fix: fixed some bugs with zobrist hashing and ep/castling

refactor: adjusted API for zobrist hashing

brogle/src/engine.rs

@@ -16,7 +16,7 @@ use threadpool::ThreadPool;
 
 use super::{
     protocols::{UciCommand, UciEngine, UciOption, UciResponse, UciSearchOptions},
-    search::{Search, SearchResult},
+    search::{SearchResult, Searcher},
     Evaluator,
 };
 
@@ -29,6 +29,26 @@ enum EngineProtocol {
     Uci,
 }
 
+/*
+pub enum ScoreBound {
+    // The score is exact
+    Exact,
+    /// The score is less than alpha
+    Upper,
+    /// The score is greater than or equal to beta
+    Lower,
+}
+
+pub struct TranspositionTableEntry {
+    key: u64,
+    bestmove: Move,
+    depth: usize,
+    score: i32,
+    score_bound: ScoreBound,
+    age: usize,
+}
+ */
+
 /// A chess engine responds to inputs (such as from a GUI or terminal) and
 /// responds with computed outputs. The most common modern protocol is UCI.
 ///
@@ -597,7 +617,7 @@ impl UciEngine for Engine {
                 let cloned_result = Arc::clone(&result);
 
                 // Start the search
-                let search = Search::new(
+                let search = Searcher::new(
                     &game,
                     timeout,
                     cloned_stopper,

brogle/src/lib.rs

@@ -2,8 +2,8 @@ pub mod engine;
 pub use engine::*;
 
 pub mod search {
-    pub mod search_utils;
-    pub use search_utils::*;
+    pub mod searcher;
+    pub use searcher::*;
 }
 
 pub mod eval {

brogle/src/protocols/uci.rs

@@ -830,19 +830,15 @@ pub trait UciEngine {
     /// score [cp <x> | mate <y> | lowerbound | upperbound]
     /// ```
     ///
-    ///   - `cp <x>`
-    /// The score from the engine's point of view in centipawns.
+    ///   - `cp <x>` - The score from the engine's point of view in centipawns.
     ///
-    ///   - `mate <y>`
-    /// Mate in `y` moves, not plies.
+    ///   - `mate <y>` - Mate in `y` moves, not plies.
     ///
     /// If the engine is getting mated, use negative values for `y`.
     ///
-    ///   - `lowerbound`
-    /// The score is just a lower bound.
+    ///   - `lowerbound` - The score is just a lower bound.
     ///
-    ///   - `upperbound`
-    /// The score is just an upper bound.
+    ///   - `upperbound` - The score is just an upper bound.
     ///
     /// ```text
     /// currmove <move>
@@ -1597,19 +1593,13 @@ pub struct UciInfo {
     /// score [cp <x> | mate <y> | lowerbound | upperbound]
     /// ```
     ///
-    ///   - `cp <x>`
-    /// The score from the engine's point of view in centipawns.
-    ///
-    ///   - `mate <y>`
-    /// Mate in `y` moves, not plies.
+    ///   - `cp <x>` - The score from the engine's point of view in centipawns.
+    ///   - `mate <y>` - Mate in `y` moves, not plies.
     ///
     /// If the engine is getting mated, use negative values for `y`.
     ///
-    ///   - `lowerbound`
-    /// The score is just a lower bound.
-    ///
-    ///   - `upperbound`
-    /// The score is just an upper bound.
+    ///   - `lowerbound` - The score is just a lower bound.
+    ///   - `upperbound` - The score is just an upper bound.
     pub score: Option<String>,
 
     /// ```text

brogle/src/search/search_utils.rs → brogle/src/search/searcher.rs

@@ -2,7 +2,6 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::Sender;
 use std::sync::{Arc, RwLock};
 use std::time::Duration;
-use std::usize;
 use std::{ops::Neg, time::Instant};
 
 use anyhow::{bail, Result};
@@ -84,7 +83,7 @@ impl Default for SearchData {
 }
 
 /// A struct to encapsulate the logic of searching through moves for a given a chess position.
-pub struct Search<'a> {
+pub struct Searcher<'a> {
     game: &'a Game,
     timeout: Duration,
     stopper: Arc<AtomicBool>,
@@ -101,7 +100,7 @@ pub struct Search<'a> {
      */
 }
 
-impl<'a> Search<'a> {
+impl<'a> Searcher<'a> {
     /// Create a new search that will search the provided position at a depth of 1.
     pub fn new(
         game: &'a Game,

brogle_core/brogle_types/src/magicgen.rs

@@ -13,9 +13,10 @@ struct MagicEntry {
 fn magic_index(entry: &MagicEntry, blockers: Bitboard) -> usize {
     let blockers = blockers.0 & entry.mask;
     let hash = blockers.wrapping_mul(entry.magic);
-    let index = (hash >> entry.shift) as usize;
+    // let index = (hash >> entry.shift) as usize;
     // entry.offset + index
-    index
+    // index
+    (hash >> entry.shift) as usize
 }
 
 // #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -111,7 +112,7 @@ fn find_and_print_all_magics(slider: &SlidingPiece, piece_name: &str) {
     let mut table_size = 0;
 
     for tile in Tile::iter() {
-        let index_bits = slider.blockers(tile).population() as u8;
+        let index_bits = slider.blockers(tile).population();
         let (entry, table) = find_magic(slider, tile, index_bits);
 
         println!(

brogle_core/brogle_types/src/tile.rs

@@ -21,7 +21,7 @@ use super::{Bitboard, Color};
 ///
 /// This bit pattern is also known as [Least Significant File Mapping](https://www.chessprogramming.org/Square_Mapping_Considerations#Deduction_on_Files_and_Ranks),
 /// so `tile = file + rank * 8`.
-#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Default)]
 #[repr(transparent)]
 pub struct Tile(pub(crate) u8);
 
@@ -695,7 +695,7 @@ impl fmt::Debug for Tile {
     }
 }
 
-#[derive(Clone, Copy, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct Rank(pub(crate) u8);
 
@@ -836,6 +836,11 @@ impl Rank {
         }
     }
 
+    /// `const` analog of `==`.
+    pub const fn is(&self, other: &Self) -> bool {
+        self.0 == other.0
+    }
+
     // Index in Little Endian (default)
     pub const fn index_le(&self) -> usize {
         self.0 as usize
@@ -1053,7 +1058,7 @@ impl fmt::Debug for Rank {
     }
 }
 
-#[derive(Clone, Copy, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, Eq, PartialOrd, Ord, Hash, Default)]
 pub struct File(pub(crate) u8);
 
 impl File {
@@ -1131,6 +1136,11 @@ impl File {
         Self::new(file_int)
     }
 
+    /// `const` analog of `==`.
+    pub const fn is(&self, other: &Self) -> bool {
+        self.0 == other.0
+    }
+
     pub const fn inner(&self) -> u8 {
         self.0
     }

brogle_core/src/main.rs

@@ -15,13 +15,26 @@ fn main() {
     println!("pos: {}\nkey: {}", game.position(), game.key());
      */
 
-    let mut game = Game::default();
-    game.make_move(Move::from_uci(&game, "b1a3").unwrap());
-    println!("repetition? {}", game.is_repetition());
-    game.make_move(Move::from_uci(&game, "b8a6").unwrap());
-    println!("repetition? {}", game.is_repetition());
-    game.make_move(Move::from_uci(&game, "a3b1").unwrap());
-    println!("repetition? {}", game.is_repetition());
-    game.make_move(Move::from_uci(&game, "a6b8").unwrap());
-    println!("repetition? {}", game.is_repetition());
+    // let fen = FEN_STARTPOS;
+    // let moves = ["b1a3", "b8a6", "a3b1", "a6b8"];
+    // let fen = "k7/8/8/8/3p4/8/4P3/K7 w - - 0 1"; // Testing hash keys with en passant
+    // let moves = ["e2e4", "d4e3"];
+    let fen = "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1";
+    let moves = ["e1g1"];
+    let mut game = Game::from_fen(fen).unwrap();
+
+    for mv in moves {
+        game.make_move(Move::from_uci(&game, mv).unwrap());
+        // println!("repetition? {}", game.is_repetition());
+    }
+
+    // let mut game = Game::default();
+    // game.make_move(Move::from_uci(&game, "b1a3").unwrap());
+    // println!("repetition? {}", game.is_repetition());
+    // game.make_move(Move::from_uci(&game, "b8a6").unwrap());
+    // println!("repetition? {}", game.is_repetition());
+    // game.make_move(Move::from_uci(&game, "a3b1").unwrap());
+    // println!("repetition? {}", game.is_repetition());
+    // game.make_move(Move::from_uci(&game, "a6b8").unwrap());
+    // println!("repetition? {}", game.is_repetition());
 }