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

extern crate pleco;

use pleco::board as board;
use self::board::{Board as Board};
use pleco::core::*;
use pleco::core::piece_move;
use pleco::core::piece_move::*;
use pleco::*;


#[test]
fn test_init_counts() {
    let board = Board::start_pos();
    assert_eq!(board.count_piece(Player::White, PieceType::P), 8);
    assert_eq!(board.count_piece(Player::White, PieceType::N), 2);
    assert_eq!(board.count_piece(Player::White, PieceType::B), 2);
    assert_eq!(board.count_piece(Player::White, PieceType::R), 2);
    assert_eq!(board.count_piece(Player::White, PieceType::K), 1);
    assert_eq!(board.count_piece(Player::White, PieceType::Q), 1);
    assert_eq!(board.count_piece(Player::Black, PieceType::P), 8);
    assert_eq!(board.count_piece(Player::Black, PieceType::N), 2);
    assert_eq!(board.count_piece(Player::Black, PieceType::B), 2);
    assert_eq!(board.count_piece(Player::Black, PieceType::R), 2);
    assert_eq!(board.count_piece(Player::Black, PieceType::K), 1);
    assert_eq!(board.count_piece(Player::Black, PieceType::Q), 1);
    assert_eq!(board.diagonal_piece_bb(Player::White).0,0b101100);
    assert_eq!(board.sliding_piece_bb(Player::White).0,0b10001001);
    assert_eq!(board.count_pieces_player(Player::White),board.count_pieces_player(Player::Black));
    assert_eq!(board.occupied().0, 0xFFFF00000000FFFF);
    assert_eq!(board.count_all_pieces(),32);
}


#[test]
fn basic_move_apply() {
    let mut b = Board::start_pos();
    let p1 = PreMoveInfo {
        src: SQ(12),
        dst: SQ(28),
        flags: MoveFlag::DoublePawnPush
    };
    let m = BitMove::init(p1);
    b.apply_move(m);
    let p2 = PreMoveInfo {
        src: SQ(51),
        dst: SQ(35),
        flags: MoveFlag::DoublePawnPush
    };
    let m = BitMove::init(p2);
    b.apply_move(m);
    let p3 = PreMoveInfo {
        src: SQ(28),
        dst: SQ(35),
        flags: MoveFlag::Capture {ep_capture: false}
    };
    let m = BitMove::init(p3);
    b.apply_move(m);
    assert_eq!(b.count_piece(Player::Black,PieceType::P),7);
    b.undo_move();
    assert_eq!(b.count_piece(Player::Black,PieceType::P),8);
    assert!(!b.in_check());
}



#[test]
fn move_seq_1() {
    let mut b = board::Board::start_pos();
    let p = PreMoveInfo {
        src: SQ(12),
        dst: SQ(28),
        flags: MoveFlag::DoublePawnPush
    };
    let m = BitMove::init(p);
    b.apply_move(m);
    let p = PreMoveInfo {
        src: SQ(51),
        dst: SQ(35),
        flags: MoveFlag::DoublePawnPush
    };
    let m = BitMove::init(p);
    b.apply_move(m);
    let p = PreMoveInfo {
        src: SQ(28),
        dst: SQ(35),
        flags: MoveFlag::Capture {ep_capture: false}
    };
    let m = BitMove::init(p);
    b.apply_move(m);

    let p = PreMoveInfo {
        src: SQ(59),
        dst: SQ(35),
        flags: MoveFlag::Capture {ep_capture: false}
    };
    let m = BitMove::init(p);
    b.apply_move(m);
    let p = PreMoveInfo {
        src: SQ(5),
        dst: SQ(12),
        flags: MoveFlag::QuietMove,
    };
    let m = BitMove::init(p);
    b.apply_move(m);
    let p = PreMoveInfo {
        src: SQ(35),
        dst: SQ(8),
        flags: MoveFlag::Capture {ep_capture: false}
    };
    let m = BitMove::init(p);
    b.apply_move(m);
    let p = PreMoveInfo {
        src: SQ(6),
        dst: SQ(21),
        flags: MoveFlag::QuietMove
    };
    let m = BitMove::init(p);
    b.apply_move(m);

    let p = piece_move::PreMoveInfo {
        src: SQ(60),
        dst: SQ(59),
        flags: piece_move::MoveFlag::QuietMove
    };
    let m = piece_move::BitMove::init(p);
    b.apply_move(m);
    let p = PreMoveInfo {
        src: SQ(4),
        dst: SQ(7),
        flags: MoveFlag::Castle{king_side: true}
    };
    let m = BitMove::init(p);
    b.apply_move(m);
}