add command

chess_uci/src/lib.rs

@@ -153,8 +153,8 @@ impl<Fi: Read, Fo: Write> UciEngine<Fi, Fo> {
     ///
     /// uci.make_move(ChessMove::from_str("e2e4").expect("error converting e2e4"));
     /// ```
-    pub fn make_move(&mut self, chess_move: ChessMove) -> bool {
+    pub fn make_move(&mut self, chess_move: &ChessMove) -> bool {
-        if self.game.make_move(chess_move) {
+        if self.game.make_move(*chess_move) {
             self.push(GuiCommand::Position {
                 position: Some(self.initial),
                 moves: self.game.actions().to_vec(),
@@ -181,7 +181,7 @@ impl<Fi: Read, Fo: Write> UciEngine<Fi, Fo> {
         self.new_game();
         for action in actions {
             if let Action::MakeMove(chessmove) = action {
-                self.make_move(chessmove);
+                self.make_move(&chessmove);
             }
         }
 
@@ -224,23 +224,29 @@ impl<Fi: Read, Fo: Write> UciEngine<Fi, Fo> {
     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(command) => self.exec_command(&command),
-            Ok(EngineCommand::UciOk) => self.uciok(),
-            Ok(EngineCommand::Opt { options: _ }) => {}
-            Ok(EngineCommand::Info { infos: _ })
-            | Ok(EngineCommand::BestMove {
-                best_move: _,
-                ponder: _,
-            })
-            | Ok(EngineCommand::ReadyOk) => {}
-            Ok(EngineCommand::Registration) | Ok(EngineCommand::CopyProtection) => {
-                unimplemented!("command not implemented")
-            }
             Err(_) => warn!("Not a command"),
         };
         uci_command
     }
 
+    pub fn exec_command(&mut self, command: &EngineCommand) {
+        match command {
+            EngineCommand::Id { id } => self.update(&id),
+            EngineCommand::UciOk => self.uciok(),
+            EngineCommand::Opt { options: _ } => {}
+            EngineCommand::Info { infos: _ }
+                | EngineCommand::BestMove {
+                    best_move: _,
+                    ponder: _,
+                }
+                | EngineCommand::ReadyOk => {}
+            EngineCommand::Registration | EngineCommand::CopyProtection => {
+                unimplemented!("command not implemented")
+            }
+        }
+    }
+
     /// 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 {
@@ -327,11 +333,11 @@ impl<Fi: Read, Fo: Write> UciEngine<Fi, Fo> {
         self.uciok
     }
 
-    pub fn human_play(&mut self, chess_move: ChessMove) -> Result<ChessMove, &'static str> {
+    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)
+                    Ok(*chess_move)
                 } else {
                     Err("Invalid move for human player")
                 }

chess_uci/src/uci_command.rs

@@ -4,7 +4,7 @@ use std::{str::FromStr, time::Duration};
 
 use chess::{Action, Board, ChessMove};
 
-#[derive(Clone, Default)]
+#[derive(Clone, Default, Debug)]
 pub struct Id {
     name: Option<String>,
     author: Option<String>,
@@ -63,7 +63,7 @@ impl fmt::Display for Opt {
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub enum EngineCommand {
     Id {
         id: Id,

chess_uci_demo/src/main.rs

@@ -58,7 +58,7 @@ pub fn main() {
     uci.new_game();
     uci.push_raw("d\n");
 
-    uci.human_play(ChessMove::from_str("e2e4").expect("error converting e2e4"))
+    uci.human_play(&ChessMove::from_str("e2e4").expect("error converting e2e4"))
         .expect("can not make human move");
 
     uci.push_raw("d\n");
@@ -68,7 +68,7 @@ pub fn main() {
     loop {
         match uci.pull() {
             Some(EngineCommand::BestMove { best_move, .. }) => {
-                uci.make_move(best_move);
+                uci.make_move(&best_move);
                 break;
             }
             Some(EngineCommand::Info { .. }) => continue,