teleporter_device: Instant Travel Between Any Two Points

Overview

A teleporter_device is a customizable rift placed in your UEFN level that moves an agent from one location to another the moment they step in — or the moment your Verse code tells it to. You can:

• React when a player walks into a teleporter (EnterEvent) or pops out the other side (TeleportedEvent).
• Push a specific player through programmatically with Teleport(Agent) or Activate(Agent).
• Enable / Disable the rift on the fly (lock a teleporter until a puzzle is solved).
• Manage linked return trips with ActivateLinkToTarget, DeactivateLinkToTarget, and ResetLinkToTarget — essential for two-way portals and teleporter groups.

Reach for teleporter_device any time you need instant positional travel: escape rooms, boss-arena transitions, multi-floor buildings, or cinematic sequences that end with the player appearing somewhere new.

API Reference

teleporter_device

Customizable rift that allows agents to move instantly between locations. You can use this to move players around your island, or create multi-island experiences with teleporters that take players from one island to another.

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

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

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Scenario: A Locked Vault Door That Opens After a Puzzle

Imagine a heist map. Players start in a lobby. When they collect a key item and step on a pressure plate (trigger), the vault teleporter activates and whisks them into the vault. Once they arrive, the return teleporter's link is activated so they can come back. If they somehow trigger the plate again, ResetLinkToTarget picks a fresh destination from the teleporter group.

This single device wires together Enable, Disable, Teleport, ActivateLinkToTarget, ResetLinkToTarget, EnterEvent, and TeleportedEvent.

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

# Log channel for vault teleporter debug output
vault_log := class(log_channel){}

# Place this device in the level, then assign the editable fields in UEFN.
vault_teleporter_manager := class(creative_device):

    # The teleporter players step into to enter the vault
    @editable
    VaultEntrance : teleporter_device = teleporter_device{}

    # The teleporter inside the vault that returns players to the lobby
    @editable
    VaultExit : teleporter_device = teleporter_device{}

    # A trigger_device the player activates to unlock the vault
    @editable
    PuzzlePlate : trigger_device = trigger_device{}

    # Vault starts locked
    OnBegin<override>()<suspends> : void =
        # Disable the entrance rift until the puzzle is solved
        VaultEntrance.Disable()

        # Subscribe to the puzzle plate — when triggered, unlock the vault
        PuzzlePlate.TriggeredEvent.Subscribe(OnPuzzleSolved)

        # React when a player enters the entrance rift
        VaultEntrance.EnterEvent.Subscribe(OnPlayerEntersVault)

        # React when a player emerges from the exit rift
        VaultExit.TeleportedEvent.Subscribe(OnPlayerExitsVault)

    # Called when the pressure plate fires (handler receives ?agent)
    OnPuzzleSolved(Instigator : ?agent) : void =
        Log("Puzzle solved — vault entrance unlocked!", ?Channel := vault_log)
        VaultEntrance.Enable()

        # Activate the two-way link so VaultExit can return players to VaultEntrance
        VaultEntrance.ActivateLinkToTarget()
        VaultExit.ActivateLinkToTarget()

    # EnterEvent fires BEFORE the player is moved; Agent is a plain agent here
    OnPlayerEntersVault(Agent : agent) : void =
        Log("A player is entering the vault rift!", ?Channel := vault_log)
        # After the puzzle is solved the rift handles movement automatically;
        # you could also call VaultEntrance.Activate(Agent) to force it.

    # TeleportedEvent fires AFTER the player emerges from VaultExit
    OnPlayerExitsVault(Agent : agent) : void =
        Log("A player has left the vault.", ?Channel := vault_log)
        # Pick a new random destination from the teleporter group for variety
        VaultExit.ResetLinkToTarget()
        # Re-lock the entrance so the next puzzle run starts fresh
        VaultEntrance.Disable()
        VaultEntrance.DeactivateLinkToTarget()
        VaultExit.DeactivateLinkToTarget()

Line-by-line breakdown

Common patterns

Pattern 1 — Teleport all players to a boss arena on round start

Use Teleport(Agent) to push every player through a specific teleporter regardless of where they are standing.

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

