Clean up events more rigorously

src/client.rs

@@ -4,8 +4,12 @@ pub mod diagnostics;
 use std::io::Cursor;
 
 use bevy::{prelude::*, utils::EntityHashMap};
-use bevy_renet::{client_connected, renet::Bytes};
-use bevy_renet::{renet::RenetClient, transport::NetcodeClientPlugin, RenetClientPlugin};
+use bevy_renet::{
+    client_connected, client_just_connected, client_just_disconnected,
+    renet::{Bytes, RenetClient},
+    transport::NetcodeClientPlugin,
+    RenetClientPlugin,
+};
 use bincode::{DefaultOptions, Options};
 use varint_rs::VarintReader;
 
@@ -27,19 +31,20 @@ impl Plugin for ClientPlugin {
             .init_resource::<BufferedUpdates>()
             .configure_sets(
                 PreUpdate,
-                ClientSet::Receive.after(NetcodeClientPlugin::update_system),
+                ClientSet::ResetEvents
+                    .after(NetcodeClientPlugin::update_system)
+                    .before(ClientSet::Receive)
+                    .run_if(client_just_connected()),
             )
             .configure_sets(
                 PreUpdate,
-                ClientSet::Reset
-                    .after(NetcodeClientPlugin::update_system)
-                    .run_if(bevy_renet::client_just_disconnected()),
+                ClientSet::Receive.after(NetcodeClientPlugin::update_system),
             )
             .configure_sets(
                 PreUpdate,
-                ClientSet::ResetEvents
+                ClientSet::Reset
                     .after(NetcodeClientPlugin::update_system)
-                    .run_if(bevy_renet::client_just_disconnected()),
+                    .run_if(client_just_disconnected()),
             )
             .configure_sets(
                 PostUpdate,
@@ -484,18 +489,22 @@ pub enum ClientSet {
     Send,
     /// Systems that reset the client.
     ///
-    /// Runs in `PreUpdate`.
+    /// Runs in `PreUpdate` when the client just disconnected.
     ///
     /// If this set is disabled, then you need to manually clean up the client after a disconnect or when
     /// reconnecting.
+    /// You may want to disable this set if you want to preserve client replication state across reconnects.
+    /// In that case, you need to manually repair the client state (or use something like
+    /// [bevy_replicon_repair](https://github.com/UkoeHB/bevy_replicon_repair)).
     Reset,
     /// Systems that reset queued server events.
     ///
-    /// Runs in `PreUpdate`.
+    /// Runs in `PreUpdate` immediately after the client connects to ensure client sessions have a fresh start.
     ///
-    /// This is a separate set from `ClientSet::Reset` in case you want to enable/disable it separately.
-    /// In general it is best practice to clear queued server events after a disconnect, whereas you may want to
-    /// preserve replication state (in which case `ClientSet::Reset` should be disabled).
+    /// This is a separate set from `ClientSet::Reset` because the reset requirements for events are different
+    /// from the replicon client internals.
+    /// It is best practice to discard client-sent and server-received events while the client is not connected
+    /// in order to guarantee clean separation between connection sessions.
     ResetEvents,
 }
 

src/network_event/client_event.rs

@@ -141,9 +141,12 @@ impl ClientEventAppExt for App {
             .insert_resource(ClientEventChannel::<T>::new(channel_id))
             .add_systems(
                 PreUpdate,
-                receiving_system
-                    .in_set(ServerSet::Receive)
-                    .run_if(resource_exists::<RenetServer>()),
+                (
+                    reset_system::<T>.in_set(ClientSet::ResetEvents),
+                    receiving_system
+                        .in_set(ServerSet::Receive)
+                        .run_if(resource_exists::<RenetServer>()),
+                ),
             )
             .add_systems(
                 PostUpdate,
@@ -220,6 +223,16 @@ fn local_resending_system<T: Event>(
     }
 }
 
+/// Discards all pending events.
+///
+/// We discard events while waiting to connect to ensure clean reconnects.
+fn reset_system<T: Event>(mut events: ResMut<Events<T>>) {
+    let drained_count = events.drain().count();
+    if drained_count > 0 {
+        warn!("discarded {drained_count} client events due to a disconnect");
+    }
+}
+
 /// An event indicating that a message from client was received.
 /// Emited only on server.
 #[derive(Clone, Copy, Event)]

src/network_event/server_event.rs

@@ -175,13 +175,15 @@ impl ServerEventAppExt for App {
             .insert_resource(ServerEventChannel::<T>::new(channel_id))
             .add_systems(
                 PreUpdate,
-                (queue_system::<T>, receiving_system)
-                    .chain()
-                    .after(ClientPlugin::replication_receiving_system)
-                    .in_set(ClientSet::Receive)
-                    .run_if(client_connected()),
+                (
+                    reset_system::<T>.in_set(ClientSet::ResetEvents),
+                    (queue_system::<T>, receiving_system)
+                        .chain()
+                        .after(ClientPlugin::replication_receiving_system)
+                        .in_set(ClientSet::Receive)
+                        .run_if(client_connected()),
+                ),
             )
-            .add_systems(PreUpdate, reset_system::<T>.in_set(ClientSet::ResetEvents))
             .add_systems(
                 PostUpdate,
                 (
@@ -290,7 +292,16 @@ fn local_resending_system<T: Event>(
     }
 }
 
+/// Clears queued events.
+///
+/// We clear events while waiting for a connection to ensure clean reconnects.
 fn reset_system<T: Event>(mut event_queue: ResMut<ServerEventQueue<T>>) {
+    if !event_queue.0.is_empty() {
+        warn!(
+            "discarding {} queued server events due to a disconnect",
+            event_queue.0.values_len()
+        );
+    }
     event_queue.0.clear();
 }