better threefold prevention

Author: andtsa

src/engine/evaluation/material.rs

@@ -60,6 +60,17 @@ pub fn material(board: &Board, side: Color, interp: Interp) -> Value {
     let side_board = board.color_combined(side);
     for (idx, piece) in MAT_PIECE_TYPES.iter().enumerate() {
         let count = board.pieces(*piece).bitand(side_board).popcnt();
+        // let blocked = if side == board.side_to_move() {
+        //     board.pieces(*piece).bitand(board.pinned()).popcnt()
+        // } else {
+        //     board
+        //         .null_move()
+        //         .map(|b| b.pieces(*piece).bitand(b.pinned()).popcnt())
+        //         // .unwrap_or(0)
+        //         .unwrap_or(board.color_combined(!side).popcnt())
+        // };
+        // let adj = count.saturating_add(count).saturating_sub(blocked).checked_shr(1).
+        // unwrap_or_default();
         value += (INITIAL_VALUES[idx] * Value::from(count)) * interp.0;
         value += (MIDGAME_VALUES[idx] * Value::from(count)) * interp.1;
         value += (ENDGAME_VALUES[idx] * Value::from(count)) * interp.2;

src/engine/evaluation/position.rs

@@ -1,8 +1,10 @@
 //! evaluating the positions of the pieces on the board
 use std::ops::BitAnd;
 
+use chess::BitBoard;
 use chess::Board;
 use chess::Color;
+use chess::Piece;
 use chess::Square;
 
 use crate::evaluation::Interp;
@@ -11,6 +13,11 @@ use crate::evaluation::bitboards::MG_PESTO_TABLE;
 use crate::evaluation::bitboards::POS_PIECE_TYPES;
 use crate::setup::values::Value;
 
+/// bitboard of dark squares
+const DARK_SQUARES: BitBoard = BitBoard(0xAA55AA55AA55AA55);
+/// bitboard of light squares
+const LIGHT_SQUARES: BitBoard = BitBoard(0x55AA55AA55AA55AA);
+
 /// returns the benefit this side has from its pieces' positions
 pub fn piece_position_benefit_for_side(pos: &Board, color: Color, interp: Interp) -> Value {
     let mut value = Value::ZERO;
@@ -48,6 +55,23 @@ pub fn sq_pi(sq: Square, color: Color) -> (usize, usize) {
     (rank, file)
 }
 
+/// check how much are my bishops blocked by other pieces.
+///
+/// issue: engine sacks bishops to minimise penalty
+#[allow(dead_code)]
+pub fn bishop_penalty(pos: &Board, side: Color) -> Value {
+    let bishop_squares = pos.pieces(Piece::Bishop) & pos.color_combined(side);
+    let mut penalty = Value::ZERO;
+
+    let dark_bishops = bishop_squares.bitand(DARK_SQUARES);
+    let light_bishops = bishop_squares.bitand(LIGHT_SQUARES);
+
+    penalty += Value::from((pos.combined() & DARK_SQUARES).popcnt() * dark_bishops.popcnt());
+    penalty += Value::from((pos.combined() & LIGHT_SQUARES).popcnt() * light_bishops.popcnt());
+
+    penalty
+}
+
 #[cfg(test)]
 #[path = "tests/positions.rs"]
 mod tests;

src/engine/position.rs

@@ -27,10 +27,10 @@ impl Position {
 
     /// check whether this position, if added to the engine history, will cause
     /// a draw by threefold repetition
-    pub fn causes_threefold(&self, history: &[Position]) -> bool {
+    pub fn causes_threefold(&self, history: &[u64]) -> bool {
         history
             .iter()
-            .filter(|p| p.chessboard.eq(&self.chessboard))
+            .filter(|p| **p == self.chessboard.get_hash())
             .count()
             >= 2
     }

src/engine/search/main_search.rs

@@ -56,7 +56,12 @@ impl Engine {
 
         let tt = self.table.get();
 
-        let engine_history = self.history.make_contiguous().to_vec();
+        let engine_history = self
+            .history
+            .make_contiguous()
+            .iter_mut()
+            .map(|p| p.chessboard.get_hash())
+            .collect::<Vec<_>>();
 
         thread::spawn(move || {
             let mut best_move: Option<ChessMove> = None;
@@ -75,6 +80,14 @@ impl Engine {
 
             let initial_options = SearchOptions {
                 extensions: Depth::ZERO,
+                history: [
+                    *engine_history.first().unwrap_or(&0),
+                    *engine_history.get(1).unwrap_or(&0),
+                    *engine_history.get(2).unwrap_or(&0),
+                    *engine_history.get(3).unwrap_or(&0),
+                    *engine_history.get(4).unwrap_or(&0),
+                    *engine_history.get(5).unwrap_or(&0),
+                ],
             };
 
             // SAFETY: if it fails it's due to poison,

src/engine/search/mod.rs

@@ -109,6 +109,9 @@ pub struct SearchOptions {
     /// how many times have we already extended the search? this is necessary to
     /// ensure the recursion terminates, and to prevent stack overflow.
     pub extensions: Depth,
+
+    /// previously played position that would cause draw by threefold repetition
+    pub history: [u64; 6],
 }
 
 /// wrapper around [`SEARCH_UNTIL`]

src/engine/search/negamax.rs

@@ -106,10 +106,28 @@ pub fn negamax(
 
     optlog!(search;trace;"ng: {pos}, td: {to_depth:?}, a: {alpha:?}, b: {beta:?}");
 
+    let current_hash = pos.chessboard.get_hash();
+    if search_options
+        .history
+        .iter()
+        .filter(|x| **x == current_hash)
+        .count()
+        >= 2
+    {
+        // threefold repetition
+        let ev = evaluate(&pos, true);
+        return SearchResult {
+            pv: vec![],
+            next_position_value: ev,
+            nodes_searched: 1,
+            tb_hits: 0,
+            depth: ONE_PLY,
+        };
+    }
+
     /* source: https://en.wikipedia.org/wiki/Negamax */
     let alpha_orig = alpha;
     if opts.use_tt {
-        let current_hash = pos.chessboard.get_hash(); // change
         if let Ok(Some(tt_entry)) = table.read().map(|l| l.get(current_hash)) {
             if tt_entry.is_valid() {
                 if tt_entry.depth() >= to_depth {
@@ -161,11 +179,13 @@ pub fn negamax(
         // if theres 3 moves or less, search +1 level deeper
     };
 
+    search_options.history.rotate_left(1);
+    search_options.history[5] = current_hash;
     search_options = SearchOptions {
         extensions: search_options
             .extensions
             .max(search_options.extensions + next_depth + 1 - to_depth),
-        // ..search_options
+        history: search_options.history,
     };
 
     let mut best = None;

src/engine/search/tests/negatest.rs

@@ -24,11 +24,11 @@ use crate::util::short_benches;
 fn startpos_is_positive() {
     let pos = Board::default();
     SEARCHING.store(true, Ordering::Relaxed);
+    let val = ng_test(pos, Depth(4), Value::MIN, Value::MAX, Opts::new()).unwrap();
     assert!(
-        ng_test(pos, Depth(4), Value::MIN, Value::MAX, Opts::new())
-            .unwrap()
-            .next_position_value
-            > Value::ZERO
+        val.next_position_value > Value::ZERO,
+        "startpos was {}",
+        val.next_position_value
     );
 }