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

major rework

Browse Source
This commit is contained in:
Ole Morud
2026-01-03 16:22:42 +01:00
parent 4998a057f5
commit 716527fa8f
14 changed files with 2431 additions and 2261 deletions
Download Patch File Download Diff File Expand all files Collapse all files

359
tests.c
View File

@@ -1,4 +1,5 @@
#define USE_PRINTF
#define _XOPEN_SOURCE 500
#include <unistd.h> /* usleep */
#include <pthread.h>
@@ -12,10 +13,12 @@
/* Tests are mostly generated by ChatGPT */
#define test_expect(expr) if (!(expr)) { fprintf(stderr, "test failed: expected <" #expr ">\n"); exit(EXIT_FAILURE); }
static void print_rook_test(const char *label,
enum square_index sq,
bitboard all_occ,
bitboard own_occ)
Sq8 sq,
Bb64 all_occ,
Bb64 own_occ)
{
printf("\n%s\n", label);
printf("All occ:\n");
@@ -23,7 +26,7 @@ static void print_rook_test(const char *label,
printf("Own occ:\n");
bitboard_print(own_occ, stdout);
const bitboard attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
const Bb64 attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
printf("Rook attacks:\n");
bitboard_print(attacks, stdout);
}
@@ -31,84 +34,84 @@ static void print_rook_test(const char *label,
static void test_rooks()
{
{
const enum square_index sq = SQ_INDEX_A1;
const bitboard rook = SQ_MASK_A1;
const bitboard all_occ = rook;
const bitboard own_occ = rook;
const Sq8 sq = SQ_A1;
const Bb64 rook = SQMASK_A1;
const Bb64 all_occ = rook;
const Bb64 own_occ = rook;
/* Expected: full rank 1 and file A, except A1 */
bitboard expected = (FILE_MASK_A | RANK_MASK_1) & ~SQ_MASK_A1;
Bb64 expected = (FILE_MASK_A | RANK_MASK_1) & ~SQMASK_A1;
print_rook_test("Test 1: Rook at A1, empty board", sq, all_occ, own_occ);
const bitboard attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
assert(attacks == expected);
const Bb64 attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
test_expect(attacks == expected);
}
{
const enum square_index sq = SQ_INDEX_A1;
const bitboard rook = SQ_MASK_A1;
const bitboard own_block = SQ_MASK_A2 | SQ_MASK_B1;
const bitboard all_occ = rook | own_block;
const bitboard own_occ = all_occ;
const Sq8 sq = SQ_A1;
const Bb64 rook = SQMASK_A1;
const Bb64 own_block = SQMASK_A2 | SQMASK_B1;
const Bb64 all_occ = rook | own_block;
const Bb64 own_occ = all_occ;
/* Expected: no legal moves (immediately blocked both directions) */
const bitboard expected = 0ULL;
const Bb64 expected = 0ULL;
print_rook_test("Test 2: Rook at A1, own blockers A2, B1", sq, all_occ, own_occ);
const bitboard attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
assert(attacks == expected);
const Bb64 attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
test_expect(attacks == expected);
}
{
const enum square_index sq = SQ_INDEX_A1;
const bitboard rook = SQ_MASK_A1;
const bitboard enemies = SQ_MASK_A3 | SQ_MASK_C1;
const bitboard all_occ = rook | enemies;
const bitboard own_occ = rook;
const Sq8 sq = SQ_A1;
const Bb64 rook = SQMASK_A1;
const Bb64 enemies = SQMASK_A3 | SQMASK_C1;
const Bb64 all_occ = rook | enemies;
const Bb64 own_occ = rook;
/*
* Expected:
* - Along file A: A2, A3 (enemy at A3 is capturable, stop there)
* - Along rank 1: B1, C1 (enemy at C1 capturable, stop there)
*/
bitboard expected = 0ULL;
expected |= SQ_MASK_A2 | SQ_MASK_A3;
expected |= SQ_MASK_B1 | SQ_MASK_C1;
Bb64 expected = 0ULL;
expected |= SQMASK_A2 | SQMASK_A3;
expected |= SQMASK_B1 | SQMASK_C1;
print_rook_test("Test 3: Rook at A1, enemy blockers A3, C1", sq, all_occ, own_occ);
const bitboard attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
assert(attacks == expected);
const Bb64 attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
test_expect(attacks == expected);
}
/* Rook Test 6: center rook on empty board */
{
const enum square_index sq = SQ_INDEX_E5;
const bitboard rook = SQ_MASK_E5;
const bitboard all_occ = rook;
const bitboard own_occ = rook;
const Sq8 sq = SQ_E5;
const Bb64 rook = SQMASK_E5;
const Bb64 all_occ = rook;
const Bb64 own_occ = rook;
/* Full rank 5 and file E, except E5 itself */
bitboard expected = (FILE_MASK_E | RANK_MASK_5) & ~SQ_MASK_E5;
Bb64 expected = (FILE_MASK_E | RANK_MASK_5) & ~SQMASK_E5;
print_rook_test("Rook Test 6: E5, empty board", sq, all_occ, own_occ);
bitboard attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
assert(attacks == expected);
Bb64 attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
test_expect(attacks == expected);
}
/* Rook Test 7: center rook, mixed blockers on rays */
{
const enum square_index sq = SQ_INDEX_E5;
const bitboard rook = SQ_MASK_E5;
const Sq8 sq = SQ_E5;
const Bb64 rook = SQMASK_E5;
/* Friendly: E7 and C5; Enemy: E3 and H5 */
const bitboard friends = rook | SQ_MASK_E7 | SQ_MASK_C5;
const bitboard enemies = SQ_MASK_E3 | SQ_MASK_H5;
const bitboard all_occ = friends | enemies;
const bitboard own_occ = friends;
const Bb64 friends = rook | SQMASK_E7 | SQMASK_C5;
const Bb64 enemies = SQMASK_E3 | SQMASK_H5;
const Bb64 all_occ = friends | enemies;
const Bb64 own_occ = friends;
/*
* From E5:
@@ -117,73 +120,73 @@ static void test_rooks()
* Left: D5, then friendly C5 (stop before C5)
* Right:F5, G5, H5 (enemy, included, then stop)
*/
bitboard expected = 0ULL;
expected |= SQ_MASK_E6;
expected |= SQ_MASK_E4 | SQ_MASK_E3;
expected |= SQ_MASK_D5;
expected |= SQ_MASK_F5 | SQ_MASK_G5 | SQ_MASK_H5;
Bb64 expected = 0ULL;
expected |= SQMASK_E6;
expected |= SQMASK_E4 | SQMASK_E3;
expected |= SQMASK_D5;
expected |= SQMASK_F5 | SQMASK_G5 | SQMASK_H5;
print_rook_test("Rook Test 7: E5, friends E7/C5, enemies E3/H5", sq, all_occ, own_occ);
bitboard attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
assert(attacks == expected);
Bb64 attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
test_expect(attacks == expected);
}
/* Rook Test 8: edge rook on empty board (top edge, not corner) */
{
const enum square_index sq = SQ_INDEX_C8;
const bitboard rook = SQ_MASK_C8;
const bitboard all_occ = rook;
const bitboard own_occ = rook;
const Sq8 sq = SQ_C8;
const Bb64 rook = SQMASK_C8;
const Bb64 all_occ = rook;
const Bb64 own_occ = rook;
/*
* From C8:
* Down file C: C7..C1
* Across rank 8: A8,B8,D8,E8,F8,G8,H8
*/
bitboard expected = 0ULL;
expected |= (FILE_MASK_C & ~SQ_MASK_C8);
expected |= (RANK_MASK_8 & ~SQ_MASK_C8);
Bb64 expected = 0ULL;
expected |= (FILE_MASK_C & ~SQMASK_C8);
expected |= (RANK_MASK_8 & ~SQMASK_C8);
print_rook_test("Rook Test 8: C8, empty board", sq, all_occ, own_occ);
bitboard attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
assert(attacks == expected);
Bb64 attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
test_expect(attacks == expected);
}
/* Rook Test 9: rook completely boxed in by friendly orthogonal neighbors */
{
const enum square_index sq = SQ_INDEX_D4;
const bitboard rook = SQ_MASK_D4;
const bitboard friends = rook |
SQ_MASK_D5 | SQ_MASK_D3 |
SQ_MASK_C4 | SQ_MASK_E4;
const bitboard enemies = 0ULL;
const bitboard all_occ = friends | enemies;
const bitboard own_occ = friends;
const Sq8 sq = SQ_D4;
const Bb64 rook = SQMASK_D4;
const Bb64 friends = rook |
SQMASK_D5 | SQMASK_D3 |
SQMASK_C4 | SQMASK_E4;
const Bb64 enemies = 0ULL;
const Bb64 all_occ = friends | enemies;
const Bb64 own_occ = friends;
/* All four rays are immediately blocked by own pieces */
const bitboard expected = 0ULL;
const Bb64 expected = 0ULL;
print_rook_test("Rook Test 9: D4, boxed by own pieces at D5/D3/C4/E4",
sq, all_occ, own_occ);
bitboard attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
assert(attacks == expected);
Bb64 attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
test_expect(attacks == expected);
}
/* Rook Test 10: rook on file with non-interfering off-ray pieces */
{
const enum square_index sq = SQ_INDEX_A4;
const bitboard rook = SQ_MASK_A4;
const Sq8 sq = SQ_A4;
const Bb64 rook = SQMASK_A4;
/* Pieces placed off the rook's rank/file; they should have no effect */
const bitboard off_ray = SQ_MASK_C1 | SQ_MASK_F6 | SQ_MASK_H8;
const Bb64 off_ray = SQMASK_C1 | SQMASK_F6 | SQMASK_H8;
(void)off_ray;
const bitboard friends = rook | SQ_MASK_C1;
const bitboard enemies = SQ_MASK_F6 | SQ_MASK_H8;
const bitboard all_occ = friends | enemies;
const bitboard own_occ = friends;
const Bb64 friends = rook | SQMASK_C1;
const Bb64 enemies = SQMASK_F6 | SQMASK_H8;
const Bb64 all_occ = friends | enemies;
const Bb64 own_occ = friends;
/*
* From A4:
@@ -191,22 +194,21 @@ static void test_rooks()
* Rank 4: B4..H4
* Pieces not on file A or rank 4 must not change attacks.
*/
bitboard expected = 0ULL;
expected |= (FILE_MASK_A | RANK_MASK_4) & ~SQ_MASK_A4;
Bb64 expected = 0ULL;
expected |= (FILE_MASK_A | RANK_MASK_4) & ~SQMASK_A4;
print_rook_test("Rook Test 10: A4, random off-ray pieces C1/F6/H8",
sq, all_occ, own_occ);
bitboard attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
assert(attacks == expected);
Bb64 attacks = rook_attacks_from_index(sq, all_occ) & ~own_occ;
test_expect(attacks == expected);
}
}
static void print_bishop_test(const char *label,
enum square_index sq,
bitboard all_occ,
bitboard own_occ)
Sq8 sq,
Bb64 all_occ,
Bb64 own_occ)
{
fprintf(stderr, "\n%s\n", label);
fprintf(stderr, "All occ:\n");
@@ -214,7 +216,7 @@ static void print_bishop_test(const char *label,
fprintf(stderr, "Own occ:\n");
bitboard_print(own_occ, stderr);
const bitboard attacks = bishop_attacks_from_index(sq, all_occ) & ~own_occ;
const Bb64 attacks = bishop_attacks_from_index(sq, all_occ) & ~own_occ;
fprintf(stderr, "Bishop attacks:\n");
bitboard_print(attacks, stderr);
}
@@ -223,10 +225,10 @@ static void test_bishops(void)
{
/* Test 1: Bishop at D4 on empty board (only bishop present) */
{
const enum square_index sq = SQ_INDEX_D4;
const bitboard bishop = SQ_MASK_D4;
const bitboard all_occ = bishop;
const bitboard own_occ = bishop;
const Sq8 sq = SQ_D4;
const Bb64 bishop = SQMASK_D4;
const Bb64 all_occ = bishop;
const Bb64 own_occ = bishop;
/*
* Expected diagonals from D4:
@@ -235,24 +237,24 @@ static void test_bishops(void)
* SE: E3, F2, G1
* SW: C3, B2, A1
*/
bitboard expected = 0ULL;
expected |= SQ_MASK_E5 | SQ_MASK_F6 | SQ_MASK_G7 | SQ_MASK_H8;
expected |= SQ_MASK_C5 | SQ_MASK_B6 | SQ_MASK_A7;
expected |= SQ_MASK_E3 | SQ_MASK_F2 | SQ_MASK_G1;
expected |= SQ_MASK_C3 | SQ_MASK_B2 | SQ_MASK_A1;
Bb64 expected = 0ULL;
expected |= SQMASK_E5 | SQMASK_F6 | SQMASK_G7 | SQMASK_H8;
expected |= SQMASK_C5 | SQMASK_B6 | SQMASK_A7;
expected |= SQMASK_E3 | SQMASK_F2 | SQMASK_G1;
expected |= SQMASK_C3 | SQMASK_B2 | SQMASK_A1;
print_bishop_test("Bishop Test 1: D4, empty board", sq, all_occ, own_occ);
const bitboard attacks = bishop_attacks_from_index(sq, all_occ) & ~own_occ;
assert(attacks == expected);
const Bb64 attacks = bishop_attacks_from_index(sq, all_occ) & ~own_occ;
test_expect(attacks == expected);
}
/* Test 2: Bishop at C1 on empty board (only bishop present) */
{
const enum square_index sq = SQ_INDEX_C1;
const bitboard bishop = SQ_MASK_C1;
const bitboard all_occ = bishop;
const bitboard own_occ = bishop;
const Sq8 sq = SQ_C1;
const Bb64 bishop = SQMASK_C1;
const Bb64 all_occ = bishop;
const Bb64 own_occ = bishop;
/*
* From C1, diagonals:
@@ -260,25 +262,25 @@ static void test_bishops(void)
* NW: B2, A3
* SE / SW: none (edge of board)
*/
bitboard expected = 0ULL;
expected |= SQ_MASK_D2 | SQ_MASK_E3 | SQ_MASK_F4 |
SQ_MASK_G5 | SQ_MASK_H6;
expected |= SQ_MASK_B2 | SQ_MASK_A3;
Bb64 expected = 0ULL;
expected |= SQMASK_D2 | SQMASK_E3 | SQMASK_F4 |
SQMASK_G5 | SQMASK_H6;
expected |= SQMASK_B2 | SQMASK_A3;
print_bishop_test("Bishop Test 2: C1, empty board", sq, all_occ, own_occ);
const bitboard attacks = bishop_attacks_from_index(sq, all_occ) & ~own_occ;
assert(attacks == expected);
const Bb64 attacks = bishop_attacks_from_index(sq, all_occ) & ~own_occ;
test_expect(attacks == expected);
}
/* Test 3: Bishop at D4, friendly blockers at F6 and B2 (no enemies) */
{
const enum square_index sq = SQ_INDEX_D4;
const bitboard bishop = SQ_MASK_D4;
const bitboard friends = bishop | SQ_MASK_F6 | SQ_MASK_B2;
const bitboard enemies = 0ULL;
const bitboard all_occ = friends | enemies;
const bitboard own_occ = friends;
const Sq8 sq = SQ_D4;
const Bb64 bishop = SQMASK_D4;
const Bb64 friends = bishop | SQMASK_F6 | SQMASK_B2;
const Bb64 enemies = 0ULL;
const Bb64 all_occ = friends | enemies;
const Bb64 own_occ = friends;
/*
* From D4:
@@ -287,26 +289,26 @@ static void test_bishops(void)
* NW: C5, B6, A7 (no blockers)
* SE: E3, F2, G1 (no blockers)
*/
bitboard expected = 0ULL;
expected |= SQ_MASK_E5;
expected |= SQ_MASK_C3;
expected |= SQ_MASK_C5 | SQ_MASK_B6 | SQ_MASK_A7;
expected |= SQ_MASK_E3 | SQ_MASK_F2 | SQ_MASK_G1;
Bb64 expected = 0ULL;
expected |= SQMASK_E5;
expected |= SQMASK_C3;
expected |= SQMASK_C5 | SQMASK_B6 | SQMASK_A7;
expected |= SQMASK_E3 | SQMASK_F2 | SQMASK_G1;
print_bishop_test("Bishop Test 3: D4, friendly blockers F6, B2", sq, all_occ, own_occ);
const bitboard attacks = bishop_attacks_from_index(sq, all_occ) & ~own_occ;
assert(attacks == expected);
const Bb64 attacks = bishop_attacks_from_index(sq, all_occ) & ~own_occ;
test_expect(attacks == expected);
}
/* Test 4: Bishop at D4, enemy blockers at F6 and B2 (no other friends) */
{
const enum square_index sq = SQ_INDEX_D4;
const bitboard bishop = SQ_MASK_D4;
const bitboard friends = bishop;
const bitboard enemies = SQ_MASK_F6 | SQ_MASK_B2;
const bitboard all_occ = friends | enemies;
const bitboard own_occ = friends;
const Sq8 sq = SQ_D4;
const Bb64 bishop = SQMASK_D4;
const Bb64 friends = bishop;
const Bb64 enemies = SQMASK_F6 | SQMASK_B2;
const Bb64 all_occ = friends | enemies;
const Bb64 own_occ = friends;
/*
* From D4:
@@ -315,27 +317,27 @@ static void test_bishops(void)
* NW: C5, B6, A7
* SE: E3, F2, G1
*/
bitboard expected = 0ULL;
expected |= SQ_MASK_E5 | SQ_MASK_F6;
expected |= SQ_MASK_C3 | SQ_MASK_B2;
expected |= SQ_MASK_C5 | SQ_MASK_B6 | SQ_MASK_A7;
expected |= SQ_MASK_E3 | SQ_MASK_F2 | SQ_MASK_G1;
Bb64 expected = 0ULL;
expected |= SQMASK_E5 | SQMASK_F6;
expected |= SQMASK_C3 | SQMASK_B2;
expected |= SQMASK_C5 | SQMASK_B6 | SQMASK_A7;
expected |= SQMASK_E3 | SQMASK_F2 | SQMASK_G1;
print_bishop_test("Bishop Test 4: D4, enemy blockers F6, B2", sq, all_occ, own_occ);
const bitboard attacks = bishop_attacks_from_index(sq, all_occ) & ~own_occ;
assert(attacks == expected);
const Bb64 attacks = bishop_attacks_from_index(sq, all_occ) & ~own_occ;
test_expect(attacks == expected);
}
/* Test 5: Bishop at D4, mixed friend/enemy + another friendly bishop elsewhere */
{
const enum square_index sq = SQ_INDEX_D4;
const bitboard bishop1 = SQ_MASK_D4; /* tested bishop */
const bitboard bishop2 = SQ_MASK_F4; /* another friendly bishop */
const bitboard friends = bishop1 | bishop2 | SQ_MASK_F6;
const bitboard enemies = SQ_MASK_B2;
const bitboard all_occ = friends | enemies;
const bitboard own_occ = friends;
const Sq8 sq = SQ_D4;
const Bb64 bishop1 = SQMASK_D4; /* tested bishop */
const Bb64 bishop2 = SQMASK_F4; /* another friendly bishop */
const Bb64 friends = bishop1 | bishop2 | SQMASK_F6;
const Bb64 enemies = SQMASK_B2;
const Bb64 all_occ = friends | enemies;
const Bb64 own_occ = friends;
/*
* From D4:
@@ -345,24 +347,23 @@ static void test_bishops(void)
* SE: E3, F2, G1
* Bishop at F4 is irrelevant; it does not sit on a diagonal from D4.
*/
bitboard expected = 0ULL;
expected |= SQ_MASK_E5;
expected |= SQ_MASK_C3 | SQ_MASK_B2;
expected |= SQ_MASK_C5 | SQ_MASK_B6 | SQ_MASK_A7;
expected |= SQ_MASK_E3 | SQ_MASK_F2 | SQ_MASK_G1;
Bb64 expected = 0ULL;
expected |= SQMASK_E5;
expected |= SQMASK_C3 | SQMASK_B2;
expected |= SQMASK_C5 | SQMASK_B6 | SQMASK_A7;
expected |= SQMASK_E3 | SQMASK_F2 | SQMASK_G1;
print_bishop_test("Bishop Test 5: D4, mixed friend/enemy + extra bishop F4", sq, all_occ, own_occ);
const bitboard attacks = bishop_attacks_from_index(sq, all_occ) & ~own_occ;
assert(attacks == expected);
const Bb64 attacks = bishop_attacks_from_index(sq, all_occ) & ~own_occ;
test_expect(attacks == expected);
}
/* Test 6: Bishop at H8, no occupancy */
{
const enum square_index sq = SQ_INDEX_H8;
const bitboard enemies = 0ULL;
const bitboard all_occ = 0ULL;
const bitboard own_occ = SQ_MASK_FROM_INDEX(sq);
const Sq8 sq = SQ_H8;
const Bb64 all_occ = 0ULL;
const Bb64 own_occ = MASK_FROM_SQ(sq);
/*
* From D4:
@@ -372,17 +373,17 @@ static void test_bishops(void)
* SE: E3, F2, G1
* Bishop at F4 is irrelevant; it does not sit on a diagonal from D4.
*/
bitboard expected = 0ULL;
expected = SQ_MASK_G7 | SQ_MASK_F6 | SQ_MASK_E5 | SQ_MASK_D4 |
SQ_MASK_C3 | SQ_MASK_B2 | SQ_MASK_A1;
Bb64 expected = 0ULL;
expected = SQMASK_G7 | SQMASK_F6 | SQMASK_E5 | SQMASK_D4 |
SQMASK_C3 | SQMASK_B2 | SQMASK_A1;
print_bishop_test("Bishop Test 6: H8, no occupancy", sq, all_occ, own_occ);
const bitboard attacks = bishop_attacks_from_index(sq, all_occ) & ~own_occ;
const Bb64 attacks = bishop_attacks_from_index(sq, all_occ) & ~own_occ;
if (attacks != expected) {
bitboard_print(attacks, stderr);
}
assert(attacks == expected);
test_expect(attacks == expected);
}
printf("\nAll bishop_attacks_from_index tests passed.\n");
@@ -403,10 +404,13 @@ void* set_after_timeout(void* x)
int main()
{
bool const print_threats = true;
printf("sizeof pos: %zu\n", sizeof (struct pos));
printf("sizeof tt: %zu\n", sizeof (struct tt));
printf("sizeof board: %zu\n", sizeof (struct board));
#if 1
#if 0
test_rooks();
test_bishops();
#endif
@@ -426,35 +430,38 @@ int main()
//board_load_fen_unsafe(b, "1n1q1rk1/r1p2P2/1p1pp2p/pB2P3/2P5/PPN5/6b1/3QK1NR b - - 0 1");
//board_load_fen_unsafe(b, "8/8/2kr4/6R1/4K3/6P1/8/8 b - - 0 1");
//board_load_fen_unsafe(b, "5R2/7k/P7/6pp/3B4/1PPK2bP/4r3/8 b - - 3 57");
//board_load_fen_unsafe(b, "8/8/5R2/8/2K3PP/1B2k3/8/8 b - - 1 4");
//board_print_fen(b->pos, stdout);
board_print(&b->pos, NULL, stdout);
board_print(&b->pos, NULL, stdout, print_threats);
struct move moves[MOVE_MAX];
size_t move_count;
for (int turn = 0; turn < 200; ++turn) {
size_t move_count = 0;
all_moves(&b->pos, b->pos.player, &move_count, moves);
move_count = 0;
all_pseudolegal_moves(&b->pos, MG_ALL, b->pos.moving_side, &move_count, moves);
if (move_count == 0) {
printf("no moves for %s, aborting\n", player_str[b->pos.player]);
board_print_threats(&b->pos, stdout, NULL);
b->pos.player = opposite_player(b->pos.player);
board_print_threats(&b->pos, stdout, NULL);
printf("no moves for %s, aborting\n", side_str[b->pos.moving_side]);
board_print(&b->pos, NULL, stdout, print_threats);
b->pos.moving_side = other_side(b->pos.moving_side);
board_print(&b->pos, NULL, stdout, print_threats);
break;
}
pthread_t timer;
atomic_bool searching;
atomic_init(&searching, true);
#if 1
struct timeout_params timer_params = {
.x = &searching,
.v = false,
.us = 3*1000*1000,
.us = 2*1000*1000,
};
pthread_create(&timer, NULL, set_after_timeout, &timer_params);
#endif
struct search_result sr = search(b, b->pos.player, 5, &searching);
struct search_result sr = search(b, b->pos.moving_side, 25, &searching);
struct move move = sr.move;
double const score = sr.score;
@@ -463,23 +470,23 @@ int main()
" .from = %s, (%s)\n"
" .to = %s,\n"
" .score = %lf,\n"
" .mask = ",
" .mask = "
"",
turn,
square_index_display[move.from],
sq8_display[move.from],
piece_str[b->mailbox[move.from]],
square_index_display[move.to],
sq8_display[move.to],
score
);
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(b, move);
enum move_result const r = board_move(b, move);
#if 1
board_print_fen(&b->pos, stdout);
tt_print_stats(&b->tt, stdout);
board_print(&b->pos, &move, stdout);
board_print(&b->pos, &move, stdout, print_threats);
fprintf(stderr, "board hist len: %zu\n", b->hist.length);
#endif
if (r == MR_STALEMATE) {
@@ -487,18 +494,18 @@ int main()
break;
}
if (b->pos.pieces[PLAYER_WHITE][PIECE_KING] == 0ULL) {
if (b->pos.pieces[SIDE_WHITE][PIECE_KING] == 0ULL) {
printf("white king gone!!\n");
exit(1);
}
if (b->pos.pieces[PLAYER_BLACK][PIECE_KING] == 0ULL) {
if (b->pos.pieces[SIDE_BLACK][PIECE_KING] == 0ULL) {
printf("black king gone!!\n");
exit(1);
}
//usleep(1000000);
}
return EXIT_SUCCESS;
}