Continue implementation

.vscode/settings.json

@@ -13,6 +13,7 @@
     "byteorder",
     "capturable",
     "CCRL",
+    "centipawn",
     "clippy",
     "Codecov",
     "doctest",

src/chess/attacks.rs

@@ -1,6 +1,13 @@
 //! Mappings of occupied squares to the attacked squares for each piece. The
 //! mappings are pre-calculated where possible to provide an efficient way of
 //! generating moves.
+//!
+//! The implementation uses BMI2 (if available) for performance ([reference]),
+//! specifically the PEXT instruction for [PEXT Bitboards].
+//!
+//! [reference]: https://www.chessprogramming.org/BMI2
+//! [PEXT Bitboards]: https://www.chessprogramming.org/BMI2#PEXTBitboards
+
 // TODO: This code is probably by far the least appealing in the project.
 // Refactor it and make it nicer.
 

src/chess/bitboard.rs

@@ -9,7 +9,14 @@
 //! that can be used together bitboard-based approach to compensate its
 //! shortcomings).
 //!
+//! The implementation is based on [PEXT Bitboards] idea, which is an
+//! improvement over Fancy Magic Bitboards.
+//!
+//! For visualizing and debugging the bitboards, there is a [BitboardCalculator] tool.
+//!
 //! [Bitboards]: https://www.chessprogramming.org/Bitboards
+//! [BitboardCalculator]: https://gekomad.github.io/Cinnamon/BitboardCalculator/
+//! [PEXT Bitboards]: https://www.chessprogramming.org/BMI2#PEXTBitboards
 
 use std::fmt::Write;
 use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, Not, Shl, Shr, Sub, SubAssign};
@@ -18,15 +25,7 @@ use std::{fmt, mem};
 use itertools::Itertools;
 
 use crate::chess::core::{
-    Direction,
-    File,
-    Piece,
-    PieceKind,
-    Player,
-    Rank,
-    Square,
-    BOARD_SIZE,
-    BOARD_WIDTH,
+    Direction, File, Piece, PieceKind, Player, Rank, Square, BOARD_SIZE, BOARD_WIDTH,
 };
 
 /// Represents a set of squares and provides common operations (e.g. AND, OR,

src/chess/position.rs

@@ -14,16 +14,7 @@ use anyhow::{bail, Context};
 use crate::chess::attacks;
 use crate::chess::bitboard::{Bitboard, Board, Pieces};
 use crate::chess::core::{
-    CastleRights,
-    File,
-    Move,
-    MoveList,
-    Piece,
-    Player,
-    Promotion,
-    Rank,
-    Square,
-    BOARD_WIDTH,
+    CastleRights, File, Move, MoveList, Piece, Player, Promotion, Rank, Square, BOARD_WIDTH,
 };
 
 /// State of the chess game: board, half-move counters and castling rights,
@@ -89,7 +80,8 @@ impl Position {
         }
     }
 
-    #[must_use] pub fn empty() -> Self {
+    #[must_use]
+    pub fn empty() -> Self {
         Self {
             board: Board::empty(),
             castling: CastleRights::NONE,
@@ -534,15 +526,18 @@ impl Position {
     /// Returns true if the player to move is in check.
     #[must_use]
     pub fn in_check(&self) -> bool {
+        // TODO: This is very expensive and is likely to be a bottleneck.
+        // Cache the attack info and/or whether the king is in check.
         self.attack_info().checkers.has_any()
     }
 
+    /// Returns true if the game is over.
     #[must_use]
-    fn is_checkmate(&self) -> bool {
+    pub fn is_checkmate(&self) -> bool {
         self.in_check() && self.generate_moves().is_empty()
     }
 
-    fn is_stalemate(&self) -> bool {
+    pub fn is_stalemate(&self) -> bool {
         !self.in_check() && self.generate_moves().is_empty()
     }
 }