---
title: AFM_Abilities
product: Advanced Framework Pro
version: 1.0
engine: Unreal Engine 5.8
updated: 2026-10-05
canonical: https://docs.human-codeable.com/plugins/afm-abilities.html
---

Module

# AFM_Abilities

The architectural root of the framework: the ability and interaction base classes, sockets, Source Info, haptics and the actor registry. Almost everything else depends on this plugin.

#### What it gives you

- The four base classes every interactive system is built from
- The blocker activation model
- Source Info, the identity struct passed through every interaction
- Haptics helpers that resolve to the correct hand automatically

#### Requires

None

#### Required by

None

28 assets70 API members

## Description

This is the plugin to understand first. It defines no gameplay of its own — it defines the contract everything else follows.

Four component base classes cover the possible places an interaction can originate or land. `BPC_PawnAbility` sits on the pawn and represents something the player can do as a whole. `BPC_ControllerAbility` sits on a motion controller and represents something one hand can do. `BPC_ActorAbility` covers abilities on non-player actors. `BPC_Interaction` sits on the target and declares what may be done to it.

The design goal is that a target object never knows what kind of player is acting on it. It receives `ST_SourceInfo` — pawn, component, identifier — and that is enough to distinguish left hand from right, or one ability from another, without referencing a single pawn or controller class. That one decision is what makes the same content work in VR, on desktop and on mobile.

Activation is managed through blockers rather than booleans. See [The blocker system](../concepts/blockers.html) for why, and for the pitfalls.

## Setup

This plugin is a dependency rather than something you configure. It is enabled by every UX plugin and by the pawns.

1. Enable `AFM_Abilities` alongside `AFL_Libraries`.
2. Nothing else is required — the base classes become available to derive from and the libraries appear in the node palette.

Note

You will rarely add these base components to an actor directly. You add the concrete subclasses that the UX plugins provide, such as `BPC_Interaction_Select` or `BPC_PawnAbility_Grip`.

## Usage

### Suppressing an ability

Call `SetActiveWithBlocker` (controller and actor abilities) or `SetBlockerAndCheckActive` (pawn abilities) with a reason name. Call again with the same reason and `false` to release.

### Suppressing a whole class of abilities

Call `setAbilityRestriction` on the pawn with a component tag. Every ability on the pawn and on both motion controllers carrying that tag is suppressed under your reason, in one call. This is how the menu disables movement while it is open.

### Giving one ability exclusive use of a hand

Call `MC_SetFocusControllerAbility` on the motion controller with the ability that should keep running. Everything else on that hand is blocked with the reason `Unfocussed`.

### Playing haptics

Call `FL_Haptics.Haptics_Effect` with the Source Info you received. It resolves the correct hand itself, and does nothing on platforms without haptics — no branching required.

### Reading who acted on you

Every interaction call gives you Source Info. `getSidesFromAbility` turns it into one hand or both; the `Identifier` field distinguishes abilities of the same type.

## Key properties

| Property | On | When to change |
|---|---|---|
| `Identifier` | All abilities | Set when a target needs to distinguish this ability from another of the same class — a fingertip versus a whole hand, for example |
| `Blockers` | All abilities | Never edit directly; use the blocker API so reasons are tracked |
| `Relevant Components` | `BPC_Interaction` | When only some of the actor's meshes should be interactive |
| `Highlight Class` | `BPC_Interaction` | Choose the highlight style; leave empty for no hover feedback |
| `Highlight Tag` | `BPC_Interaction` | When only some meshes should highlight |
| `Default Interaction State` | `BPC_Pawn_InteractionState` | To change the resting cursor and accent colour |

## Extending

Derive from `BPC_Interaction` to add a new interaction type, and pair it with an interface exposing a `CanBe…` function that returns an override flag and an answer. Call `TickHighlight` while hovering and highlighting works for free.

Derive from `BPC_PawnAbility` or `BPC_ControllerAbility` for new abilities. Override `ComponentActivated` and `ComponentDeactivated` to add and remove your input mapping context — doing it there means the blocker system manages your input automatically.

