wilds_plant_device: Explosive Pods That Launch and Detonate

Overview

The wilds_plant_device represents one of the explosive plant pods from the Wilds biome. Out of the box players can interact with it: it grows, launches projectiles, and explodes. Where it gets interesting is when you drive it from Verse — turning a decorative jungle prop into a scripted hazard or puzzle piece.

Reach for this device when you want:

• A trap room where stepping on a plate detonates a row of plants.
• A timed jungle gauntlet where plants regrow on a schedule, so players must keep moving.
• A scoring hook that rewards whichever player launched a projectile from the plant.

The device exposes three events — GrowEvent, LaunchEvent, and ExplodeEvent — and six methods: Enable, Disable, Grow, Explode, SetInfiniteRegrowths, and SetMaximumRegrowths. Crucially, the Grow and Explode methods only do anything while the device is enabled, and regrowth is governed by the infinite/maximum-regrowth settings.

API Reference

wilds_plant_device

Used to create plants with explosive pods that players can detonate and launch.

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

wilds_plant_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 jungle trap arena. A trigger (think of it as a pressure plate near the plant) tells the plant to grow when stepped on. When a player launches the plant's projectile, we award them a point. When the plant explodes, we re-grow it after a short delay so the trap resets. We cap the plant at 5 regrowths so it eventually goes dormant.

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

jungle_trap_arena := class(creative_device):

    # The explosive plant we are scripting.
    @editable
    Plant : wilds_plant_device = wilds_plant_device{}

    # A pressure-plate style trigger placed near the plant.
    @editable
    Plate : trigger_device = trigger_device{}

    # Tracks total launches for a simple score readout.
    var Launches : int = 0

    OnBegin<override>()<suspends>:void =
        # Enable the device so Grow/Explode actually work.
        Plant.Enable()

        # Allow up to 5 regrowths, then the plant stays dormant.
        Plant.SetInfiniteRegrowths(false)
        Plant.SetMaximumRegrowths(5)

        # React to the plant's lifecycle events.
        Plant.GrowEvent.Subscribe(OnGrow)
        Plant.LaunchEvent.Subscribe(OnLaunch)
        Plant.ExplodeEvent.Subscribe(OnExplode)

        # When a player steps on the plate, grow the plant.
        Plate.TriggeredEvent.Subscribe(OnPlateStepped)

    # Plate handler: a trigger_device sends ?agent.
    OnPlateStepped(MaybeAgent : ?agent):void =
        Print("Plate stepped — growing the plant")
        Plant.Grow()

    # GrowEvent carries no payload (tuple()).
    OnGrow():void =
        Print("The plant has grown and is ready to launch")

    # LaunchEvent sends the agent who triggered it (or false).
    OnLaunch(MaybeAgent : ?agent):void =
        if (Agent := MaybeAgent?):
            set Launches += 1
            Print("Player launched a projectile! Total launches: {Launches}")

    # ExplodeEvent sends the agent who caused the blast (or false).
    OnExplode(MaybeAgent : ?agent):void =
        if (Agent := MaybeAgent?):
            Print("Plant exploded by a player")
        else:
            Print("Plant exploded with no instigator")
        # Reset the trap after a short delay.
        spawn { ResetTrap() }

    ResetTrap()<suspends>:void =
        Sleep(3.0)
        Plant.Grow()

Line by line:

• @editable Plant : wilds_plant_device = wilds_plant_device{} declares the field you bind to the placed plant in UEFN. You must declare it as an @editable field — calling a bare wilds_plant_device{}.Grow() would fail.
• Plant.Enable() switches the device on. Without this, Grow() and Explode() silently do nothing.
• SetInfiniteRegrowths(false) plus SetMaximumRegrowths(5) together cap the plant at five regrowths across the whole match.
• The three Subscribe calls wire the device's events to our methods. Event handlers are methods at class scope.
• OnPlateStepped runs when the trigger fires; it calls Plant.Grow() to make the plant come back.
• OnGrow() takes no parameters because GrowEvent is listenable(tuple()).
• OnLaunch and OnExplode each receive a ?agent; we unwrap with if (Agent := MaybeAgent?) before using it.
• ResetTrap is a suspending helper spawned from OnExplode so it can Sleep without blocking the event handler.

Common patterns

Detonate the whole field on demand

Disable interaction during a cutscene, then Explode every plant at once when the scene ends.

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

field_detonator := class(creative_device):

    @editable
    Plant : wilds_plant_device = wilds_plant_device{}

    @editable
    DetonateButton : button_device = button_device{}

    OnBegin<override>()<suspends>:void =
        Plant.Enable()
        # Pressing the button detonates the plant.
        DetonateButton.InteractedWithEvent.Subscribe(OnPressed)

    OnPressed(Agent : agent):void =
        # Explode only does something while the device is enabled.
        Plant.Explode()

Endless hazard with infinite regrowths

For a survival mode, let the plant always come back and re-grow it the moment it explodes.

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

endless_hazard := class(creative_device):

    @editable
    Plant : wilds_plant_device = wilds_plant_device{}

    OnBegin<override>()<suspends>:void =
        Plant.Enable()
        # Never run out of regrowths.
        Plant.SetInfiniteRegrowths(true)
        Plant.ExplodeEvent.Subscribe(OnExplode)
        # Kick off the first growth.
        Plant.Grow()

    OnExplode(MaybeAgent : ?agent):void =
        # Immediately regrow so the hazard is always live.
        Plant.Grow()

Disable the plant when a round ends

Wire a round-end trigger to Disable so players can't keep launching pods between rounds.

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

round_controller := class(creative_device):

    @editable
    Plant : wilds_plant_device = wilds_plant_device{}

    @editable
    RoundEnd : trigger_device = trigger_device{}

    OnBegin<override>()<suspends>:void =
        Plant.Enable()
        RoundEnd.TriggeredEvent.Subscribe(OnRoundEnd)

    OnRoundEnd(MaybeAgent : ?agent):void =
        # Prevent further interaction and growth.
        Plant.Disable()

Gotchas

• Enable before you Grow/Explode. Both Grow() and Explode() are no-ops while the device is disabled. Call Plant.Enable() in OnBegin (or whenever you turn it on) first.
• GrowEvent has no agent. It's listenable(tuple()), so its handler takes no parameters: OnGrow():void =. Don't try to unwrap an agent there.
• LaunchEvent and ExplodeEvent send ?agent, and it can be false. Always unwrap with if (Agent := MaybeAgent?): and handle the no-instigator case — environmental explosions arrive with no agent.
• Regrowth caps are lifetime-wide. SetMaximumRegrowths applies across the device's entire lifetime and is unaffected by Enable/Disable. Disabling and re-enabling will not refresh the regrowth budget. The value is also clamped, so very large numbers may be reduced.
• SetInfiniteRegrowths(true) overrides the maximum. If infinite regrowths is on, SetMaximumRegrowths has no practical effect.
• Bind the @editable field in UEFN. A declared-but-unbound device field points at nothing; pick your placed plant in the Details panel after building, or events never fire.
• Sleep needs a suspends context. You can't Sleep directly inside a non-suspending event handler — spawn a small <suspends> helper (as in the walkthrough's ResetTrap).