Runtime Types¶

The data structures a State, Action, Group and Cycle are built from. See The Model for how these relate.

Action states, actions, groups, cycles¶

Enums

enum class EMovaIxDeltaSpace : uint8¶

Axis frame a State's Location and Rotation deltas travel in.

Orthogonal to EMovaIxOffsetMode, which picks the reference pose, not the axis frame.
Every mode composes a relative pose, since the final write is SetRelativeTransform.
Attach parent carries the owning Actor's world rotation in every mode. => A yawed Actor already slides along its own axes under Relative.

Values:

enumerator Local¶

Component's own relative rotation rotates the delta, post-multiplying as Ref * Delta.

Reads as: turn about the axes this Component already points along.
Differs from Relative only when this Component carries a non-zero relative rotation.
Ex: a door leaf modeled at a 30-degree relative yaw.
A Component at relative rotation 0 composes identically under Local and Relative. => That collapse is the expected math, not a defect, and is the common case in practice.
For an absolute pose ignoring every reference frame, use EMovaIxOffsetMode::Parent.

enumerator Relative¶

Parent-relative axes, layering the delta in the Component's parent space. This is the default.

Delta is added raw, and the State rotation pre-multiplies as Delta * Ref.

enumerator World¶

World axes, ignoring the object's rotation. Ex: a -40 Y always travels world Y.

Only mode that cancels the attach parent's world orientation. => A -40 Y travels world Y even when the owning Actor is yawed.

enum class EMovaIxNiagaraMode : uint8¶

How long a State's Niagara effect lives once its Keyframe is reached.

Values:

enumerator OneShot¶

Fire-and-forget burst at the Keyframe, then auto-destroys.

Ex: a splash when a lid snaps shut.

enumerator WhileActive¶

Spawns attached and keeps playing until the State is left or the Group stops.

Ex: a fountain that flows out of a sink while it is filling.

struct FMovaIxActionCycle¶

#include <MovaIxActionTypes.h>

Ordered sequence of Action Groups the Cycle steps on each interaction.

For multi-State objects.
Ex: a 3-way switch, or a sequence of door positions.

Public Members

TArray<FName> Groups¶

Ordered list of Action Group names to execute.

Moves to the next Group on each trigger.

int32 StartIndex = 0¶

Group index the cycle starts at, 0-based, set on the object and persisted.

Seeds CurrentIndex when the runtime data is built.
Pose auto-detect at BeginPlay and a SaveGame restore still override it afterward.

int32 CurrentIndex = 0¶

Index of the Group currently active, or last executed.

Persists, so the next interaction triggers the following State in the cycle.

struct FMovaIxActionKeyframe¶

#include <MovaIxActionTypes.h>

Single point on an Action timeline.

Connects a timestamp to a pre-defined FMovaIxActionState.

Public Members

float Time = 0.0f¶: Time in seconds from Action start when this State should be reached.

FName State¶

Name of the FMovaIxActionState to use.

None keeps the current pose.
@Loop cycles the Group back to its More.LoopStartTime.
Ex: a fan, an escalator.

struct FMovaIxActionStateAnimation¶

#include <MovaIxActionTypes.h>

Animation played on the Target object when a Keyframe is reached.

Fired one-shot on crossing, on each resolved Target that is a SkeletalMeshComponent.
Lets a rigged Target play an assigned AnimSequence or AnimMontage.
Ex: a door, a machine, a lever.
Works instead of the procedural transform Keyframes, or alongside them.

Public Members

UAnimationAsset *Animation = nullptr¶

Animation to play on the Target's skeletal mesh.

Accepts an AnimSequence or an AnimMontage.
None means no animation for this State.

float BlendIn = 0.1f¶

Blend-in time (s) when starting the animation.

Montages: passed as the play blend-in.
Sequences: used as the SingleNode blend, so it eases in instead of snapping.

bool bLooping = false¶

Whether a played AnimSequence should loop.

Ignored for Montages, which define their own looping sections.

float PlayRate = 1.0f¶

Playback rate multiplier.

1 is the set speed.
Negative plays in reverse where supported.

struct FMovaIxActionStateAudio¶

#include <MovaIxActionTypes.h>

Audio configuration for an Action State.

Handles discrete one-shot sound events and continuous modulated States.

Public Members

USoundBase *TriggerSound = nullptr¶: One-shot sound effect asset played at a specific point on the timeline.

FVector2D TriggerFadeInOut = FVector2D::ZeroVector¶

Fade configuration for one-shot trigger tracking.

X is the fade-in duration, Y is the fade-out duration.

float TriggerOffset = 0.0f¶

Time offset relative to the Keyframe timestamp.

Negative values play the trigger sound early.

float TriggerPitch = 1.0f¶: Pitch multiplier for the trigger sound.

FVector2D TriggerTrim = FVector2D::ZeroVector¶

Playback window extracted from the source audio asset.

X is the start position, Y is the end cutoff timestamp.

float TriggerVolume = 1.0f¶: Volume multiplier for the trigger sound.

USoundBase *ContinuousSound = nullptr¶: Persistent sound that loops and modulates while this State remains active.

FVector2D ContinuousFadeInOut = FVector2D::ZeroVector¶

Fade configuration for smooth ambient blending.

X is the fade-in duration, Y is the fade-out duration.

float ContinuousPitch = 1.0f¶: Pitch multiplier for the continuous sound.

float ContinuousVolume = 1.0f¶: Volume multiplier for the continuous sound.

USoundAttenuation *Attenuation = nullptr¶

Spatialization profile for both the trigger and continuous sounds, which play on the IC's Actor.

Leave unset for a built-in default 3D falloff.
Assign an asset to set the distance curve yourself.

struct FMovaIxActionStateParams¶

#include <MovaIxActionTypes.h>

Custom gameplay metadata passed during Action execution.

Triggers logic on other objects, or passes parameters.

Public Members

FName Action¶: Name of an ActionGroup or ActionCycle to execute on another InteractiveComponent.

float Number = 0.0f¶: Numeric payload. Ex: an elevator floor, a damage value.

FName Tag¶: Identifier used for logic branching.

FString Text¶: Optional human-readable string payload.

struct FMovaIxActionStatePhysics¶

#include <MovaIxActionTypes.h>

Physics and procedural vibration settings for an Action State.

Public Members

FVector ContinuousForce = FVector::ZeroVector¶

Continuous force applied every frame while in this State, local space.

Units: kg*cm/s^2, same as UPrimitiveComponent::AddForce.

FVector ContinuousForcePoint = FVector::ZeroVector¶: Local-space point where the continuous force is applied.

FVector Impulse = FVector::ZeroVector¶

One-shot impulse applied when entering the Keyframe, local space.

Units: kg*cm/s, same as UPrimitiveComponent::AddImpulseAtLocation's default bVelChange=false.
Mass-dependent: the same value moves a light object faster than a big one.

FVector ImpulsePoint = FVector::ZeroVector¶: Local-space point where the impulse is applied.

FVector2D LocationSpeedMinMax = FVector2D::ZeroVector¶

Travel-speed clamp for reaching this State. X is min, Y is max.

Implied speed, distance over set time, is clamped, then the segment is re-timed as distance over speed. => An Action auto-times by travel distance.
Ex: an elevator takes longer to reach a farther floor.
(0, 0) disables it.

FVector2D RotationSpeedMinMax = FVector2D::ZeroVector¶

Turn-speed clamp (deg/s) for reaching this State. X is min, Y is max.

Same logic as LocationSpeedMinMax.
(0, 0) disables it.

FVector VibrationAmplitude = FVector::ZeroVector¶

Max offset for procedural jitter.

For rumbling machinery or unstable props.

FVector VibrationFrequency = FVector(12.0f, 15.0f, 8.0f)¶: Frequency of vibration on each axis (Hz).

float VibrationImpulse = 30.0f¶

Scales VibrationAmplitude into a physics rattle applied to a PrimitiveComponent each frame.

Units: cm/s, a direct velocity change, same as UPrimitiveComponent::AddImpulse's bVelChange=true.
Unlike Impulse above, this is not divided by mass.
0 disables the rattle, the visual jitter above still runs.

struct FMovaIxActionStateVisuals¶

#include <MovaIxActionTypes.h>

Visual properties for an Action State.

Controls lighting and materials.

Public Members

FLinearColor LightColor = FLinearColor::White¶: Light color. Only applies when the Target Component is a light.

float LightIntensity = -1.0f¶: Light brightness. -1 leaves the light alone, so 0 is a real "off".

float LightTemperature = 4500.0f¶: Light temperature in Kelvin.

TArray<UMaterialInterface*> Materials¶

