Skip to content

Disable Movement / Set Movement Mode / Stop Movement Immediately

At a glance

Disable Movement target: Character Movement Component · Set Movement Mode target: Character Movement Component · Stop Movement Immediately target: any Movement Component · Returns: no value or success Boolean · Invalid target: Blueprint reports an invalid-reference runtime error and no movement state is changed · Official pages: Disable Movement, Set Movement Mode, and Stop Movement Immediately

These nodes stop three different layers. Disable Movement selects Character Movement's disabled mode. Set Movement Mode selects a named simulation mode. Stop Movement Immediately clears motion that exists now, but leaves the movement system able to accelerate again.

The one-minute version

  • Disable Movement is a convenience call for Set Movement Mode(None) on a Character Movement Component.
  • Set Movement Mode chooses Walking, Falling, Swimming, Flying, Custom, or None. Its Custom Mode byte matters only with Custom.
  • Stop Movement Immediately zeroes the Movement Component's current velocity; components that track acceleration, including Character Movement, also stop their current acceleration. It does not change Movement Mode.
  • A held input action, a graph that keeps calling Add Movement Input, root motion, physics, attachment, or an active AI path can supply motion again.
  • AIController Stop Movement is different: it aborts the controller's current path-following request. It does not permanently disable the pawn or stop a Behavior Tree from starting another move.
  • Before temporary None, remember both the previous main mode and Custom Mode byte. On restore, re-check the world instead of blindly forcing a stale mode.
  • For overlapping stun, menu, cutscene, and ability locks, keep a set/count of active blockers. Restore only when the last blocker leaves.
  • In multiplayer, authoritative movement-mode and gameplay stop decisions belong on the server. Local input/UI gates still belong on the owning client.

The three contracts

Node What it changes What it leaves active
Disable Movement Character Movement Mode becomes None (disabled). Collision settings, animation, physics settings, attachments, input sources, and controller logic.
Set Movement Mode Character Movement enters the requested main mode and optional Custom sub-mode. The rest of the actor's systems; the requested mode can change again when its requirements are not met.
Stop Movement Immediately Current Movement Component velocity becomes zero; acceleration is usually zeroed by movement types that have it. Current mode, input generation, pending/future move requests, path following, collision, and other motion owners.

None of these nodes returns a success value. The outgoing execution pin means the call finished, not that the pawn is guaranteed to remain still.

What they actually do

Disable Movement selects None

Disable Movement is the specific Character Movement version of:

pseudocode of the engine behavior - not engine source

DisableMovement():
    SetMovementMode(None)

None is a real EMovementMode value. It means Character Movement has no normal walking, falling, swimming, flying, or custom simulation to perform. Entering it also stops the component's current movement state, but the lasting contract is the mode change—not a universal freeze of the Actor.

This makes Disable Movement useful when Character Movement itself must not resume on the next update. It is stronger than merely zeroing velocity.

Set Movement Mode chooses a simulation

Set Movement Mode takes:

Input Meaning
New Movement Mode The main EMovementMode to request.
New Custom Mode An unsigned byte identifying a project-defined sub-mode; used only when the main mode is Custom.

The mode controls which Character Movement physics path runs:

Walking / Nav Walking -> floor-constrained ground movement
Falling               -> airborne gravity and air control
Swimming              -> water-volume movement
Flying                -> flying movement
Custom                 -> project-supplied custom movement physics
None                   -> Character Movement disabled

The call is a request to enter a mode, not proof that the mode will remain valid. Forcing Walking while there is no walkable floor can be followed by a change to Falling. Selecting Swimming does not create a water volume. Selecting Custom does not implement PhysCustom for you.

Setting the same effective main/custom pair again is not a new transition. For observing real changes, use On Movement Mode Changed and also initialize by reading the current mode once.

Stop Movement Immediately clears the current motion

At the base Movement Component layer, the shape is:

pseudocode - not engine source

StopMovementImmediately():
    Velocity = (0, 0, 0)
    update the moved component's reported velocity

specialized movement component:
    may also clear its current Acceleration

For a Character, Movement Mode remains whatever it was. A Walking Character is still Walking; a Falling Character is still Falling and gravity can produce a new downward velocity on the next movement update.

That makes this node appropriate for removing momentum without changing the simulation: stop knockback, cancel a dash's current speed, or discard a movement component's present velocity during a deliberate handoff. It is not a persistent lock.

