Struct TnuaSimpleAirActionsCounter 

pub struct TnuaSimpleAirActionsCounter<S: TnuaScheme> { /* private fields */ }

👎Deprecated: Use TnuaActionsCounter instead

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

It’s update must be called every frame, in the same schedule as TnuaControllerPlugin.

Implementations

impl<S> TnuaSimpleAirActionsCounter<S>

where S: TnuaScheme + TnuaAirActionDefinition, S::Basis: TnuaBasisWithGround,

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

where S: TnuaScheme + TnuaAirActionDefinition, S::Basis: TnuaBasisWithGround,

Call this every frame, in the same schedule as TnuaControllerPlugin, 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

// 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: S::ActionDiscriminant) -> 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 discriminant is important, because Tnua relies on constant feed of some actions. As long as you pass the correct discriminant, the number will not change while the action continues to be fed. The discriminant can be obtained with TnuaController::action_discriminant.

Trait Implementations

impl<S: TnuaScheme> Component for TnuaSimpleAirActionsCounter<S>

where Self: Send + Sync + 'static,

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

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_replace() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_replace 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<S: TnuaScheme> Default for TnuaSimpleAirActionsCounter<S>

fn default() -> Self

Returns the “default value” for a type.