מדריך · מערכות משחק

איך ליצור טלפורט ב-Roblox Studio

טלפורט ב-Roblox הוא אחד משניים: העברת הדמות למקום אחר באותו שרת, או שליחת השחקן לפלייס אחר במשחק שלכם. במדריך הזה נבנה את שתי האפשרויות מסקריפט שרת אחד: משטחים ששולחים אתכם למשטח התאום, תפריט Teleport שבו נקודות נעולות נפתחות תמורת Wins, ופורטלים לפלייס אחר שמנסים שוב כשהטלפורט של Roblox נכשל.

עודכן 20 בנובמבר 202618 דק׳ קריאהמאת:

בקצרה

למשטח טלפורט שימו Script ב-ServerScriptService, שמאזין לאירוע Touched של המשטח, מוצא את השחקן דרך Players:GetPlayerFromCharacter ומעביר את כל הדמות דרך character:PivotTo() לנקודה ממש לפני משטח היעד, עם הגב אליו, עם זמן המתנה של כמה שניות לכל שחקן, כדי שמשטח היעד לא ישלח אותו מיד בחזרה. כדי לשלוח שחקנים לפלייס אחר במשחק שלכם, קראו ל-TeleportService:TeleportAsync(placeId, { player }) מ-Script של שרת בתוך pcall; זה עובד רק במשחק שפורסם, לא ב-Studio.

  • העבירו את כל הדמות דרך PivotTo. השמה ל-HumanoidRootPart.Position מרחיקה את הפארט הראשי משאר הגוף, כי כשקובעים Position, Roblox מעדכנת את החיבורים.
  • תפריט טלפורט צריך לשלוח לשרת את השם של נקודת היעד, לא מיקום. השרת בודק את השם, את זמן ההמתנה ואת כל כלל פתיחה לפני שהוא מעביר מישהו.
  • TeleportService:Teleport() מיושן ועובד בלקוח. השתמשו ב-TeleportAsync בשרת, עטפו אותו ב-pcall, נסו שוב וטפלו ב-TeleportInitFailed.
בעמוד הזה
  1. איך זה עובד
  2. 1. משטחים
  3. 2. סקריפט הטלפורט
  4. 3. תפריט טלפורט
  5. 4. פלייסים אחרים
  6. מדריכים ישנים
  7. גבולות ההגנה
  8. 5. בדיקה
  9. הרחבות
  10. Common errors
  11. עם RoCode
  12. שאלות נפוצות
  13. מקורות וקריאה נוספת

שני סוגי טלפורט

איורנגיעה ב-PadA מציבה אתכם ממש לפני PadB, ולכן PadB לא שולח אתכם מיד בחזרה, והשרת מסרב לנקודה הנעולה Castle, אבל מעביר אתכם ל-Lake.

טלפורט במשחק Roblox יכול להיות שלושה דברים: משטח שמעביר אתכם על פני המפה, תפריט של נקודות שאפשר לקפוץ אליהן, או פורטל לשלב אחר. שני הראשונים מעבירים את הדמות בתוך השרת שבו השחקן כבר נמצא. השלישי שולח את השחקן לפלייס אחר במשחק שלכם, שרץ על שרתים משלו. הם משתמשים ב-API שונים, ולכן כדאי לדעת איזה מהם אתם צריכים.

שני סוגי טלפורט
בתוך אותו שרתלפלייס אחר במשחק שלכם
קריאהcharacter:PivotTo(cframe)TeleportService:TeleportAsync(placeId, players)
למהמשטחי טלפורט, תפריט טלפורט, העברת שחקנים מהלובי לזירהפורטלים לשלב אחר, לובי ששולח שחקנים לפלייס נפרד עם מבוך או משחקון
איפה זה עובדScript של שרתרק Script של שרת. ה-Teleport() בלקוח מיושן.
עובד בבדיקת משחק ב-Studioכןלא. TeleportService ב-Roblox לא תומך בבדיקת משחק ב-Studio, ולכן בודקים במשחק שפורסם.
מה השחקן רואהקפיצה על פני המפה, שיכולה לקחת עד 2 שניות אם קודם צריך לטעון את האזור הזהמסך הטעינה של Roblox, ואז הפלייס האחר
מטבעות, פריטים ונתונים אחריםנשארים כמו שהםRoblox מאפסת את הנתונים המקומיים של השחקן, ולכן כל דבר חשוב צריך להגיע ממאגר נתונים בפלייס האחר

במדריך הזה כל שלושת הסוגים נמצאים ב-Script שרת אחד, ולכן סט כללים אחד מכסה כל טלפורט במשחק שלכם: השרת מחליט, לכל שחקן יש זמן המתנה משלו, והמכשיר של השחקן רק מודיע לאיזו נקודה הוא היה רוצה להגיע.

