Josh
c02ec7875d
All checks were successful
Python tests (make) / test (push) Successful in 10s
Reviewed-on: #5 Co-authored-by: Josh <josh@joshuaschuett.com> Co-committed-by: Josh <josh@joshuaschuett.com>
120 lines
3.2 KiB
C
120 lines
3.2 KiB
C
#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;
|
|
} |