monster_chess 0.0.24

A fairy chess movegen library that can be easily extended to new chess-adjacent games.
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use super::BitBoard;

/// A direction of either `LEFT` or `RIGHT`, created primarily for bitscans of an arbitrary direction.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum Direction {
    LEFT,
    RIGHT,
}

impl Direction {
    pub fn opposite(&self) -> Direction {
        match self {
            Direction::RIGHT => Direction::LEFT,
            Direction::LEFT => Direction::LEFT
        }
    }
}

impl<const T: usize> BitBoard<T> {
    /// A forward bitscan, which finds the least significant 1-bit.
    pub fn bitscan_forward(&self) -> u16 {
        assert!(
            self.is_set(),
            "Bitscan Forward only works for non-empty BitBoards."
        );

        if T == 1 {
            self.bits[0].trailing_zeros() as u16
        } else {
            let mut zeros: u16 = 0;
            for i in (0..T).rev() {
                let data = self.bits[i];
                if data != 0 {
                    zeros += data.trailing_zeros() as u16;
                    break;
                }

                zeros += 128;
            }
            zeros
        }
    }

    /// A reverse bitscan, which finds the most significant 1-bit.
    pub fn bitscan_reverse(&self) -> u16 {
        assert!(
            self.is_set(),
            "Bitscan Reverse only works for non-empty BitBoards."
        );

        if T == 1 {
            127 - self.bits[0].leading_zeros() as u16
        } else {
            let mut zeros: u16 = 0;
            for i in 0..T {
                let data = self.bits[i];
                if data != 0 {
                    zeros += data.leading_zeros() as u16;
                    break;
                }

                zeros += 128;
            }
            (((T as u16) * 128) - 1) - zeros
        }
    }

    /// A bitscan from either given direction, left or right.
    pub fn bitscan(&self, direction: Direction) -> u16 {
        match direction {
            Direction::LEFT => self.bitscan_forward(),
            Direction::RIGHT => self.bitscan_reverse(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::BitBoard;

    #[test]
    fn bitscan_forward() {
        assert_eq!(BitBoard::from_data([0, 1]).bitscan_forward(), 0);
        assert_eq!(BitBoard::from_data([1, 1]).bitscan_forward(), 0);
        assert_eq!(BitBoard::from_data([3, 3]).bitscan_forward(), 0);
        assert_eq!(BitBoard::from_data([1, 0]).bitscan_forward(), 128);
    }

    #[test]
    fn bitscan_reverse() {
        assert_eq!(BitBoard::from_data([0, 1]).bitscan_reverse(), 0);
        assert_eq!(BitBoard::from_data([1, 1]).bitscan_reverse(), 128);
        assert_eq!(BitBoard::from_data([3, 3]).bitscan_reverse(), 129);
        assert_eq!(BitBoard::from_data([1, 0]).bitscan_reverse(), 128);
    }
}