Ve zkratce
Napište jeden serverový Script v ServerScriptService, který dokola prochází pevnou sadou stavů: přestávka (počkat na dost hráčů, pak odpočet), načtení mapy (naklonovat náhodnou mapu ze ServerStorage do Workspace), teleport (přesunout každou živou postavu na spawn part přes PivotTo), kolo (nechat tikat časovač, dokud nevyprší čas nebo nezbude jeden hráč či jeden tým) a úklid (rozdat Wins, oživit přeživší, smazat mapu).
- Smyčku spouštějte jen na serveru. Stav a zbývající sekundy zveřejňujte jako atributy na Folder v ReplicatedStorage a zobrazovat je nechte LocalScript.
- Držte tabulku těch, kdo jsou ještě v kole. Hráče odeberte, když jeho Humanoid zemře, jeho postava se smaže nebo odejde.
- Teleportujte jen hráče, jejichž postava je na začátku kola živá. Kdo přišel později, čeká v lobby na další.
Na této stránce
Jak systém kol funguje
Systém kol je stavový automat. V každém okamžiku je server přesně v jednom stavu, každý stav má jeden úkol a jedna podmínka ho posune do dalšího. Když to píšete takto, celá logika leží na jednom místě a nevznikne klasická chyba, kdy se smyčka časovače i smyčka kola snaží ukončit stejné kolo.
| Stav | Co server dělá | Kdy přejde dál |
|---|---|---|
| Waiting | Ukazuje "Waiting for players (1/2)" | Na serveru je dost hráčů |
| Intermission | Odpočítává čas, zatímco jsou všichni v lobby | Odpočet skončil (nebo návrat do Waiting, pokud hráči odešli) |
| Starting | Zkopíruje náhodnou mapu do Workspace, ukáže její název, požádá klienty, aby ji načetli | Skončil krátký odpočet "připravte se" |
| InRound | Teleportuje živé hráče, nechá tikat časovač, odebírá ty, kdo zemřeli nebo odešli | Vypršel čas, nebo zbyl jeden hráč či jeden tým |
| Results | Dá Win všem, kdo jsou ještě naživu, a ukáže, kdo vyhrál | Uplynulo několik sekund |
| Cleanup | Oživí přeživší v lobby a smaže mapu | Hned, pak smyčka začne znovu |
Každý stav vlastní server. Klienti jen ukazují, co jim server řekne. Odpočet v LocalScriptu se rozchází se skutečným, je špatný u těch, kdo přišli později, a exploiter ho může změnit. Pokud je pro vás rozdělení na server a klienta nové, přečtěte si nejdřív Script vs LocalScript vs ModuleScript.
Krok 1: Postavte lobby, mapy a statistiku Wins
- Postavte lobby ve Workspace se
SpawnLocation. Ověřte, že má zaškrtnutou vlastnost Neutral, aby se tu spawnul každý hráč, tady čekal a sem se po vyřazení vracel. - Do ServerStorage vložte
Folders názvemMaps. Objekty ve ServerStorage se hráčům nikdy neposílají, takže je nepoužívané mapy nic nestojí. - Každou mapu postavte jako
ModeluvnitřMaps, s ukotvenými party. Stavte ji daleko od lobby (několik set studů stačí), protože kopie se objeví přesně tam, kde jste ji postavili, a vyřazení hráči by se neměli mít jak vrátit. - Do každé mapy přidejte
Folders názvemSpawnsa v něm jeden ukotvenýPartna každého očekávaného hráče. Nastavte jim Transparency 1 a vypněte CanCollide, aby je nikdo neviděl a nezakopával o ně.
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 kol přičte 1 k IntValue s názvem Wins uvnitř složky leaderstats hráče. Pokud vaše hra leaderstats ještě nemá, přidejte tento krátký skript. Pokud už ho máte, například verzi s ukládáním z návodu k leaderboardu, vynechte ho: dva skripty, které vytvářejí leaderstats, dají každému hráči dvě složky.
local Players = game:GetService("Players")
local function setupLeaderstats(player: Player)
local leaderstats = Instance.new("Folder")
leaderstats.Name = "leaderstats" -- název musí být přesně takový, malými písmeny
local wins = Instance.new("IntValue")
wins.Name = "Wins"
wins.Value = 0
wins.Parent = leaderstats
leaderstats.Parent = player
end
Players.PlayerAdded:Connect(setupLeaderstats)
-- Ve Studiu můžete přijít dřív, než se tento skript spustí, proto nastavíme všechny, kdo už tu jsou
for _, player in Players:GetPlayers() do
setupLeaderstats(player)
end
Tyto Wins se vynulují, když hráč odejde. Chcete-li je uchovat mezi relacemi, vezměte verzi s DataStore z návodu k leaderboardu.
Krok 2: Přidejte skript kol
Vložte Script do ServerScriptService, pojmenujte ho RoundSystem a vložte kód níže. Nastavení nahoře jsou jediné řádky, které budete nejspíš měnit. Každý stav je samostatná funkce a smyčka dole je spouští popořadě, donekonečna.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
-- Nastavení
local MIN_PLAYERS = 2 -- dokud testujete sami, nastavte 1
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: kolo skončí, když zbudou hráči jen v jednom týmu
local mapsFolder = ServerStorage:WaitForChild("Maps")
local random = Random.new()
-- To, co ukazuje obrazovka každého hráče, se ukládá v atributech na této složce.
-- Atributy nastavené serverem se replikují všem klientům, včetně těch, kdo přišli později.
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
-- Kdo je ještě v současném kole a připojení, která každého z nich sledují
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átí postavu a Humanoid, jen pokud je hráč právě teď naživu
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čítá strany, které v kole zbývají (hráče, nebo týmy, pokud 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átí false, pokud hráči během odpočtu odešli.
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, část 1. Zkopírujeme náhodnou mapu (ne tu minulou, pokud je z čeho vybírat).
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
-- Zamícháme, aby hráči nepadali na stejný 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 jaké výšce nad podlahou je root part stojící postavy.
-- Vzorec z referenční příručky Robloxu k Humanoid.HipHeight (u rigů R6 se přičítá 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, část 2. Připravit se, pak teleportovat všechny živé.
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
-- Se zapnutým streamingem požádáme každého klienta, aby načetl mapu dřív, než postava dorazí
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
-- Účastní se jen ti, kdo jsou právě teď naživu. Ostatní čekají na další 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, proto ho zvedneme do výšky stání nad partem
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čí, když vyprší čas nebo zbude 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, které začala jedna strana (test o samotě), skončí jen časem nebo smrtí
if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
break
end
end
end
-- STAV: Results. Vyhrávají všichni, kdo jsou ještě naživu.
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) -- přestaneme je sledovat; zůstanou na mapě až do úklidu
end
setState("Results", message)
task.wait(RESULTS_SECONDS)
return winners
end
-- STAV: Cleanup. Pošleme přeživší zpět do lobby, pak smažeme mapu.
local function cleanup(map: Model, survivors: { Player })
for _, player in survivors do
if player.Parent then -- ještě na serveru
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
-- Smyčka: jeden průchod 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) -- mapy zatím nejsou: brzy to zkusíme znovu
end
end
end
Všechno důležité se děje tady, na serveru: kdo je v kole, časovač, vítěz a Wins. Klienti dostávají jen tři atributy na ReplicatedStorage.RoundInfo (State, Status a TimeLeft) a atribut InRound na každém hráči.
Jak funguje každý stav
Čekání a přestávka
runIntermission nejdřív drží smyčku, dokud #Players:GetPlayers() nedosáhne MIN_PLAYERS. Pak odpočítává po jedné sekundě přes task.wait(1) a při každém tiku kontroluje počet hráčů. Pokud někdo odešel a na serveru je jich méně než minimum, vrátí false a hlavní smyčka začne znovu od Waiting, takže kolo nikdy nezačne s jedním člověkem.
Výběr a načtení mapy
loadMap posbírá všechny Model v ServerStorage.Maps, odebere mapu z minulého kola, pokud je z čeho vybírat, a jednu vybere přes Random:NextInteger. Pak mapu naklonuje do Workspace. Originál zůstane ve ServerStorage nedotčený, takže každé kolo začíná s čerstvou kopií: všechno, co hráči v minulém kole rozbili nebo posunuli, zmizí.
V nových place je zapnutý instance streaming: klient má jen party poblíž své postavy. Před teleportem skript zavolá Player:RequestStreamAroundAsync pro každého hráče, čímž požádá engine, aby klientovi během odpočtu "připravte se" poslal oblast kolem mapy. Bez toho mohou hráči dorazit dřív, než se načte podlaha, a na okamžik zamrznout.
Teleport hráčů přes PivotTo
Po odpočtu skript sestaví seznam účastníků z hráčů, jejichž postava existuje, je ještě ve světě a má Humanoid se zdravím nad 0 a root part. Tato kontrola proběhne po odpočtu, takže kdo během něj zemřel nebo odešel, se do seznamu nedostane.
Každý účastník se přenese přes character:PivotTo(cframe). Referenční příručka Robloxu označuje PivotTo za hlavní způsob, jak hýbat modely ze skriptu, a posune všechny části postavy dohromady. Nastavit HumanoidRootPart.Position není totéž: Roblox upraví spoje tak, že se pohne jen tato jedna část, a zbytek těla může zůstat pozadu. Pivot postavy je její root part, takže cílem je CFrame spawn partu zvednutý o polovinu výšky partu plus výšku, ve které root part stojí nad podlahou. rootHeight ji počítá podle vzorce z referenční příručky Robloxu k Humanoid.HipHeight: polovina výšky root partu plus HipHeight, plus délka nohy u rigů R6. Zmenšené a vlastní avatary tak neuvíznou v partu ani na něj nespadnou shora. CFrame obsahuje otočení, takže hráči se dívají stejným směrem jako spawn part: otočte party tak, aby se všichni dívali do středu mapy.
Pokud je hráčů víc než spawn partů, skript začne znovu od prvního partu a hráči se ocitnou na sobě, proto přidejte spawnů alespoň tolik, kolik je váš maximální počet hráčů.
Pokud také používáte kontrolu rychlosti z návodu ke sprintu, přidejte player:SetAttribute("MovementCheckSkip", true) hned za character:PivotTo(...) ve startRound, aby se teleport nepočítal jako překročení rychlosti.
Časovač kola a podmínky konce
runRound tiká jednou za sekundu. Při každém tiku aktualizuje stav (kolik hráčů zbývá) a zbývající sekundy a pak spočítá živé strany. Kolo skončí jedním ze tří způsobů:
- Vypršel čas. Smyčka
fordojde k 1 a skončí. - Zbyla jedna strana. Strana je hráč, nebo tým, pokud je zapnuté
USE_TEAMS. Kontrola funguje, jen pokud kolo začalo se dvěma nebo více stranami, takže test o samotě neskončí ve stejném okamžiku, kdy začal. - Nezbyl nikdo. Všichni zemřeli nebo odešli a kolo skončí bez vítěze.
Kontrola jednou za sekundu znamená, že kolo může běžet ještě až sekundu po posledním vyřazení, což je na časovači kola skoro nepostřehnutelné.
Rozdání Wins a ukázání výsledku
Pravidlo v tomto skriptu je jednoduché: vyhrávají všichni, kdo jsou naživu na konci kola. To pokryje posledního přeživšího hráče, poslední přeživší tým i režim "vydrž, dokud nevyprší časovač" jedním řádkem logiky. finishRound přičte 1 k Wins každého vítěze, přestane je sledovat a na RESULTS_SECONDS ukáže zprávu jako "Alex wins!". Pokud chcete, aby při vypršení času vítěz nebyl, vynechte awardWin a změňte zprávu, když je sidesLeft větší než 1. V každém případě seznam dál vracejte, protože úklid podle něj vrací přeživší do lobby.
Úklid
Přeživší pořád stojí na mapě, proto je cleanup oživí v lobby přes Player:LoadCharacterAsync(), který nahrazuje starý LoadCharacter, a pak kopii mapy smaže. Každé oživení běží ve vlastním task.spawn uvnitř pcall, protože volání čeká na načtení postavy a může selhat, pokud hráč právě v tu chvíli odchází. Vyřazení hráči nic nepotřebují: už se sami oživili v lobby.
Krok 3: Ukažte časovač a stav každému hráči
Server zveřejňuje tři atributy na ReplicatedStorage.RoundInfo: State (pevné slovo jako InRound, pro skripty), Status (text pro lidi) a TimeLeft (sekundy). Atributy, které serverový skript nastaví na replikovaném objektu, se automaticky dostanou ke každému klientovi a hráč, který přijde uprostřed kola, hned dostane aktuální hodnoty. Proto se pro časovač hodí líp než remote: RemoteEvent poslaný dřív, než někdo přišel, se k němu nikdy nedostane.
- V Exploreru vložte ScreenGui do StarterGui a pojmenujte ho
RoundHud. ResetOnSpawn nechte zapnuté (výchozí). - Vložte LocalScript do
RoundHud, pojmenujte hoRoundHudClienta vložte kód níže. Nápis si vytvoří sám, takže nic dalšího kreslit nemusíte. - Klikněte na Play. Nápis nahoře na obrazovce ukazuje stav a odpočet ve formátu
m:ss.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local roundInfo = ReplicatedStorage:WaitForChild("RoundInfo")
local screenGui = script.Parent :: ScreenGui
-- Nápis. Pokud jste v RoundHud nakreslili vlastní TextLabel, smažte tento blok a použijte:
-- 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 -- dlouhé zprávy se zalomí na druhý řádek
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()
Protože je ResetOnSpawn zapnuté, Roblox dá hráči čerstvou kopii RoundHud při každém spawnu postavy, včetně oživení při úklidu. Skript pak znovu přečte aktuální atributy, takže nápis nikdy nezastará.
Klient jen čte. Nic, co hráč změní na své obrazovce, neovlivní skutečný časovač, protože změny atributů z LocalScriptu zůstanou na tomto jednom klientu. Pro odpočet s desetinami sekundy může server místo toho v atributu uchovávat čas konce z workspace:GetServerTimeNow() a každý klient od něj každý snímek odečte svůj workspace:GetServerTimeNow().
Pokud vaše hra začíná hlavním menu, RoundHud se objeví, když hráč klikne na Play, protože StarterGui se hráči kopíruje až po spawnu jeho postavy. Hráči, kteří jsou ještě v menu, nemají postavu, takže je do kola nikdy neteleportuje.
Hráči, kteří uprostřed kola umírají, odcházejí nebo přicházejí
Tyto případy se snadno přehlédnou, když skript kol píšete poprvé. Pokud některý z nich není ošetřený, obvykle uvidíte chybu v Output nebo kolo, které nikdy neskončí. Tady je, co s každým z nich dělá skript výše.
| Situace | Co se stane | Kde ve skriptu |
|---|---|---|
| Hráč v kole zemře (zabit, resetoval se, spadl) | Odebere se z kola a oživí se v lobby po Players.RespawnTime (výchozí 5 sekund). | humanoid.Died volá eliminate |
| Postava smazána bez smrti | Stejně jako při smrti: hráč je vyřazen. | player.CharacterRemoving volá eliminate |
| Hráč odejde ze serveru | Odebere se, jeho připojení se odpojí a další tik znovu spočítá strany. | Players.PlayerRemoving volá eliminate |
| Hráč přijde uprostřed kola | Spawne se v lobby, vidí živý stav a časovač a dostane se do dalšího kola. | Účastníci se vybírají jen ve startRound |
| Hráč byl na začátku kola mrtvý | Neteleportuje se, čeká v lobby. | getLivingCharacter |
| Všichni odešli nebo zemřeli | Kolo skončí s "Nobody survived" a smyčka začne znovu: Intermission, pokud je na serveru ještě dost hráčů, jinak Waiting. | sidesLeft == 0 v runRound |
eliminate je napsaný tak, aby ho bylo bezpečné volat pro stejného hráče víckrát. Hráč, který zemřel a oživil se, vyvolá Died i CharacterRemoving a ten, kdo odchází, může vyvolat všechny tři události; něco udělá jen první volání.
Jak systém rozšířit: týmy, hlasování o mapě a události kola
Poslední přeživší tým
Nastavte USE_TEAMS = true a pak do služby Teams v Exploreru přidejte objekty Team, každý s vlastním názvem a TeamColor. Ve výchozím stavu Roblox dá každého příchozího hráče do automaticky přiřazovaného týmu s nejmenším počtem členů. Když hráči odcházejí, týmy znovu nevyvažuje, takže při dlouhých relacích mohou být týmy nerovné. SpawnLocation v lobby nechte Neutral, aby se tam spawnovaly všechny týmy. Pak kolo skončí, když živí hráči zbudou jen v jednom týmu, a výsledek vypadá jako "Red wins!".
Pro formát "jeden proti všem" (jeden lovec, ostatní přežívají) vyberte ve startRound jednoho náhodného účastníka a před teleportem mu nastavte Team týmu lovce. U týmu lovce odškrtněte AutoAssignable, aby se tam nikdy nedostali noví hráči, a v cleanup vraťte lovce do týmu přeživších. Pak fungují stejné podmínky konce: lovec vyhraje, pokud byli vyřazeni všichni přeživší, a přeživší vyhrají, pokud vydrželi do konce časovače, za předpokladu, že při vypršení času vynecháte awardWin lovce.
Hlasování hráčů o mapě
Pro hlasování musí klient komunikovat se serverem, a to znamená RemoteEvent. Během přestávky server zveřejní jako atributy dva nebo tři názvy map, každý klient pošle přes RemoteEvent název, na který klikl, a server sčítá hlasy, než spustí loadMap. Server musí každý hlas zkontrolovat: že argument je řetězec, že je to jedna ze současných možností, že stav je Intermission a že se každý hráč počítá jednou (hlasy ukládejte v tabulce s klíčem Player, aby druhý hlas nahradil první, a vyčistěte ji v PlayerRemoving). Návod k RemoteEvent tento vzor kontrol podrobně rozebírá.
Vydání nástroje na začátku kola
Ostatní skripty mohou na kolo reagovat, aniž by sahaly na RoundSystem. Skript kol nastaví každému hráči atribut InRound, když ho teleportuje, a zruší ho, když hráč vypadne. Tento skript ho poslouchá a každému hráči dá kopii Toolu s názvem RoundTool, který leží ve 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, který by nástroj bral, tu není. Když postava zemře, Roblox nahradí Backpack čerstvým, naplněným ze StarterPack, a LoadCharacterAsync při úklidu ho přeživším vyprázdní, takže po kole už nástroj není.
Pokud chcete rozdávat zbraň, postavte meč nebo zbraň na raycastu, držte ji ve ServerStorage místo StarterPack a změňte "RoundTool" v tomto skriptu na její název.
NPC a další objekty jen na dobu kola
Všechno, co má existovat jen během kola, může žít uvnitř modelu mapy: nepřátelé, předměty k sebrání, pohyblivé plošiny. Skripty uvnitř modelu ve ServerStorage neběží; jakmile je kopie ve Workspace, spustí se a map:Destroy() při úklidu je smaže spolu se vším ostatním. Chcete-li přidat nepřátele, kteří pronásledují hráče, postavte jednoho podle návodu k pathfindingu pro NPC a dejte ho do mapy. Pro průlet mapou na začátku každého kola návod k cutscénám ukazuje, jak tento skript může každému hráči spustit cutscénu přes BindableEvent.
Jak z toho udělat modul
Na začátek ModuleScript nepotřebujete. Jeden Script se čte snáz, dokud hru stavíte. Rozdělte ho, když ostatní skripty potřebují funkce kola volat, nebo když chcete nastavení přesunout do jednoho sdíleného ModuleScriptu, který přes require mohou připojit server i vaše UI. Do té doby atribut State na RoundInfo a atribut InRound na každém hráči už fungují jako veřejné rozhraní systému kol: poslouchat je může jakýkoli skript.
Časté chyby a řešení
Otevřete okno Output (přes menu Window ve Studiu nebo kartu Script) před kliknutím na Play. Většina problémů se systémem kol tam vypíše varování nebo chybu s názvem skriptu a číslem řádku.
Visí na "Waiting for players (1/2)"
Testujete sami a MIN_PLAYERS je 2. Pro testy o samotě nastavte 1, nebo testujte v režimu Server & Clients se 2 klienty.
Infinite yield possible on 'ServerStorage:WaitForChild("Maps")'
Složka chybí, má v názvu překlep nebo je v jiné službě. Musí to být Folder s názvem přesně Maps přímo uvnitř ServerStorage. Stejné varování pro RoundInfo v LocalScriptu znamená, že se skript RoundSystem k jejímu vytvoření nikdy nedostal: je vypnutý, spadl s chybou nebo pořád čeká na složku Maps.
Po teleportu hráči propadnou mapou
Party mapy nejsou ukotvené, takže se kopie rozpadne, jakmile je ve Workspace. Vyberte mapu, ukotvěte její party a ověřte, že spawn party stojí nad podlahou, ne v ní.
Vyřazení hráči se oživují v aréně
Uvnitř mapy je SpawnLocation. Nahraďte ho obyčejným Partem ve složce Spawns této mapy.
Kolo neskončí, když všichni zemřou
Ověřte, že vaše poškození Humanoid opravdu zabíjí (zdraví klesne na 0), a ne že hráče posouvá nebo ukotvuje. Pokud jste u Humanoidu vypnuli stav Dead, Died se nikdy nespustí a kolo musí běžet do konce časovače.
Smyčka kol se po jedné chybě úplně zastaví
Smyčka běží v jednom vlákně, takže chyba v kterémkoli stavu ji ukončí. Přečtěte si chybu v Output, opravte řádek a testujte znovu. Častá příčina: skript byl změněn tak, že používá player.Character.Humanoid bez kontroly, že postava existuje.
Udělat s RoCode
Pokud se vám to všechno nechce stavět ručně, RoCode to může udělat ve vašem otevřeném place. Je to AI agent, který pracuje přes plugin pro Roblox Studio, takže skripty a party se objeví ve vašem Exploreru, ne v okně chatu, odkud byste je museli vkládat.
Přidej systém kol: přestávka 20 sekund, která potřebuje 2 hráče, náhodná mapa ze ServerStorage.Maps, teleport všech na spawn party mapy, kola po 2 minutách, kde vyhrává poslední živý hráč, přidej Win do leaderstats a ukaž stav a časovač nahoře na obrazovce.
- Může si nejdřív prohlédnout váš place přes List Children, Search Game a Search Scripts, aby použil vaši složku Maps a skript leaderstats a nepřidával druhou sadu
- Vytvoří Script kol v ServerScriptService a LocalScript časovače přes Create Script a může postavit arénu ze svých hotových staveb přes Place Prefab, pokud mapu zatím nemáte
- Před dokončením ověří kompilaci každého skriptu uvnitř Studia přes Check Script. To chytá syntaktické chyby, ne chyby logiky kola
- Po vašem playtestu Check Output přečte řádky Server a Client z posledního playtestu, aby opravil chybu za běhu
S pluginem 3.9 nebo novějším může RoCode spustit krátký playtest a přečíst chyby a s pluginem 3.9.11 nebo novějším ovládat jednu testovací postavu, ale s více hráči netestuje, proto kola projeďte sami v režimu Server & Clients. Každá dávka změn je bod pro vrácení ve Studiu. Smyčka kol je základem mnoha her a tvorba celé hry v Robloxu s AI, systém po systému často začíná právě takovou smyčkou. Jak se RoCode připojuje ke Studiu.
Časté otázky
Jak v Robloxu udělat systém kol s týmy?
Přidejte objekty Team do služby Teams a ve skriptu kol nastavte USE_TEAMS = true. Roblox rozděluje příchozí hráče do automaticky přiřazovaného týmu s nejmenším počtem členů a kolo skončí, když živí hráči zbudou jen v jednom týmu.
Jak ukázat odpočet všem hráčům?
Nastavujte ze serveru zbývající sekundy jako atribut na objektu v ReplicatedStorage a poslouchejte ho přes GetAttributeChangedSignal v LocalScriptu, který aktualizuje TextLabel, jako v kroku 3. Hráči, kteří přišli později, hned dostanou aktuální hodnotu.
Co použít ve smyčce kol: wait(), nebo task.wait()?
Použijte task.wait(). Roblox označuje globální wait() jako zastaralý a nahrazený task.wait().
Jak teleportovat hráče na každé kolo do jiného place?
To je jiný nástroj. Tento návod přesouvá postavy uvnitř jednoho serveru přes PivotTo. Posílání hráčů do jiného place vaší experience jde přes TeleportService, který je přenese na jiný server. Návod k teleportům staví portály, které to dělají, s opakovanými pokusy, pokud teleport selže.
Proč hráči po teleportu na okamžik zamrznou?
Se zapnutým instance streaming klient ještě nedostal mapu. Volání RequestStreamAroundAsync ve skriptu během odpočtu "připravte se" požádá engine, aby ji poslal předem; delší GET_READY_SECONDS dá pomalým připojením víc času.
Zdroje a další čtení
- Roblox Creator Docs: Add rounds (anglicky). vlastní týmová smyčka kol od Robloxu v příkladu s laser tagem
- Roblox Creator Docs: PVInstance:PivotTo (anglicky). přesun modelů a postav ze skriptu
- Roblox Creator Docs: Player (anglicky). LoadCharacterAsync, CharacterRemoving a RequestStreamAroundAsync
- Roblox Creator Docs: Properties and attributes (anglicky). nastavení atributů a sledování změn
- Roblox Creator Docs: Implement teams (anglicky). přidání týmů a automatické přiřazení
- Roblox Creator Docs: Studio testing modes (anglicky). test s více klienty Server & Clients
Jak byl kód ověřen: každý skript na této stránce prochází přísnou kontrolou typů Luau s definicemi Roblox API (luau-lsp, 20. listopadu 2026). Kontrola typů zachytí chyby v názvech API a špatné typy, ale ne chyby v herní logice, proto vše otestujte ve Studiu před publikováním.