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

איך ליצור מערכת סיבובים ב-Roblox Studio

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

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

בקצרה

כתבו Script שרת אחד ב-ServerScriptService, שעובר במחזור על קבוצה קבועה של מצבים: הפסקה (לחכות למספר השחקנים הנדרש, ואז ספירה לאחור), טעינת מפה (לשכפל מפה אקראית מ-ServerStorage ל-Workspace), טלפורט (להעביר כל דמות חיה ל-Part לידה דרך PivotTo), סיבוב (להריץ טיימר עד שהזמן נגמר או שנשאר שחקן אחד או קבוצה אחת) וניקוי (לתת Wins, להחזיר את השורדים לחיים, למחוק את המפה).

  • הריצו את הלולאה רק בשרת. פרסמו את הסטטוס ואת השניות שנשארו כ-Attributes על Folder ב-ReplicatedStorage, ותנו ל-LocalScript להציג אותם.
  • החזיקו טבלה של מי שעדיין בסיבוב. הסירו שחקן כשה-Humanoid שלו מת, כשהדמות שלו נמחקת או כשהוא יוצא.
  • שגרו רק שחקנים שהדמות שלהם חיה ברגע תחילת הסיבוב. מי שנכנס מאוחר יותר מחכה בלובי לבא.
בעמוד הזה
  1. איך זה עובד
  2. 1. לובי ומפות
  3. 2. סקריפט הסיבובים
  4. איך המצבים עובדים
  5. 3. UI של טיימר
  6. שחקנים באמצע סיבוב
  7. איך להרחיב
  8. Common errors
  9. עם RoCode
  10. שאלות נפוצות
  11. מקורות וקריאה נוספת

איך מערכת סיבובים עובדת

איורסקריפטי הסיבובים המוכנים במשחק שרץ, מואץ.

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

מצבי לולאת הסיבובים במדריך הזה
מצבמה השרת עושהמתי עוברים הלאה
Waitingמציג "Waiting for players (1/2)"בשרת יש מספיק שחקנים
Intermissionסופר את הזמן בזמן שכולם בלוביהספירה הסתיימה (או חזרה ל-Waiting, אם שחקנים יצאו)
Startingמעתיק מפה אקראית ל-Workspace, מציג את השם שלה, מבקש מהלקוחות לטעון אותההספירה הקצרה "להתכונן" הסתיימה
InRoundמשגר שחקנים חיים, מריץ טיימר, מסיר את מי שמת או יצאהזמן נגמר, או שנשאר שחקן אחד או קבוצה אחת
Resultsנותן Win לכל מי שעדיין חי, ומציג מי ניצחעברו כמה שניות
Cleanupמחזיר את השורדים לחיים בלובי ומוחק את המפהמיד, ואז הלולאה מתחילה מחדש

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

שלב 1: בנו את הלובי, המפות והמאפיין Wins

  1. בנו לובי ב-Workspace עם SpawnLocation. בדקו שהמאפיין Neutral שלו מסומן, כדי שכל שחקן ייוולד כאן, יחכה כאן ויחזור לכאן אחרי שהודח.
  2. ב-ServerStorage הכניסו Folder בשם Maps. אובייקטים ב-ServerStorage אף פעם לא נשלחים לשחקנים, ולכן מפות שלא בשימוש לא עולות להם כלום.
  3. בנו כל מפה כ-Model בתוך Maps, עם Parts מעוגנים. בנו אותה רחוק מהלובי (כמה מאות studs מספיקים), כי העותק מופיע בדיוק במקום שבו בניתם אותה, ושחקנים שהודחו לא אמורים להיות מסוגלים להיכנס בחזרה.
  4. בתוך כל מפה הוסיפו Folder בשם Spawns, ובתוכו Part מעוגן אחד לכל שחקן צפוי. קבעו להם Transparency 1 וכבו CanCollide, כדי שאף אחד לא יראה אותם ולא ייתקל בהם.
ה-Explorer אחרי המדריך הזה
Workspace
  Lobby Model
    SpawnLocation SpawnLocation
ServerStorage
  Maps Folder new
    Desert Model new
      Spawns Folder new
        Spawn1 Part new
        Spawn2 Part new
    Castle Model new
      Spawns Folder new
ServerScriptService
  Leaderstats Script new
  RoundSystem Script new
StarterGui
  RoundHud ScreenGui new
    RoundHudClient LocalScript new

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

Script בתוך ServerScriptService בשם Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- השם חייב להיות בדיוק כזה, באותיות קטנות

	local wins = Instance.new("IntValue")
	wins.Name = "Wins"
	wins.Value = 0
	wins.Parent = leaderstats

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- ב-Studio אתם יכולים להיכנס לפני שהסקריפט הזה רץ, ולכן מגדירים את כל מי שכבר כאן
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

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

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

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

