vehicle_spawner_hammerhead_choppa_device: Aerial Combat on Demand

Overview

The vehicle_spawner_hammerhead_choppa_device is a concrete specialization of vehicle_spawner_device that lets you place a Hammerhead Choppa helicopter in your UEFN island and control it entirely from Verse. It exposes the full vehicle lifecycle:

• Spawn / Respawn — call RespawnVehicle to put a fresh Choppa on the pad at any time.
• Assign a pilot — call AssignDriver(Agent) to seat a specific player immediately.
• Destroy on cue — call DestroyVehicle to blow it up from code (great for scripted sequences).
• React to events — subscribe to AgentEntersVehicleEvent, AgentExitsVehicleEvent, SpawnedEvent, and DestroyedEvent to drive score, UI, and game-state changes.
• Enable / Disable — gate the spawner so the Choppa only appears during the right phase of your game.

Reach for this device whenever you need a helicopter that responds to game logic rather than just sitting on a pad waiting for a random player.

API Reference

vehicle_spawner_hammerhead_choppa_device

Specialized vehicle_spawner_device that allows a Hammerhead Choppa 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_hammerhead_choppa_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: A boss-wave survival mode. When the final wave starts, a Hammerhead Choppa spawns and the last surviving player is automatically assigned as its pilot. If the Choppa is destroyed the device respawns it after a short delay. When a player exits the Choppa mid-flight the device logs the exit and disables the spawner so no more Choppas appear.

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

