V skratke
Napíšte jeden serverový Script v ServerScriptService, ktorý dokola prechádza pevnou sadou stavov: prestávka (počkať na potrebný počet hráčov, potom odpočítavanie), načítanie mapy (naklonovať náhodnú mapu zo ServerStorage do Workspace), teleport (presunúť každú živú postavu na spawn part cez PivotTo), kolo (tikať časovač, kým nevyprší čas alebo nezostane jeden hráč či jeden tím) a upratovanie (udeliť Wins, oživiť preživších, vymazať mapu).
- Cyklus spúšťajte len na serveri. Stav a zostávajúce sekundy zverejňujte ako atribúty na Folder v ReplicatedStorage a zobrazovať ich nech má na starosti LocalScript.
- Majte tabuľku tých, ktorí sú ešte v kole. Hráča z nej odstráňte, keď jeho Humanoid zomrie, jeho postava sa vymaže alebo odíde.
- Teleportujte len hráčov, ktorých postava je pri štarte kola živá. Kto príde neskôr, čaká v lobby na ďalšie.
Na tejto stránke
Ako funguje systém kôl
Systém kôl je stavový automat. Server je v každom okamihu presne v jednom stave, každý stav má jednu úlohu a jedna podmienka ho posunie do ďalšieho. Ak to píšete takto, celá logika leží na jednom mieste a nevznikne klasická chyba, keď cyklus časovača aj cyklus kola oba skúšajú ukončiť to isté kolo.
| Stav | Čo robí server | Kedy prejde ďalej |
|---|---|---|
| Waiting | Zobrazuje "Waiting for players (1/2)" | Na serveri je dosť hráčov |
| Intermission | Odpočítava čas, kým sú všetci v lobby | Odpočítavanie skončilo (alebo návrat do Waiting, ak hráči odišli) |
| Starting | Skopíruje náhodnú mapu do Workspace, zobrazí jej názov, požiada klientov, aby ju načítali | Skončilo krátke odpočítavanie "pripravte sa" |
| InRound | Teleportuje živých hráčov, tiká časovač, odstraňuje tých, ktorí zomreli alebo odišli | Vypršal čas alebo zostal jeden hráč či jeden tím |
| Results | Dá Win všetkým, ktorí sú ešte živí, a ukáže, kto vyhral | Uplynulo niekoľko sekúnd |
| Cleanup | Oživí preživších v lobby a vymaže mapu | Hneď, potom cyklus začne odznova |
Každý stav vlastní server. Klienti len zobrazujú to, čo im server povie. Odpočítavanie v LocalScript sa rozchádza so skutočným, je nesprávne u tých, ktorí prišli neskôr, a exploiter ho môže zmeniť. Ak je pre vás rozdelenie na server a klienta nové, najprv si prečítajte Script vs LocalScript vs ModuleScript.
Krok 1: Postavte lobby, mapy a štatistiku Wins
- Postavte lobby vo Workspace so
SpawnLocation. Skontrolujte, že má zaškrtnutú vlastnosť Neutral, aby sa tu každý hráč spawnoval, tu čakal a sem sa vracal po vypadnutí. - Do ServerStorage vložte
Folders názvomMaps. Objekty v ServerStorage sa hráčom nikdy neposielajú, takže nepoužívané mapy ich nič nestoja. - Postavte každú mapu ako
ModelvnútriMaps, s ukotvenými partmi. Postavte ju ďaleko od lobby (stačí niekoľko stoviek studov), pretože kópia sa objaví presne tam, kde ste ju postavili, a vyradení hráči by sa nemali vedieť vrátiť dnu. - Do každej mapy pridajte
Folders názvomSpawnsa doň jeden ukotvenýPartna každého očakávaného hráča. Nastavte im Transparency 1 a vypnite CanCollide, aby ich nikto nevidel a nezakopával o ne.
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
Skript kôl pripočíta 1 k IntValue s názvom Wins vnútri priečinka leaderstats hráča. Ak vaša hra ešte nemá leaderstats, pridajte tento krátky skript. Ak ho už máte, napríklad verziu s ukladaním z návodu na leaderboard, preskočte ho: dva skripty, ktoré vytvárajú leaderstats, dajú každému hráčovi dva priečinky.
local Players = game:GetService("Players")
local function setupLeaderstats(player: Player)
local leaderstats = Instance.new("Folder")
leaderstats.Name = "leaderstats" -- názov musí byť presne takýto, malými písmenami
local wins = Instance.new("IntValue")
wins.Name = "Wins"
wins.Value = 0
wins.Parent = leaderstats
leaderstats.Parent = player
end
Players.PlayerAdded:Connect(setupLeaderstats)
-- V Studiu sa môžete pripojiť skôr, než sa tento skript spustí, preto nastavíme všetkých, čo už sú tu
for _, player in Players:GetPlayers() do
setupLeaderstats(player)
end
Tieto Wins sa vynulujú, keď hráč odíde. Aby sa ukladali medzi reláciami, použite verziu s DataStore z návodu na leaderboard.
Krok 2: Pridajte skript kôl
Vložte Script do ServerScriptService, pomenujte ho RoundSystem a vložte doň kód nižšie. Nastavenia hore sú jediné riadky, ktoré budete pravdepodobne meniť. Každý stav je samostatná funkcia a cyklus dole ich spúšťa po poradí, donekonečna.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
-- Nastavenia
local MIN_PLAYERS = 2 -- nastavte 1, kým testujete sami
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: kolo skončí, keď hráči zostanú len v jednom tíme
local mapsFolder = ServerStorage:WaitForChild("Maps")
local random = Random.new()
-- To, čo zobrazuje obrazovka každého hráča, je uložené v atribútoch na tomto priečinku.
-- Atribúty nastavené serverom sa replikujú všetkým klientom, aj tým, čo prišli neskôr.
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
-- Kto je ešte v aktuálnom kole a pripojenia, ktoré sledujú každého z nich
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)
-- Vráti postavu a Humanoid, len ak je hráč práve teraz živý
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
-- Spočíta strany, ktoré zostali v kole (hráčov alebo tímy, ak je zapnuté USE_TEAMS)
local function countSides(): (number, number)
local sides: { [Instance]: boolean } = {}
local sideCount = 0
local playerCount = 0
for player in alive do
playerCount += 1
local team = player.Team
local side: Instance = if USE_TEAMS and team then team else player
if not sides[side] then
sides[side] = true
sideCount += 1
end
end
return sideCount, playerCount
end
-- STAV: Waiting a Intermission. Vráti false, ak hráči odišli počas odpočítavania.
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
-- STAV: Starting, časť 1. Skopírujeme náhodnú mapu (nie minulú, ak je z čoho vyberať).
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
-- Zamiešame, aby hráči nepadali na ten istý spawn každé kolo
for i = #points, 2, -1 do
local j = random:NextInteger(1, i)
points[i], points[j] = points[j], points[i]
end
return points
end
-- V akej výške nad podlahou je root part stojacej postavy.
-- Vzorec z referencie Robloxu k Humanoid.HipHeight (pri rigoch R6 sa pridáva výška nohy).
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
-- STAV: Starting, časť 2. Pripraviť sa, potom teleportovať všetkých živých.
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
-- So zapnutým streamingom požiadame každého klienta, aby načítal mapu pred príchodom postavy
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
-- Zúčastnia sa len tí, ktorí sú práve teraz živí. Ostatní čakajú na ďalšie kolo.
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 postavy je jej root part, preto ho zdvihneme do výšky státia nad partom
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
-- STAV: InRound. Skončí, keď vypršal čas alebo zostala jedna strana.
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()
-- Kolo začaté jednou stranou (test osamote) skončí len časom alebo smrťou
if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
break
end
end
end
-- STAV: Results. Vyhrávajú všetci, ktorí sú ešte živí.
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) -- prestaneme ich sledovať; zostanú na mape až do upratovania
end
setState("Results", message)
task.wait(RESULTS_SECONDS)
return winners
end
-- STAV: Cleanup. Pošleme preživších späť do lobby, potom vymažeme mapu.
local function cleanup(map: Model, survivors: { Player })
for _, player in survivors do
if player.Parent then -- ešte na serveri
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
-- Cyklus: jeden prechod je jedno kolo
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) -- máp zatiaľ niet: čoskoro to skúsime znova
end
end
end
Všetko dôležité sa deje tu, na serveri: kto je v kole, časovač, víťaz a Wins. Klienti dostávajú len tri atribúty na ReplicatedStorage.RoundInfo (State, Status a TimeLeft) a atribút InRound na každom hráčovi.
Ako funguje každý stav
Čakanie a prestávka
runIntermission najprv drží cyklus, kým #Players:GetPlayers() nedosiahne MIN_PLAYERS. Potom odpočítava po jednej sekunde cez task.wait(1) a pri každom tiku kontroluje počet hráčov. Ak niekto odišiel a na serveri je menej než minimum, vráti false a hlavný cyklus začne odznova od Waiting, takže kolo sa nikdy nezačne s jedným človekom.
Výber a načítanie mapy
loadMap zozbiera všetky Model v ServerStorage.Maps, vylúči mapu minulého kola, ak je z čoho vyberať, a jednu vyberie cez Random:NextInteger. Potom mapu naklonuje do Workspace. Originál zostane nedotknutý v ServerStorage, takže každé kolo začína s čerstvou kópiou: všetko, čo hráči v minulom kole rozbili alebo posunuli, zmizne.
V nových placoch je zapnutý streaming inštancií: klient má len party pri svojej postave. Pred teleportom skript zavolá Player:RequestStreamAroundAsync pre každého hráča, čo požiada engine, aby počas odpočítavania "pripravte sa" poslal klientovi oblasť okolo mapy. Bez toho môžu hráči prísť skôr, než sa načíta podlaha, a na okamih zamrznúť.
Teleport hráčov cez PivotTo
Po odpočítavaní skript zostaví zoznam účastníkov z hráčov, ktorých postava existuje, je ešte vo svete a má Humanoid so zdravím nad 0 a root part. Táto kontrola prebieha po odpočítavaní, takže kto počas neho zomrel alebo odišiel, sa do zoznamu nedostane.
Každého účastníka presunie character:PivotTo(cframe). Referencia Robloxu označuje PivotTo za hlavný spôsob, ako hýbať modelmi zo skriptu, a hýbe všetkými časťami postavy naraz. Nastaviť HumanoidRootPart.Position nie je to isté: Roblox upraví spoje tak, že sa pohne len táto jedna časť, a zvyšok tela môže zostať vzadu. Pivot postavy je jej root part, preto je cieľom CFrame spawn partu zdvihnutý o polovicu výšky partu plus výšku, v ktorej root part stojí nad podlahou. rootHeight ju počíta podľa vzorca z referencie Robloxu k Humanoid.HipHeight: polovica výšky root partu plus HipHeight, plus dĺžka nohy pri rigoch R6. Takže zväčšené a vlastné avatary nezostanú zaseknuté v parte a nepadajú naň zhora. CFrame obsahuje aj otočenie, preto sa hráči pozerajú tým istým smerom ako spawn part: otočte party tak, aby sa všetci pozerali do stredu mapy.
Ak je hráčov viac než spawn partov, skript začne znova od prvého partu a hráči skončia jeden na druhom, preto pridajte aspoň toľko spawnov, koľko je váš maximálny počet hráčov.
Ak používate aj kontrolu rýchlosti z návodu na šprint, pridajte player:SetAttribute("MovementCheckSkip", true) hneď za character:PivotTo(...) v startRound, aby sa teleport nepočítal ako prekročenie rýchlosti.
Časovač kola a podmienky konca
runRound tiká raz za sekundu. Pri každom tiku aktualizuje stav (koľko hráčov zostalo) a zostávajúce sekundy a potom spočíta živé strany. Kolo skončí jedným z troch spôsobov:
- Vypršal čas. Cyklus
fordôjde k 1 a skončí. - Zostala jedna strana. Strana je hráč alebo tím, ak je zapnuté
USE_TEAMS. Kontrola funguje, len ak sa kolo začalo s dvoma alebo viacerými stranami, takže test osamote neskončí v tom istom okamihu, ako začal. - Nikto nezostal. Všetci zomreli alebo odišli a kolo skončí bez víťaza.
Kontrola raz za sekundu znamená, že kolo môže bežať ešte až sekundu po poslednom vypadnutí, čo je na časovači kola takmer nepostrehnuteľné.
Udelenie Wins a zobrazenie výsledku
Pravidlo v tomto skripte je jednoduché: vyhrávajú všetci, ktorí sú živí v okamihu konca kola. To pokrýva posledného preživšieho hráča, posledný preživší tím aj režim "vydrž, kým neskončí časovač" jedným riadkom logiky. finishRound pripočíta 1 k Wins každého víťaza, prestane ich sledovať a na RESULTS_SECONDS zobrazí správu ako "Alex wins!". Ak chcete, aby pri vypršaní času nebol žiadny víťaz, preskočte awardWin a zmeňte správu, keď je sidesLeft väčšie než 1. V každom prípade zoznam naďalej vracajte, pretože upratovanie podľa neho vracia preživších do lobby.
Upratovanie
Preživší ešte stoja na mape, preto ich cleanup oživí v lobby cez Player:LoadCharacterAsync(), ktorý nahrádza starý LoadCharacter, a potom vymaže kópiu mapy. Každé oživenie beží vo vlastnom task.spawn vnútri pcall, pretože volanie čaká na načítanie postavy a môže zlyhať, ak hráč práve v tej chvíli odchádza. Vyradení hráči nepotrebujú nič: už sa sami oživili v lobby.
Krok 3: Ukážte časovač a stav každému hráčovi
Server zverejňuje tri atribúty na ReplicatedStorage.RoundInfo: State (pevné slovo ako InRound, pre skripty), Status (text pre ľudí) a TimeLeft (sekundy). Atribúty, ktoré serverový skript nastaví na replikovanom objekte, sa automaticky dostanú ku každému klientovi a hráč, ktorý príde uprostred kola, hneď dostane aktuálne hodnoty. Preto sa na časovač hodia lepšie než remote: RemoteEvent poslaný predtým, než niekto prišiel, sa k nemu nikdy nedostane.
- V Exploreri vložte ScreenGui do StarterGui a pomenujte ho
RoundHud. Nechajte ResetOnSpawn zapnuté (predvolene). - Vložte LocalScript do
RoundHud, pomenujte hoRoundHudClienta vložte doň kód nižšie. Nápis si vytvorí sám, takže nič iné kresliť netreba. - Stlačte Play. Nápis hore na obrazovke ukazuje stav a odpočítavanie vo formáte
m:ss.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local roundInfo = ReplicatedStorage:WaitForChild("RoundInfo")
local screenGui = script.Parent :: ScreenGui
-- Nápis. Ak ste si v RoundHud nakreslili vlastný TextLabel, vymažte tento blok a použite:
-- 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 -- dlhé správy sa zalomia na druhý riadok
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()
Keďže je ResetOnSpawn zapnuté, Roblox dá hráčovi čerstvú kópiu RoundHud pri každom spawne postavy, vrátane oživenia pri upratovaní. Skript potom znova prečíta aktuálne atribúty, takže nápis nikdy nezastará.
Klient len číta. Nič, čo hráč zmení na svojej obrazovke, neovplyvní skutočný časovač, pretože zmeny atribútov z LocalScript zostávajú na tomto jednom klientovi. Pre odpočítavanie s desatinami sekundy môže server namiesto toho uložiť do atribútu čas konca z workspace:GetServerTimeNow() a každý klient od neho každý snímok odčíta svoje workspace:GetServerTimeNow().
Ak sa vaša hra otvára hlavným menu, RoundHud sa objaví, keď hráč stlačí Play, pretože StarterGui sa hráčovi skopíruje až po spawne jeho postavy. Hráči, ktorí sú ešte v menu, nemajú postavu, preto sa nikdy neteleportujú do kola.
Hráči, ktorí zomrú, odídu alebo prídu uprostred kola
Tieto prípady sa ľahko prehliadnu, keď skript kôl píšete prvýkrát. Ak niektorý z nich nie je ošetrený, zvyčajne uvidíte chybu v Output alebo kolo, ktoré nikdy neskončí. Tu je, čo skript vyššie robí s každým z nich.
| Situácia | Čo sa stane | Kde v skripte |
|---|---|---|
| Hráč v kole zomrie (zabitý, dal reset, spadol) | Odstráni sa z kola a oživí sa v lobby po Players.RespawnTime (predvolene 5 sekúnd). | humanoid.Died zavolá eliminate |
| Postava je vymazaná bez smrti | Ako pri smrti: hráč vypadol. | player.CharacterRemoving zavolá eliminate |
| Hráč odíde zo servera | Odstráni sa, jeho pripojenia sa odpoja a ďalší tik znova spočíta strany. | Players.PlayerRemoving zavolá eliminate |
| Hráč príde uprostred kola | Spawne sa v lobby, vidí živý stav a časovač a dostane sa do ďalšieho kola. | Účastníkov vyberá len startRound |
| Hráč bol pri štarte kola mŕtvy | Neteleportuje sa, čaká v lobby. | getLivingCharacter |
| Všetci odišli alebo zomreli | Kolo skončí s "Nobody survived" a cyklus začne odznova: Intermission, ak je na serveri ešte dosť hráčov, inak Waiting. | sidesLeft == 0 v runRound |
eliminate je napísaný tak, aby sa dal bezpečne volať viackrát pre toho istého hráča. Hráč, ktorý zomrel a oživil sa, spustí Died aj CharacterRemoving, a ten, kto odchádza, môže spustiť všetky tri udalosti; niečo urobí len prvé volanie.
Ako to rozšíriť: tímy, hlasovanie o mape a udalosti kola
Posledný preživší tím
Nastavte USE_TEAMS = true, potom pridajte objekty Team do služby Teams v Exploreri, každému vlastný názov a TeamColor. Predvolene Roblox dá každého hráča, ktorý príde, do automaticky priraďovaného tímu s najmenším počtom členov. Keď hráči odchádzajú, tímy nevyvažuje, takže v dlhých reláciách môžu byť tímy nerovnaké. Nechajte SpawnLocation v lobby Neutral, aby sa tam spawnovali všetky tímy. Potom kolo skončí, keď živí hráči zostanú len v jednom tíme, a výsledok vyzerá ako "Red wins!".
Pre formát "jeden proti všetkým" (jeden lovec, ostatní prežívajú) vyberte v startRound jedného náhodného účastníka a pred teleportom mu nastavte Team na tím lovca. Zrušte AutoAssignable na tíme lovca, aby sa doň nikdy nedostali noví hráči, a v cleanup vráťte lovca do tímu preživších. Potom fungujú tie isté podmienky konca: lovec vyhrá, ak vypadli všetci preživší, a preživší vyhrajú, ak vydržali do konca časovača, za predpokladu, že pri vypršaní času preskočíte awardWin lovca.
Hlasovanie hráčov o mape
Na hlasovanie musí klient komunikovať so serverom, čo znamená, že treba RemoteEvent. Počas prestávky server zverejní cez atribúty dva alebo tri názvy máp, každý klient pošle cez RemoteEvent názov, na ktorý klikol, a server spočíta hlasy pred spustením loadMap. Server musí kontrolovať každý hlas: že argument je reťazec, že je to jedna z aktuálnych možností, že stav je Intermission a že každý hráč sa počíta raz (ukladajte hlasy do tabuľky s kľúčom Player, aby druhý hlas nahradil prvý, a čistite ju v PlayerRemoving). Návod na RemoteEvent podrobne rozoberá tento vzor kontrol.
Pridelenie nástroja na začiatku kola
Iné skripty môžu reagovať na kolo bez toho, aby sa dotkli RoundSystem. Skript kôl nastaví každému hráčovi atribút InRound, keď ho teleportuje, a zruší ho, keď hráč vypadne. Tento skript ho počúva a dá každému hráčovi kópiu Tool s názvom RoundTool, ktorý leží v 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
Kód, ktorý nástroj odoberie, tu nie je. Keď postava zomrie, Roblox nahradí Backpack čerstvým, naplneným zo StarterPack, a LoadCharacterAsync pri upratovaní ho preživším vyčistí, takže po kole už nástroj nie je.
Ak potrebujete zbraň na pridelenie, postavte si meč alebo zbraň na raycastoch, majte ju v ServerStorage namiesto StarterPack a zmeňte "RoundTool" v tomto skripte na jej názov.
NPC a ďalšie objekty len na čas kola
Všetko, čo má existovať len počas kola, môže žiť vnútri modelu mapy: nepriatelia, predmety na zbieranie, pohyblivé plošiny. Skripty vnútri modelu v ServerStorage nebežia; hneď ako sa kópia ocitne vo Workspace, spustia sa a map:Destroy() pri upratovaní ich vymaže spolu so všetkým ostatným. Ak chcete pridať nepriateľov, ktorí naháňajú hráčov, postavte jedného podľa návodu na pathfinding pre NPC a dajte ho do mapy. Pre prelet nad mapou na začiatku každého kola návod na cutscény ukazuje, ako môže tento skript spustiť cutscénu každému hráčovi cez BindableEvent.
Ako z toho urobiť modul
Na začiatok ModuleScript netreba. Jeden Script sa číta jednoduchšie, kým hru staviate. Rozdeľte ho, keď iné skripty potrebujú volať funkcie kola alebo keď chcete presunúť nastavenia do jedného spoločného ModuleScript, ktorý môže cez require načítať server aj vaše UI. Dovtedy atribút State na RoundInfo a atribút InRound na každom hráčovi už fungujú ako verejné rozhranie systému kôl: počúvať ich môže akýkoľvek skript.
Časté chyby a riešenia
Otvorte okno Output (cez menu Window v Studiu alebo kartu Script) pred stlačením Play. Väčšina problémov so systémom kôl tam vypíše varovanie alebo chybu s názvom skriptu a číslom riadku.
Visí na "Waiting for players (1/2)"
Testujete sami a MIN_PLAYERS je 2. Nastavte 1 pre testy osamote alebo testujte v režime Server & Clients s 2 klientmi.
Infinite yield possible on 'ServerStorage:WaitForChild("Maps")'
Priečinok neexistuje, má preklep v názve alebo je v nesprávnej službe. Musí to byť Folder s názvom presne Maps priamo vnútri ServerStorage. To isté varovanie pre RoundInfo v LocalScript znamená, že skript RoundSystem sa k jeho vytvoreniu nikdy nedostal: je vypnutý, spadol s chybou alebo ešte čaká na priečinok Maps.
Po teleporte hráči prepadnú cez mapu
Party mapy nie sú ukotvené, preto sa kópia rozpadne, hneď ako sa ocitne vo Workspace. Označte mapu, ukotvite jej party a skontrolujte, že spawn party stoja nad podlahou, nie v nej.
Vyradení hráči sa oživujú v aréne
Vnútri mapy je SpawnLocation. Nahraďte ho obyčajným Part v priečinku Spawns tejto mapy.
Kolo neskončí, keď všetci zomreli
Skontrolujte, že vaše poškodenie naozaj zabíja Humanoid (zdravie klesne na 0), a nie že hráčov len posúva alebo ukotvuje. Ak ste na Humanoide vypli stav Dead, Died sa nikdy nespustí a kolo musí bežať až do konca časovača.
Cyklus kôl sa po jednej chybe natrvalo zastaví
Cyklus beží v jednom threade, preto ho chyba v ktoromkoľvek stave ukončí. Prečítajte si chybu v Output, opravte riadok a otestujte znova. Častá príčina: skript upravili tak, že používa player.Character.Humanoid bez kontroly, či postava existuje.
Urobiť s RoCode
Ak sa vám nechce toto všetko skladať ručne, RoCode to môže urobiť vo vašom otvorenom place. Je to AI agent, ktorý pracuje cez plugin pre Roblox Studio, preto sa skripty a party objavia vo vašom Exploreri, a nie v okne chatu, odkiaľ by ste ich museli vkladať.
Pridaj systém kôl: prestávka 20 sekúnd, ktorá potrebuje 2 hráčov, náhodná mapa zo ServerStorage.Maps, teleport všetkých na spawn party mapy, kolá po 2 minúty, kde vyhrá posledný živý hráč, pridaj Win do leaderstats a ukáž stav a časovač hore na obrazovke.
- Môže si najprv prezrieť váš place cez List Children, Search Game a Search Scripts, aby použil váš priečinok Maps a skript leaderstats, namiesto pridania druhej sady
- Vytvorí Script kôl v ServerScriptService a LocalScript časovača cez Create Script a môže postaviť arénu zo svojich hotových stavieb cez Place Prefab, ak mapu zatiaľ nemáte
- Pred dokončením overí kompiláciu každého skriptu v Studiu cez Check Script. To zachytí syntaktické chyby, nie chyby logiky kola
- Po vašom playteste Check Output prečíta riadky Server a Client z posledného playtestu, aby opravil chybu počas behu
S pluginom 3.9 alebo novším môže RoCode spustiť krátky playtest a prečítať chyby a s pluginom 3.9.11 alebo novším môže ovládať jednu testovaciu postavu, ale s viacerými hráčmi netestuje, preto kolá vyskúšajte sami v režime Server & Clients. Každá dávka zmien je bod na vrátenie v Studiu. Cyklus kôl je základom mnohých hier a stavba celej hry v Robloxe s AI, systém po systéme často začína takýmto cyklom. Ako sa RoCode pripája k Studiu.
Časté otázky
Ako urobiť systém kôl s tímami v Robloxe?
Pridajte objekty Team do služby Teams a nastavte USE_TEAMS = true v skripte kôl. Roblox rozdelí prichádzajúcich hráčov do automaticky priraďovaného tímu s najmenším počtom členov a kolo skončí, keď živí hráči zostanú len v jednom tíme.
Ako ukázať odpočítavanie všetkým hráčom?
Nastavujte zo servera zostávajúce sekundy ako atribút na objekte v ReplicatedStorage a počúvajte ho cez GetAttributeChangedSignal v LocalScript, ktorý aktualizuje TextLabel, ako v kroku 3. Hráči, ktorí prídu neskôr, hneď dostanú aktuálnu hodnotu.
Čo použiť v cykle kôl: wait() alebo task.wait()?
Použite task.wait(). Roblox označuje globálne wait() ako zastarané a nahradené task.wait().
Ako teleportovať hráčov do iného place pre každé kolo?
To je iný nástroj. Tento návod presúva postavy v rámci jedného servera cez PivotTo. Posielanie hráčov do iného place vášho experience ide cez TeleportService, ktorý ich presunie na iný server. Návod na teleporty stavia portály, ktoré to robia, s opakovanými pokusmi, ak teleport zlyhá.
Prečo hráči po teleporte na okamih zamrznú?
So zapnutým streamingom inštancií klient ešte nedostal mapu. Volanie RequestStreamAroundAsync v skripte počas odpočítavania "pripravte sa" požiada engine, aby ju poslal vopred; dlhší GET_READY_SECONDS dá pomalým pripojeniam viac času.
Zdroje a ďalšie čítanie
- Roblox Creator Docs: Add rounds (po anglicky). vlastný tímový cyklus kôl od Robloxu v príklade s laser tagom
- Roblox Creator Docs: PVInstance:PivotTo (po anglicky). presúvanie modelov a postáv zo skriptu
- Roblox Creator Docs: Player (po anglicky). LoadCharacterAsync, CharacterRemoving a RequestStreamAroundAsync
- Roblox Creator Docs: Properties and attributes (po anglicky). nastavovanie atribútov a sledovanie zmien
- Roblox Creator Docs: Implement teams (po anglicky). pridávanie tímov a automatické priraďovanie
- Roblox Creator Docs: Studio testing modes (po anglicky). test s viacerými klientmi Server & Clients
Ako bol kód overený: každý skript na tejto stránke prechádza prísnou kontrolou typov Luau s definíciami Roblox API (luau-lsp, 20. novembra 2026). Kontrola typov zachytí chyby v názvoch API a nesprávne typy, ale nie chyby v hernej logike, preto všetko pred publikovaním otestujte v Studiu.