See [Extending the framework](../guides/extending.html) for the full pattern.

## Example map

No dedicated map — every UX example map exercises this plugin. `Map_Examples_Select` is the smallest complete demonstration.

## Troubleshooting

**An ability stopped responding and nothing changed.** A blocker was added and never removed, almost always because the release call used a different reason name. Inspect the ability's `Blockers` array at runtime; it lists exactly what is holding it down.

**My interaction never highlights.** `Highlight Class` is empty, or the actor's meshes do not carry `Highlight Tag`. Leave the tag empty to highlight everything.

## API reference

Every blueprint asset in this plugin. Expand an asset to see its members.

### Components

**BPC_ActorAbility**4 members

extends `ActorComponent` · implements `BPI_Ability`, `BPI_SourceInfo`

Base class for an ability living on an ordinary actor rather than on a pawn or a hand. Carries the identifier, the blocker list and the Source Info it hands to interactions, and works the acting pawn out through its owner's owner, so an actor spawned by a pawn still reports who is behind it. Subclass it to write an ability of your own; the base on its own does nothing.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Identifier`Identifier | `name` | Name used to identify this ability when it is reported through Source Info, so interaction targets can tell which ability acted on them. Leave as None if the ability does not need to be distinguished from others on the same actor. |
| var | `Blockers`Blocker | `name[]` | Live list of reasons this ability is currently suppressed. The ability is active only while this list is empty; entries are added and removed through Set Active With Blocker rather than edited directly. |
| fn | `SetActiveWithBlocker`Blocker | `(Set: bool, Reason: name)` | Suppresses or releases this ability under a named reason. Multiple systems can block the same ability independently; it only reactivates once every reason has been removed. |
| fn | `getAllAttachedActors`Ability | `(out Actors: Actor[])` | Returns every actor this ability currently owns or has attached to itself. Override in a child ability that spawns actors so the owning motion controller can collect them. |

**BPC_AttachmentRegistry**4 members

extends `ActorComponent`

Registry component recording the actors a pawn is currently carrying or dragging along. Registering one makes it the owner's, has a character owner's capsule ignore it while moving, and drops it again if it is destroyed; teleport and grabbing read the list back to bring held objects along and keep traces off them. The actor registry library adds it on demand, so there is no need to add it by hand.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getRegisteredActors`Registry | `(Attached: bool, NonAttached: bool, out Actors: Actor[])` | Returns the actors registered with this owner, filtered by whether they are currently attached, not attached, or both. |
| event | `RegisterActor` | `(Actor: Actor, Attached: bool)` | Adds an actor to this owner's registry and records whether it is attached. The registry automatically drops the actor again when it is destroyed. |
| event | `OnDestroyed_Event` | `(DestroyedActor: Actor)` | Internal handler that removes a registered actor from the registry when that actor is destroyed. |
| event | `UnregisterActor` | `(Actor: Actor)` | Removes an actor from this owner's registry. |

**BPC_ControllerAbility**6 members

extends `SceneComponent` · implements `BPI_Ability`, `BPI_SourceInfo`

Base class for an ability belonging to one hand: the laser, grabbing, teleport, turning and movement abilities are all built on it. Add a subclass to a motion controller and the controller initiates it with the pawn, itself and the hand side, after which the ability can trace, spawn its helper actor and answer for its Source Info. Suppressed through Set Active With Blocker rather than removed.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Identifier`Identifier | `name` | Name used to identify this ability when it is reported through Source Info, so interaction targets can tell which hand or ability acted on them. |
| var | `Blockers`Blocker | `name[]` | Live list of reasons this ability is currently suppressed. The ability is active only while this list is empty; entries are added and removed through Set Active With Blocker rather than edited directly. |
| fn | `SetActiveWithBlocker`Blocker | `(Set: bool, Reason: name)` | Suppresses or releases this ability under a named reason. Used by other abilities to take exclusive control of a hand without permanently disabling what they interrupted. |
| fn | `getAllAttachedActors`Ability | `(out Actors: Actor[])` | Returns every actor this ability currently owns or has attached to itself, so the motion controller can gather everything it is carrying. |
| event | `SetVisible` | `(Set: bool)` | Shows or hides this ability's visual representation without deactivating its logic. |
| event | `InitiateControllerAbility` | `(Pawn: Pawn, MotionController: Actor, Side: E_Side)` | Called by the motion controller once it has been spawned, handing the ability its owning pawn, controller actor and hand side. Extend this to run setup that needs to know which hand it belongs to. |

