elimination_manager_device: Reacting to Player Eliminations

Overview

The elimination_manager_device is your hook into Fortnite's combat outcome pipeline. It extends base_item_spawner_device, so on top of reporting eliminations it can also spawn an item (a weapon, a bandage, a shield potion) at a target location when a qualifying elimination happens.

Reach for it when you want to:

• Give the eliminator a reward — bonus score, a kill-streak buff, a new weapon.
• React to the eliminated player — respawn logic, drop their loot, play a taunt.
• Detect when someone picks up the item the manager dropped on a kill.
• Turn elimination tracking on and off per round or per phase with Enable/Disable.

It exposes three events — EliminatedEvent, EliminationEvent, and ItemPickedUpEvent — plus the Enable and Disable methods. The important subtlety: EliminatedEvent hands you the victim as a plain agent, while EliminationEvent hands you the eliminator as an optional ?agent (because environmental deaths have no agent behind them).

API Reference

elimination_manager_device

Used to spawn items when an agent or specified target is eliminated.

Full public surface, resolved verbatim from the live Epic digest (Fortnite.digest.verse). Inherited members are merged from base_item_spawner_device.

elimination_manager_device<public> := class<concrete><final>(base_item_spawner_device):

Events (subscribe a handler to react):

Event	Signature	Description
EliminatedEvent	EliminatedEvent<public>:listenable(agent)	Signaled when a qualifying elimination occurs. Sends the eliminated agent.
EliminationEvent	EliminationEvent<public>:listenable(?agent)	Signaled when a qualifying elimination occurs. Sends the eliminator agent. If the eliminator is a non-agent then false is returned.
ItemPickedUpEvent	ItemPickedUpEvent<public>:listenable(agent)	Signaled when an agent picks up the spawned item. Sends the agent that picked up the item.

Methods (call these to make the device act):

Method	Signature	Description
Enable	Enable<public>():void	Enables this device.
Disable	Disable<public>():void	Disables this device.

Walkthrough

Let's build a Kill Streak Arena. When a player eliminates someone, we grant them bonus score (via a placed score manager) and, on every third player's item pickup, we log a supply-drop notice. We also enable the manager only when the round starts so eliminations before the fight don't count.

Drop an Elimination Manager and a Score Manager device into the level, then bind both in Verse.

using { /Fortnite.com/Devices }
using { /Fortnite.com/Characters }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

# A kill-streak arena driven by the elimination_manager_device.
kill_streak_arena := class(creative_device):

    # Bind these in the Details panel of the device.
    @editable
    ElimManager : elimination_manager_device = elimination_manager_device{}

    @editable
    BonusScore : score_manager_device = score_manager_device{}

    # Localized text helper — message params never take raw strings.
    ArenaText<localizes>(S : string) : message = "{S}"

    OnBegin<override>()<suspends> : void =
        # Start with tracking off; we switch it on when the fight begins.
        ElimManager.Disable()

        # React to who did the eliminating.
        ElimManager.EliminationEvent.Subscribe(OnElimination)
        # React to who got eliminated.
        ElimManager.EliminatedEvent.Subscribe(OnEliminated)
        # React to item pickups from the drops it spawns.
        ElimManager.ItemPickedUpEvent.Subscribe(OnItemPickedUp)

        # Open the arena for business.
        ElimManager.Enable()
        Print(ArenaText("Kill Streak Arena is live!"))

    # EliminationEvent gives the ELIMINATOR as an OPTIONAL agent.
    OnElimination(MaybeAgent : ?agent) : void =
        if (Eliminator := MaybeAgent?):
            # A real player got the kill — reward them.
            BonusScore.Activate(Eliminator)
            Print(ArenaText("Eliminator rewarded with bonus score!"))
        else:
            # No agent = environmental / non-player elimination.
            Print(ArenaText("Environmental elimination — no reward."))

    # EliminatedEvent gives the VICTIM as a plain agent (no unwrap needed).
    OnEliminated(Victim : agent) : void =
        Print(ArenaText("A player was eliminated."))

    # Fires when someone walks over a spawned drop.
    OnItemPickedUp(Picker : agent) : void =
        Print(ArenaText("Someone grabbed the drop!"))