Script בתוך ServerScriptService בשם RoundSystem
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- הגדרות
local MIN_PLAYERS = 2 -- קבעו 1 בזמן שאתם בודקים לבד
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: הסיבוב נגמר כשנשארו שחקנים רק בקבוצה אחת

local mapsFolder = ServerStorage:WaitForChild("Maps")
local random = Random.new()

-- מה שהמסך של כל שחקן מציג נשמר ב-Attributes על התיקייה הזו.
-- Attributes שהשרת קבע משוכפלים לכל הלקוחות, כולל מי שנכנס מאוחר יותר.
local roundInfo = Instance.new("Folder")
roundInfo.Name = "RoundInfo"
roundInfo.Parent = ReplicatedStorage

local function setState(state: string, status: string)
	roundInfo:SetAttribute("State", state)
	roundInfo:SetAttribute("Status", status)
	roundInfo:SetAttribute("TimeLeft", 0)
end

local function setTimeLeft(seconds: number)
	roundInfo:SetAttribute("TimeLeft", seconds)
end

-- מי עדיין בסיבוב הנוכחי, והחיבורים שעוקבים אחרי כל אחד מהם
local alive: { [Player]: boolean } = {}
local watchers: { [Player]: { RBXScriptConnection } } = {}

local function eliminate(player: Player)
	if not alive[player] then
		return
	end
	alive[player] = nil
	player:SetAttribute("InRound", false)
	local connections = watchers[player]
	if connections then
		for _, connection in connections do
			connection:Disconnect()
		end
		watchers[player] = nil
	end
end

Players.PlayerRemoving:Connect(eliminate)

-- מחזיר את הדמות ואת ה-Humanoid, רק אם השחקן חי ממש עכשיו
local function getLivingCharacter(player: Player): (Model?, Humanoid?)
	local character = player.Character
	if not character or not character.Parent then
		return nil, nil
	end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 or not humanoid.RootPart then
		return nil, nil
	end
	return character, humanoid
end

-- סופר את הצדדים שנשארו בסיבוב (שחקנים, או קבוצות אם USE_TEAMS מופעל)
local function countSides(): (number, number)
	local sides: { [Instance]: boolean } = {}
	local sideCount = 0
	local playerCount = 0
	for player in alive do
		playerCount += 1
		local team = player.Team
		local side: Instance = if USE_TEAMS and team then team else player
		if not sides[side] then
			sides[side] = true
			sideCount += 1
		end
	end
	return sideCount, playerCount
end

-- מצב: Waiting ו-Intermission. מחזיר false אם שחקנים יצאו בזמן הספירה.
local function runIntermission(): boolean
	while #Players:GetPlayers() < MIN_PLAYERS do
		setState("Waiting", `Waiting for players ({#Players:GetPlayers()}/{MIN_PLAYERS})`)
		task.wait(1)
	end
	setState("Intermission", "Intermission")
	for secondsLeft = INTERMISSION_SECONDS, 1, -1 do
		if #Players:GetPlayers() < MIN_PLAYERS then
			return false
		end
		setTimeLeft(secondsLeft)
		task.wait(1)
	end
	return true
end

-- מצב: Starting, חלק 1. מעתיקים מפה אקראית (לא הקודמת, אם יש בחירה).
local lastMapName = ""