**BPC_Interaction**12 members

extends `ActorComponent`

Base interaction component: the target side of the ability contract. Add it to any actor that should respond to being hovered or acted on, or subclass it when the response needs its own logic. Carries the highlight it adds to the owner on demand, the hover sounds, the tag limiting which components count and the blocker list that suppresses the interaction without removing it.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Relevant Components`Conditions | `name` | Component tag limiting which of the owner's primitive components respond to this interaction. Leave empty to make every primitive component of the actor interactive. |
| var | `Highlight Class`Highlight | `class<BPC_Highlight>` | Highlight component spawned on demand when this interaction is hovered. Choose the material, mesh-copy or post-process variant depending on how the object should read; leave empty for no highlight. |
| var | `Highlight Color`Highlight | `LinearColor` | Colour passed to the highlight component when it is created. Use it to signal interaction type or state, for example a warning colour on a locked object. |
| var | `Hover Sound`Highlight\|Sound | `SoundBase` | Sound played once when this interaction starts being hovered. |
| var | `Unhover Sound`Highlight\|Sound | `SoundBase` | Sound played once when hovering over this interaction ends. |
| var | `Blockers`Blockers | `name[]` | Live list of reasons this interaction is currently suppressed. The interaction responds only while this list is empty. |
| var | `Highlight Tag`Highlight | `name` | Component tag passed to the highlight component to limit which meshes are highlighted. Leave empty to highlight every mesh on the actor. |
| fn | `getRelevantSocketComponents`Internal | `(SocketClass: class<BPC_Socket>) → SceneComponent[]` | Returns the sockets of the given class that this interaction is allowed to use, honouring the Relevant Components tag filter. |
| fn | `SetBlocker`Blocker | `(Set: bool, Reason: name)` | Suppresses or releases this interaction under a named reason, so several systems can disable it independently without overriding each other. |
| event | `TickHighlight` | `(SourceInfo: ST_SourceInfo, TraceResult: HitResult)` | Called every frame while an ability is hovering this interaction. Keeps the highlight alive and broadcasts On Highlight Tick; highlight ends automatically when the calls stop. |
| event | `OnDestroyed_Event_0` | `(DestroyedActor: Actor)` | Internal handler that deactivates this interaction when its owning actor is destroyed. |
| event | `UpdateHighlightColor` | `(HighlightColor: LinearColor)` | Changes the highlight colour at runtime and pushes the new colour to the active highlight component. |

**BPC_PawnAbility**4 members

extends `ActorComponent` · implements `BPI_Ability`, `BPI_SourceInfo`

Pawn component tracking what the pawn is currently pointing at, expressed as an interaction state data asset. Abilities push a state through Set Pawn Interaction State, the highest priority wins, and it falls back to the default a tenth of a second after the pushing stops. Applies the state's mouse cursor and cursor widget to the player controller; the crosshair reads its colour.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Identifier`Identifier | `name` | Name used to identify this ability when it is reported through Source Info, so interaction targets can tell which ability acted on them. |
| fn | `SetBlockerAndCheckActive`Blockers | `(Set: bool, Reason: name)` | Suppresses or releases this ability under a named reason and re-evaluates whether it should be active. The ability runs only when no reasons remain. |
| event | `Possess` | `(Pawn: Pawn)` | Called when the owning pawn is possessed. Caches the pawn, resolves its platform type and lifts the Unpossessed blocker so the ability can start running. |
| event | `Unpossess` | `()` | Called when the owning pawn is unpossessed. Re-applies the Unpossessed blocker so the ability stops until the pawn is possessed again. |

