教程 · 游戏系统

Roblox Studio 怎么做回合系统

Roblox 上大多数回合制游戏都在跑同一个循环:等待玩家,倒计时,加载地图,把所有人传送过去,运行计时器,选出胜者,然后清理。在本教程中,我们把这个循环写成一个清晰的服务端脚本,加上每名玩家都能看到的计时器,并讲解那些让复制来的脚本出问题的情况:回合中途死亡、退出或加入的玩家。

更新于 2026年11月20日阅读约 3 分钟作者

要点

在 ServerScriptService 中写一个服务端 Script,让它循环经过一组固定的状态:休息时间(等到足够的玩家,然后倒计时)、加载地图(从 ServerStorage 克隆一张随机地图到 Workspace)、传送(用 PivotTo 把每个活着的角色移到出生零件上)、回合(计时器一直走,直到时间用完或只剩一名玩家或一支队伍)和清理(发放 Wins,让幸存者重生,删除地图)。

  • 只在服务端运行循环。把状态和剩余秒数作为属性发布在 ReplicatedStorage 中的一个 Folder 上,由 LocalScript 负责显示。
  • 维护一张仍在回合中的玩家表。当玩家的 Humanoid 死亡、角色被删除或玩家退出时,把他移出。
  • 只传送回合开始时角色活着的玩家。之后加入的人在大厅等待下一回合。
本页内容
  1. 工作原理
  2. 1. 大厅和地图
  3. 2. 回合脚本
  4. 各状态的工作方式
  5. 3. 计时器界面
  6. 回合中途的玩家
  7. 如何扩展
  8. Common errors
  9. 用 RoCode
  10. 常见问题
  11. 参考资料

回合系统的工作原理

示意运行中的游戏里完成的回合脚本,已加速。

回合系统是一个状态机。任何时刻服务端都正好处于一个状态,每个状态只有一个任务,由一个条件把它切换到下一个状态。这样写的话,所有逻辑都集中在一个地方,也不会出现计时器循环和回合循环都想结束同一个回合的经典 bug。

本教程中回合循环的各个状态
状态服务端做什么何时进入下一个状态
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

回合脚本会给玩家 leaderstats 文件夹中名为 Wins 的 IntValue 加 1。如果你的游戏还没有 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 步:添加回合脚本

在 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 streaming):客户端只拥有自己角色附近的零件。传送之前,脚本会为每名玩家调用 Player:RequestStreamAroundAsync,请引擎在“准备”倒计时期间把地图周围的区域发送给客户端。没有这一步,玩家可能在地面加载出来之前就到达,并短暂地卡住不动。

用 PivotTo 传送玩家

倒计时结束后,脚本从玩家中收集参与者名单:角色存在、仍在世界中,并且拥有生命值大于 0 的 Humanoid 和 root part。这个检查在倒计时之后进行,所以倒计时期间死亡或退出的人不会进入名单。

每名参与者都通过 character:PivotTo(cframe) 移动。Roblox 参考文档把 PivotTo 称为用脚本移动模型的主要方式,它会让角色的所有部分一起移动。设置 HumanoidRootPart.Position 不是一回事:Roblox 会调整连接,结果只有这一个部件移动,身体的其余部分可能被留在后面。角色的 pivot 是它的 root part,所以目标是出生零件的 CFrame,再抬高零件高度的一半,加上 root part 站立时离地面的高度。rootHeight 按照 Roblox 关于 Humanoid.HipHeight 的参考文档中的公式计算这个高度:root part 高度的一半加上 HipHeight,R6 绑定还要加上腿的长度。这样缩放过的和自定义的头像就不会卡进零件里,也不会从上方掉到零件上。CFrame 包含旋转,所以玩家会面朝出生零件所朝的方向:把零件转好,让所有人都面向地图中心。

如果玩家比出生零件多,脚本会从第一个零件重新开始,玩家会叠在一起,所以添加的出生点至少要和你的最大玩家人数一样多。

如果你还使用了 冲刺教程 中的速度检查,请在 startRound 中紧接着 character:PivotTo(...) 之后添加 player:SetAttribute("MovementCheckSkip", true),这样传送就不会被当作超速。

回合计时器和结束条件

runRound 每秒走一次。每一秒它都会更新状态(还剩几名玩家)和剩余秒数,然后统计活着的阵营。回合以三种方式之一结束:

  • 时间用完。for 循环走到 1 并结束。
  • 只剩一个阵营。阵营是一名玩家,或者在启用 USE_TEAMS 时是一支队伍。只有回合以两个或更多阵营开始时,这个检查才起作用,所以单人测试不会在开始的那一刻就结束。
  • 一个人都不剩。所有人都死亡或退出了,回合在没有胜者的情况下结束。