ממה מורכב הטלפורט
רכיבאיפה הוא נמצאמה הוא עושה
Folder בשם TeleportPads עם PadA ו-PadBWorkspaceשני משטחים. האטריביוט Destination של כל אחד מציין את המשטח שאליו הוא שולח שחקנים.
Folder TeleportSpotsWorkspaceפארט אחד לכל נקודה ברשימת התפריט. האטריביוט WinsNeeded נועל נקודה.
Folder PlacePortalsWorkspaceפארטים של פורטלים. האטריביוט PlaceId של כל פורטל הוא הפלייס שאליו הוא שולח שחקנים.
Script TeleportersServerScriptServiceמנהל את כל שלושת סוגי הטלפורט ויוצר שני רימוטים. המקום היחיד שבו טלפורט יכול לקרות.
LocalScript TeleportMenuStarterPlayer > StarterPlayerScriptsמצייר את כפתור Teleport ואת רשימת הנקודות ושולח את השם של הנקודה שהשחקן בחר.
RemoteFunction בשם GetTeleportSpots ו-RemoteEvent בשם TeleportRequestReplicatedStorage (Teleporters יוצר אותם)הראשון מחזיר לתפריט את רשימת הנקודות. השני מעביר את השם שנבחר לשרת.
ה-Explorer כשהטלפורט מוכן. Teleporters מוסיף את GetTeleportSpots ואת TeleportRequest ל-ReplicatedStorage כשהמשחק רץ.
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: בנו שני משטחי טלפורט

  1. ב-Explorer רחפו מעל Workspace, לחצו על כפתור ה-+ והכניסו Folder. קראו לתיקייה TeleportPads. הסקריפט מחפש בדיוק את השם הזה.
  2. הכניסו לתיקייה שני Part וקראו להם PadA ו-PadB. עשו כל אחד לוח שטוח, למשל 6 על 1 על 6 studs, והציבו אותם על הרצפה במרחק מסוים זה מזה. בחלון Properties סמנו Anchored, השאירו את CanCollide ואת CanTouch מופעלים, וקבעו צבע בוהק וחומר Neon, כדי ששחקנים ישימו לב אליהם.
  3. סמנו את PadA, גללו בחלון Properties עד הפרק Attributes ולחצו על +. הזינו את השם Destination, בחרו את הסוג String ולחצו על Save, ואז קבעו את הערך PadB. עשו אותו דבר ב-PadB עם הערך PadA.
  4. סובבו כל משטח כך שהפאה הקדמית שלו תפנה לרצפה פנויה. שחקנים מופיעים 3 studs לפני הפאה הקדמית של משטח היעד, עם הגב אליו, ולכן השאירו שם כמה studs של רצפה פנויה. כדי לראות איזו פאה היא הקדמית, לחצו לחיצה ימנית על המשטח ובחרו Show Orientation Indicator: את הפאה הקדמית מסמן קו כחול. סובבו את המשטח בכלי Rotate עד שהקו הזה יצביע לכיוון שאליו שחקנים צריכים ללכת.

שחקנים מגיעים ליד המשטח, ולא עליו, בכוונה. בעמוד של Roblox על debounce מצוין ש-Touched נורה הרבה פעמים ברצף בנגיעה אחת, ולכן שחקן שהופיע ממש על המשטח השני היה מפעיל אותו שוב ברגע שזמן ההמתנה שלו נגמר, ועף בחזרה על פני המפה.

אתם לא מוגבלים לשני משטחים. ה-Destination של משטח יכול לציין כל פארט ב-TeleportPads, ולכן שלושה משטחים יכולים לשלוח שחקנים במעגל. למשטח חד-כיווני כוונו אותו לפארט ב-TeleportPads שאין לו Destination משלו: פארט כזה מקבל שחקנים ולא שולח אף אחד לשום מקום.

שלב 2: הוסיפו את סקריפט הטלפורט

רחפו מעל ServerScriptService, הכניסו Script, קראו לו Teleporters והדביקו בו את הקוד שלמטה. כרגע הוא משרת את המשטחים, ואחרי השלבים הבאים גם את התפריט והפורטלים, ולכן מוסיפים אותו פעם אחת. ההגדרות בהתחלה הן השורות שאתם אמורים לשנות.

Script בתוך ServerScriptService בשם 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 פעם אחת, כשהשרת עולה, ולכן משטחים ופורטלים שנוספו בזמן המשחק לא עושים כלום. אם תיקייה כלשהי חסרה, סוג הטלפורט הזה פשוט כבוי.

