Struct TnuaSimpleAirActionsCounter

pub struct TnuaSimpleAirActionsCounter { /* private fields */ }

A simple counter that counts together all the air actions a character is able to perform.

It’s update must be called every frame.

Implementations

impl TnuaSimpleAirActionsCounter

pub fn update(&mut self, controller: &TnuaController)

Call this every frame to track the air actions.

pub fn reset_count_to(&mut self, count: usize)

Resets the air actions counter to a specific count, excluding the current action.

This method allows you to manually set the count of air actions (excluding the current action) to a specified value. Use this when you need to synchronize or initialize the air actions count to a specific state.

Arguments

• count - The new count to set for air actions, excluding the current action.

Example

use bevy_tnua::control_helpers::TnuaSimpleAirActionsCounter;
let mut air_actions_counter = TnuaSimpleAirActionsCounter::default();

// Reset the air actions count to 3 (excluding the current action). should also be updated as stated in TnuaAirActionsTracker
air_actions_counter.reset_count_to(3);

pub fn get_count_mut(&mut self) -> Option<&mut usize>

Obtain a mutable reference to the air counter.

This can be use to modify the air counter while the player is in the air - for example, restoring an air jump when they pick up a floating token.

When it fits the usage, prefer reset_count which is simpler. get_count_mut should be used for more complex cases, e.g. when the player is allowed multiple air jumps, but only one jump gets restored per token.

Note that:

• When the character is grounded, this method returns None. This is only for mutating the counter while the character is airborne.
• When the character jumps from the ground, or starts a free fall, the counter is one - not zero. Setting the counter to 0 will mean that the next air jump will actually be treated as a ground jump - and they’ll get another air jump in addition to it. This is usually not the desired behavior.
• Changing the action counter returned by this method will not affect the value air_count_for returns for an action that continues to be fed.

pub fn reset_count(&mut self)

Resets the air actions counter.

This is equivalent to setting the counter to 1 using:

if let Some(count) = air_actions_counter.get_count_mut() {
    *count = 1;
}

The reason it is set to 1 and not 0 is that when the character jumps from the ground or starts a free fall the counter is 1 - and this is what one would usually want to reset to. Having a counter of 0 means that the character is grounded - but in that case get_count_mut will return None and the counter will not change.

pub fn air_count_for(&self, action_name: &str) -> usize

Calculate the “air number” of an action.

The air number of a ground action is 0. The first air jump (double jump) as an air number of 1, the second (triple jump) has an air number of 2 and so on. Other air actions (like air dashes) are counted together with the jumps.

Use this number to:

1. Determine if the action is allowed.
2. Optionally change the action’s parameters as the air number progresses.

Note that the action name is important, because Tnua relies on constant feed of some actions. As long as you pass the correct name, the number will not change while the action continues to be fed. The correct name is TnuaAction::NAME when using TnuaController::action or the first argument when using TnuaController::named_action.

Trait Implementations

impl Component for TnuaSimpleAirActionsCounter

where Self: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy::ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

fn register_required_components( requiree: ComponentId, components: &mut Components, storages: &mut Storages, required_components: &mut RequiredComponents, inheritance_depth: u16, )

Registers required components.

fn register_component_hooks(hooks: &mut ComponentHooks)

Called when registering this component, allowing mutable access to its ComponentHooks.

impl Default for TnuaSimpleAirActionsCounter

fn default() -> TnuaSimpleAirActionsCounter

Returns the “default value” for a type.