109 lines
2.6 KiB
Rust
109 lines
2.6 KiB
Rust
use crate::movegen::r#move::Move;
|
|
|
|
use super::zobrist::ZobristHash;
|
|
|
|
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, transposition_table::TranspositionTable},
|
|
evaluation::{MAX_SCORE, MIN_SCORE},
|
|
movegen::attack_generator::init_attacks,
|
|
search,
|
|
};
|
|
|
|
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(1000000);
|
|
|
|
// fill Transposition Table
|
|
search::negamax::negamax(&mut game, MIN_SCORE, MAX_SCORE, 2, 0, &mut tt);
|
|
|
|
let will_be_hash = from_fen(FEN_WILL_BE)?.hash;
|
|
let tt_entry = tt.lookup(will_be_hash);
|
|
|
|
assert!(tt_entry.is_some());
|
|
|
|
let wont_be_hash = from_fen(FEN_WONT_BE)?.hash;
|
|
let tt_entry = tt.lookup(wont_be_hash);
|
|
|
|
assert!(tt_entry.is_none());
|
|
|
|
Ok(())
|
|
}
|
|
}
|