Show opponent last move

src/bin/client.rs

@@ -2,7 +2,7 @@ extern crate ctrlc;
 use clichess::{GameInfo, RecvPositionError, UserRole, EXIT_MSG};
 use serde_json::json;
 use shakmaty::fen::Fen;
-use shakmaty::{Chess, Color, Outcome, Position, Setup};
+use shakmaty::{Chess, Color, Move, Outcome, Position, Setup};
 use std::io;
 use std::os::unix::net::UnixStream;
 use std::sync::mpsc::{channel, Receiver, TryRecvError};
@@ -16,6 +16,7 @@ struct Client {
     input_buffer: Arc<Mutex<String>>,
     server_message_recv: Receiver<String>,
     opponent_name: Option<String>,
+    last_move: Option<String>,
 }
 
 fn main() {
@@ -50,6 +51,7 @@ fn main() {
         input_buffer: input_buffer.clone(),
         server_message_recv,
         opponent_name: Option::None,
+        last_move: Option::None,
     };
 
     match prompt_user_for_role(&client, &mut stream) {
@@ -73,10 +75,18 @@ fn main() {
     }
     let mut current_position = fetch_initial_chess_position(&client);
     loop {
-        client
+        if clichess::is_player_turn(&client.player, current_position.turn())
-            .opponent_name
+            || client.player.role == UserRole::Spectator
-            .clone()
+        {
-            .map(|name| println!("{} played", &name[1..(name.len() - 1)]));
+            client
+                .opponent_name
+                .clone()
+                .map(|name| print!("{} played", &name[1..(name.len() - 1)]));
+            client
+                .last_move
+                .clone()
+                .map(|chessmove| println!(" {}", chessmove));
+        }
         println!(
             "{}",
             clichess::board_representation(&current_position, client.side)
@@ -87,11 +97,13 @@ fn main() {
         }
         if clichess::is_player_turn(&client.player, current_position.turn()) {
             //it's the user turn, taking user input
-            let input = read_user_input(&client);
+            let mut input = read_user_input(&client);
-            clichess::write_to_stream(&mut stream, String::from(input.trim())).unwrap();
+            input = String::from(input.trim());
-            if input.trim() == EXIT_MSG {
+            clichess::write_to_stream(&mut stream, input.clone()).unwrap();
+            if input == EXIT_MSG {
                 break;
             }
+            client.last_move = Some(input);
         }
         //update position after playing.
         match get_current_position(&mut client) {
@@ -181,6 +193,9 @@ fn get_current_position(client: &mut Client) -> Result<Chess, RecvPositionError>
     if game_info.opponent_name != "" {
         client.opponent_name = Some(game_info.opponent_name);
     }
+    if game_info.last_move != "" {
+        client.last_move = Some(game_info.last_move);
+    }
     if response.is_empty() {
         Err(RecvPositionError::UserCanceledError)
     } else {

src/bin/server.rs

@@ -19,6 +19,7 @@ struct Server {
     client_message_recv: Receiver<String>,
     cvar: Arc<(Mutex<bool>, Condvar)>,
     opponent_name: Option<String>,
+    last_move: Option<String>
 }
 
 fn main() {
@@ -47,6 +48,7 @@ fn main() {
                     client_message_recv,
                     cvar: condvar_pair,
                     opponent_name: Option::None,
+                    last_move: Option::None
                 };
                 /* connection succeeded */
                 thread::spawn(move || handle_player(stream, &mut server, others_serv_msg_sender));
@@ -114,7 +116,7 @@ fn main_loop(stream: &mut UnixStream, server: &mut Server, player: Player, mut p
                 let mut chess = server.chess_position.lock().unwrap();
                 let players = server.players.lock().unwrap();
                 println!("User tried to play {}", input);
-                match clichess::try_to_play_move(&chess, input) {
+                match clichess::try_to_play_move(&chess, input.clone()) {
                     Ok(played_chess) => *chess = played_chess,
                     Err(e) => println!("Error: {}", e),
                 };
@@ -126,6 +128,7 @@ fn main_loop(stream: &mut UnixStream, server: &mut Server, player: Player, mut p
                         .0
                         .username
                         .clone(),
+                        last_move: input.clone()
                 };
                 for (id, (_, others_serv_msg_sender, cvar_pair)) in players.iter() {
                     if server.id != *id {
@@ -143,6 +146,7 @@ fn main_loop(stream: &mut UnixStream, server: &mut Server, player: Player, mut p
                     serde_json::to_string(&GameInfo {
                         game_fen: fen::fen(&*chess),
                         opponent_name: server.opponent_name.clone().unwrap_or_default(),
+                        last_move: server.last_move.clone().unwrap_or_default(),
                     })
                     .unwrap(),
                 )
@@ -160,6 +164,7 @@ fn main_loop(stream: &mut UnixStream, server: &mut Server, player: Player, mut p
             let game_info = game_info_result.unwrap();
             clichess::write_to_stream(stream, serde_json::to_string(&game_info).unwrap()).unwrap();
             server.opponent_name = Some(game_info.opponent_name);
+            server.last_move = Some(game_info.last_move);
             let chess = server.chess_position.lock().unwrap();
             player_turn = chess.turn();
         }

src/lib.rs

@@ -25,6 +25,7 @@ pub struct Player {
 pub struct GameInfo {
     pub game_fen: String,
     pub opponent_name: String,
+    pub last_move: String
 }
 
 #[derive(PartialEq, Copy, Clone)]