Teleport zwischen Orten

Viele Spiele sind in mehrere Orte unterteilt, wie eine Fantasiewelt mit Städten, Burgen, Dungeons und einem weiten 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 die 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 Aufruf von TeleportAsync() 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 zu teleportieren, könntest du ein BasePart.Touched- oder ein ProximityPrompt.Triggered-Ereignis verwenden, um einen einzelnen 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 die Einzelperson teleportieren möchtest.

Sichere Teleportation konfigurieren

Drei Einstellungen regeln die Teleport-Sicherheit.

Zugriffskontrolle für Orte steuert das Teleportieren von Spielern in dein Spiel und ist die kritischste Einstellung zur Verhinderung von teleportationsbasierten 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, dem Beitreten eines Freundes und mehr.

  Dies ist eine gute Wahl, wenn dein Spiel mehrere Orte hat und du möchtest, dass Freunde einander leicht beitreten können, egal in 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 Begrenzt auf dasselbe Universum wählst, können Spieler nur über Teleportationen innerhalb deiner Spiele zu Nicht-Startorten gelangen. Diese Einstellung erlaubt sowohl client- als auch serverinitiierte Teleportationen.

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

• Wenn du Nur innerhalb des Universums sicher wählst, können Spieler nur über serverinitiierte Teleportationen innerhalb dieses Spiels zu Nicht-Startorten gelangen.

  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.

Auf sichere Teleportationen migrieren

Wenn du ein bestehendes Spiel hast, das client-seitige Teleportationen verwendet und serverinitiierte Teleportationen erfordern möchtest, besteht das Ziel darin, die gesamte Teleport-Logik aus 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 ändern, um stattdessen ProximityPrompts, ClickDetectors oder sogar einfach das BasePart.Touched-Ereignis zu verwenden.
3. Implementiere die Teleportation in einem Server-Skript mit TeleportAsync().
4. Wenn keine Teleport()-Aufrufe mehr existieren, ändere die Zugriffskontrolle für Orte auf Sicher.

Benutzerdefinierte Teleportbildschirme 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 Teleportbildschirm hinzufügen, indem du TeleportService:SetTeleportGui() auf dem Client aufrufst.

Das folgende Beispiel setzt ein angepasstes ScreenGui aus ReplicatedStorage. Alle Skripte innerhalb des ScreenGui werden nicht ausgeführt.

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

local teleportGui = ReplicatedStorage.TeleportGui

TeleportService:SetTeleportGui(teleportGui)

Teleportoptionen anpassen

Du kannst Teleportationen anpassen, wie z.B. Benutzer zu einem bestimmten Server teleportieren 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 die 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 Identifikator 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 ein eindeutiger Code für den Zugang zu einem reservierten Server ist.

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 die folgenden Ansätze verwenden, um die Datenpersistenz zwischen Orten zu handhaben:

• Wenn dein Spiel sichere Benutzerdaten wie In-Game-Währung oder Inventar verwendet, implementiere Datenbanken oder Speicher, 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. Übergebe keine sicheren Daten mit dieser Methode; 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 Dictionary 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 auf dem Client abzurufen, kannst du TeleportService:GetLocalPlayerTeleportData() verwenden.

Fehlgeschlagene Teleportationen behandeln

Wie bei jedem API-Aufruf, der Netzwerkanforderungen beinhaltet, können Teleportationen fehlschlagen und einen Fehler auslösen. Umhülle sie in geschützten Aufrufen (pcall()). Einige Fehler profitieren von Wiederholungen, insbesondere solche, die reservierte Server betreffen, daher empfehlen wir, bei einem Fehler eine bestimmte Anzahl von Versuchen zu wiederholen.

Selbst wenn ein Aufruf erfolgreich ist und der Teleport initiiert wird, kann er in letzter Minute ohne Fehlerauslösung fehlschlagen und den Benutzer im Server zurücklassen. Wenn dies geschieht, wird das Ereignis TeleportService.TeleportInitFailed ausgelöst.

Das folgende Beispiel ModuleScript gibt eine einzelne SafeTeleport-Funktion zurück, die Spieler in einem geschützten Aufruf mit Wiederholungslogik teleportiert. Es hat auch eine handleFailedTeleport-Funktion, 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 Versuch, zu teleportieren, wenn der Aufruf erfolgreich war oder das Wiederholungs-Limit erreicht wurde

    if not success then
        warn(result) -- drucke den Grund für das Scheitern 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 anstatt zu wiederholen
        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 Funktion TeleportAsync(). Du kannst das folgende Skript mit der SafeTeleport-Funktion verwenden, um Teleportationen von überall in deinem Spiel 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)