README.md

@@ -9,8 +9,6 @@ Features:
     - Tapered midgame-endgame evaluation
 - UCI compatibility
 - Iterative deepening
-- Transposition table (Zobrist hashing)
-    - Currently only stores best move.
 
 ## instructions
 

rust-toolchain.toml

@@ -1,2 +0,0 @@
-[toolchain]
-channel = "beta-2024-11-17"

src/bin/engine.rs

@@ -15,12 +15,12 @@ Copyright © 2024 dogeystamp <dogeystamp@disroot.org>
 use chess_inator::eval::eval_metrics;
 use chess_inator::fen::FromFen;
 use chess_inator::movegen::{FromUCIAlgebraic, Move, ToUCIAlgebraic};
-use chess_inator::search::{best_line, InterfaceMsg, SearchEval, TranspositionTable};
+use chess_inator::search::{best_line, InterfaceMsg, SearchEval};
 use chess_inator::Board;
 use std::io;
 use std::sync::mpsc::channel;
 use std::thread;
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 /// UCI protocol says to ignore any unknown words.
 ///
@@ -90,7 +90,7 @@ fn cmd_position(mut tokens: std::str::SplitWhitespace<'_>) -> Board {
 }
 
 /// Play the game.
-fn cmd_go(mut _tokens: std::str::SplitWhitespace<'_>, board: &mut Board, cache: &mut Option<TranspositionTable>) {
+fn cmd_go(mut _tokens: std::str::SplitWhitespace<'_>, board: &mut Board) {
     // interface-to-engine
     let (tx1, rx) = channel();
     let tx2 = tx1.clone();
@@ -101,7 +101,7 @@ fn cmd_go(mut _tokens: std::str::SplitWhitespace<'_>, board: &mut Board, cache:
         let _ = tx2.send(InterfaceMsg::Stop);
     });
 
-    let (line, eval) = best_line(board, None, Some(rx), cache);
+    let (line, eval) = best_line(board, None, Some(rx));
 
     let chosen = line.last().copied();
     println!(
@@ -133,7 +133,6 @@ fn main() {
     let stdin = io::stdin();
 
     let mut board = Board::starting_pos();
-    let mut transposition_table = Some(TranspositionTable::new(24));
 
     loop {
         let mut line = String::new();
@@ -157,7 +156,7 @@ fn main() {
                     board = cmd_position(tokens);
                 }
                 "go" => {
-                    cmd_go(tokens, &mut board, &mut transposition_table);
+                    cmd_go(tokens, &mut board);
                 }
                 // non-standard command.
                 "eval" => {

src/eval.rs

@@ -377,8 +377,7 @@ pub fn eval_metrics(board: &Board) -> EvalMetrics {
         .map_or(0, |(k1, k2)| k1.manhattan(k2));
 
     // attempt to minimize king distance for checkmates
-    let king_distance_eval =
+    let king_distance_eval = -advantage * i32::try_from(king_distance).unwrap() * max(7 - phase, 0) / 100;
-        -advantage * i32::try_from(king_distance).unwrap() * max(7 - phase, 0) / 100;
 
     let eval = pst_eval + king_distance_eval;
 

src/fen.rs

@@ -11,8 +11,8 @@ You should have received a copy of the GNU General Public License along with che
 Copyright © 2024 dogeystamp <dogeystamp@disroot.org>
 */
 
-use crate::hash::Zobrist;
 use crate::{Board, ColPiece, Color, Square, SquareIdx, BOARD_HEIGHT, BOARD_WIDTH};
+use crate::hash::Zobrist;
 
 pub const START_POSITION: &str = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
 

src/hash.rs

@@ -13,24 +13,22 @@ Copyright © 2024 dogeystamp <dogeystamp@disroot.org>
 
 //! Zobrist hash implementation.
 
-use crate::random::Pcg64Random;
+use crate::random::{random_arr_2d_64, random_arr_64};
 use crate::{
     Board, CastleRights, ColPiece, Color, Square, BOARD_WIDTH, N_COLORS, N_PIECES, N_SQUARES,
 };
-use std::ops::Index;
-use std::ops::IndexMut;
 
 const PIECE_KEYS: [[[u64; N_SQUARES]; N_PIECES]; N_COLORS] =
-    [Pcg64Random::new(11).random_arr_2d_64(), Pcg64Random::new(22).random_arr_2d_64()];
+    [random_arr_2d_64(11), random_arr_2d_64(22)];
 
 // 4 bits in castle perms -> 16 keys
-const CASTLE_KEYS: [u64; 16] = Pcg64Random::new(33).random_arr_64();
+const CASTLE_KEYS: [u64; 16] = random_arr_64(33);
 
 // ep can be specified by the file
-const EP_KEYS: [u64; BOARD_WIDTH] = Pcg64Random::new(44).random_arr_64();
+const EP_KEYS: [u64; BOARD_WIDTH] = random_arr_64(44);
 
 // current turn
-const COL_KEY: [u64; N_COLORS] = Pcg64Random::new(55).random_arr_64();
+const COL_KEY: [u64; N_COLORS] = random_arr_64(55);
 
 /// Zobrist hash state.
 ///
@@ -81,60 +79,6 @@ impl Zobrist {
         pos.zobrist.toggle_castle(&pos.castle);
         pos.zobrist.toggle_turn(pos.turn);
     }
-
-    /// Convert hash to an index.
-    fn truncate_hash(&self, size: usize) -> usize {
-        (self.hash & ((1 << size) - 1)) as usize
-    }
-}
-
-/// Map that takes Zobrist hashes as keys.
-///
-/// Heap allocated (it's a vector).
-#[derive(Debug)]
-pub struct ZobristTable<T> {
-    data: Vec<(Zobrist, Option<T>)>,
-    size: usize,
-}
-
-impl<T: Copy> ZobristTable<T> {
-    /// Create a table with 2^n entries.
-    pub fn new(size: usize) -> Self {
-        assert!(size <= 27, "Attempted to make 2^{size} entry table; aborting to avoid excessive memory usage.");
-        ZobristTable {
-            data: vec![(Zobrist { hash: 0 }, None); 1 << size],
-            size,
-        }
-    }
-}
-
-impl<T> IndexMut<Zobrist> for ZobristTable<T> {
-    fn index_mut(&mut self, zobrist: Zobrist) -> &mut Self::Output {
-        let idx = zobrist.truncate_hash(self.size);
-        if self.data[idx].0 == zobrist {
-            &mut self.data[idx].1
-        } else {
-            // miss, overwrite
-            self.data[idx].0 = zobrist;
-            self.data[idx].1 = None;
-            &mut self.data[idx].1
-        }
-    }
-}
-
-impl<T> Index<Zobrist> for ZobristTable<T> {
-    type Output = Option<T>;
-
-    fn index(&self, zobrist: Zobrist) -> &Self::Output {
-        let idx = zobrist.truncate_hash(self.size);
-        let data = &self.data[idx];
-        if data.0 == zobrist {
-            &data.1
-        } else {
-            // miss
-            &None
-        }
-    }
 }
 
 #[cfg(test)]
@@ -143,7 +87,7 @@ mod tests {
     use crate::fen::FromFen;
     use crate::movegen::{FromUCIAlgebraic, Move};
 
-    /// Zobrist hashes, and transposition table elements of the same positions should be the same. (basic sanity test)
+    /// Zobrist hashes of the same positions should be the same. (basic sanity test)
     #[test]
     fn test_zobrist_equality() {
         let test_cases = [
@@ -170,71 +114,16 @@ mod tests {
         ];
         for (pos1_fen, pos2_fen, mv_uci) in test_cases {
             eprintln!("tc: {}", pos1_fen);
-            let mut table = ZobristTable::<usize>::new(4);
             let mut pos1 = Board::from_fen(pos1_fen).unwrap();
             let hash1_orig = pos1.zobrist;
-            assert_eq!(table[pos1.zobrist], None);
-            table[pos1.zobrist] = Some(100);
             eprintln!("refreshing board 2 '{}'", pos2_fen);
             let pos2 = Board::from_fen(pos2_fen).unwrap();
-            table[pos2.zobrist] = Some(200);
             eprintln!("making mv {}", mv_uci);
             let mv = Move::from_uci_algebraic(mv_uci).unwrap();
             let anti_mv = mv.make(&mut pos1);
             assert_eq!(pos1.zobrist, pos2.zobrist);
-            assert_eq!(table[pos1.zobrist], Some(200));
             anti_mv.unmake(&mut pos1);
             assert_eq!(pos1.zobrist, hash1_orig);
-            assert_eq!(table[pos1.zobrist], Some(100));
         }
     }
-
-    // test that positions are equal when they loop back to the start
-    #[test]
-    fn test_zobrist_loops() {
-        let test_cases = [
-            (
-                "4k3/4r3/8/8/8/8/3R4/3K4 w - - 0 1",
-                "d2f2 e7f7 f2d2 f7e7",
-            ),
-            (
-                "4k3/4r3/8/8/8/8/3R4/3K4 w - - 0 1",
-                "d2f2 e7f7 f2d2 f7e7 d2f2 e7f7 f2d2 f7e7 d2f2 e7f7 f2d2 f7e7 d2f2 e7f7 f2d2 f7e7 d2f2 e7f7 f2d2 f7e7 d2f2 e7f7 f2d2 f7e7",
-            ),
-        ];
-
-        for (fen, mvs_str) in test_cases {
-            let pos_orig = Board::from_fen(fen).unwrap();
-            let mut pos = pos_orig.clone();
-            for mv_str in mvs_str.split_whitespace() {
-                let mv = Move::from_uci_algebraic(mv_str).unwrap();
-                mv.make(&mut pos);
-            }
-            pos.half_moves = pos_orig.half_moves;
-            pos.full_moves = pos_orig.full_moves;
-            assert_eq!(pos, pos_orig, "test case is incorrect, position should loop back to the original");
-            assert_eq!(pos.zobrist, pos_orig.zobrist);
-        }
-    }
-
-    #[test]
-    fn test_table() {
-        let mut table = ZobristTable::<usize>::new(4);
-
-        macro_rules! z {
-            ($i: expr) => { Zobrist { hash: $i } }
-        }
-
-        let big_number = 1 << 62;
-
-        table[z!(big_number + 3)] = Some(4);
-        table[z!(big_number + 19)] = Some(5);
-
-        // clobbered by newer entry
-        assert_eq!(table[z!(big_number + 3)], None);
-
-        assert_eq!(table[z!(big_number + 19)], Some(5));
-
-        eprintln!("{table:?}");
-    }
 }

src/lib.rs

@@ -21,7 +21,7 @@ pub mod eval;
 pub mod fen;
 mod hash;
 pub mod movegen;
-pub mod random;
+mod random;
 pub mod search;
 
 use crate::fen::{FromFen, ToFen, START_POSITION};

src/movegen.rs

@@ -13,8 +13,8 @@ Copyright © 2024 dogeystamp <dogeystamp@disroot.org>
 
 //! Move generation.
 
+use crate::hash::Zobrist;
 use crate::fen::ToFen;
-use crate::hash::{Zobrist, ZobristTable};
 use crate::{
     Board, CastleRights, ColPiece, Color, Piece, Square, SquareError, BOARD_HEIGHT, BOARD_WIDTH,
     N_SQUARES,
@@ -85,7 +85,7 @@ pub struct AntiMove {
     dest: Square,
     src: Square,
     /// Captured piece, always assumed to be of enemy color.
-    pub(crate) cap: Option<Piece>,
+    pub (crate) cap: Option<Piece>,
     move_type: AntiMoveType,
     /// Half-move counter prior to this move
     half_moves: usize,
@@ -770,13 +770,8 @@ impl MoveGenInternal for Board {
     }
 }
 
-fn perft_internal(depth: usize, pos: &mut Board, cache: &mut ZobristTable<(usize, usize)>) -> usize {
+/// How many nodes at depth N can be reached from this position.
-    if let Some((ans, cache_depth)) = cache[pos.zobrist] {
+pub fn perft(depth: usize, pos: &mut Board) -> usize {
-        if depth == cache_depth {
-            return ans;
-        }
-    }
-
     if depth == 0 {
         return 1;
     };
@@ -786,20 +781,13 @@ fn perft_internal(depth: usize, pos: &mut Board, cache: &mut ZobristTable<(usize
     let moves: Vec<Move> = pos.gen_moves().into_iter().collect();
     for mv in moves {
         let anti_move = mv.make(pos);
-        ans += perft_internal(depth - 1, pos, cache);
+        ans += perft(depth - 1, pos);
         anti_move.unmake(pos);
     }
 
-    cache[pos.zobrist] = Some((ans, depth));
     ans
 }
 
-/// How many nodes at depth N can be reached from this position.
-pub fn perft(depth: usize, pos: &mut Board) -> usize {
-    let mut cache = ZobristTable::new(23);
-    perft_internal(depth, pos, &mut cache)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/random.rs

@@ -1,82 +1,77 @@
 //! Rust port by dogeystamp <dogeystamp@disroot.org> of
 //! the pcg64 dxsm random number generator (https://dotat.at/@/2023-06-21-pcg64-dxsm.html)
 
-pub struct Pcg64Random {
+struct Pcg64Random {
     state: u128,
     inc: u128,
 }
 
+/// Generates an array of random numbers.
+///
+/// The `rng` parameter only sets the initial state. This function is deterministic and pure.
+///
+/// # Returns
+///
+/// The array of random numbers, plus the RNG state at the end.
+const fn pcg64_dxsm<const N: usize>(mut rng: Pcg64Random) -> ([u64; N], Pcg64Random) {
+    let mut ret = [0; N];
+
+    const MUL: u64 = 15750249268501108917;
+
+    let mut i = 0;
+    while i < N {
+        let state: u128 = rng.state;
+        rng.state = state.wrapping_mul(MUL as u128).wrapping_add(rng.inc);
+        let mut hi: u64 = (state >> 64) as u64;
+        let lo: u64 = (state | 1) as u64;
+        hi ^= hi >> 32;
+        hi &= MUL;
+        hi ^= hi >> 48;
+        hi = hi.wrapping_mul(lo);
+        ret[i] = hi;
+
+        i += 1;
+    }
+
+    (ret, rng)
+}
+
 /// Make an RNG state "sane".
 const fn pcg64_seed(mut rng: Pcg64Random) -> Pcg64Random {
     // ensure rng.inc is odd
     rng.inc = (rng.inc << 1) | 1;
     rng.state += rng.inc;
     // one iteration of random
-    rng.rand();
+    let (_, rng) = pcg64_dxsm::<1>(rng);
     rng
 }
 
-impl Pcg64Random {
+/// Generate array of random numbers, based on a seed.
-    pub const fn new(seed: u128) -> Self {
+///
-        pcg64_seed(Pcg64Random {
+/// This function is pure and deterministic, and also works at compile-time rather than at runtime.
-            // chosen by fair dice roll
+///
-            state: 24437033748623976104561743679864923857,
+/// Example (generate 10 random numbers):
-            inc: seed,
+///
-        })
+///```rust
-    }
+/// use crate::random::random_arr_64;
-
+/// const ARR: [u64; 10] = random_arr_64(123456);
-    /// Returns a single random number.
+///```
-    pub const fn rand(&mut self) -> u64 {
+pub const fn random_arr_64<const N: usize>(seed: u128) -> [u64; N] {
-        const MUL: u64 = 15750249268501108917;
+    let rng = pcg64_seed(Pcg64Random {
-
+        // chosen by fair dice roll
-        let state: u128 = self.state;
+        state: 24437033748623976104561743679864923857,
-        self.state = state.wrapping_mul(MUL as u128).wrapping_add(self.inc);
+        inc: seed,
-        let mut hi: u64 = (state >> 64) as u64;
+    });
-        let lo: u64 = (state | 1) as u64;
+    pcg64_dxsm(rng).0
-        hi ^= hi >> 32;
+}
-        hi &= MUL;
+
-        hi ^= hi >> 48;
+/// Generate 2D array of random numbers based on a seed.
-        hi = hi.wrapping_mul(lo);
+pub const fn random_arr_2d_64<const N: usize, const M: usize>(seed: u128) -> [[u64; N]; M] {
-
+    let mut ret = [[0; N]; M];
-        hi
+    let mut i = 0;
-    }
+    while i < M {
-
+        ret[i] = random_arr_64(seed);
-    /// Generate array of random numbers, based on a seed.
+        i += 1;
-    ///
+    }
-    /// # Returns
+    ret
-    ///
-    /// A tuple with the random number array, and the RNG state afterwards so you can reuse it in later
-    /// calls (otherwise you'll get the same result if you're using the same seed.)
-    ///
-    /// # Example
-    ///
-    ///```rust
-    /// use chess_inator::random::Pcg64Random;
-    ///
-    /// // generate 3 random numbers
-    /// const ARR: [u64; 3] = Pcg64Random::new(123456).random_arr_64();
-    /// assert_eq!(ARR, [4526545874411451611, 1124465636717751929, 12699417402402334336])
-    ///```
-    pub const fn random_arr_64<const N: usize>(&mut self) -> [u64; N] {
-        let mut ret = [0; N];
-        let mut i = 0;
-        while i < N {
-            let num = self.rand();
-            ret[i] = num;
-            i += 1;
-        }
-
-        ret
-    }
-
-    /// Generate 2D array of random numbers based on a seed.
-    pub const fn random_arr_2d_64<const N: usize, const M: usize>(&mut self) -> [[u64; N]; M] {
-        let mut ret = [[0; N]; M];
-        let mut i = 0;
-        while i < M {
-            ret[i] = self.random_arr_64();
-            i += 1;
-        }
-        ret
-    }
 }

src/search.rs

@@ -14,8 +14,7 @@ Copyright © 2024 dogeystamp <dogeystamp@disroot.org>
 //! Game-tree search.
 
 use crate::eval::{Eval, EvalInt};
-use crate::hash::ZobristTable;
+use crate::movegen::{Move, MoveGen, ToUCIAlgebraic};
-use crate::movegen::{Move, MoveGen};
 use crate::{Board, Piece};
 use std::cmp::max;
 use std::sync::mpsc;
@@ -155,7 +154,6 @@ fn minmax(
     depth: usize,
     alpha: Option<EvalInt>,
     beta: Option<EvalInt>,
-    cache: &mut TranspositionTableOpt,
 ) -> (Vec<Move>, SearchEval) {
     // default to worst, then gradually improve
     let mut alpha = alpha.unwrap_or(EVAL_WORST);
@@ -167,6 +165,7 @@ fn minmax(
         return (Vec::new(), SearchEval::Centipawns(eval));
     }
 
+    // sort moves by decreasing priority
     let mut mvs: Vec<_> = board
         .gen_moves()
         .into_iter()
@@ -174,15 +173,6 @@ fn minmax(
         .into_iter()
         .map(|mv| (move_priority(board, &mv), mv))
         .collect();
-
-    // remember the prior best move
-    if let Some(cache) = cache {
-        if let Some(entry) = &cache[board.zobrist] {
-            mvs.push((EVAL_BEST, entry.best_move));
-        }
-    }
-
-    // sort moves by decreasing priority
     mvs.sort_unstable_by_key(|mv| -mv.0);
 
     let mut abs_best = SearchEval::Centipawns(EVAL_WORST);
@@ -200,8 +190,7 @@ fn minmax(
 
     for (_priority, mv) in mvs {
         let anti_mv = mv.make(board);
-        let (continuation, score) =
+        let (continuation, score) = minmax(board, config, depth - 1, Some(-beta), Some(-alpha));
-            minmax(board, config, depth - 1, Some(-beta), Some(-alpha), cache);
         let abs_score = score.increment();
         if abs_score > abs_best {
             abs_best = abs_score;
@@ -221,11 +210,8 @@ fn minmax(
         }
     }
 
-    if let Some(best_move) = best_move {
+    if let Some(mv) = best_move {
-        best_continuation.push(best_move);
+        best_continuation.push(mv);
-        if let Some(cache) = cache {
-            cache[board.zobrist] = Some(TranspositionEntry { best_move });
-        }
     }
 
     (best_continuation, abs_best)
@@ -238,24 +224,14 @@ pub enum InterfaceMsg {
 
 type InterfaceRx = mpsc::Receiver<InterfaceMsg>;
 
-#[derive(Clone, Copy, Debug)]
-pub struct TranspositionEntry {
-    // best move found last time
-    best_move: Move,
-}
-
-pub type TranspositionTable = ZobristTable<TranspositionEntry>;
-type TranspositionTableOpt = Option<TranspositionTable>;
-
 /// Iteratively deepen search until it is stopped.
 fn iter_deep(
     board: &mut Board,
     config: &SearchConfig,
     interface: Option<InterfaceRx>,
-    cache: &mut TranspositionTableOpt,
 ) -> (Vec<Move>, SearchEval) {
     for depth in 1..=config.depth {
-        let (line, eval) = minmax(board, config, depth, None, None, cache);
+        let (line, eval) = minmax(board, config, depth, None, None);
         if let Some(ref rx) = interface {
             match rx.try_recv() {
                 Ok(msg) => match msg {
@@ -267,7 +243,7 @@ fn iter_deep(
                 },
             }
         } else if depth == config.depth - 1 {
-            return (line, eval);
+            return (line, eval)
         }
     }
     panic!("iterative deepening did not search at all")
@@ -278,10 +254,9 @@ pub fn best_line(
     board: &mut Board,
     config: Option<SearchConfig>,
     interface: Option<InterfaceRx>,
-    cache: &mut TranspositionTableOpt,
 ) -> (Vec<Move>, SearchEval) {
     let config = config.unwrap_or_default();
-    let (line, eval) = iter_deep(board, &config, interface, cache);
+    let (line, eval) = iter_deep(board, &config, interface);
     (line, eval)
 }
 
@@ -290,9 +265,8 @@ pub fn best_move(
     board: &mut Board,
     config: Option<SearchConfig>,
     interface: Option<InterfaceRx>,
-    cache: &mut TranspositionTableOpt,
 ) -> Option<Move> {
-    let (line, _eval) = best_line(board, Some(config.unwrap_or_default()), interface, cache);
+    let (line, _eval) = best_line(board, Some(config.unwrap_or_default()), interface);
     line.last().copied()
 }
 
@@ -318,7 +292,6 @@ mod tests {
                     depth: 3,
                 }),
                 None,
-                &mut None,
             )
             .unwrap();
 
@@ -331,7 +304,6 @@ mod tests {
                     depth: 3,
                 }),
                 None,
-                &mut None,
             )
             .unwrap();