Skip to content

Crouch / Un Crouch / Can Crouch

At a glance

Lives in: Blueprint API / Character · Target: Character · Crouch / Un Crouch return: nothing - exec output only · Can Crouch returns: Boolean · Can fail by: the request completing without a stance change · Official pages: Crouch, Un Crouch, and Can Crouch

Crouch and Un Crouch are requests to the Character Movement Component. Their exec output means "the request was made," not "the capsule has already changed." Read Is Crouched or react to On Start Crouch / On End Crouch when you need the completed state.

The one-minute version

  • Enable Can Crouch on the Character Movement Component before expecting the built-in crouch system to work.
  • Crouch asks Character Movement to crouch on its next movement update. It has no success Boolean and no failure exec pin.
  • On success, Character Movement shrinks the collision capsule to Crouched Half Height, updates the Character's crouched state and offsets, and fires On Start Crouch.
  • Un Crouch asks to restore the standing capsule. If a ceiling blocks that larger capsule, the Character stays crouched; On End Crouch does not fire until standing actually succeeds.
  • Can Crouch answers whether a not-currently-crouched Character can begin crouching in its current movement state. It does not answer "is there headroom to stand up?"
  • Max Walk Speed Crouched is the ground-speed limit used while crouched. It is separate from Max Walk Speed.
  • Use Started -> Crouch and Completed/Canceled -> Un Crouch for hold input. For toggle input, branch on the completed Is Crouched state.
  • Built-in crouching participates in Character Movement's client prediction, and the authoritative Is Crouched state is replicated. Do not multicast your own capsule resizing.

What the nodes actually do

The Character owns the public Blueprint nodes, while its Character Movement Component owns the movement-state update and collision-size work.

pseudocode of the relationship - not engine source

Character.Crouch():
    if CanCrouch():
        CharacterMovement wants crouch = true
    // no immediate success result

next Character Movement update:
    if crouching is allowed in this state:
        try the crouched capsule size
        if it fits:
            mark Character as crouched
            update capsule / mesh / eye-height offsets
            fire On Start Crouch

Character.UnCrouch():
    CharacterMovement wants crouch = false

next Character Movement update:
    test whether the standing capsule fits
    if it fits:
        restore standing size and offsets
        mark Character as not crouched
        fire On End Crouch
    else:
        remain crouched

The request is deliberately processed with movement. That lets capsule collision, movement mode, floor handling, network prediction, and correction agree on the same stance instead of a Blueprint changing collision at an unrelated time.

The three return contracts

Node Output What that output proves
Crouch Exec only Blueprint reached the node and made a request. It does not prove crouching completed.
Un Crouch Exec only Blueprint requested standing. It does not prove the standing capsule fit.
Can Crouch Boolean The Character is not already crouched and its movement setup/current state allows a crouch attempt.

Can Crouch = false is not an error. It is an ordinary state result. On the default Character Movement implementation, crouching must be enabled and the current movement state must permit it; walking and falling permit it by default. The check can also fail when the target is already crouched or lacks a usable Character Movement Component.

Can Crouch is most useful for UI or a pre-check. You do not have to call it before every Crouch; the movement update performs its own authoritative checks. A pre-check can become stale before the next update, so the completed state still matters.

Required Character Movement settings

Select the Character Movement Component in the Character Blueprint and check:

Setting What it controls
Can Crouch Whether this movement agent may use the built-in crouch state. It appears with the movement/navigation capabilities.
Crouched Half Height The unscaled capsule half-height used while crouched, in centimeters.
Max Walk Speed Crouched The walking speed cap while the Character is crouched, in centimeters per second.
Crouched Eye Height The Character's base eye height while crouched. This lives on the Character.

Keep the crouched half-height large enough that capsule radius and collision remain sensible. Crouch is a shorter collision stance, not a way to turn the Character into a flat or physics-simulated object.

The Details panel category can move between engine versions, so search the component Details for Can Crouch if it is folded under Nav Movement or Nav Agent Properties.

What changes when crouch succeeds

The collision capsule is the important part. Character Movement changes the capsule half-height and adjusts the Character so the mesh does not simply jump up or down with the capsule center.

While walking, the usual behavior keeps the capsule base on the floor: the shorter capsule center moves down during crouch and back up during uncrouch. The movement component tracks this with its crouch-base-location behavior; other movement modes can handle the base differently.

The Character also updates:

  • Is Crouched, the completed stance Boolean;
  • its base eye height;
  • mesh/base translation offsets used to keep presentation aligned; and
  • On Start Crouch or On End Crouch callbacks.

The events expose two floats:

Event output Meaning
Half Height Adjust Difference between the default standing collision half-height and the crouched half-height.
Scaled Half Height Adjust The same difference after component scale is applied.

Most Blueprints do not need those floats. They are available when a custom camera, mesh offset, or other presentation needs the exact size change. Do not apply them to the capsule again; Character Movement already did that work.

When crouch or uncrouch does not complete

Crouch can be rejected

The request can leave the Character standing when:

  1. Can Crouch is disabled on Character Movement.
  2. The current movement state disallows crouching. The default permits walking and falling, but a custom mode can choose another rule.
  3. The target is already crouched. There is no second crouch state to enter.
  4. The target is not the Character you think it is. A reference to another pawn, an unpossessed instance, or None does not change the watched body.
  5. Custom Character Movement code rejects or replaces the built-in path.

