Struct ActionState 

pub struct ActionState<A: ActionLike> { /* private fields */ }

Sim-side gameplay input: fed from repose events each frame, read by fixed-step systems each tick. Edges (just_pressed/just_released) clear at the END of each tick (end_tick, registered last), so compose-fed events survive until the tick’s systems run. Frame-scope readers call clear_edges after consuming.

Implementations

impl<A: ActionLike> ActionState<A>

pub fn new(map: ActionMap<A>) -> Self

pub fn map(&self) -> &ActionMap<A>

pub fn end_tick(&mut self)

Edge rollover for the tick end: edges clear, levels persist. Frame-scope readers use clear_edges instead.

pub fn clear_edges(&mut self)

Clear edges outside the schedule (after frame-scope consumption).

pub fn set_contexts(&mut self, contexts: &[&str])

Switch the active context set (phase gating, e.g. menu vs play). Empty set with contexts defined means only context-free actions fire. Pending edges drop only when the set actually changes: re-setting the same contexts every frame (the normal pump pattern) keeps them. Levels (pressed) always track hardware truthfully.

pub fn key(&mut self, chord: &KeyChord, down: bool)

Feed a keyboard chord press/release from the runner.

pub fn mouse(&mut self, button: PointerButton, down: bool)

Feed a mouse button press/release.

pub fn pad(&mut self, button: GamepadButton, down: bool)

Feed a gamepad button press/release.

pub fn axis(&mut self, axis: GamepadAxis, value: f32)

Feed an axis value; threshold bindings flip on crossing.

pub fn axis_value(&self, axis: GamepadAxis) -> f32

Latest value for an axis (0.0 if never fed).

pub fn pressed(&self, action: &A) -> bool

Held (and live in the active context, not consumed).

pub fn just_pressed(&self, action: &A) -> bool

Started this tick (and live in the active context, not consumed).

pub fn just_released(&self, action: &A) -> bool

Released this tick.

pub fn consume(&mut self, action: &A) -> bool

Swallow an action so later readers skip it (UI consumed the click). Returns true while the action is held.

pub fn consume_all(&mut self)

pub fn mock(&mut self, action: &A, down: bool)

Drive an action without hardware (cutscenes, AI, tests).

pub fn clear_consumed(&mut self)

Clear consumption (fresh frame handoff from UI).

Trait Implementations

impl<A: ActionLike> Component for ActionState<A>

where Self: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::SparseSet

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have Component<Mutability = Mutable>, while immutable components will instead have Component<Mutability = Immutable>.

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn relationship_accessor() -> Option<ComponentRelationshipAccessor<Self>>

Returns ComponentRelationshipAccessor required for working with relationships in dynamic contexts.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

fn on_discard() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_discard ComponentHook for this Component if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]

impl<A: Debug + ActionLike> Debug for ActionState<A>

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

Formats the value using the given formatter.

impl<A: ActionLike> Resource for ActionState<A>

where Self: Send + Sync + 'static,