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
Cara sistem pusingan berfungsi
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 | Apa yang pelayan buat | Bila ia beralih |
|---|---|---|
| Waiting | Memaparkan "Waiting for players (1/2)" | Pemain di pelayan sudah cukup |
| Intermission | Mengira detik sementara semua orang di lobi | Kiraan detik tamat (atau kembali ke Waiting jika pemain keluar) |
| Starting | Menyalin peta rawak ke Workspace, memaparkan namanya, meminta client memuatkannya | Kiraan detik pendek "bersedia" tamat |
| InRound | Menteleport pemain yang hidup, menjalankan pemasa, mengeluarkan mereka yang mati atau keluar | Masa habis, atau tinggal seorang pemain atau satu pasukan |
| Results | Memberi Win kepada semua yang masih hidup, dan memaparkan siapa yang menang | Beberapa saat berlalu |
| Cleanup | Menghidupkan semula yang terselamat di lobi dan memadam peta | Serta-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
- 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. - Dalam ServerStorage, masukkan
FolderbernamaMaps. Objek dalam ServerStorage tidak pernah dihantar kepada pemain, jadi peta yang tidak digunakan tidak membebankan mereka. - Bina setiap peta sebagai
Modeldi dalamMaps, 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. - Di dalam setiap peta, tambah
FolderbernamaSpawns, dan di dalamnya satuPartyang Anchored bagi setiap pemain yang dijangka. Tetapkan Transparency kepada 1 dan matikan CanCollide, supaya tiada siapa nampak atau tersadung padanya.
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.
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.
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
forsampai ke 1 dan tamat. - Tinggal satu pihak. Pihak ialah pemain, atau pasukan jika
USE_TEAMSdihidupkan. 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.
- Dalam Explorer, masukkan ScreenGui ke dalam StarterGui dan namakannya
RoundHud. Biarkan ResetOnSpawn dihidupkan (lalai). - Masukkan LocalScript ke dalam
RoundHud, namakannyaRoundHudClientdan tampal kod di bawah. Ia mencipta label sendiri, jadi tiada apa-apa lagi yang perlu dilukis. - Tekan Play. Label di bahagian atas skrin memaparkan status dan kiraan detik dalam format
m:ss.
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.
| Situasi | Apa yang berlaku | Di 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 mati | Sama seperti mati: pemain tersingkir. | player.CharacterRemoving memanggil eliminate |
| Pemain keluar dari pelayan | Dia dikeluarkan, sambungannya diputuskan, dan detik seterusnya mengira semula pihak. | Players.PlayerRemoving memanggil eliminate |
| Pemain masuk di tengah pusingan | Dia spawn di lobi, nampak status dan pemasa secara langsung, dan masuk ke pusingan seterusnya. | Peserta hanya dipilih dalam startRound |
| Pemain sudah mati ketika pusingan bermula | Dia tidak diteleport, dia menunggu di lobi. | getLivingCharacter |
| Semua keluar atau mati | Pusingan 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.
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.
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.
- 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
- Roblox Creator Docs: Add rounds (dalam bahasa Inggeris). kitaran pusingan berpasukan Roblox sendiri dalam contoh laser tag
- Roblox Creator Docs: PVInstance:PivotTo (dalam bahasa Inggeris). menggerakkan model dan watak dari skrip
- Roblox Creator Docs: Player (dalam bahasa Inggeris). LoadCharacterAsync, CharacterRemoving dan RequestStreamAroundAsync
- Roblox Creator Docs: Properties and attributes (dalam bahasa Inggeris). menetapkan atribut dan memantau perubahan
- Roblox Creator Docs: Implement teams (dalam bahasa Inggeris). menambah pasukan dan auto-assign
- Roblox Creator Docs: Studio testing modes (dalam bahasa Inggeris). ujian dengan beberapa client Server & Clients
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.