pleco 0.5.0

A blazingly-fast chess library.
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

extern crate pleco;
extern crate rand;

use pleco::{Board,BitMove};
use pleco::board::{RandBoard};


trait HashCorrect {
    fn get_hash(board: &Board) -> u64;

    fn check_hash(board: &Board) {
        if board.depth() > 0 {
            let pre_hash: u64 = Self::get_hash(board);
            let fen = board.fen();
            let fen_board = Board::from_fen(&fen).unwrap();
            let post_hash: u64 = Self::get_hash(&fen_board);

            if pre_hash != post_hash {
                Self::print_hash(board, &fen);
            }
        }

    }

    fn print_hash(board: &Board, fen: &str) {
        let last_move_played = board.last_move().unwrap_or(BitMove::null());
        let mut prev_board: Board = board.parallel_clone();
        prev_board.undo_move();
        let prev_fen = prev_board.fen();
        panic!("\nBoard did not have correct zobrist before and after! ply: {} \n\
                current fen: {}\n\
                last move played: {}, flags: {:b} \n\
                previous fen: {}\n\
                pretty: \n\
                {} \n
                previous pretty: \n\
                {} \n",
               board.depth(), fen, last_move_played, last_move_played.get_raw() >> 12,
               prev_fen, board.pretty_string(), prev_board.pretty_string());
    }
}

struct ZobHashCorrect {}
struct MaterialHashCorrect {}
struct PawnHashCorrect {}

impl HashCorrect for ZobHashCorrect {
    fn get_hash(board: &Board) -> u64 {
        board.zobrist()
    }
}
impl HashCorrect for MaterialHashCorrect {
    fn get_hash(board: &Board) -> u64 {
        board.material_key()
    }
}

impl HashCorrect for PawnHashCorrect {
    fn get_hash(board: &Board) -> u64 {
        board.pawn_key()
    }
}

// Testing that applying / undoing a move leads to the same zobriust hash
#[test]
fn zobrist_correctness() {
    for _x in 0..15 {
        let mut board = RandBoard::default().one().shallow_clone();
        randomize::<ZobHashCorrect>(&mut board);
    }
}

#[test]
fn pawn_key_correctness() {
    for _x in 0..15 {
        let mut board = RandBoard::default().one().shallow_clone();
        randomize::<PawnHashCorrect>(&mut board);
    }
}

#[test]
fn material_key_correctness() {
    for _x in 0..15 {
        let mut board = RandBoard::default().one().shallow_clone();
        randomize::<MaterialHashCorrect>(&mut board);
    }
}

fn randomize<H: HashCorrect>(board: &mut Board) {
    let list = board.generate_moves();
    let num_iterations = ((rand::random::<usize>() % 6) + 3)
        .min(list.len());

    let mut moves = Vec::with_capacity(num_iterations);
    for _x in 0..num_iterations {
        moves.push(list[rand::random::<usize>() % list.len()]);
    }

    while let Some(mov) = moves.pop() {
        let depth: usize = (rand::random::<usize>() % 9) + 6;
        board.apply_move(mov);
        randomize_inner::<H>(board, depth);
        board.undo_move();
    }
}


fn randomize_inner<H: HashCorrect>(board: &mut Board, depth: usize) {
    H::check_hash(&board);
    if depth != 0 {
        let moves = board.generate_moves();
        if moves.len() == 0 {
            return;
        }

        let rn = rand::random::<usize>() % moves.len();
        board.apply_move( moves[rn % moves.len()]);
        randomize_inner::<H>(board, depth - 1);
        board.undo_move();

        if rn > 3 && rn % 4 == 0 && depth > 4 {
            board.apply_move( moves[rn - 1]);
            randomize_inner::<H>(board, depth - 2);
            board.undo_move();
        }
    }
}

//
//fn check_zob(board: &Board) {
//    let zobrist = board.zobrist();
//    let fen = board.fen();
//    let fen_board = Board::from_fen(&fen).unwrap();
//    let post_zob = fen_board.zobrist();
//
//    if board.depth() > 0 && zobrist != post_zob {
//        let last_move_played = board.last_move().unwrap_or(BitMove::null());
//        let mut prev_board: Board = board.parallel_clone();
//        prev_board.undo_move();
//        let prev_fen = prev_board.fen();
//        panic!("\nBoard did not have correct zobrist before and after! ply: {} \n\
//                current fen: {}\n\
//                last move played: {}, flags: {:b} \n\
//                previous fen: {}\n\
//                pretty: \n\
//                {} \n
//                previous pretty: \n\
//                {} \n",
//               board.depth(), fen, last_move_played, last_move_played.get_raw() >> 12,
//               prev_fen, board.pretty_string(), prev_board.pretty_string());
//    }
//
//}