health_powerup_device: Dynamic Health Pickups in UEFN

Overview

The health_powerup_device is a placeable UEFN device that regenerates an agent's health and/or shields when picked up. It inherits from powerup_device, which provides the core spawn/despawn lifecycle, duration control, and the ItemPickedUpEvent signal.

Reach for this device when you need to:

• Spawn a heal pickup on a timer (e.g., a contested zone powerup that refreshes every 60 s).
• Scale healing dynamically based on game state (e.g., last-player-standing gets a bigger heal).
• Grant health instantly to a specific agent via code rather than waiting for them to walk over it.
• React to a pickup to trigger other game events (open a door, start a countdown, award XP).

The two methods unique to health_powerup_device — SetMagnitude and GetMagnitude — let you read and write the heal/shield amount at runtime. Everything else (spawn control, duration, effect queries) lives on the parent powerup_device.

API Reference

health_powerup_device

Used to regenerate an agent's health and/or shields.

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

health_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: The Arena Mega-Heal

Every 45 seconds a large health pickup spawns in the centre of the arena. The first player to grab it gets a big heal, the pickup disappears, and a 45-second cooldown starts again. If no one grabs it within 15 seconds it despawns on its own. When a player picks it up, a second (smaller) powerup is immediately granted to every other player as a consolation.

Place one health_powerup_device (the mega-heal) and one more (the consolation heal) in your level, then wire up the Verse device below.

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

arena_mega_heal_manager := class(creative_device):

    # The big central heal pickup — place it in the level
    @editable
    MegaHeal : health_powerup_device = health_powerup_device{}

    # A second powerup granted to everyone else as consolation
    @editable
    ConsolationHeal : health_powerup_device = health_powerup_device{}

    # How long between each mega-heal spawn (seconds)
    SpawnIntervalSeconds : float = 45.0

    # How long the mega-heal sits before auto-despawning if unclaimed
    WindowSeconds : float = 15.0

    OnBegin<override>()<suspends> : void =
        # Start despawned — we control when it appears
        MegaHeal.Despawn()
        ConsolationHeal.Despawn()

        # Set the mega-heal magnitude to 150 HP/shield
        MegaHeal.SetMagnitude(150.0)

        # Consolation heal is smaller
        ConsolationHeal.SetMagnitude(50.0)

        # React whenever someone grabs the mega-heal
        MegaHeal.ItemPickedUpEvent.Subscribe(OnMegaHealPickedUp)

        # Begin the spawn loop
        loop:
            Sleep(SpawnIntervalSeconds)
            RunSpawnWindow()

    # Spawns the mega-heal, waits for the window, then despawns if still there
    RunSpawnWindow()<suspends> : void =
        MegaHeal.Spawn()
        Sleep(WindowSeconds)
        # Only despawn if it's still sitting there (nobody grabbed it)
        if (MegaHeal.IsSpawned[]):
            MegaHeal.Despawn()

    # Called when any agent picks up the mega-heal
    OnMegaHealPickedUp(Picker : agent) : void =
        # Grant the consolation heal to all players (Apply To = All Players in device settings)
        ConsolationHeal.Pickup()

Line-by-line breakdown:

Common patterns

Pattern 1 — Instant grant to a specific agent (trigger plate reward)

A pressure plate triggers a one-time heal for the player who stepped on it. Uses Pickup(Agent:agent) to target exactly one player.

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

heal_on_plate := class(creative_device):

    @editable
    Plate : trigger_device = trigger_device{}

    @editable
    HealPowerup : health_powerup_device = health_powerup_device{}

    OnBegin<override>()<suspends> : void =
        # Keep the pickup invisible — we grant it directly
        HealPowerup.Despawn()
        # 75 HP per activation
        HealPowerup.SetMagnitude(75.0)
        Plate.TriggeredEvent.Subscribe(OnPlateTriggered)

    OnPlateTriggered(Agent : ?agent) : void =
        if (A := Agent?):
            # Grant the heal directly to whoever stepped on the plate
            HealPowerup.Pickup(A)

