rttt/engine/engine.rs

use std::io;

use crate::game::{Board, Cell};
use crate::player::{Player, PlayerConsole};

pub struct Engine {
    players: Vec<Box<dyn Player>>,
    turn: usize,
    board: Board,
    x: usize,
}

impl Engine {
    pub fn new() -> Engine {
        // TODO: accept players as args
        let p1 = PlayerConsole::new("Gopher");
        let p2 = PlayerConsole::new("Rustacean");

        let board = Board::new();

        Engine {
            players: vec![Box::new(p1), Box::new(p2)],
            turn: 0,
            board: board,
            x: 0,
        }
    }

    pub fn run(&mut self) -> Result<(), Box<dyn std::error::Error>> {
        loop {
            // setup new game for players
            self.players[self.x].start_new_game(Cell::X)?;
            self.players[(self.x + 1) % 2].start_new_game(Cell::O)?;

            // reset board
            self.board.reset();
            self.turn = self.x;

            // run game
            self.run_single_game()?;

            // switch sides
            self.x = (self.x + 1) % 2;

            match request_input("Press Enter to continue or \"q\" to quit.")
                .as_str()
                .trim()
            {
                "q" => {
                    return Ok(());
                }
                _ => {
                    continue;
                }
            }
        }
    }

    fn run_single_game(&mut self) -> Result<(), Box<dyn std::error::Error>> {
        loop {
            cls();
            home();
            println!("{}", self.board);

            // request move from player, fail if there is error
            let m = self.players[self.turn].request_move(&self.board)?;

            if !self.board.is_valid_move(&m) {
                println!("invalid move");
                continue;
            }

            // apply move
            self.board.apply(m)?;

            // check if there is a winner
            if let Some(_winner) = self.board.has_winner() {
                cls();
                home();
                println!("{} wins!", self.players[self.turn].name());
                println!("{}", self.board);
                request_input("Press Enter to continue...");
                break;
            }

            if !self.board.valid_moves_available() {
                cls();
                home();
                println!("It's a draw!");
                println!("{}", self.board);
                request_input("press Enter to continue");
                break;
            }

            self.turn = (self.turn + 1) % 2
        }

        Ok(())
    }
}

fn cls() {
    print!("{}[2J", 27 as char);
}

fn home() {
    print!("{}[H", 27 as char)
}

fn request_input(prompt: &str) -> String {
    println!("{}", prompt);

    let mut s = String::new();
    match io::stdin().read_line(&mut s) {
        Ok(_) => {}
        Err(_) => {}
    }

    s
}