Hidden Cove Ambush: elimination_result and EliminatedEvent

Overview

The elimination_result struct is the payload delivered by fort_character.EliminatedEvent() every time a character is eliminated from the match. It carries two fields:

• EliminatedCharacter : fort_character — the character that was knocked out.
• EliminatingCharacter : ?fort_character — the character that did the eliminating, wrapped in an option type (?fort_character) because eliminations can also come from environmental damage (fall damage, storm, etc.), in which case this is false.

When do you reach for this?

The event fires on the eliminated character's fort_character object, so you must subscribe per-player as each player joins the session.

API Reference

(API surface could not be resolved for this device.)

Walkthrough

Scenario: A clifftop cove battle arena. When a player is eliminated, the eliminating player receives a weapon upgrade from an Item Granter device. If the kill was environmental (no eliminator), a consolation Item Granter fires for the eliminated player when they respawn — encouraging aggressive play near the cliffs.

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

# Place this Verse device in your clifftop cove arena.
# Wire KillerGranter to an Item Granter loaded with an upgraded weapon.
# Wire ConsolationGranter to an Item Granter loaded with a starter weapon.
clifftop_elimination_manager := class(creative_device):

    # Item Granter that rewards the eliminating player with an upgraded weapon.
    @editable
    KillerGranter : item_granter_device = item_granter_device{}

    # Item Granter that gives a consolation weapon to players
    # eliminated by the environment (storm, fall damage, etc.).
    @editable
    ConsolationGranter : item_granter_device = item_granter_device{}

    # Called once when the session begins. We subscribe to PlayerAddedEvent
    # so we catch every player — including late joiners.
    OnBegin<override>()<suspends> : void =
        AllPlayers := GetPlayspace().GetPlayers()
        for (Player : AllPlayers):
            SubscribeToPlayer(Player)

        # Also subscribe to future joiners.
        GetPlayspace().PlayerAddedEvent().Subscribe(OnPlayerAdded)

    # Fires whenever a new player joins mid-session.
    OnPlayerAdded(Player : player) : void =
        SubscribeToPlayer(Player)

    # Grabs the fort_character for a player and subscribes to their EliminatedEvent.
    SubscribeToPlayer(Player : player) : void =
        if (Character := Player.GetFortCharacter[]):
            # EliminatedEvent returns a listenable(elimination_result).
            # We subscribe with our handler method.
            Character.EliminatedEvent().Subscribe(OnCharacterEliminated)

    # Handler called every time ANY subscribed character is eliminated.
    # The payload is an elimination_result struct — NOT an option type,
    # so no unwrapping needed for the struct itself.
    OnCharacterEliminated(Result : elimination_result) : void =
        # --- Who was eliminated? ---
        EliminatedChar := Result.EliminatedCharacter

        # --- Who did the eliminating? (optional — could be environment) ---
        if (Killer := Result.EliminatingCharacter?):
            # A real player (or NPC) made the kill.
            # Reward the killer with an upgraded weapon.
            if (KillerAgent := Killer.GetAgent[]):
                KillerGranter.GrantItem(KillerAgent)
        else:
            # Environmental kill — no eliminator character.
            # Give the eliminated player a consolation weapon for next respawn.
            if (EliminatedAgent := EliminatedChar.GetAgent[]):
                ConsolationGranter.GrantItem(EliminatedAgent)```

### Line-by-line breakdown

| Lines | What's happening |
|---|---|
| `@editable KillerGranter` / `ConsolationGranter` | Two Item Granter devices wired in the UEFN editor — one for kill rewards, one for environmental-death consolation. |
| `GetPlayspace().GetPlayers()` | Fetches all players currently in the session at startup. |
| `GetPlayspace().PlayerAddedEvent().Subscribe(OnPlayerAdded)` | Ensures late-joining players also get their EliminatedEvent subscribed. |
| `Player.GetFortCharacter[]` | Fails gracefully (the `[]` makes it a failable expression) if the player has no character yet. |
| `Character.EliminatedEvent().Subscribe(OnCharacterEliminated)` | The core subscription — every elimination on this character fires `OnCharacterEliminated`. |
| `Result.EliminatedCharacter` | Direct field access — always present, never optional. |
| `Result.EliminatingCharacter?` | Unwraps the `?fort_character` option. If the kill was environmental this branch is skipped. |
| `Killer.GetAgent[]` | Converts the `fort_character` back to an `agent` so Item Granter can target them. |
| `KillerGranter.GrantItem(KillerAgent)` | Hands the upgraded weapon to the killer. |
| `ConsolationGranter.GrantItem(EliminatedAgent)` | Hands a starter weapon to the environmentally-eliminated player. |

## Common patterns

### Pattern 1 — Count eliminations and announce a kill streak

Track how many kills each player has this round using a `map` and print a localized announcement at 3 kills.

```verse
using { /Fortnite.com/Characters }
using { /Fortnite.com/Game }
using { /Fortnite.com/Devices }
using { /Fortnite.com/Players }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

# Localized message helper — message params require <localizes>
KillStreakMessage<localizes>(Count : int) : message = "Kill streak: {Count}!"