Why the pawn moves again

Stopping a velocity is not the same as stopping the source that creates it. These sources can act after Stop Movement Immediately:

  1. Player input is still held. Enhanced Input fires again, the graph calls Add Movement Input, and Character Movement accelerates.
  2. A pending movement-input vector exists. It is a separate accumulator, normally consumed during the movement update. Stop the producer and, when the design requires it, deliberately consume/clear that pending input.
  3. AI path following is still active. The Path Following Component keeps requesting movement toward its goal.
  4. Gravity still applies. A Character left in Falling gains velocity again.
  5. Root motion or a Root Motion Source contributes motion. Animation or an ability system can remain an independent producer.
  6. Physics simulation owns a body. Zeroing Character Movement velocity is not the same operation as stopping a physics body.
  7. Attachment or direct transform code moves the Actor. Following a parent, a Timeline, or Set Actor Location does not require Character Movement velocity.
  8. The server corrects a client-only stop. The authoritative Character copy still has a different movement result.

For a persistent gameplay stop, identify and gate the owner instead of calling the zero-velocity node every Tick.

AIController Stop Movement is another layer

An AI move has at least two participants:

flowchart LR
    Goal[Move To request] --> Path[AIController / Path Following]
    Path --> Request[Movement request]
    Request --> MoveComp[Pawn / Character Movement]
    MoveComp --> Velocity[Capsule motion]

Stop Movement Immediately acts at the bottom: it clears component motion but does not tell path following that the goal was canceled. The next path-following update can request movement again.

AIController Stop Movement acts higher: it aborts the move the controller is currently performing. Use it when an AI should abandon its current Move To. It does not disable Character Movement, clear every possible velocity source, or prevent a Behavior Tree task/service from issuing a new move afterward.

Common AI stop:

Server-side AIController
-> Stop Movement                 // abort current path request

Controlled Character
-> Character Movement
-> Stop Movement Immediately     // remove remaining component velocity if needed

Whether both calls are needed depends on the movement and transition you want. Canceling the request is the important step when path following is the owner.

A safe temporary-disable pattern

A single bMovementDisabled Boolean breaks when two systems overlap:

stun starts      -> disable
cutscene starts  -> disable
stun ends        -> enable       // wrong: cutscene still owns a lock

Use a set, tag container, or counted reasons instead:

AddMovementBlock(Reason):
    if ActiveMovementBlocks was empty:
        SavedMode = CharacterMovement.MovementMode
        SavedCustomMode = CharacterMovement.CustomMovementMode
    add Reason
    CharacterMovement.DisableMovement()

RemoveMovementBlock(Reason):
    remove Reason
    if ActiveMovementBlocks is now empty:
        choose a valid restore mode from current world/gameplay state
        CharacterMovement.SetMovementMode(RestoreMode, RestoreCustomMode)

Store both mode values because Custom 3 and Custom 7 are different states. But do not blindly restore a stale snapshot:

  • a Character saved as Walking may now be unsupported over a ledge;
  • a Character saved as Falling may have been placed safely on a floor;
  • a water/cutscene transition may make Swimming or Flying the current answer;
  • death may intentionally have no restore path; and
  • an AI path that was aborted needs an explicit new goal if it should resume.

For a short grounded stun, restoring Walking after a floor/context check can be enough. For a general-purpose blocker, let one movement-state owner recompute the valid mode.

If a local pause/menu should only stop player commands, changing server Character Movement Mode is often the wrong layer. Gate the owning player's input with the input mode, mapping context, or Set Ignore Move Input and keep authoritative movement rules unchanged.

Pair every stacked ignore call correctly, or use its reset node intentionally. Do not use Disable Movement as a substitute for focus, cursor, or UI input routing.

What remains separate

Collision

Movement Mode None does not disable the capsule's collision, change collision responses, or make the Actor intangible. Use collision nodes when collision is the state you intend to change.

Physics simulation

These nodes do not toggle Simulate Physics, gravity on a physics body, or a ragdoll's body velocities. Character Movement normally drives the capsule; a physics-simulating mesh/body is another motion owner with its own stop/reset operations.

Animation and root motion

Disabling Character Movement does not stop animation playback or remove root motion from an animation asset. Whether extracted root motion moves the capsule depends on the active Character Movement/root-motion path. If the design needs a frozen pose, stop or pause the animation/montage layer deliberately too.

