riag 0.1.0

A chess engine
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use std::ops::BitOr;

use chumsky::prelude::*;
use strum::EnumCount;

use crate::error::Error;
use crate::{Bitboard, Board, CastlingRights, Colour, Piece, Square};

impl Board {
    /// Creates the board from a [FEN string](https://www.chessprogramming.org/Forsyth-Edwards_Notation).
    pub fn from_fen(fen: &str) -> Result<Self, Error> {
        match parser().parse(fen).into_result() {
            Ok(b) => Ok(b),
            Err(_) => Err(Error::FailedToParseFEN(fen.to_owned())),
        }
    }

    /// Exports the board to FEN.
    pub fn fen(&self) -> String {
        let mut output = String::new();

        for (i, rank) in self.board.chunks(8).rev().enumerate() {
            let mut it = rank.iter().peekable();
            while let Some(&piece) = it.next() {
                if let Some(p) = piece {
                    output.push(char::from(p));
                } else {
                    let mut n = 1;
                    while it.next_if(|&&p| p.is_none()).is_some() {
                        n += 1
                    }
                    output.push_str(&format!("{}", n));
                }
            }

            if i != 7 {
                output.push('/');
            }
        }

        output.push_str(&format!(
            " {} {} {} {} {}",
            match self.to_move {
                Colour::White => 'w',
                Colour::Black => 'b',
            },
            self.castling_rights,
            match self.en_passant {
                Some(s) => s.to_string(),
                None => "-".to_string(),
            },
            self.halfmove,
            self.fullmove,
        ));

        output
    }
}

// TODO: improve FEN parsing error messages
pub fn parser<'a>() -> impl Parser<'a, &'a str, Board> {
    let emptysquares = text::digits(10)
        .exactly(1)
        .to_slice()
        .from_str()
        .unwrapped()
        .map(|n: usize| vec![None; n]);
    let piece = one_of("KQRBNPkqrbnp").map(|c: char| vec![Some(Piece::try_from(c).unwrap())]);

    let rank = choice((emptysquares, piece))
        .repeated()
        .at_least(1)
        .collect::<Vec<_>>()
        .try_map(|its, _| {
            TryInto::<[Option<Piece>; 8]>::try_into(its.into_iter().flatten().collect::<Vec<_>>())
                .map_err(|_| EmptyErr::default())
        });

    let board = rank
        .separated_by(just('/'))
        .exactly(8)
        .collect_exactly::<[_; 8]>()
        .map(
            |mut ranks: [[Option<Piece>; 8]; 8]| -> [Option<Piece>; 64] {
                ranks.reverse(); // to conform with LERF mapping
                unsafe { std::mem::transmute(ranks) }
            },
        );

    let colour = choice((just('b').to(Colour::Black), just('w').to(Colour::White)));

    let castling_right = one_of("KQkq").map(|c| match c {
        'K' => CastlingRights::WHITE_KINGSIDE,
        'Q' => CastlingRights::WHITE_QUEENSIDE,
        'k' => CastlingRights::BLACK_KINGSIDE,
        'q' => CastlingRights::BLACK_QUEENSIDE,
        _ => unreachable!(),
    });

    let castling_rights = choice((
        just('-').to(CastlingRights::empty()),
        castling_right.foldl(castling_right.repeated(), BitOr::bitor),
    ));

    let en_passant = choice((
        just('-').to(None),
        one_of("abcdefgh")
            .then(one_of("12345678"))
            .map(Square::try_from)
            .unwrapped()
            .map(Some),
    ));

    let number = text::int(10).from_str().unwrapped();

    group((
        board,
        text::whitespace(),
        colour,
        text::whitespace(),
        castling_rights,
        text::whitespace(),
        en_passant,
        text::whitespace(),
        number.or_not(),
        text::whitespace(),
        number.or_not(),
        text::whitespace(),
        end(),
    ))
    .map(
        |(board, _, to_move, _, castling_rights, _, en_passant, _, halfmove, _, fullmove, _, _)| {
            Board {
                board,
                bitboards: bitboards(board),
                to_move,
                castling_rights,
                en_passant,
                halfmove: halfmove.unwrap_or(0),
                fullmove: fullmove.unwrap_or(1),
            }
        },
    )
}

fn bitboards(board: [Option<Piece>; 64]) -> [Bitboard; Piece::COUNT] {
    let mut bitboards = [0; Piece::COUNT];

    board
        .into_iter()
        .enumerate()
        .filter_map(|(i, p)| p.map(|p| (i, p)))
        .for_each(|(i, p)| bitboards[p.as_index()] |= 1 << i);

    bitboards
}