Add pawn, knight, and king attack move caches

engine/include/bitboard.h

@@ -0,0 +1,50 @@
+#pragma once
+#include <stdint.h>
+#include <stdbool.h>
+
+#define FILE_A 0x0101010101010101ULL
+#define FILE_B 0x0202020202020202ULL
+#define FILE_C 0x0404040404040404ULL
+#define FILE_D 0x0808080808080808ULL
+#define FILE_E 0x1010101010101010ULL
+#define FILE_F 0x2020202020202020ULL
+#define FILE_G 0x4040404040404040ULL
+#define FILE_H 0x8080808080808080ULL
+
+#define RANK_1 0x00000000000000FFULL
+#define RANK_2 0x000000000000FF00ULL
+#define RANK_3 0x0000000000FF0000ULL
+#define RANK_4 0x00000000FF000000ULL
+#define RANK_5 0x000000FF00000000ULL
+#define RANK_6 0x0000FF0000000000ULL
+#define RANK_7 0x00FF000000000000ULL
+#define RANK_8 0xFF00000000000000ULL
+
+enum Color { WHITE = 0, BLACK = 1 };
+enum Piece { PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING, PIECE_N = 6 };
+
+enum Castling {
+    CASTLE_WK = 1 << 0,
+    CASTLE_WQ = 1 << 1,
+    CASTLE_BK = 1 << 2,
+    CASTLE_BQ = 1 << 3
+};
+
+struct Board {
+    uint64_t bb[2][PIECE_N];    // Each set of pieces get a bitboard for each player.
+    uint64_t occ[2];            // Color occupancy bitboards.
+    uint64_t occ_both;          // occ[WHITE] | occ[BLACK]
+
+    uint64_t king_square[2];
+
+    uint8_t castling;
+    uint64_t ep_square;
+    enum Color side_to_move;
+
+    uint16_t halfmove_clock;
+    uint16_t fullmove_number;
+};
+
+void create_knight_attack_cache(void);
+void create_pawn_attack_cache(void);
+void create_king_attack_cache(void);

engine/src/bitboard.c

@@ -0,0 +1,61 @@
+#include "bitboard.h"
+
+uint64_t PAWN_ATTACKS[2][64];
+uint64_t KNIGHT_ATTACKS[64];
+uint64_t KING_ATTACKS[64];
+
+void create_knight_attack_cache(void) {
+    for (int sq = 0; sq < 64; sq++) {
+        uint64_t b = 1ULL << sq;
+        uint64_t mask = 0ULL;
+
+        mask |= (b & ~FILE_A)  << 15;
+        mask |= (b & ~FILE_H)  << 17;
+        mask |= (b & ~(FILE_A | FILE_B)) << 6;
+        mask |= (b & ~(FILE_G | FILE_H)) << 10;
+        mask |= (b & ~FILE_A)  >> 17;
+        mask |= (b & ~FILE_H)  >> 15;
+        mask |= (b & ~(FILE_A | FILE_B)) >> 10;
+        mask |= (b & ~(FILE_G | FILE_H)) >> 6;
+
+        KNIGHT_ATTACKS[sq] = mask;
+    }
+}
+
+void create_pawn_attack_cache(void) {
+    for (int sq = 0; sq < 64; sq++) {
+        uint64_t b = 1ULL << sq;
+
+        // White: NE (+9), NW (+7), but never from rank 8
+        uint64_t w  = ((b & ~FILE_H & ~RANK_8) << 9) | ((b & ~FILE_A & ~RANK_8) << 7);
+
+        // Black: SE (-7), SW (-9), but never from rank 1
+        uint64_t bl = ((b & ~FILE_H & ~RANK_1) >> 7) | ((b & ~FILE_A & ~RANK_1) >> 9);
+
+        PAWN_ATTACKS[WHITE][sq] = w;
+        PAWN_ATTACKS[BLACK][sq] = bl;
+    }
+}
+
+void create_king_attack_cache(void) {
+    for (int sq = 0; sq < 64; sq++) {
+        uint64_t b = 1ULL << sq;
+        uint64_t mask = 0ULL;
+
+        // North / South
+        mask |= (b & ~RANK_8) << 8;
+        mask |= (b & ~RANK_1) >> 8;
+
+        // East / West
+        mask |= (b & ~FILE_H) << 1;
+        mask |= (b & ~FILE_A) >> 1;
+
+        // Diagonals
+        mask |= (b & ~FILE_A & ~RANK_8) << 7;
+        mask |= (b & ~FILE_H & ~RANK_8) << 9;
+        mask |= (b & ~FILE_A & ~RANK_1) >> 9;
+        mask |= (b & ~FILE_H & ~RANK_1) >> 7;
+
+        KING_ATTACKS[sq] = mask;
+    }
+}