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
Cara kerja sistem ronde
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 | Apa yang dilakukan server | Lanjut saat |
|---|---|---|
| Waiting | Menampilkan "Waiting for players (1/2)" | Pemain di server sudah cukup |
| Intermission | Menghitung mundur selama semua orang ada di lobby | Hitung mundur selesai (atau kembali ke Waiting kalau ada pemain keluar) |
| Starting | Menyalin map acak ke Workspace, menampilkan namanya, meminta client memuatnya | Hitung mundur singkat "bersiap" selesai |
| InRound | Men-teleport pemain yang hidup, menjalankan timer, mengeluarkan pemain yang mati atau keluar | Waktu habis, atau tinggal satu pemain atau tim |
| Results | Memberi satu Win ke semua yang masih hidup dan menampilkan pemenangnya | Beberapa detik berlalu |
| Cleanup | Me-respawn yang selamat di lobby dan menghancurkan map | Langsung, 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
- 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. - Di ServerStorage, sisipkan sebuah
FolderbernamaMaps. Objek di ServerStorage tidak pernah dikirim ke pemain, jadi map yang tidak dipakai tidak membebani mereka. - Buat setiap map sebagai
Modeldi dalamMaps, 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. - Di dalam setiap map, tambahkan
FolderbernamaSpawnsberisi satuPartyang di-anchor untuk setiap pemain yang kamu perkirakan. Isi Transparency-nya dengan 1 dan matikan CanCollide supaya tidak ada yang melihat atau tersandung.
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.
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.
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
formencapai 1 dan selesai. - Tinggal satu pihak. Satu pihak adalah satu pemain, atau satu tim kalau
USE_TEAMSaktif. 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.
- Di Explorer, sisipkan ScreenGui ke StarterGui dan beri nama
RoundHud. Biarkan ResetOnSpawn menyala (default). - Sisipkan LocalScript ke
RoundHud, beri namaRoundHudClientdan tempel kode di bawah. Script ini membuat label-nya sendiri, jadi tidak ada lagi yang perlu digambar. - Tekan Play. Label di bagian atas layar menampilkan status dan hitung mundur
m:ss.
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.
| Situasi | Yang terjadi | Di 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 mati | Sama seperti mati: dia keluar. | player.CharacterRemoving memanggil eliminate |
| Pemain keluar dari server | Dia dikeluarkan, koneksinya diputus, dan tick berikutnya menghitung ulang pihak yang tersisa. | Players.PlayerRemoving memanggil eliminate |
| Pemain masuk di tengah ronde | Dia muncul di lobby, melihat status dan timer yang sedang berjalan, dan ikut ronde berikutnya. | Peserta hanya dipilih di startRound |
| Pemain sedang mati saat ronde dimulai | Dia tidak di-teleport dan menunggu di lobby. | getLivingCharacter |
| Semua keluar atau mati | Ronde 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.
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.
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.
- 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
- Roblox Creator Docs: Add rounds (dalam bahasa Inggris). loop ronde berbasis tim milik Roblox sendiri di contoh laser tag
- Roblox Creator Docs: PVInstance:PivotTo (dalam bahasa Inggris). menggerakkan model dan karakter dari script
- Roblox Creator Docs: Player (dalam bahasa Inggris). LoadCharacterAsync, CharacterRemoving dan RequestStreamAroundAsync
- Roblox Creator Docs: Properties and attributes (dalam bahasa Inggris). mengatur atribut dan mendeteksi perubahannya
- Roblox Creator Docs: Implement teams (dalam bahasa Inggris). menambahkan tim dan pembagian otomatis
- Roblox Creator Docs: Studio testing modes (dalam bahasa Inggris). tes multi-client Server & Clients
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.