ObstaclesTicTacToe.h

Go to the documentation of this file.

#ifndef OBSTACLESTICTACTOE_H
#define OBSTACLESTICTACTOE_H
 
#include "BoardGame_Classes.h"
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
using namespace std;
 
// Obstacles Tic Tac Toe Board
class ObstaclesTicTacToeBoard : public Board<char> {
private:
    vector<pair<int, int>> obstacles;
    int moves_since_last_obstacle = 0;
 
    void add_random_obstacle() {
        int x, y;
        do {
            x = rand() % 6;
            y = rand() % 6;
        } while (board[x][y] != ' ' || is_obstacle(x, y));
 
        obstacles.push_back({ x, y });
        board[x][y] = '#'; // Obstacle symbol
    }
 
    bool is_obstacle(int x, int y) {
        for (auto& obs : obstacles) {
            if (obs.first == x && obs.second == y)
                return true;
        }
        return false;
    }
 
public:
    ObstaclesTicTacToeBoard() : Board(6, 6) {
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 6; j++) {
                board[i][j] = ' ';
            }
        }
        srand(time(0));
    }
 
    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 >= 6 || y < 0 || y >= 6) {
            cout << "Invalid position! Use 0-5.\n";
            return false;
        }
 
        if (is_obstacle(x, y)) {
            cout << "Cell is an obstacle!\n";
            return false;
        }
 
        if (board[x][y] != ' ') {
            cout << "Cell already occupied!\n";
            return false;
        }
 
        board[x][y] = symbol;
        n_moves++;
        moves_since_last_obstacle++;
 
        // Add obstacles every 2 moves
        if (moves_since_last_obstacle >= 2) {
            for (int i = 0; i < 2; i++) {
                add_random_obstacle();
            }
            moves_since_last_obstacle = 0;
            cout << "Two new obstacles added!\n";
        }
 
        return true;
    }
 
    bool is_win(Player<char>* player) override {
        char symbol = player->get_symbol();
 
        // Check 4 in a row
        // Horizontal
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 3; j++) {
                if (board[i][j] == symbol && board[i][j + 1] == symbol &&
                    board[i][j + 2] == symbol && board[i][j + 3] == symbol)
                    return true;
            }
        }
 
        // Vertical
        for (int j = 0; j < 6; j++) {
            for (int i = 0; i < 3; i++) {
                if (board[i][j] == symbol && board[i + 1][j] == symbol &&
                    board[i + 2][j] == symbol && board[i + 3][j] == symbol)
                    return true;
            }
        }
 
        // Diagonals
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (board[i][j] == symbol && board[i + 1][j + 1] == symbol &&
                    board[i + 2][j + 2] == symbol && board[i + 3][j + 3] == symbol)
                    return true;
            }
        }
 
        for (int i = 0; i < 3; i++) {
            for (int j = 3; j < 6; j++) {
                if (board[i][j] == symbol && board[i + 1][j - 1] == symbol &&
                    board[i + 2][j - 2] == symbol && board[i + 3][j - 3] == symbol)
                    return true;
            }
        }
 
        return false;
    }
 
    bool is_lose(Player<char>* player) override {
        return false;
    }
 
    bool is_draw(Player<char>* player) override {
        // Check if board is full (no empty cells except obstacles)
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 6; j++) {
                if (board[i][j] == ' ') {
                    return false;
                }
            }
        }
        return !is_win(player);
    }
 
    bool game_is_over(Player<char>* player) override {
        return is_win(player) || is_draw(player);
    }
};
 
// Obstacles Player
class ObstaclesTicTacToe_Player : public Player<char> {
public:
    ObstaclesTicTacToe_Player(string name, char symbol) : Player(name, symbol, PlayerType::HUMAN) {}
};
 
// Obstacles Random Player
class ObstaclesTicTacToe_RandomPlayer : public Player<char> {
public:
    ObstaclesTicTacToe_RandomPlayer(char symbol) : Player("Random Computer", symbol, PlayerType::COMPUTER) {
        srand(time(0));
    }
};
 
// Obstacles UI
class ObstaclesTicTacToe_UI : public UI<char> {
public:
    ObstaclesTicTacToe_UI() : UI("Welcome to Obstacles Tic-Tac-Toe! (4 in a row, obstacles appear)", 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-5): ";
            cin >> x >> y;
            return new Move<char>(x, y, player->get_symbol());
        }
        else {
            int x = rand() % 6;
            int y = rand() % 6;
            cout << player->get_name() << " chooses position (" << x << ", " << y << ")\n";
            return new Move<char>(x, y, player->get_symbol());
        }
    }
};
 
#endif // OBSTACLESTICTACTOE_H