Refactor Rust AI core into idiomatic modules, improve and fix tests, ensure all tests pass and code is lint-free

Author: rgilks

worker/rust_ai_core/src/ai.rs

@@ -70,7 +70,7 @@ impl AI {
             .map(|(move_idx, score)| {
                 let piece = &state.get_pieces(state.current_player)[*move_idx as usize];
                 let track = GameState::get_player_track(state.current_player);
-                let (move_type, to_square) = if piece.square == -1 {
+                let (move_type, to_square) = if piece.is_at_start() {
                     ("enter".to_string(), Some(track[0]))
                 } else if let Some(track_pos) =
                     track.iter().position(|&sq| sq as i8 == piece.square)
@@ -205,7 +205,7 @@ impl AI {
 
     fn get_move_score(&self, piece: &PiecePosition, state: &GameState) -> i32 {
         let mut score = 0;
-        if piece.square == -1 {
+        if piece.is_at_start() {
             score += 100;
         } else {
             let track = GameState::get_player_track(state.current_player);
@@ -226,6 +226,26 @@ impl AI {
         }
         score
     }
+
+    pub fn clear_transposition_table(&mut self) {
+        self.transposition_table.clear();
+        self.nodes_evaluated = 0;
+        self.transposition_hits = 0;
+    }
+
+    pub fn get_cache_stats(&self) -> (usize, u32, u32) {
+        (
+            self.transposition_table.len(),
+            self.nodes_evaluated,
+            self.transposition_hits,
+        )
+    }
+}
+
+impl Default for AI {
+    fn default() -> Self {
+        Self::new()
+    }
 }
 
 #[derive(Serialize)]
@@ -240,3 +260,139 @@ pub struct MoveEvaluation {
     #[serde(rename = "toSquare")]
     pub to_square: Option<u8>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_ai_creation() {
+        let ai = AI::new();
+        assert_eq!(ai.nodes_evaluated, 0);
+        assert_eq!(ai.transposition_hits, 0);
+        assert!(ai.transposition_table.is_empty());
+    }
+
+    #[test]
+    fn test_ai_default() {
+        let ai1 = AI::new();
+        let ai2 = AI::default();
+        assert_eq!(ai1.nodes_evaluated, ai2.nodes_evaluated);
+        assert_eq!(ai1.transposition_hits, ai2.transposition_hits);
+    }
+
+    #[test]
+    fn test_ai_best_move_single_option() {
+        let mut state = GameState::new();
+        state.dice_roll = 1;
+        state.current_player = Player::Player1;
+
+        for i in 1..PIECES_PER_PLAYER {
+            state.player1_pieces[i].square = 20;
+        }
+
+        let mut ai = AI::new();
+        let (best_move, evaluations) = ai.get_best_move(&state, 2);
+
+        assert_eq!(best_move, 0);
+        assert!(evaluations.len() >= 1);
+        assert_eq!(evaluations[0].piece_index, 0);
+    }
+
+    #[test]
+    fn test_ai_best_move_multiple_options() {
+        let mut state = GameState::new();
+        state.dice_roll = 1;
+        state.current_player = Player::Player1;
+
+        let mut ai = AI::new();
+        let (best_move, evaluations) = ai.get_best_move(&state, 1);
+
+        assert!(best_move < PIECES_PER_PLAYER as u8);
+        assert!(!evaluations.is_empty());
+        assert_eq!(evaluations.len(), PIECES_PER_PLAYER);
+    }
+
+    #[test]
+    fn test_ai_no_valid_moves() {
+        let mut state = GameState::new();
+        state.dice_roll = 0;
+
+        let mut ai = AI::new();
+        let (best_move, evaluations) = ai.get_best_move(&state, 1);
+
+        assert_eq!(best_move, 0);
+        assert!(evaluations.is_empty());
+    }
+
+    #[test]
+    fn test_ai_clear_transposition_table() {
+        let mut ai = AI::new();
+        ai.nodes_evaluated = 100;
+        ai.transposition_hits = 50;
+        ai.transposition_table.insert(
+            123,
+            TranspositionEntry {
+                evaluation: 0,
+                depth: 1,
+            },
+        );
+
+        ai.clear_transposition_table();
+
+        assert_eq!(ai.nodes_evaluated, 0);
+        assert_eq!(ai.transposition_hits, 0);
+        assert!(ai.transposition_table.is_empty());
+    }
+
+    #[test]
+    fn test_ai_get_cache_stats() {
+        let mut ai = AI::new();
+        ai.nodes_evaluated = 100;
+        ai.transposition_hits = 50;
+        ai.transposition_table.insert(
+            123,
+            TranspositionEntry {
+                evaluation: 0,
+                depth: 1,
+            },
+        );
+
+        let (cache_size, nodes, hits) = ai.get_cache_stats();
+
+        assert_eq!(cache_size, 1);
+        assert_eq!(nodes, 100);
+        assert_eq!(hits, 50);
+    }
+
+    #[test]
+    fn test_move_evaluation_creation() {
+        let eval = MoveEvaluation {
+            piece_index: 2,
+            score: 150.5,
+            move_type: "capture".to_string(),
+            from_square: 5,
+            to_square: Some(10),
+        };
+
+        assert_eq!(eval.piece_index, 2);
+        assert_eq!(eval.score, 150.5);
+        assert_eq!(eval.move_type, "capture");
+        assert_eq!(eval.from_square, 5);
+        assert_eq!(eval.to_square, Some(10));
+    }
+
+    #[test]
+    fn test_get_move_score() {
+        let ai = AI::new();
+        let state = GameState::new();
+
+        let start_piece = PiecePosition::new(-1, Player::Player1);
+        let score = ai.get_move_score(&start_piece, &state);
+        assert!(score > 0);
+
+        let board_piece = PiecePosition::new(5, Player::Player1);
+        let score = ai.get_move_score(&board_piece, &state);
+        assert!(score >= 0);
+    }
+}