fort_character & character_device: Bring Your Cove to Life

Overview

Fortnite's character system splits into two distinct concepts that work together beautifully:

fort_character is the interface that represents any living character in the world — a player, an NPC, anything that can jump, crouch, sprint, take damage, and be eliminated. You get a fort_character reference by calling .GetFortCharacter[] on an agent (the player type that events hand you). From there you can query state (IsOnGround, IsCrouching), listen to events (JumpedEvent, EliminatedEvent), and read spatial data (GetViewLocation).

character_device is the placed Creative device — the interactive mannequin you drag onto your island in UEFN. It fires InteractedWithEvent when a player walks up and presses the interact button, and exposes methods like PlayEmote, Show, Hide, Enable, and Disable so you can script its behaviour entirely from Verse.

trigger_device is the trusty relay device you'll use alongside both: a pressure plate on the dock that fires TriggeredEvent when a player steps on it, letting you chain reactions without needing a button press.

When to reach for these:

• You want a dockside NPC to wave when a player approaches → trigger_device + character_device.PlayEmote
• You want to hide the mannequin until the player is actually on the ground (not gliding in) → fort_character.IsOnGround check inside the handler
• You want the mannequin to vanish after the player interacts with it → character_device.InteractedWithEvent + character_device.Hide
• You want to limit how many times the dock scene can replay → trigger_device.SetMaxTriggerCount

API Reference

fort_character

Main API implemented by Fortnite characters.

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

fort_character<native><public> := interface<unique><epic_internal>(positional, healable, healthful, damageable, shieldable, game_action_instigator, game_action_causer):

character_device

Used to configure a single interactive mannequin, that can visualize characters, clothing, and perform emotes.

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

character_device<public> := class<concrete>(creative_device_base):

Events (subscribe a handler to react):

Methods (call these to make the device act):

trigger_device

Used to relay events to other linked devices.

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

trigger_device<public> := class<concrete><final>(trigger_base_device):

Events (subscribe a handler to react):

Methods (call these to make the device act):

player

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

player<native><public> := class<unique><persistent><module_scoped_var_weak_map_key><epic_internal>(agent):

Walkthrough

Scenario: The Cove Lookout

You've built a sun-drenched cove with a wooden dock. A pirate mannequin (character_device) stands at the end of the dock. When a player steps onto a pressure-plate trigger (trigger_device) at the dock entrance, the mannequin plays its emote — but only if the player is actually standing on the ground (not gliding in from above). After the player walks up and interacts with the mannequin directly, it hides itself so the dock feels "visited". The trigger is limited to three activations total so the scene doesn't loop forever.

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

# Place this device on your island alongside a trigger_device and a character_device.
cove_lookout_manager := class(creative_device):

    # The pressure-plate trigger at the entrance to the dock.
    @editable
    DockTrigger : trigger_device = trigger_device{}

    # The pirate mannequin standing at the end of the dock.
    @editable
    PirateMannequin : character_device = character_device{}

    OnBegin<override>()<suspends> : void =
        # Limit the dock scene to 3 replays total.
        DockTrigger.SetMaxTriggerCount(3)

        # Subscribe to the pressure plate — fires when any agent steps on it.
        DockTrigger.TriggeredEvent.Subscribe(OnDockTriggered)

        # Subscribe to the mannequin's interact button — fires when a player
        # walks up and presses Interact.
        PirateMannequin.InteractedWithEvent.Subscribe(OnMannequinInteracted)

    # Called when a player (or nothing) steps on the dock pressure plate.
    # TriggeredEvent sends ?agent, so we unwrap carefully.
    OnDockTriggered(MaybeAgent : ?agent) : void =
        if (A := MaybeAgent?):
            # Get the fort_character for this agent so we can query state.
            if (FC := A.GetFortCharacter[]):
                # Only play the emote if the player is standing on solid ground
                # (not gliding in from the clifftop above the cove).
                if (FC.IsOnGround[]):
                    PirateMannequin.PlayEmote()

    # Called when a player presses Interact on the mannequin.
    # InteractedWithEvent sends agent (not optional).
    OnMannequinInteracted(A : agent) : void =
        # Hide the mannequin — the dock has been "visited".
        PirateMannequin.Hide()
        # Also disable the trigger so it stops counting down.
        DockTrigger.Disable()

Line-by-line explanation:

Common patterns

Pattern 1 — Show the mannequin only when the round starts, hide it between rounds

Use Show / Hide and Enable / Disable to gate the mannequin behind game state.

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

