Hướng dẫn · Hệ thống game

Cách làm hệ thống vòng chơi trong Roblox Studio

Phần lớn game theo vòng trên Roblox đều chạy cùng một chu trình: chờ người chơi, đếm ngược, tải map, dịch chuyển mọi người tới đó, chạy timer, chọn người thắng và dọn dẹp. Trong hướng dẫn này chúng ta dựng chu trình đó thành một script server dễ hiểu, thêm một timer mà người chơi nào cũng thấy, và xem các trường hợp làm hỏng script sao chép trên mạng: người chơi chết, thoát hoặc vào giữa vòng.

Cập nhật ngày 20 tháng 11, 202617 phút đọcTác giả:

Tóm tắt

Viết một Script server trong ServerScriptService, lặp đi lặp lại qua một tập trạng thái cố định: intermission (chờ đủ số người chơi, rồi đếm ngược), tải map (clone một map ngẫu nhiên từ ServerStorage vào Workspace), dịch chuyển (đưa mọi nhân vật còn sống tới một part spawn bằng PivotTo), vòng chơi (chạy timer cho tới khi hết giờ hoặc chỉ còn một người chơi hay một đội) và dọn dẹp (trao Wins, hồi sinh người sống sót, xóa map).

  • Chỉ chạy chu trình trên server. Đăng trạng thái và số giây còn lại dưới dạng attribute trên một Folder trong ReplicatedStorage, còn việc hiển thị để LocalScript lo.
  • Giữ một bảng những người còn trong vòng. Loại người chơi khi Humanoid của họ chết, nhân vật bị xóa hoặc họ thoát game.
  • Chỉ dịch chuyển những người chơi có nhân vật còn sống lúc vòng bắt đầu. Ai vào sau thì chờ ở lobby tới vòng tiếp theo.
Trong trang này
  1. Cách hoạt động
  2. 1. Lobby và map
  3. 2. Script vòng chơi
  4. Cách các trạng thái chạy
  5. 3. UI timer
  6. Người chơi giữa vòng
  7. Cách mở rộng
  8. Common errors
  9. Với RoCode
  10. Câu hỏi thường gặp
  11. Nguồn và tài liệu đọc thêm

Hệ thống vòng chơi hoạt động thế nào

Minh họaCác script vòng chơi hoàn chỉnh trong một game đang chạy, tua nhanh.

Hệ thống vòng chơi là một máy trạng thái. Tại mọi thời điểm server ở đúng một trạng thái, mỗi trạng thái có một nhiệm vụ, và một điều kiện chuyển nó sang trạng thái tiếp theo. Viết theo cách này thì toàn bộ logic nằm ở một chỗ, và không xảy ra lỗi kinh điển khi vòng lặp timer và vòng lặp vòng chơi cùng cố kết thúc một vòng.

Các trạng thái của chu trình vòng chơi trong hướng dẫn này
Trạng tháiServer làm gìKhi nào chuyển tiếp
WaitingHiện "Waiting for players (1/2)"Server có đủ người chơi
IntermissionĐếm ngược trong khi mọi người ở lobbyĐếm ngược xong (hoặc quay về Waiting nếu người chơi thoát)
StartingSao chép một map ngẫu nhiên vào Workspace, hiện tên map, yêu cầu client tải nóHết đoạn đếm ngược ngắn "chuẩn bị"
InRoundDịch chuyển người chơi còn sống, chạy timer, loại ai chết hoặc thoátHết giờ, hoặc chỉ còn một người chơi hay một đội
ResultsTrao một Win cho mọi người còn sống và hiện ai thắngSau vài giây
CleanupHồi sinh người sống sót ở lobby và xóa mapNgay lập tức, rồi chu trình bắt đầu lại

Mọi trạng thái đều do server nắm. Client chỉ hiển thị những gì server bảo. Một bộ đếm ngược trong LocalScript sẽ lệch với bộ đếm thật, sai với người vào sau, và exploiter có thể sửa nó. Nếu việc chia server và client còn mới với bạn, hãy đọc Script vs LocalScript vs ModuleScript trước.

