can reflect observers

crates/bevy_ecs/src/reflect/event.rs

@@ -5,7 +5,15 @@
 //!
 //! Same as [`component`](`super::component`), but for events.
 
-use crate::{event::Event, reflect::from_reflect_with_fallback, world::World};
+use alloc::boxed::Box;
+
+use crate::{
+    entity::Entity,
+    event::Event,
+    observer::{Observer, On},
+    reflect::from_reflect_with_fallback,
+    world::World,
+};
 use bevy_reflect::{FromReflect, FromType, PartialReflect, Reflect, TypePath, TypeRegistry};
 
 /// A struct used to operate on reflected [`Event`] trait of a type.
@@ -37,6 +45,11 @@ pub struct ReflectEvent(ReflectEventFns);
 pub struct ReflectEventFns {
     /// Function pointer implementing [`ReflectEvent::trigger`].
     pub trigger: fn(&mut World, &dyn PartialReflect, &TypeRegistry),
+    /// Function pointer implementing [`ReflectEvent::observe`].
+    pub observe: fn(&mut World, Box<dyn Fn(&dyn PartialReflect) + Send + Sync>) -> Entity,
+    /// Function pointer implementing [`ReflectEvent::observe_entity`].
+    pub observe_entity:
+        fn(&mut World, Entity, Box<dyn Fn(&dyn PartialReflect) + Send + Sync>) -> Entity,
 }
 
 impl ReflectEventFns {
@@ -59,6 +72,25 @@ impl ReflectEvent {
         (self.0.trigger)(world, event, registry);
     }
 
+    /// Registers a global [`Observer`] for this event type.
+    pub fn observe(
+        &self,
+        world: &mut World,
+        callback: Box<dyn Fn(&dyn PartialReflect) + Send + Sync>,
+    ) -> Entity {
+        (self.0.observe)(world, callback)
+    }
+
+    /// Registers an entity-scoped [`Observer`] for this event type.
+    pub fn observe_entity(
+        &self,
+        world: &mut World,
+        entity: Entity,
+        callback: Box<dyn Fn(&dyn PartialReflect) + Send + Sync>,
+    ) -> Entity {
+        (self.0.observe_entity)(world, entity, callback)
+    }
+
     /// Create a custom implementation of [`ReflectEvent`].
     ///
     /// This is an advanced feature,
@@ -105,6 +137,20 @@ where
                 let event = from_reflect_with_fallback::<E>(reflected_event, world, registry);
                 world.trigger(event);
             },
+            observe: |world, callback| {
+                world
+                    .add_observer(move |event: On<E>| {
+                        callback((*event).as_partial_reflect());
+                    })
+                    .id()
+            },
+            observe_entity: |world, entity, callback| {
+                let observer = Observer::new(move |event: On<E>| {
+                    callback((*event).as_partial_reflect());
+                })
+                .with_entity(entity);
+                world.spawn(observer).id()
+            },
         })
     }
 }