Thread: Jumping into c++ practice problem poker chapter 9

  1. #1
    Registered User
    Join Date
    Sep 2015
    Posts
    3

    Jumping into c++ practice problem poker chapter 9

    Im trying to learn c++ with a book "Jumping into c++" and im stuck on chapter 9.
    the practice problem tells me to make a simple poker program. Everything works exept declaring the poker hand .when it should be one pair it says two pair and when it should be straight flush it says royal flush (other winning hands work properly). also feel free to critically evaluate my code and give me some tips. (but note that i was limited to knowledge the book provided so far)


    Code:
    #include <iostream>
    #include <string>
    #include <cstdlib>
    #include <ctime>
    
    
    using namespace std;
    
    
    
    
    // SIMPLE DRAW POKER GAME
    
    
    //functions
    void gameWelcome();
    
    
    void gameMain();
    int gameNewCard(int drawnCards[8]);
    
    
    void gamePrintCards(int cardNum[5]);
    
    
    int gameCardSuit(int cardNum);
    int gameCardRank(int cardNum);
    
    
    int gameHands(int cards[5]);
    
    
    bool fiveSameSuit(int cards[5]);
    bool fiveInOrder(int cards[5]);
    bool fourSameRank(int cards[5]);
    bool threeSameRank(int cards[5]);
    bool twoSameRank(int cards[5]);
    bool twoSameRankDouble(int cards[5]);
    bool twoSameThreeSameRank(int cards[5]);
    
    
    
    
    
    
    int randRange(int low, int high)
    {
        int randNum = rand();
        int range = high - low;
    
    
        return randNum % (range + 1) + low;
    
    
    }
    
    
    int main()
    {
        int seed = time(NULL);
        srand(seed);
        cout << seed << endl;
    
    
        gameWelcome();
        gameMain();
    }
    
    
    void gameWelcome()
    {
        cout << "\tWELCOME TO : A SIMPLE POKER GAME\n\t\tby ****** ******.\n\n";
    }
    
    
    void gameMain()
    {
        int drawnCards[8];
        int currentCards[5];
    
    
        for (int i = 0; i <= 4; i++)  
        {
            currentCards[i] = gameNewCard(drawnCards); // get 5 cards
            drawnCards[i] = currentCards[i];
        }
    
    
        gamePrintCards(currentCards);  // Print cards
    
    
        string orderNum[3] = { "first", "second", "third" };
    
    
        for (int j = 0; j <= 2; j++)
        {
            int input = 0;
            cout << "\tSelect the " << orderNum[j] << " card to remove.\n\t(type 0 if you dont want to remove any cards)\n";
            cin >> input;
    
    
            if (input == 0)
            {
                break;
            }
            else
            {
                currentCards[input - 1] = gameNewCard(drawnCards);  // get new cards
                drawnCards[j + 5] = currentCards[input - 1];
            }
    
    
        }
    
    
        
        gamePrintCards(currentCards);  // print new cards
    
    
        string hands[10] = {"no hand", "one pair", "two pair", "three of a kind", "straight", "flush", "full house", "four of a kind", "straight flush", "royal flush"};
    
    
        cout << "Your hand is : " << hands[gameHands(currentCards)] << endl;  // declare the hand
    
    
    }
    
    
    int gameNewCard(int drawnCards[8]) // generates a new random card
    {
        int randCard;
        bool continueLoop = false;
    
    
        while (1)
        {
            continueLoop = false;
    
    
            randCard = randRange(0, 51);
    
    
            for (int i = 0; i <= 7; i++)
            {
                if (randCard == drawnCards[i])
                {
                    continueLoop = true;
                    break;
                }
            }
    
    
            if (continueLoop == false)
            {
                break;
            }
        }
        return randCard;
    
    
    
    
    
    
    } 
    
    
    void gamePrintCards(int cards[5]) // prints current cards
    {
        cout << "These are your current cards :\n\n";
    
    
        string suits[4] = { "Hearts", "Diamonds", "Clubs", "Spades" };
        string ranks[13] = { "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King", "Ace" };
    
    
        for (int i = 0; i <= 4; i++)
        {
            cout << " - " << i + 1 << ". " << ranks[gameCardRank(cards[i])] << " of " << suits[gameCardSuit(cards[i])] << endl;
    
    
        }
    
    
    }
    
    
    int gameCardSuit(int cardNum) // finds cards suit
    {
        return cardNum / 13; 
    }
    
    
    int gameCardRank(int cardNum) // finds card rank
    {
        return cardNum % 13;
    }
    
    
    int gameHands(int card[5]) // finds current hand
    {
        enum Hands { NO_HAND, ONE_PAIR, TWO_PAIRS, THREE_OF_A_KIND, STRAIGHT, FLUSH, FULL_HOUSE, FOUR_OF_A_KIND, STRAIGHT_FLUSH, ROYAL_FLUSH };
    
    
        
        if (fiveSameSuit(card) && fiveInOrder(card))
        {
            if (gameCardRank(card[0]) + gameCardRank(card[1]) + gameCardRank(card[2]) + gameCardRank(card[3]) + gameCardRank(card[4] == 50)) 
            {
                return ROYAL_FLUSH;
            }
            else 
            {
                return STRAIGHT_FLUSH;
            }
        }
    
    
        else if (fiveSameSuit(card))
        {
            return FLUSH;
        }
    
    
        else if (fiveInOrder(card))
        {
            return STRAIGHT;
        }
    
    
        else if (fourSameRank(card))
        {
            return FOUR_OF_A_KIND;
        }
    
    
        else if (threeSameRank(card))
        { 
            if (twoSameThreeSameRank)
            {
                return FULL_HOUSE;
            }
            else
            {
                return THREE_OF_A_KIND;
            }
        }
    
    
        else if (twoSameRank(card))
        {
            if (twoSameRankDouble) 
            {
                return TWO_PAIRS;
            }
    
    
            else 
            {
                return ONE_PAIR;
            }
        }
    
    
        else 
        {
            return NO_HAND;
        }
    
    
        
    }
    
    
    bool fiveSameSuit(int cards[5])
    {
        if (gameCardSuit(cards[0]) == gameCardSuit(cards[1]) &&
            gameCardSuit(cards[0]) == gameCardSuit(cards[2]) &&
            gameCardSuit(cards[0]) == gameCardSuit(cards[3]) &&
            gameCardSuit(cards[0]) == gameCardSuit(cards[4]))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    
    
    bool fiveInOrder(int cards[5])
    {
        int cardRanks[5] = { gameCardRank(cards[0]), gameCardRank(cards[1]),  gameCardRank(cards[2]),  gameCardRank(cards[3]),  gameCardRank(cards[4]) };
    
    
        for (int i = 0; i <= 3; i++)
        {
            for (int j = 0; j <= 3; j++)
            {
                if (cardRanks[j] > cardRanks[j + 1])
                {
                    int swapHolder = cardRanks[j + 1];
                    cardRanks[j + 1] = cardRanks[j];
                    cardRanks[j] = swapHolder;
    
    
                }
            }
        }
    
    
        if ((cardRanks[0] == cardRanks[1] - 1 &&
            cardRanks[1] == cardRanks[2] - 1 &&
            cardRanks[2] == cardRanks[3] - 1 &&
            cardRanks[3] == cardRanks[4] - 1 )
            ||
            (cardRanks[4] == 12 &&
            cardRanks[0] == 0 &&
            cardRanks[1] == 1 &&
            cardRanks[2] == 2 &&
            cardRanks[3] == 3))
        {
            return true;
        }
        else 
        {
            return false;
        }
    
    
    }
    
    
    bool fourSameRank(int cards[5])
    {
        int cardRanks[5] = { gameCardRank(cards[0]), gameCardRank(cards[1]),  gameCardRank(cards[2]),  gameCardRank(cards[3]),  gameCardRank(cards[4]) };
    
    
        for (int i = 0; i <= 3; i++)
        {
            for (int j = 0; j <= 3; j++)
            {
                if (cardRanks[j] > cardRanks[j + 1])
                {
                    int swapHolder = cardRanks[j + 1];
                    cardRanks[j + 1] = cardRanks[j];
                    cardRanks[j] = swapHolder;
    
    
                }
            }
        }
    
    
        if ((cardRanks[0] == cardRanks[1] &&
            cardRanks[1] == cardRanks[2] &&
            cardRanks[2] == cardRanks[3])
            ||
            (cardRanks[1] == cardRanks[2] &&
            cardRanks[2] == cardRanks[3] &&
            cardRanks[3] == cardRanks[4]))
        {
            return true;
        }
        else 
        {
            return false;
        }
    
    
    }
    
    
    bool threeSameRank(int cards[5])
    {
        int cardRanks[5] = { gameCardRank(cards[0]), gameCardRank(cards[1]),  gameCardRank(cards[2]),  gameCardRank(cards[3]),  gameCardRank(cards[4]) };
    
    
        for (int i = 0; i <= 3; i++)
        {
            for (int j = 0; j <= 3; j++)
            {
                if (cardRanks[j] > cardRanks[j + 1])
                {
                    int swapHolder = cardRanks[j + 1];
                    cardRanks[j + 1] = cardRanks[j];
                    cardRanks[j] = swapHolder;
    
    
                }
            }
        }
    
    
        if ((cardRanks[0] == cardRanks[1] &&
            cardRanks[1] == cardRanks[2])
            ||
            (cardRanks[2] == cardRanks[3] &&
            cardRanks[3] == cardRanks[4])
            ||
            (cardRanks[1] == cardRanks[2] &&
            cardRanks[2] == cardRanks[3]))
        {
            return true;
        }
        else
        {
            return false;
        }
    
    
    }
    
    
    bool twoSameRank(int cards[5])
    {
        int cardRanks[5] = { gameCardRank(cards[0]), gameCardRank(cards[1]),  gameCardRank(cards[2]),  gameCardRank(cards[3]),  gameCardRank(cards[4]) };
    
    
        for (int i = 0; i <= 3; i++)
        {
            for (int j = 0; j <= 3; j++)
            {
                if (cardRanks[j] > cardRanks[j + 1])
                {
                    int swapHolder = cardRanks[j + 1];
                    cardRanks[j + 1] = cardRanks[j];
                    cardRanks[j] = swapHolder;
    
    
                }
            }
        }
    
    
        if (cardRanks[0] == cardRanks[1] 
            || 
            cardRanks[1] == cardRanks[2]
            || 
            cardRanks[2] == cardRanks[3]
            ||
            cardRanks[3] == cardRanks[4])
        
        {
            return true;
        }
        else
        {
            return false;
        }
    
    
    }
    
    
    bool twoSameRankDouble(int cards[5])
    {
        int cardRanks[5] = { gameCardRank(cards[0]), gameCardRank(cards[1]),  gameCardRank(cards[2]),  gameCardRank(cards[3]),  gameCardRank(cards[4]) };
    
    
        for (int i = 0; i <= 3; i++)
        {
            for (int j = 0; j <= 3; j++)
            {
                if (cardRanks[j] > cardRanks[j + 1])
                {
                    int swapHolder = cardRanks[j + 1];
                    cardRanks[j + 1] = cardRanks[j];
                    cardRanks[j] = swapHolder;
    
    
                }
            }
        }
    
    
        if (cardRanks[0] == cardRanks[1] && cardRanks[2] == cardRanks[3]
            ||
            cardRanks[1] == cardRanks[2] && cardRanks[3] == cardRanks[4]
            ||
            cardRanks[0] == cardRanks[1] && cardRanks[3] == cardRanks[4])
        {
            return true;
        }
        else
        {
            return false;
        }
    
    
    }
    
    
    bool twoSameThreeSameRank(int cards[5]) 
    {
        int cardRanks[5] = { gameCardRank(cards[0]), gameCardRank(cards[1]),  gameCardRank(cards[2]),  gameCardRank(cards[3]),  gameCardRank(cards[4]) };
    
    
        for (int i = 0; i <= 3; i++)
        {
            for (int j = 0; j <= 3; j++)
            {
                if (cardRanks[j] > cardRanks[j + 1])
                {
                    int swapHolder = cardRanks[j + 1];
                    cardRanks[j + 1] = cardRanks[j];
                    cardRanks[j] = swapHolder;
    
    
                }
            }
        }
    
    
        if (cardRanks[0] == cardRanks[1] && cardRanks[1] == cardRanks[2] && cardRanks[3] == cardRanks[4]
            ||
            cardRanks[0] == cardRanks[1] && cardRanks[2] == cardRanks[3] && cardRanks[3] == cardRanks[4])
        {
            return true;
        }
        else
        {
            return false;
        }
    }

  2. #2
    Unregistered User Yarin's Avatar
    Join Date
    Jul 2007
    Posts
    2,158
    Because you are testing the function itself as a pointer when you are meaning to test the result of the function call.

    Code:
        else if (twoSameRank(card))
        {
            if (twoSameRankDouble) 
            {
                return TWO_PAIRS;
            }
     
     
            else
            {
                return ONE_PAIR;
            }
        }
    I highlighted your mistake.

    You should compile with all warnings turned on, it would catch this.

  3. #3
    Registered User
    Join Date
    Sep 2015
    Posts
    3
    Thanks

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Poker game - Jumping into C++ practice problem
    By 1Sunny in forum C++ Programming
    Replies: 7
    Last Post: 07-12-2015, 08:05 AM
  2. Question on "Jumping into C++" Chapter 13 practice problem 1
    By Ben Sturm in forum C++ Programming
    Replies: 9
    Last Post: 04-01-2015, 01:16 PM
  3. Linked Lists Chapter 15 Practice Problem 1 Jumping Into C++
    By ArtemisFowl2nd in forum C++ Programming
    Replies: 34
    Last Post: 04-30-2014, 12:59 PM
  4. Jumping Into C++ Chapter 14 Practice Problem 1
    By ArtemisFowl2nd in forum C++ Programming
    Replies: 5
    Last Post: 04-16-2014, 09:36 PM
  5. Replies: 2
    Last Post: 02-24-2014, 05:51 PM

Tags for this Thread