wildlife_spawner_device: Beasts You Can Tame, Ride, and Feed

Overview

The Wildlife Spawner device populates your map with Fortnite wildlife — boars, wolves, raptors, frogs — and exposes a rich Verse surface so those creatures become gameplay, not scenery. Reach for it when you want:

• A tameable companion a player can befriend and fight alongside (Tame, TamedEvent).
• A rideable mount the player teleports onto and rides (Ride, RiddenEvent, Dismount).
• An energy/stamina economy where feeding restores energy and sprinting drains it (RestoreEnergy, ConsumeEnergy, SomethingIsEatenEvent).
• A boss/horde encounter where you spawn waves and score eliminations (Spawn, SpawnAt, EliminatedEvent, EliminatingEvent).

Everything below uses the device's real methods and events. The key idea: place the device in your level, expose it as an @editable field on a Verse creative_device, then call its methods inside OnBegin and from event handlers.

API Reference

wildlife_spawner_device

Used to customize the properties of NPCs spawned by this device. Changing properties will only affect newly spawned wildlife creatures.

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

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

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Let's build a Creature Ranch: when the game starts we spawn a creature, and a player who steps on a trigger tames the nearest creature into their AI partner. Once tamed, a button mounts them onto it. We also feed energy back when the creature eats, and announce eliminations on a HUD message device.

using { /Fortnite.com/Devices }
using { /Fortnite.com/Devices/Patchwork }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporal }

# A localized-text helper: `message` params need a localized value, not a raw string.
ranch_msg<localizes>(S:string):message = "{S}"

creature_ranch := class(creative_device):

    # Drag your placed devices onto these fields in the Details panel.
    @editable Wildlife : wildlife_spawner_device = wildlife_spawner_device{}
    @editable TameTrigger : trigger_device = trigger_device{}
    @editable RideButton : button_device = button_device{}
    @editable Hud : hud_message_device = hud_message_device{}

    OnBegin<override>()<suspends>:void =
        # React to the device's lifecycle events.
        Wildlife.SpawnedEvent.Subscribe(OnCreatureSpawned)
        Wildlife.TamedEvent.Subscribe(OnCreatureTamed)
        Wildlife.RiddenEvent.Subscribe(OnCreatureRidden)
        Wildlife.SomethingIsEatenEvent.Subscribe(OnCreatureAte)
        Wildlife.EliminatedEvent.Subscribe(OnCreatureEliminated)

        # Player interactions drive the taming / riding.
        TameTrigger.TriggeredEvent.Subscribe(OnTameStep)
        RideButton.InteractedWithEvent.Subscribe(OnRidePress)

        # Kick off the encounter with one creature.
        Wildlife.Enable()
        Wildlife.Spawn()
        Print("Ranch open — spawn limit is {Wildlife.GetSpawnLimit()}")

    # SpawnedEvent hands us the wildlife agent directly (listenable(agent)).
    OnCreatureSpawned(Creature : agent):void =
        Print("A creature spawned. Total alive: {Wildlife.GetAgents().Length}")

    # Player steps on the plate -> tame the nearest creature for that player.
    OnTameStep(Agent : ?agent):void =
        if (Player := Agent?):
            Wildlife.Tame(Player)

    # TamedEvent gives a device_ai_interaction_result: Source = tamer, Target = creature.
    OnCreatureTamed(Result : device_ai_interaction_result):void =
        if (Tamer := Result.Source?):
            Hud.Show(Tamer, ?Text := ranch_msg("You tamed a creature! Press the button to ride."))

    # Button press -> teleport the player onto their nearest creature and mount it.
    OnRidePress(Agent : agent):void =
        Wildlife.Ride(Agent)

    # RiddenEvent: Source = rider, Target = the wildlife being ridden.
    OnCreatureRidden(Result : device_ai_interaction_result):void =
        if (Rider := Result.Source?):
            # Top off the mount's energy so the player can sprint right away.
            Wildlife.RestoreEnergy(Rider)

    # Wildlife ate a Shroom/Meat pickup -> reward the whole herd with energy.
    OnCreatureAte(Creature : agent):void =
        Wildlife.RestoreEnergyForAll()

    # EliminatedEvent is a device_ai_interaction_result. Source may be the eliminator.
    OnCreatureEliminated(Result : device_ai_interaction_result):void =
        if (Killer := Result.Source?):
            Hud.Show(Killer, ?Text := ranch_msg("Creature down! Respawning the herd."))
        # Repopulate so the ranch is never empty.
        Wildlife.Spawn()

Line-by-line:

• The @editable fields are how Verse reaches the placed devices. A bare Wildlife.Spawn() on an undeclared device fails with Unknown identifier — the field declaration is mandatory.
• In OnBegin we Subscribe each event to a method defined at class scope. OnBegin is where subscriptions live.
• Wildlife.Enable() then Wildlife.Spawn() activates the device and pushes out the first creature. GetSpawnLimit() returns the configured cap as an int.
• SpawnedEvent and SomethingIsEatenEvent are listenable(agent) — their handlers receive a plain agent (the creature). No unwrap needed.
• TriggeredEvent is listenable(?agent), so OnTameStep takes ?agent and we unwrap with if (Player := Agent?): before passing it to Tame.
• TamedEvent, RiddenEvent, and EliminatedEvent are listenable(device_ai_interaction_result). The result carries Source (the acting agent) and Target (the creature). Both are optional — unwrap Result.Source? before use.
• Hud.Show takes a message; we build one with the ranch_msg<localizes> helper. There is no StringToMessage.

