Work around hash collision

bdmendes · Dec 25, 2024 · 3c1cb3a · 3c1cb3a
1 parent b44b30a
commit 3c1cb3a
Show file tree

Hide file tree

Showing 12 changed files with 116 additions and 83 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -11,6 +11,7 @@ rand = "0.8.5"
 ctor = "0.2.8"
 rayon = "1.10.0"
 rstest = "0.23.0"
+portable-atomic = "1.10.0"
 
 [profile.dev]
 opt-level = 1

diff --git a/src/core/hash.rs b/src/core/hash.rs
@@ -13,11 +13,11 @@ use super::{
 pub struct ZobristHash(pub u64);
 
 // 2 colors, 6 pieces, 64 squares + 1 color + 4 castling rights + 64 ep squares
-const ZOBRIST_NUMBERS_SIZE: usize = 2 * 6 * 64 + 2 + 4 + 64;
+const ZOBRIST_NUMBERS_SIZE: usize = 2 * 6 * 64 + 1 + 4 + 64;
 
 #[ctor]
 static ZOBRIST_NUMBERS: [ZobristHash; ZOBRIST_NUMBERS_SIZE] = {
-    let mut rng = StdRng::seed_from_u64(0);
+    let mut rng = StdRng::seed_from_u64(42);
     let mut numbers = [0; ZOBRIST_NUMBERS_SIZE];
     numbers.iter_mut().take(ZOBRIST_NUMBERS_SIZE).for_each(|n| *n = rng.gen());
     numbers.map(ZobristHash)

diff --git a/src/core/mod.rs b/src/core/mod.rs
@@ -267,6 +267,13 @@ impl Position {
         generate_moves(self, stage)
     }
 
+    pub fn is_legal(&mut self) -> bool {
+        self.flip_side_to_move();
+        let res = !self.is_check();
+        self.flip_side_to_move();
+        res
+    }
+
     pub fn make_move(&self, mov: Move) -> Self {
         make_move::<true>(self, mov)
     }
@@ -276,12 +283,6 @@ impl Position {
         for m in moves {
             if mov == m.to_string().as_str() {
                 let new_position = self.make_move(m);
-                /*println!(
-                    "hash after {}: {} {}",
-                    mov,
-                    new_position.hash().0,
-                    new_position.hash_from_scratch().0
-                );*/
                 return Some(new_position);
             }
         }

diff --git a/src/core/moves/gen/mod.rs b/src/core/moves/gen/mod.rs
@@ -11,11 +11,11 @@ use magics::{bishop_attacks, queen_attacks, rook_attacks};
 use pawns::{pawn_attackers, pawn_moves, PAWN_ATTACKS_BLACK, PAWN_ATTACKS_WHITE};
 use sliders::{bishop_moves, diagonal_attackers, file_attackers, queen_moves, rook_moves};
 
-mod castle;
-mod leapers;
-mod magics;
-mod pawns;
-mod sliders;
+pub mod castle;
+pub mod leapers;
+pub mod magics;
+pub mod pawns;
+pub mod sliders;
 
 pub fn generate_moves(position: &Position, stage: MoveStage) -> Vec<Move> {
     let mut moves = Vec::with_capacity(match stage {

diff --git a/src/core/moves/make.rs b/src/core/moves/make.rs
@@ -3,7 +3,7 @@ use crate::core::{
     Position,
 };
 
-use super::{Move, MoveFlag};
+use super::{gen::pawns::pawn_attackers, Move, MoveFlag};
 
 static COLOR_CASTLE_RANKS: [Bitboard; 2] = [Bitboard::rank_mask(0), Bitboard::rank_mask(7)];
 static TO_SQUARE_KINGSIDE: [Square; 2] = [Square::G1, Square::G8];
@@ -39,7 +39,9 @@ fn make_castle<const UPDATE_META: bool>(
 
 pub fn make_move<const UPDATE_META: bool>(position: &Position, mov: Move) -> Position {
     let mut position = *position;
-
+    if position.piece_at(mov.from()).is_none() {
+        panic!("m: {}", mov);
+    }
     let piece = position.piece_at(mov.from()).unwrap();
     let side_to_move = position.side_to_move();
 
@@ -72,6 +74,7 @@ pub fn make_move<const UPDATE_META: bool>(position: &Position, mov: Move) -> Pos
             ));
         }
         MoveFlag::Quiet | MoveFlag::DoublePawnPush => {
+            // NOTICE: clear should not be needed here. This is a workaround for hash collisions.
             position.set_square_low::<UPDATE_META, true>(mov.to(), piece, side_to_move);
         }
         MoveFlag::Capture => {
@@ -131,10 +134,15 @@ pub fn make_move<const UPDATE_META: bool>(position: &Position, mov: Move) -> Pos
     });
 
     if mov.flag() == MoveFlag::DoublePawnPush {
-        position.set_ep_square(match side_to_move {
+        let candidate_ep = match side_to_move {
             Color::White => mov.to() >> 8,
             Color::Black => mov.to() << 8,
-        });
+        };
+        if !pawn_attackers(&position, side_to_move.flipped(), candidate_ep).is_empty() {
+            position.set_ep_square(candidate_ep);
+        } else {
+            position.clear_ep_square();
+        }
     } else {
         position.clear_ep_square();
     };
@@ -172,6 +180,11 @@ mod tests {
         "e1d1",
         "r3k2r/8/3Q4/8/8/8/8/R2K3R b kq - 0 2"
     )]
+    #[case(
+        "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
+        "e2e4",
+        "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1"
+    )]
     fn make(#[case] position: &str, #[case] mov: &str, #[case] expected: &str) {
         let position = Position::from_str(position).unwrap();
         let moves = position.moves(MoveStage::All);

diff --git a/src/core/moves/mod.rs b/src/core/moves/mod.rs
@@ -77,19 +77,18 @@ impl Move {
     }
 
     pub fn is_pseudo_legal(&self, position: &Position) -> bool {
-        let from_piece_color = position.piece_color_at(self.from());
         let to_color = position.color_at(self.to());
         let to_piece = position.piece_at(self.to());
 
-        if let Some((piece, color)) = from_piece_color {
+        if let Some((piece, color)) = position.piece_color_at(self.from()) {
             // Basic legality assumptions. This is a good and fast start,
             // but not sufficient.
             if color != position.side_to_move
                 || (to_color == Some(position.side_to_move) && !self.is_castle())
                 || to_piece == Some(Piece::King)
                 || (self.is_capture()
                     && self.flag() != MoveFlag::EnpassantCapture
-                    && to_piece.is_none())
+                    && to_color != Some(position.side_to_move.flipped()))
             {
                 return false;
             }

diff --git a/src/engine/commands/executor.rs b/src/engine/commands/executor.rs
@@ -191,7 +191,6 @@ pub fn execute_do_move(mov_str: &str, position: &mut Position) {
 
 pub fn execute_display(position: &Position) {
     print!("{}", position);
-    println!("{}", position.fen());
     println!("Static evaluation: {}", position.value());
     println!("Chess960: {}", position.is_chess_960());
     println!(

diff --git a/src/evaluation/moves.rs b/src/evaluation/moves.rs
@@ -7,7 +7,9 @@ use crate::{
 
 pub fn evaluate_move(position: &Position, mov: Move) -> ValueScore {
     let mut score = 0;
-
+    if position.piece_at(mov.from()).is_none() {
+        panic!("m: {}", mov);
+    }
     let moving_piece = position.piece_at(mov.from()).unwrap();
 
     if mov.is_capture() {

diff --git a/src/search/movepick.rs b/src/search/movepick.rs
@@ -4,7 +4,7 @@ use crate::{
     evaluation::{moves::evaluate_move, Evaluable, ValueScore},
 };
 use rand::{thread_rng, Rng};
-use std::sync::Arc;
+use std::{sync::Arc, thread::panicking};
 
 type ScoredVec<Move> = Vec<(Move, ValueScore)>;
 
@@ -28,7 +28,12 @@ impl MovePicker<true> {
         });
         Self {
             index: 0,
-            moves: decorate_moves_with_score(&moves, |mov| evaluate_move(position, mov)),
+            moves: decorate_moves_with_score(&moves, |mov| {
+                if mov.to_string().as_str() == "a1c1=N" || mov.to_string().as_str() == "a1g1=N" {
+                    panic!("p2: {}", position.fen());
+                }
+                evaluate_move(position, mov)
+            }),
             stage: MoveStage::CapturesAndPromotions,
             position: *position,
             table: None,
@@ -85,7 +90,14 @@ impl std::iter::Iterator for MovePicker<false> {
                 self.stage = MoveStage::CapturesAndPromotions;
                 self.moves = decorate_moves_with_score(
                     &self.position.moves(MoveStage::CapturesAndPromotions),
-                    |mov| evaluate_move(&self.position, mov),
+                    |mov| {
+                        if mov.to_string().as_str() == "a1c1=N"
+                            || mov.to_string().as_str() == "a1g1=N"
+                        {
+                            panic!("p4: {}", self.position.fen());
+                        }
+                        evaluate_move(&self.position, mov)
+                    },
                 );
 
                 self.index = 0;
@@ -100,6 +112,11 @@ impl std::iter::Iterator for MovePicker<false> {
                     if killers[1] == Some(mov) || killers[0] == Some(mov) {
                         Piece::Queen.value()
                     } else {
+                        if mov.to_string().as_str() == "a1c1=N"
+                            || mov.to_string().as_str() == "a1g1=N"
+                        {
+                            panic!("p6: {}", self.position.fen());
+                        }
                         evaluate_move(&self.position, mov)
                     }
                 });

diff --git a/src/search/pvs.rs b/src/search/pvs.rs
@@ -222,13 +222,13 @@ fn pvs<const ROOT: bool, const MAIN_THREAD: bool, const ALLOW_NMR: bool>(
             }
         }
 
+        let mut new_position = position.make_move(mov);
+
         // Late move reduction: we assume our move ordering is good, and are less interested in
         // expected non-PV nodes.
         let late_move_reduction =
             if depth > 2 && !is_check && mov.is_quiet() && i > 0 { 1 } else { 0 };
 
-        let mut new_position = position.make_move(mov);
-
         history.visit_position(&new_position, mov.is_reversible());
         let (score, nodes) = pvs_recurse::<MAIN_THREAD>(
             &mut new_position,