教學 · 遊戲系統

如何在 Roblox Studio 製作回合系統

Roblox 上大多數回合制遊戲都在跑同一個循環:等待玩家、倒數到零、載入地圖、把所有人傳送過去、跑計時器、選出贏家,然後收拾乾淨。在這篇教學中,我們把這個循環做成一個清楚易懂的伺服器 Script,加上每位玩家都看得到的計時器,並說明那些讓複製來的 Script 出問題的情況:在回合中途死亡、離開或加入的玩家。

更新日期 2026年11月20日閱讀約 3 分鐘作者

重點摘要

在 ServerScriptService 中寫一個伺服器 Script,讓它不斷循環經過一組固定的狀態:中場等待(等到玩家人數足夠,再開始倒數)、載入地圖(把 ServerStorage 中的隨機地圖複製到 Workspace)、傳送(用 PivotTo 把每個活著的角色移到重生零件上)、回合(讓計時器倒數,直到時間用完,或只剩一位玩家或一支隊伍)以及收拾(發放 Wins、讓倖存者重生、刪除地圖)。

  • 循環只在伺服器上執行。把狀態與剩餘秒數以屬性發布在 ReplicatedStorage 中的 Folder 上,再交給 LocalScript 顯示。
  • 用一個表格記錄還在回合中的玩家。當玩家的 Humanoid 死亡、角色被移除或玩家離開時,就把他移出表格。
  • 只傳送回合開始那一刻角色還活著的玩家。晚加入的人在大廳等下一回合。
本頁內容
  1. 運作方式
  2. 1. 大廳與地圖
  3. 2. 回合 Script
  4. 各狀態的運作
  5. 3. 計時器 UI
  6. 回合中途的玩家
  7. 如何擴充
  8. Common errors
  9. 用 RoCode
  10. 常見問題
  11. 來源與延伸閱讀

回合系統如何運作

示意畫面完成的回合 Script 在執行中的遊戲裡,加速播放。

回合系統是一個狀態機。任何時候伺服器都只處於一個狀態,每個狀態只有一個任務,並由一個條件把它帶到下一個狀態。用這種方式撰寫,所有邏輯都集中在一個地方,也不會出現經典的錯誤:計時器的迴圈與回合的迴圈同時想結束同一個回合。

這篇教學中回合循環的各個狀態
狀態伺服器做什麼何時進入下一個狀態
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 中插入一個名為 Maps 的 Folder。ServerStorage 中的物件絕對不會傳送給玩家,所以沒用到的地圖對他們沒有任何負擔。
  3. 把每張地圖做成 Maps 裡的一個 Model,零件都要錨定。把它建在離大廳遠一點的地方(幾百 stud 就夠了),因為副本會剛好出現在你建造它的位置,而被淘汰的玩家不應該能走回去。
  4. 在每張地圖裡加入一個名為 Spawns 的 Folder,並在裡面為每位預期的玩家放一個錨定的 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

回合 Script 會替玩家 leaderstats 資料夾中名為 Wins 的 IntValue 加 1。如果你的遊戲還沒有 leaderstats,就加入這段簡短的 Script。如果已經有了,例如 排行榜教學中有存檔的版本,就跳過它:兩個建立 leaderstats 的 Script 會讓每位玩家有兩個資料夾。

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 中你可能會比這個 Script 更早加入,所以先設定已經在場的所有人
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

這些 Wins 會在玩家離開時重置。想讓它們在不同遊戲過程之間保留,請使用 排行榜教學中的 DataStore 版本。

步驟 2:加入回合 Script

在 ServerScriptService 中插入一個 Script,命名為 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()

