Log all players (name + count) every 5 seconds.

src/bin/src/packet_handlers/login_process.rs

@@ -1,31 +1,29 @@
-use ferrumc_macros::event_handler;
-use ferrumc_net::errors::NetError;
-use ferrumc_net::packets::incoming::login_start::LoginStartEvent;
-use ferrumc_net::GlobalState;
-use tracing::{debug, info, trace};
 use ferrumc_core::identity::player_identity::PlayerIdentity;
-use ferrumc_ecs::components::ComponentRefMut;
+use ferrumc_ecs::components::storage::ComponentRefMut;
+use ferrumc_macros::event_handler;
 use ferrumc_net::connection::{ConnectionState, StreamWriter};
+use ferrumc_net::errors::NetError;
 use ferrumc_net::packets::incoming::ack_finish_configuration::AckFinishConfigurationEvent;
-use ferrumc_net::packets::incoming::login_acknowledged::{LoginAcknowledgedEvent};
+use ferrumc_net::packets::incoming::login_acknowledged::LoginAcknowledgedEvent;
+use ferrumc_net::packets::incoming::login_start::LoginStartEvent;
 use ferrumc_net::packets::incoming::server_bound_known_packs::ServerBoundKnownPacksEvent;
 use ferrumc_net::packets::outgoing::client_bound_known_packs::ClientBoundKnownPacksPacket;
-use ferrumc_net::packets::outgoing::finish_configuration::FinishConfigurationPacket;
 use ferrumc_net::packets::outgoing::game_event::GameEventPacket;
 use ferrumc_net::packets::outgoing::keep_alive::{KeepAlive, KeepAlivePacket};
 use ferrumc_net::packets::outgoing::login_play::LoginPlayPacket;
 use ferrumc_net::packets::outgoing::login_success::LoginSuccessPacket;
-use ferrumc_net::packets::outgoing::registry_data::{get_registry_packets, RegistryDataPacket};
+use ferrumc_net::packets::outgoing::registry_data::{get_registry_packets};
 use ferrumc_net::packets::outgoing::set_default_spawn_position::SetDefaultSpawnPositionPacket;
 use ferrumc_net::packets::outgoing::synchronize_player_position::SynchronizePlayerPositionPacket;
