Clients visibility

src/lib.rs

@@ -432,8 +432,9 @@ pub mod prelude {
             NetworkChannels, ReplicationChannel, RepliconCorePlugin,
         },
         server::{
-            clients_info::ClientsInfo, has_authority, ClientEntityMap, ClientMapping, ServerPlugin,
-            ServerSet, TickPolicy, SERVER_ID,
+            clients_info::{client_visibility::ClientVisibility, ClientInfo, ClientsInfo},
+            has_authority, ClientEntityMap, ClientMapping, ServerPlugin, ServerSet, TickPolicy,
+            VisibilityPolicy, SERVER_ID,
         },
         ReplicationPlugins,
     };

src/network_event/server_event.rs

@@ -323,10 +323,7 @@ pub fn send_with<T>(
         }
         SendMode::Direct(client_id) => {
             if client_id != SERVER_ID {
-                if let Some(client_info) = clients_info
-                    .iter()
-                    .find(|client_info| client_info.id() == client_id)
-                {
+                if let Some(client_info) = clients_info.get_client(client_id) {
                     let message = serialize_with(client_info, None, &serialize_fn)?;
                     server.send_message(client_info.id(), channel, message.bytes);
                 }

src/server.rs

@@ -27,7 +27,7 @@ use bevy_renet::{
 use crate::replicon_core::{
     replication_rules::ReplicationRules, replicon_tick::RepliconTick, ReplicationChannel,
 };
-use clients_info::{ClientBuffers, ClientInfo, ClientsInfo};
+use clients_info::{client_visibility::Visibility, ClientBuffers, ClientInfo, ClientsInfo};
 use despawn_buffer::{DespawnBuffer, DespawnBufferPlugin};
 use removal_buffer::{RemovalBuffer, RemovalBufferPlugin};
 use replicated_archetypes_info::ReplicatedArchetypesInfo;
@@ -39,6 +39,9 @@ pub struct ServerPlugin {
     /// Tick configuration.
     pub tick_policy: TickPolicy,
 
+    /// Visibility configuration.
+    pub visibility_policy: VisibilityPolicy,
+
     /// The time after which updates will be considered lost if an acknowledgment is not received for them.
     ///
     /// In practice updates will live at least `update_timeout`, and at most `2*update_timeout`.
@@ -49,6 +52,7 @@ impl Default for ServerPlugin {
     fn default() -> Self {
         Self {
             tick_policy: TickPolicy::MaxTickRate(30),
+            visibility_policy: Default::default(),
             update_timeout: Duration::from_secs(10),
         }
     }
@@ -62,9 +66,9 @@ impl Plugin for ServerPlugin {
             RenetServerPlugin,
             NetcodeServerPlugin,
         ))
-        .init_resource::<ClientsInfo>()
         .init_resource::<ClientBuffers>()
         .init_resource::<ClientEntityMap>()
+        .insert_resource(ClientsInfo::new(self.visibility_policy))
         .configure_sets(PreUpdate, ServerSet::Receive.after(RenetReceive))
         .configure_sets(PostUpdate, ServerSet::Send.before(RenetSend))
         .add_systems(
@@ -291,9 +295,12 @@ fn collect_changes(
         };
 
         for entity in archetype.entities() {
-            for (init_message, update_message) in messages.iter_mut() {
+            for (init_message, update_message, client_info) in messages.iter_mut_with_info() {
                 init_message.start_entity_data(entity.entity());
                 update_message.start_entity_data(entity.entity());
+                client_info
+                    .visibility_mut()
+                    .cache_visibility(entity.entity());
             }
 
             // SAFETY: all replicated archetypes have marker component with table storage.
@@ -326,7 +333,12 @@ fn collect_changes(
 
                 let mut shared_bytes = None;
                 for (init_message, update_message, client_info) in messages.iter_mut_with_info() {
-                    let new_entity = marker_added || client_info.just_connected;
+                    let visibility = client_info.visibility().cached_visibility();
+                    if visibility == Visibility::Hidden {
+                        continue;
+                    }
+
+                    let new_entity = marker_added || visibility == Visibility::Gained;
                     if new_entity || ticks.is_added(change_tick.last_run(), change_tick.this_run())
                     {
                         init_message.write_component(
@@ -352,7 +364,12 @@ fn collect_changes(
             }
 
             for (init_message, update_message, client_info) in messages.iter_mut_with_info() {
-                let new_entity = marker_added || client_info.just_connected;
+                let visibility = client_info.visibility().cached_visibility();
+                if visibility == Visibility::Hidden {
+                    continue;
+                }
+
+                let new_entity = marker_added || visibility == Visibility::Gained;
                 if new_entity || init_message.entity_data_size() != 0 {
                     // If there is any insertion or we must initialize, include all updates into init message
                     // and bump the last acknowledged tick to keep entity updates atomic.
@@ -367,8 +384,7 @@ fn collect_changes(
         }
     }
 
-    for (init_message, _, client_info) in messages.iter_mut_with_info() {
-        client_info.just_connected = false;
+    for (init_message, _) in messages.iter_mut() {
         init_message.end_array()?;
     }
 
@@ -422,7 +438,11 @@ fn collect_despawns(
         }
     }
 
-    for (message, _) in messages.iter_mut() {
+    for (message, _, client_info) in messages.iter_mut_with_info() {
+        for entity in client_info.drain_lost_visibility() {
+            message.write_entity(&mut None, entity)?;
+        }
+
         message.end_array()?;
     }
 
@@ -496,6 +516,18 @@ pub enum TickPolicy {
     Manual,
 }
 
+/// Controls how visibility will be managed via [`ClientVisibility`](clients_info::client_visibility::ClientVisibility).
+#[derive(Default, Debug, Clone, Copy)]
+pub enum VisibilityPolicy {
+    /// All entities are visible by default and visibility can't be changed.
+    #[default]
+    All,
+    /// All entities are hidden by default and should be explicitly registered to be visible.
+    Blacklist,
+    /// All entities are visible by default and should be explicitly registered to be hidden.
+    Whitelist,
+}
+
 /**
 A resource that exists on the server for mapping server entities to
 entities that clients have already spawned. The mappings are sent to clients as part of replication

src/server/clients_info.rs

@@ -1,3 +1,5 @@
+pub mod client_visibility;
+
 use std::mem;
 
 use bevy::{
@@ -7,11 +9,15 @@ use bevy::{
 };
 use bevy_renet::renet::ClientId;
 
-use crate::replicon_core::replicon_tick::RepliconTick;
+use crate::{replicon_core::replicon_tick::RepliconTick, server::VisibilityPolicy};
+use client_visibility::ClientVisibility;
 
 /// Stores meta-information about connected clients.
-#[derive(Default, Resource)]
-pub struct ClientsInfo(Vec<ClientInfo>);
+#[derive(Resource, Default)]
+pub struct ClientsInfo {
+    info: Vec<ClientInfo>,
+    policy: VisibilityPolicy,
+}
 
 /// Reusable buffers for [`ClientsInfo`] and [`ClientInfo`].
 #[derive(Default, Resource)]
@@ -28,19 +34,73 @@ pub(crate) struct ClientBuffers {
 }
 
 impl ClientsInfo {
-    /// Returns an iterator over clients information.
-    pub(crate) fn iter(&self) -> impl Iterator<Item = &ClientInfo> {
-        self.0.iter()
+    pub(super) fn new(policy: VisibilityPolicy) -> Self {
+        Self {
+            info: Default::default(),
+            policy,
+        }
+    }
+
+    /// Returns a reference to a connected client's info.
+    ///
+    /// This operation is *O*(*n*).
+    /// See also [`Self::get_client`] for the fallible version.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the passed client ID is not connected.
+    pub fn client(&self, client_id: ClientId) -> &ClientInfo {
+        self.get_client(client_id)
+            .unwrap_or_else(|| panic!("{client_id:?} should be connected"))
     }
 
-    /// Returns a mutable iterator over clients information.
-    pub(super) fn iter_mut(&mut self) -> impl Iterator<Item = &mut ClientInfo> {
-        self.0.iter_mut()
+    /// Returns a mutable reference to a connected client's info.
+    ///
+    /// This operation is *O*(*n*).
+    /// See also [`Self::get_client_mut`] for the fallible version.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the passed client ID is not connected.
+    pub fn client_mut(&mut self, client_id: ClientId) -> &mut ClientInfo {
+        self.get_client_mut(client_id)
+            .unwrap_or_else(|| panic!("{client_id:?} should be connected"))
     }
 
-    /// Returns number of connected clients.
-    pub(super) fn len(&self) -> usize {
-        self.0.len()
+    /// Returns a reference to a connected client's info.
+    ///
+    /// This operation is *O*(*n*).
+    /// See also [`Self::client`] for the panicking version.
+    pub fn get_client(&self, client_id: ClientId) -> Option<&ClientInfo> {
+        self.info.iter().find(|info| info.id == client_id)
+    }
+
+    /// Returns a mutable reference to a connected client's info.
+    ///
+    /// This operation is *O*(*n*).
+    /// See also [`Self::client`] for the panicking version.
+    pub fn get_client_mut(&mut self, client_id: ClientId) -> Option<&mut ClientInfo> {
+        self.info.iter_mut().find(|info| info.id == client_id)
+    }
+
+    /// Returns an iterator over client information.
+    pub fn iter(&self) -> impl Iterator<Item = &ClientInfo> {
+        self.info.iter()
+    }
+
+    /// Returns a mutable iterator over client information.
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut ClientInfo> {
+        self.info.iter_mut()
+    }
+
+    /// Returns the number of connected clients.
+    pub fn len(&self) -> usize {
+        self.info.len()
+    }
+
+    /// Returns `true` if no clients are connected.
+    pub fn is_empty(&self) -> bool {
+        self.info.is_empty()
     }
 
     /// Initializes a new [`ClientInfo`] for this client.
@@ -51,22 +111,22 @@ impl ClientsInfo {
             client_info.reset(client_id);
             client_info
         } else {
-            ClientInfo::new(client_id)
+            ClientInfo::new(client_id, self.policy)
         };
 
-        self.0.push(client_info);
+        self.info.push(client_info);
     }
 
     /// Removes info for the client.
     ///
     /// Keeps allocated memory in the buffers for reuse.
     pub(super) fn remove(&mut self, client_buffers: &mut ClientBuffers, client_id: ClientId) {
         let index = self
-            .0
+            .info
             .iter()
             .position(|info| info.id == client_id)
             .expect("clients info should contain all connected clients");
-        let mut client_info = self.0.remove(index);
+        let mut client_info = self.info.remove(index);
         client_buffers.entities.extend(client_info.drain_entities());
         client_buffers.info.push(client_info);
     }
@@ -75,23 +135,23 @@ impl ClientsInfo {
     ///
     /// Keeps allocated memory in the buffers for reuse.
     pub(super) fn clear(&mut self, client_buffers: &mut ClientBuffers) {
-        for mut client_info in self.0.drain(..) {
+        for mut client_info in self.info.drain(..) {
             client_buffers.entities.extend(client_info.drain_entities());
             client_buffers.info.push(client_info);
         }
     }
 }
 
-pub(crate) struct ClientInfo {
+pub struct ClientInfo {
     /// Client's ID.
     id: ClientId,
 
-    /// Indicates whether the client connected in this tick.
-    pub(super) just_connected: bool,
-
     /// Lowest tick for use in change detection for each entity.
     ticks: EntityHashMap<Entity, Tick>,
 
+    /// Entity visibility settings.
+    visibility: ClientVisibility,
+
     /// The last tick in which a replicated entity was spawned, despawned, or gained/lost a component from the perspective
     /// of the client.
     ///
@@ -108,11 +168,11 @@ pub(crate) struct ClientInfo {
 }
 
 impl ClientInfo {
-    fn new(id: ClientId) -> Self {
+    fn new(id: ClientId, policy: VisibilityPolicy) -> Self {
         Self {
             id,
-            just_connected: true,
             ticks: Default::default(),
+            visibility: ClientVisibility::new(policy),
             change_tick: Default::default(),
             updates: Default::default(),
             next_update_index: Default::default(),
@@ -124,6 +184,16 @@ impl ClientInfo {
         self.id
     }
 
+    /// Returns a reference to the client's visibility settings.
+    pub fn visibility(&self) -> &ClientVisibility {
+        &self.visibility
+    }
+
+    /// Returns a mutable reference to the client's visibility settings.
+    pub fn visibility_mut(&mut self) -> &mut ClientVisibility {
+        &mut self.visibility
+    }
+
     /// Clears all entities for unacknowledged updates, returning them as an iterator.
     ///
     /// Keeps the allocated memory for reuse.
@@ -138,7 +208,7 @@ impl ClientInfo {
     /// Keeps the allocated memory for reuse.
     fn reset(&mut self, id: ClientId) {
         self.id = id;
-        self.just_connected = true;
+        self.visibility.clear();
         self.ticks.clear();
         self.updates.clear();
         self.next_update_index = 0;
@@ -229,10 +299,20 @@ impl ClientInfo {
     /// Removes a despawned entity tracked by this client.
     pub fn remove_despawned(&mut self, entity: Entity) {
         self.ticks.remove(&entity);
+        self.visibility.remove_despawned(entity);
         // We don't clean up `self.updates` for efficiency reasons.
         // `Self::acknowledge()` will properly ignore despawned entities.
     }
 
+    /// Drains all entities for which visibility was lost during this tick.
+    ///
+    /// Internal cleanup happens lazily during the iteration.
+    pub(super) fn drain_lost_visibility(&mut self) -> impl Iterator<Item = Entity> + '_ {
+        self.visibility.drain_lost_visibility().inspect(|entity| {
+            self.ticks.remove(entity);
+        })
+    }
+
     /// Removes all updates older then `min_timestamp`.
     ///
     /// Keeps allocated memory in the buffers for reuse.