713acc2e6d
# Objective The ECS code to do with Observers was recently refactored to use an `EventKey` newtype. On reading through the PR, I was a bit confused that sometimes a variable called `event` refers to an `Event` and sometimes it refers to an `EventKey`. I think the code is clearer when `event` refers to an `Event` and `event_key` refers to an `EventKey`. ## Solution This PR renames some uses of `event` to `event_key`. ## Testing - Did you test these changes? If so, how? I ran `cargo run -p ci -- tests` - Are there any parts that need more testing? No - How can other people (reviewers) test your changes? Is there anything specific they need to know? No. - If relevant, what platforms did you test these changes on, and are there any important ones you can't test? Probably not relevant, but MacOS. --------- Co-authored-by: Steve Alexander <steve.alexander@priva.com>
108 lines
3.5 KiB
Rust
108 lines
3.5 KiB
Rust
//! Logic to track observers when cloning entities.
|
|
|
|
use crate::{
|
|
component::ComponentCloneBehavior,
|
|
entity::{
|
|
CloneByFilter, ComponentCloneCtx, EntityClonerBuilder, EntityMapper, SourceComponent,
|
|
},
|
|
observer::ObservedBy,
|
|
world::World,
|
|
};
|
|
|
|
use super::Observer;
|
|
|
|
impl<Filter: CloneByFilter> EntityClonerBuilder<'_, Filter> {
|
|
/// Sets the option to automatically add cloned entities to the observers targeting source entity.
|
|
pub fn add_observers(&mut self, add_observers: bool) -> &mut Self {
|
|
if add_observers {
|
|
self.override_clone_behavior::<ObservedBy>(ComponentCloneBehavior::Custom(
|
|
component_clone_observed_by,
|
|
))
|
|
} else {
|
|
self.remove_clone_behavior_override::<ObservedBy>()
|
|
}
|
|
}
|
|
}
|
|
|
|
fn component_clone_observed_by(_source: &SourceComponent, ctx: &mut ComponentCloneCtx) {
|
|
let target = ctx.target();
|
|
let source = ctx.source();
|
|
|
|
ctx.queue_deferred(move |world: &mut World, _mapper: &mut dyn EntityMapper| {
|
|
let observed_by = world
|
|
.get::<ObservedBy>(source)
|
|
.map(|observed_by| observed_by.0.clone())
|
|
.expect("Source entity must have ObservedBy");
|
|
|
|
world
|
|
.entity_mut(target)
|
|
.insert(ObservedBy(observed_by.clone()));
|
|
|
|
for observer_entity in observed_by.iter().copied() {
|
|
let mut observer_state = world
|
|
.get_mut::<Observer>(observer_entity)
|
|
.expect("Source observer entity must have Observer");
|
|
observer_state.descriptor.entities.push(target);
|
|
let event_keys = observer_state.descriptor.event_keys.clone();
|
|
let components = observer_state.descriptor.components.clone();
|
|
for event_key in event_keys {
|
|
let observers = world.observers.get_observers_mut(event_key);
|
|
if components.is_empty() {
|
|
if let Some(map) = observers.entity_observers.get(&source).cloned() {
|
|
observers.entity_observers.insert(target, map);
|
|
}
|
|
} else {
|
|
for component in &components {
|
|
let Some(observers) = observers.component_observers.get_mut(component)
|
|
else {
|
|
continue;
|
|
};
|
|
if let Some(map) =
|
|
observers.entity_component_observers.get(&source).cloned()
|
|
{
|
|
observers.entity_component_observers.insert(target, map);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use crate::{
|
|
entity::EntityCloner, event::EntityEvent, observer::On, resource::Resource, system::ResMut,
|
|
world::World,
|
|
};
|
|
|
|
#[derive(Resource, Default)]
|
|
struct Num(usize);
|
|
|
|
#[derive(EntityEvent)]
|
|
struct E;
|
|
|
|
#[test]
|
|
fn clone_entity_with_observer() {
|
|
let mut world = World::default();
|
|
world.init_resource::<Num>();
|
|
|
|
let e = world
|
|
.spawn_empty()
|
|
.observe(|_: On<E>, mut res: ResMut<Num>| res.0 += 1)
|
|
.id();
|
|
world.flush();
|
|
|
|
world.trigger_targets(E, e);
|
|
|
|
let e_clone = world.spawn_empty().id();
|
|
EntityCloner::build_opt_out(&mut world)
|
|
.add_observers(true)
|
|
.clone_entity(e, e_clone);
|
|
|
|
world.trigger_targets(E, [e, e_clone]);
|
|
|
|
assert_eq!(world.resource::<Num>().0, 3);
|
|
}
|
|
}
|