Struct TnuaActionsCounter 

pub struct TnuaActionsCounter<S: TnuaActionSlots> {
    pub slots: S,
    /* private fields */
}

An helper for counting the actions in scenarios where actions can only be done a limited amount of times. Mainly used for implementing air actions.

It’s update must be called every frame - even when the result is not used - in the same schedule as TnuaControllerPlugin. For air actions, this can usually be done with TnuaAirActionsPlugin.

This type exposes the slots struct to allow manual interference with the counting, but the actually checking of counters should use count_for which also takes into account the currently active action.

Fields

slots: S

Implementations

impl<S: TnuaActionSlots> TnuaActionsCounter<S>

pub fn update( &mut self, controller: &TnuaController<S::Scheme>, status_for_basis: impl FnOnce(&TnuaBasisAccess<'_, <S::Scheme as TnuaScheme>::Basis>) -> TnuaActionCountingStatus, )

Call this every frame, at the schedule of TnuaControllerPlugin, to track the actions.

The predicate and the TnuaActionSlots from the generic parameter define how the counters will get updated.

pub fn count_for( &self, action: <S::Scheme as TnuaScheme>::ActionDiscriminant, ) -> usize

Calculate the “number” of an action.

If actions are not currently being counted, this will return 0. Otherwise, it will return the number the requested action will be - meaning the first one in the counting duration will be numbered 1.

If the specified action is currently running, this method will return the number of the currently running action, not the next action of the same variant. This is done so that user control systems will keep feeding it - with allow_in_air: true - for as long as the player holds the button. Note that this means that while the very action that triggered the counting (e.g. - jumping off the ground when counting air actions) is still active, its number will be 0 (even though action counting starts from 1, this action was from before the counting so it gets to be 0)

Each slot gets counted separately. If the action does not belong to any slot, or if actions are not currently being counted, this returns 0.

let air_actions: TnuaActionsCounter<AirActionSlots>; // actually get this from a Query

controller.action(ControlScheme::Jump(TnuaBuiltinJump {
    allow_in_air: air_actions.count_for(ControlSchemeActionDiscriminant::Jump)
        // Allow one air jump - use <= instead of < because the first one in the air will
        // be have its `count_for` return 1.
        <= 1,
    ..Default::default()
}));

Trait Implementations

impl<S: TnuaActionSlots> Component for TnuaActionsCounter<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: TnuaActionSlots> Default for TnuaActionsCounter<S>

fn default() -> Self

Returns the “default value” for a type.