Use increment from uci winc/binc in time management

src/search/iterative_deepening.rs

@@ -9,52 +9,38 @@ use crate::{
 
 use super::{
     negamax,
-    time::{soft_limit, TimeInfo},
+    time::{hard_limit, TimeInfo},
 };
 
 pub fn iterative_deepening(
     game: &mut Game,
     max_depth: u8,
-    remaining_time: u128,
+    time_info: &TimeInfo,
 ) -> anyhow::Result<Option<Move>> {
-    let (mut best_move, mut best_score) = (None, MIN_SCORE);
-    let time = std::time::Instant::now();
+    let mut best_move = None;
 
     for depth in 1..=max_depth {
-        if soft_limit(&time, remaining_time, best_score) {
+        if hard_limit(time_info.instant, time_info.time, time_info.inc) {
             return Ok(best_move);
         }
 
-        let mut total_nodes_searched = 0;
-
-        let score = negamax::negamax(
-            game,
-            MIN_SCORE,
-            MAX_SCORE,
-            depth,
-            0,
-            &TimeInfo::new(time, remaining_time),
-            &mut total_nodes_searched,
-        );
+        let mut nodes = 0;
+        let score = negamax::negamax(game, MIN_SCORE, MAX_SCORE, depth, 0, time_info, &mut nodes);
 
         if score.is_err() {
             break;
         }
 
-        best_score = score?;
         best_move = game.tt.lookup(game.hash).and_then(|entry| entry.mv);
 
-        let nps = ((total_nodes_searched * 1_000_000) as u128).div_ceil(time.elapsed().as_micros())
-            as u64;
-
         write_response(
             &mut io::stdout(),
-            &search_info(
+            &log_depth_results(
                 depth,
-                time.elapsed().as_millis() as u64,
-                total_nodes_searched,
-                nps,
-                best_score,
+                time_info.instant.elapsed().as_millis() as u64,
+                nodes,
+                time_info.nps(nodes),
+                score?,
                 best_move,
             ),
         )?;
@@ -62,22 +48,22 @@ pub fn iterative_deepening(
     Ok(best_move)
 }
 
-fn search_info(
+fn log_depth_results(
     depth: u8,
-    time: u64,
-    total_nodes_searched: u64,
+    seconds: u64,
+    nodes: u64,
     nps: u64,
     best_score: i32,
     best_move: Option<Move>,
 ) -> Response {
     Response::Info(format!(
-        "info depth {} time {} nodes {} nps {} eval {} pv {}",
+        "info depth {} seconds {} nodes {} nps {} eval {} bestmove {}",
         depth,
-        time,
-        total_nodes_searched,
+        seconds,
+        nodes,
         nps,
         best_score,
-        best_move.expect("msg: No best move found")
+        best_move.expect("No best move found")
     ))
 }
 
@@ -86,7 +72,7 @@ mod tests {
     use crate::{
         board::fen::from_fen,
         movegen::attack_generator::init_attacks,
-        search::{iterative_deepening, MAX_DEPTH, REMAINING_TIME_DEFAULT},
+        search::{iterative_deepening, time::TimeInfo, INC, MAX_DEPTH, TIME},
     };
 
     const FEN: &str = "1r2k2r/2P1pq1p/2npb3/1p3ppP/p3P3/P2B1Q2/1P1PNPP1/R3K2R w KQk g6 0 1";
@@ -95,11 +81,15 @@ mod tests {
     fn test_iterative_deepening() -> anyhow::Result<()> {
         init_attacks();
         let mut game = from_fen(FEN).unwrap();
-        let time_now = std::time::Instant::now();
+        let instant = std::time::Instant::now();
 
-        iterative_deepening::iterative_deepening(&mut game, MAX_DEPTH, REMAINING_TIME_DEFAULT)?;
+        iterative_deepening::iterative_deepening(
+            &mut game,
+            MAX_DEPTH,
+            &TimeInfo::new(instant, TIME, INC),
+        )?;
 
-        dbg!(time_now.elapsed());
+        dbg!(instant.elapsed());
 
         Ok(())
     }