Material overrides for the Target mesh.

Array index matches the material slot index.

bool bVisible = true¶: Whether the Component should be visible in this State.

struct FMovaIxActionStateNiagara¶

#include <MovaIxActionTypes.h>

Niagara effect played when an Action State's Keyframe is reached.

Attaches to a resolved Target, or to the animated Component, with a local offset.

Public Members

UFXSystemAsset *System = nullptr¶

Niagara system to play. Empty means no effect.

Typed as the engine's UFXSystemAsset base, so holding one adds no Niagara dependency.
A project with Niagara disabled still loads this struct.

FName Target¶

Component to attach the effect to, resolved with the same syntax as Action.Target.

Empty attaches to the State's own animated Component.
Ex: "@Spout" to hang a fountain off the faucet.

FTransform Offset = FTransform::Identity¶: Local offset for the effect, relative to the attach Component.

EMovaIxNiagaraMode Mode = EMovaIxNiagaraMode::OneShot ¶: How long the effect lives once spawned.

struct FMovaIxActionStateMore¶

#include <MovaIxActionTypes.h>

Wrapper grouping all extended State data.

Keeps FMovaIxActionState itself short.

Public Members

FMovaIxActionStateAnimation Animation¶: Animation played on the Target's skeletal mesh when this State's Keyframe is reached.

FMovaIxActionStateAudio Audio¶: Audio settings for this State.

FMovaIxActionStateNiagara Niagara¶: Niagara effect played when this State's Keyframe is reached.

FMovaIxActionStateParams Params¶: Gameplay parameters for this State.

FMovaIxActionStatePhysics Physics¶: Physics and vibration settings for this State.

FMovaIxActionStateVisuals Visuals¶: Visual settings: light and materials.

struct FMovaIxActionState¶

#include <MovaIxActionTypes.h>

Transformation and auxiliary data of a Component at a point in time.

Usually defined in a central library on an interactive object, then referenced by name.

Public Members

FVector Location = FVector::ZeroVector¶: Target relative location.

FRotator Rotation = FRotator::ZeroRotator¶: Target relative rotation.

FVector Scale = FVector::OneVector¶: Target relative scale.

FMovaIxActionStateMore More¶: All extended data: audio, params, physics, visuals.

bool bSpecial = false¶: Set for a special State, ex: CurrentState or InitialState.

namespace MovaIx

namespace Names¶

Canonical special FName markers used by the Action data model.

Keyframe State markers, '@': resolved in FMovaIxAction::GetActionState and the Group loop handling.
Target tokens, '#': resolved in UMovaIxComponent Target parsing.

Functions

inline bool IsSpecialState(const FName &StateName)¶

True when StateName is a special Keyframe-State marker, resolved at runtime instead of looked up.

@Current, @Loop, @Start, @Stop, @StopNow, @Zero. => They are always valid and validation must skip them.

inline bool IsStopState(const FName &StateName)¶

True when StateName is a stop-control marker, @Stop or @StopNow.

Crossing such a Keyframe stops running Groups that share its Components.

Variables

const FName Current = TEXT("@Current")¶: Keyframe State: snapshot captured when the segment started, which holds the current pose.

const FName Loop = TEXT("@Loop")¶: Keyframe State: loop marker that cycles the Group back to its More.LoopStartTime. Ex: a fan, an escalator.

const FName Start = TEXT("@Start")¶

Keyframe State: pose captured at each playback Start, the run's anchor.

Relative deltas add on top of it.

const FName Stop = TEXT("@Stop")¶

Keyframe State: control marker that stops running Groups sharing this Action's Components.

Smooth stop: coasts a looping Group via RampOutTime, or eases a one-shot via StopSpeedFactor.
Applies no transform of its own.
Holds the current pose, like @Current.

const FName StopNow = TEXT("@StopNow")¶: Keyframe State: like @Stop but stops immediately, with no coast or ease.

const FName Zero = TEXT("@Zero")¶: Keyframe State: the absolute initial pose of the object.

const FName Actor = TEXT("#Actor")¶: Target token: resolves live to the interacting Actor's Root. Ex: a button targeting whoever pressed it.

const FName Carry = TEXT("#Carry")¶: Target and Component tag: marks the carry surface primitives. An animated Target carries objects on them.

const FName Grab = TEXT("#Grab")¶: Component tag: marks a physics primitive the player can grab, carry or throw. See UMovaIxGrabComponent.

const FName Parent = TEXT("#Parent")¶: Target token: the attach parent of the self Component.

const FName Root = TEXT("#Root")¶

Target token: the owning Actor's Root Component.

Lets a remote button drive an object's Root even when that object is not detectable itself.

const FName Self = TEXT("#Self")¶

Target token: the Self Component the interaction tag sits on, its own anchor Component.

Lets one shared tag animate whichever Component carries it, with no per-Component Target.
Ex: "!Push #Self".
Resolved at parse time to that Component's exact name. => Each tagged Component Targets only itself.

const FName Unique = TEXT("#unique")¶

Point modifier: this interaction never folds into a collapsed multi-choice query.

Set on any tagged Component whose interaction must stay its own aim-selected point.

struct FMovaIxCarriedObject¶

#include <MovaIxAction.h>

Runtime record of one object carried by a moving Action Target.

Public Members

TWeakObjectPtr<USceneComponent> AttachedComponent¶

Component actually attached to the mover, normally the carried Actor's Root.

Attaching a non-Root Component would move only that Component and could break the hierarchy.
Falls back to Component when the Actor has no usable movable Root.

TWeakObjectPtr<UPrimitiveComponent> Component¶: Carried primitive: the piece that actually overlapped, and of which physics State was changed.

bool bWasSimulatingPhysics = false¶: Physics simulating State before attaching, restored when detached.

struct FMovaIxAction¶

#include <MovaIxAction.h>

Core logic unit for animating a single Component.

Manages interpolation, effects, and runtime State.

Public Functions

void AttachCarriedObjects(UMovaIxComponent *IC, const FMovaIxActionGroupMore &More)¶

Attach dynamic objects resting on/inside each Target so they move with it.

No-op unless More.bCarryObjects.

void CacheLoopStates(UMovaIxComponent *IC, const FMovaIxActionGroupMore &More)¶

Caches the @Loop Target pose per Component (the State the timeline resumes at, t = More.LoopStartTime).

Only Actions with a @Loop Keyframe cache anything. Called once at playback start.
Tiered resolution:
- LoopStartTime 0 => @Zero pose.
- LoopStartTime on a Keyframe => that Keyframe's resolved State.
- LoopStartTime between Keyframes => interpolated pose at that time.

Parameters:

IC -- Interactive Component providing context.
More -- Group settings (LoopStartTime, offset mode, easing).

bool CalculateAlphaStates(UMovaIxComponent *IC, const FMovaIxActionGroupMore &More, USceneComponent *Component, float CurrentTime, const FMovaIxActionKeyframe *FrameA, const FMovaIxActionKeyframe *FrameB, float &GlobalAlpha, float &LocalAlpha, const FMovaIxActionState *&OutStateA, const FMovaIxActionState *&OutStateB)¶

Resolves the two Keyframe States bracketing CurrentTime and the blend factors between them.

Parameters:

IC -- Interactive Component providing context.
More -- Group settings (offset mode, easing).
Component -- SceneComponent being animated.
CurrentTime -- Timeline position to evaluate.
FrameA -- Keyframe at the start of the active segment.
FrameB -- Keyframe at the end of the active segment.
GlobalAlpha -- Out: Eased progress across the whole timeline (0..1).
LocalAlpha -- Out: Eased progress within the FrameA..FrameB segment (0..1).
OutStateA -- Out: Resolved start State for the segment.
OutStateB -- Out: Resolved end State for the segment.

Returns:

True if both States resolved and the alphas are valid.

void CalculateLerpedTransform(UMovaIxComponent *IC, const FMovaIxActionGroupMore &More, USceneComponent *Component, const FMovaIxActionState &StateA, const FMovaIxActionState &StateB, float LocalAlpha, const FVector &CurrentVibrationOffset, FVector &OutLerpedLocation, FQuat &OutLerpedQuat, FVector &OutLerpedScale) const¶

Blends two States into a final location + orientation + scale at the given local alpha.

Parameters:

IC -- Interactive Component providing context.
More -- Group settings (offset mode).
Component -- SceneComponent being animated.
StateA -- Start State of the segment.
StateB -- End State of the segment.
LocalAlpha -- Eased progress within the segment (0..1).
CurrentVibrationOffset -- Procedural vibration offset to add to the result.
OutLerpedLocation -- Out: Blended location.
OutLerpedQuat -- Out: Blended orientation.
OutLerpedScale -- Out: Blended relative scale (per-axis).

