chore: update and fixes based on search changes

Now use `engine.run()` in main and let the engine handle the loop of processing commands and reacting to them.

bench: 1994757

src/bin/byte-knight/bench.rs

@@ -148,13 +148,13 @@ pub(crate) fn bench(depth: u8, epd_file: &Option<String>) {
     };
 
     let mut nodes = 0u64;
-    let mut search = Search::new(config);
+    let mut search = Search::new(&config);
 
     for bench in benchmark_strings {
         let fen: &str = bench.split(";").next().unwrap();
         let mut board = Board::from_fen(fen).unwrap();
 
-        let result = search.search(&mut board);
+        let result = search.search(&mut board, None);
         nodes += result.nodes;
     }
 

src/bin/byte-knight/engine.rs

@@ -1,74 +1,35 @@
-use std::{
-    io::{self, BufRead, Write},
-    str::FromStr,
-    sync::mpsc::{self, Receiver, Sender},
-};
-
-use chess::{board::Board, move_generation::MoveGenerator, moves::Move, pieces::SQUARE_NAME};
-use uci_parser::{UciCommand, UciInfo, UciMove, UciOption, UciResponse};
-
-use crate::{defs::About, search::SearchParameters};
-
-use super::search;
-
-fn square_index_to_uci_square(square: u8) -> uci_parser::Square {
-    uci_parser::Square::from_str(SQUARE_NAME[square as usize]).unwrap()
-}
+use std::io::{self, Write};
 
