feat: add online player count to status response

Author: Quozul

binaries/pico_limbo/src/handlers/status.rs

@@ -17,6 +17,7 @@ pub async fn on_status_request(
         version.humanize(),
         version.version_number(),
         state.description_text(),
+        state.online_players(),
         state.max_players(),
         false,
     );

binaries/pico_limbo/src/server_state.rs

@@ -1,6 +1,8 @@
 use minecraft_packets::play::Dimension;
 use minecraft_server::server::GetDataDirectory;
 use std::path::PathBuf;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicU32, Ordering};
 use thiserror::Error;
 
 #[derive(Clone, Debug)]
@@ -12,6 +14,7 @@ pub struct ServerState {
     description_text: String,
     max_players: u32,
     welcome_message: String,
+    connected_clients: Arc<AtomicU32>,
 }
 
 impl ServerState {
@@ -43,6 +46,11 @@ impl ServerState {
             Some(self.welcome_message.clone())
         }
     }
+
+    /// Returns the current number of connected clients.
+    pub fn online_players(&self) -> u32 {
+        self.connected_clients.load(Ordering::SeqCst)
+    }
 }
 
 impl GetDataDirectory for ServerState {
@@ -53,6 +61,10 @@ impl GetDataDirectory for ServerState {
     fn spawn_dimension(&self) -> &Dimension {
         &self.spawn_dimension
     }
+
+    fn connected_clients(&self) -> &Arc<AtomicU32> {
+        &self.connected_clients
+    }
 }
 
 #[derive(Error, Debug)]
@@ -136,6 +148,7 @@ impl ServerStateBuilder {
             description_text: self.description_text,
             max_players: self.max_players,
             welcome_message: self.welcome_message,
+            connected_clients: Arc::new(AtomicU32::new(0)),
         })
     }
 }

crates/minecraft_packets/src/status/data/status_response.rs

@@ -44,6 +44,7 @@ impl StatusResponse {
         version_name: &str,
         version_protocol: u32,
         description_text: &str,
+        online_players: u32,
         max_players: u32,
         enforces_secure_chat: bool,
     ) -> Self {
@@ -60,7 +61,7 @@ impl StatusResponse {
             },
             players: Players {
                 max: max_players,
-                online: 0,
+                online: online_players,
                 sample: None,
             },
             description,

crates/minecraft_server/src/server.rs

@@ -3,21 +3,24 @@ use crate::event_handler::{Handler, ListenerHandler};
 use minecraft_packets::play::Dimension;
 use minecraft_protocol::data::packets_report::packet_map::PacketMap;
 use minecraft_protocol::prelude::{DecodePacket, PacketId};
+use minecraft_protocol::state::State;
 use std::collections::HashMap;
 use std::future::Future;
 use std::path::PathBuf;
 use std::sync::Arc;
-use std::time::Duration;
+use std::sync::atomic::{AtomicU32, Ordering};
 use tokio::net::{TcpListener, TcpStream};
 use tokio::signal;
 use tokio::sync::Mutex;
-use tokio::time::interval;
+use tokio::time::{Duration, interval};
 use tracing::{debug, error, info};
 
 pub trait GetDataDirectory {
     fn data_directory(&self) -> &PathBuf;
 
     fn spawn_dimension(&self) -> &Dimension;
+
+    fn connected_clients(&self) -> &Arc<AtomicU32>;
 }
 
 pub struct Server<S>
@@ -76,7 +79,7 @@ where
                             let packet_map = packet_map.clone();
                             let state = self.state.clone();
                             tokio::spawn(async move {
-                                if let Err(e) = handle_client(socket, handlers, packet_map, state).await {
+                                if let Err(e) = handle_client(socket, handlers, packet_map, state.clone()).await {
                                     error!("Error handling client {}: {:?}", addr, e);
                                 }
                             });
@@ -96,7 +99,7 @@ where
     }
 }
 
-async fn handle_client<S: Clone>(
+async fn handle_client<S: Clone + GetDataDirectory>(
     socket: TcpStream,
     handlers: Arc<HashMap<String, Box<dyn Handler<S>>>>,
     packet_map: PacketMap,
@@ -114,6 +117,10 @@ async fn handle_client<S: Clone>(
                     Ok(named_packet) => {
                         if let Some(handler) = handlers.get(&named_packet.name) {
                             handler.handle(state.clone(), client.clone(), named_packet).await;
+
+                            if client.lock().await.state() == &State::Play {
+                                state.connected_clients().fetch_add(1, Ordering::SeqCst);
+                            }
                         }
                         // Silently ignore no handler
                     }
@@ -138,5 +145,9 @@ async fn handle_client<S: Clone>(
         }
     }
 
+    if client.lock().await.state() == &State::Play {
+        state.connected_clients().fetch_sub(1, Ordering::SeqCst);
+    }
+
     Ok(())
 }