UltimateTicTacToe.h

Go to the documentation of this file.

#ifndef ULTIMATETICTACTOE_H
#define ULTIMATETICTACTOE_H
 
#include "BoardGame_Classes.h"
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
 
// Ultimate Tic Tac Toe Board
class UltimateTicTacToeBoard : public Board<char> {
private:
    char sub_winners[3][3] = { {' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '} };
    int last_move_x = -1, last_move_y = -1;
 
    bool check_sub_win(int subgrid_row, int subgrid_col, char symbol) {
        int start_row = subgrid_row * 3;
        int start_col = subgrid_col * 3;
 
        // Check rows in subgrid
        for (int i = 0; i < 3; i++) {
            if (board[start_row + i][start_col] == symbol &&
                board[start_row + i][start_col + 1] == symbol &&
                board[start_row + i][start_col + 2] == symbol)
                return true;
        }
 
        // Check columns in subgrid
        for (int j = 0; j < 3; j++) {
            if (board[start_row][start_col + j] == symbol &&
                board[start_row + 1][start_col + j] == symbol &&
                board[start_row + 2][start_col + j] == symbol)
                return true;
        }
 
        // Check diagonals in subgrid
        if (board[start_row][start_col] == symbol &&
            board[start_row + 1][start_col + 1] == symbol &&
            board[start_row + 2][start_col + 2] == symbol)
            return true;
 
        if (board[start_row][start_col + 2] == symbol &&
            board[start_row + 1][start_col + 1] == symbol &&
            board[start_row + 2][start_col] == symbol)
            return true;
 
        return false;
    }
 
    bool check_main_win(char symbol) {
        // Check rows in main grid
        for (int i = 0; i < 3; i++) {
            if (sub_winners[i][0] == symbol && sub_winners[i][1] == symbol && sub_winners[i][2] == symbol)
                return true;
        }
 
        // Check columns in main grid
        for (int j = 0; j < 3; j++) {
            if (sub_winners[0][j] == symbol && sub_winners[1][j] == symbol && sub_winners[2][j] == symbol)
                return true;
        }
 
        // Check diagonals in main grid
        if (sub_winners[0][0] == symbol && sub_winners[1][1] == symbol && sub_winners[2][2] == symbol)
            return true;
        if (sub_winners[0][2] == symbol && sub_winners[1][1] == symbol && sub_winners[2][0] == symbol)
            return true;
 
        return false;
    }
 
public:
    UltimateTicTacToeBoard() : Board(9, 9) {
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                board[i][j] = ' ';
            }
        }
    }
 
    bool update_board(Move<char>* move) override {
        int x = move->get_x();
        int y = move->get_y();
        char symbol = move->get_symbol();
 
        if (x < 0 || x >= 9 || y < 0 || y >= 9) {
            cout << "Invalid position! Use 0-8.\n";
            return false;
        }
 
        // Check if move is in allowed subgrid
        if (last_move_x != -1 && last_move_y != -1) {
            int target_subgrid_row = last_move_x % 3;
            int target_subgrid_col = last_move_y % 3;
            int current_subgrid_row = x / 3;
            int current_subgrid_col = y / 3;
 
            if (sub_winners[target_subgrid_row][target_subgrid_col] == ' ') {
                // Must play in specified subgrid unless it's won
                if (current_subgrid_row != target_subgrid_row ||
                    current_subgrid_col != target_subgrid_col) {
                    cout << "Must play in subgrid (" << target_subgrid_row
                        << ", " << target_subgrid_col << ")\n";
                    return false;
                }
            }
        }
 
        if (board[x][y] != ' ') {
            cout << "Cell already occupied!\n";
            return false;
        }
 
        board[x][y] = symbol;
        n_moves++;
 
        // Check if subgrid is won
        int subgrid_row = x / 3;
        int subgrid_col = y / 3;
        if (sub_winners[subgrid_row][subgrid_col] == ' ' &&
            check_sub_win(subgrid_row, subgrid_col, symbol)) {
            sub_winners[subgrid_row][subgrid_col] = symbol;
        }
 
        // Set next move target
        last_move_x = x;
        last_move_y = y;
 
        return true;
    }
 
    bool is_win(Player<char>* player) override {
        return check_main_win(player->get_symbol());
    }
 
    bool is_lose(Player<char>* player) override {
        return false;
    }
 
    bool is_draw(Player<char>* player) override {
        // Check if all subgrids are won or full
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (sub_winners[i][j] == ' ') {
                    // Check if subgrid has empty cells
                    bool has_empty = false;
                    for (int si = 0; si < 3; si++) {
                        for (int sj = 0; sj < 3; sj++) {
                            if (board[i * 3 + si][j * 3 + sj] == ' ') {
                                has_empty = true;
                                break;
                            }
                        }
                        if (has_empty) break;
                    }
                    if (has_empty) return false;
                }
            }
        }
        return !is_win(player);
    }
 
    bool game_is_over(Player<char>* player) override {
        return is_win(player) || is_draw(player);
    }
};
 
// Ultimate Player
class UltimateTicTacToe_Player : public Player<char> {
public:
    UltimateTicTacToe_Player(string name, char symbol) : Player(name, symbol, PlayerType::HUMAN) {}
};
 
// Ultimate Random Player
class UltimateTicTacToe_RandomPlayer : public Player<char> {
public:
    UltimateTicTacToe_RandomPlayer(char symbol) : Player("Random Computer", symbol, PlayerType::COMPUTER) {
        srand(time(0));
    }
};
 
// Ultimate UI
class UltimateTicTacToe_UI : public UI<char> {
public:
    UltimateTicTacToe_UI() : UI("Welcome to Ultimate Tic-Tac-Toe!", 3) {}
 
    Move<char>* get_move(Player<char>* player) override {
        if (player->get_type() == PlayerType::HUMAN) {
            int x, y;
            cout << player->get_name() << " (" << player->get_symbol()
                << "), enter your move (row and column 0-8): ";
            cin >> x >> y;
            return new Move<char>(x, y, player->get_symbol());
        }
        else {
            int x = rand() % 9;
            int y = rand() % 9;
            cout << player->get_name() << " chooses position (" << x << ", " << y << ")\n";
            return new Move<char>(x, y, player->get_symbol());
        }
    }
};
 
#endif // ULTIMATETICTACTOE_H