kill_streak_tracker := class(creative_device):

    @editable
    HUD : hud_message_device = hud_message_device{}

    # Maps a player's agent to their current kill count this round.
    var KillCounts : [agent]int = map{}

    OnBegin<override>()<suspends> : void =
        for (Player : GetPlayspace().GetPlayers()):
            SubscribePlayer(Player)
        GetPlayspace().PlayerAddedEvent().Subscribe(OnPlayerAdded)

    OnPlayerAdded(Player : player) : void =
        SubscribePlayer(Player)

    SubscribePlayer(Player : player) : void =
        if (Char := Player.GetFortCharacter[]):
            Char.EliminatedEvent().Subscribe(OnEliminated)

    OnEliminated(Result : elimination_result) : void =
        # Only count player-vs-player kills.
        if (Killer := Result.EliminatingCharacter?):
            if (KillerAgent := Killer.GetAgent[]):
                CurrentCount := if (C := KillCounts[KillerAgent]) then C else 0
                NewCount := CurrentCount + 1
                if (set KillCounts[KillerAgent] = NewCount) {}
                # Announce at every 3-kill milestone.
                if (Mod[NewCount, 3] = 0):
                    HUD.Show(KillerAgent)

Pattern 2 — Detect environmental eliminations and teleport the player to safety

When EliminatingCharacter is absent (environmental kill), teleport the eliminated player back to a safe spawn pad on the clifftop.

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

environmental_respawn_handler := class(creative_device):

    # A Teleporter device placed at a safe clifftop spawn point.
    @editable
    SafeTeleporter : teleporter_device = teleporter_device{}

    OnBegin<override>()<suspends> : void =
        for (Player : GetPlayspace().GetPlayers()):
            SubscribePlayer(Player)
        GetPlayspace().PlayerAddedEvent().Subscribe(OnPlayerAdded)

    OnPlayerAdded(Player : player) : void =
        SubscribePlayer(Player)

    SubscribePlayer(Player : player) : void =
        if (Char := Player.GetFortCharacter[]):
            Char.EliminatedEvent().Subscribe(OnEliminated)

    OnEliminated(Result : elimination_result) : void =
        # EliminatingCharacter is false (none) for environmental kills.
        if (Result.EliminatingCharacter?):
            # Player-vs-player kill — do nothing here.
            return
        # Environmental kill — send them to the safe clifftop teleporter.
        if (EliminatedAgent := Result.EliminatedCharacter.GetAgent[]):
            # Teleport fires after a short delay so respawn logic can complete.
            SafeTeleporter.Teleport(EliminatedAgent)

Pattern 3 — Subscribe inside a round loop using fort_round_manager

Use fort_round_manager to re-subscribe eliminations at the start of each new round, so kill counts reset cleanly.

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

round_aware_elimination_tracker := class(creative_device):

    @editable
    ScoreManager : score_manager_device = score_manager_device{}

    OnBegin<override>()<suspends> : void =
        # GetFortRoundManager is failable — use if/then.
        SimEntity := GetSimulationEntity()
        if (RoundManager := SimEntity.GetFortRoundManager[]):
            # SubscribeRoundStarted fires immediately if a round is ongoing,
            # then again at the start of every subsequent round.
            RoundManager.SubscribeRoundStarted(OnRoundStarted)

    # This callback is async (suspends) as required by SubscribeRoundStarted.
    OnRoundStarted()<suspends> : void =
        # Re-subscribe all current players at the top of each round.
        for (Player : GetPlayspace().GetPlayers()):
            if (Char := Player.GetFortCharacter[]):
                Char.EliminatedEvent().Subscribe(OnEliminated)

    OnEliminated(Result : elimination_result) : void =
        if (Killer := Result.EliminatingCharacter?):
            if (KillerAgent := Killer.GetAgent[]):
                ScoreManager.Activate(KillerAgent)

Gotchas

1. Subscribe per-character, not per-player

EliminatedEvent() lives on fort_character, not on player. Each time a player respawns they get a new fort_character instance, so their old subscription is gone. Always re-subscribe in PlayerAddedEvent and consider re-subscribing after respawn if your game mode needs it.

2. EliminatingCharacter is ?fort_character — always unwrap it

The field is an option type. Accessing it without the ? suffix in an if expression will cause a compile error. The pattern is always:

if (Killer := Result.EliminatingCharacter?):
    # Killer is fort_character here

If the if block is skipped, the kill was environmental.

3. EliminatedEvent() is NOT a field — it's a method call

You must call it with parentheses: Character.EliminatedEvent(). Omitting the () gives you a reference to the method, not the listenable, and the .Subscribe(...) call will fail to compile.

4. GetAgent[] can fail

Converting a fort_character back to an agent (needed for most device methods like GrantItem) uses the failable GetAgent[]. Always wrap it in an if expression — NPCs and some bot characters may not have an associated agent.

5. Localized text for HUD messages

If you pass text to a device that expects a message type (like hud_message_device), you cannot use a raw string. Declare a helper:

MyLabel<localizes>(S : string) : message = "{S}"

There is no StringToMessage function in Verse.

6. fort_round_manager is <epic_internal>

GetFortRoundManager is marked <epic_internal> in the current digest, meaning Epic may restrict or change its availability. Use it where it works, but don't build critical game logic that has no fallback if it becomes unavailable.

7. Subscriptions survive round boundaries unless you cancel them

EliminatedEvent().Subscribe(...) returns a cancelable. If you want kill counts to reset each round, store the cancelable and call .Cancel() at round end, then re-subscribe at round start via fort_round_manager.SubscribeRoundStarted.