מה כל חלק ב-Teleporters עושה
חלקמה הוא עושהלמה
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 מהמדריך לריצה קורא את האטריביוט הזה ומתחיל למדוד מחדש מהמיקום החדש. בלי סקריפט כזה האטריביוט לא עושה כלום.
ההגדרות בתחילת Teleporters
הגדרההערך כאןמה זה משנה
PAD_COOLDOWN_SECONDS2כמה זמן המשטחים והפורטלים מתעלמים משחקן אחרי כל טלפורט.
MENU_COOLDOWN_SECONDS3המרווח הקצר ביותר בין שני טלפורטים דרך התפריט לאותו שחקן. למשטחים ולתפריט יש שעון משותף לכל שחקן, ולכן גם בקשה מהתפריט בתוך 3 שניות אחרי טלפורט ממשטח נדחית.
PAD_ARRIVAL_GAP3כמה studs מהפאה הקדמית של משטח היעד שחקנים מופיעים, כדי שיגיעו ליד המשטח ולא עליו.
PLACE_ATTEMPTS3כמה פעמים פורטל מנסה TeleportAsync במרווח של 2 שניות לפני שהוא מוותר.

לחצו על Play כבר עכשיו ועלו על PadA: תופיעו לפני PadB. התפריט והפורטלים צריכים את שני השלבים הבאים, אבל הסקריפט כבר עובד גם בלעדיהם.

שלב 4: טלפורט לפלייס אחר

פלייס הוא עולם נפרד בתוך המשחק שלכם, עם שרתים משלו: לובי ומבוך, או האב וסט של שלבים. שחקנים עוברים בין פלייסים דרך TeleportService, ו-Roblox מריצה אותו רק במשחק שפורסם, ולכן השלב הזה מסתיים באפליקציית Roblox, לא ב-Studio.

  1. אם המשחק עוד לא פורסם, בחרו File > Publish. משחקים חדשים, עד שתשיקו אותם, פתוחים רק לכם, לאנשים שנתתם להם גישת Edit ולחברי הקבוצה עם התפקידים המתאימים, ולבדיקה שלכם של טלפורטים זה מספיק.
  2. צרו פלייס שני: פתחו פלייס חדש מכל תבנית של Studio, בנו את המבוך שלכם, ואז בחרו File > Publish As, לחצו על האריח של המשחק שלכם, בחרו Add as a new place ולחצו על Create.
  3. העתיקו את ה-ID של הפלייס החדש. פתחו את Asset Manager מתפריט Window או מהלשונית Home, עברו ל-Places In Experience, לחצו לחיצה ימנית על הפלייס ובחרו Copy Asset ID, וזה יעתיק את ה-place ID שלו.
  4. כשחזרתם לפלייס הראשון, הכניסו ל-Workspace Folder בשם PlacePortals, ובתוכו Part מעוגן בשם DungeonPortal. הוסיפו אטריביוט מסוג Number בשם PlaceId והדביקו את ה-ID כערך שלו.
  5. לחצו על Play וגעו בפורטל. ה-Output מדפיס שורה שמתחילה ב-Teleporters: would send: ב-Studio הפורטל לא עושה שום דבר נוסף.
  6. פרסמו את המשחק שוב דרך 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:

שלושת הערכים של Access Control for Places
הגדרהמי יכול להיכנס לפלייס שאינו פלייס ההתחלה
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) מ-LocalScriptRoblox מסמנת את Teleport() כמיושן, ממליצה לא להשתמש בו בפרויקטים חדשים ומתירה את TeleportAsync רק מסקריפטי שרת.קורא ל-TeleportAsync בסקריפט שרת.
אין pcall, אין ניסיונות חוזריםבעמוד של Roblox על טלפורטים כתוב שהם יכולים להיכשל ולזרוק שגיאה, וגם להיכשל אחרי שכבר התחילו.עד 3 ניסיונות ב-pcall, ו-TeleportInitFailed מאפשר לשחקן לנסות שוב.
מוותר, כי ב-Studio זה "לא עובד"TeleportService לא תומך בבדיקת משחק ב-Studio.RunService:IsStudio() במקום זה מדפיס מה הפורטל היה עושה.
GUI טלפורט שהכפתורים שלו שולחים מיקוםרמאי יכול לקרוא לאותו רימוט עם כל מיקום.הכפתורים שולחים את שם הנקודה, והשרת מחפש אותו.
מטבעות מועברים ב-teleport dataRoblox אומרת ש-teleport data גלויים ללקוח ולא מוצפנים.ממליץ לשמור מטבעות ו-Wins במאגר נתונים ולטעון אותם בפלייס האחר (ראו איך להעביר נתונים לפלייס אחר).

מה שחקנים יכולים ומה לא יכולים לזייף

הניחו שרמאי שולט בכל מה שבמכשיר שלו: הוא יכול לערוך את TeleportMenu, לקרוא לשני הרימוטים כמה פעמים שירצה עם כל ארגומנט ולהזיז את הדמות שלו. הנה מה שזה נותן לו עם הטלפורט הזה.

