rchess 2.3.0

A Chess Library Written In Rust
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 crate::defs::*;
use crate::mask_gen::sliders::{get_bishop_attacks_slow, get_rook_attacks_slow};
use lazy_static::lazy_static;

lazy_static! {
    /// A table of rays in each direction.
    pub static ref RAYS: Box<[[BitBoard; 8]; 64]> = generate_rays();

    /// A table of the lines connecting sets of squares.
    pub static ref DIRECT_CONNECTIONS: Box<[[BitBoard; 64]; 64]> = generate_direct_connections();

    /// A table of the axis lines that connect sets of squares.
    pub static ref AXIS_CONNECTIONS: Box<[[BitBoard; 64]; 64]> = generate_axis_connections();
}

/// Generates the rays table.
fn generate_rays() -> Box<[[BitBoard; 8]; 64]> {
    let mut rays = Box::new([[BitBoard::EMPTY; 8]; 64]);

    for square in SQUARES {
        for dir in DIRS {
            let mut pos = square.bitboard();
            while !dir.edge().overlaps(pos) {
                pos = pos.shift_dir(dir);
                rays[square.index()][dir.index()] |= pos;
            }
        }
    }

    rays
}

/// Generates the direct connections table.
fn generate_direct_connections() -> Box<[[BitBoard; 64]; 64]> {
    let mut direct_connections = Box::new([[BitBoard::EMPTY; 64]; 64]);

    for start_sq in SQUARES {
        let start_bb = start_sq.bitboard();
        for end_sq in SQUARES {
            let end_bb = end_sq.bitboard();

            let occupancy = start_bb | end_bb;

            let bishop_attacks = get_bishop_attacks_slow(&RAYS, start_sq, occupancy);
            let rook_attacks = get_rook_attacks_slow(&RAYS, start_sq, occupancy);

            let connection = if bishop_attacks.overlaps(end_bb) {
                let square2_attacks = get_bishop_attacks_slow(&RAYS, end_sq, occupancy);
                bishop_attacks & square2_attacks
            } else if rook_attacks.overlaps(end_bb) {
                let square2_attacks = get_rook_attacks_slow(&RAYS, end_sq, occupancy);
                rook_attacks & square2_attacks
            } else {
                BitBoard::EMPTY
            };

            direct_connections[start_sq.index()][end_sq.index()] = connection;
        }
    }

    direct_connections
}

/// Generates. the axis connections table.
fn generate_axis_connections() -> Box<[[BitBoard; 64]; 64]> {
    let mut axis_connections = Box::new([[BitBoard::EMPTY; 64]; 64]);

    for start_sq in SQUARES {
        let start_bb = start_sq.bitboard();

        for end_sq in SQUARES {
            let end_bb = end_sq.bitboard();

            let bishop_attacks =
                get_bishop_attacks_slow(&RAYS, start_sq, BitBoard::EMPTY) | start_bb;
            let rook_attacks = get_rook_attacks_slow(&RAYS, start_sq, BitBoard::EMPTY) | start_bb;

            let mut connection = BitBoard::EMPTY;
            if bishop_attacks.overlaps(end_bb) {
                let square2_attacks =
                    get_bishop_attacks_slow(&RAYS, end_sq, BitBoard::EMPTY) | end_bb;
                connection |= bishop_attacks & square2_attacks;
            }

            if rook_attacks.overlaps(end_bb) {
                let square2_attacks =
                    get_rook_attacks_slow(&RAYS, end_sq, BitBoard::EMPTY) | end_bb;
                connection |= rook_attacks & square2_attacks;
            }

            axis_connections[start_sq.index()][end_sq.index()] = connection;
        }
    }

    axis_connections
}