add-fen-loader (#5)

Reviewed-on: #5
Co-authored-by: Josh <josh@joshuaschuett.com>
Co-committed-by: Josh <josh@joshuaschuett.com>

engine/include/bitboard.h

@@ -20,8 +20,16 @@
 #define RANK_7 0x00FF000000000000ULL
 #define RANK_8 0xFF00000000000000ULL
 
-enum Color { WHITE = 0, BLACK = 1 };
+#define SET_BIT(bb, sq)     ((bb) |= (1ULL << (sq)))
-enum Piece { PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING, PIECE_N = 6 };
+#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,20 +39,20 @@ enum Castling {
 };
 
 struct Board {
-    uint64_t bb[2][PIECE_N];    // Each set of pieces get a bitboard for each player.
+    uint64_t pieces[12];    // Each set of pieces get a bitboard for each player.
-    uint64_t occ[2];            // Color occupancy bitboards.
+    uint64_t occ[3];        // Color occupancy bitboards.
-    uint64_t occ_both;          // occ[WHITE] | occ[BLACK]
 
     uint64_t king_square[2];
 
-    uint8_t castling;
+    uint8_t castling_rights;
-    uint64_t ep_square;
+    int ep_square;
     enum Color side_to_move;
 
-    uint16_t halfmove_clock;
+    int halfmove_clock;
-    uint16_t fullmove_number;
+    int fullmove_number;
 };
 
-void create_knight_attack_cache(void);
+void create_knight_attack_cache();
-void create_pawn_attack_cache(void);
+void create_pawn_attack_cache();
-void create_king_attack_cache(void);
+void create_king_attack_cache();
+void print_board();

engine/include/fen.h

@@ -0,0 +1 @@
+int load_fen();

engine/src/bitboard.c

@@ -1,4 +1,5 @@
 #include "bitboard.h"
+#include <stdio.h>
 
 uint64_t PAWN_ATTACKS[2][64];
 uint64_t KNIGHT_ATTACKS[64];
@@ -59,3 +60,44 @@ void create_king_attack_cache(void) {
         KING_ATTACKS[sq] = mask;
     }
 }
+
+static int first_set_index(uint64_t bb) {
+    for (int i = 0; i < 64; ++i) {
+        if ((bb >> i) & 1ULL) return i;
+    }
+    return -1;
+}
+
+static int pop_lsb_index(uint64_t *bb) {
+    if (*bb == 0) return -1;
+    int idx = first_set_index(*bb);
+    // Clears bit.
+    *bb &= ~(1ULL << idx);
+    return idx;
+}
+
+void print_board(const struct Board *b) {
+    static const char PIECE_CH[12] = {
+        'P','N','B','R','Q','K',
+        'p','n','b','r','q','k'
+    };
+
+    char grid[64];
+    for (int i = 0; i < 64; ++i) grid[i] = '.';
+
+    for (int p = 0; p < 12; ++p) {
+        uint64_t bb = b->pieces[p];
+        while (bb) {
+            int sq = pop_lsb_index(&bb);
+            grid[sq] = PIECE_CH[p];
+        }
+    }
+
+    for (int r = 7; r >= 0; --r) {
+        for (int f = 0; f < 8; ++f) {
+            putchar(grid[r * 8 + f]);
+            if (f < 7) putchar(' ');
+        }
+        putchar('\n');
+    }
+}

engine/src/fen.c

@@ -0,0 +1,120 @@
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#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) {
+    // Reset the board first. Weird behavior when not zeroed.
+    memset(board, 0, sizeof *board);
+    board->ep_square = -1;
+
+    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;
+}

engine/src/test.c

@@ -0,0 +1,33 @@
+/**
+    A quick test script to debug and visually inspect functions
+    and operations.
+*/
+
+
+#include <stdio.h>
+#include <string.h>
+#include "bitboard.h"
+#include "fen.h"
+
+
+static int popcount64(uint64_t x){ int c=0; while(x){ x&=x-1; ++c; } return c; }
+static const char NAME[12] = {'P','N','B','R','Q','K','p','n','b','r','q','k'};
+
+
+int main(void) {
+    const char *fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
+
+    struct Board b;
+
+    int rc = load_fen(&b, fen);
+
+    for (int i=0;i<12;i++) printf("%c: %d\n", NAME[i], popcount64(b.pieces[i]));
+
+    if (rc != 0) {
+        fprintf(stderr, "load_fen failed (rc=%d) for FEN:\n%s\n", rc, fen);
+        return 1;
+    }
+
+    print_board(&b);
+    return 0;
+}

makefile

@@ -1,5 +1,3 @@
-# Makefile at project root
-
 CC       := gcc
 CFLAGS   := -O3 -fPIC -Wall -Wextra
 LDFLAGS  := -shared
@@ -9,38 +7,51 @@ INCDIR   := engine/include
 BUILDDIR := build
 LIBNAME  := libchess
 
-UNAME_S  := $(shell uname -s)
+# Exclude test.c from the shared lib build
-ifeq ($(UNAME_S),Darwin)
+SRC := $(filter-out $(SRCDIR)/test.c,$(wildcard $(SRCDIR)/*.c))
-  SOEXT := dylib
-else
-  SOEXT := so
-endif
-
-SRC := $(wildcard $(SRCDIR)/*.c)
 OBJ := $(patsubst $(SRCDIR)/%.c,$(BUILDDIR)/%.o,$(SRC))
-LIB := $(BUILDDIR)/$(LIBNAME).$(SOEXT)
+LIB := $(BUILDDIR)/$(LIBNAME).so
 
-.PHONY: all clean clean-pycache test
+# ---- test executable (engine/src/test.c) ----
+TESTSRC := $(SRCDIR)/test.c
+TESTOBJ := $(BUILDDIR)/test.o
+TESTBIN := $(BUILDDIR)/print_board
+
+.PHONY: all clean test test-exe run
 
 all: $(LIB)
 
 $(BUILDDIR):
 	@mkdir -p $(BUILDDIR)
 
-# compile each .c into build/*.o
 $(BUILDDIR)/%.o: $(SRCDIR)/%.c | $(BUILDDIR)
 	$(CC) $(CFLAGS) -I$(INCDIR) -c $< -o $@
 
-# link shared library
 $(LIB): $(OBJ)
 	$(CC) $(LDFLAGS) -o $@ $^
 
+c-test-exe: $(TESTBIN)
+
+$(TESTOBJ): $(TESTSRC) | $(BUILDDIR)
+	$(CC) -std=c11 -Wall -Wextra -O2 -I$(INCDIR) -c $< -o $@
+
+$(TESTBIN): $(TESTOBJ) $(LIB)
+	$(CC) -O2 -o $@ $(TESTOBJ) -L$(BUILDDIR) -lchess -Wl,-rpath,'$$ORIGIN'
+
+run-c-test: test-exe
+	LD_LIBRARY_PATH=$(BUILDDIR) $(TESTBIN) $(FEN)
+
 clean:
-	@echo "Cleaning Python caches..."
+	@echo "Cleaning build and Python caches..."
+	@rm -rf $(BUILDDIR)
 	@find . -type d -name "__pycache__"    -exec rm -rf {} +
 	@find . -type d -name ".pytest_cache"  -exec rm -rf {} +
 	@find . -type f \( -name "*.pyc" -o -name "*.pyo" \) -delete
 
-# run Python unit tests
+test:
-test: all
+	@$(MAKE) clean
-	python3 -m unittest -v && $(MAKE) clean
+	@$(MAKE) all
+	@python3 -m unittest -v; \
+	status=$$?; \
+	$(MAKE) clean; \
+	exit $$status

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)