מה רמאי יכול לנסות ומה Teleporters עושה עם זה
הרמאי מנסהתוצאהלמה
לשלוח מיקום או CFrame דרך רימוט התפריטמתעלמים מזהTeleportRequest קורא מחרוזת אחת, שם נקודה באורך של עד 50 תווים. כל השאר נזרק.
לבקש את Castle בלי 3 Winsסירובהשרת קורא את ה-Wins מהעותק שלו של leaderstats. הכפתור האפור הוא רק רמז.
לבקש נקודה שלא קיימתמתעלמים מזההשרת מחפש את השם ב-TeleportSpots ולא עושה כלום אם אין פארט בשם הזה.
לקרוא לרימוט התפריט שוב ושובלא יותר מטלפורט אחד דרך התפריט כל 3 שניותזמן ההמתנה נשמר בשרת, לכל שחקן.
להפעיל משטח בלי להתקרב אליוהוא מגיע למשטח התאום, שאליו ממילא יכול היה ללכתRoblox מונה שיגור לכל נקודה ומניפולציה של אירועי Touched בין הדברים שלקוח יכול לעשות עם הדמות שלו.
להיכנס ישירות לפלייס אחר במשחק שלכםאפשרי, אם Access Control for Places לא שווה Secure within universe onlyראו מי יכול להיכנס לפלייסים האחרים שלכם.
להזיז את הדמות שלו לכל מקום, כולל נקודה נעולהאפשריכל מכשיר שולט בתנועה של הדמות שלו. נקודה נעולה היא נוחות, לא כספת, ולכן בדקו בשרת לפני שנותנים שם משהו בעל ערך.

השורה האחרונה היא הגבול הכן של כל טלפורט. למשחק תחרותי הוסיפו בדיקת תנועה בשרת, כמו במדריך לריצה. Teleporters כבר קובע את האטריביוט MovementCheckSkip שהבדיקה ההיא קוראת, ולכן הטלפורטים שלו עצמו לא מסומנים כהפרה: בתיעוד האבטחה של Roblox כתוב שמשחקים עם טלפורטים לגיטימיים צריכים בדיוק חריגה כזו בבדיקות התנועה.

שלב 5: בדקו

  1. לחצו על Play. עלו על PadA: אתם מופיעים ממש לפני PadB, עם הגב אליו. הסתובבו ועלו מיד על PadB: שום דבר לא קורה, כי המשטחים מתעלמים מכם 2 שניות אחרי ההגעה. רדו, חכו 2 שניות ועלו שוב על PadB: אתם מופיעים לפני PadA.
  2. חכו כמה שניות, ואז לחצו על Teleport בצד השמאלי של המסך. ברשימה רואים את Lake, Spawn ואת "Castle (needs 3 wins)" האפור. בחרו Lake: אתם מופיעים עליה. פתחו את התפריט שוב ובחרו Castle: שום דבר לא קורה, וב-Output שקט.
  3. תנו לעצמכם 3 Wins (לזה צריך סקריפט leaderstats עם IntValue בשם Wins, למשל מהמדריך לטבלת המובילים). לחצו על המתג Client/Server כדי לעבור ל-Server, מצאו ב-Explorer את Players, את השם שלכם, leaderstats, Wins, וקבעו את ה-Value שלו ל-3 בחלון Properties. עברו בחזרה ל-Client ופתחו שוב את התפריט: Castle נהיה סגול ומעביר אתכם לשם.
  4. געו ב-DungeonPortal. ה-Output מדפיס שורה שמתחילה ב-Teleporters: would send, עם השם שלכם וה-place ID. ב-Studio כך זה אמור להיות, והיא מודפסת לא יותר מפעם ב-2 שניות, לא משנה כמה זמן אתם עומדים על הפורטל.
  5. בחרו Server & Clients ברשימה הנפתחת של מצבי הבדיקה, קבעו 2 לקוחות ולחצו על Play. שני השחקנים יכולים להשתמש במשטחים באותו זמן, וזמן ההמתנה של אחד אף פעם לא חוסם את השני.
  6. עצרו את הבדיקה, פרסמו את המשחק והפעילו אותו מאפליקציית 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 שלהם, עם ניסיונות חוזרים.

RoCode עושה
  • יכול לסרוק את הפלייס שלכם כשהשלב צריך את זה, עם 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 גלויים ללקוח ולא מוצפנים, ולכן הם מתאימים למשהו כמו המפה שנבחרה, אבל לא למטבעות. שמרו מטבעות ופריטים במאגר נתונים וטענו אותם בפלייס האחר.

מקורות וקריאה נוספת

איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.

נסו את RoCode במשחק שלכם.

קרדיטים חינמיים בכל יום, בלי כרטיס אשראי. התקינו את הפלאגין, תארו פיצ'ר ובדקו מה מופיע ב-Studio.