Line by line:

• @editable ElimManager : elimination_manager_device = elimination_manager_device{} — declares the device field so Verse can talk to the placed device. Without this @editable binding you'd get an Unknown identifier error trying to call its methods.
• ElimManager.Disable() in OnBegin — the device ships enabled; disabling first lets you gate exactly when eliminations start counting.
• .EliminationEvent.Subscribe(OnElimination) — subscribes a method at class scope. Because this event is listenable(?agent), the handler's parameter is ?agent.
• if (Eliminator := MaybeAgent?) — unwraps the optional. If it fails, the elimination came from the environment (fall damage, storm) and there's no agent to reward.
• BonusScore.Activate(Eliminator) — awards score to the eliminator via the placed score manager.
• OnEliminated(Victim : agent) — EliminatedEvent is listenable(agent), so the victim arrives already unwrapped.
• ElimManager.Enable() — turns tracking on. From here every qualifying kill fires the events.

Common patterns

Reward only the eliminator, ignore environment kills

Use EliminationEvent and bail early when the optional agent is empty.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

eliminator_rewarder := class(creative_device):

    @editable
    ElimManager : elimination_manager_device = elimination_manager_device{}

    @editable
    WeaponGranter : item_granter_device = item_granter_device{}

    OnBegin<override>()<suspends> : void =
        ElimManager.Enable()
        ElimManager.EliminationEvent.Subscribe(OnKill)

    OnKill(MaybeAgent : ?agent) : void =
        # Only real players earn the upgrade weapon.
        if (Eliminator := MaybeAgent?):
            WeaponGranter.GrantItem(Eliminator)

Drop-and-collect: react to the spawned item

Because the manager extends the item spawner, someone can pick up what it drops. ItemPickedUpEvent tells you who.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

loot_tracker := class(creative_device):

    @editable
    ElimManager : elimination_manager_device = elimination_manager_device{}

    @editable
    HealthGranter : item_granter_device = item_granter_device{}

    OnBegin<override>()<suspends> : void =
        ElimManager.Enable()
        ElimManager.ItemPickedUpEvent.Subscribe(OnPickup)

    OnPickup(Picker : agent) : void =
        # Whoever loots the kill-drop also gets a heal item.
        HealthGranter.GrantItem(Picker)

Phase gating with Enable / Disable

Toggle whether eliminations count. Wire a button to open a "combat phase" and close it again.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

phase_gate := class(creative_device):

    @editable
    ElimManager : elimination_manager_device = elimination_manager_device{}

    @editable
    StartButton : button_device = button_device{}

    @editable
    EndButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        # Eliminations don't count until combat phase opens.
        ElimManager.Disable()
        StartButton.InteractedWithEvent.Subscribe(OnStart)
        EndButton.InteractedWithEvent.Subscribe(OnEnd)

    OnStart(Agent : agent) : void =
        ElimManager.Enable()

    OnEnd(Agent : agent) : void =
        ElimManager.Disable()

Gotchas

• EliminationEvent is ?agent, EliminatedEvent is agent. The eliminator can be missing (fall/storm/environment), so you must unwrap with if (A := MaybeAgent?):. The victim always exists, so its handler takes a plain agent. Mixing these up is the #1 compile error here.
• You must bind the device as an @editable field. Calling elimination_manager_device{}.Enable() on a fresh literal does nothing — it isn't the placed device. Declare an @editable field and drag the real device onto it in the Details panel.
• Handlers are methods, subscribed in OnBegin. Define OnElimination, OnEliminated, etc. at class scope (4-space indent) and call .Subscribe(...) inside OnBegin (8-space indent).
• Print needs localized text. Print takes a message. Build one with a <localizes> helper like ArenaText<localizes>(S:string):message = "{S}" and pass ArenaText("...") — there is no StringToMessage.
• The device may already be enabled. If you want precise control over when kills count, call Disable() at the top of OnBegin and Enable() only when your phase actually starts.
• Item spawning is optional but the pickup event only fires if an item is configured. ItemPickedUpEvent never signals unless the manager is set to spawn something on elimination in its device options.