player_counter_device: Track Players, Trigger Events, Gate Progress

Overview

The player_counter_device solves one of the most common multiplayer design problems: gating progress on player presence. Place the device in your level, set a target count, and it continuously evaluates whether the number of players inside its zone matches that target. When the count succeeds or fails, it signals events your Verse code can subscribe to. You can also query the count at any time, adjust the target dynamically, register specific players manually, and show or hide an in-world info panel so players always know how many more teammates they need.

Reach for it when you need to:

• Lock a door, barrier, or cinematic until N players are present.
• Scale enemy waves or loot drops based on current player count.
• Build a lobby "ready check" that waits for a full squad.
• Track which specific agents are inside a zone at any moment.

API Reference

player_counter_device

Used to track and react to how many players are in a particular area, and optionally display that information in game.

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

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

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Scenario — The Vault Door: Four players must stand on a pressure pad simultaneously to open a vault door (represented by a barrier_device). An info panel shows the current vs. required count. When the count succeeds the barrier disables; when players leave and the count drops, the barrier re-enables.

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

vault_manager := class(creative_device):

    # ── Editable device references ──────────────────────────────────────
    @editable
    PressurePadCounter : player_counter_device = player_counter_device{}

    @editable
    VaultDoor : barrier_device = barrier_device{}

    # ── Lifecycle ───────────────────────────────────────────────────────
    OnBegin<override>()<suspends> : void =
        # Require exactly 4 players on the pad to open the vault.
        PressurePadCounter.SetTargetCount(4)

        # Show the in-world info panel so players can see "2 / 4" etc.
        PressurePadCounter.ShowInfoPanel()

        # Subscribe to the four key events.
        PressurePadCounter.CountSucceedsEvent.Subscribe(OnCountSucceeds)
        PressurePadCounter.CountFailsEvent.Subscribe(OnCountFails)
        PressurePadCounter.CountedEvent.Subscribe(OnPlayerCounted)
        PressurePadCounter.RemovedEvent.Subscribe(OnPlayerRemoved)

        # Force an immediate evaluation in case players are already inside.
        PressurePadCounter.CompareToTarget()

    # ── Event handlers ──────────────────────────────────────────────────

    # CountSucceedsEvent fires with a tuple() — no payload to unwrap.
    OnCountSucceeds(Unused : tuple()) : void =
        # Enough players are on the pad — open the vault!
        VaultDoor.Disable()
        Print("Vault unlocked!")

    # CountFailsEvent fires when the count no longer matches the target.
    OnCountFails(Unused : tuple()) : void =
        # Someone left — re-lock the vault.
        VaultDoor.Enable()
        Print("Vault locked — not enough players.")

    # CountedEvent sends the agent who just entered the zone.
    OnPlayerCounted(Agent : agent) : void =
        Current := PressurePadCounter.GetCount()
        Target  := PressurePadCounter.GetTargetCount()
        Print("Player entered pad. Count: {Current} / {Target}")

    # RemovedEvent sends the agent who left or disconnected.
    OnPlayerRemoved(Agent : agent) : void =
        Current := PressurePadCounter.GetCount()
        Print("Player left pad. Count now: {Current}")

Line-by-line explanation:

Common patterns

Pattern 1 — Dynamic difficulty: raise the target mid-game and query which agents are inside

After the first wave clears, require more players to be on the capture point before the next wave spawns. Also iterate over every currently-counted agent to apply a buff.

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

wave_scaler := class(creative_device):

    @editable
    CaptureCounter : player_counter_device = player_counter_device{}

    @editable
    WaveSpawner : spawner_device = spawner_device{}

    OnBegin<override>()<suspends> : void =
        # Start with a target of 2 for wave 1.
        CaptureCounter.SetTargetCount(2)
        CaptureCounter.CountSucceedsEvent.Subscribe(OnCapture)

    OnCapture(Unused : tuple()) : void =
        # Raise the bar for the next wave.
        CaptureCounter.IncrementTargetCount()
        CaptureCounter.IncrementTargetCount()  # +2 each wave

        NewTarget := CaptureCounter.GetTargetCount()
        Print("Next wave requires {NewTarget} players on point.")

        # Inspect every agent currently on the capture point.
        CountedAgents := CaptureCounter.GetCountedAgents()
        for (A : CountedAgents):
            Print("Agent on point — granting wave bonus.")
            # (wire up a grant_device or item_granter_device here)

        WaveSpawner.SpawnAtRandomLocation()

Key APIs used: SetTargetCount, IncrementTargetCount, GetTargetCount, GetCountedAgents, CountSucceedsEvent.

Pattern 2 — VIP registration: only count specific players

In a VIP escort mode, only the VIP player and their two bodyguards should count toward the extraction trigger. Register them manually and use IsCounted to gate a cinematic.

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

