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. Re-evaluates every action bound to this axis with OR semantics, so a second binding holding the action keeps it pressed.

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

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

This is the raw deflection in -1..1 (sticks) or 0..1 (triggers), with no threshold or deadzone applied. Use ActionState::strength for the per-action intensity with thresholds applied.

pub fn strength(&self, action: &A) -> f32

Intensity of an action, from 0.0 (inactive) to 1.0 (fully held).

For button bindings (key, mouse, pad) the value is 0 or 1. For axis bindings it is the stick deflection |value| clamped to 0..1, so the further the stick is pushed past its threshold, the closer the value is to 1. When several bindings drive one action, the strongest active binding wins.

Returns 0.0 while the action is gated out by its context or has been consumed, matching pressed.

In most cases where you need a direction (twin-stick movement, menus), use vector instead of combining strengths by hand.

pub fn vector( &self, neg_x: &A, pos_x: &A, neg_y: &A, pos_y: &A, deadzone: f32, ) -> (f32, f32)

Movement vector from four actions: (x, y) with x = strength(pos_x) - strength(neg_x) and y = strength(pos_y) - strength(neg_y).

This is useful for vector input such as a joystick, d-pad, arrows, or WASD driving movement. The result has a circular deadzone and its length limited to 1, so diagonal input never moves faster than axis-aligned input:

• Lengths below deadzone (range 0..1) snap to (0, 0), which keeps a resting stick from drifting the player. Use 0.2 for a standard stick feel, 0.0 to disable.
• Lengths above 1 (opposite pairs can’t exceed this, but two full-strength diagonals can in theory) are normalized back to 1.

Note: y follows screen convention (pos_y is down-positive). For world-up movement, negate y or swap the pair at the call site.

let (x, y) = state.vector(&MoveLeft, &MoveRight, &MoveUp, &MoveDown, 0.2);
player.vel = Vec2::new(x, y) * SPEED;

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

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

Returns true for every tick while any of the action’s bindings is held down. Actions gated out by set_contexts or hidden by consume read as released here even while the hardware is held. The level below keeps tracking the hardware truthfully, so re-entering the context (or clear_consumed) reports held again without a new press.

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

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

Returns true only on the tick the action was pressed: the edge is set by the press event and cleared at the end of the tick by end_tick, so holding the button does not re-trigger it. If several ticks run in one frame, only systems in the first tick observe the edge.

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

Released this tick (and live in the active context, not consumed). Same gating as pressed/just_pressed, so context-gated and UI-consumed releases never leak to late readers.

Returns true only on the tick the last held binding was released (see the OR release rule in the module docs). Like just_pressed, the edge clears at end_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,