155 lines
3.9 KiB
Rust
155 lines
3.9 KiB
Rust
use anyhow::{anyhow, bail, Result};
|
|
|
|
use crate::{
|
|
board::game::Game,
|
|
evaluation::{MATE_SCORE, MIN_SCORE},
|
|
};
|
|
|
|
use super::{
|
|
move_ordering::score_move,
|
|
quiescence::quiescence,
|
|
time::{hard_limit, TimeInfo},
|
|
transposition_table::TTEntry,
|
|
};
|
|
|
|
pub fn negamax(
|
|
game: &mut Game,
|
|
mut alpha: i32,
|
|
beta: i32,
|
|
depth: u8,
|
|
plies: u8,
|
|
time_info: &TimeInfo,
|
|
total_nodes_searched: &mut u64,
|
|
) -> Result<i32> {
|
|
if hard_limit(&time_info.time, time_info.remaining_time_in_ms) {
|
|
bail!("Time is up! In Negamax");
|
|
}
|
|
|
|
if plies != 0 && game.in_repetition() {
|
|
return Ok(0);
|
|
}
|
|
|
|
if depth == 0 {
|
|
let q_score = quiescence(game, alpha, beta, time_info, total_nodes_searched)
|
|
.map_err(|e| anyhow!("{e}"))?;
|
|
return Ok(q_score);
|
|
}
|
|
|
|
let mut legal_moves = 0;
|
|
let color = game.current_player();
|
|
let mut best_score = MIN_SCORE;
|
|
let mut best_move = None;
|
|
let mut moves = game.board.pseudo_moves_all();
|
|
let tt_move = game.tt.lookup(game.hash).and_then(|entry| entry.mv);
|
|
|
|
moves.sort_unstable_by_key(|mv| score_move(&game.mailbox, *mv, tt_move));
|
|
|
|
for mv in moves {
|
|
game.make_move(&mv);
|
|
|
|
if game.board.king_under_check(color) {
|
|
game.unmake_move();
|
|
continue;
|
|
}
|
|
legal_moves += 1;
|
|
*total_nodes_searched += 1;
|
|
|
|
let score = if legal_moves == 1 {
|
|
-negamax(
|
|
game,
|
|
-beta,
|
|
-alpha,
|
|
depth - 1,
|
|
plies + 1,
|
|
time_info,
|
|
total_nodes_searched,
|
|
)?
|
|
} else {
|
|
let mut score = -negamax(
|
|
game,
|
|
-alpha - 1,
|
|
-alpha,
|
|
depth - 1,
|
|
plies + 1,
|
|
time_info,
|
|
total_nodes_searched,
|
|
)?;
|
|
if score > alpha && score < beta {
|
|
score = -negamax(
|
|
game,
|
|
-beta,
|
|
-alpha,
|
|
depth - 1,
|
|
plies + 1,
|
|
time_info,
|
|
total_nodes_searched,
|
|
)?;
|
|
}
|
|
score
|
|
};
|
|
|
|
game.unmake_move();
|
|
|
|
if score > best_score {
|
|
best_score = score;
|
|
}
|
|
|
|
if score > alpha {
|
|
alpha = score;
|
|
best_move = Some(mv);
|
|
}
|
|
|
|
if score >= beta {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if legal_moves == 0 {
|
|
if game.board.king_under_check(color) {
|
|
return Ok(-MATE_SCORE + plies as i32);
|
|
}
|
|
return Ok(0);
|
|
}
|
|
|
|
game.tt.insert(TTEntry::new(game.hash, best_move));
|
|
Ok(best_score)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use crate::board::{fen::from_fen, square::Square};
|
|
use crate::evaluation::{MAX_SCORE, MIN_SCORE};
|
|
use crate::movegen::attack_generator::init_attacks;
|
|
use crate::movegen::r#move::Move;
|
|
use crate::search::negamax::negamax;
|
|
use crate::search::time::TimeInfo;
|
|
|
|
const FEN_MATE_IN_1: [&str; 2] = [
|
|
"8/8/8/8/8/4q1k1/8/5K2 b - - 0 1",
|
|
"8/8/8/8/8/4Q1K1/8/5k2 w - - 0 1",
|
|
];
|
|
|
|
#[test]
|
|
fn test_negamax() -> anyhow::Result<()> {
|
|
init_attacks();
|
|
let mut game = from_fen(FEN_MATE_IN_1[0]).unwrap();
|
|
|
|
let e3f2 = Move::new(Square::E3, Square::F2);
|
|
let time_info = TimeInfo::new(std::time::Instant::now(), 1000);
|
|
negamax(&mut game, MIN_SCORE, MAX_SCORE, 2, 0, &time_info, &mut 0)
|
|
.expect("Expected a search result");
|
|
|
|
assert_eq!(e3f2, game.tt.lookup(game.hash).unwrap().mv.unwrap());
|
|
|
|
let mut game = from_fen(FEN_MATE_IN_1[1]).unwrap();
|
|
|
|
let e3f2 = Move::new(Square::E3, Square::F2);
|
|
negamax(&mut game, MIN_SCORE, MAX_SCORE, 2, 0, &time_info, &mut 0)
|
|
.expect("Expected a search result");
|
|
|
|
assert_eq!(e3f2, game.tt.lookup(game.hash).unwrap().mv.unwrap());
|
|
|
|
Ok(())
|
|
}
|
|
}
|