Tutorial · Sistem game

Cara membuat sistem ronde di Roblox Studio

Sebagian besar game Roblox berbasis ronde menjalankan loop yang sama: menunggu pemain, menghitung mundur, memuat map, men-teleport semua orang ke sana, menjalankan timer, menentukan pemenang lalu membereskan semuanya. Panduan ini membuat loop itu sebagai satu script server yang mudah dibaca, menambahkan timer yang bisa dilihat setiap pemain, dan menangani kasus yang bikin script hasil copy rusak: pemain yang mati, keluar atau masuk di tengah ronde.

Diperbarui 14 November 202613 menit bacaDitulis oleh

Singkatnya

Tulis satu Script server di ServerScriptService yang berputar melewati urutan state yang tetap: intermission (tunggu sampai pemain cukup, lalu hitung mundur), muat map (clone map acak dari ServerStorage ke Workspace), teleport (pindahkan setiap karakter yang hidup ke part spawn dengan PivotTo), ronde (jalankan timer sampai waktu habis atau tinggal satu pemain atau tim) dan cleanup (beri Wins, respawn yang selamat, hancurkan map).

  • Jalankan loop-nya hanya di server. Publikasikan status dan sisa detiknya sebagai atribut di sebuah Folder di ReplicatedStorage, lalu biarkan LocalScript yang menampilkannya.
  • Simpan tabel siapa saja yang masih ikut ronde. Keluarkan pemain saat Humanoid-nya mati, karakternya dihapus atau dia keluar dari game.
  • Teleport hanya pemain yang karakternya hidup saat ronde dimulai. Siapa pun yang masuk belakangan menunggu di lobby untuk ronde berikutnya.
Di halaman ini
  1. Cara kerjanya
  2. 1. Lobby dan map
  3. 2. Script ronde
  4. Cara kerja setiap state
  5. 3. UI timer
  6. Pemain di tengah ronde
  7. Mengembangkannya
  8. Error umum
  9. Dengan RoCode
  10. Pertanyaan umum
  11. Sumber dan bacaan lanjutan

Cara kerja sistem ronde

IlustrasiScript ronde yang sudah jadi di game yang sedang berjalan, dipercepat.

Sistem ronde adalah state machine. Kapan pun, server berada di tepat satu state, setiap state punya satu tugas, dan satu kondisi memindahkannya ke state berikutnya. Kalau ditulis begini, logikanya ada di satu tempat, jadi kamu terhindar dari bug klasik: loop timer dan loop ronde sama-sama mencoba mengakhiri ronde yang sama.

State di loop ronde panduan ini
StateApa yang dilakukan serverLanjut saat
WaitingMenampilkan "Waiting for players (1/2)"Pemain di server sudah cukup
IntermissionMenghitung mundur selama semua orang ada di lobbyHitung mundur selesai (atau kembali ke Waiting kalau ada pemain keluar)
StartingMenyalin map acak ke Workspace, menampilkan namanya, meminta client memuatnyaHitung mundur singkat "bersiap" selesai
InRoundMen-teleport pemain yang hidup, menjalankan timer, mengeluarkan pemain yang mati atau keluarWaktu habis, atau tinggal satu pemain atau tim
ResultsMemberi satu Win ke semua yang masih hidup dan menampilkan pemenangnyaBeberapa detik berlalu
CleanupMe-respawn yang selamat di lobby dan menghancurkan mapLangsung, lalu loop mulai lagi

Server memegang setiap state. Client hanya menampilkan apa yang dikatakan server. Hitung mundur yang berjalan di LocalScript akan melenceng dari yang asli, salah untuk pemain yang masuk belakangan, dan bisa diubah oleh exploiter. Kalau pembagian server dan client masih baru buatmu, baca dulu Script vs LocalScript vs ModuleScript (dalam bahasa Inggris).

