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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! UI implementations for the post-game menu

use std::io::{stdout, Write};
use crossterm::{
    style::Print,
    cursor::{self, MoveToColumn, MoveToRow, MoveToNextLine},
    terminal::{Clear, ClearType},
    event::{self, Event, KeyEvent, KeyCode, KeyModifiers},
    QueueableCommand,
    ExecutableCommand
};

use crate::{game_outcome::GameOutcome, game_settings::GameMode};

impl super::UI{
    
    /// The post-game menu 
    /// 
    /// Allows user to view score, the results of the previous game, 
    /// and choose whether to play another game.
    /// 
    /// Returns `true` if user chooses to play another game, `false` otherwise
    pub fn play_again_menu(&self) -> crossterm::Result<bool>
    {
        self.draw_play_again_menu()?;

        //loop until a valid event is read
        let play_again = loop {
            match event::read()?{
                Event::Key(key_event) => {
                    match key_event {
                        KeyEvent{code:KeyCode::Char('y'), ..} => {
                            break true;
                        },
                        KeyEvent{code:KeyCode::Enter, ..} => {
                            break true;
                        }
                        KeyEvent{code:KeyCode::Char('n'), ..} => {
                            break false;
                        },
                        KeyEvent{code:KeyCode::Char('q'), ..} => {
                            break false;
                        },
                        KeyEvent{code:KeyCode::Char('c'), modifiers: KeyModifiers::CONTROL, ..} => {
                            break false;
                        },
                        _ => {
                            //ignore other key events
                        }
                    }
                },
                //redraw screen upon resize
                Event::Resize(_, _) => {
                    self.draw_play_again_menu()?;
                },
                _ => {
                    //ignore other type of event
                }
            }
        };

        stdout().execute(cursor::Show)?;
        Ok(play_again)
    }

    /// Draws the play again menu
    fn draw_play_again_menu(&self) -> crossterm::Result<()>
    {
        stdout()
            .queue(Clear(ClearType::All))?
            .queue(cursor::Hide)?
            .queue(MoveToColumn(0))?
            .queue(MoveToRow(0))?
            .flush()?;
        
        let game_outcome_text = match self.game_board.game_outcome(){
            GameOutcome::PlayerX(win_position) => {
                self.draw_game(Some(win_position))?;
                match self.game_mode {
                    GameMode::Classic => "Player X wins!",
                    GameMode::Reverse => "Player O wins!"
                }
            },
            GameOutcome::PlayerO(win_position) => {
                self.draw_game(Some(win_position))?;
                match self.game_mode {
                    GameMode::Classic => "Player O wins!",
                    GameMode::Reverse => "Player X wins!"
                }
            },
            GameOutcome::Draw => {
                self.draw_game(None)?;
                "Draw!"
            },
            GameOutcome::Incomplete => {
                self.draw_game(None)?;
                "Game finished early!"
            }
        };
        let player_x_score = self.player_x_score();
        let player_o_score = self.player_o_score();
        let number_of_draws = self.number_of_draws();
        let number_of_games = self.number_of_games();
        stdout()
            .queue(MoveToRow(5))?
            .queue(Print(game_outcome_text))?
            
            .queue(MoveToNextLine(1))?
            .queue(MoveToColumn(0))?
            .queue(Print(format!("X score:     {}\t({:.2}%)", player_x_score, 
                    ((player_x_score as f64)/(number_of_games as f64))*100.0)))?
            
            .queue(MoveToNextLine(1))?
            .queue(MoveToColumn(0))?
            .queue(Print(format!("O score:     {}\t({:.2}%)", player_o_score, 
                ((player_o_score as f64)/(number_of_games as f64))*100.0)))?

            .queue(MoveToNextLine(1))?
            .queue(MoveToColumn(0))?
            .queue(Print(format!("Draws:       {}\t({:.2}%)", number_of_draws,
                ((number_of_draws as f64)/(number_of_games as f64))*100.0)))?

            .queue(MoveToNextLine(1))?
            .queue(MoveToColumn(0))?
            .queue(Print(format!("Total games: {}", number_of_games)))?
            
            .queue(MoveToNextLine(2))?
            .queue(MoveToColumn(0))?
            .queue(Print("Play again? Press y or Enter for yes; Press q or n for no "))?
            .flush()?;
        Ok(())
    }
}