Mirrored_Repos/veloren
1
0
Fork 0
mirror of https://gitlab.com/veloren/veloren.git synced 2024-08-30 18:12:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

improvement: UI for connecting to singleplayer servers + threading fixes

Browse Source
This commit is contained in:
timokoesters 2019-10-18 22:05:37 +02:00
parent 35dbd94ce6
commit 97dda3b2ca
No known key found for this signature in database
GPG Key ID: CD80BE9AAEE78097
9 changed files with 152 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
server-cli/src/main.rs
View File

@ -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())

4
voxygen/src/main.rs
View File

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

2
voxygen/src/menu/char_selection/mod.rs
View File

@ -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(),
);

95
voxygen/src/menu/main/client_init.rs
View File

@ -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) {
match Client::new(socket_addr, player.view_distance) {
Ok(mut client) => {
if let Err(ClientError::InvalidAuth) =
client.register(player, password)
{
last_err = Some(Error::InvalidAuth);
break;
}
//client.register(player, password);
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()),
]);
}
}
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);
'tries: for _ in 0..=12 { // 1 Minute
if cancel2.load(Ordering::Relaxed) {
break;
}
for socket_addr in
first_addrs.clone().into_iter().chain(second_addrs.clone())
{
match Client::new(socket_addr, player.view_distance) {
Ok(mut client) => {
if let Err(ClientError::InvalidAuth) =
client.register(player.clone(), password.clone())
{
last_err = Some(Error::InvalidAuth);
break;
}
ClientError::InvalidAuth => {
last_err = Some(Error::InvalidAuth);
//client.register(player, password);
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();
}
}

111
voxygen/src/menu/main/mod.rs
View File

@ -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;
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),
attempt_login(
global_state,
username,
password,
server_address,
DEFAULT_PORT,
&mut client_init,
);
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() {
self.main_menu_ui.show_error(error);
if let Some(info) = global_state.info_message.take() {
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());
}
}

79
voxygen/src/menu/main/start_singleplayer.rs
View File

@ -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"
}
}

11
voxygen/src/menu/main/ui.rs
View File

@ -353,10 +353,11 @@ impl MainMenuUi {
macro_rules! singleplayer {
() => {
events.push(Event::StartSingleplayer);
events.push(Event::LoginAttempt {
username: "singleplayer".to_string(),
password: String::default(),
server_address: "localhost".to_string(),
self.connecting = Some(std::time::Instant::now());
self.popup = Some(PopupData {
msg: "Connecting...".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(),

2
voxygen/src/session.rs
View File

@ -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(),
);

14
voxygen/src/singleplayer.rs
View File

@ -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 {
Some(client) => server.with_thread_pool(client.thread_pool().clone()),
None => server,
};
let thread_pool = client.map(|c| c.thread_pool().clone());
let settings2 = settings.clone();
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);
});