Rename replicate_into_scene into replicate_into

And move it to `scene` module since it's not directly related
to server and isn't used inside it.

Author: Shatur

CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - Use `EntityHashMap` instead of `HashMap` with entities as keys.
+- Rename `replicate_into_scene` into `replicate_into` and move it to `scene` module.
 
 ## [0.17.0] - 2023-11-13
 

src/lib.rs

@@ -200,7 +200,7 @@ struct Player;
 ```
 
 This pairs nicely with server state serialization and keeps saves clean.
-You can use [`replicate_into_scene`](server::replicate_into_scene) to
+You can use [`replicate_into`](scene::replicate_into) to
 fill `DynamicScene` with replicated entities and their components.
 
 The mentioned [`Ignored<T>`] component is an exception.
@@ -388,6 +388,7 @@ pub mod client;
 pub mod network_event;
 pub mod parent_sync;
 pub mod replicon_core;
+pub mod scene;
 pub mod server;
 
 pub mod prelude {

src/scene.rs

@@ -0,0 +1,102 @@
+use bevy::{ecs::archetype::ArchetypeId, prelude::*, scene::DynamicEntity};
+
+use crate::replicon_core::replication_rules::ReplicationRules;
+
+/**
+Fills scene with all replicated entities and their components.
+
+Entities won't have the [`Replication`](crate::replicon_core::replication_rules::Replication) component.
+So on deserialization you need to insert it back if you want entities to continue to replicate.
+
+# Panics
+
+Panics if any replicated component is not registered using `register_type()`
+or `#[reflect(Component)]` is missing.
+
+# Examples
+
+```
+use bevy::{prelude::*, scene::serde::SceneDeserializer};
+use bevy_replicon::{prelude::*, scene};
+use serde::de::DeserializeSeed;
+# let mut world = World::new();
+# world.init_resource::<AppTypeRegistry>();
+# world.init_resource::<ReplicationRules>();
+
+// Serialization
+let registry = world.resource::<AppTypeRegistry>();
+let mut scene = DynamicScene::default();
+scene::replicate_into(&mut scene, &world);
+let scene = scene
+    .serialize_ron(&registry)
+    .expect("scene should be serialized");
+
+// Deserialization
+let scene_deserializer = SceneDeserializer {
+    type_registry: &registry.read(),
+};
+let mut deserializer =
+    ron::Deserializer::from_str(&scene).expect("scene should be serialized as valid ron");
+let mut scene = scene_deserializer
+    .deserialize(&mut deserializer)
+    .expect("ron should be convertible to scene");
+
+// All saved entities should have `Replication` component.
+for entity in &mut scene.entities {
+    entity.components.push(Replication.clone_value());
+}
+```
+*/
+pub fn replicate_into(scene: &mut DynamicScene, world: &World) {
+    let registry = world.resource::<AppTypeRegistry>();
+    let replication_rules = world.resource::<ReplicationRules>();
+
+    let registry = registry.read();
+    for archetype in world
+        .archetypes()
+        .iter()
+        .filter(|archetype| archetype.id() != ArchetypeId::EMPTY)
+        .filter(|archetype| archetype.id() != ArchetypeId::INVALID)
+        .filter(|archetype| archetype.contains(replication_rules.get_marker_id()))
+    {
+        let entities_offset = scene.entities.len();
+        for archetype_entity in archetype.entities() {
+            scene.entities.push(DynamicEntity {
+                entity: archetype_entity.entity(),
+                components: Vec::new(),
+            });
+        }
+
+        for component_id in archetype.components() {
+            let Some((_, replication_info)) = replication_rules.get(component_id) else {
+                continue;
+            };
+            if archetype.contains(replication_info.ignored_id) {
+                continue;
+            }
+
+            // SAFETY: `component_info` obtained from the world.
+            let component_info = unsafe { world.components().get_info_unchecked(component_id) };
+            let type_name = component_info.name();
+            let type_id = component_info
+                .type_id()
+                .unwrap_or_else(|| panic!("{type_name} should have registered TypeId"));
+            let registration = registry
+                .get(type_id)
+                .unwrap_or_else(|| panic!("{type_name} should be registered"));
+            let reflect_component = registration
+                .data::<ReflectComponent>()
+                .unwrap_or_else(|| panic!("{type_name} should have reflect(Component)"));
+
+            for (index, archetype_entity) in archetype.entities().iter().enumerate() {
+                let component = reflect_component
+                    .reflect(world.entity(archetype_entity.entity()))
+                    .unwrap_or_else(|| panic!("entity should have {type_name}"));
+
+                scene.entities[entities_offset + index]
+                    .components
+                    .push(component.clone_value());
+            }
+        }
+    }
+}

