Tutorial · Sistem permainan

Cara buat sistem pusingan dalam Roblox Studio

Kebanyakan game berpusingan dalam Roblox menjalankan kitaran yang sama: menunggu pemain, mengira detik hingga sifar, memuatkan peta, menteleport semua orang ke sana, menjalankan pemasa, memilih pemenang dan mengemas. Dalam panduan ini kita membina kitaran itu sebagai satu skrip pelayan yang mudah difahami, menambah pemasa yang dilihat oleh setiap pemain, dan meneliti kes yang membuatkan skrip yang disalin rosak: pemain yang mati, keluar atau masuk di tengah-tengah pusingan.

Dikemas kini 20 November 202613 minit bacaanDitulis oleh

Ringkasnya

Tulis satu Script pelayan dalam ServerScriptService yang berulang-ulang melalui set keadaan yang tetap: intermission (tunggu bilangan pemain yang cukup, kemudian kira detik), memuatkan peta (klon peta rawak dari ServerStorage ke Workspace), teleport (pindahkan setiap watak yang hidup ke part spawn melalui PivotTo), pusingan (jalankan pemasa sehingga masa habis atau tinggal seorang pemain atau satu pasukan) dan pembersihan (beri Wins, hidupkan semula yang terselamat, padam peta).

  • Jalankan kitaran hanya pada pelayan. Terbitkan status dan saat yang tinggal sebagai atribut pada Folder dalam ReplicatedStorage, dan biarkan LocalScript memaparkannya.
  • Simpan jadual mereka yang masih dalam pusingan. Keluarkan pemain apabila Humanoidnya mati, wataknya dibuang atau dia keluar.
  • Teleport hanya pemain yang wataknya hidup ketika pusingan bermula. Yang masuk kemudian menunggu di lobi untuk pusingan seterusnya.
Di halaman ini
  1. Cara ia berfungsi
  2. 1. Lobi dan peta
  3. 2. Skrip pusingan
  4. Cara keadaan berfungsi
  5. 3. UI pemasa
  6. Pemain di tengah pusingan
  7. Cara mengembangkan
  8. Common errors
  9. Dengan RoCode
  10. Soalan lazim
  11. Sumber dan bacaan lanjut

Cara sistem pusingan berfungsi

IlustrasiSkrip pusingan siap dalam game yang sedang berjalan, dipercepatkan.

Sistem pusingan ialah mesin keadaan. Pada bila-bila masa pelayan berada dalam tepat satu keadaan, setiap keadaan mempunyai satu tugas, dan satu syarat memindahkannya ke keadaan seterusnya. Jika ditulis begini, semua logik berada di satu tempat, dan pepijat klasik tidak berlaku, iaitu apabila gelung pemasa dan gelung pusingan kedua-duanya cuba menamatkan pusingan yang sama.

Keadaan dalam kitaran pusingan panduan ini
KeadaanApa yang pelayan buatBila ia beralih
WaitingMemaparkan "Waiting for players (1/2)"Pemain di pelayan sudah cukup
IntermissionMengira detik sementara semua orang di lobiKiraan detik tamat (atau kembali ke Waiting jika pemain keluar)
StartingMenyalin peta rawak ke Workspace, memaparkan namanya, meminta client memuatkannyaKiraan detik pendek "bersedia" tamat
InRoundMenteleport pemain yang hidup, menjalankan pemasa, mengeluarkan mereka yang mati atau keluarMasa habis, atau tinggal seorang pemain atau satu pasukan
ResultsMemberi Win kepada semua yang masih hidup, dan memaparkan siapa yang menangBeberapa saat berlalu
CleanupMenghidupkan semula yang terselamat di lobi dan memadam petaSerta-merta, kemudian kitaran bermula semula

Pelayan memiliki setiap keadaan. Client hanya memaparkan apa yang diberitahu oleh pelayan. Kiraan detik dalam LocalScript menyimpang daripada yang sebenar, salah bagi mereka yang masuk kemudian, dan boleh diubah oleh exploiter. Jika pembahagian pelayan dan client masih baharu bagi anda, baca dahulu Script vs LocalScript vs ModuleScript.

