Implement 3-fold repitition rule for algos and logic. Implement search

extension module

Author: confusinguser

src/algorithms/the_algorithm.rs

@@ -12,14 +12,17 @@ pub(crate) struct Algorithm {
     pub(crate) modules: u32,
     transposition_table: HashMap<Board, TranspositionEntry>,
     pub(crate) time_per_move: Duration,
+    /// Number of times that a given board has been played
+    pub(crate) board_played_times: HashMap<Board, u32>,
 }
 
 impl Algorithm {
     pub(crate) fn new(modules: u32, time_per_move: Duration) -> Self {
         Self {
             modules,
-            transposition_table: HashMap::new(),
+            transposition_table: HashMap::with_capacity(45),
             time_per_move,
+            board_played_times: HashMap::new(),
         }
     }
 
@@ -33,6 +36,7 @@ impl Algorithm {
         original: bool,
         deadline: Option<Instant>,
         stats: &mut Stats,
+        num_extensions: u32,
     ) -> Evaluation {
         if depth == 0 {
             stats.leaves_visited += 1;
@@ -70,7 +74,7 @@ impl Algorithm {
             return best_evaluation;
         }
 
-        let mut boards = legal_moves
+        let boards = legal_moves
             .map(|chess_move| {
                 let board = board.make_move_new(chess_move);
                 let mut transposition_entry = None;
@@ -109,18 +113,35 @@ impl Algorithm {
                 return best_evaluation;
             };
 
-            let evaluation = if transposition_entry.is_some()
-                && transposition_entry.unwrap().depth >= depth
-            {
-                stats.transposition_table_accesses += 1;
-                Evaluation::new(
-                    Some(transposition_entry.unwrap().eval),
-                    transposition_entry.unwrap().next_action,
-                    None,
-                )
-            } else {
-                self.node_eval_recursive(new_board, depth - 1, alpha, beta, false, deadline, stats)
-            };
+            let extend_by =
+                if !module_enabled(self.modules, SEARCH_EXTENSIONS) || num_extensions > 3 {
+                    0
+                } else if num_legal_moves <= 3 || new_board.checkers().popcnt() != 0 {
+                    1
+                } else {
+                    0
+                };
+
+            let evaluation =
+                if transposition_entry.is_some() && transposition_entry.unwrap().depth >= depth {
+                    stats.transposition_table_accesses += 1;
+                    Evaluation::new(
+                        Some(transposition_entry.unwrap().eval),
+                        transposition_entry.unwrap().next_action,
+                        None,
+                    )
+                } else {
+                    self.node_eval_recursive(
+                        new_board,
+                        depth - 1 + extend_by,
+                        alpha,
+                        beta,
+                        false,
+                        deadline,
+                        stats,
+                        num_extensions + extend_by,
+                    )
+                };
             stats.nodes_visited += 1;
 
             // Replace best_eval if ours is better
@@ -191,31 +212,44 @@ impl Algorithm {
         best_evaluation
     }
 
-    fn next_action_internal(
+    fn next_action(
         &mut self,
         board: &Board,
         depth: u32,
         deadline: Option<Instant>,
     ) -> (Option<chess::Action>, Vec<String>, Stats) {
         let mut stats = Stats::default();
-        let out =
-            self.node_eval_recursive(board, depth, f32::MIN, f32::MAX, true, deadline, &mut stats);
+        let out = self.node_eval_recursive(
+            board,
+            depth,
+            f32::MIN,
+            f32::MAX,
+            true,
+            deadline,
+            &mut stats,
+            0,
+        );
         let analyzer_data = out.debug_data.unwrap_or_default();
         (out.next_action, analyzer_data, stats)
     }
 
-    pub(crate) fn next_action(
+    pub(crate) fn next_action_iterative_deepening(
         &mut self,
         board: &Board,
         deadline: Instant,
     ) -> (chess::Action, Vec<String>, Stats) {
+        self.board_played_times.insert(
+            *board,
+            *self.board_played_times.get(board).unwrap_or(&0) + 1,
+        );
+
         // Guarantee that at least the first layer gets done.
         const START_DEPTH: u32 = 1;
-        let mut deepest_complete_output = self.next_action_internal(board, START_DEPTH, None);
+        let mut deepest_complete_output = self.next_action(board, START_DEPTH, None);
         let mut deepest_complete_depth = START_DEPTH;
 
         for depth in (deepest_complete_depth + 1)..=10 {
-            let latest_output = self.next_action_internal(board, depth, Some(deadline));
+            let latest_output = self.next_action(board, depth, Some(deadline));
             if utils::passed_deadline(deadline) {
                 // The cancelled layer is the one with this data
                 deepest_complete_output.2.progress_on_next_layer =
@@ -229,22 +263,31 @@ impl Algorithm {
         deepest_complete_output.2.depth = deepest_complete_depth;
         deepest_complete_output.2.tt_size = self.transposition_table.len() as u32;
 
-        (
-            match deepest_complete_output.0 {
-                Some(action) => action,
-                None => match board.status() {
-                    BoardStatus::Ongoing => {
-                        println!("{}", board);
-                        println!("{:#?}", deepest_complete_output.1);
-                        panic!("No action returned by algorithm even though game is still ongoing")
-                    }
-                    BoardStatus::Stalemate => Action::DeclareDraw,
-                    BoardStatus::Checkmate => Action::Resign(board.side_to_move()),
-                },
+        let mut action = match deepest_complete_output.0 {
+            Some(action) => action,
+            None => match board.status() {
+                BoardStatus::Ongoing => {
+                    println!("{}", board);
+                    println!("{:#?}", deepest_complete_output.1);
+                    panic!("No action returned by algorithm even though game is still ongoing")
+                }
+                BoardStatus::Stalemate => Action::DeclareDraw,
+                BoardStatus::Checkmate => Action::Resign(board.side_to_move()),
             },
-            deepest_complete_output.1,
-            deepest_complete_output.2,
-        )
+        };
+
+        if let Action::MakeMove(chess_move) = action {
+            let new_board = board.make_move_new(chess_move);
+            let old_value = *self.board_played_times.get(&new_board).unwrap_or(&0);
+            if old_value >= 3 {
+                // Oh no! We should declare draw by three-fold repetition. This is not checked
+                // unless we do this.
+                action = Action::DeclareDraw;
+            }
+            self.board_played_times.insert(new_board, old_value + 1);
+        }
+
+        (action, deepest_complete_output.1, deepest_complete_output.2)
     }
 
     pub(crate) fn eval(&self, board: &Board) -> f32 {
@@ -259,6 +302,12 @@ impl Algorithm {
                 f32::MAX
             };
         }
+        if let Some(&board_played_times) = self.board_played_times.get(board) {
+            if board_played_times >= 2 {
+                // This is third time this is played. Draw by three-fold repetition
+                return 0.;
+            }
+        }
         let material_each_side = utils::material_each_side(board);
 
         // Negative when black has advantage
@@ -268,5 +317,6 @@ impl Algorithm {
 
     pub(crate) fn reset(&mut self) {
         self.transposition_table = HashMap::new();
+        self.board_played_times = HashMap::new();
     }
 }

src/common/constants.rs

@@ -1,7 +1,6 @@
 pub(crate) mod modules {
     pub(crate) const ANALYZE: u32 = 0b1;
-    /// What bit the AB feature is in the modules integer
     pub(crate) const ALPHA_BETA: u32 = 0b10;
-
     pub(crate) const TRANSPOSITION_TABLE: u32 = 0b100;
+    pub(crate) const SEARCH_EXTENSIONS: u32 = 0b1000;
 }

src/main.rs

@@ -1,16 +1,18 @@
 use std::time::Duration;
 
 use crate::algorithms::the_algorithm::Algorithm;
-use crate::common::constants::modules::{ALPHA_BETA, ANALYZE, TRANSPOSITION_TABLE};
+use crate::common::constants::modules::{
+    ALPHA_BETA, ANALYZE, SEARCH_EXTENSIONS, TRANSPOSITION_TABLE,
+};
 
-use self::pitter::logic::Competition;
+use self::pitter::logic::{Competition, GameOutcome};
 
 mod algorithms;
 mod common;
 mod pitter;
 
 fn main() {
-    let modules1 = TRANSPOSITION_TABLE | ALPHA_BETA | ANALYZE;
+    let modules1 = SEARCH_EXTENSIONS | ALPHA_BETA | ANALYZE;
     let modules2 = ALPHA_BETA | ANALYZE;
     let time_per_move1 = Duration::from_micros(2000);
     let time_per_move2 = Duration::from_micros(2000);
@@ -20,7 +22,9 @@ fn main() {
         Algorithm::new(modules2, time_per_move2),
     );
 
-    // let results = competition.analyze_algorithm_choices(|_, _| true);
-    let results = competition.start_competition(200);
+    // competition.analyze_algorithm_choices(|(game_info, _), _| {
+    //     game_info.outcome == GameOutcome::InconclusiveTooLong
+    // });
+    let results = competition.start_competition(500);
     dbg!(results);
 }

src/pitter/logic.rs

@@ -43,8 +43,8 @@ impl GamePairOutcome {
             (Draw, BlackWin) => Algo1HalfWin,
             (Draw, Draw) => GamePairOutcome::Draw,
             // Consider changing this in the future, this is an arbitrary choice
-            (Inconclusive, _) => GamePairOutcome::InconclusiveTooLong,
-            (_, Inconclusive) => GamePairOutcome::InconclusiveTooLong,
+            (InconclusiveTooLong, _) => GamePairOutcome::InconclusiveTooLong,
+            (_, InconclusiveTooLong) => GamePairOutcome::InconclusiveTooLong,
         }
     }
 }
@@ -55,7 +55,7 @@ pub(crate) enum GameOutcome {
     BlackWin,
     Draw,
     #[default]
-    Inconclusive,
+    InconclusiveTooLong,
 }
 
 #[allow(unused_assignments)]
@@ -121,9 +121,9 @@ impl Competition {
     ) -> GameInfo {
         let mut game_info = GameInfo::default();
         let mut algo1 = &mut self.algo1;
-        // algo1.reset();
+        algo1.reset();
         let mut algo2 = &mut self.algo2;
-        // algo2.reset();
+        algo2.reset();
         if reversed {
             mem::swap(&mut algo1, &mut algo2);
         };
@@ -136,14 +136,14 @@ impl Competition {
             let mut next_action = match side_to_move {
                 Color::White => {
                     analyze = algo1.modules & ANALYZE != 0;
-                    algo1.next_action(
+                    algo1.next_action_iterative_deepening(
                         &game.current_position(),
                         Instant::now() + algo1.time_per_move,
                     )
                 }
                 Color::Black => {
                     analyze = algo1.modules & ANALYZE != 0;
-                    algo2.next_action(
+                    algo2.next_action_iterative_deepening(
                         &game.current_position(),
                         Instant::now() + algo2.time_per_move,
                     )
@@ -167,14 +167,29 @@ impl Competition {
                 game_info.stats.0 += next_action.2;
             }
 
-            match next_action.0 {
+            let mut declared_draw = false;
+            let success = match next_action.0 {
                 Action::MakeMove(chess_move) => game.make_move(chess_move),
                 Action::OfferDraw(color) => game.offer_draw(color),
                 Action::AcceptDraw => game.accept_draw(),
-                Action::DeclareDraw => game.declare_draw(),
+                Action::DeclareDraw => {
+                    // The chess crate one is really bad and wrong
+                    declared_draw = true;
+                    true
+                }
                 Action::Resign(color) => game.resign(color),
             };
 
+            if !success {
+                dbg!(utils::to_pgn(&game));
+                panic!("Algorithm made illegal action");
+            }
+
+            if declared_draw {
+                game_info.outcome = GameOutcome::Draw;
+                break;
+            }
+
             if let Some(result) = game.result() {
                 game_info.outcome = match result {
                     GameResult::WhiteCheckmates => GameOutcome::WhiteWin,
@@ -188,7 +203,7 @@ impl Competition {
                 break;
             }
             if num_plies >= max_plies {
-                game_info.outcome = GameOutcome::Inconclusive;
+                game_info.outcome = GameOutcome::InconclusiveTooLong;
                 break;
             }
             num_plies += 1
@@ -222,8 +237,8 @@ impl Competition {
                 game_pair_info.1.outcome,
             );
 
-            // println!("Game pair played.  Outcome: {:?}", combined_outcome);
-            // println!("{}", utils::to_pgn(&game_pair_info.0.game.unwrap()));
+            println!("Game pair played.  Outcome: {:?}", combined_outcome);
+            println!("{}", utils::to_pgn(&game_pair_info.0.game.unwrap()));
 
             results.register_game_outcome(combined_outcome);
 
@@ -275,6 +290,8 @@ impl Competition {
             if i > 500 {
                 return None;
             }
+            self.algo1.reset();
+            self.algo2.reset();
         }
     }
 
@@ -290,19 +307,23 @@ impl Competition {
         println!("{}", utils::to_pgn(game.0.game.as_ref().unwrap()));
         let mut board = Board::default();
 
+        self.algo1.reset();
+        self.algo2.reset();
         for chess_move in game.0.game.as_ref().unwrap().actions() {
             let Action::MakeMove(chess_move) = chess_move else {continue};
 
-            // PROBLEM!! This will be unreliable if the algorithms have persistent data over moves
-            // in the future, we will have to make new instances of the algos somehow then
             let start = Instant::now();
             let mut algo_out = if i % 2 == 1 {
                 // White's turn
-                self.algo1
-                    .next_action(&board, Instant::now() + Duration::from_micros(2000))
+                self.algo1.next_action_iterative_deepening(
+                    &board,
+                    Instant::now() + Duration::from_micros(2000),
+                )
             } else {
-                self.algo2
-                    .next_action(&board, Instant::now() + Duration::from_micros(2000))
+                self.algo2.next_action_iterative_deepening(
+                    &board,
+                    Instant::now() + Duration::from_micros(2000),
+                )
             };
             let end = Instant::now();
             algo_out.2.time_spent = end - start;
@@ -320,5 +341,8 @@ impl Competition {
             board = board.make_move_new(*chess_move);
             i += 1;
         }
+
+        dbg!(&self.algo1.board_played_times.values());
+        dbg!(&self.algo2.board_played_times.values());
     }
 }