Update Rust crate clap to 4.4.1

Reviewed-on: #58

renovate.json

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

rust/sea_battle_backend/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sea_battle_backend"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "GPL-2.0-or-later"
 description = "A Sea Battle game backend server"
@@ -12,23 +12,24 @@ 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.4.1", features = ["derive"] }
-log = "0.4.17"
+log = "0.4.20"
-env_logger = "0.9.0"
+env_logger = "0.10.0"
-serde = { version = "1.0.145", features = ["derive"] }
+serde = { version = "1.0.186", features = ["derive"] }
-serde_json = "1.0.85"
+serde_json = "1.0.105"
 actix-web = "4.1.0"
 actix-cors = "0.6.2"
 actix = "0.13.0"
 actix-web-actors = "4.1.0"
-actix-rt = "2.7.0"
+actix-rt = "2.9.0"
-uuid = { version = "1.1.2", features = ["v4"] }
+uuid = { version = "1.4.1", features = ["v4"] }
 rand = "0.8.5"
-serde_with = "2.0.1"
+serde_with = "3.3.0"
 tokio = { version = "1", features = ["full"] }
+semver = "1.0.18"
 
 [dev-dependencies]
 #reqwest = { version = "0.11.11", default-features = false, features = ["json", "rustls-tls"] }
-tokio-tungstenite = "0.17.2"
+tokio-tungstenite = "0.20.0"
 serde_urlencoded = "0.7.1"
 futures = "0.3.23"

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/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;
 

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,9 +488,7 @@ mod test {
             map_height: 5,
             boats_str: "1,1".to_string(),
             boats_can_touch: false,
-            player_continue_on_hit: false,
+            ..Default::default()
-            strike_timeout: None,
-            bot_type: BotType::Random,
         };
 
         let mut boats = BoatsLayout(vec![

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/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/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,6 +164,7 @@ 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);
 
@@ -148,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))

rust/sea_battle_cli_player/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sea_battle_cli_player"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "GPL-2.0-or-later"
 description = "A Sea Battle game shell client"
@@ -12,22 +12,23 @@ 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.1.0" }
+sea_battle_backend = { path = "../sea_battle_backend", version = "0.2.0" }
-clap = { version = "4.0.15", features = ["derive"] }
+clap = { version = "4.4.1", features = ["derive"] }
-log = "0.4.17"
+log = "0.4.20"
-env_logger = "0.9.0"
+env_logger = "0.10.0"
 tui = "0.19.0"
-crossterm = "0.25.0"
+crossterm = "0.27.0"
 lazy_static = "1.4.0"
-tokio = "1.21.2"
+tokio = "1.32.0"
-num = "0.4.0"
+num = "0.4.1"
-num-traits = "0.2.15"
+num-traits = "0.2.16"
-num-derive = "0.3.3"
+num-derive = "0.4.0"
-textwrap = "0.15.1"
+textwrap = "0.16.0"
-tokio-tungstenite = { version = "0.17.2", features = ["__rustls-tls", "rustls-tls-native-roots"] }
+tokio-tungstenite = { version = "0.20.0", features = ["__rustls-tls", "rustls-tls-native-roots"] }
 serde_urlencoded = "0.7.1"
 futures = "0.3.23"
-serde_json = "1.0.85"
+serde_json = "1.0.105"
 hostname = "0.3.1"
-rustls = "0.20.6"
+rustls = "0.21.6"
-hyper-rustls = { version = "0.23.0", features = ["rustls-native-certs"] }
+hyper-rustls = { version = "0.24.1", features = ["rustls-native-certs"] }
+reqwest = { version = "0.11", features = ["json", "rustls-tls"], default-features = false }

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")]
@@ -61,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

@@ -3,12 +3,13 @@ use crate::server;
 use futures::stream::{SplitSink, SplitStream};
 use futures::{SinkExt, StreamExt};
 use hyper_rustls::ConfigBuilderExt;
-use sea_battle_backend::data::GameRules;
+use sea_battle_backend::data::*;
 use sea_battle_backend::human_player_ws::{ClientMessage, ServerMessage};
 use sea_battle_backend::server::{
     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};
@@ -18,6 +19,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
@@ -28,6 +34,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
@@ -38,7 +62,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()
                 })
