API tools faq
paste
Advertisement
Nofxthepirate

Card Shuffling and Dealing

Nofxthepirate
Jun 15th, 2018
87
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 11.38 KB | None | 0 0
raw download clone embed print report
  1. //Card Shuffling and Dealing Program. Can shuffle a deck of cards and deal a hand to the computer and the player, but cannot compare all hand types or play a game of poker. Includes main.cpp, Card.cpp, Card.hpp, DeckOfCards.cpp, and DeckOfCards.hpp
  2.  
  3. //Card.hpp code
  4.  
  5. #ifndef CARD_HPP
  6. #define CARD_HPP
  7. #include <iostream>
  8. #include <array>
  9. #include <string>
  10.  
  11.  
  12.     enum class Face{
  13.     ACE, TWO, THREE, FOUR, FIVE, SIX, SEVEN,
  14.      EIGHT, NINE, TEN, JACK,QUEEN, KING
  15.     };
  16.     enum class Suit{CLUBS, SPADES, HEARTS, DIAMONDS};
  17.  
  18. class Card{
  19.  
  20. public:
  21.     static const size_t FACEMAX{13};
  22.     static const size_t SUITMAX{4};
  23.     static const std::array<Face, FACEMAX> faces;
  24.     static const std::array<Suit, SUITMAX> suits;
  25.  
  26.  
  27.  
  28.     Card (Face face, Suit suit);
  29.     Card ();
  30.     std::string toString () const;
  31.     std::string toFaceString() const;
  32.     std::string toSuitString() const;
  33.     Face getFace() const;
  34.     Suit getSuit() const;
  35.  
  36.  
  37.  
  38. private:
  39.     Face cardFace;
  40.     Suit cardSuit;
  41.     static const std::array<std::string, FACEMAX> faceString;
  42.     static const std::array<std::string, SUITMAX> suitString;
  43.  
  44.  
  45. };
  46. std::ostream& operator<<(std::ostream& out, const Card& cardObject);
  47. bool operator==(const Card& left, const Card& right);
  48. bool operator!=(const Card& left, const Card& right);
  49. void operator+=(Card& left, int right);
  50.  
  51.  
  52.  
  53. #endif // CARD_HPP
  54.  
  55.  
  56. //Card.cpp code
  57.  
  58. #include "Card.hpp"
  59.  
  60.  
  61. const std::array<std::string, Card::FACEMAX> Card::faceString{"Ace", "Two", "Three", "Four",
  62.                                                 "Five", "Six", "Seven", "Eight",
  63.                                                 "Nine", "Ten", "Jack", "Queen", "King"};
  64.  
  65. const std::array<std::string, Card::SUITMAX> Card::suitString{"Clubs", "Spades", "Hearts", "Diamonds"};
  66.  
  67. const std::array<Face, Card::FACEMAX> Card::faces {
  68.     Face::ACE, Face::TWO, Face::THREE, Face::FOUR, Face::FIVE,
  69.     Face::SIX, Face::SEVEN, Face::EIGHT, Face::NINE, Face::TEN,
  70.     Face::JACK, Face::QUEEN, Face::KING
  71.     };
  72.  
  73. const std::array<Suit, Card::SUITMAX>
  74.     Card::suits {Suit::CLUBS, Suit::DIAMONDS, Suit::HEARTS, Suit::SPADES};
  75.  
  76. Card::Card (Face face, Suit suit)
  77.  :cardFace{face}, cardSuit{suit}
  78. {}
  79.  
  80. Card::Card()
  81. : Card(Face::ACE, Suit::CLUBS)
  82. {}
  83.  
  84. std::string Card::toString()const {
  85.     std::string cardString{};
  86.     cardString += faceString[static_cast<int>(cardFace)];
  87.     cardString += " of ";
  88.     cardString += suitString[static_cast<int>(cardSuit)];
  89.     return cardString;
  90.  
  91. }
  92. std::string Card::toFaceString() const{
  93.      std::string myString{faceString[static_cast<int>(cardFace)]};
  94.     return myString;
  95.     }
  96.  
  97. std::string Card::toSuitString() const{
  98.     std::string myString{suitString[static_cast<int>(cardSuit)]};
  99.     return myString;
  100.  
  101.     }
  102.  
  103. Face Card::getFace() const{
  104.     return cardFace;
  105. }
  106.  
  107. Suit Card::getSuit() const{
  108.     return cardSuit;
  109. }
  110.  
  111. std::ostream& operator<<(std::ostream& out, const Card& cardObject){
  112.     out << cardObject.toString();
  113.     return out;
  114. }
  115.  
  116. bool operator==(const Card& left, const Card& right){
  117.     return (left.toString() == right.toString());
  118.  
  119.     }
  120.  
  121. bool operator!=(const Card& left, const Card& right){
  122.     return (left.toString() != right.toString());
  123.  
  124.     }
  125. void operator+=(Card& left, const int right) {
  126.     ;
  127.  
  128. }
  129.  
  130.  
  131. //DeckOfCards.hpp code
  132.  
  133. #ifndef DECKOFCARDS_HPP
  134. #define DECKOFCARDS_HPP
  135.  
  136. #include "Card.hpp"
  137. #include <cstdlib>
  138. #include <iomanip>
  139.  
  140. class DeckOfCards {
  141. public:
  142.     static const size_t DECKMAX{52};
  143.     static const size_t HANDMAX{5};
  144.     DeckOfCards();
  145.     void printDeck() const;
  146.     void shuffle();
  147.     Card dealCard();
  148.     std::array<Card, HANDMAX> dealHand();
  149.     bool moreCards();
  150.     int cardsRemaining();
  151.     int getSize();
  152.     bool validateDeck();
  153.  
  154.  
  155. private:
  156.     std::array<Card, DECKMAX> deck;
  157.     int currentCard{0};
  158.     static std::array<Card, DECKMAX> initDeck();
  159.  
  160. };
  161.  
  162. #endif // DECKOFCARDS_HPP
  163.  
  164.  
  165. //DeckOfCards.cpp code
  166.  
  167. #include "DeckOfCards.hpp"
  168.  
  169. DeckOfCards::DeckOfCards()
  170. :deck{initDeck()}
  171. {
  172. //empty body
  173. }
  174.  
  175.  
  176. std::array<Card, DeckOfCards::DECKMAX> DeckOfCards::initDeck() {
  177.     std::array<Card, DECKMAX> newDeck{};
  178.     for(size_t i{0}; i < Card::SUITMAX; i += 1) {
  179.         for(size_t j{0}; j < Card::FACEMAX; j += 1) {
  180.             Card myCard{Card::faces[j], Card::suits[i]};
  181.             newDeck[i * Card::FACEMAX + j] = myCard;
  182.         }
  183.     }
  184.     return newDeck;
  185. }
  186.  
  187. void DeckOfCards::printDeck() const{
  188.     size_t i{0};
  189.         do {
  190.             std::cout << std::left << std::setw(20)<< deck[i];
  191.             ++i;
  192.             std::cout << std::setw(20)<< deck[i];
  193.             ++i;
  194.             std::cout << std::setw(20)<< deck[i];
  195.             ++i;
  196.             std::cout << std::setw(20)<< deck[i] << std::endl;
  197.             ++i;
  198.         }while (i < DECKMAX);
  199. }
  200.  
  201. void DeckOfCards::shuffle() {
  202.     int position{};
  203.     Card temp{};
  204.     int i{0};
  205.         for (auto item : deck){
  206.             position = rand() % 52;
  207.             temp = deck[position];
  208.             deck[position] = item;
  209.             deck[i] = temp;
  210.             ++i;
  211.  
  212.         }
  213. }
  214.  
  215. bool DeckOfCards::validateDeck() {
  216.     bool isValid{true};
  217.         for(size_t i{0}; i < DECKMAX; i += 1){
  218.         for(size_t j{0}; j < DECKMAX; j += 1){
  219.             if (i != j) {
  220.                 if (deck[i] == deck[j]) {
  221.                     std::cout << deck[i] << " in position " << i << " "<< deck[j] << " in position " << j;
  222.                     isValid = false;
  223.                 }
  224.             }
  225.             else{};
  226.         }
  227.     }
  228.     return isValid;
  229. }
  230.  
  231. int DeckOfCards::getSize() {
  232.     return deck.size();}
  233.  
  234. Card DeckOfCards::dealCard() {
  235.     Card deal{deck[currentCard]};
  236.     ++currentCard;
  237.     return deal;
  238. }
  239.  
  240. std::array<Card, DeckOfCards::HANDMAX> DeckOfCards::dealHand() {
  241.     std::array<Card, HANDMAX> myHand{};
  242.     for (size_t i{0}; i < HANDMAX; i += 1){
  243.         myHand[i] = dealCard();
  244.  
  245.     }
  246. return myHand;
  247.  
  248. }
  249.  
  250. bool DeckOfCards::moreCards() {
  251.     return (currentCard != DECKMAX);}
  252.  
  253. int DeckOfCards::cardsRemaining() {
  254.     return DECKMAX - currentCard;
  255.     }
  256.  
  257. //main.cpp code (includes test cases and hand evaluation methods)
  258.  
  259. #include <iostream>
  260. #include "Card.hpp"
  261. #include "DeckOfCards.hpp"
  262. using namespace std;
  263.  
  264. const size_t HANDMAX{5};
  265. bool isPair(const array<Card, HANDMAX>& hand);
  266. bool isTwoPair(const array<Card, HANDMAX>& hand);
  267. bool isThreeOfAKind(const array<Card, HANDMAX>& hand);
  268. bool isFourOfAKind(const array<Card, HANDMAX>& hand);
  269. bool isFlush(const array<Card, HANDMAX>& hand);
  270. void sortHand(array<Card, HANDMAX>& hand);
  271. bool isStraight(const array<Card, HANDMAX>& hand);
  272.  
  273. int main()
  274. {
  275.  Card card1{Face::JACK, Suit::CLUBS};
  276.  Card card2{Face::KING, Suit::CLUBS};
  277.  Card card3{Face::QUEEN, Suit::CLUBS};
  278.  Card card4{Face::TEN, Suit::CLUBS};
  279.  Card card5{Face::ACE, Suit::CLUBS};
  280.  
  281.     DeckOfCards deck{};
  282.     deck.printDeck();
  283.     cout << "Are there 52 unique cards in the deck? " << boolalpha << deck.validateDeck() <<  deck.getSize() << endl;
  284.  
  285.     deck.shuffle();
  286.     cout << "\n\n\n" << endl;
  287.     deck.printDeck();
  288.     cout << endl;
  289.     cout << "Are there 52 unique cards in the deck after shuffling? " << deck.validateDeck() << " " << deck.getSize() << endl;
  290.     array<Card, HANDMAX> playerHand{deck.dealHand()};
  291.  
  292. //    for (size_t i{0}; i < HANDMAX; i++){
  293. //    cout << playerHand[i] << endl;
  294. //    }
  295.  //   cout << isPair(playerHand);
  296.     playerHand[0] = card1;
  297.     playerHand[1] = card2;
  298.     playerHand[2] = card3;
  299.     playerHand[3] = card4;
  300.     playerHand[4] = card5;
  301.         for (size_t i{0}; i < HANDMAX; i++){
  302.         cout << playerHand[i] << endl;
  303.     }
  304.  
  305.     sortHand(playerHand);
  306.     for (size_t i{0}; i < HANDMAX; i++){
  307.         cout << playerHand[i] << endl;
  308.     }
  309. //    cout << isFlush(playerHand);
  310. //    cout << isStraight(playerHand);
  311. //    cout << isFourOfAKind(playerHand);
  312. //    cout << isTwoPair(playerHand);
  313. //    cout << isThreeOfAKind(playerHand);
  314.  
  315.  
  316.  
  317. //    cout << "Test dealing all cards and tracking the status of the deck: \n";
  318. //    for (int i{0}; i < 52; i++){
  319. //        cout << "Player is dealt: " << deck.dealCard();
  320. //        cout << " Cards still in deck: " << deck.cardsRemaining();
  321. //        cout << " Deck contains cards? " << deck.moreCards() << endl;
  322. //    }
  323.  
  324. }
  325. bool isPair(const array<Card, HANDMAX>& hand){
  326.     int sameFace{0};
  327.     Face kind{};
  328.     for(size_t i{0}; i < HANDMAX; i += 1) {
  329.         for(size_t j{i+1}; j < HANDMAX; j += 1) {
  330.             if (hand[i].getFace() == hand[j].getFace()){
  331.                 kind = hand[i].getFace();
  332.             }
  333.         }
  334.     }
  335.         for(size_t k{0}; k < HANDMAX; k += 1) {
  336.             if (kind == hand[k].getFace()){
  337.                 sameFace += 1;
  338.                     }
  339.                 }
  340.     return (sameFace == 2);
  341. }
  342. bool isTwoPair(const array<Card, HANDMAX>& hand){
  343.     Face kind{};
  344.     Face kind2{};
  345.     for(size_t i{0}; i < HANDMAX; i += 1) {
  346.         for(size_t j{i+1}; j < HANDMAX; j += 1) {
  347.             if ((hand[i].getFace() == hand[j].getFace()) && (kind == kind2)){
  348.                 kind = hand[i].getFace();
  349.             }
  350.             if ((hand[i].getFace() == hand[j].getFace()) && (hand[i].getFace() != kind)){
  351.                 kind2 = hand[i].getFace();
  352.             }
  353.         }
  354.     }
  355.     return (kind != kind2);
  356. }
  357.  
  358. bool isThreeOfAKind(const array<Card, HANDMAX>& hand){
  359.     int sameFace{0};
  360.     Face kind{};
  361.     for(size_t i{0}; i < HANDMAX; i += 1) {
  362.         for(size_t j{i+1}; j < HANDMAX; j += 1) {
  363.             if (hand[i].getFace() == hand[j].getFace()){
  364.                 kind = hand[i].getFace();
  365.             }
  366.         }
  367.     }
  368.     for(size_t k{0}; k < HANDMAX; k += 1) {
  369.         if (kind == hand[k].getFace()){
  370.             sameFace += 1;
  371.         }
  372.     }
  373.     return (sameFace == 3);
  374. }
  375. bool isFourOfAKind(const array<Card, HANDMAX>& hand){
  376.     int sameFace{0};
  377.     Face kind{};
  378.     for(size_t i{0}; i < HANDMAX; i += 1) {
  379.         for(size_t j{i+1}; j < HANDMAX; j += 1) {
  380.             if (hand[i].getFace() == hand[j].getFace()){
  381.                 kind = hand[i].getFace();
  382.             }
  383.         }
  384.     }
  385.     for(size_t k{0}; k < HANDMAX; k += 1) {
  386.         if (kind == hand[k].getFace()){
  387.             sameFace += 1;
  388.         }
  389.     }
  390.     return (sameFace == 4);
  391. }
  392. bool isFlush(const array<Card, HANDMAX>& hand) {
  393.     Suit suit{};
  394.     int suitCount{0};
  395.     for(size_t i{0}; i < HANDMAX; i += 1) {
  396.         for(size_t j{i+1}; j < HANDMAX; j += 1) {
  397.             if (hand[i].getSuit() == hand[j].getSuit()){
  398.                 suit = hand[i].getSuit();
  399.             }
  400.         }
  401.     }
  402.     for (size_t i{0}; i < HANDMAX; i += 1){
  403.         if (hand[i].getSuit() == suit) {
  404.             suitCount += 1;
  405.         }
  406.     }
  407.     return (suitCount == 5);
  408. }
  409. void sortHand(array<Card,HANDMAX>& hand){
  410.     for(size_t i{0}; i < HANDMAX; i += 1){
  411.         for(size_t j{i+1}; j < HANDMAX; j += 1){
  412.             if (hand[j].getFace() < hand[i].getFace()){
  413.                 Card temp{hand[j]};
  414.                 hand[j] = hand[i];
  415.                 hand[i] = temp;
  416.             }
  417.         }
  418.     }
  419.  
  420. }
  421.  
  422. //I dont think this straight code does what it should, but it runs.
  423. bool isStraight(const array<Card, HANDMAX>& hand) {
  424.     Card currentCard{hand[0]};
  425.     bool straight{true};
  426.     for(size_t i{0}; i < HANDMAX; i += 1){
  427.         if ((currentCard.getFace()) != (hand[i].getFace())){
  428.                 straight = false;
  429.  
  430.             }
  431.     }
  432.     return straight;
  433. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!