Refactor based on clippy, move tt to search module and call iterative deepening from uci_go

src/search/transposition_table.rs

@@ -0,0 +1,109 @@
+use crate::{board::zobrist::ZobristHash, movegen::r#move::Move};
+
+pub struct TranspositionTable {
+    positions: Vec<Option<TTEntry>>,
+    size: u64,
+}
+
+impl TranspositionTable {
+    pub fn new(size: u64) -> Self {
+        Self {
+            positions: vec![None; size as usize],
+            size,
+        }
+    }
+
+    pub fn lookup(&self, zobrist_hash: ZobristHash) -> Option<&TTEntry> {
+        let entry = self
+            .positions
+            .get((zobrist_hash.hash % self.size) as usize)
+            .and_then(|entry| entry.as_ref());
+
+        entry
+    }
+
+    pub fn insert(&mut self, tt_entry: TTEntry) {
+        let index = (tt_entry.hash.hash % self.size) as usize;
+
+        if let Some(stored) = &self.positions[index] {
+            if tt_entry.depth > stored.depth || matches!(tt_entry.bound, Bound::Exact) {
+                self.positions[index] = Some(tt_entry);
+            }
+        } else {
+            self.positions[index] = Some(tt_entry);
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct TTEntry {
+    pub hash: ZobristHash,
+    pub depth: u8,
+    pub score: i32,
+    pub mv: Option<Move>,
+    pub bound: Bound,
+}
+
+impl TTEntry {
+    pub const fn new(
+        hash: ZobristHash,
+        depth: u8,
+        score: i32,
+        mv: Option<Move>,
+        bound: Bound,
+    ) -> Self {
+        Self {
+            hash,
+            depth,
+            score,
+            mv,
+            bound,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub enum Bound {
+    Exact,
+    Lower,
+    Upper,
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        board::fen::from_fen,
+        evaluation::{MAX_SCORE, MIN_SCORE},
+        movegen::attack_generator::init_attacks,
+        search::{self, transposition_table::TranspositionTable, MAX_TT_SIZE},
+    };
+
+    const FEN: &str = "1r2k2r/2P1pq1p/2npb3/1p3ppP/p3P3/P2B1Q2/1P1PNPP1/R3K2R w KQk g6 0 1";
+    const FEN_WILL_BE: &str = "1r2k2r/2P1pq1p/2npb3/1B3ppP/p3P3/P4Q2/1P1PNPP1/R3K2R b KQk - 0 1";
+    const FEN_WONT_BE: &str = "1Q2k2r/2P1pq1p/2npb3/1p3ppP/p3P3/P2B4/1P1PNPP1/R3K2R b KQk - 0 1";
+
+    #[test]
+    fn test_transposition_table() -> Result<(), String> {
+        init_attacks();
+        let mut game = from_fen(FEN)?;
+        let mut tt = TranspositionTable::new(MAX_TT_SIZE);
+        let time_now = std::time::Instant::now();
+
+        // fill Transposition Table
+        search::negamax::negamax(&mut game, MIN_SCORE, MAX_SCORE, 4, 0, &mut tt);
+        dbg!(time_now.elapsed());
+
+        let will_be_hash = from_fen(FEN_WILL_BE)?.hash;
+        let tt_entry = tt.lookup(will_be_hash);
+
+        assert!(tt_entry.is_some());
+
+        // needs a bigger tt size because it could be a collision entry
+        let wont_be_hash = from_fen(FEN_WONT_BE)?.hash;
+        let tt_entry = tt.lookup(wont_be_hash);
+
+        assert!(tt_entry.is_none());
+
+        Ok(())
+    }
+}