Skip to content

Is Falling / Movement Mode / On Movement Mode Changed

At a glance

Is Falling lives in: Blueprint API / Movement · Declared target: Nav Movement Interface - usually a Character's Character Movement Component · Returns: Boolean · Movement Mode returns: EMovementMode on Character Movement · On Movement Mode Changed: event on Character with previous/new mode and custom-mode bytes · Official pages: Is Falling, Movement Mode Changed Delegate, and EMovementMode

Is Falling means "this movement object is currently in its falling state." For Character Movement, that is a test of Movement Mode, not vertical velocity, jump input, or distance from the floor.

The one-minute version

  • Is Falling returns true while Character Movement's current mode is Falling. It is true while rising after a jump as well as while descending.
  • It also becomes true after walking off a ledge or when a processed launch enters Falling. The Boolean does not tell you which cause started the fall.
  • Movement Mode exposes the broader state: None, Walking, Nav Walking, Falling, Swimming, Flying, or Custom.
  • On Movement Mode Changed fires when the Character's mode actually changes and supplies both previous and new values. Its custom-mode bytes matter only for the side whose mode is Custom.
  • Jump, Launch Character, and Falling are not synonyms. The first two are actions/requests; Falling is the movement simulation state they may enter.
  • Use Is Falling or cached Movement Mode for animation state. Use On Movement Mode Changed, On Landed, or action-specific events for one-time gameplay reactions.
  • The Landed event runs while Movement Mode is still Falling and provides a Hit Result. The later mode change to Walking is the better "ground mode is active now" signal.
  • In multiplayer, the owner can predict mode changes, the server simulates authoritatively, and simulated proxies apply the server's replicated mode. Every machine can observe its local copy, but not at the same instant.

The three contracts

Query or event Output What it proves
Is Falling Boolean The target movement interface currently reports a falling state. For Character Movement, the current mode is Falling.
Movement Mode EMovementMode Which main Character Movement simulation is active now.
On Movement Mode Changed Exec event plus previous/new mode and custom bytes This local Character copy just changed from one effective mode to another.

Is Falling = false has many valid meanings: standing, swimming, flying, disabled movement, custom movement, or an invalid target that produced a default output after a Blueprint runtime error. Read the broader mode when the difference matters.

What Is Falling actually tests

For a normal Character, drag from Get Character Movement and call Is Falling:

pseudocode of the Character Movement meaning - not engine source

IsFalling():
    return current Movement Mode == Falling

The Blueprint node's declared target is the broader Nav Movement Interface. Character Movement implements that interface, so its component reference fits the pin. Another movement implementation can supply its own meaning; the Character-specific mode enum and events on the rest of this page belong to UCharacterMovementComponent and ACharacter.

True while going up

A Character normally enters Falling as a jump begins. Its upward velocity can be positive while Is Falling is already true:

jump begins
-> Movement Mode changes Walking -> Falling
-> velocity moves upward
-> Is Falling = true
-> apex passes
-> velocity moves downward
-> Is Falling is still true

Therefore:

  • Is Falling does not mean "Velocity Z is negative";
  • NOT Is Falling does not prove there is a walkable floor; the Character could be swimming, flying, custom, or disabled; and
  • Is Falling does not distinguish jump ascent, jump descent, launch, knockback, or stepping off a ledge.

With default gravity, the sign of Velocity.Z can distinguish rising from descending. With custom gravity, world Z may not be the gravity-space vertical axis, so use the movement component's gravity-space direction or a deliberate project-specific calculation instead.

Movement Mode is the fuller answer

Character Movement uses one main EMovementMode value:

Mode Beginner meaning Common speed/physics owner
None Character Movement simulation is disabled. No normal Character Movement physics mode.
Walking Moving along a walkable surface. Ground speed, walking friction, floor checks.
Nav Walking Simplified ground movement constrained by navigation data. Navigation-ground rules rather than ordinary floor movement details.
Falling Airborne under Character Movement's falling simulation. Gravity, air control, lateral falling limits.
Swimming Moving through a fluid volume. Swim speed, buoyancy, fluid behavior.
Flying Flying movement without ordinary gravity. Fly speed and flying friction/deceleration.
Custom Project-defined Character Movement physics. Custom Movement Mode byte plus custom update logic.

