tactic 1.1.0

A terminal tic-tac-toe game with AI opponent
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92


pub mod gameboard;
pub mod game_outcome;
pub mod ui;
pub mod ai;

/// The PlayerType enum
pub mod player_type {

    use crate::ai::AiPlayer;

    /// Represents the type of a player (either human or AI)
    #[derive(Default, Debug, PartialEq)]
    pub enum PlayerType {
        #[default]
        Human,
        AI(AiPlayer)
    }
}

/// The ActivePlayer enum
pub mod active_player{
    use crate::gameboard::BoardSpace;


    /// Represents which player (X or O) is currently active
    #[derive(PartialEq, Eq, Clone)]
    pub enum ActivePlayer {
        PlayerX,
        PlayerO
    }
    impl ActivePlayer {
        /// Switches this PlayerTurn to the opposite player
        pub fn switch(&mut self)
        {
            *self = self.opposite();
        }

        /// Returns the opposite `PlayerTurn`
        pub fn opposite(&self) -> Self
        {
            match self {
                ActivePlayer::PlayerO => ActivePlayer::PlayerX,
                ActivePlayer::PlayerX => ActivePlayer::PlayerO
            }
        }

        /// Returns the character representing this ActivePlayer
        pub fn get_char(&self) -> char
        {
            match self {
                ActivePlayer::PlayerO => 'O',
                ActivePlayer::PlayerX => 'X'
            }
        }

        /// Returns the [BoardSpace] variant associated
        /// with this `ActivePlayer` variant
        pub fn get_board_space(&self) -> BoardSpace
        {
            match self {
                ActivePlayer::PlayerX => BoardSpace::X,
                ActivePlayer::PlayerO => BoardSpace::O
            }
        }
    }
}


/// Enums to represent different game settings
mod game_settings{
    /// Determines the game mode to be played
    #[derive(Default)]
    pub enum GameMode{
        #[default]
        Classic,
        Reverse
    }
    /// Determines how many games will be played before auto-exiting
    #[derive(Default, PartialEq, Eq)]
    pub enum GameAutoquitMode {
        /// No limit
        #[default]
        Unlimited,
        /// Limit the total number of games
        GameNumberLimit,
        /// Limit the number of games that are not draws
        NonDrawNumberLimit,
        /// Limit the score of either player
        ScoreNumberLimit
    }
}