Feature completion for 0.2.0

1 files changed, 34 insertions, 28 deletions

diff --git a/src/game.rs b/src/game.rs
index b49f626..18e6fe5 100644
--- a/src/game.rs
+++ b/src/game.rs
@@ -252,7 +252,7 @@ impl GameState {
                             || ((pos.x + 1 == self.size) && (pos.y + 1 == self.size))
                         {
                             return Err(format!(
-                                "At the start of an FCS game, {} may not place in a corner (such as {}).",
+                                "At the start of game in FCS, {} may not be placed in a corner (such as {}).",
                                 player, pos
                             ));
                         }
@@ -264,7 +264,7 @@ impl GameState {
                             || (pos.y + 1 == self.size)
                         {
                             return Err(format!(
-                                "At the start of an FES game, {} may not place along any edge (and {} is on an edge).",
+                                "At the start of a game in FES, {} may not be placed along any edge (and {} is on an edge).",
                                 player, pos
                             ));
                         }
@@ -726,26 +726,26 @@ impl fmt::Display for StartType {
 }
 
 impl StartType {
-    fn player_turnorder_at(&self, turn_num: usize) -> (Player, TurnOrder) {
+    fn player_turnorder_at(&self, ply: usize) -> (Player, TurnOrder) {
         match self {
             StartType::CPS(c) => {
-                if turn_num * 2 > (*c as usize) {
-                    if turn_num % 2 == 0 {
+                if ply / 2 >= (*c as usize) {
+                    if ply % 2 == 0 {
                         (Player::White, TurnOrder::Normal)
                     } else {
                         (Player::Black, TurnOrder::Normal)
                     }
                 } else {
-                    if turn_num % 2 == 0 {
+                    if ply % 2 == 0 {
                         (Player::White, TurnOrder::WhitePlacesBlack)
                     } else {
                         (Player::Black, TurnOrder::BlackPlacesWhite)
                     }
                 }
             }
-            StartType::FCS => StartType::CPS(1).player_turnorder_at(turn_num),
-            StartType::FES => StartType::CPS(1).player_turnorder_at(turn_num),
-            StartType::TPS => match turn_num {
+            StartType::FCS => StartType::CPS(1).player_turnorder_at(ply),
+            StartType::FES => StartType::CPS(1).player_turnorder_at(ply),
+            StartType::TPS => match ply {
                 0 => (Player::White, TurnOrder::WhitePlacesBlack),
                 1 => (Player::White, TurnOrder::WhitePlacesBlack),
                 2 => (Player::Black, TurnOrder::BlackPlacesWhite),
@@ -758,10 +758,10 @@ impl StartType {
                     TurnOrder::Normal,
                 ),
             },
-            StartType::CZS => match turn_num {
+            StartType::CZS => match ply {
                 0 => (Player::White, TurnOrder::WhitePlacesBlack),
                 n => (
-                    if n % 2 == 0 {
+                    if n % 2 == 1 {
                         Player::White
                     } else {
                         Player::Black
@@ -819,32 +819,26 @@ impl Game {
         )
     }
 
-    // Relying on only ::new(...) being used to make instances
-
-    fn last_state(&self) -> &GameState {
-        &self.states[self.states.len() - 1]
-    }
-
     pub fn query_square(&self, pos: &Position) -> Option<&Stack> {
         self.last_state().query_pos(pos)
     }
 
-    pub fn query_current_player_name(&self) -> &str {
+    pub fn get_current_player_name(&self) -> &str {
         match self.current_player {
             Player::Black => &self.black_player_name,
             Player::White => &self.white_player_name,
         }
     }
 
-    pub fn query_pieces(&self, player: Player, stone: Stone) -> u8 {
+    pub fn get_pieces(&self, player: Player, stone: Stone) -> u8 {
         self.last_state().remaining_pieces(player, stone)
     }
 
-    pub fn query_current_player(&self) -> Player {
+    pub fn get_current_player(&self) -> Player {
         self.current_player
     }
 
-    pub fn query_stone_owner(&self) -> Player {
+    pub fn get_stone_owner(&self) -> Player {
         match self.turn_order {
             TurnOrder::WhitePlacesBlack => Player::Black,
             TurnOrder::BlackPlacesWhite => Player::White,
@@ -852,15 +846,28 @@ impl Game {
         }
     }
 
+    pub fn get_start_type(&self) -> StartType {
+        self.start_type
+    }
+
     pub fn get_size(&self) -> u8 {
         self.size
     }
 
+    pub fn get_ply(&self) -> usize {
+        self.states.len() - 1
+    }
+
+    // Relying on only ::new(...) being used to make instances
+    fn last_state(&self) -> &GameState {
+        &self.states[self.states.len() - 1]
+    }
+
     pub fn get_date_string(&self) -> &str {
         &self.date_string
     }
 
-    pub fn query_action_lines(&self) -> Vec<String> {
+    pub fn get_action_lines(&self) -> Vec<String> {
         let mut result = Vec::new();
         let mut newline = true;
         let num_actions = self.actions.len();
@@ -918,7 +925,7 @@ impl Game {
                         && (*player == Player::White)
                         && (*stone == Stone::Flat)
                     {
-                        state.place_stone(*player, pos, *stone, Some(self.start_type))
+                        state.place_stone(*player, pos, *stone, None)
                     } else {
                         Err(format!(
                             "At the start of the game in {}, B must place a W flat.",
@@ -945,7 +952,7 @@ impl Game {
                 self.states.push(new_state);
                 self.actions.push(act);
                 let (current_player, turn_order) =
-                    self.start_type.player_turnorder_at(self.states.len());
+                    self.start_type.player_turnorder_at(self.get_ply());
                 self.current_player = current_player;
                 self.turn_order = turn_order;
                 // This is safe as we have just added to the states vector
@@ -959,8 +966,7 @@ impl Game {
         if self.actions.len() > 0 {
             self.actions.pop();
             self.states.pop();
-            let (current_player, turn_order) =
-                self.start_type.player_turnorder_at(self.states.len());
+            let (current_player, turn_order) = self.start_type.player_turnorder_at(self.get_ply());
             self.turn_order = turn_order;
             self.current_player = current_player;
             // I'm too lazy to work out exactly which squares must be
@@ -982,13 +988,13 @@ impl fmt::Display for Game {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
-            "[Date \"{}\"]\n[Player1 \"{}\"]\n[Player2 \"{}\"]\n[Size \"{}\"][Start \"{}\"]\n{}",
+            "[Date \"{}\"]\n[Player1 \"{}\"]\n[Player2 \"{}\"]\n[Size \"{}\"]\n[Variant \"{}\"]\n{}",
             self.date_string,
             self.white_player_name,
             self.black_player_name,
             self.size,
             self.start_type,
-            self.query_action_lines().join("\n"),
+            self.get_action_lines().join("\n"),
         )
     }
 }