Langkah 1: Buat lobby, map dan stat Wins

  1. Buat lobby di Workspace dengan sebuah SpawnLocation. Pastikan properti Neutral-nya dicentang, supaya setiap pemain muncul di sini, menunggu di sini dan kembali ke sini setelah tersingkir.
  2. Di ServerStorage, sisipkan sebuah Folder bernama Maps. Objek di ServerStorage tidak pernah dikirim ke pemain, jadi map yang tidak dipakai tidak membebani mereka.
  3. Buat setiap map sebagai Model di dalam Maps, dengan semua part-nya di-anchor. Buat jauh dari lobby (beberapa ratus stud sudah cukup), karena salinannya muncul tepat di tempat kamu membuatnya, dan pemain yang tersingkir tidak boleh bisa berjalan masuk lagi.
  4. Di dalam setiap map, tambahkan Folder bernama Spawns berisi satu Part yang di-anchor untuk setiap pemain yang kamu perkirakan. Isi Transparency-nya dengan 1 dan matikan CanCollide supaya tidak ada yang melihat atau tersandung.
Explorer setelah 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

Script ronde menambahkan 1 ke IntValue bernama Wins di dalam folder leaderstats milik pemain. Kalau game kamu belum punya leaderstats, tambahkan script pendek ini. Kalau sudah punya, misalnya versi yang menyimpan data dari panduan leaderboard, lewati saja: dua script yang sama-sama membuat leaderstats memberi setiap pemain dua folder.

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

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- harus persis nama ini, semua huruf kecil

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

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- Di Studio kamu bisa masuk sebelum script ini berjalan, jadi siapkan juga pemain yang sudah ada
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Wins ini di-reset saat pemain keluar. Untuk menyimpannya antar sesi, pakai versi data store di panduan leaderboard.

Langkah 2: Tambahkan script ronde

Sisipkan sebuah Script ke ServerScriptService, beri nama RoundSystem dan tempel kode di bawah. Pengaturan di bagian atas adalah satu-satunya baris yang perlu kamu ubah. Setiap state adalah fungsinya sendiri, dan loop di bagian bawah menjalankannya berurutan, terus-menerus.

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

-- Pengaturan
local MIN_PLAYERS = 2 -- isi 1 selama kamu tes sendirian
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: ronde berakhir saat hanya satu tim yang masih punya pemain

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

-- Apa yang tampil di layar setiap pemain disimpan di atribut folder ini.
-- Atribut yang diatur server direplikasi ke semua client, termasuk pemain yang masuk belakangan.
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 ikut ronde ini, dan koneksi yang memantau masing-masing
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 karakter dan humanoid hanya kalau pemain sedang hidup saat ini
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

-- Menghitung pihak yang masih ada di ronde (pemain, atau tim kalau USE_TEAMS aktif)
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 dan Intermission. Mengembalikan false kalau ada pemain keluar selama hitung mundur.
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, bagian 1. Salin map acak (bukan map terakhir, kalau ada pilihan lain).
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
	-- Acak urutannya, supaya pemain tidak mendarat di spawn yang sama setiap ronde
	for i = #points, 2, -1 do
		local j = random:NextInteger(1, i)
		points[i], points[j] = points[j], points[i]
	end
	return points
end

