Blueprint and C++ API

#Blueprint nodes

#Mass Projectiles (function library)

#Projectile Subsystem

#Mass Projectile Fire (component)

#Mass Projectile Hit (component)

#Structs and enums

#Projectile Fire Event (FProjectileFireEvent)

#Mass Projectile Hit Event (FMassProjectileHitEvent)

See the field table in Hits and Damage.

#Projectile Impact Type (EProjectileImpactType)

Stop · Ricochet · Penetration Enter · Penetration Exit

#C++

Add the module to your Build.cs:

PublicDependencyModuleNames.AddRange(new string[] { "MassProjectileSubsystem", "MassSpawner" });

(MassSpawner provides UMassEntityConfigAsset.)

#Firing

#include "Projectile/ProjectileSubsystem.h"
#include "MassEntityConfigAsset.h"

void AMyTurret::FireVolley(const UMassEntityConfigAsset* Type)
{
    UProjectileSubsystem* Projectiles = GetWorld()->GetSubsystem<UProjectileSubsystem>();
    if (!Projectiles) return;

    FProjectileFireEvent Event;
    Event.Origin = Muzzle->GetComponentLocation();
    Event.Direction = Muzzle->GetForwardVector();
    Event.Count = 12;
    Event.SpreadHalfAngleDeg = 2.f;

    Projectiles->SpawnProjectiles(Type, Event);   // replicates automatically on an authority
}

#Native hit listener

OnProjectileHit is a native multicast delegate with the compact worker payload (FProjectileHitPayload). It is authority-only, like the Blueprint event.

void UMyDamageSystem::Initialize(FSubsystemCollectionBase& Collection)
{
    Super::Initialize(Collection);
    if (UProjectileSubsystem* Projectiles = Collection.InitializeDependency<UProjectileSubsystem>())
    {
        HitHandle = Projectiles->OnProjectileHit.AddUObject(this, &UMyDamageSystem::HandleHit);
    }
}

void UMyDamageSystem::HandleHit(const FProjectileHitPayload& Hit)
{
    if (Hit.Event == EProjectileImpactType::Stop || Hit.Event == EProjectileImpactType::PenetrationEnter)
    {
        // Hit.HitActor, Hit.Location, Hit.Surface, Hit.TypeIndex ...
    }
}

OnProjectileHitEvent (dynamic, FMassProjectileHitEvent) carries the same hits with Damage and Type Config resolved. Prefer it when you want Base Damage.

OnProjectileHitLocal has the same signature but fires on every machine, clients included, each with its own locally simulated copy of the hit. Use it for cosmetic reactions only (hit markers, UI, local effects), never for damage or scoring.

#Useful subsystem calls

#Custom visualizer (C++)

The core module has no Niagara dependency. To draw projectiles another way (instanced meshes, a custom Niagara layout, a debug renderer):

1. Implement IProjectileVisualizer (Projectile/ProjectileVisualizer.h):

2. Register it from a UWorldSubsystem::Initialize (before world PostInitialize):

Collection.InitializeDependency<UProjectileSubsystem>()->SetVisualizer(&MyVisualizer);

3. Turn off Project Settings → Mass Projectile Niagara → Enable Niagara Visualizer.

All visualizer methods run on the game thread, and only where a local viewer exists (never on dedicated servers).