ue-mover

UE Mover

Target engine: UE 5.8. APIs below are verified against the 5.8 headers; older forms are listed under "Deprecated — do not use".

Mover is Epic's modular movement system, shipped as the Mover plugin (Experimental in 5.8 — APIs and data formats are subject to change). Movement is composed from data-driven objects — UBaseMovementMode, FLayeredMoveBase, FMovementModifierBase, FInstantMovementEffect, UBaseMovementModeTransition — hosted by UMoverComponent and driven by an external backend liaison rather than by TickComponent. Build.cs module names: "Mover" (plus "ChaosMover" for physics-driven movement, "NetworkPrediction" for the rollback backend, "MoverMassIntegration" for Mass). Public headers live under Plugins/Experimental/Mover/Source/Mover/Public. Log category is LogMover; console commands are prefixed Mover. and mover..

Context

Read .agents/ue-project-context.md if it exists (module names, conventions, enabled plugins, GAS/networking setup). Do not stop if it is missing.

Identify the area from the request and the codebase. Ask only when two plausible readings would produce different code.

Request is about…	Go to
Choosing between CMC and Mover	CMC vs Mover
Enabling plugins, Build.cs, project settings	Setup
Component, mode map, shared settings, what owns what	Architecture
Where a simulation tick goes, substeps, mixing	Tick Flow
Walk/climb/glide/zipline — a new movement type	Movement Modes
Dash, launch, knockback, homing, root motion	Layered Moves
Crouch, stance, settings swaps	Movement Modifiers
Teleport, one-shot impulse, forced mode change	Instant Movement Effects
Automatic mode switching rules	Transitions
Translating Enhanced Input into a Mover input cmd	Input Production
Custom per-frame data, position, velocity, persistence	Input and Sync State
Backends, rollback, resimulation, what must replicate	Backends and Networking
Reading velocity/mode, binding delegates, gameplay tags	Reading State and Events
Motion matching, trajectory, AI pathfollowing, Mass	Integration Points

Full templates live in mover-recipes.md; the default movement set catalogue, data-model detail, utility libraries and debugging live in mover-reference.md.

CMC vs Mover

Mover is not a drop-in UCharacterMovementComponent replacement, and UMoverComponent does not require ACharacter — a USceneComponent root is the only hard requirement. This table matches the one in ue-character-movement.

Situation	Use
Shipping title, any engine-supported platform	CMC
Existing ACharacter hierarchy, animation and AI already wired to CMC	CMC
Networked gameplay that must be stable today	CMC
Non-capsule, non-humanoid movers (vehicles, drones) that still want rollback networking	Mover
Movement composed from data-driven modes/modifiers instead of a Phys* subclass	Mover
Movement simulated on the physics thread with Chaos	Mover (ChaosMover)
Prototype that can absorb Experimental API churn	Mover

Concept mapping: CMC movement modes → UBaseMovementMode objects; root motion sources → FLayeredMoveBase; LaunchCharacter/TeleportTo → FInstantMovementEffect; crouching → FMovementModifierBase; mode-change conditions scattered in Phys* → UBaseMovementModeTransition.

Do not put both components on one pawn. Unlike CMC, Mover state is not externally writable: there is no Velocity property to assign. Change motion only through modes, layered moves, modifiers and instant effects.

Setup

Enable Mover (Experimental in 5.8). It pulls in NetworkPrediction (Beta in 5.8), MotionWarping, PoseSearch, Water and ChaosVD. Optional companions: MoverExamples (Experimental — sample maps and pawns), ChaosMover (Experimental — physics backend), MoverAnimNext (Experimental — UAF bridge), MoverIntegrations (Experimental — Mass).

// MyGame.Build.cs
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "Mover", "GameplayTags" });
// Add "EnhancedInput" when the pawn binds input actions (the pawn recipe includes EnhancedInputComponent.h).
// Add "ChaosMover" only for physics-driven Mover actors.
// Add "MoverMassIntegration" only when driving Mover pawns from Mass.

Project Settings → Plugins → Network Prediction (UNetworkPredictionSettingsObject, config=NetworkPrediction), recommended starting point from the plugin README:

Setting	Value	Why
PreferredTickingPolicy	ENetworkPredictionTickingPolicy::Fixed	Shared timeline, group rollback
SimulatedProxyNetworkLOD	ENetworkLOD::Interpolated	Other players' pawns forward-predict badly
bEnableFixedTickSmoothing	true	Fixed sim rate vs variable render rate

With smoothing on, set the component's SmoothingMode to EMoverSmoothingMode::VisualComponentOffset (the default). Single-player: use ENetworkPredictionTickingPolicy::Independent, or drop Network Prediction entirely by setting BackendClass to UMoverStandaloneLiaisonComponent.

Architecture

AActor (any APawn or AActor with a USceneComponent root)
 └─ UMoverComponent (UActorComponent, IMovementInterface)
     ├─ BackendClass            -> a UActorComponent implementing IMoverBackendLiaisonInterface
     ├─ MovementModes           : TMap<FName, TObjectPtr<UBaseMovementMode>>   (Instanced)
     ├─ StartingMovementMode    : FName
     ├─ Transitions             : TArray<TObjectPtr<UBaseMovementModeTransition>>  (global)
     ├─ PersistentSyncStateDataTypes : TArray<FMoverDataPersistence>
     ├─ InputProducer / InputProducers : objects implementing IMoverInputProducerInterface
     ├─ MovementMixer           : UMovementMixer
     └─ SharedSettings          : auto-built from each mode's SharedSettingsClasses

UCharacterMoverComponent subclasses UMoverComponent and adds character verbs: Jump(), CanActorJump(), Crouch(), UnCrouch(), CanCrouch(), GetCrouchIntent(), IsCrouching(), IsFlying(), IsFalling(), IsAirborne(), IsOnGround(), IsSwimming(), IsSlopeSliding(), and the OnStanceChanged delegate. Use it for humanoid pawns.

Modes never own gameplay state. A mode is a shared, Instanced UObject whose tuning lives in UPROPERTY fields and in shared settings objects (IMovementSettingsInterface, e.g. UCommonLegacyMovementSettings); everything that changes per frame belongs in FMoverSyncState.

// Inside UMyClimbingMode::OnRegistered, after calling Super. Full class in mover-recipes.md.
const UCommonLegacyMovementSettings* Settings = GetMoverComponent()->FindSharedSettings<UCommonLegacyMovementSettings>();

Tick Flow

The backend liaison drives three phases (EMoverTickPhase::ProduceInput, SimulateMovement, ApplyState):

1. ProduceInput — UMoverComponent::ProduceInput(const int32 DeltaTimeMS, FMoverInputCmdContext* Cmd) calls IMoverInputProducerInterface::ProduceInput on every entry of InputProducers, which BeginPlay fills with InputProducer (defaulting to the owner when it implements the interface) plus every owner component implementing it — the 5.8 .cpp never reads bGatherInputFromAllInputProducerComponents. Runs only on the controlling instance; it is not re-run during resimulation.
2. SimulateMovement — OnPreSimulate(TimeStep, StartingData) fires OnPreSimulationTick, then the simulation runs the substep loop:
   • queued instant effects apply;
   • each active FLayeredMoveBase::GenerateMove produces an FProposedMove;
   • unless a layered move fully overrides movement (mover.perf.SkipGenerateMoveIfOverridden), the active mode's GenerateMove runs;
   • UMovementMixer::MixProposedMoves combines them by EMoveMixMode;
   • ProcessGeneratedMovement (bind via BindProcessGeneratedMovement) gets the last word;
   • mode-owned Transitions then global Transitions are evaluated; the first hit calls Trigger and sets FMovementModeTickEndState::NextModeName, otherwise UBaseMovementMode::SimulationTick executes the move;
   • FMovementModeTickEndState::RemainingMs refunds time, producing another substep in the same frame. Then OnPostSimulate(TimeStep, StartingData, EndingData) fires OnPostMovement and OnPostSimulationTick.
3. ApplyState — the liaison calls FinalizeFrame(SyncState, AuxState) (or FinalizeUnchangedFrame()), which moves the actor and fires OnPostFinalize.

Movement Modes

UBaseMovementMode is UCLASS(MinimalAPI, Abstract, Blueprintable, BlueprintType, EditInlineNew, DefaultToInstanced). Override these, verbatim:

virtual void OnRegistered(const FName ModeName, const FMoverSimContext& SimContext) override;
virtual void OnUnregistered(const FMoverSimContext& SimContext) override;
virtual void Activate(const FMoverEventContext& Context, FName PrevModeName, const FMoverSimContext& SimContext, const FMoverTickStartData& StartState, FMoverSyncState* OutSyncState, FMoverAuxStateContext* OutAuxState) override;
virtual void Deactivate(const FMoverEventContext& Context, FName NextModeName, const FMoverSimContext& SimContext) override;
virtual void GenerateMove_Implementation(const FMoverSimContext& SimContext, const FMoverTickStartData& StartState, const FMoverTimeStep& TimeStep, FProposedMove& OutProposedMove) const override;
virtual void SimulationTick_Implementation(const FSimulationTickParams& Params, FMoverTickEndData& OutputState) override;

GenerateMove is const and decides what motion is wanted; SimulationTick performs it (sweeps, floor checks) and writes the ending FMoverDefaultSyncState. Call Super:: on OnRegistered, OnUnregistered, Activate and Deactivate — the base implementations manage owned transitions and fire the Blueprint events. Set bSupportsAsync = true only when GenerateMove/SimulationTick touch no scene components or other game-thread state.

Default set: UWalkingMode, UFallingMode, UFlyingMode, USwimmingMode, UNavWalkingMode, plus the async variants UAsyncWalkingMode, UAsyncFallingMode, UAsyncFlyingMode, UAsyncNavWalkingMode and the simplified USimpleWalkingMode, USimpleFlyingMode, USimpleSpringWalkingMode, USmoothWalkingMode. Default mode names are DefaultModeNames::Walking, ::Falling, ::Flying, ::Swimming. Full catalogue in mover-reference.md.

Register and switch at runtime:

static void MyEnableClimbing(UMoverComponent& MoverComp)
{
    MoverComp.AddMovementModeFromClass(TEXT("Climbing"), UMyClimbingMode::StaticClass());
    MoverComp.QueueNextMode(TEXT("Climbing"), /*bShouldReenter=*/false);   // takes effect next sim frame
}

static void MyDisableClimbing(UMoverComponent& MoverComp)
{
    MoverComp.RemoveMovementMode(TEXT("Climbing"));
}

Layered Moves

FLayeredMoveBase is temporary additive or overriding motion: it only proposes, the active mode executes. Shared fields: MixMode (EMoveMixMode), Priority, DurationMs (>0 timed, 0 single tick, <0 manual), StartSimTimeMs, FinishVelocitySettings (FLayeredMoveFinishVelocitySettings). Overrides, verbatim:

virtual bool GenerateMove(const FMoverTickStartData& StartState, const FMoverTimeStep& TimeStep, const UMoverComponent* MoverComp, UMoverBlackboard* SimBlackboard, FProposedMove& OutProposedMove) override;
virtual bool IsFinished(double CurrentSimTimeMs) const override;
virtual FLayeredMoveBase* Clone() const override;
virtual void NetSerialize(FArchive& Ar) override;
virtual UScriptStruct* GetScriptStruct() const override;
virtual FString ToSimpleString() const override;
virtual void AddReferencedObjects(class FReferenceCollector& Collector) override;

NetSerialize must call Super::NetSerialize(Ar) first, then serialize your own fields — anything omitted will not survive a correction. Queueing stores your TSharedPtr as-is until a later simulation frame flushes it (it is cloned only when the sync state is copied), so fill it in completely first:

static void MyQueueDash(UMoverComponent& MoverComp, const FVector& DashDirection)
{
    TSharedPtr<FLayeredMove_LinearVelocity> Dash = MakeShared<FLayeredMove_LinearVelocity>();
    Dash->Velocity = DashDirection.GetSafeNormal() * 2000.f;
    Dash->DurationMs = 200.f;
    Dash->MixMode = EMoveMixMode::OverrideVelocity;
    MoverComp.QueueLayeredMove(Dash);
}