Langkah 1: Bina lobi, peta dan stat Wins

  1. Bina lobi dalam Workspace dengan SpawnLocation. Pastikan sifat Neutral ditandakan, supaya setiap pemain spawn di sini, menunggu di sini dan kembali ke sini selepas tersingkir.
  2. Dalam ServerStorage, masukkan Folder bernama Maps. Objek dalam ServerStorage tidak pernah dihantar kepada pemain, jadi peta yang tidak digunakan tidak membebankan mereka.
  3. Bina setiap peta sebagai Model di dalam Maps, dengan part yang Anchored. Bina jauh dari lobi (beberapa ratus stud sudah cukup), kerana salinannya muncul tepat di tempat anda membinanya, dan pemain yang tersingkir tidak sepatutnya dapat berjalan masuk semula.
  4. Di dalam setiap peta, tambah Folder bernama Spawns, dan di dalamnya satu Part yang Anchored bagi setiap pemain yang dijangka. Tetapkan Transparency kepada 1 dan matikan CanCollide, supaya tiada siapa nampak atau tersadung padanya.
Explorer selepas panduan ini
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

Skrip pusingan menambah 1 pada IntValue bernama Wins di dalam folder leaderstats pemain. Jika game anda belum mempunyai leaderstats, tambah skrip pendek ini. Jika sudah ada, contohnya versi dengan simpanan daripada panduan leaderboard, langkau: dua skrip yang mencipta leaderstats memberi setiap pemain dua folder.

Script dalam ServerScriptService bernama Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- nama mesti tepat begini, dengan huruf kecil

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

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- Dalam Studio anda mungkin masuk sebelum skrip ini berjalan, jadi sediakan semua yang sudah ada di sini
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Wins ini direset apabila pemain keluar. Untuk menyimpannya antara sesi, gunakan versi DataStore daripada panduan leaderboard.

Langkah 2: Tambah skrip pusingan

Masukkan Script ke dalam ServerScriptService, namakannya RoundSystem dan tampal kod di bawah. Tetapan di bahagian atas ialah satu-satunya baris yang kemungkinan besar perlu anda ubah. Setiap keadaan ialah fungsi tersendiri, dan gelung di bahagian bawah menjalankannya mengikut urutan, tanpa henti.

Script dalam ServerScriptService bernama RoundSystem
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Tetapan
local MIN_PLAYERS = 2 -- tetapkan 1 semasa menguji seorang diri
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: pusingan tamat apabila pemain hanya tinggal dalam satu pasukan

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

-- Apa yang dipaparkan pada skrin setiap pemain disimpan dalam atribut pada folder ini.
-- Atribut yang ditetapkan oleh pelayan direplikasi ke semua client, termasuk yang masuk kemudian.
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

-- Siapa yang masih dalam pusingan semasa, dan sambungan yang memantau setiap seorang
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)

-- Mengembalikan watak dan Humanoid hanya jika pemain hidup sekarang
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

-- Mengira pihak yang tinggal dalam pusingan (pemain, atau pasukan jika USE_TEAMS dihidupkan)
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

-- KEADAAN: Waiting dan Intermission. Mengembalikan false jika pemain keluar semasa kiraan detik.
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

-- KEADAAN: Starting, bahagian 1. Salin peta rawak (bukan yang lepas, jika ada pilihan).
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
	-- Kocok supaya pemain tidak mendapat spawn yang sama setiap pusingan
	for i = #points, 2, -1 do
		local j = random:NextInteger(1, i)
		points[i], points[j] = points[j], points[i]
	end
	return points
end

-- Ketinggian root part watak yang berdiri di atas lantai.
-- Formula daripada rujukan Roblox untuk Humanoid.HipHeight (rig R6 menambah ketinggian kaki).
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

-- KEADAAN: Starting, bahagian 2. Bersedia, kemudian teleport semua yang hidup.
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

	-- Jika streaming dihidupkan, minta setiap client memuatkan peta sebelum watak tiba
	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

	-- Hanya yang hidup sekarang menyertai. Yang lain menunggu pusingan seterusnya.
	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 watak ialah root partnya, jadi naikkan ke ketinggian berdiri di atas 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

-- KEADAAN: InRound. Tamat apabila masa habis atau tinggal satu pihak.
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()
		-- Pusingan yang dimulakan oleh satu pihak (ujian seorang diri) hanya tamat apabila masa habis atau apabila mati
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- KEADAAN: Results. Semua yang masih hidup menang.
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) -- berhenti memantau mereka; mereka kekal di peta sehingga pembersihan
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- KEADAAN: Cleanup. Hantar yang terselamat kembali ke lobi, kemudian padam peta.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- masih di pelayan
			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

