Text based solitaire game for windows and linux

Configurare noua (How To)

Situatie

Solutie

Pasi de urmat

  1. /*=================main.cpp===========================*/
  2. #include <iostream>
  3. #include "Solitaire.h"
  5. using namespace std;
  7. void HandleMove(Solitaire& game);
  8. void HandleMoveToAnswer(Solitaire& game);
  9. void ClearScreen();
  11. int main(int argc, char** argv)
  12. {
  13. Solitaire game = Solitaire();
  14. game.PrintAllDetails();
  16. bool running = true;
  17. do{
  18. char option = ' ';
  19. cout<<endl<<endl;
  20. cout<<"1. move card between rows";
  21. cout<<"\n2. move to answers";
  22. cout<<"\n3. deal";
  23. cout<<"\n0. quit";
  24. cout<<"\nEnter option:";
  25. cin >> option;
  27. /* 48 - 55 ascii code is 0 - 7 */
  29. if(game.GameCompleted())
  30. {
  31. ClearScreen();
  32. cout<<"\n\n\n\t\t\t CONGRATULATIONS YOU WON!!!\n\n";
  33. cin.get();
  34. running = false;
  35. }
  37. else
  38. {
  39. switch((int)option)
  40. {
  41. case 48:
  42. running = false;
  43. break;
  44. case 49:
  45. HandleMove(game);
  46. break;
  47. case 50:
  48. HandleMoveToAnswer(game);
  49. break;
  50. case 51:
  51. game.Deal(3);
  52. break;
  53. default:
  54. cout<<"\ninvalid option";
  55. cin.ignore(80,'\n');
  56. break;
  57. }
  58. ClearScreen();
  59. game.PrintAllDetails();
  60. }
  62. }while(running);
  64. return 0;
  65. }
  67. void HandleMove(Solitaire& game)
  68. {
  69. char from = '0' ,to = '0';
  70. cout<<endl <<endl;
  71. cout<<"From (7 for deck):";
  72. cin >> from;
  73. cout<< "To: ";
  74. cin>> to;
  76. if( ((int)from >= 48 && (int)from <= 55) &&
  77. ((int)from >= 48 && (int)to <= 54) )
  79. {
  80. game.MakeMoveRowToRow((int)from - 48,(int)to - 48);
  81. }
  83. else
  84. {
  85. cout<<"invalid input";
  86. cin.get();
  87. cin.get();
  88. }
  90. }
  92. void HandleMoveToAnswer(Solitaire& game)
  93. {
  94. char from = 0;
  95. cout<<endl <<endl;
  96. cout<< "From (7 for deck): ";
  97. cin>> from;
  99. if((int)from >= 48 && (int)from <= 55)
  100. game.MakeSuitMove((int)from - 48);
  102. else
  103. {
  104. cout<<"invalid input";
  105. cin.get();
  106. cin.get();
  107. }
  109. }
  111. void ClearScreen()
  112. {
  113. #ifdef __linux__
  114. system("clear");
  115. #elif _WIN32
  116. system("cls");
  117. #endif
  118. }
  120. /*=============================================*/
  121. /*=================Card.h=======================*/
  122. #pragma once
  123. #include <iostream>
  125. #ifdef _WIN32
  126. #include<windows.h>
  127. const static int BLACK = 0;
  128. const static int BLUE = 9;
  129. const static int RED = 12;
  130. const static int WHITE = 15;
  131. #elif __linux__
  132. #include "stdlib.h"
  133. #endif
  135. class Card
  136. {
  137. public:
  138. Card(void);
  139. Card(char rank,char suit);
  140. ~Card(void);
  142. void Flip();
  143. bool GetIsFaceUp();
  145. int GetSolitaireValue();
  146. char GetCardSuit();
  147. char GetCardRank();
  149. friend std::ostream & operator<< (std::ostream & os, Card& c);
  151. /*
  152. Used to navigate up and
  153. down the cards in a row
  154. */
  155. Card* parent;
  156. Card* child;
  158. private:
  159. char rank;
  160. char suit;
  161. bool isFaceUp;
  163. };
  165. /*=============================================*/
  166. /*====================Card.cpp===================*/
  167. #include "Card.h"
  169. Card::Card(void)
  170. {
  171. }
  173. Card::Card(char r, char s)
  174. :rank(r)
  175. ,suit(s)
  176. ,isFaceUp(false)
  177. ,child(NULL)
  178. ,parent(NULL)
  179. {
  180. }
  182. Card::~Card(void)
  183. {
  184. }
  186. void Card::Flip()
  187. {
  188. isFaceUp = !isFaceUp;
  189. }
  191. bool Card::GetIsFaceUp()
  192. {
  193. return isFaceUp;
  194. }
  196. char Card::GetCardSuit()
  197. {
  198. return suit;
  199. }
  201. char Card::GetCardRank()
  202. {
  203. return rank;
  204. }
  206. int Card::GetSolitaireValue()
  207. {
  208. if(rank == 'A')
  209. return 1;
  210. else if(rank == 'T')
  211. return 10;
  212. else if(rank == 'J')
  213. return 11;
  214. else if(rank == 'Q')
  215. return 12;
  216. else if(rank == 'K')
  217. return 13;
  218. else
  219. {
  220. char c[] = {rank, '\0'};
  221. return atoi(c);
  222. }
  223. }
  225. std::ostream & operator<< (std::ostream & os, Card& c)
  226. {
  228. #ifdef _WIN32
  229. HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
  231. if(c.suit == 'c' || c.suit == 's')
  232. SetConsoleTextAttribute(handle, BLUE);
  233. else
  234. SetConsoleTextAttribute(handle,RED);
  236. os<< c.suit << c.rank;
  237. SetConsoleTextAttribute(handle,WHITE);
  239. #elif __linux__
  241. if(c.suit == 'c' || c.suit == 's')
  242. os<<"\033[22;34m";
  243. else
  244. os<<"\033[22;31m";
  245. os<< c.suit << c.rank;
  246. os<<"\033[22;30m";
  248. #endif
  250. return os;
  251. }
  253. /*=============================================*/
  254. /*====================Deck.h====================*/
  255. #pragma once
  256. #include "Card.h"
  257. #include <ctime>
  258. #include <iostream>
  259. #include "TableCard.h"
  261. const static int RANK_SIZE = 13;
  262. const static int SUIT_SIZE = 4;
  263. const static char RANKS[] = {'A','2','3','4','5','6','7','8','9','T','J','Q','K'};
  264. const static char SUITS[] = {'h','d','s','c'};
  267. class Deck
  268. {
  269. public:
  270. Deck(void);
  271. ~Deck(void);
  273. void Populate(void);
  274. void Shuffle(void);
  275. void PrintDeck(void);
  277. void PopulateVector(TableCard& aDeck);
  279. private:
  280. Card _deck[52];
  281. int currentIndex;
  282. };
  284. /*==============================================*/
  285. /*====================Deck.cpp====================*/
  286. #include "Deck.h"
  288. Deck::Deck(void)
  289. :currentIndex(0)
  290. {
  291. srand((unsigned)time(0));
  292. Populate();
  293. }
  296. Deck::~Deck(void)
  297. {
  298. }
  300. void Deck::Populate()
  301. {
  302. int index = 0;
  303. for(int i=0; i<SUIT_SIZE; i++)
  304. {
  305. for(int j=0; j<RANK_SIZE;j++)
  306. {
  307. _deck[index] = Card(RANKS[j],SUITS[i]);
  308. index++;
  309. }
  310. }
  311. }
  313. void Deck::Shuffle()
  314. {
  315. int max = SUIT_SIZE * RANK_SIZE;
  316. for(int i=0; i<max-1; i++)
  317. {
  318. int randNum = rand() % 52;
  319. std::swap(_deck[i],_deck[randNum]);
  320. }
  322. }
  324. void Deck::PrintDeck(void)
  325. {
  326. int max = SUIT_SIZE * RANK_SIZE;
  327. for(int i=0; i<max; i++)
  328. {
  329. if(i %13 == 0)
  330. std::cout<< '\n' <<'\n';
  331. std::cout<< _deck[i] << " " << _deck[i].GetBlackjackValue() << " ";
  332. }
  333. }
  335. void Deck::PopulateVector(TableCard& aDeck)
  336. {
  337. int max = SUIT_SIZE * RANK_SIZE;
  338. aDeck.Clear();
  339. for(int i=0; i<max; i++)
  340. aDeck.PushValueCopy(_deck[i]);
  341. }
  342. /*===============================================*/
  343. /*====================TableCard.h===================*/
  344. #pragma once
  345. #include "Card.h"
  346. #include <vector>
  348. class TableCard
  349. {
  350. public:
  351. TableCard(int maxSize);
  352. ~TableCard(void);
  354. Card& operator[](int index);
  355. bool Push(Card& card);
  356. bool PushValueCopy(Card card);
  357. int Size();
  358. bool empty();
  359. Card& top(void);
  361. bool RemoveAt(int index);
  362. bool Pop();
  363. void Clear();
  366. static void MoveBetween(TableCard& from, TableCard& to);
  369. private:
  370. int _maxSize;
  371. int _size;
  372. std::vector<Card*> _cards;
  374. };
  375. /*=============================================*/
  376. /*====================TableCard.cpp================*/
  377. #include "TableCard.h"
  379. TableCard::TableCard(int maxSize)
  380. :_size(0)
  381. ,_maxSize(maxSize)
  382. {
  383. _cards.resize(maxSize);
  384. }
  386. TableCard::~TableCard(void)
  387. {
  388. }
  390. bool TableCard::Push(Card& card)
  391. {
  392. if(_size < _maxSize)
  393. {
  394. _cards[_size] = &card;
  395. _size++;
  396. return true;
  397. }
  398. return false;
  399. }
  401. bool TableCard::PushValueCopy(Card card)
  402. {
  403. if(_size < _maxSize);
  404. {
  405. _cards[_size] = new Card(card);
  406. _size++;
  407. return true;
  408. }
  409. return false;
  410. }
  412. void TableCard::Clear()
  413. {
  414. for(int i=0; i<_size; i++)
  415. _cards[i] = NULL;
  417. _size = 0;
  418. }
  420. bool TableCard::empty()
  421. {
  422. if(_size == 0)
  423. return true;
  424. return false;
  425. }
  427. Card& TableCard::top(void)
  428. {
  429. if(_size > 0)
  430. return *_cards[_size-1];
  431. }
  433. bool TableCard::RemoveAt(int index)
  434. {
  435. if(index >= 0 && index < _maxSize)
  436. {
  437. _cards[index] = NULL;
  438. _size--;
  439. return true;
  440. }
  441. return false;
  442. }
  444. int TableCard::Size()
  445. {
  446. return _size;
  447. }
  450. bool TableCard::Pop()
  451. {
  452. if(_size > 0)
  453. {
  454. _cards[_size - 1] = NULL;
  455. _size--;
  456. return true;
  457. }
  458. return false;
  459. }
  461. Card& TableCard::operator[](int index)
  462. {
  463. if(index >= 0 && index <= _size)
  464. return *_cards[index];
  465. }
  467. void TableCard::MoveBetween(TableCard& from, TableCard& to)
  468. {
  469. to.Push(from.top());
  470. from.Pop();
  471. }
  473. /*=============================================*/
  474. /*====================Solitaire.h==================*/
  475. #pragma once
  477. #include <iostream>
  478. #include <vector>
  480. #include "Deck.h"
  481. #include "Card.h"
  482. #include "TableCard.h"
  484. const static int TABLE_SIZE = 7;
  486. class Solitaire
  487. {
  488. public:
  489. Solitaire(void);
  490. ~Solitaire(void);
  492. void PopulateTable(void);
  493. void Deal(int numToDeal=1);
  496. /* Functions for validating and moving cards */
  497. void MakeSuitMove(int from);
  498. void MakeMoveBetweenRows(int from, int to);
  499. void MakeMoveDeckToRow(int to);
  500. void MakeMoveRowToRow(int from, int to);
  501. bool ValidMove(int from, int to);
  502. bool ValidRowToRowMove(Card* fromCard, int to);
  503. bool ValidSuitMove(int from);
  505. /* Checks to see if all answer sections full */
  506. bool GameCompleted();
  508. /* Functions for printing card details */
  509. void PrintAllDetails(void);
  510. void PrintSuitDetails(void);
  511. void PrintDeckDetails(void);
  513. private:
  515. TableCard _deck;
  516. TableCard _discardedCards;
  517. std::vector<TableCard> _tableCards;
  519. //Destination of cards. When all filled player wins
  520. std::vector<TableCard> _suitCards;
  523. };
  524. /*==============================================*/
  525. /*====================Solitaire.cpp=================*/
  526. #include "Solitaire.h"
  527. using namespace std;
  528. Solitaire::Solitaire(void)
  529. :_deck(52)
  530. ,_discardedCards(52)
  531. {
  532. //Uses the deck class to populate solitaire deck
  533. //Shuffle the deck to randomize
  534. Deck deck = Deck();
  535. deck.Shuffle();
  536. deck.PopulateVector(_deck);
  538. for(int i=0; i<TABLE_SIZE; i++)
  539. {
  540. TableCard tableCard = TableCard(20);
  541. _tableCards.push_back(tableCard);
  542. }
  544. //_suitCards.resize(4);
  545. for(int i=0; i<4; i++)
  546. {
  547. TableCard suitCard = TableCard(13);
  548. _suitCards.push_back(suitCard);
  549. }
  550. PopulateTable();
  551. }
  553. Solitaire::~Solitaire(void)
  554. {
  555. }
  557. void Solitaire::PopulateTable(void)
  558. {
  559. for(int i=0; i<TABLE_SIZE; i++)
  560. {
  561. for(int j=0; j<TABLE_SIZE -i; j++)
  562. {
  563. if(j == (TABLE_SIZE - i) - 1)
  564. _deck.top().Flip();
  566. _tableCards[j].Push(_deck.top());
  567. _deck.Pop();
  568. }
  569. }
  570. }
  572. void Solitaire::Deal(int numToDeal)
  573. {
  574. int size = _deck.Size();
  575. for(int i=0; i<size; i++)
  576. {
  577. if(_deck.top().GetIsFaceUp())
  578. {
  579. _deck.top().Flip();
  580. _discardedCards.Push(_deck.top());
  581. _deck.Pop();
  582. }
  583. }
  585. if(_deck.empty())
  586. {
  587. for(int i=_discardedCards.Size()-1; i>=0; i--)
  588. _deck.Push(_discardedCards[i]);
  590. _discardedCards.Clear();
  591. }
  593. int index = 0;
  594. for(int i=0; i<numToDeal; i++)
  595. {
  596. index = _deck.Size() -i -1;
  597. if(index >= 0)
  598. {
  599. _deck[index].Flip();
  600. }
  601. else
  602. break;
  603. }
  604. }
  606. void Solitaire::PrintSuitDetails()
  607. {
  608. cout<<"=============================================\n";
  609. for(int j=0; j<_suitCards.size(); j++)
  610. {
  611. switch(j)
  612. {
  613. case 0:
  614. cout<< "h :";
  615. break;
  616. case 1:
  617. cout<< "d :";
  618. break;
  619. case 2:
  620. cout<< "s :";
  621. break;
  622. case 3:
  623. cout<< "c :";
  624. break;
  625. }
  627. for(int i=0; i<_suitCards[j].Size(); i++)
  628. {
  629. if(&_suitCards[j][i] != NULL)
  630. cout<<_suitCards[j][i] << " ";
  631. else
  632. break;
  633. }
  634. cout<< endl;
  635. }
  636. cout<<"=============================================\n";
  637. cout<<endl;
  638. }
  640. void Solitaire::PrintDeckDetails()
  641. {
  642. cout<<"--------------------------------------------\n";
  643. cout<<"|Deck: ";
  644. for(unsigned int i=0; i<_deck.Size(); i++)
  645. {
  646. if(_deck[i].GetIsFaceUp())
  647. cout<<_deck[i] << " ";
  649. }
  650. cout<<"\n--------------------------------------------\n";
  651. }
  653. void Solitaire::PrintAllDetails()
  654. {
  656. PrintDeckDetails();
  657. PrintSuitDetails();
  660. cout<< "| 6 | \t | 5 | \t | 4 | \t | 3 | \t | 2 | \t | 1 | \t | 0 |\n";
  661. cout<< "----- \t ----- \t ----- \t ----- \t ----- \t ----- \t -----\n";
  663. //Cannot be unsigned as number is always greater than or equal to 0 --
  664. int colMax = _tableCards.size();
  665. int rowMax = 0;
  666. for(int i=0; i<colMax; i++)
  667. {
  668. if(_tableCards[i].Size() > rowMax)
  669. {
  670. rowMax = _tableCards[i].Size();
  671. }
  672. }
  674. for(int i=0; i<rowMax; i++)
  675. {
  676. for(int j=colMax-1; j>=0; j--)
  677. {
  678. if(i >= _tableCards[j].Size())
  679. {
  680. cout<< " \t " ;
  681. continue;
  682. }
  684. if(_tableCards[j][i].GetIsFaceUp())
  685. cout << " " << _tableCards[j][i] << " \t ";
  686. else
  687. cout << " " <<(char)254 << " \t ";
  688. }
  689. cout<<endl;
  690. }
  691. cout<<endl<<endl;
  694. //SHOW DISCARDED CARDS
  695. /*cout<<"\nCards in the used pile: \n\n";
  696. for(unsigned int i=0; i<_discardedCards.Size(); i++)
  697. cout<<_discardedCards[i] << " ";
  698. cout<<endl<<endl;
  699. */
  700. //DISPLAYS CHILDREN AND PARENTS
  701. /*for(int i=0; i<_tableCards.size(); i++)
  702. {
  703. cout<< i << ": \n" ;
  704. for(int j= 0; j< _tableCards[i].Size(); j++)
  705. {
  706. if(_tableCards[i][j].child != NULL)
  707. {
  708. cout<< _tableCards[i][j] << "'s child is " << *_tableCards[i][j].child << endl;
  709. }
  710. if(_tableCards[i][j].parent != NULL)
  711. {
  712. cout<< _tableCards[i][j] << "'s parent is " << *_tableCards[i][j].parent << endl;
  713. }
  714. }
  715. }*/
  717. }
  719. bool Solitaire::ValidMove(int from, int to)
  720. {
  722. //start move and end move the same
  723. if(from == to && from != 7)
  724. return false;
  726. Card* toCard;
  727. Card* fromCard;
  729. if(from == 7)
  730. {
  731. if(!_deck.empty())
  732. {
  733. if(!_deck.top().GetIsFaceUp())
  734. {
  735. return false;
  736. }
  737. else
  738. {
  739. fromCard = &_deck.top();
  740. }
  741. }
  742. else
  743. {
  744. return false;
  745. }
  746. }
  747. else
  748. {
  749. //if no card in moving from row not valid
  750. if(!_tableCards[from].empty())
  751. fromCard = &_tableCards[from].top();
  752. else
  753. return false;
  754. }
  756. if(!_tableCards[to].empty())
  757. toCard = &_tableCards[to].top();
  759. //move king to empty space
  760. if(_tableCards[to].empty())
  761. {
  762. if(fromCard->GetCardRank() == 'K')
  763. return true;
  764. else
  765. return false;
  766. }
  768. else if(fromCard->GetSolitaireValue() == toCard->GetSolitaireValue()-1 )
  769. {
  770. int toColor = 0, fromColor = 0;
  771. if(toCard->GetCardSuit() == 'h' || toCard->GetCardSuit() == 'd')
  772. toColor = 0;
  773. else
  774. toColor = 1;
  775. if(fromCard->GetCardSuit() =='h' || fromCard->GetCardSuit() == 'd')
  776. fromColor = 0;
  777. else
  778. fromColor = 1;
  780. if(fromColor == toColor)
  781. return false;
  782. else
  783. return true;
  784. }
  785. return false;
  786. }
  788. bool Solitaire::ValidSuitMove(int from)
  789. {
  790. Card* fromCard;
  791. if(from == 7)
  792. {
  793. if(!_deck.empty())
  794. {
  795. if(!_deck.top().GetIsFaceUp())
  796. {
  797. return false;
  798. }
  799. else
  800. {
  801. fromCard = &_deck.top();
  802. }
  803. }
  804. else
  805. {
  806. return false;
  807. }
  808. }
  809. else
  810. {
  811. if(!_tableCards[from].empty())
  812. fromCard = &_tableCards[from].top();
  813. else
  814. return false;
  815. }
  818. char suit = fromCard->GetCardSuit();
  819. int moveIndex = 0;
  820. switch(suit)
  821. {
  822. case 'h':
  823. moveIndex = 0;
  824. break;
  825. case 'd':
  826. moveIndex = 1;
  827. break;
  828. case 's':
  829. moveIndex = 2;
  830. break;
  831. case 'c':
  832. moveIndex = 3;
  833. break;
  834. }
  836. if(fromCard->GetSolitaireValue() ==
  837. _suitCards[moveIndex].Size() + 1 )
  838. {
  839. if(!_suitCards[moveIndex].Size() == 0)
  840. {
  841. if(fromCard->parent != NULL)
  842. fromCard->parent->child = NULL;
  843. fromCard->parent = &_suitCards[moveIndex].top();
  844. _suitCards[moveIndex].top().child = fromCard;
  845. fromCard->child = NULL;
  847. }
  848. if(from != 7){
  849. TableCard::MoveBetween(_tableCards[from],_suitCards[moveIndex]);
  850. if(!_tableCards[from].empty())
  851. {
  852. if(!_tableCards[from].top().GetIsFaceUp())
  853. _tableCards[from].top().Flip();
  854. }
  855. }
  856. else
  857. {
  858. _suitCards[moveIndex].Push(_deck.top());
  859. _deck.Pop();
  860. }
  861. }
  864. return false;
  865. }
  867. void Solitaire::MakeSuitMove(int from)
  868. {
  869. /* validSuit move also makes move */
  870. ValidSuitMove(from) ;
  871. }
  875. void Solitaire::MakeMoveBetweenRows(int from, int to)
  876. {
  877. if(ValidMove(from,to))
  878. {
  879. if(!_tableCards[to].empty())
  880. _tableCards[to].top().child = &_tableCards[from].top();
  882. if(_tableCards[from].top().GetCardRank() != 'K')
  883. _tableCards[from].top().parent = &_tableCards[to].top();
  885. TableCard::MoveBetween(_tableCards[from], _tableCards[to]);
  887. if(!_tableCards[from].empty())
  888. if(!_tableCards[from].top().GetIsFaceUp())
  889. _tableCards[from].top().Flip();
  890. }
  891. }
  893. void Solitaire::MakeMoveDeckToRow(int to)
  894. {
  895. if(ValidMove(7 ,to))
  896. {
  897. if(!_tableCards[to].empty())
  898. _tableCards[to].top().child = &_deck.top();
  899. if(_deck.top().GetCardRank() != 'K')
  900. _deck.top().parent = & _tableCards[to].top();
  902. _tableCards[to].Push(_deck.top());
  903. _deck.Pop();
  906. }
  907. }
  909. void Solitaire::MakeMoveRowToRow(int from, int to)
  910. {
  911. if(from == 7)
  912. {
  913. MakeMoveDeckToRow(to);
  914. return;
  915. }
  916. else if(_tableCards[from].Size() == 0)
  917. return;
  919. Card* fromCard;
  920. fromCard = &_tableCards[from].top();
  922. if(fromCard->parent == NULL)
  923. MakeMoveBetweenRows(from,to);
  924. else
  925. {
  926. int pos = _tableCards[from].Size()-1;
  927. bool checkParent = true;
  928. bool found = false;
  929. while(checkParent && !found)
  930. {
  931. if(ValidRowToRowMove(fromCard,to))
  932. found = true;
  933. else if(fromCard->parent == NULL)
  934. checkParent = false;
  935. else
  936. {
  937. fromCard = fromCard->parent;
  938. pos--;
  939. }
  941. }
  943. if(found)
  944. {
  945. bool hasChildren = true;
  946. if(fromCard->parent != NULL)
  947. fromCard->parent->child = NULL;
  949. while(hasChildren)
  950. {
  952. if(!_tableCards[to].empty())
  953. {
  954. fromCard->parent = &_tableCards[to].top();
  955. _tableCards[to].top().child = fromCard;
  956. }
  957. _tableCards[to].Push(*fromCard);
  959. _tableCards[from].RemoveAt(pos);
  960. fromCard = fromCard->child;
  963. pos++;
  964. if(fromCard == NULL)
  965. hasChildren = false;
  966. }
  968. }
  970. if(!_tableCards[from].empty())
  971. if(!_tableCards[from].top().GetIsFaceUp())
  972. _tableCards[from].top().Flip();
  973. }
  974. }
  976. bool Solitaire::ValidRowToRowMove(Card* fromCard, int to)
  977. {
  978. Card* toCard;
  980. if(!_tableCards[to].empty())
  981. toCard = &_tableCards[to].top();
  983. //move king to empty space
  984. if(_tableCards[to].empty())
  985. {
  986. if(fromCard->GetCardRank() == 'K')
  987. return true;
  988. else
  989. return false;
  990. }
  992. else if(fromCard->GetSolitaireValue() == toCard->GetSolitaireValue()-1 )
  993. {
  994. int toColor = 0, fromColor = 0;
  995. if(toCard->GetCardSuit() == 'h' || toCard->GetCardSuit() == 'd')
  996. toColor = 0;
  997. else
  998. toColor = 1;
  999. if(fromCard->GetCardSuit() =='h' || fromCard->GetCardSuit() == 'd')
  1000. fromColor = 0;
  1001. else
  1002. fromColor = 1;
  1004. if(fromColor == toColor)
  1005. return false;
  1006. else
  1007. return true;
  1008. }
  1009. return false;
  1011. }
  1013. bool Solitaire::GameCompleted()
  1014. {
  1015. for(int i=0; i<_suitCards.size(); i++)
  1016. if(_suitCards[i].Size() < 13)
  1017. return false;
  1018. return true;
  1019. }
  1020. /*==============================================*/

Tip solutie

Permanent
Share
Tweet
Share

Despre Autor

Leave A Comment?