Struct CollisionEnd

pub struct CollisionEnd {
    pub collider1: Entity,
    pub collider2: Entity,
    pub body1: Option<Entity>,
    pub body2: Option<Entity>,
}

A collision event that is triggered when two colliders stop touching.

The event can be read using a MessageReader or observed using an observer. It is only triggered for entities with the CollisionEventsEnabled component.

Example

Below is an example of observing the CollisionEnd event using an observer.

use avian2d::prelude::*;
use bevy::prelude::*;

#[derive(Component)]
struct Player;

#[derive(Component)]
struct PressurePlate;

fn setup_pressure_plates(mut commands: Commands) {
    commands.spawn((
        PressurePlate,
        Collider::rectangle(1.0, 1.0),
        Sensor,
        // Enable collision events for this entity.
        CollisionEventsEnabled,
    ))
    .observe(on_player_stepped_off_plate);
}

fn on_player_stepped_off_plate(event: On<CollisionEnd>, player_query: Query<&Player>) {
    // `colider1` and `body1` refer to the event target and its body.
    // `collider2` and `body2` refer to the other collider and its body.
    let pressure_plate = event.collider1;
    let other_entity = event.collider2;

    if player_query.contains(other_entity) {
        println!("Player {other_entity} stepped off pressure plate {pressure_plate}");
    }
}

The event can also be read as a Message using a MessageReader. This can be more efficient for processing large numbers of collisions.

fn print_ended_collisions(mut collision_reader: MessageReader<CollisionEnd>) {
    for event in collision_reader.read() {
        println!("{} and {} stopped colliding", event.collider1, event.collider2);
    }
}

Scheduling

The CollisionEnd event is triggered after the physics step in the CollisionEventSystems system set. At this point, the solver has already run and contact impulses have been updated.

Note that if one of the colliders was removed or the bounding boxes of the colliders stopped overlapping, the ContactPair between the entities was also removed, and the contact data will not be available through Collisions.

Fields

collider1: Entity

The entity of the collider that stopped colliding with collider2.

For observers watching this event as an EntityEvent, this is the target entity.

collider2: Entity

The entity of the collider that stopped colliding with collider1.

body1: Option<Entity>

The rigid body that collider1 is attached to.

If the collider is not attached to a rigid body, this will be None.

body2: Option<Entity>

The rigid body that collider2 is attached to.

If the collider is not attached to a rigid body, this will be None.

Trait Implementations

impl Clone for CollisionEnd

fn clone(&self) -> CollisionEnd

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CollisionEnd

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl EntityEvent for CollisionEnd

where Self: Send + Sync + 'static,

fn event_target(&self) -> Entity

The Entity “target” of this EntityEvent. When triggered, this will run observers that watch for this specific entity.

fn event_target_mut(&mut self) -> &mut Entity

Returns a mutable reference to the Entity “target” of this EntityEvent. When triggered, this will run observers that watch for this specific entity.

impl Event for CollisionEnd

where Self: Send + Sync + 'static,

type Trigger<'a> = EntityTrigger

Defines which observers will run, what data will be passed to them, and the order they will be run in. See Trigger for more info.

impl PartialEq for CollisionEnd

fn eq(&self, other: &CollisionEnd) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for CollisionEnd

impl Message for CollisionEnd

where Self: Send + Sync + 'static,

impl StructuralPartialEq for CollisionEnd