Skip to content

Apply Point Damage / Apply Radial Damage / Damage Type

At a glance

Lives in: Blueprint API / Game / Damage - Target: Gameplay Statics - Apply Point Damage returns: a real number: the damage the target accepted - Apply Radial Damage returns: a Boolean: whether at least one actor was damaged - Network rule: Blueprint damage calls and point/radial damage events are authority-only; real health changes belong on the server - Official docs: Apply Point Damage, Apply Radial Damage, Apply Radial Damage with Falloff, Event PointDamage, and Event RadialDamage

The one-minute version

  • Use Apply Damage when the receiver only needs "take this amount from this source."
  • Use Apply Point Damage when the hit is one impact: bullet trace, projectile hit, weak spot, headshot, melee contact, or any case where the receiver needs the hit component, bone name, hit location, hit normal, or shot direction.
  • Use Apply Radial Damage when the source is an area: explosion, shockwave, radial trap, or blast around a world location.
  • Point damage returns the amount the target's damage path accepted. Radial damage returns true/false for "did anyone get damaged?"
  • Damage Type Class is class data that describes the category of damage. It is not health logic, not per-hit state, and not automatic fire/poison behavior unless your receiver branches on it or native code uses it.
  • Instigated By is the responsible controller. Damage Causer is the actor that directly caused the damage, such as a projectile, weapon, grenade, trap, or hazard actor.
  • In multiplayer, clients can play immediate cosmetic feedback, but the server should validate the hit and call the damage node that changes real gameplay state.

What the point/radial nodes actually do

The damage family is still the same Unreal damage pipeline. The point and radial versions send richer damage events through that pipeline.

flowchart LR
    Detect[Trace / projectile / explosion] --> Apply[Apply Point or Radial Damage]
    Apply --> Target[Damaged actor]
    Target --> TakeDamage[Actor damage path]
    TakeDamage --> Specific[Event PointDamage or Event RadialDamage]
    TakeDamage --> Any[Event AnyDamage / delegates]
    Specific --> Health[Your health and reaction logic]
    Any --> Health

The engine-side shape is roughly:

pseudocode of the engine behavior - not engine source

ApplyPointDamage(Target, Amount, Direction, HitResult, Instigator, Causer, Type):
    if Target is None or Amount is not useful:
        return 0

    Event = point damage event with Amount, HitResult, Direction, and Type
    return Target.TakeDamage(Amount, Event, Instigator, Causer)

ApplyRadialDamage(World, Amount, Origin, Radius, Type, Ignores, Causer, Instigator):
    find locally authoritative actors inside Radius
    for each candidate:
        skip ignored actors and the damage causer
        skip candidates blocked by the prevention channel
        send a radial damage event to that actor

    return true if at least one actor accepted damage

For Blueprint beginners, the important part is the event payload:

Sender Receiver event Extra data the receiver gets
Apply Damage Event AnyDamage Damage amount, damage type, instigator, damage causer.
Apply Point Damage Event PointDamage plus the generic damage path Hit location, hit normal, hit component, bone name, shot direction, full hit result.
Apply Radial Damage Event RadialDamage plus the generic damage path Origin, radial hit info, instigator, damage causer, damage type.

Do not use point or radial damage because the names sound more advanced. Use them when the receiver needs the extra information.

Apply Point Damage

Point damage is a single-impact message. It is the natural follow-up to a trace hit, projectile hit, or melee sweep result.

Pin Beginner read
Damaged Actor Actor that should receive the damage message. Guard it with Is Valid before sending.
Base Damage Amount you want to send before the target's damage path changes or rejects it.
Hit from Direction Direction the hit came from. Use the shot/travel direction, not a random actor forward.
Hit Info The FHitResult from the trace, sweep, overlap sweep, or blocking hit.
Event Instigator Controller responsible for the damage: usually the shooter's controller.
Damage Causer Actor that directly caused it: projectile, weapon actor, hazard, or sometimes the attacking pawn.
Damage Type Class Optional class category such as bullet, fire, fall, poison, or explosion.

