TeleportTo & trigger_device: Instant Travel on Your Pirate Island

Overview

The TeleportTo method lives on fort_character and moves a player's character to an exact world-space position and rotation in a single frame — no lerp, no transition screen, just instant relocation. Pair it with a trigger_device (a pressure plate, a zone, or a button relay) and you have the backbone of every escape room exit, fast-travel shrine, and pirate-ship boarding ramp in UEFN.

Reach for this combo when you need:

• Instant player relocation (spawn-room exits, puzzle completions, secret passages)
• Scripted teleport gates that can be enabled/disabled mid-match
• One-time-use portals (limit triggers so only the first player through gets the shortcut)
• Conditional teleports (only warp the player if they're on the ground, not falling off the crow's nest)

API Reference

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):

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):

vector3

3-dimensional vector with float components.

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

vector3<native><public> := struct<concrete><computes><persistable><uht_comparable>:

Walkthrough

Scenario: The Dock Portal → Clifftop Crow's Nest

Your 2D cel-shaded pirate island has a glowing rune circle on the dock. When a player steps into it, they're instantly teleported up to the clifftop crow's nest. The portal is one-use-per-player (it resets after 5 seconds) and disables entirely after 10 total uses so latecomers have to climb the hard way.

Place these devices in your level and wire them up:

• DockTrigger — a trigger_device on the dock (the rune circle)
• CrowsNestTrigger — a second trigger_device at the crow's nest (fires a confirmation effect)

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

# Teleports a player from the dock rune circle to the clifftop crow's nest.
# Place this device anywhere on the island; wire DockTrigger and CrowsNestTrigger
# in the Details panel.
dock_to_crowsnest_teleporter := class(creative_device):

    # The pressure-plate trigger on the dock (the rune circle).
    @editable
    DockTrigger : trigger_device = trigger_device{}

    # A trigger at the crow's nest — fired by code to signal arrival.
    @editable
    CrowsNestTrigger : trigger_device = trigger_device{}

    # World position of the crow's nest landing spot (set via Details panel
    # or hard-coded to match your island layout).
    # X=forward, Y=right, Z=up in Unreal centimetres.
    CrowsNestPosition : vector3 = vector3{X := 0.0, Y := 0.0, Z := 2400.0}

    OnBegin<override>()<suspends> : void =
        # Allow a maximum of 10 total uses, then the portal closes forever.
        DockTrigger.SetMaxTriggerCount(10)

        # After each use the portal is dormant for 5 seconds before it
        # can fire again — stops a single player from spamming it.
        DockTrigger.SetResetDelay(5.0)

        # Subscribe: every time someone steps on the dock rune, call OnDockTriggered.
        DockTrigger.TriggeredEvent.Subscribe(OnDockTriggered)

    # Handler called by TriggeredEvent — note the ?agent parameter.
    OnDockTriggered(MaybeAgent : ?agent) : void =
        # Unwrap the optional agent; bail out if the trigger fired without one.
        if (Agent := MaybeAgent?):
            # Cast the agent to a fort_character so we can call TeleportTo.
            if (Character := Agent.GetFortCharacter[]):
                # Only teleport if the player is standing on the dock,
                # not already falling off a plank.
                if (Character.IsOnGround[]):
                    # Build the destination transform: position at the crow's nest,
                    # identity rotation so the player faces the default direction.
                    DestRotation := MakeRotation(vector3{X:=0.0,Y:=0.0,Z:=1.0}, 0.0)
                    # TeleportTo is failable (<decides>) — wrap in if.
                    if (Character.TeleportTo[CrowsNestPosition, DestRotation]):
                        # Fire the crow's nest trigger to play its linked effects
                        # (particle burst, audio cue wired in the editor).
                        CrowsNestTrigger.Trigger(Agent)

Line-by-line explanation

Common patterns

Pattern 1 — Enable / Disable a portal gate mid-match

The pirate captain's cabin door is locked until the crew completes an objective. A separate game-manager device calls EnableDockPortal() when the objective fires.

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

# A portal that starts disabled and is unlocked by another device calling Enable.
cabin_door_portal := class(creative_device):

    @editable
    CabinTrigger : trigger_device = trigger_device{}

    CabinInteriorPosition : vector3 = vector3{X := 500.0, Y := 0.0, Z := 100.0}

    OnBegin<override>()<suspends> : void =
        # Start locked — no one can use the portal until the objective is done.
        CabinTrigger.Disable()
        CabinTrigger.TriggeredEvent.Subscribe(OnCabinTriggered)

    # Called by an external objective device when the crew wins the puzzle.
    EnableCabinPortal() : void =
        CabinTrigger.Enable()
        # Only one player gets the reward — disable again after a single use.
        CabinTrigger.SetMaxTriggerCount(1)

    OnCabinTriggered(MaybeAgent : ?agent) : void =
        if (Agent := MaybeAgent?):
            if (Character := Agent.GetFortCharacter[]):
                DestRotation := MakeRotation(vector3{X:=0.0,Y:=0.0,Z:=1.0}, 0.0)
                if (Character.TeleportTo[CabinInteriorPosition, DestRotation]):
                    # Lock the door behind them.
                    CabinTrigger.Disable()

