Teleport Player Script Examples for Unity and Unreal

Teleport Player: Quick Guide to Instant Movement in Your GameTeleportation is a common mechanic in many game genres — from fast-paced shooters and platformers to puzzle and role‑playing games. Implementing a reliable and polished teleport system improves gameplay flow, enables creative level design, and helps address performance or network concerns by moving players instantly rather than simulating long traversals. This guide covers design goals, technical approaches for common engines (Unity and Unreal Engine), handling physics and collisions, smoothing and visual feedback, multiplayer considerations, debugging tips, and sample code patterns you can adapt.

Why use teleportation?

Instant travel reduces downtime and can keep players engaged.
Level design tool: teleport pads, portals, warps, and checkpoints expand possibilities.
Gameplay mechanics: stealth escapes, puzzle solutions, and teleport-based combat.
Performance: moving an object instantly can be cheaper than long animations or pathfinding in some cases.

Design considerations

Before coding, decide how teleport fits your game:

Player control: Will teleport be player-initiated (ability, item) or environment-triggered (pad, portal)?
Restrictions: Cooldowns, limited charges, one-way vs. two-way, line-of-sight, or required items.
Safety: Prevent teleporting players inside geometry, through closed doors, or into hazards.
Feedback: Provide clear audiovisual cues so players understand when and where teleport occurs.
Game feel: Instant relocation can feel jarring; consider effects, camera handling, and temporary invulnerability.

Core technical tasks

Locate destination: define a Vector/Transform or calculate target position.
Validate destination: check collisions, navmesh, height, and gameplay rules.
Move player: set position/transform and update physics state appropriately.
Synchronize (multiplayer): update server and clients in a consistent, authoritative manner.
Visual & audio feedback: particle effects, sound, camera shake or fade.

Teleport in Unity

Basic single‑player teleport (character controller / Rigidbody)

For CharacterController: use CharacterController.enabled = false; modify transform.position; re-enable and call SimpleMove/Move as needed.
For Rigidbody (non-kinematic): use Rigidbody.position = targetPos; Rigidbody.velocity = Vector3.zero to avoid carryover momentum.
For Rigidbody (kinematic): set transform.position directly.

