address comment: remove PatchHistory as required component

Change-Id: Ifda8d3a8b1c843c3ee5300738abf32af88119fa7

Author: Charles Bournhonesque

src/shared/replication/diff.rs

@@ -358,13 +358,20 @@ enum DiffWireRef<'a, C, Patch> {
 pub trait DiffEntityExt {
     /// Applies `patch` to component `C` and records it in the entity's [`PatchHistory`].
     ///
+    /// [`EntityWorldMut`] and [`EntityCommands`] insert missing patch history before
+    /// recording. [`EntityMut`] can't perform structural changes, so it requires an
+    /// existing [`PatchHistory`].
+    ///
     /// For [`EntityCommands`], this queues the patch application. Missing components
     /// or patch application errors are reported when commands are applied.
     fn apply_patch<C: Diffable>(&mut self, patch: C::Patch) -> Result<()>;
 }
 
 impl DiffEntityExt for EntityWorldMut<'_> {
     fn apply_patch<C: Diffable>(&mut self, patch: C::Patch) -> Result<()> {
+        if !self.contains::<PatchHistory<C>>() {
+            self.insert(PatchHistory::<C>::default());
+        }
         let mut entity = self.as_mutable();
         apply_patch_to_entity::<C>(&mut entity, patch)
     }
@@ -378,7 +385,12 @@ impl DiffEntityExt for EntityMut<'_> {
 
 impl DiffEntityExt for EntityCommands<'_> {
     fn apply_patch<C: Diffable>(&mut self, patch: C::Patch) -> Result<()> {
-        self.queue(move |mut entity: EntityWorldMut| entity.apply_patch::<C>(patch));
+        self.queue(move |mut entity: EntityWorldMut| {
+            if !self.contains::<PatchHistory<C>>() {
+                self.insert(PatchHistory::<C>::default());
+            }
+            entity.apply_patch::<C>(patch)
+        });
         Ok(())
     }
 }
@@ -464,7 +476,6 @@ pub(crate) fn register_required_components<C: Diffable>(
     world: &mut World,
     registry: &mut ReplicationRegistry,
 ) -> ComponentId {
-    world.register_required_components::<C, PatchHistory<C>>();
     registry.set_receive_fns::<C>(world, write::<C>, remove::<C>);
     world.register_component::<PatchHistory<C>>()
 }
@@ -609,7 +620,7 @@ pub(crate) fn write<C: Diffable>(
 
 pub(crate) fn remove<C: Diffable>(_ctx: &mut RemoveCtx, entity: &mut DeferredEntity) {
     entity
-        .remove::<C>()
+        .remove_with_requires::<C>()
         .remove::<PatchHistory<C>>()
         .remove::<PatchBuffer<C>>();
 }
@@ -642,4 +653,16 @@ mod tests {
         assert_eq!(batches.first_index(), 1);
         assert!(!batches.is_empty());
     }
+
+    #[test]
+    fn entity_world_mut_apply_patch_inserts_missing_history() {
+        let mut world = World::new();
+        let entity = world.spawn(TestDiff(0)).id();
+
+        world.entity_mut(entity).apply_patch::<TestDiff>(1).unwrap();
+
+        let entity = world.entity(entity);
+        assert_eq!(entity.get::<TestDiff>().unwrap().0, 1);
+        assert!(entity.contains::<PatchHistory<TestDiff>>());
+    }
 }

src/shared/replication/rules.rs

@@ -829,10 +829,7 @@ impl AppRuleExt for App {
     where
         C: Diffable,
     {
-        self.replicate_with_priority_filtered::<_, F>(
-            <RuleFns<C> as IntoComponentRules>::DEFAULT_PRIORITY + F::DEFAULT_PRIORITY,
-            RuleFns::<C>::new_diff(),
-        )
+        self.replicate_with_filtered::<_, F>(RuleFns::<C>::new_diff())
     }
 
     fn replicate_with_priority_filtered<R: IntoComponentRules, F: FilterRules>(