vehicle_spawner_helicopter_device: Aerial Vehicles Under Verse Control

Overview

The vehicle_spawner_helicopter_device is a specialized subclass of vehicle_spawner_device that manages the full lifecycle of a helicopter in your UEFN island. It solves a concrete game-design problem: you need a vehicle that appears at the right moment, is handed to the right player, and cleans itself up (or respawns) based on game state — all driven by Verse logic rather than manual editor triggers.

When to reach for it:

• An extraction helicopter that appears only after an objective is completed
• A timed aerial race where the chopper respawns each round
• A boss encounter where the villain is auto-assigned as helicopter driver
• Tracking when players enter or exit the vehicle to award points or change game phase

The device inherits all methods and events from vehicle_spawner_device, so everything described here applies equally to that base class surface.

API Reference

vehicle_spawner_helicopter_device

Specialized vehicle_spawner_device that allows a helicopter to be configured and spawned.

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

vehicle_spawner_helicopter_device<public> := class<concrete><final>(vehicle_spawner_device):

Events (subscribe a handler to react):

Methods (call these to make the device act):

vehicle_spawner_device

Base class for various specialized vehicle spawners which allow specific vehicle types to be spawned and configured with specialized options.

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

vehicle_spawner_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: Extraction Helicopter

A helicopter spawner sits on a rooftop. When the round starts the helicopter is disabled. Once a player steps on a trigger plate (the "extraction zone"), the helicopter is enabled, respawned, and that player is auto-assigned as driver. We listen for them to exit the vehicle (they've landed safely) and then destroy the helicopter and print a log via a score device. We also listen for the vehicle being destroyed (shot down) to respawn it.

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

# Place this Verse device in your level, then wire up the
# @editable fields in the Details panel.
extraction_helicopter_manager := class(creative_device):

    # The helicopter spawner placed on the rooftop
    @editable
    HelicopterSpawner : vehicle_spawner_helicopter_device = vehicle_spawner_helicopter_device{}

    # A trigger_device the player walks into to call the chopper
    @editable
    ExtractionZoneTrigger : trigger_device = trigger_device{}

    # A score manager to reward the player who lands safely
    @editable
    ScoreManager : score_manager_device = score_manager_device{}

    # Called once when the game session begins
    OnBegin<override>()<suspends> : void =
        # Start with the helicopter disabled — it hasn't been called yet
        HelicopterSpawner.Disable()

        # Subscribe to the extraction zone trigger
        ExtractionZoneTrigger.TriggeredEvent.Subscribe(OnExtractionZoneTriggered)

        # React when someone climbs into the helicopter
        HelicopterSpawner.AgentEntersVehicleEvent.Subscribe(OnAgentEntersHelicopter)

        # React when someone exits the helicopter (safe landing)
        HelicopterSpawner.AgentExitsVehicleEvent.Subscribe(OnAgentExitsHelicopter)

        # React when the helicopter is destroyed (shot down mid-flight)
        HelicopterSpawner.DestroyedEvent.Subscribe(OnHelicopterDestroyed)

        # React when the helicopter spawns/respawns
        HelicopterSpawner.SpawnedEvent.Subscribe(OnHelicopterSpawned)

    # Fires when a player walks into the extraction zone
    OnExtractionZoneTriggered(TriggeringAgent : ?agent) : void =
        # Enable the spawner so it can produce a vehicle
        HelicopterSpawner.Enable()
        # Destroy any stale vehicle and spawn a fresh one
        HelicopterSpawner.RespawnVehicle()
        # Assign the triggering player as driver
        if (A := TriggeringAgent?):
            HelicopterSpawner.AssignDriver(A)

    # Fires when an agent boards the helicopter — receives the agent directly
    OnAgentEntersHelicopter(BoardingAgent : agent) : void =
        # Nothing to do here in this scenario, but you could
        # start a countdown timer, lock the zone, etc.
        # The agent is already typed as `agent` — no unwrap needed.
        ScoreManager.Activate(BoardingAgent)

    # Fires when an agent exits the helicopter — extraction complete!
    OnAgentExitsHelicopter(ExitingAgent : agent) : void =
        # Award bonus score for a safe landing
        ScoreManager.Activate(ExitingAgent)
        # Clean up the helicopter
        HelicopterSpawner.DestroyVehicle()
        # Disable the spawner until the next round
        HelicopterSpawner.Disable()

    # Fires when the helicopter is destroyed (e.g. shot down)
    OnHelicopterDestroyed(Payload : tuple()) : void =
        # Respawn the helicopter so the mission can continue
        HelicopterSpawner.RespawnVehicle()

    # Fires when the helicopter finishes spawning — receives the fort_vehicle
    OnHelicopterSpawned(Vehicle : fort_vehicle) : void =
        # You could store Vehicle for later reference if needed
        # fort_vehicle is the live vehicle object
        ScoreManager.Reset()```

**Line-by-line highlights:**

| Line / call | What it does |
|---|---|
| `HelicopterSpawner.Disable()` | Prevents the helicopter from being interacted with at round start |
| `ExtractionZoneTrigger.TriggeredEvent.Subscribe(OnExtractionZoneTriggered)` | Hooks the trigger; note the handler receives `?agent` (optional) |
| `HelicopterSpawner.AgentEntersVehicleEvent.Subscribe(OnAgentEntersHelicopter)` | `AgentEntersVehicleEvent` sends a plain `agent` — no unwrap needed in the handler |
| `HelicopterSpawner.RespawnVehicle()` | Destroys any existing vehicle and spawns a fresh helicopter |
| `HelicopterSpawner.AssignDriver(A)` | Seats the extracted agent as pilot immediately |
| `HelicopterSpawner.DestroyVehicle()` | Removes the helicopter from the world |
| `HelicopterSpawner.DestroyedEvent.Subscribe(OnHelicopterDestroyed)` | `DestroyedEvent` sends `tuple()` — the handler takes `(Payload : tuple())` |
| `HelicopterSpawner.SpawnedEvent.Subscribe(OnHelicopterSpawned)` | `SpawnedEvent` sends a `fort_vehicle` — useful for tracking the live object |

## Common patterns

### Pattern 1 — Disable the helicopter after a time limit

Respawn the helicopter at the start of each round, then destroy it after 60 seconds if it hasn't been claimed.

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

timed_helicopter_round := class(creative_device):

    @editable
    HelicopterSpawner : vehicle_spawner_helicopter_device = vehicle_spawner_helicopter_device{}

    OnBegin<override>()<suspends> : void =
        # Spawn the helicopter for this round
        HelicopterSpawner.Enable()
        HelicopterSpawner.RespawnVehicle()

        # Wait 60 seconds, then destroy it if still around
        Sleep(60.0)
        HelicopterSpawner.DestroyVehicle()
        HelicopterSpawner.Disable()

Pattern 2 — Auto-assign a specific player as driver on spawn

When the helicopter spawns, immediately seat the first player who interacted with a button.

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

auto_assign_pilot := class(creative_device):

    @editable
    HelicopterSpawner : vehicle_spawner_helicopter_device = vehicle_spawner_helicopter_device{}

    @editable
    PilotButton : button_device = button_device{}

    # Stores the agent who pressed the button
    var DesignatedPilot : ?agent = false

    OnBegin<override>()<suspends> : void =
        PilotButton.InteractedWithEvent.Subscribe(OnPilotChosen)
        HelicopterSpawner.SpawnedEvent.Subscribe(OnHelicopterSpawned)

    OnPilotChosen(Pilot : agent) : void =
        set DesignatedPilot = option{Pilot}
        # Spawn the helicopter now that we have a pilot
        HelicopterSpawner.RespawnVehicle()

    # SpawnedEvent sends fort_vehicle — we use the stored pilot
    OnHelicopterSpawned(Vehicle : fort_vehicle) : void =
        if (Pilot := DesignatedPilot?):
            HelicopterSpawner.AssignDriver(Pilot)

Pattern 3 — Track enter/exit to toggle a zone device

Activate a "no-go zone" barrier while the helicopter is occupied; deactivate it when the pilot lands.

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

helicopter_zone_guard := class(creative_device):

    @editable
    HelicopterSpawner : vehicle_spawner_helicopter_device = vehicle_spawner_helicopter_device{}

    # A mutator zone or barrier device that blocks entry while active
    @editable
    RestrictedZone : mutator_zone_device = mutator_zone_device{}

    OnBegin<override>()<suspends> : void =
        HelicopterSpawner.AgentEntersVehicleEvent.Subscribe(OnPilotBoarded)
        HelicopterSpawner.AgentExitsVehicleEvent.Subscribe(OnPilotExited)
        HelicopterSpawner.DestroyedEvent.Subscribe(OnHelicopterDestroyed)

    # AgentEntersVehicleEvent sends agent directly — no optional unwrap
    OnPilotBoarded(Pilot : agent) : void =
        RestrictedZone.Enable()

    # AgentExitsVehicleEvent sends agent directly
    OnPilotExited(Pilot : agent) : void =
        RestrictedZone.Disable()

    # DestroyedEvent sends tuple() — make sure the zone is cleared
    OnHelicopterDestroyed(Payload : tuple()) : void =
        RestrictedZone.Disable()

Gotchas

1. AgentEntersVehicleEvent / AgentExitsVehicleEvent send agent, not ?agent

Unlike many trigger events (e.g. trigger_device.TriggeredEvent) which send ?agent, these two events send a plain agent. Your handler signature must be (SomeAgent : agent) — no if (A := SomeAgent?): unwrap needed.

# CORRECT
OnAgentEntersHelicopter(BoardingAgent : agent) : void =
    HelicopterSpawner.AssignDriver(BoardingAgent)

# WRONG — will not compile, the event doesn't send ?agent
# OnAgentEntersHelicopter(BoardingAgent : ?agent) : void = ...

2. DestroyedEvent and VehicleDestroyedEvent send tuple(), not an agent

These events carry no payload agent. Your handler must accept (Payload : tuple()). You cannot identify who destroyed the vehicle from this event alone — combine it with damage tracking if you need that.

# CORRECT
OnHelicopterDestroyed(Payload : tuple()) : void =
    HelicopterSpawner.RespawnVehicle()

3. VehicleSpawnedEvent and VehicleDestroyedEvent are deprecated

The API surface lists both as deprecated. Always prefer SpawnedEvent (which also gives you the fort_vehicle object) and DestroyedEvent. Using the deprecated events will still compile today but may be removed in a future digest.

4. RespawnVehicle() destroys the old vehicle first

Calling RespawnVehicle() when a helicopter is already in the world will silently destroy it before spawning the new one. If a player is inside when this happens, they will be ejected. Don't call RespawnVehicle() inside a DestroyedEvent handler without a guard — you can create an infinite respawn loop if the helicopter is immediately destroyed again.

5. The device must be @editable — you cannot construct it in code

vehicle_spawner_helicopter_device is <concrete><final> and must be placed in the UEFN level editor and referenced via an @editable field. Attempting to write vehicle_spawner_helicopter_device{} as a standalone local variable and calling methods on it will compile but the device will have no in-world representation and nothing will happen.

6. AssignDriver requires the vehicle to already exist

Call AssignDriver after the helicopter has spawned — either inside a SpawnedEvent handler or after Sleep-ing long enough for the spawn to complete. Calling it before the vehicle exists has no effect.