creature_manager_device: Controlling Creature Waves Like a Pro

Overview

The creature_manager_device lets you control one creature type at a time from Verse. You place one device per creature type in your UEFN level, configure it in the Details panel (health, speed, damage, etc.), then reference it in Verse to:

• Enable or Disable spawning of that creature type mid-game (e.g., start a new wave, pause enemies during a cutscene).
• React to eliminations via MatchingCreatureTypeEliminatedEvent, which fires every time a creature of that type is eliminated and tells you which player made the kill.

Reach for creature_manager_device when you need Verse-driven wave logic, kill-count tracking, or dynamic difficulty scaling tied to creature behavior.

One device per creature type. If you have Wolves and Raptors, place two creature_manager_devices and wire each to a separate @editable field.

API Reference

creature_manager_device

Used to customize one creature type at a time. Place multiple creature_manager_devices for each type of creature on your island. Changing properties will respect the Affected Creatures property of the device. If Affected Creatures is set to New Pawns Only, only new spawns will get the changed property values. If set to New and Existing Pawns, all creatures spawned from this device and ne

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

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

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Scenario: A survival island with two waves of creatures. Wave 1 starts immediately. When the player eliminates 3 creatures, Wave 2 begins (a tougher creature type). If the player eliminates 5 creatures in Wave 2, they win.

wave_survival_manager := class(creative_device):

    # Wire these to your two creature_manager_device instances in the Details panel
    @editable
    Wave1Manager : creature_manager_device = creature_manager_device{}

    @editable
    Wave2Manager : creature_manager_device = creature_manager_device{}

    # Localized message helper for Print-style feedback (not used for device calls)
    WaveMessage<localizes>(S : string) : message = "{S}"

    # Mutable kill counters
    var Wave1Kills : int = 0
    var Wave2Kills : int = 0

    OnBegin<override>()<suspends> : void =
        # Wave 2 starts disabled — we enable it manually after Wave 1 threshold
        Wave2Manager.Disable()

        # Subscribe to kill events for both waves
        Wave1Manager.MatchingCreatureTypeEliminatedEvent.Subscribe(OnWave1Kill)
        Wave2Manager.MatchingCreatureTypeEliminatedEvent.Subscribe(OnWave2Kill)

        # Wave 1 is already enabled by default in the Details panel;
        # nothing else to do — handlers take over from here.

    # Called whenever a Wave 1 creature is eliminated
    # MatchingCreatureTypeEliminatedEvent is listenable(agent), so the handler receives (Agent : agent)
    OnWave1Kill(Agent : agent) : void =
        set Wave1Kills += 1
        if (Wave1Kills >= 3):
            # Disable Wave 1 spawning, start Wave 2
            Wave1Manager.Disable()
            Wave2Manager.Enable()

    # Called whenever a Wave 2 creature is eliminated
    OnWave2Kill(Agent : agent) : void =
        set Wave2Kills += 1
        if (Wave2Kills >= 5):
            # All done — disable Wave 2 so no more creatures spawn
            Wave2Manager.Disable()

Line-by-line explanation

Common patterns

Pattern 1 — Disable all creatures during a cutscene, then re-enable

Pause creature activity while a cinematic plays, then restore it.

cutscene_creature_pause := class(creative_device):

    @editable
    CreatureManager : creature_manager_device = creature_manager_device{}

    @editable
    CinematicTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        CinematicTrigger.TriggeredEvent.Subscribe(OnCinematicStart)

    OnCinematicStart(Agent : ?agent) : void =
        # Stop creatures from spawning while the cinematic plays
        CreatureManager.Disable()
        # Wait for the cinematic duration (e.g. 8 seconds)
        Sleep(8.0)
        # Resume creature spawning after the cinematic ends
        CreatureManager.Enable()

Note: CinematicTrigger.TriggeredEvent is a listenable(?agent), so the handler receives (Agent : ?agent). We don't need the agent here, so we accept but ignore it.

Pattern 2 — Track which player gets the most creature kills

Use MatchingCreatureTypeEliminatedEvent to credit individual players for kills.

kill_tracker_device := class(creative_device):

    @editable
    CreatureManager : creature_manager_device = creature_manager_device{}

    @editable
    ScoreManager : score_manager_device = score_manager_device{}

    OnBegin<override>()<suspends> : void =
        CreatureManager.MatchingCreatureTypeEliminatedEvent.Subscribe(OnCreatureKilled)

    # The event sends the eliminating agent directly
    OnCreatureKilled(Eliminator : agent) : void =
        # Award 1 point to the player who made the kill
        ScoreManager.SetScoreForAgent(Eliminator, ScoreManager.GetCurrentScore(Eliminator) + 1)

Pattern 3 — Enable a creature wave only when a button is pressed

Gate creature spawning behind a player interaction.

button_wave_starter := class(creative_device):

    @editable
    StartButton : button_device = button_device{}

    @editable
    CreatureManager : creature_manager_device = creature_manager_device{}

    OnBegin<override>()<suspends> : void =
        # Creatures are disabled until the player presses the button
        CreatureManager.Disable()
        StartButton.InteractedWithEvent.Subscribe(OnButtonPressed)

    OnButtonPressed(Agent : agent) : void =
        # Enable creatures and prevent re-pressing
        CreatureManager.Enable()
        StartButton.Disable()

Gotchas

1. One device per creature type — not one for all

creature_manager_device targets a single creature type set in its Details panel (Creature Type property). Calling Enable() or Disable() only affects that type. For multiple types, place multiple devices and wire each to a separate @editable field.

2. MatchingCreatureTypeEliminatedEvent sends agent, not ?agent

This event's signature is listenable(agent) — the handler receives a plain agent, not an optional ?agent. You do not need to unwrap it with if (A := Agent?). Contrast this with creature_placer_device.EliminatedEvent, which sends ?agent and does require unwrapping.

3. Disable() stops new spawns — it doesn't despawn existing creatures

Calling Disable() respects the Affected Creatures setting in the Details panel. If set to New Pawns Only, already-spawned creatures continue to roam. If you need to remove existing creatures, combine with a creature_placer_device or a separate despawn mechanism.

4. Enable() / Disable() are fire-and-forget — they have no <suspends> effect

Both methods return void synchronously. You can call them anywhere — inside a <suspends> coroutine or a plain event handler — without needing spawn{} or await.

5. The device must be placed in the level and wired via @editable

You cannot construct a creature_manager_device in code with creature_manager_device{} and expect it to control real creatures. The @editable field must be connected to an actual placed device in the UEFN Outliner, otherwise all method calls are no-ops on a default instance.