sisyphus32 1.1.0

Feature-based UCI Chess Engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use std::time::Duration;
use serde::Deserialize;

use crate::{BitMove, Color, FenString, Legal, MoveGeneration, Position, Uci};

const NUM_GAMES_THRESHOLD: u32 = 1_000;
const WINRATE_THRESHOLD: f32 = 0.35;
const OPENING_BOOK_TIMEOUT_MS: u64 = 500;

#[derive(Deserialize)]
struct LichessOpeningStats {
    moves: Vec<LichessMoveStats>,
}

#[derive(Deserialize)]
struct LichessMoveStats {
    uci: String,
    white: u32,
    draws: u32,
    black: u32,
}

impl LichessMoveStats {
    #[inline(always)]
    fn has_enough_games(&self) -> bool {
        self.white + self.draws + self.black >= NUM_GAMES_THRESHOLD
    }
    
    #[inline(always)]
    fn has_acceptable_winrate(&self, side: Color) -> bool {
        let (playing_side, opposing_side) = match side {
            Color::White => (self.white, self.black),
            Color::Black => (self.black, self.white),
        };

        // NOTE: To prevent dividing by zero
        if opposing_side == 0 {
            return playing_side > 0;
        }

        playing_side as f32 / (playing_side + opposing_side) as f32 > WINRATE_THRESHOLD
    }

    #[inline(always)]
    fn is_candidate(&self, side: Color) -> bool {
        self.has_enough_games() && self.has_acceptable_winrate(side)
    }
}

impl LichessOpeningStats {
    #[inline(always)]
    fn get_opening_move_contenders(&self, position: &Position) -> Vec<BitMove> {
        let legal_moves = MoveGeneration::generate_moves::<BitMove, Legal>(position);
        self.moves
            .iter()
            .filter_map(|opening_move| {
                if opening_move.is_candidate(position.side) {
                    Uci::parse_move_string(&legal_moves, &opening_move.uci).ok()
                } else {
                    None
                }
            })
            .collect()
    }
}

#[cfg(feature = "unit_opening_book")]
pub(crate) struct OpeningBook {
    agent: ureq::Agent
}

#[cfg(feature = "unit_opening_book")]
impl Default for OpeningBook {
    fn default() -> Self {
        Self {
            agent: ureq::Agent::config_builder()
                .timeout_global(Some(Duration::from_millis(OPENING_BOOK_TIMEOUT_MS)))
                .build()
                .into()
        }
    }
}

#[cfg(feature = "unit_opening_book")]
impl OpeningBook {
    fn get_lichess_opening_stats(&self, position: &Position) -> Result<LichessOpeningStats, ureq::Error> {
        let fen_string = FenString::from(position);
        let fen_with_replaced_spaces = fen_string.to_string().replace(" ", "_");
        let uri = &format!("https://explorer.lichess.ovh/masters?fen={fen_with_replaced_spaces}");
        let resp = self.agent.get(uri).call();
        let body = resp?.body_mut().read_to_string()?;
        let lichess_opening_stats: LichessOpeningStats = serde_json::from_str(&body)
            .map_err(ureq::Error::Json)?;
        Ok(lichess_opening_stats)
    }

    pub(crate) fn get_move(&self, position: &Position) -> Option<BitMove> {
        let lichess_opening_stats = self.get_lichess_opening_stats(position).ok()?;
        let opening_move_contenders = lichess_opening_stats.get_opening_move_contenders(position);
        rand::seq::IteratorRandom::choose(opening_move_contenders.iter(), &mut rand::rng()).copied()
    }
}

#[cfg(not(feature = "unit_opening_book"))]
pub(crate) struct OpeningBook;

#[cfg(not(feature = "unit_opening_book"))]
impl Default for OpeningBook {
    fn default() -> Self {
        Self
    }
}

#[cfg(not(feature = "unit_opening_book"))]
impl OpeningBook {
    pub(crate) fn get_move(&self, _position: &Position) -> Option<BitMove> {
        None
    }
}