timecat 1.52.0

A NNUE-based chess engine that implements the Negamax algorithm and can be integrated into any project as a library. It features move generation, advanced position evaluation through NNUE, and move searching capabilities.
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use super::*;

#[inline]
pub fn identity_function<T>(item: T) -> T {
    item
}

pub fn print_uci_info<T: fmt::Display>(message: &str, info: impl Into<Option<T>>) {
    if !GLOBAL_TIMECAT_STATE.is_in_debug_mode() {
        return;
    }
    let mut to_print = info.into().map_or_else(
        || message.colorize(SUCCESS_MESSAGE_STYLE),
        |info_message| {
            format!(
                "{} {}",
                message.colorize(SUCCESS_MESSAGE_STYLE),
                info_message.colorize(INFO_MESSAGE_STYLE),
            )
        },
    );
    if GLOBAL_TIMECAT_STATE.is_in_uci_mode() {
        to_print = format!("{} {to_print}", "info string".colorize(INFO_MESSAGE_STYLE))
    }
    println_wasm!("{to_print}");
}

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct TimecatDefaults {
    #[cfg(feature = "colored")]
    pub colored: bool,
    pub console_mode: bool,
    pub t_table_size: CacheTableSize,
    pub long_algebraic_notation: bool,
    pub num_threads: NonZeroUsize,
    pub move_overhead: Duration,
    pub use_own_book: bool,
    pub book_path: Option<&'static str>,
    pub inbuilt_book_bytes: Option<&'static [u8]>,
    pub debug_mode: bool,
    pub chess960_mode: bool,
}

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Debug)]
pub struct GlobalTimecatState {
    #[cfg(feature = "colored")]
    _colored: AtomicBool,
    _console_mode: AtomicBool,
    _long_algebraic_notation: AtomicBool,
    _debug_mode: AtomicBool,
}

impl Default for GlobalTimecatState {
    fn default() -> Self {
        Self::new()
    }
}

impl GlobalTimecatState {
    pub const fn new() -> Self {
        Self {
            #[cfg(feature = "colored")]
            _colored: AtomicBool::new(TIMECAT_DEFAULTS.colored),
            _console_mode: AtomicBool::new(TIMECAT_DEFAULTS.console_mode),
            _long_algebraic_notation: AtomicBool::new(TIMECAT_DEFAULTS.long_algebraic_notation),
            _debug_mode: AtomicBool::new(TIMECAT_DEFAULTS.debug_mode),
        }
    }

    #[inline]
    #[cfg(feature = "colored")]
    pub fn is_colored_output(&self) -> bool {
        self._colored.load(MEMORY_ORDERING)
    }

    #[inline]
    #[cfg(not(feature = "colored"))]
    pub fn is_colored(&self) -> bool {
        false
    }

    #[cfg(feature = "colored")]
    pub fn set_colored_output(&self, b: bool, verbose: bool) {
        self._colored.store(b, MEMORY_ORDERING);
        if verbose {
            print_uci_info("Colored output is set to", b);
        }
    }

    #[inline]
    pub fn is_in_console_mode(&self) -> bool {
        self._console_mode.load(MEMORY_ORDERING)
    }

    #[inline]
    pub fn is_in_uci_mode(&self) -> bool {
        !self.is_in_console_mode()
    }

    pub fn set_console_mode(&self, b: bool, verbose: bool) {
        self._console_mode.store(b, MEMORY_ORDERING);
        self._debug_mode.store(b, MEMORY_ORDERING);
        if verbose {
            force_println_info("Console mode is set to", b);
        }
    }

    pub fn set_uci_mode(&self, b: bool, verbose: bool) {
        self.set_console_mode(!b, false);
        if verbose {
            force_println_info("UCI mode is set to", b);
        }
    }

    #[inline]
    pub fn set_to_uci_mode(&self) {
        self.set_uci_mode(true, false);
    }

    #[inline]
    pub fn set_to_console_mode(&self) {
        self.set_console_mode(true, false);
    }

    #[inline]
    pub fn use_long_algebraic_notation(&self) -> bool {
        self._long_algebraic_notation.load(MEMORY_ORDERING)
    }

    pub fn set_long_algebraic_notation(&self, b: bool) {
        self._long_algebraic_notation.store(b, MEMORY_ORDERING);
        print_uci_info("Long algebraic notation is set to", b);
    }

    #[inline]
    pub fn is_in_debug_mode(&self) -> bool {
        self._debug_mode.load(MEMORY_ORDERING)
    }

    pub fn set_debug_mode(&self, b: bool) {
        self._debug_mode.store(b, MEMORY_ORDERING);
        print_uci_info("Debug Mode is set to", b);
    }
}