Struct leafwing_input_manager::action_state::ActionState

pub struct ActionState<A: Actionlike> {
    pub action_data: Vec<ActionData>,
    /* private fields */
}

Stores the canonical input-method-agnostic representation of the inputs received

Can be used as either a resource or as a Component on entities that you wish to control directly from player input.

Example

use leafwing_input_manager::prelude::*;
use bevy_utils::Instant;

#[derive(Actionlike, PartialEq, Eq, Clone, Copy, Debug)]
enum Action {
    Left,
    Right,
    Jump,
}

let mut action_state = ActionState::<Action>::default();

// Typically, this is done automatically by the `InputManagerPlugin` from user inputs
// using the `ActionState::update` method
action_state.press(Action::Jump);

assert!(action_state.pressed(Action::Jump));
assert!(action_state.just_pressed(Action::Jump));
assert!(action_state.released(Action::Left));

// Resets just_pressed and just_released
action_state.tick(Instant::now());
assert!(action_state.pressed(Action::Jump));
assert!(!action_state.just_pressed(Action::Jump));

action_state.release(Action::Jump);
assert!(!action_state.pressed(Action::Jump));
assert!(action_state.released(Action::Jump));
assert!(action_state.just_released(Action::Jump));

action_state.tick(Instant::now());
assert!(action_state.released(Action::Jump));
assert!(!action_state.just_released(Action::Jump));

Fields

action_data: Vec<ActionData>

The ActionData of each action

The position in this vector corresponds to Actionlike::index.

Implementations

impl<A: Actionlike> ActionState<A>

pub fn update(&mut self, action_data: Vec<ActionData>)

Updates the ActionState based on a vector of ActionData, ordered by Actionlike::id.

The action_data is typically constructed from InputMap::which_pressed, which reads from the assorted Input resources.

pub fn tick(&mut self, current_time: Instant)

Advances the time for all actions

The underlying Timing and ButtonState will be advanced according to the current_instant.

• if no [Instant] is set, the current_instant will be set as the initial time at which the button was pressed / released
• the Duration will advance to reflect elapsed time

Example

use leafwing_input_manager::prelude::*;
use leafwing_input_manager::buttonlike::ButtonState;
use bevy_utils::Instant;

#[derive(Actionlike, Clone, Copy, PartialEq, Eq, Debug)]
enum Action {
    Run,
    Jump,
}

let mut action_state = ActionState::<Action>::default();

// Actions start released
assert!(action_state.released(Action::Jump));
assert!(!action_state.just_released(Action::Run));

// Ticking time moves causes buttons that were just released to no longer be just released
action_state.tick(Instant::now());
assert!(action_state.released(Action::Jump));
assert!(!action_state.just_released(Action::Jump));

action_state.press(Action::Jump);
assert!(action_state.just_pressed(Action::Jump));

// Ticking time moves causes buttons that were just pressed to no longer be just pressed
action_state.tick(Instant::now());
assert!(action_state.pressed(Action::Jump));
assert!(!action_state.just_pressed(Action::Jump));

pub fn action_data(&self, action: A) -> ActionData

Gets a copy of the ActionData of the corresponding action

Generally, it’ll be clearer to call pressed or so on directly on the ActionState. However, accessing the raw data directly allows you to examine detailed metadata holistically.

Example

use leafwing_input_manager::prelude::*;

#[derive(Actionlike, Clone, Copy, PartialEq, Eq, Debug)]
enum Action {
    Run,
    Jump,
}
let mut action_state = ActionState::<Action>::default();
let run_data = action_state.action_data(Action::Run);

dbg!(run_data);

pub fn set_action_data(&mut self, action: A, data: ActionData)

Manually sets the ActionData of the corresponding action

You should almost always use more direct methods, as they are simpler and less error-prone.

However, this method can be useful for testing, or when transferring ActionData between action states.

Example

use leafwing_input_manager::prelude::*;

#[derive(Actionlike, Clone, Copy, PartialEq, Eq, Debug)]
enum AbilitySlot {
    Slot1,
    Slot2,
}

#[derive(Actionlike, Clone, Copy, PartialEq, Eq, Debug)]
enum Action {
    Run,
    Jump,
}

let mut ability_slot_state = ActionState::<AbilitySlot>::default();
let mut action_state = ActionState::<Action>::default();

