Enum BehaviorEvent

pub enum BehaviorEvent<T: Behavior> {
    Start {
        instance: Instance<T>,
        index: usize,
    },
    Pause {
        instance: Instance<T>,
        index: usize,
    },
    Resume {
        instance: Instance<T>,
        index: usize,
    },
    Stop {
        instance: Instance<T>,
        behavior: T,
    },
    Error {
        instance: Instance<T>,
        error: TransitionError<T>,
    },
}

An event sent during transition to signal Behavior changes.

Usage

Each successful transition results in either a Start, Pause, Resume, or Stop event.

Most events carry the Instance and index of the associated behavior.

This index maybe used with a BehaviorRef or BehaviorMut to access a specific instance of the behavior.

The index can be used to distinguish between different states if:

• More than one variation of the same state exists in the stack, or
• Multiple transitions have ocurred since the last query.

Variants

Start

Sent when a behavior is started.

Fields

instance: Instance<T>

The instance which is running the new behavior.

index: usize

The index of the new behavior.

Pause

Sent when a behavior is paused.

Fields

instance: Instance<T>

The instance which paused this behavior.

index: usize

The index of the paused behavior.

Resume

Sent when a behavior is resumed.

Fields

instance: Instance<T>

The instance which resumed this behavior.

index: usize

The index of the resumed behavior.

Stop

Fields

instance: Instance<T>

The instance which stopped this behavior.

behavior: T

The stopped behavior.

Error

Sent when a behavior transition fails.

Fields

instance: Instance<T>

The instance which failed to transition.

error: TransitionError<T>

Reason for the failure.

Trait Implementations

impl<T: Debug + Behavior> Debug for BehaviorEvent<T>

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

Formats the value using the given formatter.

impl<T: Behavior> Event for BehaviorEvent<T>

where Self: Send + Sync + 'static,

const AUTO_PROPAGATE: bool = false

When true, this event will always attempt to propagate when triggered, without requiring a call to Trigger::propagate.

type Traversal = ()

The component that describes which Entity to propagate this event to next, when propagation is enabled.

fn register_component_id(world: &mut World) -> ComponentId

Generates the ComponentId for this event type.

fn component_id(world: &World) -> Option<ComponentId>

Fetches the ComponentId for this event type, if it has already been generated.

impl<T: PartialEq + Behavior> PartialEq for BehaviorEvent<T>

fn eq(&self, other: &BehaviorEvent<T>) -> 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<T: Behavior> StructuralPartialEq for BehaviorEvent<T>