Skip to content

Projectile Movement Component and First Projectile Actor

At a glance

Lives on: an Actor as a Projectile Movement Component - Moves: the component named by UpdatedComponent, usually the actor's root collision component - Returns: no value; it updates movement during tick and exposes bounce / stop events - Fails by: not moving, moving the wrong component, stopping on a blocking hit, or handing motion to physics - Official docs: UProjectileMovementComponent, Movement Components, and Implementing Projectiles

The one-minute version

  • A Projectile Movement Component is the usual beginner way to make a spawned actor fly like a bullet, fireball, grenade, thrown rock, or simple homing missile.
  • The projectile actor still needs a real component tree: a root collision component, a visual mesh/effect under it, and the movement component.
  • The movement component normally moves the actor's root component. If your root is a plain scene component and the collision sphere is a child, the projectile may move without sweeping the part you expected.
  • Initial Speed and Velocity define the starting motion. If Initial Speed is greater than zero, Velocity is mainly the direction; Initial Speed supplies the magnitude.
  • Initial Velocity in Local Space means the velocity direction is interpreted relative to the projectile actor's rotation. That is why spawn rotation and local X+ direction matter.
  • Projectile Gravity Scale, bounce settings, homing settings, collision responses, and lifespan are all separate. A projectile can spawn correctly and still fall, bounce, stop, miss collision, or live forever.
  • In multiplayer, the server should usually spawn the authoritative gameplay projectile. Local muzzle flashes and camera shake can still happen immediately on the owning client.

What it actually does

The component is a movement component. It does not create a projectile by itself. It updates another component's transform over time.

pseudocode of the engine behavior - not engine source

ProjectileMovement tick:
    if simulation is disabled or UpdatedComponent is missing:
        do nothing

    if this is the first update:
        initialize Velocity from InitialSpeed / Velocity / local-space setting

    acceleration = gravity + homing + pending forces
    Velocity = integrate Velocity with acceleration and MaxSpeed
    move_delta = Velocity * DeltaSeconds

    sweep UpdatedComponent by move_delta
    if blocking hit:
        bounce, slide, stop, or fire projectile stop/bounce delegates

The important hidden word is UpdatedComponent. Projectile Movement Component moves that component. For a first projectile, make the collision sphere, capsule, or mesh collision body the root component so the swept movement and the actor transform agree.

BP_Projectile
-> SphereCollision (root, query/physics collision)
   -> StaticMesh or Niagara visual
-> ProjectileMovementComponent

If the actor root is an empty scene component and the collision sphere is a child, movement can move the root while collision events and blocking settings live somewhere else. That setup is sometimes intentional, but it is not the beginner default.

First projectile actor setup

A reliable first projectile actor has four jobs:

Part Beginner job
Root collision component The shape that sweeps, blocks, overlaps, and supplies hit data.
Visual component Mesh, Niagara, decal helper, or sprite that shows the projectile.
Projectile Movement Component Moves the updated component every tick.
Lifetime / impact logic Destroys the actor, applies damage, and spawns feedback.

The usual Blueprint setup:

BP_Projectile defaults
    SphereCollision = RootComponent
    SphereCollision collision preset blocks WorldStatic and valid targets
    SphereCollision Generate Hit Events only if your hit path needs it
    ProjectileMovement Initial Speed = 3000
    ProjectileMovement Max Speed = 3000
    ProjectileMovement Initial Velocity in Local Space = true
    ProjectileMovement Projectile Gravity Scale = 0 for a straight shot
    Initial Life Span = 3.0

SphereCollision.OnComponentHit or ProjectileMovement.OnProjectileStop
-> filter Other Actor
-> Apply Damage or Apply Point Damage
-> Spawn impact sound/VFX/decal
-> Destroy Actor

The firing actor's job is separate:

Input Fire
-> get Muzzle SceneComponent world transform
-> Spawn Actor from Class BP_Projectile
   Spawn Transform = Muzzle world transform
   Instigator = firing pawn
   Owner = firing actor/controller only when your networking or visibility
           rules need that actor-owner relationship