每秒检查一次意味着在最后一名玩家出局后,回合可能还会再持续最多一秒,在回合计时器上这几乎察觉不到。

发放 Wins 和显示结果

这个脚本的规则很简单:回合结束时还活着的所有人都获胜。这一行逻辑同时涵盖了最后幸存的玩家、最后幸存的队伍,以及“坚持到计时器结束”模式。finishRound 给每名胜者的 Wins 加 1,停止监视他们,并显示一条类似 "Alex wins!" 的消息,持续 RESULTS_SECONDS。如果你希望时间用完时没有胜者,就在 sidesLeft 大于 1 时跳过 awardWin 并修改消息。无论哪种情况都要继续返回这个列表,因为清理时要按它把幸存者送回大厅。

清理

幸存者还站在地图上,所以 cleanup 通过 Player:LoadCharacterAsync() 让他们在大厅重生(它取代了旧的 LoadCharacter),然后删除地图副本。每次重生都在各自的 task.spawn 中、放在 pcall 里进行,因为这个调用会等待角色加载,如果玩家恰好在这时退出,就可能出错。出局的玩家什么都不需要:他们已经自己在大厅重生了。

第 3 步:向每名玩家显示计时器和状态

服务端在 ReplicatedStorage.RoundInfo 上发布三个属性:State(像 InRound 这样的固定单词,给脚本用)、Status(给人看的文字)和 TimeLeft(秒数)。服务端脚本在会复制的对象上设置的属性会自动到达每个客户端,回合中途加入的玩家也会立即得到当前的值。所以对计时器来说,这比 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 副本。脚本会重新读取当前的属性,所以文字永远不会过时。

客户端只负责读取。玩家在自己屏幕上改动的任何东西都不会影响真正的计时器,因为 LocalScript 对属性的修改只留在这一个客户端上。如果想要精确到十分之一秒的倒计时,服务端可以改为在属性中保存来自 workspace:GetServerTimeNow() 的结束时间,每个客户端每一帧用它减去自己的 workspace:GetServerTimeNow()。

如果你的游戏以 主菜单 开始,RoundHud 会在玩家点击 Play 时出现,因为 StarterGui 只在角色出生后才复制给玩家。还在菜单中的玩家没有角色,所以永远不会被传送进回合。

回合中途死亡、退出或加入的玩家

第一次写回合脚本时,这些情况很容易被漏掉。如果其中某种情况没有处理,你通常会在 Output 中看到错误,或者遇到一个永远不结束的回合。下面是上面的脚本对每种情况的处理。

边界情况以及回合脚本如何处理它们
情况会发生什么在脚本中的位置
玩家在回合中死亡(被杀、重置、掉落)他被移出回合,并在 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 教程 详细讲解了这种检查模式。

回合开始时发放工具

其他脚本可以对回合做出反应,而不用动 RoundSystem。回合脚本在传送每名玩家时给他设置 InRound 属性,并在玩家出局时取消它。这个脚本监听这个属性,给每名玩家发一份放在 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 中,并把这个脚本里的 "RoundTool" 改成它的名字。

只在回合期间存在的 NPC 和其他对象

所有只应在回合期间存在的东西都可以放在地图模型里:敌人、可拾取的物品、移动平台。ServerStorage 中模型里的脚本不会运行;副本一进入 Workspace,它们就会启动,而清理时的 map:Destroy() 会把它们和其他一切一起删除。要添加追逐玩家的敌人,请按照 NPC 寻路教程 搭建一个,然后放进地图。要在每回合开始时环绕地图飞行展示,过场动画教程 展示了这个脚本如何通过 BindableEvent 为每名玩家播放过场动画。

如何把它做成模块

一开始不需要 ModuleScript。在你搭建游戏的过程中,一个 Script 更容易阅读。当其他脚本需要调用回合函数,或者你想把设置放进一个服务端和界面都能通过 require 引用的共享 ModuleScript 时,再把它拆开。在那之前,RoundInfo 上的 State 属性和每名玩家身上的 InRound 属性已经起到了回合系统公开接口的作用:任何脚本都可以监听它们。

常见错误与解决办法

