├── .github
    ├── dependabot.yml
    └── workflows
    │   └── rust.yml
├── .gitignore
├── CHANGELOG.md
├── Cargo.toml
├── LICENSE
├── Makefile
├── README.md
├── benches
    └── littlewing.rs
├── src
    ├── attack.rs
    ├── bitboard.rs
    ├── board.rs
    ├── clock.rs
    ├── color.rs
    ├── common.rs
    ├── dumb7fill.rs
    ├── eval.rs
    ├── fen.rs
    ├── game.rs
    ├── hyperbola.rs
    ├── lib.rs
    ├── main.rs
    ├── pgn.rs
    ├── piece.rs
    ├── piece_move.rs
    ├── piece_move_generator.rs
    ├── piece_move_list.rs
    ├── piece_move_notation.rs
    ├── piece_square_table.rs
    ├── positions.rs
    ├── protocols
    │   ├── cli.rs
    │   ├── mod.rs
    │   ├── uci.rs
    │   └── xboard.rs
    ├── search.rs
    ├── square.rs
    ├── transposition.rs
    ├── transposition_table.rs
    └── zobrist.rs
└── tests
    ├── fool.pgn
    ├── perftsuite.epd
    ├── wac.epd
    ├── wac.rs
    └── zukertort_vs_steinitz_1886.pgn


/.github/dependabot.yml:
--------------------------------------------------------------------------------
1 | version: 2
2 | updates:
3 | - package-ecosystem: cargo
4 |   directory: "/"
5 |   schedule:
6 |     interval: daily
7 |     time: "04:00"
8 |   open-pull-requests-limit: 10
9 | 


--------------------------------------------------------------------------------
/.github/workflows/rust.yml:
--------------------------------------------------------------------------------
 1 | name: Rust
 2 | on: [push]
 3 | env:
 4 |   CARGO_TERM_COLOR: always
 5 | jobs:
 6 |   test:
 7 |     runs-on: ubuntu-latest
 8 |     steps:
 9 |     - uses: actions/checkout@v2
