Jump & Launch Character

At a glance

Lives in: Blueprint API / Character - Target: Character - Returns: nothing - Can fail silently? yes, in the sense that the exec pin continues but the character may not actually leave the ground - Official docs: Jump and Launch Character

Jump is the normal character jump request. Launch Character is a one-time velocity shove. They both work on Character, not on every Pawn, and both are processed through Character Movement rather than teleporting the actor immediately.

The one-minute version

• Jump asks the Character to jump on the next movement update. It has no return value. If the character cannot jump, the graph still continues.
• Can Jump is the check that answers whether the character can jump in its current state. The default behavior can be extended in Blueprint with the custom CanJump event.
• For variable-height jumping, set Jump Max Hold Time above zero and call Stop Jumping on button release. Otherwise the character can keep receiving jump force until the hold time runs out.
• Jump Max Count controls how many jumps can happen before landing, such as a double jump.
• Launch Character sets a pending launch velocity. Character Movement applies it on its next tick, switches the character to falling, and fires the launched event.
• XYOverride and ZOverride decide whether launch velocity replaces current velocity on those axes or adds to it.

Jump: the normal button

For a normal player jump, the graph is small:

Input Jump Started / Pressed
-> Jump

Input Jump Completed / Released
-> Stop Jumping

Jump does not mean "set my Z location higher right now." It marks the Character as wanting to jump, and the Character/Character Movement update turns that request into vertical movement if the current state allows it.

The important settings are split across the Character and Character Movement:

Setting	Lives on	What it controls
Jump Max Count	Character	How many jump starts are allowed before the count resets, usually on landing.
Jump Max Hold Time	Character	How long held jump can continue applying jump force.
Jump Z Velocity	Character Movement Component	The upward velocity used for the jump.
Gravity Scale	Character Movement Component	How strongly gravity pulls the character back down.
Air Control	Character Movement Component	How much lateral steering is allowed while falling.

If the jump is the wrong height, start with Jump Z Velocity and Gravity Scale. If the jump only works once and you want a double jump, inspect Jump Max Count. If holding the button should change jump height, inspect Jump Max Hold Time and whether Stop Jumping runs on release.

What Jump actually does

At beginner altitude, the shape is:

pseudocode - not engine source

Jump:
    character records that jump input is pressed
    later, Character Movement update checks whether jumping is allowed
    if allowed:
        apply jump velocity through Character Movement
        movement mode becomes falling

The key point is that Jump is a request. It can be requested at a time when the character is not allowed to start another jump. The node does not return a success boolean and does not throw an exception.

Use Can Jump when you need a branch:

Input Jump Started
-> Can Jump
-> Branch
   True: Jump
   False: play denied sound or do nothing

Most player graphs do not need the branch for basic jumping. They just call Jump on press and Stop Jumping on release. The branch is useful when you need presentation around denial, such as a UI prompt, sound, or tutorial hint.

Stop Jumping and held jumps

Stop Jumping is not "make the character fall immediately." It clears the held jump request so held-jump force stops being applied.

If Jump Max Hold Time is zero, the release event may appear unnecessary because the jump is a tap-style impulse. Still wire the release event early. When you later tune variable-height jumping, the graph is already correct.

If Jump Max Hold Time is nonzero and you never call Stop Jumping, the Character can keep receiving jump force until the maximum hold time is reached. That is the common "my jump is always full height" or "release does nothing" mistake.

Launch Character: the shove

Launch Character is for a launch pad, knockback, bounce, dash-pop, or scripted throw. It takes a Launch Velocity vector and two override flags:

Pin	Meaning
Launch Velocity	Velocity to apply to the Character.
XYOverride	If true, replace horizontal X/Y velocity instead of adding to it.
ZOverride	If true, replace vertical Z velocity instead of adding to it.

The launch is stored as pending velocity and processed on the next Character Movement tick. When processed, the Character enters falling and the launched event fires.

Common launch pad shape:

Trigger BeginOverlap
-> Other Actor
-> Cast To Character
-> Launch Character
   Launch Velocity = Arrow Forward Vector * 1200 + (0, 0, 900)
   XYOverride = true
   ZOverride = true

Use an arrow component, scene component, or actor rotation to define the launch direction. That is easier to tune in the level than hard-coded world X/Y values.

Why the override flags matter

Without overrides, launch velocity adds to whatever velocity the Character already has. That can be exactly what you want for a bounce that preserves momentum.

It can also be the reason a launch feels weak:

• the character is already moving against the launch direction;
• a sideways launch adds only a small amount to a much larger current velocity;
• a vertical launch adds to an existing fall, so the resulting upward motion is smaller than expected;
• repeated launches stack when you expected each launch to reset the result.

Use overrides when the launch pad or ability should own that velocity component:

Launch pad that always throws the same way:
    XYOverride = true
    ZOverride = true

Bounce that preserves running speed but sets upward pop:
    XYOverride = false
    ZOverride = true

Knockback that adds to current fall:
    XYOverride = false or true, by design
    ZOverride = false

There is no universal right value. The flags are part of the ability design.

When nothing happens

1. The target is not a Character. These nodes live on Character. A plain Pawn or arbitrary Actor does not have Character jump/launch behavior.
2. The target reference is empty. A None Character reference gives you no useful movement.
3. The input event is not firing. Menus, input modes, mapping contexts, or disabled input can stop the graph before it reaches Jump.
4. The Character cannot jump right now. It may already have used its jump count, be in a blocked movement state, or have custom CanJump behavior.
5. Jump Z Velocity or Launch Velocity is too small. The request happens, but the visible motion is tiny.
6. You forgot Stop Jumping for held jumps. Release does not shorten the jump if the release graph never clears jump input.
7. Collision blocks the capsule. Neither node gives permission to pass through ceilings, walls, or other blocking geometry.
8. The server corrects the client. In multiplayer, client-only launch or movement changes can be corrected back by the server.

The exec output is not proof that a jump happened. It only proves the Blueprint flow continued.

What they do not do

• They do not work on every Pawn. Use Character or implement your own pawn movement.
• They do not set Max Walk Speed or normal run speed.
• They do not move the camera by themselves.
• They do not guarantee an animation state changes. Animation usually reads velocity, movement mode, or jump/fall state afterward.
• They do not ignore collision.
• They do not make client-only multiplayer movement authoritative.

Blueprint patterns

Basic jump

IA_Jump Started
-> Jump

IA_Jump Completed
-> Stop Jumping

Double jump tuning

Character defaults:
    Jump Max Count = 2

Character Movement:
    Jump Z Velocity = tune height
    Gravity Scale = tune hang time
    Air Control = tune steering

Launch pad

Box BeginOverlap
-> Other Actor
-> Cast To Character
-> Launch Character
   Launch Velocity = LaunchArrow Forward Vector * ForwardStrength
                   + World Up Vector * UpStrength
   XYOverride = true
   ZOverride = true

Knockback from damage

Event AnyDamage
-> direction from damage causer to character
-> Launch Character
   Launch Velocity = direction * KnockbackStrength + (0, 0, UpPop)
   XYOverride = false or true, depending on whether momentum should stack
   ZOverride = false

Lookalikes

Node or setting	Use when	Not the same as
Jump	A Character should perform its normal jump behavior.	Launch pads, knockback, or arbitrary vertical teleporting.
Stop Jumping	A held jump should stop receiving jump force on release.	Cancelling all falling motion.
Can Jump	You need to know whether Jump would be allowed before calling it.	Proof that a previous Jump node succeeded.
Launch Character	A Character should receive a one-time velocity shove.	Normal held movement input.
Add Movement Input	A pawn should request movement in a direction this frame.	Jumping or knockback.
Add Force / Add Impulse	A simulating physics body should receive physics force.	Character Movement's jump/launch system.
Set Actor Location / Teleport	You intentionally place an actor at a new location.	Movement simulation with falling, collision, and prediction.

Going deeper

• Character Movement Component: the knobs that matter - the settings that control jump height, gravity, air control, speed, and braking.
• Add Movement Input - normal movement input, which is separate from jumping and launch velocity.
• Possession - why your input graph may not run on the body you are watching.
• Get Velocity - what animation and debugging usually read after jump or launch changes velocity.
• Event AnyDamage / Apply Damage - a common place to trigger knockback.
• Official docs: Jump, Stop Jumping, Can Jump, Launch Character, and ACharacter.
• Engine source (requires engine access - we do not reproduce it here): ACharacter::Jump, ACharacter::StopJumping, ACharacter::CanJump, ACharacter::CheckJumpInput, ACharacter::LaunchCharacter, and ACharacter::OnLaunched in Engine/Source/Runtime/Engine/Private/Character.cpp and Engine/Source/Runtime/Engine/Classes/GameFramework/Character.h; launch processing and jump movement are tied into UCharacterMovementComponent in Engine/Source/Runtime/Engine/Private/Components/CharacterMovementComponent.cpp.