bruno/brchess
1
0
Fork 0
Code Issues 9 Projects Releases Wiki Activity

prepare brchess, eval, eval-simple for future use

Browse Source
This commit is contained in:
Bruno Raoult
2024-06-19 11:01:48 +02:00
parent 243805f11f
commit f530a13481
4 changed files with 543 additions and 498 deletions
Download Patch File Download Diff File Expand all files Collapse all files

390
src/eval-simple.c
View File

@@ -1,199 +1,201 @@
/* eval-simple.c - simple position evaluation.
*
* Copyright (C) 2023 Bruno Raoult ("br")
* Licensed under the GNU General Public License v3.0 or later.
* Some rights reserved. See COPYING.
*
* You should have received a copy of the GNU General Public License along with this
* program. If not, see <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
*
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
*
*/
#include "br.h"
#include "debug.h"
#include "piece.h"
#include "eval-simple.h"
#include "position.h"
/*
* Tables are from https://www.chessprogramming.org/Simplified_Evaluation_Function
* /\* eval-simple.c - simple position evaluation.
* *
* * Copyright (C) 2023 Bruno Raoult ("br")
* * Licensed under the GNU General Public License v3.0 or later.
* * Some rights reserved. See COPYING.
* *
* * You should have received a copy of the GNU General Public License along with this
* * program. If not, see <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
* *
* * SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
* *
* *\/
*
* Attention! Tables are black point of view (to be visually easier to read).
*/
static int mg_pawn[] = {
0, 0, 0, 0, 0, 0, 0, 0,
50, 50, 50, 50, 50, 50, 50, 50,
10, 10, 20, 30, 30, 20, 10, 10,
5, 5, 10, 25, 25, 10, 5, 5,
0, 0, 0, 20, 20, 0, 0, 0,
5, -5, -10, 0, 0, -10, -5, 5,
5, 10, 10, -20, -20, 10, 10, 5,
0, 0, 0, 0, 0, 0, 0, 0
};
static int mg_knight[] = {
-50, -40, -30, -30, -30, -30, -40, -50,
-40, -20, 0, 0, 0, 0, -20, -40,
-30, 0, 10, 15, 15, 10, 0, -30,
-30, 5, 15, 20, 20, 15, 5, -30,
-30, 0, 15, 20, 20, 15, 0, -30,
-30, 5, 10, 15, 15, 10, 5, -30,
-40, -20, 0, 5, 5, 0, -20, -40,
-50, -40, -30, -30, -30, -30, -40, -50
};
static int mg_bishop[] = {
-20, -10, -10, -10, -10, -10, -10, -20,
-10, 0, 0, 0, 0, 0, 0, -10,
-10, 0, 5, 10, 10, 5, 0, -10,
-10, 5, 5, 10, 10, 5, 5, -10,
-10, 0, 10, 10, 10, 10, 0, -10,
-10, 10, 10, 10, 10, 10, 10, -10,
-10, 5, 0, 0, 0, 0, 5, -10,
-20, -10, -10, -10, -10, -10, -10, -20
};
static int mg_rook[] = {
0, 0, 0, 0, 0, 0, 0, 0,
5, 10, 10, 10, 10, 10, 10, 5,
-5, 0, 0, 0, 0, 0, 0, -5,
-5, 0, 0, 0, 0, 0, 0, -5,
-5, 0, 0, 0, 0, 0, 0, -5,
-5, 0, 0, 0, 0, 0, 0, -5,
-5, 0, 0, 0, 0, 0, 0, -5,
0, 0, 0, 5, 5, 0, 0, 0
};
static int mg_queen[] = {
-20, -10, -10, -5, -5, -10, -10, -20,
-10, 0, 0, 0, 0, 0, 0, -10,
-10, 0, 5, 5, 5, 5, 0, -10,
-5, 0, 5, 5, 5, 5, 0, -5,
0, 0, 5, 5, 5, 5, 0, -5,
-10, 5, 5, 5, 5, 5, 0, -10,
-10, 0, 5, 0, 0, 0, 0, -10,
-20, -10, -10, -5, -5, -10, -10, -20
};
static int mg_king[] = {
-30, -40, -40, -50, -50, -40, -40, -30,
-30, -40, -40, -50, -50, -40, -40, -30,
-30, -40, -40, -50, -50, -40, -40, -30,
-30, -40, -40, -50, -50, -40, -40, -30,
-20, -30, -30, -40, -40, -30, -30, -20,
-10, -20, -20, -20, -20, -20, -20, -10,
20, 20, 0, 0, 0, 0, 20, 20,
20, 30, 10, 0, 0, 10, 30, 20
};
static int eg_king[] = {
-50, -40, -30, -20, -20, -30, -40, -50,
-30, -20, -10, 0, 0, -10, -20, -30,
-30, -10, 20, 30, 30, 20, -10, -30,
-30, -10, 30, 40, 40, 30, -10, -30,
-30, -10, 30, 40, 40, 30, -10, -30,
-30, -10, 20, 30, 30, 20, -10, -30,
-30, -30, 0, 0, 0, 0, -30, -30,
-50, -30, -30, -30, -30, -30, -30, -50
};
/* as pieces bitboard tables start at position 2; we make these tables
* bigger.
*/
static int *mg_tables[] = {
NULL,
NULL,
mg_pawn,
mg_knight,
mg_bishop,
mg_rook,
mg_queen,
mg_king
};
static int *eg_tables[] = {
NULL,
NULL,
mg_pawn,
mg_knight,
mg_bishop,
mg_rook,
mg_queen,
eg_king
};
/* to flip vertically a square, we need to XOR it with 56
*/
static int mg_table[2][6 + 2][64];
static int eg_table[2][6 + 2][64];
void eval_simple_init(void)
{
# ifdef DEBUG_EVAL
log_f(1, "initializing piece tables\n");
# endif
for (int piece = BB_PAWN; piece <= BB_KING; ++piece) {
for (int square = 0; square < 64; ++square) {
mg_table[WHITE][piece][square] = mg_tables[piece][FLIP_V(square)];
eg_table[WHITE][piece][square] = eg_tables[piece][FLIP_V(square)];
mg_table[BLACK][piece][square] = mg_tables[piece][square];
eg_table[BLACK][piece][square] = eg_tables[piece][square];
}
}
}
/**
* eval_simple() - simple and fast position evaluation
* @pos: &position to evaluate
* #include "br.h"
* #include "debug.h"
*
* This function is normally used only during initialization,
* or when changing phase (middlegame <--> endgame), as the eval
* will be done increntally when doing moves.
* #include "piece.h"
* #include "eval-simple.h"
* #include "position.h"
*
* @return: the @pos evaluation in centipawns
* /\*
* * Tables are from https://www.chessprogramming.org/Simplified_Evaluation_Function
* *
* * Attention! Tables are black point of view (to be visually easier to read).
* *\/
*
* static int mg_pawn[] = {
* 0, 0, 0, 0, 0, 0, 0, 0,
* 50, 50, 50, 50, 50, 50, 50, 50,
* 10, 10, 20, 30, 30, 20, 10, 10,
* 5, 5, 10, 25, 25, 10, 5, 5,
* 0, 0, 0, 20, 20, 0, 0, 0,
* 5, -5, -10, 0, 0, -10, -5, 5,
* 5, 10, 10, -20, -20, 10, 10, 5,
* 0, 0, 0, 0, 0, 0, 0, 0
* };
*
* static int mg_knight[] = {
* -50, -40, -30, -30, -30, -30, -40, -50,
* -40, -20, 0, 0, 0, 0, -20, -40,
* -30, 0, 10, 15, 15, 10, 0, -30,
* -30, 5, 15, 20, 20, 15, 5, -30,
* -30, 0, 15, 20, 20, 15, 0, -30,
* -30, 5, 10, 15, 15, 10, 5, -30,
* -40, -20, 0, 5, 5, 0, -20, -40,
* -50, -40, -30, -30, -30, -30, -40, -50
* };
*
* static int mg_bishop[] = {
* -20, -10, -10, -10, -10, -10, -10, -20,
* -10, 0, 0, 0, 0, 0, 0, -10,
* -10, 0, 5, 10, 10, 5, 0, -10,
* -10, 5, 5, 10, 10, 5, 5, -10,
* -10, 0, 10, 10, 10, 10, 0, -10,
* -10, 10, 10, 10, 10, 10, 10, -10,
* -10, 5, 0, 0, 0, 0, 5, -10,
* -20, -10, -10, -10, -10, -10, -10, -20
* };
*
* static int mg_rook[] = {
* 0, 0, 0, 0, 0, 0, 0, 0,
* 5, 10, 10, 10, 10, 10, 10, 5,
* -5, 0, 0, 0, 0, 0, 0, -5,
* -5, 0, 0, 0, 0, 0, 0, -5,
* -5, 0, 0, 0, 0, 0, 0, -5,
* -5, 0, 0, 0, 0, 0, 0, -5,
* -5, 0, 0, 0, 0, 0, 0, -5,
* 0, 0, 0, 5, 5, 0, 0, 0
* };
*
* static int mg_queen[] = {
* -20, -10, -10, -5, -5, -10, -10, -20,
* -10, 0, 0, 0, 0, 0, 0, -10,
* -10, 0, 5, 5, 5, 5, 0, -10,
* -5, 0, 5, 5, 5, 5, 0, -5,
* 0, 0, 5, 5, 5, 5, 0, -5,
* -10, 5, 5, 5, 5, 5, 0, -10,
* -10, 0, 5, 0, 0, 0, 0, -10,
* -20, -10, -10, -5, -5, -10, -10, -20
* };
*
* static int mg_king[] = {
* -30, -40, -40, -50, -50, -40, -40, -30,
* -30, -40, -40, -50, -50, -40, -40, -30,
* -30, -40, -40, -50, -50, -40, -40, -30,
* -30, -40, -40, -50, -50, -40, -40, -30,
* -20, -30, -30, -40, -40, -30, -30, -20,
* -10, -20, -20, -20, -20, -20, -20, -10,
* 20, 20, 0, 0, 0, 0, 20, 20,
* 20, 30, 10, 0, 0, 10, 30, 20
* };
*
* static int eg_king[] = {
* -50, -40, -30, -20, -20, -30, -40, -50,
* -30, -20, -10, 0, 0, -10, -20, -30,
* -30, -10, 20, 30, 30, 20, -10, -30,
* -30, -10, 30, 40, 40, 30, -10, -30,
* -30, -10, 30, 40, 40, 30, -10, -30,
* -30, -10, 20, 30, 30, 20, -10, -30,
* -30, -30, 0, 0, 0, 0, -30, -30,
* -50, -30, -30, -30, -30, -30, -30, -50
* };
*
* /\* as pieces bitboard tables start at position 2; we make these tables
* * bigger.
* *\/
* static int *mg_tables[] = {
* NULL,
* NULL,
* mg_pawn,
* mg_knight,
* mg_bishop,
* mg_rook,
* mg_queen,
* mg_king
* };
*
* static int *eg_tables[] = {
* NULL,
* NULL,
* mg_pawn,
* mg_knight,
* mg_bishop,
* mg_rook,
* mg_queen,
* eg_king
* };
*
* /\* to flip vertically a square, we need to XOR it with 56
* *\/
* static int mg_table[2][6 + 2][64];
* static int eg_table[2][6 + 2][64];
*
* void eval_simple_init(void)
* {
* # ifdef DEBUG_EVAL
* log_f(1, "initializing piece tables\n");
* # endif
* for (int piece = BB_PAWN; piece <= BB_KING; ++piece) {
* for (int square = 0; square < 64; ++square) {
* mg_table[WHITE][piece][square] = mg_tables[piece][FLIP_V(square)];
* eg_table[WHITE][piece][square] = eg_tables[piece][FLIP_V(square)];
* mg_table[BLACK][piece][square] = mg_tables[piece][square];
* eg_table[BLACK][piece][square] = eg_tables[piece][square];
* }
* }
* }
*
* /\**
* * eval_simple() - simple and fast position evaluation
* * @pos: &position to evaluate
* *
* * This function is normally used only during initialization,
* * or when changing phase (middlegame <--> endgame), as the eval
* * will be done increntally when doing moves.
* *
* * @return: the @pos evaluation in centipawns
* *\/
* eval_t eval_simple(pos_t *pos)
* {
* eval_t eval[2] = { 0, 0 };
* int eg = simple_is_endgame(pos);
* int (*gg)[6 + 2][64]= eg? eg_table: mg_table;
*
* pos->eval_simple_phase = ENDGAME;
* # ifdef DEBUG_EVAL
* log_f(5, "phase = %s.\n", eg? "endgame": "midgame");
* # endif
*
* for (int color = WHITE; color <= BLACK; ++color) {
* for (uint piece = PAWN; piece <= KING; piece <<= 1) {
* int bb = PIECETOBB(piece), cur;
* u64 _t;
*
* # ifdef DEBUG_EVAL
* log_f(5, "p=%u bb=%d %s %s: count=%d val=%ld ", piece, bb, color? "black": "white",
* P_SYM(piece), popcount64(pos->bb[color][bb]),
* popcount64(pos->bb[color][bb]) * P_VALUE(piece));
* # endif
*
* eval[color] += popcount64(pos->bb[color][bb]) * P_LETTER(piece);
* bit_for_each64(cur, _t, pos->bb[color][bb]) {
* # ifdef DEBUG_EVAL
* log(5, "sq=%d:%d ", cur, gg[color][bb][cur]);
* # endif
* eval[color] += gg[color][bb][cur];
* }
* # ifdef DEBUG_EVAL
* log(5, "\n");
* # endif
* }
* }
* # ifdef DEBUG_EVAL
* log_f(2, "eval:%d white:%d black:%d\n", eval[WHITE] - eval[BLACK],
* eval[WHITE], eval[BLACK]);
* # endif
*
* return eval[WHITE] - eval[BLACK];
* }
*/
eval_t eval_simple(pos_t *pos)
{
eval_t eval[2] = { 0, 0 };
int eg = simple_is_endgame(pos);
int (*gg)[6 + 2][64]= eg? eg_table: mg_table;
pos->eval_simple_phase = ENDGAME;
# ifdef DEBUG_EVAL
log_f(5, "phase = %s.\n", eg? "endgame": "midgame");
# endif
for (int color = WHITE; color <= BLACK; ++color) {
for (uint piece = PAWN; piece <= KING; piece <<= 1) {
int bb = PIECETOBB(piece), cur;
u64 _t;
# ifdef DEBUG_EVAL
log_f(5, "p=%u bb=%d %s %s: count=%d val=%ld ", piece, bb, color? "black": "white",
P_SYM(piece), popcount64(pos->bb[color][bb]),
popcount64(pos->bb[color][bb]) * P_VALUE(piece));
# endif
eval[color] += popcount64(pos->bb[color][bb]) * P_LETTER(piece);
bit_for_each64(cur, _t, pos->bb[color][bb]) {
# ifdef DEBUG_EVAL
log(5, "sq=%d:%d ", cur, gg[color][bb][cur]);
# endif
eval[color] += gg[color][bb][cur];
}
# ifdef DEBUG_EVAL
log(5, "\n");
# endif
}
}
# ifdef DEBUG_EVAL
log_f(2, "eval:%d white:%d black:%d\n", eval[WHITE] - eval[BLACK],
eval[WHITE], eval[BLACK]);
# endif
return eval[WHITE] - eval[BLACK];
}