Implementing check mask (#69)

* added Zeros() and Ones() static constructors for Bitboards as well as new overloads for test clear and set functions

* added Square methods to test easily for identical rank, file and diagonals

* added docstrings for attackers functions

* between squares utils and tests

* more tests for attackers

* save

* fixed linting and tests

* fixed undefined behavior on step = 0

Author: Hardcode3

include/bitbishop/bitboard.hpp

@@ -52,6 +52,12 @@ class Bitboard {
   /** @brief Returns the raw 64-bit value of the bitboard. */
   [[nodiscard]] constexpr uint64_t value() const { return m_bb; }
 
+  /** @brief Returns a Bitboard instance with all bits set to zero. */
+  static constexpr Bitboard Zeros() noexcept { return {0ULL}; }
+
+  /** @brief Returns a Bitbaord instance with all bits set to one. */
+  static constexpr Bitboard Ones() noexcept { return {~0ULL}; }
+
   /**
    * @brief Sets a bit (places a piece) on a given square.
    *
@@ -70,6 +76,7 @@ class Bitboard {
    */
   constexpr void set(Square square) { m_bb |= (1ULL << square.value()); }
   constexpr void set(Square::Value square) { m_bb |= (1ULL << square); }
+  constexpr void set(std::uint8_t square) { m_bb |= (1ULL << square); }
 
   /**
    * @brief Clears a bit (removes a piece) on a given square.
@@ -89,6 +96,7 @@ class Bitboard {
    */
   constexpr void clear(Square square) { m_bb &= ~(1ULL << square.value()); }
   constexpr void clear(Square::Value square) { m_bb &= ~(1ULL << square); }
+  constexpr void clear(std::uint8_t square) { m_bb &= ~(1ULL << square); }
 
   /**
    * @brief Checks if a square is occupied.
@@ -108,6 +116,7 @@ class Bitboard {
    */
   [[nodiscard]] constexpr bool test(Square square) const { return ((m_bb >> square.value()) & 1ULL) != 0ULL; }
   [[nodiscard]] constexpr bool test(Square::Value square) const { return ((m_bb >> square) & 1ULL) != 0ULL; }
+  [[nodiscard]] constexpr bool test(std::uint8_t square) const { return ((m_bb >> square) & 1ULL) != 0ULL; }
 
   /** @brief Clears the whole bitboard (all bits = 0). */
   constexpr void reset() { m_bb = 0ULL; }
@@ -167,6 +176,15 @@ class Bitboard {
    */
   [[nodiscard]] constexpr bool any() const noexcept { return m_bb != 0ULL; }
 
+  /**
+   * @brief Tells if the bitboard is empty / has no bit set.
+   *
+   * @return True if no bit is set on that bitboard.
+   *
+   * @note Equivalent to '!any()' or 'count() == 0'
+   */
+  [[nodiscard]] constexpr bool empty() const noexcept { return m_bb == 0ULL; }
+
   /**
    * @brief Removes and returns the least significant set bit (LSB) from the bitboard.
    *

include/bitbishop/board.hpp

@@ -63,6 +63,8 @@ class Board {
    */
   Board(const std::string& fen);
 
+  [[nodiscard]] static Board Empty() noexcept { return {"8/8/8/8/8/8/8/8 w KQkq - 0 1"}; }
+
   /**
    * @brief Retrieves the piece on a given square.
    * @param square The square to query.

include/bitbishop/lookups/attackers.hpp

@@ -10,6 +10,34 @@
 #include <bitbishop/lookups/rook_rays.hpp>
 #include <bitbishop/square.hpp>
 
+/**
+ * @brief Computes the geometric attackers to a target square for a given color.
+ *
+ * Returns a bitboard containing all squares from which a piece of the given
+ * color could attack the target square, assuming an empty board for sliding
+ * pieces.
+ *
+ * This function performs a purely geometric attack computation:
+ * - King, knight, and pawn attacks are exact.
+ * - Rook, bishop, and queen attacks are based on precomputed rays and do not
+ *   account for blockers.
+ *
+ * The resulting bitboard therefore represents *potential* attackers and must
+ * be filtered against board occupancy to determine actual attacks.
+ *
+ * This function is intended for use in:
+ * - check detection
+ * - pin detection
+ * - attack-based legality filtering
+ *
+ * @param target The square being attacked.
+ * @param color  The color of the attacking side.
+ * @return A bitboard of squares that could attack @p target.
+ *
+ * @note This function does not consider board occupancy.
+ * @note The returned bitboard may include squares that are blocked in the
+ *       current position.
+ */
 constexpr Bitboard attackers_to(Square target, Color color) {
   using namespace Lookups;
   const int square_index = target.value();
@@ -31,15 +59,40 @@ constexpr Bitboard attackers_to(Square target, Color color) {
   return attackers;
 }
 
+/**
+ * @brief Precomputed lookup table of geometric attackers for all squares and colors.
+ *
+ * For each color and target square, this table contains a bitboard of all
+ * squares from which a piece of that color could potentially attack the target
+ * square, ignoring board occupancy.
+ *
+ * The table is indexed as:
+ * @code
+ * ATTACKERS_TO[color_index][square_index]
+ * @endcode
+ *
+ * This table is computed entirely at compile time and serves as a fast,
+ * constant-time replacement for repeated calls to attackers_to().
+ *
+ * Typical use cases include:
+ * - fast king-in-check detection
+ * - identifying candidate checking pieces
+ * - pin and x-ray attack analysis
+ *
+ * @note Sliding piece attacks in this table are unblocked rays and must be
+ *       masked with board occupancy when determining actual attacks.
+ */
 constexpr std::array<std::array<Bitboard, Const::BOARD_SIZE>, ColorUtil::size()> ATTACKERS_TO = []() constexpr {
   using namespace Const;
 
   std::array<std::array<Bitboard, BOARD_SIZE>, ColorUtil::size()> table{};
+
   for (Color col : ColorUtil::all()) {
     const std::size_t coli = ColorUtil::to_index(col);
     for (int sq = 0; sq < BOARD_SIZE; ++sq) {
       table[coli][sq] = Bitboard(attackers_to(Square(sq, std::in_place), col));
     }
   }
+
   return table;
 }();

include/bitbishop/lookups/between_squares.hpp

@@ -0,0 +1,120 @@
+#include <array>
+#include <bitbishop/bitboard.hpp>
+#include <bitbishop/constants.hpp>
+
+namespace Lookups {
+
+/**
+ * @brief Computes the directional step between two aligned squares.
+ *
+ * Returns the signed square-index increment required to move from the
+ * source square toward the destination square along a shared rank, file,
+ * or diagonal.
+ *
+ * The returned value corresponds to the underlying square indexing:
+ * - +-1  for horizontal movement (same rank)
+ * - +-8  for vertical movement (same file)
+ * - +-9  for NE–SW diagonal movement
+ * - +-7  for NW–SE diagonal movement
+ * - 0    if source and destination square are identical
+ * - 0    if source and destination squares are not aligned
+ *
+ * This function assumes that the two squares are aligned. Its primary use
+ * is internal traversal of rays when building geometric lookup tables such
+ * as BETWEEN.
+ *
+ * @param from The starting square.
+ * @param to   The target square.
+ * @return The signed step value to advance one square toward @p to.
+ */
+constexpr int direction(Square from, Square to) {
+  if (from == to) {
+    return 0;
+  }
+  if (from.same_rank(to)) {
+    return (to.file() > from.file()) ? +1 : -1;
+  }
+  if (from.same_file(to)) {
+    return (to.rank() > from.rank()) ? +Const::BOARD_WIDTH : -Const::BOARD_WIDTH;
+  }
+  if (from.same_ne_sw_diag(to)) {
+    return (to.rank() > from.rank()) ? +(Const::BOARD_WIDTH + 1) : -(Const::BOARD_WIDTH + 1);
+  }
+  if (from.same_nw_se_diag(to)) {
+    return (to.rank() > from.rank()) ? +(Const::BOARD_WIDTH - 1) : -(Const::BOARD_WIDTH - 1);
+  }
+
+  return 0;
+}
+
+/**
+ * @brief Computes the bitboard of squares strictly between two aligned squares.
+ *
+ * Returns a bitboard containing all squares located strictly between the
+ * source and destination squares, excluding both endpoints.
+ *
+ * If the squares are not aligned along the same rank, file, or diagonal,
+ * or if both squares are identical, an empty bitboard is returned.
+ *
+ * This function is purely geometric and does not depend on board occupancy.
+ * It is intended for use in compile-time construction of lookup tables and
+ * in runtime legality checks such as pins and check interposition.
+ *
+ * @param from The starting square.
+ * @param to   The target square.
+ * @return A bitboard of squares strictly between @p from and @p to.
+ */
+constexpr Bitboard ray_between(Square from, Square to) {
+  if (from == to) {
+    return Bitboard::Zeros();
+  }
+
+  if (!(from.same_file(to) || from.same_rank(to) || from.same_diag(to))) {
+    return Bitboard::Zeros();
+  }
+
+  // Defensive check: if step is 0, squares aren't truly aligned
+  const int step = direction(from, to);
+  if (step == 0) {
+    return Bitboard::Zeros();
+  }
+
+  Bitboard ray = Bitboard::Zeros();
+  for (std::uint8_t square = from.value() + step; square != to.value(); square += step) {
+    ray.set(square);
+  }
+
+  return ray;
+}
+
+/**
+ * @brief Precomputed lookup table of squares lying strictly between any two squares.
+ *
+ * For each pair of squares (from, to), this table contains a bitboard of all
+ * squares strictly between them along a shared rank, file, or diagonal.
+ *
+ * If the squares are not aligned, the corresponding entry is an empty bitboard.
+ *
+ * This table is computed entirely at compile time and is used extensively
+ * in move generation, including:
+ * - pin detection
+ * - check resolution
+ * - slider attack filtering
+ *
+ * The table is indexed as BETWEEN[from][to].
+ */
+constexpr std::array<std::array<Bitboard, Const::BOARD_SIZE>, Const::BOARD_SIZE> BETWEEN = []() constexpr {
+  using namespace Const;
+
+  std::array<std::array<Bitboard, BOARD_SIZE>, BOARD_SIZE> table{};
+
+  for (int from = 0; from < BOARD_SIZE; ++from) {
+    for (int to = 0; to < BOARD_SIZE; ++to) {
+      table[from][to] = ray_between(Square(from, std::in_place), Square(to, std::in_place));
+    }
+  }
+
+  return table;
+}();
+
+}  // namespace Lookups

include/bitbishop/movegen/check_mask.hpp

@@ -0,0 +1,5 @@
+#include <bitbishop/bitboard.hpp>
+#include <bitbishop/board.hpp>
+#include <bitbishop/square.hpp>
+
+Bitboard compute_check_mask(Square king_sq, const Bitboard& checkers, const Board& board);

include/bitbishop/square.hpp

@@ -151,6 +151,70 @@ class Square {
     return static_cast<int>(m_value) / BOARD_WIDTH;
   }
 
+  /**
+   * @brief Tells if two squares lays on the same file.
+   * @return True if two squares lays on the same file, false otherwise.
+   */
+  [[nodiscard]] constexpr bool same_file(const Square& other) const { return this->file() == other.file(); }
+
+  /**
+   * @brief Tells if two squares lays on the same rank.
+   * @return True if two squares lays on the same rank, false otherwise.
+   */
+  [[nodiscard]] constexpr bool same_rank(const Square& other) const { return this->rank() == other.rank(); }
+
+  /**
+   * @brief Checks whether this square lies on the same NE–SW diagonal as another square.
+   *
+   * Two squares are aligned on a NE–SW diagonal if the difference between their
+   * file and rank coordinates is identical. Along such a diagonal, (file − rank)
+   * remains constant.
+   *
+   * This diagonal orientation corresponds to bishop movement in the NE–SW direction
+   * and is commonly used when computing diagonal attacks, pins, and interposition
+   * rays.
+   *
+   * @param other The square to compare against.
+   * @return true if both squares share the same NE–SW diagonal, false otherwise.
+   */
+  [[nodiscard]] constexpr bool same_ne_sw_diag(const Square& other) const {
+    return (this->file() - this->rank()) == (other.file() - other.rank());
+  }
+
+  /**
+   * @brief Checks whether this square lies on the same NW–SE diagonal as another square.
+   *
+   * Two squares are aligned on a NW–SE diagonal if the sum of their file and rank
+   * coordinates is identical. Along such a diagonal, (file + rank) remains constant.
+   *
+   * This diagonal orientation corresponds to bishop movement in the NW–SE direction
+   * and is commonly used when computing diagonal attacks, pins, and interposition
+   * rays.
+   *
+   * @param other The square to compare against.
+   * @return true if both squares share the same NW–SE diagonal, false otherwise.
+   */
+  [[nodiscard]] constexpr bool same_nw_se_diag(const Square& other) const {
+    return (this->file() + this->rank()) == (other.file() + other.rank());
+  }
+
+  /**
+   * @brief Checks whether this square lies on the same diagonal as another square.
+   *
+   * Two squares are on the same diagonal if they share either:
+   * - the same NE–SW diagonal, or
+   * - the same NW–SE diagonal.
+   *
+   * This geometric property is used to determine bishop and queen alignment,
+   * detect pins, compute interposition rays, and build diagonal attack lookups.
+   *
+   * @param other The square to compare against.
+   * @return true if both squares are aligned on a common diagonal, false otherwise.
+   */
+  [[nodiscard]] constexpr bool same_diag(const Square& other) const {
+    return same_ne_sw_diag(other) || same_nw_se_diag(other);
+  }
+
   /**
    * @brief Convert the square to algebraic notation.
    * @return Lowercase string like "a1", "e4", "h8".

src/bitbishop/movegen/check_mask.cpp

@@ -0,0 +1,23 @@
+#include <bitbishop/lookups/between_squares.hpp>
+#include <bitbishop/movegen/check_mask.hpp>
+
+Bitboard compute_check_mask(Square king_sq, const Bitboard& checkers, const Board& board) {
+  if (!checkers) {
+    return Bitboard::Ones();
+  }
+
+  if (checkers.count() > 1) {
+    return Bitboard::Zeros();
+  }
+
+  Square checker_sq = checkers.lsb().value();
+
+  const Bitboard knights_and_pawns =
+      board.knights(Color::WHITE) | board.knights(Color::BLACK) | board.pawns(Color::WHITE) | board.pawns(Color::BLACK);
+  const bool is_knight_or_pawn = knights_and_pawns.test(checker_sq);
+  if (is_knight_or_pawn) {
+    return checkers;
+  }
+
+  return Lookups::ray_between(checker_sq, king_sq) | checkers;
+}

tests/bitbishop/bitboard/test_bb_constructors.cpp

@@ -71,3 +71,25 @@ TEST(BitboardTest, CopyConstructorIsConstexpr) {
   static_assert(cp.value() == 0x00000000000000FFULL, "Copy constructor must be constexpr");
   EXPECT_EQ(cp.value(), 0x00000000000000FFULL);
 }
+
+/**
+ * @test Static Bitboard::Zeros() constructor.
+ * @brief Verifies that the constructor can be evaluated at compile time.
+ */
+TEST(BitboardTest, ZerosStaticConstructor) {
+  constexpr Bitboard bb = Bitboard::Zeros();
+
+  static_assert(bb.value() == 0ULL, "Bitboard::Zeros() static constructor must be constexpr");
+  EXPECT_EQ(bb.value(), 0ULL);
+}
+
+/**
+ * @test Static Bitboard::Ones() constructor.
+ * @brief Verifies that the constructor can be evaluated at compile time.
+ */
+TEST(BitboardTest, OnesStaticConstructor) {
+  constexpr Bitboard bb = Bitboard::Ones();
+
+  static_assert(bb.value() == (~0ULL), "Bitboard::Ones() static constructor must be constexpr");
+  EXPECT_EQ(bb.value(), (~0ULL));
+}