bitstackchess 0.1.1

A bitboard‐based chess game engine with 10 × u128 move history
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

//! Ten 128‐bit “planes,” each plane[i] holds the i‐th bit of up to 128 Move10 codes.

use super::move10::Move10;

#[derive(Clone, Debug)]
pub struct MovePlanes {
    pub planes: [u128; 10],
}

impl MovePlanes {
    /// Create 10 zeroed u128 planes.
    pub fn new() -> MovePlanes {
        MovePlanes { planes: [0u128; 10] }
    }

    /// Clear all ten planes.
    pub fn clear_all(&mut self) {
        for i in 0..10 {
            self.planes[i] = 0;
        }
    }

    /// Write a 10‐bit Move10 (or clear if None) at index k (0..127).
    pub fn write_ply(&mut self, k: usize, mv: Option<Move10>) {
        debug_assert!(k < 128, "ply index must be < 128");
        if let Some(mv10) = mv {
            let raw = mv10.bits() as u32;
            for bit_i in 0..10 {
                let bit_val = ((raw >> bit_i) & 1) as u128;
                if bit_val == 1 {
                    self.planes[bit_i] |= 1u128 << k;
                } else {
                    self.planes[bit_i] &= !(1u128 << k);
                }
            }
        } else {
            for i in 0..10 {
                self.planes[i] &= !(1u128 << k);
            }
        }
    }

    /// Read back the 10‐bit Move10 at index k (0..127).
    pub fn read_ply(&self, k: usize) -> Move10 {
        debug_assert!(k < 128, "ply index must be < 128");
        let mut raw: u16 = 0;
        for bit_i in 0..10 {
            let bit_val = ((self.planes[bit_i] >> k) & 1) as u16;
            raw |= bit_val << bit_i;
        }
        Move10::from_raw(raw)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::core::move10::Move10;

    #[test]
    fn write_read_planes() {
        let mut planes = MovePlanes::new();
        let codes = [
            Move10::new(3, 10),
            Move10::new(15, 63),
            Move10::new(0, 0),
            Move10::new(7, 31),
        ];
        for (i, &mv) in codes.iter().enumerate() {
            planes.write_ply(i, Some(mv));
        }
        for (i, &mv) in codes.iter().enumerate() {
            let got = planes.read_ply(i);
            assert_eq!(got, mv);
        }
        planes.write_ply(2, None);
        let cleared = planes.read_ply(2);
        assert_eq!(cleared.bits(), 0);
    }
}