Example pattern (Unity C# — CharacterController):

using UnityEngine; public class TeleportPlayer : MonoBehaviour {     public Transform destination;     private CharacterController controller;     void Start()     {         controller = GetComponent<CharacterController>();     }     public void Teleport()     {         if (controller == null || destination == null) return;         controller.enabled = false;         transform.position = destination.position;         controller.enabled = true;     } }

Notes:

Disabling the CharacterController prevents Unity from rejecting the direct transform change.
For Rigidbody-based players, prefer Rigidbody.MovePosition or setting isKinematic temporarily depending on your physics setup.

Collision and navmesh checks

Use Physics.OverlapSphere or CapsuleCast at the destination to ensure there’s space.

If using NavMeshAgent, call Warp(destination) to move the agent without pathing. Example:


Collider[] hits = Physics.OverlapCapsule(headPos, footPos, radius, blockingLayers); if (hits.Length == 0) { agent.Warp(destination.position); }

Smooth teleports and transitions

Fade screen to black, then teleport during the fade, then fade back.
Play a particle burst or teleport animation at origin and destination.
Optionally interpolate camera position for a short duration while hiding the jump with a blur or motion effect.

Teleport in Unreal Engine (Blueprints & C++)

Blueprint approach

Use SetActorLocation to change player Pawn or Character.
For Character with movement component, disable movement when changing location:
- Call DisableInput or SetMovementMode(MOVE_None), then SetActorLocation, then re-enable movement.
Use Sweep flag in SetActorLocation to prevent teleport into geometry; if Sweep returns false, choose a nearby valid location.

C++ approach (Character)

Use ACharacter::TeleportTo(NewLocation, NewRotation) which handles many movement edge cases.

Example:


FVector NewLocation = ...; FRotator NewRotation = ...; ACharacter* MyChar = Cast<ACharacter>(GetPawn()); if (MyChar) { bool bTeleported = MyChar->TeleportTo(NewLocation, NewRotation); }

NavMesh and AI

For AI controlled by AIController and NavMesh, use UNavigationSystemV1::SimpleMoveToLocation or directly call Controller->StopMovement() then SetActorLocation, or use AController::MoveTo with special handling. For navmesh agents, consider using Recast system functions to ensure agents remain valid.

Collision safety and placement strategies

Raycast checks: Raycast down from target to find ground height, ensure you’re not placing player mid-air or inside geometry.
Overlap tests: Physics.OverlapSphere / Capsule to detect blocking colliders before teleporting.
Nearest valid point: If destination blocked, search nearby points in an expanding radius for the closest valid spot (grid or radial sampling).
Use navigation meshes: Project the target point onto the navmesh (Unity NavMesh.SamplePosition) to ensure walkable placement for characters reliant on navmesh.

Example radial search (pseudocode):

radius = 0.5 to maxRadius step increment
for angle in 0..360 step angleStep:
- candidate = target + Vector2(radius * cos(angle), radius * sin(angle))
- if not Overlap(candidate): accept

Visual & audio polish

Entry and exit FX: particles, teleport rings, or shader effects.
Screen fade or blur during teleport to reduce jarring feel.
Sound cues: distinct source for departure and arrival.
Temporary invulnerability with visual indicator to avoid spawn kills on arrival.
Camera handling: if camera follows player, consider smoothing or short fade; if teleport is part of cutscene, control camera explicitly.

Multiplayer considerations

Authority model: Teleport decisions should be validated and executed by the server (authoritative server) to prevent cheating and desync.
Client prediction: if client predicts a teleport, ensure server can accept it or reconcile state changes.
Synchronization: broadcast position update and any teleport-related state (cooldowns, invulnerability windows).
Reconciliation: if server rejects a client-initiated teleport, smoothly correct client position to server-authoritative location to avoid snapping.
Security: validate destination (not inside restricted areas), check cooldowns and resource constraints on server.

Network pattern:

Client requests teleport -> Server validates -> Server sets player location and informs all clients -> Clients play effects on confirmation.

Common pitfalls and fixes

Stuck inside geometry: add overlap checks and fallback placements.
Momentum retention: clear Rigidbody velocity when appropriate or explicitly transfer momentum if intended.
Animation mismatch: reset IK, root motion and movement states after teleport.
Camera clipping: reposition camera or delay camera movement until after teleport.
Teleport spam: enforce cooldowns or resource costs.

Debugging tips

Visualize target points and overlap checks using editor gizmos.
Log server vs client positions after teleport attempts in multiplayer to identify desyncs.
Create a debug mode allowing teleport to ignore collisions so you can see intended targets without interference.
Use slow-motion or frame stepping to inspect physics interactions at the moment of teleport.

Example use cases and variations

Teleport pad: place matching entrance/exit transforms, check exit free, play sync’d effects.
Portal linking: maintain bi-directional links and cool-downs to prevent infinite loops.
Blink ability: short‑range instant dash with line-of-sight checks and slight fade.
Checkpoint respawn: teleport to a saved checkpoint on death with safe placement rules.

Sample checklist before shipping

Validate collisions and fallback placement implemented.
Server-side validation, cooldowns, and anti-cheat checks in multiplayer.
Visual/audio feedback for departure and arrival.
Temporary invulnerability if needed and clearly indicated.
Proper camera behavior and animation state resets.
Unit and integration tests for edge cases (teleport into moving platforms, elevators, during cutscenes).

Teleportation is deceptively simple in concept but requires attention to physics, animation, camera, and networking details to feel right. Start with a minimal safe implementation (validate destination, set position, clear physics state) and layer polish (effects, smoothing, server validation) as you iterate.