void DetachCarriedObjects()¶: Detach previously carried objects, restoring physics.

bool FindKeyframeSegment(float PreviousTime, float TargetTime, int32 *PreviousIdxA, int32 &OutIdxA, int32 &OutIdxB, const FMovaIxActionKeyframe *&OutFrameA, const FMovaIxActionKeyframe *&OutFrameB) const¶

Finds the Keyframe segment (A..B) spanning the move from PreviousTime to TargetTime.

Parameters:

PreviousTime -- Timeline position in the previous frame.
TargetTime -- Timeline position to evaluate.
PreviousIdxA -- In/out: Last segment's start index, used to advance efficiently.
OutIdxA -- Out: Index of the segment's start Keyframe.
OutIdxB -- Out: Index of the segment's end Keyframe.
OutFrameA -- Out: Segment's start Keyframe.
OutFrameB -- Out: Segment's end Keyframe.

Returns:

True if a valid segment was found.

const FMovaIxActionState *GetActionState(UMovaIxComponent *IC, USceneComponent *TargetComp, const FName &StateName)¶

Resolves a named State.

Handles internal virtual States like @Current or @Zero.

Parameters:

IC -- Interactive Component providing context.
TargetComp -- SceneComponent that owns or is targeted by the State.
StateName -- Key name of the State to find.

Returns:

Pointer to the found State, or nullptr if resolution fails.

int32 GetRealKeyframeCount()¶

Number of Keyframes whose State is neither @Current nor @Zero.

0 => no real animation (just returns to current/zero).
Cached in RealKeyframeCount.

void GetStateTransform(UMovaIxComponent *IC, USceneComponent *TargetComp, const FMovaIxActionState &State, const FMovaIxActionGroupMore &More, FVector &OutLocation, FQuat &OutQuat, FVector &OutScale) const¶

Resolves a State's final location + orientation + scale, applying the Group's offset mode.

Parent / special snapshot (@Current / @Zero / @Start / @Loop): the State values are returned raw.
Component Start / Start Pose / Target: the State is a delta layered on the reference pose:
- Location is added, orientation is pre-multiplied, scale is multiplied per-axis.

Parameters:

IC -- Interactive Component providing context.
TargetComp -- SceneComponent used as the reference point.
State -- Target State data.
More -- Group settings defining offset behavior.
OutLocation -- Out: Final relative location.
OutQuat -- Out: Final relative orientation.
OutScale -- Out: Final relative scale (per-axis).

void MarkTargetsMoving(UMovaIxComponent *IC)¶

Marks every Target as moving to this Action's last Keyframe State.

A State is only set at the end of a move.

void RecomputeTimesFromVelocity(UMovaIxComponent *IC, const FMovaIxActionGroupMore &More)¶

Re-times Keyframes when a destination State defines a max speed. => An Action auto-times by travel distance (ex: an elevator).