-- Gelung: satu kitaran ialah satu pusingan
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) -- belum ada peta: cuba lagi sebentar lagi
		end
	end
end

Semua yang penting berlaku di sini, pada pelayan: siapa dalam pusingan, pemasa, pemenang dan Wins. Client hanya menerima tiga atribut pada ReplicatedStorage.RoundInfo (State, Status dan TimeLeft) dan atribut InRound pada setiap pemain.

Cara setiap keadaan berfungsi

Menunggu dan intermission

runIntermission mula-mula menahan kitaran sehingga #Players:GetPlayers() mencapai MIN_PLAYERS. Kemudian ia mengira detik satu saat pada satu masa dengan task.wait(1) dan menyemak bilangan pemain pada setiap detik. Jika seseorang keluar dan pemain di pelayan kurang daripada minimum, ia mengembalikan false, dan gelung utama bermula semula dari Waiting, jadi pusingan tidak akan pernah bermula dengan seorang sahaja.

Memilih dan memuatkan peta

loadMap mengumpul semua Model dalam ServerStorage.Maps, mengetepikan peta pusingan lepas jika ada pilihan lain, dan mengambil satu dengan Random:NextInteger. Kemudian ia mengklon peta ke Workspace. Yang asal kekal tidak disentuh dalam ServerStorage, jadi setiap pusingan bermula dengan salinan baharu: apa sahaja yang pemain rosakkan atau alihkan dalam pusingan lepas hilang.

Place baharu mempunyai instance streaming yang dihidupkan: client hanya mempunyai part berhampiran wataknya. Sebelum teleport, skrip memanggil Player:RequestStreamAroundAsync untuk setiap pemain, dan ini meminta enjin menghantar kawasan di sekitar peta kepada client semasa kiraan detik "bersedia". Tanpanya, pemain mungkin tiba sebelum lantai dimuatkan dan membeku seketika.

Teleport pemain dengan PivotTo

Selepas kiraan detik, skrip menyusun senarai peserta daripada pemain yang wataknya wujud, masih berada di dunia dan mempunyai Humanoid dengan nyawa lebih daripada 0 serta root part. Semakan ini dibuat selepas kiraan detik, jadi sesiapa yang mati atau keluar semasa kiraan tidak masuk ke dalam senarai.

Setiap peserta dipindahkan dengan character:PivotTo(cframe). Rujukan Roblox menyebut PivotTo sebagai cara utama untuk menggerakkan model dari skrip, dan ia menggerakkan semua bahagian watak bersama-sama. Menetapkan HumanoidRootPart.Position tidak sama: Roblox melaraskan sambungan supaya hanya bahagian itu yang bergerak, dan bahagian badan yang lain mungkin tertinggal. Pivot watak ialah root partnya, jadi sasarannya ialah CFrame part spawn, dinaikkan setengah ketinggian part ditambah ketinggian root part berdiri di atas lantai. rootHeight mengiranya dengan formula daripada rujukan Roblox untuk Humanoid.HipHeight: setengah ketinggian root part ditambah HipHeight, ditambah panjang kaki bagi rig R6. Dengan itu avatar yang diskalakan dan avatar tersuai tidak tersangkut dalam part atau jatuh ke atasnya dari tinggi. CFrame termasuk putaran, jadi pemain menghadap ke arah yang sama dengan part spawn: putar part supaya semua orang menghadap ke tengah peta.

Jika pemain lebih ramai daripada part spawn, skrip bermula semula dari part pertama, dan pemain bertindih antara satu sama lain, jadi tambah spawn sekurang-kurangnya sebanyak bilangan pemain maksimum anda.

Jika anda juga menggunakan semakan kelajuan daripada panduan lari pecut, tambah player:SetAttribute("MovementCheckSkip", true) sejurus selepas character:PivotTo(...) dalam startRound, supaya teleport tidak dikira sebagai melebihi had kelajuan.

Pemasa pusingan dan syarat tamat