-fn move_to_uci_move(mv: &Move) -> UciMove {
-    let promotion = mv.promotion_piece().map(|p| p.as_char());
+use chess::board::Board;
+use uci_parser::{UciCommand, UciInfo, UciOption, UciResponse};
 
-    match promotion {
-        Some(promotion) => UciMove {
-            src: square_index_to_uci_square(mv.from()),
-            dst: square_index_to_uci_square(mv.to()),
-            promote: Some(uci_parser::Piece::from_str(&promotion.to_string()).unwrap()),
-        },
-        None => UciMove {
-            src: square_index_to_uci_square(mv.from()),
-            dst: square_index_to_uci_square(mv.to()),
-            promote: None,
-        },
-    }
-}
+use crate::{
+    defs::About, input_handler::InputHandler, search::SearchParameters, search_thread::SearchThread,
+};
 
 pub struct ByteKnight {
-    sender: Sender<UciCommand>,
-    receiver: Receiver<UciCommand>,
-    move_gen: MoveGenerator,
+    input_handler: InputHandler,
+    search_thread: SearchThread,
 }
 
 impl ByteKnight {
     pub fn new() -> ByteKnight {
-        let (sender, receiver) = mpsc::channel();
         ByteKnight {
-            sender,
-            receiver,
-            move_gen: MoveGenerator::new(),
+            input_handler: InputHandler::new(),
+            search_thread: SearchThread::new(),
         }
     }
 
-    pub fn run(self: &mut Self, stdin: io::Stdin) -> anyhow::Result<()> {
+    pub fn run(&mut self) -> anyhow::Result<()> {
         // spawn thread to handle UCI commands
-        let sender = self.sender.clone();
-        std::thread::spawn(move || {
-            let mut input = stdin.lock().lines();
-            loop {
-                if let Some(Ok(line)) = input.next() {
-                    let command = UciCommand::from_str(line.as_str());
-                    if let Ok(command) = command {
-                        sender.send(command).unwrap();
-                    }
-                }
-            }
-        });
         let stdout = io::stdout();
         let mut board = Board::default_board();
-        while let Ok(command) = self.receiver.recv() {
+        'engine_loop: while let Ok(command) = &self.input_handler.receiver().recv() {
             let mut stdout = stdout.lock();
             match command {
                 UciCommand::Quit => {
-                    !todo!("Implement a way to interupt the engine if we're searching");
+                    self.input_handler.stop();
+                    break 'engine_loop;
                 }
                 UciCommand::IsReady => {
                     writeln!(stdout, "{}", UciResponse::<String>::ReadyOk).unwrap();
@@ -108,49 +69,23 @@ impl ByteKnight {
                     }
                 }
                 UciCommand::Go(search_options) => {
-                    let search_params = SearchParameters::new(&search_options, &board);
-
-                    let board_info =
-                        UciInfo::default().string(format!("searching {}", board.to_fen()));
-                    writeln!(
-                        stdout,
-                        "{}",
-                        UciResponse::<String>::Info(Box::new(board_info))
-                    )
-                    .unwrap();
-
-                    let best_move = self.think(&mut board, &search_params);
+                    let info = UciInfo::default().string(format!("searching {}", board.to_fen()));
+                    writeln!(stdout, "{}", UciResponse::info(info)).unwrap();
 
-                    if let Some(bot_move) = best_move {
-                        writeln!(
-                            stdout,
-                            "{}",
-                            // TODO: Ponder
-                            UciResponse::BestMove {
-                                bestmove: Some(move_to_uci_move(&bot_move).to_string()),
-                                ponder: None
-                            }
-                        )
-                        .unwrap();
-                    } else {
-                        // TODO Handle the case when best_move is None.
-                    }
+                    // create the search parameters
+                    let search_params = SearchParameters::new(&search_options, &board);
+                    // send them and the current board to the search thread
+                    self.search_thread.start_search(&board, search_params);
+                }
+                UciCommand::Stop => {
+                    self.search_thread.stop_search();
                 }
                 _ => {}
             }
         }
 
         Ok(())
     }
-    pub(crate) fn think(
-        &mut self,
-        board: &mut Board,
-        search_params: &SearchParameters,
-    ) -> Option<Move> {
-        let mut search = search::Search::new(*search_params);
-        let result = search.search(board);
-        result.best_move
-    }
 }
 
 impl Default for ByteKnight {

src/bin/byte-knight/main.rs

@@ -16,21 +16,21 @@ mod bench;
 mod defs;
 mod engine;
 mod evaluation;
+mod input_handler;
 mod psqt;
 mod score;
 mod search;
+mod search_thread;
 mod tt_table;
+mod worker_thread;
 
 use defs::About;
 use engine::ByteKnight;
-use search::SearchParameters;
-use uci_parser::{UciCommand, UciInfo, UciMove, UciOption, UciResponse};
 
-use std::{process::exit, str::FromStr};
+use std::process::exit;
 
-use chess::{board::Board, moves::Move, pieces::SQUARE_NAME};
 use clap::{Parser, Subcommand};
-use std::io::{self, BufRead, Write};
+use std::io::{self, Write};
 
 #[derive(Parser)]
 #[command(
@@ -54,107 +54,14 @@ enum Command {
     },
 }
 
-fn square_index_to_uci_square(square: u8) -> uci_parser::Square {
-    uci_parser::Square::from_str(SQUARE_NAME[square as usize]).unwrap()
-}
-
-fn move_to_uci_move(mv: &Move) -> UciMove {
-    let promotion = mv.promotion_piece().map(|p| p.as_char());
-
-    match promotion {
-        Some(promotion) => UciMove {
-            src: square_index_to_uci_square(mv.from()),
-            dst: square_index_to_uci_square(mv.to()),
-            promote: Some(uci_parser::Piece::from_str(&promotion.to_string()).unwrap()),
-        },
-        None => UciMove {
-            src: square_index_to_uci_square(mv.from()),
-            dst: square_index_to_uci_square(mv.to()),
-            promote: None,
-        },
-    }
-}
-
 fn run_uci() {
-    let stdin: io::Stdin = io::stdin();
-    let stdout = io::stdout();
-    let mut stdout = stdout.lock();
-    let mut input = stdin.lock().lines();
-    let mut board = Board::default_board();
-
     let mut engine = ByteKnight::new();
-    writeln!(stdout, "{}", About::BANNER).unwrap();
-
-    loop {
-        if let Some(Ok(line)) = input.next() {
-            let command = UciCommand::from_str(line.as_str());
-            match command {
-                Ok(UciCommand::Uci) => {
-                    let id = UciResponse::Id {
-                        name: About::NAME,
-                        author: About::AUTHORS,
-                    };
-
-                    let options = vec![
-                        UciOption::spin("Hash", 16, 1, 1024),
-                        UciOption::spin("Threads", 1, 1, 1),
-                    ];
-                    // TODO: Actually implement the hash option
-                    for option in options {
-                        writeln!(stdout, "{}", UciResponse::Option(option)).unwrap();
-                    }
-                    writeln!(stdout, "{}", id).unwrap();
-                    writeln!(stdout, "{}", UciResponse::<String>::UciOk).unwrap();
-                }
-                Ok(UciCommand::Quit) => {
-                    exit(0);
-                }
-                Ok(UciCommand::UciNewGame) => {
-                    board = Board::default_board();
-                }
-                Ok(UciCommand::IsReady) => {
-                    writeln!(stdout, "{}", UciResponse::<String>::ReadyOk).unwrap();
-                }
-                Ok(UciCommand::Position { fen, moves }) => {
-                    match fen {
-                        None => {
-                            board = Board::default_board();
-                        }
-                        Some(fen) => {
-                            board = Board::from_fen(fen.as_str()).unwrap();
-                        }
-                    }
-
-                    for mv in moves {
-                        board.make_uci_move(&mv.to_string()).unwrap();
-                    }
-
-                    // TODO: String output of board
-                    // writeln!(stdout, "{}", Board::to_string(&board)).unwrap();
-                }
-                Ok(UciCommand::Go(search_options)) => {
-                    let info = UciInfo::default().string(format!("searching {}", board.to_fen()));
-                    writeln!(stdout, "{}", UciResponse::info(info)).unwrap();
-                    let search_params = SearchParameters::new(&search_options, &board);
-                    let best_move = engine.think(&mut board, &search_params);
-                    let move_output = UciResponse::BestMove {
-                        bestmove: best_move.map_or(None, |bot_move| {
-                            Some(move_to_uci_move(&bot_move).to_string())
-                        }),
-                        ponder: None,
-                    };
-                    writeln!(
-                        stdout,
-                        "{}",
-                        // TODO: Ponder
-                        move_output
-                    )
-                    .unwrap();
-                }
-                _ => (),
-            }
-
-            stdout.flush().unwrap();
+    let engine_run_result = engine.run();
+    match engine_run_result {
+        Ok(_) => (),
+        Err(e) => {
+            writeln!(io::stderr(), "Error running engine: {}", e).unwrap();
+            exit(1);
         }
     }
 }