Merge branch 'fix-server-info' into 'master'

Add server info and player list to client

See merge request veloren/veloren!197

chat-cli/src/main.rs

@@ -1,6 +1,6 @@
 use client::{Client, Event};
 use common::{clock::Clock, comp};
-use log::info;
+use log::{error, info};
 use std::time::Duration;
 
 const FPS: u64 = 60;
@@ -18,15 +18,21 @@ fn main() {
     let mut client =
         Client::new(([127, 0, 0, 1], 59003), None).expect("Failed to create client instance");
 
-    client.register(comp::Player::new("test".to_string(), None));
+    println!("Server info: {:?}", client.server_info);
 
+    // TODO: Remove or move somewhere else, this doesn't work immediately after connecting
+    println!("Ping: {:?}", client.get_ping_ms());
+
+    println!("Players online: {:?}", client.get_players());
+
+    client.register(comp::Player::new("test".to_string(), None));
     client.send_chat("Hello!".to_string());
 
     loop {
         let events = match client.tick(comp::Control::default(), clock.get_last_delta()) {
             Ok(events) => events,
             Err(err) => {
-                println!("Error: {:?}", err);
+                error!("Error: {:?}", err);
                 break;
             }
         };

client/src/lib.rs

@@ -9,7 +9,7 @@ pub use specs::Entity as EcsEntity;
 
 use common::{
     comp,
-    msg::{ClientMsg, ClientState, ServerMsg},
+    msg::{ClientMsg, ClientState, ServerInfo, ServerMsg},
     net::PostBox,
     state::State,
 };
@@ -22,7 +22,7 @@ use std::{
 use threadpool::ThreadPool;
 use vek::*;
 
-const SERVER_TIMEOUT: f64 = 20.0; // Seconds
+const SERVER_TIMEOUT: Duration = Duration::from_secs(20);
 
 pub enum Event {
     Chat(String),
@@ -32,8 +32,8 @@ pub enum Event {
 pub struct Client {
     client_state: ClientState,
     thread_pool: ThreadPool,
+    pub server_info: ServerInfo,
 
-    last_ping: f64,
     postbox: PostBox<ClientMsg, ServerMsg>,
 
     last_server_ping: Instant,
@@ -55,28 +55,31 @@ impl Client {
         let mut postbox = PostBox::to(addr)?;
 
         // Wait for initial sync
-        let (mut state, entity) = match postbox.next_message() {
+        let (mut state, entity, server_info) = match postbox.next_message() {
             Some(ServerMsg::InitialSync {
                 ecs_state,
                 entity_uid,
+                server_info,
             }) => {
                 let mut state = State::from_state_package(ecs_state);
                 let entity = state
                     .ecs()
                     .entity_from_uid(entity_uid)
                     .ok_or(Error::ServerWentMad)?;
-                (state, entity)
+                (state, entity, server_info)
             }
             _ => return Err(Error::ServerWentMad),
         };
 
+        postbox.send_message(ClientMsg::Ping);
+
         Ok(Self {
             client_state,
             thread_pool: threadpool::Builder::new()
                 .thread_name("veloren-worker".into())
                 .build(),
+            server_info,
 
-            last_ping: state.get_time(),
             postbox,
 
             last_server_ping: Instant::now(),
@@ -328,12 +331,9 @@ impl Client {
     fn handle_new_messages(&mut self) -> Result<Vec<Event>, Error> {
         let mut frontend_events = Vec::new();
 
-        // Step 1
         let new_msgs = self.postbox.new_messages();
 
         if new_msgs.len() > 0 {
-            self.last_ping = self.state.get_time();
-
             for msg in new_msgs {
                 match msg {
                     ServerMsg::InitialSync { .. } => return Err(Error::ServerWentMad),
@@ -393,14 +393,10 @@ impl Client {
             }
         } else if let Some(err) = self.postbox.error() {
             return Err(err.into());
-        } else if self.state.get_time() - self.last_ping > SERVER_TIMEOUT {
+        // We regularily ping in the tick method
+        } else if Instant::now().duration_since(self.last_server_ping) > SERVER_TIMEOUT {
             return Err(Error::ServerTimeout);
-        } else if self.state.get_time() - self.last_ping > SERVER_TIMEOUT * 0.5 {
-            // Try pinging the server if the timeout is nearing.
-            self.postbox.send_message(ClientMsg::Ping);
-            self.last_server_ping = Instant::now();
         }
-
         Ok(frontend_events)
     }
 
@@ -446,6 +442,17 @@ impl Client {
     pub fn state_mut(&mut self) -> &mut State {
         &mut self.state
     }
+
+    /// Get a vector of all the players on the server
+    pub fn get_players(&mut self) -> Vec<comp::Player> {
+        // TODO: Don't clone players.
+        self.state
+            .ecs()
+            .read_storage::<comp::Player>()
+            .join()
+            .map(|p| p.clone())
+            .collect()
+    }
 }
 
 impl Drop for Client {

common/src/msg/mod.rs

@@ -5,7 +5,7 @@ pub mod server;
 // Reexports
 pub use self::client::ClientMsg;
 pub use self::ecs_packet::{EcsCompPacket, EcsResPacket};
-pub use self::server::{RequestStateError, ServerMsg};
+pub use self::server::{RequestStateError, ServerInfo, ServerMsg};
 
 #[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
 pub enum ClientState {

common/src/msg/server.rs

@@ -10,11 +10,18 @@ pub enum RequestStateError {
     WrongMessage,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ServerInfo {
+    pub name: String,
+    pub description: String,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum ServerMsg {
     InitialSync {
         ecs_state: sphynx::StatePackage<EcsCompPacket, EcsResPacket>,
         entity_uid: u64,
+        server_info: ServerInfo,
     },
     StateAnswer(Result<ClientState, (RequestStateError, ClientState)>),
     ForceState(ClientState),

server/src/lib.rs

@@ -14,7 +14,7 @@ use crate::{
 };
 use common::{
     comp,
-    msg::{ClientMsg, ClientState, RequestStateError, ServerMsg},
+    msg::{ClientMsg, ClientState, RequestStateError, ServerInfo, ServerMsg},
     net::PostOffice,
     state::{State, Uid},
     terrain::{TerrainChunk, TerrainChunkSize},
@@ -66,6 +66,8 @@ pub struct Server {
     chunk_tx: mpsc::Sender<(Vec2<i32>, TerrainChunk)>,
     chunk_rx: mpsc::Receiver<(Vec2<i32>, TerrainChunk)>,
     pending_chunks: HashSet<Vec2<i32>>,
+
+    server_info: ServerInfo,
 }
 
 impl Server {
@@ -98,6 +100,11 @@ impl Server {
             chunk_tx,
             chunk_rx,
             pending_chunks: HashSet::new(),
+
+            server_info: ServerInfo {
+                name: "Server name".to_owned(),
+                description: "This is the best Veloren server.".to_owned(),
+            },
         };
 
         /*
@@ -383,6 +390,7 @@ impl Server {
             client.notify(ServerMsg::InitialSync {
                 ecs_state: self.state.ecs().gen_state_package(),
                 entity_uid: self.state.ecs().uid_from_entity(entity).unwrap().into(), // Can't fail.
+                server_info: self.server_info.clone(),
             });
 
             self.clients.add(entity, client);

voxygen/src/session.rs

@@ -67,9 +67,7 @@ impl SessionState {
                 client::Event::Chat(msg) => {
                     self.hud.new_message(msg);
                 }
-                client::Event::Disconnect => {
-                    // TODO
-                }
+                client::Event::Disconnect => {} // TODO
             }
         }