improvement: UI for connecting to singleplayer servers + threading fixes

server-cli/src/main.rs

@@ -22,6 +22,8 @@ fn main() {
     // Create server
     let mut server = Server::new(settings).expect("Failed to create server instance!");
 
+    println!("Server is ready to accept connections");
+
     loop {
         let events = server
             .tick(Input::default(), clock.get_last_delta())

voxygen/src/main.rs

@@ -43,7 +43,7 @@ pub struct GlobalState {
     settings: Settings,
     window: Window,
     audio: AudioFrontend,
-    error_message: Option<String>,
+    info_message: Option<String>,
 }
 
 impl GlobalState {
@@ -117,7 +117,7 @@ fn main() {
         audio,
         window: Window::new(&settings).expect("Failed to create window!"),
         settings,
-        error_message: None,
+        info_message: None,
     };
     let settings = &global_state.settings;
 

voxygen/src/menu/char_selection/mod.rs

@@ -114,7 +114,7 @@ impl PlayState for CharSelectionState {
                 .tick(comp::ControllerInputs::default(), clock.get_last_delta())
             {
                 error!("Failed to tick the scene: {:?}", err);
-                global_state.error_message = Some(
+                global_state.info_message = Some(
                     "Connection lost!\nDid the server restart?\nIs the client up to date?"
                         .to_owned(),
                 );

voxygen/src/menu/main/client_init.rs

@@ -2,6 +2,8 @@ use client::{error::Error as ClientError, Client};
 use common::comp;
 use crossbeam::channel::{unbounded, Receiver, TryRecvError};
 use log::info;
+use std::sync::atomic::{Ordering, AtomicBool};
+use std::sync::Arc;
 use std::{net::ToSocketAddrs, thread, time::Duration};
 
 #[cfg(feature = "discord")]
@@ -24,6 +26,7 @@ pub enum Error {
 // and create the client (which involves establishing a connection to the server).
 pub struct ClientInit {
     rx: Receiver<Result<Client, Error>>,
+    cancel: Arc<AtomicBool>,
 }
 impl ClientInit {
     pub fn new(
@@ -35,6 +38,8 @@ impl ClientInit {
         let (server_address, default_port, prefer_ipv6) = connection_args;
 
         let (tx, rx) = unbounded();
+        let cancel = Arc::new(AtomicBool::new(false));
+        let cancel2 = Arc::clone(&cancel);
 
         thread::spawn(move || {
             // Sleep the thread to wait for the single-player server to start up.
@@ -55,51 +60,58 @@ impl ClientInit {
 
                     let mut last_err = None;
 
-                    for socket_addr in first_addrs.into_iter().chain(second_addrs) {
+                    'tries: for _ in 0..=12 { // 1 Minute
-                        match Client::new(socket_addr, player.view_distance) {
+                        if cancel2.load(Ordering::Relaxed) {
-                            Ok(mut client) => {
+                            break;
-                                if let Err(ClientError::InvalidAuth) =
+                        }
-                                    client.register(player, password)
+                        for socket_addr in
-                                {
+                            first_addrs.clone().into_iter().chain(second_addrs.clone())
-                                    last_err = Some(Error::InvalidAuth);
+                        {
-                                    break;
+                            match Client::new(socket_addr, player.view_distance) {
-                                }
+                                Ok(mut client) => {
-                                //client.register(player, password);
+                                    if let Err(ClientError::InvalidAuth) =
-                                let _ = tx.send(Ok(client));
+                                        client.register(player.clone(), password.clone())
-
+                                    {
-                                #[cfg(feature = "discord")]
+                                        last_err = Some(Error::InvalidAuth);
-                                {
-                                    if !server_address.eq("127.0.0.1") {
-                                        discord::send_all(vec![
-                                            DiscordUpdate::Details(server_address),
-                                            DiscordUpdate::State("Playing...".into()),
-                                        ]);
-                                    }
-                                }
-
-                                return;
-                            }
-                            Err(err) => {
-                                match err {
-                                    // Assume the connection failed and try next address.
-                                    ClientError::Network(_) => {
-                                        last_err = Some(Error::ConnectionFailed(err))
-                                    }
-                                    ClientError::TooManyPlayers => {
-                                        last_err = Some(Error::ServerIsFull);
                                         break;
                                     }
-                                    ClientError::InvalidAuth => {
+                                    //client.register(player, password);
-                                        last_err = Some(Error::InvalidAuth);
+                                    let _ = tx.send(Ok(client));
+
+                                    #[cfg(feature = "discord")]
+                                    {
+                                        if !server_address.eq("127.0.0.1") {
+                                            discord::send_all(vec![
+                                                DiscordUpdate::Details(server_address),
+                                                DiscordUpdate::State("Playing...".into()),
+                                            ]);
+                                        }
                                     }
-                                    // TODO: Handle errors?
+
-                                    _ => panic!(
+                                    return;
+                                }
+                                Err(err) => {
+                                    match err {
+                                        // Assume the connection failed and try again soon
+                                        ClientError::Network(_) => {}
+                                        ClientError::TooManyPlayers => {
+                                            last_err = Some(Error::ServerIsFull);
+                                            break 'tries;
+                                        }
+                                        ClientError::InvalidAuth => {
+                                            last_err = Some(Error::InvalidAuth);
+                                            break 'tries;
+                                        }
+                                        // TODO: Handle errors?
+                                        _ => panic!(
                                         "Unexpected non-network error when creating client: {:?}",
                                         err
                                     ),
+                                    }
                                 }
                             }
                         }
+                        thread::sleep(Duration::from_secs(5));
                     }
                     // Parsing/host name resolution successful but no connection succeeded.
                     let _ = tx.send(Err(last_err.unwrap_or(Error::NoAddress)));
@@ -111,7 +123,7 @@ impl ClientInit {
             }
         });
 
-        ClientInit { rx }
+        ClientInit { rx, cancel, }
     }
     /// Poll if the thread is complete.
     /// Returns None if the thread is still running, otherwise returns the Result of client creation.
@@ -122,4 +134,13 @@ impl ClientInit {
             Err(TryRecvError::Disconnected) => Some(Err(Error::ClientCrashed)),
         }
     }
+    pub fn cancel(&mut self) {
+        self.cancel.store(true, Ordering::Relaxed);
+    }
+}
+
+impl Drop for ClientInit {
+    fn drop(&mut self) {
+        self.cancel();
+    }
 }

voxygen/src/menu/main/mod.rs

@@ -1,22 +1,23 @@
 mod client_init;
 #[cfg(feature = "singleplayer")]
-mod start_singleplayer;
 mod ui;
 
 use super::char_selection::CharSelectionState;
-use crate::{window::Event, Direction, GlobalState, PlayState, PlayStateResult};
+use crate::{
+    singleplayer::Singleplayer, window::Event, Direction, GlobalState, PlayState, PlayStateResult,
+};
 use argon2::{self, Config};
 use client_init::{ClientInit, Error as InitError};
 use common::{clock::Clock, comp};
 use log::warn;
 #[cfg(feature = "singleplayer")]
-use start_singleplayer::StartSingleplayerState;
 use std::time::Duration;
 use ui::{Event as MainMenuEvent, MainMenuUi};
 
 pub struct MainMenuState {
     main_menu_ui: MainMenuUi,
     title_music_channel: Option<usize>,
+    singleplayer: Option<Singleplayer>,
 }
 
 impl MainMenuState {
@@ -25,6 +26,7 @@ impl MainMenuState {
         Self {
             main_menu_ui: MainMenuUi::new(global_state),
             title_music_channel: None,
+            singleplayer: None,
         }
     }
 }
@@ -48,6 +50,9 @@ impl PlayState for MainMenuState {
             )
         }
 
+        // Reset singleplayer server if it was running already
+        self.singleplayer = None;
+
         loop {
             // Handle window events.
             for event in global_state.window.fetch_events() {
@@ -75,7 +80,7 @@ impl PlayState for MainMenuState {
                 }
                 Some(Err(err)) => {
                     client_init = None;
-                    global_state.error_message = Some(
+                    global_state.info_message = Some(
                         match err {
                             InitError::BadAddress(_) | InitError::NoAddress => "Server not found",
                             InitError::InvalidAuth => "Invalid credentials",
@@ -100,49 +105,37 @@ impl PlayState for MainMenuState {
                         password,
                         server_address,
                     } => {
-                        let mut net_settings = &mut global_state.settings.networking;
+                        attempt_login(
-                        net_settings.username = username.clone();
+                            global_state,
-                        net_settings.password = password.clone();
+                            username,
-                        if !net_settings.servers.contains(&server_address) {
+                            password,
-                            net_settings.servers.push(server_address.clone());
+                            server_address,
-                        }
+                            DEFAULT_PORT,
-                        if let Err(err) = global_state.settings.save_to_file() {
+                            &mut client_init,
-                            warn!("Failed to save settings: {:?}", err);
-                        }
-
-                        let player = comp::Player::new(
-                            username.clone(),
-                            Some(global_state.settings.graphics.view_distance),
                         );
-
-                        if player.is_valid() {
-                            // Don't try to connect if there is already a connection in progress.
-                            client_init = client_init.or(Some(ClientInit::new(
-                                (server_address, DEFAULT_PORT, false),
-                                player,
-                                {
-                                    let salt = b"staticsalt_zTuGkGvybZIjZbNUDtw15";
-                                    let config = Config::default();
-                                    argon2::hash_encoded(password.as_bytes(), salt, &config)
-                                        .unwrap()
-                                },
-                                false,
-                            )));
-                        } else {
-                            global_state.error_message =
-                                Some("Invalid username or password".to_string());
-                        }
                     }
                     MainMenuEvent::CancelLoginAttempt => {
                         // client_init contains Some(ClientInit), which spawns a thread which contains a TcpStream::connect() call
                         // This call is blocking
                         // TODO fix when the network rework happens
+                        self.singleplayer = None;
                         client_init = None;
                         self.main_menu_ui.cancel_connection();
                     }
                     #[cfg(feature = "singleplayer")]
                     MainMenuEvent::StartSingleplayer => {
-                        return PlayStateResult::Push(Box::new(StartSingleplayerState::new()));
+                        let (singleplayer, server_settings) = Singleplayer::new(None); // TODO: Make client and server use the same thread pool
+
+                        self.singleplayer = Some(singleplayer);
+
+                        attempt_login(
+                            global_state,
+                            "singleplayer".to_owned(),
+                            "".to_owned(),
+                            server_settings.gameserver_address.ip().to_string(),
+                            server_settings.gameserver_address.port(),
+                            &mut client_init,
+                        );
                     }
                     MainMenuEvent::Settings => {} // TODO
                     MainMenuEvent::Quit => return PlayStateResult::Shutdown,
@@ -152,8 +145,8 @@ impl PlayState for MainMenuState {
                 }
             }
 
-            if let Some(error) = global_state.error_message.take() {
+            if let Some(info) = global_state.info_message.take() {
-                self.main_menu_ui.show_error(error);
+                self.main_menu_ui.show_info(info);
             }
 
             // Draw the UI to the screen.
@@ -177,3 +170,45 @@ impl PlayState for MainMenuState {
         "Title"
     }
 }
+
+fn attempt_login(
+    global_state: &mut GlobalState,
+    username: String,
+    password: String,
+    server_address: String,
+    server_port: u16,
+    client_init: &mut Option<ClientInit>,
+) {
+    let mut net_settings = &mut global_state.settings.networking;
+    net_settings.username = username.clone();
+    net_settings.password = password.clone();
+    if !net_settings.servers.contains(&server_address) {
+        net_settings.servers.push(server_address.clone());
+    }
+    if let Err(err) = global_state.settings.save_to_file() {
+        warn!("Failed to save settings: {:?}", err);
+    }
+
+    let player = comp::Player::new(
+        username.clone(),
+        Some(global_state.settings.graphics.view_distance),
+    );
+
+    if player.is_valid() {
+        // Don't try to connect if there is already a connection in progress.
+        if client_init.is_none() {
+            *client_init = Some(ClientInit::new(
+                (server_address, server_port, false),
+                player,
+                {
+                    let salt = b"staticsalt_zTuGkGvybZIjZbNUDtw15";
+                    let config = Config::default();
+                    argon2::hash_encoded(password.as_bytes(), salt, &config).unwrap()
+                },
+                false,
+            ));
+        }
+    } else {
+        global_state.info_message = Some("Invalid username or password".to_string());
+    }
+}

voxygen/src/menu/main/start_singleplayer.rs

@@ -1,79 +0,0 @@
-use super::client_init::ClientInit;
-use crate::{
-    menu::char_selection::CharSelectionState, singleplayer::Singleplayer, Direction, GlobalState,
-    PlayState, PlayStateResult,
-};
-use common::comp;
-use log::{info, warn};
-use server::settings::ServerSettings;
-
-pub struct StartSingleplayerState {
-    // Necessary to keep singleplayer working
-    _singleplayer: Singleplayer,
-    server_settings: ServerSettings,
-}
-
-impl StartSingleplayerState {
-    /// Create a new `MainMenuState`.
-    pub fn new() -> Self {
-        let (_singleplayer, server_settings) = Singleplayer::new(None); // TODO: Make client and server use the same thread pool
-
-        Self {
-            _singleplayer,
-            server_settings,
-        }
-    }
-}
-
-impl PlayState for StartSingleplayerState {
-    fn play(&mut self, direction: Direction, global_state: &mut GlobalState) -> PlayStateResult {
-        match direction {
-            Direction::Forwards => {
-                let username = "singleplayer".to_owned();
-
-                let client_init = ClientInit::new(
-                    //TODO: check why we are converting out IP:Port to String instead of parsing it directly as SockAddr
-                    (
-                        self.server_settings.gameserver_address.ip().to_string(),
-                        self.server_settings.gameserver_address.port(),
-                        true,
-                    ),
-                    comp::Player::new(
-                        username.clone(),
-                        Some(global_state.settings.graphics.view_distance),
-                    ),
-                    String::default(),
-                    true,
-                );
-
-                // Create the client.
-                let client = loop {
-                    match client_init.poll() {
-                        Some(Ok(client)) => break client,
-                        Some(Err(err)) => {
-                            warn!("Failed to start single-player server: {:?}", err);
-                            return PlayStateResult::Pop;
-                        }
-                        _ => {}
-                    }
-                };
-
-                // Print the metrics port
-                info!(
-                    "Metrics port: {}",
-                    self.server_settings.metrics_address.port()
-                );
-
-                PlayStateResult::Push(Box::new(CharSelectionState::new(
-                    global_state,
-                    std::rc::Rc::new(std::cell::RefCell::new(client)),
-                )))
-            }
-            Direction::Backwards => PlayStateResult::Pop,
-        }
-    }
-
-    fn name(&self) -> &'static str {
-        "Starting Single-Player"
-    }
-}

voxygen/src/menu/main/ui.rs

@@ -353,10 +353,11 @@ impl MainMenuUi {
             macro_rules! singleplayer {
                 () => {
                     events.push(Event::StartSingleplayer);
-                    events.push(Event::LoginAttempt {
+                    self.connecting = Some(std::time::Instant::now());
-                        username: "singleplayer".to_string(),
+                    self.popup = Some(PopupData {
-                        password: String::default(),
+                        msg: "Connecting...".to_string(),
-                        server_address: "localhost".to_string(),
+                        button_text: "Cancel".to_string(),
+                        popup_type: PopupType::ConnectionInfo,
                     });
                 };
             }
@@ -650,7 +651,7 @@ impl MainMenuUi {
         events
     }
 
-    pub fn show_error(&mut self, msg: String) {
+    pub fn show_info(&mut self, msg: String) {
         self.popup = Some(PopupData {
             msg,
             button_text: "Okay".to_string(),

voxygen/src/session.rs

@@ -333,7 +333,7 @@ impl PlayState for SessionState {
             // Perform an in-game tick.
             if let Err(err) = self.tick(clock.get_avg_delta()) {
                 error!("Failed to tick the scene: {:?}", err);
-                global_state.error_message = Some(
+                global_state.info_message = Some(
                     "Connection lost!\nDid the server restart?\nIs the client up to date?"
                         .to_owned(),
                 );

voxygen/src/singleplayer.rs

@@ -30,14 +30,18 @@ impl Singleplayer {
 
         // Create server
         let settings = ServerSettings::singleplayer();
-        let server = Server::new(settings.clone()).expect("Failed to create server instance!");
 
-        let server = match client {
+        let thread_pool = client.map(|c| c.thread_pool().clone());
-            Some(client) => server.with_thread_pool(client.thread_pool().clone()),
+        let settings2 = settings.clone();
-            None => server,
-        };
 
         let thread = thread::spawn(move || {
+            let server = Server::new(settings2).expect("Failed to create server instance!");
+
+            let server = match thread_pool {
+                Some(pool) => server.with_thread_pool(pool),
+                None => server,
+            };
+
             run_server(server, receiver);
         });