Struct EntityComponentsTrigger 

pub struct EntityComponentsTrigger<'a> {
    pub components: &'a [ComponentId],
    pub old_archetype: Option<&'a Archetype>,
    pub new_archetype: Option<&'a Archetype>,
}

An EntityEvent Trigger that, in addition to behaving like a normal EntityTrigger, also runs observers that watch for components that match the slice of ComponentIds referenced in EntityComponentsTrigger. This includes both global observers of those components and “entity scoped” observers that watch the EntityEvent::event_target.

This is used by Bevy’s built-in lifecycle events.

Fields

components: &'a [ComponentId]

All of the components whose observers were triggered together for the target entity. For example, if components A and B are added together, producing the Add event, this will contain the ComponentId for both A and B.

old_archetype: Option<&'a Archetype>

The Archetype of the target entity before this change, or None if the entity was just spawned. For observers that run before the change, like Discard and Remove, this will be the current archetype.

This can be useful in Insert and Add observers, since the old archetype will not include any other components added at the same time.

Note that None should usually be treated the same as an archetype with no components, since spawning an entity should be equivalent to spawning an empty entity and then inserting all components.

Example

fn on_add_disable(
    on: On<Add, Disabled>,
    mut cache: ResMut<EntitiesWithA>,
    a_component: ComponentIdFor<A>,
) {
    // The `A` component may have been added at the same time as `Disabled`,
    // either due to an insert or spawn.  Only try to remove this entity from
    // our cache if the `A` component was in the old archetype.
    if on.trigger().old_archetype.is_some_and(|a| a.contains(*a_component)) {
        cache.0.remove(&on.entity);
    }
}

new_archetype: Option<&'a Archetype>

The Archetype of the target entity after this change, or None if the entity will be despawned. For observers that run after the change, like Insert and Add, this will be the current archetype.

This can be useful in Discard and Remove observers, since the new archetype will not include any other components removed at the same time.

Note that None should usually be treated the same as an archetype with no components, since despawning an entity should be equivalent to removing all its components and then despawning the empty entity.

Example

fn on_remove_disable(
    on: On<Remove, Disabled>,
    mut cache: ResMut<EntitiesWithA>,
    a_component: ComponentIdFor<A>,
) {
    // The `A` component may have been removed at the same time as `Disabled`,
    // either due to a remove or despawn.  Only try to add this entity to our
    // cache if the `A` component is still in the new archetype.
    if on.trigger().new_archetype.is_some_and(|a| a.contains(*a_component)) {
        cache.0.insert(on.entity);
    }
}

Trait Implementations

impl<'a> Default for EntityComponentsTrigger<'a>

fn default() -> EntityComponentsTrigger<'a>

Returns the “default value” for a type.

impl<'a, E> Trigger<E> for EntityComponentsTrigger<'a>

where E: EntityEvent<Trigger<'a> = EntityComponentsTrigger<'a>> + Event,

unsafe fn trigger( &mut self, world: DeferredWorld<'_>, observers: &CachedObservers, trigger_context: &TriggerContext, event: &mut E, )

Trigger the given event, running every Observer that matches the event, as defined by this Trigger and the state stored on self.