hexe 0.0.5

A 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

use super::*;
use std::fmt;
use std::sync::Arc;

/// A partial game state representation. Responsible for tracking [`Position`]
/// history.
///
/// [`Position`]: struct.Position.html
#[derive(Clone)]
pub struct State {
    /// The previous state. Acts as a linked list of move history.
    pub(super) prev: Option<Arc<State>>,

    /// The square used in an en passant capture, if any.
    pub(super) en_passant: Option<Square>,

    /// The castle rights for both players.
    pub(super) rights: Rights,
}

impl PartialEq for State {
    fn eq(&self, other: &State) -> bool {
        // Updated with previous states
        let mut this = self;
        let mut that = other;

        loop {
            if this.rights     == that.rights
            && this.en_passant == that.en_passant {
                match (&this.prev, &that.prev) {
                    (&Some(ref a), &Some(ref b)) => {
                        // Short circuit if same history
                        if Arc::ptr_eq(a, b) {
                            return true;
                        }
                        this = a;
                        that = b;
                    },
                    (&None, &None) => return true,
                    _ => return false,
                }
            } else {
                return false;
            }
        }
    }
}

impl Eq for State {}

impl Default for State {
    #[inline]
    fn default() -> State { State::STANDARD }
}

impl fmt::Debug for State {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("State")
            .field("prev",       &self.prev())
            .field("en_passant", &self.en_passant())
            .field("rights",     &self.rights())
            .finish()
    }
}

impl State {
    pub(crate) const STANDARD: State = State {
        prev: None,
        en_passant: None,
        rights: Rights::FULL,
    };

    /// Returns the previous state.
    #[inline]
    pub fn prev(&self) -> Option<&State> {
        self.prev.as_ref().map(AsRef::as_ref)
    }

    /// Returns the en passant square.
    #[inline]
    pub fn en_passant(&self) -> Option<Square> {
        self.en_passant
    }

    /// Returns the castle rights for both players.
    #[inline]
    pub fn rights(&self) -> Rights {
        self.rights
    }
}