-- Seberapa tinggi root part karakter yang berdiri berada di atas lantai.
-- Rumusnya dari referensi Humanoid.HipHeight Roblox (rig R6 ditambah tinggi 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

-- STATE: Starting, bagian 2. Bersiap, lalu teleport semua pemain 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

	-- Kalau streaming aktif, minta setiap client memuat map sebelum karakternya 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 pemain yang hidup saat ini yang ikut. Yang lain menunggu ronde berikutnya.
	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 karakter adalah root part-nya, jadi angkat ke tinggi 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

-- STATE: InRound. Berakhir saat waktu habis atau hanya tersisa 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()
		-- Ronde yang dimulai dengan satu pihak (tes solo) hanya berakhir karena waktu atau mati
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- STATE: 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 tetap di map sampai cleanup
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- STATE: Cleanup. Kirim yang selamat kembali ke lobby, lalu hapus map-nya.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- masih di 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

-- Loop-nya: satu putaran adalah satu ronde
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 map: coba lagi sebentar lagi
		end
	end
end

Semua yang penting terjadi di sini, di server: siapa yang ikut ronde, timer, pemenang dan Wins. Yang didapat client hanya tiga atribut di ReplicatedStorage.RoundInfo (State, Status dan TimeLeft) dan atribut InRound di setiap pemain.

Cara kerja setiap state

Menunggu dan intermission

runIntermission pertama-tama menahan loop sampai #Players:GetPlayers() mencapai MIN_PLAYERS. Lalu ia menghitung mundur satu detik setiap kali dengan task.wait(1), sambil mengecek jumlah pemain di setiap tick. Kalau ada yang keluar dan jumlahnya turun di bawah minimum, ia mengembalikan false dan loop utama mulai lagi dari Waiting, jadi ronde tidak pernah dimulai dengan satu orang saja.

Memilih dan memuat map

loadMap mengumpulkan setiap Model di ServerStorage.Maps, membuang map yang dipakai ronde lalu kalau masih ada pilihan lain, dan memilih satu dengan Random:NextInteger. Lalu map itu di-clone ke Workspace. Map aslinya tetap utuh di ServerStorage, jadi setiap ronde dimulai dari salinan baru: apa pun yang dirusak atau dipindahkan pemain di ronde lalu sudah hilang.

Place baru menyalakan instance streaming, artinya client hanya punya part yang dekat dengan karakternya. Sebelum teleport, script memanggil Player:RequestStreamAroundAsync untuk setiap pemain, yang meminta engine mengirim area di sekitar map ke client itu selama hitung mundur "bersiap". Tanpa ini, pemain bisa tiba sebelum lantainya dimuat dan tertahan sebentar.

Men-teleport pemain dengan PivotTo

Setelah hitung mundur, script menyusun daftar peserta dari pemain yang karakternya ada, masih di dunia game, dan punya Humanoid dengan health di atas 0 serta root part. Pengecekan itu terjadi setelah hitung mundur, jadi siapa pun yang mati atau keluar selama hitung mundur tidak ikut.

Setiap peserta dipindahkan dengan character:PivotTo(cframe). Referensi Roblox menyebut PivotTo sebagai cara utama menggerakkan model dari script, dan fungsi ini memindahkan semua part karakter bersamaan. Mengubah HumanoidRootPart.Position tidak sama: Roblox menyesuaikan sambungannya sehingga hanya part itu yang bergerak sendiri, dan sisa tubuhnya bisa tertinggal. Pivot karakter adalah root part-nya, jadi targetnya adalah CFrame part spawn yang dinaikkan setengah tinggi part ditambah tinggi root part saat berdiri di atas lantai. rootHeight menghitungnya dengan rumus dari referensi Humanoid.HipHeight Roblox: setengah tinggi root part ditambah HipHeight, ditambah panjang kaki pada rig R6. Dengan begitu avatar yang di-scale atau custom tidak mendarat di dalam part atau jatuh ke atasnya. Karena CFrame juga berisi rotasi, pemain menghadap ke arah yang sama dengan part spawn, jadi putar part-nya supaya semua orang menghadap ke tengah map.

Kalau pemain lebih banyak daripada part spawn, script kembali ke part pertama dan pemain mendarat bertumpuk, jadi tambahkan spawn minimal sebanyak jumlah pemain maksimalmu.

Kalau kamu juga memakai pengecekan kecepatan dari panduan script sprint, tambahkan player:SetAttribute("MovementCheckSkip", true) tepat setelah character:PivotTo(...) di startRound, supaya teleport-nya tidak ditandai sebagai kecepatan berlebih.

Timer ronde dan kondisi berakhirnya

runRound berdetak sekali per detik. Di setiap tick ia memperbarui status (berapa pemain yang tersisa) dan sisa detiknya, lalu menghitung pihak yang masih hidup. Ronde berakhir dengan salah satu dari tiga cara:

  • Waktu habis. Loop for mencapai 1 dan selesai.
  • Tinggal satu pihak. Satu pihak adalah satu pemain, atau satu tim kalau USE_TEAMS aktif. Pengecekan ini hanya berlaku kalau ronde dimulai dengan dua pihak atau lebih, jadi tes solo tidak langsung berakhir begitu dimulai.
  • Tidak ada yang tersisa. Semua mati atau keluar, jadi ronde berakhir tanpa pemenang.

Karena dicek sekali per detik, ronde bisa berjalan sampai satu detik setelah pemain terakhir tersingkir, dan di timer ronde itu jarang terasa.

Memberi Wins dan menampilkan hasil

Aturan di script ini sederhana: semua yang masih hidup saat ronde berakhir menang. Itu mencakup pemain terakhir yang bertahan, tim terakhir yang bertahan, dan "bertahan sampai timer habis" dalam satu baris logika. finishRound menambahkan 1 ke Wins setiap pemenang, berhenti memantau mereka, dan menampilkan pesan seperti "Alex wins!" selama RESULTS_SECONDS. Kalau kamu ingin waktu habis tidak punya pemenang, lewati awardWin dan ubah pesannya saat sidesLeft lebih dari 1. Tetap kembalikan daftarnya, karena cleanup memakainya untuk membawa yang selamat kembali ke lobby.

Cleanup

Yang selamat masih berdiri di map, jadi cleanup me-respawn mereka di lobby dengan Player:LoadCharacterAsync(), pengganti LoadCharacter yang lebih lama, lalu menghancurkan salinan map. Setiap respawn berjalan di task.spawn-nya sendiri di dalam pcall, karena pemanggilannya menunggu karakter selesai dimuat dan bisa gagal kalau pemain keluar tepat saat itu. Pemain yang tersingkir tidak perlu apa-apa: mereka sudah respawn sendiri di lobby.

Langkah 3: Tampilkan timer dan status ke setiap pemain

Server memublikasikan tiga atribut di ReplicatedStorage.RoundInfo: State (kata tetap seperti InRound, untuk script), Status (teks untuk manusia) dan TimeLeft (detik). Atribut yang diatur script server di objek yang direplikasi sampai ke setiap client secara otomatis, dan pemain yang masuk di tengah ronde langsung mendapat nilai saat ini. Itu sebabnya cara ini lebih cocok daripada RemoteEvent untuk timer: RemoteEvent yang di-fire sebelum seseorang masuk tidak pernah sampai ke orang itu.

  1. Di Explorer, sisipkan ScreenGui ke StarterGui dan beri nama RoundHud. Biarkan ResetOnSpawn menyala (default).
  2. Sisipkan LocalScript ke RoundHud, beri nama RoundHudClient dan tempel kode di bawah. Script ini membuat label-nya sendiri, jadi tidak ada lagi yang perlu digambar.
  3. Tekan Play. Label di bagian atas layar menampilkan status dan hitung mundur m:ss.
LocalScript di ScreenGui RoundHud di StarterGui bernama RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Label-nya. Kalau kamu sudah mendesain TextLabel sendiri di RoundHud, hapus blok ini dan pakai:
-- 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 -- pesan yang lebih panjang memakai 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()

Karena ResetOnSpawn menyala, Roblox memberi pemain salinan RoundHud yang baru setiap kali karakternya muncul, termasuk respawn saat cleanup. Script lalu membaca atribut saat ini lagi, jadi label-nya tidak pernah ketinggalan.

Client hanya membaca. Apa pun yang diubah pemain di layarnya sendiri tidak memengaruhi timer yang asli, karena perubahan atribut oleh LocalScript tetap di client itu saja. Untuk hitung mundur yang menampilkan sepersepuluh detik, server bisa menyimpan waktu selesai dari workspace:GetServerTimeNow() di sebuah atribut, lalu setiap client mengurangkan workspace:GetServerTimeNow() miliknya sendiri di setiap frame.

Kalau game kamu dibuka dengan main menu, RoundHud muncul saat pemain menekan Play, karena StarterGui baru disalin ke pemain setelah karakternya muncul. Pemain yang masih di menu belum punya karakter, jadi mereka tidak pernah di-teleport ke ronde.

Pemain yang mati, keluar atau masuk di tengah ronde

Kasus-kasus ini mudah terlewat saat pertama kali menulis script ronde. Kalau satu tidak ditangani, biasanya kamu melihat error di Output atau ronde yang tidak pernah berakhir. Ini yang dilakukan script di atas untuk masing-masing.

Kasus khusus dan cara script ronde menanganinya
SituasiYang terjadiDi bagian script
Pemain mati di ronde (dibunuh, reset, jatuh)Dia dikeluarkan dari ronde dan respawn di lobby setelah Players.RespawnTime (default 5 detik).humanoid.Died memanggil eliminate
Karakter dihapus tanpa matiSama seperti mati: dia keluar.player.CharacterRemoving memanggil eliminate
Pemain keluar dari serverDia dikeluarkan, koneksinya diputus, dan tick berikutnya menghitung ulang pihak yang tersisa.Players.PlayerRemoving memanggil eliminate
Pemain masuk di tengah rondeDia muncul di lobby, melihat status dan timer yang sedang berjalan, dan ikut ronde berikutnya.Peserta hanya dipilih di startRound
Pemain sedang mati saat ronde dimulaiDia tidak di-teleport dan menunggu di lobby.getLivingCharacter
Semua keluar atau matiRonde berakhir dengan "Nobody survived" dan loop mulai lagi: Intermission kalau pemain di server masih cukup, Waiting kalau tidak.sidesLeft == 0 di runRound

eliminate ditulis supaya aman dipanggil lebih dari sekali untuk pemain yang sama. Pemain yang mati lalu respawn memicu Died dan CharacterRemoving, dan pemain yang keluar bisa memicu ketiga event; hanya panggilan pertama yang berbuat sesuatu.

Mengembangkannya: tim, voting map dan event ronde

Tim terakhir yang bertahan

Isi USE_TEAMS = true, lalu tambahkan objek Team di bawah service Teams di Explorer, masing-masing dengan nama dan TeamColor sendiri. Secara default Roblox memasukkan setiap pemain yang baru masuk ke tim auto-assignable dengan anggota paling sedikit. Roblox tidak menyeimbangkan ulang saat pemain keluar, jadi tim bisa tidak seimbang di sesi yang panjang. Biarkan SpawnLocation lobby tetap Neutral supaya setiap tim muncul di sana. Ronde lalu berakhir saat hanya satu tim yang masih punya pemain hidup, dan hasilnya berbunyi "Red wins!".

Untuk format satu lawan banyak (satu pemburu, yang lain bertahan hidup), pilih satu peserta secara acak di startRound dan isi Team-nya dengan tim pemburu sebelum teleport. Hapus centang AutoAssignable di tim pemburu supaya pemain baru tidak pernah dimasukkan ke sana, dan pindahkan pemburu kembali ke tim survivor di cleanup. Kondisi berakhir yang sama lalu tetap berlaku: pemburu menang kalau semua survivor tersingkir, dan survivor menang kalau mereka bertahan sampai timer habis, asalkan kamu melewati awardWin untuk pemburu saat waktu habis.

Membiarkan pemain memilih map

Voting butuh client berbicara ke server, artinya butuh RemoteEvent. Selama intermission, server memublikasikan dua atau tiga nama map sebagai atribut, setiap client mem-fire RemoteEvent dengan nama yang diklik, dan server menghitung suaranya sebelum loadMap berjalan. Server harus mengecek setiap suara: argumennya string, termasuk salah satu pilihan saat ini, state-nya Intermission, dan setiap pemain dihitung sekali (simpan suara di tabel dengan Player sebagai key, supaya suara kedua menggantikan yang pertama, dan hapus saat PlayerRemoving). Panduan RemoteEvent membahas pola validasi itu secara lengkap.

Memberi pemain tool saat ronde dimulai

Script lain bisa bereaksi pada ronde tanpa menyentuh RoundSystem. Script ronde mengatur atribut InRound di setiap pemain saat dia di-teleport masuk dan menghapusnya saat dia tersingkir. Script ini mendengarkan itu dan memberi setiap pemain salinan Tool bernama RoundTool yang disimpan di ServerStorage.

Script di 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

Tidak ada kode untuk mengambil tool-nya kembali. Saat karakter mati, Roblox mengganti Backpack dengan yang baru dan mengisinya dari StarterPack, dan LoadCharacterAsync saat cleanup mengosongkannya untuk yang selamat, jadi tool-nya hilang saat ronde selesai.

Untuk senjata yang dibagikan, buat pedang atau senjata raycast (dalam bahasa Inggris), simpan di ServerStorage, bukan di StarterPack, lalu ganti "RoundTool" di script ini dengan namanya.

NPC dan objek lain khusus ronde

Apa pun yang hanya boleh ada selama ronde bisa ditaruh di dalam model map: musuh, pickup, platform bergerak. Script di dalam model di ServerStorage tidak berjalan; begitu salinannya ada di Workspace, script itu mulai, dan map:Destroy() saat cleanup menghapusnya bersama semua yang lain. Untuk menambah musuh yang mengejar pemain, buat satu dengan panduan NPC pathfinding lalu taruh di map. Untuk flyover map setiap kali ronde dimulai, panduan cutscene menunjukkan cara script ini memulai cutscene untuk setiap pemain lewat BindableEvent.

Mengubahnya jadi module

Kamu tidak perlu ModuleScript untuk mulai. Satu Script lebih mudah dibaca selama kamu membangun game. Pecah script-nya saat script lain perlu memanggil fungsi ronde, atau saat kamu ingin pengaturannya ada di satu ModuleScript bersama yang bisa di-require oleh server dan UI kamu. Sampai saat itu, atribut State di RoundInfo dan atribut InRound di setiap pemain sudah berfungsi sebagai antarmuka publik sistem ronde: script mana pun bisa mendengarkannya.

Error umum dan cara memperbaikinya

Buka jendela Output (dari menu Window atau tab Script di Studio) sebelum kamu menekan Play. Sebagian besar masalah sistem ronde menampilkan warning atau error di sana, lengkap dengan nama script dan nomor barisnya.

Tertahan di "Waiting for players (1/2)"

Kamu mengetes sendirian dan MIN_PLAYERS bernilai 2. Isi 1 untuk tes solo, atau tes dengan Server & Clients dan 2 client.

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

Folder-nya tidak ada, salah eja atau ada di service yang salah. Harus berupa Folder bernama persis Maps langsung di dalam ServerStorage. Warning yang sama untuk RoundInfo di LocalScript berarti script RoundSystem tidak pernah sampai ke tahap membuatnya: script itu dinonaktifkan, error, atau masih menunggu folder Maps.

Pemain jatuh menembus map setelah teleport

Part map tidak di-anchor, jadi salinannya berantakan begitu masuk Workspace. Pilih map-nya, anchor part-nya, dan cek bahwa part spawn ada di atas lantai, bukan di dalamnya.

Pemain yang tersingkir respawn di dalam arena

Ada SpawnLocation di dalam map. Ganti dengan Part biasa di folder Spawns map itu.

Ronde tidak pernah berakhir setelah semua mati

Cek bahwa damage kamu benar-benar membunuh Humanoid (health mencapai 0), bukan sekadar memindahkan atau meng-anchor pemain. Kalau kamu menonaktifkan state Dead pada humanoid, Died tidak pernah terpicu dan ronde harus berjalan sampai timer habis.

Loop ronde berhenti total setelah satu error

Loop berjalan di satu thread, jadi error di state mana pun menghentikannya. Baca error-nya di Output, perbaiki barisnya, lalu tes lagi. Penyebab yang sering muncul adalah mengubah script supaya memakai player.Character.Humanoid tanpa mengecek apakah karakternya ada.

Buat dengan RoCode

Kalau kamu tidak mau merakit ini secara manual, RoCode bisa membuatnya di place yang sedang kamu buka. RoCode adalah agen AI yang bekerja lewat plugin Roblox Studio, jadi script dan part-nya muncul di Explorer kamu, bukan di jendela chat yang harus kamu tempel sendiri.

Kamu ketik

Tambahkan sistem ronde: intermission 20 detik yang butuh 2 pemain, map acak dari ServerStorage.Maps, teleport semua orang ke part spawn di map, ronde 2 menit di mana pemain terakhir yang hidup menang, tambahkan satu Win di leaderstats, dan tampilkan status serta timer di bagian atas layar.

RoCode mengerjakan
  • Bisa memeriksa place kamu dulu dengan List Children, Search Game dan Search Scripts, jadi RoCode memakai folder Maps dan script leaderstats yang sudah ada, bukan menambah set kedua
  • Membuat Script ronde di ServerScriptService dan LocalScript timer dengan Create Script, dan bisa memasang arena dari struktur siap pakainya dengan Place Prefab kalau kamu belum punya map
  • Mengecek compile setiap script di dalam Studio dengan Check Script sebelum selesai. Itu menangkap error sintaks, bukan logika ronde
  • Setelah kamu playtest, Check Output membaca baris Server dan Client dari playtest terakhirmu supaya RoCode bisa memperbaiki error saat runtime

Dengan plugin 3.9 atau lebih baru RoCode bisa menjalankan playtest singkat dan membaca error-nya, dan dengan plugin 3.9.11 atau lebih baru RoCode bisa mengendalikan satu karakter tes, tapi RoCode tidak mengetes dengan beberapa pemain, jadi kamu sendiri yang menjalankan rondenya dengan Server & Clients. Setiap batch perubahan adalah satu titik undo di Studio. Loop ronde adalah inti banyak game, dan membuat satu game Roblox utuh dengan AI, sistem demi sistem sering dimulai dari loop seperti ini. Cara RoCode tersambung ke Studio.

Pertanyaan umum

Bagaimana cara membuat sistem ronde dengan tim?

Tambahkan objek Team di bawah service Teams dan isi USE_TEAMS = true di script ronde. Roblox memasukkan pemain yang baru masuk ke tim auto-assignable dengan anggota paling sedikit, dan ronde berakhir saat hanya satu tim yang masih punya pemain hidup.

Bagaimana cara menampilkan hitung mundur ke setiap pemain?

Simpan sisa detik sebagai atribut di objek di ReplicatedStorage dari server, lalu dengarkan dengan GetAttributeChangedSignal di LocalScript yang memperbarui TextLabel, seperti di Langkah 3. Pemain yang masuk belakangan langsung mendapat nilai saat ini.

Sebaiknya pakai wait() atau task.wait() di loop ronde?

Pakai task.wait(). Roblox menandai wait() global sebagai deprecated dan digantikan oleh task.wait().

Bagaimana cara men-teleport pemain ke place lain untuk setiap ronde?

Itu alat yang berbeda. Panduan ini memindahkan karakter di dalam satu server dengan PivotTo. Mengirim pemain ke place lain di experience kamu memakai TeleportService, yang memindahkan mereka ke server lain. Panduan teleport membuat portal yang melakukan itu, dengan percobaan ulang kalau teleport gagal.

Kenapa pemainku diam sebentar setelah teleport?

Dengan instance streaming aktif, client belum menerima map-nya. Pemanggilan RequestStreamAroundAsync di script selama hitung mundur bersiap meminta engine mengirimnya lebih awal; GET_READY_SECONDS yang lebih panjang memberi koneksi lambat lebih banyak waktu.

Sumber dan bacaan lanjutan

Cara kode ini dicek: setiap skrip di halaman ini lolos pemeriksa tipe strict Luau dengan definisi API Roblox (luau-lsp, 14 November 2026). Pemeriksaan tipe menangkap nama API yang salah ketik dan tipe yang keliru, bukan logika game, jadi uji dulu di Studio sebelum dipublikasikan.

Coba RoCode di game kamu sendiri.

Kredit gratis setiap hari, tanpa kartu. Pasang plugin-nya, jelaskan fiturnya, lalu cek hasilnya di Studio.