Pattern 2 — Query trigger limits at runtime

Display (or act on) how many uses remain on the dock portal — useful for a "3 uses left" UI relay or for switching to a fallback path.

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

# Monitors a portal trigger and disables a backup ladder when the portal
# still has uses remaining.
portal_monitor := class(creative_device):

    @editable
    DockTrigger : trigger_device = trigger_device{}

    # A second trigger that represents the rope-ladder shortcut.
    @editable
    LadderTrigger : trigger_device = trigger_device{}

    OnBegin<override>()<suspends> : void =
        DockTrigger.SetMaxTriggerCount(5)
        DockTrigger.SetResetDelay(3.0)
        DockTrigger.TriggeredEvent.Subscribe(OnPortalUsed)

    OnPortalUsed(MaybeAgent : ?agent) : void =
        Remaining := DockTrigger.GetTriggerCountRemaining()
        MaxCount  := DockTrigger.GetMaxTriggerCount()
        ResetSecs := DockTrigger.GetResetDelay()

        # If the portal is nearly exhausted, open the ladder as a fallback.
        if (Remaining <= 1):
            LadderTrigger.Enable()

        # Optionally act on the agent who just used the portal.
        if (Agent := MaybeAgent?):
            if (Character := Agent.GetFortCharacter[]):
                LandingPos := vector3{X := 0.0, Y := 0.0, Z := 2400.0}
                DestRot := MakeRotation(vector3{X:=0.0,Y:=0.0,Z:=1.0}, 0.0)
                if (Character.TeleportTo[LandingPos, DestRot]):
                    # Trigger a landing-effect relay at the destination.
                    DockTrigger.Trigger()

Pattern 3 — Conditional teleport based on character state

Only teleport a player from the lagoon to the pirate ship if they are currently in water (they swam to the boarding zone, they didn't just walk past it).

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

# Boarding-zone trigger in the lagoon. Only swimmers get teleported aboard.
lagoon_boarding_zone := class(creative_device):

    @editable
    LagoonTrigger : trigger_device = trigger_device{}

    # Position on the pirate ship's main deck.
    ShipDeckPosition : vector3 = vector3{X := 8000.0, Y := 200.0, Z := 350.0}

    OnBegin<override>()<suspends> : void =
        # Unlimited uses, but a 2-second cooldown so the trigger isn't spammed.
        LagoonTrigger.SetMaxTriggerCount(0)
        LagoonTrigger.SetResetDelay(2.0)
        LagoonTrigger.TriggeredEvent.Subscribe(OnLagoonTriggered)

    OnLagoonTriggered(MaybeAgent : ?agent) : void =
        if (Agent := MaybeAgent?):
            if (Character := Agent.GetFortCharacter[]):
                # Guard: only board the ship if the player is in the water.
                if (Character.IsInWater[]):
                    DeckRotation := MakeRotation(vector3{X:=0.0,Y:=0.0,Z:=1.0}, 0.0)
                    if (Character.TeleportTo[ShipDeckPosition, DeckRotation]):
                        # Fire the trigger without an agent to play a splash VFX
                        # relay wired in the editor (no specific agent needed).
                        LagoonTrigger.Trigger()

Gotchas

1. TeleportTo is failable — always wrap it in if

TeleportTo carries <decides>, meaning it can fail (e.g. the destination is inside geometry, the character is no longer active). If you call it bare outside an if, your script won't compile.

# ❌ Won't compile — TeleportTo can fail
Character.TeleportTo[Pos, Rot]

# ✅ Correct
if (Character.TeleportTo[Pos, Rot]):
    # success path

2. TriggeredEvent sends ?agent, not agent

The event payload is optional (?agent). You must unwrap it before passing it to any API that expects a plain agent:

# ❌ Won't compile
OnTriggered(A : agent) : void = ...

# ✅ Correct signature + unwrap
OnTriggered(MaybeAgent : ?agent) : void =
    if (Agent := MaybeAgent?):
        ...

3. GetFortCharacter[] is also failable

Agent.GetFortCharacter[] uses <decides> — it fails for non-player agents (NPCs in some contexts) or if the character has been eliminated. Always nest it inside if.

4. SetMaxTriggerCount clamps to [0, 20]

Passing a value above 20 silently clamps to 20. Use 0 for unlimited. If you need more than 20 lifetime uses, set to 0 and manage your own counter in Verse.

5. SetResetDelay vs SetTransmitDelay

• SetResetDelay — how long before the trigger itself can fire again (player-facing cooldown).
• SetTransmitDelay — how long before the trigger notifies linked editor devices (e.g. a linked emitter). These are independent; setting one does not affect the other.

6. MakeRotation needs a unit-length axis

Always pass a normalised axis vector to MakeRotation. vector3{X:=0.0, Y:=0.0, Z:=1.0} (world-up) gives a yaw-only rotation. Passing a zero vector will produce undefined behaviour.

7. Character state checks (IsOnGround, IsInWater, etc.) are <decides>

Like TeleportTo, these are failable expressions — they succeed when the condition is true and fail otherwise. Use them as conditions inside if, not as boolean assignments:

# ❌ Wrong
OnGround : logic = Character.IsOnGround[]

# ✅ Correct
if (Character.IsOnGround[]):
    ...