-> Is Valid Return Value

That spawn transform gives the projectile a starting location and rotation. The movement component then turns its velocity settings into motion.

Initial Speed, Velocity, and local direction

Beginners usually hit two direction traps:

  1. The projectile spawns at the muzzle but flies sideways.
  2. The projectile appears to aim correctly but falls or curves wrong.

The first trap is axis setup. Unreal's forward direction is local X+. If Initial Velocity in Local Space is enabled and Velocity is (1, 0, 0), the projectile moves along the actor's local X+ after spawn. If the visible mesh was imported facing Y+ or rotated under the root, the mesh can look sideways while the movement component is doing the right thing.

Fix the source, not the symptom:

Muzzle component points X+ where the shot should travel
-> Spawn Actor from Class using Muzzle world transform
-> Projectile Movement reads local X+ velocity

If you only rotate the visual mesh until it looks right, the actor's local forward can still be wrong. Use an Arrow or Muzzle scene component to inspect the intended X+ direction.

The second trap is speed setup:

Setting What to remember
Initial Speed Starting magnitude. If greater than zero, it can override the length of Velocity.
Velocity Starting direction, and magnitude when Initial Speed is zero.
Max Speed Cap on velocity magnitude. 0 means no cap from that property.
Initial Velocity in Local Space Whether the starting velocity is converted from actor local space to world space.
Projectile Gravity Scale Multiplier for gravity. 0 gives no gravity from this component.

For a straight training projectile:

Initial Speed = 3000
Max Speed = 3000
Velocity = (1, 0, 0)
Initial Velocity in Local Space = true
Projectile Gravity Scale = 0

For a grenade:

Initial Speed = 1200
Velocity = (1, 0, 0.35)
Initial Velocity in Local Space = true
Projectile Gravity Scale = 1
bShouldBounce = true

Those values are project tuning, not universal numbers.

Collision, bounce, and stop

Projectile movement uses swept movement when sweep collision is enabled. The collision component still decides what blocks, overlaps, or ignores the projectile.

For a projectile that should hit walls and enemies:

Projectile collision sphere
    Collision Enabled = Query and Physics or Query Only, depending on setup
    Object Type = Projectile or WorldDynamic
    Response to WorldStatic = Block
    Response to Pawn = Block or Overlap, depending on your damage path
    Response to the shooter's own components = Ignore, or filter in logic

What happens on contact depends on both collision and movement settings:

Setup Result
Target ignores projectile channel Projectile passes through for that interaction.
Target overlaps projectile channel Overlap events can fire if both sides generate overlaps.
Target blocks projectile channel and bounce is off Projectile movement can stop on the hit.
Target blocks projectile channel and bounce is on Projectile movement can reflect velocity and continue.
Updated component simulates physics Physics simulation can take over after the initial launch.

Use the event that matches your design. On Component Hit is a component-level blocking-contact event. On Projectile Bounce and On Projectile Stop belong to the movement component's simulation state. On Component Begin Overlap is a trigger-style event. They answer different questions.

Homing

Homing is not "find the nearest enemy." The movement component needs a target scene component and acceleration settings.

ProjectileMovement
    bIsHomingProjectile = true
    HomingTargetComponent = target actor's root/mesh/component
    HomingAccelerationMagnitude = tuned steering strength

If the target component is missing, destroyed, or never assigned, homing has nothing useful to steer toward. If acceleration is too low compared with speed, the projectile may barely turn. If it is too high, it can look like a snapping missile instead of an arcing one.

When it fails or looks broken

Failure usually looks like silence or wrong movement. There is no "Failed" execution pin.