Bước 1: Dựng lobby, map và chỉ số Wins

  1. Xây một lobby trong Workspace có SpawnLocation. Kiểm tra rằng thuộc tính Neutral của nó được tích, để mọi người chơi spawn ở đây, chờ ở đây và quay về đây sau khi bị loại.
  2. Trong ServerStorage, chèn một Folder tên Maps. Mọi thứ trong ServerStorage không bao giờ được gửi tới người chơi, nên các map chưa dùng không tốn gì của họ.
  3. Dựng mỗi map thành một Model bên trong Maps, với các part đã bật Anchored. Xây nó cách xa lobby (vài trăm stud là đủ), vì bản sao xuất hiện đúng chỗ bạn đã xây, và người chơi bị loại không được có cách đi bộ quay lại.
  4. Bên trong mỗi map, thêm một Folder tên Spawns, trong đó có một Part đã Anchored cho mỗi người chơi bạn dự kiến. Đặt Transparency của chúng là 1 và tắt CanCollide, để không ai thấy hay vấp phải chúng.
Explorer sau hướng dẫn này
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 vòng chơi cộng 1 vào một IntValue tên Wins bên trong folder leaderstats của người chơi. Nếu game của bạn chưa có leaderstats, hãy thêm script ngắn này. Nếu đã có rồi, ví dụ bản có lưu dữ liệu từ hướng dẫn bảng xếp hạng, hãy bỏ qua nó: hai script cùng tạo leaderstats sẽ cho mỗi người chơi hai folder.

Script trong ServerScriptService tên là Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- tên phải đúng như thế này, viết thường

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

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- Trong Studio bạn có thể vào trước khi script này chạy, nên thiết lập cho mọi người đã có mặt
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Số Wins này bị reset khi người chơi thoát. Để chúng được giữ giữa các phiên, hãy dùng bản có DataStore trong hướng dẫn bảng xếp hạng.

Bước 2: Thêm script vòng chơi

Chèn một Script vào ServerScriptService, đặt tên là RoundSystem và dán đoạn code bên dưới. Phần cài đặt ở đầu là những dòng duy nhất bạn có lẽ sẽ phải đổi. Mỗi trạng thái là một hàm riêng, và vòng lặp ở cuối chạy chúng theo thứ tự, mãi mãi.

Script trong ServerScriptService tên là RoundSystem
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Cài đặt
local MIN_PLAYERS = 2 -- đặt 1 khi bạn test một mình
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: vòng kết thúc khi chỉ còn người chơi của một đội

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

-- Những gì màn hình mỗi người chơi hiển thị được lưu trong attribute trên folder này.
-- Attribute do server đặt được replicate tới mọi client, kể cả người vào sau.
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

-- Ai còn trong vòng hiện tại, và các connection theo dõi từng người
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)

-- Trả về nhân vật và Humanoid chỉ khi người chơi đang sống ngay lúc này
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

-- Đếm số phe còn lại trong vòng (người chơi, hoặc đội nếu bật 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

-- TRẠNG THÁI: Waiting và Intermission. Trả về false nếu người chơi thoát trong lúc đếm ngược.
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

-- TRẠNG THÁI: Starting, phần 1. Sao chép một map ngẫu nhiên (khác map trước, nếu có lựa chọn).
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
	-- Xáo trộn để người chơi không rơi vào cùng một spawn mỗi vòng
	for i = #points, 2, -1 do
		local j = random:NextInteger(1, i)
		points[i], points[j] = points[j], points[i]
	end
	return points
end

-- Độ cao của root part so với sàn khi nhân vật đứng.
-- Công thức lấy từ tài liệu Roblox về Humanoid.HipHeight (rig R6 cộng thêm chiều cao chân).
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

-- TRẠNG THÁI: Starting, phần 2. Chuẩn bị, rồi dịch chuyển mọi người còn sống.
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

	-- Khi bật streaming, yêu cầu mỗi client tải map trước khi nhân vật tới nơi
	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

	-- Chỉ ai đang sống ngay lúc này mới tham gia. Những người khác chờ vòng sau.
	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 của nhân vật là root part, nên nâng nó lên độ cao đứng trên 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

-- TRẠNG THÁI: InRound. Kết thúc khi hết giờ hoặc chỉ còn một phe.
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()
		-- Vòng bắt đầu chỉ với một phe (test một mình) chỉ kết thúc khi hết giờ hoặc khi chết
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- TRẠNG THÁI: Results. Mọi người còn sống đều thắng.
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) -- ngừng theo dõi họ; họ ở lại trên map tới lúc dọn dẹp
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- TRẠNG THÁI: Cleanup. Đưa người sống sót về lobby, rồi xóa map.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- vẫn còn trên server
			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

