114 lines
2.9 KiB
Rust
114 lines
2.9 KiB
Rust
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::{
|
|
negamax::negamax, time::TimeInfo, transposition_table::TranspositionTable, MAX_TT_SIZE,
|
|
},
|
|
};
|
|
|
|
const FEN: &str = "1r2k2r/2P1pq1p/2npb3/1p3ppP/p3P3/P2B1Q2/1P1PNPP1/R3K2R w KQk g6 0 1";
|
|
const FEN_POSSIBLE: &str = "1r2k2r/2P1pq1p/2npb3/1B3ppP/p3P3/P4Q2/1P1PNPP1/R3K2R b KQk - 0 1";
|
|
const FEN_IMPOSSIBLE: &str = "1Q2k2r/2P1pq1p/2npb3/1p3ppP/p3P3/P2B4/1P1PNPP1/R3K2R b KQk - 0 1";
|
|
|
|
#[test]
|
|
fn test_transposition_table() -> anyhow::Result<()> {
|
|
init_attacks();
|
|
let mut game = from_fen(FEN).unwrap();
|
|
let mut tt = TranspositionTable::new(MAX_TT_SIZE);
|
|
let time_info = TimeInfo::new(std::time::Instant::now(), 30000);
|
|
|
|
negamax(&mut game, MIN_SCORE, MAX_SCORE, 3, 0, &time_info, &mut tt)
|
|
.expect("Expected a search result")
|
|
.best_move
|
|
.expect("Expected a move");
|
|
|
|
dbg!(time_info.time.elapsed());
|
|
|
|
let will_be_hash = from_fen(FEN_POSSIBLE).unwrap().hash;
|
|
let tt_entry = tt.lookup(will_be_hash);
|
|
|
|
assert!(tt_entry.is_some());
|
|
|
|
let wont_be_hash = from_fen(FEN_IMPOSSIBLE).unwrap().hash;
|
|
let tt_entry = tt.lookup(wont_be_hash);
|
|
|
|
assert!(tt_entry.is_none());
|
|
|
|
Ok(())
|
|
}
|
|
}
|