Merge pull request #72 from CurtisTechSolutions/fix/search-truncated-leaves

fix(opponents): treat length-capped states as search leaves

Author: nosam1998

crates/apps/gfa-server/src/opponent_tests.rs

@@ -216,3 +216,34 @@ fn players_reject_invalid_limits_and_inconsistent_turns() -> TestResult {
     );
     Ok(())
 }
+
+#[test]
+fn search_treats_length_caps_as_leaves_without_changing_game_endings() -> TestResult {
+    let game = game("chess")?;
+    for max_plies in [1, 2] {
+        let config = json!({"max_plies": max_plies});
+        for algorithm in [Algorithm::Minimax, Algorithm::Mcts] {
+            let player = SearchOpponent::new(game.clone(), config.clone(), algorithm)?;
+            let mut state = game.initial_state(&config, 0)?;
+            for _ in 0..max_plies {
+                let budget = SearchLimits {
+                    nodes: 128,
+                    depth: 4,
+                    ..limits()
+                };
+                let first = choose(game.as_ref(), &player, &state, budget, &Fixed)?;
+                assert_eq!(
+                    first,
+                    choose(game.as_ref(), &player, &state, budget, &Fixed)?
+                );
+                assert!(first.info.nodes <= budget.nodes);
+                let seat = game.current_players(&state)?[0];
+                state = game.apply(&state, seat, &first.action.json)?.0;
+            }
+            assert!(game.is_truncated(&state)?);
+            assert!(!game.is_terminal(&state)?);
+            assert_eq!(game.returns(&state)?, vec![0.0, 0.0]);
+        }
+    }
+    Ok(())
+}

crates/players/gfa-opponents/src/lib.rs

@@ -113,6 +113,7 @@ impl Opponent for SearchOpponent {
             limits.seed,
         )?;
         if self.game.is_terminal(&state)?
+            || self.game.is_truncated(&state)?
             || self.game.current_players(&state)? != [turn.seat]
             || self.game.legal_actions(&state, turn.seat)? != turn.legal_actions
         {

crates/players/gfa-opponents/src/mcts.rs

@@ -10,7 +10,7 @@ struct Node {
 }
 
 fn node(game: &dyn DynGame, state: Value, rng: &mut SeededRng) -> Result<Node, GameError> {
-    let seat = if game.is_terminal(&state)? {
+    let seat = if game.is_terminal(&state)? || game.is_truncated(&state)? {
         None
     } else {
         Some(actor(game, &state)?)
@@ -116,7 +116,10 @@ pub(super) fn choose(
         result.info.depth = result.info.depth.max(depth);
         // Rollout uses the same per-seat engine rules, with independent randomness.
         let mut rollout = tree[current].state.clone();
-        while depth < budget.limits.depth && !game.is_terminal(&rollout)? {
+        while depth < budget.limits.depth
+            && !game.is_terminal(&rollout)?
+            && !game.is_truncated(&rollout)?
+        {
             if !budget.enter() {
                 break;
             }

crates/players/gfa-opponents/src/minimax.rs

@@ -52,7 +52,7 @@ fn search(
     if !budget.enter() {
         return Ok(None);
     }
-    if depth == 0 || game.is_terminal(state)? {
+    if depth == 0 || game.is_terminal(state)? || game.is_truncated(state)? {
         return Ok(Some((payoff(game, state, root)?, vec![])));
     }
     let seat = actor(game, state)?;