feat(ecs): emit Removed events before component removal

1 files changed, 89 insertions, 17 deletions

diff --git a/ecs/src/actions.rs b/ecs/src/actions.rs
index ba3ced5..f8a59fa 100644
--- a/ecs/src/actions.rs
+++ b/ecs/src/actions.rs
@@ -1,7 +1,10 @@
+use std::any::type_name;
 use std::marker::PhantomData;
 use std::rc::{Rc, Weak};
 
 use crate::component::{Parts as ComponentParts, Sequence as ComponentSequence};
+use crate::event::component::Removed;
+use crate::pair::Pair;
 use crate::system::{Metadata as SystemMetadata, Param as SystemParam};
 use crate::uid::{Kind as UidKind, Uid};
 use crate::{ActionQueue, World};
@@ -11,10 +14,10 @@ use crate::{ActionQueue, World};
 pub struct Actions<'world>
 {
     action_queue: &'world ActionQueue,
-    action_queue_weak: Weak<ActionQueue>,
+    world: Option<&'world World>,
 }
 
-impl<'world> Actions<'world>
+impl Actions<'_>
 {
     /// Queues up a entity to spawn at the end of the current tick, returning the [`Uid`]
     /// that the entity will have.
@@ -35,6 +38,31 @@ impl<'world> Actions<'world>
     {
         debug_assert_eq!(entity_uid.kind(), UidKind::Entity);
 
+        let Some(world) = self.world else {
+            self.action_queue.push(Action::Despawn(entity_uid));
+            return;
+        };
+
+        let Some(ent) = world.get_entity(entity_uid) else {
+            tracing::warn!("Cannot entity that doesn't exist");
+            return;
+        };
+
+        // TODO: Submit all events with a single function call to reduce overhead
+        for comp_id in ent.component_ids() {
+            if comp_id.kind() == UidKind::Pair {
+                continue;
+            }
+
+            world.event_submitter().submit_event(
+                &Pair::builder()
+                    .relation::<Removed>()
+                    .target_id(comp_id)
+                    .build(),
+                entity_uid,
+            );
+        }
+
         self.action_queue.push(Action::Despawn(entity_uid));
     }
 
@@ -56,6 +84,7 @@ impl<'world> Actions<'world>
     }
 
     /// Queues up removing component(s) from a entity at the end of the current tick.
+    #[tracing::instrument(skip(self, component_ids))]
     pub fn remove_components(
         &mut self,
         entity_uid: Uid,
@@ -70,10 +99,44 @@ impl<'world> Actions<'world>
             return;
         }
 
-        self.action_queue.push(Action::RemoveComponents(
-            entity_uid,
-            component_ids.collect(),
-        ));
+        let Some(world) = self.world else {
+            self.action_queue.push(Action::RemoveComponents(
+                entity_uid,
+                component_ids.collect(),
+            ));
+            return;
+        };
+
+        let Some(ent) = world.get_entity(entity_uid) else {
+            tracing::warn!("Cannot remove components from entity that doesn't exist");
+            return;
+        };
+
+        let component_ids = component_ids
+            .filter(|comp_id| ent.has_component(*comp_id))
+            .collect::<Vec<_>>();
+
+        if component_ids.is_empty() {
+            return;
+        }
+
+        // TODO: Submit all events with a single function call to reduce overhead
+        for comp_id in &component_ids {
+            if comp_id.kind() == UidKind::Pair {
+                continue;
+            }
+
+            world.event_submitter().submit_event(
+                &Pair::builder()
+                    .relation::<Removed>()
+                    .target_id(*comp_id)
+                    .build(),
+                entity_uid,
+            );
+        }
+
+        self.action_queue
+            .push(Action::RemoveComponents(entity_uid, component_ids));
     }
 
     /// Stops the [`World`]. The world will finish the current tick and that tick will be
@@ -86,19 +149,22 @@ impl<'world> Actions<'world>
     /// Returns a struct which holds a weak reference to the [`World`] that `Actions`
     /// references and that can be used to aquire a new `Actions` instance if the
     /// referenced [`World`] is still alive.
+    ///
+    /// # Panics
+    /// This function will panic if `self` was retrieved from a [`WeakRef`].
     #[must_use]
     pub fn to_weak_ref(&self) -> WeakRef
     {
-        WeakRef {
-            action_queue: self.action_queue_weak.clone(),
-        }
-    }
+        let world = self.world.unwrap_or_else(|| {
+            panic!(
+                "This function cannot be called if the {} was retrieved from a {}",
+                type_name::<Self>(),
+                type_name::<WeakRef>()
+            )
+        });
 
-    fn new(action_queue: &'world Rc<ActionQueue>) -> Self
-    {
-        Self {
-            action_queue,
-            action_queue_weak: Rc::downgrade(action_queue),
+        WeakRef {
+            action_queue: Rc::downgrade(&world.data.action_queue),
         }
     }
 }
@@ -109,7 +175,10 @@ impl<'world> SystemParam<'world> for Actions<'world>
 
     fn new(world: &'world World, _system_metadata: &SystemMetadata) -> Self
     {
-        Self::new(&world.data.action_queue)
+        Self {
+            action_queue: &world.data.action_queue,
+            world: Some(world),
+        }
     }
 }
 
@@ -148,7 +217,10 @@ impl Ref<'_>
     #[must_use]
     pub fn to_actions(&self) -> Actions<'_>
     {
-        Actions::new(&self.action_queue)
+        Actions {
+            action_queue: &self.action_queue,
+            world: None,
+        }
     }
 }