**BPC_Pawn_InteractionState**4 members

extends `ActorComponent`

Base class for an ability the pawn owns rather than one hand: gaze, grip, select, teleport, the head-up display and the pawn interface are all built on it. Add a subclass to a pawn and the pawn gains that capability; the pawn calls Possess to hand over itself and its platform type, and until that happens a blocker keeps the ability inactive. Subclass it rather than adding the base.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Default Interaction State`Settings | `PDA_InteractionState` | Interaction state the pawn falls back to when nothing is being hovered. Defines the resting cursor and accent colour. |
| fn | `getCurrentColor` | `(out Value: LinearColor)` | Returns the accent colour of the interaction state currently in effect, so UI and highlights can match the active interaction. |
| event | `SetInteractionState` | `(Style: PDA_InteractionState, Reference: Object)` | Requests an interaction state for this frame. The highest-priority request wins, and the state reverts to the default shortly after requests stop arriving. |
| event | `ApplyInteractionState` | `(CurrentInteractionState: PDA_InteractionState, Reference: Object)` | Applies an interaction state immediately, swapping the mouse cursor and cursor widget. Prefer Set Interaction State so priority and fallback are handled for you. |

**BPC_Socket**1 members

extends `SceneComponent` · implements `Interface_Socket`

Named point on an actor that abilities can attach to or snap against. Add one wherever a hand should take hold, or subclass it, as the grip and attach-point sockets do, when the name has to be worked out rather than typed in. Interactions gather the sockets on their owner alongside its primitive components, filtered by the same relevant-components tag.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Socket Name`Socket | `name` | Name of this socket. Grip and attachment logic matches sockets by name prefix, so keep the prefix consistent with the socket type you are implementing. |

### DataAssets

**PDA_InteractionState**4 members

extends `PrimaryDataAsset`

Data asset describing one thing the pawn can be pointing at: its priority, the colour the crosshair takes, and the mouse cursor and cursor widget a desktop pawn switches to. Make one per interaction style and set it on the ability that should raise it; the pawn's interaction state component keeps whichever pushed state has the highest priority.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Priority`Priority | `int` | Ranking used when several systems request an interaction state in the same frame. The highest value wins. |
| var | `Color`Style | `LinearColor` | Accent colour associated with this interaction state, used by highlights and UI to signal what kind of interaction is available. |
| var | `Mouse Cursor`Mouse | `EMouseCursor` | Hardware mouse cursor shown while this interaction state is active, on desktop targets. |
| var | `Mouse Cursor Widget`Mouse | `class<WBP_MouseCursor>` | Optional widget drawn in place of the hardware cursor while this state is active, for a cursor that matches your project's styling. |

### Helper

**BP_Helper_ControllerAbility**1 members

extends `Actor`

Base actor for the helpers a hand ability spawns to do its work out in the world: the laser's beam and physics handle, the teleport arc, the movement and turn helpers all inherit from it. Carries the hand side it was spawned for and an auto-destroy component that tidies it away with its owner. Spawned for you rather than placed; subclass it when an ability of your own needs a world-side actor.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Side` | `E_Side` | Hand this helper actor belongs to. Set when the owning controller ability spawns the helper. |

### Interfaces

**BPI_Ability**1 members

extends `Interface`

