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

use super::BitBoard;
use std::ops::{Add, AddAssign, Sub, SubAssign};

impl<const T: usize> Add<BitBoard<T>> for BitBoard<T> {
    type Output = Self;

    fn add(self, rhs: BitBoard<T>) -> BitBoard<T> {
        let mut bit_board = self.clone();
        bit_board += rhs;
        bit_board
    }
}

impl<const T: usize> AddAssign<BitBoard<T>> for BitBoard<T> {
    fn add_assign(&mut self, rhs: BitBoard<T>) {
        if T == 1 {
            self.bits[0] += rhs.bits[0];
            return;
        }

        let mut carry = *self & rhs;
        *self ^= rhs;
        while carry.is_set() {
            let shifted_carry = carry << 1;
            carry = *self & shifted_carry;
            *self ^= shifted_carry;
        }
    }
}

impl<const T: usize> Sub<BitBoard<T>> for BitBoard<T> {
    type Output = Self;

    fn sub(self, rhs: BitBoard<T>) -> BitBoard<T> {
        let mut bit_board = self.clone();
        bit_board -= rhs;
        bit_board
    }
}

impl<const T: usize> SubAssign<BitBoard<T>> for BitBoard<T> {
    fn sub_assign(&mut self, rhs: BitBoard<T>) {
        if T == 1 {
            self.bits[0] -= rhs.bits[0];
            return;
        }

        let mut rhs = rhs.clone();
        while rhs.is_set() {
            let borrow = !(*self) & rhs;
            *self ^= rhs;
            rhs = borrow << 1;
        }
    }
}

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

    #[test]
    fn add() {
        assert_eq!(
            BitBoard::from_data([2, 13]) + BitBoard::from_data([4, 19]),
            BitBoard::from_data([6, 32])
        );
        assert_eq!(
            BitBoard::from_data([0, u128::MAX]) + BitBoard::from_data([0, 1]),
            BitBoard::from_data([1, 0])
        );
    }

    #[test]
    fn sub() {
        assert_eq!(
            BitBoard::from_data([6, 32]) - BitBoard::from_data([4, 19]),
            BitBoard::from_data([2, 13])
        );
        assert_eq!(
            BitBoard::from_data([1, 0]) - BitBoard::from_data([0, 1]),
            BitBoard::from_data([0, u128::MAX])
        );
    }
}