Merge pull request 'Update Rust crate actix-cors to v0.7.1' (#296) from renovate/actix-cors-0.x-lockfile into master

Reviewed-on: #296

README.md

@@ -1,5 +1,17 @@
 # SeaBattle
+[![Build Status](https://drone.communiquons.org/api/badges/pierre/SeaBattle/status.svg)](https://drone.communiquons.org/pierre/SeaBattle)
+
 
 Full stack sea battle game.
 
-Current status: working on backend, and then building web ui...
+
+## Implementations
+Current implementations:
+- [x] Rust shell implementations ([server](rust/sea_battle_backend) and [client](rust/sea_battle_cli_player))
+- [ ] web implementation
+- [ ] mobile implementation
+
+## Screenshots
+
+### Shell implementation
+![Shell implementation example](rust/sea_battle_cli_player/img/SeaBattleCli.png)

renovate.json

@@ -1,4 +1,10 @@
 {
   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "ignorePaths": ["**/flutter/**", "**/react/**"]
+  "ignorePaths": ["**/flutter/**", "**/react/**"],
+  "packageRules": [
+    {
+      "matchUpdateTypes": ["major", "minor", "patch"],
+      "automerge": true
+    }
+  ]
 }

rust/Cargo.toml

@@ -1,6 +1,6 @@
 [workspace]
-
+resolver = "2"
 members = [
  "sea_battle_backend",
- "cli_player"
+ "sea_battle_cli_player"
 ]

rust/Dockerfile

@@ -1,4 +1,4 @@
-FROM debian:bullseye-slim
+FROM debian:bookworm-slim
 
 COPY sea_battle_backend /usr/local/bin/sea_battle_backend
 

rust/cli_player/Cargo.toml

@@ -1,27 +0,0 @@
-[package]
-name = "cli_player"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-sea_battle_backend = { path = "../sea_battle_backend" }
-clap = { version = "4.0.15", features = ["derive"] }
-log = "0.4.17"
-env_logger = "0.9.0"
-tui = "0.19.0"
-crossterm = "0.25.0"
-lazy_static = "1.4.0"
-tokio = "1.21.2"
-num = "0.4.0"
-num-traits = "0.2.15"
-num-derive = "0.3.3"
-textwrap = "0.15.1"
-tokio-tungstenite = { version = "0.17.2", features = ["__rustls-tls", "rustls-tls-native-roots"] }
-serde_urlencoded = "0.7.1"
-futures = "0.3.23"
-serde_json = "1.0.85"
-hostname = "0.3.1"
-rustls = "0.20.6"
-hyper-rustls = { version = "0.23.0", features = ["rustls-native-certs"] }

rust/cli_player/src/main.rs

@@ -1,180 +0,0 @@
-use std::error::Error;
-use std::io;
-use std::io::ErrorKind;
-
-use crossterm::event::DisableMouseCapture;
-use crossterm::event::EnableMouseCapture;
-use crossterm::execute;
-use crossterm::terminal::EnterAlternateScreen;
-use crossterm::terminal::LeaveAlternateScreen;
-use crossterm::terminal::{disable_raw_mode, enable_raw_mode};
-use env_logger::Env;
-use tui::backend::{Backend, CrosstermBackend};
-use tui::Terminal;
-
-use cli_player::cli_args::{cli_args, TestDevScreen};
-use cli_player::client::Client;
-use cli_player::server::start_server_if_missing;
-use cli_player::ui_screens::configure_game_rules::GameRulesConfigurationScreen;
-use cli_player::ui_screens::game_screen::GameScreen;
-use cli_player::ui_screens::input_screen::InputScreen;
-use cli_player::ui_screens::popup_screen::PopupScreen;
-use cli_player::ui_screens::select_play_mode_screen::{SelectPlayModeResult, SelectPlayModeScreen};
-use cli_player::ui_screens::*;
-use sea_battle_backend::data::GameRules;
-use sea_battle_backend::human_player_ws::ServerMessage;
-use sea_battle_backend::utils::Res;
-
-/// Test code screens
-async fn run_dev<B: Backend>(
-    terminal: &mut Terminal<B>,
-    d: TestDevScreen,
-) -> Result<(), Box<dyn Error>> {
-    let res = match d {
-        TestDevScreen::Popup => popup_screen::PopupScreen::new("Welcome there!!")
-            .show(terminal)?
-            .as_string(),
-        TestDevScreen::Input => input_screen::InputScreen::new("What it your name ?")
-            .set_title("A custom title")
-            .show(terminal)?
-            .as_string(),
-        TestDevScreen::Confirm => {
-            confirm_dialog_screen::ConfirmDialogScreen::new("Do you really want to quit game?")
-                .show(terminal)?
-                .as_string()
-        }
-        TestDevScreen::SelectBotType => select_bot_type_screen::SelectBotTypeScreen::default()
-            .show(terminal)?
-            .as_string(),
-        TestDevScreen::SelectPlayMode => select_play_mode_screen::SelectPlayModeScreen::default()
-            .show(terminal)?
-            .as_string(),
-        TestDevScreen::SetBoatsLayout => {
-            let rules = GameRules {
-                boats_can_touch: true,
-                ..Default::default()
-            };
-
-            set_boats_layout_screen::SetBoatsLayoutScreen::new(&rules)
-                .show(terminal)?
-                .as_string()
-        }
-        TestDevScreen::ConfigureGameRules => {
-            configure_game_rules::GameRulesConfigurationScreen::new(GameRules::default())
-                .show(terminal)?
-                .as_string()
-        }
-    };
-
-    Err(io::Error::new(
-        ErrorKind::Other,
-        format!("DEV result: {:?}", res),
-    ))?
-}
-
-/// Ask the user to specify its username
-fn query_username<B: Backend>(terminal: &mut Terminal<B>) -> Res<String> {
-    let hostname = hostname::get()?.to_string_lossy().to_string();
-
-    let res =
-        InputScreen::new("Please specify the name to which other players should identify you:")
-            .set_title("Player name")
-            .set_value(&hostname)
-            .show(terminal)?;
-
-    Ok(res.value().unwrap_or(hostname))
-}
-
-async fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> Res {
-    if let Some(d) = cli_args().dev_screen {
-        return run_dev(terminal, d).await;
-    }
-
-    let mut rules = GameRules::default();
-
-    let mut username = "".to_string();
-
-    loop {
-        let choice = SelectPlayModeScreen::default().show(terminal)?;
-
-        if let ScreenResult::Ok(c) = choice {
-            if c.need_user_name() && username.is_empty() {
-                username = query_username(terminal)?;
-            }
-        }
-
-        match choice {
-            ScreenResult::Ok(SelectPlayModeResult::PlayRandom) => {
-                PopupScreen::new("Connecting...").show_once(terminal)?;
-
-                let client = Client::start_random_play(&username).await?;
-                PopupScreen::new("Waiting for opponent...").show_once(terminal)?;
-
-                // Wait for the server to become ready
-                while !matches!(
-                    client.recv_next_message().await?,
-                    ServerMessage::OpponentConnected
-                ) {}
-
-                // Display game screen
-                GameScreen::new(client).show(terminal).await?;
-            }
-
-            // Play against bot
-            ScreenResult::Ok(SelectPlayModeResult::PlayAgainstBot) => {
-                // First, ask for custom rules
-                rules = match GameRulesConfigurationScreen::new(rules.clone()).show(terminal)? {
-                    ScreenResult::Ok(r) => r,
-                    ScreenResult::Canceled => continue,
-                };
-
-                // Then connect to server
-                PopupScreen::new("Connecting...").show_once(terminal)?;
-                let client = Client::start_bot_play(&rules).await?;
-
-                // Wait for the server to become ready
-                while !matches!(
-                    client.recv_next_message().await?,
-                    ServerMessage::OpponentConnected
-                ) {}
-
-                // Display game screen
-                GameScreen::new(client).show(terminal).await?;
-            }
-
-            ScreenResult::Canceled | ScreenResult::Ok(SelectPlayModeResult::Exit) => return Ok(()),
-        }
-    }
-}
-
-#[tokio::main]
-pub async fn main() -> Result<(), Box<dyn Error>> {
-    env_logger::Builder::from_env(Env::default()).init();
-
-    start_server_if_missing().await;
-
-    // setup terminal
-    enable_raw_mode()?;
-    let mut stdout = io::stdout();
-    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
-    let backend = CrosstermBackend::new(stdout);
-    let mut terminal = Terminal::new(backend)?;
-
-    // create app and run it
-    let res = run_app(&mut terminal).await;
-
-    // restore terminal
-    disable_raw_mode()?;
-    execute!(
-        terminal.backend_mut(),
-        LeaveAlternateScreen,
-        DisableMouseCapture
-    )?;
-    terminal.show_cursor()?;
-
-    if let Err(err) = res {
-        println!("{:?}", err)
-    }
-
-    Ok(())
-}

rust/sea_battle_backend/Cargo.toml

@@ -1,28 +1,35 @@
 [package]
 name = "sea_battle_backend"
-version = "0.1.0"
+version = "0.2.1"
 edition = "2021"
+license = "GPL-2.0-or-later"
+description = "A Sea Battle game backend server"
+repository = "https://gitea.communiquons.org/pierre/SeaBattle"
+readme = "README.md"
+authors = ["Pierre Hubert <pierre.git@communiquons.org>"]
+categories = [ "games" ]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-clap = { version = "4.0.15", features = ["derive"] }
+clap = { version = "4.5.4", features = ["derive"] }
-log = "0.4.17"
+log = "0.4.21"
-env_logger = "0.9.0"
+env_logger = "0.11.3"
-serde = { version = "1.0.145", features = ["derive"] }
+serde = { version = "1.0.200", features = ["derive"] }
-serde_json = "1.0.85"
+serde_json = "1.0.116"
-actix-web = "4.1.0"
+actix-web = "4.5.1"
-actix-cors = "0.6.2"
+actix-cors = "0.7.0"
-actix = "0.13.0"
+actix = "0.13.3"
-actix-web-actors = "4.1.0"
+actix-web-actors = "4.3.0"
-actix-rt = "2.7.0"
+actix-rt = "2.9.0"
-uuid = { version = "1.1.2", features = ["v4"] }
+uuid = { version = "1.8.0", features = ["v4"] }
 rand = "0.8.5"
-serde_with = "2.0.1"
+serde_with = "3.8.1"
 tokio = { version = "1", features = ["full"] }
+semver = "1.0.22"
 
 [dev-dependencies]
 #reqwest = { version = "0.11.11", default-features = false, features = ["json", "rustls-tls"] }
-tokio-tungstenite = "0.17.2"
+tokio-tungstenite = "0.21.0"
 serde_urlencoded = "0.7.1"
-futures = "0.3.23"
+futures = "0.3.30"

rust/sea_battle_backend/README.md

@@ -0,0 +1,30 @@
+# Sea battle backend
+[![Build Status](https://drone.communiquons.org/api/badges/pierre/SeaBattle/status.svg)](https://drone.communiquons.org/pierre/SeaBattle)
+[![Crate](https://img.shields.io/crates/v/sea_battle_backend.svg)](https://crates.io/crates/sea_battle_backend)
+[![Documentation](https://docs.rs/sea_battle_backend/badge.svg)](https://docs.rs/sea_battle_backend/)
+
+A backend HTTP server for the Sea Battle game. The binary included in
+this crate can be used to deploy a server that will allow players to
+connect to play together.
+
+The `actix-web` library is used to spawn HTTP server. The games are encapsulated
+inside websockets.
+
+An official server is running at https://seabattleapi.communiquons.org/
+
+## Installation
+You can install the backend using the following command:
+
+```bash
+cargo install sea_battle_backend
+```
+
+## Usage
+```bash
+sea_battle_backend -l 0.0.0.0:7000
+```
+
+> Note: a reverse-proxy must be used to protect
+
+## Client
+A command-line client is available in the [sea_battle_cli_player](https://crates.io/crates/sea_battle_cli_player) crate.

rust/sea_battle_backend/src/args.rs

@@ -12,3 +12,14 @@ pub struct Args {
     #[clap(short, long, value_parser)]
     pub cors: Option<String>,
 }
+
+#[cfg(test)]
+mod test {
+    use crate::args::Args;
+
+    #[test]
+    fn verify_cli() {
+        use clap::CommandFactory;
+        Args::command().debug_assert()
+    }
+}

rust/sea_battle_backend/src/bot_player.rs

@@ -58,6 +58,8 @@ impl Player for BotPlayer {
         unreachable!()
     }
 
+    fn waiting_for_opponent_boats_layout(&self) {}
+
     fn notify_other_player_ready(&self) {}
 
     fn notify_game_starting(&self) {}

rust/sea_battle_backend/src/consts.rs

@@ -1,5 +1,8 @@
 //! # Project constants
 
+pub const MIN_REQUIRED_VERSION: &str = "0.1.0";
+pub const CURRENT_VERSION: &str = env!("CARGO_PKG_VERSION");
+
 pub const MIN_BOATS_NUMBER: usize = 1;
 pub const MAX_BOATS_NUMBER: usize = 10;
 
@@ -21,3 +24,9 @@ pub const MULTI_PLAYER_PLAYER_BOATS: [usize; 5] = [2, 3, 3, 4, 5];
 pub const ALPHABET: &str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
 pub const INVITE_CODE_LENGTH: usize = 5;
+
+pub const MIN_PLAYER_NAME_LENGTH: usize = 1;
+pub const MAX_PLAYER_NAME_LENGTH: usize = 10;
+
+pub const MIN_STRIKE_TIMEOUT: u64 = 5;
+pub const MAX_STRIKE_TIMEOUT: u64 = 90;

rust/sea_battle_backend/src/data/boats_layout.rs

@@ -361,7 +361,7 @@ impl BoatsLayout {
 mod test {
     use crate::data::boats_layout::{BoatDirection, BoatPosition, BoatsLayout, Coordinates};
     use crate::data::game_map::GameMap;
-    use crate::data::{BotType, GameRules, PlayConfiguration, PrintableMap};
+    use crate::data::*;
 
     #[test]
     fn dist_coordinates_eq() {
@@ -488,8 +488,7 @@ mod test {
             map_height: 5,
             boats_str: "1,1".to_string(),
             boats_can_touch: false,
-            player_continue_on_hit: false,
+            ..Default::default()
-            bot_type: BotType::Random,
         };
 
         let mut boats = BoatsLayout(vec![

rust/sea_battle_backend/src/data/current_game_status.rs

@@ -78,6 +78,7 @@ impl PrintableMap for PrintableCurrentGameMapStatus {
 
 #[derive(Debug, serde::Serialize, serde::Deserialize, Clone, Default)]
 pub struct CurrentGameStatus {
+    pub remaining_time_for_strike: Option<u64>,
     pub rules: GameRules,
     pub your_map: CurrentGameMapStatus,
     pub opponent_map: CurrentGameMapStatus,

rust/sea_battle_backend/src/data/game_rules.rs

@@ -1,6 +1,6 @@
 use crate::consts::*;
 use crate::data::{BotType, PlayConfiguration};
-use serde_with::{serde_as, DisplayFromStr};
+use serde_with::{serde_as, DisplayFromStr, NoneAsEmptyString};
 
 #[serde_as]
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, Eq, PartialEq)]
@@ -15,6 +15,8 @@ pub struct GameRules {
     pub boats_can_touch: bool,
     #[serde_as(as = "DisplayFromStr")]
     pub player_continue_on_hit: bool,
+    #[serde_as(as = "NoneAsEmptyString")]
+    pub strike_timeout: Option<u64>,
     pub bot_type: BotType,
 }
 
@@ -36,6 +38,7 @@ impl GameRules {
                 .join(","),
             boats_can_touch: MULTI_PLAYER_BOATS_CAN_TOUCH,
             player_continue_on_hit: MULTI_PLAYER_PLAYER_CAN_CONTINUE_AFTER_HIT,
+            strike_timeout: Some(30),
             bot_type: BotType::Smart,
         }
     }
@@ -50,6 +53,11 @@ impl GameRules {
         self
     }
 
+    pub fn with_strike_timeout(mut self, timeout: u64) -> Self {
+        self.strike_timeout = Some(timeout);
+        self
+    }
+
     /// Set the list of boats for this configuration
     pub fn set_boats_list(&mut self, boats: &[usize]) {
         self.boats_str = boats
@@ -121,12 +129,22 @@ impl GameRules {
             }
         }
 
+        if let Some(timeout) = self.strike_timeout {
+            if timeout < config.min_strike_timeout {
+                errors.push("Strike timeout is too short!");
+            }
+
+            if timeout > config.max_strike_timeout {
+                errors.push("Strike timeout is too long!");
+            }
+        }
+
         errors
     }
 
     /// Check out whether these game rules are valid or not
     pub fn is_valid(&self) -> bool {
-        return self.get_errors().is_empty();
+        self.get_errors().is_empty()
     }
 }
 

rust/sea_battle_backend/src/data/mod.rs

@@ -4,6 +4,7 @@ pub use game_map::*;
 pub use game_rules::*;
 pub use play_config::*;
 pub use printable_map::*;
+pub use version::*;
 
 mod boats_layout;
 mod current_game_status;
@@ -11,3 +12,4 @@ mod game_map;
 mod game_rules;
 mod play_config;
 mod printable_map;
+mod version;

rust/sea_battle_backend/src/data/play_config.rs

@@ -57,6 +57,10 @@ pub struct PlayConfiguration {
     pub max_boats_number: usize,
     pub bot_types: &'static [BotDescription],
     pub ordinate_alphabet: &'static str,
+    pub min_player_name_len: usize,
+    pub max_player_name_len: usize,
+    pub min_strike_timeout: u64,
+    pub max_strike_timeout: u64,
 }
 
 impl Default for PlayConfiguration {
@@ -72,6 +76,10 @@ impl Default for PlayConfiguration {
             max_boats_number: MAX_BOATS_NUMBER,
             bot_types: &BOTS_TYPES,
             ordinate_alphabet: ALPHABET,
+            min_player_name_len: MIN_PLAYER_NAME_LENGTH,
+            max_player_name_len: MAX_PLAYER_NAME_LENGTH,
+            min_strike_timeout: MIN_STRIKE_TIMEOUT,
+            max_strike_timeout: MAX_STRIKE_TIMEOUT,
         }
     }
 }

rust/sea_battle_backend/src/data/version.rs

@@ -0,0 +1,32 @@
+//! # Version Info
+//!
+//! Contains server version requirements information
+
+use crate::consts;
+use crate::utils::res_utils::Res;
+use semver::Version;
+
+#[derive(serde::Serialize, serde::Deserialize)]
+pub struct VersionInfo {
+    current: String,
+    min_required: String,
+}
+
+impl VersionInfo {
+    pub fn load_static() -> Self {
+        Self {
+            current: consts::CURRENT_VERSION.to_string(),
+            min_required: consts::MIN_REQUIRED_VERSION.to_string(),
+        }
+    }
+
+    /// Check if builtin version is compatible with a remote version or not
+    pub fn is_compatible_with_static_version(&self) -> Res<bool> {
+        let static_version = Self::load_static();
+
+        let local_current = Version::parse(&static_version.current)?;
+        let min_required = Version::parse(&self.min_required)?;
+
+        Ok(min_required <= local_current)
+    }
+}

rust/sea_battle_backend/src/dispatcher_actor.rs

@@ -89,7 +89,6 @@ impl Handler<CreateInvite> for DispatcherActor {
         msg.1.do_send(ServerMessage::SetInviteCode {
             code: invite_code.clone(),
         });
-        msg.1.do_send(ServerMessage::WaitingForAnotherPlayer);
         self.with_invite.insert(
             invite_code,
             PendingPlayer {

rust/sea_battle_backend/src/game.rs

@@ -1,4 +1,5 @@
 use std::sync::Arc;
+use std::time::Duration;
 
 use actix::prelude::*;
 use actix::{Actor, Context, Handler};
@@ -6,6 +7,7 @@ use uuid::Uuid;
 
 use crate::bot_player::BotPlayer;
 use crate::data::*;
+use crate::utils::time_utils::time;
 
 pub trait Player {
     fn get_name(&self) -> &str;
@@ -22,6 +24,8 @@ pub trait Player {
 
     fn rejected_boats_layout(&self, errors: Vec<&'static str>);
 
+    fn waiting_for_opponent_boats_layout(&self);
+
     fn notify_other_player_ready(&self);
 
     fn notify_game_starting(&self);
@@ -49,6 +53,9 @@ pub trait Player {
     fn opponent_replaced_by_bot(&self);
 }
 
+/// How often strike timeout controller is run
+const STRIKE_TIMEOUT_CONTROL: Duration = Duration::from_secs(1);
+
 fn opponent(index: usize) -> usize {
     match index {
         0 => 1,
@@ -68,6 +75,14 @@ enum GameStatus {
     RematchRejected,
 }
 
+impl GameStatus {
+    pub fn can_game_continue_with_bot(&self) -> bool {
+        *self != GameStatus::Finished
+            && *self != GameStatus::RematchRejected
+            && *self != GameStatus::RematchRequested
+    }
+}
+
 pub struct Game {
     rules: GameRules,
     players: Vec<Arc<dyn Player>>,
@@ -75,6 +90,7 @@ pub struct Game {
     map_0: Option<GameMap>,
     map_1: Option<GameMap>,
     turn: usize,
+    curr_strike_request_started: u64,
 }
 
 impl Game {
@@ -86,6 +102,7 @@ impl Game {
             map_0: None,
             map_1: None,
             turn: 0,
+            curr_strike_request_started: 0,
         }
     }
 
@@ -120,10 +137,14 @@ impl Game {
             self.turn
         );
 
-        self.request_fire();
+        self.request_fire(true);
     }
 
-    fn request_fire(&self) {
+    fn request_fire(&mut self, reset_counter: bool) {
+        if reset_counter {
+            self.curr_strike_request_started = time();
+        }
+
         self.players[self.turn].request_fire(self.get_game_status_for_player(self.turn));
         self.players[opponent(self.turn)]
             .opponent_must_fire(self.get_game_status_for_player(opponent(self.turn)));
@@ -138,6 +159,27 @@ impl Game {
         .unwrap()
     }
 
+    /// Replace user for a fire in case of timeout
+    fn force_fire_in_case_of_timeout(&mut self) {
+        if self.status != GameStatus::Started || self.rules.strike_timeout.is_none() {
+            return;
+        }
+
+        let timeout = self.rules.strike_timeout.unwrap_or_default();
+
+        if time() <= self.curr_strike_request_started + timeout {
+            return;
+        }
+
+        // Determine target of fire
+        let target = self
+            .get_game_status_for_player(self.turn)
+            .find_fire_coordinates_for_bot_type(self.rules.bot_type);
+
+        // Fire as player
+        self.handle_fire(target);
+    }
+
     fn player_map_mut(&mut self, id: usize) -> &mut GameMap {
         match id {
             0 => self.map_0.as_mut(),
@@ -156,7 +198,7 @@ impl Game {
         // Easiest case : player missed his fire
         if result == FireResult::Missed {
             self.turn = opponent(self.turn);
-            self.request_fire();
+            self.request_fire(true);
             return;
         }
 
@@ -178,7 +220,9 @@ impl Game {
             self.turn = opponent(self.turn);
         }
 
-        self.request_fire();
+        self.request_fire(
+            result != FireResult::AlreadyTargetedPosition && result != FireResult::Rejected,
+        );
     }
 
     fn handle_request_rematch(&mut self, player_id: Uuid) {
@@ -213,6 +257,9 @@ impl Game {
     /// Get current game status for a specific player
     fn get_game_status_for_player(&self, id: usize) -> CurrentGameStatus {
         CurrentGameStatus {
+            remaining_time_for_strike: self.rules.strike_timeout.map(|v| {
+                ((self.curr_strike_request_started + v) as i64 - time() as i64).max(0) as u64
+            }),
             rules: self.rules.clone(),
             your_map: self.player_map(id).current_map_status(false),
             opponent_map: self
@@ -224,6 +271,14 @@ impl Game {
 
 impl Actor for Game {
     type Context = Context<Self>;
+
+    fn started(&mut self, ctx: &mut Self::Context) {
+        if self.rules.strike_timeout.is_some() {
+            ctx.run_interval(STRIKE_TIMEOUT_CONTROL, |act, _ctx| {
+                act.force_fire_in_case_of_timeout();
+            });
+        }
+    }
 }
 
 #[derive(Message)]
@@ -286,6 +341,8 @@ impl Handler<SetBoatsLayout> for Game {
         if self.map_0.is_some() && self.map_1.is_some() {
             self.players.iter().for_each(|p| p.notify_game_starting());
             self.start_fire_exchanges();
+        } else {
+            self.players[player_index].waiting_for_opponent_boats_layout();
         }
     }
 }
@@ -363,7 +420,9 @@ impl Handler<PlayerLeftGame> for Game {
         self.players[opponent(offline_player)].opponent_left_game();
 
         // If the other player is a bot or if the game is not running, stop the game
-        if self.status != GameStatus::Started || self.players[opponent(offline_player)].is_bot() {
+        if !self.status.can_game_continue_with_bot()
+            || self.players[opponent(offline_player)].is_bot()
+        {
             ctx.stop();
         } else {
             // Replace the player with a bot
@@ -371,8 +430,11 @@ impl Handler<PlayerLeftGame> for Game {
                 Arc::new(BotPlayer::new(self.rules.bot_type, ctx.address()));
             self.players[opponent(offline_player)].opponent_replaced_by_bot();
 
-            if self.turn == offline_player {
+            // Re-do current action
-                self.request_fire();
+            if self.status == GameStatus::Started {
+                self.request_fire(true);
+            } else if self.status == GameStatus::WaitingForBoatsDisposition {
+                self.players[offline_player].query_boats_layout(&self.rules);
             }
         }
     }

rust/sea_battle_backend/src/human_player.rs

@@ -47,6 +47,11 @@ impl Player for HumanPlayer {
         });
     }
 
+    fn waiting_for_opponent_boats_layout(&self) {
+        self.player
+            .do_send(ServerMessage::WaitingForOtherPlayerConfiguration);
+    }
+
     fn notify_other_player_ready(&self) {
         self.player.do_send(ServerMessage::OpponentReady);
     }
@@ -109,6 +114,7 @@ impl Player for HumanPlayer {
 
 impl HumanPlayer {
     pub fn handle_client_message(&self, msg: ClientMessage) {
+        log::debug!("Got message from client: {:?}", msg);
         match msg {
             ClientMessage::StopGame => self.game.do_send(PlayerLeftGame(self.uuid)),
             ClientMessage::BoatsLayout { layout } => {

rust/sea_battle_backend/src/human_player_ws.rs

@@ -8,6 +8,7 @@ use actix_web_actors::ws::{CloseCode, CloseReason, Message, ProtocolError, Webso
 use uuid::Uuid;
 
 use crate::bot_player::BotPlayer;
+use crate::consts::{MAX_PLAYER_NAME_LENGTH, MIN_PLAYER_NAME_LENGTH};
 use crate::data::{BoatsLayout, Coordinates, CurrentGameStatus, FireResult, GameRules};
 use crate::dispatcher_actor::{AcceptInvite, CreateInvite, DispatcherActor, PlayRandom};
 use crate::game::{AddPlayer, Game};
@@ -149,6 +150,13 @@ impl Actor for HumanPlayerWS {
     type Context = WebsocketContext<Self>;
 
     fn started(&mut self, ctx: &mut Self::Context) {
+        // Check player name length
+        if self.name.len() < MIN_PLAYER_NAME_LENGTH || self.name.len() > MAX_PLAYER_NAME_LENGTH {
+            log::error!("Close connection due to invalid user name!");
+            ctx.stop();
+            return;
+        }
+
         self.hb(ctx);
 
         self.send_message(ServerMessage::WaitingForAnotherPlayer, ctx);
@@ -222,7 +230,7 @@ impl StreamHandler<Result<ws::Message, ProtocolError>> for HumanPlayerWS {
                 log::warn!("Got unsupported continuation message!");
             }
             Ok(Message::Pong(_)) => {
-                log::info!("Got pong message");
+                log::debug!("Got pong message");
                 self.hb = Instant::now();
             }
             Ok(Message::Close(reason)) => {
@@ -238,6 +246,7 @@ impl Handler<ServerMessage> for HumanPlayerWS {
     type Result = ();
 
     fn handle(&mut self, msg: ServerMessage, ctx: &mut Self::Context) -> Self::Result {
+        log::debug!("Send message through WS: {:?}", msg);
         ctx.text(serde_json::to_string(&msg).unwrap());
     }
 }

rust/sea_battle_backend/src/server.rs

@@ -4,7 +4,7 @@ use actix_web::{web, App, HttpRequest, HttpResponse, HttpServer, Responder};
 use actix_web_actors::ws;
 
 use crate::args::Args;
-use crate::data::{GameRules, PlayConfiguration};
+use crate::data::{BoatsLayout, GameRules, PlayConfiguration, VersionInfo};
 use crate::dispatcher_actor::DispatcherActor;
 use crate::human_player_ws::{HumanPlayerWS, StartMode};
 
@@ -18,11 +18,45 @@ async fn not_found() -> impl Responder {
     HttpResponse::NotFound().json("You missed your strike lol")
 }
 
-/// Get bot configuration
+/// Get version information
+async fn version_information() -> impl Responder {
+    HttpResponse::Ok().json(VersionInfo::load_static())
+}
+
+/// Get game configuration
 async fn game_configuration() -> impl Responder {
     HttpResponse::Ok().json(PlayConfiguration::default())
 }
 
+/// Get default game rules
+async fn default_game_rules() -> impl Responder {
+    HttpResponse::Ok().json(GameRules::random_players_rules())
+}
+
+/// Validate game rules
+async fn validate_game_rules(rules: web::Json<GameRules>) -> impl Responder {
+    HttpResponse::Ok().json(rules.get_errors())
+}
+
+/// Generate random boats layout
+async fn gen_boats_layout(rules: web::Json<GameRules>) -> impl Responder {
+    let errors = rules.get_errors();
+    if !errors.is_empty() {
+        return HttpResponse::BadRequest().json(errors);
+    }
+    match BoatsLayout::gen_random_for_rules(&rules) {
+        Ok(l) => HttpResponse::Ok().json(l),
+        Err(e) => {
+            log::error!(
+                "Failed to generate boats layout for valid game rules: {} ! / Rules: {:?}",
+                e,
+                rules
+            );
+            HttpResponse::InternalServerError().json("Failed to generate random layout!")
+        }
+    }
+}
+
 #[derive(serde::Serialize, serde::Deserialize, Eq, PartialEq, Debug)]
 pub struct BotPlayQuery {
     #[serde(flatten)]
@@ -130,7 +164,10 @@ async fn start_random(
     log::info!("New random play");
     resp
 }
+
 pub async fn start_server(args: Args) -> std::io::Result<()> {
+    log::info!("Start to listen on {}", args.listen_address);
+
     let args_clone = args.clone();
 
     let dispatcher_actor = DispatcherActor::default().start();
@@ -146,7 +183,11 @@ pub async fn start_server(args: Args) -> std::io::Result<()> {
         App::new()
             .app_data(web::Data::new(dispatcher_actor.clone()))
             .wrap(cors)
+            .route("/version", web::get().to(version_information))
             .route("/config", web::get().to(game_configuration))
+            .route("/game_rules/default", web::get().to(default_game_rules))
+            .route("/game_rules/validate", web::post().to(validate_game_rules))
+            .route("/generate_boats_layout", web::post().to(gen_boats_layout))
             .route("/play/bot", web::get().to(start_bot_play))
             .route("/play/create_invite", web::get().to(start_create_invite))
             .route("/play/accept_invite", web::get().to(start_accept_invite))
@@ -161,6 +202,7 @@ pub async fn start_server(args: Args) -> std::io::Result<()> {
 
 #[cfg(test)]
 mod test {
+    use crate::data::GameRules;
     use crate::server::BotPlayQuery;
 
     #[test]
@@ -175,4 +217,20 @@ mod test {
 
         assert_eq!(query, des)
     }
+
+    #[test]
+    fn simple_bot_request_serialize_deserialize_no_timeout() {
+        let query = BotPlayQuery {
+            rules: GameRules {
+                strike_timeout: None,
+                ..Default::default()
+            },
+            player_name: "Player".to_string(),
+        };
+
+        let string = serde_urlencoded::to_string(&query).unwrap();
+        let des = serde_urlencoded::from_str(&string).unwrap();
+
+        assert_eq!(query, des)
+    }
 }

rust/sea_battle_backend/src/test/bot_client.rs

@@ -39,7 +39,7 @@ pub struct BotClient {
     requested_rules: GameRules,
     layout: Option<BoatsLayout>,
     number_plays: usize,
-    server_msg_callback: Option<Box<dyn FnMut(&ServerMessage)>>,
+    server_msg_callback: Option<Box<dyn FnMut(&mut ServerMessage)>>,
     play_as_bot_type: BotType,
 }
 
@@ -81,7 +81,7 @@ impl BotClient {
 
     pub fn with_server_msg_callback<F>(mut self, cb: F) -> Self
     where
-        F: FnMut(&ServerMessage) + 'static,
+        F: FnMut(&mut ServerMessage) + 'static,
     {
         self.server_msg_callback = Some(Box::new(cb));
         self
@@ -152,7 +152,7 @@ impl BotClient {
         };
 
         while let Some(chunk) = socket.next().await {
-            let message = match chunk? {
+            let mut message = match chunk? {
                 Message::Text(message) => {
                     log::trace!("TEXT message from server: {}", message);
 
@@ -182,7 +182,7 @@ impl BotClient {
             };
 
             if let Some(cb) = &mut self.server_msg_callback {
-                (cb)(&message)
+                (cb)(&mut message)
             }
 
             match message {

rust/sea_battle_backend/src/test/bot_linear_play.rs

@@ -9,7 +9,7 @@ use crate::test::play_utils::check_no_replay_on_hit;
 use crate::test::{bot_client, TestPort};
 use crate::utils::network_utils::wait_for_port;
 
-fn check_strikes_are_linear(msg: &ServerMessage) {
+fn check_strikes_are_linear(msg: &mut ServerMessage) {
     if let ServerMessage::RequestFire { status } = msg {
         let mut in_fire_location = true;
         for y in 0..status.rules.map_height {

rust/sea_battle_backend/src/test/bot_random_play.rs

@@ -1,13 +1,16 @@
 use tokio::task;
 
 use crate::args::Args;
+use crate::consts::MIN_STRIKE_TIMEOUT;
 use crate::data::{BoatsLayout, GameRules};
+use crate::human_player_ws::ServerMessage;
 use crate::server::start_server;
 use crate::test::bot_client;
 use crate::test::bot_client::ClientEndResult;
 use crate::test::play_utils::check_no_replay_on_hit;
 use crate::test::TestPort;
 use crate::utils::network_utils::wait_for_port;
+use crate::utils::time_utils::time;
 
 #[tokio::test]
 async fn invalid_port() {
@@ -201,3 +204,37 @@ async fn full_game_no_replay_on_hit() {
         })
         .await;
 }
+
+#[tokio::test]
+async fn check_fire_time_out() {
+    let _ = env_logger::builder().is_test(true).try_init();
+
+    let local_set = task::LocalSet::new();
+    local_set
+        .run_until(async move {
+            task::spawn_local(start_server(Args::for_test(TestPort::RandomCheckTimeout)));
+            wait_for_port(TestPort::RandomCheckTimeout.port()).await;
+
+            let start = time();
+
+            let mut did_skip_one = false;
+            let res = bot_client::BotClient::new(TestPort::RandomCheckTimeout.as_url())
+                .with_rules(
+                    GameRules::random_players_rules().with_strike_timeout(MIN_STRIKE_TIMEOUT),
+                )
+                .with_server_msg_callback(move |msg| {
+                    if matches!(msg, ServerMessage::RequestFire { .. }) && !did_skip_one {
+                        *msg = ServerMessage::OpponentReplacedByBot;
+                        did_skip_one = true;
+                    }
+                })
+                .run_client()
+                .await
+                .unwrap();
+
+            assert!(matches!(res, ClientEndResult::Finished { .. }));
+
+            assert!(time() - start >= MIN_STRIKE_TIMEOUT);
+        })
+        .await;
+}

rust/sea_battle_backend/src/test/mod.rs

@@ -10,6 +10,7 @@ enum TestPort {
     RandomBotInvalidBoatsLayoutLenOfABoat,
     RandomBotFullGameMultipleRematch,
     RandomBotNoReplayOnHit,
+    RandomCheckTimeout,
     LinearBotFullGame,
     LinearBotNoReplayOnHit,
     IntermediateBotFullGame,

rust/sea_battle_backend/src/test/play_utils.rs

@@ -1,7 +1,7 @@
 use crate::human_player_ws::ServerMessage;
 
 /// Make sure player can not replay after successful hit
-pub fn check_no_replay_on_hit(msg: &ServerMessage) {
+pub fn check_no_replay_on_hit(msg: &mut ServerMessage) {
     if let ServerMessage::OpponentMustFire { status } | ServerMessage::RequestFire { status } = msg
     {
         let diff =

rust/sea_battle_backend/src/utils/mod.rs

@@ -1,12 +1,4 @@
-use std::error::Error;
-use std::fmt::Display;
-use std::io::ErrorKind;
-
 pub mod network_utils;
+pub mod res_utils;
 pub mod string_utils;
-
+pub mod time_utils;
-pub type Res<E = ()> = Result<E, Box<dyn Error>>;
-
-pub fn boxed_error<D: Display>(msg: D) -> Box<dyn Error> {
-    Box::new(std::io::Error::new(ErrorKind::Other, msg.to_string()))
-}

rust/sea_battle_backend/src/utils/res_utils.rs

@@ -0,0 +1,9 @@
+use std::error::Error;
+use std::fmt::Display;
+use std::io::ErrorKind;
+
+pub type Res<E = ()> = Result<E, Box<dyn Error>>;
+
+pub fn boxed_error<D: Display>(msg: D) -> Box<dyn Error> {
+    Box::new(std::io::Error::new(ErrorKind::Other, msg.to_string()))
+}

rust/sea_battle_backend/src/utils/time_utils.rs

@@ -0,0 +1,9 @@
+use std::time::{SystemTime, UNIX_EPOCH};
+
+/// Get the current time since epoch
+pub fn time() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_secs()
+}

rust/sea_battle_cli_player/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "sea_battle_cli_player"
+version = "0.2.1"
+edition = "2021"
+license = "GPL-2.0-or-later"
+description = "A Sea Battle game shell client"
+repository = "https://gitea.communiquons.org/pierre/SeaBattle"
+readme = "README.md"
+authors = ["Pierre Hubert <pierre.git@communiquons.org>"]
+categories = [ "games" ]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+sea_battle_backend = { path = "../sea_battle_backend", version = "0.2.0" }
+clap = { version = "4.5.4", features = ["derive"] }
+log = "0.4.21"
+env_logger = "0.11.3"
+tui = "0.19.0"
+crossterm = "0.27.0"
+lazy_static = "1.4.0"
+tokio = "1.37.0"
+num = "0.4.2"
+num-traits = "0.2.18"
+num-derive = "0.4.2"
+textwrap = "0.16.1"
+tokio-tungstenite = { version = "0.21.0", features = ["__rustls-tls", "rustls-tls-native-roots"] }
+serde_urlencoded = "0.7.1"
+futures = "0.3.30"
+serde_json = "1.0.116"
+hostname = "0.4.0"
+rustls = "0.22.2"
+reqwest = { version = "0.12.4", features = ["json", "rustls-tls"], default-features = false }
+rustls-native-certs = {version = "0.7.0"}

rust/sea_battle_cli_player/README.md

@@ -0,0 +1,41 @@
+# Sea battle cli player
+[![Build Status](https://drone.communiquons.org/api/badges/pierre/SeaBattle/status.svg)](https://drone.communiquons.org/pierre/SeaBattle)
+[![Crate](https://img.shields.io/crates/v/sea_battle_cli_player.svg)](https://crates.io/crates/sea_battle_cli_player)
+[![Documentation](https://docs.rs/sea_battle_cli_player/badge.svg)](https://docs.rs/sea_battle_cli_player/)
+
+![](img/SeaBattleCli.png)
+
+A sea battle shell client player for the [sea_battle_backend](https://crates.io/crates/sea_battle_backend) crate, based on the [tui](https://crates.io/crates/tui) library.
+
+## Available play modes
+* 🤖 Play against bot (this mode does not require any Internet connection, a local server is automatically spawn)
+* 🎲 Play against a random player
+* ➕ Create play invite (online). In this mode, the server returns an invitation code to give to the opponent
+* 🎫 Accept play invite (online)
+
+For the 🤖 bot and ➕ create invite modes, game rules can be customized before starting the game.
+
+## Installation
+You can install the backend using the following command:
+
+```bash
+cargo install sea_battle_cli_player
+```
+
+## Usage
+Simply launch using:
+```bash
+sea_battle_cli_player
+```
+
+
+## Offline LAN
+If you want to run a local server to play offline LAN games, the cli player can also act as the server:
+```bash
+RUST_LOG=info sea_battle_cli_player -s -l 0.0.0.0:7000
+```
+
+Then all the players must specify the address of this server to use it instead of the default official one:
+```bash
+sea_battle_cli_player -r http://IP_OF_TARGET:7000
+```

rust/sea_battle_cli_player/src/cli_args.rs

@@ -20,7 +20,7 @@ pub struct CliArgs {
         value_parser,
         default_value = "https://seabattleapi.communiquons.org"
     )]
-    pub remote_server_uri: String,
+    pub remote_server: String,
 
     /// Local server listen address
     #[clap(short, long, default_value = "127.0.0.1:5679")]
@@ -28,6 +28,10 @@ pub struct CliArgs {
 
     #[clap(long, value_enum)]
     pub dev_screen: Option<TestDevScreen>,
+
+    /// Run as server instead of as client
+    #[clap(long, short)]
+    pub serve: bool,
 }
 
 impl CliArgs {
@@ -57,3 +61,14 @@ lazy_static::lazy_static! {
 pub fn cli_args() -> &'static CliArgs {
     &ARGS
 }
+
+#[cfg(test)]
+mod test {
+    use crate::cli_args::CliArgs;
+
+    #[test]
+    fn verify_cli() {
+        use clap::CommandFactory;
+        CliArgs::command().debug_assert()
+    }
+}

rust/sea_battle_cli_player/src/client.rs

@@ -2,11 +2,13 @@ use crate::cli_args::cli_args;
 use crate::server;
 use futures::stream::{SplitSink, SplitStream};
 use futures::{SinkExt, StreamExt};
-use hyper_rustls::ConfigBuilderExt;
+use sea_battle_backend::data::*;
-use sea_battle_backend::data::GameRules;
 use sea_battle_backend::human_player_ws::{ClientMessage, ServerMessage};
-use sea_battle_backend::server::{BotPlayQuery, PlayRandomQuery};
+use sea_battle_backend::server::{
-use sea_battle_backend::utils::{boxed_error, Res};
+    AcceptInviteQuery, BotPlayQuery, CreateInviteQuery, PlayRandomQuery,
+};
+use sea_battle_backend::utils::res_utils::{boxed_error, Res};
+use std::error::Error;
 use std::fmt::Display;
 use std::sync::mpsc::TryRecvError;
 use std::sync::{mpsc, Arc};
@@ -16,6 +18,11 @@ use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
 
 type WsStream = WebSocketStream<MaybeTlsStream<TcpStream>>;
 
+pub enum GetRemoteVersionError {
+    ConnectionFailed,
+    Other(Box<dyn Error>),
+}
+
 /// Connection client
 ///
 /// This structure acts as a wrapper around websocket connection that handles automatically parsing
@@ -26,6 +33,24 @@ pub struct Client {
 }
 
 impl Client {
+    /// Get remote server version
+    pub async fn get_server_version() -> Result<VersionInfo, GetRemoteVersionError> {
+        let url = format!("{}/version", cli_args().remote_server);
+        log::debug!("Getting remote information from {} ...", url);
+
+        let res = match reqwest::get(url).await {
+            Ok(r) => r,
+            Err(e) if e.is_timeout() || e.is_connect() => {
+                return Err(GetRemoteVersionError::ConnectionFailed)
+            }
+            Err(e) => return Err(GetRemoteVersionError::Other(Box::new(e))),
+        };
+
+        res.json()
+            .await
+            .map_err(|e| GetRemoteVersionError::Other(Box::new(e)))
+    }
+
     /// Start to play against a bot
     ///
     /// When playing against a bot, local server is always used
@@ -36,7 +61,7 @@ impl Client {
             &cli_args().local_server_address(),
             &format!(
                 "/play/bot?{}",
-                serde_urlencoded::to_string(&BotPlayQuery {
+                serde_urlencoded::to_string(BotPlayQuery {
                     rules: rules.clone(),
                     player_name: "Human".to_string()
                 })
@@ -49,10 +74,42 @@ impl Client {
     /// Start to play against a random player
     pub async fn start_random_play<D: Display>(player_name: D) -> Res<Self> {
         Self::connect_url(
-            &cli_args().remote_server_uri,
+            &cli_args().remote_server,
             &format!(
                 "/play/random?{}",
-                serde_urlencoded::to_string(&PlayRandomQuery {
+                serde_urlencoded::to_string(PlayRandomQuery {
+                    player_name: player_name.to_string()
+                })
+                .unwrap()
+            ),
+        )
+        .await
+    }
+
+    /// Start a play by creating an invite
+    pub async fn start_create_invite<D: Display>(rules: &GameRules, player_name: D) -> Res<Self> {
+        Self::connect_url(
+            &cli_args().remote_server,
+            &format!(
+                "/play/create_invite?{}",
+                serde_urlencoded::to_string(CreateInviteQuery {
+                    rules: rules.clone(),
+                    player_name: player_name.to_string()
+                })
+                .unwrap()
+            ),
+        )
+        .await
+    }
+
+    /// Start a play by accepting an invite
+    pub async fn start_accept_invite<D: Display>(code: String, player_name: D) -> Res<Self> {
+        Self::connect_url(
+            &cli_args().remote_server,
+            &format!(
+                "/play/accept_invite?{}",
+                serde_urlencoded::to_string(AcceptInviteQuery {
+                    code,
                     player_name: player_name.to_string()
                 })
                 .unwrap()
@@ -69,13 +126,18 @@ impl Client {
 
         let (socket, _) = if ws_url.starts_with("wss") {
             // Perform a connection over TLS
+            let mut roots = rustls::RootCertStore::empty();
+            for cert in rustls_native_certs::load_native_certs()? {
+                roots.add(cert).unwrap();
+            }
+
             let config = rustls::ClientConfig::builder()
-                .with_safe_defaults()
+                .with_root_certificates(roots)
-                .with_native_roots()
                 .with_no_client_auth();
             let connector = tokio_tungstenite::Connector::Rustls(Arc::new(config));
 
-            tokio_tungstenite::connect_async_tls_with_config(ws_url, None, Some(connector)).await?
+            tokio_tungstenite::connect_async_tls_with_config(ws_url, None, false, Some(connector))
+                .await?
         } else {
             // Perform an unsecure connection
             tokio_tungstenite::connect_async(ws_url).await?
@@ -90,12 +152,12 @@ impl Client {
                 match Self::recv_next_msg(&mut stream).await {
                     Ok(msg) => {
                         if let Err(e) = sender.send(msg.clone()) {
-                            log::error!("Failed to forward ws message! {} (msg={:?})", e, msg);
+                            log::debug!("Failed to forward ws message! {} (msg={:?})", e, msg);
                             break;
                         }
                     }
                     Err(e) => {
-                        log::error!("Failed receive next message from websocket! {}", e);
+                        log::debug!("Failed receive next message from websocket! {}", e);
                         break;
                     }
                 }
@@ -162,4 +224,11 @@ impl Client {
     pub async fn recv_next_message(&self) -> Res<ServerMessage> {
         Ok(self.receiver.recv()?)
     }
+
+    /// Close connection
+    pub async fn close_connection(&mut self) {
+        if let Err(e) = self.sink.send(Message::Close(None)).await {
+            log::debug!("Failed to close WS connection! {:?}", e);
+        }
+    }
 }

rust/sea_battle_cli_player/src/lib.rs

@@ -2,7 +2,7 @@ extern crate core;
 
 pub mod cli_args;
 pub mod client;
-pub mod constants;
+pub mod consts;
 pub mod server;
 pub mod ui_screens;
 pub mod ui_widgets;

rust/sea_battle_cli_player/src/main.rs

@@ -0,0 +1,231 @@
+use std::error::Error;
+use std::io;
+use std::io::ErrorKind;
+
+use crossterm::event::DisableMouseCapture;
+use crossterm::event::EnableMouseCapture;
+use crossterm::execute;
+use crossterm::terminal::EnterAlternateScreen;
+use crossterm::terminal::LeaveAlternateScreen;
+use crossterm::terminal::{disable_raw_mode, enable_raw_mode};
+use env_logger::Env;
+use tui::backend::{Backend, CrosstermBackend};
+use tui::Terminal;
+
+use sea_battle_backend::consts::{
+    INVITE_CODE_LENGTH, MAX_PLAYER_NAME_LENGTH, MIN_PLAYER_NAME_LENGTH,
+};
+use sea_battle_backend::data::GameRules;
+use sea_battle_backend::utils::res_utils::Res;
+use sea_battle_cli_player::cli_args::{cli_args, TestDevScreen};
+use sea_battle_cli_player::client::{Client, GetRemoteVersionError};
+use sea_battle_cli_player::server::run_server;
+use sea_battle_cli_player::ui_screens::configure_game_rules::GameRulesConfigurationScreen;
+use sea_battle_cli_player::ui_screens::game_screen::GameScreen;
+use sea_battle_cli_player::ui_screens::input_screen::InputScreen;
+use sea_battle_cli_player::ui_screens::popup_screen::PopupScreen;
+use sea_battle_cli_player::ui_screens::select_play_mode_screen::{
+    SelectPlayModeResult, SelectPlayModeScreen,
+};
+use sea_battle_cli_player::ui_screens::*;
+
+/// Test code screens
+async fn run_dev<B: Backend>(
+    terminal: &mut Terminal<B>,
+    d: TestDevScreen,
+) -> Result<(), Box<dyn Error>> {
+    let res = match d {
+        TestDevScreen::Popup => PopupScreen::new("Welcome there!!")
+            .show(terminal)?
+            .as_string(),
+        TestDevScreen::Input => InputScreen::new("What it your name ?")
+            .set_title("A custom title")
+            .show(terminal)?
+            .as_string(),
+        TestDevScreen::Confirm => {
+            confirm_dialog_screen::ConfirmDialogScreen::new("Do you really want to quit game?")
+                .show(terminal)?
+                .as_string()
+        }
+        TestDevScreen::SelectBotType => select_bot_type_screen::SelectBotTypeScreen::default()
+            .show(terminal)?
+            .as_string(),
+        TestDevScreen::SelectPlayMode => {
+            SelectPlayModeScreen::default().show(terminal)?.as_string()
+        }
+        TestDevScreen::SetBoatsLayout => {
+            let rules = GameRules {
+                boats_can_touch: true,
+                ..Default::default()
+            };
+
+            set_boats_layout_screen::SetBoatsLayoutScreen::new(&rules)
+                .show(terminal)?
+                .as_string()
+        }
+        TestDevScreen::ConfigureGameRules => {
+            GameRulesConfigurationScreen::new(GameRules::default())
+                .show(terminal)?
+                .as_string()
+        }
+    };
+
+    Err(io::Error::new(
+        ErrorKind::Other,
+        format!("DEV result: {:?}", res),
+    ))?
+}
+
+/// Ask the user to specify the name he should be identified with
+fn query_player_name<B: Backend>(terminal: &mut Terminal<B>) -> Res<String> {
+    let mut hostname = hostname::get()?.to_string_lossy().to_string();
+    if hostname.len() > MAX_PLAYER_NAME_LENGTH {
+        hostname = hostname[0..MAX_PLAYER_NAME_LENGTH].to_string();
+    }
+
+    let res =
+        InputScreen::new("Please specify the name to which other players should identify you:")
+            .set_title("Player name")
+            .set_value(&hostname)
+            .set_min_length(MIN_PLAYER_NAME_LENGTH)
+            .set_max_length(MAX_PLAYER_NAME_LENGTH)
+            .show(terminal)?;
+
+    Ok(res.value().unwrap_or(hostname))
+}
+
+async fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> Res {
+    if let Some(d) = cli_args().dev_screen {
+        return run_dev(terminal, d).await;
+    }
+
+    let mut checked_online_compatibility = false;
+
+    let mut rules = GameRules::default();
+
+    let mut username = "".to_string();
+
+    loop {
+        terminal.clear()?;
+        let choice = SelectPlayModeScreen::default().show(terminal)?;
+
+        if let ScreenResult::Ok(c) = choice {
+            // Check compatibility
+            if c.is_online_play_mode() && !checked_online_compatibility {
+                PopupScreen::new("🖥 Checking remote server version...").show_once(terminal)?;
+                let valid_version = match Client::get_server_version().await {
+                    Ok(v) => v.is_compatible_with_static_version().unwrap_or(false),
+                    Err(GetRemoteVersionError::ConnectionFailed) => {
+                        PopupScreen::new("❌ Could not connect to remote server!")
+                            .show(terminal)?;
+                        continue;
+                    }
+                    Err(GetRemoteVersionError::Other(e)) => {
+                        log::error!("Could not load remote server information! {:?}", e);
+                        false
+                    }
+                };
+
+                if !valid_version {
+                    PopupScreen::new("❌ Unfortunately, it seems that your version of Sea Battle Cli player is too old to be used online...\n\nPlease update it before trying to play online...").show(terminal)?;
+                    continue;
+                }
+
+                checked_online_compatibility = true;
+            }
+
+            if c.need_player_name() && username.is_empty() {
+                username = query_player_name(terminal)?;
+            }
+
+            if c.need_custom_rules() {
+                rules = match GameRulesConfigurationScreen::new(rules.clone()).show(terminal)? {
+                    ScreenResult::Ok(r) => r,
+                    ScreenResult::Canceled => continue,
+                }
+            }
+        }
+
+        PopupScreen::new("🔌 Connecting...").show_once(terminal)?;
+
+        let client = match choice {
+            ScreenResult::Ok(SelectPlayModeResult::PlayRandom) => {
+                Client::start_random_play(&username).await
+            }
+
+            // Play against bot
+            ScreenResult::Ok(SelectPlayModeResult::PlayAgainstBot) => {
+                Client::start_bot_play(&rules).await
+            }
+
+            // Create invite
+            ScreenResult::Ok(SelectPlayModeResult::CreateInvite) => {
+                Client::start_create_invite(&rules, &username).await
+            }
+
+            // Join invite
+            ScreenResult::Ok(SelectPlayModeResult::AcceptInvite) => {
+                let code = match InputScreen::new("Invite code")
+                    .set_min_length(INVITE_CODE_LENGTH)
+                    .set_max_length(INVITE_CODE_LENGTH)
+                    .show(terminal)?
+                    .value()
+                {
+                    None => continue,
+                    Some(v) => v,
+                };
+
+                PopupScreen::new("🔌 Connecting...").show_once(terminal)?;
+                Client::start_accept_invite(code, &username).await
+            }
+
+            ScreenResult::Canceled | ScreenResult::Ok(SelectPlayModeResult::Exit) => return Ok(()),
+        };
+
+        match client {
+            Ok(client) => {
+                // Display game screen
+                GameScreen::new(client).show(terminal).await?;
+            }
+            Err(e) => {
+                log::error!("Failed to connect to server: {}", e);
+                PopupScreen::new("❌ Failed to connect to server!").show(terminal)?;
+            }
+        };
+    }
+}
+
+#[tokio::main]
+pub async fn main() -> Result<(), Box<dyn Error>> {
+    env_logger::Builder::from_env(Env::default()).init();
+
+    if cli_args().serve {
+        run_server().await;
+        return Ok(());
+    }
+
+    // setup terminal
+    enable_raw_mode()?;
+    let mut stdout = io::stdout();
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+    let backend = CrosstermBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    // create app and run it
+    let res = run_app(&mut terminal).await;
+
+    // restore terminal
+    disable_raw_mode()?;
+    execute!(
+        terminal.backend_mut(),
+        LeaveAlternateScreen,
+        DisableMouseCapture
+    )?;
+    terminal.show_cursor()?;
+
+    if let Err(err) = res {
+        println!("{:?}", err)
+    }
+
+    Ok(())
+}

rust/sea_battle_cli_player/src/server.rs

@@ -6,6 +6,21 @@ use sea_battle_backend::utils::network_utils;
 
 use crate::cli_args::cli_args;
 
+pub async fn run_server() {
+    let local_set = task::LocalSet::new();
+
+    local_set
+        .run_until(async move {
+            sea_battle_backend::server::start_server(Args {
+                listen_address: cli_args().listen_address.clone(),
+                cors: None,
+            })
+            .await
+            .expect("Failed to run local server!")
+        })
+        .await;
+}
+
 pub async fn start_server_if_missing() {
     if !network_utils::is_port_open(cli_args().listen_port()).await {
         log::info!(
@@ -15,16 +30,9 @@ pub async fn start_server_if_missing() {
         std::thread::spawn(move || {
             let rt = Builder::new_current_thread().enable_all().build().unwrap();
 
-            let local_set = task::LocalSet::new();
+            rt.block_on(run_server());
-
-            rt.block_on(local_set.run_until(async move {
-                sea_battle_backend::server::start_server(Args {
-                    listen_address: cli_args().listen_address.clone(),
-                    cors: None,
-                })
-                .await
-                .expect("Failed to run local server!")
-            }));
         });
+
+        network_utils::wait_for_port(cli_args().listen_port()).await;
     }
 }

rust/sea_battle_cli_player/src/ui_screens/configure_game_rules.rs

@@ -5,6 +5,9 @@ use std::time::{Duration, Instant};
 
 use crossterm::event;
 use crossterm::event::{Event, KeyCode};
+use sea_battle_backend::consts::{
+    MAX_BOATS_NUMBER, MAX_MAP_HEIGHT, MAX_MAP_WIDTH, MAX_STRIKE_TIMEOUT,
+};
 use tui::backend::Backend;
 use tui::layout::{Constraint, Direction, Layout, Margin};
 use tui::style::{Color, Style};
@@ -13,7 +16,8 @@ use tui::{Frame, Terminal};
 
 use sea_battle_backend::data::GameRules;
 
-use crate::constants::{HIGHLIGHT_COLOR, TICK_RATE};
+use crate::consts::{HIGHLIGHT_COLOR, TICK_RATE};
+use crate::ui_screens::popup_screen::show_screen_too_small_popup;
 use crate::ui_screens::select_bot_type_screen::SelectBotTypeScreen;
 use crate::ui_screens::utils::centered_rect_size;
 use crate::ui_screens::ScreenResult;
@@ -21,11 +25,12 @@ use crate::ui_widgets::button_widget::ButtonWidget;
 use crate::ui_widgets::checkbox_widget::CheckboxWidget;
 use crate::ui_widgets::text_editor_widget::TextEditorWidget;
 
-#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Eq, PartialEq)]
+#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Eq, PartialEq, Copy, Clone)]
 enum EditingField {
     MapWidth = 0,
     MapHeight,
     BoatsList,
+    StrikeTimeout,
     BoatsCanTouch,
     PlayerContinueOnHit,
     BotType,
@@ -58,13 +63,13 @@ impl GameRulesConfigurationScreen {
                 .checked_sub(last_tick.elapsed())
                 .unwrap_or_else(|| Duration::from_secs(0));
 
-            if crossterm::event::poll(timeout)? {
+            if event::poll(timeout)? {
                 let mut cursor_pos = self.curr_field as i32;
 
                 if let Event::Key(key) = event::read()? {
                     match key.code {
                         // Quit app
-                        KeyCode::Char('q') => return Ok(ScreenResult::Canceled),
+                        KeyCode::Char('q') | KeyCode::Esc => return Ok(ScreenResult::Canceled),
 
                         // Navigate between fields
                         KeyCode::Up | KeyCode::Left => cursor_pos -= 1,
@@ -114,24 +119,46 @@ impl GameRulesConfigurationScreen {
                             {
                                 self.rules.remove_last_boat();
                             }
+
+                            if self.curr_field == EditingField::StrikeTimeout {
+                                match self.rules.strike_timeout.unwrap_or(0) / 10 {
+                                    0 => self.rules.strike_timeout = None,
+                                    v => self.rules.strike_timeout = Some(v),
+                                }
+                            }
                         }
 
-                        KeyCode::Char(c) if ('0'..='9').contains(&c) => {
+                        KeyCode::Char(c) if c.is_ascii_digit() => {
                             let val = c.to_string().parse::<usize>().unwrap_or_default();
 
-                            if self.curr_field == EditingField::MapWidth {
+                            if self.curr_field == EditingField::MapWidth
+                                && self.rules.map_width <= MAX_MAP_WIDTH
+                            {
                                 self.rules.map_width *= 10;
                                 self.rules.map_width += val;
                             }
 
-                            if self.curr_field == EditingField::MapHeight {
+                            if self.curr_field == EditingField::MapHeight
+                                && self.rules.map_height <= MAX_MAP_HEIGHT
+                            {
                                 self.rules.map_height *= 10;
                                 self.rules.map_height += val;
                             }
 
-                            if self.curr_field == EditingField::BoatsList {
+                            if self.curr_field == EditingField::BoatsList
+                                && self.rules.boats_list().len() < MAX_BOATS_NUMBER
+                            {
                                 self.rules.add_boat(val);
                             }
+
+                            if self.curr_field == EditingField::StrikeTimeout {
+                                let mut timeout = self.rules.strike_timeout.unwrap_or(0);
+                                if timeout <= MAX_STRIKE_TIMEOUT {
+                                    timeout *= 10;
+                                    timeout += val as u64;
+                                    self.rules.strike_timeout = Some(timeout);
+                                }
+                            }
                         }
 
                         _ => {}
@@ -153,19 +180,29 @@ impl GameRulesConfigurationScreen {
     }
 
     fn ui<B: Backend>(&mut self, f: &mut Frame<B>) {
-        let area = centered_rect_size(50, 20, &f.size());
+        let (w, h) = (50, 23);
 
-        let block = Block::default().title("Game rules").borders(Borders::ALL);
+        if f.size().width < w || f.size().height < h {
+            show_screen_too_small_popup(f);
+            return;
+        }
+
+        let area = centered_rect_size(w, h, &f.size());
+
+        let block = Block::default()
+            .title("📓 Game rules")
+            .borders(Borders::ALL);
         f.render_widget(block, area);
 
         let chunks = Layout::default()
             .direction(Direction::Vertical)
             .constraints([
-                Constraint::Length(3),
+                Constraint::Length(3), // Map width
-                Constraint::Length(3),
+                Constraint::Length(3), // Map height
-                Constraint::Length(3),
+                Constraint::Length(3), // Boats list
-                Constraint::Length(1),
+                Constraint::Length(3), // Strike timeout
-                Constraint::Length(1),
+                Constraint::Length(1), // Boats can touch
+                Constraint::Length(1), // Player continue on hit
                 Constraint::Length(3), // Bot type
                 Constraint::Length(1), // Margin
                 Constraint::Length(1), // Buttons
@@ -203,6 +240,13 @@ impl GameRulesConfigurationScreen {
         );
         f.render_widget(editor, chunks[EditingField::BoatsList as usize]);
 
+        let editor = TextEditorWidget::new(
+            "Strike timeout (0 to disable)",
+            &self.rules.strike_timeout.unwrap_or(0).to_string(),
+            self.curr_field == EditingField::StrikeTimeout,
+        );
+        f.render_widget(editor, chunks[EditingField::StrikeTimeout as usize]);
+
         let editor = CheckboxWidget::new(
             "Boats can touch",
             self.rules.boats_can_touch,
@@ -239,10 +283,10 @@ impl GameRulesConfigurationScreen {
             .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
             .split(chunks[EditingField::OK as usize]);
 
-        let button = ButtonWidget::new("Cancel", self.curr_field == EditingField::Cancel);
+        let button = ButtonWidget::cancel(self.curr_field == EditingField::Cancel);
         f.render_widget(button, buttons_chunk[0]);
 
-        let button = ButtonWidget::new("OK", self.curr_field == EditingField::OK)
+        let button = ButtonWidget::ok(self.curr_field == EditingField::OK)
             .set_disabled(!self.rules.is_valid());
         f.render_widget(button, buttons_chunk[1]);
 

rust/sea_battle_cli_player/src/ui_screens/confirm_dialog_screen.rs

@@ -9,7 +9,7 @@ use tui::text::*;
 use tui::widgets::*;
 use tui::{Frame, Terminal};
 
-use crate::constants::*;
+use crate::consts::*;
 use crate::ui_screens::utils::centered_rect_size;
 use crate::ui_screens::ScreenResult;
 use crate::ui_widgets::button_widget::ButtonWidget;
@@ -18,6 +18,7 @@ use crate::ui_widgets::button_widget::ButtonWidget;
 pub fn confirm<B: Backend>(terminal: &mut Terminal<B>, msg: &str) -> bool {
     matches!(
         ConfirmDialogScreen::new(msg)
+            .set_can_escape(true)
             .show(terminal)
             .unwrap_or(ScreenResult::Canceled),
         ScreenResult::Ok(true)
@@ -28,19 +29,24 @@ pub struct ConfirmDialogScreen<'a> {
     title: &'a str,
     msg: &'a str,
     is_confirm: bool,
-    can_cancel: bool,
+    can_escape: bool,
 }
 
 impl<'a> ConfirmDialogScreen<'a> {
     pub fn new(msg: &'a str) -> Self {
         Self {
-            title: "Confirmation Request",
+            title: "❔ Confirmation Request",
             msg,
             is_confirm: true,
-            can_cancel: false,
+            can_escape: false,
         }
     }
 
+    pub fn set_can_escape(mut self, v: bool) -> Self {
+        self.can_escape = v;
+        self
+    }
+
     pub fn show<B: Backend>(
         mut self,
         terminal: &mut Terminal<B>,
@@ -56,7 +62,7 @@ impl<'a> ConfirmDialogScreen<'a> {
             if event::poll(timeout)? {
                 if let Event::Key(key) = event::read()? {
                     match key.code {
-                        KeyCode::Esc | KeyCode::Char('q') if self.can_cancel => {
+                        KeyCode::Esc | KeyCode::Char('q') if self.can_escape => {
                             return Ok(ScreenResult::Canceled)
                         }
 
@@ -117,10 +123,10 @@ impl<'a> ConfirmDialogScreen<'a> {
             .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
             .split(chunks[1]);
 
-        let cancel_button = ButtonWidget::new("Cancel", true).set_disabled(self.is_confirm);
+        let cancel_button = ButtonWidget::cancel(true).set_disabled(self.is_confirm);
         f.render_widget(cancel_button, buttons_area[0]);
 
-        let ok_button = ButtonWidget::new("Confirm", true).set_disabled(!self.is_confirm);
+        let ok_button = ButtonWidget::new("✅ Confirm", true).set_disabled(!self.is_confirm);
         f.render_widget(ok_button, buttons_area[1]);
     }
 }

rust/sea_battle_cli_player/src/ui_screens/game_screen.rs

@@ -12,23 +12,28 @@ use tui::{Frame, Terminal};
 
 use sea_battle_backend::data::{Coordinates, CurrentGameMapStatus, CurrentGameStatus};
 use sea_battle_backend::human_player_ws::{ClientMessage, ServerMessage};
-use sea_battle_backend::utils::Res;
+use sea_battle_backend::utils::res_utils::Res;
+use sea_battle_backend::utils::time_utils::time;
 
 use crate::client::Client;
-use crate::constants::*;
+use crate::consts::*;
 use crate::ui_screens::confirm_dialog_screen::confirm;
-use crate::ui_screens::popup_screen::PopupScreen;
+use crate::ui_screens::popup_screen::{show_screen_too_small_popup, PopupScreen};
 use crate::ui_screens::set_boats_layout_screen::SetBoatsLayoutScreen;
-use crate::ui_screens::utils::{centered_rect_size, centered_text};
+use crate::ui_screens::utils::{
+    centered_rect_size, centered_rect_size_horizontally, centered_text,
+};
 use crate::ui_screens::ScreenResult;
 use crate::ui_widgets::button_widget::ButtonWidget;
 use crate::ui_widgets::game_map_widget::{ColoredCells, GameMapWidget};
 
 type CoordinatesMapper = HashMap<Coordinates, Coordinates>;
 
-#[derive(Eq, PartialEq)]
+#[derive(Eq, PartialEq, Ord, PartialOrd)]
 enum GameStatus {
-    Pending,
+    Connecting,
+    WaitingForAnotherPlayer,
+    OpponentConnected,
     WaitingForOpponentBoatsConfig,
     OpponentReady,
     Starting,
@@ -45,26 +50,26 @@ enum GameStatus {
 
 impl GameStatus {
     pub fn can_show_game_maps(&self) -> bool {
-        self != &GameStatus::Pending
+        self > &GameStatus::Starting
-            && self != &GameStatus::WaitingForOpponentBoatsConfig
-            && self != &GameStatus::OpponentReady
     }
 
     pub fn status_text(&self) -> &str {
         match self {
-            GameStatus::Pending => "Game is pending...",
+            GameStatus::Connecting => "🔌 Connecting...",
-            GameStatus::WaitingForOpponentBoatsConfig => "Waiting for ### boats configuration",
+            GameStatus::WaitingForAnotherPlayer => "🕑 Waiting for another player...",
-            GameStatus::OpponentReady => "### is ready!",
+            GameStatus::OpponentConnected => "✅ Opponent connected!",
-            GameStatus::Starting => "Game is starting...",
+            GameStatus::WaitingForOpponentBoatsConfig => "🕑 Waiting for ### boats configuration",
-            GameStatus::MustFire => "You must fire!",
+            GameStatus::OpponentReady => "✅ ### is ready!",
-            GameStatus::OpponentMustFire => "### must fire!",
+            GameStatus::Starting => "🕑 Game is starting...",
-            GameStatus::WonGame => "You won the game!",
+            GameStatus::MustFire => "🚨 You must fire!",
-            GameStatus::LostGame => "### won the game. You loose.",
+            GameStatus::OpponentMustFire => "💣 ### must fire!",
-            GameStatus::RematchRequestedByOpponent => "Rematch requested by ###",
+            GameStatus::WonGame => "🎉 You win the game!",
-            GameStatus::RematchRequestedByPlayer => "Rematch requested by you",
+            GameStatus::LostGame => "😿 ### wins the game. You loose.",
-            GameStatus::RematchAccepted => "Rematch accepted!",
+            GameStatus::RematchRequestedByOpponent => "❓ Rematch requested by ###",
-            GameStatus::RematchRejected => "Rematch rejected!",
+            GameStatus::RematchRequestedByPlayer => "❓ Rematch requested by you",
-            GameStatus::OpponentLeftGame => "Opponent left game!",
+            GameStatus::RematchAccepted => "✅ Rematch accepted!",
+            GameStatus::RematchRejected => "❌ Rematch rejected!",
+            GameStatus::OpponentLeftGame => "⛔ Opponent left game!",
         }
     }
 }
@@ -80,18 +85,20 @@ enum Buttons {
 impl Buttons {
     pub fn text(&self) -> &str {
         match self {
-            Buttons::RequestRematch => "Request rematch",
+            Buttons::RequestRematch => "❓ Request rematch",
-            Buttons::AcceptRematch => "Accept rematch",
+            Buttons::AcceptRematch => "✅ Accept rematch",
-            Buttons::RejectRematch => "Reject rematch",
+            Buttons::RejectRematch => "❌ Reject rematch",
-            Buttons::QuitGame => "Quit game",
+            Buttons::QuitGame => "❌ Quit game",
         }
     }
 }
 
 pub struct GameScreen {
     client: Client,
+    invite_code: Option<String>,
     status: GameStatus,
     opponent_name: Option<String>,
+    game_last_update: u64,
     game: CurrentGameStatus,
     curr_shoot_position: Coordinates,
     last_opponent_fire_position: Coordinates,
@@ -102,8 +109,10 @@ impl GameScreen {
     pub fn new(client: Client) -> Self {
         Self {
             client,
-            status: GameStatus::Pending,
+            invite_code: None,
+            status: GameStatus::Connecting,
             opponent_name: None,
+            game_last_update: 0,
             game: Default::default(),
             curr_shoot_position: Coordinates::new(0, 0),
             last_opponent_fire_position: Coordinates::invalid(),
@@ -129,7 +138,7 @@ impl GameScreen {
                 .unwrap_or_else(|| Duration::from_secs(0));
 
             // Handle terminal events
-            if crossterm::event::poll(timeout)? {
+            if event::poll(timeout)? {
                 let event = event::read()?;
 
                 // Keyboard event
@@ -138,9 +147,10 @@ impl GameScreen {
 
                     match key.code {
                         // Leave game
-                        KeyCode::Char('q')
+                        KeyCode::Char('q') | KeyCode::Esc
                             if confirm(terminal, "Do you really want to leave game?") =>
                         {
+                            self.client.close_connection().await;
                             return Ok(ScreenResult::Canceled);
                         }
 
@@ -188,7 +198,10 @@ impl GameScreen {
                                     .await?;
                                 self.status = GameStatus::RematchRejected;
                             }
-                            Buttons::QuitGame => return Ok(ScreenResult::Ok(())),
+                            Buttons::QuitGame => {
+                                self.client.close_connection().await;
+                                return Ok(ScreenResult::Ok(()));
+                            }
                         },
 
                         _ => {}
@@ -206,6 +219,16 @@ impl GameScreen {
                             coordinates_mapper.get(&Coordinates::new(mouse.column, mouse.row))
                         {
                             self.curr_shoot_position = *c;
+
+                            if self.can_fire()
+                                && self.game.can_fire_at_location(self.curr_shoot_position)
+                            {
+                                self.client
+                                    .send_message(&ClientMessage::Fire {
+                                        location: self.curr_shoot_position,
+                                    })
+                                    .await?;
+                            }
                         }
                     }
                 }
@@ -214,10 +237,23 @@ impl GameScreen {
             // Handle incoming messages
             while let Some(msg) = self.client.try_recv_next_message().await? {
                 match msg {
-                    ServerMessage::SetInviteCode { .. } => unimplemented!(),
+                    ServerMessage::SetInviteCode { code } => {
-                    ServerMessage::InvalidInviteCode => unimplemented!(),
+                        self.status = GameStatus::WaitingForAnotherPlayer;
-                    ServerMessage::WaitingForAnotherPlayer => unimplemented!(),
+                        self.invite_code = Some(code);
-                    ServerMessage::OpponentConnected => unimplemented!(),
+                    }
+
+                    ServerMessage::InvalidInviteCode => {
+                        PopupScreen::new("❌ Invalid invite code!").show(terminal)?;
+                        return Ok(ScreenResult::Ok(()));
+                    }
+
+                    ServerMessage::WaitingForAnotherPlayer => {
+                        self.status = GameStatus::WaitingForAnotherPlayer;
+                    }
+
+                    ServerMessage::OpponentConnected => {
+                        self.status = GameStatus::OpponentConnected;
+                    }
 
                     ServerMessage::SetOpponentName { name } => self.opponent_name = Some(name),
 
@@ -232,6 +268,7 @@ impl GameScreen {
                                     .await?
                             }
                             ScreenResult::Canceled => {
+                                self.client.close_connection().await;
                                 return Ok(ScreenResult::Canceled);
                             }
                         };
@@ -256,11 +293,13 @@ impl GameScreen {
 
                     ServerMessage::OpponentMustFire { status } => {
                         self.status = GameStatus::OpponentMustFire;
+                        self.game_last_update = time();
                         self.game = status;
                     }
 
                     ServerMessage::RequestFire { status } => {
                         self.status = GameStatus::MustFire;
+                        self.game_last_update = time();
                         self.game = status;
                     }
 
@@ -271,11 +310,13 @@ impl GameScreen {
                     }
 
                     ServerMessage::LostGame { status } => {
+                        self.game_last_update = time();
                         self.game = status;
                         self.status = GameStatus::LostGame;
                     }
 
                     ServerMessage::WonGame { status } => {
+                        self.game_last_update = time();
                         self.game = status;
                         self.status = GameStatus::WonGame;
                     }
@@ -325,6 +366,7 @@ impl GameScreen {
                 buttons.push(Buttons::RejectRematch);
             } else if self.status != GameStatus::OpponentLeftGame
                 && self.status != GameStatus::RematchRejected
+                && self.status != GameStatus::RematchRequestedByPlayer
             {
                 buttons.push(Buttons::RequestRematch);
             }
@@ -427,17 +469,34 @@ impl GameScreen {
     }
 
     fn ui<B: Backend>(&mut self, f: &mut Frame<B>) -> CoordinatesMapper {
-        let status_text = self
+        let mut status_text = self
             .status
             .status_text()
             .replace("###", self.opponent_name());
 
         // If the game is in a state where game maps can not be shown
         if !self.status.can_show_game_maps() {
+            if self.status == GameStatus::WaitingForAnotherPlayer {
+                if let Some(code) = &self.invite_code {
+                    status_text.push_str(&format!("\n\n🎫 Invite code: {}", code));
+                }
+            }
+
             PopupScreen::new(&status_text).show_in_frame(f);
             return HashMap::default();
         }
 
+        // Add timeout (if required)
+        let mut timeout_str = String::new();
+        if self.status == GameStatus::MustFire || self.status == GameStatus::OpponentMustFire {
+            if let Some(remaining) = self.game.remaining_time_for_strike {
+                let timeout = self.game_last_update + remaining;
+                if time() < timeout {
+                    timeout_str = format!(" {} seconds left", timeout - time());
+                }
+            }
+        }
+
         // Draw main ui (default play UI)
         let player_map = self
             .player_map(&self.game.your_map, false)
@@ -481,19 +540,22 @@ impl GameScreen {
 
         let buttons_width = buttons.iter().fold(0, |a, b| a + b.estimated_size().0 + 4);
 
-        let max_width = max(maps_width, status_text.len() as u16).max(buttons_width);
+        let max_width = max(maps_width, status_text.len() as u16)
-        let total_height = 3 + maps_height + 3;
+            .max(buttons_width)
+            .max(timeout_str.len() as u16);
+        let total_height = 3 + 1 + maps_height + 3;
 
         // Check if frame is too small
         if max_width > f.size().width || total_height > f.size().height {
-            PopupScreen::new("Screen too small!").show_in_frame(f);
+            show_screen_too_small_popup(f);
             return HashMap::default();
         }
 
         let chunks = Layout::default()
             .direction(Direction::Vertical)
             .constraints([
-                Constraint::Length(3),
+                Constraint::Length(2),
+                Constraint::Length(2),
                 Constraint::Length(maps_height),
                 Constraint::Length(3),
             ])
@@ -503,25 +565,31 @@ impl GameScreen {
         let paragraph = Paragraph::new(status_text.as_str());
         f.render_widget(paragraph, centered_text(&status_text, &chunks[0]));
 
+        // Render timeout
+        let paragraph = Paragraph::new(timeout_str.as_str());
+        f.render_widget(paragraph, centered_text(&timeout_str, &chunks[1]));
+
         // Render maps
         if show_both_maps {
             let maps_chunks = Layout::default()
                 .direction(Direction::Horizontal)
-                .constraints([
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
-                    Constraint::Length(player_map_size.0),
+                .split(chunks[2]);
-                    Constraint::Length(3),
-                    Constraint::Length(opponent_map_size.0),
-                ])
-                .split(chunks[1]);
 
-            f.render_widget(player_map, maps_chunks[0]);
+            f.render_widget(
-            f.render_widget(opponent_map, maps_chunks[2]);
+                player_map,
+                centered_rect_size_horizontally(player_map_size.0, &maps_chunks[0]),
+            );
+            f.render_widget(
+                opponent_map,
+                centered_rect_size_horizontally(opponent_map_size.0, &maps_chunks[1]),
+            );
         } else {
             // Render a single map
             if self.can_fire() {
-                f.render_widget(opponent_map, chunks[1]);
+                f.render_widget(opponent_map, chunks[2]);
             } else {
-                f.render_widget(player_map, chunks[1]);
+                f.render_widget(player_map, chunks[2]);
                 drop(opponent_map);
             }
         }
@@ -535,7 +603,7 @@ impl GameScreen {
                         .map(|_| Constraint::Percentage(100 / buttons.len() as u16))
                         .collect::<Vec<_>>(),
                 )
-                .split(chunks[2]);
+                .split(chunks[3]);
 
             for (idx, b) in buttons.into_iter().enumerate() {
                 let target = centered_rect_size(

rust/sea_battle_cli_player/src/ui_screens/input_screen.rs

@@ -10,7 +10,7 @@ use tui::layout::*;
 use tui::widgets::*;
 use tui::{Frame, Terminal};
 
-use crate::constants::*;
+use crate::consts::*;
 use crate::ui_screens::utils::*;
 use crate::ui_screens::ScreenResult;
 use crate::ui_widgets::button_widget::ButtonWidget;
@@ -55,6 +55,16 @@ impl<'a> InputScreen<'a> {
         self
     }
 
+    pub fn set_min_length(mut self, v: usize) -> Self {
+        self.min_len = v;
+        self
+    }
+
+    pub fn set_max_length(mut self, v: usize) -> Self {
+        self.max_len = v;
+        self
+    }
+
     /// Get error contained in input
     fn error(&self) -> Option<&'static str> {
         if self.value.len() > self.max_len {
@@ -115,7 +125,7 @@ impl<'a> InputScreen<'a> {
 
     fn ui<B: Backend>(&mut self, f: &mut Frame<B>) {
         let area = centered_rect_size(
-            (self.msg.len() + 4).max(self.max_len + 4) as u16,
+            (self.msg.len() + 4).max(self.max_len + 4).max(25) as u16,
             7,
             &f.size(),
         );
@@ -153,12 +163,12 @@ impl<'a> InputScreen<'a> {
             .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
             .split(*chunks.last().unwrap());
 
-        let cancel_button = ButtonWidget::new("Cancel", self.is_cancel_hovered)
+        let cancel_button = ButtonWidget::cancel(self.is_cancel_hovered)
             .set_disabled(!self.can_cancel)
             .set_min_width(8);
         f.render_widget(cancel_button, buttons_area[0]);
 
-        let ok_button = ButtonWidget::new("OK", !self.is_cancel_hovered)
+        let ok_button = ButtonWidget::ok(!self.is_cancel_hovered)
             .set_min_width(8)
             .set_disabled(error.is_some());
         f.render_widget(ok_button, buttons_area[1]);

rust/sea_battle_cli_player/src/ui_screens/popup_screen.rs

@@ -9,11 +9,17 @@ use tui::text::*;
 use tui::widgets::*;
 use tui::{Frame, Terminal};
 
-use crate::constants::*;
+use crate::consts::*;
 use crate::ui_screens::utils::centered_rect_size;
 use crate::ui_screens::ScreenResult;
 use crate::ui_widgets::button_widget::ButtonWidget;
 
+/// Convenience function to inform user that his terminal window is too small to display the current
+/// screen
+pub fn show_screen_too_small_popup<B: Backend>(f: &mut Frame<B>) {
+    PopupScreen::new("🖵  Screen too small!").show_in_frame(f)
+}
+
 pub struct PopupScreen<'a> {
     title: &'a str,
     msg: &'a str,
@@ -46,7 +52,7 @@ impl<'a> PopupScreen<'a> {
             if event::poll(timeout)? {
                 if let Event::Key(key) = event::read()? {
                     match key.code {
-                        KeyCode::Char('q') => return Ok(ScreenResult::Canceled),
+                        KeyCode::Char('q') | KeyCode::Esc => return Ok(ScreenResult::Canceled),
                         KeyCode::Enter => {
                             return Ok(ScreenResult::Ok(()));
                         }

rust/sea_battle_cli_player/src/ui_screens/select_bot_type_screen.rs

@@ -11,7 +11,7 @@ use tui::{Frame, Terminal};
 
 use sea_battle_backend::data::{BotDescription, BotType, PlayConfiguration};
 
-use crate::constants::{HIGHLIGHT_COLOR, TICK_RATE};
+use crate::consts::{HIGHLIGHT_COLOR, TICK_RATE};
 use crate::ui_screens::utils::centered_rect_size;
 use crate::ui_screens::ScreenResult;
 
@@ -49,7 +49,7 @@ impl SelectBotTypeScreen {
             if event::poll(timeout)? {
                 if let Event::Key(key) = event::read()? {
                     match key.code {
-                        KeyCode::Char('q') => return Ok(ScreenResult::Canceled),
+                        KeyCode::Char('q') | KeyCode::Esc => return Ok(ScreenResult::Canceled),
                         KeyCode::Enter => {
                             return Ok(ScreenResult::Ok(self.types[self.curr_selection].r#type));
                         }

rust/sea_battle_cli_player/src/ui_screens/select_play_mode_screen.rs

@@ -1,7 +1,7 @@
 use std::io;
 use std::time::{Duration, Instant};
 
-use crate::constants::{HIGHLIGHT_COLOR, TICK_RATE};
+use crate::consts::{HIGHLIGHT_COLOR, TICK_RATE};
 use crate::ui_screens::utils::centered_rect_size;
 use crate::ui_screens::ScreenResult;
 use crossterm::event;
@@ -17,12 +17,25 @@ pub enum SelectPlayModeResult {
     #[default]
     PlayAgainstBot,
     PlayRandom,
+    CreateInvite,
+    AcceptInvite,
     Exit,
 }
 
 impl SelectPlayModeResult {
     /// Specify whether a selected play mode requires a user name or not
-    pub fn need_user_name(&self) -> bool {
+    pub fn need_player_name(&self) -> bool {
+        self != &SelectPlayModeResult::PlayAgainstBot && self != &SelectPlayModeResult::Exit
+    }
+
+    /// Specify whether a selected play mode requires a the user to specify its own game rules or
+    /// not
+    pub fn need_custom_rules(&self) -> bool {
+        self == &SelectPlayModeResult::PlayAgainstBot || self == &SelectPlayModeResult::CreateInvite
+    }
+
+    /// Specify whether a play mode is to be played online or not
+    pub fn is_online_play_mode(&self) -> bool {
         self != &SelectPlayModeResult::PlayAgainstBot && self != &SelectPlayModeResult::Exit
     }
 }
@@ -33,17 +46,25 @@ struct PlayModeDescription {
     value: SelectPlayModeResult,
 }
 
-const AVAILABLE_PLAY_MODES: [PlayModeDescription; 3] = [
+const AVAILABLE_PLAY_MODES: [PlayModeDescription; 5] = [
     PlayModeDescription {
-        name: "Play against bot (offline)",
+        name: "🤖 Play against bot (offline)",
         value: SelectPlayModeResult::PlayAgainstBot,
     },
     PlayModeDescription {
-        name: "Play against random player (online)",
+        name: "🎲 Play against random player (online)",
         value: SelectPlayModeResult::PlayRandom,
     },
     PlayModeDescription {
-        name: "Exit app",
+        name: "➕ Create play invite (online)",
+        value: SelectPlayModeResult::CreateInvite,
+    },
+    PlayModeDescription {
+        name: "🎫 Accept play invite (online)",
+        value: SelectPlayModeResult::AcceptInvite,
+    },
+    PlayModeDescription {
+        name: "❌ Exit app",
         value: SelectPlayModeResult::Exit,
     },
 ];
@@ -71,7 +92,7 @@ impl SelectPlayModeScreen {
             if crossterm::event::poll(timeout)? {
                 if let Event::Key(key) = event::read()? {
                     match key.code {
-                        KeyCode::Char('q') => return Ok(ScreenResult::Canceled),
+                        KeyCode::Char('q') | KeyCode::Esc => return Ok(ScreenResult::Canceled),
                         KeyCode::Enter => {
                             return Ok(ScreenResult::Ok(
                                 AVAILABLE_PLAY_MODES[self.curr_selection].value,
@@ -92,7 +113,7 @@ impl SelectPlayModeScreen {
     }
 
     fn ui<B: Backend>(&mut self, f: &mut Frame<B>) {
-        let area = centered_rect_size(50, 5, &f.size());
+        let area = centered_rect_size(50, 2 + AVAILABLE_PLAY_MODES.len() as u16, &f.size());
 
         // Create a List from all list items and highlight the currently selected one
         let items = AVAILABLE_PLAY_MODES

rust/sea_battle_cli_player/src/ui_screens/set_boats_layout_screen.rs

@@ -12,8 +12,9 @@ use tui::{Frame, Terminal};
 
 use sea_battle_backend::data::*;
 
-use crate::constants::*;
+use crate::consts::*;
 use crate::ui_screens::confirm_dialog_screen::confirm;
+use crate::ui_screens::popup_screen::show_screen_too_small_popup;
 use crate::ui_screens::utils::{centered_rect_size, centered_text};
 use crate::ui_screens::ScreenResult;
 use crate::ui_widgets::game_map_widget::{ColoredCells, GameMapWidget};
@@ -65,7 +66,7 @@ impl<'a> SetBoatsLayoutScreen<'a> {
                 let event = event::read()?;
                 if let Event::Key(key) = &event {
                     match key.code {
-                        KeyCode::Char('q') => {
+                        KeyCode::Char('q') | KeyCode::Esc => {
                             if !self.confirm_on_cancel
                                 || confirm(terminal, "Do you really want to quit?")
                             {
@@ -201,7 +202,7 @@ impl<'a> SetBoatsLayoutScreen<'a> {
             .add_colored_cells(current_boat)
             .add_colored_cells(invalid_boats)
             .add_colored_cells(other_boats)
-            .set_title("Choose your boat layout")
+            .set_title("🛥  Set your boats layout")
             .set_yield_func(|c, r| {
                 for i in 0..r.width {
                     for j in 0..r.height {
@@ -227,6 +228,14 @@ impl<'a> SetBoatsLayoutScreen<'a> {
         }
 
         let (w, h) = game_map_widget.estimated_size();
+
+        if f.size().width < w || f.size().height < h + 3 {
+            // +3 = for errors
+            show_screen_too_small_popup(f);
+            drop(game_map_widget);
+            return coordinates_mapper;
+        }
+
         let area = centered_rect_size(w, h, &f.size());
         f.render_widget(game_map_widget, area);
 

rust/sea_battle_cli_player/src/ui_screens/utils.rs

@@ -46,6 +46,25 @@ pub fn centered_rect_size(width: u16, height: u16, parent: &Rect) -> Rect {
     }
 }
 
+/// helper function to create a centered rect using up certain container size, only horizontally
+pub fn centered_rect_size_horizontally(width: u16, parent: &Rect) -> Rect {
+    if parent.width < width {
+        return Rect {
+            x: parent.x,
+            y: parent.y,
+            width: parent.width,
+            height: parent.height,
+        };
+    }
+
+    Rect {
+        x: parent.x + (parent.width - width) / 2,
+        y: parent.y,
+        width,
+        height: parent.height,
+    }
+}
+
 /// Get coordinates to render centered text
 pub fn centered_text(text: &str, container: &Rect) -> Rect {
     if text.len() > container.width as usize {

rust/sea_battle_cli_player/src/ui_widgets/button_widget.rs

@@ -1,6 +1,6 @@
 use std::fmt::Display;
 
-use crate::constants::HIGHLIGHT_COLOR;
+use crate::consts::HIGHLIGHT_COLOR;
 use tui::buffer::Buffer;
 use tui::layout::Rect;
 use tui::style::{Color, Style};
@@ -13,6 +13,7 @@ pub struct ButtonWidget {
     label: String,
     disabled: bool,
     min_width: usize,
+    hover_bg_color: Color,
 }
 
 impl ButtonWidget {
@@ -22,9 +23,18 @@ impl ButtonWidget {
             is_hovered,
             disabled: false,
             min_width: 0,
+            hover_bg_color: HIGHLIGHT_COLOR,
         }
     }
 
+    pub fn cancel(is_hovered: bool) -> Self {
+        Self::new("❌ Cancel", is_hovered).set_hover_bg_color(Color::Red)
+    }
+
+    pub fn ok(is_hovered: bool) -> Self {
+        Self::new("✅ OK", is_hovered)
+    }
+
     pub fn set_disabled(mut self, disabled: bool) -> Self {
         self.disabled = disabled;
         self
@@ -35,6 +45,11 @@ impl ButtonWidget {
         self
     }
 
+    pub fn set_hover_bg_color(mut self, v: Color) -> Self {
+        self.hover_bg_color = v;
+        self
+    }
+
     pub fn estimated_size(&self) -> (u16, u16) {
         ((self.label.len() + 2).max(self.min_width) as u16, 1)
     }
@@ -55,7 +70,7 @@ impl Widget for ButtonWidget {
         let input = Paragraph::new(label.as_ref()).style(match (self.disabled, self.is_hovered) {
             (true, _) => Style::default(),
             (_, false) => Style::default().bg(Color::DarkGray),
-            (_, true) => Style::default().fg(Color::White).bg(HIGHLIGHT_COLOR),
+            (_, true) => Style::default().fg(Color::White).bg(self.hover_bg_color),
         });
 
         input.render(area, buf);

rust/sea_battle_cli_player/src/ui_widgets/checkbox_widget.rs

@@ -1,4 +1,4 @@
-use crate::constants::HIGHLIGHT_COLOR;
+use crate::consts::HIGHLIGHT_COLOR;
 use std::fmt::Display;
 use tui::buffer::Buffer;
 use tui::layout::Rect;

rust/sea_battle_cli_player/src/ui_widgets/game_map_widget.rs

@@ -77,8 +77,8 @@ impl<'a> GameMapWidget<'a> {
     }
 
     pub fn grid_size(&self) -> (u16, u16) {
-        let w = self.rules.map_width as u16 * 2 + 1;
+        let w = (self.rules.map_width as u16 * 2) + 2;
-        let h = self.rules.map_height as u16 * 2 + 1;
+        let h = (self.rules.map_height as u16 * 2) + 2;
 
         (w, h)
     }
@@ -98,7 +98,7 @@ impl<'a> GameMapWidget<'a> {
     }
 }
 
-impl<'a> Widget for GameMapWidget<'a> {
+impl Widget for GameMapWidget<'_> {
     fn render(mut self, area: Rect, buf: &mut Buffer) {
         let alphabet = PlayConfiguration::default().ordinate_alphabet;
 

rust/sea_battle_cli_player/src/ui_widgets/text_editor_widget.rs

@@ -1,6 +1,6 @@
 use std::fmt::Display;
 
-use crate::constants::HIGHLIGHT_COLOR;
+use crate::consts::HIGHLIGHT_COLOR;
 use tui::buffer::Buffer;
 use tui::layout::Rect;
 use tui::style::*;