move more server stuff in send to avoid feature bounds

Change-Id: Ica56566aeab40df4ab18f299e9eb91313668e0fa

Author: Charles Bournhonesque

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`](shared::replication::send::server_tick::ServerTick) resource
+in [`SendSystems::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)
@@ -294,7 +294,7 @@ app.add_client_message::<Ping>(Channel::Ordered)
     .add_systems(
         PreUpdate,
         receive
-            .after(ServerSystems::Receive)
+            .after(SendSystems::Receive)
             .run_if(in_state(ServerState::Running)),
     )
     .add_systems(
@@ -380,7 +380,7 @@ app.add_server_message::<Pong>(Channel::Ordered)
     )
     .add_systems(
         PostUpdate,
-        send.before(ServerSystems::Send).run_if(in_state(ServerState::Running)),
+        send.before(SendSystems::Send).run_if(in_state(ServerState::Running)),
     );
 
 fn send(mut pongs: MessageWriter<ToClients<Pong>>) {
@@ -499,8 +499,8 @@ For server messages we drain [`ToClients<E>`] and, if the [`ClientId::Server`] i
 re-emit it as `E` locally. The same applies to the event API. This emulates message receiving for both server
 and singleplayer without actually transmitting data over the network.
 
-We also provide [`ClientSystems`] and [`ServerSystems`] to schedule your system at specific time in the frame.
-For example, you can run your systems right after receive using [`ClientSystems::Receive`] or [`ServerSystems::Receive`].
+We also provide [`ClientSystems`] and [`SendSystems`] to schedule your system at specific time in the frame.
+For example, you can run your systems right after receive using [`ClientSystems::Receive`] or [`SendSystems::Receive`].
 
 ## Organizing your game code
 
@@ -722,7 +722,6 @@ pub mod prelude {
                 receive_markers::AppMarkerExt,
                 registry::rule_fns::RuleFns,
                 rules::{AppRuleExt, component::ReplicationMode},
-                send::related_entities::SyncRelatedAppExt,
                 signature::Signature,
             },
             replicon_tick::RepliconTick,
@@ -734,18 +733,20 @@ pub mod prelude {
         ClientPlugin, ClientReplicationStats, ClientSystems, Remote, message::ClientMessagePlugin,
     };
 
-    #[cfg(feature = "server")]
-    #[expect(deprecated, reason = "Re-export of deprecated aliases")]
-    pub use super::{
-        server::{AuthorizedClient, ServerPlugin, ServerSystems, message::ServerMessagePlugin},
-        shared::replication::send::{
-            priority_map::PriorityMap,
-            visibility::{
-                AppVisibilityExt, ComponentScope, FilterScope, SingleComponent, VisibilityFilter,
-            },
+    #[expect(deprecated, reason = "Re-export of deprecated alias")]
+    pub use super::shared::replication::send::{
+        AuthorizedClient, SendSystems,
+        priority_map::PriorityMap,
+        related_entities::SyncRelatedAppExt,
+        server_tick::ServerTick,
+        visibility::{
+            AppVisibilityExt, ComponentScope, FilterScope, SingleComponent, VisibilityFilter,
         },
     };
 
+    #[cfg(feature = "server")]
+    pub use super::server::{ServerPlugin, message::ServerMessagePlugin};
+
     #[cfg(feature = "client_diagnostics")]
     pub use super::client::diagnostics::ClientDiagnosticsPlugin;
 }

src/server.rs

@@ -8,7 +8,7 @@ use bevy::{
     prelude::*,
     time::common_conditions::on_timer,
 };
-use log::{Level, debug, log_enabled, trace};
+use log::{Level, debug, log_enabled};
 
 use crate::{
     prelude::*,
@@ -17,23 +17,14 @@ use crate::{
         replication::{
             rules::ReplicationRules,
             send::{
-                DespawnBuffer, ServerChangeTick, buffer_despawn, buffer_removals,
-                check_mutation_ticks, cleanup_acks,
-                client_pools::ClientPools,
-                client_ticks::ClientTicks,
-                collect_changes, collect_despawns, collect_mappings, collect_removals,
-                prepare_messages,
-                priority_map::PriorityMap,
-                receive_acks,
-                related_entities::RelatedEntities,
-                removal_buffer::RemovalBuffer,
+                self, AuthorizedClient, DespawnBuffer, SendSystems, ServerChangeTick,
+                buffer_despawn, buffer_removals, check_mutation_ticks, cleanup_acks,
+                client_pools::ClientPools, collect_changes, collect_despawns, collect_mappings,
+                collect_removals, increment_tick, prepare_messages, 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},
+                replication_messages::serialized_data::SerializedData, send_messages,
+                server_tick::ServerTick, visibility::registry::FilterRegistry,
             },
         },
     },
@@ -109,14 +100,14 @@ impl Plugin for ServerPlugin {
             .init_resource::<FilterRegistry>()
             .configure_sets(
                 PreUpdate,
-                (ServerSystems::ReceivePackets, ServerSystems::Receive).chain(),
+                (SendSystems::ReceivePackets, SendSystems::Receive).chain(),
             )
             .configure_sets(
                 PostUpdate,
                 (
-                    ServerSystems::IncrementTick,
-                    ServerSystems::Send,
-                    ServerSystems::SendPackets,
+                    SendSystems::IncrementTick,
+                    SendSystems::Send,
+                    SendSystems::SendPackets,
                 )
                     .chain(),
             )
@@ -131,10 +122,10 @@ impl Plugin for ServerPlugin {
                     cleanup_acks(self.mutations_timeout).run_if(on_timer(self.mutations_timeout)),
                 )
                     .chain()
-                    .in_set(ServerSystems::Receive)
+                    .in_set(SendSystems::Receive)
                     .run_if(in_state(ServerState::Running)),
             )
-            .add_systems(OnExit(ServerState::Running), reset)
+            .add_systems(OnExit(ServerState::Running), send::reset)
             .add_systems(
                 PostUpdate,
                 (
@@ -147,7 +138,7 @@ impl Plugin for ServerPlugin {
                 )
                     .chain()
                     .run_if(resource_changed::<ServerTick>)
-                    .in_set(ServerSystems::Send)
+                    .in_set(SendSystems::Send)
                     .run_if(in_state(ServerState::Running)),
             );
 
@@ -156,7 +147,7 @@ impl Plugin for ServerPlugin {
             app.add_systems(
                 tick_schedule,
                 increment_tick
-                    .in_set(ServerSystems::IncrementTick)
+                    .in_set(SendSystems::IncrementTick)
                     .run_if(in_state(ServerState::Running)),
             );
         }
@@ -242,74 +233,3 @@ fn check_protocol(
         disconnects.write(DisconnectRequest { client });
     }
 }
-
-/// Increments current server tick which causes the server to replicate this frame.
-pub fn increment_tick(mut server_tick: ResMut<ServerTick>) {
-    trace!("incrementing `{:?}`", *server_tick);
-    server_tick.increment();
-}
-
-fn reset(
-    mut commands: Commands,
-    mut messages: ResMut<ServerMessages>,
-    mut server_tick: ResMut<ServerTick>,
-    mut related_entities: ResMut<RelatedEntities>,
-    clients: Query<Entity, With<ConnectedClient>>,
-    mut message_buffer: ResMut<MessageBuffer>,
-) {
-    messages.clear();
-    *server_tick = Default::default();
-    message_buffer.clear();
-    related_entities.clear();
-    for client in &clients {
-        commands.entity(client).despawn();
-    }
-}
-
-/// Set with replication and event systems related to server.
-#[derive(SystemSet, Debug, Hash, PartialEq, Eq, Clone, Copy)]
-pub enum ServerSystems {
-    /// Systems that receive packets from the messaging backend and update [`ServerState`].
-    ///
-    /// Used by the messaging backend.
-    ///
-    /// Runs in [`PreUpdate`].
-    ReceivePackets,
-    /// Systems that read data from [`ServerMessages`].
-    ///
-    /// Runs in [`PreUpdate`].
-    Receive,
-    /// Systems that build the initial graph with all related entities registered via
-    /// [`crate::shared::replication::send::related_entities::SyncRelatedAppExt::sync_related_entities`].
-    ///
-    /// The graph is kept in sync with observers.
-    ///
-    /// Runs in [`OnEnter`] for [`ServerState::Running`].
-    ReadRelations,
-    /// System that increments [`ServerTick`].
-    ///
-    /// Runs in [`ServerPlugin::tick_schedule`].
-    IncrementTick,
-    /// Systems that write data to [`ServerMessages`].
-    ///
-    /// Runs in [`PostUpdate`] if [`ServerTick`] changes.
-    Send,
-    /// Systems that send packets to the messaging backend.
-    ///
-    /// Used by the messaging backend.
-    ///
-    /// Runs in [`PostUpdate`] if [`ServerTick`] changes.
-    SendPackets,
-}
-
-/// Marker that enables replication and all events for a client.
-///
-/// Until authorization happened, the client and server can still exchange network events that are marked as
-/// independent via [`ServerMessageAppExt::make_message_independent`] or [`ServerEventAppExt::make_event_independent`].
-/// **All other events will be ignored**.
-///
-/// See also [`ConnectedClient`] and [`RepliconSharedPlugin::auth_method`].
-#[derive(Component, Reflect, Default)]
-#[component(immutable)]
-#[require(ClientTicks, ClientVisibility, PriorityMap, Updates, Mutations)]
-pub struct AuthorizedClient;

src/server/message.rs

@@ -10,7 +10,9 @@ use crate::{
         registry::RemoteMessageRegistry,
         server_message::message_buffer::MessageBuffer,
     },
-    shared::replication::send::{client_ticks::ClientTicks, server_tick::ServerTick},
+    shared::replication::send::{
+        self, SendSystems, client_ticks::ClientTicks, server_tick::ServerTick,
+    },
 };
 
 /// Sending messages and events from the server to clients.
@@ -94,7 +96,7 @@ impl Plugin for ServerMessagePlugin {
                     trigger_fn.run_if(in_state(ClientState::Disconnected)),
                 )
                     .chain()
-                    .in_set(ServerSystems::Receive),
+                    .in_set(SendSystems::Receive),
             )
             .add_systems(
                 PostUpdate,
@@ -106,8 +108,8 @@ impl Plugin for ServerMessagePlugin {
                     send_locally_fn.run_if(in_state(ClientState::Disconnected)),
                 )
                     .chain()
-                    .after(super::send_messages)
-                    .in_set(ServerSystems::Send),
+                    .after(send::send_messages)
+                    .in_set(SendSystems::Send),
             );
     }
 }

