Pawn Structure + tweaks

Author: LelleSwe

Cargo.lock

@@ -9,5 +9,6 @@ edition = "2021"
 #bevy = { version = "0.11.2", features = ["dynamic_linking"] }
 chess = "3.2.0"
 rand = "0.8.5"
+rustc-hash = "1.1.0"
 tokio = { version = "1.34.0", features = ["full"] }
 # ordered_float = "4.1.1"

Cargo.toml

@@ -1,5 +1,6 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, cmp};
 use tokio::time::{Duration, Instant};
+use rustc_hash::FxHasher;
 
 use chess::{Action, Board, BoardStatus, ChessMove, Color, MoveGen, Piece, BitBoard};
 
@@ -15,6 +16,7 @@ pub(crate) struct Algorithm {
     pub(crate) time_per_move: Duration,
     /// Number of times that a given board has been played
     pub(crate) board_played_times: HashMap<Board, u32>,
+    pub(crate) pawn_hash: HashMap<BitBoard, f32>
 }
 
 impl Algorithm {
@@ -24,6 +26,7 @@ impl Algorithm {
             transposition_table: HashMap::with_capacity(45),
             time_per_move,
             board_played_times: HashMap::new(),
+            pawn_hash: HashMap::new()
         }
     }
 
@@ -40,6 +43,8 @@ impl Algorithm {
         num_extensions: u32,
         board_played_times_prediction: &mut HashMap<Board, u32>,
     ) -> Evaluation {
+
+
         if depth == 0 {
             stats.leaves_visited += 1;
             let eval = self.eval(board, board_played_times_prediction);
@@ -67,14 +72,17 @@ impl Algorithm {
 
             // If we arrive at here and it is checkmate, then we know that the side playing
             // has been checkmated.
-
+             
             best_evaluation.eval = Some(if board.side_to_move() == Color::White {
                 f32::MIN
             } else {
                 f32::MAX
             });
             return best_evaluation;
-        }
+            }
+            
+            //best_evaluation.eval = Some(f32::MIN);
+
 
         let mut boards = legal_moves
             .map(|chess_move| {
@@ -114,6 +122,11 @@ impl Algorithm {
                     (i.saturating_sub(1)) as f32 / num_legal_moves as f32;
                 return best_evaluation;
             };
+
+            if depth > stats.max_depth {
+                stats.max_depth = depth;
+            }
+
             if module_enabled(self.modules, SKIP_BAD_MOVES)
                 && i as f32 > num_legal_moves as f32 * 1.
             {
@@ -159,6 +172,7 @@ impl Algorithm {
                     );
                     evaluation
                 };
+
             stats.nodes_visited += 1;
 
             // Replace best_eval if ours is better
@@ -309,7 +323,7 @@ impl Algorithm {
     }
 
     pub(crate) fn eval(
-        &self,
+        &mut self,
         board: &Board,
         board_played_times_prediction: &HashMap<Board, u32>,
     ) -> f32 {
@@ -351,10 +365,9 @@ impl Algorithm {
                 //Essentially, gets the dot product between a "vector" of the bitboard (containing 64 0s and 1s) and the table with position bonus constants.
                 let mut bonus: f32 = 0.;
                 //Get's the bitboard with all piece positions, and runs bitwise and for the board having one's own colors.
-                let mut piece_board: u64 = (piece_bitboard & color_bitboard).reverse_colors().to_size(0) as u64;
                 for i in 0..63 {
-                    //I'm pretty sure the bitboard and position_table have opposite orientationns. Regardless, flipping the bitboard significantly increased performance.
-                    bonus += (piece_board >> i & 1) as f32 * position_table[i]; 
+                    //The position table and bitboard are flipped vertically, hence .reverse_colors(). Reverse colors is for some reason faster than replacing i with 56-i+2*(i%8).
+                    bonus += ((piece_bitboard & color_bitboard).reverse_colors().to_size(0) >> i & 1) as f32 * position_table[i]; 
                 }
                 return bonus;
             }
@@ -375,12 +388,54 @@ impl Algorithm {
             }
         }
 
-        let evaluation: f32 = controlled_squares as f32 / 20. + diff_material as f32 + position_bonus;
+        let mut pawn_structure: f32 = 0.;
+        if utils::module_enabled(self.modules, modules::PAWN_STRUCTURE) {
+            fn pawn_structure_calc(all_pawn_bitboard: &BitBoard, color_bitboard: &BitBoard, all_king_bitboard: &BitBoard) -> f32 {
+                let mut bonus: f32 = 0.;
+                let pawn_bitboard: usize = (all_pawn_bitboard & color_bitboard).to_size(0);
+                let king_bitboard: usize = (all_king_bitboard & color_bitboard).to_size(0);
+                //pawn chain, awarding 0.5 eval for each pawn protected by another pawn.
+                bonus += 0.5*((pawn_bitboard & (pawn_bitboard << 7)).count_ones() + (pawn_bitboard & (pawn_bitboard << 9)).count_ones()) as f32;
+
+                //stacked pawns. -0.5 points per rank containing >1 pawns. By taking the pawn bitboard and operating bitwise and for another bitboard (integer) where the leftmost rank is filled. This returns 
+                for i in 0..7 {
+                    //constant 9259542123273814144 = 0x8080808080808080, or the entire first rank.
+                    bonus -= 0.5*cmp::max((pawn_bitboard & (0x8080808080808080 >> i)).count_ones() as i64 - 1, 0) as f32;
+                }
+
+                //king safety. Outer 3 pawns get +1 eval bonus per pawn if king is behind them. King position required is either ..X..... or ......X.
+                if (king_bitboard & 0x2).count_ones() > 0 {
+                    bonus += (pawn_bitboard & 0x7).count_ones() as f32;
+                }
+                if (king_bitboard & 0x20).count_ones() > 0 {
+                    bonus += (pawn_bitboard & 0xE000).count_ones() as f32;
+                }
+                return bonus;
+            }
+
+            //Because pawn moves (according to chessprogramming.org) are rarely performed, hashing them is useful.
+            if board.side_to_move() == Color::White {
+                let pawn_bitboard: BitBoard = board.pieces(Piece::Pawn) & board.color_combined(Color::White);
+                if !self.pawn_hash.contains_key(&pawn_bitboard) {
+                    self.pawn_hash.insert(pawn_bitboard, pawn_structure_calc(board.pieces(Piece::Pawn), board.color_combined(Color::White), board.pieces(Piece::King)));
+                }
+                pawn_structure = *self.pawn_hash.get(&pawn_bitboard).unwrap();
+            } else {
+                let pawn_bitboard: BitBoard = board.pieces(Piece::Pawn) & board.color_combined(Color::Black);
+                if !self.pawn_hash.contains_key(&pawn_bitboard) {
+                    self.pawn_hash.insert(pawn_bitboard, pawn_structure_calc(board.pieces(Piece::Pawn), board.color_combined(Color::Black), board.pieces(Piece::King)));
+                }
+                pawn_structure = *self.pawn_hash.get(&pawn_bitboard).unwrap();
+            }
+        }
+
+        let evaluation: f32 = controlled_squares as f32 / 20. + diff_material as f32 + position_bonus + pawn_structure;
         return evaluation
     }
 
     pub(crate) fn reset(&mut self) {
         self.transposition_table = HashMap::new();
         self.board_played_times = HashMap::new();
+        self.pawn_hash = HashMap::new();
     }
 }

src/algorithms/the_algorithm.rs

@@ -6,6 +6,7 @@ pub(crate) mod modules {
     pub(crate) const SQUARE_CONTROL_METRIC: u32 = 0b10000;
     pub(crate) const SKIP_BAD_MOVES: u32 = 0b100000;
     pub(crate) const POSITION_BONUS: u32 = 0b1000000;
+    pub(crate) const PAWN_STRUCTURE: u32 = 0b10000000;
 }
 
 //POSITION_BONUS TABLES
@@ -73,6 +74,6 @@ pub(crate) const position_bonus_table_king: [f32; 64] = [
     0., 0., 0., 0., 0., 0., 0., 0.,
     0., 0., 0., 0., 0., 0., 0., 0.,
     0., 0., 0., 0., 0., 0., 0., 0.,
-    0.1, 0.3, 0.3, 0., 0., 0.3, 0.3, 0.1
+    0.1, 0.3, 0.3, 0., 0., 0., 0.3, 0.1
 ];
 }