-- Chu trình: mỗi lượt là một vòng
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) -- chưa có map: lát nữa thử lại
		end
	end
end

Mọi thứ quan trọng đều diễn ra ở đây, trên server: ai đang trong vòng, timer, người thắng và Wins. Client chỉ nhận ba attribute trên ReplicatedStorage.RoundInfo (State, Status và TimeLeft) và attribute InRound trên mỗi người chơi.

Từng trạng thái hoạt động thế nào

Chờ và intermission

runIntermission trước hết giữ chu trình lại cho tới khi #Players:GetPlayers() đạt MIN_PLAYERS. Sau đó nó đếm ngược từng giây bằng task.wait(1) và kiểm tra số người chơi ở mỗi nhịp. Nếu có người thoát và server còn ít hơn mức tối thiểu, nó trả về false, và vòng lặp chính bắt đầu lại từ Waiting, nên vòng chơi không bao giờ bắt đầu với chỉ một người.

Chọn và tải map

loadMap gom mọi Model trong ServerStorage.Maps, bỏ map của vòng trước nếu còn lựa chọn khác, và chọn một map bằng Random:NextInteger. Sau đó nó clone map vào Workspace. Bản gốc vẫn nguyên vẹn trong ServerStorage, nên mỗi vòng bắt đầu với một bản sao mới: mọi thứ người chơi phá hay dời đi ở vòng trước đều biến mất.

Các place mới bật sẵn instance streaming: client chỉ có các part ở gần nhân vật của mình. Trước khi dịch chuyển, script gọi Player:RequestStreamAroundAsync cho từng người chơi, yêu cầu engine gửi vùng quanh map tới client trong lúc đếm ngược "chuẩn bị". Không có bước này, người chơi có thể tới nơi trước khi sàn tải xong và bị đứng hình trong chốc lát.

Dịch chuyển người chơi bằng PivotTo

Sau khi đếm ngược, script lập danh sách người tham gia từ những người chơi có nhân vật tồn tại, vẫn ở trong thế giới, và có Humanoid với máu lớn hơn 0 cùng một root part. Bước kiểm tra này diễn ra sau khi đếm ngược, nên ai chết hoặc thoát trong lúc đó sẽ không vào danh sách.

Mỗi người tham gia được di chuyển bằng character:PivotTo(cframe). Tài liệu Roblox gọi PivotTo là cách chính để di chuyển model từ script, và nó di chuyển mọi phần của nhân vật cùng lúc. Đặt HumanoidRootPart.Position thì khác: Roblox điều chỉnh các khớp nối sao cho chỉ phần đó di chuyển, và phần còn lại của cơ thể có thể bị bỏ lại. Pivot của nhân vật là root part, nên đích đến là CFrame của part spawn, nâng lên một nửa chiều cao của part cộng với độ cao mà root part đứng trên sàn. rootHeight tính độ cao đó theo công thức trong tài liệu Roblox về Humanoid.HipHeight: một nửa chiều cao root part cộng HipHeight, cộng chiều dài chân với rig R6. Nhờ vậy avatar được phóng to thu nhỏ hay avatar tùy chỉnh không bị kẹt trong part và không rơi xuống nó từ trên cao. CFrame có cả hướng xoay, nên người chơi nhìn cùng hướng với part spawn: hãy xoay các part để tất cả nhìn vào giữa map.

Nếu số người chơi nhiều hơn số part spawn, script quay lại từ part đầu tiên, và người chơi chồng lên nhau, nên hãy thêm số spawn ít nhất bằng số người chơi tối đa của bạn.

Nếu bạn cũng dùng bước kiểm tra tốc độ trong hướng dẫn chạy nhanh, hãy thêm player:SetAttribute("MovementCheckSkip", true) ngay sau character:PivotTo(...) trong startRound, để lần dịch chuyển không bị coi là vượt tốc độ.

Timer của vòng và điều kiện kết thúc