# Place this Verse device in your level alongside a vehicle_spawner_hammerhead_choppa_device
# and a trigger_device that fires when the final wave begins.
boss_wave_choppa_manager := class(creative_device):

    # Wire up in the Details panel to your placed Hammerhead Choppa spawner.
    @editable
    ChoppaSpawner : vehicle_spawner_hammerhead_choppa_device = vehicle_spawner_hammerhead_choppa_device{}

    # Wire up to a trigger that fires when the final wave starts.
    @editable
    FinalWaveTrigger : trigger_device = trigger_device{}

    # Tracks whether we should auto-respawn after destruction.
    var ShouldRespawn : logic = false

    OnBegin<override>()<suspends> : void =
        # Start with the spawner disabled — no Choppa until the final wave.
        ChoppaSpawner.Disable()

        # Subscribe to the final-wave trigger (listenable(?agent) — unwrap the option).
        FinalWaveTrigger.TriggeredEvent.Subscribe(OnFinalWaveStarted)

        # Subscribe to vehicle lifecycle events.
        ChoppaSpawner.SpawnedEvent.Subscribe(OnChoppaSpawned)
        ChoppaSpawner.AgentEntersVehicleEvent.Subscribe(OnPilotBoarded)
        ChoppaSpawner.AgentExitsVehicleEvent.Subscribe(OnPilotExited)
        ChoppaSpawner.DestroyedEvent.Subscribe(OnChoppaDestroyed)

    # Called when the final-wave trigger fires.
    # trigger_device.TriggeredEvent is listenable(?agent), so the param is ?agent.
    OnFinalWaveStarted(MaybeAgent : ?agent) : void =
        set ShouldRespawn = true
        ChoppaSpawner.Enable()
        # Spawn the Choppa — RespawnVehicle destroys any existing one first.
        ChoppaSpawner.RespawnVehicle()
        # If a specific agent triggered the wave, assign them as pilot immediately.
        if (A := MaybeAgent?):
            ChoppaSpawner.AssignDriver(A)

    # SpawnedEvent sends the fort_vehicle directly (not optional).
    OnChoppaSpawned(Vehicle : fort_vehicle) : void =
        # The Choppa is live — game logic can react here (e.g. start a timer).
        Print("Hammerhead Choppa is airborne!")

    # AgentEntersVehicleEvent sends agent directly.
    OnPilotBoarded(BoardingAgent : agent) : void =
        Print("Pilot has boarded the Choppa.")

    # AgentExitsVehicleEvent sends agent directly.
    OnPilotExited(ExitingAgent : agent) : void =
        # Pilot bailed — disable the spawner so no more Choppas appear.
        set ShouldRespawn = false
        ChoppaSpawner.Disable()
        Print("Pilot exited — spawner disabled.")

    # DestroyedEvent sends tuple() — no payload.
    OnChoppaDestroyed(Payload : tuple()) : void =
        if (ShouldRespawn?):
            # Respawn after a 5-second delay using an async task.
            spawn { RespawnAfterDelay() }

    RespawnAfterDelay()<suspends> : void =
        Sleep(5.0)
        if (ShouldRespawn?):
            ChoppaSpawner.RespawnVehicle()```

### Line-by-line highlights

| Lines | What's happening |
|---|---|
| `ChoppaSpawner.Disable()` in `OnBegin` | Prevents the Choppa from appearing before the final wave. |
| `FinalWaveTrigger.TriggeredEvent.Subscribe(OnFinalWaveStarted)` | Hooks the wave-start trigger; handler receives `?agent`. |
| `ChoppaSpawner.Enable()` then `RespawnVehicle()` | Enables the spawner, then immediately spawns a fresh Choppa. |
| `if (A := MaybeAgent?):` | Safe unwrap of the `?agent` option before calling `AssignDriver`. |
| `AssignDriver(A)` | Seats the triggering player as the Choppa's pilot. |
| `SpawnedEvent` handler receives `fort_vehicle` | The modern event — use this instead of the deprecated `VehicleSpawnedEvent`. |
| `DestroyedEvent` handler receives `tuple()` | No payload; use the `ShouldRespawn` flag to decide whether to call `RespawnVehicle`. |
| `spawn { RespawnAfterDelay() }` | Launches an async coroutine so `Sleep` doesn't block the event handler. |

## Common patterns

### Pattern 1 — Instant pilot assignment when a player boards

Force every player who boards to become the official driver (useful if your Choppa has a fixed pilot seat you want locked to one team).

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

choppa_auto_assign := class(creative_device):

    @editable
    ChoppaSpawner : vehicle_spawner_hammerhead_choppa_device = vehicle_spawner_hammerhead_choppa_device{}

    OnBegin<override>()<suspends> : void =
        # Re-assign driver every time someone boards.
        ChoppaSpawner.AgentEntersVehicleEvent.Subscribe(OnAgentBoarded)

    OnAgentBoarded(BoardingAgent : agent) : void =
        # Immediately (re)assign the boarding agent as the official driver.
        ChoppaSpawner.AssignDriver(BoardingAgent)

Pattern 2 — Scripted cinematic destruction

A button press triggers a dramatic Choppa explosion mid-cutscene, then the spawner is disabled so it never returns.

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

choppa_cinematic_destroy := class(creative_device):

    @editable
    ChoppaSpawner : vehicle_spawner_hammerhead_choppa_device = vehicle_spawner_hammerhead_choppa_device{}

    @editable
    DetonateButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        DetonateButton.InteractedWithEvent.Subscribe(OnDetonatePressed)
        ChoppaSpawner.DestroyedEvent.Subscribe(OnChoppaGone)

    # button_device.InteractedWithEvent is listenable(agent) — direct agent, no option.
    OnDetonatePressed(Interactor : agent) : void =
        # Blow up the Choppa on cue.
        ChoppaSpawner.DestroyVehicle()

    OnChoppaGone(Payload : tuple()) : void =
        # Lock out the spawner so the Choppa stays gone.
        ChoppaSpawner.Disable()

Pattern 3 — Track the spawned fort_vehicle reference

Use SpawnedEvent (which sends the actual fort_vehicle) to store a reference for later use — for example, to feed into other devices that accept a vehicle target.

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

choppa_vehicle_tracker := class(creative_device):

    @editable
    ChoppaSpawner : vehicle_spawner_hammerhead_choppa_device = vehicle_spawner_hammerhead_choppa_device{}

    # Store the live fort_vehicle reference.
    var ActiveChoppa : ?fort_vehicle = false

    OnBegin<override>()<suspends> : void =
        ChoppaSpawner.SpawnedEvent.Subscribe(OnChoppaSpawned)
        ChoppaSpawner.DestroyedEvent.Subscribe(OnChoppaDestroyed)
        # Kick off the initial spawn.
        ChoppaSpawner.RespawnVehicle()

    # SpawnedEvent delivers fort_vehicle directly — store it.
    OnChoppaSpawned(Vehicle : fort_vehicle) : void =
        set ActiveChoppa = option{ Vehicle }

    OnChoppaDestroyed(Payload : tuple()) : void =
        # Clear the reference when the vehicle is gone.
        set ActiveChoppa = false

Gotchas

1. DestroyedEvent and SpawnedEvent vs. the deprecated pair

VehicleSpawnedEvent and VehicleDestroyedEvent both send tuple() and are deprecated. Always use SpawnedEvent (which sends the fort_vehicle) and DestroyedEvent instead. The fort_vehicle payload from SpawnedEvent is the only way to get a typed reference to the live vehicle from this device.

2. AgentEntersVehicleEvent / AgentExitsVehicleEvent send agent, not ?agent

These two events are listenable(agent) — the handler receives a plain agent, no option unwrap needed. Contrast this with many trigger-style events that send ?agent.

3. RespawnVehicle destroys any existing Choppa first

Calling RespawnVehicle when a Choppa is already live will destroy it and fire DestroyedEvent before spawning the new one. If your DestroyedEvent handler calls RespawnVehicle unconditionally you will create an infinite respawn loop. Always guard with a flag (like ShouldRespawn in the walkthrough).

4. The spawner must be enabled for RespawnVehicle to work

If you call RespawnVehicle() while the device is disabled, nothing happens. Always call Enable() before RespawnVehicle() if you previously disabled the spawner.

5. AssignDriver requires the vehicle to already exist

AssignDriver seats the agent in the current vehicle. If called before SpawnedEvent fires (i.e., before the vehicle actually exists), the call is silently ignored. Subscribe to SpawnedEvent and call AssignDriver from inside that handler, or call it after RespawnVehicle returns and the spawn event has fired.

6. Every @editable device field must be wired in the Details panel

Declaring ChoppaSpawner : vehicle_spawner_hammerhead_choppa_device = vehicle_spawner_hammerhead_choppa_device{} gives you a default empty instance — it does nothing until you drag your placed spawner device into that slot in the UEFN Details panel. Forgetting this is the #1 reason vehicle code appears to run but has no effect.