olemorud/chess-engine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

almost working now

Browse Source
This commit is contained in:
Ole Morud
2025-12-15 22:51:10 +01:00
parent 25705d6cd6
commit 2f65828ae2
4 changed files with 1487 additions and 529 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
Makefile
View File

@@ -1,16 +1,27 @@
CFLAGS := -std=c23 -g
BUILD ?= debug
CC := clang
CFLAGS.gcc.release := -O3
CFLAGS.gcc.debug := -ggdb -O0 -fsanitize=address
CFLAGS.gcc := -std=c23 -Wall -Wextra -Wconversion -Wno-unused-function
CFLAGS.clang.release := -O3
CFLAGS.clang.debug := -ggdb -O0
CFLAGS.clang := -std=c23 -Wall -Wextra -Wconversion -Wno-unused-function -Wimplicit-int-conversion
CFLAGS := $(CFLAGS.$(CC)) $(CFLAGS.$(CC).$(BUILD))
all: tests
codegen: codegen.c
$(CC) -o $@ $(CFLAGS) -DCODEGEN $^
$(CC) -o $@ $(CFLAGS) $^
mbb_rook.h: codegen
#./codegen
./codegen
mbb_bishop.h: codegen
#./codegen
./codegen
tests: tests.c | mbb_rook.h mbb_bishop.h base.h
$(CC) -o $@ $(CFLAGS) $^
tests: tests.c mbb_rook.h mbb_bishop.h base.h
$(CC) -o $@ $(CFLAGS) tests.c

1780
base.h
View File

File diff suppressed because it is too large Load Diff

147
codegen.c
View File

@@ -1,104 +1,8 @@
#define CODEGEN
#include "base.h"
#include <stdlib.h>
#include <stdio.h>
static bitboard bishop_attacks_from_index_slow(enum square_index sq, bitboard occ)
{
const enum rank_index rank = index_to_rank(sq);
const enum file_index file = index_to_file(sq);
bitboard atk = 0ULL;
/* following loops assume rank and file types are unsigned, which relies on C23 enums */
_Static_assert(((enum rank_index)0) - ((enum rank_index)1) > ((enum rank_index)0));
_Static_assert(((enum file_index)0) - ((enum file_index)1) > ((enum file_index)0));
enum rank_index walk_rank;
enum file_index walk_file;
for (walk_rank = rank+1, walk_file = file+1;
walk_rank <= RANK_INDEX_8 && walk_file <= FILE_INDEX_H;
++walk_rank, ++walk_file) {
const bitboard sq = SQ_MASK_FROM_RF(walk_rank, walk_file);
atk |= sq;
if (occ & sq) {
break;
}
}
for (walk_rank = rank+1, walk_file = file-1;
walk_rank <= RANK_INDEX_8 && walk_file <= FILE_INDEX_H;
++walk_rank, --walk_file) {
const bitboard sq = SQ_MASK_FROM_RF(walk_rank, walk_file);
atk |= sq;
if (occ & sq) {
break;
}
}
for (walk_rank = rank-1, walk_file = file+1;
walk_rank <= RANK_INDEX_8 && walk_file <= FILE_INDEX_H;
--walk_rank, ++walk_file) {
const bitboard sq = SQ_MASK_FROM_RF(walk_rank, walk_file);
atk |= sq;
if (occ & sq) {
break;
}
}
for (walk_rank = rank-1, walk_file = file-1;
walk_rank <= RANK_INDEX_8 && walk_file <= FILE_INDEX_H;
--walk_rank, --walk_file) {
const bitboard sq = SQ_MASK_FROM_RF(walk_rank, walk_file);
atk |= sq;
if (occ & sq) {
break;
}
}
return atk;
}
static bitboard rook_attacks_from_index_slow(enum square_index sq, bitboard occ)
{
const enum rank_index rank = index_to_rank(sq);
const enum file_index file = index_to_file(sq);
bitboard atk = 0ULL;
/* following loops assume rank and file types are unsigned, which relies on C23 enums */
_Static_assert(((enum rank_index)0) - ((enum rank_index)1) > ((enum rank_index)0));
_Static_assert(((enum file_index)0) - ((enum file_index)1) > ((enum file_index)0));
for (enum rank_index walk_rank = rank+1; walk_rank <= RANK_INDEX_8; ++walk_rank) {
const bitboard sq = SQ_MASK_FROM_RF(walk_rank, file);
atk |= sq;
if (occ & sq) {
break;
}
}
for (enum rank_index walk_rank = rank-1; walk_rank <= RANK_INDEX_8; --walk_rank) {
const bitboard sq = SQ_MASK_FROM_RF(walk_rank, file);
atk |= sq;
if (occ & sq) {
break;
}
}
for (enum file_index walk_file = file+1; walk_file <= FILE_INDEX_H; ++walk_file) {
const bitboard sq = SQ_MASK_FROM_RF(rank, walk_file);
atk |= sq;
if (occ & sq) {
break;
}
}
for (enum file_index walk_file = file-1; walk_file <= FILE_INDEX_H; --walk_file) {
const bitboard sq = SQ_MASK_FROM_RF(rank, walk_file);
atk |= sq;
if (occ & sq) {
break;
}
}
return atk;
}
/* gets the next number with the same bitcount, unless it overflows, in which
* it returns the first number with popcount+1 */
uint64_t next_magic(uint64_t seed) {
@@ -116,21 +20,6 @@ uint64_t next_magic(uint64_t seed) {
return seed;
}
uint64_t rand64() {
union {
uint64_t v;
uint16_t vs[4];
} x = {
.vs = {
(uint16_t)rand(),
(uint16_t)rand(),
(uint16_t)rand(),
(uint16_t)rand(),
}
};
return x.v;
}
int main()
{
@@ -146,6 +35,8 @@ int main()
index bishop_relevant_bits[9] = {0};
size_t bishop_relevant_bits_count = 0;
bitboard between_lookup[SQ_INDEX_COUNT][SQ_INDEX_COUNT];
for (enum square_index sq_index = SQ_INDEX_BEGIN; sq_index < SQ_INDEX_COUNT; ++sq_index) {
enum file_index file = index_to_file(sq_index);
enum rank_index rank = index_to_rank(sq_index);
@@ -183,7 +74,7 @@ int main()
occ |= ((test >> i) & 1ULL) << rook_relevant_bits[i];
}
atk = rook_attacks_from_index_slow(sq_index, occ);
atk = rook_attacks_from_index(sq_index, occ);
const size_t hash = ((occ * magic) >> (64ULL-12));
@@ -239,7 +130,7 @@ int main()
occ |= ((test >> i) & 1ULL) << bishop_relevant_bits[i];
}
atk = bishop_attacks_from_index_slow(sq_index, occ);
atk = bishop_attacks_from_index(sq_index, occ);
const size_t hash = ((occ * magic) >> (64ULL-9));
@@ -258,6 +149,16 @@ int main()
next_bishop_magic:
}
}
/* BETWEEN TABLE
* ===================== */
{
for (enum square_index i = SQ_INDEX_BEGIN; i < SQ_INDEX_COUNT; ++i) {
for (enum square_index j = SQ_INDEX_BEGIN; j < SQ_INDEX_COUNT; ++j) {
between_lookup[i][j] = between_mask(i, j);
}
}
}
}
/* --- write to files --- */
@@ -336,6 +237,24 @@ int main()
fprintf(f,"};\n");
}
{ /* between table */
FILE* f = fopen("between_lookup.h", "w");
if (!f) {
perror("fopen");
exit(EXIT_FAILURE);
}
fprintf(f, "static const bitboard between_lookup[SQ_INDEX_COUNT][SQ_INDEX_COUNT] = {\n");
for (enum square_index i = SQ_INDEX_BEGIN; i < SQ_INDEX_COUNT; ++i) {
fprintf(f, "[%s] = {\n", square_index_str[i]);
for (enum square_index j = SQ_INDEX_BEGIN; j < SQ_INDEX_COUNT; ++j) {
fprintf(f, "0x%016"BITBOARD_FMT_X"ULL, \n", between_lookup[i][j]);
}
fprintf(f, "\n},\n");
}
fprintf(f,"};\n");
}
#undef TAB
#undef NL
}

