// 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::{self, parse_date_field, Date}, tree::{parse_collection, ParseSizeError, Size}, }; use serde::{Deserialize, Serialize}; use typeshare::typeshare; #[derive(Debug)] pub enum Error<'a> { InvalidField, InvalidBoardSize, Incomplete, InvalidSgf(nom::error::VerboseError<&'a str>), } impl<'a> From>> for Error<'a> { fn from(err: nom::Err>) -> Self { match err { nom::Err::Incomplete(_) => Error::Incomplete, nom::Err::Error(e) => Error::InvalidSgf(e.clone()), nom::Err::Failure(e) => Error::InvalidSgf(e.clone()), } } } impl<'a> From for Error<'a> { fn from(_: ParseSizeError) -> Self { Self::InvalidBoardSize } } #[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 { let parts = r.split(" ").map(|s| s.to_owned()).collect::>(); let cnt = parts[0].parse::().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)] pub struct GameTree { pub file_format: i8, pub app_name: Option, pub game_type: GameType, pub board_size: Size, pub info: GameInfo, // pub text: String, } #[derive(Clone, Debug, Default)] pub struct GameInfo { pub annotator: Option, pub copyright: Option, pub event: Option, // Games can be played across multiple days, even multiple years. The format specifies // shortcuts. pub date: Vec, pub location: Option, // special rules for the round-number and type pub round: Option, pub ruleset: Option, pub source: Option, pub time_limits: Option, pub game_keeper: Option, pub komi: Option, pub game_name: Option, pub game_comments: Option, pub black_player: Option, pub black_rank: Option, pub black_team: Option, pub white_player: Option, pub white_rank: Option, pub white_team: Option, pub opening: Option, pub overtime: Option, pub result: Option, } #[derive(Clone, Debug, PartialEq)] pub enum GameResult { Annulled, Draw, Black(Win), White(Win), } impl TryFrom<&str> for GameResult { type Error = String; fn try_from(s: &str) -> Result { if s == "0" { Ok(GameResult::Draw) } else if s == "Void" { Ok(GameResult::Annulled) } else { let parts = s.split("+").collect::>(); let res = match parts[0].to_ascii_lowercase().as_str() { "b" => GameResult::Black, "w" => GameResult::White, _ => panic!("unknown result format"), }; 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::().unwrap(); Ok(res(Win::Score(score))) } } } } } #[derive(Clone, Debug, PartialEq)] pub enum Win { Score(f32), Resignation, Forfeit, Time, } #[derive(Clone, Debug, PartialEq)] pub enum GameType { Go, Unsupported, } /* enum PropType { Move, Setup, Root, GameInfo, } enum PropValue { Empty, Number, Real, Double, Color, SimpleText, Text, Point, Move, Stone, } */ pub fn parse_sgf<'a>(input: &'a str) -> Result, Error<'a>> { let (_, trees) = parse_collection::>(input)?; let games = trees .into_iter() .map(|tree| { let file_format = match tree.sequence[0].find_prop("FF") { Some(prop) => prop.values[0].parse::().unwrap(), None => 4, }; let app_name = tree.sequence[0] .find_prop("AP") .map(|prop| prop.values[0].clone()); let board_size = match tree.sequence[0].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.black_player = tree.sequence[0] .find_prop("PB") .map(|prop| prop.values.join(", ")); info.black_rank = tree.sequence[0] .find_prop("BR") .and_then(|prop| Rank::try_from(prop.values[0].as_str()).ok()); info.white_player = tree.sequence[0] .find_prop("PW") .map(|prop| prop.values.join(", ")); info.white_rank = tree.sequence[0] .find_prop("WR") .and_then(|prop| Rank::try_from(prop.values[0].as_str()).ok()); info.result = tree.sequence[0] .find_prop("RE") .and_then(|prop| GameResult::try_from(prop.values[0].as_str()).ok()); info.time_limits = tree.sequence[0] .find_prop("TM") .and_then(|prop| prop.values[0].parse::().ok()) .and_then(|seconds| Some(std::time::Duration::from_secs(seconds))); info.date = tree.sequence[0] .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.sequence[0] .find_prop("EV") .map(|prop| prop.values.join(", ")); info.round = tree.sequence[0] .find_prop("RO") .map(|prop| prop.values.join(", ")); info.source = tree.sequence[0] .find_prop("SO") .map(|prop| prop.values.join(", ")); info.game_keeper = tree.sequence[0] .find_prop("US") .map(|prop| prop.values.join(", ")); Ok(GameTree { file_format, app_name, game_type: GameType::Go, board_size, info, }) }) .collect::, Error>>()?; Ok(games) } #[cfg(test)] mod tests { use super::*; use crate::{date::Date, tree::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)) { let games = parse_sgf(text).unwrap(); f(games); } fn with_file(path: &std::path::Path, f: impl FnOnce(Vec)) { 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.file_format, 4); assert_eq!(tree.app_name, None); assert_eq!(tree.game_type, GameType::Go); 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.file_format, 4); assert_eq!(tree.app_name, None); assert_eq!(tree.game_type, GameType::Go); 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())); }); } }