Teleport zwischen Orten

Viele Spiele sind in mehrere Orte unterteilt, wie z.B. eine Fantasiewelt mit Städten, Schlössern, Dungeons und einem riesigen Wald. Verwende TeleportService, um Benutzer zwischen Orten, zu verschiedenen Servern oder sogar zu anderen Spielen zu teleportieren.

Spieler teleportieren

Um Spieler zu teleportieren, verwende TeleportService:TeleportAsync(). Diese Methode akzeptiert drei Parameter:

• Die PlaceId, zu der Benutzer teleportiert werden sollen.
• Ein Array, das die Player-Instanzen enthält, die du teleportieren möchtest.
• Eine optionale TeleportOptions-Instanz, die benutzerdefinierte Eigenschaften für den TeleportAsync()-Aufruf enthält.

local Players = game:GetService("Players")
local TeleportService = game:GetService("TeleportService")

local TARGET_PLACE_ID = 12345678901234 -- ersetze dies durch deine eigene
local playerToTeleport = Players:GetPlayers()[1] -- hole den ersten Benutzer im Spiel

TeleportService:TeleportAsync(TARGET_PLACE_ID, {playerToTeleport})

Um die entsprechenden Spieler für den Teleport zu erhalten, kannst du ein BasePart.Touched oder ein ProximityPrompt.Triggered-Ereignis verwenden, um einen individuellen Player zu erhalten. Dann kannst du überprüfen, ob der Spieler Teil eines Teams (Player.Team) oder einer Gruppe (Player.PartyId) ist. Schließlich kannst du Team:GetPlayers() oder SocialService:GetPlayersByPartyId() verwenden, wenn du die gesamte Gruppe und nicht nur das Individuum teleportieren möchtest.

Sichere Teleportation konfigurieren

Drei Einstellungen regeln die Sicherheit beim Teleportieren.

Zugriffskontrolle für Orte regelt das Teleportieren von Spielern in dein Spiel und ist die kritischste Einstellung zur Verhinderung von Teleport-basierten Exploits.

• Wenn du Vollständig offen wählst, können Spieler jeden Ort in deinem Spiel durch Teleportationen aus jedem Spiel betreten, einschließlich Deep-Links, Spieleinladungen, das Beitreten zu einem Freund usw.

  Dies ist eine gute Wahl, wenn dein Spiel mehrere Orte hat und du möchtest, dass Freunde einander einfach beitreten können, egal an welchem Ort sie sich befinden. Wenn du diese Option nicht wählst, werden Spieler, die versuchen, ihren Freunden in Nicht-Startorten beizutreten, stattdessen den Startort deines Spiels betreten.

• Wenn du Auf dasselbe Universum beschränkt auswählst, können Spieler Nicht-Startorte nur durch Teleportationen innerhalb deiner Spiele betreten. Diese Einstellung erlaubt sowohl clientseitig als auch serverseitig initiierte Teleportationen.

  Dies ist eine gute Wahl, wenn du ein Legacy-Spiel hast, das du nicht zu sicheren Teleportationen migrieren möchtest.

• Wenn du Nur im Universum sicher wählst, können Spieler Nicht-Startorte nur durch serverinitiierte Teleportationen innerhalb dieses Spiels betreten.

  Dies ist eine gute Wahl, wenn dein Spiel ein strenges Fortschrittssystem hat, bevor Spieler auf bestimmte Bereiche zugreifen können. Es ist auch eine gute Wahl, wenn dein Spiel einen Testort hat, auf den Spieler keinen Zugriff haben sollten, oder für Orte, die ausschließlich reservierte Server verwenden.

Zu sicheren Teleportationen migrieren

Wenn du ein bestehendes Spiel hast, das clientseitige Teleportationen verwendet, und serverinitiierte Teleportationen vorschreiben möchtest, besteht das Ziel darin, die gesamte Teleport-Logik von Client-Skripten in Server-Skripte zu verschieben:

1. Finde alle Client-Skripte, die Teleport() aufrufen.
2. Ändere diese Aufrufe, um stattdessen Remote-Events auszulösen. Alternativ kannst du die Aufrufe so ändern, dass du ProximityPrompts, ClickDetectors oder sogar nur das BasePart.Touched-Ereignis verwendest.
3. Implementiere den Teleport in einem Server-Skript mit TeleportAsync().
4. Wenn keine weiteren Teleport()-Aufrufe existieren, ändere die Zugriffskontrolle für Orte auf Sicher.

Benutzerdefinierte Teleport-Bildschirme erstellen

Wenn ein Benutzer einen Teleport auslöst, sieht er den standardmäßigen Roblox-Ladebildschirm, während er auf das Laden des neuen Ortes wartet. Wenn gewünscht, kannst du einen benutzerdefinierten Teleport-Bildschirm hinzufügen, indem du TeleportService:SetTeleportGui() im Client aufrufst.

Das folgende Beispiel setzt eine angepasste ScreenGui aus ReplicatedStorage. Alle Skripte innerhalb der ScreenGui werden nicht ausgeführt.

local TeleportService = game:GetService("TeleportService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local teleportGui = ReplicatedStorage.TeleportGui

TeleportService:SetTeleportGui(teleportGui)

Teleport-Optionen anpassen

Du kannst Teleportationen anpassen, wie z.B. benutzerspezifische Teleportationen zu einem bestimmten Server und Benutzerdaten zusammen mit Teleportationen senden, indem du die TeleportOptions-Instanz festlegst und sie an die Methode TeleportService:TeleportAsync() übergibst.

Zu bestimmten Servern teleportieren

Um Benutzer zu bestimmten Servern zu teleportieren, setze den Zielserver mit TeleportOptions und übergebe ihn an die Methode TeleportAsync(). Wenn du keinen Server angibst, werden Benutzer in einen öffentlichen Server teleportiert; die Informationen des ersten Benutzers in der Liste werden für das Matchmaking verwendet.

Um Benutzer zu einem bestimmten öffentlichen Server zu teleportieren, setze die TeleportOptions.ServerInstanceId-Eigenschaft auf eine gültige Instanz-ID, die ein eindeutiger Bezeichner für einen öffentlichen Server ist.

local teleportOptions = Instance.new("TeleportOptions")
teleportOptions.ServerInstanceId = targetServerId

Um Benutzer zu einem bestimmten reservierten Server zu teleportieren, setze einen gültigen TeleportOptions.ReservedServerAccessCode, der einen eindeutigen Code zum Betreten eines reservierten Servers darstellt.

local teleportOptions = Instance.new("TeleportOptions")
teleportOptions.ReservedServerAccessCode = reservedServerCode

Um Benutzer zu einem neuen reservierten Server zu teleportieren, setze TeleportOptions.ShouldReserveServer auf true.

local teleportOptions = Instance.new("TeleportOptions")
teleportOptions.ShouldReserveServer = true

Benutzerdaten zusammen mit Teleportationen senden

Das Teleportieren eines Benutzers zwischen Orten verwirft alle lokalen Daten, die mit diesem Benutzer verbunden sind. Du kannst folgende Ansätze verwenden, um die Datenpersistenz zwischen Orten zu handhaben:

• Wenn dein Spiel sichere Benutzerdaten wie Währung oder Inventar verwendet, implementiere Daten-Speicher oder Speicherlösungen, um Daten von Ort zu Ort zu erhalten.

• Um grundlegende nicht sichere Daten von Ort zu Ort zu senden, rufe TeleportOptions:SetTeleportData() auf, bevor du sie an TeleportAsync() übergibst. Gib keine sicheren Daten mit dieser Methode weiter; die Daten sind für den Client sichtbar und unverschlüsselt.

local teleportData = {
    randomNumber = RNG:NextInteger(1, 100),
}

local teleportOptions = Instance.new("TeleportOptions")
teleportOptions:SetTeleportData(teleportData)

Um alle Daten abzurufen, wenn ein Benutzer nach einem Teleport im neuen Ort ankommt, verwende die Funktion Player:GetJoinData(), die ein Wörterbuch mit einem TeleportData-Schlüssel zurückgibt.

local Players = game:GetService("Players")

local function onPlayerAdded(player)
    local joinData = player:GetJoinData()
    local teleportData = joinData.TeleportData
    local randomNumber = teleportData.randomNumber

    print(player.Name .. " trat mit der Zahl " .. randomNumber .. " bei")
end

Players.PlayerAdded:Connect(onPlayerAdded)

Um nur die Teleportdaten im Client abzurufen, kannst du TeleportService:GetLocalPlayerTeleportData() verwenden.

Fehlgeschlagene Teleporte behandeln

Wie bei jedem API-Aufruf, der Netzwerkanforderungen beinhaltet, können Teleporte fehlschlagen und einen Fehler auslösen. Schütze sie mit geschützten Aufrufen (pcall()). Einige Fehler profitieren von Wiederholungen, insbesondere solche, die reservierte Server betreffen, daher empfehlen wir, eine bestimmte Anzahl von Wiederholungen im Fehlerfall.

Selbst wenn ein Aufruf erfolgreich ist und der Teleport initiiert wird, kann er dennoch im letzten Moment ohne Fehlermeldung fehlschlagen und den Benutzer auf dem Server lassen. In diesem Fall wird das Ereignis TeleportService.TeleportInitFailed ausgelöst.

Das folgende Beispiel ModuleScript gibt eine einzige Funktion SafeTeleport zurück, die Spieler in einem geschützten Aufruf mit Wiederholungslogik teleportiert. Es hat auch eine Funktion handleFailedTeleport, um mit Situationen umzugehen, in denen der Aufruf erfolgreich war, der Teleport jedoch nicht stattfand.

local TeleportService = game:GetService("TeleportService")

local ATTEMPT_LIMIT = 5
local RETRY_DELAY = 1
local FLOOD_DELAY = 15

local function SafeTeleport(placeId, players, options)
    local attemptIndex = 0
    local success, result -- definiere pcall-Ergebnisse außerhalb der Schleife, damit die Ergebnisse später gemeldet werden können

    repeat
        success, result = pcall(function()
            return TeleportService:TeleportAsync(placeId, players, options) -- teleportiere den Benutzer in einem geschützten Aufruf, um Fehler zu vermeiden
        end)
        attemptIndex += 1
        if not success then
            task.wait(RETRY_DELAY)
        end
    until success or attemptIndex == ATTEMPT_LIMIT -- stoppe den Teleport, wenn der Aufruf erfolgreich war oder das Wiederholungs-Limit erreicht wird

    if not success then
        warn(result) -- drucke den Fehlgrund in die Ausgabe
    end

    return success, result
end

local function handleFailedTeleport(player, teleportResult, errorMessage, targetPlaceId, teleportOptions)
    if teleportResult == Enum.TeleportResult.Flooded then
        task.wait(FLOOD_DELAY)
    elseif teleportResult == Enum.TeleportResult.Failure then
        task.wait(RETRY_DELAY)
    else
        -- wenn der Teleport ungültig ist, melde den Fehler anstelle von Wiederholungen
        error(("Ungültiger Teleport [%s]: %s"):format(teleportResult.Name, errorMessage))
    end

    SafeTeleport(targetPlaceId, {player}, teleportOptions)
end

TeleportService.TeleportInitFailed:Connect(handleFailedTeleport)

return SafeTeleport

Die SafeTeleport-Funktion erhält die gleichen Argumente wie die TeleportAsync()-Funktion. Du kannst das folgende Skript zusammen mit der SafeTeleport-Funktion verwenden, um Teleporte von überall in deinem Spiel aus durchzuführen:

local Players = game:GetService("Players")
local TeleportService = game:GetService("TeleportService")
local ServerScriptService = game:GetService("ServerScriptService")

local SafeTeleport = require(ServerScriptService.SafeTeleport)

local PLACE_TO_TELEPORT_TO = 12345678

local function teleport(touchPart)
    local playerToTeleport = game.Players:GetPlayerFromCharacter(touchPart.Parent)

    if playerToTeleport then
        SafeTeleport(PLACE_TO_TELEPORT_TO, {playerToTeleport})
    end
end

script.Parent.Touched:Connect(teleport)