בקצרה
למשטח טלפורט שימו Script ב-ServerScriptService, שמאזין לאירוע Touched של המשטח, מוצא את השחקן דרך Players:GetPlayerFromCharacter ומעביר את כל הדמות דרך character:PivotTo() לנקודה ממש לפני משטח היעד, עם הגב אליו, עם זמן המתנה של כמה שניות לכל שחקן, כדי שמשטח היעד לא ישלח אותו מיד בחזרה. כדי לשלוח שחקנים לפלייס אחר במשחק שלכם, קראו ל-TeleportService:TeleportAsync(placeId, { player }) מ-Script של שרת בתוך pcall; זה עובד רק במשחק שפורסם, לא ב-Studio.
- העבירו את כל הדמות דרך
PivotTo. השמה ל-HumanoidRootPart.Positionמרחיקה את הפארט הראשי משאר הגוף, כי כשקובעים Position, Roblox מעדכנת את החיבורים. - תפריט טלפורט צריך לשלוח לשרת את השם של נקודת היעד, לא מיקום. השרת בודק את השם, את זמן ההמתנה ואת כל כלל פתיחה לפני שהוא מעביר מישהו.
TeleportService:Teleport()מיושן ועובד בלקוח. השתמשו ב-TeleportAsyncבשרת, עטפו אותו ב-pcall, נסו שוב וטפלו ב-TeleportInitFailed.
בעמוד הזה
שני סוגי טלפורט
טלפורט במשחק Roblox יכול להיות שלושה דברים: משטח שמעביר אתכם על פני המפה, תפריט של נקודות שאפשר לקפוץ אליהן, או פורטל לשלב אחר. שני הראשונים מעבירים את הדמות בתוך השרת שבו השחקן כבר נמצא. השלישי שולח את השחקן לפלייס אחר במשחק שלכם, שרץ על שרתים משלו. הם משתמשים ב-API שונים, ולכן כדאי לדעת איזה מהם אתם צריכים.
| בתוך אותו שרת | לפלייס אחר במשחק שלכם | |
|---|---|---|
| קריאה | character:PivotTo(cframe) | TeleportService:TeleportAsync(placeId, players) |
| למה | משטחי טלפורט, תפריט טלפורט, העברת שחקנים מהלובי לזירה | פורטלים לשלב אחר, לובי ששולח שחקנים לפלייס נפרד עם מבוך או משחקון |
| איפה זה עובד | Script של שרת | רק Script של שרת. ה-Teleport() בלקוח מיושן. |
| עובד בבדיקת משחק ב-Studio | כן | לא. TeleportService ב-Roblox לא תומך בבדיקת משחק ב-Studio, ולכן בודקים במשחק שפורסם. |
| מה השחקן רואה | קפיצה על פני המפה, שיכולה לקחת עד 2 שניות אם קודם צריך לטעון את האזור הזה | מסך הטעינה של Roblox, ואז הפלייס האחר |
| מטבעות, פריטים ונתונים אחרים | נשארים כמו שהם | Roblox מאפסת את הנתונים המקומיים של השחקן, ולכן כל דבר חשוב צריך להגיע ממאגר נתונים בפלייס האחר |
במדריך הזה כל שלושת הסוגים נמצאים ב-Script שרת אחד, ולכן סט כללים אחד מכסה כל טלפורט במשחק שלכם: השרת מחליט, לכל שחקן יש זמן המתנה משלו, והמכשיר של השחקן רק מודיע לאיזו נקודה הוא היה רוצה להגיע.
| רכיב | איפה הוא נמצא | מה הוא עושה |
|---|---|---|
Folder בשם TeleportPads עם PadA ו-PadB | Workspace | שני משטחים. האטריביוט Destination של כל אחד מציין את המשטח שאליו הוא שולח שחקנים. |
Folder TeleportSpots | Workspace | פארט אחד לכל נקודה ברשימת התפריט. האטריביוט WinsNeeded נועל נקודה. |
Folder PlacePortals | Workspace | פארטים של פורטלים. האטריביוט PlaceId של כל פורטל הוא הפלייס שאליו הוא שולח שחקנים. |
Script Teleporters | ServerScriptService | מנהל את כל שלושת סוגי הטלפורט ויוצר שני רימוטים. המקום היחיד שבו טלפורט יכול לקרות. |
LocalScript TeleportMenu | StarterPlayer > StarterPlayerScripts | מצייר את כפתור Teleport ואת רשימת הנקודות ושולח את השם של הנקודה שהשחקן בחר. |
RemoteFunction בשם GetTeleportSpots ו-RemoteEvent בשם TeleportRequest | ReplicatedStorage (Teleporters יוצר אותם) | הראשון מחזיר לתפריט את רשימת הנקודות. השני מעביר את השם שנבחר לשרת. |
Workspace
TeleportPads Folder new
PadA Part new
PadB Part new
TeleportSpots Folder new
Spawn Part new
Lake Part new
Castle Part new
PlacePortals Folder new
DungeonPortal Part new
ServerScriptService
Teleporters Script new
StarterPlayer
StarterPlayerScripts
TeleportMenu LocalScript new
שלב 1: בנו שני משטחי טלפורט
- ב-Explorer רחפו מעל Workspace, לחצו על כפתור ה-+ והכניסו Folder. קראו לתיקייה
TeleportPads. הסקריפט מחפש בדיוק את השם הזה. - הכניסו לתיקייה שני Part וקראו להם
PadAו-PadB. עשו כל אחד לוח שטוח, למשל 6 על 1 על 6 studs, והציבו אותם על הרצפה במרחק מסוים זה מזה. בחלון Properties סמנו Anchored, השאירו את CanCollide ואת CanTouch מופעלים, וקבעו צבע בוהק וחומר Neon, כדי ששחקנים ישימו לב אליהם. - סמנו את PadA, גללו בחלון Properties עד הפרק Attributes ולחצו על +. הזינו את השם
Destination, בחרו את הסוג String ולחצו על Save, ואז קבעו את הערךPadB. עשו אותו דבר ב-PadB עם הערךPadA. - סובבו כל משטח כך שהפאה הקדמית שלו תפנה לרצפה פנויה. שחקנים מופיעים 3 studs לפני הפאה הקדמית של משטח היעד, עם הגב אליו, ולכן השאירו שם כמה studs של רצפה פנויה. כדי לראות איזו פאה היא הקדמית, לחצו לחיצה ימנית על המשטח ובחרו Show Orientation Indicator: את הפאה הקדמית מסמן קו כחול. סובבו את המשטח בכלי Rotate עד שהקו הזה יצביע לכיוון שאליו שחקנים צריכים ללכת.
שחקנים מגיעים ליד המשטח, ולא עליו, בכוונה. בעמוד של Roblox על debounce מצוין ש-Touched נורה הרבה פעמים ברצף בנגיעה אחת, ולכן שחקן שהופיע ממש על המשטח השני היה מפעיל אותו שוב ברגע שזמן ההמתנה שלו נגמר, ועף בחזרה על פני המפה.
אתם לא מוגבלים לשני משטחים. ה-Destination של משטח יכול לציין כל פארט ב-TeleportPads, ולכן שלושה משטחים יכולים לשלוח שחקנים במעגל. למשטח חד-כיווני כוונו אותו לפארט ב-TeleportPads שאין לו Destination משלו: פארט כזה מקבל שחקנים ולא שולח אף אחד לשום מקום.
שלב 2: הוסיפו את סקריפט הטלפורט
רחפו מעל ServerScriptService, הכניסו Script, קראו לו Teleporters והדביקו בו את הקוד שלמטה. כרגע הוא משרת את המשטחים, ואחרי השלבים הבאים גם את התפריט והפורטלים, ולכן מוסיפים אותו פעם אחת. ההגדרות בהתחלה הן השורות שאתם אמורים לשנות.
-- Script ב-ServerScriptService בשם Teleporters.
-- כל טלפורט מוכרע כאן, בשרת:
-- 1. משטחים: נגיעה בפארט ב-Workspace.TeleportPads מעבירה אתכם לפארט שמצוין
-- באטריביוט Destination שלו.
-- 2. תפריט: ה-LocalScript בשם TeleportMenu מבקש נקודה מ-Workspace.TeleportSpots
-- לפי שם. השרת בודק את השם, את זמן ההמתנה ואת ה-Wins שהנקודה דורשת.
-- 3. פורטלים: נגיעה בפארט ב-Workspace.PlacePortals שולחת אתכם לפלייס
-- מהאטריביוט PlaceId שלו (פלייס אחר של המשחק הזה).
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local TeleportService = game:GetService("TeleportService")
local PAD_COOLDOWN_SECONDS = 2 -- כמה זמן המשטחים מתעלמים משחקן אחרי כל טלפורט
local MENU_COOLDOWN_SECONDS = 3
local PAD_ARRIVAL_GAP = 3 -- studs לפני משטח היעד, כדי ששחקנים יגיעו לידו
local PLACE_ATTEMPTS = 3
local padFolder = workspace:FindFirstChild("TeleportPads")
local spotFolder = workspace:FindFirstChild("TeleportSpots")
local portalFolder = workspace:FindFirstChild("PlacePortals")
-- הסקריפט הזה יוצר בעצמו את שני הרימוטים, ולכן אל תוסיפו אותם ידנית
local getSpots = Instance.new("RemoteFunction")
getSpots.Name = "GetTeleportSpots"
getSpots.Parent = ReplicatedStorage
local teleportRequest = Instance.new("RemoteEvent")
teleportRequest.Name = "TeleportRequest"
teleportRequest.Parent = ReplicatedStorage
local lastTeleport: { [Player]: number } = {}
local warnedPads: { [Instance]: boolean } = {}
local leavingForPlace: { [Player]: boolean } = {}
local function playerFromHit(otherPart: BasePart): Player?
local character = otherPart:FindFirstAncestorOfClass("Model")
return if character then Players:GetPlayerFromCharacter(character) else nil
end
local function onCooldown(player: Player, seconds: number): boolean
return os.clock() - (lastTeleport[player] or -math.huge) < seconds
end
-- באיזה גובה מעל הרצפה נמצא הפארט הראשי של דמות עומדת.
-- הנוסחה מהתיעוד של Roblox על Humanoid.HipHeight (בריגים R6 מתווסף גובה הרגל).
local function rootHeight(character: Model, humanoid: Humanoid, rootPart: BasePart): number
local height = rootPart.Size.Y / 2 + humanoid.HipHeight
if humanoid.RigType == Enum.HumanoidRigType.R6 then
local leg = character:FindFirstChild("Left Leg")
if leg and leg:IsA("BasePart") then
height += leg.Size.Y
end
end
return height
end
local function teleportTo(player: Player, destination: BasePart, besidePad: boolean)
local character = player.Character
local humanoid = character and character:FindFirstChildOfClass("Humanoid")
local rootPart = humanoid and humanoid.RootPart
if not (character and humanoid and rootPart) or humanoid.Health <= 0 then
return
end
lastTeleport[player] = os.clock() -- קובעים לפני ההמתנה, כדי שנגיעה שנייה לא תפעיל טלפורט שני
-- מסתכלים לכיוון שאליו מופנית הפאה הקדמית של נקודת היעד (ישר, בלי הטיה)
local facing = destination.CFrame.LookVector * Vector3.new(1, 0, 1)
if facing.Magnitude < 0.01 then
facing = Vector3.new(0, 0, -1)
end
facing = facing.Unit
-- עומדים על הפאה העליונה שלה: ה-pivot של הדמות הוא הפארט הראשי שלה, ולכן מרימים אותו לגובה עמידה.
-- משטח, לעומת זאת, מציב שחקנים כמה studs לפניו, כי שחקן שעומד
-- על המשטח היה מפעיל אותו שוב בצעד הבא.
local lift = destination.Size.Y / 2 + rootHeight(character, humanoid, rootPart)
local top = destination.Position + destination.CFrame.UpVector * lift
if besidePad then
top += facing * (destination.Size.Z / 2 + PAD_ARRIVAL_GAP)
end
local target = CFrame.lookAlong(top, facing)
-- כש-instance streaming מופעל, קודם טוענים את האזור סביב נקודת היעד (עד 2 שניות)
pcall(function()
player:RequestStreamAroundAsync(target.Position, 2)
end)
if player.Parent == nil or player.Character ~= character or humanoid.Health <= 0 then
return -- יצא, נולד מחדש או מת בזמן שהאזור נטען
end
-- דמות יושבת מרותכת למושב, והזזה שלה הייתה גוררת את המושב איתה.
-- השמדת ה-SeatWeld קודם משחררת את הדמות מהמושב.
local seat = humanoid.SeatPart
if seat then
local seatWeld = seat:FindFirstChild("SeatWeld")
if seatWeld then
seatWeld:Destroy()
end
end
character:PivotTo(target)
-- בהגעה מתחילים את זמן ההמתנה מחדש: הטעינה המוקדמת למעלה יכולה לקחת עד 2 שניות,
-- והמשטח שלידו השחקן הגיע לא אמור לשלוח אותו מיד בחזרה
lastTeleport[player] = os.clock()
player:SetAttribute("MovementCheckSkip", true) -- לסקריפט בדיקת המהירות, אם יש לכם כזה
end
-- 1. משטחים
if padFolder then
for _, pad in padFolder:GetChildren() do
if pad:IsA("BasePart") then
pad.Touched:Connect(function(otherPart: BasePart)
local player = playerFromHit(otherPart)
local destinationName = pad:GetAttribute("Destination")
if not player or typeof(destinationName) ~= "string" or onCooldown(player, PAD_COOLDOWN_SECONDS) then
return
end
local destination = padFolder:FindFirstChild(destinationName)
if destination and destination:IsA("BasePart") then
teleportTo(player, destination, true)
elseif not warnedPads[pad] then
warnedPads[pad] = true -- מזהירים פעם אחת, לא בכל נגיעה
warn(`Teleporters: {pad.Name} points to {destinationName}, which is not a part in TeleportPads`)
end
end)
end
end
end
-- 2. תפריט: רשימת הנקודות, ואז בקשה לפי שם
local function winsOf(player: Player): number
local leaderstats = player:FindFirstChild("leaderstats")
local wins = leaderstats and leaderstats:FindFirstChild("Wins")
return if wins and wins:IsA("IntValue") then wins.Value else 0
end
local function winsNeeded(spot: Instance): number
local value = spot:GetAttribute("WinsNeeded")
return if typeof(value) == "number" then value else 0
end
getSpots.OnServerInvoke = function(_player: Player)
local list = {}
if spotFolder then
for _, spot in spotFolder:GetChildren() do
if spot:IsA("BasePart") then
table.insert(list, { name = spot.Name, winsNeeded = winsNeeded(spot) })
end
end
end
table.sort(list, function(a, b)
if a.winsNeeded ~= b.winsNeeded then
return a.winsNeeded < b.winsNeeded
end
return a.name < b.name -- אותו מספר Wins: לפי סדר האלף-בית, כדי שהסדר אף פעם לא ישתנה
end)
return list
end
teleportRequest.OnServerEvent:Connect(function(player: Player, spotName: unknown)
-- הלקוח שולח רק שם. אף פעם אל תקבלו מהלקוח מיקום או CFrame.
if typeof(spotName) ~= "string" or #spotName > 50 or not spotFolder then
return
end
if onCooldown(player, MENU_COOLDOWN_SECONDS) then
return
end
local spot = spotFolder:FindFirstChild(spotName)
if not (spot and spot:IsA("BasePart")) then
return
end
if winsOf(player) < winsNeeded(spot) then
return -- נעול לשחקן הזה
end
teleportTo(player, spot, false)
end)
-- 3. פורטלים לפלייס אחר של המשחק הזה
local function sendToPlace(player: Player, placeId: number)
if leavingForPlace[player] or onCooldown(player, PAD_COOLDOWN_SECONDS) then
return -- כבר בדרך, או נגע בטלפורט לפני שנייה
end
lastTeleport[player] = os.clock()
if RunService:IsStudio() then
print(`Teleporters: would send {player.Name} to place {placeId}. Place teleports only work in the published game.`)
return
end
leavingForPlace[player] = true
for attempt = 1, PLACE_ATTEMPTS do
local ok, err = pcall(function()
TeleportService:TeleportAsync(placeId, { player })
end)
if ok then
return
end
warn(`Teleporters: teleport attempt {attempt} for {player.Name} failed: {err}`)
task.wait(2)
end
leavingForPlace[player] = nil -- מוותרים; נגיעה חדשה בפורטל מנסה שוב
end
-- טלפורט יכול להיכשל גם אחרי שהתחיל. השחקן נשאר כאן ויכול לנסות שוב.
TeleportService.TeleportInitFailed:Connect(function(player: Player, result: Enum.TeleportResult, message: string)
warn(`Teleporters: {player.Name} could not leave ({result.Name}): {message}`)
leavingForPlace[player] = nil
end)
if portalFolder then
for _, portal in portalFolder:GetChildren() do
if portal:IsA("BasePart") then
portal.Touched:Connect(function(otherPart: BasePart)
local player = playerFromHit(otherPart)
local placeId = portal:GetAttribute("PlaceId")
if player and typeof(placeId) == "number" and placeId > 0 then
sendToPlace(player, placeId)
end
end)
end
end
end
Players.PlayerRemoving:Connect(function(player: Player)
lastTeleport[player] = nil
leavingForPlace[player] = nil
end)
Teleporters יוצר בעצמו את ה-RemoteFunction בשם GetTeleportSpots ואת ה-RemoteEvent בשם TeleportRequest, ולכן לא צריך להכניס שום דבר ידנית ל-ReplicatedStorage. הוא מחבר את המשטחים מ-TeleportPads ואת הפורטלים מ-PlacePortals פעם אחת, כשהשרת עולה, ולכן משטחים ופורטלים שנוספו בזמן המשחק לא עושים כלום. אם תיקייה כלשהי חסרה, סוג הטלפורט הזה פשוט כבוי.
| חלק | מה הוא עושה | למה |
|---|---|---|
playerFromHit | מוצא את מודל הדמות שאליו שייך הפארט שנגע, ושואל את Players:GetPlayerFromCharacter של מי היא. | במשטחים נוגעים רגליים, כובעים ופארטים חופשיים. כל מה שאינו חלק מדמות של שחקן מחזיר nil ומתעלמים ממנו. |
onCooldown | משווה את os.clock() לזמן הטלפורט האחרון של השחקן. | זמן המתנה אחד לכל שחקן, ולכן שחקן שעומד ליד משטח אף פעם לא חוסם את האחרים. שום דבר לא מחכה ולא ישן. |
rootHeight | מחשב באיזה גובה מעל הרצפה נמצא הפארט הראשי של דמות עומדת: חצי מגובה הפארט הראשי ועוד ה-HipHeight של ה-Humanoid, ועוד אורך הרגל בריגים R6. | זו הנוסחה מהתיעוד של Roblox על Humanoid.HipHeight. ה-pivot של הדמות הוא הפארט הראשי שלה, ולכן הרמת ה-pivot בגודל הזה מציבה את הרגליים על המשטח, גם באווטארים קטנים, גם בגדולים וגם ב-R6. |
הבדיקות בתחילת teleportTo | יוצא אם לשחקן אין דמות חיה עם פארט ראשי, ומיד אחר כך רושם את הזמן. | בקשת הסטרימינג למטה יכולה לגרום לסקריפט לחכות. אם רושמים את הזמן מראש, אירועי Touched הרבים ברגע הזה לא יפעילו טלפורט שני. |
| נקודת ההגעה | הפאה העליונה של נקודת היעד, מורמת ב-rootHeight, עם כיוון מבט לאן שהפאה הקדמית שלה פונה, בלי הטיה. במשטח הנקודה גם מוזזת 3 studs מהפאה הקדמית שלו. | הדמות מופיעה עומדת, ולא בתוך פארט היעד. ליד משטח הרגליים שלה מתחילות בגובה הפאה העליונה שלו, ולכן היא יורדת לרצפה בעובי המשטח. CFrame.lookAlong בונה CFrame במיקום עם כיוון מבט נתון. |
RequestStreamAroundAsync | מבקש מ-Roblox קודם לשלוח לשחקן הזה את האזור סביב נקודת ההגעה, ומחכה לא יותר מ-2 שניות. | Instance streaming מופעל כברירת מחדל בפלייסים חדשים, ולכן חלק רחוק של המפה עוד לא בהכרח נטען במכשיר של השחקן. Roblox ממליצה על הקריאה הזו בשרת לפני העברת דמות למקום רחוק, אם כי היא לא מבטיחה מה בדיוק יגיע. |
| בדיקה שנייה | אם השחקן יצא, והדמות נולדה מחדש או מתה בזמן ההמתנה, שום דבר לא זז. | השחקן יכול היה לעשות reset או לצאת מהמשחק בזמן שהאזור נטען. גם דוגמת הטעינה המוקדמת של Roblox עצמה בודקת שהדמות עדיין במשחק לפני שמזיזים אותה. |
השורות עם SeatWeld | אם הדמות יושבת, משמיד את ה-Weld שמחזיק אותה על המושב. | Roblox מרתכת דמות יושבת למושב. PivotTo מזיז פארטים על ידי שינוי ה-CFrame שלהם, ובתיעוד של Roblox כתוב שקביעת ה-CFrame של פארט מזיזה גם את הפארטים שמחוברים אליו, ולכן בלי זה המושב וכל מה שמרותך אליו היו מגיעים יחד עם השחקן. השמדת ה-SeatWeld היא הדרך שבה התיעוד של Roblox על Seat מקים דמות מהמושב מתוך סקריפט. |
character:PivotTo(target) | מעביר את כל הדמות, כל האיברים והאביזרים יחד, לנקודת ההגעה. | Roblox קוראת ל-PivotTo הפונקציה העיקרית להזזת מודלים מסקריפטים. |
השורה השנייה עם lastTeleport | מתחיל את זמן ההמתנה מחדש בהגעה. | בקשת הסטרימינג יכולה לקחת עד 2 שניות, כמו זמן ההמתנה של המשטח עצמו, ולכן בלי השורה הזו שחקן יכול היה להגיע עם זמן המתנה שכבר נגמר. |
MovementCheckSkip | קובע אטריביוט על ה-Player אחרי כל העברה. | בדיקת מהירות בשרת הייתה מפרשת את הקפיצה כרמאות. MovementCheck מהמדריך לריצה קורא את האטריביוט הזה ומתחיל למדוד מחדש מהמיקום החדש. בלי סקריפט כזה האטריביוט לא עושה כלום. |
| הגדרה | הערך כאן | מה זה משנה |
|---|---|---|
PAD_COOLDOWN_SECONDS | 2 | כמה זמן המשטחים והפורטלים מתעלמים משחקן אחרי כל טלפורט. |
MENU_COOLDOWN_SECONDS | 3 | המרווח הקצר ביותר בין שני טלפורטים דרך התפריט לאותו שחקן. למשטחים ולתפריט יש שעון משותף לכל שחקן, ולכן גם בקשה מהתפריט בתוך 3 שניות אחרי טלפורט ממשטח נדחית. |
PAD_ARRIVAL_GAP | 3 | כמה studs מהפאה הקדמית של משטח היעד שחקנים מופיעים, כדי שיגיעו ליד המשטח ולא עליו. |
PLACE_ATTEMPTS | 3 | כמה פעמים פורטל מנסה TeleportAsync במרווח של 2 שניות לפני שהוא מוותר. |
לחצו על Play כבר עכשיו ועלו על PadA: תופיעו לפני PadB. התפריט והפורטלים צריכים את שני השלבים הבאים, אבל הסקריפט כבר עובד גם בלעדיהם.
שלב 4: טלפורט לפלייס אחר
פלייס הוא עולם נפרד בתוך המשחק שלכם, עם שרתים משלו: לובי ומבוך, או האב וסט של שלבים. שחקנים עוברים בין פלייסים דרך TeleportService, ו-Roblox מריצה אותו רק במשחק שפורסם, ולכן השלב הזה מסתיים באפליקציית Roblox, לא ב-Studio.
- אם המשחק עוד לא פורסם, בחרו File > Publish. משחקים חדשים, עד שתשיקו אותם, פתוחים רק לכם, לאנשים שנתתם להם גישת Edit ולחברי הקבוצה עם התפקידים המתאימים, ולבדיקה שלכם של טלפורטים זה מספיק.
- צרו פלייס שני: פתחו פלייס חדש מכל תבנית של Studio, בנו את המבוך שלכם, ואז בחרו File > Publish As, לחצו על האריח של המשחק שלכם, בחרו Add as a new place ולחצו על Create.
- העתיקו את ה-ID של הפלייס החדש. פתחו את Asset Manager מתפריט Window או מהלשונית Home, עברו ל-Places In Experience, לחצו לחיצה ימנית על הפלייס ובחרו Copy Asset ID, וזה יעתיק את ה-place ID שלו.
- כשחזרתם לפלייס הראשון, הכניסו ל-Workspace Folder בשם
PlacePortals, ובתוכו Part מעוגן בשםDungeonPortal. הוסיפו אטריביוט מסוג Number בשםPlaceIdוהדביקו את ה-ID כערך שלו. - לחצו על Play וגעו בפורטל. ה-Output מדפיס שורה שמתחילה ב-
Teleporters: would send: ב-Studio הפורטל לא עושה שום דבר נוסף. - פרסמו את המשחק שוב דרך File > Publish, כדי שהפורטל יופיע במשחק שפורסם, ובדקו אותו מאפליקציית Roblox, כמו בשלב 5.
Teleporters קורא ל-TeleportAsync בתוך pcall, עד 3 פעמים עם הפסקה של 2 שניות בין הניסיונות, כי בעמוד של Roblox על טלפורטים כתוב שטלפורטים יכולים להיכשל ולזרוק שגיאה, ומומלץ לנסות שוב. טלפורט יכול גם להתחיל ולהיכשל ברגע האחרון בלי שגיאה, ולהשאיר את השחקן איפה שהיה. למקרה הזה Roblox מפעילה את TeleportInitFailed, והסקריפט מסיר מהשחקן את הדגל "עוזב", ולכן נגיעה חדשה בפורטל מנסה שוב.
כדי להחזיר שחקנים, עשו אותו דבר בפלייס השני: שימו עותק של Teleporters ב-ServerScriptService שלו והוסיפו פורטל שה-PlaceId שלו הוא ה-ID של הפלייס הראשון שלכם, שהועתק מ-Asset Manager באותה דרך.
מי יכול להיכנס לפלייסים האחרים שלכם
תיעוד האבטחה של Roblox מזהיר: ברגע שלקוח נמצא בפלייס אחד של המשחק שלכם, הוא יכול להשתגר לכל פלייס אחר שלו, לא משנה איזה מסלול תכננתם, וכיבוי Direct Access בפלייס מסיר רק את כפתור ה-Join באתר. את זה משנה ההגדרה Access Control for Places בפרק Audience > Access Settings ב-Creator Dashboard:
| הגדרה | מי יכול להיכנס לפלייס שאינו פלייס ההתחלה |
|---|---|
| Fully open | כל אחד, דרך טלפורטים מכל משחק, deep links, הזמנות למשחק והצטרפות לחבר. |
| Limited to same universe | רק שחקנים שמשתגרים מתוך המשחקים שלכם. מותרים טלפורטים גם מהלקוח וגם מהשרת. |
| Secure within universe only | רק שחקנים שסקריפטי השרת שלכם משגרים מתוך המשחק הזה. |
אם שחקנים צריכים להגיע לפלייס רק דרך הפורטל שלכם, למשל למבוך, בחרו Secure within universe only. כל טלפורט במדריך הזה מתחיל בשרת, ולכן הוא ימשיך לעבוד. Roblox גם אומרת שהרבה משחקים לא צריכים טלפורטים מאובטחים, ולכן משחק שכל הפלייסים שלו פתוחים לכולם יכול להשאיר את ההגדרה כמו שהיא.
במה טועים מדריכים ישנים לטלפורט
אם אתם משווים את המדריך הזה לסרטון או לפוסט בפורום, הנה ההבדלים החשובים והסיבה שכל טריק יוצר בעיה.
| מדריך | הבעיה | המדריך הזה |
|---|---|---|
קובע hit.Parent.HumanoidRootPart.Position = target.Position | בתיעוד של Roblox כתוב שקביעת Position מעדכנת את החיבורים של הפארט, והוא זז ביחס לפארטים שהוא מחובר אליהם: הפארט הראשי נוסע בלי הגוף. | מעביר את כל הדמות דרך PivotTo. |
קובע HumanoidRootPart.CFrame = target.CFrame | אמצע הדמות נמצא באמצע פארט היעד, חלקית בתוכו, ומקבל את ההטיה של הפארט. | הדמות מופיעה בגובה עמידה מעל הפאה העליונה, ליד המשטח, בלי הטיה. |
משתמש במשתנה debounce אחד לכל המשטח | בזמן ששחקן אחד משתגר, המשטח מתעלם מכל השאר. ובלי debounce בכלל, שחקן שהופיע על המשטח השני נשלח מיד בחזרה. | זמן המתנה אחד לכל שחקן, שנרשם לפני כל המתנה, ושחקנים מופיעים ליד המשטח. |
קורא ל-TeleportService:Teleport(placeId, player) מ-LocalScript | Roblox מסמנת את Teleport() כמיושן, ממליצה לא להשתמש בו בפרויקטים חדשים ומתירה את TeleportAsync רק מסקריפטי שרת. | קורא ל-TeleportAsync בסקריפט שרת. |
אין pcall, אין ניסיונות חוזרים | בעמוד של Roblox על טלפורטים כתוב שהם יכולים להיכשל ולזרוק שגיאה, וגם להיכשל אחרי שכבר התחילו. | עד 3 ניסיונות ב-pcall, ו-TeleportInitFailed מאפשר לשחקן לנסות שוב. |
| מוותר, כי ב-Studio זה "לא עובד" | TeleportService לא תומך בבדיקת משחק ב-Studio. | RunService:IsStudio() במקום זה מדפיס מה הפורטל היה עושה. |
| GUI טלפורט שהכפתורים שלו שולחים מיקום | רמאי יכול לקרוא לאותו רימוט עם כל מיקום. | הכפתורים שולחים את שם הנקודה, והשרת מחפש אותו. |
| מטבעות מועברים ב-teleport data | Roblox אומרת ש-teleport data גלויים ללקוח ולא מוצפנים. | ממליץ לשמור מטבעות ו-Wins במאגר נתונים ולטעון אותם בפלייס האחר (ראו איך להעביר נתונים לפלייס אחר). |
מה שחקנים יכולים ומה לא יכולים לזייף
הניחו שרמאי שולט בכל מה שבמכשיר שלו: הוא יכול לערוך את TeleportMenu, לקרוא לשני הרימוטים כמה פעמים שירצה עם כל ארגומנט ולהזיז את הדמות שלו. הנה מה שזה נותן לו עם הטלפורט הזה.
| הרמאי מנסה | תוצאה | למה |
|---|---|---|
| לשלוח מיקום או CFrame דרך רימוט התפריט | מתעלמים מזה | TeleportRequest קורא מחרוזת אחת, שם נקודה באורך של עד 50 תווים. כל השאר נזרק. |
| לבקש את Castle בלי 3 Wins | סירוב | השרת קורא את ה-Wins מהעותק שלו של leaderstats. הכפתור האפור הוא רק רמז. |
| לבקש נקודה שלא קיימת | מתעלמים מזה | השרת מחפש את השם ב-TeleportSpots ולא עושה כלום אם אין פארט בשם הזה. |
| לקרוא לרימוט התפריט שוב ושוב | לא יותר מטלפורט אחד דרך התפריט כל 3 שניות | זמן ההמתנה נשמר בשרת, לכל שחקן. |
| להפעיל משטח בלי להתקרב אליו | הוא מגיע למשטח התאום, שאליו ממילא יכול היה ללכת | Roblox מונה שיגור לכל נקודה ומניפולציה של אירועי Touched בין הדברים שלקוח יכול לעשות עם הדמות שלו. |
| להיכנס ישירות לפלייס אחר במשחק שלכם | אפשרי, אם Access Control for Places לא שווה Secure within universe only | ראו מי יכול להיכנס לפלייסים האחרים שלכם. |
| להזיז את הדמות שלו לכל מקום, כולל נקודה נעולה | אפשרי | כל מכשיר שולט בתנועה של הדמות שלו. נקודה נעולה היא נוחות, לא כספת, ולכן בדקו בשרת לפני שנותנים שם משהו בעל ערך. |
השורה האחרונה היא הגבול הכן של כל טלפורט. למשחק תחרותי הוסיפו בדיקת תנועה בשרת, כמו במדריך לריצה. Teleporters כבר קובע את האטריביוט MovementCheckSkip שהבדיקה ההיא קוראת, ולכן הטלפורטים שלו עצמו לא מסומנים כהפרה: בתיעוד האבטחה של Roblox כתוב שמשחקים עם טלפורטים לגיטימיים צריכים בדיוק חריגה כזו בבדיקות התנועה.
שלב 5: בדקו
- לחצו על Play. עלו על PadA: אתם מופיעים ממש לפני PadB, עם הגב אליו. הסתובבו ועלו מיד על PadB: שום דבר לא קורה, כי המשטחים מתעלמים מכם 2 שניות אחרי ההגעה. רדו, חכו 2 שניות ועלו שוב על PadB: אתם מופיעים לפני PadA.
- חכו כמה שניות, ואז לחצו על Teleport בצד השמאלי של המסך. ברשימה רואים את Lake, Spawn ואת "Castle (needs 3 wins)" האפור. בחרו Lake: אתם מופיעים עליה. פתחו את התפריט שוב ובחרו Castle: שום דבר לא קורה, וב-Output שקט.
- תנו לעצמכם 3 Wins (לזה צריך סקריפט leaderstats עם IntValue בשם Wins, למשל מהמדריך לטבלת המובילים). לחצו על המתג Client/Server כדי לעבור ל-Server, מצאו ב-Explorer את
Players, את השם שלכם,leaderstats,Wins, וקבעו את ה-Value שלו ל-3 בחלון Properties. עברו בחזרה ל-Client ופתחו שוב את התפריט: Castle נהיה סגול ומעביר אתכם לשם. - געו ב-DungeonPortal. ה-Output מדפיס שורה שמתחילה ב-
Teleporters: would send, עם השם שלכם וה-place ID. ב-Studio כך זה אמור להיות, והיא מודפסת לא יותר מפעם ב-2 שניות, לא משנה כמה זמן אתם עומדים על הפורטל. - בחרו Server & Clients ברשימה הנפתחת של מצבי הבדיקה, קבעו 2 לקוחות ולחצו על Play. שני השחקנים יכולים להשתמש במשטחים באותו זמן, וזמן ההמתנה של אחד אף פעם לא חוסם את השני.
- עצרו את הבדיקה, פרסמו את המשחק והפעילו אותו מאפליקציית Roblox. געו בפורטל: מופיע מסך הטעינה של Roblox, ואתם בפלייס האחר. אם נשארתם במקום, פתחו את ה-Developer Console במקש F9, העבירו את הלוג לתצוגת Server, שרואים רק בעלי המשחק וחברי קבוצה עם הרשאת עריכה, וחפשו אזהרות
Teleporters:, שבהן מופיעה הסיבה ש-Roblox נתנה.
במהלך השלבים ב-Studio השאירו את חלון ה-Output פתוח (תפריט Window, ואז Output). כש-Teleporters עובד, הוא לא מדפיס כלום חוץ משורת הפורטל משלב 4, ולכן כדאי לקרוא כל אזהרה או שגיאה אדומה. ראו שגיאות נפוצות.
איך להרחיב
טלפורט של קבוצה או פארטי יחד
TeleportAsync מקבל רשימת שחקנים, ולכן פורטל אחד יכול לשלוח קבוצה שלמה לפלייס אחד. העמוד של Roblox על טלפורטים מציע להתחיל מהשחקן שנגע בפורטל: player.Team ו-Team:GetPlayers() לקבוצה, או SocialService:GetPlayersByPartyId() עם player.PartyId לפארטי. העבירו את הרשימה הזו במקום { player } וקבעו את הדגל leavingForPlace לכל שחקן ממנה.
שליחת קבוצה לשרת משלה
כברירת מחדל שחקנים שמשתגרים מגיעים לשרת ציבורי של הפלייס האחר. כדי לשלוח קבוצה לשרת שמור חדש, למשל למשחקון, צרו TeleportOptions, קבעו את ה-ShouldReserveServer שלו ל-true והעבירו אותו כארגומנט שלישי: TeleportService:TeleportAsync(placeId, players, options). Roblox מציינת שבכשלים שקשורים דווקא לשרתים שמורים ניסיונות חוזרים מועילים במיוחד, והסקריפט כבר עושה אותם.
איך להעביר נתונים לפלייס אחר
טלפורט מאפס את כל הנתונים המקומיים של השחקן הזה. ה-teleport data ב-Roblox, שנקבעים דרך TeleportOptions:SetTeleportData() ונקראים בפלייס האחר דרך player:GetJoinData(), גלויים ללקוח ולא מוצפנים, ולכן השתמשו בהם רק לבחירות לא מזיקות, למשל איזו מפה לטעון. מטבעות, Wins ופריטים שמרו במאגר נתונים, כמו במדריך ל-DataStore, וטענו אותם שוב כשהשחקן מגיע לפלייס האחר.
מסך טעינה משלכם
בזמן שטלפורט לפלייס נטען, שחקנים רואים את מסך הטעינה הסטנדרטי של Roblox. כדי להציג מסך משלכם, קראו בלקוח ל-TeleportService:SetTeleportGui() עם ScreenGui, למשל כזה שנמצא ב-ReplicatedStorage. הטלפורטים במדריך הזה מתחילים בשרת, ולכן הלקוח צריך לקרוא לו מראש, למשל ברגע שהשחקן נכנס. Roblox אומרת שצריך לקבוע את המסך מחדש לפני כל טלפורט ושהוא לא משמש לפלייס במשחק אחר. שם גם מצוין שסקריפטים בתוך ה-ScreenGui הזה לא רצים, ולכן עשו אותו סטטי.
טלפורטים של סיבובים וצ׳קפוינטים
מערכת הסיבובים בתחילת כל סיבוב מעבירה את כל השחקנים לזירה עם אותה קריאה ל-PivotTo, והפרק PivotTo או SpawnLocation במדריך לאובי משווה את הגישה הזו לנקודות הלידה של Roblox. אם נקודה צריכה להיפתח רק אחרי סיבוב, מערכת הסיבובים כבר מעניקה Wins, ש-WinsNeeded קורא.
שגיאות נפוצות ופתרונות
פתחו את חלון ה-Output (תפריט Window, ואז Output) לפני שלוחצים על Play. Teleporters מציין את המשטח כש-Destination מצביע לשום מקום, ולכן רוב הבעיות רואים שם.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("GetTeleportSpots")'
TeleportMenu מחכה לרימוט ש-Teleporters יוצר, כלומר Teleporters לא רץ. בדקו שזה Script, לא LocalScript, שהוא נמצא ישירות ב-ServerScriptService, לא מושבת, ושב-Output אין ממנו שגיאה אדומה. המדריך לשגיאות בסקריפטים מסביר את האזהרה הזו בפירוט.
Teleporters: PadA points to PadC, which is not a part in TeleportPads
האטריביוט Destination של המשטח מציין משהו שאינו פארט ישירות בתוך התיקייה TeleportPads. בדקו את האיות ואת האותיות הגדולות בערך האטריביוט ובשם של משטח היעד. האזהרה מופיעה פעם אחת לכל משטח, כששחקן נוגע בו בפעם הראשונה.
אני עולה על המשטח, ושום דבר לא קורה
בדקו שהתיקייה נקראת בדיוק TeleportPads ונמצאת ישירות ב-Workspace כשהמשחק מתחיל, שהאטריביוט Destination של המשטח הוא מסוג String (מתעלמים מאטריביוט מסוג Number), ושעברו 2 שניות מהטלפורט האחרון שלכם. בדקו גם שבמשטח מופעל CanTouch: Roblox אומרת שחיבור Touched לפארט עם CanTouch כבוי זורק שגיאה, והיא עוצרת את הסקריפט.
אני מופיע בתוך קיר או נופל מהקצה
שחקנים מופיעים 3 studs לפני הפאה הקדמית של משטח היעד. לחצו לחיצה ימנית על המשטח, בחרו Show Orientation Indicator וסובבו את המשטח עד שהקו הכחול יצביע על רצפה פנויה. נקודות התפריט מציבות שחקנים מעל הפארט, ולכן השאירו כל נקודה על הרצפה.
הכפתור Castle נשאר אפור אחרי שהרווחתי 3 Wins
הרשימה מצוירת כשפותחים את התפריט, ולכן סגרו את התפריט ופתחו אותו שוב. אם הכפתור עדיין אפור, בדקו שב-leaderstats יש IntValue בשם Wins בדיוק, ושה-Wins השתנו בשרת, ולא רק במצב Client.
הפורטל לא עושה כלום במשחק שפורסם
פתחו את ה-Developer Console במקש F9, העבירו את הלוג לתצוגת Server (רואים אותה רק בעלי המשחק וחברי קבוצה עם הרשאת עריכה, כי Teleporters הוא Script של שרת) וקראו את אזהרות ה-Teleporters:, שבהן מופיעה הסיבה ש-Roblox נתנה. בדקו שהאטריביוט PlaceId של הפורטל הוא מסוג Number ומכיל את ה-ID מ-Asset Manager, ושפרסמתם את הפלייס מחדש אחרי הוספת הפורטל.
לעשות עם RoCode
אם לא בא לכם לבנות את כל זה ביד, RoCode יכול לעשות את זה בפלייס שפתוח אצלכם. RoCode הוא סוכן AI עצמאי ל-Roblox Studio, לא של Roblox: אתם מתארים את הפיצ׳ר בצ׳אט שלו באתר, והפלאגין שלו ל-Studio יוצר את הפארטים והסקריפטים ב-Explorer שלכם, כך שלא צריך להעתיק קוד מחלון הצ׳אט.
תוסיף טלפורטים: משטחים ב-Workspace.TeleportPads ששולחים שחקנים למשטח מהאטריביוט Destination שלהם עם זמן המתנה של 2 שניות, תפריט Teleport לנקודות ב-Workspace.TeleportSpots, שבו Castle דורש 3 Wins עם בדיקה בשרת, ופורטלים ב-Workspace.PlacePortals ששולחים שחקנים לפלייס עם ה-ID מהאטריביוט PlaceId שלהם, עם ניסיונות חוזרים.
- יכול לסרוק את הפלייס שלכם כשהשלב צריך את זה, עם Search Game ו-Search Scripts, כדי להישען על פריטים, רימוטים או קוד שמירה קיימים, ולא להוסיף מערכת שנייה
- יוצר את התיקיות ואת הפארטים של המשטחים עם Create Instance, קובע את המאפיינים שלהם עם Set Property וכותב את Teleporters ואת TeleportMenu עם Create Script
- הוא מונחה לבדוק את הקומפילציה של כל סקריפט שכתב עם Check Script, שמקמפל אותו ב-Studio בלי להריץ
- שולח את השינויים בקבוצות, וכל קבוצה היא נקודת ביטול בהיסטוריה של Studio
טלפורטים בין פלייסים עובדים רק במשחק שפורסם, ולכן בדקו אותם באפליקציית Roblox בעצמכם. עם פלאגין 3.9 ומעלה RoCode יכול להריץ בדיקת משחק קצרה ולקרוא את השגיאות, ועם פלאגין 3.9.15 ומעלה דמות הבדיקה שלו יכולה לעלות על משטחים וללחוץ על כפתורי התפריט, אבל הוא בודק רק את מה שהוא עצמו החליט לבדוק, ולכן עלו על המשטחים ופתחו את התפריט בעצמכם. טלפורט הוא מערכת אחת מתוך הרבה במשחק; יצירת משחק שלם עם RoCode הולכת באותה דרך, מערכת אחת לכל פרומפט. איך RoCode מתחבר ל-Studio.
שאלות נפוצות
איך יוצרים משטח טלפורט ב-Roblox Studio?
תנו לשני פארטים אטריביוט Destination עם השמות זה של זה, ותנו לסקריפט שרת אחד להעביר את מי שנגע במשטח דרך character:PivotTo לנקודה ממש לפני המשטח השני, עם זמן המתנה קצר לכל שחקן. שלב 1 ושלב 2 בונים בדיוק את זה.
למה הטלפורט שלי לא עובד ב-Studio?
משטחים ותפריט עובדים ב-Studio. טלפורטים לפלייס אחר לא: TeleportService ב-Roblox לא תומך בבדיקת משחק ב-Studio, ולכן פרסמו את המשחק ובדקו באפליקציית Roblox. הסקריפט מהמדריך הזה במקום טלפורט מדפיס מה הפורטל היה עושה, כך שאתם עדיין יכולים לבדוק שהוא מופעל.
איך משגרים שחקנים לפלייס אחר במשחק שלי?
הוסיפו פלייס דרך File > Publish As (Add as a new place), העתיקו את ה-place ID שלו מ-Asset Manager וקראו ל-TeleportService:TeleportAsync(placeId, { player }) מ-Script של שרת בתוך pcall, עם ניסיון חוזר בכישלון. שלב 4 מוביל דרך כל זה.
איך יוצרים GUI לטלפורט?
בנו את הכפתורים ב-LocalScript ושלחו לשרת רק את שם הנקודה שהשחקן בחר. השרת מחפש את השם בתיקייה, בודק את זמן ההמתנה ואת כל כלל פתיחה, ואז מעביר את הדמות. אף פעם אל תשלחו מיקום מהלקוח: רמאי יכול לשלוח כל מיקום.
למה הדמות שלי נתקעת או מתפרקת אחרי טלפורט?
השמה ל-Position של הפארט הראשי מזיזה רק את הפארט הזה, בלי הגוף שמחובר אליו, והעתקת ה-CFrame של המשטח מציבה את אמצע הדמות בתוך המשטח. השתמשו ב-character:PivotTo עם נקודה בגובה עמידה מעל הרצפה, שמחושבת מה-HipHeight של ה-Humanoid.
אפשר להעביר מטבעות או פריטים יחד עם טלפורט?
לא בבטחה. Roblox אומרת ש-teleport data גלויים ללקוח ולא מוצפנים, ולכן הם מתאימים למשהו כמו המפה שנבחרה, אבל לא למטבעות. שמרו מטבעות ופריטים במאגר נתונים וטענו אותם בפלייס האחר.
מקורות וקריאה נוספת
- Roblox Creator Docs: Teleport between places (באנגלית). TeleportAsync, בדיקות משחק ב-Studio, Access Control for Places, מסכי טלפורט, teleport data וטלפורטים שנכשלו
- Roblox Creator Docs: TeleportService (באנגלית). Teleport המיושן, TeleportAsync רק בשרת ו-TeleportInitFailed
- Roblox Creator Docs: PVInstance:PivotTo (באנגלית). הפונקציה העיקרית להזזת מודלים מסקריפטים
- Roblox Creator Docs: BasePart.Position (באנגלית). למה קביעת Position בפארט מחובר מזיזה אותו ביחס לאחרים
- Roblox Creator Docs: Humanoid.HipHeight (באנגלית). באיזה גובה נמצא הפארט הראשי של דמות עומדת, לריגים R15 ו-R6
- Roblox Creator Docs: Seat (באנגלית). ה-SeatWeld שמחזיק דמות יושבת, והשמדה שלו כדי להקים את הדמות
- Roblox Creator Docs: Player:RequestStreamAroundAsync (באנגלית). בקשה לאזור לפני שהדמות עוברת לשם, בלי הבטחה למה שיגיע
- Roblox Creator Docs: Streaming techniques and conversion (באנגלית). סטרימינג מקדים לפני טלפורט
- Roblox Creator Docs: Access control and confidentiality (באנגלית). למה לקוחות יכולים להגיע לכל פלייס של המשחק אם הטלפורטים לא מאובטחים
- Roblox Creator Docs: Network ownership, movement validation, and physics (באנגלית). מה לקוח יכול לעשות עם הדמות שלו וחריגות לטלפורטים בבדיקות תנועה
- Roblox Creator Docs: Create and publish games and places (באנגלית). פרסום, מי יכול לפתוח משחק חדש, והוספת פלייס דרך Publish As
- Roblox Creator Docs: Asset Manager (באנגלית). איך מעתיקים place ID
- Roblox Creator Docs: Developer Console (באנגלית). תצוגת Server בלוג ומי רואה אותה
- Roblox Creator Docs: Debounce patterns (באנגלית). למה Touched נורה כמה פעמים בנגיעה אחת
איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.