Pending input

Stop Movement Immediately is not a promise to flush the Pawn's pending input vector. Stop the code that keeps adding input. Only consume the vector manually when you understand that doing so takes it away from the next movement update.

Direct movement and attachment

Teleporting, setting transforms, Timelines, moving platforms, and attached parents can change world position without these nodes. A zero Movement Component velocity is not evidence that the Actor's transform cannot change.

Multiplayer: which machine changes movement?

Character Movement supports owning-client prediction, server validation, and simulated-proxy replication. That does not make an arbitrary client-side mode change authoritative.

Decision Usual owner
Gameplay stun, death lock, server-authoritative cutscene state Server changes the authoritative movement state; replicated/predicted presentation follows.
Player releases movement or opens local UI Owning client gates local input; tell the server only if gameplay state also changes.
AI stops following a path Server-side AIController/path following.
Cosmetic camera/animation pause The local machine presenting it.

Calling Disable Movement, Set Movement Mode, or Stop Movement Immediately only on a replicated Character's owning client can be corrected by the server. Calling them only on a simulated proxy changes a copy that does not own the gameplay result.

For a predicted custom ability, integrate the mode/root-motion change with the project's Character Movement prediction path. A loose Blueprint call is not automatically turned into a saved move or server request.

When it fails (and what failure does)

There is no success output, so diagnose the observed state:

  1. The target is None. Blueprint emits an invalid-reference runtime diagnostic, cannot call the component, and continues with no state change.
  2. You targeted another movement component. Disable/Set Mode require Character Movement; Stop Movement can target broader movement components whose specialized behavior may differ.
  3. The Character immediately moves again. Input, path following, gravity, root motion, physics, attachment, or direct transform code is still active.
  4. The requested mode changes again. Its environmental prerequisites are not true, or another system owns mode selection.
  5. Custom mode does nothing. Selecting Custom plus a byte does not implement custom physics.
  6. AI resumes. The path request was not aborted, or behavior logic started a new one.
  7. A remote/client result snaps back. The call ran on a non-authoritative network copy.
  8. Restore enables too early. Multiple blockers were represented by one Boolean instead of tracked independently.

The pattern everyone actually uses

Server-authoritative stun:

Server applies Stunned gameplay state
-> add "Stun" to movement blockers
-> Character Movement: Disable Movement
-> Stop Movement Immediately if an immediate zero is required

Stun expires on server
-> remove "Stun"
-> if no blockers remain:
     re-evaluate floor/gameplay state
     Set Movement Mode to the valid restore mode

AI death:

Server AIController: Stop Movement       // cancel path request
Character Movement: Disable Movement     // no normal movement resume
Character Movement: Stop Movement Immediately
stop Behavior Tree / death-state logic
configure collision, animation/ragdoll, and lifespan separately

The C++ twin, for the curious (our own example code):

void ATrainingCharacter::EnterServerMovementLock()
{
    if (!HasAuthority())
    {
        return;
    }

    UCharacterMovementComponent* Move = GetCharacterMovement();
    SavedMovementMode = Move->MovementMode;
    SavedCustomMode = Move->CustomMovementMode;
    Move->DisableMovement();
}

Lookalikes - which one do I want?

Node / setting Use when It does not
Disable Movement Character Movement should stay in disabled mode. Disable collision, input, animation, physics, or every transform change.
Set Movement Mode Select Walking/Falling/Swimming/Flying/Custom/None deliberately. Make an invalid environment or unimplemented Custom mode work.
Stop Movement Immediately Remove current Movement Component velocity without choosing another mode. Cancel input, gravity, or AI path following permanently.
AIController Stop Movement Abort the AI controller's current path-following move. Disable the pawn or prevent later Move To requests.
Set Ignore Move Input A Controller should ignore player movement commands. Change Character Movement Mode or stop AI logic.
Disable Input Remove an Actor from a PlayerController's input stack. Stop existing velocity or server/AI movement.
Set Collision Enabled Change whether a component participates in queries/physics collision. Select a movement mode.
Set Simulate Physics Hand a primitive body to physics simulation. Behave like Character Movement or an AI path stop.
Set Actor Location / Teleport Place the Actor directly. Provide an ongoing disabled/stopped state.

Rule of thumb: stop the owner of the motion. Mode owns Character simulation, path following owns an AI goal, input owns player requests, and physics owns a simulating body.

Going deeper