runRound chạy mỗi giây một nhịp. Ở mỗi nhịp nó cập nhật trạng thái (còn bao nhiêu người chơi) và số giây còn lại, rồi đếm số phe còn sống. Vòng kết thúc theo một trong ba cách:

  • Hết giờ. Vòng lặp for chạy tới 1 và kết thúc.
  • Chỉ còn một phe. Một phe là một người chơi, hoặc một đội nếu bật USE_TEAMS. Bước kiểm tra này chỉ có tác dụng khi vòng bắt đầu với hai phe trở lên, nên khi test một mình vòng không kết thúc ngay lúc vừa bắt đầu.
  • Không còn ai. Mọi người đã chết hoặc thoát, và vòng kết thúc mà không có người thắng.

Kiểm tra mỗi giây một lần nghĩa là vòng có thể chạy thêm tối đa một giây sau lần loại cuối cùng, và trên timer của vòng điều này gần như không thấy được.

Trao Wins và hiện kết quả

Quy tắc trong script này rất đơn giản: mọi người còn sống lúc vòng kết thúc đều thắng. Một dòng logic này bao luôn người chơi sống sót cuối cùng, đội sống sót cuối cùng, và chế độ "trụ được tới khi hết timer". finishRound cộng 1 vào Wins của mỗi người thắng, ngừng theo dõi họ và hiện một thông báo như "Alex wins!" trong RESULTS_SECONDS. Nếu bạn muốn không có ai thắng khi hết giờ, hãy bỏ qua awardWin và đổi thông báo khi sidesLeft lớn hơn 1. Dù sao thì vẫn tiếp tục trả về danh sách, vì bước dọn dẹp dùng nó để đưa người sống sót về lobby.

Dọn dẹp

Người sống sót vẫn còn đứng trên map, nên cleanup hồi sinh họ ở lobby bằng Player:LoadCharacterAsync(), hàm thay thế cho LoadCharacter cũ, rồi xóa bản sao của map. Mỗi lần hồi sinh chạy trong một task.spawn riêng bên trong pcall, vì lệnh gọi chờ nhân vật tải xong và có thể lỗi nếu người chơi đúng lúc đó đang thoát. Người chơi bị loại thì không cần gì: họ đã tự hồi sinh ở lobby rồi.

Bước 3: Hiện timer và trạng thái cho mọi người chơi

Server đăng ba attribute trên ReplicatedStorage.RoundInfo: State (một từ cố định như InRound, dành cho script), Status (chữ cho người đọc) và TimeLeft (số giây). Attribute mà script server đặt trên một object được replicate sẽ tự tới mọi client, và người chơi vào giữa vòng nhận ngay giá trị hiện tại. Vì thế cách này hợp với timer hơn remote: một RemoteEvent gửi đi trước khi ai đó vào game sẽ không bao giờ tới được họ.

  1. Trong Explorer, chèn một ScreenGui vào StarterGui và đặt tên là RoundHud. Để ResetOnSpawn bật (mặc định).
  2. Chèn một LocalScript vào RoundHud, đặt tên là RoundHudClient và dán đoạn code bên dưới. Nó tự tạo dòng chữ, nên bạn không cần vẽ thêm gì.
  3. Bấm Play. Dòng chữ ở đầu màn hình hiện trạng thái và đếm ngược dạng m:ss.
LocalScript trong ScreenGui RoundHud trong StarterGui tên là RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Dòng chữ. Nếu bạn đã tự vẽ TextLabel trong RoundHud, hãy xóa khối này và dùng:
-- 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 -- thông báo dài sẽ xuống dòng thứ hai
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()

Vì ResetOnSpawn đang bật, Roblox cho người chơi một bản RoundHud mới mỗi lần nhân vật spawn, kể cả lần hồi sinh khi dọn dẹp. Lúc đó script đọc lại các attribute hiện tại, nên dòng chữ không bao giờ bị cũ.

Client chỉ đọc. Không có gì người chơi thay đổi trên màn hình của mình ảnh hưởng tới timer thật, vì thay đổi attribute từ LocalScript chỉ nằm lại trên client đó. Để đếm ngược tới phần mười giây, server có thể lưu trong attribute thời điểm kết thúc lấy từ workspace:GetServerTimeNow(), còn mỗi client mỗi khung hình lấy nó trừ đi workspace:GetServerTimeNow() của mình.

Nếu game của bạn mở đầu bằng menu chính, RoundHud xuất hiện khi người chơi bấm Play, vì StarterGui chỉ được sao chép cho người chơi sau khi nhân vật của họ spawn. Người chơi còn ở menu chưa có nhân vật, nên họ sẽ không bao giờ bị dịch chuyển vào vòng.

