chess_uci/chess_uci/src/lib.rs

#![allow(dead_code)]

/// Manage UCI messages and link into chess component
pub mod uci_command;

use log::{info, warn};
use std::io::*;
use std::time::Duration;
use std::result::Result;
use crate::uci_command::*;

use chess::{Game, Board, ChessMove};

const DEFAULT_TIME: (Option<Duration>, Option<Duration>) = (Some(Duration::from_secs(120 * 60)), None);

/// Structure used to manage a chess game with a uci engine.
///
/// It needs a in / out communication channel to read / push line by line uci commands
///c
/// ```rust
/// use chess_uci::UciEngine;
/// use std::process::{Command, Stdio};
/// use std::io::BufReader;
///
/// let process = match Command::new("stockfish")
///     .stdin(Stdio::piped())
///     .stdout(Stdio::piped())
///    .spawn() {
///        Err(why) => panic!("couldn't spawn stockfish: {}", why),
///        Ok(process) => process,
///    };
/// let (sf_in,sf_out) = (process.stdin.expect("Program stdin"), process.stdout.expect("Program stdout"));
///
/// let mut uci = UciEngine::new(BufReader::new(sf_out), sf_in);
/// // .. uci.init(); ..
/// uci.push_raw("quit\n");
/// ```
pub struct UciEngine<Fi: Read, Fo: Write> {
    source: Option<BufReader<Fi>>,
    destination: Option<Fo>,
    uciok: bool,
    id: Id,
    initial: Board,
    game: Game,
    /// white (total, incr), black (total, incr)
    time: [(Option<Duration>, Option<Duration>); 2],
    /// white, black
    player: [Player; 2],
}

pub enum UciOption {
    Ponder{value: bool},
    UCIElo{value: Option<u32>},
}

#[derive(Clone, Copy)]
pub enum Player{Human{elo: Option<u32>}, Machine{elo: Option<u32>}}
pub enum GameOption {
    WhiteTotalTime{value: Option<Duration>},
    BlackTotalTime{value: Option<Duration>},
    WhiteIncrement{value: Option<Duration>},
    BlackIncrement{value: Option<Duration>},
    WhitePlayer{value: Player},
    BlackPlayer{value: Player},
}

impl<Fi: Read, Fo:  Write> UciEngine<Fi, Fo> {

    /// Create new game manager
    ///
    /// Requires line by line input and output streams to communicate with uci engine
    pub fn new(source: Option<Fi>, destination: Option<Fo>) -> UciEngine<Fi, Fo> {
        UciEngine::<Fi, Fo>{
            source: if let Some(source) = source {Some(BufReader::new(source))} else {None},
            destination,
            id: Id::new(),
            uciok: false,
            initial: Board::default(),
            game: Game::new(),
            time: [DEFAULT_TIME; 2],
            player: [Player::Human{elo: None}; 2],
        }
    }

    pub fn game_option(&mut self, option: GameOption) -> GameOption {
        let old_value: GameOption;
        match option {
            GameOption::WhiteTotalTime{value} => {old_value = GameOption::WhiteTotalTime { value: self.time[Color::White.to_index()].0 };
                                                  self.time[Color::White.to_index()].0 = value},
            GameOption::BlackTotalTime{value} => {old_value = GameOption::BlackTotalTime { value: self.time[Color::Black.to_index()].0 };
                                                  self.time[Color::Black.to_index()].0 = value},
            GameOption::WhiteIncrement{value} => {old_value = GameOption::WhiteIncrement { value: self.time[Color::White.to_index()].1 };
                                                  self.time[Color::White.to_index()].1 = value},
            GameOption::BlackIncrement{value} => {old_value = GameOption::BlackIncrement { value: self.time[Color::Black.to_index()].1 };
                                                  self.time[Color::Black.to_index()].1 = value},
            GameOption::WhitePlayer{value} => {old_value = GameOption::WhitePlayer { value: self.player[Color::White.to_index()] };
                                               self.player[Color::White.to_index()] = value},
            GameOption::BlackPlayer{value} => {old_value = GameOption::WhitePlayer { value: self.player[Color::Black.to_index()] };
                                               self.player[Color::Black.to_index()] = value},
        }

        old_value
    }

    /// Launch uci engine initialisation
    ///
    /// Retrieve data from uci engine (until uciok command from engine)
    pub fn init(&mut self){
        self.push(GuiCommand::Uci);

        // Consume commands until uciok messages
        if self.source.is_some() {
            while !self.uciok {
                self.pull();
            }
        }
    }

    /// Initialize a new game
    ///
    /// Set a new board internally and tell the engine
    pub fn new_game(&mut self) {
        self.initial = Board::default();
        self.game = Game::new_with_board(self.initial);
        self.push(GuiCommand::UciNewGame);
    }

    /// Play a move
    ///
    /// Update internal game reference and tell the uci engine
    ///
    /// ```rust
    /// use chess::ChessMove;
    /// use std::str::FromStr;
    /// use chess_uci::*;
    /// use std::io;
    ///
    /// let mut uci = UciEngine::new(io::empty(), io::sink());
    ///
    /// uci.make_move(ChessMove::from_str("e2e4").expect("error converting e2e4"));
    /// ```
    pub fn make_move(&mut self, chess_move: ChessMove) -> bool {
        if  self.game.make_move(chess_move) {
            self.push(GuiCommand::Position { position: Some(self.initial), moves: self.game.actions().to_vec() });
            true
        } else {
            false
        }

    }


    fn terminate(&mut self, reason: &str) {
        self.uciok = false;
        info!("UCI termination: {}", reason);
    }