// Extract the state from the ability slot
let slot_1_state = ability_slot_state.action_data(AbilitySlot::Slot1);

// And transfer it to the actual ability that we care about
// without losing timing information
action_state.set_action_data(Action::Run, slot_1_state);

pub fn press(&mut self, action: A)

Press the action

No initial instant or reasons why the button was pressed will be recorded Instead, this is set through ActionState::tick()

pub fn release(&mut self, action: A)

Release the action

No initial instant will be recorded Instead, this is set through ActionState::tick()

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

Consumes the action

The action will be released, and will not be able to be pressed again until it would have otherwise been released by ActionState::release, ActionState::release_all or ActionState::update.

No initial instant will be recorded Instead, this is set through ActionState::tick()

Example

use leafwing_input_manager::prelude::*;

#[derive(Actionlike, Clone, Copy, PartialEq, Eq, Debug)]
enum Action {
    Eat,
    Sleep,
}

let mut action_state = ActionState::<Action>::default();

action_state.press(Action::Eat);
assert!(action_state.pressed(Action::Eat));

// Consuming actions releases them
action_state.consume(Action::Eat);
assert!(action_state.released(Action::Eat));

// Doesn't work, as the action was consumed
action_state.press(Action::Eat);
assert!(action_state.released(Action::Eat));

// Releasing consumed actions allows them to be pressed again
action_state.release(Action::Eat);
action_state.press(Action::Eat);
assert!(action_state.pressed(Action::Eat));

pub fn release_all(&mut self)

Releases all actions

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

Is this action currently pressed?

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

Was this action pressed since the last time tick was called?

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

Is this action currently released?

This is always the logical negation of pressed

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

Was this action pressed since the last time tick was called?

pub fn get_pressed(&self) -> Vec<A>

Which actions are currently pressed?

pub fn get_just_pressed(&self) -> Vec<A>

Which actions were just pressed?

pub fn get_released(&self) -> Vec<A>

Which actions are currently released?

pub fn get_just_released(&self) -> Vec<A>

Which actions were just released?

pub fn reasons_pressed(&self, action: A) -> Vec<UserInput>

The reasons (in terms of UserInput) that the button was pressed

If the button is currently released, the Vec<UserInput> returned will be empty

Example

use leafwing_input_manager::prelude::*;
use leafwing_input_manager::buttonlike::ButtonState;
use leafwing_input_manager::action_state::ActionData;
use bevy_input::keyboard::KeyCode;

#[derive(Actionlike, Clone)]
enum PlatformerAction{
    Move,
    Jump,
}

let mut action_state = ActionState::<PlatformerAction>::default();

// Usually this will be done automatically for you, via [`ActionState::update`]
action_state.set_action_data(PlatformerAction::Jump,
  ActionData {
        state: ButtonState::JustPressed,
        // Manually setting the reason why this action was pressed
        reasons_pressed: vec![KeyCode::Space.into()],
        // For the sake of this example, we don't care about any other fields
        ..Default::default()
    }
);

let reasons_jumped = action_state.reasons_pressed(PlatformerAction::Jump);
assert_eq!(reasons_jumped[0], KeyCode::Space.into());

pub fn instant_started(&self, action: A) -> Option<Instant>

The [Instant] that the action was last pressed or released

If the action was pressed or released since the last time ActionState::tick was called the value will be None. This ensures that all of our actions are assigned a timing and duration that corresponds exactly to the start of a frame, rather than relying on idiosyncratic timing.

pub fn current_duration(&self, action: A) -> Duration

The Duration for which the action has been held or released

pub fn previous_duration(&self, action: A) -> Duration

The Duration for which the action was last held or released

This is a snapshot of the ActionState::current_duration state at the time the action was last pressed or released.

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Actionlike> Component for ActionState<A> where
    Self: Send + Sync + 'static, 

type Storage = TableStorage

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> Default for ActionState<A>

fn default() -> ActionState<A>

Returns the “default value” for a type.

impl<'de, A: Actionlike> Deserialize<'de> for ActionState<A>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

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

fn eq(&self, other: &ActionState<A>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &ActionState<A>) -> bool

This method tests for !=.

impl<A: Actionlike> Serialize for ActionState<A>

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 ActionState<A>