Người chơi chết, thoát hoặc vào giữa vòng

Những trường hợp này rất dễ bỏ sót khi viết script vòng chơi lần đầu. Nếu một trường hợp nào đó không được xử lý, thường bạn sẽ thấy lỗi trong Output hoặc một vòng không bao giờ kết thúc. Đây là cách script ở trên xử lý từng trường hợp.

Các trường hợp biên và cách script vòng chơi xử lý chúng
Tình huốngĐiều gì xảy raỞ đâu trong script
Người chơi chết trong vòng (bị giết, reset, rơi xuống)Họ bị loại khỏi vòng và hồi sinh ở lobby sau Players.RespawnTime (mặc định 5 giây).humanoid.Died gọi eliminate
Nhân vật bị xóa mà không chếtGiống như khi chết: người chơi bị loại.player.CharacterRemoving gọi eliminate
Người chơi thoát khỏi serverHọ bị loại, các connection của họ bị ngắt, và nhịp tiếp theo đếm lại số phe.Players.PlayerRemoving gọi eliminate
Người chơi vào giữa vòngHọ spawn ở lobby, thấy trạng thái và timer trực tiếp, và được vào vòng tiếp theo.Người tham gia chỉ được chọn trong startRound
Người chơi đã chết lúc vòng bắt đầuHọ không bị dịch chuyển, mà chờ ở lobby.getLivingCharacter
Mọi người đã thoát hoặc chếtVòng kết thúc với "Nobody survived", và chu trình bắt đầu lại: Intermission nếu server vẫn còn đủ người chơi, nếu không thì Waiting.sidesLeft == 0 trong runRound

eliminate được viết sao cho gọi nhiều lần cho cùng một người chơi vẫn an toàn. Người chơi chết rồi hồi sinh sẽ kích hoạt cả Died lẫn CharacterRemoving, còn người thoát game có thể kích hoạt cả ba sự kiện; chỉ lần gọi đầu tiên có tác dụng.

Cách mở rộng: đội, bình chọn map và sự kiện của vòng

Đội sống sót cuối cùng

Đặt USE_TEAMS = true, rồi thêm các object Team vào service Teams trong Explorer, mỗi đội một tên và TeamColor riêng. Mặc định Roblox đưa mỗi người chơi mới vào đội tự gán có ít thành viên nhất. Khi người chơi thoát, nó không cân bằng lại các đội, nên trong các phiên chơi dài các đội có thể bị lệch. Để SpawnLocation trong lobby ở chế độ Neutral, để mọi đội đều spawn ở đó. Khi đó vòng kết thúc khi người chơi còn sống chỉ thuộc một đội, và kết quả trông như "Red wins!".

Với kiểu "một chọi tất cả" (một thợ săn, những người khác sống sót), trong startRound hãy chọn ngẫu nhiên một người tham gia và đặt Team của họ thành đội thợ săn trước khi dịch chuyển. Bỏ tích AutoAssignable ở đội thợ săn để người chơi mới không bao giờ vào đó, và trong cleanup đưa thợ săn về lại đội sống sót. Khi đó các điều kiện kết thúc vẫn y như cũ: thợ săn thắng nếu mọi người sống sót đều bị loại, còn người sống sót thắng nếu trụ được tới hết timer, với điều kiện bạn bỏ qua awardWin của thợ săn khi hết giờ.

Người chơi bình chọn map

Để bình chọn, client phải giao tiếp với server, nghĩa là cần một RemoteEvent. Trong intermission, server đăng hai hoặc ba tên map bằng attribute, mỗi client gửi qua RemoteEvent tên mà nó đã bấm, và server đếm phiếu trước khi chạy loadMap. Server bắt buộc phải kiểm tra từng phiếu: đối số là một string, nó là một trong các lựa chọn hiện tại, trạng thái đang là Intermission, và mỗi người chơi chỉ được tính một lần (lưu phiếu trong một bảng có khóa là Player để phiếu thứ hai thay phiếu thứ nhất, và xóa nó trong PlayerRemoving). Hướng dẫn RemoteEvent giải thích chi tiết mẫu kiểm tra này.

Phát tool khi vòng bắt đầu

Các script khác có thể phản ứng với vòng chơi mà không cần đụng tới RoundSystem. Script vòng chơi đặt attribute InRound cho mỗi người chơi khi dịch chuyển họ, và tắt nó khi người chơi bị loại. Script này lắng nghe attribute đó và phát cho mỗi người chơi một bản sao của Tool tên RoundTool nằm trong ServerStorage.

