ruchess 0.0.6

rust chess
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
157
158

//! # Moves
//!
//! A [`Move`] is a fully-decorated chess move: the piece, the squares
//! involved, any capture, promotion, castling, or en-passant flags, and the
//! [`Board`]s before and after the move is applied.
//!
//! Construct moves through the named constructors ([`Move::quiet`],
//! [`Move::capture`], [`Move::castle`], [`Move::enpassant`],
//! [`Move::promotion`]) rather than by hand — they fill in the
//! mutually-exclusive flag fields correctly.

use crate::{
    board::Board,
    color::Color,
    piece::Piece,
    role::{PromotableRole, Role},
    side::Side,
    square::Square,
};

/// A chess move together with all of its side effects.
///
/// Each move is either a quiet push, a capture, a castle, an en-passant
/// capture, or a promotion. The flag fields are mutually exclusive — at
/// most one of `castle`, `enpassant`, and `promotion` is `Some`.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Move {
    /// The piece making the move (color is the side making the move).
    pub piece: Piece,
    /// The origin square.
    pub orig: Square,
    /// The destination square.
    pub dest: Square,
    /// The square of the captured piece, if any. For en-passant this is the
    /// captured pawn's actual square (not `dest`).
    pub capture: Option<Square>,
    /// The role this pawn promotes to, if the move is a promotion.
    pub promotion: Option<PromotableRole>,
    /// The castling side, if the move is a castle.
    pub castle: Option<Side>,
    /// `Some(())` if the move is an en-passant capture.
    pub enpassant: Option<()>,
    /// The board state resulting from applying this move.
    pub after: Board,
}

impl Move {
    /// Builds a quiet (non-capturing, non-special) move from `orig` to `dest`.
    pub fn quiet(piece: Piece, orig: Square, dest: Square, after: Board) -> Self {
        Self {
            piece,
            orig,
            dest,
            capture: None,
            promotion: None,
            castle: None,
            enpassant: None,
            after,
        }
    }

    /// Builds an ordinary capture. `captured` is the square holding the
    /// captured piece — for non-en-passant captures this equals `dest`.
    pub fn capture(
        piece: Piece,
        orig: Square,
        dest: Square,
        captured: Square,
        after: Board,
    ) -> Self {
        Self {
            piece,
            orig,
            dest,
            capture: Some(captured),
            promotion: None,
            castle: None,
            enpassant: None,
            after,
        }
    }

    /// Builds a castling move on `side` for `color`.
    ///
    /// `king_from`/`king_to` describe the king's motion; the rook movement is
    /// implied by the [`Side`] and is recorded in `after`.
    pub fn castle(
        color: Color,
        side: Side,
        king_from: Square,
        king_to: Square,
        after: Board,
    ) -> Self {
        Self {
            piece: Piece {
                role: Role::King,
                color,
            },
            orig: king_from,
            dest: king_to,
            capture: None,
            promotion: None,
            castle: Some(side),
            enpassant: None,
            after,
        }
    }

    /// Builds an en-passant capture by `color`'s pawn from `orig` to `dest`,
    /// with the opposing pawn removed at `captured`.
    pub fn enpassant(
        color: Color,
        orig: Square,
        dest: Square,
        captured: Square,
        after: Board,
    ) -> Self {
        Self {
            piece: Piece {
                role: Role::Pawn,
                color,
            },
            orig,
            dest,
            capture: Some(captured),
            promotion: None,
            castle: None,
            enpassant: Some(()),
            after,
        }
    }

    /// Builds a promotion move. `captured` is `Some(square)` when the
    /// promotion is also a capture (a diagonal pawn move into the back rank),
    /// otherwise `None` for a straight push.
    pub fn promotion(
        color: Color,
        orig: Square,
        dest: Square,
        role: PromotableRole,
        captured: Option<Square>,
        after: Board,
    ) -> Self {
        Self {
            piece: Piece {
                role: Role::Pawn,
                color,
            },
            orig,
            dest,
            capture: captured,
            promotion: Some(role),
            castle: None,
            enpassant: None,
            after,
        }
    }
}