Smallest contract an ability answers to: which pawn it ultimately belongs to. All three ability bases implement it and each works the answer out differently, so code holding an unknown ability component can ask for the pawn without knowing whether it sits on a hand, on the pawn or on an ordinary actor.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Ability_getOwningPawn`Ability | `(out Pawn: Pawn)` | Returns the pawn that owns this ability, regardless of whether it sits on the pawn, on a motion controller or on a player controller. |

**BPI_AbilityRestriction**1 members

extends `Interface`

Contract for switching whole groups of abilities off on a pawn. Set Ability Restriction takes a component tag and puts a named blocker on every pawn and controller ability carrying it, which is how a menu or a cutscene suspends grabbing or movement without touching abilities one at a time. All three shipped pawns implement it.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `setAbilityRestriction`Ability Restriction | `(AbilityTag: name, Set: bool, Reason: name)` | Suppresses or releases every ability carrying the given tag, under a named reason. Implemented by pawns so one system can disable a whole class of abilities at once, for example blocking movement while a menu is open. |

**BPI_MotionController**4 members

extends `Interface`

Contract every motion controller answers to: which side it is, what is attached to it, whether the controller mesh is shown, and which ability currently has exclusive focus. Hand abilities call it on the actor they were initiated with, so implement it on a controller of your own instead of expecting them to cast to the shipped one.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `MC_getMotionControllerSide`Motion Controller | `(out Side: E_Side)` | Returns which hand this controller represents. |
| fn | `MC_SetControllerVisibility`Motion Controller | `(Set: bool)` | Shows or hides the controller's visual representation, for example to hide a hand mesh while an object is held. |
| fn | `MC_GetAllAttachedActors`Motion Controller | `(out Actors: Actor[])` | Returns every actor currently held or spawned by any ability on this controller. |
| fn | `MC_SetFocusControllerAbility`Motion Controller | `(ControllerAbility: BPC_ControllerAbility, Set: bool)` | Gives one ability exclusive use of this controller by blocking all the others, or releases that exclusivity again. |

**BPI_MotionController_Hands**7 members

extends `Interface`

Extra contract for the hand-mesh style of motion controller, on top of the plain one: snapping the hand to a socket, reading the grab transform, switching hand collision on and off, asking whether the hand is open and getting or setting its pose. Only the hand grabbing ability calls it, so a controller-mesh hand can leave it alone.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `MCHands_GetPose`Motion Controller Hands | `(out HandPose: AnimSequenceBase)` | Returns the hand pose currently applied. |
| fn | `MCHands_SetPose`Motion Controller Hands | `(HandPose: AnimSequenceBase)` | Applies a hand pose animation, typically the custom grip pose defined on the object being held. |
| fn | `MCHands_isHandOpen`Motion Controller Hands | `(out Open: bool)` | Returns whether the hand is currently in an open pose, used to decide whether an object can be released or auto-gripped. |
| fn | `MCHands_getCurrentSnapSocket`Motion Controller Hands | `(out Socket: ST_Socket)` | Returns the socket the hand is currently snapped to, or an empty socket if the hand is free. |
| fn | `MCHands_SetHandCollision`Motion Controller Hands | `(Collision: ECollisionEnabled)` | Changes the collision mode of the hand mesh, for example disabling collision while an object is being carried. |
| fn | `MCHands_getGrabWorldTransform`Motion Controller Hands | `(out Transform: Transform)` | Returns the world transform of the hand's grab point, the position objects are picked up relative to. |
| fn | `MCHands_SnapToSocket`Motion Controller Hands | `(Socket: ST_Socket)` | Snaps the hand mesh onto the given socket, so a held object determines the hand's position and pose. |

**BPI_PawnInfo**3 members

extends `Interface`

Contract letting a shared ability ask the pawn what it needs without knowing the pawn class: the camera component, the platform type and a request to recentre the capsule under the head. All three shipped pawns implement it, and any pawn of your own that is to carry framework abilities should too.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Interface_RecenterCapsule`Pawn Info | `()` | Moves the collision capsule under the player's current head position without moving the tracked camera. Called after locomotion so the capsule follows real-world walking. |
| fn | `Interface_getPawnType`Pawn Info | `(out PawnType: E_Pawn_Type)` | Returns whether this pawn is the VR, desktop or mobile variant, so shared abilities can branch on platform. |
| fn | `Interface_getCamera`Pawn Info | `(out Camera: SceneComponent)` | Returns the pawn's camera component, so abilities can work from the view direction without knowing the pawn class. |

