Struct TnuaController

pub struct TnuaController { /* private fields */ }

The main component used for interaction with the controls and animation code.

Every frame, the game code should 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. It is the game code’s responsibility to ensure only one basis is fed at any given time, because basis can hold state and replacing the basis type restarts the state.

  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.

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

Without TnuaControllerPlugin this component will not do anything.

Implementations

impl TnuaController

pub fn basis<B: TnuaBasis>(&mut self, basis: B)

Feed a basis - the main movement command - with its default name.

pub fn named_basis<B: TnuaBasis>(&mut self, name: &'static str, basis: B)

Feed a basis - the main movement command - with a custom name.

This should only be used if the same basis type needs to be used with different names to allow, for example, different animations. Otherwise prefer to use the default name with basis.

pub fn neutralize_basis(&mut self)

Instruct the basis to pretend the user provided no input this frame.

The exact meaning is defined in the basis’ neutralize method, but generally it means that fields that typically come from a configuration will not be touched, and only fields that are typically set by user input get nullified.

pub fn basis_name(&self) -> Option<&'static str>

The name of the currently running basis.

When using the basis with it’s default name, prefer to match this against TnuaBasis::NAME and not against a string literal.

pub fn dynamic_basis(&self) -> Option<&dyn DynamicBasis>

A dynamic accessor to the currently running basis.

pub fn concrete_basis<B: TnuaBasis>(&self) -> Option<(&B, &B::State)>

The currently running basis, together with its state.

This is mainly useful for animation. When multiple basis types are used in the game, basis_name be used to determine the type of the current basis first, to avoid having to try multiple downcasts.

pub fn concrete_basis_mut<B: TnuaBasis>( &mut self, ) -> Option<(&B, &mut B::State)>

The currently running basis, together with its state, as mutable. Useful if you need to touch the state of a running action to respond to game events.

pub fn action<A: TnuaAction>(&mut self, action: A)

Feed an action with its default name.

pub fn named_action<A: TnuaAction>(&mut self, name: &'static str, action: A)

Feed an action with a custom name.

This should only be used if the same action type needs to be used with different names to allow, for example, different animations. Otherwise prefer to use the default name with action.

pub fn action_name(&self) -> Option<&'static str>

The name of the currently running action.

When using an action with it’s default name, prefer to match this against TnuaAction::NAME and not against a string literal.

pub fn dynamic_action(&self) -> Option<&dyn DynamicAction>

A dynamic accessor to the currently running action.

pub fn concrete_action<A: TnuaAction>(&self) -> Option<(&A, &A::State)>

The currently running action, together with its state.

This is mainly useful for animation. When multiple action types are used in the game, action_name be used to determine the type of the current action first, to avoid having to try multiple downcasts.

pub fn concrete_action_mut<A: TnuaAction>( &mut self, ) -> Option<(&A, &mut A::State)>

The currently running action, together with its state, as mutable. Useful if you need to touch the state of a running action to respond to game events.

If the action is replaced, the state will be lost. If you need to keep the state, you should store it separately.

pub fn action_flow_status(&self) -> &TnuaActionFlowStatus

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_name 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 is_airborne(&self) -> Result<bool, TnuaControllerHasNoBasis>

Checks if the character is currently airborne.

The check is done based on the basis, and is equivalent to getting the controller’s dynamic_basis and checking its is_airborne method.

Trait Implementations

impl Component for TnuaController

where Self: Send + Sync + 'static,

Required Components: TnuaMotor, TnuaRigidBodyTracker, TnuaProximitySensor.

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.

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 TnuaController

fn default() -> TnuaController

Returns the “default value” for a type.