ucui 0.1.4

A minimal UCI engine frontend experiment
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

use std::{str::FromStr, sync::mpsc::channel, thread};

use blunders_engine::Fen as _;
use shakmaty::{Chess, FromSetup as _, Move};
use shakmaty_uci::{ParseUciMoveError, UciMove};

use crate::state::Store;

use super::Engine;

pub struct BlunderEngine {
    store: Store,
}

fn to_move(r: blunders_engine::SearchResult, game: &Chess) -> Option<Move> {
    let bm = r.best_move;
    UciMove::from_str(&format!("{}", bm))
        .and_then(|um| um.to_move(game).map_err(|_| ParseUciMoveError))
        .ok()

    // match best_move_uci.to_move(game) {
    //     Err(e) => log::error!(
    //         "Failed to produce a bestmove from {best_move_uci}: {} ({})",
    //         e,
    //         Fen::from_position(game.clone(), shakmaty::EnPassantMode::Always)
    //     ),
    //     Ok(m) => self.store.update_engine(EngineState::PendingMove(m)),
    // }
}

impl Engine for BlunderEngine {
    fn new_game(&self) {}

    fn go(
        &self,
        fen: shakmaty::fen::Fen,
        white_time: chrono::Duration,
        black_time: chrono::Duration,
    ) {
        if let Ok(pos) = blunders_engine::Position::parse_fen(&fen.to_string()) {
            let (tx, rx) = channel::<blunders_engine::SearchResult>();
            let store = self.store.clone();
            let game = Chess::from_setup(fen.as_setup().clone(), shakmaty::CastlingMode::Standard)
                .unwrap();
            let mut engine = blunders_engine::EngineBuilder::new()
                .position(pos)
                .transpositions_mb(10)
                .debug(false)
                .build();

            thread::spawn(move || {
                rx.recv().map(|result| {
                    let m =
                        to_move(result, &game).expect("blunders move failed to parse correctly");
                    store.update_engine(super::EngineState::PendingMove(m));
                })
            });

            let _ = engine.search(
                blunders_engine::Mode::standard(
                    white_time.num_milliseconds() as i32,
                    black_time.num_milliseconds() as i32,
                    None,
                    None,
                    None,
                    None,
                ),
                tx,
            );
        }
    }
}

pub fn connect_engine(store: Store) -> BlunderEngine {
    BlunderEngine { store }
}