**BPI_SourceInfo**2 members

extends `Interface`

Contract for reading and writing the Source Info an object acts with, the pawn, the ability and its identifier. Abilities implement the getter so interactions can tell who is acting on them; widgets and interactions implement the setter so they can remember what last reached them. Implement it on anything of your own that has to pass that identity on.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `setSourceInfo`Source Info | `(SourceInfo: ST_SourceInfo)` | Stores Source Info on this object, used by helper actors that need to remember which ability created them. |
| fn | `getSourceInfo`Source Info | `(out SourceInfo: ST_SourceInfo)` | Returns the Source Info describing this ability: the owning pawn, the component acting, and its identifier. Passed into every interaction so targets know who is acting on them. |

**BPI_WidgetInteraction**2 members

extends `Interface`

Contract handing a widget the widget interaction component currently pointing at it. The laser and the pawn's widget ability push theirs onto whatever they hit, the widget component stores it, and the text field reads it back so the virtual keyboard it opens is driven by the same pointer. Implement it on any widget host of your own.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Widget_GetWidgetInteractionComponent`Widget Interaction | `(out WidgetInteractionComponent: WidgetInteractionComponent)` | Returns the widget interaction component currently driving pointer events for this object. |
| fn | `Widget_SetWidgetInteractionComponent`WidgetInteraction | `(WidgetInteractionComponent: WidgetInteractionComponent)` | Assigns the widget interaction component this object should route pointer events through. |

**Interface_Socket**1 members

extends `Interface`

Contract for anything offering itself as a named attachment point: it reports the socket name to look for on the mesh. The socket component implements it and grip searches through it, so a component of your own can serve as a snap target without inheriting from the socket component.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Socket_getSocketName` | `(out Name: name)` | Returns this socket's name, used to match sockets against the prefix an ability is looking for. |

### Libraries

**BFL_ActorRegistry**3 members

extends `BlueprintFunctionLibrary`

Function library for the attachment registry, called statically with the parent actor as an argument. Register Actor, Unregister Actor and Get Registered Actors put the registry component on the parent the first time one is needed, so grabbing, pickups and teleport can record what a pawn is carrying without anyone having to add the component first.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `getRegisteredActors`Registry | `(Parent: Actor, Attached: bool, NonAttached: bool, __WorldContext: Object, out Actors: Actor[])` | Returns the actors registered against a parent, filtered by attachment state. |
| fn | `UnregisterActor`Registry | `(Parent: Actor, Actor: Actor, __WorldContext: Object)` | Removes an actor from a parent actor's registry. |
| fn | `RegisterActor`Registry | `(Parent: Actor, Actor: Actor, Attached: bool, __WorldContext: Object)` | Registers an actor against a parent actor and records whether it is attached. Use this to track spawned or carried actors without holding hard references. |

**FL_Haptics**5 members

extends `BlueprintFunctionLibrary`

Function library playing controller haptics from a Source Info rather than from a hand. It works out which hands to buzz from the ability that acted, one side for a hand ability and both for a pawn ability, then plays, holds or stops the effect on that pawn's player controller. Call it statically from an interaction that should be felt; the caller never has to know which controller is which.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Haptics_Effect_BothHands`Haptics | `(Pawn: Pawn, HapticEffect: HapticFeedbackEffect_Base, __WorldContext: Object)` | Plays a one-shot haptic effect on the hand or hands that the given Source Info came from. Does nothing on platforms without haptics. |
| fn | `getSidesFromAbility`Sides | `(Ability: ActorComponent, __WorldContext: Object, out Sides: E_Side[])` | Returns which hands an ability is associated with. A controller ability resolves to its own hand; a pawn ability resolves to both. |
| fn | `Haptics_Stop`Haptics | `(SourceInfo: ST_SourceInfo, __WorldContext: Object)` | Stops any continuous haptic feedback running on the hand the Source Info came from. |
| fn | `Haptics_Continous`Haptics | `(SourceInfo: ST_SourceInfo, Frequency: float, Amplitude: float, __WorldContext: Object)` | Starts a continuous rumble at the given frequency and amplitude on the hand the Source Info came from. Must be stopped explicitly with Haptics Stop. |
| fn | `Haptics_Effect`Haptics | `(SourceInfo: ST_SourceInfo, HapticEffect: HapticFeedbackEffect_Base, __WorldContext: Object)` | Plays a one-shot haptic effect on the hand or hands that the given Source Info came from. Does nothing on platforms without haptics. |

