Struct ActionDiffEvent

pub struct ActionDiffEvent<A: Actionlike> {
    pub owner: Option<Entity>,
    pub action_diffs: Vec<ActionDiff<A>>,
}

Will store an ActionDiff as well as what generated it (either an Entity, or nothing if the input actions are represented by a Resource)

These are typically accessed using the Events<ActionDiffEvent> resource.

Fields

owner: Option<Entity>

If some: the entity that has the ActionState<A> component If none: ActionState<A> is a Resource, not a component

action_diffs: Vec<ActionDiff<A>>

The ActionDiff that was generated

Trait Implementations

impl<A: Clone + Actionlike> Clone for ActionDiffEvent<A>

fn clone(&self) -> ActionDiffEvent<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Actionlike> Debug for ActionDiffEvent<A>

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

Formats the value using the given formatter.

impl<'de, A> Deserialize<'de> for ActionDiffEvent<A>

where A: Deserialize<'de> + Actionlike,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A: Actionlike> Event for ActionDiffEvent<A>

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<A: Actionlike> MapEntities for ActionDiffEvent<A>

Implements entity mapping for ActionDiffEvent.

This allows the owner entity to be remapped when transferring event diffs between different ECS worlds (e.g. client and server).

fn map_entities<M: EntityMapper>(&mut self, entity_mapper: &mut M)

Updates all Entity references stored inside using entity_mapper.

impl<A: PartialEq + Actionlike> PartialEq for ActionDiffEvent<A>

fn eq(&self, other: &ActionDiffEvent<A>) -> 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<A> Serialize for ActionDiffEvent<A>

where A: Serialize + Actionlike,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<A: Actionlike> StructuralPartialEq for ActionDiffEvent<A>