Slight improvement in chess bot

Author: shashankp28

notebooks/benchmark.ipynb

@@ -1,2 +1,3 @@
 pub mod root;
 pub mod get_eval;
+pub mod static_eval;

src/api/get/mod.rs

@@ -0,0 +1,39 @@
+use axum::{ extract::Json, response::IntoResponse, http::StatusCode };
+use serde::{ Deserialize, Serialize };
+use std::str::FromStr;
+use chess::Board;
+
+use crate::bot::algorithm::eval::evaluate_board;
+
+#[derive(Debug, Deserialize)]
+pub struct EvalRequest {
+    pub current_fen: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct StaticEvalResponse {
+    pub eval: i32,
+}
+
+pub async fn static_eval_handler(Json(payload): Json<EvalRequest>) -> impl IntoResponse {
+    let current_board = match Board::from_str(&payload.current_fen) {
+        Ok(board) => board,
+        Err(_) => {
+            return (
+                StatusCode::BAD_REQUEST,
+                Json(StaticEvalResponse {
+                    eval: 0,
+                }),
+            );
+        }
+    };
+
+    let eval = evaluate_board(&current_board);
+
+    (
+        StatusCode::OK,
+        Json(StaticEvalResponse {
+            eval,
+        }),
+    )
+}

src/api/get/static_eval.rs

@@ -1,22 +1,27 @@
 use chess::{ Board, ChessMove, MoveGen };
 use std::time::Instant;
 use crate::bot::algorithm::eval::evaluate_board;
-use crate::bot::algorithm::root::QUIET_SEARCH_DEPTH;
+use crate::bot::include::types::SpecialMove;
 use crate::bot::util::board::BoardExt;
 use crate::bot::util::piece::piece_value;
 use crate::bot::{ include::types::{ EngineState } };
 
-pub fn get_prioritized_moves(board: &Board, is_capture: bool) -> Vec<(ChessMove, i32)> {
+pub fn get_prioritized_moves(board: &Board, only_noise: bool) -> Vec<(ChessMove, i32)> {
     let mut move_priority_pairs = Vec::new();
 
     for mv in MoveGen::new_legal(board) {
-        if is_capture {
+        if only_noise {
+            let move_tags = board.classify_move(mv);
+            if
+                !move_tags.contains(&SpecialMove::Promotion) &&
+                !move_tags.contains(&SpecialMove::Capture)
+            {
+                continue;
+            }
             if let Some((attacker, victim)) = board.capture_pieces(mv) {
                 if piece_value(victim) < piece_value(attacker) {
                     continue;
                 }
-            } else {
-                continue;
             }
         }
 
@@ -58,7 +63,8 @@ pub fn alpha_beta(
     match board.status() {
         chess::BoardStatus::Checkmate => {
             let eval = evaluate_board(board);
-            let score = (eval * ((depth as i32) + 1)).clamp(-100_000, 100_000);
+            let depth_weight = 20 - current_depth.min(20);
+            let score = (eval * ((depth_weight as i32) + 1)).clamp(-500_000, 500_000);
             return (None, score);
         }
         chess::BoardStatus::Stalemate => {
@@ -76,7 +82,7 @@ pub fn alpha_beta(
                 nodes,
                 deadline,
                 engine_state,
-                QUIET_SEARCH_DEPTH,
+                current_depth-1,
                 true,
                 current_depth + 1,
                 max_depth_reached
@@ -112,7 +118,6 @@ pub fn alpha_beta(
             max_depth_reached
         );
 
-
         if let Some(count) = engine_state.history.get_mut(&new_hash) {
             *count -= 1;
             if *count == 0 {

src/bot/algorithm/ab.rs

@@ -1,56 +1,30 @@
-use chess::{ Board, Piece };
+use chess::{ Board, Color, File, Piece, Rank, Square };
 use crate::bot::{ include::types::GlobalMap, util::{ board::BoardExt, piece::piece_value } };
 
-fn is_endgame(board: &Board) -> bool {
-    // Simple heuristic: endgame if total material (excluding kings) is low
-    let mut non_king_material = 0;
-
-    for sq in chess::ALL_SQUARES {
-        if let Some(piece) = board.piece_on(sq) {
-            if piece == Piece::King {
-                continue;
-            }
-
-            non_king_material += match piece {
-                Piece::Pawn => 100,
-                Piece::Knight => 320,
-                Piece::Bishop => 330,
-                Piece::Rook => 500,
-                Piece::Queen => 900,
-                _ => 0,
-            };
-        }
-    }
-
-    non_king_material < 1600 // adjust threshold as needed
-}
-
-fn square_distance(a: chess::Square, b: chess::Square) -> u8 {
-    let file_dist = ((a.get_file().to_index() as i32) - (b.get_file().to_index() as i32)).abs();
-    let rank_dist = ((a.get_rank().to_index() as i32) - (b.get_rank().to_index() as i32)).abs();
-    (file_dist + rank_dist) as u8
+fn distance_between(a: Square, b: Square) -> u8 {
+    let file_distance = ((a.get_file().to_index() as i8) - (b.get_file().to_index() as i8)).abs();
+    let rank_distance = ((a.get_rank().to_index() as i8) - (b.get_rank().to_index() as i8)).abs();
+    (file_distance + rank_distance) as u8
 }
 
-fn evaluate_king_proximity(board: &Board) -> i32 {
-    use chess::{ Color::*, Piece::King };
-
-    if !is_endgame(board) {
-        return 0;
+fn evaluate_king_proximity(board: &Board, is_endgame: bool) -> i32 {
+    if is_endgame {
+        let white_king_sq = (board.pieces(Piece::King) & board.color_combined(Color::White))
+            .into_iter()
+            .next()
+            .unwrap();
+        let black_king_sq = (board.pieces(Piece::King) & board.color_combined(Color::Black))
+            .into_iter()
+            .next()
+            .unwrap();
+
+        let proximity = distance_between(white_king_sq, black_king_sq) as i32;
+        let score = 11 + (14 - proximity);
+
+        return score;
     }
 
-    let white_king_sq = (board.pieces(King) & board.color_combined(White))
-        .into_iter()
-        .next()
-        .unwrap();
-    let black_king_sq = (board.pieces(King) & board.color_combined(Black))
-        .into_iter()
-        .next()
-        .unwrap();
-
-    let dist = square_distance(white_king_sq, black_king_sq);
-    let proximity_score = 10 - (dist as i32); // Closer = better
-
-    proximity_score * 3
+    0
 }
 
 fn evaluate_connected_pawns(board: &Board) -> i32 {
@@ -66,21 +40,84 @@ fn evaluate_connected_pawns(board: &Board) -> i32 {
             let file = sq.get_file().to_index();
 
             let connected = [-1, 1].iter().any(|&df| {
-                let f = ((file as isize) + df) as usize;
-                if f > 7 {
+                let f = (file as isize) + df;
+                if f < 0 || f > 7 {
                     return false;
                 }
-                let adj_sq = chess::Square::make_square(
-                    chess::Rank::from_index(rank),
-                    chess::File::from_index(f)
-                );
-                board.piece_on(adj_sq) == Some(Pawn) && board.color_on(adj_sq) == Some(color)
+
+                // Check same rank, one ahead, and one behind
+                [-1, 0, 1].iter().any(|&dr| {
+                    let r = (rank as isize) + dr;
+                    if r < 0 || r > 7 {
+                        return false;
+                    }
+
+                    let adj_sq = chess::Square::make_square(
+                        chess::Rank::from_index(r as usize),
+                        chess::File::from_index(f as usize)
+                    );
+                    board.piece_on(adj_sq) == Some(Pawn) && board.color_on(adj_sq) == Some(color)
+                })
             });
 
             if connected {
                 score += match color {
-                    White => 10,
-                    Black => -10,
+                    White => 15,
+                    Black => -15,
+                };
+            }
+        }
+    }
+
+    score
+}
+
+pub fn evaluate_passed_pawns(board: &Board) -> i32 {
+    use Color::{ White, Black };
+    use Piece::Pawn;
+
+    let mut score = 0;
+
+    for &color in &[White, Black] {
+        let pawns = board.pieces(Pawn) & board.color_combined(color);
+        let opponent_color = match color {
+            Color::White => Color::Black,
+            Color::Black => Color::White,
+        };
+
+        for sq in pawns {
+            let rank_idx = sq.get_rank().to_index();
+            let file_idx = sq.get_file().to_index();
+
+            // Check files: current, left, right
+            let file_range = file_idx.saturating_sub(1)..=(file_idx + 1).min(7);
+
+            let is_passed = file_range.clone().all(|f| {
+                let file = File::from_index(f);
+                match color {
+                    White => {
+                        // Check ahead of current rank
+                        (rank_idx + 1..=7).all(|r| {
+                            let sq = Square::make_square(Rank::from_index(r), file);
+                            board.piece_on(sq) != Some(Pawn) ||
+                                board.color_on(sq) != Some(opponent_color)
+                        })
+                    }
+                    Black => {
+                        // Check behind current rank
+                        (0..rank_idx).all(|r| {
+                            let sq = Square::make_square(Rank::from_index(r), file);
+                            board.piece_on(sq) != Some(Pawn) ||
+                                board.color_on(sq) != Some(opponent_color)
+                        })
+                    }
+                }
+            });
+
+            if is_passed {
+                score += match color {
+                    White => 15,
+                    Black => -15,
                 };
             }
         }
@@ -93,15 +130,20 @@ pub fn evaluate_board(board: &Board) -> i32 {
     use chess::{ Piece::*, Color::* };
 
     // Fifty-move rule draw
-    if board.halfmove_clock() >= 50 {
+    if board.halfmove_clock() >= 100 {
         return 0;
     }
 
     // Check for checkmate
     if board.status() == chess::BoardStatus::Checkmate {
         return if board.side_to_move() == White { -10_000 } else { 10_000 };
+    } else if board.status() == chess::BoardStatus::Stalemate {
+        return 0;
     }
 
+    let white_base: i32 = board.material_score(chess::Color::White);
+    let black_base = board.material_score(chess::Color::Black);
+
     let mut white_total = 0;
     let mut black_total = 0;
     let mut white_bishops = 0;
@@ -160,9 +202,8 @@ pub fn evaluate_board(board: &Board) -> i32 {
         return 0;
     }
 
-    // Case 2: One side has only king+bishop or king+knight; ignore its score
     let mut score: i32 = 0;
-    let is_endgame = is_endgame(board);
+    let is_endgame = white_base + black_base < 1600;
 
     for sq in chess::ALL_SQUARES {
         if let Some(piece) = board.piece_on(sq) {
@@ -189,22 +230,29 @@ pub fn evaluate_board(board: &Board) -> i32 {
                 }
             };
 
-            let value = base + positional;
-
+            // Case 2: One side has only king+bishop or king+knight; ignore its base score
             if color == White {
                 if !is_minor_or_lone(white_total, white_bishops, white_knights) {
-                    score += value;
+                    score += base;
                 }
+                score += positional;
             } else {
                 if !is_minor_or_lone(black_total, black_bishops, black_knights) {
-                    score -= value;
+                    score -= base;
                 }
+                score -= positional;
             }
         }
     }
 
+    let proximity_score = evaluate_king_proximity(board, is_endgame);
     score += evaluate_connected_pawns(board);
-    score += evaluate_king_proximity(board);
+    score += evaluate_passed_pawns(board);
+    if white_base > black_base {
+        score += proximity_score;
+    } else {
+        score -= proximity_score;
+    }
 
     score
 }

src/bot/algorithm/eval.rs

@@ -5,8 +5,6 @@ use crate::bot::algorithm::eval::evaluate_board;
 use crate::bot::util::lookup::lookup_opening_db;
 use crate::bot::{ include::types::{ EngineState } };
 
-pub const QUIET_SEARCH_DEPTH: u8 = 4;
-
 pub fn search(
     time_left_ms: u128,
     time_limit_ms: Option<u128>,

src/bot/algorithm/root.rs

@@ -31,12 +31,12 @@ fn read_opening_db() -> Result<Value, io::Error> {
         let tar = GzDecoder::new(tar_file);
         let mut archive = Archive::new(tar);
         archive.unpack(output_dir)?;
-        
+
         // Clean up
         fs::remove_file(&compressed_path)?;
         println!("OpeningDB extracted to {:?}", file_path);
     }
-    
+
     // Read and parse JSON
     let file_content = fs::read_to_string(&file_path)?;
     let json_data: Value = serde_json
@@ -123,13 +123,13 @@ impl GlobalMap {
     ];
 
     pub const KING_TABLE_END: [[i32; 8]; 8] = [
-        [-50, -30, -30, -30, -30, -30, -30, -50],
-        [-30, -30, 0, 0, 0, 0, -30, -30],
-        [-30, -10, 20, 30, 30, 20, -10, -30],
-        [-30, -10, 30, 40, 40, 30, -10, -30],
-        [-30, -10, 30, 40, 40, 30, -10, -30],
-        [-30, -10, 20, 30, 30, 20, -10, -30],
-        [-30, -20, -10, 0, 0, -10, -20, -30],
-        [-50, -40, -30, -20, -20, -30, -40, -50],
+        [-25, -23, -20, -20, -20, -20, -23, -25],
+        [-23, -15, -5, -5, -5, -5, -15, -23],
+        [-20, -5, 15, 20, 20, 15, -5, -20],
+        [-20, -5, 20, 25, 25, 20, -5, -20],
+        [-20, -5, 20, 25, 25, 20, -5, -20],
+        [-20, -5, 15, 20, 20, 15, -5, -20],
+        [-23, -15, -5, -5, -5, -5, -15, -23],
+        [-25, -23, -20, -20, -20, -20, -23, -25],
     ];
 }