# Teleports every player to the boss arena when a button is pressed.
boss_arena_starter := class(creative_device):

    # Drop this teleporter inside the boss arena
    @editable
    ArenaEntrance : teleporter_device = teleporter_device{}

    # A button_device the host presses to start the boss round
    @editable
    StartButton : button_device = button_device{}

    OnBegin<override>()<suspends> : void =
        StartButton.InteractedWithEvent.Subscribe(OnStartPressed)

    OnStartPressed(Agent : agent) : void =
        # Pull every player on the island into the arena
        AllPlayers := GetPlayspace().GetPlayers()
        for (P : AllPlayers):
            ArenaEntrance.Teleport(P)

Key point: Teleport(Agent) sends the agent to this device's location. Place ArenaEntrance inside the arena and every player lands there instantly.

Pattern 2 — Activate a teleporter group for a random destination

Activate(Agent) sends the agent to the target group configured in the device's settings panel — great for randomized map sections.

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

# When a player steps on a trigger, send them to a random zone via Activate.
random_zone_sender := class(creative_device):

    # This teleporter's Target Group is set to a group of zone teleporters in UEFN
    @editable
    RandomDispatcher : teleporter_device = teleporter_device{}

    # Trigger the player walks over
    @editable
    ZonePlate : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        ZonePlate.TriggeredEvent.Subscribe(OnZonePlateTriggered)

    OnZonePlateTriggered(MaybeAgent : ?agent) : void =
        # Unwrap the optional agent before using it
        if (A := MaybeAgent?):
            # Activate sends A to whichever teleporter in the group is selected
            RandomDispatcher.Activate(A)
            # Shuffle the destination for the next player
            RandomDispatcher.ResetLinkToTarget()

Key point: Activate respects the device's Target Group setting. ResetLinkToTarget re-rolls the group selection so each player can land somewhere different.

Pattern 3 — Enable / Disable a teleporter based on a team score

Toggle the rift open or shut in response to game events without touching the player at all.

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

# Locks or unlocks a teleporter based on which team controls a capture zone.
capture_zone_gatekeeper := class(creative_device):

    # The rift that leads to the winning team's reward room
    @editable
    RewardTeleporter : teleporter_device = teleporter_device{}

    # A capture area device that signals when Team 1 takes control
    @editable
    CaptureZone : capture_area_device = capture_area_device{}

    OnBegin<override>()<suspends> : void =
        # Start locked — no team controls the zone yet
        RewardTeleporter.Disable()

        CaptureZone.TeamAFullyCapturedEvent.Subscribe(OnTeamCaptured)
        CaptureZone.TeamALostCaptureEvent.Subscribe(OnTeamLostCapture)

    OnTeamCaptured(Index : int) : void =
        # Team 1 now controls the zone — open the reward rift
        RewardTeleporter.Enable()

    OnTeamLostCapture(Index : int) : void =
        # Team 1 lost control — seal the rift again
        RewardTeleporter.Disable()

Key point: Enable / Disable are instant and affect all players simultaneously — no per-agent logic needed.

Gotchas

1. EnterEvent vs TeleportedEvent — timing matters

EnterEvent fires before the player is moved. TeleportedEvent fires after they emerge at the destination. If you need to grant a weapon or play a sound at the destination, subscribe to TeleportedEvent, not EnterEvent.

2. Teleport vs Activate — direction matters

• Teleport(Agent) moves the agent to this device (the one you call it on).
• Activate(Agent) moves the agent from this device to its configured target group.

Mixing these up is the single most common bug with teleporters.

3. Two-way links require ActivateLinkToTarget on both ends

The docs are explicit: both the origin and destination teleporter must call ActivateLinkToTarget() for a return trip to work. Calling it on only one side silently does nothing.

4. trigger_device.TriggeredEvent sends ?agent, not agent

When you chain a trigger to a teleporter, the trigger handler receives (?agent). You must unwrap it before passing to Teleport or Activate:

OnPlateTriggered(MaybeAgent : ?agent) : void =
    if (A := MaybeAgent?):
        MyTeleporter.Teleport(A)

Forgetting the unwrap is a compile error.

5. @editable is mandatory

You cannot write teleporter_device{}.Teleport(Agent) inline — the runtime device only exists when it is declared as an @editable field and wired in the UEFN editor. A bare literal teleporter_device{} is a default-constructed stub with no placed actor behind it.

6. ResetLinkToTarget is non-deterministic in groups

If your teleporter's target is a Teleporter Group, ResetLinkToTarget picks a random eligible member. Do not rely on it selecting a specific destination — use a dedicated teleporter_device reference and call Teleport directly if you need a guaranteed target.