path: root/game.cpp

/*
 * game.cpp
 *
 *
 */

#include "game.h"
#include <cstdlib>

/* forward declaration of hands array, very interesting, I didn't know C++ needs this */
string *Game::hands[10];
string *Game::suits[5];

Game::Game(void)
{
    hands[0] = new string("Royal Flush");
    hands[1] = new string("Straight Flush");
    hands[2] = new string("Four of a Kind");
    hands[3] = new string("Full House");
    hands[4] = new string("Flush");
    hands[5] = new string("Straight");
    hands[6] = new string("Three of a Kind");
    hands[7] = new string("Two Pair");
    hands[8] = new string("One Pair");
    hands[9] = new string("High Card");

    suits[0] = new string("Undefined");
    suits[1] = new string("Clubs");
    suits[2] = new string("Diamonds");
    suits[3] = new string("Hearts");
    suits[4] = new string("Spades");
}

void Game::shufflePile(void)
{
    /* interesting algorithm that was discussed in the class */
    Card *tmp;
    int i, j;
    for (i = 0; i < 52; i++)
    {
        j = rand() % 52;
        tmp = getCardFromDeck(i);

        putCardToDeck(i, getCardFromDeck(j));
        putCardToDeck(j, tmp);
    }
}

int Game::parseInt(string *msg, int rangeA, int rangeB)
{
    int tmp;
    bool continueAsking = true;

    while (continueAsking)
    {
        if (msg)
            cout << *msg;

        if (!(cin >> tmp))
        {
            cin.clear();
            cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            PRINT_COLOR(ANSI_COLOR_RED, "Invalid input!\n");
            continue;
        }

        if ((tmp >= rangeA) && (tmp <= rangeB))
            continueAsking = false;
        else
            PRINT_COLOR(ANSI_COLOR_YELLOW, "Number not in the range!\n");
    }

    return tmp;
}

void Game::askForNumberOfOpponents(void)
{
    bool continueAsking = true;
    while (continueAsking)
    {
        cout << "Enter the amount of opponents between 1 to 3: ";

        if (!(cin >> numOfOpponents))
        {
            cin.clear();
            cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            PRINT_COLOR(ANSI_COLOR_RED, "Invalid character(s)!\n");
            continue;
        }

        if ((numOfOpponents >= 1) && (numOfOpponents <= 3))
            continueAsking = false;
        else
            PRINT_COLOR(ANSI_COLOR_YELLOW, "Number not in the range!\n");
    }
}

void Game::repeatGame(bool *quit)
{
    bool continueAsking = true;
    char play_again;
    cout << endl;
    while (continueAsking)
    {
        PRINT_COLOR(ANSI_COLOR_GREEN, "Play again? (y/n) ");
        cin >> play_again;
        play_again = tolower(play_again);

        if (play_again == 'y')
            continueAsking = false;

        else if (play_again == 'n')
        {
            continueAsking = false;
            *quit = true;
        }
    }
}

int Game::howManyCardsOfSameSuit(Card **cards)
{
    if (cards == NULL)
    {
        PRINT_COLOR(ANSI_COLOR_RED, "\nhowManyCardsOfSameSuit(): cards parameter is NULL!\n");
        return -1;
    }

    char c, l;
    l = cards[0]->getType()[1];

    int i;
    for (i = 1; i < 5; i++)
    {
        c = cards[i]->getType()[1];
        if (c != l)
            break;
    }

    return i;
}

bool Game::pairOrBetter(Card **cards)
{
    if (cards == NULL)
    {
        PRINT_COLOR(ANSI_COLOR_RED, "\npairOrBetter(): cards parameter is NULL!\n");
        return false;
    }

    char c1, c2;
    int ret = 0;

    int i, j;
    for (i = 0; i < 5; i++)
    {
        c1 = cards[i]->getType()[0];

        for (j = i+1; j < 5; j++)
        {
            c2 = cards[j]->getType()[0];
            if (c1 == c2)
            {
                ret++;
                break;
            }
        }
    }

    return (ret != 0);
}