dock_round_gate := class(creative_device):

    # The pirate mannequin on the lagoon dock.
    @editable
    LagoonMannequin : character_device = character_device{}

    # A trigger wired to a "Round Start" channel in UEFN.
    @editable
    RoundStartTrigger : trigger_device = trigger_device{}

    # A trigger wired to a "Round End" channel in UEFN.
    @editable
    RoundEndTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        # Start hidden and disabled — players can't see or interact with it yet.
        LagoonMannequin.Hide()
        LagoonMannequin.Disable()

        RoundStartTrigger.TriggeredEvent.Subscribe(OnRoundStart)
        RoundEndTrigger.TriggeredEvent.Subscribe(OnRoundEnd)

    OnRoundStart(MaybeAgent : ?agent) : void =
        # Reveal and enable the mannequin when the round begins.
        LagoonMannequin.Show()
        LagoonMannequin.Enable()

    OnRoundEnd(MaybeAgent : ?agent) : void =
        # Hide and disable again between rounds.
        LagoonMannequin.Hide()
        LagoonMannequin.Disable()

Pattern 2 — Read trigger timing values and adjust the reset delay at runtime

Use GetResetDelay / SetResetDelay and GetTriggerCountRemaining to build a dynamic cooldown system on the clifftop signal fire.

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

clifftop_signal_fire := class(creative_device):

    # A trigger representing the signal-fire pressure plate on the clifftop.
    @editable
    SignalTrigger : trigger_device = trigger_device{}

    # The signal-fire mannequin that celebrates each activation.
    @editable
    SignalMannequin : character_device = character_device{}

    OnBegin<override>()<suspends> : void =
        # Allow up to 5 activations, each with a 10-second cooldown.
        SignalTrigger.SetMaxTriggerCount(5)
        SignalTrigger.SetResetDelay(10.0)

        SignalTrigger.TriggeredEvent.Subscribe(OnSignalFired)

    OnSignalFired(MaybeAgent : ?agent) : void =
        # Play the mannequin emote for every activation.
        SignalMannequin.PlayEmote()

        # Read back how many fires remain and the current reset delay.
        Remaining := SignalTrigger.GetTriggerCountRemaining()
        CurrentDelay := SignalTrigger.GetResetDelay()

        # As the signal fire gets used up, slow the cooldown down
        # (the fire is running low on fuel!).
        if (Remaining < 3):
            SignalTrigger.SetResetDelay(CurrentDelay + 5.0)

Pattern 3 — Query fort_character state on interact: only reward grounded, non-crouching players

Combine InteractedWithEvent with fort_character state queries to gate a reward behind a specific pose.

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

pirate_chest_guard := class(creative_device):

    # The chest-guardian mannequin on the pirate ship deck.
    @editable
    ChestGuard : character_device = character_device{}

    # An item granter wired up in UEFN to give the treasure reward.
    @editable
    TreasureGranter : item_granter_device = item_granter_device{}

    OnBegin<override>()<suspends> : void =
        ChestGuard.InteractedWithEvent.Subscribe(OnGuardInteracted)

    OnGuardInteracted(A : agent) : void =
        # Only grant treasure if the player is standing upright on the deck
        # (not crouching to sneak past, not in the air).
        if (FC := A.GetFortCharacter[]):
            if (FC.IsOnGround[]):
                # IsOnGround succeeds — player is standing on the ship deck.
                # Make sure they are NOT crouching (IsCrouching would succeed if crouching).
                if (not FC.IsCrouching[]):
                    TreasureGranter.GrantItem(A)
                    ChestGuard.PlayEmote()

Gotchas

1. TriggeredEvent sends ?agent, InteractedWithEvent sends agent

These two events have different payload types. trigger_device.TriggeredEvent sends ?agent (optional) because the trigger can be fired from Verse code with no player involved. Always unwrap it with if (A := MaybeAgent?): before use. character_device.InteractedWithEvent sends a plain agent — no unwrapping needed, a real player always caused it.

2. GetFortCharacter[] is failable — use [] not ()

Converting an agent to a fort_character uses the failable bracket syntax: A.GetFortCharacter[]. It must live inside an if expression. Writing A.GetFortCharacter() is a compile error.

3. IsOnGround[] and IsCrouching[] are failable — they succeed or fail, they don't return bool

Don't try to store the result of FC.IsOnGround[] in a variable. Use it directly as a condition: if (FC.IsOnGround[]):. To test the negative (player is NOT on the ground), write if (not FC.IsOnGround[]): — the not operator inverts a failable expression.

4. SetMaxTriggerCount clamps between 0 and 20

Passing a value outside [0, 20] is silently clamped. 0 means unlimited. If you want exactly 1 activation (a one-shot dock scene), pass 1.

5. PlayEmote plays whatever emote is configured on the device in UEFN

PlayEmote() takes no arguments — the emote is chosen in the device's Details panel, not in code. If you forget to assign an emote in the editor, the call succeeds but nothing visible happens.

6. Hide vs Disable — they are not the same

Hide() makes the mannequin invisible but it can still be interacted with (and InteractedWithEvent can still fire). Disable() prevents interaction entirely. For a fully "gone" mannequin, call both.

7. All @editable device fields must be assigned in the UEFN Details panel

If you leave an @editable field unassigned (pointing at the default empty device), your Verse code compiles fine but nothing happens at runtime — the methods fire on a dummy device. Always drag your placed devices into the Details panel slots.