goban 0.20.1

Library for Go move generation and Go ruling.
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

use sgf_parser::{Action, Outcome, RuleSet, SgfToken};

use crate::pieces::stones::{Color, Stone};
use crate::pieces::Nat;
use crate::rules::game::Game;
use crate::rules::game_builder::GameBuilder;
use crate::rules::{EndGame, Move, Rule, CHINESE, JAPANESE};

type SgfColor = sgf_parser::Color;

impl Game {
    pub fn from_sgf(sgf_str: &str) -> Result<Self, String> {
        let game_tree = match sgf_parser::parse(sgf_str) {
            Ok(game) => Ok(game),
            Err(e) => Err(e.to_string()),
        }?;
        let mut game_builder: GameBuilder = Default::default();
        let mut first = true;
        let mut moves = vec![];

        for node in game_tree.iter() {
            if first {
                // first token if the root token
                // Game information
                for token in &node.tokens {
                    match token {
                        SgfToken::Komi(komi) => {
                            game_builder.komi(*komi);
                        }
                        SgfToken::Size(x, y) => {
                            game_builder.size((*x as u8, *y as u8));
                        }
                        SgfToken::Result(o) => {
                            game_builder.outcome((*o).into());
                        }
                        SgfToken::Add {
                            color,
                            coordinate: (x, y),
                        } => {
                            game_builder.add(Stone {
                                coord: ((*y - 1) as Nat, (*x - 1) as Nat),
                                color: match color {
                                    SgfColor::Black => Color::Black,
                                    SgfColor::White => Color::White,
                                },
                            });
                        }
                        SgfToken::Rule(rule) => {
                            game_builder.rule(rule.clone().into());
                        }
                        SgfToken::Handicap(handicap) => {
                            game_builder.handicap(*handicap);
                        }
                        SgfToken::Game(go) => {
                            assert_eq!(*go, sgf_parser::Game::Go);
                        }

                        //TODO another options
                        _ => (),
                    }
                    for tokens in node.get_unknown_tokens() {
                        if let SgfToken::Unknown((key, value)) = tokens {
                            if key.as_str() == "PL" {
                                match value.as_str() {
                                    "B" => {
                                        game_builder.turn(Color::Black);
                                    }
                                    "W" => {
                                        game_builder.turn(Color::White);
                                    }
                                    _ => unreachable!(),
                                }
                            }
                        }
                    }
                }
                first = false;
            } else if !node.tokens.is_empty() {
                let token = node.tokens.first().unwrap();
                if let SgfToken::Move { action, .. } = token {
                    moves.push((*action).into());
                }
            }
        }
        game_builder.moves(&moves);
        game_builder.build()
    }
}

impl From<RuleSet> for Rule {
    fn from(r: RuleSet) -> Self {
        match r {
            RuleSet::Japanese => JAPANESE,
            RuleSet::Chinese => CHINESE,
            _ => panic!("The rule {} is not implemented yet !", r.to_string()),
        }
    }
}

impl From<SgfColor> for Color {
    fn from(x: sgf_parser::Color) -> Self {
        match x {
            SgfColor::Black => Self::Black,
            SgfColor::White => Self::White,
        }
    }
}

impl From<Outcome> for EndGame {
    fn from(o: Outcome) -> Self {
        match o {
            Outcome::WinnerByResign(c) => EndGame::WinnerByResign(c.into()),
            Outcome::WinnerByForfeit(c) => EndGame::WinnerByForfeit(c.into()),
            Outcome::WinnerByPoints(c, p) => EndGame::WinnerByScore(c.into(), p),
            Outcome::WinnerByTime(c) => EndGame::WinnerByTime(c.into()),
            Outcome::Draw => EndGame::Draw,
        }
    }
}

impl From<Action> for Move {
    fn from(a: Action) -> Self {
        match a {
            Action::Move(col, line) => Move::Play((line - 1) as Nat, (col - 1) as Nat),
            Action::Pass => Move::Pass,
        }
    }
}