/* returns max number of same cards, returns 0 when all cards are different */
int Game::numOfSameCards(Card **cards)
{
    if (cards == NULL)
    {
        PRINT_COLOR(ANSI_COLOR_RED, "\nnumOfSameCards(): cards parameter is NULL!\n");
        return -1;
    }

    char c1, c2;
    int same = 0;
    int max = 0;

    int i, j;
    for (i = 0; i < 5; i++)
    {
        c1 = cards[i]->getType()[0];

        for (j = i+1; j < 5; j++)
        {
            c2 = cards[j]->getType()[0];
            same = 1;

            if (c1 == c2)
            {
                same++;
                if (same > max)
                    max = same;
            }
            else
            {
                same = 0;
                c1 = c2;
            }
        }
    }

    return max;
}

struct countAndSuit Game::numOfSameSuit(Card **cards)
{
    struct countAndSuit same[5] =
    {
        { Clubs, 0},
        { Diamond, 0 },
        { Hearts, 0 },
        { Spades, 0 },
        { Undef, -1 },
    };

    if (cards == NULL)
    {
        PRINT_COLOR(ANSI_COLOR_RED, "\nnumOfSameSuit(): cards parameter is NULL!\n");
        return same[4];
    }

    int max = 0;
    enum Suit tmpSuit = Undef;

    /* go through all cards and count how many there is of each suit */
    int i;
    for (i = 0; i < 5; i++)
    {
        tmpSuit = cards[i]->getSuit();

        switch (tmpSuit)
        {
        case Clubs:
            same[0].count += 1;
            break;
        case Diamond:
            same[1].count += 1;
            break;
        case Hearts:
            same[2].count += 1;
            break;
        case Spades:
            same[3].count += 1;
            break;
        default:
            cout << "could not determine the suit of the card" << endl;
        }
    }

    int whereMaxWasFound = 0;
    /* look for the max number of cards of the same suit */
    for (i = 0; i < 4; i++)
        if (same[i].count > max)
        {
            max = same[i].count;
            whereMaxWasFound = i;
        }

    return same[whereMaxWasFound];
}

bool Game::doWeHaveAnAce(Card **cards)
{
    if (cards == NULL)
    {
        PRINT_COLOR(ANSI_COLOR_RED, "\ndoWeHaveAnAce(): cards parameter is NULL!\n");
        return false;
    }

    char c;

    int i;
    for (i = 0; i < 5; i++)
    {
        c = cards[i]->getType()[0];
        if (c == 'A')
            return true;
    }

    return false;
}

void Game::discardFromPairOrBetter(Card **cards, int whichOpponent)
{
    if (cards == NULL)
    {
        PRINT_COLOR(ANSI_COLOR_RED, "\ndiscardFromPairOrBetter(): cards parameter is NULL!\n");
        return;
    }


    int howManyOfSameCards[5] = { 1,1,1,1,1 };
    int numOfDiscarded = 0;
    char c1, c2;

    /* goal is to look later at indices that contain zero */ 
    int i, j;
    for (i = 0; i < 5; i++)
    {
        c1 = cards[i]->getType()[0];

        for (j = 0; j < 5; j++)
        {
            /* don't count itself */
            if (j == i)
                continue;

            c2 = cards[j]->getType()[0];
            if (c1 == c2)
                howManyOfSameCards[i] += 1;
        }
    }

    /* indices that contain a zero should be discarded */
    for (i = 0; i < 5; i++)
    {
        if (howManyOfSameCards[i] == 1)
        {
            discardAndDraw(cards, 1, i);
            numOfDiscarded++;
        }
    }

    cout << "Opponent " << whichOpponent << " has discarded "
         << numOfDiscarded << " card(s)" << endl;
}

/* make sure cards are in decreasing rank */
bool Game::sanityCheck(Card **cards)
{
    if (cards == NULL)
    {
        PRINT_COLOR(ANSI_COLOR_RED, "\nsanityCheck(): cards parameter is NULL!\n");
        return false;
    }

    int back1, back2;
    back1 = cards[0]->getRank();

    int i;
    for (i = 1; i < 5; i++)
    {
        back2 = cards[i]->getRank();
        if (back2 >= back1) /* this could mean that cards are not sorted or
                             * there a pair, which would be really bad since
                             * opponentAI should catch that */
            return false;
        back1 = back2;
    }

#ifdef DEBUG
    PRINT_COLOR(ANSI_COLOR_CYAN, "\ndebug: sanity check passed, must be a High Hand");
#endif

    return true;
}