runRound berdetik sekali sesaat. Pada setiap detik ia mengemas kini status (berapa ramai pemain yang tinggal) dan saat yang tinggal, kemudian mengira pihak yang masih hidup. Pusingan tamat dengan salah satu daripada tiga cara:

  • Masa habis. Gelung for sampai ke 1 dan tamat.
  • Tinggal satu pihak. Pihak ialah pemain, atau pasukan jika USE_TEAMS dihidupkan. Semakan ini hanya berfungsi jika pusingan bermula dengan dua pihak atau lebih, jadi ujian seorang diri tidak tamat sebaik sahaja ia bermula.
  • Tiada siapa yang tinggal. Semua mati atau keluar, dan pusingan tamat tanpa pemenang.

Semakan sekali sesaat bermakna pusingan boleh berterusan sehingga satu saat selepas penyingkiran terakhir, dan pada pemasa pusingan itu hampir tidak ketara.

Memberi Wins dan memaparkan keputusan

Peraturan dalam skrip ini mudah: semua yang hidup ketika pusingan tamat menang. Ini meliputi pemain terakhir yang terselamat, pasukan terakhir yang terselamat dan mod "bertahan sehingga pemasa habis" dengan satu baris logik. finishRound menambah 1 pada Wins setiap pemenang, berhenti memantau mereka dan memaparkan mesej seperti "Alex wins!" selama RESULTS_SECONDS. Jika anda mahu tiada pemenang apabila masa habis, langkau awardWin dan tukar mesej apabila sidesLeft lebih daripada 1. Walau bagaimanapun, teruskan memulangkan senarai, kerana pembersihan menggunakannya untuk mengembalikan yang terselamat ke lobi.

Pembersihan

Yang terselamat masih berdiri di peta, jadi cleanup menghidupkan mereka semula di lobi dengan Player:LoadCharacterAsync(), yang menggantikan LoadCharacter lama, kemudian memadam salinan peta. Setiap penghidupan semula berjalan dalam task.spawn sendiri di dalam pcall, kerana panggilan itu menunggu watak dimuatkan dan boleh gagal jika pemain sedang keluar pada saat itu. Pemain yang tersingkir tidak perlukan apa-apa: mereka sudah hidup semula sendiri di lobi.

Langkah 3: Paparkan pemasa dan status kepada setiap pemain

Pelayan menerbitkan tiga atribut pada ReplicatedStorage.RoundInfo: State (perkataan tetap seperti InRound, untuk skrip), Status (teks untuk manusia) dan TimeLeft (saat). Atribut yang ditetapkan oleh skrip pelayan pada objek yang direplikasi sampai ke setiap client secara automatik, dan pemain yang masuk di tengah pusingan terus mendapat nilai semasa. Oleh itu ia lebih sesuai untuk pemasa berbanding remote: RemoteEvent yang dihantar sebelum seseorang masuk tidak akan sampai kepadanya.

  1. Dalam Explorer, masukkan ScreenGui ke dalam StarterGui dan namakannya RoundHud. Biarkan ResetOnSpawn dihidupkan (lalai).
  2. Masukkan LocalScript ke dalam RoundHud, namakannya RoundHudClient dan tampal kod di bawah. Ia mencipta label sendiri, jadi tiada apa-apa lagi yang perlu dilukis.
  3. Tekan Play. Label di bahagian atas skrin memaparkan status dan kiraan detik dalam format m:ss.
LocalScript dalam ScreenGui RoundHud dalam StarterGui bernama RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Label. Jika anda telah melukis TextLabel sendiri dalam RoundHud, padam blok ini dan gunakan:
-- 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 -- mesej panjang dibalut ke baris kedua
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()

Oleh kerana ResetOnSpawn dihidupkan, Roblox memberi pemain salinan baharu RoundHud setiap kali wataknya spawn, termasuk penghidupan semula semasa pembersihan. Skrip kemudian membaca semula atribut semasa, jadi label tidak pernah ketinggalan.

Client hanya membaca. Tiada apa yang pemain ubah pada skrinnya mempengaruhi pemasa sebenar, kerana perubahan atribut daripada LocalScript kekal pada client itu sahaja. Untuk kiraan detik dengan persepuluh saat, pelayan boleh sebaliknya menyimpan masa tamat daripada workspace:GetServerTimeNow() dalam atribut, dan setiap client menolak workspace:GetServerTimeNow() miliknya daripada nilai itu pada setiap frame.

Jika game anda dibuka dengan menu utama, RoundHud muncul apabila pemain menekan Play, kerana StarterGui hanya disalin kepada pemain selepas wataknya spawn. Pemain yang masih di menu tidak mempunyai watak, jadi mereka tidak akan diteleport ke dalam pusingan.

