בקצרה
כתבו Script שרת אחד ב-ServerScriptService, שעובר במחזור על קבוצה קבועה של מצבים: הפסקה (לחכות למספר השחקנים הנדרש, ואז ספירה לאחור), טעינת מפה (לשכפל מפה אקראית מ-ServerStorage ל-Workspace), טלפורט (להעביר כל דמות חיה ל-Part לידה דרך PivotTo), סיבוב (להריץ טיימר עד שהזמן נגמר או שנשאר שחקן אחד או קבוצה אחת) וניקוי (לתת Wins, להחזיר את השורדים לחיים, למחוק את המפה).
- הריצו את הלולאה רק בשרת. פרסמו את הסטטוס ואת השניות שנשארו כ-Attributes על Folder ב-ReplicatedStorage, ותנו ל-LocalScript להציג אותם.
- החזיקו טבלה של מי שעדיין בסיבוב. הסירו שחקן כשה-Humanoid שלו מת, כשהדמות שלו נמחקת או כשהוא יוצא.
- שגרו רק שחקנים שהדמות שלהם חיה ברגע תחילת הסיבוב. מי שנכנס מאוחר יותר מחכה בלובי לבא.
בעמוד הזה
איך מערכת סיבובים עובדת
מערכת סיבובים היא מכונת מצבים. בכל רגע השרת נמצא בדיוק במצב אחד, לכל מצב משימה אחת, ותנאי אחד מעביר אותו למצב הבא. כשכותבים כך, כל הלוגיקה נמצאת במקום אחד, ולא נוצר הבאג הקלאסי שבו לולאת הטיימר ולולאת הסיבוב מנסות שתיהן לסיים את אותו סיבוב.
| מצב | מה השרת עושה | מתי עוברים הלאה |
|---|---|---|
| Waiting | מציג "Waiting for players (1/2)" | בשרת יש מספיק שחקנים |
| Intermission | סופר את הזמן בזמן שכולם בלובי | הספירה הסתיימה (או חזרה ל-Waiting, אם שחקנים יצאו) |
| Starting | מעתיק מפה אקראית ל-Workspace, מציג את השם שלה, מבקש מהלקוחות לטעון אותה | הספירה הקצרה "להתכונן" הסתיימה |
| InRound | משגר שחקנים חיים, מריץ טיימר, מסיר את מי שמת או יצא | הזמן נגמר, או שנשאר שחקן אחד או קבוצה אחת |
| Results | נותן Win לכל מי שעדיין חי, ומציג מי ניצח | עברו כמה שניות |
| Cleanup | מחזיר את השורדים לחיים בלובי ומוחק את המפה | מיד, ואז הלולאה מתחילה מחדש |
השרת הוא הבעלים של כל מצב. הלקוחות רק מציגים את מה שהשרת אומר להם. ספירה לאחור ב-LocalScript סוטה מהאמיתית, שגויה אצל מי שנכנס מאוחר יותר, ואקספלויטר יכול לשנות אותה. אם ההפרדה בין שרת ללקוח חדשה לכם, קראו קודם את Script vs LocalScript vs ModuleScript.
שלב 1: בנו את הלובי, המפות והמאפיין Wins
- בנו לובי ב-Workspace עם
SpawnLocation. בדקו שהמאפיין Neutral שלו מסומן, כדי שכל שחקן ייוולד כאן, יחכה כאן ויחזור לכאן אחרי שהודח. - ב-ServerStorage הכניסו
FolderבשםMaps. אובייקטים ב-ServerStorage אף פעם לא נשלחים לשחקנים, ולכן מפות שלא בשימוש לא עולות להם כלום. - בנו כל מפה כ-
ModelבתוךMaps, עם Parts מעוגנים. בנו אותה רחוק מהלובי (כמה מאות studs מספיקים), כי העותק מופיע בדיוק במקום שבו בניתם אותה, ושחקנים שהודחו לא אמורים להיות מסוגלים להיכנס בחזרה. - בתוך כל מפה הוסיפו
FolderבשםSpawns, ובתוכוPartמעוגן אחד לכל שחקן צפוי. קבעו להם Transparency 1 וכבו CanCollide, כדי שאף אחד לא יראה אותם ולא ייתקל בהם.
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 נותנים לכל שחקן שתי תיקיות.
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 והדביקו את הקוד שלמטה. ההגדרות למעלה הן השורות היחידות שכנראה תצטרכו לשנות. כל מצב הוא פונקציה נפרדת, והלולאה שלמטה מריצה אותן לפי הסדר, בלי סוף.
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 שנשלח לפני שמישהו נכנס לא יגיע אליו אף פעם.
- ב-Explorer הכניסו ScreenGui ל-StarterGui וקראו לו
RoundHud. השאירו את ResetOnSpawn מופעל (ברירת מחדל). - הכניסו LocalScript ל-
RoundHud, קראו לוRoundHudClientוהדביקו את הקוד שלמטה. הוא יוצר את הכיתוב בעצמו, אז לא צריך לצייר שום דבר נוסף. - לחצו על Play. הכיתוב בראש המסך מציג את הסטטוס ואת הספירה בפורמט
m:ss.
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.
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 ותציג את הסטטוס והטיימר בראש המסך.
- יכול קודם לסרוק את הפלייס שלכם עם 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 ארוך יותר נותן לחיבורים איטיים יותר זמן.
מקורות וקריאה נוספת
- Roblox Creator Docs: Add rounds (באנגלית). לולאת הסיבובים הקבוצתית של Roblox עצמה, בדוגמה עם לייזר טאג
- Roblox Creator Docs: PVInstance:PivotTo (באנגלית). הזזת מודלים ודמויות מסקריפט
- Roblox Creator Docs: Player (באנגלית). LoadCharacterAsync, CharacterRemoving ו-RequestStreamAroundAsync
- Roblox Creator Docs: Properties and attributes (באנגלית). קביעת Attributes ומעקב אחרי שינויים
- Roblox Creator Docs: Implement teams (באנגלית). הוספת קבוצות ושיוך אוטומטי
- Roblox Creator Docs: Studio testing modes (באנגלית). בדיקה עם כמה לקוחות, Server & Clients
איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.