local function loadMap(): Model?
	local allMaps: { Model } = {}
	local freshMaps: { Model } = {}
	for _, child in mapsFolder:GetChildren() do
		if child:IsA("Model") then
			table.insert(allMaps, child)
			if child.Name ~= lastMapName then
				table.insert(freshMaps, child)
			end
		end
	end
	local choices = if #freshMaps > 0 then freshMaps else allMaps
	if #choices == 0 then
		warn("RoundSystem: add at least one map Model to ServerStorage > Maps")
		return nil
	end
	local chosen = choices[random:NextInteger(1, #choices)]
	lastMapName = chosen.Name
	local map = chosen:Clone()
	map.Parent = workspace
	return map
end

local function getSpawnPoints(map: Model): { BasePart }
	local points: { BasePart } = {}
	local folder = map:FindFirstChild("Spawns")
	if folder then
		for _, child in folder:GetChildren() do
			if child:IsA("BasePart") then
				table.insert(points, child)
			end
		end
	end
	-- מערבבים, כדי ששחקנים לא ינחתו על אותה נקודת לידה בכל סיבוב
	for i = #points, 2, -1 do
		local j = random:NextInteger(1, i)
		points[i], points[j] = points[j], points[i]
	end
	return points
end

-- באיזה גובה מעל הרצפה נמצא ה-root part של דמות שעומדת.
-- הנוסחה מהתיעוד של Roblox על Humanoid.HipHeight (ב-Rigs מסוג 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

-- מצב: Starting, חלק 2. להתכונן, ואז לשגר את כל החיים.
local function startRound(map: Model): boolean
	local spawnPoints = getSpawnPoints(map)
	if #spawnPoints == 0 then
		warn(`RoundSystem: {map.Name} needs a Spawns folder with at least one part in it`)
		return false
	end

	-- כשסטרימינג מופעל, מבקשים מכל לקוח לטעון את המפה לפני שהדמות מגיעה
	if workspace.StreamingEnabled then
		local mapPosition = map:GetPivot().Position
		for _, player in Players:GetPlayers() do
			task.spawn(function()
				pcall(function()
					player:RequestStreamAroundAsync(mapPosition, GET_READY_SECONDS)
				end)
			end)
		end
	end

	setState("Starting", `Map: {map.Name}`)
	for secondsLeft = GET_READY_SECONDS, 1, -1 do
		setTimeLeft(secondsLeft)
		task.wait(1)
	end

	-- משתתפים רק מי שחי ממש עכשיו. השאר מחכים לסיבוב הבא.
	local participants: { Player } = {}
	for _, player in Players:GetPlayers() do
		if getLivingCharacter(player) then
			table.insert(participants, player)
		end
	end
	if #participants < MIN_PLAYERS then
		setState("Waiting", "Not enough players, starting over")
		task.wait(2)
		return false
	end

	for index, player in participants do
		local character, humanoid = getLivingCharacter(player)
		local rootPart = if humanoid then humanoid.RootPart else nil
		if character and humanoid and rootPart then
			local spawnPart = spawnPoints[(index - 1) % #spawnPoints + 1]
			-- ה-pivot של הדמות הוא ה-root part שלה, ולכן מרימים אותו לגובה עמידה מעל ה-Part
			local height = spawnPart.Size.Y / 2 + rootHeight(character, humanoid, rootPart)
			character:PivotTo(spawnPart.CFrame + Vector3.new(0, height, 0))
			alive[player] = true
			player:SetAttribute("InRound", true)
			watchers[player] = {
				humanoid.Died:Connect(function()
					eliminate(player)
				end),
				player.CharacterRemoving:Connect(function()
					eliminate(player)
				end),
			}
		end
	end
	return true
end

-- מצב: InRound. נגמר כשהזמן נגמר או שנשאר צד אחד.
local function runRound()
	setState("InRound", "Round in progress")
	local startingSides = countSides()
	for secondsLeft = ROUND_SECONDS, 1, -1 do
		local _, playersLeft = countSides()
		roundInfo:SetAttribute("Status", `{playersLeft} left`)
		setTimeLeft(secondsLeft)
		task.wait(1)
		local sidesLeft = countSides()
		-- סיבוב שהתחיל עם צד אחד (בדיקה לבד) נגמר רק לפי זמן או במוות
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- מצב: Results. כל מי שעדיין חי מנצח.
local function awardWin(player: Player)
	local leaderstats = player:FindFirstChild("leaderstats")
	local wins = leaderstats and leaderstats:FindFirstChild("Wins")
	if wins and wins:IsA("IntValue") then
		wins.Value += 1
	end
end

local function finishRound(): { Player }
	local sidesLeft = countSides()
	local winners: { Player } = {}
	for player in alive do
		table.insert(winners, player)
	end

	local message = `{#winners} players survived!`
	local firstTeam = if #winners > 0 then winners[1].Team else nil
	if #winners == 0 then
		message = "Nobody survived"
	elseif USE_TEAMS and sidesLeft == 1 and firstTeam then
		message = `{firstTeam.Name} wins!`
	elseif #winners == 1 then
		message = `{winners[1].DisplayName} wins!`
	end

	for _, player in winners do
		awardWin(player)
		eliminate(player) -- מפסיקים לעקוב אחריהם; הם נשארים במפה עד הניקוי
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- מצב: Cleanup. שולחים את השורדים חזרה ללובי, ואז מוחקים את המפה.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- עדיין בשרת
			task.spawn(function()
				local ok, err = pcall(function()
					player:LoadCharacterAsync()
				end)
				if not ok then
					warn(`RoundSystem: could not respawn {player.Name}: {err}`)
				end
			end)
		end
	end
	map:Destroy()
end

-- הלולאה: מעבר אחד הוא סיבוב אחד
while true do
	if runIntermission() then
		local map = loadMap()
		if map then
			local survivors: { Player } = {}
			if startRound(map) then
				runRound()
				survivors = finishRound()
			end
			cleanup(map, survivors)
		else
			task.wait(5) -- עוד אין מפות: ננסה שוב בקרוב
		end
	end
end

כל מה שחשוב קורה כאן, בשרת: מי בסיבוב, הטיימר, המנצח וה-Wins. הלקוחות מקבלים רק שלושה Attributes על ReplicatedStorage.RoundInfo (State, Status ו-TimeLeft), ואת ה-Attribute בשם InRound על כל שחקן.

איך כל מצב עובד

המתנה והפסקה

runIntermission קודם מחזיק את הלולאה עד ש-#Players:GetPlayers() מגיע ל-MIN_PLAYERS. אחר כך הוא סופר שנייה אחר שנייה דרך task.wait(1), ובכל תקתוק בודק את מספר השחקנים. אם מישהו יצא ובשרת נשארו פחות מהמינימום, הוא מחזיר false, והלולאה הראשית מתחילה מחדש מ-Waiting, כך שסיבוב אף פעם לא יתחיל עם אדם אחד.

בחירה וטעינה של מפה

loadMap אוסף את כל ה-Model ב-ServerStorage.Maps, מוציא את המפה של הסיבוב הקודם אם יש ממה לבחור, ולוקח אחת דרך Random:NextInteger. אחר כך הוא משכפל את המפה ל-Workspace. המקור נשאר שלם ב-ServerStorage, כך שכל סיבוב מתחיל מעותק טרי: כל מה ששחקנים שברו או הזיזו בסיבוב הקודם נעלם.

בפלייסים חדשים instance streaming מופעל: ללקוח יש רק Parts ליד הדמות שלו. לפני הטלפורט הסקריפט קורא ל-Player:RequestStreamAroundAsync לכל שחקן, וזה מבקש מהמנוע לשלוח ללקוח את האזור סביב המפה בזמן הספירה "להתכונן". בלי זה שחקנים עלולים להגיע לפני שהרצפה נטענה, ולקפוא לרגע.

טלפורט של שחקנים דרך PivotTo

אחרי הספירה הסקריפט אוסף רשימת משתתפים מהשחקנים שיש להם דמות שקיימת, עדיין נמצאת בעולם, ויש לה Humanoid עם חיים מעל 0 ו-root part. הבדיקה הזו נעשית אחרי הספירה, ולכן מי שמת או יצא בזמן הספירה לא נכנס לרשימה.

כל משתתף מועבר דרך character:PivotTo(cframe). התיעוד של Roblox קורא ל-PivotTo הדרך העיקרית להזיז מודלים מסקריפט, והוא מזיז את כל חלקי הדמות יחד. לקבוע את HumanoidRootPart.Position זה לא אותו דבר: Roblox מתאימה את המפרקים כך שרק החלק הזה זז, ושאר הגוף עלול להישאר מאחור. ה-pivot של הדמות הוא ה-root part שלה, ולכן המטרה היא ה-CFrame של Part הלידה, מורם בחצי מגובה ה-Part ועוד הגובה שבו ה-root part עומד מעל הרצפה. rootHeight מחשב אותו לפי הנוסחה מהתיעוד של Roblox על Humanoid.HipHeight: חצי מגובה ה-root part ועוד HipHeight, ועוד אורך הרגל ב-Rigs מסוג R6. כך אווטארים מותאמים ובקנה מידה שונה לא נתקעים ב-Part ולא נופלים עליו מלמעלה. ה-CFrame כולל סיבוב, ולכן השחקנים מסתכלים לאותו כיוון כמו Part הלידה: סובבו את ה-Parts כך שכולם יסתכלו למרכז המפה.

אם יש יותר שחקנים מ-Parts ללידה, הסקריפט מתחיל שוב מה-Part הראשון, ושחקנים נוחתים זה על זה, אז הוסיפו נקודות לידה כמספר השחקנים המקסימלי שלכם לפחות.

אם אתם משתמשים גם בבדיקת המהירות מהמדריך לספרינט, הוסיפו player:SetAttribute("MovementCheckSkip", true) מיד אחרי character:PivotTo(...) ב-startRound, כדי שהטלפורט לא ייחשב כחריגה ממהירות.

טיימר הסיבוב ותנאי הסיום

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

  • הזמן נגמר. לולאת ה-for מגיעה ל-1 ומסתיימת.
  • נשאר צד אחד. צד הוא שחקן, או קבוצה אם USE_TEAMS מופעל. הבדיקה עובדת רק אם הסיבוב התחיל עם שני צדדים או יותר, ולכן בדיקה לבד לא נגמרת באותו רגע שבו היא התחילה.
  • לא נשאר אף אחד. כולם מתו או יצאו, והסיבוב נגמר בלי מנצח.

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

מתן Wins והצגת התוצאה

הכלל בסקריפט הזה פשוט: כל מי שחי ברגע סיום הסיבוב מנצח. זה מכסה גם את השחקן האחרון ששרד, גם את הקבוצה האחרונה ששרדה, וגם את המצב "תחזיקו מעמד עד שהטיימר נגמר", בשורת לוגיקה אחת. finishRound מוסיף 1 ל-Wins של כל מנצח, מפסיק לעקוב אחריהם ומציג הודעה כמו "Alex wins!" למשך RESULTS_SECONDS. אם אתם רוצים שכשהזמן נגמר לא יהיה מנצח, דלגו על awardWin ושנו את ההודעה כש-sidesLeft גדול מ-1. בכל מקרה המשיכו להחזיר את הרשימה, כי הניקוי מחזיר לפיה את השורדים ללובי.

ניקוי

השורדים עדיין עומדים במפה, ולכן cleanup מחזיר אותם לחיים בלובי דרך Player:LoadCharacterAsync(), שמחליף את LoadCharacter הישן, ואז מוחק את העותק של המפה. כל לידה מחדש רצה ב-task.spawn משלה בתוך pcall, כי הקריאה מחכה לטעינת הדמות ויכולה להיכשל אם השחקן בדיוק יוצא באותו רגע. שחקנים שהודחו לא צריכים כלום: הם כבר חזרו לחיים בלובי בעצמם.

שלב 3: הציגו את הטיימר והסטטוס לכל שחקן

השרת מפרסם שלושה Attributes על ReplicatedStorage.RoundInfo: State (מילה קבועה כמו InRound, לסקריפטים), Status (טקסט לבני אדם) ו-TimeLeft (שניות). Attributes שסקריפט שרת קובע על אובייקט משוכפל מגיעים אוטומטית לכל לקוח, ושחקן שנכנס באמצע סיבוב מקבל מיד את הערכים הנוכחיים. לכן לטיימר זה מתאים יותר מ-remote: RemoteEvent שנשלח לפני שמישהו נכנס לא יגיע אליו אף פעם.

  1. ב-Explorer הכניסו ScreenGui ל-StarterGui וקראו לו RoundHud. השאירו את ResetOnSpawn מופעל (ברירת מחדל).
  2. הכניסו LocalScript ל-RoundHud, קראו לו RoundHudClient והדביקו את הקוד שלמטה. הוא יוצר את הכיתוב בעצמו, אז לא צריך לצייר שום דבר נוסף.
  3. לחצו על Play. הכיתוב בראש המסך מציג את הסטטוס ואת הספירה בפורמט m:ss.
LocalScript בתוך ה-ScreenGui בשם RoundHud ב-StarterGui בשם RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local roundInfo = ReplicatedStorage:WaitForChild("RoundInfo")
local screenGui = script.Parent :: ScreenGui

-- הכיתוב. אם ציירתם TextLabel משלכם ב-RoundHud, מחקו את הבלוק הזה והשתמשו ב:
-- local label = screenGui:WaitForChild("StatusLabel") :: TextLabel
local label = Instance.new("TextLabel")
label.Name = "StatusLabel"
label.AnchorPoint = Vector2.new(0.5, 0)
label.Position = UDim2.new(0.5, 0, 0, 12)
label.Size = UDim2.fromOffset(320, 44)
label.BackgroundColor3 = Color3.fromRGB(20, 14, 32)
label.BackgroundTransparency = 0.2
label.TextColor3 = Color3.new(1, 1, 1)
label.Font = Enum.Font.BuilderSansBold
label.TextSize = 22
label.TextWrapped = true -- הודעות ארוכות עוברות לשורה שנייה
label.Text = ""
label.Parent = screenGui

local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(0, 10)
corner.Parent = label

local function formatTime(seconds: number): string
	return string.format("%d:%02d", seconds // 60, seconds % 60)
end

local function update()
	local status = roundInfo:GetAttribute("Status")
	local timeLeft = roundInfo:GetAttribute("TimeLeft")
	local text = if type(status) == "string" then status else ""
	if type(timeLeft) == "number" and timeLeft > 0 then
		text ..= "   " .. formatTime(timeLeft)
	end
	label.Text = text
end

roundInfo:GetAttributeChangedSignal("Status"):Connect(update)
roundInfo:GetAttributeChangedSignal("TimeLeft"):Connect(update)
update()

מכיוון ש-ResetOnSpawn מופעל, Roblox נותנת לשחקן עותק טרי של RoundHud בכל לידה של הדמות, כולל הלידה מחדש בניקוי. הסקריפט אז קורא שוב את ה-Attributes הנוכחיים, כך שהכיתוב אף פעם לא מתיישן.

הלקוח רק קורא. שום דבר ששחקן ישנה במסך שלו לא משפיע על הטיימר האמיתי, כי שינויים ב-Attributes מ-LocalScript נשארים בלקוח האחד הזה. לספירה עם עשיריות שנייה השרת יכול במקום זה לשמור ב-Attribute את זמן הסיום מ-workspace:GetServerTimeNow(), וכל לקוח בכל פריים מחסיר ממנו את ה-workspace:GetServerTimeNow() שלו.

אם המשחק שלכם נפתח בתפריט ראשי, RoundHud מופיע כשהשחקן לוחץ על Play, כי StarterGui מועתק לשחקן רק אחרי שהדמות שלו נולדת. לשחקנים שעדיין בתפריט אין דמות, ולכן הם אף פעם לא משוגרים לסיבוב.

שחקנים שמתים, יוצאים או נכנסים באמצע סיבוב

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

מקרי קצה ואיך סקריפט הסיבובים מתמודד איתם
מצבמה קורהאיפה בסקריפט
שחקן מת בסיבוב (נהרג, עשה reset, נפל)מסירים אותו מהסיבוב, והוא חוזר לחיים בלובי אחרי Players.RespawnTime (ברירת מחדל 5 שניות).humanoid.Died קורא ל-eliminate
הדמות נמחקה בלי מוותכמו במוות: השחקן הודח.player.CharacterRemoving קורא ל-eliminate
שחקן יוצא מהשרתמסירים אותו, החיבורים שלו מנותקים, והתקתוק הבא סופר מחדש את הצדדים.Players.PlayerRemoving קורא ל-eliminate
שחקן נכנס באמצע סיבובהוא נולד בלובי, רואה את הסטטוס החי ואת הטיימר, ונכנס לסיבוב הבא.משתתפים נבחרים רק ב-startRound
השחקן היה מת ברגע תחילת הסיבובלא משגרים אותו, הוא מחכה בלובי.getLivingCharacter
כולם יצאו או מתוהסיבוב נגמר עם "Nobody survived", והלולאה מתחילה מחדש: Intermission אם בשרת עדיין יש מספיק שחקנים, אחרת Waiting.sidesLeft == 0 ב-runRound

eliminate כתוב כך שבטוח לקרוא לו כמה פעמים לאותו שחקן. שחקן שמת וחזר לחיים מפעיל גם את Died וגם את CharacterRemoving, ומי שיוצא יכול להפעיל את כל שלושת האירועים; רק הקריאה הראשונה עושה משהו.

איך להרחיב: קבוצות, הצבעה על מפה ואירועי סיבוב

הקבוצה האחרונה ששרדה

קבעו USE_TEAMS = true, ואז הוסיפו אובייקטי Team לשירות Teams ב-Explorer, לכל אחד שם ו-TeamColor משלו. כברירת מחדל Roblox שמה כל שחקן שנכנס בקבוצה עם השיוך האוטומטי שיש בה הכי מעט חברים. כששחקנים יוצאים, היא לא מאזנת מחדש את הקבוצות, כך שבסשנים ארוכים הקבוצות עלולות להיות לא שוות. השאירו את ה-SpawnLocation בלובי Neutral, כדי שכל הקבוצות ייוולדו שם. אז הסיבוב נגמר כששחקנים חיים נשארו רק בקבוצה אחת, והתוצאה נראית כמו "Red wins!".

לפורמט "אחד נגד כולם" (צייד אחד, השאר שורדים), בחרו ב-startRound משתתף אקראי אחד, ולפני הטלפורט קבעו לו את ה-Team של קבוצת הצייד. הסירו את AutoAssignable מקבוצת הצייד, כדי ששחקנים חדשים אף פעם לא ייכנסו אליה, וב-cleanup החזירו את הצייד לקבוצת השורדים. אז עובדים אותם תנאי סיום: הצייד מנצח אם כל השורדים הודחו, והשורדים מנצחים אם החזיקו מעמד עד סוף הטיימר, בתנאי שאתם מדלגים על ה-awardWin של הצייד כשהזמן נגמר.

הצבעת שחקנים על מפה

להצבעה הלקוח צריך לתקשר עם השרת, ולכן צריך RemoteEvent. בזמן ההפסקה השרת מפרסם כ-Attributes שניים או שלושה שמות של מפות, כל לקוח שולח דרך RemoteEvent את השם שהוא לחץ עליו, והשרת סופר את הקולות לפני שהוא מריץ את loadMap. השרת חייב לבדוק כל קול: שהארגומנט הוא מחרוזת, שהוא אחת האפשרויות הנוכחיות, שהמצב הוא Intermission, ושכל שחקן נספר פעם אחת (שמרו קולות בטבלה עם המפתח Player, כדי שקול שני יחליף את הראשון, ונקו אותה ב-PlayerRemoving). המדריך ל-RemoteEvent מפרט את תבנית הבדיקות הזו.

נתינת כלי בתחילת סיבוב

סקריפטים אחרים יכולים להגיב לסיבוב בלי לגעת ב-RoundSystem. סקריפט הסיבובים קובע לכל שחקן את ה-Attribute בשם InRound כשהוא משגר אותו, ומסיר אותו כשהשחקן מודח. הסקריפט הזה מאזין לו ונותן לכל שחקן עותק של Tool בשם RoundTool שנמצא ב-ServerStorage.

Script בתוך ServerScriptService בשם GiveRoundTool
local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")

local toolTemplate = ServerStorage:WaitForChild("RoundTool") :: Tool

local function watchPlayer(player: Player)
	player:GetAttributeChangedSignal("InRound"):Connect(function()
		if player:GetAttribute("InRound") ~= true then
			return
		end
		local backpack = player:FindFirstChildOfClass("Backpack")
		if backpack then
			toolTemplate:Clone().Parent = backpack
		end
	end)
end

Players.PlayerAdded:Connect(watchPlayer)
for _, player in Players:GetPlayers() do
	watchPlayer(player)
end

קוד שלוקח את הכלי בחזרה אין. כשדמות מתה, Roblox מחליפה את ה-Backpack בחדש, שמתמלא מ-StarterPack, ו-LoadCharacterAsync בניקוי מרוקן אותו אצל השורדים, כך שאחרי הסיבוב הכלי כבר לא קיים.

אם צריך נשק לחלוקה, בנו חרב או רובה על raycast, שמרו אותו ב-ServerStorage במקום ב-StarterPack, ושנו את "RoundTool" בסקריפט הזה לשם שלו.

NPCs ואובייקטים אחרים רק לזמן הסיבוב

כל מה שצריך להתקיים רק בזמן הסיבוב יכול לחיות בתוך מודל המפה: אויבים, פריטים לאיסוף, פלטפורמות זזות. סקריפטים בתוך מודל ב-ServerStorage לא רצים; ברגע שהעותק נמצא ב-Workspace הם מתחילים לרוץ, ו-map:Destroy() בניקוי מוחק אותם יחד עם כל השאר. כדי להוסיף אויבים שרודפים אחרי שחקנים, בנו אחד לפי המדריך ל-pathfinding של NPC ושימו אותו במפה. לסיור במפה בתחילת כל סיבוב, המדריך לסצנות קולנועיות מראה איך הסקריפט הזה יכול להפעיל סצנה לכל שחקן דרך BindableEvent.

איך הופכים את זה למודול

בהתחלה לא צריך ModuleScript. Script אחד קל יותר לקריאה בזמן שאתם בונים את המשחק. פצלו אותו כשסקריפטים אחרים צריכים לקרוא לפונקציות של הסיבוב, או כשאתם רוצים להוציא את ההגדרות ל-ModuleScript משותף אחד, שגם השרת וגם ה-UI שלכם יכולים לטעון דרך require. עד אז ה-Attribute בשם State על RoundInfo וה-Attribute בשם InRound על כל שחקן כבר עובדים כממשק הציבורי של מערכת הסיבובים: כל סקריפט יכול להאזין להם.

שגיאות נפוצות ופתרונות

פתחו את חלון ה-Output (דרך תפריט Window ב-Studio או הלשונית Script) לפני שלוחצים על Play. רוב הבעיות עם מערכת סיבובים מדפיסות שם אזהרה או שגיאה עם שם הסקריפט ומספר השורה.

תקוע על "Waiting for players (1/2)"

אתם בודקים לבד, ו-MIN_PLAYERS שווה 2. קבעו 1 לבדיקות לבד, או בדקו במצב Server & Clients עם 2 לקוחות.

Infinite yield possible on 'ServerStorage:WaitForChild("Maps")'

התיקייה לא קיימת, יש בשם שלה שגיאת הקלדה או שהיא בשירות הלא נכון. היא חייבת להיות Folder בשם בדיוק Maps ישירות בתוך ServerStorage. אותה אזהרה ל-RoundInfo ב-LocalScript אומרת שהסקריפט RoundSystem לא הגיע אף פעם ליצירה שלה: הוא כבוי, נפל עם שגיאה או עדיין מחכה לתיקייה Maps.

אחרי הטלפורט שחקנים נופלים דרך המפה

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

שחקנים שהודחו חוזרים לחיים בזירה

בתוך המפה יש SpawnLocation. החליפו אותו ב-Part רגיל בתיקייה Spawns של המפה הזו.

הסיבוב לא נגמר כשכולם מתו

בדקו שהנזק שלכם באמת הורג את ה-Humanoid (החיים מגיעים ל-0), ולא מזיז או מעגן שחקנים. אם כיביתם את המצב Dead ב-Humanoid, Died אף פעם לא נורה, והסיבוב נאלץ להימשך עד סוף הטיימר.

לולאת הסיבובים נעצרת לתמיד אחרי שגיאה אחת

הלולאה רצה ב-thread אחד, ולכן שגיאה בכל מצב מסיימת אותה. קראו את השגיאה ב-Output, תקנו את השורה ובדקו שוב. סיבה נפוצה: שינו את הסקריפט כך שהוא משתמש ב-player.Character.Humanoid בלי לבדוק שהדמות קיימת.

לעשות עם RoCode

אם לא בא לכם לבנות את כל זה ביד, RoCode יכול לעשות את זה בפלייס שפתוח אצלכם. זה סוכן AI שעובד דרך פלאגין ל-Roblox Studio, ולכן הסקריפטים וה-Parts מופיעים ב-Explorer שלכם, ולא בחלון הצ׳אט, שממנו הייתם צריכים להדביק אותם.

אתם כותבים

תוסיף מערכת סיבובים: הפסקה של 20 שניות שצריכה 2 שחקנים, מפה אקראית מ-ServerStorage.Maps, טלפורט של כולם ל-Parts הלידה של המפה, סיבובים של 2 דקות שבהם השחקן האחרון שחי מנצח, תוסיף Win ל-leaderstats ותציג את הסטטוס והטיימר בראש המסך.

RoCode עושה
  • יכול קודם לסרוק את הפלייס שלכם עם List Children, Search Game ו-Search Scripts, כדי לקחת את התיקייה Maps ואת סקריפט ה-leaderstats שלכם, ולא להוסיף סט שני
  • יוצר את ה-Script של הסיבובים ב-ServerScriptService ואת ה-LocalScript של הטיימר עם Create Script, ויכול להציב זירה מהמבנים המוכנים שלו עם Place Prefab, אם עוד אין לכם מפה
  • בודק את הקומפילציה של כל סקריפט בתוך Studio עם Check Script לפני הסיום. זה תופס שגיאות תחביר, לא שגיאות בלוגיקה של הסיבוב
  • אחרי בדיקת המשחק שלכם, Check Output קורא את שורות ה-Server וה-Client מבדיקת המשחק האחרונה, כדי לתקן שגיאה בזמן ריצה

עם פלאגין 3.9 ומעלה RoCode יכול להריץ בדיקת משחק קצרה ולקרוא את השגיאות, ועם פלאגין 3.9.11 ומעלה יכול לשלוט בדמות בדיקה אחת, אבל עם כמה שחקנים הוא לא בודק, אז הריצו את הסיבובים בעצמכם במצב Server & Clients. כל קבוצת שינויים היא נקודת ביטול ב-Studio. לולאת סיבובים נמצאת בבסיס של הרבה משחקים, ויצירת משחק Roblox שלם עם AI, מערכת אחר מערכת מתחילה הרבה פעמים מלולאה כזו. איך RoCode מתחבר ל-Studio.

שאלות נפוצות

איך יוצרים מערכת סיבובים עם קבוצות ב-Roblox?

הוסיפו אובייקטי Team לשירות Teams וקבעו USE_TEAMS = true בסקריפט הסיבובים. Roblox משייכת שחקנים שנכנסים לקבוצה עם השיוך האוטומטי שיש בה הכי מעט חברים, והסיבוב נגמר כששחקנים חיים נשארו רק בקבוצה אחת.

איך מציגים ספירה לאחור לכל השחקנים?

קבעו מהשרת את השניות שנשארו כ-Attribute על אובייקט ב-ReplicatedStorage, והאזינו לו דרך GetAttributeChangedSignal ב-LocalScript שמעדכן TextLabel, כמו בשלב 3. שחקנים שנכנסו מאוחר יותר מקבלים מיד את הערך הנוכחי.

במה להשתמש בלולאת סיבובים: wait() או task.wait()?

השתמשו ב-task.wait(). Roblox מסמנת את wait() הגלובלי כמיושן וכמוחלף ב-task.wait().

איך משגרים שחקנים לפלייס אחר בכל סיבוב?

זה כלי אחר. המדריך הזה מעביר דמויות בתוך שרת אחד דרך PivotTo. שליחת שחקנים לפלייס אחר ב-experience שלכם עוברת דרך TeleportService, שמעביר אותם לשרת אחר. המדריך לטלפורטים בונה פורטלים שעושים את זה, עם ניסיונות חוזרים אם הטלפורט נכשל.

למה שחקנים קופאים לרגע אחרי טלפורט?

כש-instance streaming מופעל, הלקוח עוד לא קיבל את המפה. הקריאה ל-RequestStreamAroundAsync בסקריפט בזמן הספירה "להתכונן" מבקשת מהמנוע לשלוח אותה מראש; GET_READY_SECONDS ארוך יותר נותן לחיבורים איטיים יותר זמן.

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

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

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

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