tanton 1.0.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

extern crate tanton;

use self::board::Board;
use tanton::board;
use tanton::core::piece_move;
use tanton::core::piece_move::*;
use tanton::core::*;
use tanton::*;

#[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);
}