Pemain yang mati, keluar atau masuk di tengah pusingan

Kes-kes ini mudah terlepas pandang apabila menulis skrip pusingan buat kali pertama. Jika salah satunya tidak dikendalikan, biasanya anda akan nampak ralat dalam Output atau pusingan yang tidak pernah tamat. Inilah yang dibuat oleh skrip di atas untuk setiap satu.

Kes tepi dan cara skrip pusingan mengendalikannya
SituasiApa yang berlakuDi mana dalam skrip
Pemain mati dalam pusingan (dibunuh, reset, jatuh)Dia dikeluarkan daripada pusingan, dan hidup semula di lobi selepas Players.RespawnTime (lalai 5 saat).humanoid.Died memanggil eliminate
Watak dibuang tanpa matiSama seperti mati: pemain tersingkir.player.CharacterRemoving memanggil eliminate
Pemain keluar dari pelayanDia dikeluarkan, sambungannya diputuskan, dan detik seterusnya mengira semula pihak.Players.PlayerRemoving memanggil eliminate
Pemain masuk di tengah pusinganDia spawn di lobi, nampak status dan pemasa secara langsung, dan masuk ke pusingan seterusnya.Peserta hanya dipilih dalam startRound
Pemain sudah mati ketika pusingan bermulaDia tidak diteleport, dia menunggu di lobi.getLivingCharacter
Semua keluar atau matiPusingan tamat dengan "Nobody survived", dan kitaran bermula semula: Intermission jika pemain di pelayan masih cukup, jika tidak Waiting.sidesLeft == 0 dalam runRound

eliminate ditulis supaya selamat dipanggil beberapa kali untuk pemain yang sama. Pemain yang mati dan hidup semula mencetuskan kedua-dua Died dan CharacterRemoving, dan pemain yang keluar mungkin mencetuskan ketiga-tiga peristiwa; hanya panggilan pertama yang melakukan sesuatu.

Cara mengembangkannya: pasukan, undian peta dan peristiwa pusingan

Pasukan terakhir yang terselamat

Tetapkan USE_TEAMS = true, kemudian tambah objek Team ke perkhidmatan Teams dalam Explorer, setiap satu dengan nama dan TeamColor sendiri. Secara lalai Roblox meletakkan setiap pemain yang masuk ke dalam pasukan auto-assign yang paling sedikit ahlinya. Apabila pemain keluar, ia tidak mengimbangkan semula pasukan, jadi dalam sesi yang panjang pasukan boleh menjadi tidak sama rata. Biarkan SpawnLocation di lobi sebagai Neutral, supaya semua pasukan spawn di situ. Pusingan kemudian tamat apabila pemain yang hidup hanya tinggal dalam satu pasukan, dan keputusannya kelihatan seperti "Red wins!".

Untuk format "seorang lawan semua" (seorang pemburu, yang lain cuba bertahan), pilih seorang peserta rawak dalam startRound dan sebelum teleport tetapkan Team miliknya kepada pasukan pemburu. Matikan AutoAssignable pada pasukan pemburu supaya pemain baharu tidak pernah masuk ke situ, dan dalam cleanup kembalikan pemburu ke pasukan yang bertahan. Syarat tamat yang sama kemudian berfungsi: pemburu menang jika semua yang bertahan tersingkir, dan yang bertahan menang jika mereka bertahan sehingga pemasa habis, dengan syarat anda melangkau awardWin untuk pemburu apabila masa habis.

Undian pemain untuk peta

Untuk undian, client perlu berhubung dengan pelayan, jadi anda perlukan RemoteEvent. Semasa intermission, pelayan menerbitkan dua atau tiga nama peta sebagai atribut, setiap client menghantar nama yang diklik melalui RemoteEvent, dan pelayan mengira undi sebelum menjalankan loadMap. Pelayan wajib menyemak setiap undi: bahawa argumen ialah string, bahawa ia salah satu pilihan semasa, bahawa keadaan ialah Intermission dan bahawa setiap pemain dikira sekali (simpan undi dalam jadual dengan kunci Player, supaya undi kedua menggantikan yang pertama, dan kosongkan dalam PlayerRemoving). Panduan RemoteEvent menerangkan corak semakan ini dengan terperinci.

Memberi tool pada permulaan pusingan

