1 files changed, 17 insertions, 17 deletions

diff --git a/src/game.rs b/src/game.rs
index be9d23d..a6c79a4 100644
--- a/src/game.rs
+++ b/src/game.rs
@@ -661,8 +661,8 @@ impl GameState {
 }
 
 enum TurnOrder {
-    BlackPlacesWhite,
     WhitePlacesBlack,
+    BlackPlacesWhite,
     Normal,
 }
 
@@ -692,8 +692,8 @@ impl Game {
                 black_player_name: black_player_name.to_string(),
                 states: vec![GameState::new(size)],
                 actions: Vec::new(),
-                current_player: Player::Black,
-                turn_order: TurnOrder::BlackPlacesWhite,
+                current_player: Player::White,
+                turn_order: TurnOrder::WhitePlacesBlack,
             },
             warning,
         )
@@ -719,8 +719,8 @@ impl Game {
 
     pub fn query_stone_owner(&self) -> Player {
         match self.turn_order {
-            TurnOrder::BlackPlacesWhite => Player::White,
             TurnOrder::WhitePlacesBlack => Player::Black,
+            TurnOrder::BlackPlacesWhite => Player::White,
             TurnOrder::Normal => self.current_player,
         }
     }
@@ -734,11 +734,11 @@ impl Game {
         let mut newline = true;
         let num_actions = self.actions.len();
         if num_actions > 0 {
-            result += "0. ";
+            result += "1. ";
             for i in 0..num_actions {
                 if i > 1 && newline {
                     // TODO: Is placing the opponent's first stone the zeroeth action?
-                    result += &format!("{}. ", i);
+                    result += &format!("{}. ", i / 2 + 1);
                 }
                 result += &format!("{} ", self.actions[i]);
                 if i > 0 && !newline {
@@ -761,27 +761,27 @@ impl Game {
         let state = maybe_state.unwrap();
         let new_state_either = match &act {
             Action::Place(player, pos, stone) => match self.turn_order {
-                TurnOrder::BlackPlacesWhite => {
-                    if (self.current_player == Player::Black)
-                        && (*player == Player::White)
+                TurnOrder::WhitePlacesBlack => {
+                    if (self.current_player == Player::White)
+                        && (*player == Player::Black)
                         && (*stone == Stone::Flat)
                     {
                         state.place_stone(*player, pos, *stone)
                     } else {
                         Err(String::from(
-                            "At the start of the game, B must place a W flat.",
+                            "At the start of the game, W must place a B flat.",
                         ))
                     }
                 }
-                TurnOrder::WhitePlacesBlack => {
-                    if (self.current_player == Player::White)
-                        && (*player == Player::Black)
+                TurnOrder::BlackPlacesWhite => {
+                    if (self.current_player == Player::Black)
+                        && (*player == Player::White)
                         && (*stone == Stone::Flat)
                     {
                         state.place_stone(*player, pos, *stone)
                     } else {
                         Err(String::from(
-                            "At the start of the game, W must place a B flat.",
+                            "At the start of the game, B must place a W flat.",
                         ))
                     }
                 }
@@ -810,8 +810,8 @@ impl Game {
                 self.states.push(new_state);
                 self.actions.push(act);
                 self.current_player = match self.turn_order {
+                    TurnOrder::WhitePlacesBlack => Player::Black,
                     TurnOrder::BlackPlacesWhite => Player::White,
-                    TurnOrder::WhitePlacesBlack => Player::White,
                     TurnOrder::Normal => match self.current_player {
                         Player::Black => Player::White,
                         Player::White => Player::Black,
@@ -819,8 +819,8 @@ impl Game {
                 };
 
                 self.turn_order = match self.turn_order {
-                    TurnOrder::BlackPlacesWhite => TurnOrder::WhitePlacesBlack,
-                    TurnOrder::WhitePlacesBlack => TurnOrder::Normal,
+                    TurnOrder::WhitePlacesBlack => TurnOrder::BlackPlacesWhite,
+                    TurnOrder::BlackPlacesWhite => TurnOrder::Normal,
                     TurnOrder::Normal => TurnOrder::Normal,
                 };
                 return Ok((pos_vec, self.last_state().check_win()));