Rename RepliconClient into ClientMessages

Because it holds only messages now.

Author: Shatur

CHANGELOG.md

@@ -33,6 +33,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Rename `replication_registry` module into `registry`.
 - Rename `IntoComponentRule::register_component` to `IntoComponentRule::into_rule` and move it to the `shared::replication::rules::component` module.
 - Rename `NetworkStats` to `ClientStats` and move it from `shared::backend::connected_client` to `shared::backend`. It's also now a separate resource from `RepliconClient`.
+- Rename `RepliconClient` into `ClientMessages`. It holds only messages now.
 - Replace `IntoReplicationRule` with `IntoComponentRules`, which returns only `Vec<ComponentRule>`.
 - Replace `ReplicationBundle` with `BundleRules`, which returns only `Vec<ComponentRule>` and uses an associated constant to customize the priority.
 - Hide `ServerEntityMap` mutation methods from public API.

bevy_replicon_example_backend/src/client.rs

@@ -49,7 +49,7 @@ fn set_disconnected(mut state: ResMut<NextState<ClientState>>) {
 fn receive_packets(
     mut commands: Commands,
     mut client: ResMut<ExampleClient>,
-    mut replicon_client: ResMut<RepliconClient>,
+    mut messages: ResMut<ClientMessages>,
     config: Option<Res<ConditionerConfig>>,
 ) {
     let now = Instant::now();
@@ -76,16 +76,16 @@ fn receive_packets(
     }
 
     while let Some((channel_id, message)) = client.conditioner.pop(now) {
-        replicon_client.insert_received(channel_id, message);
+        messages.insert_received(channel_id, message);
     }
 }
 
 fn send_packets(
     mut commands: Commands,
     mut client: ResMut<ExampleClient>,
-    mut replicon_client: ResMut<RepliconClient>,
+    mut messages: ResMut<ClientMessages>,
 ) {
-    for (channel_id, message) in replicon_client.drain_sent() {
+    for (channel_id, message) in messages.drain_sent() {
         if let Err(e) = tcp::send_message(&mut client.stream, channel_id, &message) {
             error!("disconnecting due message write error: {e}");
             commands.remove_resource::<ExampleClient>();

src/client.rs

@@ -38,7 +38,7 @@ pub struct ClientPlugin;
 
 impl Plugin for ClientPlugin {
     fn build(&self, app: &mut App) {
-        app.init_resource::<RepliconClient>()
+        app.init_resource::<ClientMessages>()
             .init_resource::<ClientStats>()
             .init_resource::<ServerEntityMap>()
             .init_resource::<ServerUpdateTick>()
@@ -98,9 +98,9 @@ impl Plugin for ClientPlugin {
         }
 
         app.world_mut()
-            .resource_scope(|world, mut client: Mut<RepliconClient>| {
+            .resource_scope(|world, mut messages: Mut<ClientMessages>| {
                 let channels = world.resource::<RepliconChannels>();
-                client.setup_server_channels(channels.server_channels().len());
+                messages.setup_server_channels(channels.server_channels().len());
             });
     }
 }
@@ -126,7 +126,7 @@ pub(super) fn receive_replication(
     mut changes: Local<DeferredChanges>,
     mut entity_markers: Local<EntityMarkers>,
 ) {
-    world.resource_scope(|world, mut client: Mut<RepliconClient>| {
+    world.resource_scope(|world, mut messages: Mut<ClientMessages>| {
         world.resource_scope(|world, mut entity_map: Mut<ServerEntityMap>| {
             world.resource_scope(|world, mut buffered_mutations: Mut<BufferedMutations>| {
                 world.resource_scope(|world, command_markers: Mut<CommandMarkers>| {
@@ -151,7 +151,7 @@ pub(super) fn receive_replication(
                                 apply_replication(
                                     world,
                                     &mut params,
-                                    &mut client,
+                                    &mut messages,
                                     &mut buffered_mutations,
                                 );
 
@@ -171,15 +171,15 @@ pub(super) fn receive_replication(
 }
 
 fn reset(
-    mut client: ResMut<RepliconClient>,
+    mut messages: ResMut<ClientMessages>,
     mut stats: ResMut<ClientStats>,
     mut update_tick: ResMut<ServerUpdateTick>,
     mut entity_map: ResMut<ServerEntityMap>,
     mut buffered_mutations: ResMut<BufferedMutations>,
     mutate_ticks: Option<ResMut<ServerMutateTicks>>,
     replication_stats: Option<ResMut<ClientReplicationStats>>,
 ) {
-    client.clear();
+    messages.clear();
     *stats = Default::default();
     *update_tick = Default::default();
     entity_map.clear();
@@ -209,10 +209,10 @@ fn log_protocol_error(_trigger: Trigger<ProtocolMismatch>) {
 fn apply_replication(
     world: &mut World,
     params: &mut ReceiveParams,
-    client: &mut RepliconClient,
+    messages: &mut ClientMessages,
     buffered_mutations: &mut BufferedMutations,
 ) {
-    for mut message in client.receive(ServerChannel::Updates) {
+    for mut message in messages.receive(ServerChannel::Updates) {
         if let Err(e) = apply_update_message(world, params, &mut message) {
             error!("unable to apply update message: {e}");
         }
@@ -225,15 +225,15 @@ fn apply_replication(
     // (unless user requested history via marker).
     let update_tick = *world.resource::<ServerUpdateTick>();
     let acks_size =
-        MutateIndex::POSTCARD_MAX_SIZE * client.received_count(ServerChannel::Mutations);
+        MutateIndex::POSTCARD_MAX_SIZE * messages.received_count(ServerChannel::Mutations);
     if acks_size != 0 {
         let mut acks = Vec::with_capacity(acks_size);
-        for message in client.receive(ServerChannel::Mutations) {
+        for message in messages.receive(ServerChannel::Mutations) {
             if let Err(e) = buffer_mutate_message(params, buffered_mutations, message, &mut acks) {
                 error!("unable to buffer mutate message: {e}");
             }
         }
-        client.send(ClientChannel::MutationAcks, acks);
+        messages.send(ClientChannel::MutationAcks, acks);
     }
 
     apply_mutate_messages(world, params, buffered_mutations, update_tick);
@@ -760,7 +760,7 @@ pub enum ClientSet {
     ///
     /// Runs in [`PreUpdate`].
     ReceivePackets,
-    /// Systems that receive data from [`RepliconClient`].
+    /// Systems that read data from [`ClientMessages`].
     ///
     /// Runs in [`PreUpdate`] and [`OnEnter`] for [`ClientState::Connected`] (to avoid 1 frame delay).
     Receive,
@@ -772,7 +772,7 @@ pub enum ClientSet {
     ///
     /// Runs in [`OnEnter`] for [`ClientState::Connected`].
     SendHash,
-    /// Systems that send data to [`RepliconClient`].
+    /// Systems that write data to [`ClientMessages`].
     ///
     /// Runs in [`PostUpdate`].
     Send,

src/client/event.rs

@@ -165,7 +165,7 @@ impl Plugin for ClientEventPlugin {
 fn send(
     events: FilteredResources,
     mut readers: FilteredResourcesMut,
-    mut client: ResMut<RepliconClient>,
+    mut messages: ResMut<ClientMessages>,
     type_registry: Res<AppTypeRegistry>,
     entity_map: Res<ServerEntityMap>,
     event_registry: Res<RemoteEventRegistry>,
@@ -186,15 +186,15 @@ fn send(
 
         // SAFETY: passed pointers were obtained using this event data.
         unsafe {
-            event.send(&mut ctx, &events, reader.into_inner(), &mut client);
+            event.send(&mut ctx, &events, reader.into_inner(), &mut messages);
         }
     }
 }
 
 fn receive(
     mut events: FilteredResourcesMut,
     mut queues: FilteredResourcesMut,
-    mut client: ResMut<RepliconClient>,
+    mut messages: ResMut<ClientMessages>,
     type_registry: Res<AppTypeRegistry>,
     entity_map: Res<ServerEntityMap>,
     event_registry: Res<RemoteEventRegistry>,
@@ -220,7 +220,7 @@ fn receive(
                 &mut ctx,
                 events.into_inner(),
                 queue.into_inner(),
-                &mut client,
+                &mut messages,
                 **update_tick,
             )
         };

src/lib.rs

@@ -711,8 +711,8 @@ pub mod prelude {
             backend::{
                 ClientState, ClientStats, DisconnectRequest, ServerState,
                 channels::{Channel, RepliconChannels},
+                client_messages::ClientMessages,
                 connected_client::ConnectedClient,
-                replicon_client::RepliconClient,
                 replicon_server::RepliconServer,
             },
             client_id::ClientId,

src/shared/backend.rs

@@ -5,7 +5,7 @@
 //! - Create channels defined in the [`RepliconChannels`](channels::RepliconChannels) resource.
 //!   This can be done via an extension trait that provides a conversion which the user needs to call manually to get channels for the backend.
 //! - Manage the [`ClientState`] and [`ServerState`] states.
-//! - Update the [`RepliconServer`](replicon_server::RepliconServer) and [`RepliconClient`](replicon_client::RepliconClient) resources.
+//! - Update the [`RepliconServer`](replicon_server::RepliconServer) and [`ClientMessages`](client_messages::ClientMessages) resources.
 //! - Spawn and despawn entities with [`ConnectedClient`](connected_client::ConnectedClient) component.
 //! - React on [`DisconnectRequest`] event.
 //! - Optionally update statistic in [`ClientStats`] resource and components.
@@ -23,8 +23,8 @@
 //! which we maintain.
 
 pub mod channels;
+pub mod client_messages;
 pub mod connected_client;
-pub mod replicon_client;
 pub mod replicon_server;
 
 use bevy::prelude::*;
@@ -115,18 +115,18 @@ mod tests {
     #[test]
     fn client_to_server() {
         let channels = RepliconChannels::default();
-        let mut client = RepliconClient::default();
-        client.setup_server_channels(channels.server_channels().len());
+        let mut client_messages = ClientMessages::default();
+        client_messages.setup_server_channels(channels.server_channels().len());
 
         const MESSAGES: &[&[u8]] = &[&[0], &[1]];
         for &message in MESSAGES {
-            client.send(ClientChannel::MutationAcks, message);
+            client_messages.send(ClientChannel::MutationAcks, message);
         }
 
         let mut server = RepliconServer::default();
         server.setup_client_channels(channels.client_channels().len());
 
-        for (channel_id, message) in client.drain_sent() {
+        for (channel_id, message) in client_messages.drain_sent() {
             server.insert_received(Entity::PLACEHOLDER, channel_id, message);
         }
 
@@ -148,14 +148,14 @@ mod tests {
             server.send(Entity::PLACEHOLDER, ServerChannel::Mutations, message);
         }
 
-        let mut client = RepliconClient::default();
-        client.setup_server_channels(channels.server_channels().len());
+        let mut client_messages = ClientMessages::default();
+        client_messages.setup_server_channels(channels.server_channels().len());
 
         for (_, channel_id, message) in server.drain_sent() {
-            client.insert_received(channel_id, message);
+            client_messages.insert_received(channel_id, message);
         }
 
-        let messages: Vec<_> = client.receive(ServerChannel::Mutations).collect();
+        let messages: Vec<_> = client_messages.receive(ServerChannel::Mutations).collect();
         assert_eq!(messages, MESSAGES);
     }
 }

src/shared/backend/replicon_client.rs renamed to src/shared/backend/client_messages.rs

@@ -2,19 +2,17 @@ use bevy::prelude::*;
 use bytes::Bytes;
 use log::trace;
 
-/// Stores information about a client independent from the messaging backend.
+/// Sent and received messages for exchange between Replicon and the messaging backend.
 ///
 /// The messaging backend is responsible for updating this resource:
-/// - For receiving messages, [`Self::insert_received`] should be to used.
-///   A system to forward backend messages to Replicon should run in
+/// - Received messages should be forwarded to Replicon via [`Self::insert_received`] in
 ///   [`ClientSet::ReceivePackets`](crate::prelude::ClientSet::ReceivePackets).
-/// - For sending messages, [`Self::drain_sent`] should be used to drain all sent messages.
-///   A system to forward Replicon messages to the backend should run in
+/// - Replicon messages needs to be forwarded to the backend via [`Self::drain_sent`] in
 ///   [`ClientSet::SendPackets`](crate::prelude::ClientSet::SendPackets).
 ///
 /// Inserted as resource by [`ClientPlugin`](crate::prelude::ClientPlugin).
 #[derive(Resource, Default)]
-pub struct RepliconClient {
+pub struct ClientMessages {
     /// List of received messages for each channel.
     ///
     /// Top index is channel ID.
@@ -25,7 +23,7 @@ pub struct RepliconClient {
     sent_messages: Vec<(usize, Bytes)>,
 }
 
-impl RepliconClient {
+impl ClientMessages {
     /// Changes the size of the receive messages storage according to the number of server channels.
     pub(crate) fn setup_server_channels(&mut self, channels_count: usize) {
         self.received_messages.resize(channels_count, Vec::new());

src/shared/event/client_event.rs

@@ -229,9 +229,9 @@ impl ClientEvent {
         ctx: &mut ClientSendCtx,
         events: &Ptr,
         reader: PtrMut,
-        client: &mut RepliconClient,
+        messages: &mut ClientMessages,
     ) {
-        unsafe { (self.send)(self, ctx, events, reader, client) };
+        unsafe { (self.send)(self, ctx, events, reader, messages) };
     }
 
     /// Typed version of [`Self::send`].
@@ -245,7 +245,7 @@ impl ClientEvent {
         ctx: &mut ClientSendCtx,
         events: &Ptr,
         reader: PtrMut,
-        client: &mut RepliconClient,
+        messages: &mut ClientMessages,
     ) {
         let reader: &mut ClientEventReader<E> = unsafe { reader.deref_mut() };
         let events = unsafe { events.deref() };
@@ -260,7 +260,7 @@ impl ClientEvent {
             }
 
             debug!("sending event `{}`", any::type_name::<E>());
-            client.send(self.channel_id, message);
+            messages.send(self.channel_id, message);
         }
     }
 
@@ -418,7 +418,7 @@ impl ClientEvent {
 }
 
 /// Signature of client event sending functions.
-type SendFn = unsafe fn(&ClientEvent, &mut ClientSendCtx, &Ptr, PtrMut, &mut RepliconClient);
+type SendFn = unsafe fn(&ClientEvent, &mut ClientSendCtx, &Ptr, PtrMut, &mut ClientMessages);
 
 /// Signature of client event receiving functions.
 type ReceiveFn = unsafe fn(&ClientEvent, &mut ServerReceiveCtx, PtrMut, &mut RepliconServer);

src/shared/event/server_event.rs

@@ -436,10 +436,10 @@ impl ServerEvent {
         ctx: &mut ClientReceiveCtx,
         events: PtrMut,
         queue: PtrMut,
-        client: &mut RepliconClient,
+        messages: &mut ClientMessages,
         update_tick: RepliconTick,
     ) {
-        unsafe { (self.receive)(self, ctx, events, queue, client, update_tick) }
+        unsafe { (self.receive)(self, ctx, events, queue, messages, update_tick) }
     }
 
     /// Typed version of [`ServerEvent::receive`].
@@ -453,7 +453,7 @@ impl ServerEvent {
         ctx: &mut ClientReceiveCtx,
         events: PtrMut,
         queue: PtrMut,
-        client: &mut RepliconClient,
+        messages: &mut ClientMessages,
         update_tick: RepliconTick,
     ) {
         let events: &mut Events<E> = unsafe { events.deref_mut() };
@@ -477,7 +477,7 @@ impl ServerEvent {
             }
         }
 
-        for mut message in client.receive(self.channel_id) {
+        for mut message in messages.receive(self.channel_id) {
             if !self.independent {
                 let tick = match postcard_utils::from_buf(&mut message) {
                     Ok(tick) => tick,
@@ -644,7 +644,7 @@ type ReceiveFn = unsafe fn(
     &mut ClientReceiveCtx,
     PtrMut,
     PtrMut,
-    &mut RepliconClient,
+    &mut ClientMessages,
     RepliconTick,
 );
 

src/test_app.rs

@@ -135,16 +135,16 @@ impl ServerTestAppExt for App {
 
     fn exchange_with_client(&mut self, client_app: &mut App) {
         let client_entity = **client_app.world().resource::<TestClientEntity>();
-        let mut client = client_app.world_mut().resource_mut::<RepliconClient>();
+        let mut client_messages = client_app.world_mut().resource_mut::<ClientMessages>();
 
         let mut server = self.world_mut().resource_mut::<RepliconServer>();
-        for (channel_id, message) in client.drain_sent() {
+        for (channel_id, message) in client_messages.drain_sent() {
             server.insert_received(client_entity, channel_id, message)
         }
 
         server.retain_sent(|(entity, channel_id, message)| {
             if *entity == client_entity {
-                client.insert_received(*channel_id, message.clone());
+                client_messages.insert_received(*channel_id, message.clone());
                 false
             } else {
                 true