Script trong ServerScriptService tên là 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

Không có code nào lấy lại tool. Khi nhân vật chết, Roblox thay Backpack bằng một cái mới lấy từ StarterPack, còn LoadCharacterAsync lúc dọn dẹp làm trống nó cho người sống sót, nên sau vòng chơi tool đã không còn.

Nếu cần một vũ khí để phát, hãy làm một thanh kiếm hoặc khẩu súng dùng raycast, giữ nó trong ServerStorage thay vì StarterPack và đổi "RoundTool" trong script này thành tên của nó.

NPC và các object chỉ tồn tại trong vòng

Mọi thứ chỉ cần tồn tại trong lúc vòng chơi diễn ra có thể nằm bên trong model của map: kẻ địch, vật phẩm nhặt được, nền di chuyển. Script bên trong model ở ServerStorage không chạy; ngay khi bản sao vào Workspace, chúng bắt đầu chạy, và map:Destroy() lúc dọn dẹp xóa chúng cùng mọi thứ khác. Để thêm kẻ địch đuổi theo người chơi, hãy làm một con theo hướng dẫn pathfinding cho NPC và đặt nó vào map. Để bay một vòng quanh map khi mỗi vòng bắt đầu, hướng dẫn cutscene chỉ cách script này có thể chạy cutscene cho mỗi người chơi qua một BindableEvent.

Cách biến nó thành module

Lúc đầu bạn không cần ModuleScript. Một Script duy nhất dễ đọc hơn trong lúc bạn đang làm game. Hãy tách nó ra khi các script khác cần gọi các hàm của vòng chơi, hoặc khi bạn muốn đưa phần cài đặt vào một ModuleScript chung mà cả server lẫn UI có thể require. Cho tới lúc đó, attribute State trên RoundInfo và attribute InRound trên mỗi người chơi đã đóng vai trò giao diện công khai của hệ thống vòng chơi: script nào cũng có thể lắng nghe chúng.

Lỗi thường gặp và cách sửa

Mở cửa sổ Output (qua menu Window trong Studio hoặc tab Script) trước khi bấm Play. Phần lớn sự cố với hệ thống vòng chơi đều in ra ở đó một cảnh báo hoặc lỗi kèm tên script và số dòng.

Kẹt ở "Waiting for players (1/2)"

Bạn đang test một mình, còn MIN_PLAYERS bằng 2. Đặt 1 khi test một mình, hoặc test ở chế độ Server & Clients với 2 client.

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

Folder không tồn tại, tên bị gõ sai hoặc nó nằm sai service. Nó phải là một Folder tên đúng Maps nằm ngay bên trong ServerStorage. Cảnh báo tương tự cho RoundInfo trong LocalScript nghĩa là script RoundSystem chưa bao giờ chạy tới bước tạo nó: script bị tắt, bị lỗi, hoặc vẫn đang chờ folder Maps.

Sau khi dịch chuyển, người chơi rơi xuyên qua map

Các part của map chưa bật Anchored, nên bản sao vỡ ra ngay khi vào Workspace. Chọn map, bật Anchored cho các part của nó và kiểm tra rằng các part spawn nằm trên sàn, không phải bên trong sàn.

Người chơi bị loại hồi sinh trên đấu trường

Bên trong map có một SpawnLocation. Thay nó bằng một Part thường trong folder Spawns của map đó.

Vòng không kết thúc khi mọi người đã chết

Kiểm tra rằng sát thương của bạn thật sự giết Humanoid (máu về 0), chứ không chỉ đẩy hay anchor người chơi. Nếu bạn đã tắt trạng thái Dead của Humanoid, Died không bao giờ kích hoạt, và vòng phải chạy tới hết timer.

Chu trình vòng chơi dừng hẳn sau một lỗi

Chu trình chạy trong một thread duy nhất, nên lỗi ở bất kỳ trạng thái nào cũng làm nó dừng. Đọc lỗi trong Output, sửa dòng đó và test lại. Nguyên nhân hay gặp: script bị sửa để dùng player.Character.Humanoid mà không kiểm tra nhân vật có tồn tại hay không.

Làm với RoCode

