alcibiades 0.2.2

A framework for writing chess engines in Rust
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

use std::sync::RwLock;
use std::cmp::min;
use std::time::SystemTime;
use board::*;
use search_executor::*;
use hash_table::Variation;
use search_node::SearchNode;
use time_manager::{TimeManager, RemainingTime};
use uci::{SetOption, OptionDescription};


/// Decides when the search must be terminated.
pub struct StdTimeManager {
    started_at: SystemTime,
    move_time_millis: u64, // move time in milliseconds
    must_play: bool,
}


impl<S> TimeManager<S> for StdTimeManager
    where S: SearchExecutor<ReportData = Vec<Variation>>
{
    #[allow(unused_variables)]
    fn new(position: &S::SearchNode, time: RemainingTime) -> StdTimeManager {
        // TODO: We ignore "PONDER".

        let (t, inc) = if position.board().to_move == WHITE {
            (time.white_millis, time.winc_millis)
        } else {
            (time.black_millis, time.binc_millis)
        };
        let movestogo = time.movestogo.unwrap_or(40);
        let movetime = (t + inc * movestogo) / movestogo;
        StdTimeManager {
            started_at: SystemTime::now(),
            move_time_millis: min(movetime, t / 2),
            must_play: false,
        }
    }

    #[allow(unused_variables)]
    fn update(&mut self, report: &SearchReport<Vec<Variation>>) {
        // TODO: Implement smarter time management.
        let duration = self.started_at.elapsed().unwrap();
        let duration_millis = 1000 * duration.as_secs() + duration.subsec_nanos() as u64 / 1000000;
        self.must_play = duration_millis >= self.move_time_millis;
    }

    #[allow(unused_variables)]
    fn must_play(&self, search: &S) -> bool {
        self.must_play
    }
}


impl SetOption for StdTimeManager {
    fn options() -> Vec<(String, OptionDescription)> {
        vec![("Ponder".to_string(), OptionDescription::Check { default: false })]
    }

    fn set_option(name: &str, value: &str) {
        if name == "Ponder" {
            match value {
                "true" => *PONDER.write().unwrap() = true,
                "false" => *PONDER.write().unwrap() = false,
                _ => (),
            }
        }
    }
}


lazy_static! {
    static ref PONDER: RwLock<bool> = RwLock::new(false);
}