-use ferrumc_net_codec::encode::{NetEncodeOpts};
+use ferrumc_net::GlobalState;
+use ferrumc_net_codec::encode::NetEncodeOpts;
+use tracing::{debug, trace};
 
 #[event_handler]
 async fn handle_login_start(
     login_start_event: LoginStartEvent,
     state: GlobalState,
 ) -> Result<LoginStartEvent, NetError> {
-
     debug!("Handling login start event");
 
     let uuid = login_start_event.login_start_packet.uuid;
@@ -35,10 +33,10 @@ async fn handle_login_start(
 
     // Add the player identity component to the ECS for the entity.
     state.universe.add_component::<PlayerIdentity>(
-            login_start_event.conn_id,
-            PlayerIdentity::new(username.to_string(), uuid)
-        );
-
+        login_start_event.conn_id,
+        PlayerIdentity::new(username.to_string(), uuid),
+    )?;
+    
     //Send a Login Success Response to further the login sequence
     let mut writer = state
         .universe
@@ -54,7 +52,6 @@ async fn handle_login_acknowledged(
     login_acknowledged_event: LoginAcknowledgedEvent,
     state: GlobalState,
 ) -> Result<LoginAcknowledgedEvent, NetError> {
-
     trace!("Handling Login Acknowledged event");
 
     //Set the connection State to Configuration
@@ -106,31 +103,31 @@ async fn handle_ack_finish_configuration(
     let mut conn_state = state
         .universe
         .get_mut::<ConnectionState>(conn_id)?;
-    
+
     *conn_state = ConnectionState::Play;
 
     let mut writer = state
         .universe
         .get_mut::<StreamWriter>(conn_id)?;
-    
+
     writer.send_packet(&LoginPlayPacket::new(conn_id), &NetEncodeOpts::WithLength).await?;
     writer.send_packet(&SetDefaultSpawnPositionPacket::default(), &NetEncodeOpts::WithLength).await?;
     writer.send_packet(&SynchronizePlayerPositionPacket::default(), &NetEncodeOpts::WithLength).await?;
     writer.send_packet(&GameEventPacket::start_waiting_for_level_chunks(), &NetEncodeOpts::WithLength).await?;
 
     send_keep_alive(conn_id, state, &mut writer).await?;
-    
+
 
     Ok(ack_finish_configuration_event)
 }
 async fn send_keep_alive(conn_id: usize, state: GlobalState, writer: &mut ComponentRefMut<'_, StreamWriter>) -> Result<(), NetError> {
     let keep_alive_packet = KeepAlivePacket::default();
     writer.send_packet(&keep_alive_packet, &NetEncodeOpts::WithLength).await?;
-    
+
     let id = keep_alive_packet.id;
-
-    state.universe.add_component::<KeepAlive>(conn_id, id);
 
-
+    state.universe.add_component::<KeepAlive>(conn_id, id)?;
+
+
     Ok(())
 }

src/bin/src/systems/keep_alive_system.rs

@@ -17,11 +17,12 @@ impl System for KeepAliveSystem {
                 break;
             }
 
-            let online_players = state.universe.query::<&PlayerIdentity>().collect::<Vec<_>>();
-            let online_players = online_players.iter().map(|v| v.username.clone()).collect::<Vec<_>>();
+            let online_players = state.universe.query::<&PlayerIdentity>();
+            let online_players = online_players.into_iter().map(|player| player.username.clone()).collect::<Vec<String>>();
             tracing::debug!("Online players: {:?}", online_players);
+            tracing::debug!("Total of {} online players", online_players.len());
 
-            tokio::time::sleep(Duration::from_secs(10)).await;
+            tokio::time::sleep(Duration::from_secs(5)).await;
         }
     }
 

src/lib/ecs/src/components/mod.rs

@@ -331,7 +331,10 @@ impl ComponentManager {
 
     pub fn get_entities_with<T: Component>(&self) -> Vec<usize> {
         let type_id = TypeId::of::<T>();
-        let ptr = *self.components.get(&type_id).unwrap();
+        let Some(ptr) = self.components.get(&type_id) else {
+            return Vec::new();
+        };
+        let ptr = *ptr;
         let component_set = unsafe { &*(ptr as *const ComponentSparseSet<T>) };
         component_set.entities()
     }

src/lib/ecs/src/lib.rs

@@ -64,7 +64,6 @@ impl Universe {
     }
 
     pub fn query<Q: QueryItem>(&self) -> Query<Q> {
-        /*Query::new(&self.components)*/
-        unimplemented!()
+        Query::new(&self.components)
     }
 }

src/lib/net/src/connection.rs

@@ -75,22 +75,19 @@ impl Default for CompressionStatus {
 }
 
 pub async fn handle_connection(state: Arc<ServerState>, tcp_stream: TcpStream) -> NetResult<()> {
-    let (reader, writer) = tcp_stream.into_split();
+    let (mut reader, writer) = tcp_stream.into_split();
 
     let entity = state
         .universe
         .builder()
-        .with(StreamReader::new(reader))
-        .with(StreamWriter::new(writer))
-        .with(ConnectionState::Handshaking)
-        .with(CompressionStatus::new())
+        .with(StreamWriter::new(writer))?
+        .with(ConnectionState::Handshaking)?
+        .with(CompressionStatus::new())?
         .build();
 
-    let mut reader = state.universe.get_mut::<StreamReader>(entity)?;
-
     'recv: loop {
         let compressed = state.universe.get::<CompressionStatus>(entity)?.enabled;
-        let Ok(mut packet_skele) = PacketSkeleton::new(&mut reader.reader, compressed).await else {
+        let Ok(mut packet_skele) = PacketSkeleton::new(&mut reader, compressed).await else {
             trace!("Failed to read packet. Possibly connection closed.");
             break 'recv;
         };