src/server.rs

@@ -11,7 +11,6 @@ use bevy::{
         system::SystemChangeTick,
     },
     prelude::*,
-    scene::DynamicEntity,
     time::common_conditions::on_timer,
     utils::HashMap,
 };
@@ -475,105 +474,6 @@ impl AckedTicks {
 #[derive(Clone, Copy, Debug, Default, Deref, DerefMut, Resource)]
 pub(super) struct MinRepliconTick(RepliconTick);
 
-/**
-Fills scene with all replicated entities and their components.
-
-Entities won't have the [`Replication`](crate::replicon_core::replication_rules::Replication) component.
-So on deserialization you need to insert it back if you want entities to continue to replicate.
-
-# Panics
-
-Panics if any replicated component is not registered using `register_type()`
-or `#[reflect(Component)]` is missing.
-
-# Examples
-
-```
-use bevy::{prelude::*, scene::serde::SceneDeserializer};
-use bevy_replicon::{prelude::*, server};
-use serde::de::DeserializeSeed;
-# let mut world = World::new();
-# world.init_resource::<AppTypeRegistry>();
-# world.init_resource::<ReplicationRules>();
-
-// Serialization
-let registry = world.resource::<AppTypeRegistry>();
-let mut scene = DynamicScene::default();
-server::replicate_into_scene(&mut scene, &world);
-let scene = scene
-    .serialize_ron(&registry)
-    .expect("scene should be serialized");
-
-// Deserialization
-let scene_deserializer = SceneDeserializer {
-    type_registry: &registry.read(),
-};
-let mut deserializer =
-    ron::Deserializer::from_str(&scene).expect("scene should be serialized as valid ron");
-let mut scene = scene_deserializer
-    .deserialize(&mut deserializer)
-    .expect("ron should be convertible to scene");
-
-// All saved entities should have `Replication` component.
-for entity in &mut scene.entities {
-    entity.components.push(Replication.clone_value());
-}
-```
-*/
-pub fn replicate_into_scene(scene: &mut DynamicScene, world: &World) {
-    let registry = world.resource::<AppTypeRegistry>();
-    let replication_rules = world.resource::<ReplicationRules>();
-
-    let registry = registry.read();
-    for archetype in world
-        .archetypes()
-        .iter()
-        .filter(|archetype| archetype.id() != ArchetypeId::EMPTY)
-        .filter(|archetype| archetype.id() != ArchetypeId::INVALID)
-        .filter(|archetype| archetype.contains(replication_rules.get_marker_id()))
-    {
-        let entities_offset = scene.entities.len();
-        for archetype_entity in archetype.entities() {
-            scene.entities.push(DynamicEntity {
-                entity: archetype_entity.entity(),
-                components: Vec::new(),
-            });
-        }
-
-        for component_id in archetype.components() {
-            let Some((_, replication_info)) = replication_rules.get(component_id) else {
-                continue;
-            };
-            if archetype.contains(replication_info.ignored_id) {
-                continue;
-            }
-
-            // SAFETY: `component_info` obtained from the world.
-            let component_info = unsafe { world.components().get_info_unchecked(component_id) };
-            let type_name = component_info.name();
-            let type_id = component_info
-                .type_id()
-                .unwrap_or_else(|| panic!("{type_name} should have registered TypeId"));
-            let registration = registry
-                .get(type_id)
-                .unwrap_or_else(|| panic!("{type_name} should be registered"));
-            let reflect_component = registration
-                .data::<ReflectComponent>()
-                .unwrap_or_else(|| panic!("{type_name} should have reflect(Component)"));
-
-            for (index, archetype_entity) in archetype.entities().iter().enumerate() {
-                let component = reflect_component
-                    .reflect(world.entity(archetype_entity.entity()))
-                    .unwrap_or_else(|| panic!("entity should have {type_name}"));
-
-                scene.entities[entities_offset + index]
-                    .components
-                    .push(component.clone_value());
-            }
-        }
-    }
-}
-
 /**
 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

tests/replication.rs

@@ -1,7 +1,7 @@
 mod common;
 
 use bevy::prelude::*;
-use bevy_replicon::{prelude::*, server};
+use bevy_replicon::{prelude::*, scene};
 
 use bevy_renet::renet::{transport::NetcodeClientTransport, ClientId};
 use serde::{Deserialize, Serialize};
@@ -305,7 +305,7 @@ fn replication_into_scene() {
         .id();
 
     let mut scene = DynamicScene::default();
-    server::replicate_into_scene(&mut scene, &app.world);
+    scene::replicate_into(&mut scene, &app.world);
 
     assert!(scene.resources.is_empty());