SUS.h

Go to the documentation of this file.

#ifndef SUS_H
#define SUS_H
 
#include "BoardGame_Classes.h"
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
 
// SUS Board
class SUS_Board : public Board<char> {
private:
    int count_SUS_sequences(char symbol) {
        int count = 0;
        string target = "SUS";
 
        // Check rows
        for (int i = 0; i < 3; i++) {
            string row;
            for (int j = 0; j < 3; j++) row += board[i][j];
            if (row == target) count++;
        }
 
        // Check columns
        for (int j = 0; j < 3; j++) {
            string col;
            for (int i = 0; i < 3; i++) col += board[i][j];
            if (col == target) count++;
        }
 
        // Check diagonals
        string diag1 = string(1, board[0][0]) + string(1, board[1][1]) + string(1, board[2][2]);
        string diag2 = string(1, board[0][2]) + string(1, board[1][1]) + string(1, board[2][0]);
        if (diag1 == target) count++;
        if (diag2 == target) count++;
 
        return count;
    }
 
public:
    SUS_Board() : Board(3, 3) {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; 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 >= 3 || y < 0 || y >= 3) {
            cout << "Invalid position! Use 0-2.\n";
            return false;
        }
 
        if (board[x][y] != ' ') {
            cout << "Cell already occupied!\n";
            return false;
        }
 
        if (symbol != 'S' && symbol != 'U') {
            cout << "Invalid symbol! Use only S or U.\n";
            return false;
        }
 
        board[x][y] = symbol;
        n_moves++;
        return true;
    }
 
    bool is_win(Player<char>* player) override {
        // Game doesn't have immediate win condition
        return false;
    }
 
    bool is_lose(Player<char>* player) override {
        return false;
    }
 
    bool is_draw(Player<char>* player) override {
        return (n_moves == 9);
    }
 
    bool game_is_over(Player<char>* player) override {
        return is_draw(player);
    }
 
    pair<int, int> get_scores() {
        int x_score = count_SUS_sequences('X');
        int o_score = count_SUS_sequences('O');
        return make_pair(x_score, o_score);
    }
};
 
// SUS Player
class SUS_Player : public Player<char> {
public:
    SUS_Player(string name, char symbol) : Player(name, symbol, PlayerType::HUMAN) {}
};
 
// SUS Random Player
class SUS_Random_Player : public Player<char> {
public:
    SUS_Random_Player(char symbol) : Player("Random Computer", symbol, PlayerType::COMPUTER) {
        srand(time(0));
    }
};
 
// SUS UI
class SUS_UI : public UI<char> {
public:
    SUS_UI() : UI("Welcome to SUS Game!", 3) {}
 
    Move<char>* get_move(Player<char>* player) override {
        if (player->get_type() == PlayerType::HUMAN) {
            int x, y;
            char symbol;
            cout << player->get_name() << " (" << player->get_symbol()
                << "), enter your move (row, column, and S/U): ";
            cin >> x >> y >> symbol;
            symbol = toupper(symbol);
            return new Move<char>(x, y, symbol);
        }
        else {
            int x = rand() % 3;
            int y = rand() % 3;
            char symbol = (rand() % 2 == 0) ? 'S' : 'U';
            cout << player->get_name() << " chooses position (" << x << ", " << y
                << ") with symbol " << symbol << "\n";
            return new Move<char>(x, y, symbol);
        }
    }
};
 
#endif // SUS_H