4 files changed, 90 insertions, 2 deletions

diff --git a/noncore/games/solitaire/canvascardgame.cpp b/noncore/games/solitaire/canvascardgame.cpp
index 8e07cc8..8250193 100644
--- a/noncore/games/solitaire/canvascardgame.cpp
+++ b/noncore/games/solitaire/canvascardgame.cpp
@@ -282,102 +282,103 @@ void CanvasCardGame::contentsMouseMoveEvent(QMouseEvent *e) {
         int tx = (int)p.x() - cardXOff; 
         int ty = (int)p.y() - cardYOff;
 
         if (snapOn == TRUE) {
             CardPile *pile = closestPile( tx, ty, 50 );
             if ( pile && pile->isAllowedOnTop( moving ) ) {
                     QPoint p = pile->getHypertheticalNextCardPos();
                     if ( alphaCardPile )
                         alphaCardPile->move( p.x(), p.y() );
                     return;
             }
         }
 
         if ( alphaCardPile )
             alphaCardPile->move( tx, ty );
     }
     
 }
 
 
 void CanvasCardGame::contentsMouseReleaseEvent(QMouseEvent *e)
 { 
     QPoint p = e->pos();
 
     Q_UNUSED(p);
 
     if ( moving ) {
         
         CanvasCard *item = moving;
 
         if ( item->animated() )
             return;
         
         if ( alphaCardPile )
         if ( moved ) {
             
             CardPile *pile = closestPile((int)alphaCardPile->x(), (int)alphaCardPile->y(), 30);
 
             if (pile && pile->isAllowedOnTop(item)) {
                     CardPile *oldPile = item->getCardPile();
                     Card *c = NULL;
                     if ( oldPile != pile) {
                         while ( item ) {
                             item->show();
                             if ( oldPile ) {
                                 c = oldPile->cardInfront(item);
                                 oldPile->removeCard(item);
                             }    
-                            pile->addCardToTop(item);
                             item->setCardPile(pile);
                             //item->move( pile->getCardPos(item) );
+                            pile->addCardToTop(item);
                             QPoint p = pile->getCardPos(item);
                             item->setPos( p.x(), p.y(), highestZ );
                             highestZ++;
+                                checkUnusable();   // added for freecell to move card to discard pile
 
                             if (item->getValue() == king && haveWeWon()) {
                                 alphaCardPile->hide();
                                 gameWon();
                                 moving = NULL;
                                 return;
                             }
                             
                             if (oldPile) {
                                 item = (CanvasCard *)c;
                             } else {
                                 item = NULL;
                             }
                                 }
                         alphaCardPile->hide();
                         moving = NULL;
                         return;
                     }
             }
 
             alphaCardPile->animatedMove();
         }
     }
 
     moved = FALSE;
 }
 
 
 void CanvasCardGame::readPile( Config& cfg, CardPile *pile, QString name, int& highestZ )
 {
     cfg.setGroup( name );
     int numberOfCards = cfg.readNumEntry("NumberOfCards", 0);
     Card *card = NULL;
 
     for ( int i = 0; i < numberOfCards; i++ ) {
         QString cardStr;
         cardStr.sprintf( "%i", i );
         int val = cfg.readNumEntry( "Card" + cardStr );
         bool facing = cfg.readBoolEntry( "CardFacing" + cardStr );
 
         card = cards[ val ];
         card->setFace(facing);
                 card->setCardPile(pile);        // cam: setCardPile has to happen bevor addCardToTop
                 pile->addCardToTop(card);       //      due to a empty pointer if you use cardAddedToTop
         QPoint p = pile->getCardPos( card );
         card->setPos( p.x(), p.y(), highestZ );
         card->showCard();
         highestZ++;
diff --git a/noncore/games/solitaire/canvascardgame.h b/noncore/games/solitaire/canvascardgame.h
index 0dfb85e..d159de6 100644
--- a/noncore/games/solitaire/canvascardgame.h
+++ b/noncore/games/solitaire/canvascardgame.h
@@ -33,64 +33,65 @@
 
 #include <stdlib.h>
 #include <time.h>
 
 
 class CanvasCardPile;
 
 
 class CanvasCardGame : public QCanvasView, public CardGame
 {
 public:
     CanvasCardGame(QCanvas &c, bool snap, QWidget *parent = 0, int numOfDecks = 1, const char *name = 0, WFlags f = 0) :
             QCanvasView( &c, parent, name, f ),
         CardGame(0,numOfDecks),
         moved(FALSE),
         moving(NULL),
         alphaCardPile( NULL ), 
         cardXOff(0), cardYOff(0),
         snapOn(snap),
         numberToDraw(1) { }
 
     virtual ~CanvasCardGame();
 
     virtual Card *newCard( eValue v, eSuit s, bool f ) {
         return new CanvasCard( v, s, f, canvas() );
     }
 
     virtual void readConfig( Config& cfg ) { Q_UNUSED( cfg ); }
     virtual void writeConfig( Config& cfg ) { Q_UNUSED( cfg ); }
 
     virtual void gameWon();
     virtual bool haveWeWon() { return FALSE; }
 
     virtual bool mousePressCard(Card *card, QPoint p) { Q_UNUSED(card); Q_UNUSED(p); return FALSE; }  
     virtual void mouseReleaseCard(Card *card, QPoint p) { Q_UNUSED(card); Q_UNUSED(p); }
 
     void cancelMoving() { moving = NULL; }
     void toggleSnap() { snapOn = (snapOn == TRUE) ? FALSE : TRUE; }
     void toggleCardsDrawn() { numberToDraw = (numberToDraw == 1) ? 3 : 1; }
     int cardsDrawn() { return numberToDraw; }
     void setNumberToDraw(int numToDraw) { this->numberToDraw = numToDraw; }
 
     void readPile( Config& cfg, CardPile *pile, QString name, int& highestZ );
 
 protected:
     void contentsMousePressEvent(QMouseEvent *e);
     void contentsMouseReleaseEvent(QMouseEvent *e);
     void contentsMouseMoveEvent(QMouseEvent *e);
+                virtualvoid checkUnusable() { }  //added for freecell
 
 protected:
     // Mouse event state variables
     bool moved;
     CanvasCard *moving;
     CanvasCardPile *alphaCardPile;
     int cardXOff, cardYOff;
 
 private:
     bool snapOn;
     int numberToDraw;
 };
 
 
 #endif
 
diff --git a/noncore/games/solitaire/freecellcardgame.cpp b/noncore/games/solitaire/freecellcardgame.cpp
index 98415aa..aeb32fc 100644
--- a/noncore/games/solitaire/freecellcardgame.cpp
+++ b/noncore/games/solitaire/freecellcardgame.cpp
@@ -24,96 +24,179 @@
 extern int highestZ;
 int numberOfFreeCells = 4;
 
 
 FreecellCardGame::FreecellCardGame(QCanvas *c, bool snap, QWidget *parent) : CanvasCardGame(*c, snap, parent)
 {
     numberOfFreeCells = 4;
     highestZ = 0;
 
     int spaceBetweenPiles = ( qt_screen->deviceWidth() < 200 ) ? 21 : 28;
     int xOrigin = ( qt_screen->deviceWidth() < 200 ) ? 0 : 5;
     int spacing = ( qt_screen->deviceWidth() < 200 ) ? 0 : 0;
 
     for (int i = 0; i < 4; i++) {
         freecellPiles[i] = new FreecellFreecellPile( xOrigin + i * spaceBetweenPiles, 10, canvas() );
         addCardPile(freecellPiles[i]);
     }
     for (int i = 0; i < 4; i++) {
         discardPiles[i] = new FreecellDiscardPile( xOrigin + spacing + 6 + (i + 4) * spaceBetweenPiles, 10, canvas() );
         addCardPile(discardPiles[i]);
     }
     for (int i = 0; i < 8; i++) {
         workingPiles[i] = new FreecellWorkingPile( xOrigin + spacing + 2 + i * spaceBetweenPiles, 50, canvas() );
         addCardPile(workingPiles[i]);
     }
 }
 
 
 void FreecellCardGame::deal(void)
 {
     highestZ = 1;
     
     beginDealing();
     
     for (int i = 0; i < 52; i++) {
         Card *card = cards[i];
         card->setFace( TRUE );
         card->setPos( 0, 0, highestZ );
         card->setCardPile( workingPiles[i%8] );
         workingPiles[i%8]->addCardToTop( card );
         card->move( workingPiles[i%8]->getCardPos( card ) );
         card->showCard();
         highestZ++;
     }
 
     endDealing();
 }
 
+        // checks if smaller card with different color, that could be put on top on the
+        // card, is present in working or freecell pile
+bool FreecellCardGame::checkNeeded(Card *card)
+{
+        if (card->getValue() > 2){
+                int i;
+                Card *c;
+                for (i=0;i<4;i++){
+                        c = freecellPiles[i]->cardOnBottom();
+                        if (c != NULL){
+                                if (card->isRed()!= c->isRed() && card->getValue()== c->getValue()+1){
+                                        return (false); 
+                                }
+                        }
+                }
+                for (i=0;i<8;i++){
+                        c=workingPiles[i]->cardOnBottom();
+                        while (c!=NULL){
+                                        if (card->isRed() != c->isRed()&& card->getValue() == c->getValue()+1) {
+                                        return (false);
+                                }
+                                c=workingPiles[i]->cardInfront(c);
+                        }
+                }
+        }
+        return(true);
+}
+        
+//  added to move cards, on which no card can be moved, to discard pile 
+void FreecellCardGame::checkUnusable()
+{
+        int i,j;
+        //printf("void FreecellCardGame::checkUnusable()\n");
+        Card *top_one;
+        for (i=0;i < 8;i++)
+        {
+                top_one = workingPiles[i]->cardOnTop();
+                if (top_one != NULL)
+                {
+                        j = 0;
+                        while ((j < 4))
+                        {
+                                if (discardPiles[j]->isAllowedOnTop(top_one)){
+                                        if (checkNeeded(top_one)){
+                                                top_one->setCardPile(discardPiles[j]);
+                                                workingPiles[i]->removeCard(top_one);
+        //                                      printf("k %d f work%d to disk%d on %d\n ",top_one->getValue(),i+1,j+1,highestZ);
+                                                discardPiles[j]->addCardToTop(top_one);
+                                                top_one->setPos(discardPiles[j]->getX(),discardPiles[j]->getY(),highestZ);
+                                                highestZ++;
+                                                j = 4;
+                                                checkUnusable();
+                                        }
+                                }
+                                j++;
+                        }
+                } 
+        }
+        for (i=0;i<4;i++){
+                top_one = freecellPiles[i]->cardOnTop();
+                if (top_one != NULL)
+                {
+                        j = 0;
+                        while ((j < 4))
+                        {
+                                if (discardPiles[j]->isAllowedOnTop(top_one)){
+                                        if (checkNeeded(top_one)){
+                                                top_one->setCardPile(discardPiles[j]);
+                                                freecellPiles[i]->removeCard(top_one);
+        //                                      printf("k %d f work%d to disk%d on %d\n ",top_one->getValue(),i+1,j+1,highestZ);
+                                                discardPiles[j]->addCardToTop(top_one);
+                                                top_one->setPos(discardPiles[j]->getX(),discardPiles[j]->getY(),highestZ);
+                                                highestZ++;
+                                                j = 4;
+                                                checkUnusable();
+                                        }
+                                }
+                                j++;
+                        }
+                } 
+                }       
+}
+
 
 bool FreecellCardGame::mousePressCard( Card *c, QPoint p )
 {
     Q_UNUSED(p);
     
     if ( !c->getCardPile()->isAllowedToBeMoved(c) ) {
         moving = NULL;
         return TRUE;
     }
 
     return FALSE;
 }
 
 
 void FreecellCardGame::readConfig( Config& cfg )
 {
     cfg.setGroup("GameState");
 
     // Create Cards, but don't shuffle or deal them yet
     createDeck();
 
     // Move the cards to their piles (deal them to their previous places)
     beginDealing();
 
     highestZ = 1;
 
     for (int k = 0; k < 4; k++) {
         QString pile;
         pile.sprintf( "FreeCellPile%i", k );
         readPile( cfg, freecellPiles[k], pile, highestZ );
     }
 
     for (int k = 0; k < 4; k++) {
         QString pile;
         pile.sprintf( "DiscardPile%i", k );
         readPile( cfg, discardPiles[k], pile, highestZ );
     }
 
     for (int k = 0; k < 8; k++) {
         QString pile;
         pile.sprintf( "WorkingPile%i", k );
         readPile( cfg, workingPiles[k], pile, highestZ );
     }
 
     highestZ++;
 
     endDealing();
 }
diff --git a/noncore/games/solitaire/freecellcardgame.h b/noncore/games/solitaire/freecellcardgame.h
index f1b09ab..2df751b 100644
--- a/noncore/games/solitaire/freecellcardgame.h
+++ b/noncore/games/solitaire/freecellcardgame.h
@@ -1,152 +1,155 @@
 /**********************************************************************
 ** 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 FREECELL_CARD_GAME_H 
 #define FREECELL_CARD_GAME_H 
 
 
 #include "patiencecardgame.h"
 
 
 extern int numberOfFreeCells;
 
 
 class FreecellDiscardPile : public PatienceDiscardPile
 {
 public:
     FreecellDiscardPile(int x, int y, QCanvas *canvas) :
             PatienceDiscardPile(x, y, canvas) { }
 
 };
 
 
 class FreecellWorkingPile : public PatienceWorkingPile
 {
 public:
     FreecellWorkingPile(int x, int y, QCanvas *canvas) :
             PatienceWorkingPile(x, y, canvas) { }
 
      virtual bool isAllowedOnTop(Card *card) {
         if ( cardOnBottom() == NULL ) {
             int numberOfCardsBeingMoved = 0;
             Card *tempCard = card;
-
+            
             while ((tempCard != NULL)) {
                 numberOfCardsBeingMoved++;
                 tempCard = cardInfront(tempCard); 
             }
        
             if (numberOfCardsBeingMoved > numberOfFreeCells)
                 return FALSE;
         }
 
         if ( card->isFacing() &&
               cardOnTop() == NULL )
             return TRUE;
                 return PatienceWorkingPile::isAllowedOnTop( card );
     }
     
+
     virtual bool isAllowedToBeMoved(Card *card) {
         int nextExpectedValue = (int)card->getValue();
         bool nextExpectedColor = card->isRed();
         int numberOfCardsBeingMoved = 0;
         
         while ((card != NULL)) {
             numberOfCardsBeingMoved++;
             if ( (int)card->getValue() != nextExpectedValue )
                 return FALSE;
             if ( card->isRed() != nextExpectedColor )
                 return FALSE;
             nextExpectedValue--;;
             nextExpectedColor = !nextExpectedColor;
             card = cardInfront(card); 
         }
        
         if (numberOfCardsBeingMoved <= (numberOfFreeCells + 1))
             return TRUE;
         
         return FALSE;
     }
     virtual void cardRemoved(Card *card) {
         if ( !isDealing() &&  !cardOnTop() )
             numberOfFreeCells++;
         PatienceWorkingPile::cardRemoved( card );
     }
     virtual void cardAddedToTop(Card *card) {
         if ( !isDealing() && cardOnBottom() == card )
             numberOfFreeCells--;
         PatienceWorkingPile::cardAddedToTop( card );
     }
 };
 
 
 class FreecellFreecellPile : public CardPile, public CanvasRoundRect
 {
 public:
     FreecellFreecellPile(int x, int y, QCanvas *canvas)
         : CardPile(x, y), CanvasRoundRect(x, y, canvas) { }
     virtual bool isAllowedOnTop(Card *card) {
         if ( ( cardOnTop() == NULL ) && ( card->getCardPile()->cardInfront(card) == NULL  ) )
             return TRUE;
                 return FALSE;
     }
     virtual bool isAllowedToBeMoved(Card *card) {
         Q_UNUSED(card);
             return TRUE;
     }
     virtual void cardAddedToTop(Card *card) {
         Q_UNUSED(card);
         numberOfFreeCells--;
     }
     virtual void cardRemoved(Card *card) {
         Q_UNUSED(card);
         numberOfFreeCells++;
     }
 };
 
 
 class FreecellCardGame : public CanvasCardGame
 {
 public:
     FreecellCardGame(QCanvas *c, bool snap, QWidget *parent = 0);
     virtual void deal(void);
     virtual bool haveWeWon() { 
         return ( discardPiles[0]->kingOnTop() &&
                  discardPiles[1]->kingOnTop() &&
                  discardPiles[2]->kingOnTop() &&
                  discardPiles[3]->kingOnTop() );
     }
     virtual void mousePress(QPoint p) { Q_UNUSED(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); }
+     virtual void checkUnusable();
     void readConfig( Config& cfg );
     void writeConfig( Config& cfg );
     bool snapOn;
 private:
+    bool checkNeeded(Card *card);
     FreecellFreecellPile *freecellPiles[8];
     FreecellWorkingPile *workingPiles[8];
     FreecellDiscardPile *discardPiles[4];
 };
 
 
 #endif