nitro_hoop_device: Blazing Boost Gates for Racers and Riders

Overview

The nitro_hoop_device places a dramatic flaming ring in your island that accelerates any player or vehicle that passes through it. Out of the box it works standalone, but connecting it to Verse unlocks a rich set of controls:

• Enable / Disable hoops on a schedule or in response to game state (e.g., only the next hoop in a sequence is active).
• Cooldown management — let the hoop rest between uses, shorten or extend that rest period at runtime, or bypass cooldown entirely for an always-hot boost pad.
• Event hooks — react when a player or vehicle triggers the hoop, when cooldown begins, or when the hoop comes back online.

Reach for nitro_hoop_device whenever you need boost gates that respond to game logic: sequential activation, per-lap cooldowns, team-gated hoops, or score multipliers tied to hoop combos.

API Reference

nitro_hoop_device

Use to create a flaming hoop that accelerates and applies nitro to players and vehicles.

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

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

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Scenario: Sequential Race Gate System

You have three nitro hoops placed along a race circuit. Only the first hoop starts active. When a player flies through it, it disables itself, the next hoop lights up, and a short cooldown is applied to the just-used hoop so it can reactivate for the next lap. We also log vehicle passes and announce when a hoop comes back online.

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

# Attach this Verse device in UEFN and wire up three nitro_hoop_device references.
sequential_hoop_manager := class(creative_device):

    # The three hoops placed along the circuit, in order.
    @editable
    Hoop1 : nitro_hoop_device = nitro_hoop_device{}

    @editable
    Hoop2 : nitro_hoop_device = nitro_hoop_device{}

    @editable
    Hoop3 : nitro_hoop_device = nitro_hoop_device{}

    # How long (seconds) a used hoop waits before it can fire again.
    # Clamped by the device to [1.0, 60.0].
    CooldownSeconds : float = 8.0

    # Delay between triggering and entering cooldown phase (seconds).
    DelaySeconds : float = 0.5

    OnBegin<override>()<suspends> : void =
        # Configure cooldown durations at runtime.
        Hoop1.SetDefaultCooldownDuration(CooldownSeconds)
        Hoop2.SetDefaultCooldownDuration(CooldownSeconds)
        Hoop3.SetDefaultCooldownDuration(CooldownSeconds)

        # Small delay before cooldown phase kicks in after a pass-through.
        Hoop1.SetCooldownDelay(DelaySeconds)
        Hoop2.SetCooldownDelay(DelaySeconds)
        Hoop3.SetCooldownDelay(DelaySeconds)

        # Only Hoop1 starts active; the others wait.
        Hoop2.Disable()
        Hoop3.Disable()

        # Subscribe to player triggers for each hoop.
        Hoop1.PlayerTriggeredEvent.Subscribe(OnHoop1Player)
        Hoop2.PlayerTriggeredEvent.Subscribe(OnHoop2Player)
        Hoop3.PlayerTriggeredEvent.Subscribe(OnHoop3Player)

        # Subscribe to vehicle triggers — payload is ?agent (driver, may be false).
        Hoop1.VehicleTriggeredEvent.Subscribe(OnHoop1Vehicle)

        # React when Hoop1 finishes cooldown and comes back online.
        Hoop1.EnabledEvent.Subscribe(OnHoop1Reenabled)

        # React when Hoop1 enters cooldown (not triggered by manual Disable).
        Hoop1.CooldownStartEvent.Subscribe(OnHoop1CooldownStart)

    # --- Hoop 1 handlers ---

    OnHoop1Player(Agent : agent) : void =
        # Advance the sequence: disable this hoop, light up the next.
        Hoop1.Disable()
        Hoop2.Enable()

    OnHoop1Vehicle(Agent : ?agent) : void =
        # Unwrap the optional driver before using them.
        if (Driver := Agent?):
            # A driven vehicle passed through — advance the sequence.
            Hoop1.Disable()
            Hoop2.Enable()
        # If Agent is false, the vehicle was unoccupied; ignore.

    OnHoop1CooldownStart() : void =
        # Hoop1 entered cooldown naturally (AllowCooldown is default).
        # Nothing extra needed here, but you could update a HUD.
        var Duration : float = Hoop1.GetDefaultCooldownDuration()

    OnHoop1Reenabled() : void =
        # Hoop1 is hot again after cooldown — ready for the next lap.
        # Re-disable Hoop2 and Hoop3 to reset the sequence for this hoop.
        Hoop2.Disable()
        Hoop3.Disable()

    # --- Hoop 2 handler ---

    OnHoop2Player(Agent : agent) : void =
        Hoop2.Disable()
        Hoop3.Enable()

    # --- Hoop 3 handler ---

    OnHoop3Player(Agent : agent) : void =
        # Final hoop — start a timed cooldown of 5 seconds, then re-enable.
        Hoop3.StartCooldown(5.0)
        # Optionally re-enable Hoop1 for the next lap pass.
        Hoop1.Enable()

Line-by-line explanation

Common patterns

Pattern 1 — Always-On Boost Pad (DisallowCooldown)

For a power-up lane where the hoop should never go dark, call DisallowCooldown at startup. The hoop fires every time without entering a rest state.

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

