eschac 0.1.0

computing chess moves
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

use crate::bitboard::*;
use crate::board::*;

pub(crate) struct Rays(BySquare<ByDirection<Bitboard>>);

impl Rays {
    pub(crate) fn new() -> Self {
        Self(BySquare::new(|square| {
            ByDirection::new(|direction| {
                let mut square = square;
                let mut res = Bitboard::new();
                while let Some(x) = square.trans(direction) {
                    square = x;
                    res |= square.bitboard();
                }
                res
            })
        }))
    }

    #[inline]
    pub(crate) fn ray(&self, square: Square, direction: Direction) -> Bitboard {
        *self.0.get(square).get(direction)
    }

    pub(crate) fn blocked(
        &self,
        square: Square,
        direction: Direction,
        blockers: Bitboard,
    ) -> Bitboard {
        let blockers = blockers & *self.0.get(square).get(direction);
        let square2 = if (direction as u8) < 4 {
            blockers.first()
        } else {
            blockers.last()
        };
        *self.0.get(square).get(direction)
            & !match square2 {
                Some(square2) => *self.0.get(square2).get(direction),
                None => Bitboard::new(),
            }
    }
}