Skip to content

Event Hit

At a glance

Lives in: Blueprint API / Add Event / Collision - Runs on: an Actor when one of its primitive components receives a blocking hit; component-level version is On Component Hit - Returns: no value; it starts execution and gives you hit details - Fails by: never firing, usually silently - Needs: blocking collision from movement, sweep, or physics; physics simulation hit notifications need Simulation Generates Hit Events - Official docs: Event Hit and On Component Hit

The one-minute version

  • Event Hit is for blocking contact: something tried to move into something solid and collision said "stop here."
  • It is not an overlap trigger. If the two objects are meant to pass through each other and report entry/exit, use overlap events.
  • The event gives you My Comp, Other, Other Comp, Self Moved, Hit Location, Hit Normal, Normal Impulse, and the full Hit result.
  • For physics-simulated contact to raise Blueprint hit events, enable Simulation Generates Hit Events on the component that needs the notification. Swept movement can still produce blocking hit events through the movement path.
  • Normal Impulse is useful for physics-simulated hits. For swept movement hits, it is usually zero.
  • Hit events can repeat while movement or physics keeps reporting blocking contact. Filter, gate, or destroy the projectile instead of assuming one contact means one event forever.

What it actually does

When a primitive component moves, sweeps, or participates in physics, Unreal can detect a blocking hit against another primitive component. The hit result is then dispatched to the owning actor and component delegates.

pseudocode of the engine behavior - not engine source

function MoveOrPhysicsStep(Component):
    Hit = try to move or simulate Component

    if Hit is a blocking hit:
        Owner = Component.GetOwner()
        dispatch actor hit notification to Owner
        dispatch component hit notification to Component

Blueprint exposes the actor-level version as Event Hit. It is convenient because it catches hits from the actor's components in one place. The cost of that convenience is that you must read My Comp to know which component on your actor was actually involved.

Event Hit
    My Comp        = component on this actor that hit or was hit
    Other          = actor on the other side
    Other Comp     = component on the other actor
    Self Moved     = whether this actor/component was the mover
    Hit Location   = contact location supplied by the event
    Hit Normal     = normal supplied by the event
    Normal Impulse = physics impulse when physics simulation reports one
    Hit            = full FHitResult details

If the exact component matters, use On Component Hit on that component:

flowchart LR
    Projectile[BP_Projectile] --> Sphere[Collision Sphere]
    Sphere -- On Component Hit --> HitLogic[Damage / impact logic]
    Projectile --> Mesh[Visual Mesh]

That graph says "only the collision sphere handles projectile impacts." The visual mesh can ignore hit logic completely.

Hit vs overlap

Hit and overlap answer different collision questions:

You want Use
A wall stops the player capsule. Hit/blocking collision.
A projectile should explode when it strikes a wall. Hit or swept movement result.
A trigger opens when the player walks through it. Begin/End overlap.
A pickup is collected when the player enters its sphere. Begin overlap.
A laser asks what object is under the crosshair right now. Trace by channel.

A blocking hit means the movement path found a solid obstruction. An overlap means the two shapes are allowed to interpenetrate and optionally notify you. Trying to use one as the other creates most beginner collision confusion:

  • a trigger set to Block may stop the player instead of feeling like an area;
  • a wall set to Overlap may let the player walk through it;
  • a projectile with overlap-only collision may never fill the impact fields you expected from a blocking hit.

When it fails (and what failure does)

Event Hit has no Failed pin. If Unreal does not dispatch a hit notification, your Blueprint simply does not run.

Common causes:

  1. The pair does not block. If either side ignores, there is no interaction. If the pair resolves to overlap, use overlap events instead.
  2. Movement did not ask for collision. Teleport-style movement, such as setting a location with Sweep off, can skip the swept blocking hit path.
  3. Physics simulation notifications are off. For simulating bodies, the component that wants Blueprint hit notifications needs Simulation Generates Hit Events enabled.
  4. You listened at the wrong level. Actor Event Hit catches the actor's dispatch; component On Component Hit listens to one component. If your collision is on a child sphere but your logic assumes the mesh, inspect My Comp.
  5. The collision shape is wrong or missing. A visual mesh can look solid while the actual collision geometry is absent, too simple, or on another component.
  6. You are already penetrating or resting. Initial penetration and continuous contact can produce behavior that feels different from a clean "one impact" moment. Use the Hit result fields and gate repeated logic.
  7. You are watching the wrong world. In multiplayer, hit events are local to the server or client world where the movement/physics happened. They are not automatic replicated gameplay events.

Failure does not apply damage, run End Overlap, bounce the actor, print a warning, or retry later. The physics/movement result and your Blueprint logic are separate things.

The Hit Result fields beginners need

The full Hit pin is an FHitResult: a packed report about the blocking hit. Break it when you need details beyond the top-level event pins.

