giga-chess 0.8.2

A rust chess library built for performance, handling game logic and legal/best move generation.
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

use chrono::Local;

#[derive(Debug, Default, Clone, Eq, PartialEq)]
#[cfg_attr(feature = "bincode", derive(bincode::Encode, bincode::Decode))]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PGNMetadata {
    event: Option<String>,
    site: Option<String>,
    date: Option<String>,
    round: Option<String>,
    white: Option<String>,
    black: Option<String>,
}

impl PGNMetadata {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn now() -> Self {
        let date = Local::now().format("%Y.%m.%d").to_string();
        Self {
            date: Some(date),
            ..Self::default()
        }
    }

    pub fn format(&self, result: Option<&str>, fen: Option<&str>) -> String {
        let mut pgn = String::new();
        if let Some(event) = &self.event {
            pgn.push_str(&format!("[Event \"{}\"]\n", event));
        }
        if let Some(site) = &self.site {
            pgn.push_str(&format!("[Site \"{}\"]\n", site));
        }
        if let Some(date) = &self.date {
            pgn.push_str(&format!("[Date \"{}\"]\n", date));
        }
        if let Some(round) = &self.round {
            pgn.push_str(&format!("[Round \"{}\"]\n", round));
        }
        if let Some(white) = &self.white {
            pgn.push_str(&format!("[White \"{}\"]\n", white));
        }
        if let Some(black) = &self.black {
            pgn.push_str(&format!("[Black \"{}\"]\n", black));
        }
        if let Some(result) = result {
            pgn.push_str(&format!("[Result \"{}\"]\n", result));
        }
        if let Some(fen) = fen {
            pgn.push_str(&format!("[FEN \"{}\"]\n", fen));
        }
        pgn
    }

    pub fn event(self, event: &str) -> Self {
        Self {
            event: Some(event.to_string()),
            ..self
        }
    }

    pub fn site(self, site: &str) -> Self {
        Self {
            site: Some(site.to_string()),
            ..self
        }
    }

    pub fn date(self, date: &str) -> Self {
        Self {
            date: Some(date.to_string()),
            ..self
        }
    }

    pub fn round(self, round: &str) -> Self {
        Self {
            round: Some(round.to_string()),
            ..self
        }
    }

    pub fn white(self, white: &str) -> Self {
        Self {
            white: Some(white.to_string()),
            ..self
        }
    }

    pub fn black(self, black: &str) -> Self {
        Self {
            black: Some(black.to_string()),
            ..self
        }
    }
}