Tutorial · Mga game system

Paano gumawa ng round system sa Roblox Studio

Karamihan sa mga round-based na game sa Roblox ay umiikot sa iisang loop: hinihintay ang mga player, nagbibilang pababa, naglo-load ng map, tine-teleport ang lahat doon, pinapatakbo ang timer, pumipili ng panalo at naglilinis. Sa guide na ito, binubuo namin ang loop na iyon bilang isang malinaw na server script, nagdadagdag ng timer na nakikita ng bawat player, at hinihimay ang mga kaso kung saan nasisira ang mga kinopyang script: mga player na namamatay, umaalis o pumapasok sa gitna ng round.

In-update Nobyembre 20, 202617 minutong basaIsinulat ni

Sa madaling salita

Sumulat ng isang server Script sa ServerScriptService na paulit-ulit na dumadaan sa fixed na set ng mga state: intermission (hintayin ang sapat na bilang ng player, saka mag-countdown), pag-load ng map (i-clone ang random na map mula sa ServerStorage papunta sa Workspace), teleport (ilipat ang bawat buhay na character sa isang spawn part gamit ang PivotTo), round (patakbuhin ang timer hanggang maubos ang oras o isang player o isang team na lang ang natira) at cleanup (magbigay ng Wins, i-respawn ang mga nakaligtas, i-delete ang map).

  • Sa server lang patakbuhin ang loop. I-publish ang status at natitirang segundo bilang mga attribute sa isang Folder sa ReplicatedStorage, at hayaang LocalScript ang magpakita nito.
  • Magtago ng table ng mga nasa round pa. Alisin ang player kapag namatay ang Humanoid niya, na-delete ang character niya o umalis siya.
  • I-teleport lang ang mga player na buhay ang character sa sandaling magsimula ang round. Ang pumasok nang huli ay maghihintay sa lobby para sa susunod.
Sa page na ito
  1. Paano ito gumagana
  2. 1. Lobby at mga map
  3. 2. Round script
  4. Paano gumagana ang mga state
  5. 3. UI ng timer
  6. Mga player sa gitna ng round
  7. Paano palawakin
  8. Common errors
  9. Gamit ang RoCode
  10. Mga madalas itanong
  11. Mga source at dagdag na babasahin

Paano gumagana ang round system

IllustrationAng mga tapos na round script sa tumatakbong game, pinabilis.

Ang round system ay isang state machine. Sa kahit anong sandali, nasa iisang state lang ang server, may iisang trabaho ang bawat state, at isang kondisyon ang naglilipat dito sa susunod. Kapag ganito ang pagkakasulat, nasa iisang lugar ang lahat ng logic, at hindi nangyayari ang klasikong bug kung saan parehong sinusubukan ng timer loop at round loop na tapusin ang iisang round.

Mga state ng round loop sa guide na ito
StateAno ang ginagawa ng serverKailan lumilipat
WaitingIpinapakita ang "Waiting for players (1/2)"Sapat na ang player sa server
IntermissionNagbibilang ng oras habang nasa lobby ang lahatTapos na ang countdown (o bumalik sa Waiting kung may umalis na player)
StartingKinokopya ang random na map sa Workspace, ipinapakita ang pangalan nito, hinihiling sa mga client na i-load itoTapos na ang maikling "get ready" na countdown
InRoundTine-teleport ang mga buhay na player, pinapatakbo ang timer, inaalis ang mga namatay o umalisNaubos ang oras, o isang player o isang team na lang ang natira
ResultsNagbibigay ng Win sa lahat ng buhay pa, at ipinapakita kung sino ang nanaloLumipas ang ilang segundo
CleanupNire-respawn ang mga nakaligtas sa lobby at dine-delete ang mapAgad, saka magsisimula ulit ang loop

Ang server ang may-ari ng bawat state. Ipinapakita lang ng mga client ang sinasabi sa kanila ng server. Ang countdown sa LocalScript ay lumalayo sa totoo, mali para sa mga pumasok nang huli, at kayang baguhin ng exploiter. Kung bago sa iyo ang paghihiwalay ng server at client, basahin muna ang Script vs LocalScript vs ModuleScript.

