From c07e793b55dc86946998fa649eecd25896707e4f Mon Sep 17 00:00:00 2001 From: Savanni D'Gerinel Date: Fri, 15 Sep 2023 12:10:10 -0400 Subject: [PATCH] Set up an overarching game data structure --- sgf/src/game.rs | 278 +++++++++++++++++++++++++++++++++++++++++----- sgf/src/go.rs | 120 +------------------- sgf/src/parser.rs | 4 +- sgf/src/types.rs | 4 +- 4 files changed, 255 insertions(+), 151 deletions(-) diff --git a/sgf/src/game.rs b/sgf/src/game.rs index 7ba5aed..143786d 100644 --- a/sgf/src/game.rs +++ b/sgf/src/game.rs @@ -1,6 +1,6 @@ use crate::{ - parser::{self, Annotation, Evaluation, SetupInstr, UnknownProperty}, - Color, + parser::{self, Annotation, Evaluation, GameType, SetupInstr, Size, UnknownProperty}, + Color, Date, GameResult, }; use std::{collections::HashSet, time::Duration}; use uuid::Uuid; @@ -17,11 +17,106 @@ pub enum SetupNodeError { ConflictingPosition, } +#[derive(Clone, Debug, PartialEq)] +pub enum GameError { + InvalidGame, +} + #[derive(Clone, Debug, PartialEq)] pub enum GameNodeError { UnsupportedGameNode, } +#[derive(Clone, Debug, PartialEq, Default)] +pub struct Player { + pub name: Option, + pub rank: Option, + pub team: Option, +} + +#[derive(Clone, Debug, PartialEq)] +pub struct Game { + game_type: GameType, + + // TODO: board size is not necessary in all games. Hive has no defined board size. + board_size: Size, + black_player: Player, + white_player: Player, + + app: Option, + annotator: Option, + copyright: Option, + dates: Vec, + event: Option, + game_name: Option, + extra_info: Option, + opening_info: Option, + location: Option, + result: GameResult, + round: Option, + rules: Option, + source: Option, + time_limit: Option, + overtime: Option, + data_entry: Option, + + children: Vec, +} + +impl Game { + fn new( + game_type: GameType, + board_size: Size, + black_player: Player, + white_player: Player, + ) -> Self { + Self { + game_type, + board_size, + black_player, + white_player, + + app: None, + annotator: None, + copyright: None, + dates: vec![], + event: None, + game_name: None, + extra_info: None, + opening_info: None, + location: None, + result: GameResult::Unknown, + round: None, + rules: None, + source: None, + time_limit: None, + overtime: None, + data_entry: None, + + children: vec![], + } + } +} + +impl Node for Game { + fn children<'a>(&'a self) -> Vec<&'a GameNode> { + self.children.iter().collect::>() + } + + fn add_child<'a>(&'a mut self, node: GameNode) -> &'a mut GameNode { + self.children.push(node); + self.children.last_mut().unwrap() + } +} + +impl TryFrom<&parser::Tree> for Game { + type Error = GameError; + + fn try_from(tree: &parser::Tree) -> Result { + unimplemented!() + } +} + #[derive(Clone, Debug, PartialEq)] pub enum GameNode { MoveNode(MoveNode), @@ -89,28 +184,6 @@ impl TryFrom<&parser::Node> for GameNode { } } -// Root node -pub struct GameTree { - children: Vec, -} - -impl GameTree { - fn new() -> Self { - Self { children: vec![] } - } -} - -impl Node for GameTree { - fn children<'a>(&'a self) -> Vec<&'a GameNode> { - self.children.iter().collect::>() - } - - fn add_child<'a>(&'a mut self, node: GameNode) -> &'a mut GameNode { - self.children.push(node); - self.children.last_mut().unwrap() - } -} - #[derive(Clone, Debug, PartialEq)] pub struct MoveNode { id: Uuid, @@ -289,20 +362,36 @@ mod test { #[test] fn it_can_create_an_empty_game_tree() { - let tree = GameTree::new(); + let tree = Game::new( + GameType::Go, + Size { + width: 19, + height: 19, + }, + Player::default(), + Player::default(), + ); assert_eq!(tree.nodes().len(), 0); } #[test] fn it_can_add_moves_to_a_game() { - let mut tree = GameTree::new(); + let mut game = Game::new( + GameType::Go, + Size { + width: 19, + height: 19, + }, + Player::default(), + Player::default(), + ); let first_move = MoveNode::new(Color::Black, "dd".to_owned()); - let first_ = tree.add_child(GameNode::MoveNode(first_move.clone())); + let first_ = game.add_child(GameNode::MoveNode(first_move.clone())); let second_move = MoveNode::new(Color::White, "qq".to_owned()); first_.add_child(GameNode::MoveNode(second_move.clone())); - let nodes = tree.nodes(); + let nodes = game.nodes(); assert_eq!(nodes.len(), 2); assert_eq!(nodes[0].id(), first_move.id); assert_eq!(nodes[1].id(), second_move.id); @@ -436,3 +525,136 @@ mod path_test { unimplemented!() } } + +#[cfg(test)] +mod file_test { + use crate::Win; + + use super::*; + use parser::parse_collection; + use std::{fs::File, io::Read}; + + fn with_text(text: &str, f: impl FnOnce(Vec)) { + let (_, games) = parse_collection::>(text).unwrap(); + let games = games + .into_iter() + .map(|game| Game::try_from(&game).expect("game to parse")) + .collect::>(); + 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_can_load_basic_game_records() { + with_file( + std::path::Path::new("test_data/2020 USGO DDK, Round 1.sgf"), + |games| { + assert_eq!(games.len(), 1); + let game = &games[0]; + + assert_eq!(game.game_type, GameType::Go); + assert_eq!( + game.board_size, + Size { + width: 19, + height: 19 + } + ); + assert_eq!( + game.black_player, + Player { + name: Some("savanni".to_owned()), + rank: Some("23k".to_owned()), + team: None + } + ); + assert_eq!( + game.white_player, + Player { + name: Some("Geckoz".to_owned()), + rank: None, + team: None + } + ); + assert_eq!(game.app, Some("CGoban:3".to_owned())); + + assert_eq!(game.annotator, None); + assert_eq!(game.copyright, None); + assert_eq!( + game.dates, + vec![Date::Date( + chrono::NaiveDate::from_ymd_opt(2020, 8, 5).unwrap() + )] + ); + assert_eq!(game.event, None); + assert_eq!(game.game_name, None); + assert_eq!(game.extra_info, None); + assert_eq!(game.opening_info, None); + assert_eq!( + game.location, + Some("The KGS Go Server at http://www.gokgs.com/".to_owned()) + ); + assert_eq!(game.result, GameResult::White(Win::Score(17.5))); + assert_eq!(game.round, None); + assert_eq!(game.rules, Some("AGA".to_owned())); + assert_eq!(game.source, None); + assert_eq!(game.time_limit, Some(Duration::from_secs(1800))); + assert_eq!(game.overtime, Some("5x30 byo-yomi".to_owned())); + assert_eq!(game.data_entry, None); + + /* + Property { + ident: "KM".to_owned(), + values: vec!["7.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]); + } + */ + }, + ); + } +} diff --git a/sgf/src/go.rs b/sgf/src/go.rs index c01c106..27edb5e 100644 --- a/sgf/src/go.rs +++ b/sgf/src/go.rs @@ -233,8 +233,6 @@ pub struct GameInfo { pub result: Option, } - - /* enum PropType { Move, @@ -347,121 +345,5 @@ mod tests { } #[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]); - } - }, - ); - } + fn it_presents_the_mainline_of_game_without_branches() {} } diff --git a/sgf/src/parser.rs b/sgf/src/parser.rs index 9804620..7ff1d23 100644 --- a/sgf/src/parser.rs +++ b/sgf/src/parser.rs @@ -1,4 +1,4 @@ -use crate::{Color, Error, GameResult}; +use crate::{Color, Date, Error, GameResult}; use nom::{ branch::alt, bytes::complete::{escaped_transform, tag, take_until1}, @@ -422,7 +422,7 @@ pub enum Property { Copyright(String), // DT - EventDates(Vec), + EventDates(Vec), // EV EventName(String), diff --git a/sgf/src/types.rs b/sgf/src/types.rs index 44435f8..0362733 100644 --- a/sgf/src/types.rs +++ b/sgf/src/types.rs @@ -70,7 +70,7 @@ pub enum GameResult { Black(Win), White(Win), Void, - Unknown(String), + Unknown, } impl TryFrom<&str> for GameResult { @@ -85,7 +85,7 @@ impl TryFrom<&str> for GameResult { let res = match parts[0].to_ascii_lowercase().as_str() { "b" => GameResult::Black, "w" => GameResult::White, - _ => return Ok(GameResult::Unknown(parts[0].to_owned())), + _ => return Ok(GameResult::Unknown), }; match parts[1].to_ascii_lowercase().as_str() { "r" | "resign" => Ok(res(Win::Resignation)),