Common patterns

Spawn at an exact position with SpawnAt (suspends)

SpawnAt is <suspends> because the engine streams in the NPC asset before returning it. It returns ?agent — false if the spawn cap is hit. Call it from a suspending context.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /Verse.org/SpatialMath }
using { /UnrealEngine.com/Temporal }

ambush_spawner := class(creative_device):

    @editable Wildlife : wildlife_spawner_device = wildlife_spawner_device{}
    @editable StartButton : button_device = button_device{}

    OnBegin<override>()<suspends>:void =
        StartButton.InteractedWithEvent.Subscribe(OnStart)

    OnStart(Agent : agent):void =
        # Launch the suspending spawn work without blocking the handler.
        spawn{ SpawnAmbush() }

    SpawnAmbush()<suspends>:void =
        # Drop three creatures in a line ahead of the device.
        for (I := 0..2):
            SpawnPos := vector3{ X := 500.0 * Float(I), Y := 0.0, Z := 100.0 }
            if (Beast := Wildlife.SpawnAt(SpawnPos)?):
                Print("Spawned creature #{I} at the ambush point")
            Sleep(0.5)

A stamina drain: ConsumeEnergy while riding, RestoreEnergy on feed

Use ConsumeEnergyForAll/RestoreEnergy to build a stamina loop. Here a "sprint" trigger drains the herd; an eaten pickup restores the rider's mount.

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

stamina_loop := class(creative_device):

    @editable Wildlife : wildlife_spawner_device = wildlife_spawner_device{}
    @editable SprintPad : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        SprintPad.TriggeredEvent.Subscribe(OnSprint)
        Wildlife.SomethingIsEatenEvent.Subscribe(OnAte)
        Wildlife.DismountedEvent.Subscribe(OnDismount)

    # Stepping on the sprint pad burns energy across every creature.
    OnSprint(Agent : ?agent):void =
        Wildlife.ConsumeEnergyForAll()

    # Eating refills energy for the whole herd.
    OnAte(Creature : agent):void =
        Wildlife.RestoreEnergyForAll()

    # On dismount, untame so the creature returns to the wild.
    OnDismount(Result : device_ai_interaction_result):void =
        if (Rider := Result.Source?):
            Wildlife.Untame(Rider)

Cleanup: despawn, untame all, and tear down the spawner

When a round ends, dismiss every creature cleanly. DismountAll and UntameAll take no args; DestroySpawner and Despawn need an agent to credit.

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

round_cleanup := class(creative_device):

    @editable Wildlife : wildlife_spawner_device = wildlife_spawner_device{}
    @editable EndTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        EndTrigger.TriggeredEvent.Subscribe(OnRoundEnd)

    OnRoundEnd(Agent : ?agent):void =
        # Get everyone off mounts and break all tame bonds first.
        Wildlife.DismountAll()
        Wildlife.UntameAll()
        # Despawn each creature, crediting the agent who ended the round.
        if (Ender := Agent?):
            for (Beast : Wildlife.GetAgents()):
                Wildlife.Despawn(Ender)
        # Finally disable so no new creatures appear.
        Wildlife.Disable()

Gotchas

• SpawnAt is <suspends> and returns ?agent. You cannot call it from a plain (...)void handler directly — wrap it in spawn{ ... } or call it from another <suspends> function. Always unwrap the result with if (Beast := Wildlife.SpawnAt(Pos)?): — it returns false when the spawn limit is reached.
• device_ai_interaction_result.Source and .Target are optional. Events like TamedEvent, RiddenEvent, EliminatedEvent, and DamagedEvent hand you a result whose Source/Target must be unwrapped (if (A := Result.Source?):). A non-agent eliminator (e.g. a fall) leaves Source empty.
• SpawnedEvent vs TamedEvent payloads differ. SpawnedEvent/ForceSpawnedEvent/SomethingIsEatenEvent are listenable(agent) — handler signature is (Creature : agent). The interaction events are listenable(device_ai_interaction_result). Mixing the two signatures causes a type error on Subscribe.
• TriggeredEvent gives ?agent, not agent. When piping a trigger into Tame/Ride, unwrap first. Ride and Tame require a non-optional agent.
• message params need localized text. Hud.Show(..., ?Text := ...) won't accept a raw string. Declare a <localizes> helper like ranch_msg<localizes>(S:string):message = "{S}" and pass ranch_msg("...").
• Property changes only affect new spawns. The device docs note that changing its configured properties affects newly spawned creatures only — already-spawned wildlife keep their original settings. Re-Spawn to apply updated config.
• int↔float is not automatic. SpawnAt needs a vector3 of floats; convert ints with Float(I) as shown in the ambush example.
• Tame / RestoreEnergy are per-agent. They act on wildlife belonging to the passed agent. Use the ...ForAll / UntameAll / DismountAll variants when you mean the whole herd.