Step 1: Buuin ang lobby, mga map at ang Wins stat

  1. Bumuo ng lobby sa Workspace na may SpawnLocation. Siguraduhing naka-check ang property na Neutral nito, para dito mag-spawn, maghintay at bumalik ang bawat player pagkatapos ma-eliminate.
  2. Sa ServerStorage, maglagay ng Folder na pinangalanang Maps. Hindi kailanman ipinapadala sa mga player ang mga object sa ServerStorage, kaya walang gastos sa kanila ang mga hindi ginagamit na map.
  3. Buuin ang bawat map bilang Model sa loob ng Maps, na naka-anchor ang mga part. Buuin ito malayo sa lobby (sapat na ang ilang daang stud), dahil lumalabas ang kopya eksakto kung saan mo ito binuo, at hindi dapat makabalik ang mga na-eliminate na player.
  4. Sa loob ng bawat map, magdagdag ng Folder na pinangalanang Spawns, at sa loob nito ay isang naka-anchor na Part para sa bawat inaasahang player. Gawing 1 ang Transparency nila at i-off ang CanCollide, para walang makakita o matisod sa kanila.
Ang Explorer pagkatapos ng guide na ito
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

Nagdadagdag ang round script ng 1 sa IntValue na pinangalanang Wins sa loob ng leaderstats folder ng player. Kung wala pang leaderstats ang game mo, idagdag ang maikling script na ito. Kung mayroon na, halimbawa ang version na nagse-save mula sa guide sa leaderboard, laktawan ito: dalawang script na gumagawa ng leaderstats ay nagbibigay sa bawat player ng dalawang folder.

Script sa ServerScriptService na pinangalanang Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- dapat eksaktong ganito ang pangalan, maliliit na titik

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

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- Sa Studio, puwede kang makapasok bago tumakbo ang script na ito, kaya sine-set up natin ang lahat ng nandito na
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Nare-reset ang mga Wins na ito kapag umalis ang player. Para ma-save ang mga ito sa pagitan ng mga session, gamitin ang version na may DataStore mula sa guide sa leaderboard.

Step 2: Idagdag ang round script

Maglagay ng Script sa ServerScriptService, pangalanan itong RoundSystem at i-paste ang code sa ibaba. Ang mga setting sa itaas lang ang mga linyang malamang na kailangan mong baguhin. Bawat state ay hiwalay na function, at pinapatakbo ng loop sa ibaba ang mga ito nang sunod-sunod, walang katapusan.

Script sa ServerScriptService na pinangalanang RoundSystem
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Mga setting
local MIN_PLAYERS = 2 -- gawing 1 habang mag-isa kang nagte-test
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: natatapos ang round kapag nasa iisang team na lang ang mga player

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

-- Ang ipinapakita ng screen ng bawat player ay naka-store sa mga attribute sa folder na ito.
-- Nare-replicate sa lahat ng client ang mga attribute na sine-set ng server, kasama ang mga pumasok nang huli.
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

-- Sino pa ang nasa kasalukuyang round, at ang mga connection na sumusubaybay sa bawat isa
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)

-- Ibinabalik ang character at Humanoid, kung buhay lang ang player ngayon mismo
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

-- Binibilang ang mga panig na natitira sa round (mga player, o mga team kung naka-on ang 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

-- STATE: Waiting at Intermission. Nagbabalik ng false kung umalis ang mga player habang countdown.
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

-- STATE: Starting, part 1. Kinokopya ang random na map (hindi ang nakaraan, kung may mapagpipilian).
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
	-- Binabalasa para hindi mapunta ang mga player sa iisang spawn bawat round
	for i = #points, 2, -1 do
		local j = random:NextInteger(1, i)
		points[i], points[j] = points[j], points[i]
	end
	return points
end

-- Gaano kataas sa sahig ang root part ng nakatayong character.
-- Formula mula sa reference ng Roblox para sa Humanoid.HipHeight (sa mga R6 rig, idinadagdag ang taas ng binti).
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

-- STATE: Starting, part 2. Get ready, saka i-teleport ang lahat ng buhay.
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

	-- Kapag naka-on ang streaming, hinihiling sa bawat client na i-load ang map bago dumating ang character
	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

	-- Ang buhay lang ngayon mismo ang kasali. Ang iba ay maghihintay sa susunod na round.
	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]
			-- Root part ng character ang pivot nito, kaya itinataas natin ito sa taas ng nakatayo sa ibabaw ng 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