Shipped moves: FLayeredMove_LinearVelocity, FLayeredMove_JumpImpulseOverDuration, FLayeredMove_JumpTo, FLayeredMove_MoveTo, FLayeredMove_MoveToDynamic, FLayeredMove_RadialImpulse, FLayeredMove_MultiJump, FLayeredMove_Launch, FLayeredMove_AnimRootMotion, FLayeredMove_AnimRootMotion_SimDriven.

A second, instanced form is in progress: stateless logic in ULayeredMoveLogic plus replicated data in FLayeredMoveInstancedData, activated with FLayeredMoveActivationParams. Register the logic class with RegisterMove<T>() / K2_RegisterMove, then QueueLayeredMoveActivation(UMyMoveLogic::StaticClass()) or QueueLayeredMoveActivationWithContext(Params). Prefer FLayeredMoveBase for new C++ work until the instanced path lands; both live side by side in FMoverSyncState.

Movement Modifiers

FMovementModifierBase changes how the simulation behaves without proposing motion — stances, settings swaps, mode remaps. Overrides:

virtual void OnStart(UMoverComponent* MoverComp, const FMoverTimeStep& TimeStep, const FMoverSyncState& SyncState, const FMoverAuxStateContext& AuxState) override;
virtual void OnEnd(UMoverComponent* MoverComp, const FMoverTimeStep& TimeStep, const FMoverSyncState& SyncState, const FMoverAuxStateContext& AuxState) override;
virtual void OnPreMovement(UMoverComponent* MoverComp, const FMoverTimeStep& TimeStep) override;
virtual void OnPostMovement(UMoverComponent* MoverComp, const FMoverTimeStep& TimeStep, const FMoverSyncState& SyncState, const FMoverAuxStateContext& AuxState) override;
virtual FMovementModifierBase* Clone() const override;
virtual void NetSerialize(FArchive& Ar) override;
virtual UScriptStruct* GetScriptStruct() const override;
virtual bool Matches(const FMovementModifierBase* Other) const override;

static FMovementModifierHandle MyQueueStance(UMoverComponent& MoverComp)
{
    return MoverComp.QueueMovementModifier(MakeShared<FStanceModifier>());
}

static void MyCancelStance(UMoverComponent& MoverComp, const FMovementModifierHandle& Handle)
{
    if (MoverComp.IsModifierActiveOrQueued(Handle))
    {
        MoverComp.CancelModifierFromHandle(Handle);
    }
}

Mover assumes one modifier of a given type at a time; the default Matches compares type only. To allow several, override Matches using fields that NetSerialize also writes. FStanceModifier (with EStanceMode and UStanceSettings) is the shipped crouch implementation, driven by UCharacterMoverComponent::Crouch().

Instant Movement Effects

FInstantMovementEffect applies once, consuming no time, at the start or end of a substep. Override virtual bool ApplyMovementEffect(FApplyMovementEffectParams& ApplyEffectParams, FMoverSyncState& OutputState) override; and return true when you changed anything. Shipped: FTeleportEffect, FAsyncTeleportEffect, FJumpImpulseEffect, FApplyVelocityEffect.

static void MyQueueTeleport(UMoverComponent& MoverComp, const FVector& Destination)
{
    TSharedPtr<FTeleportEffect> Teleport = MakeShared<FTeleportEffect>();
    Teleport->TargetLocation = Destination;
    MoverComp.QueueInstantMovementEffect(Teleport);
}

ScheduleInstantMovementEffect / ScheduleLayeredMove delay execution so every endpoint runs them on the same frame; they matter only for ChaosMover's networked physics path. Default to the Queue* forms.

Transitions

UBaseMovementModeTransition decides mode changes from state. Override virtual FTransitionEvalResult Evaluate_Implementation(const FSimulationTickParams& Params) const override; (return FTransitionEvalResult(NextModeName) or FTransitionEvalResult::NoTransition) and virtual void Trigger_Implementation(const FSimulationTickParams& Params) override; for side effects. Put it in a mode's Transitions array for mode-scoped checks or the component's for global ones; bAllowModeReentry and bFirstSubStepOnly control re-entry and substep scope. Transitions are optional — QueueNextMode, FProposedMove::PreferredMode and FMovementModeTickEndState::NextModeName also change modes.

Input Production