Skrip lain boleh bertindak balas terhadap pusingan tanpa menyentuh RoundSystem. Skrip pusingan menetapkan atribut InRound pada setiap pemain apabila menteleportnya, dan membuangnya apabila pemain tersingkir. Skrip ini mendengarnya dan memberi setiap pemain salinan Tool bernama RoundTool yang terletak dalam ServerStorage.

Script dalam ServerScriptService bernama 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

Tiada kod yang mengambil semula tool. Apabila watak mati, Roblox menggantikan Backpack dengan yang baharu, diisi daripada StarterPack, dan LoadCharacterAsync semasa pembersihan mengosongkannya bagi yang terselamat, jadi selepas pusingan tool itu sudah tiada.

Jika anda perlukan senjata untuk diberi, bina pedang atau senapang raycast, simpan dalam ServerStorage dan bukan StarterPack, dan tukar "RoundTool" dalam skrip ini kepada namanya.

NPC dan objek lain hanya untuk tempoh pusingan

Apa sahaja yang hanya perlu wujud semasa pusingan boleh berada di dalam model peta: musuh, item yang boleh dikutip, platform bergerak. Skrip di dalam model dalam ServerStorage tidak berjalan; sebaik sahaja salinan berada dalam Workspace, ia bermula, dan map:Destroy() semasa pembersihan memadamnya bersama semua yang lain. Untuk menambah musuh yang mengejar pemain, bina satu mengikut panduan pathfinding NPC dan letakkan dalam peta. Untuk penerbangan kamera mengelilingi peta pada permulaan setiap pusingan, panduan cutscene menunjukkan cara skrip ini boleh memainkan cutscene untuk setiap pemain melalui BindableEvent.

Cara menjadikannya modul

Untuk bermula, ModuleScript tidak diperlukan. Satu Script lebih mudah dibaca semasa anda membina game. Pecahkannya apabila skrip lain perlu memanggil fungsi pusingan atau apabila anda mahu memindahkan tetapan ke satu ModuleScript bersama yang boleh di-require oleh pelayan dan UI anda. Sehingga itu, atribut State pada RoundInfo dan atribut InRound pada setiap pemain sudah berfungsi sebagai antara muka awam sistem pusingan: mana-mana skrip boleh mendengarnya.

Ralat biasa dan cara membaikinya

Buka tetingkap Output (melalui menu Window dalam Studio atau tab Script) sebelum menekan Play. Kebanyakan masalah sistem pusingan memaparkan amaran atau ralat di situ dengan nama skrip dan nombor baris.

Tersekat pada "Waiting for players (1/2)"

Anda menguji seorang diri, dan MIN_PLAYERS ialah 2. Tetapkan 1 untuk ujian seorang diri atau uji dalam mod Server & Clients dengan 2 client.

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

Folder tiada, namanya tersalah eja atau ia dalam perkhidmatan yang salah. Ia mesti Folder bernama tepat Maps terus di dalam ServerStorage. Amaran yang sama untuk RoundInfo dalam LocalScript bermakna skrip RoundSystem tidak pernah sampai ke tahap menciptanya: ia dimatikan, gagal dengan ralat atau masih menunggu folder Maps.

Selepas teleport, pemain jatuh menembusi peta

Part peta tidak Anchored, jadi salinannya runtuh sebaik sahaja berada dalam Workspace. Pilih peta, anchor partnya dan pastikan part spawn berada di atas lantai, bukan di dalamnya.

Pemain yang tersingkir hidup semula di arena

Ada SpawnLocation di dalam peta. Gantikannya dengan Part biasa dalam folder Spawns peta itu.

Pusingan tidak tamat apabila semua mati

Pastikan kerosakan anda benar-benar membunuh Humanoid (nyawa sampai ke 0), dan bukan menggerakkan atau meng-anchor pemain. Jika anda mematikan keadaan Dead pada Humanoid, Died tidak pernah dicetuskan, dan pusingan terpaksa berjalan sehingga pemasa habis.

Kitaran pusingan berhenti terus selepas satu ralat

Kitaran berjalan dalam satu thread, jadi ralat dalam mana-mana keadaan menamatkannya. Baca ralat dalam Output, betulkan baris itu dan uji semula. Punca biasa: skrip diubah sehingga ia menggunakan player.Character.Humanoid tanpa menyemak bahawa watak wujud.

Buat dengan RoCode

