From db115213297e58669aee1cc6e428a112f1ea6f45 Mon Sep 17 00:00:00 2001 From: Josh Date: Fri, 15 Aug 2025 15:32:50 -0400 Subject: [PATCH] Add fen parser and board loading --- engine/include/bitboard.h | 25 +++++--- engine/src/fen.c | 116 ++++++++++++++++++++++++++++++++++++++ test/test_fen_loader.py | 104 ++++++++++++++++++++++++++++++++++ 3 files changed, 236 insertions(+), 9 deletions(-) create mode 100644 engine/src/fen.c create mode 100644 test/test_fen_loader.py diff --git a/engine/include/bitboard.h b/engine/include/bitboard.h index 381a371..7e1f246 100644 --- a/engine/include/bitboard.h +++ b/engine/include/bitboard.h @@ -20,8 +20,16 @@ #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 }; +#define SET_BIT(bb, sq) ((bb) |= (1ULL << (sq))) +#define CLEAR_BIT(bb, sq) ((bb) &= ~(1ULL << (sq))) +#define GET_BIT(bb, sq) ((bb) & (1ULL << (sq))) +#define TOGGLE_BIT(bb, sq) ((bb) ^= (1ULL << (sq))) + +enum Color { WHITE = 0, BLACK = 1, BOTH = 2 }; +enum Piece { + P, N, B, R, Q, K, // 0..5 white + p, n, b, r, q, k // 6..11 black +}; enum Castling { CASTLE_WK = 1 << 0, @@ -31,18 +39,17 @@ enum Castling { }; 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 pieces[12]; // Each set of pieces get a bitboard for each player. + uint64_t occ[3]; // Color occupancy bitboards. uint64_t king_square[2]; - uint8_t castling; - uint64_t ep_square; + uint8_t castling_rights; + int ep_square; enum Color side_to_move; - uint16_t halfmove_clock; - uint16_t fullmove_number; + int halfmove_clock; + int fullmove_number; }; void create_knight_attack_cache(void); diff --git a/engine/src/fen.c b/engine/src/fen.c new file mode 100644 index 0000000..bef7b6a --- /dev/null +++ b/engine/src/fen.c @@ -0,0 +1,116 @@ +#include +#include +#include +#include +#include +#include "bitboard.h" + + +int square_index(int file, int rank) { + return rank*8 + file; +} + +int char_to_piece_index(char c) { + switch (c) { + case 'P': return P; case 'N': return N; case 'B': return B; + case 'R': return R; case 'Q': return Q; case 'K': return K; + case 'p': return p; case 'n': return n; case 'b': return b; + case 'r': return r; case 'q': return q; case 'k': return k; + default: return -1; + } +} + +int load_fen(struct Board *board, const char *fen) { + int rank = 7, file = 0; + const char *ptr = fen; + + // Place pieces into the board. + while (*ptr && *ptr != ' ') { + if (isdigit(*ptr)) { + file += *ptr - '0'; + ptr++; + } else if (isalpha(*ptr)) { + if (file >= 8) return -1; + + int piece = char_to_piece_index(*ptr); + + if (piece == -1) return -1; + + SET_BIT(board->pieces[piece], rank * 8 + file); + file++; + ptr++; + } else if (*ptr == '/') { + // Each rank must have exactly 8 files + if (file != 8) return -1; + rank--; + file = 0; + ptr++; + } else { + // Unexpected character + return -1; + } + } + + if (rank != 0 || file != 8) return -1; + ptr++; + + // Side to move. + if (*ptr != 'w' && *ptr != 'b') return -1; + + board->side_to_move = (*ptr == 'w') ? WHITE : BLACK; + ptr += 2; + + // Castling rights. + board->castling_rights = 0; + while (*ptr && *ptr != ' ') { + switch (*ptr) { + case 'K': board->castling_rights |= CASTLE_WK; break; + case 'Q': board->castling_rights |= CASTLE_WQ; break; + case 'k': board->castling_rights |= CASTLE_BK; break; + case 'q': board->castling_rights |= CASTLE_BQ; break; + case '-': break; + default: return -1; + } + ptr++; + } + + if (*ptr != ' ') return -1; + ptr++; + + // En Passant square. + if (*ptr == '-') { + board->ep_square = -1; + ptr += 2; + } else { + if (ptr[0] < 'a' || ptr[0] > 'h' || ptr[1] < '1' || ptr[1] > '8') return -1; + + // Strict FEN: Rank must be 3 or 6. + char rank_char = ptr[1]; + if (rank_char != '3' && rank_char != '6') return -1; + + int file = ptr[0] - 'a'; + int rank = ptr[1] - '1'; + + + + board->ep_square = square_index(file, rank); + ptr += 3; + } + + // Parse halfmove clock for the game. + board->halfmove_clock = atoi(ptr); + while (*ptr && *ptr != ' ') ptr++; + if (*ptr == ' ') ptr++; + + // Parse the fullmove number. + board->fullmove_number = atoi(ptr); + + int num_pieces = 6; + for (int i = 0; i < num_pieces; i++) { + board->occ[WHITE] |= board->pieces[i]; // white + board->occ[BLACK] |= board->pieces[i + 6]; // black + } + board->occ[BOTH] = board->occ[WHITE] | board->occ[BLACK]; + + return 0; +} \ No newline at end of file diff --git a/test/test_fen_loader.py b/test/test_fen_loader.py new file mode 100644 index 0000000..088b0ff --- /dev/null +++ b/test/test_fen_loader.py @@ -0,0 +1,104 @@ +import ctypes +from test.base import ChessLibTestBase +from test.base import BLACK +from test.base import WHITE +from test.base import sq +from test.base import popcount + + +class Board(ctypes.Structure): + _fields_ = [ + ("pieces", ctypes.c_uint64 * 12), + ("occ", ctypes.c_uint64 * 3), + ("king_square", ctypes.c_uint64 * 2), + ("castling_rights", ctypes.c_uint8), + ("ep_square", ctypes.c_int), + ("side_to_move", ctypes.c_int), + ("halfmove_clock", ctypes.c_int), + ("fullmove_number", ctypes.c_int), + ] +class FenTests(ChessLibTestBase): + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.lib.load_fen.argtypes = [ctypes.POINTER(Board), ctypes.c_char_p] + cls.lib.load_fen.restype = ctypes.c_int + + + def rank_mask(self, r): + return sum(1 << (r*8 + f) for f in range(8)) + + + def test_startpos_fields_and_occupancies(self): + fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1" + b = Board() + + self.lib.load_fen(ctypes.byref(b), fen.encode("ascii")) + + self.assertEqual(b.side_to_move, WHITE) + self.assertEqual(b.castling_rights, 0b1111) # KQkq + self.assertEqual(b.ep_square, -1) + self.assertEqual(b.halfmove_clock, 0) + self.assertEqual(b.fullmove_number, 1) + + white_expected = self.rank_mask(0) | self.rank_mask(1) # ranks 1 & 2 + black_expected = self.rank_mask(6) | self.rank_mask(7) # ranks 7 & 8 + self.assertEqual(int(b.occ[WHITE]), white_expected) + self.assertEqual(int(b.occ[BLACK]), black_expected) + self.assertEqual(int(b.occ[2]), white_expected | black_expected) + + self.assertEqual(popcount(int(b.occ[WHITE])), 16) + self.assertEqual(popcount(int(b.occ[BLACK])), 16) + + + def test_castling_flags_parsing(self): + fen = "r3k2r/8/8/8/8/8/8/R3K2R b KQkq - 5 42" + b = Board() + self.lib.load_fen(ctypes.byref(b), fen.encode("ascii")) + self.assertEqual(b.side_to_move, BLACK) + self.assertEqual(b.castling_rights, 0b1111) + self.assertEqual(b.halfmove_clock, 5) + self.assertEqual(b.fullmove_number, 42) + + + def test_en_passant_targets(self): + # EP at e6, black to move + fen1 = "8/8/8/3pP3/8/8/8/8 b KQkq e6 0 1" + + b1 = Board() + self.lib.load_fen(ctypes.byref(b1), fen1.encode("ascii")) + self.assertEqual(b1.side_to_move, BLACK) + self.assertEqual(b1.ep_square, sq("e6")) + + # EP at d3, white to move + fen2 = "8/8/8/8/3Pp3/8/8/8 w KQkq d3 12 7" + b2 = Board() + self.lib.load_fen(ctypes.byref(b2), fen2.encode("ascii")) + self.assertEqual(b2.side_to_move, WHITE) + self.assertEqual(b2.ep_square, sq("d3")) + + + def test_malformed_piece_field(self): + # rank sums wrong (9 on a rank), bad char, missing separators + bad = [ + "9/8/8/8/8/8/8/8 w - - 0 1", + "8/8/8/8/8/8/8/7x w - - 0 1", + "8/8/8/8/8/8/8/8w - - 0 1", + ] + for fen in bad: + b = Board() + r = self.lib.load_fen(ctypes.byref(b), fen.encode("ascii")) + self.assertEqual(r, -1) + + + def test_malformed_side_castling_ep(self): + bad = [ + "8/8/8/8/8/8/8/8 x - - 0 1", # bad side + "8/8/8/8/8/8/8/8 w KX - 0 1", # bad castling char + "8/8/8/8/8/8/8/8 w - j9 0 1", # bad EP square + "8/8/8/8/8/8/8/8 w - e4 0 1", # EP not rank 3/6 (your code allows any 1..8; consider tightening) + ] + for fen in bad: + b = Board() + r = self.lib.load_fen(ctypes.byref(b), fen.encode("ascii")) + self.assertEqual(r, -1) \ No newline at end of file