Mover does not read Enhanced Input. Cache input on the game thread, then translate it inside ProduceInput:

// AMyMoverPawn : public APawn, public IMoverInputProducerInterface.
// CachedMoveInputIntent, bJumpHeld and bJumpPressedThisFrame are members filled by Enhanced Input handlers.
void AMyMoverPawn::ProduceInput_Implementation(int32 SimTimeMs, FMoverInputCmdContext& InputCmdResult)
{
    FCharacterDefaultInputs& CharacterInputs = InputCmdResult.InputCollection.FindOrAddMutableDataByType<FCharacterDefaultInputs>();
    CharacterInputs.ControlRotation = GetControlRotation();
    CharacterInputs.SetMoveInput(EMoveInputType::DirectionalIntent, CharacterInputs.ControlRotation.RotateVector(CachedMoveInputIntent));
    CharacterInputs.OrientationIntent = CharacterInputs.GetMoveInput().GetSafeNormal();
    CharacterInputs.bIsJumpPressed = bJumpHeld;
    CharacterInputs.bIsJumpJustPressed = bJumpPressedThisFrame;
    bJumpPressedThisFrame = false;
}

With fixed ticking, several render frames can feed one input cmd (or one frame can feed several ticks), so accumulate rather than sample. FCharacterDefaultInputs also carries SuggestedMovementMode, MovementBase/MovementBaseBoneName/bUsingMovementBase. FMoverAIInputs carries RVOVelocityDelta for AI. Full pawn in mover-recipes.md.

Input and Sync State

Both the input cmd and the sync state are dynamic collections (FMoverDataCollection) of FMoverDataStructBase-derived structs, so custom data needs no component subclass.

Type	Holds
FMoverInputCmdContext	InputCollection — authored by the owner each frame
FMoverSyncState	MovementMode, LayeredMoves, LayeredMoveInstances, MovementModifiers, SyncStateCollection
FMoverAuxStateContext	AuxStateCollection — rarely changing simulation input
FMoverDefaultSyncState	location, orientation, velocity, AngularVelocityDegrees, MoveDirectionIntent, movement base
FMoverTickStartData	InputCmd, SyncState, AuxState for the tick
FMoverTickEndData	SyncState, AuxState, MovementEndState, MoveRecord
FProposedMove	PreferredMode, DirectionIntent, LinearVelocity, AngularVelocityDegrees, bHasDirIntent, MixMode
FMoverTimeStep	ServerFrame, BaseSimTimeMs, StepMs, bIsResimulating, bIsFirstResimFrame

FMoverDefaultSyncState is required on every Mover actor. Read through the world/base-space accessors — GetLocation_WorldSpace(), GetVelocity_WorldSpace(), GetOrientation_WorldSpace(), GetAngularVelocityDegrees_WorldSpace(), GetTransform_WorldSpace() — and write with SetTransforms_WorldSpace(Location, Orient, Velocity, AngularVelocityDegrees, Base, BaseBone).

void UMyClimbingMode::SimulationTick_Implementation(const FSimulationTickParams& Params, FMoverTickEndData& OutputState)
{
    const FMoverDefaultSyncState* StartingSyncState = Params.StartState.SyncState.SyncStateCollection.FindDataByType<FMoverDefaultSyncState>();
    check(StartingSyncState);

    FMyClimbState& OutClimb = OutputState.SyncState.SyncStateCollection.FindOrAddMutableDataByType<FMyClimbState>();
    OutClimb.SurfaceNormal = StartingSyncState->GetOrientation_WorldSpace().Vector();
}

Custom state structs must override Clone, NetSerialize, GetScriptStruct, ToString, ShouldReconcile and Interpolate. Anything that must survive a frame without being rewritten goes in PersistentSyncStateDataTypes as an FMoverDataPersistence.

UMoverBlackboard (GetSimBlackboard() / GetSimBlackboard_Mutable()) caches derived values outside the networked state — CommonBlackboard::LastFloorResult, LastWaterResult, LastFoundDynamicMovementBase, TimeSinceSupported. It is being replaced by the rollback-aware blackboard (GetRollbackBlackboardExternal()), so always treat a lookup as possibly missing and provide a fallback. TryGet<T> and Set<T> are type-strict: store and read the same type (a value written as double must be read as double).