void Game::discardAndDraw(Card **cards, int amount, int offset)
{
    if (offset + amount > 5)
    {
        PRINT_COLOR(ANSI_COLOR_RED, "amount of cards to be discarded is out of bounds!\n");
        return;
    }
    else if (cards == NULL)
    {
        PRINT_COLOR(ANSI_COLOR_RED, "\ndiscardAndDraw(): cards parameter is NULL!\n");
        return;
    }

    int i;
    /* discard cards starting from offset */
    for (i = 0; i < amount; i++)
    {
#ifdef DEBUG
        cout << ANSI_COLOR_CYAN << "debug: discarding card " << i+1 << " \"" << cards[offset+i]->getType()
             << "\" at cards[" << offset+i << "]" << endl << ANSI_COLOR_RESET;
#endif
        putCardToDiscardPile(cards[offset+i]);
    }

    /* draw cards from the deck into starting at cards[offset] */
    for (i = 0; i < amount; i++)
    {
        cards[offset+i] = PopCardFromDeck();
#ifdef DEBUG
        cout << ANSI_COLOR_CYAN << "debug: drawing card " << i+1 << " \"" << cards[offset+i]->getType()
             << "\" into cards[" << offset+i << "]" << endl << ANSI_COLOR_RESET;
#endif
    }
}



void Game::opponentAI(int whichOpponent)
{
    Card **cards = getOpponentsCards(whichOpponent);
    if (cards == NULL)
        return;

    struct countAndSuit tmp = numOfSameSuit(cards);

    if (pairOrBetter(cards))
    {
#ifdef DEBUG
        cout << ANSI_COLOR_CYAN << "\ndebug: opponent " << whichOpponent
             << ", there's a pair or better" << endl << ANSI_COLOR_RESET;
#endif
        /* discard some cards*/
        discardFromPairOrBetter(cards, whichOpponent);

        return;
    }

    else if ( (tmp = numOfSameSuit(cards)).count == 5)
    {
#ifdef DEBUG
        cout << ANSI_COLOR_CYAN << "\ndebug: opponent " << whichOpponent
             << ", 5 cards are of the same suit!" << endl << ANSI_COLOR_RESET;
#endif
        /* keep 5 cards of the same suit */
        cout << "Opponent " << whichOpponent << " kept all 5 of the cards" << endl;

        return;
    }

    else if (tmp.count == 4)
    {
#ifdef DEBUG
        cout << ANSI_COLOR_CYAN << "\ndebug: opponent " << whichOpponent
            << ", 4 cards are of the same suit" << endl << ANSI_COLOR_RESET;
#endif
        /* keep 4 cards of the same suit and discard 1 of different suit */

        /* we need to loop through cards[] and find a card with different suit */
        int i;
        for (i = 0; i < 5; i++)
        {
            if (cards[i]->getSuit() != tmp.whatSuit)
                break;
        }

        /* no i should be the index of card that we want to discard */
        discardAndDraw(cards, 1, i);
        cout << "Opponent " << whichOpponent << " has discarded 1 card" << endl;

        return;
    }

    else if (doWeHaveAnAce(cards))
    {
    #ifdef DEBUG
        cout << ANSI_COLOR_CYAN << "\ndebug: opponent " << whichOpponent
             << ", High Hand with Ace detected" << endl << ANSI_COLOR_RESET;
    #endif

        /* discard 4 cards */
        discardAndDraw(cards, 4, 1);
        cout << "Opponent " << whichOpponent << " has discarded 4 cards" << endl;

        return;
    }

    else if (sanityCheck(cards))
    {
    #ifdef DEBUG
        cout << ANSI_COLOR_CYAN << "\ndebug: opponent " << whichOpponent
             << ", High Hand detected" << endl << ANSI_COLOR_RESET;
    #endif

        /* discard 3 cards */
        discardAndDraw(cards, 3, 2);
        cout << "Opponent " << whichOpponent << " has discarded 3 cards" << endl;

        return;
    }

    #ifdef DEBUG
    else
        cout << ANSI_COLOR_RED << "\ndebug: opponent " << whichOpponent
             << ", FATAL: cards did not match any of the criterias!"
             << endl << ANSI_COLOR_RESET;
    #endif
}