Game.cpp

#include "Game.h"
#include <iostream>
#include <limits>

static int readInt() {
    int n;
    while (!(std::cin >> n)) {
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }
    return n;
}

Game::Game() : current(0), activeColor(Color::Red) {
    std::cout << "Player 1 name: ";
    std::getline(std::cin, playerNames[0]);
    if (playerNames[0].empty()) playerNames[0] = "Player 1";
    std::cout << "Player 2 name: ";
    std::getline(std::cin, playerNames[1]);
    if (playerNames[1].empty()) playerNames[1] = "Player 2";

    for (int i = 0; i < 7; ++i) {
        hands[0].addCard(deck.draw());
        hands[1].addCard(deck.draw());
    }
    // keep flipping until we get a non-wild start card
    Card* startCard;
    do {
        startCard = deck.draw();
        if (startCard->color == Color::Wild) {
            deck.buryCard(startCard);
            startCard = nullptr;
        }
    } while (!startCard);
    activeColor = startCard->color;
    deck.discard(startCard);
}

Game::~Game() {
    for (auto& h : hands)
        for (Card* c : h.cards)
            delete c;
}

Color Game::chooseColor() const {
    std::cout << "Pick a color: 0=🔴  1=🟡  2=🟢  3=🔵\n> ";
    int ch;
    while (!(std::cin >> ch) || ch < 0 || ch > 3) {
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        std::cout << "> ";
    }
    Color opts[] = { Color::Red, Color::Yellow, Color::Green, Color::Blue };
    return opts[ch];
}

void Game::handleFallout(const TurnEffect& effect) {
    int other = 1 - current;
    for (int i = 0; i < effect.forceDraw; ++i) {
        Card* c = deck.draw();
        if (c) hands[other].addCard(c);
    }
    if (effect.skipNext)
        std::cout << playerNames[other] << " is skipped.\n";
}

bool Game::hasPlayable(const Hand& h) const {
    const Card* top = deck.peekTop();
    for (Card* c : h.cards)
        if (c->isPlayable(activeColor, top)) return true;
    return false;
}

void Game::run() {
    std::cout << "=== UNO -- 2 Player ===\n";

    while (true) {
        int other = 1 - current;
        const Card* top = deck.peekTop();

        std::cout << "\n--- " << playerNames[current] << "'s turn ---\n";
        std::cout << playerNames[other] << " has " << hands[other].cards.size()
                  << " card(s).  Draw pile: " << deck.size() << " card(s).\n";
        std::cout << "Discard: " << top->display();
        if (top->color == Color::Wild)
            std::cout << " (active: " << colorName(activeColor) << ")";
        std::cout << "\nHand:\n";
        hands[current].display(activeColor);

        TurnEffect effect;
        bool cardPlayed = false;

        if (hasPlayable(hands[current])) {
            int idx;
            while (true) {
                std::cout << "Play card [0-" << (int)hands[current].cards.size() - 1 << "]: ";
                idx = readInt();
                if (idx < 0 || idx >= (int)hands[current].cards.size()) {
                    std::cout << "Out of range.\n";
                    continue;
                }
                if (!hands[current].cards[idx]->isPlayable(activeColor, deck.peekTop())) {
                    std::cout << "That card doesn't play here.\n";
                    continue;
                }
                break;
            }
            Card* c = hands[current].removeCard(idx);
            std::cout << "Played: " << c->display() << "\n";
            if (c->color == Color::Wild) {
                activeColor = chooseColor();
                std::cout << "Active color: " << colorName(activeColor) << "\n";
            } else {
                activeColor = c->color;
            }
            effect = c->applyEffect();
            deck.discard(c);
            cardPlayed = true;
        } else {
            // draw until a playable card is found
            std::cout << "No playable cards. Drawing...\n";
            Card* playableDrawn = nullptr;
            while (!playableDrawn) {
                Card* drawn = deck.draw();
                if (!drawn) {
                    std::cout << "Deck is empty, nothing to draw.\n";
                    break;
                }
                std::cout << "Drew: " << drawn->display() << "\n";
                if (drawn->isPlayable(activeColor, deck.peekTop())) {
                    playableDrawn = drawn;
                } else {
                    hands[current].addCard(drawn);
                }
            }
            if (playableDrawn) {
                std::cout << "It's playable! Play it? 1=yes  0=keep: ";
                if (readInt() == 1) {
                    std::cout << "Played: " << playableDrawn->display() << "\n";
                    if (playableDrawn->color == Color::Wild) {
                        activeColor = chooseColor();
                        std::cout << "Active color: " << colorName(activeColor) << "\n";
                    } else {
                        activeColor = playableDrawn->color;
                    }
                    effect = playableDrawn->applyEffect();
                    deck.discard(playableDrawn);
                    cardPlayed = true;
                } else {
                    hands[current].addCard(playableDrawn);
                }
            }
        }

        // when a player drops to 1 card, opponent can call Uno
        if (cardPlayed && hands[current].cards.size() == 1) {
            std::cout << playerNames[other] << ", call Uno on " << playerNames[current]
                      << "? 1=yes  0=no: ";
            if (readInt() == 1) {
                std::cout << playerNames[current] << " must draw 2 penalty cards!\n";
                for (int i = 0; i < 2; ++i) {
                    Card* c = deck.draw();
                    if (c) hands[current].addCard(c);
                }
            }
        }

        if (hands[current].isEmpty()) {
            std::cout << playerNames[current] << " wins! UNO!\n";
            return;
        }

        handleFallout(effect);

        if (!effect.skipNext)
            current = 1 - current;
    }
}