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 prolong_action(&mut self)

Re-feed the same action that is currently active.

This is useful when matching on action_name and wanting to continue feeding the exact same action with the exact same input without having to use concrete_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.

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, components: &mut ComponentsRegistrator<'_>, required_components: &mut RequiredComponents, inheritance_depth: u16, recursion_check_stack: &mut Vec<ComponentId>, )

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 register_component_hooks(hooks: &mut ComponentHooks)

👎Deprecated since 0.16.0: Use the individual hook methods instead (e.g., Component::on_add, etc.)

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

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 Default for TnuaController

fn default() -> TnuaController

Returns the “default value” for a type.