elimination_feed_device: Custom Kill-Feed Messages

Overview

The elimination feed is the real-time notification strip that tells every player what's happening in the match. By default it only shows standard elimination events, but elimination_feed_device gives you a Verse handle to inject your own messages at any time.

When to reach for it:

• Announce a boss elimination with a dramatic custom message.
• Broadcast a "First Blood" or "Killing Spree" callout triggered by your own game logic.
• Disable the feed entirely during a cinematic sequence, then re-enable it.
• Credit a specific player as the instigator of a scripted event (e.g., activating a trap).

The device has no events — it is purely output. You drive it from other devices or game logic and call its methods to show messages or toggle its availability.

API Reference

elimination_feed_device

Used to send custom messages to the elimination feed.

Full public surface, resolved verbatim from the live Epic digest (Fortnite.digest.verse).

elimination_feed_device<public> := class<concrete><final>(creative_device_base):

Methods (call these to make the device act):

Walkthrough

Scenario: A "Boss Arena" island. When a player steps on a pressure plate, the boss health bar appears. When the boss is eliminated, the plate's Verse device fires a custom feed message crediting that player as the boss slayer.

In this example we wire a trigger_device (the pressure plate) and an elimination_feed_device together. Stepping on the plate calls Activate(Agent) so the feed shows a message with that player as the instigator. A second trigger (wired to the boss dying) calls the no-agent Activate() overload for a global announcement.

boss_arena_manager := class(creative_device):

    # Drop an elimination_feed_device into your level and assign it here.
    @editable
    BossFeed : elimination_feed_device = elimination_feed_device{}

    # A trigger_device placed under the boss-entry pressure plate.
    @editable
    EntryPlate : trigger_device = trigger_device{}

    # A trigger_device wired to fire when the boss is defeated
    # (e.g., connected to a Conditional Button or Health Bar device).
    @editable
    BossDefeatedTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        # Subscribe to the pressure plate — handler receives ?agent
        EntryPlate.TriggeredEvent.Subscribe(OnPlayerEnteredArena)
        # Subscribe to the boss-defeated trigger — no agent variant
        BossDefeatedTrigger.TriggeredEvent.Subscribe(OnBossDefeated)

    # Called when a player steps on the entry plate.
    # TriggeredEvent hands us (?agent), so we unwrap before calling Activate.
    OnPlayerEnteredArena(MaybeAgent : ?agent) : void =
        if (Agent := MaybeAgent?):
            # Activate with the specific agent — the feed message
            # uses this agent as the named instigator.
            BossFeed.Activate(Agent)

    # Called when the boss-defeated trigger fires.
    # No specific player to credit, so use the no-agent overload.
    # NOTE: the elimination_feed_device's *Activated by Team / Class*
    # option in the Details panel MUST be set to "All" for this to work.
    OnBossDefeated(MaybeAgent : ?agent) : void =
        BossFeed.Activate()

Line-by-line breakdown:

Common patterns

Pattern 1 — Enable / Disable around a cinematic

During a scripted cutscene you don't want stray elimination messages cluttering the screen. Disable the feed before the cinematic plays and re-enable it when gameplay resumes.

cinematic_feed_guard := class(creative_device):

    @editable
    GameFeed : elimination_feed_device = elimination_feed_device{}

    # A trigger_device that fires when the cinematic starts.
    @editable
    CinematicStartTrigger : trigger_device = trigger_device{}

    # A trigger_device that fires when the cinematic ends.
    @editable
    CinematicEndTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        CinematicStartTrigger.TriggeredEvent.Subscribe(OnCinematicStart)
        CinematicEndTrigger.TriggeredEvent.Subscribe(OnCinematicEnd)

    OnCinematicStart(MaybeAgent : ?agent) : void =
        # Hide all elimination feed messages for the duration of the cinematic.
        GameFeed.Disable()

    OnCinematicEnd(MaybeAgent : ?agent) : void =
        # Restore the feed so players see eliminations again.
        GameFeed.Enable()

Pattern 2 — Activate for every player on a team wipe

When your game logic detects that an entire team has been eliminated, loop over the surviving agents and call Activate(Agent) for each one so each survivor sees the announcement attributed to them.

team_wipe_announcer := class(creative_device):

    @editable
    WipeFeed : elimination_feed_device = elimination_feed_device{}

    # A trigger_device wired to fire when the last member of a team is eliminated.
    @editable
    TeamWipeTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        TeamWipeTrigger.TriggeredEvent.Subscribe(OnTeamWiped)

    OnTeamWiped(MaybeAgent : ?agent) : void =
        # Credit the specific player who landed the final blow,
        # if the trigger passes one through.
        if (Agent := MaybeAgent?):
            WipeFeed.Activate(Agent)
        else:
            # Fallback: no agent available, post a generic announcement.
            # Requires *Activated by Team / Class* = All in device settings.
            WipeFeed.Activate()

Pattern 3 — Conditional feed based on match phase

Only show custom feed messages during the final circle. Use a var logic flag set by round-phase triggers to gate Activate calls.

final_circle_feed := class(creative_device):

    @editable
    CircleFeed : elimination_feed_device = elimination_feed_device{}

    # Trigger fires when the final circle begins.
    @editable
    FinalCircleStartTrigger : trigger_device = trigger_device{}

    # Trigger fires when any player gets an elimination.
    @editable
    EliminationTrigger : trigger_device = trigger_device{}

    # Track whether we are in the final circle.
    var IsFinalCircle : logic = false

    OnBegin<override>()<suspends> : void =
        FinalCircleStartTrigger.TriggeredEvent.Subscribe(OnFinalCircleBegins)
        EliminationTrigger.TriggeredEvent.Subscribe(OnElimination)

    OnFinalCircleBegins(MaybeAgent : ?agent) : void =
        set IsFinalCircle = true
        # Enable the device so it's ready to post messages.
        CircleFeed.Enable()

    OnElimination(MaybeAgent : ?agent) : void =
        if (IsFinalCircle?):
            if (Agent := MaybeAgent?):
                # Post a custom final-circle elimination message
                # attributed to the eliminating player.
                CircleFeed.Activate(Agent)

Gotchas

1. Activate() (no agent) requires a device setting change. The zero-argument Activate() only works when the device's Activated by Team / Class property in the UEFN Details panel is set to All. If it's set to a specific team or class, the call silently does nothing. Always check this setting first when your global announcements aren't appearing.

2. Always unwrap ?agent before calling Activate(Agent). TriggeredEvent (and most Fortnite events) hands your handler a (?agent) — an optional. You cannot pass a ?agent directly to Activate(Agent : agent). Use if (Agent := MaybeAgent?): to unwrap it first, or the code won't compile.

3. No events on this device. elimination_feed_device is output-only. It has no ActivatedEvent or similar listenable. If you need to react to an elimination, subscribe to fort_character.EliminatedEvent or a connected device, then call the feed from that handler.

4. Disabled device ignores all calls. After Disable(), both Activate(Agent) and Activate() are no-ops until Enable() is called again. If your messages stop appearing mid-match, check whether something else in your logic called Disable() without a matching Enable().

5. The message text is configured in the device, not in Verse. Unlike a HUD message device, you don't pass a string from Verse — the text displayed in the feed is set in the device's Details panel properties in UEFN. Verse only controls when and for whom the message fires. Plan your message variants as separate placed devices if you need different text for different events.

6. @editable is mandatory. You cannot construct a elimination_feed_device in Verse with elimination_feed_device{} and expect it to do anything useful at runtime — that creates an unplaced, non-functional instance. Always declare it @editable and assign the placed level device in the Details panel.