accolades_device: Rewarding Players with Battle Pass XP

Overview

The accolades_device lets UEFN island creators grant Battle Pass XP to players when they accomplish something meaningful on your island. Accolades are the official mechanism Epic provides for rewarding player engagement — they show up in the player's Battle Pass progression and incentivize repeated play.

When should you reach for it?

• A player completes a bounty, puzzle, or obstacle course → call Award.
• You want to temporarily disable XP rewards during a setup or intermission phase → call Disable / Enable.
• You're testing your island and want to verify XP fires correctly before publishing → subscribe to TestAwardEvent.

The device is placed in the UEFN editor like any other Creative device, then referenced from Verse with @editable. You drive it entirely through code — there are no in-editor triggers to configure beyond the XP amount you set on the device itself.

API Reference

accolades_device

Used to set up islands so players will earn Battle Pass XP when they interact with your island. Accolades are achievements or accomplishments that players can complete to earn XP.

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

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

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Scenario: A survival island where players must reach a glowing extraction zone (a trigger_device) to earn XP. When the round starts the accolade is enabled; when a player steps on the extraction trigger, they receive their XP reward. A second trigger disables the accolade when the round ends so late arrivals can't farm it.

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

# extraction_reward_manager
# Place this Verse device, an accolades_device, a trigger_device for
# the extraction zone, and a trigger_device for round-end in the scene.
extraction_reward_manager := class(creative_device):

    # The accolades device configured in UEFN with the desired XP amount.
    @editable
    ExtractionAccolade : accolades_device = accolades_device{}

    # Players step on this trigger to extract and earn XP.
    @editable
    ExtractionZone : trigger_device = trigger_device{}

    # This trigger fires when the round ends (e.g. from a timer device).
    @editable
    RoundEndTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        # Make sure the accolade is active at round start.
        ExtractionAccolade.Enable()

        # Subscribe to the extraction zone — fires when a player steps on it.
        ExtractionZone.TriggeredEvent.Subscribe(OnPlayerExtracted)

        # Subscribe to the round-end trigger to lock out late XP farming.
        RoundEndTrigger.TriggeredEvent.Subscribe(OnRoundEnd)

    # Called when a player steps on the extraction zone trigger.
    # TriggeredEvent sends ?agent, so we unwrap it before awarding.
    OnPlayerExtracted(MaybeAgent : ?agent) : void =
        if (Agent := MaybeAgent?):
            ExtractionAccolade.Award(Agent)

    # Called when the round-end trigger fires.
    # Disable the accolade so no more XP can be awarded this round.
    OnRoundEnd(MaybeAgent : ?agent) : void =
        ExtractionAccolade.Disable()

Line-by-line explanation

Common patterns

Pattern 1 — Enable / Disable for timed XP windows

Only allow XP to be earned during an active event window. A button starts the window; a second button closes it.

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

# xp_window_manager
# Wires two button_devices to open and close an XP-earning window.
xp_window_manager := class(creative_device):

    @editable
    EventAccolade : accolades_device = accolades_device{}

    # Press this button to open the XP window (e.g. a game-master button).
    @editable
    OpenWindowButton : button_device = button_device{}

    # Press this button to close the XP window.
    @editable
    CloseWindowButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        # Start with accolade disabled — no XP until the event begins.
        EventAccolade.Disable()

        OpenWindowButton.InteractedWithEvent.Subscribe(OnWindowOpen)
        CloseWindowButton.InteractedWithEvent.Subscribe(OnWindowClose)

    OnWindowOpen(Agent : agent) : void =
        EventAccolade.Enable()

    OnWindowClose(Agent : agent) : void =
        EventAccolade.Disable()

Note: button_device.InteractedWithEvent delivers a plain agent (not ?agent), so no unwrapping is needed here.

Pattern 2 — TestAwardEvent for pre-publish verification

During development, log which player receives the accolade to confirm your wiring is correct. TestAwardEvent only fires in unpublished island environments, so this code is safe to ship — it simply never triggers in production.

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

