implemented generate_attacks

Author: Hardcode3

include/bitbishop/attacks/generate_attacks.hpp

@@ -0,0 +1,79 @@
+#include <bitbishop/attacks/bishop_attacks.hpp>
+#include <bitbishop/attacks/queen_attacks.hpp>
+#include <bitbishop/attacks/rook_attacks.hpp>
+#include <bitbishop/bitboard.hpp>
+#include <bitbishop/board.hpp>
+#include <bitbishop/color.hpp>
+#include <bitbishop/lookups/king_attacks.hpp>
+#include <bitbishop/lookups/knight_attacks.hpp>
+#include <bitbishop/lookups/pawn_attacks.hpp>
+
+/**
+ * @brief Computes the set of squares attacked by all pieces of a given side.
+ *
+ * Generates a bitboard containing every square currently attacked by the
+ * specified color, based on the current board occupancy. This includes
+ * attacks from the king, knights, pawns, and all sliding pieces (rooks,
+ * bishops, queens).
+ *
+ * The result represents geometric attacks only and does not account for
+ * move legality, pins, discovered checks, or whether the attacking pieces
+ * themselves are defended.
+ *
+ * This function is primarily used for king safety evaluation, including
+ * legal king move generation and castling validation.
+ *
+ * @param board The current board position.
+ * @param enemy The side whose attacks are to be generated.
+ * @return A bitboard of all squares attacked by the given side.
+ */
+Bitboard generate_attacks(const Board& board, Color enemy) {
+  Bitboard attacks = Bitboard::Zeros();
+
+  Bitboard occupied = board.occupied();
+
+  Bitboard king = board.king(enemy);
+  if (king.any()) {
+    Square sq = king.pop_lsb().value();
+    attacks |= Lookups::KING_ATTACKS[sq.value()];
+  }
+
+  Bitboard knights = board.knights(enemy);
+  while (knights) {
+    Square sq = knights.pop_lsb().value();
+    attacks |= Lookups::KNIGHT_ATTACKS[sq.value()];
+  }
+
+  Bitboard pawns = board.pawns(enemy);
+  if (enemy == Color::WHITE) {
+    while (pawns) {
+      Square sq = pawns.pop_lsb().value();
+      attacks |= Lookups::WHITE_PAWN_ATTACKS[sq.value()];
+    }
+  } else {
+    while (pawns) {
+      Square sq = pawns.pop_lsb().value();
+      attacks |= Lookups::BLACK_PAWN_ATTACKS[sq.value()];
+    }
+  }
+
+  Bitboard rooks = board.rooks(enemy);
+  while (rooks) {
+    Square sq = rooks.pop_lsb().value();
+    attacks |= rook_attacks(sq, occupied);
+  }
+
+  Bitboard bishops = board.bishops(enemy);
+  while (bishops) {
+    Square sq = bishops.pop_lsb().value();
+    attacks |= bishop_attacks(sq, occupied);
+  }
+
+  Bitboard queens = board.queens(enemy);
+  while (queens) {
+    Square sq = queens.pop_lsb().value();
+    attacks |= queen_attacks(sq, occupied);
+  }
+
+  return attacks;
+}

include/bitbishop/movegen/king_moves.hpp

@@ -0,0 +1,23 @@
+#include <bitbishop/board.hpp>
+#include <bitbishop/color.hpp>
+#include <bitbishop/lookups/king_attacks.hpp>
+#include <bitbishop/move.hpp>
+#include <utility>
+#include <vector>
+
+void generate_legal_king_moves(std::vector<Move>& moves, const Board& board, Color us, Square king_sq,
+                               const Bitboard& enemy_attacks, const Bitboard& check_mask) {
+  const Bitboard own = board.friendly(us);
+  const Bitboard enemy = board.enemy(us);
+
+  Bitboard candidates = Lookups::KING_ATTACKS[king_sq.value()];
+
+  candidates &= ~own;
+  candidates &= ~enemy_attacks;
+  candidates &= check_mask;
+
+  for (Square to : candidates) {
+    const bool is_capture = enemy.test(to);
+    moves.emplace_back(king_sq, to, std::nullopt, is_capture, false, false);
+  }
+}