Use built-in ReflectMapEntities

`ReflectMapEntities::map_specific_entity` was added in 0.10.1,
so our custom `ReflectMapEntity` is no longer needed.

Author: Shatur

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- Use `#[reflect(MapEntities)]` from Bevy 0.10.1 instead of custom `#[reflect(MapEntity)]`.
+
 ### Fixed
 
 - Fix tick checks after overflow.

Cargo.toml

@@ -20,7 +20,9 @@ include = ["/src", "/LICENSE*"]
 
 [dependencies]
 bevy_renet = "0.0.7"
-bevy = { version = "0.10", default-features = false, features = ["bevy_scene"] }
+bevy = { version = "0.10.1", default-features = false, features = [
+  "bevy_scene",
+] }
 bincode = "1.3"
 serde = "1.0"
 tap = "1.0"

src/client.rs

@@ -1,7 +1,9 @@
-pub mod map_entity;
-
 use bevy::{
-    ecs::system::{Command, SystemChangeTick},
+    ecs::{
+        entity::{EntityMap, MapEntitiesError},
+        reflect::ReflectMapEntities,
+        system::{Command, SystemChangeTick},
+    },
     prelude::*,
     reflect::TypeRegistryInternal,
     utils::HashMap,
@@ -13,9 +15,8 @@ use serde::{de::DeserializeSeed, Deserialize, Serialize};
 use crate::{
     tick::Tick,
     world_diff::{ComponentDiff, WorldDiff, WorldDiffDeserializer},
-    REPLICATION_CHANNEL_ID,
+    Replication, REPLICATION_CHANNEL_ID,
 };
-use map_entity::{NetworkEntityMap, ReflectMapEntity};
 
 pub struct ClientPlugin;
 
@@ -193,12 +194,63 @@ fn apply_component_diff(
     match component_diff {
         ComponentDiff::Changed(component) => {
             reflect_component.apply_or_insert(&mut world.entity_mut(client_entity), &**component);
-            if let Some(reflect_map_entities) = registration.data::<ReflectMapEntity>() {
+            if let Some(reflect_map_entities) = registration.data::<ReflectMapEntities>() {
                 reflect_map_entities
-                    .map_entities(world, entity_map.to_client(), client_entity)
+                    .map_specific_entities(world, entity_map.to_client(), &[client_entity])
                     .unwrap_or_else(|e| panic!("entities in {type_name} should be mappable: {e}"));
             }
         }
         ComponentDiff::Removed(_) => reflect_component.remove(&mut world.entity_mut(client_entity)),
     }
 }
+
+/// Maps server entities to client entities and vice versa.
+///
+/// Used only on client.
+#[derive(Default, Resource)]
+pub(crate) struct NetworkEntityMap {
+    server_to_client: EntityMap,
+    client_to_server: EntityMap,
+}
+
+impl NetworkEntityMap {
+    #[cfg(test)]
+    pub(crate) fn insert(&mut self, server_entity: Entity, client_entity: Entity) {
+        self.server_to_client.insert(server_entity, client_entity);
+        self.client_to_server.insert(client_entity, server_entity);
+    }
+
+    pub(crate) fn get_by_server_or_spawn(
+        &mut self,
+        world: &mut World,
+        server_entity: Entity,
+    ) -> Entity {
+        *self
+            .server_to_client
+            .entry(server_entity)
+            .or_insert_with(|| {
+                let client_entity = world.spawn(Replication).id();
+                self.client_to_server.insert(client_entity, server_entity);
+                client_entity
+            })
+    }
+
+    pub(crate) fn remove_by_server(
+        &mut self,
+        server_entity: Entity,
+    ) -> Result<Entity, MapEntitiesError> {
+        let client_entity = self.server_to_client.remove(server_entity);
+        if let Some(client_entity) = client_entity {
+            self.client_to_server.remove(client_entity);
+        }
+        client_entity.ok_or(MapEntitiesError::EntityNotFound(server_entity))
+    }
+
+    pub(crate) fn to_client(&self) -> &EntityMap {
+        &self.server_to_client
+    }
+
+    pub(crate) fn to_server(&self) -> &EntityMap {
+        &self.client_to_server
+    }
+}

src/client/map_entity.rs

@@ -72,13 +72,19 @@ This also automatically registers the specified type, so you don't need to call
 If your component contains [`Entity`] then it cannot be deserialized as is
 because entity IDs are different on server and client. The client should do the
 mapping. Therefore, to replicate such components properly, they need implement
-[`bevy::ecs::entity::MapEntities`] and have `#[reflect(MapEntity)]`:
+[`bevy::ecs::entity::MapEntities`] and have `#[reflect(MapEntities)]`:
 
 ```rust
-# use bevy::{prelude::*, ecs::entity::{EntityMap, MapEntities, MapEntitiesError}};
+# use bevy::{
+#     ecs::{
+#         entity::{EntityMap, MapEntities, MapEntitiesError},
+#         reflect::ReflectMapEntities,
+#     },
+#     prelude::*,
+# };
 # use bevy_replicon::prelude::*;
 #[derive(Component, Reflect)]
-#[reflect(Component, MapEntity)]
+#[reflect(Component, MapEntities)]
 struct MappedComponent(Entity);
 
 impl MapEntities for MappedComponent {
@@ -229,8 +235,14 @@ map it before sending it to the server.
 To do this, use [`ClientEventAppExt::add_mapped_client_event()`]:
 
 ```rust
+# use bevy::{
+#     ecs::{
+#         entity::{EntityMap, MapEntities, MapEntitiesError},
+#         reflect::ReflectMapEntities,
+#     },
+#     prelude::*,
+# };
 # use bevy_replicon::prelude::*;
-# use bevy::{prelude::*, ecs::entity::{EntityMap, MapEntities, MapEntitiesError}};
 # use serde::{Deserialize, Serialize};
 # let mut app = App::new();
 # app.add_plugins(ReplicationPlugins);
@@ -343,7 +355,7 @@ mod world_diff;
 
 pub mod prelude {
     pub use super::{
-        client::{map_entity::ReflectMapEntity, ClientPlugin, ClientState},
+        client::{ClientPlugin, ClientState},
         network_event::{
             client_event::{ClientEventAppExt, FromClient},
             server_event::{SendMode, ServerEventAppExt, ToClients},
@@ -378,14 +390,17 @@ impl PluginGroup for ReplicationPlugins {
 #[cfg(test)]
 mod tests {
     use bevy::{
-        ecs::entity::{EntityMap, MapEntities, MapEntitiesError},
+        ecs::{
+            entity::{EntityMap, MapEntities, MapEntitiesError},
+            reflect::ReflectMapEntities,
+        },
         utils::HashMap,
     };
     use bevy_renet::renet::RenetClient;
 
     use super::*;
     use crate::{
-        client::map_entity::{NetworkEntityMap, ReflectMapEntity},
+        client::NetworkEntityMap,
         replication_core::{AppReplicationExt, Replication},
         server::{despawn_tracker::DespawnTracker, removal_tracker::RemovalTracker, AckedTicks},
         test_network::TestNetworkPlugin,
@@ -608,7 +623,7 @@ mod tests {
     }
 
     #[derive(Component, Reflect)]
-    #[reflect(Component, MapEntity)]
+    #[reflect(Component, MapEntities)]
     struct MappedComponent(Entity);
 
     impl MapEntities for MappedComponent {

src/lib.rs

@@ -10,7 +10,7 @@ use tap::TapFallible;
 
 use super::EventChannel;
 use crate::{
-    client::{map_entity::NetworkEntityMap, ClientState},
+    client::{ClientState, NetworkEntityMap},
     prelude::NetworkChannels,
     server::{ServerSet, ServerState, SERVER_ID},
     REPLICATION_CHANNEL_ID,

src/network_event/client_event.rs

@@ -9,7 +9,7 @@ use serde::{de::DeserializeOwned, Serialize};
 
 use super::EventChannel;
 use crate::{
-    client::{map_entity::NetworkEntityMap, ClientState},
+    client::{ClientState, NetworkEntityMap},
     prelude::NetworkChannels,
     server::{ServerSet, ServerState, SERVER_ID},
     REPLICATION_CHANNEL_ID,

src/network_event/server_event.rs

@@ -7,7 +7,7 @@ use bevy::{
     scene,
 };
 
-use crate::prelude::{AppReplicationExt, ReflectMapEntity};
+use crate::AppReplicationExt;
 
 pub struct ParentSyncPlugin;
 
@@ -33,7 +33,7 @@ impl ParentSyncPlugin {
 }
 
 #[derive(Component, Reflect, Clone, Copy)]
-#[reflect(Component, MapEntities, MapEntity)]
+#[reflect(Component, MapEntities)]
 pub struct ParentSync(pub Entity);
 
 // We need to impl either [`FromWorld`] or [`Default`] so [`SyncParent`] can be registered as [`Reflect`].