74
tests.c
View File

@@ -357,9 +357,11 @@ static void test_bishops(void)
printf("\nAll bishop_attacks_from_index tests passed.\n");
}
int main()
{
printf("sizeof board: %zu\n", sizeof (struct board));
test_rooks();
test_bishops();
@@ -369,37 +371,61 @@ int main()
fprintf(stdout, "\033[0m\n"); /* reset background color */
struct board board = BOARD_INITIAL;
enum player player = PLAYER_WHITE;
enum square_index pieces[SQ_INDEX_COUNT] = {0};
struct move moves[MOVE_MAX] = {0};
for (int i = 0; i < 40; ++i) {
board_print_threats(&board, stdout, player);
//board_load_fen_unsafe(&board, "1n1q1rk1/r1p2P2/1p1pp2p/pB2P3/2P5/PPN5/6b1/3QK1NR b - - 0 1");
//board_print_fen(&board, stdout);
board_print(&board.pos, NULL, stdout);
const size_t piece_count = all_player_pieces(&board, player, pieces);
struct move moves[MOVE_MAX];
if (piece_count == 0) {
printf("no pieces for %s, aborting\n", player_str[player]);
break;
}
size_t move_count;
for (size_t i = 0; i < piece_count; ++i) {
move_count = all_moves_from(&board, player, pieces[i], moves);
if (move_count > 0) {
board_move_piece(&board, player, moves[0]);
break;
}
}
for (int turn = 0; turn < 200; ++turn) {
size_t move_count = 0;
all_moves(&board.pos, board.pos.player, &move_count, moves);
if (move_count == 0) {
printf("no moves for %s, aborting\n", player_str[player]);
printf("no moves for %s, aborting\n", player_str[board.pos.player]);
board_print_threats(&board.pos, stdout, NULL);
board.pos.player = opposite_player(board.pos.player);
board_print_threats(&board.pos, stdout, NULL);
break;
}
player = opposite_player(player);
//struct move move = moves[0];
struct move move = search(&board, board.pos.player, 6);
usleep(300000);
printf("move %d: {\n"
" .from = %s, (%s)\n"
" .to = %s,\n"
" .mask = ",
turn,
square_index_display[move.from],
piece_str[board.mailbox[move.from]],
square_index_display[move.to]
);
if (move.attr & MATTR_CAPTURE) printf("MATTR_CAPTURE ");
if (move.attr & MATTR_PROMOTE) printf("MATTR_PROMOTE ");
printf("\n}\n");
enum move_result const r = board_move_2(&board, move);
#if 1
board_print(&board.pos, &move, stdout);
#endif
if (r == MR_STALEMATE) {
printf("stalemate\n");
break;
}
if (board.pos.pieces[PLAYER_WHITE][PIECE_KING] == 0ULL) {
printf("white king gone!!\n");
exit(1);
}
if (board.pos.pieces[PLAYER_BLACK][PIECE_KING] == 0ULL) {
printf("black king gone!!\n");
exit(1);
}
//usleep(1000000);
}
return EXIT_SUCCESS;