always_on_hoop := class(creative_device):

    @editable
    BoostHoop : nitro_hoop_device = nitro_hoop_device{}

    OnBegin<override>()<suspends> : void =
        # Prevent cooldown from ever triggering — hoop stays active indefinitely.
        BoostHoop.DisallowCooldown()

        # Subscribe to confirm it's firing.
        BoostHoop.PlayerTriggeredEvent.Subscribe(OnBoosted)

    OnBoosted(Agent : agent) : void =
        # The hoop is still enabled — verify with IsEnabled (failable).
        if (BoostHoop.IsEnabled[]):
            # Hoop is confirmed active; game logic here.
            var Delay : float = BoostHoop.GetCooldownDelay()

Pattern 2 — Timed Lockout After Vehicle Pass

In a demolition derby mode, lock a hoop for 15 seconds whenever a vehicle drives through it, then re-enable it. Use StartCooldown for precise control.

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

vehicle_lockout_hoop := class(creative_device):

    @editable
    DerbyHoop : nitro_hoop_device = nitro_hoop_device{}

    # Lockout duration in seconds (clamped to minimum 1.0 by the device).
    LockoutDuration : float = 15.0

    OnBegin<override>()<suspends> : void =
        DerbyHoop.VehicleTriggeredEvent.Subscribe(OnVehiclePass)
        DerbyHoop.EnabledEvent.Subscribe(OnHoopBack)

    OnVehiclePass(Agent : ?agent) : void =
        # Start a hard 15-second cooldown regardless of editor settings.
        DerbyHoop.StartCooldown(LockoutDuration)

    OnHoopBack() : void =
        # Hoop is live again — restore default cooldown behaviour.
        DerbyHoop.AllowCooldown()
        DerbyHoop.SetDefaultCooldownDuration(5.0)

Pattern 3 — Phase-Gated Hoop (Enable/Disable on game state)

Only activate the nitro hoop during the "Sprint" phase of a mini-game. Wire a trigger to flip the hoop on and off.

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

phase_gated_hoop := class(creative_device):

    @editable
    SprintHoop : nitro_hoop_device = nitro_hoop_device{}

    # A trigger_device wired to fire when the Sprint phase begins.
    @editable
    SprintStartTrigger : trigger_device = trigger_device{}

    # A trigger_device wired to fire when the Sprint phase ends.
    @editable
    SprintEndTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        # Hoop starts disabled; only active during Sprint phase.
        SprintHoop.Disable()

        SprintStartTrigger.TriggeredEvent.Subscribe(OnSprintStart)
        SprintEndTrigger.TriggeredEvent.Subscribe(OnSprintEnd)

        SprintHoop.CooldownStartEvent.Subscribe(OnCooldownBegan)

    OnSprintStart(Agent : ?agent) : void =
        # Enable the hoop (also cancels any active cooldown).
        SprintHoop.Enable()

    OnSprintEnd(Agent : ?agent) : void =
        # Disable the hoop for the rest phase.
        SprintHoop.Disable()

    OnCooldownBegan() : void =
        # Log the current cooldown duration for debugging.
        var Duration : float = SprintHoop.GetDefaultCooldownDuration()

Gotchas

1. @editable is mandatory — bare identifiers won't compile

You cannot write nitro_hoop_device{}.Enable() inline. Every placed device must be declared as an @editable field inside your class(creative_device). Without it, Verse has no reference to the actor placed in the level.

2. VehicleTriggeredEvent sends ?agent, not agent

The vehicle event's payload is ?agent (an optional). If the vehicle has no driver, the value is false. Always unwrap:

if (Driver := Agent?):
    # safe to use Driver here

Forgetting the unwrap causes a compile error because ?agent is not directly usable where agent is expected.

3. CooldownStartEvent does NOT fire after Disable()

If you call Hoop.Disable() manually, CooldownStartEvent is not signalled. It only fires when the cooldown is triggered naturally by a player or vehicle passing through. If you need to react to manual disables, subscribe to your own game-state variable instead.

4. IsEnabled[] is failable — use it inside if

IsEnabled is marked <decides>, meaning it either succeeds or fails rather than returning a logic value. Call it inside a condition:

if (MyHoop.IsEnabled[]):
    # hoop is active

Calling it outside a failable context is a compile error.

5. StartCooldown ignores the cooldown delay

The cooldown delay set by SetCooldownDelay applies only to natural cooldowns (player/vehicle trigger). When you call StartCooldown(Seconds) or Disable() directly, the device enters cooldown immediately with no delay.

6. Duration clamping

• SetDefaultCooldownDuration clamps to [1.0, 60.0] — values outside this range are silently clamped.
• StartCooldown clamps to a minimum of 1.0 — passing 0.0 gives you a 1-second cooldown, not an instant re-enable.
• SetCooldownDelay also has a minimum of 0.0; consult the editor tooltip for the upper bound.

7. Enable() cancels active cooldown

Calling Enable() while the hoop is in cooldown immediately ends the cooldown and makes the hoop active. This is intentional and useful for phase resets, but can surprise you if you call Enable() accidentally mid-cooldown.