Implementing generate attackers function (#74)

* added a board constructor using fen starting position

* implemented generate_attacks

* removed file that was not supposed to be added to the PR

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/board.hpp

@@ -63,6 +63,10 @@ class Board {
    */
   Board(const std::string& fen);
 
+  [[nodiscard]] static Board StartingPosition() noexcept {
+    return {"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"};
+  }
+
   [[nodiscard]] static Board Empty() noexcept { return {"8/8/8/8/8/8/8/8 w KQkq - 0 1"}; }
 
   /**