Field Beginner translation
Hit Actor / Actor The actor on the other side of the hit. Often the same thing as Other.
Hit Component / Component The component on the other side. Often the same thing as Other Comp.
Location For a sweep, where the moving shape ended up when it was stopped.
Impact Point The contact point on the impacted surface. For a line trace, this is often the same as Location; for a swept sphere or capsule, it can differ.
Normal Direction associated with the swept shape's movement/result. Useful for sliding or response direction.
Impact Normal Surface normal at the thing you hit. Useful for placing decals, sparks, or aligning impact effects.
Blocking Hit Whether this hit was a blocking result.
Start Penetrating Whether the query started already inside something.
Bone Name Skeletal mesh bone hit, when the hit data has one.
Physical Material Surface material, when requested and available.

For a beginner projectile impact, the two fields you reach for most are:

Impact Point  -> spawn impact effect at the surface
Impact Normal -> orient the effect away from the surface

For movement response, Location, Normal, Blocking Hit, and Start Penetrating are usually more important than the actor name.

Why Hit can fire over and over

Blocking contact can be reported more than once. A character holding movement into a wall asks the movement system to move into that wall every frame. A simulating physics body resting against something can keep producing contact reports. A projectile can hit, bounce, and hit again.

Do not treat Event Hit as "guaranteed one time per actor." Make your graph explicit:

Projectile Event Hit
-> Branch bAlreadyExploded is false
-> Set bAlreadyExploded true
-> Apply Damage / spawn impact effect
-> Destroy Actor

For a shove, bounce, or sound that should happen repeatedly, use a cooldown:

Event Hit
-> Branch TimeSinceLastImpactSound > 0.2
-> Play Sound at Location
-> Set LastImpactSoundTime

For a player pressing into a wall, you usually do nothing in Event Hit; the movement component already handled "do not pass through the wall."

What Event Hit does not do

  • It does not mean damage happened. It only reports blocking contact.
  • It does not choose the gameplay target. Filter Other, Other Comp, owner, tags, team, or interface before acting.
  • It does not guarantee a physics impulse. Normal Impulse is zero for swept blocking hits.
  • It does not fire for overlap-only triggers.
  • It does not promise one event per actor. It is tied to collision reporting, not your gameplay story.
  • It does not replicate. Server-authoritative hit gameplay still belongs on the server.

The pattern everyone actually uses

For a simple projectile:

CollisionSphere.OnComponentHit
-> Other Actor
-> Is Valid
-> Branch Other Actor != self and Other Actor != Get Owner
-> Apply Point Damage or Apply Damage
   Damaged Actor = Other Actor
   Damage Causer = self
   Event Instigator = Get Instigator Controller
-> Spawn impact effect at Hit.ImpactPoint
-> Destroy Actor

For a physics crate impact sound:

StaticMesh.OnComponentHit
-> Normal Impulse
-> Vector Length
-> Branch length > impact threshold
-> Play Sound at Location

For C++, bind the component whose collision matters:

void ATrainingProjectile::BeginPlay()
{
    Super::BeginPlay();

    CollisionSphere->OnComponentHit.AddDynamic(
        this, &ATrainingProjectile::HandleHit);
}

void ATrainingProjectile::HandleHit(
    UPrimitiveComponent* HitComponent,
    AActor* OtherActor,
    UPrimitiveComponent* OtherComp,
    FVector NormalImpulse,
    const FHitResult& Hit)
{
    if (!IsValid(OtherActor) || OtherActor == this || OtherActor == GetOwner())
    {
        return;
    }

    UGameplayStatics::ApplyPointDamage(
        OtherActor,
        Damage,
        GetVelocity().GetSafeNormal(),
        Hit,
        GetInstigatorController(),
        this,
        DamageTypeClass);

    Destroy();
}

Lookalikes - which one do I want?

Event or node Use when Watch out
Event Hit Actor-level blocking hit handling is enough. Check My Comp so you know which component hit.
On Component Hit One specific component owns the hit logic. Preferred for projectiles, hitboxes, and physics meshes with clear collision components.
On Actor Hit You want to bind to another actor's hit delegate. It is still actor-level; component identity may be hidden.
On Component Begin / End Overlap You want trigger-style enter/exit logic. Overlap lets objects pass through; it is not a blocking impact.
Line Trace By Channel You want to ask what is under a ray right now. A trace result is a query, not a physical collision event.
Apply Point Damage You already have a hit and want damage with location/normal data. Damage is not automatic; you call it after filtering.
Projectile Movement bounce / stop events Projectile movement owns the bounce/stop behavior. Use these when the movement component is the real state machine.

Rule of thumb: use hit events for solid contact, overlap events for areas, and traces for questions.

Going deeper