None is a real mode, not a null reference and not an exception. The Disable Movement node selects it. A Character can still be moved by another system - teleporting, attachment, physics, or root-motion-related code - so the enum describes Character Movement's current simulation, not every possible source of world motion.

Read Movement Mode when animation or gameplay must distinguish more than ground versus air:

Get Character Movement
-> Movement Mode
-> Switch on EMovementMode
   Walking / Nav Walking -> grounded behavior
   Falling              -> airborne behavior
   Swimming             -> swim behavior
   Flying               -> flight behavior
   Custom               -> inspect Custom Movement Mode
   None                 -> disabled behavior

Do not assume NOT Is Falling means Walking. That shortcut breaks as soon as the project adds water, flight, a ladder custom mode, or disabled movement.

On Movement Mode Changed

Inside a Character Blueprint, add Event On Movement Mode Changed. The event exposes:

Pin Meaning
Prev Movement Mode The main mode before this change.
New Movement Mode The main mode now active.
Prev Custom Mode Previous custom sub-mode byte; meaningful when Prev Movement Mode was Custom.
New Custom Mode New custom sub-mode byte; meaningful when New Movement Mode is Custom.

The Character also exposes a Movement Mode Changed multicast delegate for systems that bind dynamically. Both report a change that already happened on that local Character copy.

The event does not fire simply because a graph reads the property. Requesting the same main mode and same custom sub-mode again is not a new transition. A listener bound after the Character already entered a mode also does not receive the past event; initialize it by reading the current mode once.

A useful event pattern

Event On Movement Mode Changed
-> Switch on New Movement Mode

Falling:
    record fall start state if gameplay needs it
    start local airborne presentation

Walking or Nav Walking:
    clear airborne state
    restore ground-only permissions

Swimming:
    equip swim presentation / rules

Custom:
    switch on New Custom Mode

Keep persistent truth in variables that can be initialized and replicated; use the event to update or react to that truth. An event alone is not a state container for late joiners or newly created UI.

Jumping, launching, and falling are different

Jump

Jump records a Character jump request. When Character Movement accepts it, it applies jump behavior and normally enters Falling. The Character can still be moving upward, and a held variable-height jump can continue providing jump force.

Use:

  • On Jumped for the moment an accepted jump begins;
  • Is Jump Providing Force when the held-jump force window matters; and
  • Is Falling for the broader airborne movement state.

Walking off a ledge produces Falling without On Jumped, which is exactly why Is Falling is the usual animation transition input.

Launch Character

Launch Character queues a launch velocity for the next Character Movement update. When processed, it enters Falling and fires the launch event. A launch can therefore produce Is Falling = true, but not every falling Character was launched.

Use On Launched or your ability/gameplay state when the cause matters. Use Movement Mode when the movement simulation matters.

Landing

On Landed and Movement Mode Changed have deliberately different moments:

falling capsule finds a valid landing spot
-> On Landed fires
   Movement Mode is still Falling here
   Hit Result and impact-time Velocity are available
-> movement changes to Walking or another ground mode
-> On Movement Mode Changed fires

Use On Landed for impact surface, landing velocity, fall damage, dust, or a landing sound. Use the transition to Walking/Nav Walking when downstream logic requires the new ground mode to be active already.

The Animation Blueprint pattern

Animation needs a stable snapshot for the graph's current update:

Event Blueprint Update Animation
-> Is Valid OwnerCharacter
-> Get Character Movement
-> Is Falling
-> set bIsFalling

OwnerCharacter
-> Get Velocity
-> Vector Length XY
-> set GroundSpeed

The state machine then reads the cached Boolean:

Locomotion -> Airborne when bIsFalling
Airborne -> Locomotion when NOT bIsFalling

This handles jumping and walking off ledges. Add more variables only when the poses really differ: Velocity.Z or gravity-relative vertical speed for ascent/descent, Is Crouched for crouch, or the full Movement Mode for swim, flight, and custom movement.

For UE5 thread-safe Animation Blueprint updates, follow the Property Access pattern rather than calling arbitrary game objects from a worker-thread graph. The important contract is unchanged: animation consumes the Character copy's current movement state; it does not author the authoritative mode.

Custom Movement Mode

Custom is one main enum value with a second uint8 - an unsigned byte from 0 through 255 - identifying your project's sub-mode.

Example project mapping:

Custom 0 -> Mantle
Custom 1 -> Ladder
Custom 2 -> Wall Run