Backends and Networking

IMoverBackendLiaisonInterface (Backends/MoverBackendLiaison.h) is the contract: GetCurrentSimTimeMs(), GetCurrentSimFrame(), IsAsync(), IsFixedDt(), ShouldResim(), the pending/presentation sync-state accessors, and OnSimulationRollback(NewSyncState, NewBaseTimeStep, PreRollbackTimeStep). Set the implementing component class on UMoverComponent::BackendClass.

Backend	Use for	Notes
UMoverNetworkPredictionLiaisonComponent	networked or standalone play	Network Prediction (Beta in 5.8); fixed or independent ticking, rollback + resim
UMoverStandaloneLiaisonComponent	standalone, no physics-driven movement	no Network Prediction overhead
UChaosMoverBackendComponent	physics-driven pawns	ChaosMover (Experimental in 5.8); async, fixed dt, Chaos Networked Physics

Network model: every endpoint simulates a shared timeline, clients running slightly ahead. Clients send only input cmds for a given sim frame; the server buffers them, simulates, and broadcasts state. Clients compare and decide whether to roll back and resimulate — FMoverSyncState::ShouldReconcile compares MovementMode, SyncStateCollection and MovementModifiers.

Consequences for your code:

• Everything the simulation reads next frame must be in the sync state (or aux state) and must NetSerialize. State cached on a mode object, a layered move that skips a field in NetSerialize, or blackboard data is not restored on rollback.
• GenerateMove / SimulationTick / ApplyMovementEffect re-run during resimulation. Keep them deterministic: no RNG without seeded state, no spawning, no one-shot audio or VFX. Use FMoverTimeStep::bIsResimulating and FMoverEventContext::bIsCausedByRollback to gate cosmetic work.
• ProduceInput does not re-run on resim, and runs only on the controlling instance — aim assist and lock-on belong there, movement logic does not.
• Simulated proxies: prefer ENetworkLOD::Interpolated; forward prediction of other players mispredicts on direction changes and jumps.
• Mover does not solve GAS/movement synchronisation; GAS still replicates independently.

For RPC rules, net roles, DOREPLIFETIME and push model, see ue-networking-replication.

Reading State and Events

static void MyReadMoverState(const UMoverComponent& MoverComp)
{
    const FMoverSyncState& SyncState = MoverComp.GetSyncState();
    const FName ModeName             = MoverComp.GetMovementModeName();
    const FVector Velocity           = MoverComp.GetVelocity();
    const FVector Intent             = MoverComp.GetMovementIntent();
    const FRotator TargetOrientation = MoverComp.GetTargetOrientation();
    const bool bGrounded             = MoverComp.HasGameplayTag(Mover_IsOnGround, /*bExactMatch=*/false);

    FHitResult FloorHit;
    const bool bHasFloor = MoverComp.TryGetFloorCheckHitResult(FloorHit);

    UE_LOG(LogMyGame, Verbose, TEXT("%s: mode %s, speed %.1f, grounded %d, floor %d, intent %s, facing %s"),
        *SyncState.MovementMode.ToString(), *ModeName.ToString(), Velocity.Size(),
        bGrounded ? 1 : 0, bHasFloor ? 1 : 0, *Intent.ToString(), *TargetOrientation.ToString());
}

Multicast delegates on UMoverComponent: OnPreSimulationTick (FMover_OnPreSimTick), OnPostSimulationTick (FMover_OnPostSimTick), OnPostMovement (FMover_OnPostMovement), OnPostSimulationRollback (FMover_OnPostSimRollback), OnMovementModeChanged (FMover_OnMovementModeChanged), OnTeleportSucceeded, OnTeleportFailed, OnBasedMovementApplied, OnGameplayTagAdded, OnGameplayTagRemoved, OnMovementTransitionTriggered, OnPostFinalize, plus the C++-only OnPostSimEventReceived. UCharacterMoverComponent adds OnStanceChanged.

