shooting_range_target_track_device: Moving Targets That Pop, Hop, and Score

Overview

The shooting_range_target_track_device is a pop-up target that lives on a movement track. Think of it as the moving duck in a carnival shooting gallery: it can stand upright (active) or lie flat (inactive), it can hop up and down a little to dodge your aim, and — unlike the plain shooting_range_target_device — it can slide along a rail from one end to the other.

Reach for this device when you want:

• A moving target challenge — drive the target between two points and award players for tagging it.
• A dodging target — make it harder by calling HopUp/HopDown after each hit.
• A timed gallery round — PopUp a wave of targets, ActivateTrack to start them moving, and PopDown survivors when time runs out.
• Bullseye scoring — react differently to a center hit (BullseyeHitEvent) versus a glancing hit (HitEvent).

The non-track sibling shooting_range_target_device shares all the pop/hop methods and hit events but has no track — use it for stationary targets. Everything you learn here applies to both.

Key distinction to remember:

• Track movement (EnableTrackMovement / DisableTrackMovement) is a gate. It only permits or forbids movement — it does not start anything.
• ActivateTrack / DeactivateTrack turns the track on/off as a system.
• MoveToEnd / MoveToStart are what actually send the target sliding.

API Reference

shooting_range_target_track_device

A set of customizable pop up targets that can be hit by players to trigger various events.

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

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

Events (subscribe a handler to react):

Methods (call these to make the device act):

shooting_range_target_device

A single customizable pop up target that can be hit by agents to trigger various events.

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

shooting_range_target_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 complete moving-gallery round. When the game begins we enable the target, pop it upright, turn on the track, and send it sliding toward the end. Each time the player lands a hit we make the target dodge with a hop; a bullseye sends it sliding back to the start as a reward-reset; and a knockdown pops it flat and bounces it home.

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

# A moving shooting-gallery round driven entirely by the track target's real API.
moving_gallery_device := class(creative_device):

    # Drag the placed shooting range target (track) device onto this field in UEFN.
    @editable
    Target : shooting_range_target_track_device = shooting_range_target_track_device{}

    # Tracks which direction the target is currently sliding.
    var MovingToEnd : logic = false

    OnBegin<override>()<suspends>:void =
        # 1. Turn the device on and stand the target upright.
        Target.Enable()
        Target.PopUp()

        # 2. Subscribe to every reaction we care about BEFORE the action starts.
        Target.HitEvent.Subscribe(OnHit)
        Target.BullseyeHitEvent.Subscribe(OnBullseye)
        Target.KnockdownEvent.Subscribe(OnKnockdown)
        Target.HopUpEvent.Subscribe(OnHopUp)

        # 3. Allow the rail to move, switch the track system on,
        #    then actually send the target gliding to the far end.
        Target.EnableTrackMovement()
        Target.ActivateTrack()
        Target.MoveToEnd()
        set MovingToEnd = true

    # Fired on any hit. Make the target dodge by hopping up a little.
    OnHit():void =
        Target.HopUp()

    # A reaction to the hop completing — log-free, we just hop back down
    # after the dodge so the next shot is fair again.
    OnHopUp():void =
        Target.HopDown()

    # A perfect center hit: reward the player by sending the target
    # sliding back the way it came.
    OnBullseye():void =
        if (MovingToEnd?):
            Target.MoveToStart()
            set MovingToEnd = false
        else:
            Target.MoveToEnd()
            set MovingToEnd = true

    # Enough damage to knock it down: lay it flat and send it home.
    OnKnockdown():void =
        Target.PopDown()
        Target.MoveToStart()
        set MovingToEnd = false

Line by line:

• @editable Target : shooting_range_target_track_device = shooting_range_target_track_device{} — declares the field you bind to the placed device in the Details panel. Without this @editable field, calling Target.Enable() fails with Unknown identifier.
• var MovingToEnd : logic = false — a simple bit of state so we know which direction to send the target next.
• In OnBegin, Enable() powers the device and PopUp() raises the target from flat to upright so it can be shot.
• Each .Subscribe(handler) wires a class method to one of the device's events. Note the handlers are methods declared at class scope, exactly as the rules require.
• EnableTrackMovement() opens the gate, ActivateTrack() switches the track system on, and MoveToEnd() is the call that actually makes it slide. All three are needed — skip EnableTrackMovement and the target stays put.
• OnHit calls HopUp() so the target dodges; OnHopUp (fired when the hop completes) calls HopDown() to return it to a fair height.
• OnBullseye flips direction using our MovingToEnd flag — a center hit reverses the slide.
• OnKnockdown flattens the target with PopDown() and sends it back to the start.

Common patterns

Pattern 1 — A timed wave: pop up, then pop down survivors

Use PopUp / PopDown to create rounds. Here the target stands up at the start and lies flat after a delay, whether or not it was hit.

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

timed_wave_device := class(creative_device):

    @editable
    Target : shooting_range_target_track_device = shooting_range_target_track_device{}

    OnBegin<override>()<suspends>:void =
        Target.Enable()
        # Stand the target up to start the wave.
        Target.PopUp()
        # Wait five seconds, then lay it flat to end the wave.
        Sleep(5.0)
        Target.PopDown()

Pattern 2 — Bullseye vs. glancing hit scoring

HitEvent fires on any hit; BullseyeHitEvent only on a center hit. Subscribe to both and react differently. Here a bullseye disables the target (round over) while a normal hit just makes it dodge.

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

scoring_target_device := class(creative_device):

    @editable
    Target : shooting_range_target_device = shooting_range_target_device{}

    OnBegin<override>()<suspends>:void =
        Target.Enable()
        Target.PopUp()
        Target.HitEvent.Subscribe(OnAnyHit)
        Target.BullseyeHitEvent.Subscribe(OnBullseyeHit)

    OnAnyHit():void =
        # Glancing hit — make it dodge.
        Target.HopUp()

    OnBullseyeHit():void =
        # Perfect shot — retire the target.
        Target.Disable()

Pattern 3 — Patrolling target that ping-pongs the rail

Drive the target end-to-end forever by reversing direction every time it pops back up. This pattern uses DeactivateTrack/ActivateTrack together with the move calls.

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

patrol_target_device := class(creative_device):

    @editable
    Target : shooting_range_target_track_device = shooting_range_target_track_device{}

    OnBegin<override>()<suspends>:void =
        Target.Enable()
        Target.PopUp()
        Target.EnableTrackMovement()
        Target.ActivateTrack()
        # Patrol back and forth with a pause at each end.
        loop:
            Target.MoveToEnd()
            Sleep(4.0)
            Target.MoveToStart()
            Sleep(4.0)

Gotchas

• EnableTrackMovement does NOT start movement. It only permits it. You still need ActivateTrack and then MoveToEnd/MoveToStart to make the target actually slide. Likewise DisableTrackMovement freezes the target in place no matter how many move calls you issue.
• Track methods only exist on the track device. shooting_range_target_device has the pop/hop methods and hit events but NO MoveToEnd, ActivateTrack, etc. If your target doesn't move, double-check you placed (and typed your @editable field as) the track variant.
• HopUp/HopDown only work when the target is upright. They move an active target; calling them on a flat (popped-down) target does nothing. Always PopUp() first.
• All these events carry tuple(), not an agent. HitEvent, BullseyeHitEvent, etc. hand your handler an empty tuple — so your handler signature is OnHit():void, with no agent parameter to unwrap. Don't write OnHit(Agent:?agent) for these events; that won't match.
• Subscribe before you act. Wire up your .Subscribe(...) calls in OnBegin before you PopUp/MoveToEnd, or an early hit could fire before a handler is attached.
• You must bind the @editable field in UEFN. The = shooting_range_target_track_device{} default is just a placeholder; drag the actual placed device onto the field in the Details panel or none of your calls will reach hardware.
• Enable() first. A disabled device ignores PopUp, MoveToEnd, and friends. Call Enable() at the top of OnBegin.