-- STATE: InRound. Natatapos kapag naubos ang oras o isang panig na lang ang natira.
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()
		-- Ang round na sinimulan ng iisang panig (solo na test) ay natatapos lang sa oras o sa pagkamatay
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- STATE: Results. Panalo ang lahat ng buhay pa.
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) -- tumitigil na tayo sa pagsubaybay sa kanila; nananatili sila sa map hanggang cleanup
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- STATE: Cleanup. Ibinabalik ang mga nakaligtas sa lobby, saka dine-delete ang map.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- nasa server pa
			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

-- Loop: isang ikot ay isang round
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) -- wala pang map: susubukan ulit maya-maya
		end
	end
end

Nangyayari dito, sa server, ang lahat ng mahalaga: sino ang nasa round, ang timer, ang panalo at ang Wins. Tatlong attribute lang ang natatanggap ng mga client sa ReplicatedStorage.RoundInfo (State, Status at TimeLeft) at ang attribute na InRound sa bawat player.

Paano gumagana ang bawat state

Waiting at intermission

Unang pinipigilan ng runIntermission ang loop hanggang umabot ang #Players:GetPlayers() sa MIN_PLAYERS. Pagkatapos, nagbibilang ito pababa nang tig-isang segundo gamit ang task.wait(1) at sinusuri ang bilang ng player sa bawat tick. Kung may umalis at bumaba sa minimum ang nasa server, nagbabalik ito ng false, at magsisimula ulit ang main loop sa Waiting, kaya hindi kailanman magsisimula ang round na isa lang ang tao.

Pagpili at pag-load ng map

Kinokolekta ng loadMap ang lahat ng Model sa ServerStorage.Maps, inaalis ang map ng nakaraang round kung may mapagpipilian, at pumipili ng isa gamit ang Random:NextInteger. Pagkatapos, kino-clone nito ang map sa Workspace. Nananatiling buo ang original sa ServerStorage, kaya bawat round ay nagsisimula sa bagong kopya: nawawala ang lahat ng sinira o inilipat ng mga player sa nakaraang round.

Naka-on ang instance streaming sa mga bagong place: nasa client lang ang mga part na malapit sa character nito. Bago mag-teleport, tinatawag ng script ang Player:RequestStreamAroundAsync para sa bawat player, at hinihiling nito sa engine na ipadala sa client ang lugar sa paligid ng map habang nasa "get ready" na countdown. Kung wala ito, puwedeng dumating ang mga player bago ma-load ang sahig at sandaling mag-freeze.

Pag-teleport ng mga player gamit ang PivotTo

Pagkatapos ng countdown, binubuo ng script ang listahan ng mga kalahok mula sa mga player na may character na umiiral, nasa mundo pa, at may Humanoid na may health na higit sa 0 at root part. Nangyayari ang check na ito pagkatapos ng countdown, kaya hindi kasama sa listahan ang namatay o umalis habang nagbibilang.