# accolade_test_logger
# Attach to any accolades_device to verify awards fire correctly in
# your unpublished test session.
accolade_test_logger := class(creative_device):

    @editable
    TrackedAccolade : accolades_device = accolades_device{}

    # Trigger that manually fires the award for testing.
    @editable
    TestTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        # Subscribe to TestAwardEvent — only fires in unpublished sessions.
        TrackedAccolade.TestAwardEvent.Subscribe(OnTestAward)

        # Wire a trigger so we can manually fire an award during testing.
        TestTrigger.TriggeredEvent.Subscribe(OnTestTriggerFired)

    # TestAwardEvent delivers a plain `agent` (not optional).
    OnTestAward(Agent : agent) : void =
        Print("[TEST] Accolade awarded successfully to an agent.")

    OnTestTriggerFired(MaybeAgent : ?agent) : void =
        if (Agent := MaybeAgent?):
            TrackedAccolade.Award(Agent)

Pattern 3 — Award on elimination (multi-accolade combo)

Grant XP for eliminations by subscribing to an elimination_manager_device and awarding two separate accolades — one for the eliminator, one participation accolade for the eliminated player.

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

# elimination_xp_manager
# Awards XP to the eliminating player via an accolades_device.
elimination_xp_manager := class(creative_device):

    # XP reward for getting an elimination.
    @editable
    EliminationAccolade : accolades_device = accolades_device{}

    # XP reward just for participating (awarded to eliminated player).
    @editable
    ParticipationAccolade : accolades_device = accolades_device{}

    @editable
    ElimManager : elimination_manager_device = elimination_manager_device{}

    OnBegin<override>()<suspends> : void =
        EliminationAccolade.Enable()
        ParticipationAccolade.Enable()
        ElimManager.EliminationEvent.Subscribe(OnElimination)

    # EliminationEvent delivers elimination_result which contains
    # EliminatingAgent (?agent) and EliminatedAgent (agent).
    OnElimination(Result : elimination_result) : void =
        # Award the eliminated player participation XP unconditionally.
        ParticipationAccolade.Award(Result.EliminatedAgent)

        # Award the eliminator only if a real player made the kill.
        if (Eliminator := Result.EliminatingAgent?):
            EliminationAccolade.Award(Eliminator)

Gotchas

1. @editable is mandatory — bare instantiation does nothing

Declaring MyAccolade : accolades_device = accolades_device{} without @editable creates a default, unconnected instance. Your Award calls will compile and run but will never grant XP because the object isn't wired to the placed device in the scene. Always add @editable and assign the device in the UEFN Details panel.

2. TriggeredEvent delivers ?agent, not agent

trigger_device.TriggeredEvent (and many other device events) sends ?agent — an optional agent. You must unwrap it before passing to Award:

# CORRECT
if (Agent := MaybeAgent?):
    MyAccolade.Award(Agent)

# WRONG — won't compile; Award expects agent, not ?agent
MyAccolade.Award(MaybeAgent)

3. TestAwardEvent is test-only

TestAwardEvent fires only in unpublished island sessions. Never build production game logic that depends on it — it will silently never fire once your island is published.

4. Calling Award on a disabled device is a no-op

If you call Award after Disable, no XP is granted and no error is thrown. This is intentional for gating, but it can be a silent bug if you forget to call Enable at round start. A common fix is to call Enable() explicitly in OnBegin.

5. XP amount is configured in the editor, not in Verse

The accolades_device has no Verse API for setting the XP value. The amount is set on the device instance in the UEFN Details panel. If players aren't receiving the expected XP, check the device's XP Amount property in the editor first before debugging your Verse code.

6. One accolade device = one XP tier

If you need to award different XP amounts for different achievements (e.g. 100 XP for a basic task, 500 XP for a hard challenge), place multiple accolades_device instances in the scene, each configured with a different XP value, and reference each with its own @editable field.