-- 每位玩家畫面上顯示的內容,都存在這個資料夾的屬性中。
-- 由伺服器設定的屬性會複製到所有用戶端,包括晚加入的人。
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 說明(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,所以把它抬到站在零件上的高度
			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。用戶端只會收到 ReplicatedStorage.RoundInfo 上的三個屬性(State、Status 與 TimeLeft),以及每位玩家身上的 InRound 屬性。

每個狀態如何運作

等待與中場

runIntermission 會先讓循環停住,直到 #Players:GetPlayers() 達到 MIN_PLAYERS。接著用 task.wait(1) 每次倒數一秒,並在每一下檢查玩家人數。如果有人離開,伺服器人數低於下限,它就回傳 false,主循環從 Waiting 重新開始,所以回合永遠不會只有一個人就開始。

選擇與載入地圖

loadMap 會收集 ServerStorage.Maps 中所有的 Model,有得選時排除上一回合的地圖,再用 Random:NextInteger 選出一張。接著把地圖複製到 Workspace。原件在 ServerStorage 中保持不動,所以每回合都從全新的副本開始:玩家在上一回合破壞或移動的東西都會消失。

新的場景預設開啟 instance 串流:用戶端只擁有角色附近的零件。傳送之前,Script 會替每位玩家呼叫 Player:RequestStreamAroundAsync,請引擎在「準備」倒數期間把地圖周圍的區域傳給用戶端。少了這一步,玩家可能在地板載入之前就抵達,短暫地僵住。

用 PivotTo 傳送玩家

倒數結束後,Script 會從符合條件的玩家中組出參賽者名單:角色存在、仍在世界中,並且有生命值大於 0 的 Humanoid 與 root part。這個檢查是在倒數之後進行的,所以倒數期間死亡或離開的人不會被列入名單。

每位參賽者都用 character:PivotTo(cframe) 移動。Roblox 的說明把 PivotTo 稱為用 Script 移動模型的主要方式,它會讓角色的所有部分一起移動。設定 HumanoidRootPart.Position 不是同一回事:Roblox 會調整連接,只移動這一個部分,身體其餘部分可能會被留在原地。角色的 Pivot 就是它的 root part,所以目標是重生零件的 CFrame,往上抬高零件高度的一半,再加上 root part 站在地面上方的高度。rootHeight 用 Roblox Humanoid.HipHeight 說明中的公式來計算:root part 高度的一半加上 HipHeight,R6 骨架再加上腿長。這樣縮放過的與自訂的虛擬人偶就不會卡進零件,也不會從上方掉下來。CFrame 包含旋轉,所以玩家會面向重生零件面對的方向:把零件轉向,讓大家都面向地圖中央。

如果玩家比重生零件多,Script 會從第一個零件重新開始,玩家就會疊在一起,所以重生點的數量至少要和你的玩家人數上限一樣多。

如果你也使用 衝刺教學中的速度檢查,請在 startRound 中的 character:PivotTo(...) 之後立刻加上 player:SetAttribute("MovementCheckSkip", true),以免傳送被當成超速。

回合計時器與結束條件

runRound 每秒跳一次。每一下它都會更新狀態(還剩幾位玩家)與剩餘秒數,然後計算還活著的陣營。回合會以下列三種方式之一結束:

  • 時間用完。for 迴圈數到 1 並結束。
  • 只剩一個陣營。陣營是一位玩家,或在開啟 USE_TEAMS 時是一支隊伍。這個檢查只在回合以兩個以上陣營開始時才有作用,所以單人測試不會一開始就結束。
  • 沒有人留下。所有人都死了或離開了,回合在沒有贏家的情況下結束。

每秒檢查一次代表回合可能在最後一位玩家被淘汰後再多跑最多一秒,在回合計時器上這幾乎察覺不到。

發放 Wins 與顯示結果

這個 Script 的規則很簡單:回合結束時還活著的人都獲勝。這一行邏輯就涵蓋了最後倖存的玩家、最後倖存的隊伍,以及「撐到計時器結束」模式。finishRound 會替每位贏家的 Wins 加 1,停止監看他們,並顯示像 "Alex wins!" 這樣的訊息 RESULTS_SECONDS 秒。如果你希望時間用完時沒有贏家,就在 sidesLeft 大於 1 時跳過 awardWin 並更改訊息。不論哪種情況,都要繼續回傳名單,因為收拾時要靠它把倖存者送回大廳。

收拾

倖存者還站在地圖上,所以 cleanup 會用 Player:LoadCharacterAsync()(取代舊的 LoadCharacter)讓他們在大廳重生,再刪除地圖副本。每次重生都在自己的 task.spawn 中、包在 pcall 裡執行,因為這個呼叫會等待角色載入,如果玩家剛好在這時離開就可能失敗。被淘汰的玩家不需要做任何事:他們已經自己在大廳重生了。

步驟 3:讓每位玩家看到計時器與狀態

伺服器會在 ReplicatedStorage.RoundInfo 上發布三個屬性:State(固定的字詞,例如 InRound,給 Script 用)、Status(給人看的文字)與 TimeLeft(秒數)。伺服器 Script 在會複製的物件上設定的屬性會自動傳到每個用戶端,而在回合中途加入的玩家會立刻拿到目前的值。所以對計時器來說,這比 remote 更合適:在某人加入之前送出的 RemoteEvent,永遠不會送到他那裡。

  1. 在 Explorer 中,在 StarterGui 裡插入一個 ScreenGui,命名為 RoundHud。保持 ResetOnSpawn 開啟(預設值)。
  2. 在 RoundHud 中插入一個 LocalScript,命名為 RoundHudClient,並貼上下面的程式碼。它會自己建立文字標籤,所以不需要再畫任何東西。
  3. 按下 Play。畫面上方的文字會以 m:ss 格式顯示狀態與倒數。
LocalScript 位於 StarterGui 中的 ScreenGui RoundHud 名稱為 RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- 文字標籤。如果你在 RoundHud 中畫了自己的 TextLabel,請刪除這段並改用:
-- 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。Script 接著會重新讀取目前的屬性,所以文字永遠不會過時。

用戶端只負責讀取。玩家在自己畫面上改動的任何東西都不會影響真正的計時器,因為 LocalScript 對屬性的變更只會留在這一個用戶端上。如果要做到十分之一秒的倒數,伺服器可以改成在屬性中保存來自 workspace:GetServerTimeNow() 的結束時間,而每個用戶端每一影格都用自己的 workspace:GetServerTimeNow() 去相減。

如果你的遊戲以主選單開場,RoundHud 會在玩家按下 Play 時出現,因為 StarterGui 只會在角色重生後才複製給玩家。還在選單中的玩家沒有角色,所以永遠不會被傳送進回合。

在回合中途死亡、離開或加入的玩家

第一次寫回合 Script 時,這些情況很容易被忽略。如果其中哪一種沒處理好,通常你會在 Output 中看到錯誤,或回合永遠不會結束。下面是上面的 Script 對每種情況的處理方式。

特殊情況與回合 Script 的處理方式
情況會發生什麼在 Script 的哪裡
玩家在回合中死亡(被殺、自己重置、掉下去)他會被移出回合,並在 Players.RespawnTime(預設 5 秒)後於大廳重生。humanoid.Died 呼叫 eliminate
角色在沒有死亡的情況下被移除和死亡一樣:玩家被淘汰。player.CharacterRemoving 呼叫 eliminate
玩家離開伺服器他會被移除,他的連線會中斷,下一下會重新計算陣營。Players.PlayerRemoving 呼叫 eliminate
玩家在回合中途加入他在大廳重生,看得到即時的狀態與計時器,並參加下一回合。只在 startRound 中選出參賽者
回合開始時玩家已經死亡他不會被傳送,而是在大廳等待。getLivingCharacter
所有人都離開或死亡回合以 "Nobody survived" 結束,循環重新開始:伺服器人數還夠就進入 Intermission,否則進入 Waiting。runRound 中的 sidesLeft == 0

eliminate 寫成對同一位玩家呼叫多次也很安全。死亡後重生的玩家會同時觸發 Died 與 CharacterRemoving,而離開的人可能會觸發全部三個事件;只有第一次呼叫會做事。

如何擴充:隊伍、地圖投票與回合事件

最後倖存的隊伍

設定 USE_TEAMS = true,然後在 Explorer 的 Teams 服務中加入 Team 物件,每個都有自己的名稱與 TeamColor。預設情況下,Roblox 會把每位加入的玩家放進人數最少、可自動分配的隊伍。玩家離開時它不會重新平衡隊伍,所以在很長的遊戲過程中隊伍可能變得不平均。讓大廳的 SpawnLocation 保持 Neutral,這樣所有隊伍都會在那裡重生。之後回合會在只剩一支隊伍還有活著的玩家時結束,結果看起來像 "Red wins!"。

如果是「一對多」的玩法(一位獵人,其他人要存活),就在 startRound 中隨機選一位參賽者,並在傳送前把他的 Team 設為獵人隊伍。取消獵人隊伍的 AutoAssignable,讓新玩家永遠不會被分進去,並在 cleanup 中把獵人放回倖存者隊伍。這樣同樣的結束條件就能運作:所有倖存者都被淘汰時獵人獲勝,倖存者撐到計時器結束則倖存者獲勝,前提是時間用完時你要跳過獵人的 awardWin。

玩家投票選地圖

投票需要用戶端與伺服器溝通,也就是需要 RemoteEvent。中場期間,伺服器以屬性發布兩到三個地圖名稱,每個用戶端透過 RemoteEvent 傳送自己點選的名稱,伺服器在執行 loadMap 之前統計票數。伺服器必須檢查每一票:參數是字串、是目前的選項之一、狀態是 Intermission,而且每位玩家只算一次(把票存在以 Player 為鍵的表格中,讓第二票取代第一票,並在 PlayerRemoving 中清除)。RemoteEvent 教學詳細說明了這種檢查模式。

回合開始時發放工具

其他 Script 可以對回合做出反應,而不用動到 RoundSystem。回合 Script 在傳送玩家時會替他設定 InRound 屬性,玩家被淘汰時再清除。這個 Script 監聽這個屬性,並給每位玩家一份放在 ServerStorage、名為 RoundTool 的 Tool 副本。

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 會換上一個用 StarterPack 填好的新 Backpack,而收拾時的 LoadCharacterAsync 會清空倖存者的 Backpack,所以回合結束後工具就不在了。

如果需要發放武器,可以做一把劍或射線槍,把它放在 ServerStorage 而不是 StarterPack,並把這個 Script 中的 "RoundTool" 改成它的名稱。

只在回合期間存在的 NPC 與其他物件

任何只該在回合期間存在的東西都可以放在地圖模型裡:敵人、可撿取的物品、移動平台。ServerStorage 中模型裡的 Script 不會執行;副本一進入 Workspace 它們就會啟動,而收拾時的 map:Destroy() 會把它們連同其他東西一起刪除。要加入會追玩家的敵人,照著 NPC 尋路教學做一個並放進地圖。如果想在每回合開始時繞著地圖飛一圈,過場動畫教學會示範這個 Script 如何透過 BindableEvent 替每位玩家播放過場動畫。

如何把它改成模組

一開始不需要 ModuleScript。在你建構遊戲時,單一個 Script 比較容易閱讀。等到其他 Script 需要呼叫回合的函式,或你想把設定移到一個伺服器與 UI 都能用 require 載入的共用 ModuleScript 時,再把它拆開。在那之前,RoundInfo 上的 State 屬性與每位玩家身上的 InRound 屬性,就已經是回合系統的公開介面:任何 Script 都能監聽它們。

常見錯誤與解法

按下 Play 之前,先打開 Output 視窗(透過 Studio 的 Window 選單或 Script 分頁)。回合系統的大部分問題都會在那裡輸出帶有 Script 名稱與行號的警告或錯誤。

停在 "Waiting for players (1/2)"

你在單人測試,而 MIN_PLAYERS 是 2。單人測試時設為 1,或在 Server & Clients 模式下用 2 個用戶端測試。

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

這個資料夾不存在、名稱打錯了,或放在錯誤的服務裡。它必須是直接放在 ServerStorage 裡、名稱剛好是 Maps 的 Folder。如果 LocalScript 中出現 RoundInfo 的同樣警告,代表 RoundSystem Script 始終沒有執行到建立它的地方:它被停用了、因錯誤而中止,或還在等待 Maps 資料夾。

傳送後玩家掉穿地圖

地圖的零件沒有錨定,所以副本一進入 Workspace 就散開了。選取地圖、錨定它的零件,並確認重生零件在地板上方,而不是在地板裡面。

被淘汰的玩家在競技場上重生

地圖裡有 SpawnLocation。把它換成該地圖 Spawns 資料夾中的普通 Part。

所有人都死了,回合卻沒有結束

確認你的傷害真的會殺死 Humanoid(生命值降到 0),而不是移動或錨定玩家。如果你停用了 Humanoid 的 Dead 狀態,Died 永遠不會觸發,回合就只能跑到計時器結束。

回合循環在一次錯誤後就永久停止

循環在單一執行緒中執行,所以任何狀態中的錯誤都會讓它結束。閱讀 Output 中的錯誤,修正那一行再重新測試。常見原因:Script 被改成直接使用 player.Character.Humanoid,卻沒有先確認角色存在。

用 RoCode 製作

如果不想手動組裝這些東西,RoCode 可以在你開啟的場景中完成。它是透過 Roblox Studio 外掛程式運作的 AI 代理,所以 Script 與零件會出現在你的 Explorer 中,而不是出現在聊天視窗裡,讓你還得自己貼上。

你輸入

加入回合系統:需要 2 位玩家的 20 秒中場等待、從 ServerStorage.Maps 隨機選地圖、把所有人傳送到地圖的重生零件、每回合 2 分鐘且最後活著的玩家獲勝,在 leaderstats 加上 Win,並在畫面上方顯示狀態與計時器。

RoCode 會做
  • 可以先用 List Children、Search Game 與 Search Scripts 查看你的場景,沿用你的 Maps 資料夾與 leaderstats Script,而不是再加一套
  • 用 Create Script 在 ServerScriptService 中建立回合 Script 與計時器 LocalScript,如果你還沒有地圖,也可以用 Place Prefab 從它現成的建築中放一個競技場
  • 完成之前,用 Check Script 在 Studio 中檢查每個 Script 能否編譯。這能抓出語法錯誤,而不是回合邏輯的錯誤
  • 在你試玩測試之後,Check Output 會讀取上一次試玩測試的 Server 與 Client 輸出,以修正執行時的錯誤

搭配外掛程式 3.9 或更新版本,RoCode 可以執行簡短的試玩測試並讀取錯誤;搭配外掛程式 3.9.11 或更新版本,它可以控制一個測試角色,但它不會用多位玩家測試,所以請你自己在 Server & Clients 模式下跑回合。每一批變更都是 Studio 中的一個復原點。回合循環是許多遊戲的基礎,而用 AI 一個系統接一個系統做出完整的 Roblox 遊戲常常就是從這樣的循環開始。RoCode 如何連接 Studio。

常見問題

如何在 Roblox 製作有隊伍的回合系統?

在 Teams 服務中加入 Team 物件,並在回合 Script 中設定 USE_TEAMS = true。Roblox 會把加入的玩家分進人數最少、可自動分配的隊伍,而回合會在只剩一支隊伍還有活著的玩家時結束。

如何讓所有玩家看到倒數?

從伺服器把剩餘秒數設成 ReplicatedStorage 中某個物件的屬性,並在更新 TextLabel 的 LocalScript 中用 GetAttributeChangedSignal 監聽它,就像步驟 3 那樣。晚加入的玩家會立刻拿到目前的值。

回合循環中該用 wait() 還是 task.wait()?

使用 task.wait()。Roblox 把全域的 wait() 標示為已淘汰,並由 task.wait() 取代。

如何在每回合把玩家傳送到另一個場景?

那是另一種工具。這篇教學是用 PivotTo 在同一個伺服器內移動角色。把玩家送到你 experience 中的另一個場景要透過 TeleportService,它會把他們移到另一個伺服器。傳送教學會做出能這麼做的傳送門,並在傳送失敗時重試。

為什麼玩家傳送後會短暫僵住?

開啟 instance 串流時,用戶端還沒收到地圖。Script 在「準備」倒數期間呼叫 RequestStreamAroundAsync,請引擎提前把地圖傳過去;較長的 GET_READY_SECONDS 能給連線較慢的玩家更多時間。

來源與延伸閱讀

程式碼如何驗證:本頁每一段 Script 都通過 Luau 嚴格型別檢查,並使用 Roblox API 定義(luau-lsp,2026年11月20日)。型別檢查能找出拼錯的 API 與錯誤的型別,但無法檢查遊戲邏輯,所以發布前請先在 Studio 中測試。

在你自己的遊戲裡試試 RoCode。

每天都有免費點數,不需要信用卡。安裝外掛程式,描述你要的功能,再看看 Studio 裡出現了什麼。