commit cdfff1b8b0d8706f3178cfaede6210a2550c2e8a
parent 7e7b1f3d78e9ea7f09b3f992d5025df7499bdd8e
Author: Dimitrije Dobrota <mail@dimitrijedobrota.com>
Date: Sun, 2 Oct 2022 14:07:43 +0200
Refactoring engine
Diffstat:
| M | src/CBoard.c | | | 6 | ++---- |
| M | src/engine.c | | | 690 | +++++++++++++++++++++++++++++++++++++++++-------------------------------------- |
2 files changed, 361 insertions(+), 335 deletions(-)
diff --git a/src/CBoard.c b/src/CBoard.c
@@ -116,11 +116,9 @@ U64 CBoard_colorBB_get(CBoard_T self, eColor color, Square target) {
}
int CBoard_piece_get(CBoard_T self, Square square) {
- for (int i = 0; i < 6; i++) {
- if (bit_get(self->pieceBB[i], square)) {
+ for (int i = 0; i < 6; i++)
+ if (bit_get(self->pieceBB[i], square))
return i;
- }
- }
return -1;
}
diff --git a/src/engine.c b/src/engine.c
@@ -25,40 +25,195 @@
"r2q1rk1/ppp2ppp/2n1bn2/2b1p3/3pP3/3P1NPP/PPP1NPB1/R1BQ1RK1 b - - 0 9 "
typedef U32 Move;
-#define Move_encode(source, target, piece, promoted, capture, dbl, enpassant, \
- castling) \
- (source) | (target << 6) | (piece << 12) | (promoted << 16) | \
- (capture << 20) | (dbl << 21) | (enpassant << 22) | (castling << 23)
+
+Move Move_encode(Square src, Square tgt, Piece_T Piece, Piece_T Promotion,
+ int capture, int dbl, int enpassant, int castle) {
+ assert(Piece);
+ int prom = (Promotion == 0) ? 0 : Piece_index(Promotion);
+ return (src) | (tgt << 6) | (Piece_index(Piece) << 12) | (prom << 16) |
+ (capture << 20) | (dbl << 21) | (enpassant << 22) | (castle << 23);
+}
#define Move_source(move) (((move)&C32(0x00003f)))
#define Move_target(move) (((move)&C32(0x000fc0)) >> 6)
#define Move_piece(move) Piece_fromIndex((((move)&C32(0x00f000)) >> 12))
-#define Move_promote(move) (((move)&C32(0x0f0000)) >> 16)
#define Move_capture(move) (((move)&C32(0x100000)) >> 20)
#define Move_double(move) (((move)&C32(0x200000)) >> 21)
#define Move_enpassant(move) (((move)&C32(0x400000)) >> 22)
#define Move_castle(move) (((move)&C32(0x800000)) >> 23)
+Piece_T Move_promote(Move move) {
+ int index = (move & C32(0x0f0000)) >> 16;
+ if (!index)
+ return NULL;
+ return Piece_fromIndex(index);
+}
+
+// clang-format off
+const int castling_rights[64] = {
+ 13, 15, 15, 15, 12, 15, 15, 14,
+ 15, 15, 15, 15, 15, 15, 15, 15,
+ 15, 15, 15, 15, 15, 15, 15, 15,
+ 15, 15, 15, 15, 15, 15, 15, 15,
+ 15, 15, 15, 15, 15, 15, 15, 15,
+ 15, 15, 15, 15, 15, 15, 15, 15,
+ 15, 15, 15, 15, 15, 15, 15, 15,
+ 7, 15, 15, 15, 3, 15, 15, 11,
+};
+
+struct Score_T {
+ int value;
+ int position[64];
+ int capture[6];
+};
+
+struct Score_T Scores[] = {
+[PAWN] = {
+.value = 100,
+.position = {
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, -10, -10, 0, 0, 0,
+ 0, 0, 0, 5, 5, 0, 0, 0,
+ 5, 5, 10, 20, 20, 5, 5, 5,
+ 10, 10, 10, 20, 20, 10, 10, 10,
+ 20, 20, 20, 30, 30, 30, 20, 20,
+ 30, 30, 30, 40, 40, 30, 30, 30,
+ 90, 90, 90, 90, 90, 90, 90, 90, },
+.capture = { [PAWN] = 105, [KNIGHT] = 205,
+ [BISHOP] = 305, [ROOK] = 405,
+ [QUEEN] = 505, [KING] = 605} },
+[KNIGHT] = {
+.value = 300,
+.position = {
+ -5, -10 , 0, 0, 0, 0, -10, -5,
+ -5, 0, 0, 0, 0, 0, 0, -5,
+ -5, 5, 20, 10, 10, 20, 5, -5,
+ -5, 10, 20, 30, 30, 20, 10, -5,
+ -5, 10, 20, 30, 30, 20, 10, -5,
+ -5, 5, 20, 20, 20, 20, 5, -5,
+ -5, 0, 0, 10, 10, 0, 0, -5,
+ -5, 0, 0, 0, 0, 0, 0, -5, },
+.capture = { [PAWN] = 104, [KNIGHT] = 204,
+ [BISHOP] = 304, [ROOK] = 404,
+ [QUEEN] = 504, [KING] = 604} },
+[BISHOP] = {
+.value = 350,
+.position = {
+ 0, 0, -10, 0, 0, -10, 0, 0,
+ 0, 30, 0, 0, 0, 0, 30, 0,
+ 0, 10, 0, 0, 0, 0, 10, 0,
+ 0, 0, 10, 20, 20, 10, 0, 0,
+ 0, 0, 10, 20, 20, 10, 0, 0,
+ 0, 0, 0, 10, 10, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, },
+.capture = { [PAWN] = 103, [KNIGHT] = 203,
+ [BISHOP] = 303, [ROOK] = 403,
+ [QUEEN] = 503, [KING] = 603} },
+[ROOK] = {
+.value = 500,
+.position = {
+ 0, 0, 0, 20, 20, 0, 0, 0,
+ 0, 0, 10, 20, 20, 10, 0, 0,
+ 0, 0, 10, 20, 20, 10, 0, 0,
+ 0, 0, 10, 20, 20, 10, 0, 0,
+ 0, 0, 10, 20, 20, 10, 0, 0,
+ 0, 0, 10, 20, 20, 10, 0, 0,
+ 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 50, },
+.capture = { [PAWN] = 102, [KNIGHT] = 202,
+ [BISHOP] = 302, [ROOK] = 402,
+ [QUEEN] = 502, [KING] = 602} },
+[QUEEN] = {
+.value = 1000,
+.position = {
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, },
+.capture = { [PAWN] = 101, [KNIGHT] = 201,
+ [BISHOP] = 301, [ROOK] = 401,
+ [QUEEN] = 501, [KING] = 601} },
+[KING] = {
+.value = 10000,
+.position = {
+ 0, 0, 5, 0, -15, 0, 10, 0,
+ 0, 5, 5, -5, -5, 0, 5, 0,
+ 0, 0, 5, 10, 10, 5, 0, 0,
+ 0, 5, 10, 20, 20, 10, 5, 0,
+ 0, 5, 10, 20, 20, 10, 5, 0,
+ 0, 5, 5, 10, 10, 5, 5, 0,
+ 0, 0, 5, 5, 5, 5, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, },
+.capture = { [PAWN] = 100, [KNIGHT] = 200,
+ [BISHOP] = 300, [ROOK] = 400,
+ [QUEEN] = 500, [KING] = 600} },
+};
+
+const int mirror_score[128] =
+{
+ a8, b8, c8, d8, e8, f8, g8, h8,
+ a7, b7, c7, d7, e7, f7, g7, h7,
+ a6, b6, c6, d6, e6, f6, g6, h6,
+ a5, b5, c5, d5, e5, f5, g5, h5,
+ a4, b4, c4, d4, e4, f4, g4, h4,
+ a3, b3, c3, d3, e3, f3, g3, h3,
+ a2, b2, c2, d2, e2, f2, g2, h2,
+ a1, b1, c1, d1, e1, f1, g1, h1, no_sq,
+};
+// clang-format on
+
+int Score_value(ePiece piece) { return Scores[piece].value; }
+
+int Score_position(ePiece piece, eColor color, Square square) {
+ if (color == BLACK)
+ square = mirror_score[square];
+ return Scores[piece].position[square];
+}
+
+int Score_capture(ePiece src, ePiece tgt) { return Scores[src].capture[tgt]; }
+
+#define MAX_PLY 64
+
+long nodes = 0;
+
+int pv_length[MAX_PLY];
+Move pv_table[MAX_PLY][MAX_PLY];
+
+int ply;
+Move killer_moves[2][MAX_PLY];
+Move history_moves[16][64];
+
+int Move_score(CBoard_T board, Move move) {
+ if (Move_capture(move)) {
+ return Score_capture(CBoard_piece_get(board, Move_source(move)),
+ CBoard_piece_get(board, Move_target(move)));
+ } else {
+ if (killer_moves[0][ply] == move)
+ return 9000;
+ else if (killer_moves[1][ply] == move)
+ return 8000;
+ else
+ return history_moves[Piece_index(Move_piece(move))][Move_target(move)];
+ }
+
+ return 0;
+}
+
void Move_print(Move move) {
- int promote = Move_promote(move);
printf("%5s %5s %5s %5c %4d %4d %4d %4d\n",
square_to_coordinates[Move_source(move)],
square_to_coordinates[Move_target(move)],
Piece_unicode(Move_piece(move)),
- promote ? Piece_asci(Piece_fromIndex(promote)) : 'X',
+ Move_promote(move) ? Piece_asci(Move_promote(move)) : 'X',
Move_capture(move) ? 1 : 0, Move_double(move) ? 1 : 0,
Move_enpassant(move) ? 1 : 0, Move_castle(move) ? 1 : 0);
}
-void Move_print_UCI(Move move) {
- int prom;
-
- printf("%s%s", square_to_coordinates[Move_source(move)],
- square_to_coordinates[Move_target(move)]);
- if ((prom = Move_promote(move)))
- printf(" %c", Piece_asci(Piece_fromIndex(prom)));
-}
-
typedef struct MoveList_T *MoveList_T;
struct MoveList_T {
Move moves[256];
@@ -71,6 +226,12 @@ MoveList_T MoveList_new(void) {
return p;
}
+void MoveList_free(MoveList_T *p) { FREE(*p); }
+
+Move MoveList_move(MoveList_T self, int index) { return self->moves[index]; }
+int MoveList_size(MoveList_T self) { return self->count; }
+void MoveList_reset(MoveList_T self) { self->count = 0; }
+
void MoveList_add(MoveList_T self, Move move) {
self->moves[self->count++] = move;
}
@@ -82,7 +243,23 @@ void MoveList_print(MoveList_T self) {
printf("Total: %d\n", self->count);
}
-void MoveList_free(MoveList_T *p) { FREE(*p); }
+void MoveList_sort(CBoard_T board, MoveList_T list) {
+ int score[list->count];
+ for (int i = 0; i < list->count; i++)
+ score[i] = Move_score(board, list->moves[i]);
+
+ for (int i = 0; i < list->count; i++)
+ for (int j = i + 1; j < list->count; j++)
+ if (score[i] < score[j]) {
+ Move t = list->moves[i];
+ list->moves[i] = list->moves[j];
+ list->moves[j] = t;
+
+ int s = score[i];
+ score[i] = score[j];
+ score[j] = s;
+ }
+}
#define pawn_canPromote(color, source) \
((color == WHITE && source >= a7 && source <= h7) || \
@@ -94,57 +271,56 @@ void MoveList_free(MoveList_T *p) { FREE(*p); }
#define pawn_promote(source, target, index, capture) \
for (int i = 1; i < 5; i++) { \
- move = Move_encode(source, target, index, \
- Piece_index(Piece_get(i, color)), capture, 0, 0, 0); \
+ move = Move_encode(source, target, index, Piece_get(i, color), capture, 0, \
+ 0, 0); \
MoveList_add(moves, move); \
}
-MoveList_T generate_moves(CBoard_T cboard, MoveList_T moves) {
+MoveList_T MoveList_generate(MoveList_T moves, CBoard_T board) {
Move move;
Square src, tgt;
- eColor color = CBoard_side(cboard);
+ eColor color = CBoard_side(board);
if (!moves)
moves = MoveList_new();
{ // pawn moves
Piece_T Piece = Piece_get(PAWN, color);
- int index = Piece_index(Piece);
- U64 bitboard = CBoard_pieceSet(cboard, Piece);
+ U64 bitboard = CBoard_pieceSet(board, Piece);
bitboard_for_each_bit(src, bitboard) {
{ // quiet
int add = (color == WHITE) ? +8 : -8;
tgt = src + add;
- if (tgt > a1 && tgt < h8 && !CBoard_square_isOccupied(cboard, tgt)) {
+ if (tgt > a1 && tgt < h8 && !CBoard_square_isOccupied(board, tgt)) {
if (pawn_canPromote(color, src)) {
- pawn_promote(src, tgt, index, 0);
+ pawn_promote(src, tgt, Piece, 0);
} else {
- MoveList_add(moves, Move_encode(src, tgt, index, 0, 0, 0, 0, 0));
+ MoveList_add(moves, Move_encode(src, tgt, Piece, 0, 0, 0, 0, 0));
// two ahead
if (pawn_onStart(color, src) &&
- !CBoard_square_isOccupied(cboard, tgt += add))
- MoveList_add(moves, Move_encode(src, tgt, index, 0, 0, 1, 0, 0));
+ !CBoard_square_isOccupied(board, tgt += add))
+ MoveList_add(moves, Move_encode(src, tgt, Piece, 0, 0, 1, 0, 0));
}
}
}
{ // capture
- U64 attack = CBoard_piece_attacks(cboard, Piece, src) &
- CBoard_colorBB(cboard, !color);
+ U64 attack = CBoard_piece_attacks(board, Piece, src) &
+ CBoard_colorBB(board, !color);
bitboard_for_each_bit(tgt, attack) {
if (pawn_canPromote(color, src)) {
- pawn_promote(src, tgt, index, 1);
+ pawn_promote(src, tgt, Piece, 1);
} else {
- MoveList_add(moves, Move_encode(src, tgt, index, 0, 1, 0, 0, 0));
+ MoveList_add(moves, Move_encode(src, tgt, Piece, 0, 1, 0, 0, 0));
}
}
}
{ // en passant
- if (CBoard_enpassant(cboard) != no_sq &&
- CBoard_piece_attacks(cboard, Piece, src) &
- (C64(1) << CBoard_enpassant(cboard)))
- MoveList_add(moves, Move_encode(src, CBoard_enpassant(cboard), index,
+ if (CBoard_enpassant(board) != no_sq &&
+ CBoard_piece_attacks(board, Piece, src) &
+ (C64(1) << CBoard_enpassant(board)))
+ MoveList_add(moves, Move_encode(src, CBoard_enpassant(board), Piece,
0, 1, 0, 1, 0));
}
}
@@ -153,14 +329,13 @@ MoveList_T generate_moves(CBoard_T cboard, MoveList_T moves) {
// All piece move
for (int piece = 1; piece < 6; piece++) {
Piece_T Piece = Piece_get(piece, color);
- U64 bitboard = CBoard_pieceSet(cboard, Piece);
+ U64 bitboard = CBoard_pieceSet(board, Piece);
bitboard_for_each_bit(src, bitboard) {
- U64 attack = CBoard_piece_attacks(cboard, Piece, src) &
- ~CBoard_colorBB(cboard, color);
+ U64 attack = CBoard_piece_attacks(board, Piece, src) &
+ ~CBoard_colorBB(board, color);
bitboard_for_each_bit(tgt, attack) {
- int take = bit_get(CBoard_colorBB(cboard, !color), tgt);
- MoveList_add(
- moves, Move_encode(src, tgt, Piece_index(Piece), 0, take, 0, 0, 0));
+ int take = bit_get(CBoard_colorBB(board, !color), tgt);
+ MoveList_add(moves, Move_encode(src, tgt, Piece, 0, take, 0, 0, 0));
}
}
}
@@ -168,38 +343,38 @@ MoveList_T generate_moves(CBoard_T cboard, MoveList_T moves) {
// Castling
{
if (color == WHITE) {
- int index = Piece_index(Piece_get(KING, WHITE));
- if (CBoard_castle(cboard) & WK) {
- if (!CBoard_square_isOccupied(cboard, f1) &&
- !CBoard_square_isOccupied(cboard, g1) &&
- !CBoard_square_isAttack(cboard, e1, BLACK) &&
- !CBoard_square_isAttack(cboard, f1, BLACK))
- MoveList_add(moves, Move_encode(e1, g1, index, 0, 0, 0, 0, 1));
+ Piece_T Piece = Piece_get(KING, WHITE);
+ if (CBoard_castle(board) & WK) {
+ if (!CBoard_square_isOccupied(board, f1) &&
+ !CBoard_square_isOccupied(board, g1) &&
+ !CBoard_square_isAttack(board, e1, BLACK) &&
+ !CBoard_square_isAttack(board, f1, BLACK))
+ MoveList_add(moves, Move_encode(e1, g1, Piece, 0, 0, 0, 0, 1));
}
- if (CBoard_castle(cboard) & WQ) {
- if (!CBoard_square_isOccupied(cboard, d1) &&
- !CBoard_square_isOccupied(cboard, c1) &&
- !CBoard_square_isOccupied(cboard, b1) &&
- !CBoard_square_isAttack(cboard, e1, BLACK) &&
- !CBoard_square_isAttack(cboard, d1, BLACK))
- MoveList_add(moves, Move_encode(e1, c1, index, 0, 0, 0, 0, 1));
+ if (CBoard_castle(board) & WQ) {
+ if (!CBoard_square_isOccupied(board, d1) &&
+ !CBoard_square_isOccupied(board, c1) &&
+ !CBoard_square_isOccupied(board, b1) &&
+ !CBoard_square_isAttack(board, e1, BLACK) &&
+ !CBoard_square_isAttack(board, d1, BLACK))
+ MoveList_add(moves, Move_encode(e1, c1, Piece, 0, 0, 0, 0, 1));
}
} else {
- int index = Piece_index(Piece_get(KING, BLACK));
- if (CBoard_castle(cboard) & BK) {
- if (!CBoard_square_isOccupied(cboard, f8) &&
- !CBoard_square_isOccupied(cboard, g8) &&
- !CBoard_square_isAttack(cboard, e8, WHITE) &&
- !CBoard_square_isAttack(cboard, f8, WHITE))
- MoveList_add(moves, Move_encode(e8, g8, index, 0, 0, 0, 0, 1));
+ Piece_T Piece = Piece_get(KING, BLACK);
+ if (CBoard_castle(board) & BK) {
+ if (!CBoard_square_isOccupied(board, f8) &&
+ !CBoard_square_isOccupied(board, g8) &&
+ !CBoard_square_isAttack(board, e8, WHITE) &&
+ !CBoard_square_isAttack(board, f8, WHITE))
+ MoveList_add(moves, Move_encode(e8, g8, Piece, 0, 0, 0, 0, 1));
}
- if (CBoard_castle(cboard) & BQ) {
- if (!CBoard_square_isOccupied(cboard, d8) &&
- !CBoard_square_isOccupied(cboard, c8) &&
- !CBoard_square_isOccupied(cboard, b8) &&
- !CBoard_square_isAttack(cboard, e8, WHITE) &&
- !CBoard_square_isAttack(cboard, d8, WHITE))
- MoveList_add(moves, Move_encode(e8, c8, index, 0, 0, 0, 0, 1));
+ if (CBoard_castle(board) & BQ) {
+ if (!CBoard_square_isOccupied(board, d8) &&
+ !CBoard_square_isOccupied(board, c8) &&
+ !CBoard_square_isOccupied(board, b8) &&
+ !CBoard_square_isAttack(board, e8, WHITE) &&
+ !CBoard_square_isAttack(board, d8, WHITE))
+ MoveList_add(moves, Move_encode(e8, c8, Piece, 0, 0, 0, 0, 1));
}
}
}
@@ -207,240 +382,60 @@ MoveList_T generate_moves(CBoard_T cboard, MoveList_T moves) {
return moves;
}
-// clang-format off
-const int castling_rights[64] = {
- 13, 15, 15, 15, 12, 15, 15, 14,
- 15, 15, 15, 15, 15, 15, 15, 15,
- 15, 15, 15, 15, 15, 15, 15, 15,
- 15, 15, 15, 15, 15, 15, 15, 15,
- 15, 15, 15, 15, 15, 15, 15, 15,
- 15, 15, 15, 15, 15, 15, 15, 15,
- 15, 15, 15, 15, 15, 15, 15, 15,
- 7, 15, 15, 15, 3, 15, 15, 11,
-};
-// clang-format on
-
-int make_move(CBoard_T cboard, Move move, int flag) {
+int Move_make(Move move, CBoard_T board, int flag) {
if (flag == 0) {
Square source = Move_source(move);
Square target = Move_target(move);
Piece_T Piece = Move_piece(move);
- eColor color = CBoard_side(cboard);
+ eColor color = CBoard_side(board);
if (!Move_capture(move))
- CBoard_piece_move(cboard, Piece, source, target);
+ CBoard_piece_move(board, Piece, source, target);
else
- CBoard_piece_capture(cboard, Piece, source, target);
+ CBoard_piece_capture(board, Piece, source, target);
if (Move_promote(move)) {
- Piece_T Promote = Piece_fromIndex(Move_promote(move));
- CBoard_piece_pop(cboard, Piece, target);
- CBoard_piece_set(cboard, Promote, target);
+ CBoard_piece_pop(board, Piece, target);
+ CBoard_piece_set(board, Move_promote(move), target);
}
{
int ntarget = target + (color == WHITE ? -8 : +8);
if (Move_enpassant(move))
- CBoard_piece_pop(cboard, Piece_get(PAWN, !color), ntarget);
+ CBoard_piece_pop(board, Piece_get(PAWN, !color), ntarget);
- CBoard_enpassant_set(cboard, Move_double(move) ? ntarget : no_sq);
+ CBoard_enpassant_set(board, Move_double(move) ? ntarget : no_sq);
}
if (Move_castle(move)) {
- Piece_T Rook = Piece_get(ROOK, CBoard_side(cboard));
+ Piece_T Rook = Piece_get(ROOK, CBoard_side(board));
switch (target) {
- case g1: CBoard_piece_move(cboard, Rook, h1, f1); break;
- case c1: CBoard_piece_move(cboard, Rook, a1, d1); break;
- case g8: CBoard_piece_move(cboard, Rook, h8, f8); break;
- case c8: CBoard_piece_move(cboard, Rook, a8, d8); break;
+ case g1: CBoard_piece_move(board, Rook, h1, f1); break;
+ case c1: CBoard_piece_move(board, Rook, a1, d1); break;
+ case g8: CBoard_piece_move(board, Rook, h8, f8); break;
+ case c8: CBoard_piece_move(board, Rook, a8, d8); break;
default: break;
}
}
- CBoard_castle_and(cboard, castling_rights[source]);
- CBoard_castle_and(cboard, castling_rights[target]);
+ CBoard_castle_and(board, castling_rights[source]);
+ CBoard_castle_and(board, castling_rights[target]);
- if (!CBoard_isCheck(cboard)) {
- CBoard_side_switch(cboard);
+ if (!CBoard_isCheck(board)) {
+ CBoard_side_switch(board);
return 1;
} else
return 0;
} else {
if (Move_capture(move))
- return make_move(cboard, move, 0);
+ return Move_make(move, board, 0);
else
return 0;
}
}
-long nodes = 0;
-struct MoveList_T moveList[10];
-
-void perft_driver(CBoard_T self, int depth) {
- if (depth == 0) {
- nodes++;
- return;
- }
-
- MoveList_T moves = generate_moves(self, &moveList[depth]);
- CBoard_T copy = CBoard_new();
-
- for (int i = 0; i < moves->count; i++) {
- CBoard_copy(self, copy);
- if (!make_move(copy, moves->moves[i], 0))
- continue;
-
- perft_driver(copy, depth - 1);
- }
- moveList[depth].count = 0;
-}
-
-void perft_test(CBoard_T self, int depth) {
- MoveList_T moves = generate_moves(self, &moveList[depth]);
- CBoard_T copy = CBoard_new();
- long start = get_time_ms();
-
- printf("\n Performance test\n\n");
- for (int i = 0; i < moves->count; i++) {
- CBoard_copy(self, copy);
- if (!make_move(copy, moves->moves[i], 0))
- continue;
- long cummulative_nodes = nodes;
- perft_driver(copy, depth - 1);
- long old_nodes = nodes - cummulative_nodes;
- printf("%s%s: %ld\n", square_to_coordinates[Move_source(moves->moves[i])],
- square_to_coordinates[Move_target(moves->moves[i])], old_nodes);
- }
-
- printf("\nNodes searched: %ld\n\n", nodes);
- return;
- printf("\n Depth: %d\n", depth);
- printf(" Nodes: %ld\n", nodes);
- printf(" Time: %ld\n\n", get_time_ms() - start);
-}
-
-void init_all() {
- init_leapers_attacks();
- init_sliders_attacks();
-}
-
-/* UCI */
-
-struct Score_T {
- int value;
- int score[64];
- int capture[6];
-};
-
-// clang-format off
-struct Score_T Scores[] = {
-[PAWN] = {
-.value = 100,
-.score = {
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, -10, -10, 0, 0, 0,
- 0, 0, 0, 5, 5, 0, 0, 0,
- 5, 5, 10, 20, 20, 5, 5, 5,
- 10, 10, 10, 20, 20, 10, 10, 10,
- 20, 20, 20, 30, 30, 30, 20, 20,
- 30, 30, 30, 40, 40, 30, 30, 30,
- 90, 90, 90, 90, 90, 90, 90, 90, },
-.capture = { [PAWN] = 105, [KNIGHT] = 205,
- [BISHOP] = 305, [ROOK] = 405,
- [QUEEN] = 505, [KING] = 605} },
-[KNIGHT] = {
-.value = 300,
-.score = {
- -5, -10 , 0, 0, 0, 0, -10, -5,
- -5, 0, 0, 0, 0, 0, 0, -5,
- -5, 5, 20, 10, 10, 20, 5, -5,
- -5, 10, 20, 30, 30, 20, 10, -5,
- -5, 10, 20, 30, 30, 20, 10, -5,
- -5, 5, 20, 20, 20, 20, 5, -5,
- -5, 0, 0, 10, 10, 0, 0, -5,
- -5, 0, 0, 0, 0, 0, 0, -5, },
-.capture = { [PAWN] = 104, [KNIGHT] = 204,
- [BISHOP] = 304, [ROOK] = 404,
- [QUEEN] = 504, [KING] = 604} },
-[BISHOP] = {
-.value = 350,
-.score = {
- 0, 0, -10, 0, 0, -10, 0, 0,
- 0, 30, 0, 0, 0, 0, 30, 0,
- 0, 10, 0, 0, 0, 0, 10, 0,
- 0, 0, 10, 20, 20, 10, 0, 0,
- 0, 0, 10, 20, 20, 10, 0, 0,
- 0, 0, 0, 10, 10, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, },
-.capture = { [PAWN] = 103, [KNIGHT] = 203,
- [BISHOP] = 303, [ROOK] = 403,
- [QUEEN] = 503, [KING] = 603} },
-[ROOK] = {
-.value = 500,
-.score = {
- 0, 0, 0, 20, 20, 0, 0, 0,
- 0, 0, 10, 20, 20, 10, 0, 0,
- 0, 0, 10, 20, 20, 10, 0, 0,
- 0, 0, 10, 20, 20, 10, 0, 0,
- 0, 0, 10, 20, 20, 10, 0, 0,
- 0, 0, 10, 20, 20, 10, 0, 0,
- 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 50, },
-.capture = { [PAWN] = 102, [KNIGHT] = 202,
- [BISHOP] = 302, [ROOK] = 402,
- [QUEEN] = 502, [KING] = 602} },
-[QUEEN] = {
-.value = 1000,
-.score = {
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, },
-.capture = { [PAWN] = 101, [KNIGHT] = 201,
- [BISHOP] = 301, [ROOK] = 401,
- [QUEEN] = 501, [KING] = 601} },
-[KING] = {
-.value = 10000,
-.score = {
- 0, 0, 5, 0, -15, 0, 10, 0,
- 0, 5, 5, -5, -5, 0, 5, 0,
- 0, 0, 5, 10, 10, 5, 0, 0,
- 0, 5, 10, 20, 20, 10, 5, 0,
- 0, 5, 10, 20, 20, 10, 5, 0,
- 0, 5, 5, 10, 10, 5, 5, 0,
- 0, 0, 5, 5, 5, 5, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, },
-.capture = { [PAWN] = 100, [KNIGHT] = 200,
- [BISHOP] = 300, [ROOK] = 400,
- [QUEEN] = 500, [KING] = 600} },
-};
-
-const int mirror_score[128] =
-{
- a8, b8, c8, d8, e8, f8, g8, h8,
- a7, b7, c7, d7, e7, f7, g7, h7,
- a6, b6, c6, d6, e6, f6, g6, h6,
- a5, b5, c5, d5, e5, f5, g5, h5,
- a4, b4, c4, d4, e4, f4, g4, h4,
- a3, b3, c3, d3, e3, f3, g3, h3,
- a2, b2, c2, d2, e2, f2, g2, h2,
- a1, b1, c1, d1, e1, f1, g1, h1, no_sq,
-};
-// clang-format on
-
-int Score_value(ePiece piece) { return Scores[piece].value; }
-
-int Score_score(ePiece piece, eColor color, Square square) {
- if (color == BLACK)
- square = mirror_score[square];
- return Scores[piece].score[square];
-}
+/* SEARCHING */
int evaluate(CBoard_T board) {
Square square;
@@ -453,10 +448,10 @@ int evaluate(CBoard_T board) {
bitboard_for_each_bit(square, bitboard) {
if (bit_get(occupancy, square)) {
score += Score_value(i);
- score += Score_score(i, side, square);
+ score += Score_position(i, side, square);
} else {
score -= Score_value(i);
- score -= Score_score(i, !side, square);
+ score -= Score_position(i, !side, square);
}
}
}
@@ -464,47 +459,6 @@ int evaluate(CBoard_T board) {
return score;
}
-int pv_length[64];
-Move pv_table[64][64];
-
-int ply;
-int killer_moves[2][64];
-int history_moves[16][64];
-
-int move_score(CBoard_T board, Move move) {
- if (Move_capture(move)) {
- return Scores[CBoard_piece_get(board, Move_source(move))]
- .capture[CBoard_piece_get(board, Move_target(move))];
- } else {
- if (killer_moves[0][ply] == move)
- return 9000;
- else if (killer_moves[1][ply] == move)
- return 8000;
- else
- return history_moves[Piece_index(Move_piece(move))][Move_target(move)];
- }
-
- return 0;
-}
-
-void MoveList_sort(CBoard_T board, MoveList_T list) {
- int score[list->count];
- for (int i = 0; i < list->count; i++)
- score[i] = move_score(board, list->moves[i]);
-
- for (int i = 0; i < list->count; i++)
- for (int j = i + 1; j < list->count; j++)
- if (score[i] < score[j]) {
- Move t = list->moves[i];
- list->moves[i] = list->moves[j];
- list->moves[j] = t;
-
- int s = score[i];
- score[i] = score[j];
- score[j] = s;
- }
-}
-
int quiescence(CBoard_T board, int alpha, int beta) {
MoveList_T moves;
CBoard_T copy;
@@ -521,14 +475,14 @@ int quiescence(CBoard_T board, int alpha, int beta) {
}
copy = CBoard_new();
- moves = generate_moves(board, NULL);
+ moves = MoveList_generate(NULL, board);
MoveList_sort(board, moves);
- for (int i = 0; i < moves->count; i++) {
+ for (int i = 0; i < MoveList_size(moves); i++) {
CBoard_copy(board, copy);
ply++;
- if (make_move(copy, moves->moves[i], 1) == 0) {
+ if (Move_make(MoveList_move(moves, i), copy, 1) == 0) {
ply--;
continue;
}
@@ -562,10 +516,13 @@ int negamax(CBoard_T board, int alpha, int beta, int depth) {
if (depth == 0)
return quiescence(board, alpha, beta);
+ if (ply > MAX_PLY - 1)
+ return evaluate(board);
+
nodes++;
copy = CBoard_new();
- list = generate_moves(board, NULL);
+ list = MoveList_generate(NULL, board);
isCheck = CBoard_isCheck(board);
if (isCheck)
@@ -573,12 +530,12 @@ int negamax(CBoard_T board, int alpha, int beta, int depth) {
int legal_moves = 0;
MoveList_sort(board, list);
- for (int i = 0; i < list->count; i++) {
- Move move = list->moves[i];
+ for (int i = 0; i < MoveList_size(list); i++) {
+ Move move = MoveList_move(list, i);
ply++;
CBoard_copy(board, copy);
- if (make_move(copy, move, 0) == 0) {
+ if (Move_make(move, copy, 0) == 0) {
ply--;
continue;
}
@@ -622,16 +579,33 @@ int negamax(CBoard_T board, int alpha, int beta, int depth) {
return alpha;
}
+/* UCI */
+
+void Move_print_UCI(Move move) {
+ printf("%s%s", square_to_coordinates[Move_source(move)],
+ square_to_coordinates[Move_target(move)]);
+ if (Move_promote(move))
+ printf(" %c", Piece_asci(Move_promote(move)));
+}
+
void search_position(CBoard_T board, int depth) {
- int score = negamax(board, -50000, 50000, depth);
+ memset(killer_moves, 0, sizeof(killer_moves));
+ memset(history_moves, 0, sizeof(history_moves));
+ memset(pv_table, 0, sizeof(pv_table));
+ memset(pv_length, 0, sizeof(pv_length));
+ nodes = 0;
- printf("info score cp %d depth %d nodes %ld pv ", score, depth, nodes);
+ for (int crnt = 1; crnt <= depth; crnt++) {
+ int score = negamax(board, -50000, 50000, crnt);
- for (int i = 0; i < pv_length[0]; i++) {
- Move_print_UCI(pv_table[0][i]);
- printf(" ");
+ printf("info score cp %d depth %d nodes %ld pv ", score, crnt, nodes);
+
+ for (int i = 0; i < pv_length[0]; i++) {
+ Move_print_UCI(pv_table[0][i]);
+ printf(" ");
+ }
+ printf("\n");
}
- printf("\n");
printf("bestmove ");
Move_print_UCI(pv_table[0][0]);
@@ -700,7 +674,7 @@ char *Instruction_token_next(Instruction_T self) {
return Instruction_token_n(self, 1);
}
-Move parse_move(CBoard_T self, char *move_string) {
+Move parse_move(CBoard_T board, char *move_string) {
Move result = 0;
MoveList_T moves;
Square source, target;
@@ -708,13 +682,12 @@ Move parse_move(CBoard_T self, char *move_string) {
source = coordinates_to_square(move_string);
target = coordinates_to_square(move_string + 2);
- moves = generate_moves(self, NULL);
+ moves = MoveList_generate(NULL, board);
for (int i = 0; i < moves->count; i++) {
Move move = moves->moves[i];
if (Move_source(move) == source && Move_target(move) == target) {
if (move_string[4]) {
- Piece_T promoted = Piece_fromIndex(Move_promote(move));
- if (tolower(Piece_code(promoted)) != move_string[4])
+ if (tolower(Piece_code(Move_promote(move))) != move_string[4])
continue;
}
result = move;
@@ -759,7 +732,7 @@ CBoard_T Instruction_parse(Instruction_T self, CBoard_T board) {
while ((token = Instruction_token_next(self))) {
Move move = parse_move(board, token);
if (move) {
- make_move(board, move, 0);
+ Move_make(move, board, 0);
} else {
printf("Invalid move %s!\n", token);
}
@@ -821,9 +794,64 @@ void uci_loop(void) {
CBoard_free(&board);
}
+/* PERFT */
+
+struct MoveList_T moveList[10];
+
+void perft_driver(CBoard_T board, int depth) {
+ if (depth == 0) {
+ nodes++;
+ return;
+ }
+
+ MoveList_T list = MoveList_generate(&moveList[depth], board);
+ CBoard_T copy = CBoard_new();
+
+ for (int i = 0; i < MoveList_size(list); i++) {
+ CBoard_copy(board, copy);
+ if (!Move_make(MoveList_move(list, i), copy, 0))
+ continue;
+ perft_driver(copy, depth - 1);
+ }
+ MoveList_reset(list);
+}
+
+void perft_test(CBoard_T board, int depth) {
+ MoveList_T list = MoveList_generate(&moveList[depth], board);
+ CBoard_T copy = CBoard_new();
+ long start = get_time_ms();
+
+ printf("\n Performance test\n\n");
+ for (int i = 0; i < MoveList_size(list); i++) {
+ CBoard_copy(board, copy);
+ Move move = MoveList_move(list, i);
+ if (!Move_make(MoveList_move(list, i), copy, 0))
+ continue;
+ long cummulative_nodes = nodes;
+ perft_driver(copy, depth - 1);
+ long old_nodes = nodes - cummulative_nodes;
+ printf("%s%s: %ld\n", square_to_coordinates[Move_source(move)],
+ square_to_coordinates[Move_target(move)], old_nodes);
+ }
+ MoveList_reset(list);
+
+ printf("\nNodes searched: %ld\n\n", nodes);
+ return;
+ printf("\n Depth: %d\n", depth);
+ printf(" Nodes: %ld\n", nodes);
+ printf(" Time: %ld\n\n", get_time_ms() - start);
+}
+
+/* MAIN */
+
+void init_all() {
+ init_leapers_attacks();
+ init_sliders_attacks();
+}
+
int main(void) {
init_all();
- int debug = 0;
+ int debug = 1;
if (debug) {
printf("debugging!\n");
CBoard_T board = NULL;