vip_extraction := class(creative_device):

    @editable
    ExtractionCounter : player_counter_device = player_counter_device{}

    @editable
    CinematicSequence : cinematic_sequence_device = cinematic_sequence_device{}

    @editable
    VipSpawner : player_spawner_device = player_spawner_device{}

    OnBegin<override>()<suspends> : void =
        # Only 1 player (the VIP) needs to reach extraction.
        ExtractionCounter.SetTargetCount(1)

        # Clear any stale registrations from a previous round.
        ExtractionCounter.UnregisterAll()

        ExtractionCounter.CountSucceedsEvent.Subscribe(OnExtractionSuccess)
        ExtractionCounter.CountFailsEvent.Subscribe(OnExtractionFailed)

        # Simulate registering the VIP when they spawn.
        VipSpawner.SpawnedEvent.Subscribe(OnVipSpawned)

    OnVipSpawned(Agent : agent) : void =
        # Register this specific agent so only they count toward extraction.
        ExtractionCounter.Register(Agent)
        Print("VIP registered with extraction counter.")

    OnExtractionSuccess(Unused : tuple()) : void =
        # Check the VIP is genuinely in the zone before playing the cinematic.
        CountedAgents := ExtractionCounter.GetCountedAgents()
        for (A : CountedAgents):
            if (ExtractionCounter.IsCounted[A]):
                CinematicSequence.Play()
                Print("VIP extracted! Playing outro cinematic.")

    OnExtractionFailed(Unused : tuple()) : void =
        Print("VIP left the extraction zone — hold position!")

Key APIs used: SetTargetCount, UnregisterAll, Register, CountSucceedsEvent, CountFailsEvent, GetCountedAgents, IsCounted.

Pattern 3 — Info panel toggle and passing-test query

A lobby manager shows the info panel while waiting for players, hides it once the game starts, and periodically checks IsPassingTest to decide whether to begin the match.

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

lobby_manager := class(creative_device):

    @editable
    LobbyCounter : player_counter_device = player_counter_device{}

    @editable
    GameStartSequence : cinematic_sequence_device = cinematic_sequence_device{}

    OnBegin<override>()<suspends> : void =
        LobbyCounter.SetTargetCount(4)
        LobbyCounter.ShowInfoPanel()

        # Poll every 3 seconds until enough players are ready.
        loop:
            Sleep(3.0)
            # Force a fresh comparison so events fire if state changed.
            LobbyCounter.CompareToTarget()

            if (LobbyCounter.IsPassingTest[]):
                # Enough players — hide the panel and start the game.
                LobbyCounter.HideInfoPanel()
                LobbyCounter.Disable()   # Stop counting; game is live.
                GameStartSequence.Play()
                break
            else:
                Current := LobbyCounter.GetCount()
                Target  := LobbyCounter.GetTargetCount()
                Print("Waiting: {Current} / {Target} players in lobby.")

Key APIs used: SetTargetCount, ShowInfoPanel, CompareToTarget, IsPassingTest, GetCount, GetTargetCount, HideInfoPanel, Disable.

Gotchas

1. CountSucceedsEvent and CountFailsEvent carry tuple(), not agent

These two events have the signature listenable(tuple()). Your handler must accept (Unused : tuple()). A common mistake is writing (Agent : agent) — that won't compile. Only CountedEvent and RemovedEvent carry an agent.

2. CountedEvent sends agent directly — no option unwrap needed

Unlike some device events that send ?agent, CountedEvent and RemovedEvent send a plain agent. Do not write if (A := Agent?) — just use Agent directly in the handler body.

3. IsPassingTest[] and IsCounted[] are failable — call inside if

Both methods are marked <decides>, meaning they can fail. Always call them inside an if expression:

if (LobbyCounter.IsPassingTest[]):
    # safe to proceed

Calling them bare (outside if) is a compile error.

4. IsShowingInfoPanel[] is also <decides>

Same rule applies: wrap in if (Counter.IsShowingInfoPanel[]): before branching on it.

5. CompareToTarget() is not automatic

The device evaluates on a configurable tick frequency set in the editor. If you need an immediate evaluation — for example, right after calling SetTargetCount or IncrementTargetCount — call CompareToTarget() explicitly. Both IncrementTargetCount and DecrementTargetCount do trigger an immediate comparison, but SetTargetCount also does — check your editor settings to avoid double-firing.

6. Register / Unregister behaviour depends on the editor setting

The Track Registered Players option in the device's editor settings controls whether registered players are unioned, intersected, or differenced with the zone-tracked players. Calling Register(Agent) in Verse without configuring this setting first may produce surprising count results.

7. GetCountedAgents() is <reads> — avoid in <transacts> contexts

GetCountedAgents is marked <reads>, which means it can observe mutable state. It cannot be called from a <transacts>-only context. Call it from a regular (suspending or non-transacting) function.

8. Disable() stops counting — don't forget to Enable() again

Calling Disable() freezes the device: no new players are counted and no events fire. If your game has rounds, call Enable() at the start of each round and UnregisterAll() to reset the registered list.