Convert minimax to negamax and implement alpha-beta pruning

src/evaluation/evaluation.rs

@@ -6,6 +6,9 @@ use crate::{
     evaluation::psqt::{mirror_index, piece_square_score},
 };
 
+pub const MAX_EVAL: i32 = 100000;
+pub const MIN_EVAL: i32 = -100000;
+
 const fn piece_score(piece_type: PieceType) -> i32 {
     match piece_type {
         PieceType::Pawn => 100,
@@ -17,7 +20,7 @@ const fn piece_score(piece_type: PieceType) -> i32 {
     }
 }
 
-fn evaluate_side(board: &Board, color: Color) -> i32 {
+fn evaluate_side_for(board: &Board, color: Color) -> i32 {
     let mut total_score = 0;
     let pieces = match color {
         Color::White => &board.white_pieces,
@@ -42,23 +45,21 @@ fn evaluate_side(board: &Board, color: Color) -> i32 {
     total_score
 }
 
-pub fn evaluate_position(board: &Board, color: Color) -> i32 {
-    let total_white_score = evaluate_side(board, Color::White);
-    let total_black_score = evaluate_side(board, Color::Black);
-    let evaluation = total_white_score - total_black_score;
+pub fn evaluate_position(board: &Board) -> i32 {
+    let total_white_score = evaluate_side_for(board, Color::White);
+    let total_black_score = evaluate_side_for(board, Color::Black);
 
-    match color {
-        Color::White => evaluation,
-        Color::Black => -evaluation,
-    }
+    -(total_white_score - total_black_score)
 }
 
 #[cfg(test)]
 mod tests {
     use crate::{
-        board::board::{Color, PieceType},
-        board::fen::from_fen,
-        evaluation::evaluation::{evaluate_position, evaluate_side, piece_score},
+        board::{
+            board::{Color, PieceType},
+            fen::from_fen,
+        },
+        evaluation::evaluation::{evaluate_position, evaluate_side_for, piece_score},
     };
 
     const FEN_QUIET: [&str; 2] = [
@@ -79,17 +80,17 @@ mod tests {
     }
 
     #[test]
-    fn test_evaluate_side() -> Result<(), String> {
+    fn test_evaluate_side_for() -> Result<(), String> {
         let game = from_fen(FEN_QUIET[0])?;
 
         assert_eq!(
-            evaluate_side(&game.board, Color::White),
-            evaluate_side(&game.board, Color::Black)
+            evaluate_side_for(&game.board, Color::White),
+            evaluate_side_for(&game.board, Color::Black)
         );
 
         let game_2 = from_fen(FEN_QUIET[1])?;
-        let evaluate_white = evaluate_side(&game_2.board, Color::White);
-        let evaluate_black = evaluate_side(&game_2.board, Color::Black);
+        let evaluate_white = evaluate_side_for(&game_2.board, Color::White);
+        let evaluate_black = evaluate_side_for(&game_2.board, Color::Black);
 
         assert_eq!(24005, evaluate_white);
         assert_eq!(23965, evaluate_black);
@@ -102,14 +103,13 @@ mod tests {
         let game = from_fen(FEN_QUIET[0])?;
 
         assert_eq!(
-            evaluate_position(&game.board, Color::White),
-            evaluate_position(&game.board, Color::Black)
+            evaluate_position(&game.board),
+            evaluate_position(&game.board)
         );
 
         let game_2 = from_fen(FEN_QUIET[1])?;
 
-        assert_eq!(40, evaluate_position(&game_2.board, Color::White));
-        assert_eq!(-40, evaluate_position(&game_2.board, Color::Black));
+        assert_eq!(-40, evaluate_position(&game_2.board));
 
         Ok(())
     }