Jika anda tidak mahu membina semua ini dengan tangan, RoCode boleh membuatnya dalam place yang sedang anda buka. Ia ejen AI yang bekerja melalui plugin Roblox Studio, jadi skrip dan part muncul dalam Explorer anda, bukan dalam tetingkap chat yang perlu anda salin dan tampal.

Anda tulis

Tambah sistem pusingan: intermission 20 saat yang memerlukan 2 pemain, peta rawak dari ServerStorage.Maps, teleport semua orang ke part spawn peta, pusingan 2 minit di mana pemain terakhir yang hidup menang, tambah Win dalam leaderstats dan paparkan status serta pemasa di bahagian atas skrin.

RoCode buat
  • Mungkin meninjau place anda dahulu dengan List Children, Search Game dan Search Scripts, supaya ia menggunakan folder Maps dan skrip leaderstats anda dan tidak menambah set kedua
  • Mencipta Script pusingan dalam ServerScriptService dan LocalScript pemasa melalui Create Script, dan boleh meletakkan arena daripada binaan siapnya melalui Place Prefab jika anda belum mempunyai peta
  • Menyemak kompilasi setiap skrip dalam Studio melalui Check Script sebelum selesai. Ini mengesan ralat sintaks, bukan kesilapan logik pusingan
  • Selepas playtest anda, Check Output membaca baris Server dan Client daripada playtest terakhir untuk membaiki ralat semasa larian

Dengan plugin 3.9 atau lebih baharu, RoCode boleh menjalankan playtest pendek dan membaca ralat, dan dengan plugin 3.9.11 atau lebih baharu ia boleh mengawal satu watak ujian, tetapi ia tidak menguji dengan beberapa pemain, jadi jalankan pusingan sendiri dalam mod Server & Clients. Setiap kumpulan perubahan ialah titik undo dalam Studio. Kitaran pusingan menjadi asas banyak game, dan membina seluruh game Roblox dengan AI, satu sistem demi satu sistem sering bermula dengan kitaran seperti ini. Cara RoCode bersambung dengan Studio.

Soalan lazim

Bagaimana cara buat sistem pusingan dengan pasukan dalam Roblox?

Tambah objek Team ke perkhidmatan Teams dan tetapkan USE_TEAMS = true dalam skrip pusingan. Roblox meletakkan pemain yang masuk ke dalam pasukan auto-assign yang paling sedikit ahlinya, dan pusingan tamat apabila pemain yang hidup hanya tinggal dalam satu pasukan.

Bagaimana memaparkan kiraan detik kepada semua pemain?

Tetapkan saat yang tinggal dari pelayan sebagai atribut pada objek dalam ReplicatedStorage dan dengar melalui GetAttributeChangedSignal dalam LocalScript yang mengemas kini TextLabel, seperti dalam langkah 3. Pemain yang masuk kemudian terus mendapat nilai semasa.

Apa yang perlu digunakan dalam kitaran pusingan: wait() atau task.wait()?

Gunakan task.wait(). Roblox menandakan wait() global sebagai lapuk dan digantikan oleh task.wait().

Bagaimana menteleport pemain ke place lain untuk setiap pusingan?

Itu alat yang berbeza. Panduan ini memindahkan watak dalam satu pelayan melalui PivotTo. Menghantar pemain ke place lain dalam experience anda dibuat melalui TeleportService, yang memindahkan mereka ke pelayan lain. Panduan teleport membina portal yang melakukannya, dengan cubaan semula jika teleport gagal.

Kenapa pemain membeku seketika selepas teleport?

Dengan instance streaming dihidupkan, client belum menerima peta. Panggilan RequestStreamAroundAsync dalam skrip semasa kiraan detik "bersedia" meminta enjin menghantarnya lebih awal; GET_READY_SECONDS yang lebih panjang memberi sambungan perlahan lebih banyak masa.

Sumber dan bacaan lanjut

Cara kod disemak: setiap skrip di halaman ini lulus semakan jenis Luau yang ketat dengan definisi API Roblox (luau-lsp, 20 November 2026). Semakan jenis mengesan kesilapan nama API dan jenis yang salah, tetapi bukan kesilapan logik permainan, jadi uji semuanya dalam Studio sebelum anda menerbitkannya.

Cuba RoCode dalam permainan anda.

Kredit percuma setiap hari, tanpa kad. Pasang plugin, terangkan ciri yang anda mahu dan semak hasilnya dalam Studio.