damage_amplifier_powerup_device: Supercharge Your Players' Damage

Overview

The damage_amplifier_powerup_device is a powerup_device subclass that wraps the in-world Damage Amplifier pickup. Drop one on your map and it sits there glowing until a player walks over it; the player then deals amplified damage for the configured duration.

Reach for this device when you want to:

• Reward skill — spawn a high-multiplier pickup after a player gets an elimination streak.
• Create timed power windows — grant the buff directly to all players at the start of a round.
• Build dynamic difficulty — lower or raise the multiplier mid-match based on score.
• Gate progression — despawn the pickup until a puzzle is solved, then spawn it as the prize.

Because SetMagnitude and SetDuration only affect future pickups (not currently active effects), you must configure them before the player picks up the item or before you call Pickup.

API Reference

damage_amplifier_powerup_device

Used to amplify an agent's damage temporarily. This applies to any weapon the agent is using at the time of the powerup.

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

damage_amplifier_powerup_device<public> := class<concrete><final>(powerup_device):

Events (subscribe a handler to react):

Methods (call these to make the device act):

powerup_device

Base class for various powerup devices offering common events like ItemPickedUpEvent.

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

powerup_device<public> := class<abstract><epic_internal>(creative_device_base):

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Scenario: A boss arena. When the boss phase starts, a Damage Amplifier spawns in the center. The first player to grab it gets a 3× damage buff for 15 seconds. A HUD message announces who grabbed it, and a second amplifier is granted to every remaining player 10 seconds later as a catch-up mechanic.

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

# Localized message helper
PickupAnnounce<localizes>(Name : string) : message = "Power surge: {Name} grabbed the amplifier!"
CatchupAnnounce<localizes>() : message = "Catch-up boost granted to all remaining players!"

boss_arena_manager := class(creative_device):

    # Wire this to your Damage Amplifier Powerup device in the Details panel
    @editable
    Amplifier : damage_amplifier_powerup_device = damage_amplifier_powerup_device{}

    # Wire this to a second Damage Amplifier Powerup device (Apply To = All Players)
    @editable
    CatchupAmplifier : damage_amplifier_powerup_device = damage_amplifier_powerup_device{}

    # Wire this to a HUD Message device to display announcements
    @editable
    HUDMessage : hud_message_device = hud_message_device{}

    # Wire this to a trigger_device that fires when the boss phase begins
    @editable
    BossPhaseTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        # Configure the main amplifier before spawning
        Amplifier.SetMagnitude(3.0)   # 3× damage multiplier
        Amplifier.SetDuration(15.0)   # lasts 15 seconds

        # Configure the catch-up amplifier
        CatchupAmplifier.SetMagnitude(2.0)  # 2× for latecomers
        CatchupAmplifier.SetDuration(10.0)

        # Keep the amplifier hidden until the boss phase starts
        Amplifier.Despawn()
        CatchupAmplifier.Despawn()

        # Listen for the boss phase trigger
        BossPhaseTrigger.TriggeredEvent.Subscribe(OnBossPhaseStart)

        # Listen for someone picking up the main amplifier
        Amplifier.ItemPickedUpEvent.Subscribe(OnAmplifierPickedUp)

    # Called when the boss phase trigger fires
    OnBossPhaseStart(Agent : ?agent) : void =
        # Spawn the amplifier into the world so players can grab it
        if (not Amplifier.IsSpawned[]):
            Amplifier.Spawn()

    # Called when a player picks up the main amplifier
    OnAmplifierPickedUp(PickupAgent : agent) : void =
        # Confirm the effect is now active on this agent
        if (Amplifier.HasEffect[PickupAgent]):
            # Show how long they have left (should be ~15 s right after pickup)
            Remaining := Amplifier.GetRemainingTime(PickupAgent)
            # Announce the pickup — in a real project you'd resolve the player name
            # via a player_ui or name tag device; here we show the pattern
            HUDMessage.Show()

        # 10 seconds later, grant a catch-up buff to everyone else via Pickup()
        # Pickup() with no agent requires "Apply To = All Players" in the device settings
        spawn { DelayCatchupGrant() }

    DelayCatchupGrant()<suspends> : void =
        Sleep(10.0)
        if (not CatchupAmplifier.IsSpawned[]):
            CatchupAmplifier.Spawn()
        CatchupAmplifier.Pickup()   # grants to ALL players (Apply To = All Players)

Line-by-line explanation

Common patterns

Pattern 1 — Dynamic multiplier based on player count

Scale the damage multiplier up as the lobby shrinks, rewarding survivors.

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