Native tags declared in MoverTypes.h: Mover_IsOnGround, Mover_IsInAir, Mover_IsFalling, Mover_IsFlying, Mover_IsSwimming, Mover_IsCrouching, Mover_IsNavWalking, Mover_AnimRootMotion, Mover_SkipAnimRootMotion, Mover_SkipVerticalAnimRootMotion, Mover_DisableLanding. Add your own with AddGameplayTag / RemoveGameplayTag; query with HasGameplayTag or GetGameplayTags().

Integration Points

• Animation — GetPredictedTrajectory(FMoverPredictTrajectoryParams) returns TArray<FTrajectorySampleInfo> for motion matching. FLayeredMove_AnimRootMotion and FLayeredMove_AnimRootMotion_SimDriven drive root motion; ConvertLocalRootMotionToWorld plus ProcessLocalRootMotionDelegate / ProcessWorldRootMotionDelegate let Motion Warping hook in. MoverAnimNext (Experimental in 5.8) bridges to UAF. Montages and anim graph belong to ue-animation-system.
• AI — add UNavMoverComponent alongside the Mover component; it implements INavMovementInterface and IRVOAvoidanceInterface, and ConsumeNavMovementData(OutIntent, OutVelocity) feeds ProduceInput. UNavWalkingMode / UAsyncNavWalkingMode project onto the navmesh. Navmesh generation and queries belong to ue-ai-navigation.
• Mass — MoverIntegrations (Experimental in 5.8) supplies UMoverMassAgentTrait, UMoverMassAgentOrientationSyncTrait and UMassMoverInputComponent (an IMoverInputProducerInterface component). Entity/processor design belongs to ue-mass-entity.
• Physics — kinematic modes sweep with UMovementUtils::TrySafeMoveUpdatedComponent and TryMoveToSlideAlongSurface; impacts route through HandleImpact(FMoverOnImpactParams&). ChaosMover instead drives a Chaos character-ground constraint on the physics thread. Channels, sweeps and responses belong to ue-physics-collision.

Deprecated — do not use

Do not emit	Use in 5.8	Source
UBaseMovementMode::OnActivate()	Activate()	UE_DEPRECATED(5.6) in MovementMode.h
UBaseMovementMode::OnDeactivate()	Deactivate()	UE_DEPRECATED(5.6) in MovementMode.h
UBaseMovementMode::OnGenerateMove()	GenerateMove_Implementation()	UE_DEPRECATED(5.6) in MovementMode.h
UBaseMovementMode::OnSimulationTick()	SimulationTick_Implementation()	UE_DEPRECATED(5.6) in MovementMode.h
UBaseMovementModeTransition::OnEvaluate()	Evaluate_Implementation()	UE_DEPRECATED(5.6) in MovementModeTransition.h
UBaseMovementModeTransition::OnTrigger()	Trigger_Implementation()	UE_DEPRECATED(5.6) in MovementModeTransition.h
UMoverComponent::GetFutureTrajectory()	GetPredictedTrajectory()	UE_DEPRECATED(5.5) in MoverComponent.h
UMoverComponent::HasValidCachedState()	nothing — state is always valid now	UE_DEPRECATED(5.6) in MoverComponent.h
UMoverComponent::HasValidCachedInputCmd()	nothing — input cmd is always valid now	UE_DEPRECATED(5.6) in MoverComponent.h
SetTransforms_WorldSpace(Loc, Orient, Velocity, Base, BaseBone)	the overload taking FVector WorldAngularVelocityDegrees	UE_DEPRECATED(5.7) in MoverDataModelTypes.h
UMovementUtils::ComputeAngularVelocity(FRotator, ...)	ComputeAngularVelocityDegrees()	UE_DEPRECATED(5.7) in MoveLibrary/MovementUtils.h
UMovementUtils::ApplyAngularVelocity(FRotator, FRotator, float)	ApplyAngularVelocityToRotator() / ApplyAngularVelocityToQuat()	UE_DEPRECATED(5.7) in MoveLibrary/MovementUtils.h
UMovementUtils::IsAngularVelocityZero(FRotator)	angular velocity is an FVector — test it directly	UE_DEPRECATED(5.7) in MoveLibrary/MovementUtils.h
UFloorQueryUtils::FindFloor / ComputeFloorDist with loose float params	the overloads taking FFloorCheckSettings	UE_DEPRECATED(5.8) in MoveLibrary/FloorQueryUtils.h
UAirMovementUtils::IsValidLandingSpot / TryMoveToFallAlongSurface / TestFallingMoveAlongHitSurface with loose float params	the FFloorCheckSettings overloads	UE_DEPRECATED(5.8) in MoveLibrary/AirMovementUtils.h
UGroundMovementUtils::TryMoveToStepUp / TestMoveToStepOver with loose float params	the FFloorCheckSettings overloads	UE_DEPRECATED(5.8) in MoveLibrary/GroundMovementUtils.h
EBlackboardPersistencePolicy::NextFrameOnly	EBlackboardPersistencePolicy::ThroughNextFrame	UE_DEPRECATED(5.8) in MoveLibrary/RollbackBlackboard.h

