From f231736218f389e7db6de33a6a34009cd7e920d8 Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Sun, 2 Mar 2025 02:10:16 +0200
Subject: [PATCH] Migrate to connected clients as entities

---
 Cargo.toml              |   4 +-
 examples/simple_box.rs  | 104 ++++++++++++++++++++++----------
 examples/tic_tac_toe.rs | 129 ++++++++++++++++++++++++----------------
 src/client.rs           |  22 +++----
 src/lib.rs              |   2 +-
 src/server.rs           | 126 +++++++++++++++++++++++----------------
 tests/netcode.rs        |   7 +--
 7 files changed, 237 insertions(+), 157 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index d98d824..958a511 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,9 +25,10 @@ rustdoc-args = ["-Zunstable-options", "--cfg", "docsrs"]
 all-features = true
 
 [dependencies]
-bevy_replicon = { version = "0.30", default-features = false }
+bevy_replicon = { git = "https://github.com/projectharmonia/bevy_replicon", branch = "connected-entities", default-features = false }
 bevy_renet = { version = "1.0", default-features = false }
 bevy = { version = "0.15", default-features = false }
+serde = "1.0"
 
 [dev-dependencies]
 bevy = { version = "0.15", default-features = false, features = [
@@ -40,7 +41,6 @@ bevy = { version = "0.15", default-features = false, features = [
   "default_font",
 ] }
 clap = { version = "4.1", features = ["derive"] }
-serde = "1.0"
 
 [features]
 default = ["client", "server", "renet_netcode"]
diff --git a/examples/simple_box.rs b/examples/simple_box.rs
index 9415c1b..8eae053 100644
--- a/examples/simple_box.rs
+++ b/examples/simple_box.rs
@@ -3,6 +3,7 @@
 
 use std::{
     error::Error,
+    hash::{DefaultHasher, Hash, Hasher},
     net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket},
     time::SystemTime,
 };
@@ -46,7 +47,7 @@ struct SimpleBoxPlugin;
 impl Plugin for SimpleBoxPlugin {
     fn build(&self, app: &mut App) {
         app.replicate::<BoxPosition>()
-            .replicate::<BoxColor>()
+            .replicate::<PlayerBox>()
             .add_client_trigger::<MoveBox>(ChannelKind::Ordered)
             .add_observer(spawn_clients)
             .add_observer(despawn_clients)
@@ -66,7 +67,12 @@ fn read_cli(
     match *cli {
         Cli::SinglePlayer => {
             info!("starting single-player game");
-            commands.spawn((BoxPlayer(ClientId::SERVER), BoxColor(GREEN.into())));
+            commands.spawn((
+                PlayerBox {
+                    color: GREEN.into(),
+                },
+                BoxOwner(SERVER),
+            ));
         }
         Cli::Server { port } => {
             info!("starting server at port {port}");
@@ -101,7 +107,12 @@ fn read_cli(
                 },
                 TextColor::WHITE,
             ));
-            commands.spawn((BoxPlayer(ClientId::SERVER), BoxColor(GREEN.into())));
+            commands.spawn((
+                PlayerBox {
+                    color: GREEN.into(),
+                },
+                BoxOwner(SERVER),
+            ));
         }
         Cli::Client { port, ip } => {
             info!("connecting to {ip}:{port}");
@@ -130,7 +141,7 @@ fn read_cli(
             commands.insert_resource(transport);
 
             commands.spawn((
-                Text(format!("Client: {client_id:?}")),
+                Text(format!("Client: {client_id}")),
                 TextFont {
                     font_size: 30.0,
                     ..default()
@@ -148,24 +159,37 @@ fn spawn_camera(mut commands: Commands) {
 }
 
 /// Spawns a new box whenever a client connects.
-fn spawn_clients(trigger: Trigger<ClientConnected>, mut commands: Commands) {
-    // Generate pseudo random color from client id.
-    let r = ((trigger.client_id.get() % 23) as f32) / 23.0;
-    let g = ((trigger.client_id.get() % 27) as f32) / 27.0;
-    let b = ((trigger.client_id.get() % 39) as f32) / 39.0;
-    info!("spawning box for `{:?}`", trigger.client_id);
-    commands.spawn((BoxPlayer(trigger.client_id), BoxColor(Color::srgb(r, g, b))));
+fn spawn_clients(trigger: Trigger<OnAdd, ConnectedClient>, mut commands: Commands) {
+    // Hash index to generate visually distinctive color.
+    let mut hasher = DefaultHasher::new();
+    trigger.entity().index().hash(&mut hasher);
+    let hash = hasher.finish();
+
+    // Use the lower 24 bits.
+    // Divide by 255 to convert bytes into 0..1 floats.
+    let r = ((hash >> 16) & 0xFF) as f32 / 255.0;
+    let g = ((hash >> 8) & 0xFF) as f32 / 255.0;
+    let b = (hash & 0xFF) as f32 / 255.0;
+
+    // Generate pseudo random color from client entity.
+    info!("spawning box for `{}`", trigger.entity());
+    commands.spawn((
+        PlayerBox {
+            color: Color::srgb(r, g, b),
+        },
+        BoxOwner(trigger.entity()),
+    ));
 }
 
 /// Despawns a box whenever a client disconnects.
 fn despawn_clients(
-    trigger: Trigger<ClientDisconnected>,
+    trigger: Trigger<OnRemove, ConnectedClient>,
     mut commands: Commands,
-    boxes: Query<(Entity, &BoxPlayer)>,
+    boxes: Query<(Entity, &BoxOwner)>,
 ) {
     let (entity, _) = boxes
         .iter()
-        .find(|(_, &player)| *player == trigger.client_id)
+        .find(|(_, &owner)| *owner == trigger.entity())
         .expect("all clients should have entities");
     commands.entity(entity).despawn();
 }
@@ -198,26 +222,28 @@ fn read_input(mut commands: Commands, input: Res<ButtonInput<KeyCode>>) {
 fn apply_movement(
     trigger: Trigger<FromClient<MoveBox>>,
     time: Res<Time>,
-    mut boxes: Query<(&BoxPlayer, &mut BoxPosition)>,
+    mut boxes: Query<(&BoxOwner, &mut BoxPosition)>,
 ) {
     const MOVE_SPEED: f32 = 300.0;
-    info!("received movement from `{:?}`", trigger.client_id);
-    for (player, mut position) in &mut boxes {
-        // Find the sender entity. We don't include the entity as a trigger target to save traffic, since the server knows
-        // which entity to apply the input to. We could have a resource that maps connected clients to controlled entities,
-        // but we didn't implement it for the sake of simplicity.
-        if trigger.client_id == **player {
-            **position += *trigger.event * time.delta_secs() * MOVE_SPEED;
-        }
-    }
+    info!("received movement from `{}`", trigger.client_entity);
+
+    // Find the sender entity. We don't include the entity as a trigger target to save traffic, since the server knows
+    // which entity to apply the input to. We could have a resource that maps connected clients to controlled entities,
+    // but we didn't implement it for the sake of simplicity.
+    let (_, mut position) = boxes
+        .iter_mut()
+        .find(|(&owner, _)| *owner == trigger.client_entity)
+        .unwrap_or_else(|| panic!("`{}` should be connected", trigger.client_entity));
+
+    **position += *trigger.event * time.delta_secs() * MOVE_SPEED;
 }
 
-fn draw_boxes(mut gizmos: Gizmos, boxes: Query<(&BoxPosition, &BoxColor)>) {
-    for (position, color) in &boxes {
+fn draw_boxes(mut gizmos: Gizmos, boxes: Query<(&BoxPosition, &PlayerBox)>) {
+    for (position, player) in &boxes {
         gizmos.rect(
             Vec3::new(position.x, position.y, 0.0),
             Vec2::ONE * 50.0,
-            **color,
+            player.color,
         );
     }
 }
@@ -250,18 +276,30 @@ impl Default for Cli {
     }
 }
 
-/// Identifies which player controls the box.
+/// Player-controlled box.
 ///
 /// We want to replicate all boxes, so we just set [`Replicated`] as a required component.
-#[derive(Component, Clone, Copy, Deref, Serialize, Deserialize)]
-#[require(BoxPosition, BoxColor, Replicated)]
-struct BoxPlayer(ClientId);
+#[derive(Component, Deref, Deserialize, Serialize, Default)]
+#[require(BoxPosition, Replicated)]
+struct PlayerBox {
+    /// Color to visually distinguish boxes.
+    color: Color,
+}
 
+/// Position of a player-controlled box.
+///
+/// This is a separate component from [`PlayerBox`] because, when the position
+/// changes, we only want to send this component (and it changes often!).
 #[derive(Component, Deserialize, Serialize, Deref, DerefMut, Default)]
 struct BoxPosition(Vec2);
 
-#[derive(Component, Deref, Deserialize, Serialize, Default)]
-struct BoxColor(Color);
+/// Identifies which player controls the box.
+///
+/// Points to client entity. Used to apply movement to the correct box.
+///
+/// It's not replicated and present only on server or singleplayer.
+#[derive(Component, Clone, Copy, Deref)]
+struct BoxOwner(Entity);
 
 /// A movement event for the controlled box.
 #[derive(Deserialize, Deref, Event, Serialize)]
diff --git a/examples/tic_tac_toe.rs b/examples/tic_tac_toe.rs
index 39bfbeb..043a911 100644
--- a/examples/tic_tac_toe.rs
+++ b/examples/tic_tac_toe.rs
@@ -52,9 +52,8 @@ impl Plugin for TicTacToePlugin {
             .init_resource::<SymbolFont>()
             .init_resource::<TurnSymbol>()
             .replicate::<Symbol>()
-            .replicate::<Player>()
             .add_client_trigger::<CellPick>(ChannelKind::Ordered)
-            .add_client_trigger::<MapCells>(ChannelKind::Ordered)
+            .add_client_trigger::<MapBoard>(ChannelKind::Ordered)
             .insert_resource(ClearColor(BACKGROUND_COLOR))
             .add_observer(disconnect_by_client)
             .add_observer(init_client)
@@ -112,8 +111,8 @@ fn read_cli(
         Cli::Hotseat => {
             info!("starting hotseat");
             // Set all players to server to play from a single machine and start the game right away.
-            commands.spawn((Player(ClientId::SERVER), Symbol::Cross));
-            commands.spawn((Player(ClientId::SERVER), Symbol::Nought));
+            commands.spawn((LocalPlayer, Symbol::Cross, PlayerClient(SERVER)));
+            commands.spawn((LocalPlayer, Symbol::Nought, PlayerClient(SERVER)));
             commands.set_state(GameState::InGame);
         }
         Cli::Server { port, symbol } => {
@@ -140,7 +139,7 @@ fn read_cli(
 
             commands.insert_resource(server);
             commands.insert_resource(transport);
-            commands.spawn((Player(ClientId::SERVER), symbol));
+            commands.spawn((LocalPlayer, symbol, PlayerClient(SERVER)));
         }
         Cli::Client { port, ip } => {
             info!("connecting to {ip}:{port}");
@@ -167,6 +166,7 @@ fn read_cli(
 
             commands.insert_resource(client);
             commands.insert_resource(transport);
+            commands.spawn(LocalPlayer);
         }
     }
 
@@ -300,32 +300,29 @@ fn apply_pick(
     mut commands: Commands,
     cells: Query<(Entity, &Cell)>,
     turn_symbol: Res<TurnSymbol>,
-    players: Query<(&Player, &Symbol)>,
+    players: Query<(&PlayerClient, &Symbol)>,
 ) {
     // It's good to check the received data because client could be cheating.
-    if trigger.event.index > GRID_SIZE * GRID_SIZE {
-        debug!("received invalid cell index {:?}", trigger.event.index);
+    if trigger.index > GRID_SIZE * GRID_SIZE {
+        error!("received invalid cell index {}", trigger.index);
         return;
     }
 
     if !players
         .iter()
-        .any(|(&player, &symbol)| *player == trigger.client_id && symbol == **turn_symbol)
+        .any(|(&client, &symbol)| *client == trigger.client_entity && symbol == **turn_symbol)
     {
-        debug!(
-            "{:?} chose cell {:?} at wrong turn",
-            trigger.client_id, trigger.event.index
+        error!(
+            "`{}` chose cell {} at wrong turn",
+            trigger.client_entity, trigger.index
         );
         return;
     }
 
-    let Some((entity, _)) = cells
-        .iter()
-        .find(|(_, cell)| cell.index == trigger.event.index)
-    else {
-        debug!(
-            "{:?} has chosen an already occupied cell {:?}",
-            trigger.client_id, trigger.event.index
+    let Some((entity, _)) = cells.iter().find(|(_, cell)| cell.index == trigger.index) else {
+        error!(
+            "`{}` has chosen an already occupied cell {}",
+            trigger.client_entity, trigger.index
         );
         return;
     };
@@ -361,20 +358,27 @@ fn init_symbols(
         });
 }
 
-/// Sends cell entities and starts the game after successful connection.
+/// Sends cell and local player entities and starts the game.
 ///
 /// Replicon maps entities when you replicate them from server automatically.
 /// But in this game we spawn cells beforehand. So we send a special event to
 /// server to receive replication to already existing entities.
 ///
 /// Used only for client.
-fn client_start(mut commands: Commands, cells: Query<(Entity, &Cell)>) {
-    let mut entities = HashMap::new();
+fn client_start(
+    mut commands: Commands,
+    cells: Query<(Entity, &Cell)>,
+    player_entity: Single<Entity, With<LocalPlayer>>,
+) {
+    let mut cell_entities = HashMap::new();
     for (entity, cell) in &cells {
-        entities.insert(cell.index, entity);
+        cell_entities.insert(cell.index, entity);
     }
 
-    commands.client_trigger(MapCells(entities));
+    commands.client_trigger(MapBoard {
+        cell_entities,
+        player_entity: *player_entity,
+    });
     commands.set_state(GameState::InGame);
 }
 
@@ -382,38 +386,45 @@ fn client_start(mut commands: Commands, cells: Query<(Entity, &Cell)>) {
 ///
 /// Used only for server.
 fn init_client(
-    trigger: Trigger<FromClient<MapCells>>,
+    trigger: Trigger<FromClient<MapBoard>>,
     mut commands: Commands,
-    mut entity_map: ResMut<ClientEntityMap>,
     cells: Query<(Entity, &Cell)>,
-    server_symbol: Single<&Symbol, With<Player>>,
+    server_symbol: Single<&Symbol, With<LocalPlayer>>,
 ) {
+    let mut entity_map = ClientEntityMap::default();
     for (server_entity, cell) in &cells {
-        let Some(&client_entity) = trigger.event.get(&cell.index) else {
+        let Some(&client_entity) = trigger.cell_entities.get(&cell.index) else {
             error!("received cells missing index {}, disconnecting", cell.index);
             commands.set_state(GameState::Disconnected);
             return;
         };
 
-        entity_map.insert(
-            trigger.client_id,
-            ClientMapping {
-                server_entity,
-                client_entity,
-            },
-        );
+        entity_map.insert(server_entity, client_entity);
     }
 
-    commands.spawn((Player(trigger.client_id), server_symbol.next()));
+    let player_entity = commands
+        .spawn((
+            Player,
+            server_symbol.next(),
+            PlayerClient(trigger.client_entity),
+        ))
+        .id();
+    entity_map.insert(player_entity, trigger.player_entity);
+
+    // When `replicate_after_connect` is set to false, `ReplicatedClient`
+    // and `ClientEntityMap` are not inserted automatically to client entities.
+    // We need to insert them manually to start replication.
     commands.set_state(GameState::InGame);
-    commands.trigger(StartReplication(trigger.client_id));
+    commands
+        .entity(trigger.client_entity)
+        .insert((ReplicatedClient, entity_map));
 }
 
 /// Sets the game in disconnected state if client closes the connection.
 ///
 /// Used only for server.
 fn disconnect_by_client(
-    _trigger: Trigger<ClientDisconnected>,
+    _trigger: Trigger<OnRemove, ConnectedClient>,
     game_state: Res<State<GameState>>,
     mut commands: Commands,
 ) {
@@ -533,13 +544,9 @@ fn show_waiting_client_text(
 /// Returns `true` if the local player can select cells.
 fn local_player_turn(
     turn_symbol: Res<TurnSymbol>,
-    client: Res<RepliconClient>,
-    players: Query<(&Player, &Symbol)>,
+    players: Query<&Symbol, With<LocalPlayer>>,
 ) -> bool {
-    let client_id = client.id().unwrap_or(ClientId::SERVER);
-    players
-        .iter()
-        .any(|(&player, &symbol)| *player == client_id && symbol == **turn_symbol)
+    players.iter().any(|&symbol| symbol == **turn_symbol)
 }
 
 const PORT: u16 = 5000;
@@ -594,7 +601,7 @@ enum GameState {
 #[derive(Resource, Default, Deref, DerefMut)]
 struct TurnSymbol(Symbol);
 
-/// A component that defines the symbol of a player or a filled cell.
+/// A component that defines the symbol of a [`Player`], current [`TurnSymbol`] or a filled cell (see [`CellPick`]).
 #[derive(Clone, Component, Copy, Default, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
 enum Symbol {
     #[default]
@@ -657,12 +664,27 @@ struct Cell {
     index: usize,
 }
 
-/// Contains player ID.
-///
-/// We want to replicate all players, so we just set [`Replicated`] as a required component.
-#[derive(Clone, Copy, Component, Deref, Serialize, Deserialize)]
+/// Marker for a player entity.
+#[derive(Component, Default)]
 #[require(Replicated)]
-struct Player(ClientId);
+struct Player;
+
+/// Marks [`Player`] as locally controlled.
+///
+/// Used to determine if player can place a symbol.
+///
+/// See also [`local_player_turn`].
+#[derive(Component)]
+#[require(Player)]
+struct LocalPlayer;
+
+/// Identifies which player controlled by which client.
+///
+/// Points to client entity. Used to verify client's turns.
+///
+/// It's not replicated and present only on server or singleplayer.
+#[derive(Clone, Copy, Component, Deref)]
+struct PlayerClient(Entity);
 
 /// A trigger that indicates a symbol pick.
 ///
@@ -676,5 +698,8 @@ struct CellPick {
 /// A trigger to send client cell entities to server to estabialize mappings for replication.
 ///
 /// See [`TicTacToePlugin::client_start`] for details.
-#[derive(Event, Deref, Serialize, Deserialize)]
-struct MapCells(HashMap<usize, Entity>);
+#[derive(Event, Serialize, Deserialize)]
+struct MapBoard {
+    cell_entities: HashMap<usize, Entity>,
+    player_entity: Entity,
+}
diff --git a/src/client.rs b/src/client.rs
index 4a0f3da..e743e2d 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -1,6 +1,6 @@
 use bevy::prelude::*;
 #[cfg(feature = "renet_netcode")]
-use bevy_renet::netcode::{NetcodeClientPlugin, NetcodeClientTransport};
+use bevy_renet::netcode::NetcodeClientPlugin;
 #[cfg(feature = "renet_steam")]
 use bevy_renet::steam::SteamClientPlugin;
 use bevy_renet::{self, renet::RenetClient, RenetClientPlugin, RenetReceive, RenetSend};
@@ -53,18 +53,8 @@ impl RepliconRenetClientPlugin {
         }
     }
 
-    fn set_connected(
-        mut client: ResMut<RepliconClient>,
-        #[cfg(feature = "renet_netcode")] transport: Option<Res<NetcodeClientTransport>>,
-    ) {
-        // In renet only transport knows the ID.
-        // TODO: Pending renet issue https://github.com/lucaspoffo/renet/issues/153
-        #[cfg(feature = "renet_netcode")]
-        let client_id = transport.map(|transport| ClientId::new(transport.client_id()));
-        #[cfg(not(feature = "renet_netcode"))]
-        let client_id = None;
-
-        client.set_status(RepliconClientStatus::Connected { client_id });
+    fn set_connected(mut client: ResMut<RepliconClient>) {
+        client.set_status(RepliconClientStatus::Connected);
     }
 
     fn receive_packets(
@@ -81,6 +71,12 @@ impl RepliconRenetClientPlugin {
                 replicon_client.insert_received(channel_id, message);
             }
         }
+
+        let stats = replicon_client.stats_mut();
+        stats.rtt = renet_client.rtt();
+        stats.packet_loss = renet_client.packet_loss();
+        stats.sent_bps = renet_client.bytes_sent_per_sec();
+        stats.received_bps = renet_client.bytes_received_per_sec();
     }
 
     fn send_packets(
diff --git a/src/lib.rs b/src/lib.rs
index 4ebc225..fa589aa 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -92,7 +92,7 @@ pub use bevy_renet::steam;
 #[cfg(feature = "client")]
 pub use client::RepliconRenetClientPlugin;
 #[cfg(feature = "server")]
-pub use server::RepliconRenetServerPlugin;
+pub use server::{RenetId, RepliconRenetServerPlugin};
 
 use bevy::{app::PluginGroupBuilder, prelude::*};
 use bevy_replicon::prelude::*;
diff --git a/src/server.rs b/src/server.rs
index 6c6df1d..e5f8e79 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,18 +1,14 @@
-use std::{
-    error::Error,
-    fmt::{self, Display, Formatter},
-};
-
-use bevy::prelude::*;
+use bevy::{prelude::*, utils::HashMap};
 #[cfg(feature = "renet_netcode")]
 use bevy_renet::netcode::NetcodeServerPlugin;
 #[cfg(feature = "renet_steam")]
 use bevy_renet::steam::SteamServerPlugin;
 use bevy_renet::{
-    renet::{self, RenetServer, ServerEvent},
+    renet::{ClientId, RenetServer, ServerEvent},
     RenetReceive, RenetSend, RenetServerPlugin,
 };
 use bevy_replicon::prelude::*;
+use serde::{Deserialize, Serialize};
 
 /// Adds renet as server messaging backend.
 ///
@@ -23,20 +19,19 @@ pub struct RepliconRenetServerPlugin;
 impl Plugin for RepliconRenetServerPlugin {
     fn build(&self, app: &mut App) {
         app.add_plugins(RenetServerPlugin)
+            .init_resource::<RenetIdMap>()
             .configure_sets(PreUpdate, ServerSet::ReceivePackets.after(RenetReceive))
             .configure_sets(PostUpdate, ServerSet::SendPackets.before(RenetSend))
             .add_systems(
                 PreUpdate,
                 (
-                    (
-                        Self::set_running.run_if(resource_added::<RenetServer>),
-                        Self::set_stopped.run_if(resource_removed::<RenetServer>),
-                        Self::receive_packets.run_if(resource_exists::<RenetServer>),
-                    )
-                        .chain()
-                        .in_set(ServerSet::ReceivePackets),
-                    Self::forward_server_events.in_set(ServerSet::TriggerConnectionEvents),
-                ),
+                    Self::set_running.run_if(resource_added::<RenetServer>),
+                    Self::set_stopped.run_if(resource_removed::<RenetServer>),
+                    (Self::receive_packets, Self::forward_server_events)
+                        .run_if(resource_exists::<RenetServer>),
+                )
+                    .chain()
+                    .in_set(ServerSet::ReceivePackets),
             )
             .add_systems(
                 PostUpdate,
@@ -63,78 +58,105 @@ impl RepliconRenetServerPlugin {
 
     fn forward_server_events(
         mut commands: Commands,
-        mut renet_server_events: EventReader<ServerEvent>,
+        mut server_events: EventReader<ServerEvent>,
+        mut renet_map: ResMut<RenetIdMap>,
     ) {
-        for event in renet_server_events.read() {
-            debug!("forwarding event `{event:?}`");
+        for event in server_events.read() {
             match event {
-                ServerEvent::ClientConnected { client_id } => commands.trigger(ClientConnected {
-                    client_id: ClientId::new(*client_id),
-                }),
+                ServerEvent::ClientConnected { client_id } => {
+                    let client_entity = commands.spawn((ConnectedClient, RenetId(*client_id))).id();
+                    renet_map.0.insert(*client_id, client_entity);
+                    debug!("connecting client with ID {client_id} as `{client_entity}`");
+                }
                 ServerEvent::ClientDisconnected { client_id, reason } => {
-                    let reason = match reason {
-                        renet::DisconnectReason::DisconnectedByClient => {
-                            DisconnectReason::DisconnectedByClient
-                        }
-                        renet::DisconnectReason::DisconnectedByServer => {
-                            DisconnectReason::DisconnectedByServer
-                        }
-                        _ => Box::<BackendError>::from(RenetDisconnectReason(*reason)).into(),
-                    };
-                    commands.trigger(ClientDisconnected {
-                        client_id: ClientId::new(*client_id),
-                        reason,
-                    });
+                    let client_entity = renet_map
+                        .0
+                        .remove(client_id)
+                        .expect("clients should be connected before disconnection");
+
+                    commands.entity(client_entity).despawn();
+                    debug!("disconnecting client `{client_entity}` with ID {client_id}: {reason}");
                 }
             }
         }
     }
 
     fn receive_packets(
-        connected_clients: Res<ConnectedClients>,
         channels: Res<RepliconChannels>,
         mut renet_server: ResMut<RenetServer>,
         mut replicon_server: ResMut<RepliconServer>,
+        mut clients: Query<(Entity, &RenetId, &mut NetworkStats)>,
     ) {
-        for &client in connected_clients.iter() {
+        for (client_entity, &renet_id, mut stats) in &mut clients {
             for channel_id in 0..channels.client_channels().len() as u8 {
-                while let Some(message) =
-                    renet_server.receive_message(client.id().get(), channel_id)
-                {
+                while let Some(message) = renet_server.receive_message(*renet_id, channel_id) {
                     trace!(
                         "forwarding {} received bytes over channel {channel_id}",
                         message.len()
                     );
-                    replicon_server.insert_received(client.id(), channel_id, message);
+                    replicon_server.insert_received(client_entity, channel_id, message);
                 }
             }
+
+            // Renet events reading runs in parallel, so the client might have been disconnected.
+            if let Ok(info) = renet_server.network_info(*renet_id) {
+                stats.rtt = info.rtt;
+                stats.packet_loss = info.packet_loss;
+                stats.sent_bps = info.bytes_sent_per_second;
+                stats.received_bps = info.bytes_received_per_second;
+            }
         }
     }
 
     fn send_packets(
         mut renet_server: ResMut<RenetServer>,
         mut replicon_server: ResMut<RepliconServer>,
+        clients: Query<&RenetId>,
     ) {
-        for (client_id, channel_id, message) in replicon_server.drain_sent() {
+        for (client_entity, channel_id, message) in replicon_server.drain_sent() {
             trace!(
                 "forwarding {} sent bytes over channel {channel_id}",
                 message.len()
             );
-            renet_server.send_message(client_id.get(), channel_id, message)
+            let renet_id = *clients
+                .get(client_entity)
+                .expect("messages should be sent only to connected clients");
+            renet_server.send_message(*renet_id, channel_id, message)
         }
     }
 }
 
-/// A wrapper to implement [`Error`] for [`renet::DisconnectReason`].
+/// Maps [`ClientId`]'s into client entities.
 ///
-/// Temporary workaround until [this PR](https://github.com/lucaspoffo/renet/pull/170) is merged.
-#[derive(Debug)]
-pub struct RenetDisconnectReason(pub renet::DisconnectReason);
+/// See also [`RenetId`] for getting [`ClientId`] from entities (using [`Query::get`], for example).
+#[derive(Resource, Deref, Default)]
+struct RenetIdMap(HashMap<ClientId, Entity>);
 
-impl Display for RenetDisconnectReason {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        self.0.fmt(f)
+/// Component with Renet's [`ClientId`].
+///
+/// Attached to connected clients by backend.
+///
+/// See also [`RenetIdMap`] for getting client entities from [`ClientId`].
+#[derive(
+    Component,
+    Debug,
+    Clone,
+    Copy,
+    Hash,
+    PartialEq,
+    Eq,
+    Ord,
+    PartialOrd,
+    Serialize,
+    Deserialize,
+    Reflect,
+    Deref,
+)]
+pub struct RenetId(u64);
+
+impl RenetId {
+    /// Creates a new ID wrapping the given value.
+    pub const fn new(value: u64) -> Self {
+        Self(value)
     }
 }
-
-impl Error for RenetDisconnectReason {}
diff --git a/tests/netcode.rs b/tests/netcode.rs
index 0d88ba6..e5f0902 100644
--- a/tests/netcode.rs
+++ b/tests/netcode.rs
@@ -37,8 +37,8 @@ fn connect_disconnect() {
     let renet_server = server_app.world().resource::<RenetServer>();
     assert_eq!(renet_server.connected_clients(), 1);
 
-    let connected_clients = server_app.world().resource::<ConnectedClients>();
-    assert_eq!(connected_clients.len(), 1);
+    let mut clients = server_app.world_mut().query::<&ConnectedClient>();
+    assert_eq!(clients.iter(server_app.world()).len(), 1);
 
     let replicon_client = client_app.world().resource::<RepliconClient>();
     assert!(replicon_client.is_connected());
@@ -51,8 +51,7 @@ fn connect_disconnect() {
     client_app.update();
     server_app.update();
 
-    let connected_clients = server_app.world().resource::<ConnectedClients>();
-    assert_eq!(connected_clients.len(), 0);
+    assert_eq!(clients.iter(server_app.world()).len(), 0);
 
     let renet_server = server_app.world().resource::<RenetServer>();
     assert_eq!(renet_server.connected_clients(), 0);