NumericalTicTacToe.h

Go to the documentation of this file.

#ifndef NUMERICALTICTACTOE_H
#define NUMERICALTICTACTOE_H
 
#include "BoardGame_Classes.h"
#include <iostream>
#include <set>
#include <cstdlib>
#include <ctime>
using namespace std;
 
// Numerical Tic Tac Toe Board
class NumericalTicTacToeBoard : public Board<int> {
private:
    set<int> used_numbers;
 
    bool check_sum(int a, int b, int c) {
        return (a + b + c == 15);
    }
 
public:
    NumericalTicTacToeBoard() : Board(3, 3) {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                board[i][j] = 0;
            }
        }
    }
 
    bool update_board(Move<int>* move) override {
        int x = move->get_x();
        int y = move->get_y();
        int number = move->get_symbol();
 
        if (x < 0 || x >= 3 || y < 0 || y >= 3) {
            cout << "Invalid position! Use 0-2.\n";
            return false;
        }
 
        if (board[x][y] != 0) {
            cout << "Cell already occupied!\n";
            return false;
        }
 
        if (number < 1 || number > 9) {
            cout << "Number must be 1-9!\n";
            return false;
        }
 
        if (used_numbers.find(number) != used_numbers.end()) {
            cout << "Number " << number << " already used!\n";
            return false;
        }
 
        // Check parity: Player 1 (odd moves) uses odd numbers, Player 2 uses even
        if ((n_moves % 2 == 0 && number % 2 == 0) ||
            (n_moves % 2 == 1 && number % 2 == 1)) {
            cout << "Wrong number type! Player " << (n_moves % 2 == 0 ? "1" : "2")
                << " must use " << (n_moves % 2 == 0 ? "odd" : "even") << " number.\n";
            return false;
        }
 
        board[x][y] = number;
        used_numbers.insert(number);
        n_moves++;
        return true;
    }
 
    bool is_win(Player<int>* player) override {
        // Check rows
        for (int i = 0; i < 3; i++) {
            if (check_sum(board[i][0], board[i][1], board[i][2]))
                return true;
        }
 
        // Check columns
        for (int j = 0; j < 3; j++) {
            if (check_sum(board[0][j], board[1][j], board[2][j]))
                return true;
        }
 
        // Check diagonals
        if (check_sum(board[0][0], board[1][1], board[2][2]) ||
            check_sum(board[0][2], board[1][1], board[2][0]))
            return true;
 
        return false;
    }
 
    bool is_lose(Player<int>* player) override {
        return false;
    }
 
    bool is_draw(Player<int>* player) override {
        return (n_moves == 9 && !is_win(player));
    }
 
    bool game_is_over(Player<int>* player) override {
        return is_win(player) || is_draw(player);
    }
};
 
// Numerical Player
class NumericalTicTacToePlayer : public Player<int> {
public:
    NumericalTicTacToePlayer(string name, int symbol) : Player(name, symbol, PlayerType::HUMAN) {}
};
 
// Numerical Random Player
class NumericalTicTacToeRandomPlayer : public Player<int> {
public:
    NumericalTicTacToeRandomPlayer(int symbol) : Player("Random Computer", symbol, PlayerType::COMPUTER) {
        srand(time(0));
    }
};
 
// Numerical UI
class NumericalTicTacToeUI : public UI<int> {
public:
    NumericalTicTacToeUI() : UI("Welcome to Numerical Tic-Tac-Toe!", 3) {}
 
    Move<int>* get_move(Player<int>* player) override {
        if (player->get_type() == PlayerType::HUMAN) {
            int x, y, number;
            cout << player->get_name() << " ("
                << (player->get_symbol() == 1 ? "Odd" : "Even")
                << " numbers), enter your move (row, column, and number): ";
            cin >> x >> y >> number;
            return new Move<int>(x, y, number);
        }
        else {
            int x = rand() % 3;
            int y = rand() % 3;
            int number;
 
            // Generate appropriate number based on turn
            if (player->get_symbol() == 1) { // Odd numbers
                number = (rand() % 5) * 2 + 1; // 1, 3, 5, 7, 9
            }
            else { // Even numbers
                number = (rand() % 4) * 2 + 2; // 2, 4, 6, 8
            }
 
            cout << player->get_name() << " chooses position (" << x << ", " << y
                << ") with number " << number << "\n";
            return new Move<int>(x, y, number);
        }
    }
};
 
#endif // NUMERICALTICTACTOE_H