summaryrefslogtreecommitdiff
Side-by-side diff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/games/solitaire/patiencecardgame.cpp13
-rw-r--r--noncore/games/solitaire/patiencecardgame.h31
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