src/common/constants.rs

@@ -80,6 +80,7 @@ pub(crate) use vector_push_debug;
 pub(crate) struct Stats {
     pub(crate) alpha_beta_breaks: u32,
     pub(crate) depth: u32,
+    pub(crate) max_depth: u32,
     pub(crate) leaves_visited: u32,
     pub(crate) nodes_visited: u32,
     pub(crate) num_plies: u32,
@@ -95,6 +96,7 @@ impl AddAssign for Stats {
     fn add_assign(&mut self, rhs: Self) {
         self.nodes_visited += rhs.nodes_visited;
         self.depth += rhs.depth;
+        self.max_depth += rhs.max_depth;
         self.leaves_visited += rhs.leaves_visited;
         self.alpha_beta_breaks += rhs.alpha_beta_breaks;
         self.num_plies += rhs.num_plies;
@@ -112,6 +114,7 @@ impl Div<u32> for Stats {
         StatsAverage {
             alpha_beta_breaks: self.alpha_beta_breaks as f32 / rhs as f32,
             depth: self.depth as f32 / rhs as f32,
+            max_depth: self.max_depth as f32 / rhs as f32,
             leaves_visited: self.leaves_visited as f32 / rhs as f32,
             nodes_visited: self.nodes_visited as f32 / rhs as f32,
             num_plies: self.num_plies as f32 / rhs as f32,
@@ -132,6 +135,7 @@ impl Div<u32> for Stats {
 pub(crate) struct StatsAverage {
     pub(crate) alpha_beta_breaks: f32,
     pub(crate) depth: f32,
+    pub(crate) max_depth: f32,
     pub(crate) leaves_visited: f32,
     pub(crate) nodes_visited: f32,
     pub(crate) num_plies: f32,

src/common/utils.rs

@@ -1,9 +1,10 @@
 use std::time::Duration;
 
 use crate::algorithms::the_algorithm::Algorithm;
+#[allow(dead_code)]
 use crate::common::constants::modules::{
     ALPHA_BETA, ANALYZE, SEARCH_EXTENSIONS, SKIP_BAD_MOVES, SQUARE_CONTROL_METRIC,
-    TRANSPOSITION_TABLE, POSITION_BONUS
+    TRANSPOSITION_TABLE, POSITION_BONUS, PAWN_STRUCTURE
 };
 
 use self::pitter::logic::{Competition, GameOutcome};
@@ -14,10 +15,11 @@ mod pitter;
 
 #[tokio::main]
 async fn main() {
-    let modules1 = ALPHA_BETA | POSITION_BONUS;
+    //ALPHA_BETA | ANALYZE | SEARCH_EXTENSIONS | SKIP_BAD_MOVES | SQUARE_CONTROL_METRIC | TRANSPOSITION_TABLE | POSITION_BONUS | PAWN_STRUCTURE
+    let modules1 = ALPHA_BETA | PAWN_STRUCTURE;
     let modules2 = ALPHA_BETA;
-    let time_per_move1 = Duration::from_micros(500);
-    let time_per_move2 = Duration::from_micros(500);
+    let time_per_move1 = Duration::from_micros(12000);
+    let time_per_move2 = Duration::from_micros(12000);
 
     let competition = Competition::new(
         Algorithm::new(modules1, time_per_move1),
@@ -27,6 +29,6 @@ async fn main() {
     // competition.analyze_algorithm_choices(|(game_info, _), _| {
     //     game_info.outcome == GameOutcome::InconclusiveTooLong
     // });
-    let results = competition.start_competition(2000).await;
+    let results = competition.start_competition(500).await;
     dbg!(results);
 }

src/main.rs

@@ -240,8 +240,10 @@ impl Competition {
                     game_pair_info.1.outcome,
                 );
 
+                //Whether the game just played should be printed in console.
                 //println!("Game pair played.  Outcome: {:?}", combined_outcome);
                 //println!("{}", utils::to_pgn(&game_pair_info.0.game.unwrap()));
+
                 results.lock().await.register_game_outcome(combined_outcome);
 
                 let mut locked_stats = sum_stats.lock().await;