scaling_amplifier_manager := class(creative_device):

    @editable
    Amplifier : damage_amplifier_powerup_device = damage_amplifier_powerup_device{}

    # Wire to an elimination manager or player counter trigger
    @editable
    EliminationTrigger : trigger_device = trigger_device{}

    var AliveCount : int = 16

    OnBegin<override>()<suspends> : void =
        EliminationTrigger.TriggeredEvent.Subscribe(OnElimination)
        Amplifier.Spawn()

    OnElimination(Agent : ?agent) : void =
        set AliveCount = AliveCount - 1
        # Increase multiplier as players are eliminated
        NewMagnitude : float =
            if (AliveCount <= 4) then 3.0
            else if (AliveCount <= 8) then 2.0
            else 1.5
        Amplifier.SetMagnitude(NewMagnitude)
        # Log current configured multiplier for debugging
        CurrentMag := Amplifier.GetMagnitude()
        # Respawn the pickup so the new magnitude takes effect on next grab
        if (Amplifier.IsSpawned[]):
            Amplifier.Despawn()
        Amplifier.Spawn()

Key calls: SetMagnitude, GetMagnitude, IsSpawned[], Despawn, Spawn.

Pattern 2 — Grant the buff directly to a specific player on a button press

A vending-machine style interaction: player presses a button and instantly receives the buff.

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

vending_amplifier := class(creative_device):

    @editable
    Amplifier : damage_amplifier_powerup_device = damage_amplifier_powerup_device{}

    # A button_device the player interacts with to purchase the buff
    @editable
    PurchaseButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        # Keep the world pickup despawned — we grant programmatically
        Amplifier.Despawn()
        Amplifier.SetDuration(20.0)
        Amplifier.SetMagnitude(2.5)

        PurchaseButton.InteractedWithEvent.Subscribe(OnPurchase)

    OnPurchase(Agent : agent) : void =
        # Only grant if the player doesn't already have the effect
        if (not Amplifier.HasEffect[Agent]):
            Amplifier.Pickup(Agent)   # grants directly to this specific agent
        # If they already have it, check remaining time
        else:
            TimeLeft := Amplifier.GetRemainingTime(Agent)
            # TimeLeft > 0 means the buff is ticking; -1.0 means infinite

Key calls: SetDuration, SetMagnitude, HasEffect[], Pickup(Agent), GetRemainingTime.

Pattern 3 — Timed respawn loop

The amplifier respawns 30 seconds after it is picked up, creating a recurring power-up cycle.

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

respawning_amplifier := class(creative_device):

    @editable
    Amplifier : damage_amplifier_powerup_device = damage_amplifier_powerup_device{}

    OnBegin<override>()<suspends> : void =
        Amplifier.SetMagnitude(2.0)
        Amplifier.SetDuration(10.0)
        Amplifier.Spawn()
        Amplifier.ItemPickedUpEvent.Subscribe(OnPickedUp)

    OnPickedUp(Agent : agent) : void =
        spawn { RespawnAfterDelay() }

    RespawnAfterDelay()<suspends> : void =
        Sleep(30.0)
        # Only respawn if it hasn't somehow been spawned again already
        if (not Amplifier.IsSpawned[]):
            Amplifier.Spawn()

Key calls: ItemPickedUpEvent, IsSpawned[], Spawn.

Gotchas

1. SetMagnitude and SetDuration don't affect active buffs

These setters only influence the next pickup. If a player already has the effect running, changing the magnitude won't alter their current buff. Despawn and respawn the device (or let the current effect expire) before the new values matter.

2. IsSpawned[] and HasEffect[] are failable — use them inside if

Both methods carry <decides>, meaning they fail (rather than return false) when the condition isn't met. Always call them inside an if expression:

# Correct
if (Amplifier.IsSpawned[]):
    Amplifier.Despawn()

# Wrong — compile error, decides functions can't be called as statements
# Amplifier.IsSpawned[]

3. ItemPickedUpEvent sends agent, not ?agent

Unlike some device events that send ?agent, ItemPickedUpEvent on powerup_device sends a plain agent directly to the handler. Your handler signature must be (Agent : agent), not (Agent : ?agent). No unwrapping needed.

4. Pickup() (no-arg) requires Apply To = All Players in the Details panel

If you call Pickup() without an agent and the device isn't configured for All Players, the call silently does nothing. Use Pickup(Agent : agent) for targeted grants.

5. GetRemainingTime return values

• Returns the seconds remaining if the effect is active.
• Returns -1.0 if the duration is set to Infinite.
• Returns 0.0 if the agent does not have the effect — not a failure, just zero. Check HasEffect[] first if you need to distinguish "no effect" from "just expired".

6. Magnitude is clamped by the Details panel

SetMagnitude is clamped to the Min and Max values you configure in the UEFN Details panel for the device. If your Verse call seems to have no effect, check that your target value falls within those bounds.