Common Mistakes

Storing per-frame state on the mode object: a mode is a shared instanced UObject, not per-frame storage. A member written in SimulationTick is never rolled back, so it silently desyncs under latency. Put it in a FMoverDataStructBase inside FMoverSyncState and add the type to PersistentSyncStateDataTypes.

Forgetting the backend: UMoverComponent has no TickComponent-driven update. With no BackendClass set to a component implementing IMoverBackendLiaisonInterface — and, for the Network Prediction liaison, the NetworkPrediction plugin enabled — the actor simply never moves.

Mixing CMC and Mover on one pawn: two components fighting over the same root produces jitter and corrections. Pick one; UMoverComponent does not need ACharacter.

Assuming CMC APIs exist:

// WRONG — no such members on UMoverComponent
MoverComp.Velocity = FVector(0.0, 0.0, 600.0);
MoverComp.SetMovementMode(MOVE_Flying);

// RIGHT
static void MyStartFlyingJump(UMoverComponent& MoverComp)
{
    TSharedPtr<FLayeredMove_JumpImpulseOverDuration> Jump = MakeShared<FLayeredMove_JumpImpulseOverDuration>();
    Jump->UpwardsSpeed = 600.f;
    MoverComp.QueueLayeredMove(Jump);
    MoverComp.QueueNextMode(DefaultModeNames::Flying);
}

Omitting a field from NetSerialize: a layered move or state struct that serializes only some of its fields replays with different values after a correction, producing rubber-banding that appears only under latency. Serialize everything the move reads, and call Super::NetSerialize(Ar) first.

Queueing a move you then mutate: QueueLayeredMove, QueueMovementModifier and QueueInstantMovementEffect keep your TSharedPtr in a queue that the simulation (possibly on another thread) flushes later, and the sync state clones it after that. Changes made afterwards race with the simulation and may or may not be seen — never touch the struct once queued.

Expecting an immediate mode change: QueueNextMode takes effect on the next simulation frame, not the calling frame. Read back with GetNextMovementModeName(), not GetMovementModeName().

Spawning or playing effects inside the simulation: mode and layered-move code re-runs during resimulation. Gate cosmetic work on !TimeStep.bIsResimulating, or do it from OnPostFinalize / OnMovementModeChanged.

Two modifiers of the same type: Mover keeps only one per type because the default Matches compares the struct type. Override Matches with fields your NetSerialize also writes if you need several.

Trusting the blackboard: UMoverBlackboard entries are invalidated on rollback and on mode changes. Always handle TryGet returning false, and never read a value as a different type than it was stored with.

Related Skills

• ue-character-movement — UCharacterMovementComponent, ACharacter, FSavedMove_Character; the system Mover is intended to succeed
• ue-networking-replication — net roles, RPCs, DOREPLIFETIME, push model, relevancy; the replication layer under the Mover backends
• ue-animation-system — montages, anim graph, root motion and motion matching fed by Mover trajectories
• ue-ai-navigation — navmesh generation, pathfollowing and avoidance behind UNavMoverComponent and UNavWalkingMode
• ue-physics-collision — collision channels, sweeps and Chaos bodies used by Mover sweeps and the ChaosMover backend
• ue-gameplay-framework — pawn, controller and possession wiring around a Mover actor
• ue-input-system — Enhanced Input actions and mappings that feed ProduceInput
• ue-mass-entity — Mass entities and processors behind the MoverIntegrations traits