move visibility into send

Change-Id: Ice21174c0c5486b058530a42e4fec421de2ce627

Author: Charles Bournhonesque

Cargo.toml

@@ -93,6 +93,10 @@ harness = false
 name = "mutations"
 required-features = ["client", "server"]
 
+[[test]]
+name = "bidirectional_event"
+required-features = ["client", "server"]
+
 [[test]]
 name = "client_message"
 required-features = ["client", "server"]
@@ -117,6 +121,14 @@ required-features = ["client"]
 name = "insertion"
 required-features = ["client", "server"]
 
+[[test]]
+name = "mutate_ticks"
+required-features = ["client", "server"]
+
+[[test]]
+name = "priority"
+required-features = ["client", "server"]
+
 [[test]]
 name = "removal"
 required-features = ["client", "server"]

src/client.rs

@@ -3,7 +3,8 @@ pub mod diagnostics;
 pub mod message;
 
 pub use crate::shared::replication::receive::{
-    ServerUpdateTick, confirm_history, server_mutate_ticks,
+    ServerUpdateTick, client_replication_stats::ClientReplicationStats, confirm_history,
+    remote::Remote, server_mutate_ticks,
 };
 
 use bevy::prelude::*;
@@ -149,35 +150,3 @@ pub enum ClientSystems {
     /// Runs in [`OnExit`] for [`ClientState::Connected`].
     Reset,
 }
-
-/// Replication stats during message processing.
-///
-/// Statistic will be collected only if the resource is present.
-/// The resource is not added by default.
-///
-/// See also [`ClientDiagnosticsPlugin`]
-/// for automatic integration with Bevy diagnostics.
-#[derive(Resource, Default, Reflect, Debug, Clone, Copy)]
-pub struct ClientReplicationStats {
-    /// Incremented per entity that changes.
-    pub entities_changed: usize,
-    /// Incremented for every component that changes.
-    pub components_changed: usize,
-    /// Incremented per client mapping added.
-    pub mappings: usize,
-    /// Incremented per entity despawn.
-    pub despawns: usize,
-    /// Replication messages received.
-    pub messages: usize,
-    /// Replication bytes received in message payloads (without internal messaging plugin data).
-    pub bytes: usize,
-}
-
-/// Marker for entities spawned by replication.
-///
-/// Automatically inserted for each newly received entity.
-///
-/// See also [`Replicated`].
-#[derive(Component, Default, Reflect, Debug, Clone, Copy)]
-#[reflect(Component)]
-pub struct Remote;

src/lib.rs

