TicTacToe4x4.h

Go to the documentation of this file.

#ifndef TICTACTOE4X4_H
#define TICTACTOE4X4_H
 
#include "BoardGame_Classes.h"
#include <cstdlib>
#include <ctime>
 
class TicTacToe4x4_Board : public Board<char> {
public:
    TicTacToe4x4_Board();
    bool update_board(Move<char>* move) override;
    bool is_win(Player<char>* player) override;
    bool is_draw(Player<char>* player) override;
    bool is_lose(Player<char>* player) override;
    bool game_is_over(Player<char>* player) override;
};
 
class TicTacToe4x4_Player : public Player<char> {
public:
    TicTacToe4x4_Player(string name, char symbol, PlayerType type)
        : Player<char>(name, symbol, type) {}
};
 
class TicTacToe4x4_UI : public UI<char> {
public:
    TicTacToe4x4_UI() : UI<char>("4x4 TicTacToe", 3) {}
 
    Move<char>* get_move(Player<char>* p) override {
        int x, y;
 
        // Computer move
        if (p->get_type() == PlayerType::COMPUTER) {
            srand(time(0));
            auto board_matrix = p->get_board_ptr()->get_board_matrix();
 
            // find an empty cell
            do {
                x = rand() % 4;
                y = rand() % 4;
            } while (board_matrix[x][y] != ' ');
 
            cout << "\nComputer played at (" << x << "," << y << ")\n";
            return new Move<char>(x, y, p->get_symbol());
        }
 
        // Human move
        while (true) {
            cout << "\n" << p->get_name() << " enter row and column [0-3]: ";
            cin >> x >> y;
 
            if (x < 0 || x > 3 || y < 0 || y > 3) {
                cout << "Invalid cell. Please enter values between 0-3.\n";
                continue;
            }
 
            auto board_matrix = p->get_board_ptr()->get_board_matrix();
            if (board_matrix[x][y] != ' ') {
                cout << "Box already occupied. Choose another Box.\n";
                continue;
            }
 
            return new Move<char>(x, y, p->get_symbol());
        }
    }
 
    Player<char>* create_player(string& name, char symbol, PlayerType type) override {
        return new TicTacToe4x4_Player(name, symbol, type);
    }
};
 
// Implementation
TicTacToe4x4_Board::TicTacToe4x4_Board() : Board(4, 4) {
    // Initialize empty board
    for (auto& row : board) {
        for (auto& cell : row) {
            cell = ' ';
        }
    }
    n_moves = 0;
}
 
bool TicTacToe4x4_Board::update_board(Move<char>* move) {
    int x = move->get_x();
    int y = move->get_y();
    char symbol = move->get_symbol();
 
    // Check if move is valid
    if (x < 0 || x >= rows || y < 0 || y >= columns) {
        return false;
    }
 
    if (board[x][y] != ' ') {
        return false;
    }
 
    board[x][y] = symbol;
    n_moves++;
    return true;
}
 
bool TicTacToe4x4_Board::is_win(Player<char>* player) {
    char symbol = player->get_symbol();
 
    // Check rows
    for (int i = 0; i < 4; i++) {
        if (board[i][0] == symbol && board[i][1] == symbol &&
            board[i][2] == symbol && board[i][3] == symbol) {
            return true;
        }
    }
 
    // Check columns
    for (int j = 0; j < 4; j++) {
        if (board[0][j] == symbol && board[1][j] == symbol &&
            board[2][j] == symbol && board[3][j] == symbol) {
            return true;
        }
    }
 
    // Check diagonals
    if (board[0][0] == symbol && board[1][1] == symbol &&
        board[2][2] == symbol && board[3][3] == symbol) {
        return true;
    }
    if (board[0][3] == symbol && board[1][2] == symbol &&
        board[2][1] == symbol && board[3][0] == symbol) {
        return true;
    }
 
    return false;
}
 
bool TicTacToe4x4_Board::is_draw(Player<char>* player) {
    // Check if board is full and no win
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < columns; j++) {
            if (board[i][j] == ' ') {
                return false;
            }
        }
    }
    return !is_win(player);
}
 
bool TicTacToe4x4_Board::is_lose(Player<char>* player) {
    return false;
}
 
bool TicTacToe4x4_Board::game_is_over(Player<char>* player) {
    return is_win(player) || is_draw(player);
}
 
#endif // TICTACTOE4X4_H