    /// Provides the name of the uci engine
    pub fn name(&self) -> Option<String> {
        self.id.name()
    }

    /// Provides the author sof the uci engine
    pub fn author(&self) -> Option<String> {
        self.id.author()
    }

    fn update(&mut self, id: &Id){
        if self.is_uciok() {warn!("Engine info should not be updated now (uciok)");}
        self.id.update(id);
    }

    fn update_from_str(&mut self, name: Option<&str>, author: Option<&str>){
        if self.is_uciok() {warn!("Engine info should not be updated now (uciok)");}
        self.id.update_from_str(name, author);
    }

    /// Execute a uci command
    ///
    /// if `EngineCommand::Id`: update name or authorship of the engine
    /// if `EngineCommand::UciOk`: end engine initialization phase
    pub fn exec(&mut self, command: &str) -> Result<EngineCommand, &'static str> {
        let uci_command = parse (&mut command.to_string());
        match  uci_command.clone() {
            Ok(EngineCommand::Id{id}) => self.update(&id),
            Ok(EngineCommand::UciOk) => self.uciok(),
            Ok(EngineCommand::Opt { options: _ }) => {},
            Ok(_) => {unimplemented!("command not implemented")},
            Err(_) => warn!("Not a command"),
        };
        uci_command
    }

    /// Retrieve a line from the uci engine input stream and parse it
    pub fn pull(&mut self) -> Option<EngineCommand> {

        if let Some(source) = &mut self.source {
            let mut command = String::new();
            match source.read_line(&mut command) {
                Ok(0) => {self.terminate("Chess engine closed connection."); None},
                Ok(_) => {
                    info!("← {}", command);
                    self.exec(&command).ok()
                },
                Err(reason) => {warn!("Unable to read from engine: {reason}"); None},
            }
        } else {
            info!("❌ No connected uci engine");
            None
        }
    }

    /// Read a line from the uci engine input stream (do not parse)
    pub fn pull_raw(&mut self) -> Option<String> {
        if let Some(source) = &mut self.source {
            let mut data = String::new();
            match source.read_line(&mut data) {
                Ok(0) => {self.terminate("Chess engine closed connection."); None},
                Ok(_) => {info!("↜ {}", data); Some(data.clone())},
                Err(reason) => {warn!("Unable to read from engine: {reason}"); None},
            }
        } else {
            info!("❌ No connected uci engine");
            None
        }
    }

    /// Push a Uci Gui command to the engine
    fn push(&mut self, command: GuiCommand) {
        if let Some(destination) = &mut self.destination {
            let command_str = command.to_string();
            match destination.write(&command_str.as_bytes()){
                Ok(n) if n == command_str.len() => info!("→ gui: {command_str}"),
                Ok(n) => warn!("⚠ gui: {command_str} truncated at {n}"),
                Err(reason) => warn!("Unable to send command {command_str}: {reason}"),
            }
        } else {
            info!("❌ No connected uci engine");
        }
    }

    /// Push string (not a game manager integrated command) to the Uci engine output stream
    pub fn push_raw(&mut self, data: &str){
        if let Some(destination) = &mut self.destination {
            match destination.write(data.as_bytes()) {
                Ok(n) if n == data.len() => info!("↝ raw: {data}"),
                Ok(n) => warn!("⚠ raw: {data} truncated at {n}"),
                Err(reason) => warn!("Unable to send raw {data}: {reason}"),
            }
        } else {
            info!("❌ No connected uci engine");
        }
    }
}

impl<Fi: Read, Fo:  Write> UciEngine<Fi, Fo> {
    fn uciok(&mut self){
        self.uciok = true;
    }

    /// Tell whether the uci engine has initialized
    pub fn is_uciok(&self) -> bool {
        self.uciok
    }

    pub fn human_play(&mut self, chess_move: ChessMove) -> Result<ChessMove, &'static str> {
        match self.player[self.side_to_move().to_index()] {
            Player::Human{..} => {
                if self.make_move(chess_move) {
                    Ok(chess_move)
                } else {
                    Err("Invalid move for human player")
                }
            },
            Player::Machine {..} => Err("Not a human to play for current color.")
        }
    }

    pub fn go(&mut self) -> Result<(), &'static str> {
        match self.player[self.side_to_move().to_index()] {
            Player::Human{..} => Err("Not a machine to play for current color."),
            Player::Machine {elo} => 
            {
                if self.is_uciok() {
                    if let Some(elo) = elo {
                        self.push(GuiCommand::SetOption {option: Opt::UCILimitStrength{value: true}});
                        self.push(GuiCommand::SetOption {option: Opt::UCIElo{value: elo}});
                    }
                    let (wtime, wincr) = self.time[Color::White.to_index()];
                    let (btime, bincr) = self.time[Color::Black.to_index()];
                    self.push(GuiCommand::Go{wtime, wincr, btime, bincr});

                    Ok(())
                } else {
                    Err("UCI engine not ready")                    
                }
            }
        }
    }
}

use chess::{Square, Piece, Color};
impl<Fi: Read, Fo:  Write> UciEngine<Fi, Fo> {
    pub fn piece_on(&self, square: Square) -> Option<Piece> {
        self.game.current_position().piece_on(square)
    }
    pub fn color_on(&self, square: Square) -> Option<Color> {
        self.game.current_position().color_on(square)
    }

    pub fn current_position(&self) -> Board {
        self.game.current_position()
    }

    pub fn side_to_move(&self) -> Color {
        self.game.side_to_move()
    }
}
//  LocalWords:  uci