Key point: Pickup(Agent:agent) targets one specific agent — perfect for reward plates, checkpoint heals, or boss-kill bonuses. The powerup doesn't need to be spawned in the world for this to work.

Pattern 2 — Query effect status and remaining time

A UI ticker checks whether the local player already has the heal effect active and prints the remaining time. Uses HasEffect and GetRemainingTime.

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

heal_status_checker := class(creative_device):

    @editable
    HealPowerup : health_powerup_device = health_powerup_device{}

    @editable
    StatusTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        StatusTrigger.TriggeredEvent.Subscribe(OnCheckStatus)

    OnCheckStatus(Agent : ?agent) : void =
        if (A := Agent?):
            # HasEffect[] is failable — use if() to branch
            if (HealPowerup.HasEffect[A]):
                Remaining := HealPowerup.GetRemainingTime(A)
                # Remaining == -1.0 means infinite duration
                if (Remaining = -1.0):
                    # Effect is permanent on this agent
                    var Dummy : int = 0
                else:
                    # Effect is still ticking down
                    var Dummy2 : int = 0
            else:
                # Agent does not have the effect
                var Dummy3 : int = 0

Key point: HasEffect[] uses the <decides> specifier — it's a failable expression that must live inside an if() (or similar failure context). GetRemainingTime returns -1.0 for infinite duration and 0.0 if the agent has no effect.

Pattern 3 — Scaling magnitude based on surviving player count

As players are eliminated the heal powerup gets stronger — last survivors get a bigger boost. Uses GetMagnitude to read the current value before writing a new one.

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

scaling_heal_manager := class(creative_device):

    @editable
    HealPowerup : health_powerup_device = health_powerup_device{}

    @editable
    EliminationTracker : trigger_device = trigger_device{}

    # Bonus HP added per elimination event
    BonusPerElim : float = 10.0

    OnBegin<override>()<suspends> : void =
        HealPowerup.SetMagnitude(50.0)
        EliminationTracker.TriggeredEvent.Subscribe(OnElimination)

    OnElimination(Agent : ?agent) : void =
        Current := HealPowerup.GetMagnitude()
        # Increase magnitude — clamped by device Min/Max automatically
        HealPowerup.SetMagnitude(Current + BonusPerElim)
        # Respawn the pickup so the new magnitude is visible
        if (HealPowerup.IsSpawned[]):
            HealPowerup.Despawn()
        HealPowerup.Spawn()

Key point: SetMagnitude does not affect already-applied effects — only future pickups. Despawning and respawning the device resets it so the next player to grab it sees the updated value. GetMagnitude lets you do additive math on the current value rather than hard-coding a new one.

Gotchas

1. SetMagnitude / SetDuration don't retroactively update active effects

Both setters are documented as "will not apply to any currently applied effects." If a player already has the heal ticking, changing the magnitude won't change what they're experiencing. Only future Pickup calls or world pickups use the new value.

2. IsSpawned[] and HasEffect[] are failable — wrap them in if()

Both carry <decides>, meaning they can fail. Calling them outside a failure context is a compile error. Always write if (HealPowerup.IsSpawned[]): not HealPowerup.IsSpawned().

3. Pickup() (no-arg) requires Apply To = All Players in device settings

If you call the zero-argument Pickup() overload without setting Apply To → All Players in the UEFN Details panel, the call silently does nothing. Use Pickup(Agent) for single-target grants.

4. Magnitude is clamped to the device's Min/Max — set those in the editor

SetMagnitude clamps to the Min and Max you configured on the device in UEFN. If you try to set 200.0 but the device max is 100, you'll get 100. Always verify your device's range in the Details panel matches your Verse intent.

5. GetRemainingTime returns 0.0 (not failure) when the agent has no effect

Unlike HasEffect[], GetRemainingTime always returns a float — 0.0 means no effect, -1.0 means infinite. Don't use it as a boolean; use HasEffect[] first to confirm the agent is under the effect.

6. ItemPickedUpEvent sends agent, not ?agent

Unlike some other device events (e.g., trigger_device.TriggeredEvent which sends ?agent), ItemPickedUpEvent delivers a concrete agent directly. Your handler signature should be (Picker : agent) : void — no optional unwrap needed.