Inililipat ang bawat kalahok gamit ang character:PivotTo(cframe). Tinatawag ng reference ng Roblox ang PivotTo na pangunahing paraan ng paggalaw ng mga model mula sa script, at sabay nitong ginagalaw ang lahat ng bahagi ng character. Hindi pareho ang pag-set ng HumanoidRootPart.Position: inaayos ng Roblox ang mga joint para iyon lang na bahagi ang gumalaw, at puwedeng maiwan ang ibang bahagi ng katawan. Root part ng character ang pivot nito, kaya ang target ay ang CFrame ng spawn part, itinaas nang kalahati ng taas ng part dagdag ang taas kung saan nakatayo ang root part sa ibabaw ng sahig. Kinukuwenta ito ng rootHeight gamit ang formula mula sa reference ng Roblox para sa Humanoid.HipHeight: kalahati ng taas ng root part dagdag ang HipHeight, dagdag ang haba ng binti sa mga R6 rig. Kaya hindi naiipit sa part o nahuhulog dito mula sa itaas ang mga naka-scale at custom na avatar. Kasama sa CFrame ang rotation, kaya nakaharap ang mga player sa kung saan nakaharap ang spawn part: iikot ang mga part para lahat ay nakaharap sa gitna ng map.

Kung mas marami ang player kaysa sa spawn part, magsisimula ulit ang script sa unang part, at magpapatong-patong ang mga player, kaya magdagdag ng spawn na hindi bababa sa maximum mong bilang ng player.

Kung ginagamit mo rin ang speed check mula sa guide sa sprint, idagdag ang player:SetAttribute("MovementCheckSkip", true) kasunod mismo ng character:PivotTo(...) sa startRound, para hindi mabilang ang teleport bilang sobrang bilis.

Round timer at mga kondisyon ng pagtatapos

Nagti-tick ang runRound kada segundo. Sa bawat tick, ina-update nito ang status (ilang player ang natitira) at ang natitirang segundo, saka binibilang ang mga buhay na panig. Natatapos ang round sa isa sa tatlong paraan:

  • Naubos ang oras. Umaabot sa 1 ang for loop at natatapos.
  • Isang panig na lang ang natira. Ang panig ay isang player, o isang team kung naka-on ang USE_TEAMS. Gumagana lang ang check kung nagsimula ang round na may dalawa o higit pang panig, kaya hindi natatapos ang solo na test sa mismong sandaling nagsimula ito.
  • Wala nang natira. Namatay o umalis ang lahat, at natatapos ang round nang walang panalo.

Dahil kada segundo ang check, puwedeng tumakbo pa ang round nang hanggang isang segundo pagkatapos ng huling elimination, at halos hindi ito napapansin sa round timer.

Pagbibigay ng Wins at pagpapakita ng resulta

Simple ang patakaran sa script na ito: panalo ang lahat ng buhay sa sandaling matapos ang round. Sakop nito ang huling nakaligtas na player, ang huling nakaligtas na team, at ang mode na "tumagal hanggang maubos ang timer" sa isang linya ng logic. Nagdadagdag ang finishRound ng 1 sa Wins ng bawat panalo, tumitigil sa pagsubaybay sa kanila at nagpapakita ng message gaya ng "Alex wins!" nang RESULTS_SECONDS. Kung gusto mong walang panalo kapag naubos ang oras, laktawan ang awardWin at palitan ang message kapag higit sa 1 ang sidesLeft. Sa kahit anong kaso, patuloy na ibalik ang listahan, dahil ginagamit ito ng cleanup para ibalik ang mga nakaligtas sa lobby.

Cleanup

Nakatayo pa sa map ang mga nakaligtas, kaya nire-respawn sila ng cleanup sa lobby gamit ang Player:LoadCharacterAsync(), na pumapalit sa lumang LoadCharacter, saka dine-delete ang kopya ng map. Bawat respawn ay nasa sarili nitong task.spawn sa loob ng pcall, dahil naghihintay ang tawag na ma-load ang character at puwedeng mag-fail kung umaalis ang player sa mismong sandaling iyon. Walang kailangan ang mga na-eliminate na player: kusa na silang nag-respawn sa lobby.

Step 3: Ipakita ang timer at status sa bawat player