@@ -51,10 +75,10 @@ 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()
@@ -66,10 +90,10 @@ impl Client {
     /// 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_uri,
+            &cli_args().remote_server,
             &format!(
                 "/play/create_invite?{}",
-                serde_urlencoded::to_string(&CreateInviteQuery {
+                serde_urlencoded::to_string(CreateInviteQuery {
                     rules: rules.clone(),
                     player_name: player_name.to_string()
                 })
@@ -82,10 +106,10 @@ impl Client {
     /// 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_uri,
+            &cli_args().remote_server,
             &format!(
                 "/play/accept_invite?{}",
-                serde_urlencoded::to_string(&AcceptInviteQuery {
+                serde_urlencoded::to_string(AcceptInviteQuery {
                     code,
                     player_name: player_name.to_string()
                 })
@@ -109,7 +133,7 @@ impl Client {
                 .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?

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

@@ -18,7 +18,7 @@ use sea_battle_backend::consts::{
 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;
+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;
@@ -35,10 +35,10 @@ async fn run_dev<B: Backend>(
     d: TestDevScreen,
 ) -> Result<(), Box<dyn Error>> {
     let res = match d {
-        TestDevScreen::Popup => popup_screen::PopupScreen::new("Welcome there!!")
+        TestDevScreen::Popup => PopupScreen::new("Welcome there!!")
             .show(terminal)?
             .as_string(),
-        TestDevScreen::Input => input_screen::InputScreen::new("What it your name ?")
+        TestDevScreen::Input => InputScreen::new("What it your name ?")
             .set_title("A custom title")
             .show(terminal)?
             .as_string(),
@@ -50,9 +50,9 @@ async fn run_dev<B: Backend>(
         TestDevScreen::SelectBotType => select_bot_type_screen::SelectBotTypeScreen::default()
             .show(terminal)?
             .as_string(),
-        TestDevScreen::SelectPlayMode => select_play_mode_screen::SelectPlayModeScreen::default()
+        TestDevScreen::SelectPlayMode => {
-            .show(terminal)?
+            SelectPlayModeScreen::default().show(terminal)?.as_string()
-            .as_string(),
+        }
         TestDevScreen::SetBoatsLayout => {
             let rules = GameRules {
                 boats_can_touch: true,
@@ -64,7 +64,7 @@ async fn run_dev<B: Backend>(
                 .as_string()
         }
         TestDevScreen::ConfigureGameRules => {
-            configure_game_rules::GameRulesConfigurationScreen::new(GameRules::default())
+            GameRulesConfigurationScreen::new(GameRules::default())
                 .show(terminal)?
                 .as_string()
         }
@@ -99,14 +99,41 @@ async fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> Res {
         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)?;
             }
@@ -123,17 +150,17 @@ async fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> Res {
 
         let client = match choice {
             ScreenResult::Ok(SelectPlayModeResult::PlayRandom) => {
-                Client::start_random_play(&username).await?
+                Client::start_random_play(&username).await
             }
 
             // Play against bot
             ScreenResult::Ok(SelectPlayModeResult::PlayAgainstBot) => {
-                Client::start_bot_play(&rules).await?
+                Client::start_bot_play(&rules).await
             }
 
             // Create invite
             ScreenResult::Ok(SelectPlayModeResult::CreateInvite) => {
-                Client::start_create_invite(&rules, &username).await?
+                Client::start_create_invite(&rules, &username).await
             }
 
             // Join invite
@@ -149,15 +176,23 @@ async fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> Res {
                 };
 
                 PopupScreen::new("🔌 Connecting...").show_once(terminal)?;
-                Client::start_accept_invite(code, &username).await?
+                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]

rust/sea_battle_cli_player/src/ui_screens/configure_game_rules.rs

@@ -16,7 +16,7 @@ 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;
@@ -25,7 +25,7 @@ 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,
@@ -69,7 +69,7 @@ impl GameRulesConfigurationScreen {
                 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,
@@ -128,7 +128,7 @@ impl GameRulesConfigurationScreen {
                             }
                         }
 
-                        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
@@ -283,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

@@ -16,7 +16,7 @@ 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::{show_screen_too_small_popup, PopupScreen};
 use crate::ui_screens::set_boats_layout_screen::SetBoatsLayoutScreen;
@@ -147,7 +147,7 @@ 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;

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;
@@ -163,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,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;
@@ -52,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;
@@ -33,6 +33,11 @@ impl SelectPlayModeResult {
     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
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -87,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,

rust/sea_battle_cli_player/src/ui_screens/set_boats_layout_screen.rs

@@ -12,7 +12,7 @@ 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};
@@ -66,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?")
                             {
@@ -202,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 {

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/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::*;