Merge pull request #223 from Sunnickel/fix/fix-disconnect

Fix: Disconnecting

Author: ReCore-sys

src/bin/src/systems/connection_killer.rs

@@ -12,48 +12,52 @@ pub fn connection_killer(
     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) in query.iter() {
-                    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) in query.iter() {
+            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
-                                );
-                            }
-                        } else {
-                            trace!(
+                    }
+                } else {
+                    trace!(
                         "Connection for player {} is not running, skipping disconnect packet",
                         player_identity.username
                     );
-                        }
-                    } else {
-                        system_messages::player_leave::handle(disconnecting_player.2, entity);
-                    }
-                    cmd.entity(entity).despawn();
                 }
-            }
-            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/bin/src/systems/keep_alive_system.rs

@@ -19,6 +19,9 @@ pub fn keep_alive_system(
             .running
             .load(std::sync::atomic::Ordering::Relaxed)
         {
+            if state.0.players.is_connected(entity) {
+                state.0.players.disconnect(entity, None);
+            }
             continue;
         }
 

src/bin/src/systems/new_connections.rs

@@ -8,7 +8,7 @@ use ferrumc_core::transform::position::Position;
 use ferrumc_core::transform::rotation::Rotation;
 use ferrumc_inventories::hotbar::Hotbar;
 use ferrumc_inventories::inventory::Inventory;
-use ferrumc_net::connection::NewConnection;
+use ferrumc_net::connection::{DisconnectHandle, NewConnection};
 use ferrumc_state::GlobalStateResource;
 use std::time::Instant;
 use tracing::{error, trace};
@@ -28,6 +28,9 @@ pub fn accept_new_connections(
         let return_sender = new_connection.entity_return;
         let entity = cmd.spawn((
             new_connection.stream,
+            DisconnectHandle {
+                sender: Some(new_connection.disconnect_handle),
+            },
             Position::default(),
             ChunkReceiver::default(),
             Rotation::default(),

src/lib/net/src/conn_init/login.rs

@@ -210,21 +210,27 @@ pub(super) async fn login(
 
     // =============================================================================================
     // 13 Await client's teleport acceptance
-    let mut skel = PacketSkeleton::new(conn_read, compressed, Play).await?;
+    // The client may send other packets (like client_tick_end) before accepting the teleport,
+    // so we loop until we get the accept_teleportation packet
     let expected_id = lookup_packet!("play", "serverbound", "accept_teleportation");
-    if skel.id != expected_id {
-        return Err(NetError::Packet(PacketError::UnexpectedPacket {
-            expected: expected_id,
-            received: skel.id,
-            state: Play,
-        }));
-    }
-
-    let confirm_player_teleport =
-        crate::packets::incoming::confirm_player_teleport::ConfirmPlayerTeleport::decode(
-            &mut skel.data,
-            &NetDecodeOpts::None,
-        )?;
+    let confirm_player_teleport = loop {
+        let mut skel = PacketSkeleton::new(conn_read, compressed, Play).await?;
+        if skel.id == expected_id {
+            // Got the teleport confirmation
+            let confirm =
+                crate::packets::incoming::confirm_player_teleport::ConfirmPlayerTeleport::decode(
+                    &mut skel.data,
+                    &NetDecodeOpts::None,
+                )?;
+            break confirm;
+        } else {
+            // Client sent another packet before confirming teleport - just ignore it
+            trace!(
+                "Ignoring packet 0x{:02X} while waiting for teleport confirmation",
+                skel.id
+            );
+        }
+    };
 
     if confirm_player_teleport.teleport_id.0 != teleport_id_i32 {
         error!(
@@ -235,21 +241,25 @@ pub(super) async fn login(
 
     // =============================================================================================
     // 14 Receive first movement packet from player
-    let mut skel = PacketSkeleton::new(conn_read, compressed, Play).await?;
+    // Similarly, the client may send other packets before the movement packet
     let expected_id = lookup_packet!("play", "serverbound", "move_player_pos_rot");
-    if skel.id != expected_id {
-        return Err(NetError::Packet(PacketError::UnexpectedPacket {
-            expected: expected_id,
-            received: skel.id,
-            state: Play,
-        }));
-    }
-
-    let _player_pos_and_rot =
-        crate::packets::incoming::set_player_position_and_rotation::SetPlayerPositionAndRotationPacket::decode(
-            &mut skel.data,
-            &NetDecodeOpts::None,
-        )?;
+    let _player_pos_and_rot = loop {
+        let mut skel = PacketSkeleton::new(conn_read, compressed, Play).await?;
+
+        if skel.id == expected_id {
+            let pos_rot = crate::packets::incoming::set_player_position_and_rotation::SetPlayerPositionAndRotationPacket::decode(
+                &mut skel.data,
+                &NetDecodeOpts::None,
+            )?;
+            break pos_rot;
+        } else {
+            // Client sent another packet before movement - ignore it
+            trace!(
+                "Ignoring packet 0x{:02X} while waiting for initial movement packet",
+                skel.id
+            );
+        }
+    };
 
     // =============================================================================================
     // 15 Send initial game event (e.g., "change game mode")