Nagpa-publish ang server ng tatlong attribute sa ReplicatedStorage.RoundInfo: State (fixed na salita gaya ng InRound, para sa mga script), Status (text para sa tao) at TimeLeft (segundo). Ang mga attribute na sine-set ng server script sa isang nare-replicate na object ay kusang nakakarating sa bawat client, at agad na natatanggap ng player na pumasok sa gitna ng round ang mga kasalukuyang value. Kaya mas bagay ito sa timer kaysa sa remote: hindi kailanman makakarating sa isang tao ang RemoteEvent na ipinadala bago siya pumasok.

  1. Sa Explorer, maglagay ng ScreenGui sa StarterGui at pangalanan itong RoundHud. Iwanang naka-on ang ResetOnSpawn (default).
  2. Maglagay ng LocalScript sa RoundHud, pangalanan itong RoundHudClient at i-paste ang code sa ibaba. Ito mismo ang gumagawa ng text, kaya wala ka nang kailangang iguhit.
  3. Pindutin ang Play. Ipinapakita ng text sa itaas ng screen ang status at ang countdown sa format na m:ss.
LocalScript sa ScreenGui RoundHud sa StarterGui na pinangalanang RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Text. Kung gumuhit ka ng sarili mong TextLabel sa RoundHud, i-delete ang block na ito at gamitin ang:
-- 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 -- ang mahahabang message ay lumilipat sa pangalawang linya
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()

Dahil naka-on ang ResetOnSpawn, binibigyan ng Roblox ang player ng bagong kopya ng RoundHud sa bawat spawn ng character, kasama ang respawn sa cleanup. Binabasa ulit ng script ang mga kasalukuyang attribute, kaya hindi kailanman nalalaos ang text.

Nagbabasa lang ang client. Walang binabago ang player sa screen niya na nakakaapekto sa totoong timer, dahil nananatili sa iisang client na iyon ang mga pagbabago ng attribute mula sa LocalScript. Para sa countdown na may ikasampu ng segundo, puwedeng mag-imbak ang server sa attribute ng oras ng pagtatapos mula sa workspace:GetServerTimeNow(), at bawat client ay ibabawas dito ang sarili nitong workspace:GetServerTimeNow() bawat frame.

Kung nagbubukas ang game mo sa main menu, lalabas ang RoundHud kapag pinindot ng player ang Play, dahil kinokopya lang sa player ang StarterGui pagkatapos mag-spawn ng character niya. Walang character ang mga player na nasa menu pa, kaya hindi sila kailanman tine-teleport sa round.

Mga player na namamatay, umaalis o pumapasok sa gitna ng round

Madaling makaligtaan ang mga kasong ito kapag unang beses kang sumusulat ng round script. Kung hindi naaasikaso ang alinman, karaniwang makakakita ka ng error sa Output o round na hindi natatapos. Narito ang ginagawa ng script sa itaas sa bawat isa.

Mga edge case at kung paano inaasikaso ng round script
SitwasyonAno ang nangyayariSaan sa script
Namatay ang player sa round (napatay, nag-reset, nahulog)Inaalis siya sa round, at nagre-respawn siya sa lobby pagkatapos ng Players.RespawnTime (default na 5 segundo).Tinatawag ng humanoid.Died ang eliminate
Na-delete ang character nang hindi namamatayGaya ng pagkamatay: na-eliminate ang player.Tinatawag ng player.CharacterRemoving ang eliminate
Umalis ang player sa serverInaalis siya, dini-disconnect ang mga connection niya, at muling binibilang ng susunod na tick ang mga panig.Tinatawag ng Players.PlayerRemoving ang eliminate
Pumasok ang player sa gitna ng roundNag-spawn siya sa lobby, nakikita ang live na status at timer, at kasama sa susunod na round.Sa startRound lang pinipili ang mga kalahok
Patay ang player sa sandaling nagsimula ang roundHindi siya tine-teleport, naghihintay siya sa lobby.getLivingCharacter
Umalis o namatay ang lahatNatatapos ang round sa "Nobody survived", at magsisimula ulit ang loop: Intermission kung sapat pa ang player sa server, kung hindi ay Waiting.sidesLeft == 0 sa runRound