Nếu không muốn tự ráp mọi thứ, RoCode có thể làm việc này trong place bạn đang mở. Đây là AI agent làm việc qua plugin Roblox Studio, nên script và part xuất hiện trong Explorer của bạn, chứ không nằm trong cửa sổ chat để bạn phải tự dán.

Bạn gõ

Thêm hệ thống vòng chơi: intermission 20 giây cần 2 người chơi, map ngẫu nhiên từ ServerStorage.Maps, dịch chuyển mọi người tới các part spawn của map, mỗi vòng 2 phút và người chơi còn sống cuối cùng thắng, cộng Win vào leaderstats và hiện trạng thái cùng timer ở đầu màn hình.

RoCode làm
  • Có thể xem trước place của bạn bằng List Children, Search Game và Search Scripts để dùng folder Maps và script leaderstats bạn đã có, thay vì thêm một bộ thứ hai
  • Tạo Script vòng chơi trong ServerScriptService và LocalScript timer bằng Create Script, và có thể đặt một đấu trường từ các công trình dựng sẵn của nó bằng Place Prefab nếu bạn chưa có map
  • Kiểm tra mỗi script có compile được ngay trong Studio bằng Check Script trước khi xong việc. Bước này bắt lỗi cú pháp, không bắt lỗi logic của vòng chơi
  • Sau khi bạn playtest, Check Output đọc các dòng Server và Client của lần playtest gần nhất để sửa lỗi lúc chạy

Với plugin 3.9 trở lên, RoCode có thể chạy một playtest ngắn và đọc lỗi, còn với plugin 3.9.11 trở lên nó có thể điều khiển một nhân vật thử nghiệm, nhưng nó không test với nhiều người chơi, nên hãy tự chạy thử các vòng ở chế độ Server & Clients. Mỗi đợt thay đổi là một điểm undo trong Studio. Chu trình vòng chơi là nền móng của nhiều game, và làm cả một game Roblox bằng AI, từng hệ thống một thường bắt đầu từ một chu trình như vậy. RoCode kết nối với Studio thế nào.

Câu hỏi thường gặp

Làm hệ thống vòng chơi có đội trong Roblox thế nào?

Thêm các object Team vào service Teams và đặt USE_TEAMS = true trong script vòng chơi. Roblox chia người chơi mới vào đội tự gán có ít thành viên nhất, còn vòng kết thúc khi người chơi còn sống chỉ thuộc một đội.

Làm sao hiện đếm ngược cho mọi người chơi?

Từ server, đặt số giây còn lại làm attribute trên một object trong ReplicatedStorage và lắng nghe nó bằng GetAttributeChangedSignal trong một LocalScript cập nhật TextLabel, như ở bước 3. Người chơi vào sau nhận ngay giá trị hiện tại.

Trong chu trình vòng chơi nên dùng wait() hay task.wait()?

Dùng task.wait(). Roblox đánh dấu wait() toàn cục là đã lỗi thời và được thay bằng task.wait().

Làm sao dịch chuyển người chơi sang place khác cho mỗi vòng?

Đó là một công cụ khác. Hướng dẫn này di chuyển nhân vật bên trong một server bằng PivotTo. Gửi người chơi tới một place khác trong experience của bạn thì dùng TeleportService, nó chuyển họ sang một server khác. Hướng dẫn dịch chuyển làm các cổng dịch chuyển như vậy, có thử lại nếu dịch chuyển thất bại.

Vì sao người chơi đứng hình một chút sau khi dịch chuyển?

Khi bật instance streaming, client chưa nhận được map. Lệnh RequestStreamAroundAsync trong script lúc đếm ngược "chuẩn bị" yêu cầu engine gửi map trước; GET_READY_SECONDS dài hơn cho các kết nối chậm thêm thời gian.

Nguồn và tài liệu đọc thêm

Cách kiểm tra code: mọi script trong trang này đều qua trình kiểm tra kiểu nghiêm ngặt (strict) của Luau với định nghĩa API của Roblox (luau-lsp, 20 tháng 11, 2026). Kiểm tra kiểu bắt được API gõ sai và kiểu dữ liệu sai, không bắt được lỗi logic của game, nên hãy thử trong Studio trước khi xuất bản.

Thử RoCode trong chính game của bạn.

Mỗi ngày có credit miễn phí, không cần thẻ. Cài plugin, mô tả tính năng và xem kết quả xuất hiện trong Studio.