Common causes:

  1. No updated component. The movement component has nothing useful to move. Use a root collision component for the beginner projectile shape.
  2. Zero useful velocity. Initial Speed is zero and Velocity is zero, or the direction vector was accidentally cleared.
  3. Wrong local axis. The actor's X+ does not point where the muzzle/crosshair points.
  4. Collision stops the spawn immediately. The projectile starts inside the shooter, wall, or weapon. Move the muzzle forward, ignore the shooter, or change spawn collision handling deliberately.
  5. Physics simulation takes over. A simulating updated component is no longer being steered every tick by projectile movement the same way a non-simulating component is.
  6. Bounce is enabled when you expected impact cleanup. The projectile hits, bounces, and keeps living because the movement component is following bounce rules.
  7. Gravity is still active. Projectile Gravity Scale is not zero, so a bullet-like projectile drops.
  8. Lifetime is missing. A projectile that never hits anything can stay in the level forever unless you set lifespan or another cleanup policy.
  9. Client spawned the gameplay projectile. In multiplayer, the local actor exists only where it was spawned unless the server also creates the replicated actor.

Use Print String and the Output Log or breakpoints to inspect the projectile's actor rotation, velocity, updated component, collision profile, owner/instigator, and authority.

What it does not do

  • It does not spawn the projectile actor. Use Spawn Actor from Class.
  • It does not choose the muzzle transform. Use a scene component, socket, or actor/camera transform intentionally.
  • It does not apply damage. Call Apply Damage or Apply Point Damage after a valid hit/overlap/stop result.
  • It does not ignore the shooter automatically in every setup.
  • It does not make the visual mesh face the travel direction unless rotation settings and mesh axes agree.
  • It does not replicate local client spawns into server authority.
  • It does not clean up misses unless lifespan, distance, or custom logic does.

The pattern everyone actually uses

For a first single-player projectile:

BP_PlayerCharacter Fire
-> MuzzleComponent.GetWorldTransform
-> Spawn Actor from Class BP_Projectile
   Instigator = self
-> Is Valid Return Value

BP_Projectile
-> SphereCollision root
-> ProjectileMovement Initial Speed / local velocity
-> SphereCollision OnComponentHit
-> Other Actor != self and Other Actor != GetInstigator
-> Apply Point Damage
-> Spawn Niagara / decal / sound at Hit.ImpactPoint
-> Destroy Actor

For a multiplayer projectile:

Owning client presses Fire
-> play local muzzle flash if desired
-> Run on Server: ServerFire
-> server checks ammo/cooldown/range
-> server Spawn Actor from Class BP_Projectile
   Replicates = true on class
   Replicate Movement = true if this actor's movement should replicate
   Instigator = firing pawn
-> clients receive the replicated projectile or approved impact state

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

ATrainingProjectile::ATrainingProjectile()
{
    CollisionSphere = CreateDefaultSubobject<USphereComponent>(TEXT("Collision"));
    RootComponent = CollisionSphere;

    ProjectileMovement =
        CreateDefaultSubobject<UProjectileMovementComponent>(TEXT("ProjectileMovement"));
    ProjectileMovement->UpdatedComponent = CollisionSphere;
    ProjectileMovement->InitialSpeed = 3000.0f;
    ProjectileMovement->MaxSpeed = 3000.0f;
    ProjectileMovement->bInitialVelocityInLocalSpace = true;
    ProjectileMovement->ProjectileGravityScale = 0.0f;

    InitialLifeSpan = 3.0f;
}

Lookalikes - which one do I want?

Tool Use when Watch out
Projectile Movement Component A spawned actor should move like a projectile without you writing Tick movement. Collision/root setup still matters.
Line Trace By Channel The weapon hit is instant, like a hitscan rifle or interaction ray. It does not create a moving projectile.
Sphere / Capsule Trace The hit test needs thickness or melee forgiveness. It is still a query, not a flying actor.
Add Impulse / Add Force A physics body should be shoved or continuously pushed. Physics simulation is not the same as projectile movement steering.
Character Movement Component A Character walks, falls, jumps, or swims. It is for Characters, not arbitrary projectile actors.
Timeline / Set Actor Location You need authored, deterministic motion such as a door or platform. You must handle collision and impact behavior yourself.

Rule of thumb: use projectile movement when a spawned actor should travel over time and own its own collision/impact lifetime.

Going deeper