fixed connection_killer.rs merge issues

Author: Sunnickel

src/bin/src/systems/connection_killer.rs

@@ -12,58 +12,62 @@ pub fn connection_killer(
         &StreamWriter,
         &PlayerIdentity,
         &mut DisconnectHandle,
-    )>, // Mutable query
+    )>,
     mut cmd: Commands,
     state: Res<GlobalStateResource>,
 ) {
     while let Some((disconnecting_entity, reason)) = state.0.players.disconnection_queue.pop() {
-        let entity_result = query.get(disconnecting_entity);
-        match entity_result {
-            Ok(disconnecting_player) => {
-                for (entity, conn, player_identity, mut disconnect_handle) in query.iter_mut() {
-                    if disconnecting_entity == entity {
-                        info!(
-                            "Player {} ({}) disconnected: {}",
-                            player_identity.username,
-                            player_identity.uuid,
-                            reason.as_deref().unwrap_or("No reason")
+        let disconnecting_player_identity = query
+            .get(disconnecting_entity)
+            .ok()
+            .map(|(_, _, identity, _)| identity.clone());
+
+        if disconnecting_player_identity.is_none() {
+            warn!("Player's entity has already been removed");
+            continue;
+        }
+
+        let disconnecting_player_identity = disconnecting_player_identity.unwrap();
+
+        for (entity, conn, player_identity, mut disconnect_handle) in query.iter_mut() {
+            if disconnecting_entity == entity {
+                info!(
+                    "Player {} ({}) disconnected: {}",
+                    player_identity.username,
+                    player_identity.uuid,
+                    reason.as_deref().unwrap_or("No reason")
+                );
+                if conn.running.load(std::sync::atomic::Ordering::Relaxed) {
+                    trace!(
+                        "Sending disconnect packet to player {}",
+                        player_identity.username
+                    );
+                    if let Err(e) = conn.send_packet_ref(
+                        &ferrumc_net::packets::outgoing::disconnect::DisconnectPacket {
+                            reason: TextComponent::from(
+                                reason.as_deref().unwrap_or("Disconnected"),
+                            ),
+                        },
+                    ) {
+                        warn!(
+                            "Failed to send disconnect packet to player {}: {:?}",
+                            player_identity.username, e
                         );
-                        if conn.running.load(std::sync::atomic::Ordering::Relaxed) {
-                            trace!(
-                                "Sending disconnect packet to player {}",
-                                player_identity.username
-                            );
-                            if let Err(e) = conn.send_packet_ref(
-                                &ferrumc_net::packets::outgoing::disconnect::DisconnectPacket {
-                                    reason: TextComponent::from(
-                                        reason.as_deref().unwrap_or("Disconnected"),
-                                    ),
-                                },
-                            ) {
-                                warn!(
-                                    "Failed to send disconnect packet to player {}: {:?}",
-                                    player_identity.username, e
-                                );
-                            }
-                            if let Some(sender) = disconnect_handle.sender.take() {
-                                if let Err(_) = sender.send(()) {
-                                    trace!("Failed to send disconnect signal (receiver already dropped)");
-                                }
-                            }
-                        } else {
-                            trace!(
-                                "Connection for player {} is not running, skipping disconnect packet",
-                                player_identity.username
-                            );
+                    }
+                    if let Some(sender) = disconnect_handle.sender.take() {
+                        if sender.send(()).is_err() {
+                            trace!("Failed to send disconnect signal (receiver already dropped)");
                         }
-                    } else {
-                        system_messages::player_leave::handle(disconnecting_player.2, entity);
                     }
-                    cmd.entity(entity).despawn();
+                } else {
+                    trace!(
+                        "Connection for player {} is not running, skipping disconnect packet",
+                        player_identity.username
+                    );
                 }
-            }
-            Err(e) => {
-                warn!("Player's entity has already been removed: {}", e);
+                cmd.entity(entity).despawn();
+            } else {
+                system_messages::player_leave::handle(&disconnecting_player_identity, entity);
             }
         }
     }

src/lib/net/src/connection.rs

@@ -269,31 +269,28 @@ pub async fn handle_connection(
 
         // Read next packet
         let mut packet_skele;
-        'play_receive: loop {
-            tokio::select! {
-                packet_result = PacketSkeleton::new(&mut tcp_reader, login_result.compression, Play) => {
-                    match packet_result {
-                        Ok(packet) => {
-                                packet_skele = packet;
-                                break 'play_receive
-                            },
-                        Err(err) => {
-                            if let NetError::ConnectionDropped = err {
-                                trace!("Connection dropped for entity {:?}", entity);
-                                running.store(false, Ordering::Relaxed);
-                                break 'recv;
-                            }
-                            error!("Failed to read packet skeleton: {:?} for {:?}", err, entity);
+        tokio::select! {
+            packet_result = PacketSkeleton::new(&mut tcp_reader, login_result.compression, Play) => {
+                match packet_result {
+                    Ok(packet) => {
+                        packet_skele = packet;
+                    },
+                    Err(err) => {
+                        if let NetError::ConnectionDropped = err {
+                            trace!("Connection dropped for entity {:?}", entity);
                             running.store(false, Ordering::Relaxed);
                             break 'recv;
                         }
+                        error!("Failed to read packet skeleton: {:?} for {:?}", err, entity);
+                        running.store(false, Ordering::Relaxed);
+                        break 'recv;
                     }
                 }
+            }
 
-                _ = &mut disconnect_receiver => {
-                    debug!("Received disconnect signal");
-                    break 'recv;
-                }
+            _ = &mut disconnect_receiver => {
+                debug!("Received disconnect signal");
+                break 'recv;
             }
         }
 
@@ -333,24 +330,3 @@ pub async fn handle_connection(
 
     Ok(())
 }
-
-impl StreamWriter {
-    /// Gracefully closes the connection, optionally sending a disconnect reason packet.
-    ///
-    /// Note: This does not despawn the associated ECS entity. The caller
-    /// is responsible for removing the entity separately.
-    pub fn kill(&self, reason: Option<String>) -> Result<(), NetError> {
-        self.running.store(false, Ordering::Relaxed);
-        if let Err(err) = self.send_packet(crate::packets::outgoing::disconnect::DisconnectPacket {
-            reason: ferrumc_text::TextComponent::from(reason.unwrap_or("Disconnected".to_string())),
-        }) {
-            if matches!(err, NetError::ConnectionDropped) {
-                trace!("Connection already dropped, skipping disconnect packet");
-            } else {
-                error!("Failed to send disconnect packet: {:?}", err);
-                return Err(err);
-            }
-        }
-        Ok(())
-    }
-}