Event PointDamage is useful because the damaged actor can branch on exact impact data:

Enemy Event PointDamage
-> Break Hit Info
-> Branch Bone Name == "head"
-> FinalDamage = Damage * HeadshotMultiplier
-> Health = Clamp(Health - FinalDamage, 0, MaxHealth)
-> Spawn hit reaction from Hit Location / Hit Normal

For a hitscan rifle:

Input Fire
-> Line Trace By Channel
-> Branch Return Value
-> Break Hit Result
-> Hit Actor
-> Is Valid
-> Apply Point Damage
   Damaged Actor = Hit Actor
   Base Damage = RifleDamage
   Hit from Direction = TraceDirection
   Hit Info = Out Hit
   Event Instigator = Get Controller
   Damage Causer = self or weapon actor

For a projectile:

Projectile OnComponentHit
-> Other Actor
-> filter self / instigator / invalid target
-> Apply Point Damage
   Hit from Direction = Projectile Velocity normalized
   Hit Info = Hit
   Event Instigator = Get Instigator Controller
   Damage Causer = self projectile
-> impact feedback
-> Destroy Actor

The Return Value is a number. It is not the target, not the remaining health, and not guaranteed to equal Base Damage if the target's native damage path changes the amount.

Apply Radial Damage

Radial damage asks "which actors around this origin should take area damage?"

Pin Beginner read
Base Damage Damage at the origin. With plain radial damage, this may be full damage depending on the full-damage setting.
Origin World location of the blast or area source.
Damage Radius How far from Origin the query reaches.
Damage Type Class Class category for the damage.
Ignore Actors Actors that should not be damaged by this call. Add the shooter, owner, or friendly exceptions deliberately.
Damage Causer Actor that directly caused the area damage. This actor is also excluded from damage and from blocking the damage check.
Instigated by Controller Controller responsible for the damage.
Do Full Damage Whether distance should stop scaling the amount for the plain radial node.
Damage Prevention Channel Trace channel used to decide whether something between the origin and target blocks damage.

Apply Radial Damage returns a Boolean:

  • true means at least one actor accepted damage;
  • false means no actor was damaged.

It does not return the list of damaged actors. If you need a list for scoring, UI, or debugging, collect it in your own overlap/trace query or in the damaged actors' response path.

For an explosion actor:

Grenade Explode
-> Apply Radial Damage
   Base Damage = 80
   Origin = GetActorLocation
   Damage Radius = 500
   Ignore Actors = [self, optional owner]
   Damage Causer = self grenade
   Instigated by Controller = Get Instigator Controller
   Damage Prevention Channel = Visibility or project-specific damage channel
-> Spawn Niagara explosion at Origin
-> Play Sound at Location
-> Destroy Actor

The prevention channel is a line-of-sight filter. If a wall between the origin and a target blocks that channel, damage can be prevented for that target. That is why explosions sometimes "do nothing through glass/walls" even though the radius is large: the collision response for the prevention channel is part of the damage rule.

Use Apply Radial Damage with Falloff when you need a clear inner full-damage radius, outer minimum-damage radius, minimum damage value, and falloff curve. The plain node is enough for a first explosion where everything in range takes the same accepted amount or a simple distance-scaled amount.

Damage Type Class

Damage Type Class is a class reference, not a live object you fill with per-hit values.

Use it for categories:

Damage type class What the receiver can do
DT_Bullet Apply headshot/body armor logic, spawn bullet hit reactions.
DT_Fire Start a burn effect if this actor can burn.
DT_Poison Ignore shields and start a timer-driven damage-over-time effect.
DT_Explosion Apply blast resistance, screen shake, or special death reactions.
DT_Fall Suppress kill credit or use different UI messaging.

Do not put changing state in a damage type: "this exact shot's crit chance," "the actor who fired," "remaining burn time," or "which inventory item caused it." Put per-hit state in the damage amount, hit result, instigator/causer references, component state, or your own damage payload system.

In Blueprint, a common beginner pattern is:

Event AnyDamage / Event PointDamage / Event RadialDamage
-> Damage Type
-> Class Is Child Of DT_Fire?
-> branch into fire resistance or burn effect

