Count Matching: How Many Racers Passed?

Count array elements matching a condition (racers past checkpoint N).

📖 Reference & full walkthrough: Count Matching: How Many Racers Passed?

🧩 Your capstone piece: Racers-remaining and checkpoint-progress counters

Barnaby the bear has a clipboard problem. Six dirtbikes are tearing through Codewood Grove, and every few seconds someone on the sidelines yells "how many racers made it past the rope bridge?!" Counting by paw takes too long. Counting with a for loop and an if takes one blink — and that is exactly the skill this lesson locks in: walk an array, test each element against a condition, and add 1 every time the test passes.

If you finished the sum-an-array lesson, this will feel familiar. Summing says "add the value to the total." Counting says "add 1 to the total — but only when the element passes a test." Same loop skeleton, one extra if. That tiny difference powers every "racers remaining", "players ready", and "checkpoints cleared" counter you will ever build.

What you will build

A checkpoint_progress_device for Barnaby's Jungle Mod-Rally — the north-jungle capstone. When a trigger_device at a checkpoint fires, the device counts two things from plain []int arrays and flashes them on every screen with a hud_message_device:

• Checkpoint progress — how many racers have passed checkpoint 3 (Zipline Run) or beyond.
• Racers remaining — how many racers have not yet finished all their laps.

These are the exact "racers-remaining and checkpoint-progress counters" the Mod-Rally race manager reads every time a checkpoint fires, so the code you write here drops straight into the capstone.

Walkthrough

The counting pattern

Every count-matching counter has four beats:

1. var Count : int = 0 — start at zero.
2. for (Value : MyArray) — visit every element.
3. if (Value >= Threshold): — the condition. Only elements that pass get counted.
4. set Count += 1 — add one (not the value — this is a headcount, not a treasure tally).

Here is the complete device. Wire the two @editable device references in the UEFN Details panel, drop it on your island, and it compiles and runs as-is.

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

# Localisation helper — HUD messages must be `message`, not raw string.
RallyMessage<localizes>(S : string) : message = "{S}"

checkpoint_progress_device := class(creative_device):

    # ── Editable device references ────────────────────────────────────────
    # Wire this to the trigger_device sensor at the checkpoint.
    @editable
    CheckpointTrigger : trigger_device = trigger_device{}

    # HUD message device set to "All Players" in its properties.
    @editable
    ProgressHUD : hud_message_device = hud_message_device{}

    # ── Race data (the capstone updates these as racers ride) ─────────────
    # Highest checkpoint each racer has passed this lap. Index 0 = racer 1.
    @editable
    RacerCheckpoints : []int = array{3, 1, 4, 2, 4, 0}

    # Laps completed per racer — same racer order as above.
    @editable
    RacerLaps : []int = array{1, 0, 2, 1, 2, 0}

    # The rally is a 3-lap race by default.
    @editable
    TotalLaps : int = 3

    # Which checkpoint we are reporting progress for (3 = Zipline Run).
    @editable
    ReportCheckpoint : int = 3

    # ── The reusable counter ──────────────────────────────────────────────
    # Counts how many values in Values are at least Threshold.
    CountAtLeast(Values : []int, Threshold : int) : int =
        var Count : int = 0
        for (Value : Values):
            if (Value >= Threshold):
                set Count += 1
        Count

    # ── Lifecycle ─────────────────────────────────────────────────────────
    OnBegin<override>()<suspends> : void =
        # When the checkpoint sensor fires, refresh the counters.
        CheckpointTrigger.TriggeredEvent.Subscribe(OnCheckpointPassed)
        # 0.0 keeps the message on screen until we replace it.
        ProgressHUD.SetDisplayTime(0.0)

    # ── Event handler — TriggeredEvent sends ?agent ───────────────────────
    OnCheckpointPassed(MaybeAgent : ?agent) : void =
        # Counter 1: racers at or past the report checkpoint.
        PastCheckpoint : int = CountAtLeast(RacerCheckpoints, ReportCheckpoint)

        # Counter 2: racers remaining — laps still BELOW the total.
        var StillRacing : int = 0
        for (Laps : RacerLaps):
            if (Laps < TotalLaps):
                set StillRacing += 1

        ProgressHUD.Show(RallyMessage("{PastCheckpoint} past checkpoint {ReportCheckpoint} - {StillRacing} racers still in the rally!"))

Line-by-line explanation

With the sample arrays: CountAtLeast(RacerCheckpoints, 3) returns 3 (the values 3, 4 and 4 pass the test), and the remaining-loop returns 6 — nobody has banked all 3 laps yet, so every racer is still in the rally. Run it, tweak the arrays in the Details panel, and watch the numbers move. That instant feedback is the fastest way to make the pattern stick.

Common patterns

Pattern 1 — Count exact matches with =

Sometimes you want "racers on exactly lap 2", not "lap 2 or more". In a condition, Verse compares equality with a single = (it is a failable check, not an assignment):

# Counts racers whose lap counter is exactly TargetLap.
CountOnLap(LapsPerRacer : []int, TargetLap : int) : int =
    var Count : int = 0
    for (Laps : LapsPerRacer):
        if (Laps = TargetLap):
            set Count += 1
    Count

Handy for a "3 riders battling on lap 2!" commentary line. Use <> if you ever need "not equal".

Pattern 2 — Compound conditions with and

Conditions can stack. This counter finds racers closing in on the finish: on their final lap and already past the halfway checkpoint:

# Racers on their last lap who have passed the halfway checkpoint.
CountClosingIn(LapsPerRacer : []int, Checkpoints : []int, FinalLap : int, HalfwayPoint : int) : int =
    var Count : int = 0
    for (Index -> Laps : LapsPerRacer):
        if (Laps >= FinalLap - 1 and Checkpoints[Index] >= HalfwayPoint):
            set Count += 1
    Count

The Index -> Laps form gives you the position too, so you can look up the same racer in a second array — both conditions must succeed before the count bumps. (Array indexing Checkpoints[Index] is failable, which is fine: it just becomes part of the condition.)

Where this goes next

• Next lesson — filter-an-array: counting tells you how many passed the test; filtering hands you the elements themselves. Same loop, but you build a new array instead of bumping a counter.
• The capstone — Barnaby's Jungle Mod-Rally: the race manager imports exactly this piece. CountAtLeast drives the checkpoint-progress HUD line after every CheckpointPassedEvent, and the racers-remaining loop (with laps < TotalLaps) decides when the rally flips its race_phase state machine to Finished. When you reach the maps lesson, the []int arrays upgrade to [player]int maps — but the counting condition you wrote today stays word-for-word the same.