From 09981e0173a2427264e432226804292c91e1f920 Mon Sep 17 00:00:00 2001
From: HampusM <hampus@hampusmat.com>
Date: Tue, 26 Aug 2025 16:43:40 +0200
Subject: feat(ecs): add component changed event

---
 ecs/src/component.rs | 59 ++++++++++++++++++++++++++++++----------------------
 1 file changed, 34 insertions(+), 25 deletions(-)

(limited to 'ecs/src/component.rs')

diff --git a/ecs/src/component.rs b/ecs/src/component.rs
index 8f946f0..9e3975f 100644
--- a/ecs/src/component.rs
+++ b/ecs/src/component.rs
@@ -4,6 +4,8 @@ use std::ops::{Deref, DerefMut};
 
 use seq_macro::seq;
 
+use crate::event::component::OnChanged;
+use crate::event::Submitter as EventSubmitter;
 use crate::lock::{
     Error as LockError,
     MappedReadGuard,
@@ -11,10 +13,11 @@ use crate::lock::{
     ReadGuard,
     WriteGuard,
 };
+use crate::pair::Pair;
 use crate::system::Input as SystemInput;
 use crate::uid::Uid;
 use crate::util::Array;
-use crate::EntityComponentRef;
+use crate::{EntityComponentRef, World};
 
 pub mod local;
 
@@ -69,12 +72,12 @@ pub trait Sequence
 }
 
 #[derive(Debug)]
-pub struct Handle<'a, ComponentData: 'static>
+pub struct Handle<'a, DataT: 'static>
 {
-    inner: MappedReadGuard<'a, ComponentData>,
+    inner: MappedReadGuard<'a, DataT>,
 }
 
-impl<'comp, ComponentData: 'static> Handle<'comp, ComponentData>
+impl<'comp, DataT: 'static> Handle<'comp, DataT>
 {
     /// Creates a new handle instance from a [`EntityComponentRef`].
     ///
@@ -96,16 +99,16 @@ impl<'comp, ComponentData: 'static> Handle<'comp, ComponentData>
     {
         Ok(Self {
             inner: ReadGuard::try_map(inner, |component| {
-                component.downcast_ref::<ComponentData>()
+                component.downcast_ref::<DataT>()
             })
             .map_err(|_| HandleError::IncorrectType)?,
         })
     }
 }
 
-impl<ComponentData: 'static> Deref for Handle<'_, ComponentData>
+impl<DataT: 'static> Deref for Handle<'_, DataT>
 {
-    type Target = ComponentData;
+    type Target = DataT;
 
     fn deref(&self) -> &Self::Target
     {
@@ -114,12 +117,14 @@ impl<ComponentData: 'static> Deref for Handle<'_, ComponentData>
 }
 
 #[derive(Debug)]
-pub struct HandleMut<'a, ComponentData: 'static>
+pub struct HandleMut<'a, DataT: 'static>
 {
-    inner: MappedWriteGuard<'a, ComponentData>,
+    entity_component_ref: EntityComponentRef<'a>,
+    inner: MappedWriteGuard<'a, DataT>,
+    event_submitter: EventSubmitter<'a>,
 }
 
-impl<'comp, ComponentData: 'static> HandleMut<'comp, ComponentData>
+impl<'comp, DataT: 'static> HandleMut<'comp, DataT>
 {
     /// Creates a new handle instance from a [`EntityComponentRef`].
     ///
@@ -127,32 +132,36 @@ impl<'comp, ComponentData: 'static> HandleMut<'comp, ComponentData>
     /// Will return `Err` if acquiring the component's lock fails.
     pub fn from_entity_component_ref(
         entity_component_ref: &EntityComponentRef<'comp>,
+        world: &'comp World,
     ) -> Result<Self, HandleError>
     {
-        Self::new(
-            entity_component_ref
-                .component()
-                .write_nonblock()
-                .map_err(AcquireLockError)?,
-        )
-    }
+        let inner = entity_component_ref
+            .component()
+            .write_nonblock()
+            .map_err(AcquireLockError)?;
 
-    // TODO: Make this function private
-    pub(crate) fn new(inner: WriteGuard<'comp, Box<dyn Any>>)
-        -> Result<Self, HandleError>
-    {
         Ok(Self {
+            entity_component_ref: entity_component_ref.clone(),
             inner: WriteGuard::try_map(inner, |component| {
-                component.downcast_mut::<ComponentData>()
+                component.downcast_mut::<DataT>()
             })
             .map_err(|_| HandleError::IncorrectType)?,
+            event_submitter: world.event_submitter(),
         })
     }
+
+    pub fn set_changed(&self)
+    {
+        self.event_submitter.submit_event(
+            &Pair::new::<OnChanged>(self.entity_component_ref.id()),
+            self.entity_component_ref.entity_id(),
+        );
+    }
 }
 
-impl<ComponentData: 'static> Deref for HandleMut<'_, ComponentData>
+impl<DataT: 'static> Deref for HandleMut<'_, DataT>
 {
-    type Target = ComponentData;
+    type Target = DataT;
 
     fn deref(&self) -> &Self::Target
     {
@@ -160,7 +169,7 @@ impl<ComponentData: 'static> Deref for HandleMut<'_, ComponentData>
     }
 }
 
-impl<ComponentData: 'static> DerefMut for HandleMut<'_, ComponentData>
+impl<DataT: 'static> DerefMut for HandleMut<'_, DataT>
 {
     fn deref_mut(&mut self) -> &mut Self::Target
     {
-- 
cgit v1.2.3-18-g5258