mirror of
https://github.com/RetroShare/RetroShare.git
synced 2025-05-02 14:16:16 -04:00
added game plugin solocards
git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@2346 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
defnax
parent
f2f23e7ece
commit
082d5732b0
92 changed files with 24978 additions and 0 deletions
693
plugins/qsolocards_plugin/FreeCellBoard.cpp
Normal file
693
plugins/qsolocards_plugin/FreeCellBoard.cpp
Normal file
|
|
@ -0,0 +1,693 @@
|
|||
/*
|
||||
QSoloCards is a collection of Solitaire card games written using Qt
|
||||
Copyright (C) 2009 Steve Moore
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "FreeCellBoard.h"
|
||||
#include "CardPixmaps.h"
|
||||
#include "CardDeck.h"
|
||||
#include "CardAnimationLock.h"
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include <QtGui/QMessageBox>
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
FreeCellBoard::FreeCellBoard()
|
||||
:GameBoard(NULL,QString(tr("Freecell")).trimmed(),QString("Freecell")),
|
||||
m_pDeck(NULL),
|
||||
m_freeVector(),
|
||||
m_stackVector(),
|
||||
m_homeVector(),
|
||||
m_cheat(false)
|
||||
{
|
||||
this->setHelpFile(":/help/FreeCellHelp.html");
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
FreeCellBoard::~FreeCellBoard()
|
||||
{
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
void FreeCellBoard::undoMove()
|
||||
{
|
||||
GameBoard::undoMove();
|
||||
|
||||
this->setNumStackMoveCards();
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
void FreeCellBoard::redoMove()
|
||||
{
|
||||
GameBoard::redoMove();
|
||||
|
||||
this->setNumStackMoveCards();
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
bool FreeCellBoard::getHint(CardStack * & pSrc,
|
||||
unsigned int & srcIndex,
|
||||
CardStack * & pDst)
|
||||
{
|
||||
bool rc=false;
|
||||
unsigned int i;
|
||||
unsigned int j;
|
||||
|
||||
|
||||
// first see if we have any cards from the free cells to move
|
||||
// home
|
||||
for (i=0;i<this->m_freeVector.size() && !rc;i++)
|
||||
{
|
||||
if (!this->m_freeVector[i]->isEmpty())
|
||||
{
|
||||
const PlayingCardVector & cardVector=this->m_freeVector[i]->getCardVector();
|
||||
PlayingCardVector moveCards;
|
||||
|
||||
srcIndex=cardVector.size()-1;
|
||||
|
||||
moveCards.push_back(cardVector[srcIndex]);
|
||||
|
||||
for (j=0;j<this->m_homeVector.size();j++)
|
||||
{
|
||||
if (this->m_homeVector[j]->canAddCards(moveCards))
|
||||
{
|
||||
pSrc=this->m_freeVector[i];
|
||||
pDst=this->m_homeVector[j];
|
||||
rc=true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// now see if there are any cards in the stacks to move home
|
||||
if (!rc)
|
||||
{
|
||||
for (i=0;i<this->m_stackVector.size() && !rc;i++)
|
||||
{
|
||||
if (!this->m_stackVector[i]->isEmpty())
|
||||
{
|
||||
const PlayingCardVector & cardVector=this->m_stackVector[i]->getCardVector();
|
||||
PlayingCardVector moveCards;
|
||||
|
||||
srcIndex=cardVector.size()-1;
|
||||
|
||||
moveCards.push_back(cardVector[srcIndex]);
|
||||
|
||||
for (j=0;j<this->m_homeVector.size();j++)
|
||||
{
|
||||
if (this->m_homeVector[j]->canAddCards(moveCards))
|
||||
{
|
||||
pSrc=this->m_stackVector[i];
|
||||
pDst=this->m_homeVector[j];
|
||||
rc=true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// now see if we can move cards from the free cells to the stacks
|
||||
if (!rc)
|
||||
{
|
||||
for (i=0;i<this->m_freeVector.size() && !rc;i++)
|
||||
{
|
||||
if (!this->m_freeVector[i]->isEmpty())
|
||||
{
|
||||
PlayingCardVector moveCards;
|
||||
|
||||
if (this->m_freeVector[i]->getMovableCards(moveCards,srcIndex))
|
||||
{
|
||||
for (j=0;j<this->m_stackVector.size();j++)
|
||||
{
|
||||
if (this->m_stackVector[j]->canAddCards(moveCards))
|
||||
{
|
||||
pSrc=this->m_freeVector[i];
|
||||
pDst=this->m_stackVector[j];
|
||||
rc=true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// now look for stack to stack moves
|
||||
if (!rc)
|
||||
{
|
||||
for (i=0;i<this->m_stackVector.size() && !rc;i++)
|
||||
{
|
||||
if (!this->m_stackVector[i]->isEmpty())
|
||||
{
|
||||
PlayingCardVector moveCards;
|
||||
|
||||
if (this->m_stackVector[i]->getMovableCards(moveCards,srcIndex))
|
||||
{
|
||||
// look through the stacks if we couldn't move the card home
|
||||
for (j=0;j<this->m_stackVector.size();j++)
|
||||
{
|
||||
// make sure not the same stackVector and that we are not moving
|
||||
// the last card in a stack to an empty stack. Moving the last
|
||||
// card in a stack to an empty stack doesn't do anything. And lastly
|
||||
// if the cards can be added we have a match.
|
||||
if (i!=j &&
|
||||
!(0==srcIndex && this->m_stackVector[j]->isEmpty()) &&
|
||||
this->m_stackVector[j]->canAddCards(moveCards))
|
||||
{
|
||||
pSrc=this->m_stackVector[i];
|
||||
pDst=this->m_stackVector[j];
|
||||
rc=true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// now look to move something to a free cell if all else has failed
|
||||
// for now just going to be a basic move an available card from the first
|
||||
// stack with cards in it to the free cell.
|
||||
if (!rc)
|
||||
{
|
||||
// first find an open free cell. If we don't have one no need to continue.
|
||||
pDst=NULL;
|
||||
|
||||
for (i=0;i<this->m_freeVector.size();i++)
|
||||
{
|
||||
if (this->m_freeVector[i]->isEmpty())
|
||||
{
|
||||
pDst=this->m_freeVector[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (NULL!=pDst)
|
||||
{
|
||||
for (i=0;i<this->m_stackVector.size();i++)
|
||||
{
|
||||
if (!this->m_stackVector[i]->isEmpty())
|
||||
{
|
||||
PlayingCardVector moveCards;
|
||||
|
||||
|
||||
if (this->m_stackVector[i]->getMovableCards(moveCards,srcIndex) &&
|
||||
pDst->canAddCards(moveCards))
|
||||
{
|
||||
pSrc=this->m_stackVector[i];
|
||||
rc=true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
void FreeCellBoard::newGame()
|
||||
{
|
||||
// call the base class to clean up
|
||||
GameBoard::newGame();
|
||||
|
||||
CardDeck deck;
|
||||
unsigned int i;
|
||||
|
||||
|
||||
// add all the cards to the deck
|
||||
while(!deck.isEmpty())
|
||||
{
|
||||
this->m_pDeck->addCard(deck.next());
|
||||
}
|
||||
|
||||
// setup the deal of cards
|
||||
DealItemVector dealItemVector;
|
||||
|
||||
// Create the dealItemVector to direct the DealAnimation object on
|
||||
// how to deal the cards.
|
||||
for (i=0;i<this->m_stackVector.size();i++)
|
||||
{
|
||||
unsigned int j;
|
||||
unsigned int cardsInStack=((i<4)?7:6);
|
||||
|
||||
dealItemVector.push_back(DealItem(this->m_stackVector[i],m_pDeck));
|
||||
|
||||
for (j=0;j<cardsInStack;j++)
|
||||
{
|
||||
dealItemVector[i].addCard(true);
|
||||
}
|
||||
}
|
||||
|
||||
// ok now start the deal. We don't need a move record for this item.
|
||||
m_dealAni.dealCards(dealItemVector,false);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
void FreeCellBoard::addGameMenuItems(QMenu & menu)
|
||||
{
|
||||
Q_UNUSED(menu);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
void FreeCellBoard::loadSettings(const QSettings & settings)
|
||||
{
|
||||
Q_UNUSED(settings);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
void FreeCellBoard::saveSettings(QSettings & settings)
|
||||
{
|
||||
Q_UNUSED(settings);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
void FreeCellBoard::setCheat(bool cheat)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
for (i=0;i<m_stackVector.size();i++)
|
||||
{
|
||||
m_stackVector[i]->setCheat(cheat);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
void FreeCellBoard::slotCardsMoved(const CardMoveRecord & moveRecord)
|
||||
{
|
||||
GameBoard::slotCardsMoved(moveRecord);
|
||||
|
||||
this->setNumStackMoveCards();
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
void FreeCellBoard::slotFreeCardsClicked(CardStack * pCardStack,
|
||||
const PlayingCardVector & cardVector,
|
||||
const CardMoveRecord & startMoveRecord)
|
||||
{
|
||||
Q_UNUSED(pCardStack);
|
||||
|
||||
CardStack * pEmptyStack=NULL;
|
||||
CardStack * pMoveStack=NULL;
|
||||
unsigned int i;
|
||||
|
||||
// ok look for where we would move the cards to. We will look first at the home stacks.
|
||||
// After the home stacks the next priority will be a non-empty stack and then lastly
|
||||
// an empty stack.
|
||||
|
||||
for (i=0;i<this->m_homeVector.size();i++)
|
||||
{
|
||||
if (this->m_homeVector[i]->canAddCards(cardVector))
|
||||
{
|
||||
pMoveStack=this->m_homeVector[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// if we did not find a match continue to look
|
||||
if (NULL==pMoveStack)
|
||||
{
|
||||
for (i=0;i<this->m_stackVector.size();i++)
|
||||
{
|
||||
if (this->m_stackVector[i]->canAddCards(cardVector))
|
||||
{
|
||||
if (this->m_stackVector[i]->isEmpty())
|
||||
{
|
||||
pEmptyStack=this->m_stackVector[i];
|
||||
}
|
||||
else
|
||||
{
|
||||
pMoveStack=this->m_stackVector[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (NULL!=pMoveStack || NULL!=pEmptyStack)
|
||||
{
|
||||
if (NULL==pMoveStack)
|
||||
{
|
||||
pMoveStack=pEmptyStack;
|
||||
}
|
||||
|
||||
CardMoveRecord moveRecord(startMoveRecord);
|
||||
pMoveStack->addCards(cardVector,moveRecord,true);
|
||||
|
||||
// perform the move of the cards and animate it if animations
|
||||
// are enabled
|
||||
m_sToSAniMove.moveCards(moveRecord);
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
void FreeCellBoard::slotStackCardsClicked(CardStack * pCardStack,
|
||||
const PlayingCardVector & cardVector,
|
||||
const CardMoveRecord & startMoveRecord)
|
||||
{
|
||||
CardStack * pEmptyStack=NULL;
|
||||
CardStack * pMoveStack=NULL;
|
||||
unsigned int i;
|
||||
|
||||
// ok look for where we would move the cards to. We will look first at the home stacks.
|
||||
// After the home stacks the next priority will be a non-empty stack then an empty stack.
|
||||
// And lastly a free cell.
|
||||
|
||||
for (i=0;i<this->m_homeVector.size();i++)
|
||||
{
|
||||
if (this->m_homeVector[i]->canAddCards(cardVector))
|
||||
{
|
||||
pMoveStack=this->m_homeVector[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// if we did not find a match continue to look
|
||||
if (NULL==pMoveStack)
|
||||
{
|
||||
for (i=0;i<this->m_stackVector.size();i++)
|
||||
{
|
||||
if (this->m_stackVector[i]!=pCardStack)
|
||||
{
|
||||
if (this->m_stackVector[i]->canAddCards(cardVector))
|
||||
{
|
||||
if (this->m_stackVector[i]->isEmpty())
|
||||
{
|
||||
pEmptyStack=this->m_stackVector[i];
|
||||
}
|
||||
else
|
||||
{
|
||||
pMoveStack=this->m_stackVector[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// now look in the free cells
|
||||
if (NULL==pMoveStack)
|
||||
{
|
||||
for (i=0;i<this->m_freeVector.size();i++)
|
||||
{
|
||||
if (this->m_freeVector[i]->canAddCards(cardVector))
|
||||
{
|
||||
pMoveStack=this->m_freeVector[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (NULL!=pMoveStack || NULL!=pEmptyStack)
|
||||
{
|
||||
if (NULL==pMoveStack)
|
||||
{
|
||||
pMoveStack=pEmptyStack;
|
||||
}
|
||||
|
||||
CardMoveRecord moveRecord(startMoveRecord);
|
||||
pMoveStack->addCards(cardVector,moveRecord,true);
|
||||
|
||||
// perform the move of the cards and animate it if animations
|
||||
// are enabled
|
||||
m_sToSAniMove.moveCards(moveRecord);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
void FreeCellBoard::calcScore()
|
||||
{
|
||||
int score=0;
|
||||
|
||||
for(unsigned int i=0;i<this->m_homeVector.size();i++)
|
||||
{
|
||||
score+=this->m_homeVector[i]->score();
|
||||
}
|
||||
|
||||
emit scoreChanged(score,"");
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
void FreeCellBoard::resizeEvent (QResizeEvent * event)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
GameBoard::resizeEvent(event);
|
||||
|
||||
|
||||
QSize cardSize(CardPixmaps::getInst().getCardSize());
|
||||
|
||||
QPointF currPos(GameBoard::LayoutSpacing,GameBoard::LayoutSpacing);
|
||||
|
||||
for (i=0;i<m_freeVector.size();i++)
|
||||
{
|
||||
m_freeVector[i]->setPos(currPos);
|
||||
currPos.rx()+=cardSize.width()+GameBoard::LayoutSpacing;
|
||||
}
|
||||
|
||||
currPos.rx()+=(cardSize.width() + GameBoard::LayoutSpacing)/2;
|
||||
|
||||
m_pDeck->setPos(currPos);
|
||||
|
||||
currPos.setX(GameBoard::LayoutSpacing*7 + cardSize.width()*6);
|
||||
|
||||
|
||||
for (i=0;i<m_homeVector.size();i++)
|
||||
{
|
||||
m_homeVector[i]->setPos(currPos);
|
||||
currPos.rx()+=cardSize.width()+GameBoard::LayoutSpacing;
|
||||
}
|
||||
|
||||
currPos.setY(GameBoard::LayoutSpacing*2+cardSize.height());
|
||||
currPos.setX(GameBoard::LayoutSpacing*2+cardSize.width());
|
||||
for (i=0;i<m_stackVector.size();i++)
|
||||
{
|
||||
m_stackVector[i]->setPos(currPos);
|
||||
currPos.rx()+=cardSize.width()+GameBoard::LayoutSpacing;
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
bool FreeCellBoard::runDemo(bool stopWhenNoMore)
|
||||
{
|
||||
bool rc=true;
|
||||
|
||||
if (!GameBoard::runDemo(false))
|
||||
{
|
||||
// if we didn't find a move. Try to just move a card to a freecell.
|
||||
CardStack * pDst=NULL;
|
||||
bool foundMove=false;
|
||||
CardStack * pSrc=NULL;
|
||||
unsigned int srcIndex=0;
|
||||
PlayingCardVector moveCards;
|
||||
unsigned int i;
|
||||
|
||||
for (i=0;i<this->m_freeVector.size();i++)
|
||||
{
|
||||
if (this->m_freeVector[i]->isEmpty())
|
||||
{
|
||||
pDst=this->m_freeVector[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (NULL!=pDst)
|
||||
{
|
||||
for (i=0;i<this->m_stackVector.size();i++)
|
||||
{
|
||||
if (!this->m_stackVector[i]->isEmpty())
|
||||
{
|
||||
if (this->m_stackVector[i]->getMovableCards(moveCards,srcIndex) &&
|
||||
pDst->canAddCards(moveCards))
|
||||
{
|
||||
pSrc=this->m_stackVector[i];
|
||||
foundMove=true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// if we found a move create the move record. And call the stack to stack
|
||||
// animation to move it.
|
||||
if (foundMove)
|
||||
{
|
||||
CardMoveRecord moveRecord;
|
||||
|
||||
pSrc->removeCardsStartingAt(srcIndex,moveCards,moveRecord,true);
|
||||
pDst->addCards(moveCards,moveRecord,true);
|
||||
|
||||
m_sToSAniMove.moveCards(moveRecord,this->getDemoCardAniTime());
|
||||
}
|
||||
else
|
||||
{
|
||||
if (stopWhenNoMore)
|
||||
{
|
||||
stopDemo();
|
||||
rc=false;
|
||||
}
|
||||
else
|
||||
{
|
||||
rc=false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return rc;
|
||||
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
void FreeCellBoard::createStacks()
|
||||
{
|
||||
this->setCardResizeAlg(10,ResizeByWidth);
|
||||
|
||||
unsigned int i;
|
||||
|
||||
// first create the home widgets where the cards need to be eventually stacked to
|
||||
// win the game.
|
||||
for(i=0;i<4;i++)
|
||||
{
|
||||
this->m_homeVector.push_back(new FreeCellHome);
|
||||
this->m_scene.addItem(m_homeVector[i]);
|
||||
}
|
||||
|
||||
// now create the free cells
|
||||
for(i=0;i<4;i++)
|
||||
{
|
||||
this->m_freeVector.push_back(new FreeCellFree);
|
||||
this->m_scene.addItem(m_freeVector[i]);
|
||||
this->connect(this->m_freeVector[i],SIGNAL(cardsMovedByDragDrop(CardMoveRecord)),
|
||||
this,SLOT(slotCardsMoved(CardMoveRecord)));
|
||||
this->connect(this->m_freeVector[i],SIGNAL(movableCardsClicked(CardStack*,PlayingCardVector,CardMoveRecord)),
|
||||
this,SLOT(slotFreeCardsClicked(CardStack*,PlayingCardVector,CardMoveRecord)));
|
||||
}
|
||||
|
||||
// now create the 8 rows for the stacks.
|
||||
for (i=0;i<8;i++)
|
||||
{
|
||||
this->m_stackVector.push_back(new FreeCellStack);
|
||||
this->m_scene.addItem(m_stackVector[i]);
|
||||
this->connect(this->m_stackVector[i],SIGNAL(cardsMovedByDragDrop(CardMoveRecord)),
|
||||
this,SLOT(slotCardsMoved(CardMoveRecord)));
|
||||
this->connect(this->m_stackVector[i],SIGNAL(movableCardsClicked(CardStack*,PlayingCardVector,CardMoveRecord)),
|
||||
this,SLOT(slotStackCardsClicked(CardStack*,PlayingCardVector,CardMoveRecord)));
|
||||
}
|
||||
|
||||
this->m_pDeck=new FreeCellDeck;
|
||||
this->m_scene.addItem(this->m_pDeck);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
bool FreeCellBoard::isGameWon()const
|
||||
{
|
||||
bool rc=true;
|
||||
|
||||
for (unsigned int i=0;i<this->m_homeVector.size();i++)
|
||||
{
|
||||
if (!this->m_homeVector[i]->isStackComplete())
|
||||
{
|
||||
rc=false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
bool FreeCellBoard::isGameWonNotComplete()const
|
||||
{
|
||||
bool rc=true;
|
||||
|
||||
for (unsigned int i=0;i<this->m_stackVector.size();i++)
|
||||
{
|
||||
if (!this->m_stackVector[i]->cardsAscendingTopToBottom())
|
||||
{
|
||||
rc=false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
void FreeCellBoard::setNumStackMoveCards()
|
||||
{
|
||||
// as a convience allow dragging of cards if there would be enough
|
||||
// freecells to move the cards
|
||||
unsigned int numDragCards=1;
|
||||
unsigned int i;
|
||||
|
||||
for (i=0;i<m_stackVector.size();i++)
|
||||
{
|
||||
if (m_stackVector[i]->isEmpty())
|
||||
{
|
||||
numDragCards++;
|
||||
}
|
||||
}
|
||||
|
||||
// in the case that we might be dragging the cards to a free
|
||||
// space, we don't want the free space to count. It would not
|
||||
// be a free space to dump a card. So, it can't be counted.
|
||||
if (numDragCards>1)
|
||||
{
|
||||
numDragCards--;
|
||||
}
|
||||
|
||||
for (i=0;i<m_freeVector.size();i++)
|
||||
{
|
||||
if (m_freeVector[i]->isEmpty())
|
||||
{
|
||||
numDragCards++;
|
||||
}
|
||||
}
|
||||
|
||||
for (i=0;i<m_stackVector.size();i++)
|
||||
{
|
||||
m_stackVector[i]->setMaxMoveCards(numDragCards);
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue