Rework messages serialization

CHANGELOG.md

@@ -9,10 +9,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- Various optimizations for replication messages to use fewer bytes.
+- Accept `Vec<u8>` instead of `Cursor<Vec<u8>>` for serialization.
 - All `TestFnsEntityExt` now accept `FnsId`.
 - Move replication-related modules from `core` module under `core::replication`.
 - Move `Replicated` to the `replication` module.
 - Split the `ctx` module and move event-related contexts under `core::events_registry::ctx` and replication-related contexts under `core::replication_registry::ctx`.
+- Rename `ServerPlugin::change_timeout` into `ServerPlugin::mutations_timeout`.
+- Rename `ServerInitTick` into `ServerChangeTick`.
+- Rename `ReplicatedClient::init_tick` into `ReplicatedClient::change_tick`.
+- Rename `ReplicatedClient::get_change_tick` into `ReplicatedClient::mutation_tick`.
+- Rename `ReplicationChannel::Init` into `ReplicationChannel::Changes`.
+- Rename `ReplicationChannel::Update` into `ReplicationChannel::Mutations`.
 
 ### Removed
 

Cargo.toml

@@ -31,6 +31,7 @@ bincode = "1.3"
 serde = "1.0"
 integer-encoding = "4.0"
 ordered-multimap = "0.7"
+bitflags = "2.6"
 
 [dev-dependencies]
 bevy = { version = "0.14", default-features = false, features = [
@@ -66,7 +67,7 @@ name = "replication"
 harness = false
 
 [[test]]
-name = "changes"
+name = "mutations"
 required-features = ["client", "server"]
 
 [[test]]

benches/replication.rs

@@ -49,7 +49,7 @@ fn replication<C: Component + Default + Serialize + DeserializeOwned + Clone>(c:
     name = &name[MODULE_PREFIX_LEN..];
 
     for clients in [1, 20] {
-        c.bench_function(&format!("{name}, init send, {clients} client(s)"), |b| {
+        c.bench_function(&format!("{name}, changes send, {clients} client(s)"), |b| {
             b.iter_custom(|iter| {
                 let mut elapsed = Duration::ZERO;
                 for _ in 0..iter {
@@ -82,53 +82,56 @@ fn replication<C: Component + Default + Serialize + DeserializeOwned + Clone>(c:
             })
         });
 
-        c.bench_function(&format!("{name}, update send, {clients} client(s)"), |b| {
-            b.iter_custom(|iter| {
-                let mut server_app = create_app::<C>();
-                let mut client_apps = Vec::new();
-                for _ in 0..clients {
-                    client_apps.push(create_app::<C>());
-                }
-
-                for client_app in &mut client_apps {
-                    server_app.connect_client(client_app);
-                }
-
-                server_app
-                    .world_mut()
-                    .spawn_batch(vec![(Replicated, C::default()); ENTITIES as usize]);
-                let mut query = server_app.world_mut().query::<&mut C>();
-
-                server_app.update();
-                for client_app in &mut client_apps {
-                    server_app.exchange_with_client(client_app);
-                    client_app.update();
-                    assert_eq!(client_app.world().entities().len(), ENTITIES);
-                }
+        c.bench_function(
+            &format!("{name}, mutations send, {clients} client(s)"),
+            |b| {
+                b.iter_custom(|iter| {
+                    let mut server_app = create_app::<C>();
+                    let mut client_apps = Vec::new();
+                    for _ in 0..clients {
+                        client_apps.push(create_app::<C>());
+                    }
 
-                let mut elapsed = Duration::ZERO;
-                for _ in 0..iter {
-                    for mut component in query.iter_mut(server_app.world_mut()) {
-                        component.set_changed();
+                    for client_app in &mut client_apps {
+                        server_app.connect_client(client_app);
                     }
 
-                    let instant = Instant::now();
-                    server_app.update();
-                    elapsed += instant.elapsed();
+                    server_app
+                        .world_mut()
+                        .spawn_batch(vec![(Replicated, C::default()); ENTITIES as usize]);
+                    let mut query = server_app.world_mut().query::<&mut C>();
 
+                    server_app.update();
                     for client_app in &mut client_apps {
                         server_app.exchange_with_client(client_app);
                         client_app.update();
                         assert_eq!(client_app.world().entities().len(), ENTITIES);
                     }
-                }
 
-                elapsed
-            })
-        });
+                    let mut elapsed = Duration::ZERO;
+                    for _ in 0..iter {
+                        for mut component in query.iter_mut(server_app.world_mut()) {
+                            component.set_changed();
+                        }
+
+                        let instant = Instant::now();
+                        server_app.update();
+                        elapsed += instant.elapsed();
+
+                        for client_app in &mut client_apps {
+                            server_app.exchange_with_client(client_app);
+                            client_app.update();
+                            assert_eq!(client_app.world().entities().len(), ENTITIES);
+                        }
+                    }
+
+                    elapsed
+                })
+            },
+        );
     }
 
-    c.bench_function(&format!("{name}, init receive"), |b| {
+    c.bench_function(&format!("{name}, changes receive"), |b| {
         b.iter_custom(|iter| {
             let mut elapsed = Duration::ZERO;
             for _ in 0..iter {
@@ -154,7 +157,7 @@ fn replication<C: Component + Default + Serialize + DeserializeOwned + Clone>(c:
         })
     });
 
-    c.bench_function(&format!("{name}, update receive"), |b| {
+    c.bench_function(&format!("{name}, mutations receive"), |b| {
         b.iter_custom(|iter| {
             let mut server_app = create_app::<C>();
             let mut client_app = create_app::<C>();