Pyramic_XO.h

Go to the documentation of this file.

#ifndef PYRAMIC_XO_H
#define PYRAMIC_XO_H
 
#include "BoardGame_Classes.h"
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
 
// Pyramid Tic Tac Toe Board
class Pyramic_XO_Board : public Board<char> {
private:
    bool is_valid_position(int x, int y) {
        if (x < 0 || x >= 3 || y < 0 || y >= 5) return false;
        int start = (5 - (2 * x + 1)) / 2;
        int end = start + (2 * x + 1);
        return (y >= start && y < end);
    }
 
public:
    Pyramic_XO_Board() : Board(3, 5) {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 5; j++) {
                if (is_valid_position(i, j)) {
                    board[i][j] = '.';
                }
                else {
                    board[i][j] = '#'; // Invalid position
                }
            }
        }
    }
 
    bool update_board(Move<char>* move) override {
        int x = move->get_x();
        int y = move->get_y();
        char symbol = move->get_symbol();
 
        if (!is_valid_position(x, y)) {
            cout << "Invalid position! Not in pyramid shape.\n";
            return false;
        }
 
        if (board[x][y] != '.') {
            cout << "Cell already occupied!\n";
            return false;
        }
 
        board[x][y] = symbol;
        n_moves++;
        return true;
    }
 
    bool is_win(Player<char>* player) override {
        char symbol = player->get_symbol();
 
        // Check center column
        if (board[0][2] == symbol && board[1][2] == symbol && board[2][2] == symbol)
            return true;
 
        // Check rows
        for (int i = 0; i < 3; i++) {
            int start = (5 - (2 * i + 1)) / 2;
            int end = start + (2 * i + 1);
            for (int j = start; j <= end - 3; j++) {
                if (board[i][j] == symbol && board[i][j + 1] == symbol && board[i][j + 2] == symbol)
                    return true;
            }
        }
 
        // Check diagonals
        if (board[0][2] == symbol && board[1][1] == symbol && board[2][0] == symbol)
            return true;
        if (board[0][2] == symbol && board[1][3] == symbol && board[2][4] == symbol)
            return true;
 
        return false;
    }
 
    bool is_lose(Player<char>* player) override {
        return false;
    }
 
    bool is_draw(Player<char>* player) override {
        // Count valid cells (9 in pyramid)
        int valid_cells = 0;
        int filled_cells = 0;
 
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 5; j++) {
                if (board[i][j] != '#') {
                    valid_cells++;
                    if (board[i][j] != '.') {
                        filled_cells++;
                    }
                }
            }
        }
 
        return (filled_cells == valid_cells && !is_win(player));
    }
 
    bool game_is_over(Player<char>* player) override {
        return is_win(player) || is_draw(player);
    }
};
 
// Pyramid Player
class Pyramic_XO_Player : public Player<char> {
public:
    Pyramic_XO_Player(string name, char symbol) : Player(name, symbol, PlayerType::HUMAN) {}
};
 
// Pyramid Random Player
class Pyramic_XO_RandomPlayer : public Player<char> {
public:
    Pyramic_XO_RandomPlayer(char symbol) : Player("Random Computer", symbol, PlayerType::COMPUTER) {
        srand(time(0));
    }
};
 
// Pyramid UI
class Pyramic_XO_UI : public UI<char> {
public:
    Pyramic_XO_UI() : UI("Welcome to Pyramid 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 0-2, column 0-4 in pyramid shape): ";
            cin >> x >> y;
            return new Move<char>(x, y, player->get_symbol());
        }
        else {
            int x, y;
            do {
                x = rand() % 3;
                y = rand() % 5;
            } while (!is_valid_pyramid_position(x, y));
 
            cout << player->get_name() << " chooses position (" << x << ", " << y << ")\n";
            return new Move<char>(x, y, player->get_symbol());
        }
    }
 
private:
    bool is_valid_pyramid_position(int x, int y) {
        int start = (5 - (2 * x + 1)) / 2;
        int end = start + (2 * x + 1);
        return (x >= 0 && x < 3 && y >= start && y < end);
    }
};
 
#endif // PYRAMIC_XO_H