Isinulat ang eliminate para ligtas itong tawagin nang ilang beses para sa iisang player. Ang player na namatay at nag-respawn ay nagti-trigger ng Died at CharacterRemoving, at ang umaalis ay puwedeng mag-trigger ng tatlong event; ang unang tawag lang ang may ginagawa.

Paano palawakin: mga team, map voting at mga event ng round

Huling nakaligtas na team

Itakda ang USE_TEAMS = true, saka magdagdag ng mga Team object sa Teams service sa Explorer, bawat isa ay may sariling pangalan at TeamColor. Bilang default, inilalagay ng Roblox ang bawat pumapasok na player sa auto-assignable na team na may pinakakaunting miyembro. Kapag may umaalis na player, hindi nito binabalanse ulit ang mga team, kaya sa mahahabang session puwedeng maging hindi pantay ang mga team. Iwanang Neutral ang SpawnLocation sa lobby para doon mag-spawn ang lahat ng team. Kaya natatapos ang round kapag nasa iisang team na lang ang mga buhay na player, at ang resulta ay mukhang "Red wins!".

Para sa format na "isa laban sa lahat" (isang hunter, ang iba ay nagsu-survive), pumili sa startRound ng isang random na kalahok at bago mag-teleport ay itakda ang Team niya sa team ng hunter. Alisin ang AutoAssignable sa team ng hunter para hindi kailanman mapunta roon ang mga bagong player, at sa cleanup ay ibalik ang hunter sa team ng mga survivor. Kaya gumagana ang parehong mga kondisyon ng pagtatapos: panalo ang hunter kung na-eliminate ang lahat ng survivor, at panalo ang mga survivor kung tumagal sila hanggang matapos ang timer, basta nilalaktawan mo ang awardWin ng hunter kapag naubos ang oras.

Pagboto ng mga player sa map

Para sa pagboto, kailangang makipag-usap ng client sa server, kaya kailangan ng RemoteEvent. Habang intermission, nagpa-publish ang server ng dalawa o tatlong pangalan ng map bilang mga attribute, ipinapadala ng bawat client sa pamamagitan ng RemoteEvent ang pangalang pinindot niya, at binibilang ng server ang mga boto bago patakbuhin ang loadMap. Dapat suriin ng server ang bawat boto: na string ang argument, na isa ito sa mga kasalukuyang pagpipilian, na Intermission ang state, at na isang beses lang binibilang ang bawat player (itago ang mga boto sa table na Player ang key, para palitan ng pangalawang boto ang una, at linisin ito sa PlayerRemoving). Detalyadong hinihimay ng guide sa RemoteEvent ang pattern na ito ng mga check.

Pagbibigay ng tool sa simula ng round

Kayang tumugon ng ibang script sa round nang hindi ginagalaw ang RoundSystem. Nilalagyan ng round script ang bawat player ng attribute na InRound kapag tine-teleport siya, at inaalis ito kapag na-eliminate ang player. Pinapakinggan ito ng script na ito at binibigyan ang bawat player ng kopya ng Tool na pinangalanang RoundTool, na nasa ServerStorage.

Script sa ServerScriptService na pinangalanang 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

Walang code na kumukuha ng tool. Kapag namatay ang character, pinapalitan ng Roblox ang Backpack ng bago na pinupuno mula sa StarterPack, at nililinis ito ng LoadCharacterAsync sa cleanup para sa mga nakaligtas, kaya wala na ang tool pagkatapos ng round.

Kung kailangan mo ng armas na ibibigay, bumuo ng espada o raycast na baril, itago ito sa ServerStorage sa halip na sa StarterPack, at palitan ang "RoundTool" sa script na ito ng pangalan nito.

NPC at ibang object para lang sa oras ng round

