Names, who goes first, date in PTN

3 files changed, 82 insertions, 36 deletions

diff --git a/src/game.rs b/src/game.rs
index 3c15796..5db2c48 100644
--- a/src/game.rs
+++ b/src/game.rs
@@ -670,14 +670,20 @@ pub struct Game {
     size: u8,
     current_player: Player,
     turn_order: TurnOrder,
-    white_player_name: String,
-    black_player_name: String,
     actions: Vec<Action>,
     states: Vec<GameState>,
+    white_player_name: String,
+    black_player_name: String,
+    date_string: String,
 }
 
 impl Game {
-    pub fn new(size: u8, white_player_name: &str, black_player_name: &str) -> (Game, String) {
+    pub fn new(
+        size: u8,
+        white_player_name: &str,
+        black_player_name: &str,
+        date_str: &str,
+    ) -> (Game, String) {
         let (size, warning) = if (size <= 3) || (size >= 8) {
             (5, format!("Warning: the requested game size of {}x{} is not supported, defaulting to 5x5.",
                     size, size))
@@ -688,12 +694,13 @@ impl Game {
         (
             Game {
                 size: size,
-                white_player_name: white_player_name.to_string(),
-                black_player_name: black_player_name.to_string(),
                 states: vec![GameState::new(size)],
                 actions: Vec::new(),
                 current_player: Player::White,
                 turn_order: TurnOrder::WhitePlacesBlack,
+                white_player_name: white_player_name.to_string(),
+                black_player_name: black_player_name.to_string(),
+                date_string: date_str.to_string(),
             },
             warning,
         )
@@ -709,6 +716,13 @@ impl Game {
         self.last_state().query_pos(pos)
     }
 
+    pub fn query_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 {
         self.last_state().remaining_pieces(player, stone)
     }
@@ -826,7 +840,8 @@ impl fmt::Display for Game {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
-            "[Date \"\"]\n[Player1 \"{}\"]\n[Player2 \"{}\"]\n[Size \"{}\"]\n{}",
+            "[Date \"{}\"]\n[Player1 \"{}\"]\n[Player2 \"{}\"]\n[Size \"{}\"]\n{}",
+            self.date_string,
             self.white_player_name,
             self.black_player_name,
             self.size,
diff --git a/src/gui.rs b/src/gui.rs
index 1b5f8a2..ed5acb5 100644
--- a/src/gui.rs
+++ b/src/gui.rs
@@ -33,8 +33,7 @@ impl GameLog {
     }
 
     pub fn update(&self, game: &Game) {
-        // No need to clear, always stays the same size
-        self.pieces_window.mv(0, 0);
+        self.pieces_window.clear();
 
         if self.has_colours {
             self.pieces_window.attrset(ColorPair(self.white_colour));
@@ -85,15 +84,14 @@ impl GameLog {
                 if self.has_colours {
                     self.pieces_window.attrset(ColorPair(self.black_colour));
                 }
-                self.pieces_window.addstr("Black");
             }
             Player::White => {
                 if self.has_colours {
                     self.pieces_window.attrset(ColorPair(self.white_colour));
                 }
-                self.pieces_window.addstr("White");
             }
         }
+        self.pieces_window.addstr(game.query_current_player_name());
 
         self.pieces_window.refresh();
 
diff --git a/src/main.rs b/src/main.rs
index 6a2f70a..e46a855 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,4 +1,5 @@
 extern crate argparse;
+extern crate chrono;
 
 mod consulter;
 mod game;
@@ -11,6 +12,8 @@ use crate::gui::*;
 use crate::parser::*;
 
 use argparse::*;
+use chrono::Local;
+use std::env;
 use std::io::Error;
 use std::time::SystemTime;
 
@@ -79,10 +82,10 @@ fn init_gui(size: u8) -> GUI {
     let action_entry = ActionEntry::new(board_bottom, 0, 13);
 
     let message_log = MessageLog::new(
-        board_bottom + 1,
+        board_bottom + 2,
         0,
         height - board_bottom - 1,
-        width,
+        board_right,
         has_colours,
         red_colour,
     );
@@ -116,9 +119,13 @@ fn human_action(gui: &GUI, game: &Game) -> Result<Action, Error> {
 }
 
 fn main() {
-    let mut p1_name = String::from("Player1");
+    let mut p1_name = match env::var("USER") {
+        Err(_) => String::from("Player1"),
+        Ok(user) => user,
+    };
     let mut p2_name = String::from("Player2");
-    let mut computer_opponent = String::new();
+    let mut engine = String::new();
+    let mut name = String::new();
     let mut size: u8 = 5;
 
     {
@@ -128,25 +135,32 @@ fn main() {
         ap.refer(&mut p1_name).add_option(
             &["--player1"],
             Store,
-            "Name of first player, Black/White assignment is still random.",
+            "Name of first player, defaults to $USER. See --name-white below for Black/White assignment.",
         );
 
         ap.refer(&mut p2_name).add_option(
             &["--player2"],
             Store,
-            "Name of second player, ignored if playing against a
-            computer opponent.",
+            "Name of second player, defaults to ``Player2'' and is
+            overridden by the arument ENGINE of --engine when applicable.",
         );
 
-        ap.refer(&mut computer_opponent).add_option(
+        ap.refer(&mut engine).add_option(
             &["-e", "--engine"],
             Store,
             "Name of process which will be used as a computer opponent.
              The process must accept a single argument point to a PTN file
              of the current game state, and must generate a single PTN action
-             on STDOUT.",
+             on STDOUT. The engine will replace the second player, and the name
+             of player 2 is set to this argument.",
         );
 
+        ap.refer(&mut name).add_option(
+            &["--name-white"],
+            Store,
+            "Force the player named NAME to play white. If not supplied, assignment is ``random''.",
+        ).metavar("NAME");
+
         ap.refer(&mut size).add_option(
             &["-s", "--size"],
             Store,
@@ -161,39 +175,57 @@ fn main() {
         ap.parse_args_or_exit();
     }
 
-    let human_first;
     let call_proc;
-    if !computer_opponent.is_empty() {
-        p2_name = computer_opponent.clone();
+    if !engine.is_empty() {
+        p2_name = engine.clone();
         call_proc = true;
-        // Perhaps there's a better way.
-        human_first = match SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {
-            Ok(n) => n.as_secs() % 2 == 0,
-            Err(_) => false,
-        };
+    // Perhaps there's a better way.
     } else {
-        human_first = false;
         call_proc = false;
     }
 
     let gui = init_gui(size);
 
-    let (mut game, warning) = Game::new(size, &p1_name, &p2_name);
+    let p1_white;
+    if !name.is_empty() {
+        if name == p1_name {
+            p1_white = true;
+        } else if name == p2_name {
+            p1_white = false;
+        } else {
+            panic!(
+                "Player named as white ({}) is not a player in this game ({} and {}).",
+                name, p1_name, p2_name
+            );
+        }
+    } else {
+        p1_white = match SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {
+            Ok(n) => n.as_millis() % 2 == 0,
+            Err(_) => false,
+        };
+    }
+
+    let date_string = Local::now().to_string();
+    let (mut game, warning) = if p1_white {
+        Game::new(size, &p1_name, &p2_name, &date_string)
+    } else {
+        Game::new(size, &p2_name, &p1_name, &date_string)
+    };
     gui.message_log.log_error(warning);
     gui.game_log.update(&game);
 
     loop {
         let inp = match game.query_current_player() {
             Player::Black => {
-                if call_proc && human_first {
-                    consult_next_action(&game, &computer_opponent)
+                if call_proc && p1_white {
+                    consult_next_action(&game, &engine)
                 } else {
                     human_action(&gui, &game)
                 }
             }
             Player::White => {
-                if call_proc && (!human_first) {
-                    consult_next_action(&game, &computer_opponent)
+                if call_proc && (!p1_white) {
+                    consult_next_action(&game, &engine)
                 } else {
                     human_action(&gui, &game)
                 }
@@ -208,10 +240,11 @@ fn main() {
             Ok(act) => {
                 let stone_owner = game.query_stone_owner();
                 let player = game.query_current_player();
+                let pn = game.query_current_player_name();
 
                 gui.message_log.log_message(format!(
                     "{} performs {}{}",
-                    player,
+                    pn,
                     act,
                     if stone_owner != player {
                         format!(" with a {} stone.", stone_owner)
@@ -224,8 +257,8 @@ fn main() {
                         gui.message_log.log_error(e);
                         let current = game.query_current_player();
                         if call_proc
-                            && ((human_first && current == Player::Black)
-                                || ((!human_first) && current == Player::White))
+                            && ((p1_white && current == Player::Black)
+                                || ((!p1_white) && current == Player::White))
                         {
                             gui.message_log.log_error(String::from(
                                 "Error: external and internal game states disagree.",