在点击 Play 之前打开 Output 窗口(通过 Studio 的 Window 菜单或 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 脚本一直没走到创建它的那一步:它被禁用了、出错了,或者还在等待 Maps 文件夹。

传送后玩家掉出地图

地图的零件没有锚定,所以副本一进入 Workspace 就散架了。选中地图,锚定它的零件,并检查出生零件是否在地面上方,而不是在地面里面。

出局的玩家在竞技场里重生

地图里有一个 SpawnLocation。把它换成这张地图 Spawns 文件夹中的普通 Part。

所有人都死了,回合却不结束

检查你的伤害是否真的杀死了 Humanoid(生命值降到 0),而不是移动或锚定了玩家。如果你禁用了 Humanoid 的 Dead 状态,Died 就永远不会触发,回合只能一直走到计时器结束。

一次错误后回合循环就永久停止了

循环在一个线程中运行,所以任何状态中的错误都会终止它。阅读 Output 中的错误,修复那一行,然后重新测试。常见原因:脚本被改成了在没有检查角色是否存在的情况下使用 player.Character.Humanoid。

用 RoCode 来做

如果不想手动搭建这一切,RoCode 可以在你打开的场景中完成。它是通过 Roblox Studio 插件工作的 AI 代理,所以脚本和零件会出现在你的 Explorer 中,而不是出现在聊天窗口里让你再去粘贴。

你输入

添加一个回合系统:需要 2 名玩家的 20 秒休息时间,从 ServerStorage.Maps 中随机选地图,把所有人传送到地图的出生零件上,每回合 2 分钟,最后活着的玩家获胜,在 leaderstats 中加一次 Win,并在屏幕顶部显示状态和计时器。

RoCode 的操作
  • 可以先通过 List Children、Search Game 和 Search Scripts 浏览你的场景,使用你的 Maps 文件夹和 leaderstats 脚本,而不是再添加一套
  • 通过 Create Script 在 ServerScriptService 中创建回合 Script 和计时器 LocalScript;如果你还没有地图,还可以通过 Place Prefab 用它的现成建筑放置一个竞技场
  • 完成之前在 Studio 内通过 Check Script 检查每个脚本能否编译。这能发现语法错误,而不是回合逻辑的错误
  • 你做完游戏测试后,Check Output 会读取上一次游戏测试中的 Server 和 Client 行,以便修复运行时错误

使用插件 3.9 或更新版本时,RoCode 可以运行一次简短的游戏测试并读取错误;使用插件 3.9.11 或更新版本时,它可以控制一个测试角色,但它不做多人测试,所以请你自己在 Server & Clients 模式下把回合跑一遍。每一批修改都是 Studio 中的一个撤销点。回合循环是许多游戏的基础,用 AI 一个系统一个系统地制作完整的 Roblox 游戏 往往就从这样一个循环开始。RoCode 如何连接 Studio。

常见问题

Roblox 怎么做带队伍的回合系统?

往 Teams 服务添加 Team 对象,并在回合脚本中设置 USE_TEAMS = true。Roblox 会把加入的玩家分到人数最少的自动分配队伍,当活着的玩家只剩一支队伍时回合结束。

怎么向所有玩家显示倒计时?

从服务端把剩余秒数设置为 ReplicatedStorage 中某个对象的属性,并在 LocalScript 中通过 GetAttributeChangedSignal 监听它,更新 TextLabel,就像第 3 步那样。后来加入的玩家会立即得到当前的值。

回合循环里该用 wait() 还是 task.wait()?

使用 task.wait()。Roblox 把全局的 wait() 标记为已弃用,并由 task.wait() 取代。

怎么在每个回合把玩家传送到另一个场景?

那是另一种工具。本教程通过 PivotTo 在同一台服务器内移动角色。把玩家送到你体验中的另一个场景要通过 TeleportService,它会把他们转到另一台服务器。传送教程 搭建了实现这一点的传送门,并在传送失败时重试。

为什么传送后玩家会短暂地卡住不动?

启用实例流式传输时,客户端还没有收到地图。脚本在“准备”倒计时期间调用 RequestStreamAroundAsync,请引擎提前发送它;更长的 GET_READY_SECONDS 能给慢速网络更多时间。

参考资料

代码如何验证:本页的所有脚本都已用 Roblox API 类型定义(luau-lsp,2026年11月20日)通过 Luau strict 类型检查。类型检查能发现 API 名称写错和类型不匹配,但发现不了游戏逻辑上的错误。发布前请务必在 Studio 中测试。

在你自己的游戏里试试 RoCode。

每天有免费额度,无需绑定银行卡。安装插件,描述你想要的功能,然后看看它在 Studio 里做了什么。