rust_fish_chess_engine 0.1.4

A chess engine and functionality built in Rust. Built for the intention of incorporating it into my Svelte chess project through WASM.
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

use crate::{Piece, PieceType};
use super::{king::CastleState, Move, SpecialRule};


/// Moves piece from current_pos to new_pos
/// Returns taken piece if any
pub fn move_piece(
    moving: &Move,
    board: &mut Vec<Vec<Option<Piece>>>,
    castle_state: &mut CastleState,
) -> Option<Piece> {
    update_castle_state(moving, castle_state);
    let mut taken_piece = board[moving.new_pos.0][moving.new_pos.1].clone();
    let piece = board[moving.current_pos.0][moving.current_pos.1].clone();
    board[moving.new_pos.0][moving.new_pos.1] = piece.clone();
    board[moving.current_pos.0][moving.current_pos.1] = None;

    match &moving.special_rule {
        Some(SpecialRule::Enpassant) => {
            taken_piece = board[moving.current_pos.0][moving.new_pos.1].clone();
            board[moving.current_pos.0][moving.new_pos.1] = None;
        },
        Some(SpecialRule::Castle) => {
            if moving.new_pos.1 == 2 {
                let rook = board[moving.new_pos.0][0].clone();
                board[moving.new_pos.0][3] = rook;
                board[moving.new_pos.0][0] = None;
            } else if moving.new_pos.1 == 6 {
                let rook = board[moving.new_pos.0][7].clone();
                board[moving.new_pos.0][5] = rook;
                board[moving.new_pos.0][7] = None;
            }
        },
        Some(SpecialRule::Promotion(piece_type)) => {
            board[moving.new_pos.0][moving.new_pos.1] = Some(match piece {
                Some(Piece::White(_)) => Piece::White(piece_type.clone()),
                Some(Piece::Black(_)) => Piece::Black(piece_type.clone()),
                _ => return None
            });
        },
        None => {}
    }
    return taken_piece
}

pub fn unmove_piece(
    moving: &Move,
    board: &mut Vec<Vec<Option<Piece>>>,
    taken_piece: Option<Piece>,
) -> Result<(), String> {
    let piece = board[moving.new_pos.0][moving.new_pos.1].clone();
    board[moving.current_pos.0][moving.current_pos.1] = piece.clone();

    match moving.special_rule {
        Some(SpecialRule::Enpassant) => {
            board[moving.current_pos.0][moving.new_pos.1] = taken_piece;
        },
        Some(SpecialRule::Castle) => {
            if moving.new_pos.1 == 2 {
                let rook = board[moving.new_pos.0][3].clone();
                board[moving.new_pos.0][0] = rook;
                board[moving.new_pos.0][3] = None;
            } else if moving.new_pos.1 == 6 {
                let rook = board[moving.new_pos.0][5].clone();
                board[moving.new_pos.0][7] = rook;
                board[moving.new_pos.0][5] = None;
            }
        },
        Some(SpecialRule::Promotion(_)) => {
            board[moving.current_pos.0][moving.current_pos.1] = match piece {
                Some(Piece::White(_)) => Some(Piece::White(PieceType::Pawn)),
                Some(Piece::Black(_)) => Some(Piece::Black(PieceType::Pawn)),
                None => return Err(format!("No piece to undo promote: {:?} {:?}", moving, board))
            };
            board[moving.new_pos.0][moving.new_pos.1] = taken_piece;
        },
        None => board[moving.new_pos.0][moving.new_pos.1] = taken_piece
    }

    Ok(())
}

fn update_castle_state(moving: &Move, castle_state: &mut CastleState) {
    match moving.current_pos {
        (0, 4) => castle_state.black_king_moved = true,
        (0, 0) => castle_state.black_left_rook_moved = true,
        (0, 7) => castle_state.black_right_rook_moved = true,
        (7, 4) => castle_state.white_king_moved = true,
        (7, 0) => castle_state.white_left_rook_moved = true,
        (7, 7) => castle_state.white_right_rook_moved = true,
        _ => {}
    }
}

// fn unupdate_castle_state(moving: &Move, piece: &Option<Piece>, castle_state: &mut CastleState) {
//     match moving.current_pos {
//         (0, 4) => match piece {
//             Some(Piece::Black(PieceType::King)) => castle_state.black_king_moved = false,
//             _ => {}
//         },
//         (0, 0) => match piece {
//             Some(Piece::Black(PieceType::Rook)) => castle_state.black_left_rook_moved = false,
//             _ => {}
//         },
//         (0, 7) => match piece {
//             Some(Piece::Black(PieceType::Rook)) => castle_state.black_right_rook_moved = false,
//             _ => {}
//         },
//         (7, 4) => match piece {
//             Some(Piece::White(PieceType::King)) => castle_state.white_king_moved = false,
//             _ => {}
//         },
//         (7, 0) => match piece {
//             Some(Piece::White(PieceType::Rook)) => castle_state.white_left_rook_moved = false,
//             _ => {}
//         },
//         (7, 7) => match piece {
//             Some(Piece::White(PieceType::Rook)) => castle_state.white_right_rook_moved = false,
//             _ => {}
//         },
//         _ => {}
//     }
// }