Struct ActionState 

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

Sim-side gameplay input fed from repose events, read per tick. Edges clear at tick end via end_tick (registered last). 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 replace_map(&mut self, map: ActionMap<A>)

pub fn end_tick(&mut self)

Edge rollover for tick end: edges clear, levels persist.

pub fn clear_edges(&mut self)

Clear edges outside the schedule.

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

Switch the active context set. Pending edges drop on change; re-setting the same set keeps them. Levels track hardware.

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

Feed a keyboard chord press/release.

pub fn physical(&mut self, key: PhysicalKey, down: bool)

Feed a physical key position press/release.

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 raw value fed for an axis (0.0 if not fed).

Raw deflection in -1..1 (sticks) or 0..1 (triggers), no threshold applied.

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

Intensity from 0.0 (inactive) to 1.0 (held). Buttons read 0/1; axes remap threshold..1 to 0..1. Strongest binding wins. Gated or consumed actions read 0.0.

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. Lengths below deadzone snap to zero; lengths above 1 normalize back. y is screen convention (down-positive).

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

Held, live, and not consumed. True each tick a binding is down.

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

Started this tick. Edge set on press, cleared at end_tick.

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

Released this tick. Clears at end_tick like just_pressed.

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

Mark consumed so later readers skip it. Returns true while held.

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

Take a press edge once: first caller per tick gets true, later callers get false. Held state is untouched, so pressed() keeps reading true while the binding is down. Edges clear in end_tick like just_pressed.

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

Take a release edge once: first caller per tick gets true, later callers get false. Clears in end_tick like just_released.

pub fn consume_all(&mut self)

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

Drive an action without hardware.

pub fn clear_consumed(&mut self)

Clear consumption.

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,