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

use super::*;

#[cfg(feature = "nnue_reader")]
pub mod evaluate_nnue;
pub mod evaluate_non_nnue;

#[cfg(feature = "nnue_reader")]
pub use evaluate_nnue::*;
pub use evaluate_non_nnue::*;

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Clone, Default, Debug)]
pub struct Evaluator {
    #[cfg(feature = "inbuilt_nnue")]
    inner_evaluator: EvaluatorNNUE,
    #[cfg(not(feature = "inbuilt_nnue"))]
    inner_evaluator: EvaluatorNonNNUE,
}

impl Evaluator {
    pub fn new(position: &ChessPosition) -> Self {
        Self {
            #[cfg(feature = "inbuilt_nnue")]
            inner_evaluator: EvaluatorNNUE::new(position),
            #[cfg(not(feature = "inbuilt_nnue"))]
            inner_evaluator: EvaluatorNonNNUE::new(position),
        }
    }

    pub fn slow_evaluate(position: &ChessPosition) -> Score {
        #[cfg(feature = "inbuilt_nnue")]
        {
            EvaluatorNNUE::slow_evaluate(position)
        }
        #[cfg(not(feature = "inbuilt_nnue"))]
        {
            EvaluatorNonNNUE::slow_evaluate(position)
        }
    }
}

impl PositionEvaluation for Evaluator {
    fn evaluate(&mut self, position: &ChessPosition) -> Score {
        self.inner_evaluator.evaluate(position)
    }

    fn reset_variables(&mut self) {
        self.inner_evaluator.reset_variables()
    }

    fn clear(&mut self) {
        self.inner_evaluator.clear()
    }

    fn print_info(&self) {
        self.inner_evaluator.print_info()
    }

    fn evaluate_flipped(&mut self, position: &ChessPosition) -> Score {
        self.inner_evaluator.evaluate_flipped(position)
    }

    fn evaluate_checkmate_in(&mut self, mate_distance: Ply) -> Score {
        self.inner_evaluator.evaluate_checkmate_in(mate_distance)
    }
}

impl Deref for Evaluator {
    #[cfg(feature = "inbuilt_nnue")]
    type Target = EvaluatorNNUE;
    #[cfg(not(feature = "inbuilt_nnue"))]
    type Target = EvaluatorNonNNUE;

    fn deref(&self) -> &Self::Target {
        &self.inner_evaluator
    }
}

impl DerefMut for Evaluator {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner_evaluator
    }
}