Struct TnuaController 

pub struct TnuaController<S: TnuaScheme> {
    pub basis: S::Basis,
    pub basis_config: Option<<S::Basis as TnuaBasis>::Config>,
    pub basis_memory: <S::Basis as TnuaBasis>::Memory,
    pub current_action: Option<S::ActionState>,
    /* private fields */
}

The main component used for interaction with the controls and animation code (needs a TnuaConfig)

Every frame, the game code should invoke initiate_action_feeding and then feed input this component on every controlled entity. What should be fed is:

• A basis - this is the main movement command - usually TnuaBuiltinWalk, but there can be others. The controller’s basis is takens from the scheme (the generic argument). Controlling it is done by modifying the basis field of the controller.

  Refer to the documentation of the implementors of TnuaBasis for more information.

• Zero or more actions - these are movements like jumping, dashing, crouching, etc. Multiple actions can be fed, but only one can be active at any given moment. Unlike basis, there is a smart mechanism for deciding which action to use and which to discard, so it is safe to feed many actions at the same frame. Actions are also defined in the scheme, and can be fed using the action method.

  Refer to the documentation of the implementors of TnuaAction for more information.

Without TnuaControllerPlugin of the same scheme this component will not do anything.

Fields

basis: S::Basis

Input for the basis - the main movement command.

basis_config: Option<<S::Basis as TnuaBasis>::Config>

A copy of the basis’ configuration from the asset.

basis_memory: <S::Basis as TnuaBasis>::Memory

Kept by the basis itself - but user code may modify if it knows what it`s doing.

current_action: Option<S::ActionState>

The full state of the currently running action.

Be careful when touching that:

• Changing the input and even config is usually fine.
• Only change the state if you know what you’re doing.
• Never change the actual variant.

Implementations

impl<S: TnuaScheme> TnuaController<S>

pub fn basis_access( &self, ) -> Result<TnuaBasisAccess<'_, S::Basis>, TnuaControllerHasNotPulledConfiguration>

Access to the entire basis state. This is what the basis capabilities usually use.

pub fn initiate_action_feeding(&mut self)

Must be called each frame before feeding the actions (unless action) is never used)

pub fn action(&mut self, action: S)

Feed an action.

This is used in pull fashion - a system (or set of systems) that checks the state of the playter input (or of some NPC controller) and can feed the action every frame its still on. This system must start by calling initiate_action_feeding.

For pushing actions, use one of the other action_* methods.

pub fn action_trigger(&mut self, action: S)

Trigger an action in a push fashion. The action must be one that handles its own duration.

This means that actions like TnuaBuiltinCrouch cannot be used with this method - the character will rise after one frame of starting to crouch. Actions like ’TnuaBuiltinDash` are okay because the dash will only end when the motion itself is finished.

pub fn action_interrupt(&mut self, action: S)

Similar to action_trigger, but can override other action contenders and other action feeding methods cannot override it.

pub fn action_start(&mut self, action: S)

Trigger an action in a push fashion. The action will continue until action_end is called - or until the motion itself is finished.

pub fn action_end(&mut self, action: S::ActionDiscriminant)

End an action that started with action_start

pub fn prolong_action(&mut self)

Re-feed the same action that is currently active.

This is useful when matching on current_action and wanting to continue feeding the exact same action with the exact same input without having to

pub fn action_discriminant(&self) -> Option<S::ActionDiscriminant>

The discriminant of the currently running action.

pub fn action_flow_status(&self) -> &TnuaActionFlowStatus<S::ActionDiscriminant>

Indicator for the state and flow of movement actions.

Query this every frame to keep track of the actions. For air actions, TnuaAirActionsTracker is easier to use (and uses this behind the scenes)

The benefits of this over querying action_discriminant every frame are:

• action_flow_status can indicate when the same action has been fed again immediately after stopping or cancelled into itself.
• action_flow_status shows an ActionEnded when the action is no longer fed, even if the action is still active (termination sequence)

pub fn up_direction(&self) -> Option<Dir3>

Returns the direction considered as up.

Note that the up direction is based on gravity, as reported by TnuaRigidBodyTracker::gravity, and that it’d typically be one frame behind since it gets updated in the same system that applies the controller logic. If this is unacceptable, consider using TnuaRigidBodyTracker::gravity directly or deducing the up direction via different means.

impl<S: TnuaScheme> TnuaController<S>

where S::Basis: TnuaBasisWithGround,

pub fn is_airborne( &self, ) -> Result<bool, TnuaControllerHasNotPulledConfiguration>

Checks if the character is currently airborne.

The check is done based on the basis, and is equivalent to getting the controller’s basis_access and using TnuaBasisWithGround::is_airborne on it.

Trait Implementations

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

where Self: Send + Sync + 'static,

Required Components: TnuaMotor, TnuaRigidBodyTracker.

A component’s Required Components are inserted whenever it is inserted. Note that this will also insert the required components of the required components, recursively, in depth-first order.

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 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 TnuaController<S>

fn default() -> Self

Returns the “default value” for a type.