@@ -105,7 +105,7 @@ For implementation details see [`ServerChannel`](shared::backend::channels::Serv
 ### Tick rate
 
 By default, updates are not sent every frame in order to save bandwidth. Replication runs
-in [`ServerSystems::Send`] whenever the [`ServerTick`](server::server_tick::ServerTick) resource
+in [`ServerSystems::Send`] whenever the [`ServerTick`](shared::replication::send::server_tick::ServerTick) resource
 changes and if the state is [`ServerState::Running`].
 
 By default, the tick is incremented in [`FixedPostUpdate`] each time [`FixedMain`](bevy::app::FixedMain)
@@ -283,6 +283,8 @@ These messages will appear on server as [`FromClient`] wrapper message that
 contains sender ID and the message.
 
 ```
+# #[cfg(all(feature = "client", feature = "server"))]
+# {
 # use bevy::{prelude::*, state::app::StatesPlugin};
 # use bevy_replicon::prelude::*;
 # use serde::{Deserialize, Serialize};
@@ -312,6 +314,7 @@ fn receive(mut pings: MessageReader<FromClient<Ping>>) {
 
 #[derive(Message, Deserialize, Serialize)]
 struct Ping;
+# }
 ```
 
 If a message contains an entity, implement
@@ -327,6 +330,8 @@ Alternatively, you can use events with a similar API. First, you need to registe
 using [`ClientEventAppExt::add_client_event`], and then use [`ClientTriggerExt::client_trigger`].
 
 ```
+# #[cfg(all(feature = "client", feature = "server"))]
+# {
 # use bevy::{prelude::*, state::app::StatesPlugin};
 # use bevy_replicon::prelude::*;
 # use serde::{Deserialize, Serialize};
@@ -345,6 +350,7 @@ fn receive(ping: On<FromClient<Ping>>) {
 }
 # #[derive(Event, Deserialize, Serialize)]
 # struct Ping;
+# }
 ```
 
 For events with entities inside use [`ClientEventAppExt::add_mapped_client_event`].
@@ -358,6 +364,8 @@ and send it from server using [`ToClients`]. This wrapper contains send paramete
 and the message itself.
 
 ```
+# #[cfg(all(feature = "client", feature = "server"))]
+# {
 # use bevy::{prelude::*, state::app::StatesPlugin};
 # use bevy_replicon::prelude::*;
 # use serde::{Deserialize, Serialize};
@@ -390,6 +398,7 @@ fn receive(mut pongs: MessageReader<Pong>) {
 
 #[derive(Message, Deserialize, Serialize)]
 struct Pong;
+# }
 ```
 
 Just like for client messages, we provide [`ServerMessageAppExt::add_mapped_server_message`]
@@ -727,11 +736,13 @@ pub mod prelude {
 
     #[cfg(feature = "server")]
     #[expect(deprecated, reason = "Re-export of deprecated aliases")]
-    pub use super::server::{
-        AuthorizedClient, PriorityMap, ServerPlugin, ServerSystems,
-        message::ServerMessagePlugin,
-        visibility::{
-            AppVisibilityExt, ComponentScope, FilterScope, SingleComponent, VisibilityFilter,
+    pub use super::{
+        server::{AuthorizedClient, ServerPlugin, ServerSystems, message::ServerMessagePlugin},
+        shared::replication::send::{
+            priority_map::PriorityMap,
+            visibility::{
+                AppVisibilityExt, ComponentScope, FilterScope, SingleComponent, VisibilityFilter,
+            },
         },
     };
 

src/server.rs

@@ -1,11 +1,9 @@
 pub mod message;
-pub mod server_tick;
-pub mod visibility;
 
 use core::time::Duration;
 
 use bevy::{
-    ecs::{entity::EntityHashMap, intern::Interned, schedule::ScheduleLabel},
+    ecs::{intern::Interned, schedule::ScheduleLabel},
     platform::collections::HashSet,
     prelude::*,
     time::common_conditions::on_timer,
@@ -14,10 +12,6 @@ use log::{Level, debug, log_enabled, trace};
 
 use crate::{
     prelude::*,
-    server::{
-        server_tick::ServerTick, visibility::client_visibility::ClientVisibility,
-        visibility::registry::FilterRegistry,
-    },
     shared::{
         message::server_message::message_buffer::MessageBuffer,
         replication::{
@@ -28,14 +22,18 @@ use crate::{
                 client_pools::ClientPools,
                 client_ticks::ClientTicks,
                 collect_changes, collect_despawns, collect_mappings, collect_removals,
-                prepare_messages, receive_acks,
+                prepare_messages,
+                priority_map::PriorityMap,
+                receive_acks,
                 related_entities::RelatedEntities,
                 removal_buffer::RemovalBuffer,
                 replicated_archetypes::ReplicatedArchetypes,
                 replication_messages::{
                     mutations::Mutations, serialized_data::SerializedData, updates::Updates,
                 },
                 send_messages,
+                server_tick::ServerTick,
+                visibility::{client_visibility::ClientVisibility, registry::FilterRegistry},
             },
         },
     },
@@ -315,26 +313,3 @@ pub enum ServerSystems {
 #[component(immutable)]
 #[require(ClientTicks, ClientVisibility, PriorityMap, Updates, Mutations)]
 pub struct AuthorizedClient;
-
-/// Controls how often mutations are sent for an authorized client.
-///
-/// Associates entities with a priority number configurable by the user.
-/// If the priority is not set, it defaults to 1.0.
-///
-/// During replication, we multiply the difference between the last acknowledged tick
-/// and [`ServerTick`] by the priority. If the result is greater than or equal to 1.0,
-/// we send mutations for this entity.
-///
-/// This means the priority accumulates across server ticks until an entity is acknowledged,
-/// at which point its priority is reset. As a result, even low-priority objects eventually
-/// reach a high enough priority to be considered for replication.
-///
-/// For example, if the base priority is 0.5, mutations for an entity will be sent
-/// no more often than once every 2 ticks. With the default priority of 1.0,
-/// all unacknowledged mutations will be sent every tick.
-///
-/// All of this only affects mutations. For any component insertion or removal, the changes
-/// will be sent using [`ServerChannel::Updates`](crate::shared::backend::channels::ServerChannel::Updates).
-/// See its documentation for more details.
-#[derive(Component, Reflect, Deref, DerefMut, Default, Debug, Clone)]
-pub struct PriorityMap(EntityHashMap<f32>);

src/server/message.rs

@@ -3,15 +3,14 @@ use bevy::{
     prelude::*,
 };
 
-use super::server_tick::ServerTick;
 use crate::{
     prelude::*,
     shared::message::{
         ctx::{ServerReceiveCtx, ServerSendCtx},
         registry::RemoteMessageRegistry,
         server_message::message_buffer::MessageBuffer,
     },
-    shared::replication::send::client_ticks::ClientTicks,
+    shared::replication::send::{client_ticks::ClientTicks, server_tick::ServerTick},
 };
 
 /// Sending messages and events from the server to clients.

src/shared.rs

@@ -30,6 +30,8 @@ pub struct RepliconSharedPlugin {
     [`AuthMethod::ProtocolCheck`], but it could be any event.
 
     ```
+    # #[cfg(feature = "server")]
+    # {
     use bevy::{prelude::*, state::app::StatesPlugin};
     use bevy_replicon::prelude::*;
     use serde::{Deserialize, Serialize};
@@ -93,6 +95,7 @@ pub struct RepliconSharedPlugin {
         protocol: ProtocolHash,
         player_name: String,
     }
+    # }
     ```
     **/
     pub auth_method: AuthMethod,

src/shared/replication/receive.rs

@@ -1,4 +1,6 @@
+pub mod client_replication_stats;
 pub mod confirm_history;
+pub mod remote;
 pub mod server_mutate_ticks;
 
 use bevy::prelude::*;
@@ -7,7 +9,6 @@ use log::{debug, error, trace};
 use postcard::experimental::max_size::MaxSize;
 
 use crate::{
-    client::{ClientReplicationStats, Remote},
     postcard_utils,
     prelude::*,
     shared::{
@@ -26,7 +27,9 @@ use crate::{
         server_entity_map::{EntityEntry, ServerEntityMap},
     },
 };
+use client_replication_stats::ClientReplicationStats;
 use confirm_history::{ConfirmHistory, EntityReplicated};
+use remote::Remote;
 use server_mutate_ticks::{MutateTickReceived, ServerMutateTicks};
 
 /// Receives and applies replication messages from the server.

src/shared/replication/receive/client_replication_stats.rs

@@ -0,0 +1,24 @@
+use bevy::prelude::*;
+
+/// Replication stats during message processing.
+///
+/// Statistic will be collected only if the resource is present.
+/// The resource is not added by default.
+///
+/// See also [`ClientDiagnosticsPlugin`](crate::client::diagnostics::ClientDiagnosticsPlugin)
+/// for automatic integration with Bevy diagnostics.
+#[derive(Resource, Default, Reflect, Debug, Clone, Copy)]
+pub struct ClientReplicationStats {
+    /// Incremented per entity that changes.
+    pub entities_changed: usize,
+    /// Incremented for every component that changes.
+    pub components_changed: usize,
+    /// Incremented per client mapping added.
+    pub mappings: usize,
+    /// Incremented per entity despawn.
+    pub despawns: usize,
+    /// Replication messages received.
+    pub messages: usize,
+    /// Replication bytes received in message payloads (without internal messaging plugin data).
+    pub bytes: usize,
+}

src/shared/replication/receive/remote.rs

@@ -0,0 +1,10 @@
+use bevy::prelude::*;
+
+/// Marker for entities spawned by replication.
+///
+/// Automatically inserted for each newly received entity.
+///
+/// See also [`Replicated`](crate::shared::replication::Replicated).
+#[derive(Component, Default, Reflect, Debug, Clone, Copy)]
+#[reflect(Component)]
+pub struct Remote;

src/shared/replication/registry/test_fns.rs

@@ -34,13 +34,15 @@ use bevy_replicon::{
             test_fns::TestFnsEntityExt, ReplicationRegistry,
         },
         replicon_tick::RepliconTick,
+        server_entity_map::ServerEntityMap,
     },
     prelude::*,
 };
 use serde::{Deserialize, Serialize};
 
 let mut app = App::new();
-app.add_plugins((MinimalPlugins, StatesPlugin, RepliconPlugins));
+app.add_plugins((MinimalPlugins, StatesPlugin, RepliconPlugins))
+    .init_resource::<ServerEntityMap>();
 
 let tick = RepliconTick::default();