The Crouch exec output still runs. There is no automatic log saying "crouch was rejected" and no failure branch. Check Is Crouched on a later movement update or use On Start Crouch when success matters.

A low ceiling can block Un Crouch

Standing requires the larger default capsule to fit without encroaching blocking geometry. Under a low ceiling:

Un Crouch request
-> desired crouch state becomes false
-> standing capsule overlap test fails
-> Is Crouched remains true
-> On End Crouch does not fire

Character Movement can try again on later updates while standing is still the desired state. When the Character reaches enough headroom, it can restore the standing capsule and fire On End Crouch.

This produces a useful distinction:

  • wants crouch can be false because the button was released;
  • is crouched can remain true because collision still requires the short capsule.

Do not force Is Crouched false or enlarge the capsule without the fit test. That can place the Character inside geometry.

None target behavior

These nodes target Character. Calling them through an invalid external Character reference produces an Accessed None-style Blueprint runtime error and no useful stance change. Inside the Character Blueprint, use Self.

Can Crouch on a valid Character returns a Boolean. It does not log because the Character is already crouched or because its current state disallows a new crouch; those are normal false results.

Hold input and toggle input

Hold to crouch

With an Enhanced Input Boolean action:

IA_Crouch Started
-> Crouch (Target = Self)

IA_Crouch Completed
-> Un Crouch (Target = Self)

IA_Crouch Canceled
-> Un Crouch (Target = Self)

Handling both Completed and Canceled prevents a held stance from getting stuck when a trigger or mapping context is interrupted. Avoid using Triggered for the request every update; one state change is enough.

Toggle crouch

The simplest toggle is:

IA_Crouch Started
-> Branch on Is Crouched
   true  -> Un Crouch
   false -> Crouch

For a game with blocked uncrouch, sprint cancellation, or animation transitions, keep a separate bWantsCrouch input state and let one stance function apply the request. Is Crouched remains the collision-approved result.

Speed, camera, and animation

Speed

While crouched on the ground, Character Movement uses Max Walk Speed Crouched. That property is not automatically kept in a custom relationship with Max Walk Speed. If slows and buffs affect both, calculate both limits from shared modifier state instead of copying whichever float happened to be current.

See Runtime Character Speed for the one-owner calculation pattern.

Camera

The Character updates its crouched eye height, but a Camera Component or Spring Arm with authored relative offsets may still need a local transition. Drive that presentation from the completed crouch state or crouch events and interpolate deliberately. Do not move the collision capsule again to smooth a camera.

In multiplayer, camera changes belong only on the locally viewed player copy. The server still owns gameplay collision; it does not need to run a local camera blend for every player.

Animation

An Animation Blueprint should read the Character's completed Is Crouched state, not guess from camera height or the input button:

OwnerCharacter
-> Is Crouched
-> AnimBP bIsCrouched
-> crouched locomotion state / blend

That stays correct when uncrouch is blocked. Continue to read actual velocity for movement speed; Max Walk Speed Crouched is a limit, not current motion.

Multiplayer behavior

Built-in Character crouching is part of the Character Movement networking path:

  • the owning autonomous client can predict its request;
  • the wants-to-crouch flag is represented in saved character moves sent to the server;
  • the server runs the authoritative movement and collision checks;
  • Is Crouched is a replicated Character property; and
  • non-owning client copies apply the replicated crouch state and offsets.

For ordinary player input, call Crouch / Un Crouch on the locally controlled Character and let Character Movement transport and correct its state. Do not add a multicast that manually shrinks every capsule; that duplicates the engine's prediction and replication work and can disagree with server collision.

Custom gameplay permission is still yours. If stamina, a status effect, or a server-only rule can forbid crouching, validate that rule authoritatively. A client's local Can Crouch result is not permission to bypass server game rules.

On simulated proxies, Is Crouched and the crouch events reflect the last state received from the server, not local input. Use that replicated result for remote animation. Keep local-only camera effects gated by local control.

What these nodes do not do

Crouch, Un Crouch, and Can Crouch do not:

  • create crouch animations or change an Animation Blueprint state machine;
  • bind an input action;
  • smooth a camera transition;
  • hide the mesh or disable collision;
  • change Max Walk Speed for standing movement;
  • prove the Character has room to stand;
  • return a failure reason; or
  • replace server validation for custom gameplay restrictions.

They own the Character's built-in crouch request and collision-approved state. Presentation and game-specific permission sit around that contract.

Lookalikes - which one do I want?

Node or value Use it when Common confusion
Crouch Request the built-in Character crouch state. Its exec output is not a success result.
Un Crouch Request the standing state. A low ceiling can keep Is Crouched true.
Can Crouch Ask whether a standing Character can begin a crouch attempt now. It is not an uncrouch-clearance test.
Is Crouched Read the completed, collision-approved Character state. It is not the input request.
On Start / End Crouch React when the stance really changes. They are not input events.
Set Capsule Half Height Build a custom capsule-size system with your own fit, movement, and replication rules. It bypasses the built-in crouch state contract.
Set Actor Scale Intentionally scale an entire Actor. It is not a safe crouch implementation.

Going deeper