10 |     - uses: actions/cache@v2
11 |       with:
12 |         path: |
13 |           ~/.cargo/registry
14 |           ~/.cargo/git
15 |           target
16 |         key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
17 |     - run: cargo build --verbose
18 |     - run: cargo test --verbose
19 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /Cargo.lock
2 | /target
3 | /release
4 | TODO.md
5 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # Changelog
  2 | 
  3 | ## Unreleased
  4 | 
  5 | ### 0.7.0 (2021-08-21)
  6 | ### Fixed
  7 | - Fix getopts parsing (#75)
  8 | ### Added
  9 | - Add `no_std` support to lib (#81)
 10 | - Add chess prelude to lib (#82)
 11 | ### Changed
 12 | - Increase search reductions (#47)
 13 | - Speed up large transposition table creations (#48)
 14 | - Used std::time instead of time (#49)
 15 | - Upgrade dependencies (#58)
 16 | - Migrate from TravisCI to GitHub Actions (#66)
 17 | - Upgrade to GitHub-native Dependabot (#72)
 18 | - Update colored requirement from 1.9.3 to 2.0.0 (#60)
 19 | 
 20 | ## 0.6.0 (2019-12-22)
 21 | ### Fixed
 22 | - Fix castling right update bug
 23 | - Fix pawn move disambiguation in SAN
 24 | - Fix white pieces color with black on white terminals in CLI
 25 | - Avoid panicking in CLI
 26 | ### Added
 27 | - Add makefile
 28 | - Parse moves in SAN format (#41)
 29 | - Add `go movetime` command to UCI (#40)
 30 | - Add `load pgn` and `save pgn` commands to CLI (#42)
 31 | - Add `play none` subcommand to CLI
 32 | - Add `init` command to CLI
 33 | - Add command history file to CLI (#38)
 34 | - Add autocompletion to CLI (#36)
 35 | ### Changed
 36 | - Increase futility pruning depth (#44)
 37 | - Avoid TT cutoff on PV-nodes
 38 | - Split PV over multiple lines in CLI mode (#45)
 39 | - Add error propagation to CLI commands (#43)
 40 | - Improve colors in CLI
 41 | - Refactor board drawing
 42 | - Update dependencies
 43 | 
 44 | ## 0.5.0 (2018-07-18)
 45 | ### Added
 46 | - Use Hyperbola Quintessence and First Rank Attacks for sliding piece attacks
 47 | - Use Xorshift random number generator for Zobrist hashing
 48 | - Add depth parameter to `perft` CLI command
 49 | - Add `save fen` and `save pgn` CLI commands
 50 | - Add `--silent` flag to executable
 51 | ### Changed
 52 | - Improve CLI output
 53 | - Rename `load` CLI command to `load fen`
 54 | - Rename `Direction` to `Shift` and introduce a new (compass) `Direction`
 55 | - Rename `Move*` to `PieceMove*`
 56 | - Store castling rights in a u8 in `Position`
 57 | - Use fail-soft instead of fail-hard in search
 58 | - Refactor many parts of the code
 59 | 
 60 | ## 0.4.0 (2017-11-20)
 61 | ### Added
 62 | - Add library with public API and documentation
 63 | - Add getopt to parse program options
 64 | - Add readline to user interface
 65 | - Add piece square tables to evaluation
 66 | - Add upper and lower bounds in transposition table
 67 | - Add age field in transposition table
 68 | - Add delta pruning to quiescence search
 69 | - Add transposition table to quiescence search
 70 | - Add basic UCI support
 71 | - Add very basic parallel search in threads with shared transposition table
 72 | ### Changed
 73 | - Improve CLI
 74 | - Improve statistics debug output
 75 | - Refactor many parts of the code
 76 | - Allow NMP, IID, and LMR at shallower depth
 77 | - Set NMP R to 3
 78 | 
 79 | ## 0.3.0 (2017-10-11)
 80 | ### Added
 81 | - Add principal variation search
 82 | - Add internal iterative deepening
 83 | - Add late move reduction
 84 | - Add killer heuristic
 85 | - Add basic null move pruning
 86 | - Add basic futility pruning
 87 | - Add basic mobility evaluation
 88 | - Add static exchange evaluation
 89 | ### Changed
 90 | - Use static exchange evaluation in moves ordering
 91 | - Skip bad captures in quiescence search
 92 | 
 93 | ## 0.2.0 (2016-08-22)
 94 | ### Added
 95 | - Add basic quiescence search
 96 | - Add basic transposition table
 97 | - Add MVV/LVA moves ordering by insertion sort
 98 | - Add staged moves generation
 99 | - Add fullmoves and halfmoves counting
100 | - Add draw detection
101 | - Add mate pruning
102 | - Add XBoard `memory` command
103 | - Add `color` and `debug` command line flag
104 | ### Changed
105 | - Improve user interface
106 | - Display game result in XBoard
107 | - Save best move during iterative deepening
108 | - Print principal variation from transpositions table
109 | ### Fixed
110 | - Fix compiler warnings
111 | - Fix castling bug
112 | - Fix bug when undoing promotions
113 | 
114 | ## 0.1.0 (2016-08-10)
115 | ### Changed
116 | - Improve time management
117 | ### Fixed
118 | - Fix compiler errors and warnings
119 | - Fix bug in search function
120 | - Fix promotion parsing bug
121 | 
122 | ## 0.0.1 (2015-06-09)
123 | ### Added
124 | - Add bitboard moves generation with De Bruijn sequence
125 | - Add board array representation
126 | - Add basic evaluation
127 | - Add alpha beta pruning
128 | - Add iterative deepening
129 | - Add basic time management
130 | - Add support of XBoard protocol
131 | - Add Zobrist hashing
132 | - Add FEN support
133 | - Add `perft`, `perftsuite`, and `divide` commands in user interface
134 | - Add Travis CI
135 | 
136 | ## 0.0.0 (2014-12-23)
137 | ### Added
138 | - Initial commit
139 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "littlewing"
 3 | description = """
 4 | A chess engine rated at 2050+ ELO, compatible with both UCI and XBoard
 5 | protocols, with a nice CLI, and a documented library.
 6 | """
 7 | version = "0.7.0"
 8 | license = "MIT"
 9 | authors = ["Vincent Ollivier <v@vinc.cc>"]
10 | repository = "https://github.com/vinc/littlewing"
11 | homepage = "https://vinc.cc/software/littlewing"
12 | readme = "README.md"
13 | 
14 | [lib]
15 | name = "littlewing"
16 | path = "src/lib.rs"
17 | 
18 | [[bin]]
19 | name = "littlewing"
20 | path = "src/main.rs"
21 | doc = false
22 | 
23 | [features]
24 | default = ["std", "bin"]
25 | std = ["dirs", "regex", "rustyline", "rustyline-derive", "no-std-compat/std"]
26 | bin = ["atty", "getopts"]
27 | 
28 | [dependencies]
29 | atty = { version = "0.2.14", optional = true }
30 | dirs = { version = "4.0.0", optional = true }
31 | getopts = { version = "0.2.21", optional = true }
32 | lazy_static = "1.4.0"
33 | no-std-compat = { version = "0.4.1", features = ["alloc", "compat_macros"] }
34 | rand = { version = "0.8.5", default-features = false }
35 | rand_xorshift = { version = "0.3.0", default-features = false }
36 | regex = { version = "1.3.9", optional = true }
37 | rustyline = { version = "10.0.0", optional = true }
38 | rustyline-derive = { version = "0.7.0", optional = true }
39 | 
40 | [badges]
41 | travis-ci = { repository = "vinc/littlewing" }
42 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014-2023 Vincent Ollivier
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | .PHONY: setup build install clean cross
 2 | .EXPORT_ALL_VARIABLES:
 3 | 
 4 | PREFIX = /usr/local
 5 | LITTLEWING_VERSION = $(shell git describe)
 6 | build: RUSTFLAGS = -C target-cpu=native
 7 | 
 8 | build:
 9 | 	cargo build --release
10 | 
11 | setup:
12 | 	curl https://sh.rustup.rs -sSf | sh
13 | 	rustup update
14 | 
15 | install:
16 | 	cp target/release/littlewing $(PREFIX)/bin
17 | 
18 | uninstall:
19 | 	rm -f $(PREFIX)/bin/littlewing
20 | 
21 | clean:
22 | 	cargo clean
23 | 
24 | release:
25 | 	mkdir -p release
26 | 	cp README.md release/README.txt
27 | 	cp LICENSE release/LICENSE.txt
28 | 	cp CHANGELOG.md release/CHANGELOG.txt
29 | 	cross build --release --target x86_64-unknown-linux-gnu
30 | 	cross build --release --target x86_64-pc-windows-gnu
31 | 	cross build --release --target armv7-linux-androideabi
32 | 	cp target/x86_64-unknown-linux-gnu/release/littlewing release/littlewing-$(LITTLEWING_VERSION)-linux-x86
33 | 	cp target/armv7-linux-androideabi/release/littlewing release/littlewing-$(LITTLEWING_VERSION)-android-armv7
34 | 	cp target/x86_64-pc-windows-gnu/release/littlewing.exe release/littlewing-$(LITTLEWING_VERSION)-windows-x86.exe
35 | 	gzip release/littlewing-*
36 | 	cd release && shasum littlewing-* > shasums.txt
37 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | Little Wing: a chess engine written in Rust
  2 | ===========================================
  3 | 
  4 | [![Travis](https://img.shields.io/travis/vinc/littlewing/master.svg)](https://travis-ci.org/vinc/littlewing/branches)
  5 | [![Crates.io](https://img.shields.io/crates/v/littlewing.svg)](https://crates.io/crates/littlewing)
  6 | 
  7 | Little Wing is the successor of [Purple Haze](https://github.com/vinc/purplehaze).
  8 | 
  9 | The project started in December 2014 to learn the Rust language and play with
 10 | bitboards. Both experiments were conclusive and Little Wing it is still
 11 | maintained in 2023.
 12 | 
 13 | Currently evaluated at around 2200 ELO on CCRL 40/4 Rating List.
 14 | 
 15 | [![asciicast](https://asciinema.org/a/146112.png)](https://asciinema.org/a/146112)
 16 | 
 17 | 
 18 | Features
 19 | --------
 20 | 
 21 | - Interfaces
 22 |   - A nice CLI with many commands
 23 |   - XBoard and UCI communication protocols
 24 |   - Public API with [documented library](https://docs.rs/littlewing)
 25 | - Board representation
 26 |   - Bitboard with LLVM CTPOP and CTTZ
 27 |   - Sliding piece attacks with Hyperbola Quintessence and First Rank Attacks
 28 |   - Zobrist hashing with Xorshift RNG
 29 |   - Staged moves generation
 30 |   - MVV/LVA and SEE moves ordering with insertion sort
 31 |   - FEN support
 32 | - Search
 33 |   - Principal variation search
 34 |   - Quiescence search
 35 |   - Transposition table
 36 |   - Null move pruning
 37 |   - Internal iterative deepening
 38 |   - Futility pruning
 39 |   - Late move reduction
 40 |   - Killer heuristic
 41 | - Evaluation
 42 |   - Piece square table evaluation
 43 |   - Mobility evaluation
 44 |   - Static exchange evaluation
 45 | 
 46 | 
 47 | Install
 48 | -------
 49 | 
 50 | Binaries for GNU/Linux (x86-64), Android (ARMv7), and Windows (x86-64) are
 51 | available: https://vinc.cc/binaries
 52 | 
 53 | If you want to compile Little Wing yourself, you must first install Rust:
 54 | 
 55 |     $ curl https://sh.rustup.rs -sSf | sh
 56 | 
 57 | Then you can install the latest stable version of the engine with Cargo:
 58 | 
 59 |     $ cargo install littlewing
 60 | 
 61 | Or the development version by fetching the git repository:
 62 | 
 63 |     $ git clone https://github.com/vinc/littlewing.git
 64 |     $ cd littlewing
 65 |     $ export RUSTFLAGS="-C target-cpu=native"
 66 |     $ export LITTLEWING_VERSION="$(git describe)"
 67 |     $ cargo build --release
 68 |     $ sudo cp target/release/littlewing /usr/local/bin
 69 | 
 70 | 
 71 | Usage
 72 | -----
 73 | 
 74 | Little Wing is compatible with XBoard and UCI communication protocols,
 75 | and in addition it has its own text-based user interface:
 76 | 
 77 |     $ littlewing
 78 |                                           _,;
 79 |                    ,       .--.       _,-'.-;
 80 |                     \`-, <) o  `._ ,-' ,'`_7
 81 |                     <_  `-\ _       _,' _.'
 82 |                       <_`".| `\    `  _.>
 83 |                         <_ ;   \     _>
 84 |                          `"     ;  ``
 85 |       Little Wing v0.7.0    \   |   \
 86 |                              '|-. _  \
 87 |       by Vincent Ollivier  _/ /     \ '.
 88 |       +---+---+---+---+---+"-"`---+--'\_>
 89 |       | r | n | b | q | k | b | n | r | 8
 90 |       +---+---+---+---+---+---+---+---+
 91 |       | p | p | p | p | p | p | p | p | 7
 92 |       +---+---+---+---+---+---+---+---+
 93 |       |   |   |   |   |   |   |   |   | 6
 94 |       +---+---+---+---+---+---+---+---+
 95 |       |   |   |   |   |   |   |   |   | 5
 96 |       +---+---+---+---+---+---+---+---+
 97 |       |   |   |   |   |   |   |   |   | 4
 98 |       +---+---+---+---+---+---+---+---+
 99 |       |   |   |   |   |   |   |   |   | 3
100 |       +---+---+---+---+---+---+---+---+
101 |       | P | P | P | P | P | P | P | P | 2
102 |       +---+---+---+---+---+---+---+---+
103 |       | R | N | B | Q | K | B | N | R | 1
104 |       +---+---+---+---+---+---+---+---+
105 |         a   b   c   d   e   f   g   h
106 | 
107 |     > move e4
108 | 
109 |       +---+---+---+---+---+---+---+---+
110 |       | r | n | b | q | k | b | n | r | 8
111 |       +---+---+---+---+---+---+---+---+
112 |       | p | p | p | p | p | p | p | p | 7
113 |       +---+---+---+---+---+---+---+---+
114 |       |   |   |   |   |   |   |   |   | 6
115 |       +---+---+---+---+---+---+---+---+
116 |       |   |   |   |   |   |   |   |   | 5
117 |       +---+---+---+---+---+---+---+---+
118 |       |   |   |   |   | P |   |   |   | 4
119 |       +---+---+---+---+---+---+---+---+
120 |       |   |   |   |   |   |   |   |   | 3
121 |       +---+---+---+---+---+---+---+---+
122 |       | P | P | P | P |   | P | P | P | 2
123 |       +---+---+---+---+---+---+---+---+
124 |       | R | N | B | Q | K | B | N | R | 1
125 |       +---+---+---+---+---+---+---+---+
126 |         a   b   c   d   e   f   g   h
127 | 
128 |     > time 1 10
129 |     > show think
130 |     > play black
131 | 
132 |       ply  score    time      nodes  pv
133 |         1    -46       0          1  1. ... a6
134 |         1    -45       0          3  1. ... c6
135 |         1    -22       0          4  1. ... d6
136 |         1    -20       0          5  1. ... e6
137 |         1     -1       0         14  1. ... d5
138 |         1      0       0         15  1. ... e5
139 |         1      9       0         20  1. ... Nc6
140 |         2    -47       0         53  1. ... Nc6 2. Nc3
141 |         3      9       0        278  1. ... Nc6 2. Nc3 Nf6
142 |         4    -45       0        860  1. ... Nc6 2. Nc3 Nf6 3. Nf3
143 |         4    -31       1       2437  1. ... d5 2. exd5 Qxd5 3. Nc3
144 |         5    -32       1       4647  1. ... d5 2. exd5 Qxd5 3. Nc3 Qd4
145 |         5    -20       2       7442  1. ... d6 2. Nc3 Nf6 3. Nf3 Nc6
146 |         5      0       2      11381  1. ... e5 2. Nc3 Nf6 3. Nf3 Nc6
147 |         5      1       2      12946  1. ... Nc6 2. Nc3 Nf6 3. Nf3 d5
148 |         6    -21       3      14052  1. ... Nc6 2. Nc3 Nf6 3. Nf3 d5 4. d3
149 |         7     -7       6      34813  1. ... Nc6 2. Nf3 Nf6 3. e5 Ng4 4. d4 d5
150 |         8    -29       9      53113  1. ... Nc6 2. Nf3 Nf6 3. e5 Ng4 4. d4 d6
151 |                                      5. h3
152 |         9    -25      27     181431  1. ... Nc6 2. d4 d5 3. e5 e6 4. Nc3 Bb4
153 |                                      5. Nf3 Nge7
154 |         9    -12      35     241217  1. ... e5 2. Nc3 Nf6 3. Nf3 Nc6 4. d4 exd4
155 |                                      5. Nxd4 d5
156 |        10    -10      50     363028  1. ... e5 2. Nc3 Nf6 3. Nf3 Nc6 4. d4 exd4
157 |                                      5. Nxd4 d5 6. f3
158 |        11     -7     109     815399  1. ... e5 2. Nf3 Nf6 3. Nxe5 d6 4. Nc4 Nxe4
159 |                                      5. d3 Nf6 6. Nc3 Nc6
160 |        12    -23     218    1686098  1. ... e5 2. Nf3 Nf6 3. Nc3 Nc6 4. d4 exd4
161 |                                      5. Nxd4 d5 6. exd5 Nxd5 7. Bc4
162 |        13    -13     467    3791367  1. ... e5 2. Nf3 Nf6 3. Nc3 Nc6 4. d4 exd4
163 |                                      5. Nxd4 d5 6. exd5 Nxd5 7. Bc4
164 | 
165 |     < move e5
166 | 
167 |       +---+---+---+---+---+---+---+---+
168 |       | r | n | b | q | k | b | n | r | 8
169 |       +---+---+---+---+---+---+---+---+
170 |       | p | p | p | p |   | p | p | p | 7
171 |       +---+---+---+---+---+---+---+---+
172 |       |   |   |   |   |   |   |   |   | 6
173 |       +---+---+---+---+---+---+---+---+
174 |       |   |   |   |   | p |   |   |   | 5
175 |       +---+---+---+---+---+---+---+---+
176 |       |   |   |   |   | P |   |   |   | 4
177 |       +---+---+---+---+---+---+---+---+
178 |       |   |   |   |   |   |   |   |   | 3
179 |       +---+---+---+---+---+---+---+---+
180 |       | P | P | P | P |   | P | P | P | 2
181 |       +---+---+---+---+---+---+---+---+
182 |       | R | N | B | Q | K | B | N | R | 1
183 |       +---+---+---+---+---+---+---+---+
184 |         a   b   c   d   e   f   g   h
185 | 
186 |     > help
187 | 
188 |     Commands:
189 | 
190 |       quit                      Exit this program
191 |       help                      Display this screen
192 |       load [<options>]          Load game from <options>
193 |       save [<options>]          Save game to <options>
194 |       hint                      Search the best move
195 |       play [<color>]            Search and play [<color>] move[s]
196 |       undo                      Undo the last move
197 |       move <move>               Play <move> on the board
198 | 
199 |       show <feature>            Show <feature>
200 |       hide <feature>            Hide <feature>
201 |       time <moves> <time>       Set clock to <moves> in <time> (in seconds)
202 |       hash <size>               Set the <size> of the memory (in MB)
203 |       core <number>             Set the <number> of threads
204 | 
205 |       perft [<depth>]           Count the nodes at each depth
206 |       perftsuite <epd>          Compare perft results to each position of <epd>
207 |       testsuite <epd> [<time>]  Search each position of <epd> [for <time>]
208 |       divide <depth>            Count the nodes at <depth> for each moves
209 | 
210 |       uci                       Start UCI mode
211 |       xboard                    Start XBoard mode
212 | 
213 |     Made with <3 in 2014-2023 by Vincent Ollivier <v@vinc.cc>
214 | 
215 |     Report bugs to https://github.com/vinc/littlewing/issues
216 | 
217 |     > quit
218 | 
219 | 
220 | Tests
221 | -----
222 | 
223 | Run the test suite with Cargo:
224 | 
225 |     $ cargo test
226 | 
227 | Little Wing also have a `perft` command for counting the number of nodes at
228 | each depth from the starting position.
229 | 
230 |     $ cargo run -- --silent
231 |     > perft
232 |     perft 1 -> 20 (0.00 s, 5.83e4 nps)
233 |     perft 2 -> 400 (0.00 s, 7.62e5 nps)
234 |     perft 3 -> 8902 (0.01 s, 7.44e5 nps)
235 |     perft 4 -> 197281 (0.16 s, 1.26e6 nps)
236 |     perft 5 -> 4865609 (3.82 s, 1.27e6 nps)
237 | 
238 | And a `perftsuite` command for comparing the results of a perft calculation
239 | with the given EPD file.
240 | 
241 |     $ cargo run -- --silent
242 |     > perftsuite tests/perftsuite.epd
243 |     rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1 -> ......
244 |     r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1 -> ......
245 |     4k3/8/8/8/8/8/8/4K2R w K - 0 1 -> ......
246 |     4k3/8/8/8/8/8/8/R3K3 w Q - 0 1 -> ......
247 |     4k2r/8/8/8/8/8/8/4K3 w k - 0 1 -> ......
248 |     r3k3/8/8/8/8/8/8/4K3 w q - 0 1 -> ......
249 |     4k3/8/8/8/8/8/8/R3K2R w KQ - 0 1 -> ......
250 |     r3k2r/8/8/8/8/8/8/4K3 w kq - 0 1 -> ......
251 |     8/8/8/8/8/8/6k1/4K2R w K - 0 1 -> ......
252 |     8/8/8/8/8/8/1k6/R3K3 w Q - 0 1 -> ......
253 |     4k2r/6K1/8/8/8/8/8/8 w k - 0 1 -> ......
254 |     r3k3/1K6/8/8/8/8/8/8 w q - 0 1 -> ......
255 | 
256 | And the usual debug commands like `divide` or `testsuite`:
257 | 
258 |     $ cargo run -- --silent
259 |     > testsuite tests/wac.epd 1
260 |     2rr3k/pp3pp1/1nnqbN1p/3pN3/2pP4/2P3Q1/PPB4P/R4RK1 w - - bm Qg6 -> Qg6
261 |     8/7p/5k2/5p2/p1p2P2/Pr1pPK2/1P1R3P/8 b - - bm Rxb2 -> c3
262 |     5rk1/1ppb3p/p1pb4/6q1/3P1p1r/2P1R2P/PP1BQ1P1/5RKN w - - bm Rg3 -> Rg3
263 |     r1bq2rk/pp3pbp/2p1p1pQ/7P/3P4/2PB1N2/PP3PPR/2KR4 w - - bm Qxh7+ -> Qxh7+
264 |     5k2/6pp/p1qN4/1p1p4/3P4/2PKP2Q/PP3r2/3R4 b - - bm Qc4+ -> Qc4+
265 |     7k/p7/1R5K/6r1/6p1/6P1/8/8 w - - bm Rb7 -> Rb7
266 |     rnbqkb1r/pppp1ppp/8/4P3/6n1/7P/PPPNPPP1/R1BQKBNR b KQkq - bm Ne3 -> Ne3
267 |     r4q1k/p2bR1rp/2p2Q1N/5p2/5p2/2P5/PP3PPP/R5K1 w - - bm Rf7 -> Rf7
268 |     3q1rk1/p4pp1/2pb3p/3p4/6Pr/1PNQ4/P1PB1PP1/4RRK1 b - - bm Bh2+ -> Bh2+
269 |     2br2k1/2q3rn/p2NppQ1/2p1P3/Pp5R/4P3/1P3PPP/3R2K1 w - - bm Rxh7 -> Rxh7
270 |     r1b1kb1r/3q1ppp/pBp1pn2/8/Np3P2/5B2/PPP3PP/R2Q1RK1 w kq - bm Bxc6 -> Bxc6
271 | 
272 | Here we used `cargo run` to run the engine in debug mode, but you can invoke
273 | it from `littlewing` if you installed it to make it run (much) faster.
274 | 
275 | The CLI as been designed to interface nicely with other Unix tools, for example
276 | to test if the times from perft are stable you can do:
277 | 
278 |     $ for i in $(seq 0 10); do littlewing -s <<< "perft 6"; sleep 1; done
279 | 
280 | Anyway, have fun with it and send me your feedback at <v@vinc.cc>!
281 | 
282 | 
283 | License
284 | -------
285 | 
286 | Little Wing is released under MIT.
287 | 


--------------------------------------------------------------------------------
/benches/littlewing.rs:
--------------------------------------------------------------------------------
  1 | #![feature(test)]
  2 | 
  3 | extern crate test;
  4 | extern crate littlewing;
  5 | 
  6 | use test::Bencher;
  7 | 
  8 | use littlewing::color;
  9 | use littlewing::eval::Eval;
 10 | use littlewing::fen::FEN;
 11 | use littlewing::game::Game;
 12 | use littlewing::piece_move_generator::PieceMoveGenerator;
 13 | use littlewing::piece_move_notation::PieceMoveNotation;
 14 | use littlewing::search::Search;
 15 | 
 16 | #[bench]
 17 | fn bench_next_move(b: &mut Bencher) {
 18 |     let mut game = Game::from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").unwrap();
 19 | 
 20 |     b.iter(|| {
 21 |         let mut n = 0;
 22 |         game.moves.clear();
 23 |         while let Some(_) = game.next_move() {
 24 |             n += 1;
 25 |         }
 26 |         n
 27 |     })
 28 | }
 29 | 
 30 | #[bench]
 31 | fn bench_next_move_without_ordering(b: &mut Bencher) {
 32 |     let mut game = Game::from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").unwrap();
 33 |     game.moves.skip_ordering = true;
 34 | 
 35 |     b.iter(|| {
 36 |         let mut n = 0;
 37 |         game.moves.clear();
 38 |         while let Some(_) = game.next_move() {
 39 |             n += 1;
 40 |         }
 41 |         n
 42 |     })
 43 | }
 44 | 
 45 | #[bench]
 46 | fn bench_make_undo_move(b: &mut Bencher) {
 47 |     let mut game = Game::from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").unwrap();
 48 |     let m = game.move_from_lan("e2e4");
 49 | 
 50 |     b.iter(|| {
 51 |         game.make_move(m);
 52 |         game.undo_move(m);
 53 |     })
 54 | }
 55 | 
 56 | #[bench]
 57 | fn bench_eval(b: &mut Bencher) {
 58 |     let game = Game::from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").unwrap();
 59 | 
 60 |     b.iter(|| {
 61 |         game.eval()
 62 |     })
 63 | }
 64 | 
 65 | #[bench]
 66 | fn bench_eval_material(b: &mut Bencher) {
 67 |     let game = Game::from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").unwrap();
 68 | 
 69 |     b.iter(|| {
 70 |         game.eval_material(color::WHITE)
 71 |     })
 72 | }
 73 | 
 74 | #[bench]
 75 | fn bench_see(b: &mut Bencher) {
 76 |     let mut game = Game::from_fen("rnbqkb1r/pp2pppp/2p2n2/1B1p4/4P3/2N5/PPPP1PPP/R1BQK1NR w KQkq - 0 4").unwrap();
 77 |     let m = game.move_from_lan("c2d5");
 78 | 
 79 |     b.iter(|| {
 80 |         game.see(m)
 81 |     })
 82 | }
 83 | 
 84 | #[bench]
 85 | fn bench_search(b: &mut Bencher) {
 86 |     let mut game = Game::from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").unwrap();
 87 | 
 88 |     b.iter(|| {
 89 |         game.search(1..5)
 90 |     })
 91 | }
 92 | 
 93 | #[bench]
 94 | fn bench_perft(b: &mut Bencher) {
 95 |     let mut game = Game::from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").unwrap();
 96 |     b.iter(|| {
 97 |         game.perft(3)
 98 |     });
 99 | }
100 | 
101 | #[bench]
102 | fn bench_move_from_lan(b: &mut Bencher) {
103 |     let mut game = Game::from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").unwrap();
104 |     b.iter(|| {
105 |         game.move_from_lan("e2e4");
106 |     });
107 | }
108 | 
109 | #[bench]
110 | fn bench_move_from_san(b: &mut Bencher) {
111 |     let mut game = Game::from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").unwrap();
112 |     b.iter(|| {
113 |         game.move_from_san("e4");
114 |     });
115 | }
116 | 
117 | #[bench]
118 | fn bench_tt_16mb_get(b: &mut Bencher) {
119 |     let mut game = Game::from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").unwrap();
120 |     let m = game.move_from_lan("e2e4");
121 |     game.tt_resize(16 << 20); // 16 MB
122 |     game.search(1..5);
123 |     game.make_move(m);
124 |     let hash = game.positions.top().hash;
125 |     b.iter(|| {
126 |         if let Some(t) = game.tt.get(hash) {
127 |             t.score()
128 |         } else {
129 |             0
130 |         }
131 |     })
132 | }
133 | 
134 | #[bench]
135 | fn bench_tt_256mb_get(b: &mut Bencher) {
136 |     let mut game = Game::from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").unwrap();
137 |     let m = game.move_from_lan("e2e4");
138 |     game.tt_resize(256 << 20); // 256 MB
139 |     game.search(1..5);
140 |     game.make_move(m);
141 |     let hash = game.positions.top().hash;
142 |     b.iter(|| {
143 |         if let Some(t) = game.tt.get(hash) {
144 |             t.score()
145 |         } else {
146 |             0
147 |         }
148 |     })
149 | }
150 | 


--------------------------------------------------------------------------------
/src/attack.rs:
--------------------------------------------------------------------------------
  1 | use crate::color::*;
  2 | use crate::piece::*;
  3 | use crate::square::*;
  4 | use crate::common::*;
  5 | use crate::bitboard::{Bitboard, BitboardExt};
  6 | use crate::game::Game;
  7 | use crate::hyperbola::bishop_attacks;
  8 | use crate::hyperbola::rook_attacks;
  9 | 
 10 | pub trait Attack {
 11 |     fn is_check(&self, side: Color) -> bool;
 12 |     fn is_attacked(&self, square: Square, side: Color) -> bool;
 13 |     fn attacks_to(&self, square: Square, occupied: Bitboard) -> Bitboard;
 14 | }
 15 | 
 16 | impl Attack for Game {
 17 |     fn is_check(&self, side: Color) -> bool {
 18 |         let king = self.bitboards[(side | KING) as usize];
 19 |         king == 0 || self.is_attacked(king.scan() as Square, side)
 20 |     }
 21 | 
 22 |     fn is_attacked(&self, square: Square, side: Color) -> bool {
 23 |         let bbs = &self.bitboards;
 24 | 
 25 |         let occupied = bbs[WHITE as usize] | bbs[BLACK as usize];
 26 | 
 27 |         let pawns = bbs[(side ^ 1 | PAWN) as usize];
 28 |         let attacks = PAWN_ATTACKS[side as usize][square as usize];
 29 |         if attacks & pawns > 0 {
 30 |             return true;
 31 |         }
 32 | 
 33 |         let knights = bbs[(side ^ 1 | KNIGHT) as usize];
 34 |         let attacks = PIECE_MASKS[KNIGHT as usize][square as usize];
 35 |         if attacks & knights > 0 {
 36 |             return true;
 37 |         }
 38 | 
 39 |         let king = bbs[(side ^ 1 | KING) as usize];
 40 |         let attacks = PIECE_MASKS[KING as usize][square as usize];
 41 |         if attacks & king > 0 {
 42 |             return true;
 43 |         }
 44 | 
 45 |         let queens = bbs[(side ^ 1 | QUEEN) as usize];
 46 | 
 47 |         let bishops = bbs[(side ^ 1 | BISHOP) as usize];
 48 |         let attacks = bishop_attacks(square, occupied);
 49 |         if attacks & (bishops | queens) > 0 {
 50 |             return true;
 51 |         }
 52 | 
 53 |         let rooks = bbs[(side ^ 1 | ROOK) as usize];
 54 |         let attacks = rook_attacks(square, occupied);
 55 |         if attacks & (rooks | queens) > 0 {
 56 |             return true;
 57 |         }
 58 | 
 59 |         false
 60 |     }
 61 | 
 62 |     fn attacks_to(&self, square: Square, occupied: Bitboard) -> Bitboard {
 63 |         let bbs = &self.bitboards;
 64 | 
 65 |         // Read the array in sequential order from bbs[0] to bbs[13]
 66 |         let wpawns  = bbs[WHITE_PAWN   as usize];
 67 |         let bpawns  = bbs[BLACK_PAWN   as usize];
 68 |         let knights = bbs[WHITE_KNIGHT as usize] | bbs[BLACK_KNIGHT as usize];
 69 |         let kings   = bbs[WHITE_KING   as usize] | bbs[BLACK_KING   as usize];
 70 |         let bishops = bbs[WHITE_BISHOP as usize] | bbs[BLACK_BISHOP as usize];
 71 |         let rooks   = bbs[WHITE_ROOK   as usize] | bbs[BLACK_ROOK   as usize];
 72 |         let queens  = bbs[WHITE_QUEEN  as usize] | bbs[BLACK_QUEEN  as usize];
 73 | 
 74 |         (wpawns             & piece_attacks(BLACK_PAWN, square, occupied)) |
 75 |         (bpawns             & piece_attacks(WHITE_PAWN, square, occupied)) |
 76 |         (knights            & piece_attacks(KNIGHT,     square, occupied)) |
 77 |         (kings              & piece_attacks(KING,       square, occupied)) |
 78 |         ((queens | bishops) & piece_attacks(BISHOP,     square, occupied)) |
 79 |         ((queens | rooks)   & piece_attacks(ROOK,       square, occupied))
 80 |     }
 81 | }
 82 | 
 83 | /// Return the attacks bitboard of a piece attacks to a square
 84 | pub fn piece_attacks(piece: Piece, square: Square, occupied: Bitboard) -> Bitboard {
 85 |     match piece.kind() {
 86 |         PAWN   => PAWN_ATTACKS[piece.color() as usize][square as usize],
 87 |         KNIGHT => PIECE_MASKS[KNIGHT as usize][square as usize],
 88 |         KING   => PIECE_MASKS[KING as usize][square as usize],
 89 |         BISHOP => bishop_attacks(square, occupied),
 90 |         ROOK   => rook_attacks(square, occupied),
 91 |         QUEEN  => bishop_attacks(square, occupied) | rook_attacks(square, occupied),
 92 |         _      => unreachable!()
 93 |     }
 94 | }
 95 | 
 96 | lazy_static! {
 97 |     pub static ref PAWN_ATTACKS: [[Bitboard; 64]; 2] = {
 98 |         let xdirs = [LEFT, RIGHT];
 99 |         let ydirs = [DOWN, UP];
100 |         let files = [FILE_H, FILE_A];
101 |         let mut attacks = [[0; 64]; 2];
102 |         for side in 0..2 {
103 |             for square in 0..64 {
104 |                 for i in 0..2 {
105 |                     let dir = ydirs[side ^ 1] + xdirs[i];
106 |                     attacks[side][square] |= (1 << square).shift(dir) & !files[i];
107 |                 }
108 |             }
109 |         }
110 |         attacks
111 |     };
112 | }
113 | 
114 | #[cfg(test)]
115 | mod tests {
116 |     use super::*;
117 |     use crate::fen::FEN;
118 | 
119 |     #[test]
120 |     fn test_piece_attacks() {
121 |         let fen = "r1bqk2r/1pppbppp/p1n2n2/4p3/B3P3/5N2/PPPP1PPP/RNBQR1K1 b kq - 5 6";
122 |         let game = Game::from_fen(fen).unwrap();
123 | 
124 |         let occupied = game.bitboard(WHITE) | game.bitboard(BLACK);
125 | 
126 |         assert_eq!(game.board[A4 as usize], WHITE | BISHOP);
127 |         assert_eq!(game.board[C2 as usize], WHITE | PAWN);
128 |         assert_eq!(game.board[C6 as usize], BLACK | KNIGHT);
129 | 
130 |         // Return the attacks set of bishop attacks to C6
131 |         let attacks = piece_attacks(WHITE | BISHOP, C6, occupied);
132 |         assert_eq!(attacks.count(), 6);
133 |         assert_eq!(attacks & game.bitboard(WHITE | BISHOP), 1 << A4);
134 | 
135 |         // Return the attacks set of bishop attacks from A4
136 |         let moves = piece_attacks(WHITE | BISHOP, A4, occupied);
137 |         assert_eq!(moves.count(), 4);
138 | 
139 |         let quiet_moves = moves & !occupied;
140 |         assert_eq!(quiet_moves.count(), 2);
141 | 
142 |         let captures = moves & game.bitboard(BLACK);
143 |         assert_eq!(captures.count(), 1);
144 |         assert_eq!(captures.scan() as Square, C6);
145 | 
146 |         let defended = moves & game.bitboard(WHITE);
147 |         assert_eq!(defended.count(), 1);
148 |         assert_eq!(defended.scan() as Square, C2);
149 |     }
150 | 
151 |     #[test]
152 |     fn test_bishop_attacks() {
153 |         let fen = "r1bqk1nr/ppppbppp/2n5/1B2p3/4P3/5N2/PPPP1PPP/RNBQK2R w KQkq - 4 4";
154 |         let game = Game::from_fen(fen).unwrap();
155 |         let occupied = game.bitboard(WHITE) | game.bitboard(BLACK);
156 | 
157 |         bishop_attacks(B5, occupied).debug();
158 |         bishop_attacks(C8, occupied).debug();
159 |         bishop_attacks(E7, occupied).debug();
160 |         assert_eq!(bishop_attacks(B5, occupied), 0x0000050005081020);
161 |         assert_eq!(bishop_attacks(C8, occupied), 0x000A000000000000);
162 |         assert_eq!(bishop_attacks(E7, occupied), 0x2800284482010000);
163 |     }
164 | 
165 |     #[test]
166 |     fn test_rook_attacks() {
167 |         let fen = "r3k3/8/8/8/3R4/8/8/R3K3 w - - 0 1";
168 |         let game = Game::from_fen(fen).unwrap();
169 |         let occupied = game.bitboard(WHITE) | game.bitboard(BLACK);
170 | 
171 |         rook_attacks(A1, occupied).debug();
172 |         rook_attacks(A8, occupied).debug();
173 |         rook_attacks(D4, occupied).debug();
174 |         assert_eq!(rook_attacks(A1, occupied), 0x010101010101011E);
175 |         assert_eq!(rook_attacks(A8, occupied), 0x1E01010101010101);
176 |         assert_eq!(rook_attacks(D4, occupied), 0x08080808F7080808);
177 |     }
178 | }
179 | 


--------------------------------------------------------------------------------
/src/bitboard.rs:
--------------------------------------------------------------------------------
  1 | use std::prelude::v1::*;
  2 | 
  3 | use crate::common::*;
  4 | use crate::square::*;
  5 | use crate::board;
  6 | 
  7 | pub type Bitboard = u64;
  8 | 
  9 | pub trait BitboardExt {
 10 |     fn from_square(sq: Square) -> Bitboard;
 11 | 
 12 |     /// Population count using LLVM `ctpop`
 13 |     fn count(self) -> u32;
 14 | 
 15 |     /// Bitscan using LLVM `cttz`
 16 |     fn scan(self) -> u32;
 17 | 
 18 |     /// Generalized shift (left shift positive values and right shift negative values)
 19 |     fn shift(self, s: Shift) -> Bitboard;
 20 | 
 21 |     /// Get occupancy at the given square
 22 |     fn get(self, sq: Square) -> bool;
 23 | 
 24 |     /// Set occupancy bit at the given square
 25 |     fn set(&mut self, sq: Square);
 26 | 
 27 |     /// Toggle occupancy bit at the given square
 28 |     fn toggle(&mut self, sq: Square); // FIXME: Return instead of update?
 29 | 
 30 |     /// Reset occupancy bit at the given square
 31 |     fn reset(&mut self, sq: Square);
 32 | 
 33 |     fn debug(&self);
 34 |     fn to_debug_string(&self) -> String;
 35 | }
 36 | 
 37 | impl BitboardExt for Bitboard {
 38 |     fn from_square(sq: Square) -> Bitboard {
 39 |         //BB_SQUARES[sq as usize]
 40 |         //unsafe { *BB_SQUARES.get_unchecked(sq as usize) }
 41 |         1 << sq
 42 |     }
 43 | 
 44 |     #[inline]
 45 |     fn count(self) -> u32 {
 46 |         self.count_ones()
 47 |     }
 48 | 
 49 |     #[inline]
 50 |     fn scan(self) -> u32 {
 51 |         self.trailing_zeros()
 52 |     }
 53 | 
 54 |     #[inline]
 55 |     fn shift(self, s: Shift) -> Bitboard {
 56 |         if s > 0 {
 57 |             self << s
 58 |         } else {
 59 |             self >> -s
 60 |         }
 61 |     }
 62 | 
 63 |     #[inline]
 64 |     fn get(self, sq: Square) -> bool {
 65 |         (self & Bitboard::from_square(sq)) > 0
 66 |     }
 67 | 
 68 |     #[inline]
 69 |     fn set(&mut self, sq: Square) {
 70 |         *self |= Bitboard::from_square(sq)
 71 |     }
 72 | 
 73 |     #[inline]
 74 |     fn toggle(&mut self, sq: Square) {
 75 |         *self ^= Bitboard::from_square(sq)
 76 |     }
 77 | 
 78 |     #[inline]
 79 |     fn reset(&mut self, sq: Square) {
 80 |         *self &= !Bitboard::from_square(sq)
 81 |     }
 82 | 
 83 |     // FIXME: remove this method
 84 |     // #[deprecated(since="0.2.0", note="please use `to_debug_string` instead")]
 85 |     fn debug(&self) {
 86 |         println!("{}", self.to_debug_string());
 87 |     }
 88 | 
 89 |     fn to_debug_string(&self) -> String {
 90 |         let mut out = String::new();
 91 |         out.push_str(&format!(" Bitboard  (0x{:016X})\n", *self));
 92 |         let squares = (0..64).map(|i| {
 93 |             if self.get(i) {
 94 |                 bold_green("1")
 95 |             } else {
 96 |                 "0".to_string()
 97 |             }
 98 |         }).collect();
 99 |         out.push_str(&board::draw_compact_with_coordinates(squares));
100 |         out
101 |     }
102 | }
103 | 
104 | pub fn upfill(mut pieces: Bitboard) -> Bitboard {
105 |     pieces |= pieces << 8;
106 |     pieces |= pieces << 16;
107 |     pieces |= pieces << 32;
108 |     pieces
109 | }
110 | 
111 | pub fn downfill(mut pieces: Bitboard) -> Bitboard {
112 |     pieces |= pieces >> 8;
113 |     pieces |= pieces >> 16;
114 |     pieces |= pieces >> 32;
115 |     pieces
116 | }
117 | 
118 | pub fn filefill(pieces: Bitboard) -> Bitboard {
119 |     upfill(pieces) | downfill(pieces)
120 | }
121 | 
122 | pub trait BitboardIterator {
123 |     type Item;
124 |     fn next(&mut self) -> Option<Self::Item>;
125 | }
126 | 
127 | impl BitboardIterator for Bitboard {
128 |     type Item = Square;
129 | 
130 |     fn next(&mut self) -> Option<Square> {
131 |         if *self > 0 {
132 |             let sq = self.scan() as Square;
133 | 
134 |             self.reset(sq);
135 | 
136 |             Some(sq)
137 |         } else {
138 |             None
139 |         }
140 |     }
141 | }
142 | 
143 | /*
144 | lazy_static! {
145 |     static ref BB_SQUARES: [Bitboard; 64] = {
146 |         let mut bb_squares = [0; 64];
147 |         for sq in 0..64 {
148 |             bb_squares[sq] = 1 << sq;
149 |         }
150 |         bb_squares
151 |     };
152 | }
153 | */
154 | 
155 | #[cfg(test)]
156 | mod tests {
157 |     use super::*;
158 | 
159 |     #[test]
160 |     fn test_shift() {
161 |         let bb1: Bitboard = 0b0011000000000000000000000000000000110000000000000000000000000000;
162 |         let bb2: Bitboard = 0b1100000000000000000000000000000011000000000000000000000000000011;
163 |         let bb3: Bitboard = 0b0000000000000000000000000000001100000000000000000000000000001100;
164 | 
165 |         assert_eq!(bb2.shift(0),  bb2, "{:b} == {:b}", bb2, bb2);
166 |         assert_eq!(bb2 << 2,      bb3, "{:b} == {:b}", bb2, bb3);
167 |         assert_eq!(bb2.shift(2),  bb3, "{:b} == {:b}", bb2, bb3);
168 |         assert_eq!(bb2 >> 2,      bb1, "{:b} == {:b}", bb2, bb1);
169 |         assert_eq!(bb2.shift(-2), bb1, "{:b} == {:b}", bb2, bb1);
170 |     }
171 | 
172 |     #[test]
173 |     fn test_iterator() {
174 |         let mut bb: Bitboard = 0;
175 | 
176 |         bb.set(A2);
177 |         bb.set(B2);
178 |         bb.set(C2);
179 |         bb.set(D2);
180 | 
181 |         assert_eq!(bb.next(), Some(A2));
182 |         assert_eq!(bb.next(), Some(B2));
183 |         assert_eq!(bb.next(), Some(C2));
184 |         assert_eq!(bb.next(), Some(D2));
185 |         assert_eq!(bb.next(), None);
186 |     }
187 | }
188 | 


--------------------------------------------------------------------------------
/src/board.rs:
--------------------------------------------------------------------------------
  1 | use std::prelude::v1::*;
  2 | 
  3 | pub fn draw(squares: Vec<String>) -> String {
  4 |     let line = "  +---+---+---+---+---+---+---+---+\n";
  5 |     let file = "";
  6 |     draw_with(squares, line, file)
  7 | }
  8 | 
  9 | pub fn draw_with_coordinates(squares: Vec<String>) -> String {
 10 |     let line = "  +---+---+---+---+---+---+---+---+\n";
 11 |     let file = "    a   b   c   d   e   f   g   h\n";
 12 |     draw_with(squares, line, file)
 13 | }
 14 | 
 15 | pub fn draw_compact_with_coordinates(squares: Vec<String>) -> String {
 16 |     let line = "+--------+\n";
 17 |     let file = " abcdefgh\n";
 18 |     draw_with(squares, line, file)
 19 | }
 20 | 
 21 | fn draw_with(squares: Vec<String>, line: &str, file: &str) -> String {
 22 |     debug_assert!(squares.len() == 64);
 23 |     let with_spaces = line.len() > 12;
 24 |     let with_coords = !file.is_empty();
 25 |     let mut out = String::new();
 26 |     out.push_str(line);
 27 |     for i in (0..8).rev() {
 28 |         if with_spaces {
 29 |             out.push_str("  ");
 30 |         } else {
 31 |             out.push_str("|");
 32 |         }
 33 |         for j in 0..8 {
 34 |             let s = &squares[8 * i + j];
 35 |             if with_spaces {
 36 |                 out.push_str(&format!("| {} ", s));
 37 |             } else {
 38 |                 out.push_str(&format!("{}", s));
 39 |             }
 40 |         }
 41 |         if with_coords {
 42 |             out.push_str(&format!("| {}\n", i + 1));
 43 |         } else {
 44 |             out.push_str("|\n");
 45 |         }
 46 |         if with_spaces {
 47 |             out.push_str(line);
 48 |         }
 49 |     }
 50 |     if !with_spaces {
 51 |         out.push_str(line);
 52 |     }
 53 |     out.push_str(file);
 54 |     out
 55 | }
 56 | 
 57 | #[allow(dead_code)]
 58 | static PIECES_WITHOUT_COORDS: &str = "  \
 59 |   +---+---+---+---+---+---+---+---+
 60 |   | r | n | b | q | k | b | n | r |
 61 |   +---+---+---+---+---+---+---+---+
 62 |   | p | p | p | p | p | p | p | p |
 63 |   +---+---+---+---+---+---+---+---+
 64 |   |   |   |   |   |   |   |   |   |
 65 |   +---+---+---+---+---+---+---+---+
 66 |   |   |   |   |   |   |   |   |   |
 67 |   +---+---+---+---+---+---+---+---+
 68 |   |   |   |   |   | P |   |   |   |
 69 |   +---+---+---+---+---+---+---+---+
 70 |   |   |   |   |   |   |   |   |   |
 71 |   +---+---+---+---+---+---+---+---+
 72 |   | P | P | P | P |   | P | P | P |
 73 |   +---+---+---+---+---+---+---+---+
 74 |   | R | N | B | Q | K | B | N | R |
 75 |   +---+---+---+---+---+---+---+---+
 76 | ";
 77 | 
 78 | #[allow(dead_code)]
 79 | static PIECES_WITH_COORDS: &str = "  \
 80 |   +---+---+---+---+---+---+---+---+
 81 |   | r | n | b | q | k | b | n | r | 8
 82 |   +---+---+---+---+---+---+---+---+
 83 |   | p | p | p | p | p | p | p | p | 7
 84 |   +---+---+---+---+---+---+---+---+
 85 |   |   |   |   |   |   |   |   |   | 6
 86 |   +---+---+---+---+---+---+---+---+
 87 |   |   |   |   |   |   |   |   |   | 5
 88 |   +---+---+---+---+---+---+---+---+
 89 |   |   |   |   |   | P |   |   |   | 4
 90 |   +---+---+---+---+---+---+---+---+
 91 |   |   |   |   |   |   |   |   |   | 3
 92 |   +---+---+---+---+---+---+---+---+
 93 |   | P | P | P | P |   | P | P | P | 2
 94 |   +---+---+---+---+---+---+---+---+
 95 |   | R | N | B | Q | K | B | N | R | 1
 96 |   +---+---+---+---+---+---+---+---+
 97 |     a   b   c   d   e   f   g   h
 98 | ";
 99 | 
100 | #[allow(dead_code)]
101 | static BITBOARD_WITH_COORDS: &str = " \
102 |  Bitboard  (0xFFFF00001000EFFF)
103 | +--------+
104 | |11111111| 8
105 | |11111111| 7
106 | |00000000| 6
107 | |00000000| 5
108 | |00001000| 4
109 | |00000000| 3
110 | |11110111| 2
111 | |11111111| 1
112 | +--------+
113 |  abcdefgh
114 | ";
115 | 
116 | #[cfg(test)]
117 | mod tests {
118 |     use crate::bitboard::BitboardExt;
119 |     use crate::color::*;
120 |     use crate::common::*;
121 |     use crate::fen::FEN;
122 |     use crate::game::Game;
123 |     use crate::piece_move::PieceMove;
124 |     use crate::piece_move_generator::PieceMoveGenerator;
125 |     use crate::square::*;
126 |     use super::*;
127 | 
128 |     #[test]
129 |     fn test_draw() {
130 |         colorize(false);
131 |         let mut game = Game::from_fen(DEFAULT_FEN).unwrap();
132 |         game.make_move(PieceMove::new(E2, E4, DOUBLE_PAWN_PUSH));
133 |         assert_eq!(format!("{}", game), PIECES_WITHOUT_COORDS);
134 |     }
135 | 
136 |     #[test]
137 |     fn test_draw_with_coordinates() {
138 |         colorize(false);
139 |         let mut game = Game::from_fen(DEFAULT_FEN).unwrap();
140 |         game.show_coordinates = true;
141 |         game.make_move(PieceMove::new(E2, E4, DOUBLE_PAWN_PUSH));
142 |         assert_eq!(format!("{}", game), PIECES_WITH_COORDS);
143 |     }
144 | 
145 |     #[test]
146 |     fn test_draw_compact_with_coordinates() {
147 |         colorize(false);
148 |         let mut game = Game::from_fen(DEFAULT_FEN).unwrap();
149 |         game.make_move(PieceMove::new(E2, E4, DOUBLE_PAWN_PUSH));
150 |         let bb = game.bitboards[WHITE as usize] | game.bitboards[BLACK as usize];
151 |         assert_eq!(format!("{}", bb.to_debug_string()), BITBOARD_WITH_COORDS);
152 |     }
153 | }
154 | 


--------------------------------------------------------------------------------
/src/clock.rs:
--------------------------------------------------------------------------------
  1 | use std::prelude::v1::*;
  2 | use std::sync::atomic::{AtomicBool, Ordering};
  3 | use std::sync::Arc;
  4 | 
  5 | #[cfg(feature = "std")]
  6 | fn default_system_time() -> u128 {
  7 |     use std::time::SystemTime;
  8 |     SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_millis()
  9 | }
 10 | 
 11 | #[cfg(not(feature = "std"))]
 12 | fn default_system_time() -> u128 {
 13 |     0 // NOTE: Must be overrided in Clock by external crates
 14 | }
 15 | 
 16 | #[derive(Clone)]
 17 | pub struct Clock {
 18 |     pub system_time: Arc<dyn Fn() -> u128 + Send + Sync + 'static>,
 19 |     pub polling_nodes_count: u64,
 20 |     pub started_at: u128,
 21 |     moves_level: u16,
 22 |     moves_remaining: u16,
 23 |     time_remaining: u64,
 24 |     last_nodes_count: u64,
 25 |     is_finished: Arc<AtomicBool>,
 26 |     is_level: bool // TODO: find a better name
 27 | }
 28 | 
 29 | impl Clock {
 30 |     pub fn new(moves: u16, time: u64) -> Clock {
 31 |         let system_time = Arc::new(default_system_time);
 32 |         Clock {
 33 |             system_time: system_time,
 34 |             polling_nodes_count: 100,
 35 |             started_at: 0,
 36 |             moves_level: moves,
 37 |             moves_remaining: if moves > 0 { moves } else { 20 },
 38 |             time_remaining: time,
 39 |             last_nodes_count: 0,
 40 |             is_finished: Arc::new(AtomicBool::new(false)),
 41 |             is_level: true
 42 |         }
 43 |     }
 44 | 
 45 |     pub fn start(&mut self, ply: usize) {
 46 |         self.is_finished.store(false, Ordering::Relaxed);
 47 |         self.last_nodes_count = 0;
 48 |         self.started_at = (self.system_time)();
 49 | 
 50 |         // The UCI protocol gives the number of remaining moves before each
 51 |         // search but XBoard doesn't so we need to calculate it based on moves
 52 |         // history and the level command.
 53 |         if self.is_level && self.moves_level > 0 {
 54 |             assert!(ply > 0);
 55 |             let moves_done = (((ply - 1) / 2) as u16) % self.moves_level;
 56 |             self.moves_remaining = self.moves_level - moves_done;
 57 |         }
 58 |     }
 59 | 
 60 |     pub fn stop(&mut self) {
 61 |         self.is_finished.store(true, Ordering::Relaxed);
 62 |     }
 63 | 
 64 |     pub fn disable_level(&mut self) {
 65 |         self.is_level = false;
 66 |     }
 67 | 
 68 |     pub fn set_time(&mut self, time: u64) {
 69 |         self.time_remaining = time;
 70 |     }
 71 | 
 72 |     pub fn allocated_time(&self) -> u64 {
 73 |         self.time_remaining / self.moves_remaining as u64
 74 |     }
 75 | 
 76 |     pub fn elapsed_time(&self) -> u64 {
 77 |         ((self.system_time)() - self.started_at) as u64
 78 |     }
 79 | 
 80 |     pub fn poll(&mut self, nodes_count: u64) -> bool {
 81 |         // We do the real computation only every `polling_nodes_count` nodes
 82 |         // TODO: do we need this?
 83 |         if nodes_count - self.last_nodes_count > self.polling_nodes_count {
 84 |             self.last_nodes_count = nodes_count;
 85 | 
 86 |             // A certain amount of time pass between two polls,
 87 |             // and after the end of the search.
 88 |             let time_between_polls = self.polling_nodes_count / 4;
 89 |             let time_to_play = 25;
 90 |             let delta = time_between_polls + time_to_play;
 91 | 
 92 |             if delta + self.elapsed_time() > self.allocated_time() {
 93 |                 self.is_finished.store(true, Ordering::Relaxed);
 94 |             }
 95 |         }
 96 | 
 97 |         self.is_finished.load(Ordering::Relaxed)
 98 |     }
 99 | }
100 | 


--------------------------------------------------------------------------------
/src/color.rs:
--------------------------------------------------------------------------------
1 | pub type Color = u8;
2 | 
3 | pub const WHITE:  Color = 0b0000; // 0
4 | pub const BLACK:  Color = 0b0001; // 1
5 | 
6 | pub const COLORS: [Color; 2] = [WHITE, BLACK];
7 | 


--------------------------------------------------------------------------------
/src/common.rs:
--------------------------------------------------------------------------------
  1 | #![allow(dead_code)]
  2 | 
  3 | use std::prelude::v1::*;
  4 | use std::sync::atomic::{AtomicBool, Ordering};
  5 | 
  6 | use crate::piece::*;
  7 | use crate::square::*;
  8 | use crate::bitboard::Bitboard;
  9 | 
 10 | pub type Shift = i8;
 11 | pub type Direction = usize;
 12 | pub type PieceMoveType = u8;
 13 | pub type Score = i16;
 14 | pub type Depth = i8;
 15 | 
 16 | pub const INF: Score = 29999;
 17 | 
 18 | pub const UP:    Shift = 8;
 19 | pub const DOWN:  Shift = -8;
 20 | pub const LEFT:  Shift = -1;
 21 | pub const RIGHT: Shift = 1;
 22 | 
 23 | pub const NORTH:     Direction = 0; // 0b0000
 24 | pub const SOUTH:     Direction = 1; // 0b0001
 25 | pub const WEST:      Direction = 2; // 0b0010
 26 | pub const EAST:      Direction = 3; // 0b0011
 27 | pub const NORTHWEST: Direction = 4; // 0b0100
 28 | pub const NORTHEAST: Direction = 5; // 0b0101
 29 | pub const SOUTHWEST: Direction = 6; // 0b0110
 30 | pub const SOUTHEAST: Direction = 7; // 0b0111
 31 | 
 32 | pub trait DirectionExt {
 33 |     fn is_north(self) -> bool;
 34 |     fn is_south(self) -> bool;
 35 |     fn is_west(self) -> bool;
 36 |     fn is_east(self) -> bool;
 37 | }
 38 | 
 39 | impl DirectionExt for Direction {
 40 |     fn is_north(self) -> bool {
 41 |         DIRECTION_SHIFTS[self] > 1
 42 |     }
 43 |     fn is_south(self) -> bool {
 44 |         DIRECTION_SHIFTS[self] < 1
 45 |     }
 46 |     fn is_east(self) -> bool {
 47 |         self > 1 && self % 2 == 0
 48 |     }
 49 |     fn is_west(self) -> bool {
 50 |         self > 1 && self % 2 == 1
 51 |     }
 52 | }
 53 | 
 54 | pub const DIRECTION_SHIFTS: [Shift; 8] = [
 55 |     UP,
 56 |     DOWN,
 57 |     LEFT,
 58 |     RIGHT,
 59 |     UP + LEFT,
 60 |     UP + RIGHT,
 61 |     DOWN + LEFT,
 62 |     DOWN + RIGHT
 63 | ];
 64 | 
 65 | pub const DIRECTION_MASKS: [Bitboard; 8] = [
 66 |     0xFFFFFFFFFFFFFFFF,
 67 |     0xFFFFFFFFFFFFFFFF,
 68 |     0x7F7F7F7F7F7F7F7F,
 69 |     0xFEFEFEFEFEFEFEFE,
 70 |     0x7F7F7F7F7F7F7F7F,
 71 |     0xFEFEFEFEFEFEFEFE,
 72 |     0x7F7F7F7F7F7F7F7F,
 73 |     0xFEFEFEFEFEFEFEFE
 74 | ];
 75 | 
 76 | pub const RANK_1: Bitboard = 0x00000000000000FF;
 77 | pub const RANK_2: Bitboard = 0x000000000000FF00;
 78 | pub const RANK_3: Bitboard = 0x0000000000FF0000;
 79 | pub const RANK_4: Bitboard = 0x00000000FF000000;
 80 | pub const RANK_5: Bitboard = 0x000000FF00000000;
 81 | pub const RANK_6: Bitboard = 0x0000FF0000000000;
 82 | pub const RANK_7: Bitboard = 0x00FF000000000000;
 83 | pub const RANK_8: Bitboard = 0xFF00000000000000;
 84 | 
 85 | pub const RANKS: [Bitboard; 8] = [
 86 |     RANK_1,
 87 |     RANK_2,
 88 |     RANK_3,
 89 |     RANK_4,
 90 |     RANK_5,
 91 |     RANK_6,
 92 |     RANK_7,
 93 |     RANK_8,
 94 | ];
 95 | 
 96 | pub const FILE_A: Bitboard = 0x0101010101010101;
 97 | pub const FILE_B: Bitboard = 0x0202020202020202;
 98 | pub const FILE_C: Bitboard = 0x0404040404040404;
 99 | pub const FILE_D: Bitboard = 0x0808080808080808;
100 | pub const FILE_E: Bitboard = 0x1010101010101010;
101 | pub const FILE_F: Bitboard = 0x2020202020202020;
102 | pub const FILE_G: Bitboard = 0x4040404040404040;
103 | pub const FILE_H: Bitboard = 0x8080808080808080;
104 | 
105 | pub const FILES: [Bitboard; 8] = [
106 |     FILE_A,
107 |     FILE_B,
108 |     FILE_C,
109 |     FILE_D,
110 |     FILE_E,
111 |     FILE_F,
112 |     FILE_G,
113 |     FILE_H,
114 | ];
115 | 
116 | pub const QUIET_MOVE:               PieceMoveType = 0b0000; // 0
117 | pub const DOUBLE_PAWN_PUSH:         PieceMoveType = 0b0001; // 1
118 | pub const KING_CASTLE:              PieceMoveType = 0b0010; // 2
119 | pub const QUEEN_CASTLE:             PieceMoveType = 0b0011; // 3
120 | pub const CAPTURE:                  PieceMoveType = 0b0100; // 4
121 | pub const EN_PASSANT:               PieceMoveType = 0b0101; // 5
122 | pub const NULL_MOVE:                PieceMoveType = 0b0110; // 6
123 | pub const KNIGHT_PROMOTION:         PieceMoveType = 0b1000; // 8
124 | pub const BISHOP_PROMOTION:         PieceMoveType = 0b1001; // 9
125 | pub const ROOK_PROMOTION:           PieceMoveType = 0b1010; // 10
126 | pub const QUEEN_PROMOTION:          PieceMoveType = 0b1011; // 11
127 | pub const KNIGHT_PROMOTION_CAPTURE: PieceMoveType = 0b1100; // 12
128 | pub const BISHOP_PROMOTION_CAPTURE: PieceMoveType = 0b1101; // 13
129 | pub const ROOK_PROMOTION_CAPTURE:   PieceMoveType = 0b1110; // 14
130 | pub const QUEEN_PROMOTION_CAPTURE:  PieceMoveType = 0b1111; // 15
131 | 
132 | pub const BEST_MOVE:                PieceMoveType = 0b00010000; // 16
133 | pub const KILLER_MOVE:              PieceMoveType = 0b00010001; // 17
134 | 
135 | pub const PROMOTION_MASK:           PieceMoveType = 0b1000;
136 | pub const PROMOTION_KIND_MASK:      PieceMoveType = 0b1100;
137 | 
138 | pub const PROMOTION_KINDS: [Piece; 4] = [KNIGHT, BISHOP, ROOK, QUEEN];
139 | 
140 | pub const CASTLING_MASKS: [[Bitboard; 2]; 2] = [
141 |     [1 << F1 | 1 << G1, 1 << B1 | 1 << C1 | 1 << D1],
142 |     [1 << F8 | 1 << G8, 1 << B8 | 1 << C8 | 1 << D8]
143 | ];
144 | 
145 | pub const DEFAULT_FEN: &str =
146 |     "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
147 | 
148 | /*
149 | pub const SQUARES: [Square; 64] = [
150 |     A1, B1, C1, D1, E1, F1, G1, H1,
151 |     A2, B2, C2, D2, E2, F2, G2, H2,
152 |     A3, B3, C3, D3, E3, F3, G3, H3,
153 |     A4, B4, C4, D4, E4, F4, G4, H4,
154 |     A5, B5, C5, D5, E5, F5, G5, H5,
155 |     A6, B6, C6, D6, E6, F6, G6, H6,
156 |     A7, B7, C7, D7, E7, F7, G7, H7,
157 |     A8, B8, C8, D8, E8, F8, G8, H8
158 | ];
159 | */
160 | 
161 | pub const MAX_PLY: usize = 128;
162 | pub const MAX_MOVES: usize = 256;
163 | pub const MAX_KILLERS: usize = 2;
164 | 
165 | pub const TT_SIZE: usize = 8 << 20; // 8 Mb
166 | 
167 | pub const XSHIFTS: [Shift; 2] = [LEFT, RIGHT];
168 | pub const YSHIFTS: [Shift; 2] = [UP, DOWN];
169 | pub const END_FILES: [Bitboard; 2] = [FILE_A, FILE_H];
170 | pub const SEC_RANKS: [Bitboard; 2] = [RANK_3, RANK_6];
171 | pub const END_RANKS: [Bitboard; 2] = [RANK_8, RANK_1];
172 | 
173 | lazy_static! {
174 |     pub static ref PIECE_MASKS: [[Bitboard; 64]; 14] = { // TODO: s/12/5/
175 |         let mut piece_masks = [[0u64; 64]; 14];
176 | 
177 |         let deltas = [-2, -1, 0, 1, 2];
178 |         for x in 0..8 {
179 |             for y in 0..8 {
180 |                 let from = 8 * x + y;
181 |                 for &i in &deltas {
182 |                     for &j in &deltas {
183 |                         for k in 1..7 {
184 |                             let dx = x + i * k;
185 |                             let dy = y + j * k;
186 |                             let to = 8 * dx + dy;
187 |                             if to == from {
188 |                                 break;
189 |                             }
190 |                             if dx as u8 >= 8 || dy as u8 >= 8 {
191 |                                 break; // Out of board
192 |                             }
193 |                             if i == -2 || j == -2 || i == 2 || j == 2 {
194 |                                 if i == -1 || j == -1 || i == 1 || j == 1 {
195 |                                     piece_masks[KNIGHT as usize][from as usize] |= 1 << to;
196 |                                 }
197 |                                 break;
198 |                             }
199 |                             if k == 1 {
200 |                                 piece_masks[KING as usize][from as usize] |= 1 << to;
201 |                             }
202 |                             if (dx + i) as u8 >= 8 || (dy + j) as u8 >= 8 {
203 |                                 break; // Edge of the board
204 |                             }
205 |                             if i == 0 || j == 0 {
206 |                                 piece_masks[ROOK as usize][from as usize] |= 1 << to;
207 |                             } else {
208 |                                 piece_masks[BISHOP as usize][from as usize] |= 1 << to;
209 |                             }
210 |                             piece_masks[QUEEN as usize][from as usize] |= 1 << to;
211 |                         }
212 |                     }
213 |                 }
214 |             }
215 |         };
216 | 
217 |         piece_masks
218 |     };
219 | 
220 |     static ref COLORIZE: AtomicBool = AtomicBool::new(true);
221 | }
222 | 
223 | pub fn colorize(b: bool) {
224 |     COLORIZE.store(b, Ordering::Relaxed);
225 | }
226 | 
227 | pub fn bold_white(s: &str) -> String {
228 |     if COLORIZE.load(Ordering::Relaxed) {
229 |         format!("\x1b[1;97m{}\x1b[0m", s)
230 |     } else {
231 |         s.to_string()
232 |     }
233 | }
234 | 
235 | pub fn bold_red(s: &str) -> String {
236 |     if COLORIZE.load(Ordering::Relaxed) {
237 |         format!("\x1b[1;91m{}\x1b[0m", s)
238 |     } else {
239 |         s.to_string()
240 |     }
241 | }
242 | 
243 | pub fn bold_green(s: &str) -> String {
244 |     if COLORIZE.load(Ordering::Relaxed) {
245 |         format!("\x1b[1;92m{}\x1b[0m", s)
246 |     } else {
247 |         s.to_string()
248 |     }
249 | }
250 | 
251 | #[cfg(test)]
252 | mod tests {
253 |     use super::*;
254 | 
255 |     #[test]
256 |     fn test_piece_masks() {
257 |         assert_eq!(PIECE_MASKS[KING as usize][A1 as usize],   0x0000000000000302);
258 |         assert_eq!(PIECE_MASKS[KING as usize][E3 as usize],   0x0000000038283800);
259 |         assert_eq!(PIECE_MASKS[KNIGHT as usize][B1 as usize], 0x0000000000050800);
260 |         assert_eq!(PIECE_MASKS[BISHOP as usize][A1 as usize], 0x0040201008040200);
261 |         assert_eq!(PIECE_MASKS[BISHOP as usize][E3 as usize], 0x0000024428002800);
262 |         assert_eq!(PIECE_MASKS[ROOK as usize][E3 as usize],   0x00101010106E1000);
263 |         assert_eq!(PIECE_MASKS[ROOK as usize][A1 as usize],   0x000101010101017E);
264 |     }
265 | }
266 | 


--------------------------------------------------------------------------------
/src/dumb7fill.rs:
--------------------------------------------------------------------------------
 1 | use crate::common::*;
 2 | use crate::square::*;
 3 | use crate::bitboard::{Bitboard, BitboardExt};
 4 | 
 5 | // Flood fill algorithm
 6 | #[allow(dead_code)]
 7 | pub fn dumb7fill(mut fill: Bitboard, empty: Bitboard, dir: Shift) -> Bitboard {
 8 |     let mut flood: Bitboard = 0;
 9 | 
10 |     while fill > 0 {
11 |         flood |= fill;
12 |         fill = fill.shift(dir) & empty;
13 |     }
14 | 
15 |     flood
16 | }
17 | 
18 | #[allow(dead_code)]
19 | pub fn bishop_attacks(from: Square, occupied: Bitboard) -> Bitboard {
20 |     let fill = 1 << from;
21 |     let mut targets = 0;
22 | 
23 |     let occluded = dumb7fill(fill, !occupied & 0x7F7F7F7F7F7F7F7F, UP + LEFT);
24 |     targets |= 0x7F7F7F7F7F7F7F7F & occluded.shift(UP + LEFT);
25 |     let occluded = dumb7fill(fill, !occupied & 0x7F7F7F7F7F7F7F7F, DOWN + LEFT);
26 |     targets |= 0x7F7F7F7F7F7F7F7F & occluded.shift(DOWN + LEFT);
27 |     let occluded = dumb7fill(fill, !occupied & 0xFEFEFEFEFEFEFEFE, DOWN + RIGHT);
28 |     targets |= 0xFEFEFEFEFEFEFEFE & occluded.shift(DOWN + RIGHT);
29 |     let occluded = dumb7fill(fill, !occupied & 0xFEFEFEFEFEFEFEFE, UP + RIGHT);
30 |     targets |= 0xFEFEFEFEFEFEFEFE & occluded.shift(UP + RIGHT);
31 | 
32 |     targets
33 | }
34 | 
35 | #[allow(dead_code)]
36 | pub fn rook_attacks(from: Square, occupied: Bitboard) -> Bitboard {
37 |     let fill = Bitboard::from_square(from);
38 |     let mut targets = 0;
39 | 
40 |     let occluded = dumb7fill(fill, !occupied & 0xFFFFFFFFFFFFFFFF, UP);
41 |     targets |= 0xFFFFFFFFFFFFFFFF & occluded.shift(UP);
42 |     let occluded = dumb7fill(fill, !occupied & 0xFFFFFFFFFFFFFFFF, DOWN);
43 |     targets |= 0xFFFFFFFFFFFFFFFF & occluded.shift(DOWN);
44 |     let occluded = dumb7fill(fill, !occupied & 0x7F7F7F7F7F7F7F7F, LEFT);
45 |     targets |= 0x7F7F7F7F7F7F7F7F & occluded.shift(LEFT);
46 |     let occluded = dumb7fill(fill, !occupied & 0xFEFEFEFEFEFEFEFE, RIGHT);
47 |     targets |= 0xFEFEFEFEFEFEFEFE & occluded.shift(RIGHT);
48 | 
49 |     targets
50 | }
51 | 
52 | #[cfg(test)]
53 | mod tests {
54 |     use crate::common::*;
55 |     use super::*;
56 | 
57 |     #[test]
58 |     fn test_dumb7fill() {
59 |         let rooks: Bitboard = 0x0000000000100000;
60 | 
61 |         let empty: Bitboard = !rooks;
62 |         let targets = dumb7fill(rooks, empty, UP);
63 |         targets.debug();
64 |         let attacks = targets.shift(UP);
65 |         attacks.debug();
66 |         assert_eq!(targets, 0x1010101010100000);
67 | 
68 |         let empty: Bitboard = !rooks;
69 |         let targets = dumb7fill(rooks, empty, DOWN);
70 |         targets.debug();
71 |         let attacks = targets.shift(DOWN);
72 |         attacks.debug();
73 |         assert_eq!(targets, 0x0000000000101010);
74 | 
75 |         let empty: Bitboard = !rooks & 0x7F7F7F7F7F7F7F7F;
76 |         let targets = dumb7fill(rooks, empty, RIGHT);
77 |         targets.debug();
78 |         let attacks = targets.shift(RIGHT);
79 |         attacks.debug();
80 |         assert_eq!(targets, 0x0000000000700000);
81 | 
82 |         let empty: Bitboard = !(rooks | rooks << 16); // With blocker
83 |         let targets = dumb7fill(rooks, empty, UP);
84 |         targets.debug();
85 |         let attacks = targets.shift(UP);
86 |         attacks.debug();
87 |         assert_eq!(targets, 0x0000000010100000);
88 | 
89 |         let bishop: Bitboard = 0x0000000000100000;
90 |         let empty: Bitboard = !bishop & 0x7F7F7F7F7F7F7F7F;
91 |         let targets = dumb7fill(bishop, empty, UP + RIGHT);
92 |         targets.debug();
93 |         let attacks = targets.shift(UP + RIGHT);
94 |         attacks.debug();
95 |         assert_eq!(targets, 0x0000004020100000);
96 |     }
97 | }
98 | 


--------------------------------------------------------------------------------
/src/eval.rs:
--------------------------------------------------------------------------------
  1 | use std::prelude::v1::*;
  2 | use std::cmp;
  3 | 
  4 | use crate::color::*;
  5 | use crate::piece::*;
  6 | use crate::square::*;
  7 | use crate::common::*;
  8 | use crate::attack::Attack;
  9 | use crate::attack::piece_attacks;
 10 | use crate::bitboard::{Bitboard, BitboardExt, BitboardIterator};
 11 | use crate::bitboard::filefill;
 12 | use crate::game::Game;
 13 | use crate::piece_move::PieceMove;
 14 | use crate::piece_square_table::PST;
 15 | 
 16 | pub const PAWN_VALUE:       Score =   100;
 17 | pub const KNIGHT_VALUE:     Score =   350;
 18 | pub const BISHOP_VALUE:     Score =   350;
 19 | pub const ROOK_VALUE:       Score =   500;
 20 | pub const QUEEN_VALUE:      Score =  1000; // R + B + P + bonus bishop pair
 21 | pub const KING_VALUE:       Score = 10000;
 22 | 
 23 | const BONUS_BISHOP_PAIR:    Score =    50;
 24 | //const BONUS_HALF_OPEN_FILE: Score =     5;
 25 | //const BONUS_KNIGHT_PAWNS:   Score =     5;
 26 | //const BONUS_ROOK_OPEN_FILE: Score =    20;
 27 | //const BONUS_ROOK_PAWNS:     Score =     5;
 28 | //const MALUS_DOUBLED_PAWN:   Score =   -10;
 29 | 
 30 | lazy_static! {
 31 |     static ref PIECE_VALUES: [Score; 14] = {
 32 |         let mut piece_values = [0; 14];
 33 | 
 34 |         piece_values[PAWN   as usize] = PAWN_VALUE;
 35 |         piece_values[KNIGHT as usize] = KNIGHT_VALUE;
 36 |         piece_values[BISHOP as usize] = BISHOP_VALUE;
 37 |         piece_values[ROOK   as usize] = ROOK_VALUE;
 38 |         piece_values[QUEEN  as usize] = QUEEN_VALUE;
 39 |         piece_values[KING   as usize] = KING_VALUE;
 40 | 
 41 |         for i in 0..7 {
 42 |             let j = i * 2;
 43 |             piece_values[j + 1] = piece_values[j];
 44 |         }
 45 | 
 46 |         piece_values
 47 |     };
 48 | }
 49 | 
 50 | /// Evaluation algorithms
 51 | pub trait Eval {
 52 |     /// Evaluate the current position
 53 |     fn eval(&self) -> Score;
 54 | 
 55 |     /// Evaluate material at the current position for the given side
 56 |     fn eval_material(&self, c: Color) -> Score;
 57 | 
 58 |     /// Static Exchange Evaluation
 59 |     fn see(&self, capture: PieceMove) -> Score;
 60 | }
 61 | 
 62 | trait EvalExt {
 63 |     fn eval_ending(&self, c: Color) -> Option<Score>;
 64 |     fn lvp(&self, side: Color, attacks: Bitboard, occupied: Bitboard) -> Square;
 65 | }
 66 | 
 67 | impl Eval for Game {
 68 |     fn eval(&self) -> Score {
 69 |         let occupied = self.bitboard(WHITE) | self.bitboard(BLACK);
 70 |         let side = self.side();
 71 | 
 72 |         // Look for win/loss/draw
 73 |         if let Some(score) = self.eval_ending(side) {
 74 |             return score;
 75 |         }
 76 | 
 77 |         let mut material = [0; 2];
 78 |         let mut mobility = [0; 2];
 79 |         let mut position = [[0; 2]; 2]; // Opening and ending phases
 80 | 
 81 |         for &c in &COLORS {
 82 |             for &p in &PIECES {
 83 |                 let piece = c | p;
 84 |                 let mut pieces = self.bitboards[piece as usize];
 85 |                 let n = pieces.count() as Score;
 86 |                 material[c as usize] += n * PIECE_VALUES[piece as usize];
 87 |                 if p == BISHOP && n > 1 { // FIXME: Slows eval from 1250ns to 1350ns
 88 |                     material[c as usize] += BONUS_BISHOP_PAIR;
 89 |                 }
 90 |                 while let Some(square) = pieces.next() {
 91 |                     let targets = piece_attacks(piece, square, occupied);
 92 |                     mobility[c as usize] += targets.count() as Score;
 93 |                     position[c as usize][0] += PST[piece as usize][square as usize][0];
 94 |                     position[c as usize][1] += PST[piece as usize][square as usize][1];
 95 |                 }
 96 |             }
 97 |         }
 98 | 
 99 |         let mut position_score = 0;
100 |         let mut material_score = 0;
101 |         let mut mobility_score = 0;
102 |         let c = side as usize;
103 | 
104 |         // Linear interpolation between opening and ending scores
105 |         // based on the number of pieces on the board
106 |         let x0 = 32; // Max
107 |         let x1 = 2; // Min
108 |         let x = occupied.count() as Score; // Current
109 | 
110 |         let y0 = position[c][0];
111 |         let y1 = position[c][1];
112 |         position_score += (y0 * (x1 - x) + y1 * (x - x0)) / (x1 - x0);
113 |         material_score += material[c];
114 |         mobility_score += mobility[c];
115 | 
116 |         let y0 = position[c ^ 1][0];
117 |         let y1 = position[c ^ 1][1];
118 |         position_score -= (y0 * (x1 - x) + y1 * (x - x0)) / (x1 - x0);
119 |         material_score -= material[c ^ 1];
120 |         mobility_score -= mobility[c ^ 1];
121 | 
122 |         let score = position_score + material_score + mobility_score;
123 | 
124 |         if self.is_eval_verbose {
125 |             println!("material: {:>5.2}", 0.01 * material_score as f64);
126 |             println!("position: {:>5.2}", 0.01 * position_score as f64);
127 |             println!("mobility: {:>5.2}", 0.01 * mobility_score as f64);
128 |             println!("total:    {:>5.2}", 0.01 * score as f64);
129 |         }
130 | 
131 |         score
132 |     }
133 | 
134 |     fn eval_material(&self, c: Color) -> Score {
135 |         let mut score = 0;
136 | 
137 |         /*
138 |         let mut pawns_count = 0;
139 | 
140 |         let color_pawns = self.bitboards[(c | PAWN) as usize];
141 |         let other_pawns = self.bitboards[(c ^ 1 | PAWN) as usize];
142 | 
143 |         let open_files = open_files(color_pawns, other_pawns);
144 | 
145 |         let half_open_files = half_open_files(color_pawns, other_pawns);
146 |         let half_open_files_count = (half_open_files & RANK_1).count() as Score;
147 |         score += half_open_files_count * BONUS_HALF_OPEN_FILE;
148 |         */
149 | 
150 |         for &p in &PIECES {
151 |             let piece = c | p;
152 |             let pieces = self.bitboards[piece as usize];
153 |             let n = pieces.count() as Score;
154 |             score += n * PIECE_VALUES[piece as usize];
155 | 
156 |             /*
157 |             match p { // FIXME: Slows eval from 65 to 130ns
158 |                 PAWN => {
159 |                     pawns_count = n;
160 | 
161 |                     let pawns_files_count = (filefill(pieces) & RANK_1).count() as Score;
162 |                     score += (pawns_count - pawns_files_count) * MALUS_DOUBLED_PAWN;
163 |                 },
164 |                 KNIGHT => {
165 |                     score += n * pawns_count * BONUS_KNIGHT_PAWNS;
166 |                 },
167 |                 BISHOP if n == 2 => {
168 |                     score += BONUS_BISHOP_PAIR;
169 |                 },
170 |                 ROOK => {
171 |                     let rooks_on_open_files = (pieces & open_files).count();
172 |                     let rooks_on_half_open_files = (pieces & half_open_files).count();
173 |                     score += (rooks_on_open_files as Score) * BONUS_ROOK_OPEN_FILE;
174 |                     score += (rooks_on_half_open_files as Score) * BONUS_ROOK_OPEN_FILE / 2;
175 |                     score += n * (8 - pawns_count) * BONUS_ROOK_PAWNS;
176 |                 },
177 |                 _ => { }
178 |             }
179 |             */
180 |         }
181 | 
182 |         score
183 |     }
184 | 
185 |     fn see(&self, capture: PieceMove) -> Score {
186 |         let mut occupied = self.bitboard(WHITE) | self.bitboard(BLACK);
187 |         let mut sq = capture.from();
188 |         let mut side = self.side();
189 |         let mut gains = [0; 32];
190 |         let mut d = 0;
191 | 
192 |         let piece = self.board[capture.to() as usize];
193 |         let value = PIECE_VALUES[piece as usize];
194 |         gains[d] = value;
195 | 
196 |         while sq != OUT {
197 |             d += 1;
198 |             side ^= 1;
199 |             occupied.reset(sq); // Remove piece
200 | 
201 |             let piece = self.board[sq as usize];
202 |             let value = PIECE_VALUES[piece as usize];
203 |             gains[d] = value - gains[d - 1];
204 | 
205 |             // Get square of least valuable piece remaining
206 |             let attacks = self.attacks_to(capture.to(), occupied);
207 |             sq = self.lvp(side, attacks, occupied);
208 |         }
209 | 
210 |         while { d -= 1; d > 0 } {
211 |             gains[d - 1] = -cmp::max(-gains[d - 1], gains[d]);
212 |         }
213 | 
214 |         gains[0]
215 |     }
216 | }
217 | 
218 | impl EvalExt for Game {
219 |     fn eval_ending(&self, side: Color) -> Option<Score> {
220 |         let occupied = self.bitboard(WHITE) | self.bitboard(BLACK);
221 | 
222 |         let kings = self.bitboard(WHITE | KING) | self.bitboard(BLACK | KING);
223 |         if kings.count() < 2 {
224 |             if self.bitboard(side | KING).count() == 0 {
225 |                 return Some(-INF); // Loss
226 |             } else {
227 |                 return Some(INF); // Win
228 |             }
229 |         }
230 | 
231 |         // Draw by insufficient material
232 |         if occupied.count() < 4 {
233 |             let knights = self.bitboard(WHITE | KNIGHT) | self.bitboard(BLACK | KNIGHT);
234 |             let bishops = self.bitboard(WHITE | BISHOP) | self.bitboard(BLACK | BISHOP);
235 |             if (kings | knights | bishops) == occupied {
236 |                 return Some(0); // Draw
237 |             }
238 |         }
239 | 
240 |         None
241 |     }
242 | 
243 |     // Get square of least valuable piece
244 |     fn lvp(&self, side: Color, attacks: Bitboard, occupied: Bitboard) -> Square {
245 |         for p in &PIECES {
246 |             let piece = side | p;
247 |             // NOTE: we need `occupied` only to be able to hide some pieces
248 |             // from the bitboard.
249 |             let subset = attacks & occupied & self.bitboards[piece as usize];
250 |             if subset > 0 {
251 |                 return subset.scan() as Square;
252 |             }
253 |         }
254 | 
255 |         OUT
256 |     }
257 | }
258 | 
259 | #[allow(dead_code)]
260 | fn closed_files(white_pawns: Bitboard, black_pawns: Bitboard) -> Bitboard {
261 |     filefill(white_pawns) & filefill(black_pawns)
262 | }
263 | 
264 | #[allow(dead_code)]
265 | fn open_files(white_pawns: Bitboard, black_pawns: Bitboard) -> Bitboard {
266 |     !filefill(white_pawns) & !filefill(black_pawns)
267 | }
268 | 
269 | #[allow(dead_code)]
270 | fn half_open_files(pawns: Bitboard, opponent_pawns: Bitboard) -> Bitboard {
271 |     !filefill(pawns) ^ open_files(pawns, opponent_pawns)
272 | }
273 | 
274 | #[cfg(test)]
275 | mod tests {
276 |     use crate::color::*;
277 |     use crate::piece::*;
278 |     use crate::common::*;
279 |     use super::*;
280 |     use crate::fen::FEN;
281 |     use crate::game::Game;
282 |     use crate::piece_move::PieceMove;
283 | 
284 |     #[test]
285 |     fn test_draw() {
286 |         let mut game = Game::new();
287 | 
288 |         game.load_fen("8/8/4k3/8/8/4K3/8/8 w - - 0 1").unwrap();
289 |         assert_eq!(game.eval(), 0);
290 | 
291 |         game.load_fen("8/8/4k3/8/4B3/4K3/8/8 w - - 0 1").unwrap();
292 |         assert_eq!(game.eval(), 0);
293 | 
294 |         game.load_fen("8/8/4k3/8/4N3/4K3/8/8 w - - 0 1").unwrap();
295 |         assert_eq!(game.eval(), 0);
296 |     }
297 | 
298 |     #[test]
299 |     fn test_see() {
300 |         let mut game = Game::new();
301 | 
302 |         let fen = "1k1r4/1pp4p/p7/4p3/8/P5P1/1PP4P/2K1R3 w - -";
303 |         game.load_fen(fen).unwrap();
304 |         assert_eq!(game.see(PieceMove::new(E1, E5, CAPTURE)), PAWN_VALUE);
305 | 
306 |         let fen = "1k1r3q/1ppn3p/p4b2/4p3/8/P2N2P1/1PP1R1BP/2K1Q3 w - -";
307 |         game.load_fen(fen).unwrap();
308 |         assert_eq!(game.see(PieceMove::new(D3, E5, CAPTURE)), PAWN_VALUE - KNIGHT_VALUE);
309 | 
310 |         let fen = "rnbqkbnr/ppp1pppp/8/3p4/4P3/8/PPPP1PPP/RNBQKBNR w KQkq d6 0 2";
311 |         game.load_fen(fen).unwrap();
312 |         assert_eq!(game.see(PieceMove::new(E4, D5, CAPTURE)), 0);
313 | 
314 |         let fen = "rnbqkb1r/ppp1pppp/5n2/3p4/4P3/2N5/PPPP1PPP/R1BQKBNR w KQkq - 2 3";
315 |         game.load_fen(fen).unwrap();
316 |         assert_eq!(game.see(PieceMove::new(E4, D5, CAPTURE)), 0);
317 | 
318 |         let fen = "rnbqkb1r/pp2pppp/2p2n2/1B1p4/4P3/2N5/PPPP1PPP/R1BQK1NR w KQkq - 0 4";
319 |         game.load_fen(fen).unwrap();
320 |         assert_eq!(game.see(PieceMove::new(E4, D5, CAPTURE)), 0);
321 |         assert_eq!(game.see(PieceMove::new(C3, D5, CAPTURE)), PAWN_VALUE - KNIGHT_VALUE);
322 |         assert_eq!(game.see(PieceMove::new(B5, C6, CAPTURE)), PAWN_VALUE - BISHOP_VALUE);
323 | 
324 |         let fen = "rnbqkbnr/pppp1ppp/8/4p3/3P4/8/PPP1PPPP/RNBQKBNR w KQkq e6 0 2";
325 |         game.load_fen(fen).unwrap();
326 |         assert_eq!(game.see(PieceMove::new(D4, E5, CAPTURE)), PAWN_VALUE);
327 | 
328 |         let fen = "1K1k4/8/5n2/3p4/8/1BN2B2/6b1/7b w - -";
329 |         game.load_fen(fen).unwrap();
330 |         assert_eq!(game.see(PieceMove::new(B3, D5, CAPTURE)), PAWN_VALUE);
331 | 
332 |         let fen = "3r2k1/pppb2pp/5q2/5p2/3R1P2/2B5/PPP3PP/5RK1 w - - 0 1";
333 |         game.load_fen(fen).unwrap();
334 |         assert_eq!(game.see(PieceMove::new(D4, D7, CAPTURE)), BISHOP_VALUE - ROOK_VALUE);
335 | 
336 |         let fen = "k1K5/8/4N3/1p6/2rp1n2/1P2P3/3Q4/8 w - - 0 1";
337 |         game.load_fen(fen).unwrap();
338 |         assert_eq!(game.see(PieceMove::new(E3, F4, CAPTURE)), KNIGHT_VALUE);
339 |         assert_eq!(game.see(PieceMove::new(E6, F4, CAPTURE)), KNIGHT_VALUE);
340 |         assert_eq!(game.see(PieceMove::new(B3, C4, CAPTURE)), ROOK_VALUE - PAWN_VALUE);
341 |         assert_eq!(game.see(PieceMove::new(D2, D4, CAPTURE)), PAWN_VALUE + ROOK_VALUE - QUEEN_VALUE);
342 | 
343 |         let fen = "7k/p7/1p6/8/8/1Q6/8/7K w - - 0 1";
344 |         game.load_fen(fen).unwrap();
345 |         assert_eq!(game.see(PieceMove::new(B3, B6, CAPTURE)), PAWN_VALUE - QUEEN_VALUE);
346 | 
347 |         let fen = "7k/2p5/1p6/8/8/1Q6/8/7K w - - 0 1";
348 |         game.load_fen(fen).unwrap();
349 |         assert_eq!(game.see(PieceMove::new(B3, B6, CAPTURE)), PAWN_VALUE - QUEEN_VALUE);
350 | 
351 |         let fen = "7k/3n4/1p6/8/8/1Q6/8/7K w - - 0 1";
352 |         game.load_fen(fen).unwrap();
353 |         assert_eq!(game.see(PieceMove::new(B3, B6, CAPTURE)), PAWN_VALUE - QUEEN_VALUE);
354 |     }
355 | 
356 |     #[test]
357 |     fn test_open_files() {
358 |         let game = Game::from_fen("8/8/3k4/3p4/8/2PP4/3R1R2/3K4 w - - 0 1").unwrap();
359 | 
360 |         let black_pawns = game.bitboards[(BLACK | PAWN) as usize];
361 |         let white_pawns = game.bitboards[(WHITE | PAWN) as usize];
362 |         let white_rooks = game.bitboards[(WHITE | ROOK) as usize];
363 | 
364 |         let open_files = open_files(white_pawns, black_pawns);
365 | 
366 |         assert_eq!(white_rooks.count(), 2);
367 |         assert_eq!((white_rooks & open_files).count(), 1);
368 |     }
369 | 
370 |     #[test]
371 |     fn test_closed_files() {
372 |         let game = Game::from_fen("8/8/3k4/3p4/8/2PP4/3R1R2/3K4 w - - 0 1").unwrap();
373 | 
374 |         let black_pawns = game.bitboards[(BLACK | PAWN) as usize];
375 |         let white_pawns = game.bitboards[(WHITE | PAWN) as usize];
376 | 
377 |         let closed_files = closed_files(white_pawns, black_pawns);
378 | 
379 |         assert_eq!(black_pawns.count(), 1);
380 |         assert_eq!(white_pawns.count(), 2);
381 |         assert_eq!((black_pawns & closed_files).count(), 1);
382 |         assert_eq!((white_pawns & closed_files).count(), 1);
383 |     }
384 | 
385 |     #[test]
386 |     fn test_half_open_files() {
387 |         let game = Game::from_fen("8/8/3k4/3p4/8/2PP4/3R1R2/3K4 w - - 0 1").unwrap();
388 | 
389 |         let black_pawns = game.bitboards[(BLACK | PAWN) as usize];
390 |         let white_pawns = game.bitboards[(WHITE | PAWN) as usize];
391 | 
392 |         // NOTE: Param order is important here
393 |         let black_half_open_files = half_open_files(black_pawns, white_pawns);
394 |         let white_half_open_files = half_open_files(white_pawns, black_pawns);
395 | 
396 |         assert_eq!(black_pawns.count(), 1);
397 |         assert_eq!(white_pawns.count(), 2);
398 |         assert_eq!((black_pawns & white_half_open_files).count(), 0);
399 |         assert_eq!((white_pawns & black_half_open_files).count(), 1);
400 |     }
401 | }
402 | 


--------------------------------------------------------------------------------
/src/fen.rs:
--------------------------------------------------------------------------------
  1 | use std::prelude::v1::*;
  2 | 
  3 | use crate::color::*;
  4 | use crate::piece::*;
  5 | use crate::square::*;
  6 | use crate::common::*;
  7 | use crate::bitboard::BitboardExt;
  8 | use crate::game::Game;
  9 | use crate::piece::PieceChar;
 10 | use crate::square::SquareExt;
 11 | use crate::positions::Position;
 12 | 
 13 | /// Forsyth–Edwards Notation support
 14 | pub trait FEN {
 15 |     /// Create `Game` from a given FEN string
 16 |     fn from_fen(fen: &str) -> Result<Game, String>;
 17 | 
 18 |     /// Load game state from a given FEN string
 19 |     fn load_fen(&mut self, fen: &str) -> Result<(), String>;
 20 | 
 21 |     /// Export game state to a FEN string
 22 |     fn to_fen(&self) -> String;
 23 | }
 24 | 
 25 | impl FEN for Game {
 26 |     fn from_fen(fen: &str) -> Result<Game, String> {
 27 |         let mut game = Game::new();
 28 |         match game.load_fen(fen) {
 29 |             Ok(()) => Ok(game),
 30 |             Err(msg) => Err(msg),
 31 |         }
 32 |     }
 33 | 
 34 |     // TODO: Return error if loading fail
 35 |     fn load_fen(&mut self, fen: &str) -> Result<(), String> {
 36 |         self.clear();
 37 |         self.starting_fen = String::from(fen);
 38 |         let mut position = Position::new();
 39 | 
 40 |         let mut fields = fen.split_whitespace();
 41 | 
 42 |         let mut sq = A8;
 43 |         if let Some(field) = fields.next() {
 44 |             for c in field.chars() {
 45 |                 let dir = match c {
 46 |                     '/' => {
 47 |                         2 * DOWN
 48 |                     },
 49 |                     '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' => {
 50 |                         c.to_digit(10).unwrap() as Shift
 51 |                     },
 52 |                     'P' | 'N' | 'B' | 'R' | 'Q' | 'K' |
 53 |                     'p' | 'n' | 'b' | 'r' | 'q' | 'k' => {
 54 |                         let p = PieceChar::from_char(c);
 55 |                         self.board[sq as usize] = p;
 56 |                         self.bitboards[(p) as usize].set(sq);
 57 |                         self.bitboards[(p & 1) as usize].set(sq); // TODO: p.color()
 58 |                         position.hash ^= self.zobrist.pieces[p as usize][sq as usize];
 59 |                         1
 60 |                     },
 61 |                     _ => {
 62 |                         self.load_fen(DEFAULT_FEN)?;
 63 |                         return Err("invalid fen string".into());
 64 |                     }
 65 |                 };
 66 |                 //sq += dir;
 67 |                 sq = ((sq as i8) + dir) as Square;
 68 |             }
 69 |         } else {
 70 |             self.load_fen(DEFAULT_FEN)?;
 71 |             return Err("invalid fen string".into());
 72 |         }
 73 | 
 74 |         position.side = match fields.next() {
 75 |             Some("w") => WHITE,
 76 |             Some("b") => BLACK,
 77 |             _ => {
 78 |                 self.load_fen(DEFAULT_FEN)?;
 79 |                 return Err("invalid fen string".into());
 80 |             }
 81 |         };
 82 | 
 83 |         if position.side == BLACK {
 84 |             position.hash ^= self.zobrist.side;
 85 |         }
 86 | 
 87 |         if let Some(field) = fields.next() {
 88 |             for c in field.chars() {
 89 |                 match c {
 90 |                     'K' => {
 91 |                         position.set_castling_right(WHITE, KING);
 92 |                         position.hash ^= self.zobrist.castling_right(WHITE, KING);
 93 |                     }
 94 |                     'Q' => {
 95 |                         position.set_castling_right(WHITE, QUEEN);
 96 |                         position.hash ^= self.zobrist.castling_right(WHITE, QUEEN);
 97 |                     }
 98 |                     'k' => {
 99 |                         position.set_castling_right(BLACK, KING);
100 |                         position.hash ^= self.zobrist.castling_right(BLACK, KING);
101 |                     }
102 |                     'q' => {
103 |                         position.set_castling_right(BLACK, QUEEN);
104 |                         position.hash ^= self.zobrist.castling_right(BLACK, QUEEN);
105 |                     }
106 |                     _   => break
107 |                 }
108 |             }
109 |         }
110 | 
111 |         if let Some(ep) = fields.next() {
112 |             if ep != "-" {
113 |                 position.en_passant = SquareExt::from_coord(ep); // TODO: check square
114 |                 position.hash ^= self.zobrist.en_passant[position.en_passant as usize];
115 |             }
116 |         };
117 | 
118 |         self.positions.push(position);
119 | 
120 |         if let Some(hm) = fields.next() {
121 |             if let Ok(n) = hm.parse::<u8>() {
122 |                 self.positions.set_halfmoves(n);
123 |             }
124 |         };
125 | 
126 |         if let Some(fm) = fields.next() {
127 |             if let Ok(n) = fm.parse::<u8>() {
128 |                 self.positions.set_fullmoves(n);
129 |             }
130 |         };
131 | 
132 |         Ok(())
133 |     }
134 | 
135 |     fn to_fen(&self) -> String {
136 |         let mut fen = String::new();
137 |         let mut n = 0;
138 |         let mut sq = A8;
139 |         loop {
140 |             let p = self.board[sq as usize];
141 | 
142 |             if p == EMPTY {
143 |                 n += 1;
144 |             } else {
145 |                 if n > 0 {
146 |                     debug_assert!(n < 10);
147 |                     let c = (b'0' + n) as char;
148 |                     fen.push(c);
149 |                     n = 0;
150 |                 }
151 |                 fen.push(p.to_char());
152 |             }
153 | 
154 |             if sq == H1 {
155 |                 break;
156 |             }
157 | 
158 |             if sq & H1 == H1 { // TODO: is_file_h!(sq)
159 |                 if n > 0 { // TODO: DRY
160 |                     debug_assert!(n < 10);
161 |                     let c = (b'0' + n) as char;
162 |                     fen.push(c);
163 |                     n = 0;
164 |                 }
165 |                 fen.push('/');
166 |                 //sq += 2 * DOWN;
167 |                 sq = ((sq as i8) + 2 * DOWN) as Square; // 0 <= sq <= 64
168 |             }
169 | 
170 |             //sq += RIGHT;
171 |             sq = ((sq as i8) + RIGHT) as Square; // 0 <= sq <= 64
172 |         }
173 | 
174 |         fen.push(' ');
175 |         if self.side() == WHITE {
176 |             fen.push('w');
177 |         } else {
178 |             fen.push('b');
179 |         }
180 | 
181 |         fen.push(' ');
182 |         let &pos = self.positions.top();
183 |         let mut castles = String::new();
184 |         if pos.castling_right(WHITE, KING) {
185 |             castles.push('K');
186 |         }
187 |         if pos.castling_right(WHITE, QUEEN) {
188 |             castles.push('Q');
189 |         }
190 |         if pos.castling_right(BLACK, KING) {
191 |             castles.push('k');
192 |         }
193 |         if pos.castling_right(BLACK, QUEEN) {
194 |             castles.push('q');
195 |         }
196 |         if castles.is_empty() {
197 |             castles.push('-');
198 |         }
199 |         fen.push_str(&castles);
200 | 
201 |         fen.push(' ');
202 |         // TODO: implement `square.is_out()`
203 |         let ep = self.positions.top().en_passant;
204 |         if ep < OUT {
205 |             fen.push_str(&ep.to_coord());
206 |         } else {
207 |             fen.push('-');
208 |         }
209 | 
210 |         fen.push(' ');
211 |         let hm = self.positions.halfmoves();
212 |         let fm = self.positions.fullmoves();
213 |         fen.push_str(&format!("{} {}", hm, fm));
214 | 
215 |         fen
216 |     }
217 | }
218 | 
219 | #[cfg(test)]
220 | mod tests {
221 |     use crate::piece::*;
222 |     use crate::square::*;
223 |     use crate::common::*;
224 |     use crate::fen::FEN;
225 |     use crate::game::Game;
226 | 
227 |     #[test]
228 |     fn test_from_fen() {
229 |         let game = Game::from_fen(DEFAULT_FEN).unwrap();
230 |         assert_eq!(game.board[E2 as usize], WHITE_PAWN);
231 |     }
232 | 
233 |     #[test]
234 |     fn test_to_fen() {
235 |         let fens = [
236 |             DEFAULT_FEN,
237 |             "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1",
238 |             "rnbqkbnr/pp1ppppp/8/2p5/4P3/5N2/PPPP1PPP/RNBQKB1R w KQkq - 0 1",
239 |             "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1",
240 |             "8/8/p1p5/1p5p/1P5p/8/PPP2K1p/4R1rk w - - 4 23"
241 |         ];
242 |         for &fen in fens.iter() {
243 |             let game = Game::from_fen(fen).unwrap();
244 |             assert_eq!(&game.to_fen(), fen);
245 |         }
246 |     }
247 | }
248 | 


--------------------------------------------------------------------------------
/src/game.rs:
--------------------------------------------------------------------------------
  1 | use std::prelude::v1::*;
  2 | use std::fmt;
  3 | 
  4 | use crate::board;
  5 | use crate::color::*;
  6 | use crate::piece::*;
  7 | use crate::common::*;
  8 | use crate::bitboard::Bitboard;
  9 | use crate::clock::Clock;
 10 | use crate::piece_move::PieceMove;
 11 | use crate::piece_move_list::PieceMoveList;
 12 | use crate::positions::Positions;
 13 | use crate::transposition_table::TranspositionTable;
 14 | use crate::zobrist::Zobrist;
 15 | use crate::piece::{PieceAttr, PieceChar};
 16 | #[cfg(feature = "std")]
 17 | use crate::protocols::Protocol;
 18 | 
 19 | /// A `Game` type to store the state of a chess game
 20 | #[derive(Clone)]
 21 | pub struct Game {
 22 |     #[cfg(feature = "std")]
 23 |     pub protocol: Protocol,
 24 | 
 25 |     pub starting_fen: String,
 26 |     pub is_debug: bool,  // Print debugging
 27 |     pub is_eval_verbose: bool, // Print thinking in eval
 28 |     pub is_search_verbose: bool, // Print thinking in search
 29 |     pub show_coordinates: bool,
 30 |     pub threads_count: usize,
 31 |     pub nodes_count: u64,
 32 |     pub clock: Clock,
 33 |     pub bitboards: [Bitboard; 14],
 34 |     pub board: [Piece; 64],
 35 |     pub moves: PieceMoveList,
 36 |     pub positions: Positions,
 37 |     pub zobrist: Zobrist,
 38 |     pub history: Vec<PieceMove>,
 39 |     pub tt: TranspositionTable
 40 | }
 41 | 
 42 | impl Game {
 43 |     /// Create a new `Game`
 44 |     pub fn new() -> Game {
 45 |         Game {
 46 |             #[cfg(feature = "std")]
 47 |             protocol: Protocol::CLI,
 48 | 
 49 |             starting_fen: String::from(DEFAULT_FEN),
 50 |             is_debug: false,
 51 |             is_eval_verbose: false,
 52 |             is_search_verbose: false,
 53 |             show_coordinates: false,
 54 |             threads_count: 0,
 55 |             nodes_count: 0,
 56 |             clock: Clock::new(40, 5 * 60),
 57 |             bitboards: [0; 14],
 58 |             board: [EMPTY; 64],
 59 |             moves: PieceMoveList::new(),
 60 |             positions: Positions::new(),
 61 |             zobrist: Zobrist::new(),
 62 |             history: Vec::new(),
 63 |             tt: TranspositionTable::with_memory(TT_SIZE)
 64 |         }
 65 |     }
 66 | 
 67 |     /// Get the transposition table size in byte
 68 |     pub fn tt_size(&self) -> usize {
 69 |         self.tt.memory()
 70 |     }
 71 | 
 72 |     /// Resize the transposition table at the given size in byte or the next
 73 |     /// power of two
 74 |     pub fn tt_resize(&mut self, memory: usize) {
 75 |         self.tt = TranspositionTable::with_memory(memory);
 76 |     }
 77 | 
 78 |     /// Clear the current game state
 79 |     pub fn clear(&mut self) {
 80 |         self.bitboards = [0; 14];
 81 |         self.board = [EMPTY; 64];
 82 |         self.moves.clear_all();
 83 |         self.positions.clear();
 84 |         self.history.clear();
 85 |         self.tt.clear();
 86 |     }
 87 | 
 88 |     /// Get a bitboard representation of the given piece in the game
 89 |     #[inline]
 90 |     pub fn bitboard(&self, piece: Piece) -> &Bitboard {
 91 |         &self.bitboards[piece as usize]
 92 |     }
 93 | 
 94 |     /// Get the current side color
 95 |     pub fn side(&self) -> Color {
 96 |         self.positions.top().side
 97 |     }
 98 | }
 99 | 
100 | impl fmt::Display for Game {
101 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
102 |         let squares = (0..64).map(|i| {
103 |             let p = self.board[i];
104 |             let c = p.to_char().to_string();
105 |             if p.color() == WHITE {
106 |                 bold_white(&c)
107 |             } else if p.color() == BLACK {
108 |                 bold_red(&c)
109 |             } else {
110 |                 c
111 |             }
112 |         }).collect();
113 | 
114 |         let board = if self.show_coordinates {
115 |             board::draw_with_coordinates(squares)
116 |         } else {
117 |             board::draw(squares)
118 |         };
119 | 
120 |         write!(f, "{}", board)
121 |     }
122 | }
123 | 
124 | #[cfg(test)]
125 | mod tests {
126 |     use super::*;
127 | 
128 |     #[test]
129 |     fn test_tt_resize() {
130 |         let mut game = Game::new();
131 | 
132 |         let size = 4 << 20; // 4 MB
133 |         game.tt_resize(size);
134 |         assert_eq!(game.tt_size(), size);
135 |     }
136 | }
137 | 


--------------------------------------------------------------------------------
/src/hyperbola.rs:
--------------------------------------------------------------------------------
  1 | use std::prelude::v1::*;
  2 | 
  3 | use crate::common::*;
  4 | use crate::color::*;
  5 | use crate::square::*;
  6 | use crate::bitboard::{Bitboard, BitboardExt};
  7 | 
  8 | pub fn bishop_attacks(from: Square, occupied: Bitboard) -> Bitboard {
  9 |     hyperbola(occupied, from, HyperbolaMask::Diag) |
 10 |     hyperbola(occupied, from, HyperbolaMask::Anti)
 11 | }
 12 | 
 13 | pub fn rook_attacks(from: Square, occupied: Bitboard) -> Bitboard {
 14 |     hyperbola(occupied, from, HyperbolaMask::File) |
 15 |     rank_attacks(occupied, from)
 16 | }
 17 | 
 18 | #[repr(usize)]
 19 | enum HyperbolaMask { File, Rank, Diag, Anti }
 20 | 
 21 | // Hyperbola Quintessence
 22 | fn hyperbola(occupied: Bitboard, sq: Square, t: HyperbolaMask) -> Bitboard {
 23 |     debug_assert!(sq < OUT);
 24 |     let mask = HYPERBOLA_MASKS[sq as usize][t as usize];
 25 |     let mut forward = occupied & mask;
 26 |     let mut reverse = forward.swap_bytes();
 27 |     //forward -= 1 << sq;
 28 |     //reverse -= 1 << sq.flip(BLACK);
 29 |     forward = forward.wrapping_sub(Bitboard::from_square(sq));
 30 |     reverse = reverse.wrapping_sub(Bitboard::from_square(sq.flip(BLACK)));
 31 |     forward ^= reverse.swap_bytes();
 32 |     forward & mask
 33 | }
 34 | 
 35 | // First Rank Attacks
 36 | fn rank_attacks(occupied: Bitboard, sq: Square) -> Bitboard {
 37 |     debug_assert!(sq < OUT);
 38 |     let f = sq & 7; // sq.file() as Bitboard;
 39 |     let r = sq & !7; // (sq.rank() * 8) as Bitboard;
 40 |     let o = (occupied >> (r + 1)) & 63;
 41 |     FIRST_RANK_ATTACKS[o as usize][f as usize] << r
 42 | }
 43 | 
 44 | lazy_static! {
 45 |     static ref HYPERBOLA_MASKS: [[Bitboard; 4]; 64] = {
 46 |         let mut hyperbola_masks = [[0; 4]; 64];
 47 |         for sq in 0..64 {
 48 |             let mask = &mut hyperbola_masks[sq as usize];
 49 |             mask[HyperbolaMask::File as usize] = generate_mask(NORTH,     sq) | generate_mask(SOUTH,     sq);
 50 |             mask[HyperbolaMask::Rank as usize] = generate_mask(EAST,      sq) | generate_mask(WEST,      sq);
 51 |             mask[HyperbolaMask::Diag as usize] = generate_mask(NORTHEAST, sq) | generate_mask(SOUTHWEST, sq);
 52 |             mask[HyperbolaMask::Anti as usize] = generate_mask(NORTHWEST, sq) | generate_mask(SOUTHEAST, sq);
 53 |         }
 54 |         hyperbola_masks
 55 |     };
 56 | 
 57 |     static ref FIRST_RANK_ATTACKS: [[Bitboard; 8]; 64] = {
 58 |         let mut first_rank_attacks = [[0; 8]; 64];
 59 |         for o in 0..64 {
 60 |             for f in 0..8 {
 61 |                 first_rank_attacks[o][f] = 0;
 62 | 
 63 |                 for i in (f + 1)..8 {
 64 |                     first_rank_attacks[o][f] |= 1 << i;
 65 |                     if (o << 1) & (1 << i) > 0 {
 66 |                         break;
 67 |                     }
 68 |                 }
 69 |                 for i in (0..f).rev() {
 70 |                     first_rank_attacks[o][f] |= 1 << i;
 71 |                     if (o << 1) & (1 << i) > 0 {
 72 |                         break;
 73 |                     }
 74 |                 }
 75 |             }
 76 |         }
 77 | 
 78 |         first_rank_attacks
 79 |     };
 80 | }
 81 | 
 82 | fn is_out_rank(dir: Direction, sq: Square) -> bool {
 83 |     let crossed_north = dir.is_north() && sq.rank() == 7;
 84 |     let crossed_south = dir.is_south() && sq.rank() == 0;
 85 |     crossed_north || crossed_south
 86 | }
 87 | 
 88 | fn is_out_file(dir: Direction, sq: Square) -> bool {
 89 |     let crossed_west = dir.is_west() && sq.file() == 0;
 90 |     let crossed_east = dir.is_east() && sq.file() == 7;
 91 |     crossed_west || crossed_east
 92 | }
 93 | 
 94 | fn generate_mask(dir: Direction, sq: Square) -> Bitboard {
 95 |     debug_assert!(sq < OUT);
 96 |     let shift = DIRECTION_SHIFTS[dir];
 97 |     let mut bb = 0;
 98 |     let mut dest = ((sq as Shift) + shift) as Square;
 99 |     loop {
100 |         if is_out_file(dir, dest) || dest >= OUT {
101 |             break;
102 |         }
103 |         bb |= Bitboard::from_square(dest);
104 |         if is_out_rank(dir, dest) {
105 |             break;
106 |         }
107 |         dest = ((dest as Shift) + shift) as Square;
108 |     }
109 |     bb
110 | }
111 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
  1 | //! Little Wing is a chess engine rated at 2050+ ELO, compatible with both UCI
  2 | //! and XBoard protocols, with a nice CLI, and a documented library.
  3 | //!
  4 | //! # Example
  5 | //!
  6 | //! ```rust
  7 | //! use littlewing::chess::*;
  8 | //!
  9 | //! // Byrne vs Fischer (1956)
 10 | //! let fen = "r3r1k1/pp3pbp/1Bp1b1p1/8/2BP4/Q1n2N2/P4PPP/3R1K1R b - - 0 18";
 11 | //!
 12 | //! let mut game = Game::from_fen(fen).unwrap();
 13 | //!
 14 | //! game.clock = Clock::new(1, 5000); // Search 1 move in 5 seconds
 15 | //!
 16 | //! match game.search(1..15) { // Search from depth 1 to 15
 17 | //!     Some(m) => {
 18 | //!         assert_eq!(game.move_to_san(m), "Bxc4");
 19 | //!
 20 | //!         game.make_move(m);
 21 | //!         game.history.push(m); // Keep track of the moves played
 22 | //!
 23 | //!         println!("Engine played {}", m.to_lan());
 24 | //!     },
 25 | //!     None => {
 26 | //!         println!("Engine could not find a move to play");
 27 | //!     }
 28 | //! }
 29 | //! ```
 30 | 
 31 | #![no_std]
 32 | 
 33 | #[allow(unused_imports)]
 34 | #[macro_use]
 35 | extern crate no_std_compat as std;
 36 | 
 37 | #[macro_use]
 38 | extern crate lazy_static;
 39 | extern crate rand;
 40 | extern crate rand_xorshift;
 41 | 
 42 | #[cfg(feature = "std")]
 43 | extern crate dirs;
 44 | #[cfg(feature = "std")]
 45 | extern crate regex;
 46 | #[cfg(feature = "std")]
 47 | extern crate rustyline;
 48 | #[cfg(feature = "std")]
 49 | extern crate rustyline_derive;
 50 | 
 51 | pub mod attack;
 52 | mod board;
 53 | mod common;
 54 | mod dumb7fill;
 55 | mod hyperbola;
 56 | mod piece_move;
 57 | mod piece_move_list;
 58 | mod positions;
 59 | mod piece_square_table;
 60 | mod transposition;
 61 | mod transposition_table;
 62 | mod zobrist;
 63 | 
 64 | /// Bitboard type
 65 | pub mod bitboard;
 66 | 
 67 | /// Clock controls
 68 | pub mod clock;
 69 | 
 70 | /// Color type
 71 | pub mod color;
 72 | 
 73 | /// Evaluation algorithms
 74 | pub mod eval;
 75 | 
 76 | /// Forsyth–Edwards Notation support
 77 | pub mod fen;
 78 | 
 79 | /// Game engine
 80 | pub mod game;
 81 | 
 82 | /// Portable Game Notation support
 83 | pub mod pgn;
 84 | 
 85 | /// Piece move generator
 86 | pub mod piece_move_generator;
 87 | 
 88 | /// Piece move notation
 89 | pub mod piece_move_notation;
 90 | 
 91 | /// Piece type
 92 | pub mod piece;
 93 | 
 94 | /// Communication protocols
 95 | #[cfg(feature = "std")]
 96 | pub mod protocols;
 97 | 
 98 | /// Search algorithms
 99 | pub mod search;
100 | 
101 | /// Square type
102 | pub mod square;
103 | 
104 | /// Chess prelude
105 | pub mod chess {
106 |     pub use crate::attack::Attack;
107 |     pub use crate::clock::Clock;
108 |     pub use crate::color;
109 |     pub use crate::fen::FEN;
110 |     pub use crate::game::Game;
111 |     pub use crate::piece_move_generator::PieceMoveGenerator;
112 |     pub use crate::piece_move_notation::PieceMoveNotation;
113 |     pub use crate::search::Search;
114 | }
115 | 
116 | use std::prelude::v1::*;
117 | 
118 | /// Return Little Wing's version
119 | pub fn version() -> String {
120 |     let ver = String::from("v") + env!("CARGO_PKG_VERSION");
121 |     let ver = option_env!("LITTLEWING_VERSION").unwrap_or(&ver);
122 |     format!("Little Wing {}", ver)
123 | }
124 | 
125 | pub use crate::common::{colorize, bold_white, bold_green, bold_red};
126 | 


--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
 1 | extern crate littlewing;
 2 | extern crate getopts;
 3 | extern crate atty;
 4 | 
 5 | use std::prelude::v1::*;
 6 | use std::env;
 7 | 
 8 | use atty::Stream;
 9 | use getopts::Options;
10 | 
11 | use littlewing::protocols::cli::CLI;
12 | use littlewing::{colorize, bold_white, version};
13 | 
14 | fn print_usage(opts: Options) {
15 |     let brief = format!("Usage: littlewing [options]");
16 |     print!("{}", opts.usage(&brief));
17 | }
18 | 
19 | fn print_banner(mut board: String) {
20 |     let author = "Vincent Ollivier";
21 |     let mut version = version();
22 |     println!("                                      _,;");
23 |     println!("               ,       .--.       _,-'.-;");
24 |     println!("                \\`-, <) o  `._ ,-' ,'`_7");
25 |     println!("                <_  `-\\ _       _,' _.'");
26 |     println!("                  <_`\".| `\\    `  _.>");
27 |     println!("                    <_ ;   \\     _>");
28 |     println!("                     `\"     ;  ``");
29 |     if version.len() < 19 {
30 |         version = format!("{}    \\   |   \\", bold_white(&version));
31 |     } else {
32 |         version = format!("{}", bold_white(&version));
33 |     }
34 |     println!("  {}", version);
35 |     println!("                         '|-. _  \\");
36 |     println!("  by {}  _/ /     \\ '.", bold_white(author));
37 |     board.replace_range(23..35, "\"-\"`---+--'\\_>");
38 |     println!("{}", board);
39 | }
40 | 
41 | fn main() {
42 |     let mut cli = CLI::new();
43 | 
44 |     if !atty::is(Stream::Stdout) {
45 |         colorize(false);
46 |     }
47 | 
48 |     let mut opts = Options::new();
49 |     opts.optopt("t",  "tt",      "set transposition table size (in MB)", "SIZE");
50 |     opts.optflag("d", "debug",   "enable debug output");
51 |     opts.optflag("h", "help",    "print this message");
52 |     opts.optflag("s", "silent",  "display less output");
53 |     opts.optflag("v", "version", "print version");
54 | 
55 |     let args: Vec<String> = env::args().collect();
56 |     let matches = match opts.parse(&args) {
57 |         Ok(m) => { m }
58 |         Err(f) => {
59 |             println!("{}\n", f);
60 |             print_usage(opts);
61 |             return;
62 |         }
63 |     };
64 | 
65 |     if matches.opt_present("h") {
66 |         print_usage(opts);
67 |         return;
68 |     }
69 | 
70 |     if matches.opt_present("v") {
71 |         println!("{}", version());
72 |         return;
73 |     }
74 | 
75 |     if !matches.opt_present("s") {
76 |         cli.show_board = true;
77 |         cli.game.show_coordinates = true;
78 |         print_banner(cli.game.to_string());
79 |     }
80 | 
81 |     if matches.opt_present("d") {
82 |         cli.game.is_debug = true;
83 |     }
84 | 
85 |     if matches.opt_present("t") {
86 |         if let Some(size) = matches.opt_str("t") {
87 |             let memory = size.parse::<usize>().unwrap() << 20;
88 |             cli.game.tt_resize(memory);
89 |         }
90 |     }
91 | 
92 |     cli.run();
93 | }
94 | 


--------------------------------------------------------------------------------
/src/pgn.rs:
--------------------------------------------------------------------------------
  1 | use std::prelude::v1::*;
  2 | use std::collections::BTreeMap;
  3 | use std::fmt;
  4 | 
  5 | #[cfg(feature = "std")]
  6 | use regex::Regex;
  7 | 
  8 | use crate::attack::*;
  9 | use crate::color::*;
 10 | use crate::common::*;
 11 | use crate::fen::FEN;
 12 | use crate::game::Game;
 13 | use crate::piece_move_notation::PieceMoveNotation;
 14 | use crate::piece_move_generator::PieceMoveGenerator;
 15 | use crate::search::*;
 16 | 
 17 | #[derive(Debug)]
 18 | pub struct PGN {
 19 |     // Header keys are sorted by prefixing them with a number
 20 |     headers: BTreeMap<String, String>,
 21 | 
 22 |     body: String,
 23 | }
 24 | 
 25 | lazy_static! {
 26 |     static ref DEFAULT_HEADERS: Vec<(String, String)> = vec![
 27 |         ("1Event".to_string(), "?".to_string()),
 28 |         ("2Site".to_string(), "?".to_string()),
 29 |         ("3White".to_string(), "?".to_string()),
 30 |         ("4Black".to_string(), "?".to_string()),
 31 |         ("5Result".to_string(), "*".to_string()),
 32 |     ];
 33 | }
 34 | 
 35 | impl PGN {
 36 |     fn new() -> PGN {
 37 |         PGN {
 38 |             headers: DEFAULT_HEADERS.clone().into_iter().collect(),
 39 |             body: "".to_string(),
 40 |         }
 41 |     }
 42 | 
 43 |     pub fn white(&self) -> String {
 44 |         self.headers["3White"].clone()
 45 |     }
 46 | 
 47 |     pub fn black(&self) -> String {
 48 |         self.headers["4Black"].clone()
 49 |     }
 50 | 
 51 |     pub fn result(&self) -> String {
 52 |         self.headers["5Result"].clone()
 53 |     }
 54 | 
 55 |     pub fn set_white(&mut self, white: &str) {
 56 |         self.headers.insert("3White".to_string(), white.to_string());
 57 |     }
 58 | 
 59 |     pub fn set_black(&mut self, black: &str) {
 60 |         self.headers.insert("4Black".to_string(), black.to_string());
 61 |     }
 62 | 
 63 |     pub fn set_result(&mut self, result: &str) {
 64 |         self.headers.insert("5Result".to_string(), result.to_string());
 65 |     }
 66 | 
 67 |     pub fn set_fen(&mut self, fen: &str) {
 68 |         self.headers.insert("FEN".to_string(), fen.to_string());
 69 |         self.headers.insert("SetUp".to_string(), "1".to_string());
 70 |     }
 71 | 
 72 |     pub fn set_header(&mut self, key: &str, val: &str) {
 73 |         self.headers.insert(key.to_string(), val.to_string());
 74 |     }
 75 | }
 76 | 
 77 | impl fmt::Display for PGN {
 78 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 79 |         for (key, val) in self.headers.iter() {
 80 |             writeln!(f, "[{} \"{}\"]", key.trim_start_matches(char::is_numeric), val)?;
 81 |         }
 82 |         writeln!(f)?;
 83 |         write!(f, "{}", self.body)?;
 84 |         Ok(())
 85 |     }
 86 | }
 87 | 
 88 | #[cfg(feature = "std")]
 89 | impl From<String> for PGN {
 90 |     fn from(s: String) -> PGN {
 91 |         lazy_static! {
 92 |             static ref RE: Regex = Regex::new("\\[(?P<key>\\w+) \"(?P<val>.*)\"\\]").unwrap();
 93 |         }
 94 |         let mut pgn = PGN::new();
 95 |         for line in s.lines() {
 96 |             match RE.captures(line) {
 97 |                 Some(header) => {
 98 |                     // Keep only the last game
 99 |                     if !pgn.body.is_empty() {
100 |                         pgn = PGN::new();
101 |                     }
102 | 
103 |                     let key = header["key"].to_string();
104 |                     let val = header["val"].to_string();
105 |                     let mut is_default_header = false;
106 |                     for (k, _) in DEFAULT_HEADERS.iter() {
107 |                         if key == k.trim_start_matches(char::is_numeric) {
108 |                             pgn.set_header(k, &val);
109 |                             is_default_header = true;
110 |                             break;
111 |                         }
112 |                     }
113 |                     if !is_default_header {
114 |                         pgn.set_header(&key, &val);
115 |                     }
116 |                 }
117 |                 None => {
118 |                     if !line.is_empty() {
119 |                         pgn.body.push_str(line);
120 |                         pgn.body.push('\n');
121 |                     }
122 |                 }
123 |             }
124 |         }
125 |         pgn
126 |     }
127 | }
128 | 
129 | /// Portable Game Notation export
130 | pub trait ToPGN {
131 |     /// Export to PGN
132 |     fn to_pgn(&mut self) -> PGN;
133 | }
134 | 
135 | impl ToPGN for Game {
136 |     fn to_pgn(&mut self) -> PGN {
137 |         let mut pgn = PGN::new();
138 | 
139 |         let starting_fen = self.starting_fen.clone();
140 |         if starting_fen != DEFAULT_FEN {
141 |             pgn.set_fen(&starting_fen);
142 |         }
143 | 
144 |         let result = if self.is_mate() {
145 |             if self.is_check(WHITE) {
146 |                 "0-1"
147 |             } else if self.is_check(BLACK) {
148 |                 "1-0"
149 |             } else {
150 |                 "1/2-1/2"
151 |             }
152 |         } else {
153 |             "*"
154 |         };
155 |         pgn.set_result(result);
156 | 
157 |         let moves = self.history.clone();
158 |         self.load_fen(&starting_fen).unwrap();
159 | 
160 |         let mut first_move = true;
161 |         let mut line = String::new();
162 |         for m in moves {
163 |             let fm = self.positions.fullmoves();
164 |             if self.side() == WHITE {
165 |                 line.push_str(&format!("{}. ", fm));
166 |             } else if first_move {
167 |                 line.push_str(&format!("{}. ... ", fm));
168 |             }
169 |             first_move = false;
170 | 
171 |             line.push_str(&self.move_to_san(m));
172 | 
173 |             self.make_move(m);
174 |             self.history.push(m);
175 | 
176 |             if self.is_mate() {
177 |                 line.push('#');
178 |             } else if self.is_check(self.side()) {
179 |                 line.push('+');
180 |             }
181 | 
182 |             if line.len() > 70 {
183 |                 pgn.body.push_str(&format!("{}\n", line));
184 |                 line = String::new();
185 |             } else {
186 |                 line.push(' ');
187 |             }
188 |         }
189 |         pgn.body.push_str(&format!("{}{}\n", line, result));
190 | 
191 |         pgn
192 |     }
193 | }
194 | 
195 | /// Portable Game Notation import
196 | #[cfg(feature = "std")]
197 | pub trait LoadPGN {
198 |     /// Load PGN
199 |     fn load_pgn(&mut self, pgn: PGN);
200 | }
201 | 
202 | #[cfg(feature = "std")]
203 | impl LoadPGN for Game {
204 |     fn load_pgn(&mut self, pgn: PGN) {
205 |         self.clear();
206 |         let starting_fen = pgn.headers.get("FEN").map_or(DEFAULT_FEN, String::as_str);
207 |         self.load_fen(starting_fen).unwrap();
208 |         let mut comment_level = 0;
209 |         let mut variation_level = 0;
210 |         for line in pgn.body.lines() {
211 |             for word in line.split(' ') {
212 |                 if word.starts_with(';') {
213 |                     break;
214 |                 }
215 |                 comment_level += word.matches('{').count();
216 |                 comment_level -= word.matches('}').count();
217 |                 variation_level += word.matches('(').count();
218 |                 variation_level -= word.matches(')').count();
219 |                 if comment_level > 0 || variation_level > 0 {
220 |                     continue;
221 |                 }
222 | 
223 |                 if let Some(m) = self.parse_move(word) {
224 |                     self.make_move(m);
225 |                     self.history.push(m);
226 |                 }
227 |             }
228 |         }
229 |     }
230 | }
231 | 
232 | #[cfg(feature = "std")]
233 | #[cfg(test)]
234 | mod tests {
235 |     use std::fs;
236 | 
237 |     use crate::square::*;
238 |     use crate::common::*;
239 |     use crate::game::Game;
240 |     use crate::piece_move::PieceMove;
241 |     use crate::piece_move_generator::PieceMoveGenerator;
242 | 
243 |     use super::*;
244 | 
245 |     #[test]
246 |     fn test_game_to_pgn() {
247 |         let mut game = Game::from_fen(DEFAULT_FEN).unwrap();
248 |         let moves = vec![
249 |             PieceMove::new(F2, F3, QUIET_MOVE),
250 |             PieceMove::new(E7, E5, DOUBLE_PAWN_PUSH),
251 |             PieceMove::new(G2, G4, DOUBLE_PAWN_PUSH),
252 |             PieceMove::new(D8, H4, QUIET_MOVE)
253 |         ];
254 |         for m in moves {
255 |             game.make_move(m);
256 |             game.history.push(m);
257 |         }
258 |         let pgn = game.to_pgn();
259 | 
260 |         let content = fs::read_to_string("tests/fool.pgn").unwrap();
261 |         assert_eq!(pgn.to_string(), content);
262 |     }
263 | 
264 |     #[test]
265 |     fn test_string_to_pgn() {
266 |         let content = fs::read_to_string("tests/fool.pgn").unwrap();
267 |         let pgn = PGN::from(content.clone());
268 |         assert_eq!(pgn.to_string(), content);
269 |         assert_eq!(pgn.result(), "0-1".to_string());
270 |     }
271 | 
272 |     #[test]
273 |     fn test_game_load_pgn() {
274 |         let mut game = Game::new();
275 | 
276 |         let s1 = fs::read_to_string("tests/fool.pgn").unwrap();
277 |         let pgn = PGN::from(s1.clone());
278 |         game.load_pgn(pgn);
279 |         assert_eq!(game.history.len(), 4);
280 | 
281 |         let s2 = fs::read_to_string("tests/zukertort_vs_steinitz_1886.pgn").unwrap();
282 |         let pgn = PGN::from(s2.clone());
283 |         game.load_pgn(pgn);
284 |         assert_eq!(game.history.len(), 58);
285 | 
286 |         let pgn = PGN::from(format!("{}\n{}", s1, s2));
287 |         game.load_pgn(pgn);
288 |         assert_eq!(game.history.len(), 58);
289 |     }
290 | }
291 | 


--------------------------------------------------------------------------------
/src/piece.rs:
--------------------------------------------------------------------------------
  1 | use crate::color::*;
  2 | 
  3 | pub type Piece = u8;
  4 | 
  5 | #[allow(dead_code)]
  6 | pub const LEAPER: Piece = 0b0000;
  7 | 
  8 | #[allow(dead_code)]
  9 | pub const SLIDER: Piece = 0b1000;
 10 | 
 11 | pub const EMPTY:  Piece = 0b0000; // 0
 12 | pub const PAWN:   Piece = 0b0010; // 2
 13 | pub const KNIGHT: Piece = 0b0100; // 4
 14 | pub const KING:   Piece = 0b0110; // 6
 15 | pub const BISHOP: Piece = 0b1000; // 8
 16 | pub const ROOK:   Piece = 0b1010; // 10
 17 | pub const QUEEN:  Piece = 0b1100; // 12
 18 | 
 19 | pub const PIECES: [Piece; 6] = [PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING];
 20 | 
 21 | pub const WHITE_PAWN:   Piece = WHITE | PAWN;
 22 | pub const WHITE_KNIGHT: Piece = WHITE | KNIGHT;
 23 | pub const WHITE_BISHOP: Piece = WHITE | BISHOP;
 24 | pub const WHITE_ROOK:   Piece = WHITE | ROOK;
 25 | pub const WHITE_QUEEN:  Piece = WHITE | QUEEN;
 26 | pub const WHITE_KING:   Piece = WHITE | KING;
 27 | pub const BLACK_PAWN:   Piece = BLACK | PAWN;
 28 | pub const BLACK_KNIGHT: Piece = BLACK | KNIGHT;
 29 | pub const BLACK_BISHOP: Piece = BLACK | BISHOP;
 30 | pub const BLACK_ROOK:   Piece = BLACK | ROOK;
 31 | pub const BLACK_QUEEN:  Piece = BLACK | QUEEN;
 32 | pub const BLACK_KING:   Piece = BLACK | KING;
 33 | 
 34 | pub trait PieceChar {
 35 |     fn from_char(c: char) -> Self;
 36 |     fn to_char(&self) -> char;
 37 | }
 38 | 
 39 | impl PieceChar for Piece {
 40 |     fn from_char(c: char) -> Piece {
 41 |         match c {
 42 |             'P' => WHITE_PAWN,
 43 |             'N' => WHITE_KNIGHT,
 44 |             'B' => WHITE_BISHOP,
 45 |             'R' => WHITE_ROOK,
 46 |             'Q' => WHITE_QUEEN,
 47 |             'K' => WHITE_KING,
 48 |             'p' => BLACK_PAWN,
 49 |             'n' => BLACK_KNIGHT,
 50 |             'b' => BLACK_BISHOP,
 51 |             'r' => BLACK_ROOK,
 52 |             'q' => BLACK_QUEEN,
 53 |             'k' => BLACK_KING,
 54 |             _   => EMPTY // FIXME
 55 |         }
 56 |     }
 57 | 
 58 |     fn to_char(&self) -> char {
 59 |         match *self {
 60 |             WHITE_PAWN   => 'P',
 61 |             WHITE_KNIGHT => 'N',
 62 |             WHITE_BISHOP => 'B',
 63 |             WHITE_ROOK   => 'R',
 64 |             WHITE_QUEEN  => 'Q',
 65 |             WHITE_KING   => 'K',
 66 |             BLACK_PAWN   => 'p',
 67 |             BLACK_KNIGHT => 'n',
 68 |             BLACK_BISHOP => 'b',
 69 |             BLACK_ROOK   => 'r',
 70 |             BLACK_QUEEN  => 'q',
 71 |             BLACK_KING   => 'k',
 72 |             EMPTY        => ' ', // FIXME: not really for FEN format
 73 |             _            => '?' // FIXME
 74 |         }
 75 |     }
 76 | }
 77 | 
 78 | pub trait PieceAttr {
 79 |     /// Get the color of a piece
 80 |     fn color(&self) -> Color;
 81 | 
 82 |     /// Get a piece without its color
 83 |     fn kind(&self) -> Piece;
 84 | 
 85 |     fn is_pawn(&self) -> bool;
 86 |     fn is_knight(&self) -> bool;
 87 |     fn is_bishop(&self) -> bool;
 88 |     fn is_rook(&self) -> bool;
 89 |     fn is_queen(&self) -> bool;
 90 |     fn is_king(&self) -> bool;
 91 | }
 92 | 
 93 | impl PieceAttr for Piece {
 94 |     fn color(&self) -> Color {
 95 |         *self & 0b0001
 96 |     }
 97 |     fn kind(&self) -> Piece {
 98 |         *self & 0b1110
 99 |     }
100 |     fn is_pawn(&self) -> bool {
101 |         self.kind() == PAWN
102 |     }
103 |     fn is_knight(&self) -> bool {
104 |         self.kind() == KNIGHT
105 |     }
106 |     fn is_bishop(&self) -> bool {
107 |         self.kind() == BISHOP
108 |     }
109 |     fn is_rook(&self) -> bool {
110 |         self.kind() == ROOK
111 |     }
112 |     fn is_queen(&self) -> bool {
113 |         self.kind() == QUEEN
114 |     }
115 |     fn is_king(&self) -> bool {
116 |         self.kind() == KING
117 |     }
118 | }
119 | 
120 | #[cfg(test)]
121 | mod tests {
122 |     use super::*;
123 | 
124 |     #[test]
125 |     fn test_piece() {
126 |         assert_eq!(LEAPER & PAWN,   LEAPER);
127 |         assert_eq!(LEAPER & KNIGHT, LEAPER);
128 |         assert_eq!(LEAPER & KING,   LEAPER);
129 |         assert_eq!(LEAPER & BISHOP, EMPTY);
130 |         assert_eq!(LEAPER & ROOK,   EMPTY);
131 |         assert_eq!(LEAPER & QUEEN,  EMPTY);
132 | 
133 |         assert_eq!(SLIDER & PAWN,   EMPTY);
134 |         assert_eq!(SLIDER & KNIGHT, EMPTY);
135 |         assert_eq!(SLIDER & KING,   EMPTY);
136 |         assert_eq!(SLIDER & BISHOP, SLIDER);
137 |         assert_eq!(SLIDER & ROOK,   SLIDER);
138 |         assert_eq!(SLIDER & QUEEN,  SLIDER);
139 |     }
140 | }
141 | 


--------------------------------------------------------------------------------
/src/piece_move.rs:
--------------------------------------------------------------------------------
  1 | use std::prelude::v1::*;
  2 | use std::fmt;
  3 | 
  4 | use crate::color::*;
  5 | use crate::piece::*;
  6 | use crate::square::*;
  7 | use crate::common::*;
  8 | use crate::piece::PieceChar;
  9 | use crate::square::SquareExt;
 10 | 
 11 | pub const BEST_MOVE_SCORE:    u8 = 255;
 12 | pub const KILLER_MOVE_SCORE:  u8 = 254;
 13 | pub const GOOD_CAPTURE_SCORE: u8 = 64;
 14 | pub const QUIET_MOVE_SCORE:   u8 = 0;
 15 | 
 16 | #[derive(Copy, Clone, Eq, PartialEq)]
 17 | pub struct PieceMove(u16);
 18 | 
 19 | impl PieceMove {
 20 |     pub fn new(from: Square, to: Square, mt: PieceMoveType) -> PieceMove {
 21 |         // from: 6 bits
 22 |         // to:   6 bits
 23 |         // mt:   4 bits
 24 |         PieceMove(((from as u16) << 10) | ((to as u16) << 4) | mt as u16)
 25 |     }
 26 | 
 27 |     pub fn new_null() -> PieceMove {
 28 |         PieceMove(0)
 29 |     }
 30 | 
 31 |     pub fn from(self) -> Square {
 32 |         (self.0 >> 10) as Square
 33 |     }
 34 | 
 35 |     pub fn to(self) -> Square {
 36 |         ((self.0 >> 4) & 0b111111) as Square
 37 |     }
 38 | 
 39 |     pub fn kind(self) -> PieceMoveType {
 40 |         (self.0 & 0b1111) as PieceMoveType
 41 |     }
 42 | 
 43 |     pub fn is_null(self) -> bool {
 44 |         self.0 == 0
 45 |     }
 46 | 
 47 |     // TODO: Add en passant?
 48 |     pub fn is_capture(self) -> bool {
 49 |         self.kind() == CAPTURE || self.kind() & PROMOTION_KIND_MASK == PROMOTION_KIND_MASK
 50 |     }
 51 | 
 52 |     pub fn is_en_passant(self) -> bool {
 53 |         self.kind() == EN_PASSANT
 54 |     }
 55 | 
 56 |     pub fn is_castle(self) -> bool {
 57 |         self.kind() == KING_CASTLE || self.kind() == QUEEN_CASTLE
 58 |     }
 59 | 
 60 |     pub fn castle_kind(self) -> Piece {
 61 |         QUEEN_CASTLE << self.kind() - 1
 62 |     }
 63 | 
 64 |     pub fn is_promotion(self) -> bool {
 65 |         self.kind() & PROMOTION_MASK > 0
 66 |     }
 67 | 
 68 |     pub fn promotion_kind(self) -> Piece {
 69 |         PROMOTION_KINDS[(self.kind() & PROMOTION_KIND_MASK >> 2) as usize]
 70 |     }
 71 | 
 72 |     pub fn to_lan(self) -> String {
 73 |         self.to_string()
 74 |     }
 75 | }
 76 | 
 77 | impl fmt::Display for PieceMove {
 78 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 79 |         let mut out = String::new();
 80 |         out.push_str(self.from().to_coord().as_str());
 81 |         out.push_str(self.to().to_coord().as_str());
 82 |         if self.is_promotion() {
 83 |             out.push((BLACK | self.promotion_kind()).to_char());
 84 |         }
 85 |         write!(f, "{}", out)
 86 |     }
 87 | }
 88 | 
 89 | impl fmt::Debug for PieceMove {
 90 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 91 |         write!(f, "{}", self)
 92 |     }
 93 | }
 94 | 
 95 | 
 96 | #[cfg(test)]
 97 | mod tests {
 98 |     use crate::piece::*;
 99 |     use crate::common::*;
100 |     use super::*;
101 | 
102 |     #[test]
103 |     fn test_move_is_castle() {
104 |         assert_eq!(PieceMove::new(E2, E3, QUIET_MOVE).is_castle(), false);
105 |         assert_eq!(PieceMove::new(E1, G1, KING_CASTLE).is_castle(), true);
106 |         assert_eq!(PieceMove::new(E1, C1, QUEEN_CASTLE).is_castle(), true);
107 |     }
108 | 
109 |     #[test]
110 |     fn test_move_castle_kind() {
111 |         assert_eq!(PieceMove::new(E1, G1, KING_CASTLE).castle_kind(), KING);
112 |         assert_eq!(PieceMove::new(E1, C1, QUEEN_CASTLE).castle_kind(), QUEEN);
113 |     }
114 | 
115 |     #[test]
116 |     fn test_move_is_promotion() {
117 |         assert_eq!(PieceMove::new(E2, E3, QUIET_MOVE).is_promotion(), false);
118 |         assert_eq!(PieceMove::new(E7, E8, QUEEN_PROMOTION).is_promotion(), true);
119 |         assert_eq!(PieceMove::new(E7, D8, QUEEN_PROMOTION_CAPTURE).is_promotion(), true);
120 |     }
121 | 
122 |     #[test]
123 |     fn test_move_promotion_kind() {
124 |         assert_eq!(PieceMove::new(E7, E8, QUEEN_PROMOTION).promotion_kind(), QUEEN);
125 |         assert_eq!(PieceMove::new(E7, D8, ROOK_PROMOTION_CAPTURE).promotion_kind(), ROOK);
126 |     }
127 | }
128 | 


--------------------------------------------------------------------------------
/src/piece_move_list.rs:
--------------------------------------------------------------------------------
  1 | use std::prelude::v1::*;
  2 | use std::ops::{Index, IndexMut};
  3 | 
  4 | use crate::color::*;
  5 | use crate::piece::*;
  6 | use crate::square::*;
  7 | use crate::common::*;
  8 | use crate::attack::*;
  9 | use crate::piece_move::*;
 10 | use crate::square::SquareExt;
 11 | use crate::bitboard::{Bitboard, BitboardExt, BitboardIterator};
 12 | use crate::hyperbola::bishop_attacks;
 13 | use crate::hyperbola::rook_attacks;
 14 | 
 15 | #[derive(Copy, Clone, Eq, PartialEq)]
 16 | pub struct Scored<T, S> {
 17 |     pub item: T,
 18 |     pub score: S
 19 | }
 20 | 
 21 | impl<T, S> Scored<T, S> {
 22 |     pub fn new(item: T, score: S) -> Self {
 23 |         Scored { item, score }
 24 |     }
 25 | }
 26 | 
 27 | #[repr(u8)]
 28 | #[derive(Clone, Copy, Eq, PartialEq, PartialOrd, Debug)]
 29 | pub enum PieceMoveListStage { // If we don't care about `PartialOrd` we could do:
 30 |     BestPieceMove   = 0,      // = 16 (BEST_MOVE)
 31 |     Capture         = 1,      // =  4 (CAPTURE)
 32 |     KillerPieceMove = 2,      // = 17 (KILLER_MOVE)
 33 |     QuietPieceMove  = 3,      // =  0 (QUIET_MOVE < CAPTURE)
 34 |     Done            = 4,
 35 | }
 36 | 
 37 | // Convert `PieceMoveListStage::Capture` into `CAPTURE`
 38 | // and `PieceMoveListStage::QuietPieceMove` into `QUIET_MOVE`
 39 | // but does not work with other values of `PieceMoveListStage`
 40 | impl From<PieceMoveListStage> for PieceMoveType {
 41 |     fn from(stage: PieceMoveListStage) -> Self {
 42 |         // Without `PartialOrd` we could do: stage as PieceMoveType
 43 |         CAPTURE * ((stage == PieceMoveListStage::Capture) as PieceMoveType)
 44 |     }
 45 | }
 46 | 
 47 | #[derive(Clone)]
 48 | pub struct PieceMoveList {
 49 |     killers: [[PieceMove; MAX_KILLERS]; MAX_PLY],
 50 | 
 51 |     // We store the generated moves for each ply in a two dimensional array
 52 |     // used by the recursive search function. It must be able to store any
 53 |     // ply up to `MAX_PLY`, the theoretical maximum number of plies in a chess
 54 |     // game. And likewise it must be able to store the generated moves up to
 55 |     // the maximum of any chess position `MAX_MOVES`.
 56 |     lists: [[Scored<PieceMove, u8>; MAX_MOVES]; MAX_PLY],
 57 | 
 58 |     // Number of moves at a given ply.
 59 |     sizes: [usize; MAX_PLY],
 60 | 
 61 |     // Index of the current move being searched at a given ply.
 62 |     indexes: [usize; MAX_PLY],
 63 | 
 64 |     stages: [PieceMoveListStage; MAX_PLY],
 65 | 
 66 |     pub skip_ordering: bool,
 67 |     pub skip_killers: bool,
 68 | 
 69 |     // Index of the ply currently searched.
 70 |     ply: usize,
 71 | }
 72 | 
 73 | impl PieceMoveList {
 74 |     pub fn new() -> PieceMoveList {
 75 |         PieceMoveList {
 76 |             killers: [[PieceMove::new_null(); MAX_KILLERS]; MAX_PLY],
 77 |             lists: [[Scored::new(PieceMove::new_null(), 0); MAX_MOVES]; MAX_PLY],
 78 |             sizes: [0; MAX_PLY],
 79 |             indexes: [0; MAX_PLY],
 80 |             stages: [PieceMoveListStage::BestPieceMove; MAX_PLY],
 81 |             skip_ordering: false,
 82 |             skip_killers: false,
 83 |             ply: 0,
 84 |         }
 85 |     }
 86 | 
 87 |     pub fn inc(&mut self) {
 88 |         self.ply += 1;
 89 |     }
 90 | 
 91 |     pub fn dec(&mut self) {
 92 |         // NOTE: the condition is only required if we use `moves.clear_all()`
 93 |         // in `root()` instead of `moves.clear()` that is used in `search()`
 94 |         // and `quiescence()`.
 95 |         if self.ply > 0 {
 96 |             self.ply -= 1;
 97 |         }
 98 |     }
 99 | 
100 |     pub fn clear(&mut self) {
101 |         self.sizes[self.ply] = 0;
102 |         self.indexes[self.ply] = 0;
103 |         self.stages[self.ply] = PieceMoveListStage::BestPieceMove;
104 |     }
105 | 
106 |     pub fn clear_all(&mut self) {
107 |         self.killers = [[PieceMove::new_null(); MAX_KILLERS]; MAX_PLY];
108 |         self.sizes = [0; MAX_PLY];
109 |         self.indexes = [0; MAX_PLY];
110 |         self.stages = [PieceMoveListStage::BestPieceMove; MAX_PLY];
111 |         self.ply = 0;
112 |     }
113 | 
114 |     pub fn len(&self) -> usize {
115 |         self.sizes[self.ply]
116 |     }
117 | 
118 |     pub fn index(&self) -> usize {
119 |         self.indexes[self.ply]
120 |     }
121 | 
122 |     pub fn stage(&self) -> PieceMoveListStage {
123 |         self.stages[self.ply]
124 |     }
125 | 
126 |     pub fn next_stage(&mut self) {
127 |         self.stages[self.ply] = match self.stages[self.ply] {
128 |             PieceMoveListStage::BestPieceMove   => PieceMoveListStage::Capture,
129 |             PieceMoveListStage::Capture    => PieceMoveListStage::KillerPieceMove,
130 |             PieceMoveListStage::KillerPieceMove => PieceMoveListStage::QuietPieceMove,
131 |             PieceMoveListStage::QuietPieceMove  => PieceMoveListStage::Done,
132 |             PieceMoveListStage::Done       => panic!("no next stage")
133 |         }
134 |     }
135 | 
136 |     pub fn is_last_stage(&self) -> bool {
137 |         // debug_assert(self.stages[self.ply] != PieceMoveListStage::Done);
138 |         // self.stages[self.ply] == PieceMoveListStage::QuietPieceMove
139 |         self.stages[self.ply] >= PieceMoveListStage::QuietPieceMove
140 |     }
141 | 
142 |     #[allow(dead_code)]
143 |     pub fn is_empty(&self) -> bool {
144 |         self.sizes[self.ply] == 0
145 |     }
146 | 
147 |     pub fn add_move(&mut self, m: PieceMove) {
148 |         // Avoid adding again a best move
149 |         // NOTE: The best move is always first in the list, but the list
150 |         // could contains previous entries so we need to check its current
151 |         // length.
152 |         if self.len() > 0 && self.lists[self.ply][0].item == m {
153 |             return;
154 |         }
155 | 
156 |         // Avoid adding again a killer move
157 |         if self.stage() == PieceMoveListStage::QuietPieceMove && !self.skip_killers {
158 |             for &killer in &self.killers[self.ply] {
159 |                 if killer == m {
160 |                     return;
161 |                 }
162 |             }
163 |         }
164 | 
165 |         // NOTE: we cannot use MVV/LVA or SEE to assign a score to captures
166 |         // here because we don't have access to the board from `PieceMoveList`.
167 |         let score = match self.stage() {
168 |             PieceMoveListStage::BestPieceMove   => BEST_MOVE_SCORE,
169 |             PieceMoveListStage::Capture    => QUIET_MOVE_SCORE,
170 |             PieceMoveListStage::KillerPieceMove => KILLER_MOVE_SCORE,
171 |             PieceMoveListStage::QuietPieceMove  => QUIET_MOVE_SCORE,
172 |             PieceMoveListStage::Done       => panic!("last stage")
173 |         };
174 | 
175 |         self.lists[self.ply][self.sizes[self.ply]] = Scored::new(m, score);
176 |         self.sizes[self.ply] += 1;
177 |     }
178 | 
179 |     pub fn add_moves(&mut self, mut targets: Bitboard, dir: Shift, mt: PieceMoveType) {
180 |         while targets != 0 {
181 |             let to = targets.scan() as Square;
182 |             debug_assert!((to as Shift) - dir >= 0);
183 |             debug_assert!((to as Shift) - dir < 64);
184 |             let from = ((to as Shift) - dir) as Square;
185 |             let m = PieceMove::new(from, to, mt);
186 |             self.add_move(m);
187 |             targets.reset(to);
188 |         }
189 |     }
190 | 
191 |     pub fn add_moves_from(&mut self, mut targets: Bitboard, from: Square, mt: PieceMoveType) {
192 |         while targets != 0 {
193 |             let to = targets.scan() as Square;
194 |             let m = PieceMove::new(from, to, mt);
195 |             self.add_move(m);
196 |             targets.reset(to);
197 |         }
198 |     }
199 | 
200 |     pub fn add_pawns_moves(&mut self, bitboards: &[Bitboard], side: Color, ep: Square) {
201 |         let ydir = YSHIFTS[side as usize];
202 |         let end_rank = END_RANKS[side as usize];
203 | 
204 |         match self.stage() {
205 |             PieceMoveListStage::QuietPieceMove => {
206 |                 let occupied = bitboards[WHITE as usize] | bitboards[BLACK as usize];
207 | 
208 |                 let pushes = bitboards[(side | PAWN) as usize].shift(ydir) & !occupied;
209 | 
210 |                 self.add_moves(pushes & !end_rank, ydir, QUIET_MOVE);
211 |                 self.add_moves(pushes & end_rank, ydir, KNIGHT_PROMOTION);
212 |                 self.add_moves(pushes & end_rank, ydir, BISHOP_PROMOTION);
213 |                 self.add_moves(pushes & end_rank, ydir, ROOK_PROMOTION);
214 |                 self.add_moves(pushes & end_rank, ydir, QUEEN_PROMOTION);
215 | 
216 |                 let double_pushes = (pushes & SEC_RANKS[side as usize]).shift(ydir) & !occupied;
217 |                 self.add_moves(double_pushes, 2 * ydir, DOUBLE_PAWN_PUSH);
218 |             },
219 |             PieceMoveListStage::Capture => {
220 |                 for i in 0..2 { // LEFT and RIGHT attacks
221 |                     let dir = ydir + XSHIFTS[i as usize];
222 |                     let attackers = bitboards[(side | PAWN) as usize] & !END_FILES[i];
223 | 
224 |                     let targets = attackers.shift(dir);
225 |                     //let epb = 1 << ep; // FIXME: 1 << 64 == 0
226 |                     let epb = ((ep as u64 >> 6) ^ 1) << (ep % 64);
227 |                     self.add_moves(targets & epb, dir, EN_PASSANT);
228 | 
229 |                     let attacks = targets & bitboards[(side ^ 1) as usize];
230 | 
231 |                     self.add_moves(attacks & !end_rank, dir, CAPTURE);
232 |                     self.add_moves(attacks & end_rank, dir, KNIGHT_PROMOTION_CAPTURE);
233 |                     self.add_moves(attacks & end_rank, dir, BISHOP_PROMOTION_CAPTURE);
234 |                     self.add_moves(attacks & end_rank, dir, ROOK_PROMOTION_CAPTURE);
235 |                     self.add_moves(attacks & end_rank, dir, QUEEN_PROMOTION_CAPTURE);
236 |                 }
237 |             },
238 |             _ => panic!("wrong generation stage")
239 |         }
240 |     }
241 | 
242 |     // NOTE: this method is the generic version of the next methods
243 |     // but it's slower due to the `match` in `attacks` called in the loop.
244 |     #[allow(dead_code)]
245 |     pub fn add_moves_for(&mut self, p: Piece, bitboards: &[Bitboard], side: Color) {
246 |         let occupied = bitboards[WHITE as usize] | bitboards[BLACK as usize];
247 |         let mut pieces = bitboards[(side | p) as usize];
248 |         let mt = PieceMoveType::from(self.stage());
249 |         let targets = match self.stage() {
250 |             PieceMoveListStage::QuietPieceMove => !occupied,
251 |             PieceMoveListStage::Capture        => bitboards[(side ^ 1) as usize],
252 |             _                                  => panic!("wrong generation stage")
253 |         };
254 |         while let Some(from) = pieces.next() {
255 |             let mask = piece_attacks(p, from, occupied);
256 |             self.add_moves_from(targets & mask, from, mt);
257 |         }
258 |     }
259 | 
260 |     pub fn add_knights_moves(&mut self, bitboards: &[Bitboard], side: Color) {
261 |         let occupied = bitboards[WHITE as usize] | bitboards[BLACK as usize];
262 |         let mut knights = bitboards[(side | KNIGHT) as usize];
263 |         let mt = PieceMoveType::from(self.stage());
264 |         let dests = match self.stage() {
265 |             PieceMoveListStage::QuietPieceMove => !occupied,
266 |             PieceMoveListStage::Capture        => bitboards[(side ^ 1) as usize],
267 |             _                                  => panic!("wrong generation stage")
268 |         };
269 |         while let Some(from) = knights.next() {
270 |             let mask = PIECE_MASKS[KNIGHT as usize][from as usize];
271 |             let targets = dests & mask;
272 |             self.add_moves_from(targets, from, mt);
273 |         }
274 |     }
275 | 
276 |     pub fn add_king_moves(&mut self, bitboards: &[Bitboard], side: Color) {
277 |         let occupied = bitboards[WHITE as usize] | bitboards[BLACK as usize];
278 |         let mut kings = bitboards[(side | KING) as usize];
279 |         let mt = PieceMoveType::from(self.stage());
280 |         let dests = match self.stage() {
281 |             PieceMoveListStage::QuietPieceMove => !occupied,
282 |             PieceMoveListStage::Capture        => bitboards[(side ^ 1) as usize],
283 |             _                                  => panic!("wrong generation stage")
284 |         };
285 |         while let Some(from) = kings.next() {
286 |             let mask = PIECE_MASKS[KING as usize][from as usize];
287 |             let targets = dests & mask;
288 |             self.add_moves_from(targets, from, mt);
289 |         }
290 |     }
291 | 
292 |     pub fn add_bishops_moves(&mut self, bitboards: &[Bitboard], side: Color) {
293 |         let occupied = bitboards[WHITE as usize] | bitboards[BLACK as usize];
294 |         let mut bishops = bitboards[(side | BISHOP) as usize];
295 |         let mt = PieceMoveType::from(self.stage());
296 |         let dests = match self.stage() {
297 |             PieceMoveListStage::QuietPieceMove => !occupied,
298 |             PieceMoveListStage::Capture        => bitboards[(side ^ 1) as usize],
299 |             _                                  => panic!("wrong generation stage")
300 |         };
301 |         while let Some(from) = bishops.next() {
302 |             let targets = bishop_attacks(from, occupied);
303 |             self.add_moves_from(targets & dests, from, mt);
304 |         }
305 |     }
306 | 
307 |     pub fn add_rooks_moves(&mut self, bitboards: &[Bitboard], side: Color) {
308 |         let occupied = bitboards[WHITE as usize] | bitboards[BLACK as usize];
309 |         let mut rooks = bitboards[(side | ROOK) as usize];
310 |         let mt = PieceMoveType::from(self.stage());
311 |         let dests = match self.stage() {
312 |             PieceMoveListStage::QuietPieceMove => !occupied,
313 |             PieceMoveListStage::Capture        => bitboards[(side ^ 1) as usize],
314 |             _                                  => panic!("wrong generation stage")
315 |         };
316 |         while let Some(from) = rooks.next() {
317 |             let targets = rook_attacks(from, occupied);
318 |             self.add_moves_from(targets & dests, from, mt);
319 |         }
320 |     }
321 | 
322 |     pub fn add_queens_moves(&mut self, bitboards: &[Bitboard], side: Color) {
323 |         let occupied = bitboards[WHITE as usize] | bitboards[BLACK as usize];
324 |         let mut queens = bitboards[(side | QUEEN) as usize];
325 |         let mt = PieceMoveType::from(self.stage());
326 |         let dests = match self.stage() {
327 |             PieceMoveListStage::QuietPieceMove => !occupied,
328 |             PieceMoveListStage::Capture        => bitboards[(side ^ 1) as usize],
329 |             _                                  => panic!("wrong generation stage")
330 |         };
331 |         while let Some(from) = queens.next() {
332 |             let targets = bishop_attacks(from, occupied) | rook_attacks(from, occupied);
333 |             self.add_moves_from(targets & dests, from, mt);
334 |         }
335 |     }
336 | 
337 |     pub fn add_king_castle(&mut self, side: Color) {
338 |         let m = PieceMove::new(E1.flip(side), G1.flip(side), KING_CASTLE);
339 |         self.add_move(m);
340 |     }
341 | 
342 |     pub fn add_queen_castle(&mut self, side: Color) {
343 |         let m = PieceMove::new(E1.flip(side), C1.flip(side), QUEEN_CASTLE);
344 |         self.add_move(m);
345 |     }
346 | 
347 |     pub fn swap(&mut self, i: usize, j: usize) {
348 |         self.lists[self.ply].swap(i, j);
349 |     }
350 | 
351 |     pub fn get_killer_move(&mut self, i: usize) -> PieceMove {
352 |         self.killers[self.ply][i]
353 |     }
354 | 
355 |     pub fn add_killer_move(&mut self, killer_move: PieceMove) {
356 |         debug_assert_eq!(MAX_KILLERS, 2);
357 |         if killer_move != self.killers[self.ply][0] {
358 |             self.killers[self.ply][1] = self.killers[self.ply][0];
359 |             self.killers[self.ply][0] = killer_move;
360 |         }
361 |     }
362 | }
363 | 
364 | impl Iterator for PieceMoveList {
365 |     type Item = PieceMove;
366 | 
367 |     fn next(&mut self) -> Option<PieceMove> {
368 |         let i = self.indexes[self.ply];
369 |         let n = self.sizes[self.ply];
370 | 
371 |         if i < n {
372 |             self.indexes[self.ply] += 1;
373 |             /*
374 |             if !self.skip_ordering {
375 |                 // Find the next best move by selection sort
376 |                 let mut j = i;
377 |                 for k in (i + 1)..n {
378 |                     if self.lists[self.ply][j].score < self.lists[self.ply][k].score {
379 |                         j = k
380 |                     }
381 |                 }
382 | 
383 |                 // Swap it with the current next move
384 |                 if i != j {
385 |                     self.lists[self.ply].swap(i, j);
386 |                 }
387 |             }
388 |             */
389 | 
390 |             Some(self.lists[self.ply][i].item)
391 |         } else {
392 |             None
393 |         }
394 |     }
395 | }
396 | 
397 | impl Index<usize> for PieceMoveList {
398 |     type Output = Scored<PieceMove, u8>;
399 | 
400 |     fn index(&self, index: usize) -> &Scored<PieceMove, u8> {
401 |         &self.lists[self.ply][index]
402 |     }
403 | }
404 | 
405 | impl IndexMut<usize> for PieceMoveList {
406 |     fn index_mut(&mut self, index: usize) -> &mut Scored<PieceMove, u8> {
407 |         &mut self.lists[self.ply][index]
408 |     }
409 | }
410 | 
411 | #[cfg(test)]
412 | mod tests {
413 |     use crate::common::*;
414 |     use super::*;
415 | 
416 |     #[test]
417 |     fn test_next_stage() {
418 |         let mut moves = PieceMoveList::new();
419 |         assert_eq!(moves.stage(), PieceMoveListStage::BestPieceMove);
420 |         moves.next_stage();
421 |         assert_eq!(moves.stage(), PieceMoveListStage::Capture);
422 |         moves.next_stage();
423 |         assert_eq!(moves.stage(), PieceMoveListStage::KillerPieceMove);
424 |         moves.next_stage();
425 |         assert_eq!(moves.stage(), PieceMoveListStage::QuietPieceMove);
426 |     }
427 | 
428 |     #[test]
429 |     fn test_moves_ordering() {
430 |         // TODO: rewrite this test
431 | 
432 |         // NOTE: move ordering is now done outside of PieceMoveList to access the board
433 |         let m1 = PieceMove::new(D2, C1, QUIET_MOVE);
434 |         let m2 = PieceMove::new(D2, C2, CAPTURE);
435 |         //let m3 = PieceMove::new(D2, C3, CAPTURE);
436 | 
437 |         let mut moves = PieceMoveList::new();
438 |         moves.add_move(m1);
439 |         moves.next_stage(); // From BestPieceMove to Capture
440 |         moves.add_move(m2);
441 |         moves.next_stage(); // From Capture to QuietPieceMove
442 |         //moves.add_move(m3);
443 | 
444 |         println!("m1 = {}, {}", moves[0].item, moves[0].score);
445 |         println!("m2 = {}, {}", moves[1].item, moves[1].score);
446 |         //println!("m3 = {}, {}", moves[2].m, moves[2].s);
447 | 
448 |         assert_eq!(moves.next(), Some(m1));
449 |         //assert_eq!(moves.next(), Some(m3));
450 |         assert_eq!(moves.next(), Some(m2));
451 |         assert_eq!(moves.next(), None);
452 |     }
453 | }
454 | 


--------------------------------------------------------------------------------
/src/piece_move_notation.rs:
--------------------------------------------------------------------------------
  1 | use std::prelude::v1::*;
  2 | 
  3 | #[cfg(feature = "std")]
  4 | use regex::Regex;
  5 | 
  6 | use crate::attack::piece_attacks;
  7 | use crate::bitboard::BitboardExt;
  8 | use crate::color::*;
  9 | use crate::common::*;
 10 | use crate::game::Game;
 11 | use crate::piece::*;
 12 | use crate::piece::{PieceAttr, PieceChar};
 13 | use crate::piece_move::*;
 14 | use crate::square::*;
 15 | use crate::square::SquareExt;
 16 | #[cfg(feature = "std")]
 17 | use crate::search::Search;
 18 | use crate::attack::Attack;
 19 | use crate::piece_move_generator::PieceMoveGenerator;
 20 | 
 21 | #[cfg(feature = "std")]
 22 | static RE_LAN: &str = r"^(?P<from>[a-h][1-8])(?P<to>[a-h][1-8])(?P<promotion>[nbrq])?$";
 23 | 
 24 | #[cfg(feature = "std")]
 25 | static RE_SAN: &str = r"(?x)
 26 |     ^(?P<piece>[NBRQK])?(?P<file>[a-h])?(?P<rank>[1-8])?(?P<capture>x)?(?P<to>[a-h][1-8])=?(?P<promotion>[KBRQ])?
 27 |     |(?P<queen>O-O-O)
 28 |     |(?P<king>O-O)";
 29 | 
 30 | /// PieceMoveList generator
 31 | pub trait PieceMoveNotation {
 32 |     /// Parse move from string
 33 |     #[cfg(feature = "std")]
 34 |     fn parse_move(&mut self, s: &str) -> Option<PieceMove>;
 35 | 
 36 |     /// Get move from string in long algebraic notation (LAN)
 37 |     fn move_from_lan(&mut self, s: &str) -> PieceMove;
 38 | 
 39 |     /// Get move from string in standard algebraic notation (SAN)
 40 |     #[cfg(feature = "std")]
 41 |     fn move_from_san(&mut self, s: &str) -> Option<PieceMove>;
 42 | 
 43 |     /// Get SAN string from move
 44 |     fn move_to_san(&mut self, m: PieceMove) -> String;
 45 | 
 46 |     /// Check parsed move legality (slow)
 47 |     fn is_parsed_move_legal(&mut self, m: PieceMove) -> bool;
 48 | }
 49 | 
 50 | trait PieceMoveNotationExt {
 51 |     #[cfg(feature = "std")]
 52 |     fn move_from_lan_checked(&mut self, s: &str) -> Option<PieceMove>;
 53 | }
 54 | 
 55 | impl PieceMoveNotation for Game {
 56 |     #[cfg(feature = "std")]
 57 |     fn parse_move(&mut self, s: &str) -> Option<PieceMove> {
 58 |         self.move_from_san(s).or(self.move_from_lan_checked(s))
 59 |     }
 60 | 
 61 |     fn move_from_lan(&mut self, s: &str) -> PieceMove {
 62 |         debug_assert!(s.len() == 4 || s.len() == 5);
 63 | 
 64 |         let side = self.side();
 65 |         let from = Square::from_coord(&s[0..2]);
 66 |         let to = Square::from_coord(&s[2..4]);
 67 |         let piece = self.board[from as usize];
 68 |         let capture = self.board[to as usize];
 69 | 
 70 |         let mt = if s.len() == 5 {
 71 |             let promotion = match s.chars().nth(4) {
 72 |                 Some('n') => KNIGHT_PROMOTION,
 73 |                 Some('b') => BISHOP_PROMOTION,
 74 |                 Some('r') => ROOK_PROMOTION,
 75 |                 Some('q') => QUEEN_PROMOTION,
 76 |                 _         => panic!("could not parse promotion")
 77 |             };
 78 |             if capture == EMPTY {
 79 |                 promotion
 80 |             } else {
 81 |                 promotion | CAPTURE
 82 |             }
 83 |         } else if piece.kind() == KING && from == E1.flip(side) && to == G1.flip(side) {
 84 |             KING_CASTLE
 85 |         } else if piece.kind() == KING && from == E1.flip(side) && to == C1.flip(side) {
 86 |             QUEEN_CASTLE
 87 |         } else if capture == EMPTY {
 88 |             let d = (to.flip(side) as Shift) - (from.flip(side) as Shift);
 89 |             if piece.kind() == PAWN && (d == 2 * UP) {
 90 |                 DOUBLE_PAWN_PUSH
 91 |             } else if piece.kind() == PAWN && to == self.positions.top().en_passant {
 92 |                 EN_PASSANT
 93 |             } else {
 94 |                 QUIET_MOVE
 95 |             }
 96 |         } else {
 97 |             CAPTURE
 98 |         };
 99 | 
100 |         PieceMove::new(from, to, mt)
101 |     }
102 | 
103 |     #[cfg(feature = "std")]
104 |     fn move_from_san(&mut self, s: &str) -> Option<PieceMove> {
105 |         lazy_static! {
106 |             static ref RE: Regex = Regex::new(RE_SAN).unwrap();
107 |         }
108 |         let caps = match RE.captures(s) {
109 |             Some(caps) => caps,
110 |             None => return None,
111 |         };
112 | 
113 |         let side = self.side();
114 |         if caps.name("queen").is_some() {
115 |             return Some(PieceMove::new(E1.flip(side), C1.flip(side), QUEEN_CASTLE));
116 |         }
117 |         if caps.name("king").is_some() {
118 |             return Some(PieceMove::new(E1.flip(side), G1.flip(side), KING_CASTLE));
119 |         }
120 | 
121 |         if caps.name("to").is_none() {
122 |             return None;
123 |         }
124 |         let to = Square::from_coord(&caps["to"]);
125 |         for m in self.get_moves() {
126 |             if m.to() != to {
127 |                 continue;
128 |             }
129 | 
130 |             let p = self.board[m.from() as usize];
131 |             if let Some(piece) = caps.name("piece") {
132 |                 if p.kind().to_char().to_string() != piece.as_str() {
133 |                     continue;
134 |                 }
135 |             } else if p.kind() != PAWN {
136 |                 continue;
137 |             }
138 | 
139 |             if let Some(file) = caps.name("file") {
140 |                 if m.from().file_to_char().to_string() != file.as_str() {
141 |                     continue;
142 |                 }
143 |             }
144 | 
145 |             if let Some(rank) = caps.name("rank") {
146 |                 if m.from().rank_to_char().to_string() != rank.as_str() {
147 |                     continue;
148 |                 }
149 |             }
150 | 
151 |             if let Some(promotion) = caps.name("promotion") {
152 |                 if m.promotion_kind().to_char().to_string() != promotion.as_str() {
153 |                     continue;
154 |                 }
155 |             }
156 | 
157 |             return Some(m);
158 |         }
159 | 
160 |         None
161 |     }
162 | 
163 |     // NOTE: this function assumes that the move has not been played yet
164 |     fn move_to_san(&mut self, m: PieceMove) -> String {
165 |         let mut out = String::new();
166 | 
167 |         if m.is_castle() {
168 |             if m.castle_kind() == KING {
169 |                 out.push_str("O-O");
170 |             } else {
171 |                 out.push_str("O-O-O");
172 |             }
173 |             return out;
174 |         }
175 | 
176 |         let piece = self.board[m.from() as usize];
177 |         if !piece.is_pawn() {
178 |             out.push(piece.kind().to_char());
179 |         }
180 | 
181 |         // Piece disambiguation or pawn capture
182 |         if !piece.is_pawn() || m.is_capture() || m.is_en_passant() {
183 |             let occupied = self.bitboard(WHITE) | self.bitboard(BLACK);
184 |             let pieces = self.bitboard(piece);
185 |             let attacks = piece_attacks(piece, m.to(), occupied);
186 |             let attackers = pieces & attacks;
187 |             if attackers.count() > 1 || piece.is_pawn() {
188 |                 if (attackers != attackers & FILES[m.from().file() as usize]) || piece.is_pawn() {
189 |                     out.push(m.from().file_to_char());
190 |                 } else if attackers != attackers & RANKS[m.from().rank() as usize] {
191 |                     out.push(m.from().rank_to_char());
192 |                 } else {
193 |                     out.push(m.from().file_to_char());
194 |                     out.push(m.from().rank_to_char());
195 |                 }
196 |             }
197 |         }
198 | 
199 |         // TODO: Should en passant be a capture?
200 |         if m.is_capture() || m.is_en_passant() {
201 |             out.push('x');
202 |         }
203 | 
204 |         out.push_str(m.to().to_coord().as_str());
205 | 
206 |         if m.is_promotion() {
207 |             out.push(m.promotion_kind().to_char());
208 |         }
209 | 
210 |         out
211 |     }
212 | 
213 |     // This method is slow compared to `is_move_legal` but it is exhaustive
214 |     // and applicable to any parsed move instead of only moves generated by
215 |     // the engine
216 |     fn is_parsed_move_legal(&mut self, m: PieceMove) -> bool {
217 |         let side = self.side();
218 |         self.moves.clear();
219 |         while let Some(generated_move) = self.next_move() {
220 |             if m == generated_move {
221 |                 self.make_move(m);
222 |                 let is_legal = !self.is_check(side);
223 |                 self.undo_move(m);
224 |                 return is_legal;
225 |             }
226 |         }
227 |         false
228 |     }
229 | }
230 | 
231 | impl PieceMoveNotationExt for Game {
232 |     #[cfg(feature = "std")]
233 |     fn move_from_lan_checked(&mut self, s: &str) -> Option<PieceMove> {
234 |         lazy_static! {
235 |             static ref RE: Regex = Regex::new(RE_LAN).unwrap();
236 |         }
237 |         if RE.is_match(s) {
238 |             Some(self.move_from_lan(s))
239 |         } else {
240 |             None
241 |         }
242 |     }
243 | }
244 | 
245 | 
246 | #[cfg(test)]
247 | mod tests {
248 |     use crate::common::*;
249 |     use crate::piece_move::PieceMove;
250 |     use crate::fen::FEN;
251 |     use crate::game::Game;
252 |     use super::*;
253 | 
254 |     #[test]
255 |     fn test_move_from_lan() {
256 |         let mut game = Game::from_fen(DEFAULT_FEN).unwrap();
257 | 
258 |         let m = game.move_from_lan("e2e4");
259 |         assert_eq!(m, PieceMove::new(E2, E4, DOUBLE_PAWN_PUSH));
260 | 
261 |         let m = game.move_from_lan("g1f3");
262 |         assert_eq!(m, PieceMove::new(G1, F3, QUIET_MOVE));
263 |     }
264 | 
265 |     #[test]
266 |     fn test_move_from_lan_checked() {
267 |         let mut game = Game::from_fen(DEFAULT_FEN).unwrap();
268 | 
269 |         let m = game.move_from_lan_checked("e2e4");
270 |         assert_eq!(m, Some(PieceMove::new(E2, E4, DOUBLE_PAWN_PUSH)));
271 | 
272 |         let m = game.move_from_lan_checked("g1f3");
273 |         assert_eq!(m, Some(PieceMove::new(G1, F3, QUIET_MOVE)));
274 | 
275 |         let m = game.move_from_lan_checked("none");
276 |         assert_eq!(m, None);
277 |     }
278 | 
279 |     #[test]
280 |     fn test_move_to_san() {
281 |         let fen = "7k/3P1ppp/4PQ2/8/8/8/8/6RK w - - 0 1";
282 |         let mut game = Game::from_fen(fen).unwrap();
283 | 
284 |         // NOTE: This move should end with `#` but this is added in `search::get_pv()`.
285 |         assert_eq!(game.move_to_san(PieceMove::new(F6, G7, CAPTURE)), "Qxg7");
286 | 
287 |         let fen = "1q3rk1/Pbpp1p1p/2nb1n1Q/1p2p1pP/2NPP3/1B3N2/1PPB1PP1/R3K2R w KQ g6 0 25";
288 |         let mut game = Game::from_fen(fen).unwrap();
289 |         assert_eq!(game.move_to_san(PieceMove::new(D4, E5, CAPTURE)), "dxe5");
290 |         assert_eq!(game.move_to_san(PieceMove::new(F3, E5, CAPTURE)), "Nfxe5");
291 |         assert_eq!(game.move_to_san(PieceMove::new(C4, E5, CAPTURE)), "Ncxe5");
292 |         assert_eq!(game.move_to_san(PieceMove::new(A7, B8, KNIGHT_PROMOTION_CAPTURE)), "axb8N");
293 |         assert_eq!(game.move_to_san(PieceMove::new(H5, G6, EN_PASSANT)), "hxg6");
294 | 
295 |         let fen = "1q3rk1/Pbpp1p1p/2nb1n1Q/1p2p2P/2NPP1p1/1B3N2/1PPB1PP1/R4RK1 w - - 0 26";
296 |         let mut game = Game::from_fen(fen).unwrap();
297 |         assert_eq!(game.move_to_san(PieceMove::new(A1, E1, QUIET_MOVE)), "Rae1");
298 |         assert_eq!(game.move_to_san(PieceMove::new(F1, E1, QUIET_MOVE)), "Rfe1");
299 | 
300 |         let fen = "1q3rk1/Pbpp1p1p/2nb1n1Q/Rp2p2P/2NPP1p1/1B3N2/1PPB1PP1/R5K1 w - - 4 28";
301 |         let mut game = Game::from_fen(fen).unwrap();
302 |         assert_eq!(game.move_to_san(PieceMove::new(A5, A4, QUIET_MOVE)), "R5a4");
303 |         assert_eq!(game.move_to_san(PieceMove::new(A1, A4, QUIET_MOVE)), "R1a4");
304 |     }
305 | 
306 |     #[test]
307 |     fn test_move_from_san() {
308 |         let fen = "1q3rk1/Pbpp1p1p/2nb1n1Q/1p2p1pP/2NPP3/1B3N2/1PPB1PP1/R3K2R w KQ g6 0 25";
309 |         let mut game = Game::from_fen(fen).unwrap();
310 |         assert_eq!(game.move_from_san("none"), None);
311 |         assert_eq!(game.move_from_san("O-O"), Some(PieceMove::new(E1, G1, KING_CASTLE)));
312 |         assert_eq!(game.move_from_san("O-O-O"), Some(PieceMove::new(E1, C1, QUEEN_CASTLE)));
313 |         assert_eq!(game.move_from_san("g3"), Some(PieceMove::new(G2, G3, QUIET_MOVE)));
314 |         assert_eq!(game.move_from_san("Ng1"), Some(PieceMove::new(F3, G1, QUIET_MOVE)));
315 |         assert_eq!(game.move_from_san("Ng5"), Some(PieceMove::new(F3, G5, CAPTURE)));
316 |         assert_eq!(game.move_from_san("dxe5"), Some(PieceMove::new(D4, E5, CAPTURE)));
317 |         assert_eq!(game.move_from_san("Nfxe5"), Some(PieceMove::new(F3, E5, CAPTURE)));
318 |         assert_eq!(game.move_from_san("Ncxe5"), Some(PieceMove::new(C4, E5, CAPTURE)));
319 |         assert_eq!(game.move_from_san("a8Q"), Some(PieceMove::new(A7, A8, QUEEN_PROMOTION)));
320 |         assert_eq!(game.move_from_san("axb8N"), Some(PieceMove::new(A7, B8, KNIGHT_PROMOTION_CAPTURE)));
321 |         assert_eq!(game.move_from_san("g4"), Some(PieceMove::new(G2, G4, DOUBLE_PAWN_PUSH)));
322 |         assert_eq!(game.move_from_san("hxg6"), Some(PieceMove::new(H5, G6, EN_PASSANT)));
323 |         assert_eq!(game.move_from_san("hxg6e.p."), Some(PieceMove::new(H5, G6, EN_PASSANT)));
324 |         assert_eq!(game.move_from_san("Qg7"), Some(PieceMove::new(H6, G7, QUIET_MOVE)));
325 |         assert_eq!(game.move_from_san("Qxh7"), Some(PieceMove::new(H6, H7, CAPTURE)));
326 |         assert_eq!(game.move_from_san("Qg7!"), Some(PieceMove::new(H6, G7, QUIET_MOVE)));
327 |         assert_eq!(game.move_from_san("Qxh7!"), Some(PieceMove::new(H6, H7, CAPTURE)));
328 |         for m in game.get_moves() {
329 |             let san = game.move_to_san(m);
330 |             assert_eq!(game.move_from_san(&san), Some(m));
331 |         }
332 | 
333 |         let fen = "1q3rk1/Pbpp1p1p/2nb1n1Q/1p2p2P/2NPP1p1/1B3N2/1PPB1PP1/R4RK1 w - - 0 26";
334 |         let mut game = Game::from_fen(fen).unwrap();
335 |         assert_eq!(game.move_from_san("Rae1"), Some(PieceMove::new(A1, E1, QUIET_MOVE)));
336 |         assert_eq!(game.move_from_san("Rfe1"), Some(PieceMove::new(F1, E1, QUIET_MOVE)));
337 |         for m in game.get_moves() {
338 |             let san = game.move_to_san(m);
339 |             assert_eq!(game.move_from_san(&san), Some(m));
340 |         }
341 | 
342 |         let fen = "1q3rk1/Pbpp1p1p/2nb1n1Q/Rp2p2P/2NPP1p1/1B3N2/1PPB1PP1/R5K1 w - - 4 28";
343 |         let mut game = Game::from_fen(fen).unwrap();
344 |         assert_eq!(game.move_from_san("R5a4"), Some(PieceMove::new(A5, A4, QUIET_MOVE)));
345 |         assert_eq!(game.move_from_san("R1a4"), Some(PieceMove::new(A1, A4, QUIET_MOVE)));
346 |         for m in game.get_moves() {
347 |             let san = game.move_to_san(m);
348 |             assert_eq!(game.move_from_san(&san), Some(m));
349 |         }
350 |     }
351 | 
352 |     #[test]
353 |     fn test_parse_move() {
354 |         let fen = "1q3rk1/Pbpp1p1p/2nb1n1Q/1p2p1pP/2NPP3/1B3N2/1PPB1PP1/R3K2R w KQ g6 0 25";
355 |         let mut game = Game::from_fen(fen).unwrap();
356 |         assert_eq!(game.parse_move("O-O"), Some(PieceMove::new(E1, G1, KING_CASTLE)));
357 |         assert_eq!(game.parse_move("O-O-O"), Some(PieceMove::new(E1, C1, QUEEN_CASTLE)));
358 |         assert_eq!(game.parse_move("g3"), Some(PieceMove::new(G2, G3, QUIET_MOVE)));
359 |         assert_eq!(game.parse_move("Ng1"), Some(PieceMove::new(F3, G1, QUIET_MOVE)));
360 |         assert_eq!(game.parse_move("g2g3"), Some(PieceMove::new(G2, G3, QUIET_MOVE)));
361 |         assert_eq!(game.parse_move("f3g1"), Some(PieceMove::new(F3, G1, QUIET_MOVE)));
362 |     }
363 | }
364 | 


--------------------------------------------------------------------------------
/src/piece_square_table.rs:
--------------------------------------------------------------------------------
  1 | use crate::common::*;
  2 | use crate::color::*;
  3 | use crate::piece::*;
  4 | use crate::square::*;
  5 | 
  6 | const WHITE_PAWN_OPENING: [Score; 64] = [
  7 |     0,   0,   0,   0,   0,   0,   0,   0,
  8 |     0,   0,   0,   0,   0,   0,   0,   0,
  9 |    -5,   0,   5,  20,  20,   5,   0,  -5,
 10 |   -10,   0,  10,  30,  30,  10,   0, -10,
 11 |   -10,   0,   5,  20,  20,   5,   0, -10,
 12 |     0,   0,   0,   0,   0,   0,   0,   0,
 13 |     0,   0,   0, -20, -20,   0,   0,   0,
 14 |     0,   0,   0,   0,   0,   0,   0,   0
 15 | ];
 16 | 
 17 | const WHITE_PAWN_ENDING: [Score; 64] = [
 18 |     0,   0,   0,   0,   0,   0,   0,   0,
 19 |    50,  50,  30,  20,  20,  30,  50,  50,
 20 |    30,  30,  20,  10,  10,  20,  30,  30,
 21 |     0,   0,   0,   0,   0,   0,   0,   0,
 22 |     0,   0,   0,   0,   0,   0,   0,   0,
 23 |     0,   0,   0,   0,   0,   0,   0,   0,
 24 |     0,   0,   0,   0,   0,   0,   0,   0,
 25 |     0,   0,   0,   0,   0,   0,   0,   0
 26 | ];
 27 | 
 28 | const WHITE_KNIGHT_OPENING: [Score; 64] = [
 29 |   -50, -40, -30, -20, -20, -30, -40, -50,
 30 |   -40, -15,   0,   0,   0,   0, -15, -40,
 31 |   -30,   0,  10,  15,  15,  10,   0, -30,
 32 |   -20,   5,  15,  20,  20,  15,   5, -20,
 33 |   -20,   0,  15,  20,  20,  15,   0, -20,
 34 |   -30,   5,  10,  15,  15,  10,   5, -30,
 35 |   -40, -15,   0,   5,   5,   0, -15, -40,
 36 |   -50, -40, -30, -20, -20, -30, -40, -50,
 37 | ];
 38 | 
 39 | const WHITE_KNIGHT_ENDING: [Score; 64] = [
 40 |   -50, -40, -30, -30, -30, -30, -40, -50,
 41 |   -40, -20,   0,   0,   0,   0, -20, -40,
 42 |   -30,   0,  10,  15,  15,  10,   0, -30,
 43 |   -30,   5,  15,  20,  20,  15,   5, -30,
 44 |   -30,   0,  15,  20,  20,  15,   0, -30,
 45 |   -30,   5,  10,  15,  15,  10,   5, -30,
 46 |   -40, -20,   0,   5,   5,   0, -20, -40,
 47 |   -50, -40, -30, -30, -30, -30, -40, -50,
 48 | ];
 49 | 
 50 | const WHITE_BISHOP_OPENING: [Score; 64] = [
 51 |   -20, -10, -10, -10, -10, -10, -10, -20,
 52 |   -10,   0,   0,   0,   0,   0,   0, -10,
 53 |   -10,   0,   5,  10,  10,   5,   0, -10,
 54 |   -10,   5,   5,  10,  10,   5,   5, -10,
 55 |   -10,   0,  10,  10,  10,  10,   0, -10,
 56 |   -10,  10,  10,  10,  10,  10,  10, -10,
 57 |   -10,   5,   0,   0,   0,   0,   5, -10,
 58 |   -20, -10, -10, -10, -10, -10, -10, -20,
 59 | ];
 60 | 
 61 | const WHITE_BISHOP_ENDING: [Score; 64] = [
 62 |   -20, -10, -10, -10, -10, -10, -10, -20,
 63 |   -10,   0,   0,   0,   0,   0,   0, -10,
 64 |   -10,   0,   5,  10,  10,   5,   0, -10,
 65 |   -10,   5,   5,  10,  10,   5,   5, -10,
 66 |   -10,   0,  10,  10,  10,  10,   0, -10,
 67 |   -10,  10,  10,  10,  10,  10,  10, -10,
 68 |   -10,   5,   0,   0,   0,   0,   5, -10,
 69 |   -20, -10, -10, -10, -10, -10, -10, -20,
 70 | ];
 71 | 
 72 | const WHITE_ROOK_OPENING: [Score; 64] = [
 73 |     0,   0,   0,   0,   0,   0,   0,   0,
 74 |     5,  10,  10,  10,  10,  10,  10,   5,
 75 |    -5,   0,   0,   0,   0,   0,   0,  -5,
 76 |    -5,   0,   0,   0,   0,   0,   0,  -5,
 77 |    -5,   0,   0,   0,   0,   0,   0,  -5,
 78 |    -5,   0,   0,   0,   0,   0,   0,  -5,
 79 |    -5,   0,   0,   0,   0,   0,   0,  -5,
 80 |     0,   0,   0,   5,   5,   0,   0,   0
 81 | ];
 82 | 
 83 | const WHITE_ROOK_ENDING: [Score; 64] = [
 84 |     0,   0,   0,   0,   0,   0,   0,   0,
 85 |     5,  10,  10,  10,  10,  10,  10,   5,
 86 |    -5,   0,   0,   0,   0,   0,   0,  -5,
 87 |    -5,   0,   0,   0,   0,   0,   0,  -5,
 88 |    -5,   0,   0,   0,   0,   0,   0,  -5,
 89 |    -5,   0,   0,   0,   0,   0,   0,  -5,
 90 |    -5,   0,   0,   0,   0,   0,   0,  -5,
 91 |     0,   0,   0,   5,   5,   0,   0,   0
 92 | ];
 93 | 
 94 | const WHITE_QUEEN_OPENING: [Score; 64] = [
 95 |   -20, -10, -10,  -5,  -5, -10, -10, -20,
 96 |   -10,   0,   0,   0,   0,   0,   0, -10,
 97 |   -10,   0,   5,   5,   5,   5,   0, -10,
 98 |    -5,   0,   5,   5,   5,   5,   0,  -5,
 99 |     0,   0,   5,   5,   5,   5,   0,  -5,
100 |   -10,   5,   5,   5,   5,   5,   0, -10,
101 |   -10,   0,   5,   0,   0,   0,   0, -10,
102 |   -20, -10, -10,  -5,  -5, -10, -10, -20
103 | ];
104 | 
105 | const WHITE_QUEEN_ENDING: [Score; 64] = [
106 |   -20, -10, -10,  -5,  -5, -10, -10, -20,
107 |   -10,   0,   0,   0,   0,   0,   0, -10,
108 |   -10,   0,   5,   5,   5,   5,   0, -10,
109 |    -5,   0,   5,   5,   5,   5,   0,  -5,
110 |     0,   0,   5,   5,   5,   5,   0,  -5,
111 |   -10,   5,   5,   5,   5,   5,   0, -10,
112 |   -10,   0,   5,   0,   0,   0,   0, -10,
113 |   -20, -10, -10,  -5,  -5, -10, -10, -20
114 | ];
115 | 
116 | const WHITE_KING_OPENING: [Score; 64] = [
117 |   -30, -40, -40, -50, -50, -40, -40, -30,
118 |   -30, -40, -40, -50, -50, -40, -40, -30,
119 |   -30, -40, -40, -50, -50, -40, -40, -30,
120 |   -30, -40, -40, -50, -50, -40, -40, -30,
121 |   -20, -30, -30, -40, -40, -30, -30, -20,
122 |   -10, -20, -20, -20, -20, -20, -20, -10,
123 |    20,  20,   0,   0,   0,   0,  20,  20,
124 |    20,  30,  10,   0,   0,  10,  30,  20
125 | ];
126 | 
127 | const WHITE_KING_ENDING: [Score; 64] = [
128 |   -50, -40, -30, -20, -20, -30, -40, -50,
129 |   -30, -20, -10,   0,   0, -10, -20, -30,
130 |   -30, -10,  20,  30,  30,  20, -10, -30,
131 |   -30, -10,  30,  40,  40,  30, -10, -30,
132 |   -30, -10,  30,  40,  40,  30, -10, -30,
133 |   -30, -10,  20,  30,  30,  20, -10, -30,
134 |   -30, -30,   0,   0,   0,   0, -30, -30,
135 |   -50, -30, -30, -30, -30, -30, -30, -50
136 | ];
137 | 
138 | const WHITE_PIECES_OPENING: [[Score; 64]; 6] = [
139 |     WHITE_PAWN_OPENING,
140 |     WHITE_KNIGHT_OPENING,
141 |     WHITE_BISHOP_OPENING,
142 |     WHITE_ROOK_OPENING,
143 |     WHITE_QUEEN_OPENING,
144 |     WHITE_KING_OPENING
145 | ];
146 | 
147 | const WHITE_PIECES_ENDING: [[Score; 64]; 6] = [
148 |     WHITE_PAWN_ENDING,
149 |     WHITE_KNIGHT_ENDING,
150 |     WHITE_BISHOP_ENDING,
151 |     WHITE_ROOK_ENDING,
152 |     WHITE_QUEEN_ENDING,
153 |     WHITE_KING_ENDING
154 | ];
155 | 
156 | lazy_static! {
157 |     pub static ref PST: [[[Score; 2]; 64]; 14] = {
158 |         let mut pst_values = [[[0; 2]; 64]; 14];
159 | 
160 |         for c in 0..2 {
161 |             for p in 0..6 {
162 |                 for s in 0..64 {
163 |                     let square = (s as Square).flip((c as Color) ^ 1);
164 |                     let piece = (c as Color) | PIECES[p];
165 | 
166 |                     let score = WHITE_PIECES_OPENING[p][s];
167 |                     pst_values[piece as usize][square as usize][0] = score;
168 | 
169 |                     let score = WHITE_PIECES_ENDING[p][s];
170 |                     pst_values[piece as usize][square as usize][1] = score;
171 |                 }
172 |             }
173 |         }
174 | 
175 |         pst_values
176 |     };
177 | }
178 | 
179 | #[cfg(test)]
180 | mod tests {
181 |     use super::*;
182 | 
183 |     #[test]
184 |     fn test_pst() {
185 |         let white_score = PST[WHITE_KNIGHT as usize][F3.flip(WHITE) as usize][0];
186 |         let black_score = PST[BLACK_KNIGHT as usize][F3.flip(BLACK) as usize][0];
187 |         assert!(white_score > 0);
188 |         assert_eq!(white_score, black_score);
189 |     }
190 | }
191 | 


--------------------------------------------------------------------------------
/src/positions.rs:
--------------------------------------------------------------------------------
  1 | use std::prelude::v1::*;
  2 | use std::ops::Index;
  3 | 
  4 | use crate::color::*;
  5 | use crate::piece::*;
  6 | use crate::square::*;
  7 | 
  8 | #[derive(Copy, Clone)]
  9 | pub struct Position {
 10 |     pub hash: u64,
 11 |     pub side: Color,
 12 |     pub capture: Piece, // TODO: use `Option<Piece>`?
 13 |     pub en_passant: Square, // TODO: use `Option<Square>`?
 14 |     pub null_move_right: bool,
 15 |     pub castling_rights: u8,
 16 |     pub halfmoves_count: u8,
 17 | }
 18 | 
 19 | // WHITE == 0b0000 => 0b0000
 20 | // BLACK == 0b0001 => 0b0001
 21 | // KING  == 0b0110 => 0b0010
 22 | // QUEEN == 0b1100 => 0b0000
 23 | fn castling_rights_index(side: Color, wing: Piece) -> u8 {
 24 |     (wing & 0b0010) | side
 25 | }
 26 | 
 27 | impl Position {
 28 |     pub fn new() -> Position {
 29 |         Position {
 30 |             hash: 0, // TODO: is it a problem for the starting position?
 31 |             side: WHITE,
 32 |             capture: EMPTY, // TODO: use `None`?
 33 |             en_passant: OUT, // TODO: use `None`?
 34 |             null_move_right: true,
 35 |             castling_rights: 0,
 36 |             halfmoves_count: 0,
 37 |         }
 38 |     }
 39 | 
 40 |     pub fn castling_right(&self, side: Color, wing: Piece) -> bool {
 41 |         let i = castling_rights_index(side, wing);
 42 |         self.castling_rights & (1 << i) > 0
 43 |     }
 44 | 
 45 |     pub fn set_castling_right(&mut self, side: Color, wing: Piece) {
 46 |         let i = castling_rights_index(side, wing);
 47 |         self.castling_rights |= 1 << i;
 48 |     }
 49 | 
 50 |     pub fn reset_castling_right(&mut self, side: Color, wing: Piece) {
 51 |         let i = castling_rights_index(side, wing);
 52 |         self.castling_rights &= !(1 << i);
 53 |     }
 54 | }
 55 | 
 56 | const MAX_POSITIONS: usize = 1024;
 57 | 
 58 | #[derive(Clone)]
 59 | pub struct Positions {
 60 |     stack: [Position; MAX_POSITIONS],
 61 |     fullmoves_init: u8,
 62 |     ply: usize
 63 | }
 64 | 
 65 | impl Positions {
 66 |     pub fn new() -> Positions {
 67 |         Positions {
 68 |             stack: [Position::new(); MAX_POSITIONS],
 69 |             fullmoves_init: 0,
 70 |             ply: 0
 71 |         }
 72 |     }
 73 | 
 74 |     pub fn push(&mut self, position: Position) {
 75 |         self.stack[self.ply] = position; // FIXME: this operation is very slow
 76 |         self.ply += 1;
 77 |     }
 78 | 
 79 |     pub fn pop(&mut self) { // TODO: pop() should return last Position
 80 |         self.ply -= 1;
 81 |     }
 82 | 
 83 |     pub fn clear(&mut self) {
 84 |         self.ply = 0;
 85 |     }
 86 | 
 87 |     // TODO: this should be mutable.
 88 |     pub fn top(&self) -> &Position {
 89 |         &self.stack[self.ply - 1]
 90 |     }
 91 | 
 92 |     #[allow(dead_code)]
 93 |     pub fn len(&self) -> usize {
 94 |         self.ply
 95 |     }
 96 | 
 97 |     pub fn halfmoves(&self) -> u8 {
 98 |         self.top().halfmoves_count
 99 |     }
100 | 
101 |     pub fn fullmoves(&self) -> u8 {
102 |         let n = self.fullmoves_init + (self.ply / 2) as u8;
103 |         let blacks_started = self.top().side == BLACK && self.ply % 2 == 0;
104 | 
105 |         if blacks_started { n - 1 } else { n }
106 |     }
107 | 
108 |     pub fn set_halfmoves(&mut self, n: u8) {
109 |         self.stack[self.ply - 1].halfmoves_count = n;
110 |     }
111 | 
112 |     pub fn set_fullmoves(&mut self, n: u8) {
113 |         self.fullmoves_init = n;
114 |     }
115 | 
116 |     pub fn is_draw(&self) -> bool {
117 |         // Fifty-move rule
118 |         if self.top().halfmoves_count >= 99 {
119 |             return true; // Fifty-move rule
120 |         }
121 | 
122 |         // Threefold repetitions
123 |         let mut repetitions_count = 0;
124 |         let hash = self.top().hash;
125 |         let mut i = self.len() - 1;
126 |         while i >= 2 {
127 |             i -= 2;
128 |             if self[i].hash == hash {
129 |                 repetitions_count += 1;
130 |                 if repetitions_count > 0 {
131 |                     return true;
132 |                 }
133 |             }
134 |             if self[i].halfmoves_count == 0 {
135 |                 break;
136 |             }
137 |             // TODO: allow one repetition
138 |         }
139 | 
140 |         false
141 |     }
142 | 
143 |     // FIXME: this should be in `Position`
144 |     pub fn enable_null_move(&mut self) {
145 |         debug_assert!(!self.stack[self.ply - 1].null_move_right);
146 |         self.stack[self.ply - 1].null_move_right = true;
147 |     }
148 | 
149 |     // FIXME: this should be in `Position`
150 |     pub fn disable_null_move(&mut self) {
151 |         debug_assert!(self.stack[self.ply - 1].null_move_right);
152 |         self.stack[self.ply - 1].null_move_right = false;
153 |     }
154 | }
155 | 
156 | impl Index<usize> for Positions {
157 |     type Output = Position;
158 | 
159 |     fn index(&self, i: usize) -> &Position {
160 |         &self.stack[i]
161 |     }
162 | }
163 | 
164 | #[cfg(test)]
165 | mod tests {
166 |     use std::mem;
167 |     use super::*;
168 | 
169 |     #[test]
170 |     fn test_size_of_position() {
171 |         assert_eq!(mem::size_of::<u64>(),       8); // x1
172 |         assert_eq!(mem::size_of::<u8>(),        1); // x2
173 |         assert_eq!(mem::size_of::<bool>(),      1); // x1
174 |         assert_eq!(mem::size_of::<Color>(),     1); // x1
175 |         assert_eq!(mem::size_of::<Piece>(),     1); // x1
176 |         assert_eq!(mem::size_of::<Square>(),    1); // x1
177 | 
178 |         assert_eq!(mem::size_of::<Position>(), 16);
179 |     }
180 | 
181 |     #[test]
182 |     fn test_position_castling_rights() {
183 |         let mut pos = Position::new();
184 |         
185 |         assert_eq!(pos.castling_right(WHITE, KING),  false);
186 |         assert_eq!(pos.castling_right(WHITE, QUEEN), false);
187 |         assert_eq!(pos.castling_right(BLACK, KING),  false);
188 |         assert_eq!(pos.castling_right(BLACK, QUEEN), false);
189 | 
190 |         pos.set_castling_right(WHITE, KING);
191 |         assert_eq!(pos.castling_right(WHITE, KING),  true);
192 |         assert_eq!(pos.castling_right(WHITE, QUEEN), false);
193 |         assert_eq!(pos.castling_right(BLACK, KING),  false);
194 |         assert_eq!(pos.castling_right(BLACK, QUEEN), false);
195 | 
196 |         pos.set_castling_right(WHITE, KING);
197 |         assert_eq!(pos.castling_right(WHITE, KING),  true);
198 |         assert_eq!(pos.castling_right(WHITE, QUEEN), false);
199 |         assert_eq!(pos.castling_right(BLACK, KING),  false);
200 |         assert_eq!(pos.castling_right(BLACK, QUEEN), false);
201 | 
202 |         pos.set_castling_right(BLACK, QUEEN);
203 |         assert_eq!(pos.castling_right(WHITE, KING),  true);
204 |         assert_eq!(pos.castling_right(WHITE, QUEEN), false);
205 |         assert_eq!(pos.castling_right(BLACK, KING),  false);
206 |         assert_eq!(pos.castling_right(BLACK, QUEEN), true);
207 | 
208 |         pos.reset_castling_right(WHITE, KING);
209 |         assert_eq!(pos.castling_right(WHITE, KING),  false);
210 |         assert_eq!(pos.castling_right(WHITE, QUEEN), false);
211 |         assert_eq!(pos.castling_right(BLACK, KING),  false);
212 |         assert_eq!(pos.castling_right(BLACK, QUEEN), true);
213 | 
214 |         pos.reset_castling_right(BLACK, QUEEN);
215 |         assert_eq!(pos.castling_right(WHITE, KING),  false);
216 |         assert_eq!(pos.castling_right(WHITE, QUEEN), false);
217 |         assert_eq!(pos.castling_right(BLACK, KING),  false);
218 |         assert_eq!(pos.castling_right(BLACK, QUEEN), false);
219 | 
220 |         pos.reset_castling_right(BLACK, QUEEN);
221 |         assert_eq!(pos.castling_right(WHITE, KING),  false);
222 |         assert_eq!(pos.castling_right(WHITE, QUEEN), false);
223 |         assert_eq!(pos.castling_right(BLACK, KING),  false);
224 |         assert_eq!(pos.castling_right(BLACK, QUEEN), false);
225 |     }
226 | }
227 | 


--------------------------------------------------------------------------------
/src/protocols/mod.rs:
--------------------------------------------------------------------------------
 1 | pub mod cli;
 2 | pub mod uci;
 3 | pub mod xboard;
 4 | 
 5 | #[repr(u8)]
 6 | #[derive(Clone, Eq, PartialEq)]
 7 | pub enum Protocol {
 8 |     CLI,
 9 |     UCI,
10 |     XBoard
11 | }
12 | 


--------------------------------------------------------------------------------
/src/protocols/uci.rs:
--------------------------------------------------------------------------------
  1 | use std::prelude::v1::*;
  2 | use std::io;
  3 | use std::thread;
  4 | use std::sync::Arc;
  5 | use std::sync::atomic::{AtomicBool, Ordering};
  6 | 
  7 | use crate::color::*;
  8 | use crate::common::*;
  9 | use crate::clock::Clock;
 10 | use crate::fen::FEN;
 11 | use crate::game::Game;
 12 | use crate::piece_move_generator::PieceMoveGenerator;
 13 | use crate::piece_move_notation::PieceMoveNotation;
 14 | use crate::search::Search;
 15 | use crate::protocols::Protocol;
 16 | use crate::version;
 17 | 
 18 | pub struct UCI {
 19 |     pub game: Game,
 20 |     max_depth: Depth,
 21 |     searcher: Option<thread::JoinHandle<()>>,
 22 |     print_bestmove: Arc<AtomicBool>,
 23 | }
 24 | 
 25 | impl UCI {
 26 |     pub fn new() -> UCI {
 27 |         UCI {
 28 |             game: Game::from_fen(DEFAULT_FEN).unwrap(),
 29 |             max_depth: (MAX_PLY - 10) as Depth,
 30 |             searcher: None,
 31 |             print_bestmove: Arc::new(AtomicBool::new(false))
 32 |         }
 33 |     }
 34 |     pub fn run(&mut self) {
 35 |         self.game.protocol = Protocol::UCI;
 36 |         self.game.is_search_verbose = true;
 37 |         println!("id name {}", version());
 38 |         println!("id author Vincent Ollivier");
 39 |         println!("uciok");
 40 |         loop {
 41 |             let mut cmd = String::new();
 42 |             io::stdin().read_line(&mut cmd).unwrap();
 43 |             let args: Vec<&str> = cmd.trim().split(' ').collect();
 44 |             match args[0] {
 45 |                 "quit"       => break,
 46 |                 "stop"       => self.cmd_stop(),
 47 |                 "isready"    => self.cmd_isready(),
 48 |                 "ucinewgame" => self.cmd_ucinewgame(),
 49 |                 "position"   => self.cmd_position(&args),
 50 |                 "go"         => self.cmd_go(&args),
 51 |                 _            => continue, // Ignore unknown commands
 52 |             }
 53 |         }
 54 |         self.abort_search();
 55 |     }
 56 | 
 57 |     fn cmd_stop(&mut self) {
 58 |         self.stop_search();
 59 |     }
 60 | 
 61 |     fn cmd_isready(&mut self) {
 62 |         println!("readyok");
 63 |     }
 64 | 
 65 |     fn cmd_ucinewgame(&mut self) {
 66 |         self.abort_search();
 67 | 
 68 |         self.max_depth = (MAX_PLY - 10) as Depth;
 69 |         self.game.clear();
 70 |     }
 71 | 
 72 |     fn cmd_go(&mut self, args: &[&str]) {
 73 |         self.abort_search();
 74 | 
 75 |         let side = self.game.side();
 76 |         let mut time = u64::MAX; // Infinite time
 77 |         let mut moves = 0;
 78 |         let mut next_arg_is_time = false;
 79 |         let mut next_arg_is_moves = false;
 80 |         for &arg in args {
 81 |             match arg {
 82 |                 "wtime" => {
 83 |                     if side == WHITE {
 84 |                         next_arg_is_time = true;
 85 |                     }
 86 |                 },
 87 |                 "btime" => {
 88 |                     if side == BLACK {
 89 |                         next_arg_is_time = true;
 90 |                     }
 91 |                 },
 92 |                 "movetime" => {
 93 |                     next_arg_is_time = true;
 94 |                 }
 95 |                 "movestogo" => {
 96 |                     next_arg_is_moves = true;
 97 |                 },
 98 |                 _ => {
 99 |                     if next_arg_is_time {
100 |                         time = arg.parse::<u64>().unwrap();
101 |                         next_arg_is_time = false;
102 |                     } else if next_arg_is_moves {
103 |                         moves = arg.parse::<u16>().unwrap();
104 |                         next_arg_is_moves = false;
105 |                     }
106 |                 }
107 |             }
108 |         }
109 |         // FIXME: time increment is ignored
110 |         self.game.clock = Clock::new(moves, time);
111 |         self.game.clock.disable_level();
112 |         self.print_bestmove.store(true, Ordering::Relaxed);
113 |         self.start_search();
114 |     }
115 | 
116 |     fn cmd_position(&mut self, args: &[&str]) {
117 |         self.abort_search();
118 | 
119 |         let mut is_fen = false;
120 |         let mut is_move = false;
121 |         let mut fen = Vec::with_capacity(args.len());
122 |         let mut moves = Vec::with_capacity(args.len());
123 |         for &arg in args {
124 |             match arg {
125 |                 "startpos" => {
126 |                     fen.push(DEFAULT_FEN);
127 |                 },
128 |                 "fen" => { // Next args will form the fen string
129 |                     is_fen = true;
130 |                     is_move = false;
131 |                 },
132 |                 "moves" => { // Next args will form the moves list
133 |                     is_fen = false;
134 |                     is_move = true;
135 |                 },
136 |                 _ => {
137 |                     if is_fen {
138 |                         fen.push(arg);
139 |                     } else if is_move {
140 |                         moves.push(arg);
141 |                     }
142 |                 }
143 |             }
144 |         }
145 | 
146 |         self.game.load_fen(&fen.join(" ")).unwrap();
147 | 
148 |         for s in moves {
149 |             let m = self.game.move_from_lan(s);
150 |             self.game.make_move(m);
151 |             self.game.history.push(m);
152 |         }
153 |     }
154 | 
155 |     fn start_search(&mut self) {
156 |         let n = self.max_depth;
157 |         let mut game = self.game.clone();
158 |         let print_bestmove = self.print_bestmove.clone();
159 | 
160 |         let builder = thread::Builder::new().
161 |             name(String::from("searcher")).
162 |             stack_size(4 << 20);
163 | 
164 |         self.searcher = Some(builder.spawn(move || {
165 |             let res = game.search(1..n);
166 | 
167 |             if print_bestmove.load(Ordering::Relaxed) {
168 |                 match res {
169 |                     Some(m) => println!("bestmove {}", m.to_lan()),
170 |                     None    => println!("bestmove 0000")
171 |                 }
172 |             }
173 |         }).unwrap());
174 |     }
175 | 
176 |     fn stop_search(&mut self) {
177 |         self.game.clock.stop();
178 | 
179 |         // Wait for current search to end
180 |         if let Some(searcher) = self.searcher.take() {
181 |             searcher.join().unwrap();
182 |         }
183 |     }
184 | 
185 |     fn abort_search(&mut self) {
186 |         self.print_bestmove.store(false, Ordering::Relaxed);
187 |         self.stop_search();
188 |     }
189 | }
190 | 


--------------------------------------------------------------------------------
/src/protocols/xboard.rs:
--------------------------------------------------------------------------------
  1 | use std::prelude::v1::*;
  2 | use std::io;
  3 | use regex::Regex;
  4 | 
  5 | use crate::color::*;
  6 | use crate::common::*;
  7 | use crate::attack::Attack;
  8 | use crate::clock::Clock;
  9 | use crate::fen::FEN;
 10 | use crate::game::Game;
 11 | use crate::piece_move_generator::PieceMoveGenerator;
 12 | use crate::piece_move_notation::PieceMoveNotation;
 13 | use crate::search::Search;
 14 | use crate::protocols::Protocol;
 15 | use crate::version;
 16 | 
 17 | pub struct XBoard {
 18 |     pub game: Game,
 19 |     max_depth: Depth,
 20 |     force: bool
 21 | }
 22 | 
 23 | impl XBoard {
 24 |     pub fn new() -> XBoard {
 25 |         XBoard {
 26 |             game: Game::from_fen(DEFAULT_FEN).unwrap(),
 27 |             max_depth: (MAX_PLY - 10) as Depth,
 28 |             force: false
 29 |         }
 30 |     }
 31 |     pub fn run(&mut self) {
 32 |         self.game.protocol = Protocol::XBoard;
 33 |         println!(""); // Acknowledge XBoard mode
 34 |         loop {
 35 |             let mut line = String::new();
 36 |             io::stdin().read_line(&mut line).unwrap();
 37 |             let args: Vec<&str> = line.trim().split(' ').collect();
 38 |             match args[0] {
 39 |                 "quit"     => break,
 40 |                 "force"    => self.cmd_force(),
 41 |                 "new"      => self.cmd_new(),
 42 |                 "go"       => self.cmd_go(),
 43 |                 "post"     => self.cmd_post(),
 44 |                 "nopost"   => self.cmd_nopost(),
 45 |                 "undo"     => self.cmd_undo(),
 46 |                 "remove"   => self.cmd_remove(),
 47 |                 "time"     => self.cmd_time(&args),
 48 |                 "ping"     => self.cmd_ping(&args),
 49 |                 "setboard" => self.cmd_setboard(&args),
 50 |                 "memory"   => self.cmd_memory(&args),
 51 |                 "cores"    => self.cmd_cores(&args),
 52 |                 "sd"       => self.cmd_depth(&args),
 53 |                 "level"    => self.cmd_level(&args),
 54 |                 "protover" => self.cmd_protover(&args),
 55 |                 _          => self.parse_move(&args)
 56 |             }
 57 |         }
 58 |     }
 59 | 
 60 |     fn cmd_force(&mut self) {
 61 |         self.force = true;
 62 |     }
 63 | 
 64 |     fn cmd_new(&mut self) {
 65 |         self.max_depth = (MAX_PLY - 10) as Depth;
 66 |         self.game.clear();
 67 |         self.game.load_fen(DEFAULT_FEN).unwrap();
 68 |     }
 69 | 
 70 |     fn cmd_go(&mut self) {
 71 |         self.force = false;
 72 |         self.think();
 73 |     }
 74 | 
 75 |     fn cmd_post(&mut self) {
 76 |         self.game.is_search_verbose = true;
 77 |     }
 78 | 
 79 |     fn cmd_nopost(&mut self) {
 80 |         self.game.is_search_verbose = false;
 81 |     }
 82 | 
 83 |     fn cmd_undo(&mut self) {
 84 |         if self.game.history.len() > 0 {
 85 |             let m = self.game.history.pop().unwrap();
 86 |             self.game.undo_move(m);
 87 |         }
 88 |     }
 89 | 
 90 |     fn cmd_remove(&mut self) {
 91 |         let m = self.game.history.pop().unwrap();
 92 |         self.game.undo_move(m);
 93 | 
 94 |         let m = self.game.history.pop().unwrap();
 95 |         self.game.undo_move(m);
 96 |     }
 97 | 
 98 |     fn cmd_time(&mut self, args: &[&str]) {
 99 |         // `time` is given in centiseconds
100 |         let time = args[1].parse::<u64>().unwrap();
101 |         self.game.clock.set_time(time * 10);
102 |     }
103 | 
104 |     fn cmd_ping(&mut self, args: &[&str]) {
105 |         println!("pong {}", args[1].parse::<usize>().unwrap());
106 |     }
107 | 
108 |     fn cmd_setboard(&mut self, args: &[&str]) {
109 |         if args.len() == 1 {
110 |             panic!("no fen given");
111 |         }
112 | 
113 |         let fen = args[1..].join(" ");
114 | 
115 |         self.game.clear();
116 |         self.game.load_fen(&fen).unwrap();
117 |     }
118 | 
119 |     fn cmd_level(&mut self, args: &[&str]) {
120 |         let moves = args[1].parse::<u16>().unwrap();
121 | 
122 |         // `time` is given in `mm:ss` or `ss`.
123 |         let time = match args[2].find(':') {
124 |             Some(i) => args[2][0..i].parse::<u64>().unwrap() * 60 +
125 |                        args[2][(i + 1)..].parse::<u64>().unwrap(),
126 |             None    => args[2].parse::<u64>().unwrap()
127 |         };
128 | 
129 |         // FIXME: time increment is ignored
130 | 
131 |         self.game.clock = Clock::new(moves, time * 1000);
132 |     }
133 | 
134 |     fn cmd_depth(&mut self, args: &[&str]) {
135 |         self.max_depth = args[1].parse::<Depth>().unwrap() + 1;
136 |     }
137 | 
138 |     fn cmd_memory(&mut self, args: &[&str]) {
139 |         let memory = args[1].parse::<usize>().unwrap(); // In MB
140 |         self.game.tt_resize(memory << 20);
141 |     }
142 | 
143 |     fn cmd_cores(&mut self, args: &[&str]) {
144 |         self.game.threads_count = args[1].parse::<usize>().unwrap();
145 |     }
146 | 
147 |     #[allow(unused_variables)] // TODO: remove that
148 |     fn cmd_protover(&mut self, args: &[&str]) {
149 |         println!("feature myname=\"{}\"", version());
150 |         println!("feature sigint=0 ping=1 setboard=1 memory=1 smp=1 done=1");
151 |         // TODO: check that the features got accepted
152 |     }
153 | 
154 |     fn parse_move(&mut self, args: &[&str]) {
155 |         let re = Regex::new(r"^[a-h][0-9][a-h][0-9][nbrq]?$").unwrap();
156 |         if !re.is_match(args[0]) {
157 |             return;
158 |         }
159 | 
160 |         let m = self.game.move_from_lan(args[0]);
161 |         self.game.make_move(m);
162 |         self.game.history.push(m);
163 | 
164 |         if !self.force {
165 |             self.think();
166 |         }
167 |     }
168 | 
169 |     fn think(&mut self) {
170 |         let n = self.max_depth;
171 |         match self.game.search(1..n) {
172 |             None => {
173 |                 if self.game.is_check(WHITE) {
174 |                     println!("0-1 {{black mates}}");
175 |                 } else if self.game.is_check(BLACK) {
176 |                     println!("1-0 {{white mates}}");
177 |                 } else {
178 |                     println!("1/2-1/2 {{draw}}");
179 |                 }
180 |             },
181 |             Some(m) => {
182 |                 self.game.make_move(m);
183 |                 self.game.history.push(m);
184 | 
185 |                 println!("move {}", m.to_lan());
186 |             }
187 |         }
188 |     }
189 | }
190 | 


--------------------------------------------------------------------------------
/src/square.rs:
--------------------------------------------------------------------------------
  1 | #![allow(dead_code)]
  2 | 
  3 | use std::prelude::v1::*;
  4 | 
  5 | use crate::color::*;
  6 | 
  7 | pub type Square = u8;
  8 | 
  9 | pub const A1: Square = 0;
 10 | pub const B1: Square = 1;
 11 | pub const C1: Square = 2;
 12 | pub const D1: Square = 3;
 13 | pub const E1: Square = 4;
 14 | pub const F1: Square = 5;
 15 | pub const G1: Square = 6;
 16 | pub const H1: Square = 7;
 17 | pub const A2: Square = 8;
 18 | pub const B2: Square = 9;
 19 | pub const C2: Square = 10;
 20 | pub const D2: Square = 11;
 21 | pub const E2: Square = 12;
 22 | pub const F2: Square = 13;
 23 | pub const G2: Square = 14;
 24 | pub const H2: Square = 15;
 25 | pub const A3: Square = 16;
 26 | pub const B3: Square = 17;
 27 | pub const C3: Square = 18;
 28 | pub const D3: Square = 19;
 29 | pub const E3: Square = 20;
 30 | pub const F3: Square = 21;
 31 | pub const G3: Square = 22;
 32 | pub const H3: Square = 23;
 33 | pub const A4: Square = 24;
 34 | pub const B4: Square = 25;
 35 | pub const C4: Square = 26;
 36 | pub const D4: Square = 27;
 37 | pub const E4: Square = 28;
 38 | pub const F4: Square = 29;
 39 | pub const G4: Square = 30;
 40 | pub const H4: Square = 31;
 41 | pub const A5: Square = 32;
 42 | pub const B5: Square = 33;
 43 | pub const C5: Square = 34;
 44 | pub const D5: Square = 35;
 45 | pub const E5: Square = 36;
 46 | pub const F5: Square = 37;
 47 | pub const G5: Square = 38;
 48 | pub const H5: Square = 39;
 49 | pub const A6: Square = 40;
 50 | pub const B6: Square = 41;
 51 | pub const C6: Square = 42;
 52 | pub const D6: Square = 43;
 53 | pub const E6: Square = 44;
 54 | pub const F6: Square = 45;
 55 | pub const G6: Square = 46;
 56 | pub const H6: Square = 47;
 57 | pub const A7: Square = 48;
 58 | pub const B7: Square = 49;
 59 | pub const C7: Square = 50;
 60 | pub const D7: Square = 51;
 61 | pub const E7: Square = 52;
 62 | pub const F7: Square = 53;
 63 | pub const G7: Square = 54;
 64 | pub const H7: Square = 55;
 65 | pub const A8: Square = 56;
 66 | pub const B8: Square = 57;
 67 | pub const C8: Square = 58;
 68 | pub const D8: Square = 59;
 69 | pub const E8: Square = 60;
 70 | pub const F8: Square = 61;
 71 | pub const G8: Square = 62;
 72 | pub const H8: Square = 63;
 73 | pub const OUT: Square = 64;
 74 | 
 75 | pub trait SquareExt {
 76 |     fn from_coord(s: &str) -> Self;
 77 |     fn to_coord(&self) -> String;
 78 |     fn file_to_char(&self) -> char;
 79 |     fn rank_to_char(&self) -> char;
 80 |     fn file(&self) -> u8;
 81 |     fn rank(&self) -> u8;
 82 |     fn flip(&self, c: Color) -> Self;
 83 | }
 84 | 
 85 | impl SquareExt for Square {
 86 |     fn from_coord(s: &str) -> Self { // TODO: -> Option<Self>
 87 |         let bytes = s.as_bytes();
 88 | 
 89 |         ((bytes[0] - b'a') + 8 * (bytes[1] - b'1')) as Square
 90 |     }
 91 | 
 92 |     fn to_coord(&self) -> String {
 93 |         // FIXME: OUT.to_coord() => a9
 94 |         format!("{}{}", self.file_to_char(), self.rank_to_char())
 95 |     }
 96 | 
 97 |     fn rank_to_char(&self) -> char {
 98 |         (b'1' + self.rank()) as char
 99 |     }
100 | 
101 |     fn file_to_char(&self) -> char {
102 |         (b'a' + self.file()) as char
103 |     }
104 | 
105 |     fn file(&self) -> u8 {
106 |         *self % 8
107 |     }
108 | 
109 |     fn rank(&self) -> u8 {
110 |         *self / 8
111 |     }
112 | 
113 |     fn flip(&self, c: Color) -> Self {
114 |         *self ^ (A8 * c)
115 |     }
116 | }
117 | 
118 | #[cfg(test)]
119 | mod tests {
120 |     use super::*;
121 | 
122 |     #[test]
123 |     fn test_from_coord() {
124 |         let sq: Square = SquareExt::from_coord("e2");
125 |         assert_eq!(sq, E2);
126 |     }
127 | 
128 |     #[test]
129 |     fn test_to_coord() {
130 |         assert_eq!(A1.to_coord(), "a1");
131 |         assert_eq!(E2.to_coord(), "e2");
132 |         assert_eq!(C6.to_coord(), "c6");
133 |     }
134 | 
135 |     #[test]
136 |     fn test_flip() {
137 |         assert_eq!(E2.flip(WHITE), E2);
138 |         assert_eq!(E2.flip(BLACK), E7);
139 |     }
140 | }
141 | 
142 | 


--------------------------------------------------------------------------------
/src/transposition.rs:
--------------------------------------------------------------------------------
 1 | use std::prelude::v1::*;
 2 | 
 3 | use crate::common::*;
 4 | use crate::piece_move::PieceMove;
 5 | 
 6 | #[repr(u8)]
 7 | #[derive(Clone, Copy, Eq, PartialEq, Debug)]
 8 | pub enum Bound {
 9 |     Exact,
10 |     Lower,
11 |     Upper
12 | }
13 | 
14 | #[derive(Copy, Clone, PartialEq, Debug)]
15 | pub struct Transposition {
16 |     hash: u64,            // 64 bits => 8 bytes
17 |     best_move: PieceMove, // 16 bits => 2 bytes
18 |     score: Score,         // 16 bits => 2 bytes
19 |     depth: Depth,         //  8 bits => 1 bytes
20 |     bound: Bound,         //  8 bits => 1 bytes
21 |     age: u8,              //  8 bits => 1 bytes
22 | 
23 |     // Total: 16 bytes
24 |     //
25 |     // NOTE: `depth` will never go above MAX_PLY, which is 128 so we can store
26 |     // it as `i8`.
27 |     //
28 |     // TODO: we don't need to store the whole hash as the first part is the
29 |     // index of the entry: `entries[hash % size]`
30 | }
31 | 
32 | impl Transposition {
33 |     pub fn new(hash: u64, depth: Depth, score: Score, best_move: PieceMove, bound: Bound, age: u8) -> Transposition {
34 |         Transposition { hash, depth, score, best_move, bound, age }
35 |     }
36 | 
37 |     pub fn new_null() -> Transposition {
38 |         Transposition::new(0, 0, 0, PieceMove::new_null(), Bound::Exact, 0)
39 |     }
40 | 
41 |     pub fn hash(&self) -> u64 {
42 |         self.hash
43 |     }
44 | 
45 |     pub fn depth(&self) -> Depth {
46 |         self.depth
47 |     }
48 | 
49 |     pub fn score(&self) -> Score {
50 |         self.score
51 |     }
52 | 
53 |     pub fn best_move(&self) -> PieceMove {
54 |         self.best_move
55 |     }
56 | 
57 |     pub fn bound(&self) -> Bound {
58 |         self.bound
59 |     }
60 | 
61 |     pub fn age(&self) -> u8 {
62 |         self.age
63 |     }
64 | }
65 | 
66 | #[cfg(test)]
67 | mod tests {
68 |     use std::mem;
69 | 
70 |     use super::*;
71 |     use crate::piece_move::PieceMove;
72 | 
73 |     #[test]
74 |     fn test_size_of_transposition() {
75 |         assert_eq!(mem::size_of::<u64>(),       8); // Hash
76 |         assert_eq!(mem::size_of::<Score>(),     2); // Score
77 |         assert_eq!(mem::size_of::<PieceMove>(), 2); // PieceMove
78 |         assert_eq!(mem::size_of::<u8>(),        1); // Depth
79 | 
80 |         assert_eq!(mem::size_of::<Transposition>(), 16);
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/transposition_table.rs:
--------------------------------------------------------------------------------
  1 | use std::prelude::v1::*;
  2 | use std::cell::UnsafeCell;
  3 | use std::mem;
  4 | use std::sync::Arc;
  5 | 
  6 | use crate::common::*;
  7 | use crate::piece_move::PieceMove;
  8 | use crate::transposition::{Transposition, Bound};
  9 | 
 10 | #[derive(Clone)]
 11 | pub struct TranspositionTable {
 12 |     entries: Arc<SharedTable>,
 13 |     age: u8,
 14 |     stats_lookups: u64,
 15 |     stats_inserts: u64,
 16 |     stats_hits : u64,
 17 |     stats_collisions: u64
 18 | }
 19 | 
 20 | impl TranspositionTable {
 21 |     pub fn with_capacity(capacity: usize) -> TranspositionTable {
 22 |         let n = if capacity.is_power_of_two() {
 23 |             capacity
 24 |         } else {
 25 |             capacity.next_power_of_two()
 26 |         };
 27 | 
 28 |         TranspositionTable {
 29 |             entries: Arc::new(SharedTable::with_capacity(n)),
 30 |             age: 0,
 31 |             stats_lookups: 0,
 32 |             stats_inserts: 0,
 33 |             stats_hits: 0,
 34 |             stats_collisions: 0
 35 |         }
 36 |     }
 37 | 
 38 |     pub fn with_memory(memory: usize) -> TranspositionTable {
 39 |         let capacity = memory / mem::size_of::<Transposition>();
 40 | 
 41 |         TranspositionTable::with_capacity(capacity)
 42 |     }
 43 | 
 44 |     pub fn get(&mut self, hash: u64) -> Option<&Transposition> {
 45 |         self.stats_lookups += 1;
 46 | 
 47 |         let h = self.entries.get();
 48 |         let n = self.len() as u64;
 49 |         let k = (hash % n) as usize; // TODO: hash & (n - 1)
 50 |         let t = &h[k]; // TODO: use get_unchecked?
 51 | 
 52 |         // TODO: how faster would it be to just also return null move?
 53 |         if t.best_move().is_null() {
 54 |             None
 55 |         } else if t.hash() != hash {
 56 |             self.stats_collisions += 1;
 57 |             None
 58 |         } else {
 59 |             debug_assert_eq!(t.hash(), hash);
 60 |             self.stats_hits += 1;
 61 |             Some(t)
 62 |         }
 63 |     }
 64 | 
 65 |     pub fn set(&mut self, hash: u64, depth: Depth, score: Score, best_move: PieceMove, bound: Bound) {
 66 |         let age = self.age;
 67 |         let h = self.entries.get();
 68 |         let n = self.len() as u64;
 69 |         let k = (hash % n) as usize;
 70 | 
 71 |         // Always replace entries from previous searches (entry.age < age)
 72 |         // but use depth preferred replacement strategy for the current search.
 73 |         if age > h[k].age() || (age == 0 && h[k].age() > 0) || depth >= h[k].depth() {
 74 |             let t = Transposition::new(hash, depth, score, best_move, bound, age);
 75 |             h[k] = t;
 76 |             self.stats_inserts += 1;
 77 |         }
 78 |     }
 79 | 
 80 |     pub fn reset(&mut self) {
 81 |         self.age = (self.age + 1) % u8::MAX;
 82 |         self.clear_stats();
 83 |     }
 84 | 
 85 |     pub fn clear(&mut self) {
 86 |         let n = self.len();
 87 |         self.entries = Arc::new(SharedTable::with_capacity(n));
 88 |         self.clear_stats();
 89 |     }
 90 | 
 91 |     fn clear_stats(&mut self) {
 92 |         self.stats_lookups = 0;
 93 |         self.stats_inserts = 0;
 94 |         self.stats_hits = 0;
 95 |         self.stats_collisions = 0;
 96 |     }
 97 | 
 98 |     pub fn len(&self) -> usize {
 99 |         self.entries.get().len()
100 |     }
101 | 
102 |     pub fn memory(&self) -> usize {
103 |         self.len() * mem::size_of::<Transposition>()
104 |     }
105 | 
106 |     /// Print transposition table stats
107 |     #[cfg(feature = "std")]
108 |     pub fn print_stats(&mut self) {
109 |         // Memory size
110 |         let v = self.memory() as u64;
111 |         let z = (63 - v.leading_zeros()) / 10;
112 |         let size = v / (1 << (10 * z));
113 |         let unit = "KMG".chars().nth((z - 1) as usize).unwrap();
114 | 
115 |         // Occupacy
116 |         let mut exact_count = 0;
117 |         let mut upper_count = 0;
118 |         let mut lower_count = 0;
119 |         for t in self.entries.get() {
120 |             if t.best_move().is_null() {
121 |                 continue;
122 |             }
123 |             match t.bound() {
124 |                 Bound::Exact => exact_count += 1,
125 |                 Bound::Upper => upper_count += 1,
126 |                 Bound::Lower => lower_count += 1,
127 |             }
128 |         }
129 | 
130 |         // Usage
131 |         let collisions = self.stats_collisions;
132 |         let hits = self.stats_hits;
133 |         let miss = self.stats_lookups - hits - collisions;
134 | 
135 |         println!("# {:15} {:>8} ({} {}B)", "tt size:", self.len(), size, unit);
136 | 
137 |         let percent = (lower_count as f64) * 100.0 / (self.len() as f64);
138 |         println!("# {:15} {:>8} ({:.2} %)", " - lower:", lower_count, percent);
139 |         let percent = (upper_count as f64) * 100.0 / (self.len() as f64);
140 |         println!("# {:15} {:>8} ({:.2} %)", " - upper:", upper_count, percent);
141 |         let percent = (exact_count as f64) * 100.0 / (self.len() as f64);
142 |         println!("# {:15} {:>8} ({:.2} %)", " - exact:", exact_count, percent);
143 | 
144 |         println!("# {:15} {:>8}", "tt inserts:", self.stats_inserts);
145 |         println!("# {:15} {:>8}", "tt lookups:", self.stats_lookups);
146 | 
147 |         let percent = (miss as f64) * 100.0 / (self.stats_lookups as f64);
148 |         println!("# {:15} {:>8} ({:.2} %)", " - miss:", miss, percent);
149 |         let percent = (hits as f64) * 100.0 / (self.stats_lookups as f64);
150 |         println!("# {:15} {:>8} ({:.2} %)", " - hits:", hits, percent);
151 |         let percent = (collisions as f64) * 100.0 / (self.stats_lookups as f64);
152 |         println!("# {:15} {:>8} ({:.2} %)", " - collisions:", collisions, percent);
153 |     }
154 | }
155 | 
156 | pub struct SharedTable {
157 |     inner: UnsafeCell<Box<[Transposition]>>
158 | }
159 | 
160 | // Tell the compiler than the transposition table can be shared between
161 | // threads inside an `Arc`, even if it's not really safe at all in reality :)
162 | unsafe impl Sync for SharedTable {}
163 | 
164 | impl SharedTable {
165 |     pub fn with_capacity(capacity: usize) -> SharedTable {
166 |         SharedTable {
167 |             // NOTE: Transmuting a boxed slice of zeroed 128 bit integers into
168 |             // empty transpositions is much faster than creating a boxed slice
169 |             // of transitions directly.
170 |             // inner: UnsafeCell::new(vec![Transposition::new_null(); capacity].into_boxed_slice())
171 |             inner: UnsafeCell::new(unsafe {
172 |                 mem::transmute::<Box<[u128]>, Box<[Transposition]>>(
173 |                     vec![0u128; capacity].into_boxed_slice()
174 |                 )
175 |             })
176 |         }
177 |     }
178 | 
179 |     // FIXME: mutable borrow from immutable input
180 |     pub fn get(&self) -> &mut [Transposition] {
181 |         unsafe { &mut *self.inner.get() }
182 |     }
183 | }
184 | 
185 | #[cfg(test)]
186 | mod tests {
187 |     #[cfg(feature = "std")]
188 |     use std::sync::{Arc, Barrier};
189 |     #[cfg(feature = "std")]
190 |     use std::thread;
191 | 
192 |     use super::*;
193 |     use crate::square::*;
194 |     use crate::piece_move::PieceMove;
195 | 
196 |     #[test]
197 |     fn test_transposition_table_size() {
198 |         assert_eq!(TranspositionTable::with_memory(512).len(), 32); // 512 / 16 == 32
199 |         assert_eq!(TranspositionTable::with_capacity(32).len(), 32);
200 | 
201 |         // Size should be a power of two for efficient lookups
202 |         assert_eq!(TranspositionTable::with_capacity(24).len(), 32);
203 | 
204 |         // Large table of 1 M entries using 16 MB of memory
205 |         assert_eq!(TranspositionTable::with_memory(16 << 20).len(), 1048576);
206 |     }
207 | 
208 |     #[test]
209 |     fn test_transposition_table() {
210 |         let mut tt = TranspositionTable::with_capacity(1 << 20); // 1 M entries
211 | 
212 |         let h = 42;
213 |         let m = PieceMove::new(E2, E4, DOUBLE_PAWN_PUSH);
214 |         let s = 100;
215 |         let d = 8;
216 |         let b = Bound::Exact;
217 |         let a = 0;
218 |         let t = Transposition::new(h, d, s, m, b, a);
219 | 
220 |         assert_eq!(t.best_move(), m);
221 |         assert_eq!(t.score(), s);
222 |         assert_eq!(t.depth(), d);
223 | 
224 |         tt.set(h, d, s, m, b);
225 | 
226 |         assert_eq!(tt.get(h).unwrap().best_move(), m);
227 | 
228 |         let h = 1337;
229 |         assert_eq!(tt.get(h), None);
230 |     }
231 | 
232 |     #[cfg(feature = "std")]
233 |     #[test]
234 |     fn test_transposition_table_in_threads() {
235 |         // Transposition content
236 |         let h = 42;
237 |         let m = PieceMove::new(E2, E4, DOUBLE_PAWN_PUSH);
238 |         let s = 100;
239 |         let d = 8;
240 |         let b = Bound::Exact;
241 | 
242 |         let n = 4;
243 |         let mut children = Vec::with_capacity(n);
244 |         let shared_tt = TranspositionTable::with_memory(1 << 20);
245 |         let barrier = Arc::new(Barrier::new(n));
246 |         for i in 0..n {
247 |             let mut tt = shared_tt.clone();
248 |             let c = barrier.clone();
249 | 
250 |             children.push(thread::spawn(move || {
251 |                 if i == 0 {
252 |                     tt.set(h, d, s, m, b); // First thread set a value in TT
253 |                 }
254 |                 c.wait(); // Synchronize all threads
255 |                 tt.get(h).unwrap().best_move() // All threads should get it
256 |             }));
257 |         }
258 | 
259 |         for child in children {
260 |             assert_eq!(child.join().unwrap(), m);
261 |         }
262 |     }
263 | }
264 | 


--------------------------------------------------------------------------------
/src/zobrist.rs:
--------------------------------------------------------------------------------
 1 | use std::prelude::v1::*;
 2 | 
 3 | use rand::{RngCore, SeedableRng};
 4 | use rand_xorshift::XorShiftRng;
 5 | 
 6 | use crate::color::Color;
 7 | use crate::piece::Piece;
 8 | 
 9 | #[derive(Clone)]
10 | pub struct Zobrist {
11 |     pub pieces: [[u64; 64]; 14],
12 |     pub en_passant: [u64; 64],
13 |     pub castling_rights: [[u64; 2]; 2],
14 |     pub side: u64
15 | }
16 | 
17 | const SEED: [u8; 16] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
18 | 
19 | impl Zobrist {
20 |     pub fn new() -> Zobrist {
21 |         let mut zobrist = Zobrist {
22 |             pieces: [[0; 64]; 14],
23 |             en_passant: [0; 64],
24 |             castling_rights: [[0; 2]; 2],
25 |             side: 0
26 |         };
27 | 
28 |         let mut rng = XorShiftRng::from_seed(SEED);
29 | 
30 |         for i in 0..14 {
31 |             for j in 0..64 {
32 |                 zobrist.pieces[i][j] = rng.next_u64();
33 |             }
34 |         }
35 |         for i in 0..64 {
36 |             zobrist.en_passant[i] = rng.next_u64();
37 |         }
38 |         for i in 0..2 {
39 |             for j in 0..2 {
40 |                 zobrist.castling_rights[i][j] = rng.next_u64();
41 |             }
42 |         }
43 |         zobrist.side = rng.next_u64();
44 | 
45 |         zobrist
46 |     }
47 | 
48 |     pub fn castling_right(&self, side: Color, wing: Piece) -> u64 {
49 |         self.castling_rights[side as usize][(wing >> 3) as usize]
50 |     }
51 | }
52 | 
53 | #[cfg(test)]
54 | mod tests {
55 |     use crate::zobrist::Zobrist;
56 | 
57 |     #[test]
58 |     fn test_new() {
59 |         let zobrist = Zobrist::new();
60 |         assert!(zobrist.pieces[0][0] != zobrist.pieces[7][42]);
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/tests/fool.pgn:
--------------------------------------------------------------------------------
1 | [Event "?"]
2 | [Site "?"]
3 | [White "?"]
4 | [Black "?"]
5 | [Result "0-1"]
6 | 
7 | 1. f3 e5 2. g4 Qh4# 0-1
8 | 


--------------------------------------------------------------------------------
/tests/perftsuite.epd:
--------------------------------------------------------------------------------
  1 | rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1 ;D1 20 ;D2 400 ;D3 8902 ;D4 197281 ;D5 4865609 ;D6 119060324
  2 | r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1 ;D1 48 ;D2 2039 ;D3 97862 ;D4 4085603 ;D5 193690690 ;D6 8031647685
  3 | 4k3/8/8/8/8/8/8/4K2R w K - 0 1 ;D1 15 ;D2 66 ;D3 1197 ;D4 7059 ;D5 133987 ;D6 764643
  4 | 4k3/8/8/8/8/8/8/R3K3 w Q - 0 1 ;D1 16 ;D2 71 ;D3 1287 ;D4 7626 ;D5 145232 ;D6 846648
  5 | 4k2r/8/8/8/8/8/8/4K3 w k - 0 1 ;D1 5 ;D2 75 ;D3 459 ;D4 8290 ;D5 47635 ;D6 899442
  6 | r3k3/8/8/8/8/8/8/4K3 w q - 0 1 ;D1 5 ;D2 80 ;D3 493 ;D4 8897 ;D5 52710 ;D6 1001523
  7 | 4k3/8/8/8/8/8/8/R3K2R w KQ - 0 1 ;D1 26 ;D2 112 ;D3 3189 ;D4 17945 ;D5 532933 ;D6 2788982
  8 | r3k2r/8/8/8/8/8/8/4K3 w kq - 0 1 ;D1 5 ;D2 130 ;D3 782 ;D4 22180 ;D5 118882 ;D6 3517770
  9 | 8/8/8/8/8/8/6k1/4K2R w K - 0 1 ;D1 12 ;D2 38 ;D3 564 ;D4 2219 ;D5 37735 ;D6 185867
 10 | 8/8/8/8/8/8/1k6/R3K3 w Q - 0 1 ;D1 15 ;D2 65 ;D3 1018 ;D4 4573 ;D5 80619 ;D6 413018
 11 | 4k2r/6K1/8/8/8/8/8/8 w k - 0 1 ;D1 3 ;D2 32 ;D3 134 ;D4 2073 ;D5 10485 ;D6 179869
 12 | r3k3/1K6/8/8/8/8/8/8 w q - 0 1 ;D1 4 ;D2 49 ;D3 243 ;D4 3991 ;D5 20780 ;D6 367724
 13 | r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 0 1 ;D1 26 ;D2 568 ;D3 13744 ;D4 314346 ;D5 7594526 ;D6 179862938
 14 | r3k2r/8/8/8/8/8/8/1R2K2R w Kkq - 0 1 ;D1 25 ;D2 567 ;D3 14095 ;D4 328965 ;D5 8153719 ;D6 195629489
 15 | r3k2r/8/8/8/8/8/8/2R1K2R w Kkq - 0 1 ;D1 25 ;D2 548 ;D3 13502 ;D4 312835 ;D5 7736373 ;D6 184411439
 16 | r3k2r/8/8/8/8/8/8/R3K1R1 w Qkq - 0 1 ;D1 25 ;D2 547 ;D3 13579 ;D4 316214 ;D5 7878456 ;D6 189224276
 17 | 1r2k2r/8/8/8/8/8/8/R3K2R w KQk - 0 1 ;D1 26 ;D2 583 ;D3 14252 ;D4 334705 ;D5 8198901 ;D6 198328929
 18 | 2r1k2r/8/8/8/8/8/8/R3K2R w KQk - 0 1 ;D1 25 ;D2 560 ;D3 13592 ;D4 317324 ;D5 7710115 ;D6 185959088
 19 | r3k1r1/8/8/8/8/8/8/R3K2R w KQq - 0 1 ;D1 25 ;D2 560 ;D3 13607 ;D4 320792 ;D5 7848606 ;D6 190755813
 20 | 4k3/8/8/8/8/8/8/4K2R b K - 0 1 ;D1 5 ;D2 75 ;D3 459 ;D4 8290 ;D5 47635 ;D6 899442
 21 | 4k3/8/8/8/8/8/8/R3K3 b Q - 0 1 ;D1 5 ;D2 80 ;D3 493 ;D4 8897 ;D5 52710 ;D6 1001523
 22 | 4k2r/8/8/8/8/8/8/4K3 b k - 0 1 ;D1 15 ;D2 66 ;D3 1197 ;D4 7059 ;D5 133987 ;D6 764643
 23 | r3k3/8/8/8/8/8/8/4K3 b q - 0 1 ;D1 16 ;D2 71 ;D3 1287 ;D4 7626 ;D5 145232 ;D6 846648
 24 | 4k3/8/8/8/8/8/8/R3K2R b KQ - 0 1 ;D1 5 ;D2 130 ;D3 782 ;D4 22180 ;D5 118882 ;D6 3517770
 25 | r3k2r/8/8/8/8/8/8/4K3 b kq - 0 1 ;D1 26 ;D2 112 ;D3 3189 ;D4 17945 ;D5 532933 ;D6 2788982
 26 | 8/8/8/8/8/8/6k1/4K2R b K - 0 1 ;D1 3 ;D2 32 ;D3 134 ;D4 2073 ;D5 10485 ;D6 179869
 27 | 8/8/8/8/8/8/1k6/R3K3 b Q - 0 1 ;D1 4 ;D2 49 ;D3 243 ;D4 3991 ;D5 20780 ;D6 367724
 28 | 4k2r/6K1/8/8/8/8/8/8 b k - 0 1 ;D1 12 ;D2 38 ;D3 564 ;D4 2219 ;D5 37735 ;D6 185867
 29 | r3k3/1K6/8/8/8/8/8/8 b q - 0 1 ;D1 15 ;D2 65 ;D3 1018 ;D4 4573 ;D5 80619 ;D6 413018
 30 | r3k2r/8/8/8/8/8/8/R3K2R b KQkq - 0 1 ;D1 26 ;D2 568 ;D3 13744 ;D4 314346 ;D5 7594526 ;D6 179862938
 31 | r3k2r/8/8/8/8/8/8/1R2K2R b Kkq - 0 1 ;D1 26 ;D2 583 ;D3 14252 ;D4 334705 ;D5 8198901 ;D6 198328929
 32 | r3k2r/8/8/8/8/8/8/2R1K2R b Kkq - 0 1 ;D1 25 ;D2 560 ;D3 13592 ;D4 317324 ;D5 7710115 ;D6 185959088
 33 | r3k2r/8/8/8/8/8/8/R3K1R1 b Qkq - 0 1 ;D1 25 ;D2 560 ;D3 13607 ;D4 320792 ;D5 7848606 ;D6 190755813
 34 | 1r2k2r/8/8/8/8/8/8/R3K2R b KQk - 0 1 ;D1 25 ;D2 567 ;D3 14095 ;D4 328965 ;D5 8153719 ;D6 195629489
 35 | 2r1k2r/8/8/8/8/8/8/R3K2R b KQk - 0 1 ;D1 25 ;D2 548 ;D3 13502 ;D4 312835 ;D5 7736373 ;D6 184411439
 36 | r3k1r1/8/8/8/8/8/8/R3K2R b KQq - 0 1 ;D1 25 ;D2 547 ;D3 13579 ;D4 316214 ;D5 7878456 ;D6 189224276
 37 | 8/1n4N1/2k5/8/8/5K2/1N4n1/8 w - - 0 1 ;D1 14 ;D2 195 ;D3 2760 ;D4 38675 ;D5 570726 ;D6 8107539
 38 | 8/1k6/8/5N2/8/4n3/8/2K5 w - - 0 1 ;D1 11 ;D2 156 ;D3 1636 ;D4 20534 ;D5 223507 ;D6 2594412
 39 | 8/8/4k3/3Nn3/3nN3/4K3/8/8 w - - 0 1 ;D1 19 ;D2 289 ;D3 4442 ;D4 73584 ;D5 1198299 ;D6 19870403
 40 | K7/8/2n5/1n6/8/8/8/k6N w - - 0 1 ;D1 3 ;D2 51 ;D3 345 ;D4 5301 ;D5 38348 ;D6 588695
 41 | k7/8/2N5/1N6/8/8/8/K6n w - - 0 1 ;D1 17 ;D2 54 ;D3 835 ;D4 5910 ;D5 92250 ;D6 688780
 42 | 8/1n4N1/2k5/8/8/5K2/1N4n1/8 b - - 0 1 ;D1 15 ;D2 193 ;D3 2816 ;D4 40039 ;D5 582642 ;D6 8503277
 43 | 8/1k6/8/5N2/8/4n3/8/2K5 b - - 0 1 ;D1 16 ;D2 180 ;D3 2290 ;D4 24640 ;D5 288141 ;D6 3147566
 44 | 8/8/3K4/3Nn3/3nN3/4k3/8/8 b - - 0 1 ;D1 4 ;D2 68 ;D3 1118 ;D4 16199 ;D5 281190 ;D6 4405103
 45 | K7/8/2n5/1n6/8/8/8/k6N b - - 0 1 ;D1 17 ;D2 54 ;D3 835 ;D4 5910 ;D5 92250 ;D6 688780
 46 | k7/8/2N5/1N6/8/8/8/K6n b - - 0 1 ;D1 3 ;D2 51 ;D3 345 ;D4 5301 ;D5 38348 ;D6 588695
 47 | B6b/8/8/8/2K5/4k3/8/b6B w - - 0 1 ;D1 17 ;D2 278 ;D3 4607 ;D4 76778 ;D5 1320507 ;D6 22823890
 48 | 8/8/1B6/7b/7k/8/2B1b3/7K w - - 0 1 ;D1 21 ;D2 316 ;D3 5744 ;D4 93338 ;D5 1713368 ;D6 28861171
 49 | k7/B7/1B6/1B6/8/8/8/K6b w - - 0 1 ;D1 21 ;D2 144 ;D3 3242 ;D4 32955 ;D5 787524 ;D6 7881673
 50 | K7/b7/1b6/1b6/8/8/8/k6B w - - 0 1 ;D1 7 ;D2 143 ;D3 1416 ;D4 31787 ;D5 310862 ;D6 7382896
 51 | B6b/8/8/8/2K5/5k2/8/b6B b - - 0 1 ;D1 6 ;D2 106 ;D3 1829 ;D4 31151 ;D5 530585 ;D6 9250746
 52 | 8/8/1B6/7b/7k/8/2B1b3/7K b - - 0 1 ;D1 17 ;D2 309 ;D3 5133 ;D4 93603 ;D5 1591064 ;D6 29027891
 53 | k7/B7/1B6/1B6/8/8/8/K6b b - - 0 1 ;D1 7 ;D2 143 ;D3 1416 ;D4 31787 ;D5 310862 ;D6 7382896
 54 | K7/b7/1b6/1b6/8/8/8/k6B b - - 0 1 ;D1 21 ;D2 144 ;D3 3242 ;D4 32955 ;D5 787524 ;D6 7881673
 55 | 7k/RR6/8/8/8/8/rr6/7K w - - 0 1 ;D1 19 ;D2 275 ;D3 5300 ;D4 104342 ;D5 2161211 ;D6 44956585
 56 | R6r/8/8/2K5/5k2/8/8/r6R w - - 0 1 ;D1 36 ;D2 1027 ;D3 29215 ;D4 771461 ;D5 20506480 ;D6 525169084
 57 | 7k/RR6/8/8/8/8/rr6/7K b - - 0 1 ;D1 19 ;D2 275 ;D3 5300 ;D4 104342 ;D5 2161211 ;D6 44956585
 58 | R6r/8/8/2K5/5k2/8/8/r6R b - - 0 1 ;D1 36 ;D2 1027 ;D3 29227 ;D4 771368 ;D5 20521342 ;D6 524966748
 59 | 6kq/8/8/8/8/8/8/7K w - - 0 1 ;D1 2 ;D2 36 ;D3 143 ;D4 3637 ;D5 14893 ;D6 391507
 60 | 6KQ/8/8/8/8/8/8/7k b - - 0 1 ;D1 2 ;D2 36 ;D3 143 ;D4 3637 ;D5 14893 ;D6 391507
 61 | K7/8/8/3Q4/4q3/8/8/7k w - - 0 1 ;D1 6 ;D2 35 ;D3 495 ;D4 8349 ;D5 166741 ;D6 3370175
 62 | 6qk/8/8/8/8/8/8/7K b - - 0 1 ;D1 22 ;D2 43 ;D3 1015 ;D4 4167 ;D5 105749 ;D6 419369
 63 | 6KQ/8/8/8/8/8/8/7k b - - 0 1 ;D1 2 ;D2 36 ;D3 143 ;D4 3637 ;D5 14893 ;D6 391507
 64 | K7/8/8/3Q4/4q3/8/8/7k b - - 0 1 ;D1 6 ;D2 35 ;D3 495 ;D4 8349 ;D5 166741 ;D6 3370175
 65 | 8/8/8/8/8/K7/P7/k7 w - - 0 1 ;D1 3 ;D2 7 ;D3 43 ;D4 199 ;D5 1347 ;D6 6249
 66 | 8/8/8/8/8/7K/7P/7k w - - 0 1 ;D1 3 ;D2 7 ;D3 43 ;D4 199 ;D5 1347 ;D6 6249
 67 | K7/p7/k7/8/8/8/8/8 w - - 0 1 ;D1 1 ;D2 3 ;D3 12 ;D4 80 ;D5 342 ;D6 2343
 68 | 7K/7p/7k/8/8/8/8/8 w - - 0 1 ;D1 1 ;D2 3 ;D3 12 ;D4 80 ;D5 342 ;D6 2343
 69 | 8/2k1p3/3pP3/3P2K1/8/8/8/8 w - - 0 1 ;D1 7 ;D2 35 ;D3 210 ;D4 1091 ;D5 7028 ;D6 34834
 70 | 8/8/8/8/8/K7/P7/k7 b - - 0 1 ;D1 1 ;D2 3 ;D3 12 ;D4 80 ;D5 342 ;D6 2343
 71 | 8/8/8/8/8/7K/7P/7k b - - 0 1 ;D1 1 ;D2 3 ;D3 12 ;D4 80 ;D5 342 ;D6 2343
 72 | K7/p7/k7/8/8/8/8/8 b - - 0 1 ;D1 3 ;D2 7 ;D3 43 ;D4 199 ;D5 1347 ;D6 6249
 73 | 7K/7p/7k/8/8/8/8/8 b - - 0 1 ;D1 3 ;D2 7 ;D3 43 ;D4 199 ;D5 1347 ;D6 6249
 74 | 8/2k1p3/3pP3/3P2K1/8/8/8/8 b - - 0 1 ;D1 5 ;D2 35 ;D3 182 ;D4 1091 ;D5 5408 ;D6 34822
 75 | 8/8/8/8/8/4k3/4P3/4K3 w - - 0 1 ;D1 2 ;D2 8 ;D3 44 ;D4 282 ;D5 1814 ;D6 11848
 76 | 4k3/4p3/4K3/8/8/8/8/8 b - - 0 1 ;D1 2 ;D2 8 ;D3 44 ;D4 282 ;D5 1814 ;D6 11848
 77 | 8/8/7k/7p/7P/7K/8/8 w - - 0 1 ;D1 3 ;D2 9 ;D3 57 ;D4 360 ;D5 1969 ;D6 10724
 78 | 8/8/k7/p7/P7/K7/8/8 w - - 0 1 ;D1 3 ;D2 9 ;D3 57 ;D4 360 ;D5 1969 ;D6 10724
 79 | 8/8/3k4/3p4/3P4/3K4/8/8 w - - 0 1 ;D1 5 ;D2 25 ;D3 180 ;D4 1294 ;D5 8296 ;D6 53138
 80 | 8/3k4/3p4/8/3P4/3K4/8/8 w - - 0 1 ;D1 8 ;D2 61 ;D3 483 ;D4 3213 ;D5 23599 ;D6 157093
 81 | 8/8/3k4/3p4/8/3P4/3K4/8 w - - 0 1 ;D1 8 ;D2 61 ;D3 411 ;D4 3213 ;D5 21637 ;D6 158065
 82 | k7/8/3p4/8/3P4/8/8/7K w - - 0 1 ;D1 4 ;D2 15 ;D3 90 ;D4 534 ;D5 3450 ;D6 20960
 83 | 8/8/7k/7p/7P/7K/8/8 b - - 0 1 ;D1 3 ;D2 9 ;D3 57 ;D4 360 ;D5 1969 ;D6 10724
 84 | 8/8/k7/p7/P7/K7/8/8 b - - 0 1 ;D1 3 ;D2 9 ;D3 57 ;D4 360 ;D5 1969 ;D6 10724
 85 | 8/8/3k4/3p4/3P4/3K4/8/8 b - - 0 1 ;D1 5 ;D2 25 ;D3 180 ;D4 1294 ;D5 8296 ;D6 53138
 86 | 8/3k4/3p4/8/3P4/3K4/8/8 b - - 0 1 ;D1 8 ;D2 61 ;D3 411 ;D4 3213 ;D5 21637 ;D6 158065
 87 | 8/8/3k4/3p4/8/3P4/3K4/8 b - - 0 1 ;D1 8 ;D2 61 ;D3 483 ;D4 3213 ;D5 23599 ;D6 157093
 88 | k7/8/3p4/8/3P4/8/8/7K b - - 0 1 ;D1 4 ;D2 15 ;D3 89 ;D4 537 ;D5 3309 ;D6 21104
 89 | 7k/3p4/8/8/3P4/8/8/K7 w - - 0 1 ;D1 4 ;D2 19 ;D3 117 ;D4 720 ;D5 4661 ;D6 32191
 90 | 7k/8/8/3p4/8/8/3P4/K7 w - - 0 1 ;D1 5 ;D2 19 ;D3 116 ;D4 716 ;D5 4786 ;D6 30980
 91 | k7/8/8/7p/6P1/8/8/K7 w - - 0 1 ;D1 5 ;D2 22 ;D3 139 ;D4 877 ;D5 6112 ;D6 41874
 92 | k7/8/7p/8/8/6P1/8/K7 w - - 0 1 ;D1 4 ;D2 16 ;D3 101 ;D4 637 ;D5 4354 ;D6 29679
 93 | k7/8/8/6p1/7P/8/8/K7 w - - 0 1 ;D1 5 ;D2 22 ;D3 139 ;D4 877 ;D5 6112 ;D6 41874
 94 | k7/8/6p1/8/8/7P/8/K7 w - - 0 1 ;D1 4 ;D2 16 ;D3 101 ;D4 637 ;D5 4354 ;D6 29679
 95 | k7/8/8/3p4/4p3/8/8/7K w - - 0 1 ;D1 3 ;D2 15 ;D3 84 ;D4 573 ;D5 3013 ;D6 22886
 96 | k7/8/3p4/8/8/4P3/8/7K w - - 0 1 ;D1 4 ;D2 16 ;D3 101 ;D4 637 ;D5 4271 ;D6 28662
 97 | 7k/3p4/8/8/3P4/8/8/K7 b - - 0 1 ;D1 5 ;D2 19 ;D3 117 ;D4 720 ;D5 5014 ;D6 32167
 98 | 7k/8/8/3p4/8/8/3P4/K7 b - - 0 1 ;D1 4 ;D2 19 ;D3 117 ;D4 712 ;D5 4658 ;D6 30749
 99 | k7/8/8/7p/6P1/8/8/K7 b - - 0 1 ;D1 5 ;D2 22 ;D3 139 ;D4 877 ;D5 6112 ;D6 41874
100 | k7/8/7p/8/8/6P1/8/K7 b - - 0 1 ;D1 4 ;D2 16 ;D3 101 ;D4 637 ;D5 4354 ;D6 29679
101 | k7/8/8/6p1/7P/8/8/K7 b - - 0 1 ;D1 5 ;D2 22 ;D3 139 ;D4 877 ;D5 6112 ;D6 41874
102 | k7/8/6p1/8/8/7P/8/K7 b - - 0 1 ;D1 4 ;D2 16 ;D3 101 ;D4 637 ;D5 4354 ;D6 29679
103 | k7/8/8/3p4/4p3/8/8/7K b - - 0 1 ;D1 5 ;D2 15 ;D3 102 ;D4 569 ;D5 4337 ;D6 22579
104 | k7/8/3p4/8/8/4P3/8/7K b - - 0 1 ;D1 4 ;D2 16 ;D3 101 ;D4 637 ;D5 4271 ;D6 28662
105 | 7k/8/8/p7/1P6/8/8/7K w - - 0 1 ;D1 5 ;D2 22 ;D3 139 ;D4 877 ;D5 6112 ;D6 41874
106 | 7k/8/p7/8/8/1P6/8/7K w - - 0 1 ;D1 4 ;D2 16 ;D3 101 ;D4 637 ;D5 4354 ;D6 29679
107 | 7k/8/8/1p6/P7/8/8/7K w - - 0 1 ;D1 5 ;D2 22 ;D3 139 ;D4 877 ;D5 6112 ;D6 41874
108 | 7k/8/1p6/8/8/P7/8/7K w - - 0 1 ;D1 4 ;D2 16 ;D3 101 ;D4 637 ;D5 4354 ;D6 29679
109 | k7/7p/8/8/8/8/6P1/K7 w - - 0 1 ;D1 5 ;D2 25 ;D3 161 ;D4 1035 ;D5 7574 ;D6 55338
110 | k7/6p1/8/8/8/8/7P/K7 w - - 0 1 ;D1 5 ;D2 25 ;D3 161 ;D4 1035 ;D5 7574 ;D6 55338
111 | 3k4/3pp3/8/8/8/8/3PP3/3K4 w - - 0 1 ;D1 7 ;D2 49 ;D3 378 ;D4 2902 ;D5 24122 ;D6 199002
112 | 7k/8/8/p7/1P6/8/8/7K b - - 0 1 ;D1 5 ;D2 22 ;D3 139 ;D4 877 ;D5 6112 ;D6 41874
113 | 7k/8/p7/8/8/1P6/8/7K b - - 0 1 ;D1 4 ;D2 16 ;D3 101 ;D4 637 ;D5 4354 ;D6 29679
114 | 7k/8/8/1p6/P7/8/8/7K b - - 0 1 ;D1 5 ;D2 22 ;D3 139 ;D4 877 ;D5 6112 ;D6 41874
115 | 7k/8/1p6/8/8/P7/8/7K b - - 0 1 ;D1 4 ;D2 16 ;D3 101 ;D4 637 ;D5 4354 ;D6 29679
116 | k7/7p/8/8/8/8/6P1/K7 b - - 0 1 ;D1 5 ;D2 25 ;D3 161 ;D4 1035 ;D5 7574 ;D6 55338
117 | k7/6p1/8/8/8/8/7P/K7 b - - 0 1 ;D1 5 ;D2 25 ;D3 161 ;D4 1035 ;D5 7574 ;D6 55338
118 | 3k4/3pp3/8/8/8/8/3PP3/3K4 b - - 0 1 ;D1 7 ;D2 49 ;D3 378 ;D4 2902 ;D5 24122 ;D6 199002
119 | 8/Pk6/8/8/8/8/6Kp/8 w - - 0 1 ;D1 11 ;D2 97 ;D3 887 ;D4 8048 ;D5 90606 ;D6 1030499
120 | n1n5/1Pk5/8/8/8/8/5Kp1/5N1N w - - 0 1 ;D1 24 ;D2 421 ;D3 7421 ;D4 124608 ;D5 2193768 ;D6 37665329
121 | 8/PPPk4/8/8/8/8/4Kppp/8 w - - 0 1 ;D1 18 ;D2 270 ;D3 4699 ;D4 79355 ;D5 1533145 ;D6 28859283
122 | n1n5/PPPk4/8/8/8/8/4Kppp/5N1N w - - 0 1 ;D1 24 ;D2 496 ;D3 9483 ;D4 182838 ;D5 3605103 ;D6 71179139
123 | 8/Pk6/8/8/8/8/6Kp/8 b - - 0 1 ;D1 11 ;D2 97 ;D3 887 ;D4 8048 ;D5 90606 ;D6 1030499
124 | n1n5/1Pk5/8/8/8/8/5Kp1/5N1N b - - 0 1 ;D1 24 ;D2 421 ;D3 7421 ;D4 124608 ;D5 2193768 ;D6 37665329
125 | 8/PPPk4/8/8/8/8/4Kppp/8 b - - 0 1 ;D1 18 ;D2 270 ;D3 4699 ;D4 79355 ;D5 1533145 ;D6 28859283
126 | n1n5/PPPk4/8/8/8/8/4Kppp/5N1N b - - 0 1 ;D1 24 ;D2 496 ;D3 9483 ;D4 182838 ;D5 3605103 ;D6 71179139
127 | 


--------------------------------------------------------------------------------
/tests/wac.rs:
--------------------------------------------------------------------------------
 1 | extern crate littlewing;
 2 | 
 3 | use std::fs;
 4 | 
 5 | use littlewing::clock::Clock;
 6 | use littlewing::fen::FEN;
 7 | use littlewing::game::Game;
 8 | use littlewing::piece_move_notation::PieceMoveNotation;
 9 | use littlewing::search::Search;
10 | 
11 | #[test]
12 | fn test_wac() {
13 |     let mut game = Game::new();
14 | 
15 |     // Test some WAC positions
16 |     let file = fs::read_to_string("tests/wac.epd").unwrap();
17 |     let lines = [1, 3, 4, 5, 6, 7, 8, 9, 37, 199, 255];
18 |     let mut l = 0;
19 |     for line in file.lines() {
20 |         l += 1;
21 |         if !lines.contains(&l) {
22 |             continue;
23 |         }
24 |         let line = line.split(";").next().unwrap();
25 | 
26 |         let i = line.find("m ").unwrap() - 1;
27 |         let (fen, rem) = line.split_at(i);
28 |         let (mt, moves) = rem.split_at(2); // Extract the best move list
29 |         assert_eq!(mt, "bm");
30 | 
31 |         game.load_fen(fen).unwrap();
32 |         game.clock = Clock::new(1, 1000); // search for 1 second
33 | 
34 |         let m = game.search(1..99).unwrap();
35 |         let best_move = game.move_to_san(m);
36 | 
37 |         println!("{} <- {}", moves, best_move);
38 | 
39 |         assert!(moves.contains(&best_move));
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/tests/zukertort_vs_steinitz_1886.pgn:
--------------------------------------------------------------------------------
 1 | [Event "Steinitz - Zukertort World Championship Match"]
 2 | [Site "New Orleans, LA USA"]
 3 | [Date "1886.03.24"]
 4 | [EventDate "?"]
 5 | [Round "19"]
 6 | [Result "0-1"]
 7 | [White "Johannes Zukertort"]
 8 | [Black "Wilhelm Steinitz"]
 9 | [ECO "D50"]
10 | [WhiteElo "?"]
11 | [BlackElo "?"]
12 | [PlyCount "58"]
13 | 
14 | 1. d4 {Notes by Robert James Fischer from a television
15 | interview. } d5 2. c4 e6 3. Nc3 Nf6 4. Bg5 Be7 5. Nf3 O-O
16 | 6. c5 {White plays a mistake already; he should just play e3,
17 | naturally.--Fischer} b6 7. b4 bxc5 8. dxc5 a5 9. a3 {Now he
18 | plays this fantastic move; it's the winning move. -- Fischer}
19 | d4 {He can't take with the knight, because of axb4.--Fischer}
20 | 10. Bxf6 gxf6 11. Na4 e5 {This kingside weakness is nothing;
21 | the center is easily winning.--Fischer} 12. b5 Be6 13. g3 c6
22 | 14. bxc6 Nxc6 15. Bg2 Rb8 {Threatening Bb3.--Fischer} 16. Qc1
23 | d3 17. e3 e4 18. Nd2 f5 19. O-O Re8 {A very modern move; a
24 | quiet positional move. The rook is doing nothing now, but
25 | later...--Fischer} 20. f3 {To break up the center, it's his
26 | only chance.--Fischer} Nd4 21. exd4 Qxd4+ 22. Kh1 e3 23. Nc3
27 | Bf6 24. Ndb1 d2 25. Qc2 Bb3 26. Qxf5 d1=Q 27. Nxd1 Bxd1
28 | 28. Nc3 e2 29. Raxd1 Qxc3 0-1
29 | 


--------------------------------------------------------------------------------