510 lines
14 KiB
Rust
510 lines
14 KiB
Rust
// https://red-bean.com/sgf/
|
|
// https://red-bean.com/sgf/user_guide/index.html
|
|
// https://red-bean.com/sgf/sgf4.html
|
|
|
|
// todo: support collections in a file
|
|
// Properties to support. Remove each one as it gets support.
|
|
// B
|
|
// KO
|
|
// MN
|
|
// W
|
|
// AB
|
|
// AE
|
|
// AW
|
|
// PL
|
|
// C
|
|
// DM
|
|
// GB
|
|
// GW
|
|
// HO
|
|
// N
|
|
// UC
|
|
// V
|
|
// BM
|
|
// DO
|
|
// IT
|
|
// TE
|
|
// AR
|
|
// CR
|
|
// DD
|
|
// LB
|
|
// LN
|
|
// MA
|
|
// SL
|
|
// SQ
|
|
// TR
|
|
// AP
|
|
// CA
|
|
// FF
|
|
// GM
|
|
// ST
|
|
// SZ
|
|
// AN
|
|
// BR
|
|
// BT
|
|
// CP
|
|
// DT
|
|
// EV
|
|
// GN
|
|
// GC
|
|
// ON
|
|
// OT
|
|
// PB
|
|
// PC
|
|
// PW
|
|
// RE
|
|
// RO
|
|
// RU
|
|
// SO
|
|
// TM
|
|
// US
|
|
// WR
|
|
// WT
|
|
// BL
|
|
// OB
|
|
// OW
|
|
// WL
|
|
// FG
|
|
// PM
|
|
// VW
|
|
|
|
use crate::{
|
|
date::{parse_date_field, Date},
|
|
tree::{Size, Tree},
|
|
Error,
|
|
};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::ops::Deref;
|
|
use typeshare::typeshare;
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct Game {
|
|
pub board_size: Size,
|
|
pub info: GameInfo,
|
|
|
|
pub tree: Tree,
|
|
}
|
|
|
|
impl Deref for Game {
|
|
type Target = Tree;
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.tree
|
|
}
|
|
}
|
|
|
|
impl TryFrom<Tree> for Game {
|
|
type Error = Error;
|
|
|
|
fn try_from(tree: Tree) -> Result<Self, Self::Error> {
|
|
let board_size = match tree.root.find_prop("SZ") {
|
|
Some(prop) => Size::try_from(prop.values[0].as_str())?,
|
|
None => Size {
|
|
width: 19,
|
|
height: 19,
|
|
},
|
|
};
|
|
let mut info = GameInfo::default();
|
|
info.app_name = tree.root.find_prop("AP").map(|prop| prop.values[0].clone());
|
|
|
|
info.game_name = tree.root.find_prop("GN").map(|prop| prop.values[0].clone());
|
|
|
|
info.black_player = tree.root.find_prop("PB").map(|prop| prop.values.join(", "));
|
|
|
|
info.black_rank = tree
|
|
.root
|
|
.find_prop("BR")
|
|
.and_then(|prop| Rank::try_from(prop.values[0].as_str()).ok());
|
|
|
|
info.white_player = tree.root.find_prop("PW").map(|prop| prop.values.join(", "));
|
|
|
|
info.white_rank = tree
|
|
.root
|
|
.find_prop("WR")
|
|
.and_then(|prop| Rank::try_from(prop.values[0].as_str()).ok());
|
|
|
|
info.result = tree
|
|
.root
|
|
.find_prop("RE")
|
|
.and_then(|prop| GameResult::try_from(prop.values[0].as_str()).ok());
|
|
|
|
info.time_limits = tree
|
|
.root
|
|
.find_prop("TM")
|
|
.and_then(|prop| prop.values[0].parse::<u64>().ok())
|
|
.and_then(|seconds| Some(std::time::Duration::from_secs(seconds)));
|
|
|
|
info.date = tree
|
|
.root
|
|
.find_prop("DT")
|
|
.and_then(|prop| {
|
|
let v = prop
|
|
.values
|
|
.iter()
|
|
.map(|val| parse_date_field(val))
|
|
.fold(Ok(vec![]), |acc, v| match (acc, v) {
|
|
(Ok(mut acc), Ok(mut values)) => {
|
|
acc.append(&mut values);
|
|
Ok(acc)
|
|
}
|
|
(Ok(_), Err(err)) => Err(err),
|
|
(Err(err), _) => Err(err),
|
|
})
|
|
.ok()?;
|
|
Some(v)
|
|
})
|
|
.unwrap_or(vec![]);
|
|
|
|
info.event = tree.root.find_prop("EV").map(|prop| prop.values.join(", "));
|
|
|
|
info.round = tree.root.find_prop("RO").map(|prop| prop.values.join(", "));
|
|
|
|
info.source = tree.root.find_prop("SO").map(|prop| prop.values.join(", "));
|
|
|
|
info.game_keeper = tree.root.find_prop("US").map(|prop| prop.values.join(", "));
|
|
|
|
Ok(Game {
|
|
board_size,
|
|
info,
|
|
|
|
tree,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[typeshare]
|
|
pub enum Rank {
|
|
Kyu(u8),
|
|
Dan(u8),
|
|
Pro(u8),
|
|
}
|
|
|
|
impl TryFrom<&str> for Rank {
|
|
type Error = String;
|
|
fn try_from(r: &str) -> Result<Rank, Self::Error> {
|
|
let parts = r.split(" ").map(|s| s.to_owned()).collect::<Vec<String>>();
|
|
let cnt = parts[0].parse::<u8>().map_err(|err| format!("{:?}", err))?;
|
|
match parts[1].to_ascii_lowercase().as_str() {
|
|
"kyu" => Ok(Rank::Kyu(cnt)),
|
|
"dan" => Ok(Rank::Dan(cnt)),
|
|
"pro" => Ok(Rank::Pro(cnt)),
|
|
_ => Err("unparsable".to_owned()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ToString for Rank {
|
|
fn to_string(&self) -> String {
|
|
unimplemented!()
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, Default)]
|
|
pub struct GameInfo {
|
|
pub app_name: Option<String>,
|
|
pub annotator: Option<String>,
|
|
pub copyright: Option<String>,
|
|
pub event: Option<String>,
|
|
// Games can be played across multiple days, even multiple years. The format specifies
|
|
// shortcuts.
|
|
pub date: Vec<Date>,
|
|
pub location: Option<String>,
|
|
// special rules for the round-number and type
|
|
pub round: Option<String>,
|
|
pub ruleset: Option<String>,
|
|
pub source: Option<String>,
|
|
pub time_limits: Option<std::time::Duration>,
|
|
pub game_keeper: Option<String>,
|
|
pub komi: Option<f32>,
|
|
|
|
pub game_name: Option<String>,
|
|
pub game_comments: Option<String>,
|
|
|
|
pub black_player: Option<String>,
|
|
pub black_rank: Option<Rank>,
|
|
pub black_team: Option<String>,
|
|
|
|
pub white_player: Option<String>,
|
|
pub white_rank: Option<Rank>,
|
|
pub white_team: Option<String>,
|
|
|
|
pub opening: Option<String>,
|
|
pub overtime: Option<String>,
|
|
pub result: Option<GameResult>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum GameResult {
|
|
Annulled,
|
|
Draw,
|
|
Black(Win),
|
|
White(Win),
|
|
Unknown(String),
|
|
}
|
|
|
|
impl TryFrom<&str> for GameResult {
|
|
type Error = String;
|
|
fn try_from(s: &str) -> Result<GameResult, Self::Error> {
|
|
if s == "0" {
|
|
Ok(GameResult::Draw)
|
|
} else if s == "Void" {
|
|
Ok(GameResult::Annulled)
|
|
} else {
|
|
let parts = s.split("+").collect::<Vec<&str>>();
|
|
let res = match parts[0].to_ascii_lowercase().as_str() {
|
|
"b" => GameResult::Black,
|
|
"w" => GameResult::White,
|
|
_ => return Ok(GameResult::Unknown(parts[0].to_owned())),
|
|
};
|
|
match parts[1].to_ascii_lowercase().as_str() {
|
|
"r" | "resign" => Ok(res(Win::Resignation)),
|
|
"t" | "time" => Ok(res(Win::Time)),
|
|
"f" | "forfeit" => Ok(res(Win::Forfeit)),
|
|
_ => {
|
|
let score = parts[1].parse::<f32>().unwrap();
|
|
Ok(res(Win::Score(score)))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum Win {
|
|
Score(f32),
|
|
Resignation,
|
|
Forfeit,
|
|
Time,
|
|
}
|
|
|
|
/*
|
|
enum PropType {
|
|
Move,
|
|
Setup,
|
|
Root,
|
|
GameInfo,
|
|
}
|
|
|
|
enum PropValue {
|
|
Empty,
|
|
Number,
|
|
Real,
|
|
Double,
|
|
Color,
|
|
SimpleText,
|
|
Text,
|
|
Point,
|
|
Move,
|
|
Stone,
|
|
}
|
|
*/
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::{
|
|
date::Date,
|
|
tree::{parse_collection, Property, Size},
|
|
};
|
|
use std::fs::File;
|
|
use std::io::Read;
|
|
|
|
const EXAMPLE: &'static str = "(;FF[4]C[root](;C[a];C[b](;C[c])
|
|
(;C[d];C[e]))
|
|
(;C[f](;C[g];C[h];C[i])
|
|
(;C[j])))";
|
|
|
|
fn with_text(text: &str, f: impl FnOnce(Vec<Game>)) {
|
|
let (_, games) = parse_collection::<nom::error::VerboseError<&str>>(text).unwrap();
|
|
let games = games
|
|
.into_iter()
|
|
.map(|game| Game::try_from(game).expect("game to parse"))
|
|
.collect::<Vec<Game>>();
|
|
f(games);
|
|
}
|
|
|
|
fn with_file(path: &std::path::Path, f: impl FnOnce(Vec<Game>)) {
|
|
let mut file = File::open(path).unwrap();
|
|
let mut text = String::new();
|
|
let _ = file.read_to_string(&mut text);
|
|
with_text(&text, f);
|
|
}
|
|
|
|
#[test]
|
|
fn it_parses_game_root() {
|
|
with_text(EXAMPLE, |trees| {
|
|
assert_eq!(trees.len(), 1);
|
|
let tree = &trees[0];
|
|
assert_eq!(tree.info.app_name, None);
|
|
assert_eq!(
|
|
tree.board_size,
|
|
Size {
|
|
width: 19,
|
|
height: 19
|
|
}
|
|
);
|
|
// assert_eq!(tree.text, EXAMPLE.to_owned());
|
|
});
|
|
|
|
with_file(std::path::Path::new("test_data/print1.sgf"), |trees| {
|
|
assert_eq!(trees.len(), 1);
|
|
let tree = &trees[0];
|
|
assert_eq!(tree.info.app_name, None);
|
|
assert_eq!(
|
|
tree.board_size,
|
|
Size {
|
|
width: 19,
|
|
height: 19
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn it_parses_game_info() {
|
|
with_file(std::path::Path::new("test_data/print1.sgf"), |trees| {
|
|
assert_eq!(trees.len(), 1);
|
|
let tree = &trees[0];
|
|
assert_eq!(tree.info.black_player, Some("Takemiya Masaki".to_owned()));
|
|
assert_eq!(tree.info.black_rank, Some(Rank::Dan(9)));
|
|
assert_eq!(tree.info.white_player, Some("Cho Chikun".to_owned()));
|
|
assert_eq!(tree.info.white_rank, Some(Rank::Dan(9)));
|
|
assert_eq!(tree.info.result, Some(GameResult::White(Win::Resignation)));
|
|
assert_eq!(
|
|
tree.info.time_limits,
|
|
Some(std::time::Duration::from_secs(28800))
|
|
);
|
|
assert_eq!(
|
|
tree.info.date,
|
|
vec![
|
|
Date::Date(chrono::NaiveDate::from_ymd_opt(1996, 10, 18).unwrap()),
|
|
Date::Date(chrono::NaiveDate::from_ymd_opt(1996, 10, 19).unwrap()),
|
|
]
|
|
);
|
|
assert_eq!(tree.info.event, Some("21st Meijin".to_owned()));
|
|
assert_eq!(tree.info.round, Some("2 (final)".to_owned()));
|
|
assert_eq!(tree.info.source, Some("Go World #78".to_owned()));
|
|
assert_eq!(tree.info.game_keeper, Some("Arno Hollosi".to_owned()));
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn it_presents_the_mainline_of_game_without_branches() {
|
|
with_file(
|
|
std::path::Path::new("test_data/2020 USGO DDK, Round 1.sgf"),
|
|
|trees| {
|
|
assert_eq!(trees.len(), 1);
|
|
let tree = &trees[0];
|
|
|
|
let node = &tree.root;
|
|
assert_eq!(node.properties.len(), 16);
|
|
let expected_properties = vec![
|
|
Property {
|
|
ident: "GM".to_owned(),
|
|
values: vec!["1".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "FF".to_owned(),
|
|
values: vec!["4".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "CA".to_owned(),
|
|
values: vec!["UTF-8".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "AP".to_owned(),
|
|
values: vec!["CGoban:3".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "ST".to_owned(),
|
|
values: vec!["2".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "RU".to_owned(),
|
|
values: vec!["AGA".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "SZ".to_owned(),
|
|
values: vec!["19".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "KM".to_owned(),
|
|
values: vec!["7.50".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "TM".to_owned(),
|
|
values: vec!["1800".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "OT".to_owned(),
|
|
values: vec!["5x30 byo-yomi".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "PW".to_owned(),
|
|
values: vec!["Geckoz".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "PB".to_owned(),
|
|
values: vec!["savanni".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "BR".to_owned(),
|
|
values: vec!["23k".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "DT".to_owned(),
|
|
values: vec!["2020-08-05".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "PC".to_owned(),
|
|
values: vec!["The KGS Go Server at http://www.gokgs.com/".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "RE".to_owned(),
|
|
values: vec!["W+17.50".to_owned()],
|
|
},
|
|
];
|
|
|
|
for i in 0..16 {
|
|
assert_eq!(node.properties[i], expected_properties[i]);
|
|
}
|
|
|
|
let node = node.next().unwrap();
|
|
let expected_properties = vec![
|
|
Property {
|
|
ident: "B".to_owned(),
|
|
values: vec!["pp".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "BL".to_owned(),
|
|
values: vec!["1795.449".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "C".to_owned(),
|
|
values: vec!["Geckoz [?]: Good game\nsavanni [23k?]: There we go! This UI is... tough.\nsavanni [23k?]: Have fun! Talk to you at the end.\nGeckoz [?]: Yeah, OGS is much better; I'm a UX professional\n".to_owned()],
|
|
}
|
|
];
|
|
|
|
for i in 0..3 {
|
|
assert_eq!(node.properties[i], expected_properties[i]);
|
|
}
|
|
|
|
let node = node.next().unwrap();
|
|
let expected_properties = vec![
|
|
Property {
|
|
ident: "W".to_owned(),
|
|
values: vec!["dp".to_owned()],
|
|
},
|
|
Property {
|
|
ident: "WL".to_owned(),
|
|
values: vec!["1765.099".to_owned()],
|
|
},
|
|
];
|
|
for i in 0..2 {
|
|
assert_eq!(node.properties[i], expected_properties[i]);
|
|
}
|
|
},
|
|
);
|
|
}
|
|
}
|