**ML_Actor_Input**0 members

extends `Actor`

Macro library for adding and removing Enhanced Input mapping contexts from an actor, plain or picked by hand side out of a mapping context struct. Parented to Actor, so the macros are offered in any actor; the desktop and mobile pawns use them to swap their contexts as the control mode changes.

No editor-visible members; this asset configures defaults only.

**ML_Actors_Haptics**0 members

extends `Actor`

Macro library holding the continuous-haptics macro for actors: it keeps a buzz running while the macro is re-entered and stops it a tenth of a second after the calls stop, so a repeating event never has to remember to switch it off. Parented to Actor. Nothing in the shipped content uses this version; the component one does the same job inside abilities and interactions.

No editor-visible members; this asset configures defaults only.

**ML_Comp_Input**0 members

extends `ActorComponent`

Macro library for adding and removing Enhanced Input mapping contexts from a component, plain or picked by hand side out of a mapping context struct. Parented to Actor Component, so the macros are offered inside any ability; the laser, grab, teleport, grip, select and widget abilities use them to bring their input in and out as they activate.

No editor-visible members; this asset configures defaults only.

**ML_Component_Haptics**0 members

extends `ActorComponent`

Macro library holding the continuous-haptics macro for components: it keeps a buzz running while the macro is re-entered and stops it a tenth of a second after the calls stop. Parented to Actor Component, so it is offered inside any ability or interaction; the drag state uses it to make a handle rattle while it is being pulled.

No editor-visible members; this asset configures defaults only.

**ML_ControllerAbilities**0 members

extends `BPC_ControllerAbility`

Macro library for hand abilities: a side guard that only continues on the hand the ability belongs to, a button handler folding left and right triggered and completed input events into one boolean, and a Source Info shortcut. Parented to the controller ability base, so the macros only appear inside abilities that inherit from it.

No editor-visible members; this asset configures defaults only.

**ML_Helper_ControllerAbility**0 members

extends `BP_Helper_ControllerAbility`

Macro library for the helper actors hand abilities spawn, mirroring the ability-side one: a side guard that only continues on the hand the helper was spawned for, and a button handler folding left and right start and completed events into one boolean. Parented to the helper base, so the macros only appear in helpers inheriting from it.

No editor-visible members; this asset configures defaults only.

**ML_Object_SourceInfo**0 members

extends `Object`

Macro library with the locally-controlled branch for a Source Info: one pin continues when the pawn that acted is the local player's, the other when it is not. Parented to Object, so it is offered everywhere, and it is the usual guard before running an effect that should only happen on the machine of whoever caused it.

No editor-visible members; this asset configures defaults only.

**ML_PawnAbility**0 members

extends `BPC_PawnAbility`

Macro library for pawn abilities: a Source Info shortcut, a locally-controlled branch on the possessed pawn, and Set Pawn Interaction State, which pushes an interaction state data asset onto the pawn's interaction state component when it has one. Parented to the pawn ability base, so the macros only appear inside abilities inheriting from it.

No editor-visible members; this asset configures defaults only.

### Widgets

**WBP_MouseCursor**1 members

extends `UserWidget`

Base widget for a software mouse cursor. It holds nothing but the reference object it is created with, which is whatever raised the interaction state, so a cursor can show something about the thing under it. Subclass it, name the subclass on an interaction state data asset, and the pawn's interaction state component creates it and hands it to the player controller.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Reference` | `Object` | Object that requested this cursor widget, available so the cursor can reflect what is being pointed at. |