The numbers have no built-in meaning. Define one mapping and reuse it in the movement component, Character, Animation Blueprint, and debugging output. In C++, projects commonly define their own byte-sized enum. In Blueprint, avoid scattering literal numbers across graphs; centralize the mapping in a function, enum conversion, or the system that owns custom movement.

Interpret the bytes conditionally:

  • Prev Custom Mode matters only if Prev Movement Mode is Custom;
  • New Custom Mode matters only if New Movement Mode is Custom; and
  • 0 can be a valid project sub-mode, not a failure value.

Changing from Custom 0 to Custom 1 is a real movement-mode change even though the main enum remains Custom.

When the result looks wrong

Invalid target

Is Falling needs a valid movement-interface target. On a Character, use its Character Movement component. An invalid reference cannot provide a meaningful answer; a Blueprint call can emit an Accessed None-style runtime diagnostic and leave the Boolean at its default false.

That false is not proof that the Character is grounded. Guard the Character or component reference before the query. In an Animation Blueprint editor preview, the expected live owner/component chain may not exist at all.

Similarly, reading Movement Mode through an invalid component can leave the default enum output looking like None. Check validity before treating None as a real disabled mode.

The event did not fire

Check these cases:

  1. No effective change occurred. Setting the same mode/sub-mode again does not create a transition.
  2. The listener bound too late. Read the current mode during initialization.
  3. You are watching another Character instance. In Play In Editor, select the correct client and debug object.
  4. You changed a variable that resembles a mode. A custom bIsFlying Boolean does not change Character Movement's enum.
  5. A network copy has not received the server update yet. Role and timing differ across machines.
  6. Another system immediately chose a second mode. A single movement update can leave one mode and continue physics in another; log previous and new values rather than watching only the final frame.

Is Falling is false in the air

Inspect Movement Mode. Flying, Swimming, Custom, and None can all exist away from a floor while reporting false. A physics-simulating actor may move through the air without Character Movement owning it at all.

Multiplayer: which copy knows what?

Character Movement uses different local paths by network role:

Copy What it observes
Authority (server) The authoritative mode after server movement simulation and validation.
Autonomous proxy (owning client) A locally predicted mode, later confirmed or corrected by the server.
Simulated proxy (other clients) The mode packed with replicated Character movement and applied after it arrives.

Movement Mode and its custom byte are included in the Character movement state replicated to simulated proxies. That lets remote Animation Blueprints observe Walking/Falling/etc. without running the remote player's input graph.

The transition event is local to each Character copy. The owning client can enter Falling before the server processes its move; a simulated proxy learns later. Never assume three event timestamps are one global gameplay moment.

Use the server's movement/landing state for authoritative fall damage, ability permission, or win/loss rules. Use each client's observed mode for local and remote animation/presentation. If a cosmetic effect must be seen by everyone, replicate the gameplay fact or trigger it through an appropriate networked presentation path; do not make a simulated proxy authoritative because its local event fired.

What these nodes do not do

Is Falling, Movement Mode, and the change event do not:

  • start a jump, launch, fall, swim, or flight mode;
  • tell you why Falling began;
  • tell ascent from descent;
  • provide a landing Hit Result;
  • guarantee a walkable floor when false;
  • change animation state by themselves;
  • make a custom movement mode simulate anything; or
  • make local gameplay authority global across the network.

Is Falling is a side-effect-free query. Reading Movement Mode is also a snapshot. The event is a notification after a local transition; none of them cache a history for you.

Lookalikes - which one do I want?

Node or event Use it when Not the same as
Is Falling You need a simple current airborne-mode Boolean. "Moving downward" or "jump was pressed."
Movement Mode You must distinguish ground, air, water, flight, custom, and disabled states. A command to change mode.
On Movement Mode Changed React once when a local Character enters or leaves a mode. Current-state initialization for a late listener.
On Jumped React to an accepted jump start. Walking off a ledge.
Is Jump Providing Force Check the held variable-height jump-force window. Every Falling state.
On Launched React to a processed Character launch. Every airborne cause.
On Landed Read impact Hit Result and landing-time velocity. A post-change Walking event; mode is still Falling during Landed.
Is Moving on Ground Accept the movement interface's ground states. A test for only plain Walking.
Velocity / vertical speed Distinguish motion direction or magnitude. The movement simulation mode.
Set Movement Mode Intentionally select a mode. A read-only query.

Going deeper