Skip to content

Add Impulse / Add Force

At a glance

Lives in: Blueprint API / Physics - Target: Primitive Component for the physics-body nodes - Returns: no value and no success/failure branch - Can fail silently? yes; execution continues even if the body does not visibly move - Main choice: impulse is a one-time hit; force is a push over time - Official docs: Add Impulse, UPrimitiveComponent::AddForce, and Set Simulate Physics

Add Impulse and Add Force push a physics body. They are not normal Character movement buttons, and they are not a magic "move any actor" command.

The one-minute version

  • Add Impulse is a one-frame shove. Use it for a box hit, explosion pop, tossed prop, or instant knock.
  • Add Force is a continuous push. Call it every frame or on a repeated physics update for as long as the thruster/wind/magnet should push.
  • These Physics-category nodes act on a Primitive Component that has a physics body, such as a Static Mesh Component, Skeletal Mesh body, Box Component, Capsule Component, or Sphere Component.
  • For a normal Character, use Launch Character for knockback or launch pads. Character movement is not the same as a loose simulating physics prop.
  • If the component is not simulating physics, the node can run with no visible movement. The exec wire continuing is not proof that a shove happened.
  • Vel Change / Accel Change make the push ignore mass. Without those flags, heavier bodies react less.
  • Turning on Simulate Physics for a simple attached component can detach it from its parent. That is why a held mesh can "fall off" a character when you make it simulate physics.

What they actually do

Both nodes hand a vector to the component's physics body. The vector carries both direction and strength:

Impulse = ForwardVector * 1200
Force   = UpVector * 50000

At beginner altitude:

pseudocode of the engine behavior - not engine source

AddImpulse(Component, Impulse, BoneName, VelChange):
    body = find the physics body on Component, or named skeletal body
    if body can receive physics impulses:
        if VelChange:
            treat Impulse as a direct velocity change
        else:
            treat Impulse as mass-dependent impulse
        apply it once
    return nothing

AddForce(Component, Force, BoneName, AccelChange):
    body = find the physics body on Component, or named skeletal body
    if body can receive physics force:
        if AccelChange:
            treat Force as acceleration change
        else:
            treat Force as mass-dependent force
        add it for this physics step
    return nothing

The node does not spawn a physics body, enable simulation, choose a direction for you, or switch a Character into ragdoll. It only applies a physics input to a body that is already set up to respond.

Impulse vs force

Need Use How often
Explosion kick, bullet hit, pickup toss, one bounce Add Impulse Once per event.
Wind, magnet pull, hover thrust, engine thrust Add Force Every frame or every physics update while active.

The common mistake is calling Add Force once from BeginOverlap and expecting a dramatic launch. A force is useful because it accumulates over time. If you only have one event pulse, use impulse.

Explosion overlap
-> Add Impulse

Wind volume while actor remains inside
-> Tick or timer while overlapping
-> Add Force

The pins that matter

Target

The component receiving the physics input. This is usually a mesh or collision component, not the Actor reference itself.

If you drag from an Actor and cannot find the node you expect, get the actor's Static Mesh Component, Skeletal Mesh Component, Capsule Component, or another Primitive Component first.

Impulse / Force

The vector is in world space for the normal Blueprint nodes. Its direction is the direction of the push. Its length is the strength.

Useful direction recipes:

Push away from explosion:
    Direction = Normalize(TargetLocation - ExplosionLocation)
    Impulse = Direction * Strength

Throw forward:
    Impulse = ActorForwardVector * Strength + WorldUpVector * UpStrength

Constant upward thruster:
    Force = WorldUpVector * Strength

If the object moves sideways when you expected forward, inspect which forward vector you used. Actor forward, control/camera forward, and component forward can be different. See Get Forward Vector & Find Look at Rotation.

Bone Name

For a Skeletal Mesh Component with a physics asset, Bone Name chooses which body receives the push. None means the root body. For a Static Mesh Component, leave it as None.

If you are working with ragdolls, body names come from the physics asset, not from a random Blueprint variable name.

Vel Change / Accel Change

These flags decide whether mass matters:

Flag On Off
Vel Change on Add Impulse Treat the vector as direct velocity change. Mass does not reduce the result. Treat the vector as an impulse. Heavier bodies move less.
Accel Change on Add Force Treat the vector as acceleration. Mass does not reduce the result. Treat the vector as a force. Heavier bodies accelerate less.

Use mass-dependent pushes when weight should matter. Use velocity/acceleration change when the design says every object should receive the same motion change regardless of mass.

The Simulate Physics prerequisite

A placed mesh can block, overlap, and move with Set Actor Location without being a simulating physics body. Add Impulse and Add Force need the physics body path.

For a simple prop:

Static Mesh Component
-> Collision enabled
-> Simulate Physics = true
-> Add Impulse on that Static Mesh Component