That branch is your logic. The class alone does not subtract health, ignite the actor, or replicate anything.

When they fail (and what failure does)

These nodes do not have Failed execution pins. The execution wire continues.

Common point-damage failures:

  1. Damaged Actor is None. There is no target to receive the message.
  2. Base Damage is zero or rejected. The target can accept 0.0 or reject damage depending on its damage path.
  3. The hit result is empty or from the wrong target. The receiver gets unhelpful hit location, bone, component, or normal data.
  4. You used the wrong direction. Shot-direction reactions, impulses, or facing logic can look backwards.
  5. The target cannot currently be damaged. Actor damage settings or native overrides can return 0.0.
  6. You called it on the wrong machine. Authority-only Blueprint damage does not make client-only health authoritative.

Common radial-damage failures:

  1. No valid world/context. The query cannot find actors without a world.
  2. No actors are inside radius. Return Value is false.
  3. Candidates are ignored. The ignore list and damage causer exclusion can intentionally remove actors.
  4. Collision blocks the prevention channel. A wall or component that blocks the chosen channel can prevent damage.
  5. Targets do not block the expected channel/component path. Radial damage relies on collision data to find/prevent candidates.
  6. The target's damage path rejects the event. Native overrides or damage-enabled state can reduce the accepted amount to zero.
  7. You expected falloff but used the plain node incorrectly. Use the falloff variant when minimum damage, inner radius, outer radius, and falloff exponent matter.

Failure does not print a guaranteed warning, retry later, spawn effects, destroy the damage causer, or change health for you.

The pattern everyone actually uses

For a first weapon:

Detect hit
-> filter target, self, owner, team, already-hit state
-> choose damage node:
      one exact impact -> Apply Point Damage
      one simple generic target -> Apply Damage
      blast area -> Apply Radial Damage
-> receiver changes health on the server
-> presentation spawns locally or from replicated/server-approved state

For multiplayer, keep trust boundaries explicit:

Owning client presses Fire
-> local muzzle flash / sound / recoil
-> Run on Server: ServerFire
-> server checks ammo, cooldown, range, team, and line of sight
-> server calls Apply Point Damage or Apply Radial Damage
-> target updates replicated Health
-> clients display hit/death feedback from replicated state or approved effects

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

void ATrainingWeapon::ApplyConfirmedPointHit(const FHitResult& Hit, const FVector& ShotDirection)
{
    AActor* HitActor = Hit.GetActor();
    if (!IsValid(HitActor))
    {
        return;
    }

    const float AcceptedDamage = UGameplayStatics::ApplyPointDamage(
        HitActor,
        Damage,
        ShotDirection,
        Hit,
        GetInstigatorController(),
        this,
        DamageTypeClass);

    if (AcceptedDamage <= 0.0f)
    {
        return;
    }
}

Lookalikes - which one do I want?

Node or hook Use when Watch out
Apply Damage One actor needs generic damage. No hit location, bone, component, radius, or origin.
Event AnyDamage The target should react to any damage style that reaches it. It has the least specific hit data.
Apply Point Damage A single impact result matters. It does not search an area.
Event PointDamage The target needs impact details for weak spots, hit reactions, or effects. It is authority-only in Blueprint.
Apply Radial Damage A blast or area source should affect actors around an origin. It returns only true/false, not a hit list.
Apply Radial Damage with Falloff Distance-based minimum/maximum damage matters. More pins mean more tuning and more ways to misread radius.
Event RadialDamage The target needs explosion origin or radial hit info. It is still the receiver; it does not create the explosion.
Damage Type Class Damage category should affect receiver behavior. It is not per-hit data or health logic by itself.
Sphere/Capsule Trace You need to find targets with a swept shape. Detection is not damage.
Overlap / Event Hit Collision or trigger state should detect contact. They do not subtract health until you send a damage message.

Rule of thumb: detection answers "what did I hit?" Damage answers "what message should the target receive?" Health logic answers "what does this actor do with that message?"

Going deeper