Lahat ng dapat umiral lang habang may round ay puwedeng nasa loob ng model ng map: mga kalaban, mga napupulot na item, mga gumagalaw na platform. Hindi gumagana ang mga script sa loob ng model sa ServerStorage; sa sandaling mapunta ang kopya sa Workspace, tumatakbo ang mga ito, at dine-delete sila ng map:Destroy() sa cleanup kasama ng lahat ng iba pa. Para magdagdag ng mga kalaban na humahabol sa mga player, bumuo ng isa gamit ang guide sa pathfinding para sa NPC at ilagay ito sa map. Para sa flyover ng map sa simula ng bawat round, ipinapakita ng guide sa cutscene kung paano mapapatakbo ng script na ito ang cutscene para sa bawat player gamit ang BindableEvent.

Paano gawing module ito

Hindi mo kailangan ng ModuleScript sa simula. Mas madaling basahin ang iisang Script habang binubuo mo ang game. Hatiin ito kapag kailangan ng ibang script na tawagin ang mga function ng round, o kapag gusto mong ilipat ang mga setting sa iisang shared na ModuleScript na puwedeng i-require ng server at ng UI mo. Hanggang doon, gumagana na bilang public interface ng round system ang attribute na State sa RoundInfo at ang attribute na InRound sa bawat player: kayang pakinggan ng kahit anong script ang mga ito.

Mga karaniwang error at solusyon

Buksan ang Output window (sa Window menu ng Studio o sa Script tab) bago pindutin ang Play. Karamihan sa mga problema sa round system ay naglalabas doon ng warning o error na may pangalan ng script at numero ng linya.

Nakabitin sa "Waiting for players (1/2)"

Mag-isa kang nagte-test, at 2 ang MIN_PLAYERS. Gawin itong 1 para sa solo na test, o mag-test sa Server & Clients mode na may 2 client.

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

Wala ang folder, may typo sa pangalan nito, o nasa maling service ito. Dapat itong Folder na eksaktong pinangalanang Maps direkta sa loob ng ServerStorage. Ang parehong warning para sa RoundInfo sa LocalScript ay nangangahulugang hindi na umabot ang RoundSystem script sa paggawa nito: naka-off ito, nag-error, o naghihintay pa sa Maps folder.

Pagkatapos ng teleport, lumulusot ang mga player sa map

Hindi naka-anchor ang mga part ng map, kaya gumuguho ang kopya sa sandaling mapunta ito sa Workspace. I-select ang map, i-anchor ang mga part nito at siguraduhing nasa ibabaw ng sahig ang mga spawn part, hindi sa loob nito.

Nagre-respawn sa arena ang mga na-eliminate na player

May SpawnLocation sa loob ng map. Palitan ito ng karaniwang Part sa Spawns folder ng map na iyon.

Hindi natatapos ang round kapag namatay ang lahat

Siguraduhing talagang pinapatay ng damage mo ang Humanoid (umaabot sa 0 ang health), at hindi lang ginagalaw o ina-anchor ang mga player. Kung in-off mo ang Dead state ng Humanoid, hindi kailanman nagti-trigger ang Died, at kailangang tumakbo ang round hanggang matapos ang timer.

Tuluyang humihinto ang round loop pagkatapos ng isang error

Tumatakbo ang loop sa iisang thread, kaya tinatapos ito ng error sa kahit anong state. Basahin ang error sa Output, ayusin ang linya at i-test ulit. Karaniwang dahilan: binago ang script para gamitin ang player.Character.Humanoid nang hindi sinusuri kung umiiral ang character.

Gawin gamit ang RoCode

Kung ayaw mong buuin lahat ito nang mano-mano, kaya itong gawin ng RoCode sa place na bukas mo. Isa itong AI agent na gumagana sa pamamagitan ng plugin para sa Roblox Studio, kaya lumalabas ang mga script at part sa Explorer mo, hindi sa chat window na kailangan mo pang pagkopyahan.

Ang tina-type mo

Magdagdag ng round system: 20 segundong intermission na kailangan ng 2 player, random na map mula sa ServerStorage.Maps, i-teleport ang lahat sa mga spawn part ng map, 2 minutong round kung saan panalo ang huling buhay na player, magdagdag ng Win sa leaderstats at ipakita ang status at timer sa itaas ng screen.