If Simulate Physics is off, the node can run and still produce no visible movement. If collision is disabled or the body is constrained, the result can also look wrong even though the call happened.

Why a held mesh falls off

When you turn on Simulate Physics for a simple component that is attached to another component, Unreal may detach that component so physics can move it independently. That is intentional engine behavior: a simulated body cannot also be treated as a normal child transform in the same simple way.

That is the "my sword fell out of the hand socket" trap:

Character mesh
-> sword mesh attached to hand socket
-> Set Simulate Physics true on sword mesh
-> sword stops behaving like a normal attached child and falls

For held items, common solutions are:

  • keep physics simulation off while held, then enable it after dropping;
  • spawn a separate dropped physics actor and destroy/hide the held visual;
  • use a physics constraint or handle when you intentionally want a held object to simulate;
  • explicitly reattach after turning simulation off again, if that is your design.

Characters are different

A Character is driven by Character Movement, not by treating the whole actor as a loose rigid body. The default Character capsule is not usually a free-simulating physics prop.

Use this split:

Goal First node to consider
Launch pad or knockback for a player/enemy Character Launch Character
Normal walking input Add Movement Input
Push a loose crate, barrel, pickup, debris, grenade Add Impulse or Add Force on the mesh/collision component
Make a dead character ragdoll Enable physics on the skeletal mesh bodies, then apply impulses to bones as needed

There are also Character Movement Component versions of Add Force and Add Impulse. Those feed Character Movement's accumulated force/impulse path, not the same Primitive Component rigid-body path this page focuses on.

The pattern everyone actually uses

Toss a physics pickup

Drop item
-> Detach from hand
-> Set Simulate Physics true on item mesh
-> Add Impulse
   Impulse = Character Forward Vector * ThrowStrength
           + World Up Vector * TossUp
   Vel Change = false or true, by design

Explosion pushes nearby props

Explosion happens
-> sphere overlap for physics props
-> for each hit component:
      Direction = Normalize(ComponentLocation - ExplosionLocation)
      Add Impulse(Direction * ExplosionStrength)

Use a radial-force component or radial impulse node when you need a more purpose-built explosion shape. The point here is the same: physics bodies receive physics input; gameplay actors do not automatically become physics.

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

void APhysicsPickup::ThrowFrom(const FVector& Origin, const FVector& Direction)
{
    if (!IsValid(ItemMesh))
    {
        return;
    }

    ItemMesh->DetachFromComponent(FDetachmentTransformRules::KeepWorldTransform);
    ItemMesh->SetSimulatePhysics(true);

    const FVector Impulse = Direction.GetSafeNormal() * ThrowStrength
                          + FVector::UpVector * TossUpStrength;
    ItemMesh->AddImpulse(Impulse, NAME_None, false);
}

When nothing moves

  1. Target is the wrong thing. You called the node on an actor or a non-simulating component instead of the primitive component that owns the physics body.
  2. Simulate Physics is off. The body is not being driven by physics.
  3. The vector is too small. A mass-dependent impulse that moves a can may barely move a heavy crate.
  4. You used Add Force once. Use impulse for an event hit, or keep applying force over time.
  5. The body is constrained or blocked. Constraints, locked axes, collision, and sleeping/wake behavior can hide or limit the result.
  6. You pushed the wrong skeletal body. Check the Bone Name and the physics asset.
  7. A client-only shove was corrected. In multiplayer, the server should own authoritative physics/gameplay movement for replicated actors.

Print the target component's name, whether it is simulating physics, the vector length, and the target mass while debugging. Guessing from the visible actor is usually slower.

What they do not do

  • They do not enable Simulate Physics.
  • They do not attach, detach, or spawn actors by themselves.
  • They do not work like Launch Character on a normal Character.
  • They do not guarantee the body wakes, clears constraints, or ignores collision.
  • They do not replicate the shove to other machines just because the local graph ran.
  • They do not move the actor root unless the pushed component/body is what actually drives that actor's world motion.

Lookalikes - which one do I want?

Node or component Use when Not the same as
Add Impulse One-time physics-body shove. Continuous force or Character launch.
Add Force Continuous physics-body push over time. Instant explosion kick.
Add Impulse at Location The hit point matters and should add spin/torque. Pushing through the center of mass only.
Add Radial Impulse / Radial Force Explosion or field affects many bodies from a point. Manually computing one component's direction.
Launch Character Character knockback, launch pads, bounce pads. Simulating a loose prop.
Add Movement Input Player/AI movement requests through pawn movement. Physics force.
Projectile Movement Component Non-physics projectile-style movement. Simulating a tumbling rigid body.
Physics Constraint / Physics Handle Hold or connect simulating objects. A one-time push.

Going deeper