Use one TT per game, use time manger in ID

src/search/iterative_deepening.rs

@@ -1,30 +1,58 @@
+use std::time::Instant;
+
 use crate::{
     board::game::Game,
     evaluation::{MAX_SCORE, MIN_SCORE},
     movegen::r#move::Move,
 };
 
-use super::{negamax, transposition_table::TranspositionTable, MAX_TT_SIZE};
+use super::{
+    negamax, transposition_table::TranspositionTable, HARD_LIMIT_DIVISION, SOFT_EVAL_THRESHOLD,
+    SOFT_LIMIT_DIVISION,
+};
 
-pub fn iterative_deepening(game: &mut Game, max_depth: u8, move_time: u128) -> Option<Move> {
-    let mut tt = TranspositionTable::new(MAX_TT_SIZE);
-    let mut mv: Option<Move> = None;
+pub fn iterative_deepening(
+    game: &mut Game,
+    max_depth: u8,
+    remaining_time: u128,
+    tt: &mut TranspositionTable,
+) -> Option<Move> {
+    let (mut best_move, mut best_eval): (Option<Move>, i32) = (None, MIN_SCORE);
     let time_now = std::time::Instant::now();
 
     for depth in 1..=max_depth {
-        if time_now.elapsed().as_millis() >= move_time {
-            return mv;
+        if time_limit_reached(&time_now, remaining_time, best_eval) {
+            return best_move;
         }
 
-        (mv, _) = negamax::negamax(game, MIN_SCORE, MAX_SCORE, depth, 0, &mut tt);
+        (best_move, best_eval) = negamax::negamax(game, MIN_SCORE, MAX_SCORE, depth, 0, tt);
     }
 
-    mv
+    best_move
+}
+
+fn time_limit_reached(time: &Instant, remaining_time: u128, eval: i32) -> bool {
+    hard_limit(time, remaining_time) || soft_limit(time, remaining_time, eval)
+}
+
+fn hard_limit(time_now: &Instant, remaining_time: u128) -> bool {
+    time_now.elapsed().as_millis() >= remaining_time / HARD_LIMIT_DIVISION
+}
+
+fn soft_limit(time: &Instant, remaining_time: u128, eval: i32) -> bool {
+    time.elapsed().as_millis() >= remaining_time / SOFT_LIMIT_DIVISION && eval > SOFT_EVAL_THRESHOLD
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::{board::fen::from_fen, movegen::attack_generator::init_attacks, search};
+    use crate::{
+        board::fen::from_fen,
+        movegen::attack_generator::init_attacks,
+        search::{
+            iterative_deepening, transposition_table::TranspositionTable, MAX_DEPTH, MAX_TT_SIZE,
+            REMAINING_TIME_DEFAULT,
+        },
+    };
 
     const FEN: &str = "1r2k2r/2P1pq1p/2npb3/1p3ppP/p3P3/P2B1Q2/1P1PNPP1/R3K2R w KQk g6 0 1";
 
@@ -32,9 +60,16 @@ mod tests {
     fn test_iterative_deepening() -> Result<(), String> {
         init_attacks();
         let mut game = from_fen(FEN)?;
+        let mut tt = TranspositionTable::new(MAX_TT_SIZE);
         let time_now = std::time::Instant::now();
 
-        let _ = search::iterative_deepening::iterative_deepening(&mut game, 6, 1000);
+        iterative_deepening::iterative_deepening(
+            &mut game,
+            MAX_DEPTH,
+            REMAINING_TIME_DEFAULT,
+            &mut tt,
+        );
+
         dbg!(time_now.elapsed());
 
         Ok(())

src/search/mod.rs

@@ -5,7 +5,10 @@ pub mod perft;
 pub mod quiescence;
 pub mod transposition_table;
 
-pub const MAX_DEPTH: u8 = 4;
+pub const MAX_DEPTH: u8 = 7;
 pub const QUIESCENCE_DEPTH: u8 = 3;
-pub const MOVE_TIME: u128 = 1000;
+pub const REMAINING_TIME_DEFAULT: u128 = 100000; // in ms
+pub const HARD_LIMIT_DIVISION: u128 = 10;
+pub const SOFT_LIMIT_DIVISION: u128 = 2;
+pub const SOFT_EVAL_THRESHOLD: i32 = 500;
 pub const MAX_TT_SIZE: u64 = 1000000;