Speed-bearing segment: timed by distance / speed (from the previous Keyframe's resolved position).
No-speed segment: keeps its own time.
No State uses speed: no-op.

void ResetPlayback()¶: Resets runtime indices and tracking accumulators before starting a new animation sequence.

FName ResolveBone(const UMovaIxComponent *IC, const USceneComponent *Component) const¶

Bone this Target drives on Component, or NAME_None for the whole Component.

Read from the resolved-Target cache (index-aligned Components / BoneNames).
Ex: Target "@Door/hinge_01" => "hinge_01" for the Door mesh Component.
One bone per Component per Target => first match wins when a mesh repeats.

const TArray<USceneComponent*> &ResolveComponents(UMovaIxComponent *IC) const¶: Resolves Target into one or more Components using a unified syntax.

USceneComponent *ResolveOffsetTarget(UMovaIxComponent *IC, const FMovaIxActionGroupMore &More) const¶

Resolves More.OffsetTarget to its first matching Component (the reference frame for the Target offset mode).

Returns nullptr if the mode is not Target, the name is empty, or nothing matches.

void SaveState(UMovaIxComponent *IC, float CurrentTime)¶

Captures the current Component State as a starting point for animation.

Parameters:

IC -- Component to capture.
CurrentTime -- Timestamp at which the capture occurs.

void StopContinuousAudio()¶

Stops any running continuous audio: classic crossfade Components A/B, and the parametric MetaSound Component.

Forgets the sustained-carryover flag.
Safe to call when nothing is running.
Called by the Group on every stop path, mirroring StopContinuousNiagara.

void StopContinuousNiagara()¶

Deactivates any running WhileActive Niagara effect, ex: shuts the fountain off.

Safe to call when nothing is running.
Called by the Group on every stop path.

bool Tick(UMovaIxComponent *IC, const FMovaIxActionGroupMore &More, float PreviousTime, float CurrentTime, float DeltaTime)¶

Main per-frame update: interpolate transforms and trigger all frame-based effects.

Parameters:

IC -- Context Component.
More -- Group settings.
PreviousTime -- Timeline position in the previous frame.
CurrentTime -- Timeline position in the current frame.
DeltaTime -- Real-world time passed since last frame.

Returns:

True if the Action is still playing.

Public Members

TArray<FMovaIxActionKeyframe> Keyframes¶: Ordered list of Keyframes defining the animation.

FName Target¶

What this Action drives, as an address.

SELECTION - which thing (start of the address):

"Light" or "@Light" a Component named Light on this Actor.
"@=Tag" a Component on this Actor carrying tag "=Tag".
"%Tag" an External Actor anywhere in the level tagged "=Tag".
"#Self" "#Parent" "#Root" "#Actor" "#Carry" "#Grab" logic-resolved specials.
Worked out relative to the tagged Component, not looked up by name or tag.

CHAINING - walk inwards with @, hop to an external Actor with %:

"%Lift@Panel" the Panel Component of the external Actor Lift.

BONES - a trailing "/Bone" on an "@" hop drives a Bone of a Poseable Mesh, not the Component. Only valid after "@", so "Mesh/Bone" on its own will not parse:

"@DoorMesh/hinge_01" the hinge_01 bone of DoorMesh, and the mesh itself stays put.

DELEGATION - a trailing "^" hands the reset of the address to that element's own IC. This IC then does not drive the Components directly with its own Keyframes:

"%Lift" we drive Lift's Components ourselves.
"%Lift^" Lift's own IC runs its own interaction.
"%Lift^@Platform" Lift's IC takes over, and Targets its Platform.

STATE - append ":State" to filter by resting State, where "!" negates:

"%Lights:On" only the =Lights Actors currently On.
"@Lock:!Off" my Lock Component, when it is not Off.

Full reference with worked examples: grammar.md in the plugin folder.

UAudioComponent *AudioCompA = nullptr¶: Audio Component A for crossfading.

UAudioComponent *AudioCompB = nullptr¶: Audio Component B for crossfading.

UAudioComponent *AudioContinuousComp = nullptr¶: Persistent MetaSound audio Component for continuous environmental effects.

int64 AudioTriggeredMask = 0¶: Bitmask tracking which Keyframe indices have already fired their one-shot audio during this playback.

TArray<FMovaIxCarriedObject> CarriedObjects¶: Objects currently carried by this Action's moving Target (not reflected, runtime only).

TMap<USceneComponent*, FMovaIxActionState> CurrentStates¶: States captured when current playback segment started.

FName GroupName¶: Name of Group owning this Action (set by parent Group).

bool bInitialCaptured = false¶: Whether the InitialState has been captured.

int32 LastReachedKF = INDEX_NONE¶: Index of the last Keyframe reached on the timeline.

TMap<USceneComponent*, FMovaIxActionState> LoopStates¶

Cached @Loop Target pose per Component (the State the timeline resumes at, t = More.LoopStartTime).

Built by CacheLoopStates at playback start. Empty for non-looping Actions.

FName Name¶: Name of this Action (set by parent Group).

UFXSystemComponent *NiagaraContinuousComp = nullptr¶

Persistent Niagara Component for a WhileActive State effect.

Ex: a fountain while a sink fills.
Spawned attached on entering the effect State. Deactivated when the State is left or the Group stops.

TArray<float> OriginalKeyframeTimes¶: Keyframe times as typed, captured before any velocity-based recompute (runtime only).

int32 RealKeyframeCount = INDEX_NONE¶

Cached real-State Keyframe count.

-1 = not computed yet.
See GetRealKeyframeCount().

TMap<USceneComponent*, FMovaIxActionState> StartStates¶

Pose captured once at playback start (the @Start anchor), held stable for the whole run.

Unlike CurrentStates (re-snapshotted per segment), this is the run's fixed reference.
Used by OffsetMode StartPose and the @Start marker so restarts continue from the current pose.

float StartTime = 0.0f¶: Time when current playback segment began.

FVector VibrationOffset = FVector::ZeroVector¶: Current vibration offset to apply on top of the calculated location.

float VibrationTimer = 0.0f¶: Accumulator timer used for procedural vibration waves.

Public Static Functions

static void ComposeDelta(EMovaIxDeltaSpace Space, const FVector &Delta, const FQuat &DeltaQuat, const FVector &RefLoc, const FQuat &RefQuat, const FQuat &ParentQuat, FVector &OutLoc, FQuat &OutQuat)¶

Composes a State's Location + Rotation delta onto a reference pose, in the chosen axis frame.

Pure math => unit-testable.
Relative: parent-space add, orientation pre-multiplies (the default).
Local: the delta follows RefQuat => a rotated object moves / turns along its own axes.
World: the delta stays in world axes, re-expressed against ParentQuat.

Parameters:

Space -- Axis frame to apply the delta in.
Delta -- State location delta.
DeltaQuat -- State rotation delta.
RefLoc -- Reference relative location.
RefQuat -- Reference relative orientation.
ParentQuat -- Attach parent's world orientation, used only by World.
OutLoc -- Out: Composed relative location.
OutQuat -- Out: Composed relative orientation.

Private Functions

void ProcessCrossing(UMovaIxComponent *IC, int32 Idx, const FMovaIxActionKeyframe &FrameA, float CurrentTime)¶: Process discrete events when a Keyframe has been crossed.

void ProcessCrossings(UMovaIxComponent *IC, float PreviousTime, float CurrentTime)¶: Iterates through the timeline to identify all Keyframes crossed since last tick.

bool ProcessInterpolations(UMovaIxComponent *IC, const FMovaIxActionGroupMore &More, float PreviousTime, float CurrentTime, float DeltaTime)¶: Process interpolations between Keyframes.

void TriggerAnimation(USceneComponent *Component, AActor *Owner, const FMovaIxActionStateAnimation &Animation)¶

Plays the State's animation on the Target if it is a SkeletalMeshComponent.

AnimMontage -> played via the mesh's AnimInstance. AnimSequence -> played as a single-node animation.
No-op when the Target is not skeletal or no animation is set.

void TriggerAudio(USceneComponent *Component, AActor *Owner, const FMovaIxActionStateAudio &Audio)¶

Triggers one-shot audio for the current frame.

Component assumed valid.

void TriggerNiagara(UMovaIxComponent *IC, USceneComponent *AnimatedComponent, const FMovaIxActionStateNiagara &Niagara)¶

Spawns / stops this State's Niagara effect when its Keyframe is reached.

Resolves the attach Component from Niagara.Target, falling back to AnimatedComponent.
WhileActive: spawns attached and keeps it alive. Re-crossing the same system is a no-op, no flicker.
OneShot: fires a self-destroying burst.
A State without a WhileActive system shuts any running effect off, ex: reaching @Zero empties the sink.

Parameters:

IC -- Interactive Component providing context (Target resolution).
AnimatedComponent -- Component this State animates, used as the fallback attach point.
Niagara -- Effect settings for the reached State.

void TriggerPhysics(USceneComponent *Component, AActor *Owner, const FMovaIxActionStatePhysics &PhysicsA)¶

Triggers physics for the current frame: impulses + continuous-force marks.

Component assumed valid.

void UpdateAudio(USceneComponent *Component, AActor *Owner, const FMovaIxActionStateMore &MoreA, const FMovaIxActionStateMore &MoreB, float GlobalAlpha, float LocalAlpha, bool bEnteredKF)¶

Updates audio for the current frame: MetaSound params + classic crossfading.

Component assumed valid.

void UpdatePhysics(USceneComponent *Component, const FMovaIxActionStatePhysics &PhysicsA)¶

Updates active physical forces.

Component assumed valid.

void UpdateTransform(UMovaIxComponent *IC, const FMovaIxActionGroupMore &More, USceneComponent *Component, const FMovaIxActionState &StateA, const FMovaIxActionState &StateB, float LocalAlpha)¶

Blends location, rotation, and scale between two States.

Component assumed valid.

void UpdateVibration(USceneComponent *Component, float DeltaTime, const FMovaIxActionStatePhysics &PhysicsA)¶

Applies procedural sinusoidal offsets.

Component assumed valid.

void UpdateVisuals(USceneComponent *Component, const FMovaIxActionStateVisuals &VisualA, const FMovaIxActionStateVisuals &VisualB, float LocalAlpha)¶

Evaluates visuals (light intensity, scale) at the current frame.

Component assumed valid.

Private Members

bool bAudioCompASustained = false¶

True while AudioCompA is the same playing sound carried over from the previous segment.

Ex: 2 keyframes in a row both naming "Ajar".

See also

FMovaIxAction::UpdateAudio

bool bWarnedFewKeyframes = false¶: Tick already warned about too few Keyframes.

bool bWarnedNoComponents = false¶

Tick already warned about having no Components.

Tick runs every frame, so one warning per Action is the cap.

Friends

friend class FMovaIxComponentVisualizer

Enums

enum class EMovaIxOffsetMode : uint8¶

Reference frame a State's Location and Rotation are expressed in.

Values:

enumerator ComponentStart¶: Deltas from the Component's captured initial pose, its @Zero snapshot. This is the default.

enumerator Parent¶

Used as-is, in the Component's parent relative space.

No offset applied.

enumerator StartPose¶

Deltas from the pose captured at each playback start, its @Start snapshot, not the fixed @Zero.

Restarting continues from the current pose instead of snapping back to @Zero.
Ex: a fan resumes spinning forward from whatever angle it coasted to a stop at.

enumerator Target¶: Deltas from the first Component matching OffsetTarget, whose pivot is the frame of reference.

enum class EMovaIxRepeatPolicy : uint8¶

Controls whether a Group can retrigger while it is not currently mid-play.

Only applies once the Group is at rest, finished or never started.
A bitmask: both flags can combine (ex: a door that neither reopens once open nor restarts mid-swing).

Values:

enumerator None¶

enumerator BlockWhenDone¶

Blocked once the Group has fully finished, and is not playing.

Ex: OpenLeft on a door already sitting fully open does not re-trigger.
A different Action, ex: CloseLeft, is unaffected.

enumerator BlockWhilePlaying¶

Blocked only while the Group is currently playing.

Ex: a one-shot flourish that should not restart while still opening.
Combine with BlockWhenDone for a door that neither reopens once open nor restarts mid-swing.

Functions

FString MovaIxRepeatPolicyToString(int32 Flags)¶: Readable debug string for a RepeatPolicy bitmask, ex: "BlockWhenDone|BlockWhilePlaying", "None".

struct FMovaIxActionGroupMore¶

#include <MovaIxActionGroup.h>

Group-wide shared settings and behavior.

Controls easing, deltas, stopping behavior and reverse Groups.

Public Members

bool bCanBeInterrupted = true¶

Whether the Group can be interrupted.

Ex: an elevator should not be, mid-travel between floors.

bool bCarryObjects = false¶

Carries dynamic objects resting on or inside the moving Target: attaches on start, detaches on end.

Scanned once when the Group starts: an object dropped in mid-motion is not picked up.

float CarryHeight = 20.0f¶: How far above the Target bounds to scan for objects to carry.

float ConfirmTime = 0.0f¶

Hold-to-confirm time (s) before the Group runs. A UI can show a filling ring.

0 executes instantly on press.
Above 0 holds the interact button that long.

TEnumAsByte<EEasingFunc::Type> EasingFunction = EEasingFunc::EaseInOut¶: Easing function applied to all animations in the Group.

float EasingExponent = 2.0f¶: Exponent for non-linear easing curves. Ex: Power for EaseIn.

TArray<FName> Gates¶

Conditions the Group requires before it may start.

Every entry must pass, ex: "Open", "@Lock:!Off".
A trailing ":!State" negates that one entry: allow and block share this one list.

float LoopStartTime = 0.0f¶

Time (s) the timeline jumps back to when a @Loop Keyframe is reached.

0 restarts from the beginning, ex: a fan or an escalator.
Above 0 skips an intro and loops only the later portion, ex: spin up over 0-1s, then loop from 1s.

EMovaIxOffsetMode OffsetMode = EMovaIxOffsetMode::ComponentStart ¶

Reference frame for this Group's State Location and Rotation values.

Component Start: deltas from each Target's captured @Zero pose, the default.
Target: deltas from the first Component matching OffsetTarget.
Parent: used as-is, in the Component's parent space.

FName OffsetTarget¶

Component used as the reference frame when OffsetMode is Target.

Resolved with the same Target syntax as Action.Target.
First match is used.

EMovaIxDeltaSpace DeltaSpace = EMovaIxDeltaSpace::Relative ¶

Axis frame the State Location and Rotation deltas travel in.

Relative: parent space, the default.
Local: rotates the delta by this Component's own relative rotation.
World: fixed world axes, the only mode that cancels the Actor's own yaw.
OffsetMode::Parent gives an absolute pose, ignoring every reference frame here.

float RampInTime = 0.0f¶

Seconds to ramp the playrate from 0 up to full when the Group starts.

0 starts at full speed instantly.
Ex: a ceiling fan reaching speed over 4s.

float RampOutTime = 0.0f¶

Seconds to coast the playrate from full down to 0 when the Group stops.

0 uses the normal stop: StopSpeedFactor for a non-looping Group, immediate otherwise.
For a looping Group, the timeline decelerates and stops in place, with no return to @Zero and no reverse.

int32 RepeatPolicy = 0 | static_cast<int32>(EMovaIxRepeatPolicy::BlockWhenDone) | static_cast<int32>(EMovaIxRepeatPolicy::BlockWhilePlaying)¶

Whether the Group can retrigger while it is not currently playing (combinable flags).

BlockWhenDone: no re-run once at rest at its own end pose. Ex: OpenLeft on an already-open door.
BlockWhilePlaying: no re-run while mid-play. Ex: OpenLeft on a door already swinging open.
Default blocks both, ex: a door that neither reopens once open nor restarts mid-swing.
Neither flag set: always allowed, ex: a doorbell Group replayed on every press.

float StopSpeedFactor = 0.25f¶: Multiplier on total duration when stopping mid-play for a smooth landing. Non-looping Groups only.

struct FMovaIxActionGroup¶

#include <MovaIxActionGroup.h>

Collection of Actions triggered together as a Group.

Ex: a lever pull that animates the lever, a light and a gear at once.

Public Functions

float ComputeTimeline(bool bForce = false)¶

Computes and caches this Group's total duration and loop trigger time.

Parameters:: bForce -- Ignores the cached values and recalculates.
Returns:: Total duration in seconds.

void DetachCarriedObjects()¶: Detaches all objects carried by this Group's Actions.

float GetNormalizedProgress() const¶: Normalized progress, 0.0 to 1.0, against the Group's total duration.

bool HasStopControl() const¶: True when any Action holds a @Stop or @StopNow control Keyframe.

bool IsInteractable(UMovaIxComponent *IC, FText *OutBlockedReason = nullptr) const¶

Whether this Group may be triggered right now.

True while playing: interrupting it is a separate decision, More.bCanBeInterrupted.
Otherwise resolved from More.RepeatPolicy AND More.Gates (both must allow it).
Ex: CloseLeft undoing OpenLeft's end pose makes OpenLeft interactable again.
Ex: "OpenLeft" gated by "?:!OpenedRight" reads false while OpenedRight holds.
A UI, ex: the default prompt, uses this to hide/gray a choice already done or blocked by its own Gates.

See also

EMovaIxRepeatPolicy

Parameters:

IC -- Owning Component, resolves live States and Gate conditions.
OutBlockedReason -- Optional: on a false return, the first reason it fails, in words.

void StartPlayback(UMovaIxComponent *IC)¶: Initializes all internal Actions and starts the shared timeline.

void Stop(UMovaIxComponent *IC, bool bImmediate)¶

Stops all Actions.

Parameters:

IC -- Context Component.
bImmediate -- True snaps to the current position, false performs a smooth stop.

void StopContinuousAudio()¶: Fades out and forgets every Action's continuous audio Components: crossfade A/B and MetaSound.

void StopContinuousNiagara()¶: Deactivates every Action's WhileActive Niagara effect. Ex: all fountains off when the Group stops.

bool Tick(UMovaIxComponent *IC, float DeltaTime, float OverrideTime = -1.0f)¶

Steps the shared timeline and ticks every child Action.

Parameters:

DeltaTime -- Time passed since the last tick.
OverrideTime -- Manually sets the new ElapsedTime instead of advancing it.

Returns:

True when the Group was playing to begin with.

Public Members

TMap<FName, FMovaIxAction> Actions¶

Individual Actions that run in parallel.

Key is the unique Action name within the Group.

FMovaIxActionGroupMore More¶: Shared settings for the entire Group.

FName BaseName¶

Original Action name before target-key combination.

Routes replication on clients.

FName BaseTarget¶

Original Target name before target-key combination.

Routes replication on clients.

float CurrentSpeed = 1.0f¶: Current playrate multiplier, 0 to 1, eased by RampInTime and RampOutTime.

float ElapsedTime = 0.0f¶: Current elapsed time for the Group timeline.

float LoopTriggerTime = -1.0f¶: Time of the earliest @Loop Keyframe across all Actions, or -1 when the Group does not loop.

FName Name¶: Name of this Group, assigned by the parent Component.

bool bPlaying = false¶: Whether the Group is currently ticking.

bool bPreviewing = false¶

ControlPanel requested an update.

Reset to false after the frame is rendered.

bool bRampingOut = false¶: True while coasting a looping Group to a halt in place, with the playrate ramping to 0 over RampOutTime.

bool bStopping = false¶: True when a stop command is being processed with interpolation.

float StopRemaining = 0.0f¶: Remaining time countdown when performing a smooth stop.

bool bStopRequested = false¶

Set by a gate's StopGroup flow.

Group completes at the end of its current Tick.

float StopTargetTime = 0.0f¶: Calculated Target time to reach during a smooth stop.

float TotalDuration = -1.0f¶

Cached total Group duration.

Computed once on start or change.

Core enums and small types¶

Enums

enum class EMovaIxAnimationPreviewFlags : uint8¶

How the live animation preview is shown. Ghost and RealObject can be combined.

Values:

enumerator None¶

enumerator Ghost¶: Draw the animated wireframe ghost.

enumerator RealObject¶: Move the real Component. Only while scrubbing the timeline, restored on release.

enum class EMovaIxDebugDrawFlags : uint8¶

Controls which debug elements are drawn.

Values:

enumerator None¶

enumerator Bounds¶: Bounding box of the selected object.

enumerator Gates¶: Gate tokens with live pass / fail State floated over the aimed Actor.

enumerator LineOfSight¶: Line of sight, red when blocked and green when clear.

enumerator PointLine¶: Line from the player or camera to the best point.

enumerator Points¶

Every interaction point of the aimed Actor, not only the best one.

Each gets a sphere and an anchor label.

enumerator PointSphere¶: Sphere on the best point.

enumerator Tags¶

Per-target address tokens floated over the aimed Actor, resolved and unresolved.

Tokens are @ for a Component, % for an external Actor, ^ for delegated execution.

enumerator ViewCone¶: Interaction view cone, ViewAngle wide, from the player origin.

enum class EMovaIxPromptAnchor : uint8¶

Where on the Target's bounding box the interaction prompt is anchored, before PromptOffset.

Values:

enumerator ActorOrigin¶: Actor's raw pivot, ignoring bounds entirely. Cheap: skips the per-tick bounds pass every Bound* option pays.

enumerator BoundBottom¶: Bottom of the bounding box.

enumerator BoundCenter¶: Center of the bounding box.

enumerator BoundLeft¶: Left face of the bounding box, Min.X.

enumerator BoundRight¶: Right face of the bounding box, Max.X.

enumerator BoundTop¶: Top of the bounding box.

enumerator Point¶

Resolved InteractivePoint location, FMovaIxPoint::Location. Default, cheap like ActorOrigin: no per-tick bounds pass.

Correct for a multi-point object where the bounds center is not the interaction.

enum class EMovaIxDirectionSource : uint8¶

Which direction is used for interaction detection and targeting.

Values:

enumerator CameraView¶: Follows the Camera's orientation entirely.

enumerator PawnForward¶: Follows the Pawn's facing direction entirely.

enumerator Hybrid¶: Pawn's forward vector for the global direction, with the Camera allowed small adjustments.

enum class EMovaIxFocusTrigger : uint8¶

When the interactor drives an optional focus camera, a MovaFocusController on the pawn.

No controller present makes every mode a silent no-op, and interaction still works.

Values:

enumerator Off¶: Don't drive a focus camera.

enumerator Hover¶: Focus as soon as an object becomes the best Target, release when it stops being the Target.

enumerator Engage¶: Focus only once the player commits to interacting, release when the Target is left.

enumerator Hold¶

Frame while the button is held, release the moment it goes up => hold-to-inspect.

A one-shot: frames once, then the player owns the camera (look + zoom).

enum class EMovaIxViewMode : uint8¶

Camera perspective the interactor assumes for targeting and focus behavior.

Values:

enumerator Auto¶: Detect from the pawn and camera setup, spring arm or camera distance.

enumerator FirstPerson¶: First-person: camera at the eyes.

enumerator ThirdPerson¶: Third-person: camera behind the character.

enum class EMovaIxPropertySearchFlags : uint8¶

Which native Details search boxes are enabled in the Control Panel's Inspector.

Values:

enumerator None¶

enumerator More¶: Native search box on every per-Group/State/Cycle "More" struct editor.

enumerator Advanced¶: Native search box on the "Advanced" section.

enum class EMovaIxVisualizerDrawFlags : uint8¶

Controls which elements the Interactive Component Visualizer draws in the editor viewport.

Values:

enumerator None¶

enumerator Animation¶: Moving live preview mesh ghost.

enumerator Arrow¶: Arrow showing the movement direction.

enumerator Gizmo¶: Coordinates gizmo located at the Pivot.

enumerator Keyframes¶: Static Keyframe ghost volumes.

enumerator PathLines¶: Motion path lines and trajectory curves.

enumerator Pivot¶: Wireframe diamond located at the Pivot.

enumerator Shadow¶: Ground projection line and anchor circle.

enumerator Trail¶: Trail following the animation.

Addressing¶

MovaIxAddress.h and MovaIxUtils.h both extend the same MovaIx namespace (parsing/resolution helpers and small free-function utilities respectively), shown together here to avoid duplicating the namespace's documentation:

enum class MovaIx::EMovaIxStatePhase : uint8¶

What a ':State' test accepts, set by a mark before the State name.

A State is only set at the end of a move.

Values:

enumerator Either¶: ":State", on its way there or already there, the default.

enumerator Moving¶: ":~State", the move is still going.

enumerator Settled¶: ":=State", the move ended.

enum class MovaIx::EMovaIxTokenRole : uint8¶

Role a whole-tag token plays, from its prefix alone,

See also

GRAMMAR.md.

Values:

enumerator None¶: Normal Tag.

enumerator Address¶: Address selecting what an Action drives: '@', '', '#', or only ':State'.

enumerator Gate¶: Inline '?' precondition, its payload after the '?' being an address.

enumerator Identity¶: Identity tag '=Name', naming this Actor instead of selecting anything.

enumerator Marker¶: Reserved marker '~Name', consumed by game-side systems and ignored by the Action parser.

enumerator Offset¶: Point placement '$X,Y,Z'.

enumerator Verb¶: Flow verb starting an Action: !Parallel, >Choice, +Extension.

FMovaIxTokenInfo MovaIx::ClassifyToken(const FString &Token, bool bFirstToken)¶

Reads one whole-tag token, the same split the tag parser does.

Shared: the editor chips and the runtime agree.
Takes only the string: no Component, no Actor, no world.
Checks the grammar, names being the caller's job.

Parameters:

Token -- One space-separated token from an interaction tag. Ex: "!Open", "?@Lock:Off", "@Door", "=Door".
bFirstToken -- True for a tag's first token, ex: "Open @Door" needs no '!'.

Returns:

Role, payload, parsed address, and any error.

FText MovaIx::DescribeGate(const FString &Gate)¶

Turns a '?' gate into a phrase a player can read, ex: "needs Drawer1 closed".

For a prompt row that is visible but blocked, where the raw "?@Drawer1:!Open" means nothing.
Reads the same grammar IsStateConditionMet evaluates => words match the rule.
Negation reads as "not", ex: "@Lock:!Off" => "needs Lock not Off".
Phase markers read as motion: ":~Open" => "while Opening", ":=Open" => "once Open".

Parameters:: Gate -- Gate token, with or without its leading '?'.
Returns:: Phrase naming what must hold, or the token itself when it does not parse.

FMovaIxAddress MovaIx::ParseAddress(const FString &Str)¶

Parses one address token into its structure.

Input is a single space-separated token with no flow verb and no leading '?' gate marker.
See also

GRAMMAR.md for the full grammar.

Parameters:: Str -- Address token. Ex: "%Lift^@Panel", "@Lock:!Off", ":Open".
Returns:: Parsed address, valid only when bValid is set.

FString MovaIx::RenameComponentInTag(const FString &Tag, const FString &OldName, const FString &NewName)¶

Renames a Component of the current Actor across a full space-separated tag string.

First part is the flow and verb, never an address => left alone.
A '?' gate's payload is rewritten like any other address.

Parameters:

Tag -- Full tag string. Ex: "!Open @Door ?@Lock:Off".
OldName -- Component name to replace.
NewName -- Replacement Component name.

Returns:

Rewritten tag, or the input unchanged when nothing matched.

FString MovaIx::RenameComponentInToken(const FString &Token, const FString &OldName, const FString &NewName)¶

Renames a Component of the current Actor inside one address token.

Only '@Name' hops that this Actor's IC resolves itself are touched:

'=Tag' is a match by tag => names no Component and is never rewritten.
'Actor' is an external Actor tag, never a Component.
'#Self' and friends are logic-resolved.
Anything past a '' hop or '^' delegation belongs to another Actor entirely.
Rewriting it retargets the Action with no warning.

Parameters:

Token -- Single address token, no flow verb and no leading '?'.
OldName -- Component name to replace.
NewName -- Replacement Component name.

Returns:

Rewritten token, or the input unchanged when nothing matched or it did not parse.

FString MovaIx::ToString(const FMovaIxAddress &Addr)¶

Rebuilds the canonical text of a parsed address.

ParseAddress then ToString is the identity for every valid token. => A rewrite changes only the part that was actually changed.

Parameters:: Addr -- Parsed address.
Returns:: Address text. Empty for an invalid address.

void MovaIx::DrawDebugArrow(UWorld *World, const FVector &From, const FVector &To, const FColor &Color = FColor::Red, float Thickness = 1.0f, float LifeTime = -1.0f)¶

Draws a debug directional arrow in the world.

Useful for interaction rays, hit directions, or animation paths.

Parameters:

World -- World context, usually GetWorld().
From -- Start location of the arrow in world space.
To -- End location of the arrow in world space.
Color -- Color of the arrow.
Thickness -- Line thickness, clamped between 0.5 and 10.0.
LifeTime -- How long the arrow remains visible. -1.0f is persistent in editor, one frame in game.

void MovaIx::DrawDebugCrosshair(UWorld *World, const FVector &Center, const FVector &Right, const FVector &Up, float HalfSize, const FColor &Color = FColor::White, float Thickness = 1.5f, float LifeTime = -1.0f, uint8 DepthPriority = 0)¶

Draws a flat crosshair of 2 crossing lines at a world location, oriented to face a camera.

Parameters:

World -- World context, usually GetWorld().
Center -- World location of the crosshair center.
Right -- Camera right vector, which defines the horizontal line.
Up -- Camera up vector, which defines the vertical line.
HalfSize -- Half-length of each line arm in world units.
Color -- Crosshair color.
Thickness -- Line thickness.
LifeTime -- How long the crosshair remains visible. -1.0f is one frame in game.
DepthPriority -- Scene depth priority Group. SDPG_Foreground draws on top of geometry.

USceneComponent *MovaIx::FindBestRoot(USceneComponent *ClickedComp)¶

Walks up from a Component to its best logical Root. Ex: "Drawer1" from "Drawer1Front".

Climbs while a parent's name ends "Root" or the child name starts with the parent name.
Stops at the Actor Root.
Groups the interacted Component with its siblings, for selection routing and tiered outlines.

Parameters:: ClickedComp -- Component to start from.
Returns:: Best Root Component, possibly ClickedComp itself. Null only when ClickedComp is null.

FString MovaIx::GetActorDebugName(const AActor *Actor)¶

Safe debug name for an Actor.

Editor returns the friendly Label.
Packaged returns the internal Name.

Parameters:: Actor -- Actor to name.
Returns:: Label or name of the Actor.

FString MovaIx::GetActorDebugName(AActor *Actor)¶

Overload taking a non-const Actor.

Parameters:: Actor -- Actor to name.
Returns:: Label or name of the Actor.

FString MovaIx::GetActorDebugName(const UActorComponent *Component)¶

Debug name of a Component's owner, or the Component name when it has no owner.

Parameters:: Component -- Component to evaluate.
Returns:: Owner's label or name, or the Component's name.

FString MovaIx::GetActorDebugName(UActorComponent *Component)¶

Overload taking a non-const Component.

Parameters:: Component -- Component to evaluate.
Returns:: Owner's label or name, or the Component's name.

FString MovaIx::GetActorStemName(AActor *Actor)¶

Extracts the middle "Stem" of an Actor's name. Ex: "Elevator" from "BP_Elevator_IO_01".

Assumes the format Prefix_Stem_Suffix.

Parameters:: Actor -- Actor whose name is parsed.
Returns:: Extracted stem, or the full name when there are no underscores.

TCHAR MovaIx::GetFirstChar(const FName &Name)¶: First character of a Name, or '\0' when the Name is empty.

FLinearColor MovaIx::GetInteractionRoleColor(int32 TagCount, bool bTarget, bool bIsolatedGroupTarget)¶

Color that identifies a Component's interaction role. Shared by the Control Panel's hierarchy rows and the viewport's [TAG] and [Target] badges. Only place these colors are computed. Both views call it, a change here moves both at once.

Condition	Color	Reads as
Targeted by the isolated Group	Cyan	"The isolated group moves this"
Has tags and is a Target	Green	"Fully wired: it triggers and it moves"
Has tags only	Yellow	"You can interact with this"
Is a Target only	Blue	"Something else moves this"
Neither	Gray	"Not part of any interaction"

Parameters:

TagCount -- Number of interaction tags on the Component.
bTarget -- Whether any Action Targets this Component.
bIsolatedGroupTarget -- Whether the currently isolated Group Targets it.

bool MovaIx::IsWithinInteractRange(const FVector &InstigatorLocation, const FVector &TargetLocation, float MaxDistance)¶

True when an instigator is close enough to a Target to interact. Server-side anti-cheat range test.

MaxDistance <= 0 disables the test and always returns true.

Parameters:

InstigatorLocation -- World location of the interacting pawn.
TargetLocation -- World location on or nearest the Target. Ex: closest point on its bounds.
MaxDistance -- Allowed distance, <= 0 means unlimited.

Returns:

True when within range, or when the test is disabled.

FString MovaIx::MakeOppositeName(const FString &Name, const FString &Suffix = TEXT("Reverse"))¶

Best-effort "reverse" name for a Group or State that reads like a verb.

Substitutes a known opposite word found anywhere in Name, ex: Open<=>Close, On<=>Off.

Matched whole-word: only replaces at a real word boundary.
Ex: "LightOpen" -> "LightClose", "DoorOpen" -> "DoorClose".
A name like "Open123" has no word boundary after "Open" and is left alone, not mangled.
Case of the matched word is preserved: Open, open and OPEN map to Close, close and close.
Falls back to Name + Suffix when no known opposite is found anywhere in Name.

Parameters:

Name -- Source name to find an opposite for. Ex: "LightOpen".
Suffix -- Fallback suffix appended to Name when no opposite word is recognized.

Returns:

The opposite name, or Name + Suffix as a fallback.

FLinearColor MovaIx::MakeRandomColor(bool bVivid = true)¶

Builds a random color via HSV: hues spread evenly, unlike raw RGB randomness.

Parameters:: bVivid -- True for bright, saturated colors, false for softer pastels.
Returns:: Random linear color, alpha 1.

FString MovaIx::MakeStatedName(const FString &Name)¶

Best-effort "reached" name for a Group's trailing verb, turning an Action into the State it leaves.

Ex: Open -> Opened, Close -> Closed.

Matched whole-word the same way as MakeOppositeName, same boundary and capitalization rules.
Same "Last word wins" rule when a name holds more than one candidate.
Ex: "OpenDoorClose" -> "OpenDoorClosed".
Words with no natural past participle map to themselves: On, Off, Up, Down, In, Out.
Falls back to Name unchanged when nothing is recognized.

Parameters:: Name -- Source Group or Action name to derive a State name from. Ex: "DoorOpen".
Returns:: The state-form name, or Name unchanged as a fallback.

void MovaIx::PaintActor(AActor *Actor, const FLinearColor &Color, FName ParamName = TEXT("Color"))¶

Tints every primitive Component on an Actor.

See also

PaintComponent.

Parameters:

Actor -- Actor whose primitives are tinted.
Color -- Color to write into the parameter.
ParamName -- Material vector parameter name to drive.

void MovaIx::PaintComponent(UPrimitiveComponent *Prim, const FLinearColor &Color, FName ParamName = TEXT("Color"))¶

Tints every material slot of a primitive, by setting a vector parameter on a dynamic instance.

Target materials must expose a vector parameter matching ParamName.
Otherwise this is a visual no-op.

Parameters:

Prim -- Primitive whose materials are tinted.
Color -- Color to write into the parameter.
ParamName -- Material vector parameter name to drive.

bool MovaIx::ParsePointOffsetToken(const FString &Token, FVector &OutOffset)¶

Parses a "$X,Y,Z" point-offset token into a Component-space offset.

Component space, not Actor space: offset follows the part when it swings.
Any of the 3 Components may be omitted: "$0,0,50" and "$,,50" mean the same thing.

Parameters:

Token -- Whole token including the leading '$'.
OutOffset -- Receives the parsed offset when parsing succeeds.

Returns:

True when the token was a well-formed offset.

void MovaIx::RandomizeActorColors(AActor *Actor, FName ParamName = TEXT("Color"), bool bVivid = true)¶

Tints each material slot of every primitive on an Actor with its own random color.

A multi-material mesh ends up with several different colors.
Ex: a character with 2 slots.
Slots must expose the param.

Parameters:

Actor -- Actor whose material slots are tinted.
ParamName -- Material vector parameter name to drive.
bVivid -- Bright saturated colors, or softer pastels when false.

FName MovaIx::ReplaceFirstChar(const FName &Name, TCHAR NewChar)¶

Returns Name with its first character replaced by NewChar. Ex: "@Target" -> "=Target".

Uses FNameBuilder: no intermediate FString heap churn.
None stays None.

bool MovaIx::ShouldLog(ELogVerbosity::Type InVerbosity)¶

Whether a UE_LOG(LogMovaIx, InVerbosity, ...) call at InVerbosity should actually emit.

Uses UMovaIxSettings::MinLogVerbosity.
Independent of Unreal's own per-category console verbosity command.
Fatal always passes.

FString MovaIx::SplitCycleStepLabel(const FString &Step, FString &OutLabel)¶

Remove a "(Turn on)" display label from a Cycle step, at the start or at the end.

Only a whole bracketed token at the very start or very end counts.

Parameters:

Step -- Whole step string.
OutLabel -- Receives the label text, brackets removed, or empty when there is none.

Returns:

Step with the label and its surrounding space removed.

TPair<FName, FName> MovaIx::SplitString(const FString &Str)¶: Splits a string of the form "Actor|SubTarget" into the pair ("Actor", "SubTarget").

bool MovaIx::AreMovaIxTimingsEnabled()¶: Whether timing collection is switched on (UMovaIxSettings::bDebugTimings).

void MovaIx::BeginMovaIxSelectionEpoch()¶

Opens a click-to-ready measurement, if none is open.

One click fires several selection events and the rebuild is deferred to end of frame.

void MovaIx::EndMovaIxSelectionEpoch()¶: Closes the click-to-ready measurement and reports it, deferred work included.

TArray<FMovaIxTimingEntry> &MovaIx::GetMovaIxTimings()¶: Timings for the most recent selection, oldest first, cleared at the start of each one.

void MovaIx::MarkMovaIxSection(const FString &Label)¶

Starts a section and closes the previous one, for sequential blocks that are not C++ scopes.

Empty label closes the last section without opening another.

void MovaIx::ReportMovaIxTimings()¶

Prints the recorded stages on screen and to the log.

On screen, not in the panel: the cost is paid with the panel hidden, ex: from the Outliner.

void MovaIx::ResetMovaIxTimings()¶: Drops every recorded step and resets nesting, called once when a new selection begins.

struct FMovaIxAccumTiming¶

#include <MovaIxUtils.h>

Sums every scope sharing InLabel into one reported entry.

A per-row timer in a loop of hundreds buries the report it belongs to.

Public Functions

explicit FMovaIxAccumTiming(const TCHAR *InLabel)¶

~FMovaIxAccumTiming()¶

struct FMovaIxAddress¶

#include <MovaIxAddress.h>

A parsed address token: an optional path of hops plus an optional trailing ":State" test.

Ex: "%Lift^@Panel:Docked" => 2 hops + State "Docked".
Ex: ":Off" => no hops + self State "Off".

Public Functions

inline bool HasState() const¶: True when a ":State" test is present.

inline bool IsSelfState() const¶: True for a ":State" on its own, which has no address and means this IC's own State.

Public Members

TArray<FMovaIxHop> Hops¶: Path, left to right. Empty for a ":State" self-test.

bool bStateNegated = false¶: ":!State" negates the State test.

EMovaIxStatePhase StatePhase = EMovaIxStatePhase::Either ¶

Which phase of the State the test accepts.

Unmarked ":State" takes both.

FString StateTest¶: Trailing State name after ':'. Empty when there is none.

bool bValid = false¶: True when the string parsed cleanly under the grammar.

struct FMovaIxHop¶

#include <MovaIxAddress.h>

One hop in an address path.

Ex: the "@Panel" in "%Lift^@Panel".

Public Members

FString BoneName¶

Trailing "/Bone" on a '@' hop Targets that bone of the resolved skeletal or poseable mesh.

Empty means the whole Component.
Ex: "@DoorMesh/hinge_01" => Name "DoorMesh", BoneName "hinge_01".

bool bByTag = false¶: "@=" matches the Component by its tag instead of its name. Only meaningful for '@'.

bool bDelegate = false¶: Trailing '^' hands the rest of the path to this element's own IC.

FString Name¶

Identifier after the scope char.

May hold a '*' wildcard.
For '#' it is the marker name.

TCHAR Scope = TEXT('\0')¶

Scope character:

'@' a Component on the current Actor.
'' an external Actor (always by tag).
'#' special marker.

struct FMovaIxScopedTiming¶

#include <MovaIxUtils.h>

Times a step, recording it on scope exit.

Free while bDebugTimings is off.

Public Functions

explicit FMovaIxScopedTiming(FString InLabel)¶: Opens the step and reserves its slot: prints above its children.

~FMovaIxScopedTiming()¶: Closes the step and writes its elapsed time.

struct FMovaIxTimingEntry¶

#include <MovaIxUtils.h>

One timed step of a selection: label, nesting depth, elapsed ms.

Public Members

int32 Depth = 0¶: Nesting level, 0 = outermost => printed as indentation.

FString Label¶: Name of the step.

double Milliseconds = 0.0¶: Elapsed time, 0 until the step closes.

struct FMovaIxTimingSession¶

#include <MovaIxUtils.h>

Captures timings for one scope and reports them on exit.

Declare before any FMovaIxScopedTiming, or it reports incomplete data.

Public Functions

FMovaIxTimingSession()¶: Drops the stages of the previous session.

~FMovaIxTimingSession()¶: Reports everything recorded during the session.

struct FMovaIxTokenInfo¶

#include <MovaIxAddress.h>

One token of an interaction tag, checked against the grammar.

Public Members

FMovaIxAddress Address¶: Parsed address, only set for an Address or a Gate that parsed.

FString Error¶: Why the token is wrong, ready to show, empty if bValid.

FString Payload¶: Token with its role prefix cut, ex: "Open" from "!Open".

EMovaIxTokenRole Role = EMovaIxTokenRole::Address ¶: What the token is for.

bool bValid = false¶: True if the token is well formed for its role.

See Tag Grammar Reference for the human-readable grammar this parses.

class UMovaIxLibrary : public UBlueprintFunctionLibrary¶

Blueprint wrapper for the MovaIx utilities: reachable from the editor.

Public Static Functions

static void DrawDebugArrow(UObject *WorldContextObject, FVector From, FVector To, FColor Color = FColor::Red, float Thickness = 1.0f, float LifeTime = 2.0f)¶

Draws a debug directional arrow.

Parameters:

WorldContextObject -- Object used to derive the world.
From -- Start location of the arrow.
To -- End location of the arrow.
Color -- Color of the arrow.
Thickness -- Thickness of the lines, 0.5 to 10.0.
LifeTime -- How long the arrow stays visible.

static FString GetActorStemName(AActor *Actor)¶

Stem name of an Actor, the part between the first and second underscore.

Parameters:: Actor -- Target Actor.
Returns:: Extracted stem. Ex: "Elevator".

static FLinearColor MakeRandomColor(bool bVivid = true)¶

Builds a random color, HSV-based for an even hue spread.

Parameters:: bVivid -- Bright saturated colors, or softer pastels when false.
Returns:: Random linear color.

static void PaintActor(AActor *Actor, FLinearColor Color, FName ParamName = TEXT("Color"))¶

Tints every primitive on an Actor by driving a material vector parameter.

Target materials must expose the parameter for the change to be visible.

Parameters:

Actor -- Actor to tint.
Color -- Color applied to the parameter.
ParamName -- Material vector parameter name.

static void PaintComponent(UPrimitiveComponent *Component, FLinearColor Color, FName ParamName = TEXT("Color"))¶

Tints a single primitive by driving a material vector parameter.

See also

PaintActor.

Parameters:

Component -- Primitive to tint.
Color -- Color applied to the parameter.
ParamName -- Material vector parameter name.

static void RandomizeActorColors(AActor *Actor, FName ParamName = TEXT("Color"), bool bVivid = true)¶

Tints each material slot of an Actor with its own random color, for multi-material variety.

Parameters:

Actor -- Actor to tint.
ParamName -- Material vector parameter name.
bVivid -- Bright saturated colors, or softer pastels when false.

Save data¶

struct FMovaIxCarriedSave¶

#include <MovaIxSaveGame.h>

One object a Group was carrying at save time, under bCarryObjects.

Group is restarted first and only scrubbed to its saved phase afterwards.
A re-scan runs with the Target at its rest pose.

Public Members

FString CarriedActorId¶: Actor being carried, by the same id scheme as FMovaIxActorSave::ActorId.

FName GroupName¶: Group that was carrying it, matching a key in RunningGroups.

FTransform RelativeTransform = FTransform::Identity¶: Pose relative to that Target: returns where the player left it.

FName TargetComponentName¶: Component of this Actor it was attached to: the same Target reclaims it.

bool bWasSimulatingPhysics = false¶: Whether its physics was simulating before the carry parked it: release restores that.

struct FMovaIxComponentSave¶

#include <MovaIxSaveGame.h>

Saved transform/visibility of one scene Component.

Public Members

FName ComponentName¶: Name of the Component this record applies to.

FTransform RelativeTransform = FTransform::Identity¶: Transform to restore on the Component relative to its parent.

bool bVisible = true¶: Visibility to restore on the Component.

struct FMovaIxActorSave¶

#include <MovaIxSaveGame.h>

Saved runtime State of one interactive Actor, keyed by the Actor's name.

Public Members

FString ActorId¶: Stable identifier of the Actor this record applies to.

TArray<FMovaIxCarriedSave> CarriedObjects¶

Everything the running Groups were carrying at save time.

Restored by re-attaching directly, not by re-running the overlap scan.
See FMovaIxCarriedSave.

TArray<FMovaIxComponentSave> Components¶: Saved transform/visibility of every tracked scene Component on this Actor.

TArray<FName> CurrentStates¶: Named States the Actor's IC(s) were resting in at save time.

TMap<FName, int32> CycleIndices¶: Runtime cycle step index at save time, keyed by cycle name.

TMap<FString, FMovaIxActionState> InitialStates¶: @Zero resting State of each animated Component, keyed by Component path.

TMap<FName, float> RunningGroupTimes¶

Per-running-group timeline position at save time, in seconds of ElapsedTime.

Keyed by the same runtime Group key stored in RunningGroups.
Restores the exact phase: a looping animation resumes mid-cycle.

TArray<FName> RunningGroups¶

Runtime keys of every Action Group that was still playing at save time.

Re-executed on load: an endless interaction resumes.

class UMovaIxSaveGame : public USaveGame¶

#include <MovaIxSaveGame.h>

Snapshot of every interactive object in the level.

Public Members

TArray<FMovaIxActorSave> Actors¶: Saved record for every interactive Actor in the level.

FString MapName¶: Level this snapshot was taken in.

int32 Version = 1¶: Save format version, for future migration.

class UMovaIxSaveLibrary : public UBlueprintFunctionLibrary¶

#include <MovaIxSaveGame.h>

Blueprint entry points for saving/loading interactive object State at runtime.

Public Static Functions

static bool LoadInteractiveGame(UObject *WorldContextObject, const FString &SlotName = TEXT("InteractiveSave"))¶

Restore every InteractiveComponent's State from a slot. Returns false when the slot is missing.

Parameters:

WorldContextObject -- Any object in the world to restore.
SlotName -- Save slot to load from.

static bool SaveInteractiveGame(UObject *WorldContextObject, const FString &SlotName = TEXT("InteractiveSave"))¶

Snapshot every InteractiveComponent's State into a slot.

Parameters:

WorldContextObject -- Any object in the world to snapshot.
SlotName -- Save slot to write to.

See Save & load.