src/shared.rs

@@ -16,6 +16,7 @@ use replication::{
     receive_markers::ReceiveMarkers, registry::ReplicationRegistry, rules::ReplicationRules,
     track_mutate_messages::TrackMutateMessages,
 };
+use server_entity_map::ServerEntityMap;
 
 /// Initializes types, resources and events needed for both client and server.
 #[derive(Default)]
@@ -30,8 +31,6 @@ 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};
@@ -95,7 +94,6 @@ pub struct RepliconSharedPlugin {
         protocol: ProtocolHash,
         player_name: String,
     }
-    # }
     ```
     **/
     pub auth_method: AuthMethod,
@@ -107,6 +105,7 @@ impl Plugin for RepliconSharedPlugin {
             .init_state::<ServerState>()
             .init_resource::<ProtocolHasher>()
             .init_resource::<NetworkIdMap>()
+            .init_resource::<ServerEntityMap>()
             .init_resource::<TrackMutateMessages>()
             .init_resource::<RepliconChannels>()
             .init_resource::<ReplicationRegistry>()

src/shared/backend.rs

@@ -53,7 +53,7 @@ pub enum ClientState {
 /// <div class="warning">
 ///
 /// Should only be changed from the messaging backend when the server changes its state
-/// in [`ServerSystems::ReceivePackets`](crate::server::ServerSystems::ReceivePackets).
+/// in [`SendSystems::ReceivePackets`](crate::prelude::SendSystems::ReceivePackets).
 ///
 /// </div>
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, Default, States)]

src/shared/backend/server_messages.rs

@@ -6,9 +6,9 @@ use log::trace;
 ///
 /// The messaging backend is responsible for updating this resource:
 /// - Received messages should be forwarded to Replicon via [`Self::insert_received`] in
-///   [`ServerSystems::ReceivePackets`](crate::prelude::ServerSystems::ReceivePackets).
+///   [`SendSystems::ReceivePackets`](crate::prelude::SendSystems::ReceivePackets).
 /// - Replicon messages needs to be forwarded to the backend via [`Self::drain_sent`] in
-///   [`ServerSystems::SendPackets`](crate::prelude::ServerSystems::SendPackets).
+///   [`SendSystems::SendPackets`](crate::prelude::SendSystems::SendPackets).
 ///
 /// Inserted as resource by [`ServerPlugin`](crate::server::ServerPlugin).
 #[derive(Resource, Default)]

src/shared/replication/registry/test_fns.rs

@@ -34,15 +34,13 @@ 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))
-    .init_resource::<ServerEntityMap>();
+app.add_plugins((MinimalPlugins, StatesPlugin, RepliconPlugins));
 
 let tick = RepliconTick::default();