Ang ginagawa ng RoCode
  • Puwedeng tingnan muna ang place mo gamit ang List Children, Search Game at Search Scripts, para gamitin ang Maps folder at leaderstats script mo sa halip na magdagdag ng pangalawang set
  • Gumagawa ng round Script sa ServerScriptService at LocalScript ng timer gamit ang Create Script, at kayang maglagay ng arena mula sa mga ready-made na build nito gamit ang Place Prefab kung wala ka pang map
  • Sinusuri ang compile ng bawat script sa loob ng Studio gamit ang Check Script bago matapos. Nahuhuli nito ang mga syntax error, hindi ang mga mali sa logic ng round
  • Pagkatapos ng playtest mo, binabasa ng Check Output ang mga linya ng Server at Client mula sa huling playtest para ayusin ang runtime error

Sa plugin 3.9 o mas bago, kayang magpatakbo ng RoCode ng maikling playtest at basahin ang mga error, at sa plugin 3.9.11 o mas bago ay kayang kontrolin ang isang test character, pero hindi ito nagte-test na may maraming player, kaya ikaw mismo ang magpatakbo ng mga round sa Server & Clients mode. Bawat batch ng pagbabago ay undo point sa Studio. Nasa puso ng maraming game ang round loop, at ang paggawa ng buong Roblox game gamit ang AI, system kada system ay madalas nagsisimula sa ganitong loop. Paano kumokonekta ang RoCode sa Studio.

Mga madalas itanong

Paano gumawa ng round system na may mga team sa Roblox?

Magdagdag ng mga Team object sa Teams service at itakda ang USE_TEAMS = true sa round script. Inilalagay ng Roblox ang mga pumapasok na player sa auto-assignable na team na may pinakakaunting miyembro, at natatapos ang round kapag nasa iisang team na lang ang mga buhay na player.

Paano ipakita ang countdown sa lahat ng player?

Mula sa server, i-set ang natitirang segundo bilang attribute sa isang object sa ReplicatedStorage at pakinggan ito gamit ang GetAttributeChangedSignal sa isang LocalScript na nag-a-update ng TextLabel, gaya ng sa step 3. Agad na natatanggap ng mga pumasok nang huli ang kasalukuyang value.

Ano ang gagamitin sa round loop: wait() o task.wait()?

Gamitin ang task.wait(). Minamarkahan ng Roblox ang global na wait() bilang deprecated at pinalitan ng task.wait().

Paano i-teleport ang mga player sa ibang place sa bawat round?

Ibang tool iyon. Inililipat ng guide na ito ang mga character sa loob ng iisang server gamit ang PivotTo. Ang pagpapadala ng mga player sa ibang place ng experience mo ay sa pamamagitan ng TeleportService, na naglilipat sa kanila sa ibang server. Binubuo ng guide sa teleport ang mga portal na gumagawa nito, may retry kapag nag-fail ang teleport.

Bakit sandaling nagfi-freeze ang mga player pagkatapos ng teleport?

Kapag naka-on ang instance streaming, hindi pa natatanggap ng client ang map. Ang tawag sa RequestStreamAroundAsync sa script habang nasa "get ready" na countdown ay humihiling sa engine na ipadala ito nang maaga; mas maraming oras ang naibibigay ng mas mahabang GET_READY_SECONDS sa mabagal na koneksyon.

Mga source at dagdag na babasahin

Paano sinuri ang code: bawat script sa page na ito ay dumaan sa strict Luau type check gamit ang mga definition ng Roblox API (luau-lsp, Nobyembre 20, 2026). Nahuhuli ng type check ang maling pangalan ng API at maling type, pero hindi ang mga mali sa game logic, kaya i-test muna ang lahat sa Studio bago mag-publish.

Subukan ang RoCode sa sarili mong game.

Libreng credits araw-araw, walang card. I-install ang plugin, ilarawan ang feature, at tingnan kung ano ang lumabas sa Studio.