2 files changed, 25 insertions, 19 deletions

diff --git a/noncore/games/solitaire/patiencecardgame.cpp b/noncore/games/solitaire/patiencecardgame.cpp
index 756577a..a1e4968 100644
--- a/noncore/games/solitaire/patiencecardgame.cpp
+++ b/noncore/games/solitaire/patiencecardgame.cpp
@@ -1,279 +1,288 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include "patiencecardgame.h"
 
 
 int highestZ = 0;
 
 
 PatienceCardGame::PatienceCardGame(QCanvas *c, bool snap, QWidget *parent) : CanvasCardGame(*c, snap, parent)
 {
     numberOfTimesThroughDeck = 0;
     highestZ = 0;
 
     if ( qt_screen->deviceWidth() < 200 )
     {
         circleCross = new CanvasCircleOrCross( 7, 16, canvas() );
         rectangle = new CanvasRoundRect(  30, 10, canvas() );
 
         for (int i = 0; i < 4; i++)
         {
             discardPiles[i] = new PatienceDiscardPile( 78 + i * 23, 10, canvas() );
             addCardPile(discardPiles[i]);
         }
         for (int i = 0; i < 7; i++)
         {
             workingPiles[i] = new PatienceWorkingPile( 5 + i * 23, 50, canvas() );
             addCardPile(workingPiles[i]);
         }
         faceDownDealingPile = new PatienceFaceDownDeck( 5, 10, canvas() );
         faceUpDealingPile   = new PatienceFaceUpDeck( 30, 10, canvas() );
     }
     else
     {
         circleCross = new CanvasCircleOrCross( 7, 18, canvas() );
         rectangle = new CanvasRoundRect(  35, 10, canvas() );
 
         for (int i = 0; i < 4; i++)
         {
             discardPiles[i] = new PatienceDiscardPile( 110 + i * 30, 10, canvas() );
             addCardPile(discardPiles[i]);
         }
         for (int i = 0; i < 7; i++)
         {
             workingPiles[i] = new PatienceWorkingPile( 10 + i * 30, 50, canvas() );
             addCardPile(workingPiles[i]);
         }
         faceDownDealingPile = new PatienceFaceDownDeck( 5, 10, canvas() );
         faceUpDealingPile   = new PatienceFaceUpDeck( 35, 10, canvas() );
     }
 }
 
 
 PatienceCardGame::~PatienceCardGame()
 {
     delete circleCross;
     delete rectangle;
     delete faceDownDealingPile;
     delete faceUpDealingPile;
 }
 
 
 void PatienceCardGame::deal(void)
 {
     highestZ = 1;
     int t = 0;
 
     beginDealing();
 
     for (int i = 0; i < 7; i++)
     {
         cards[t]->setFace(TRUE);
         for (int k = i; k < 7; k++, t++)
         {
             Card *card = cards[t];
             workingPiles[k]->addCardToTop(card);
             card->setCardPile( workingPiles[k] );
             QPoint p = workingPiles[k]->getCardPos( card );
             card->setPos( p.x(), p.y(), highestZ );
             card->showCard();
             highestZ++;
         }
     }
 
     for ( ; t < 52; t++)
     {
         Card *card = cards[t];
         faceDownDealingPile->addCardToTop(card);
         card->setCardPile( faceDownDealingPile );
         QPoint p = faceDownDealingPile->getCardPos( card );
         card->setPos( p.x(), p.y(), highestZ );
         card->showCard();
         highestZ++;
     }
 
     endDealing();
 }
 
 
 void PatienceCardGame::readConfig( Config& cfg )
 {
     cfg.setGroup("GameState");
 
+        deckTurns = cfg.readNumEntry("DeckTurns", 2500);
     // Do we have a config file to read in?
-    if ( !cfg.hasKey("numberOfTimesThroughDeck") )
-    {
+    if ( !cfg.hasKey("numberOfTimesThroughDeck") ) {
         // if not, create a new game
         newGame();
         return;
     }
     // We have a config file, lets read it in and use it
 
     // Create Cards, but don't shuffle or deal them yet
     createDeck();
 
     // How many times through the deck have we been
     numberOfTimesThroughDeck = cfg.readNumEntry("numberOfTimesThroughDeck");
 
     // restore state to the circle/cross under the dealing pile
     if ( canTurnOverDeck() )
         circleCross->setCircle();
     else
         circleCross->setCross();
 
     // Move the cards to their piles (deal them to their previous places)
     beginDealing();
 
     highestZ = 1;
 
     for (int k = 0; k < 7; k++)
     {
         QString pile;
         pile.sprintf( "WorkingPile%i", k );
         readPile( cfg, workingPiles[k], pile, highestZ );
     }
 
     for (int k = 0; k < 4; k++)
     {
         QString pile;
         pile.sprintf( "DiscardPile%i", k );
         readPile( cfg, discardPiles[k], pile, highestZ );
     }
 
     readPile( cfg, faceDownDealingPile, "FaceDownDealingPile", highestZ );
     readPile( cfg, faceUpDealingPile,   "FaceUpDealingPile", highestZ );
 
     highestZ++;
 
     endDealing();
 }
 
 
 void PatienceCardGame::writeConfig( Config& cfg )
 {
     cfg.setGroup("GameState");
     cfg.writeEntry("numberOfTimesThroughDeck", numberOfTimesThroughDeck);
 
     for ( int i = 0; i < 7; i++ )
     {
         QString pile;
         pile.sprintf( "WorkingPile%i", i );
         workingPiles[i]->writeConfig( cfg, pile );
     }
     for ( int i = 0; i < 4; i++ )
     {
         QString pile;
         pile.sprintf( "DiscardPile%i", i );
         discardPiles[i]->writeConfig( cfg, pile );
     }
     faceDownDealingPile->writeConfig( cfg, "FaceDownDealingPile" );
     faceUpDealingPile->writeConfig( cfg, "FaceUpDealingPile" );
 }
 
 
 bool PatienceCardGame::mousePressCard( Card *card, QPoint p )
 {
     Q_UNUSED(p);
 
     CanvasCard *item = (CanvasCard *)card;
     if (item->isFacing() != TRUE)
     {
         // From facedown stack
         if ((item->x() == 5) && ((int)item->y() == 10))
         {
             item->setZ(highestZ);
             highestZ++;
 
             // Added Code
             faceDownDealingPile->removeCard(item);
             faceUpDealingPile->addCardToTop(item);
             item->setCardPile( faceUpDealingPile );
 
             if ( qt_screen->deviceWidth() < 200 )
                 item->flipTo( 30, (int)item->y() );
             else
                 item->flipTo( 35, (int)item->y() );
         }
                 else return FALSE;                      // <- was missing, caused facedown card to react
         // to clicking, which is wrong
         moving = NULL;
         moved = FALSE;
 
         // move two other cards if we flip three at a time
         int flipped = 1;
         QCanvasItemList l = canvas()->collisions( p );
         for (QCanvasItemList::Iterator it = l.begin(); (it != l.end()) && (flipped != cardsDrawn()); ++it)
         {
             if ( (*it)->rtti() == canvasCardId )
             {
                 CanvasCard *item = (CanvasCard *)*it;
                 if (item->animated())
                     continue;
                 item->setZ(highestZ);
                 highestZ++;
                 flipped++;
 
                 // Added Code
                 faceDownDealingPile->removeCard(item);
                 faceUpDealingPile->addCardToTop(item);
                 item->setCardPile( faceUpDealingPile );
 
                 if ( qt_screen->deviceWidth() < 200 )
                     item->flipTo( 30, (int)item->y(), 8 * flipped );
                 else
                     item->flipTo( 35, (int)item->y(), 8 * flipped );
             }
         }
 
         return TRUE;
     }
 
     return FALSE;
 }
 
 
 void PatienceCardGame::mousePress(QPoint p)
 {
     if ( canTurnOverDeck() &&
             (p.x() >  5) && (p.x() < 28) &&
             (p.y() > 10) && (p.y() < 46) )
     {
 
         beginDealing();
         Card *card = faceUpDealingPile->cardOnTop();
         while ( card )
         {
             card->setPos( 5, 10, highestZ );
             card->setFace( FALSE );
             faceUpDealingPile->removeCard( card );
             faceDownDealingPile->addCardToTop( card );
             card->setCardPile( faceDownDealingPile );
             card = faceUpDealingPile->cardOnTop();
             highestZ++;
         }
         endDealing();
 
         throughDeck();
 
         moved = TRUE;
     }
 }
 
 
+bool PatienceCardGame::canTurnOverDeck() {
+        return (numberOfTimesThroughDeck != deckTurns);
+}
+
+void PatienceCardGame::throughDeck() {
+        numberOfTimesThroughDeck++;
+        if (numberOfTimesThroughDeck == deckTurns)
+                circleCross->setCross();
+ }
diff --git a/noncore/games/solitaire/patiencecardgame.h b/noncore/games/solitaire/patiencecardgame.h
index 0d0e3d5..b76251a 100644
--- a/noncore/games/solitaire/patiencecardgame.h
+++ b/noncore/games/solitaire/patiencecardgame.h
@@ -1,209 +1,206 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #ifndef PATIENCE_CARD_GAME_H
-#define PATIENCE_CARD_GAME_H 
+#define PATIENCE_CARD_GAME_H
 
 
 #include <qpopupmenu.h>
 #include <qmainwindow.h>
 #include <qintdict.h>
 #include <qcanvas.h>
 #include <qgfx_qws.h>
 // #include "canvascardshapes.h"
 // #include "canvascard.h"
 #include "canvascardgame.h"
 
 
 class PatienceFaceDownDeck : public CardPile, public CanvasRoundRect
 {
 public:
     PatienceFaceDownDeck(int x, int y, QCanvas *canvas)
         : CardPile(x, y), CanvasRoundRect(x, y, canvas) { }
     virtual bool isAllowedOnTop(Card *card) {
         Q_UNUSED(card);
         // Need to check it is from the faceUpDealingPile
         return TRUE;
     }
     virtual bool isAllowedToBeMoved(Card *card) {
         Q_UNUSED(card);
         //if ( ( !card->isFacing() ) && ( card == cardOnTop() ) )
         if ( card == cardOnTop() )
             return TRUE;
-                return FALSE;
+        return FALSE;
     }
 };
 
 
 class PatienceFaceUpDeck : public CardPile, public CanvasRoundRect
 {
 public:
     PatienceFaceUpDeck(int x, int y, QCanvas *canvas)
         : CardPile(x, y), CanvasRoundRect(x, y, canvas) { }
     virtual bool isAllowedOnTop(Card *card) {
         Q_UNUSED(card);
         // Need to check it is from the faceDownDealingPile
         return TRUE;
     }
     virtual bool isAllowedToBeMoved(Card *card) {
         Q_UNUSED(card);
         //if ( ( card->isFacing() ) && ( card == cardOnTop() ) )
         if ( card == cardOnTop() )
             return TRUE;
-                return FALSE;
+        return FALSE;
     }
 };
 
 
 class PatienceDiscardPile : public CardPile, public CanvasRoundRect
 {
 public:
     PatienceDiscardPile(int x, int y, QCanvas *canvas)
         : CardPile(x, y), CanvasRoundRect(x, y, canvas) { }
     virtual bool isAllowedOnTop(Card *card) {
         if ( card->isFacing() && ( card->getCardPile()->cardInfront(card) == NULL ) &&
            ( ( ( cardOnTop() == NULL ) && ( card->getValue() == ace ) ) ||
              ( ( cardOnTop() != NULL ) &&
                ( (int)card->getValue() == (int)cardOnTop()->getValue() + 1 ) &&
                ( card->getSuit() == cardOnTop()->getSuit() ) ) ) )
             return TRUE;
-                return FALSE;
+        return FALSE;
     }
     virtual bool isAllowedToBeMoved(Card *card) {
         if ( card->isFacing() && ( card == cardOnTop() ) )
             return TRUE;
-                return FALSE;
+        return FALSE;
     }
 };
 
 
 class PatienceWorkingPile : public CardPile, public CanvasRoundRect
 {
 public:
     PatienceWorkingPile(int x, int y, QCanvas *canvas)
         : CardPile(x, y), CanvasRoundRect(x, y, canvas), top(x, y) { }
     virtual bool isAllowedOnTop(Card *card) {
         if ( card->isFacing() &&
              ( ( ( cardOnTop() == NULL ) && (card->getValue() == king) ) ||
                ( ( cardOnTop() != NULL ) &&
                   ( (int)card->getValue() + 1 == (int)cardOnTop()->getValue() ) &&
                  ( card->isRed() != cardOnTop()->isRed() ) ) ) )
             return TRUE;
-                return FALSE;
+        return FALSE;
     }
     virtual bool isAllowedToBeMoved(Card *card) {
         if ( card->isFacing() )
             return TRUE;
-                return FALSE;
+        return FALSE;
     }
     virtual void cardAddedToTop(Card *card) {
         Q_UNUSED(card);
         top = getCardPos(NULL);
         setNextX( top.x() );
         setNextY( top.y() );
     }
     virtual void cardRemoved(Card *card) {
         Q_UNUSED(card);
 
         Card *newTopCard = cardOnTop();
 
         if ( !newTopCard ) {
             top = QPoint( pileX, pileY );
             setNextX( pileX );
                 setNextY( pileY );
             return;
         } else {
             top = getCardPos(NULL);
             if ( newTopCard->isFacing() == FALSE ) {
                 int offsetDown = ( qt_screen->deviceWidth() < 200 ) ? 9 : 13;
                 // correct the position taking in to account the card is not
                 // yet flipped, but will become flipped
                 top = QPoint( top.x() - 1, top.y() - 3 );
                 newTopCard->flipTo( top.x(), top.y() );
                 top = QPoint( top.x(), top.y() + offsetDown );
             }
                 setNextX( top.x() );
             setNextY( top.y() );
         }
     }
     virtual QPoint getCardPos(Card *c) {
         int x = pileX, y = pileY;
         Card *card = cardOnBottom();
         while ((card != c) && (card != NULL)) {
             if (card->isFacing()) {
                 int offsetDown = ( qt_screen->deviceWidth() < 200 ) ? 9 : 13;
-                y += offsetDown; 
+                y += offsetDown;
             } else {
-                x += 1;    
+                x += 1;
                 y += 3;
             }
-            card = cardInfront(card); 
+            card = cardInfront(card);
         }
         return QPoint( x, y );
     }
     virtual QPoint getHypertheticalNextCardPos(void) {
         return top;
         // return QPoint( getNextX(), getNextY() );
     }
 private:
     QPoint top;
 
 };
 
 
 class PatienceCardGame : public CanvasCardGame
 {
 public:
     PatienceCardGame(QCanvas *c, bool snap, QWidget *parent = 0);
     virtual ~PatienceCardGame();
     virtual void deal(void);
-    virtual bool haveWeWon() { 
+        int deckTurns;
+    virtual bool haveWeWon() {
         return ( discardPiles[0]->kingOnTop() &&
                  discardPiles[1]->kingOnTop() &&
                  discardPiles[2]->kingOnTop() &&
                  discardPiles[3]->kingOnTop() );;
     }
     virtual void mousePress(QPoint p);
     virtual void mouseRelease(QPoint p) { Q_UNUSED(p); }
 //    virtual void mouseMove(QPoint p);
     virtual bool mousePressCard(Card *card, QPoint p);
     virtual void mouseReleaseCard(Card *card, QPoint p) { Q_UNUSED(card); Q_UNUSED(p); }
 //    virtual void mouseMoveCard(Card *card, QPoint p) { Q_UNUSED(card); Q_UNUSED(p); }
-    bool canTurnOverDeck(void) { return (numberOfTimesThroughDeck != 3); }
-    void throughDeck(void) {
-        numberOfTimesThroughDeck++;
-        if (numberOfTimesThroughDeck == 3)
-                circleCross->setCross();
-    }
+    bool canTurnOverDeck();
+    void throughDeck();
     bool snapOn;
     virtual void writeConfig( Config& cfg );
     virtual void readConfig( Config& cfg );
 private:
     CanvasCircleOrCross *circleCross;
     CanvasRoundRect *rectangle;
     PatienceWorkingPile *workingPiles[7];
     PatienceDiscardPile *discardPiles[4];
     PatienceFaceDownDeck *faceDownDealingPile;
     PatienceFaceUpDeck *faceUpDealingPile;
     int numberOfTimesThroughDeck;
 };
 
 
 #endif