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

integrated material eval into psqt

Browse source
This commit is contained in:
Moritz 2025-11-18 20:14:47 +01:00
parent 7b84e8a0ab
commit b69323665c
4 changed files with 127 additions and 120 deletions
Download patch file Download diff file Expand all files Collapse all files

BIN
progress_tracking/progress.xlsx
View file

Binary file not shown.

4
src/bin/suite.rs
View file

@ -29,7 +29,7 @@ fn main() {
let mut engine = Engine::new("Yakari".to_string(), "EiSiMo".to_string());
// Set the time limit to 1 second
let time_limit = Duration::from_millis(500);
let time_limit = Duration::from_millis(1000);
for test in &sts {
let fen = &test[0];
@ -40,7 +40,7 @@ fn main() {
// Record start time
let start_time = Instant::now();
let result = engine.search(490_u64);
let result = engine.search(990_u64);
// Calculate duration
let duration = start_time.elapsed();

81
src/eval/basic.rs
View file

@ -1,72 +1,65 @@
use crate::board::*;
use crate::eval::piece_square_tables::PSQT;
// Pawn, Knight, Bishop, Rook, Queen
pub const MATERIAL_WEIGHTS: [i32; 5] = [100, 300, 300, 500, 900];
pub const PHASE_WEIGHTS: [i32; 5] = [0, 1, 1, 2, 4];
pub fn evaluate_board(board: &Board) -> i32 {
let mut mg_score = 0_i32;
let mut eg_score = 0_i32;
let mut phase = 0_i32;
// --- WHITE PIECES ---
// Iterating Pawn (0) to Queen (4) for Material + Phase + PSQT
for pt in 0..5 {
let mut pieces = board.pieces[pt][Color::White as usize];
let count = pieces.count_ones() as i32;
mg_score += count * MATERIAL_WEIGHTS[pt];
eg_score += count * MATERIAL_WEIGHTS[pt];
phase += count * PHASE_WEIGHTS[pt];
// We use a macro to force loop unrolling.
// This enables the compiler to use constant offsets for PSQT access
// instead of calculating addresses at runtime based on a loop variable.
macro_rules! score_piece {
($pt:expr, $phase_weight:expr) => {
// --- WHITE ---
let mut pieces = board.pieces[$pt][Color::White as usize];
if pieces > 0 {
// Phase calculation uses count_ones (POPPCNT) which is very fast
phase += (pieces.count_ones() as i32) * $phase_weight;
while pieces > 0 {
let sq = pieces.trailing_zeros() as usize;
pieces &= pieces - 1; // Clear LS1B
// Access: [Piece][Color][Phase (0=MG, 1=EG)][Square]
mg_score += PSQT[pt][Color::White as usize][0][sq];
eg_score += PSQT[pt][Color::White as usize][1][sq];
// Material is already baked into PSQT, so we just add the table value
// Since $pt is a const literal here, this compiles to a direct memory access
mg_score += PSQT[$pt][Color::White as usize][0][sq];
eg_score += PSQT[$pt][Color::White as usize][1][sq];
}
}
// King (Index 5) - No Material/Phase weight, only PSQT
let mut white_king = board.pieces[5][Color::White as usize];
if white_king > 0 {
let sq = white_king.trailing_zeros() as usize;
mg_score += PSQT[5][Color::White as usize][0][sq];
eg_score += PSQT[5][Color::White as usize][1][sq];
}
// --- BLACK PIECES ---
// Iterating Pawn (0) to Queen (4)
for pt in 0..5 {
let mut pieces = board.pieces[pt][Color::Black as usize];
let count = pieces.count_ones() as i32;
mg_score -= count * MATERIAL_WEIGHTS[pt];
eg_score -= count * MATERIAL_WEIGHTS[pt];
phase += count * PHASE_WEIGHTS[pt];
// --- BLACK ---
let mut pieces = board.pieces[$pt][Color::Black as usize];
if pieces > 0 {
phase += (pieces.count_ones() as i32) * $phase_weight;
while pieces > 0 {
let sq = pieces.trailing_zeros() as usize;
pieces &= pieces - 1;
mg_score -= PSQT[pt][Color::Black as usize][0][sq];
eg_score -= PSQT[pt][Color::Black as usize][1][sq];
mg_score -= PSQT[$pt][Color::Black as usize][0][sq];
eg_score -= PSQT[$pt][Color::Black as usize][1][sq];
}
}
};
}
// King (Index 5) for Black
let mut black_king = board.pieces[5][Color::Black as usize];
if black_king > 0 {
let sq = black_king.trailing_zeros() as usize;
mg_score -= PSQT[5][Color::Black as usize][0][sq];
eg_score -= PSQT[5][Color::Black as usize][1][sq];
}
// Explicitly unrolled execution order
// Pawn (0), Weight 0
score_piece!(0, 0);
// Knight (1), Weight 1
score_piece!(1, 1);
// Bishop (2), Weight 1
score_piece!(2, 1);
// Rook (3), Weight 2
score_piece!(3, 2);
// Queen (4), Weight 4
score_piece!(4, 4);
// King (5), Weight 0 (Phase doesn't change)
score_piece!(5, 0);
// Tapered Evaluation Interpolation
let phase = phase.min(24); // Clamp to 24 max
// Tapered Evaluation
let phase = phase.min(24);
let mg_phase = phase;
let eg_phase = 24 - phase;

52
src/eval/piece_square_tables.rs
View file

@ -1,3 +1,17 @@
// --- Material Values (PeSTO Standard) ---
const MG_PAWN_VAL: i32 = 82;
const EG_PAWN_VAL: i32 = 94;
const MG_KNIGHT_VAL: i32 = 337;
const EG_KNIGHT_VAL: i32 = 281;
const MG_BISHOP_VAL: i32 = 365;
const EG_BISHOP_VAL: i32 = 297;
const MG_ROOK_VAL: i32 = 477;
const EG_ROOK_VAL: i32 = 512;
const MG_QUEEN_VAL: i32 = 1025;
const EG_QUEEN_VAL: i32 = 936;
const MG_KING_VAL: i32 = 0; // King usually has no material value in eval summation (captured = game over)
const EG_KING_VAL: i32 = 0;
pub const MG_PAWN_TABLE: [i32; 64] = [
0, 0, 0, 0, 0, 0, 0, 0,
98, 134, 61, 95, 68, 126, 34, -11,
@ -130,49 +144,49 @@ pub const EG_KING_TABLE: [i32; 64] = [
-53, -34, -21, -11, -28, -14, -24, -43
];
/// Helper function to mirror the table vertically at compile time
const fn mirror_psqt(table: [i32; 64]) -> [i32; 64] {
let mut mirrored = [0; 64];
/// Combines logic: mirrors (if needed) AND adds material value.
/// This happens at compile-time, so no runtime cost.
const fn prepare_table(table: [i32; 64], material: i32, mirror: bool) -> [i32; 64] {
let mut out = [0; 64];
let mut i = 0;
while i < 64 {
// XOR 56 maps rank 1 to 8, 2 to 7 etc, keeping files intact
mirrored[i] = table[i ^ 56];
let idx = if mirror { i ^ 56 } else { i };
out[i] = table[idx] + material;
i += 1;
}
mirrored
out
}
// Type signature: [Piece (6)] -> [Color (2)] -> [Phase (2)] -> [Square (64)]
pub const PSQT: [[[[i32; 64]; 2]; 2]; 6] = [
// 1. PAWN
[
[mirror_psqt(MG_PAWN_TABLE), mirror_psqt(EG_PAWN_TABLE)], // White (Muss geflippt werden!)
[MG_PAWN_TABLE, EG_PAWN_TABLE] // Black (Ist bereits korrekt für schwarze Indices)
[prepare_table(MG_PAWN_TABLE, MG_PAWN_VAL, true), prepare_table(EG_PAWN_TABLE, EG_PAWN_VAL, true)], // White (Mirrored + Mat)
[prepare_table(MG_PAWN_TABLE, MG_PAWN_VAL, false), prepare_table(EG_PAWN_TABLE, EG_PAWN_VAL, false)] // Black (Normal + Mat)
],
// 2. KNIGHT
[
[mirror_psqt(MG_KNIGHT_TABLE), mirror_psqt(EG_KNIGHT_TABLE)], // White
[MG_KNIGHT_TABLE, EG_KNIGHT_TABLE] // Black
[prepare_table(MG_KNIGHT_TABLE, MG_KNIGHT_VAL, true), prepare_table(EG_KNIGHT_TABLE, EG_KNIGHT_VAL, true)],
[prepare_table(MG_KNIGHT_TABLE, MG_KNIGHT_VAL, false), prepare_table(EG_KNIGHT_TABLE, EG_KNIGHT_VAL, false)]
],
// 3. BISHOP
[
[mirror_psqt(MG_BISHOP_TABLE), mirror_psqt(EG_BISHOP_TABLE)], // White
[MG_BISHOP_TABLE, EG_BISHOP_TABLE] // Black
[prepare_table(MG_BISHOP_TABLE, MG_BISHOP_VAL, true), prepare_table(EG_BISHOP_TABLE, EG_BISHOP_VAL, true)],
[prepare_table(MG_BISHOP_TABLE, MG_BISHOP_VAL, false), prepare_table(EG_BISHOP_TABLE, EG_BISHOP_VAL, false)]
],
// 4. ROOK
[
[mirror_psqt(MG_ROOK_TABLE), mirror_psqt(EG_ROOK_TABLE)], // White
[MG_ROOK_TABLE, EG_ROOK_TABLE] // Black
[prepare_table(MG_ROOK_TABLE, MG_ROOK_VAL, true), prepare_table(EG_ROOK_TABLE, EG_ROOK_VAL, true)],
[prepare_table(MG_ROOK_TABLE, MG_ROOK_VAL, false), prepare_table(EG_ROOK_TABLE, EG_ROOK_VAL, false)]
],
// 5. QUEEN
[
[mirror_psqt(MG_QUEEN_TABLE), mirror_psqt(EG_QUEEN_TABLE)], // White
[MG_QUEEN_TABLE, EG_QUEEN_TABLE] // Black
[prepare_table(MG_QUEEN_TABLE, MG_QUEEN_VAL, true), prepare_table(EG_QUEEN_TABLE, EG_QUEEN_VAL, true)],
[prepare_table(MG_QUEEN_TABLE, MG_QUEEN_VAL, false), prepare_table(EG_QUEEN_TABLE, EG_QUEEN_VAL, false)]
],
// 6. KING
[
[mirror_psqt(MG_KING_TABLE), mirror_psqt(EG_KING_TABLE)], // White
[MG_KING_TABLE, EG_KING_TABLE] // Black
[prepare_table(MG_KING_TABLE, MG_KING_VAL, true), prepare_table(EG_KING_TABLE, EG_KING_VAL, true)],
[prepare_table(MG_KING_TABLE, MG_KING_VAL, false), prepare_table(EG_KING_TABLE, EG_KING_VAL, false)]
],
];