Tutoriál · Herní systémy

Jak udělat systém kol v Roblox Studiu

Většina her na kola v Robloxu točí stejnou smyčku: čeká na hráče, odpočítá do nuly, načte mapu, všechny tam teleportuje, nechá běžet časovač, vybere vítěze a uklidí. V tomto návodu tuto smyčku postavíme jako jeden srozumitelný serverový skript, přidáme časovač, který vidí každý hráč, a rozebereme případy, na kterých se zkopírované skripty rozbíjejí: hráče, kteří uprostřed kola umírají, odcházejí nebo přicházejí.

Aktualizováno 20. listopadu 202613 min čteníAutor:

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
  1. Jak to funguje
  2. 1. Lobby a mapy
  3. 2. Skript kol
  4. Jak fungují stavy
  5. 3. UI časovače
  6. Hráči uprostřed kola
  7. Jak rozšířit
  8. Common errors
  9. S RoCode
  10. Časté otázky
  11. Zdroje a další čtení

Jak systém kol funguje

IlustraceHotové skripty kol ve spuštěné hře, zrychleně.

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.

Stavy smyčky kol v tomto návodu
StavCo server děláKdy přejde dál
WaitingUkazuje "Waiting for players (1/2)"Na serveru je dost hráčů
IntermissionOdpočítává čas, zatímco jsou všichni v lobbyOdpočet skončil (nebo návrat do Waiting, pokud hráči odešli)
StartingZkopíruje náhodnou mapu do Workspace, ukáže její název, požádá klienty, aby ji načetliSkončil krátký odpočet "připravte se"
InRoundTeleportuje živé hráče, nechá tikat časovač, odebírá ty, kdo zemřeli nebo odešliVypršel čas, nebo zbyl jeden hráč či jeden tým
ResultsDá Win všem, kdo jsou ještě naživu, a ukáže, kdo vyhrálUplynulo několik sekund
CleanupOživí přeživší v lobby a smaže mapuHned, 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

  1. 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.
  2. Do ServerStorage vložte Folder s názvem Maps. Objekty ve ServerStorage se hráčům nikdy neposílají, takže je nepoužívané mapy nic nestojí.
  3. Každou mapu postavte jako Model uvnitř 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.
  4. Do každé mapy přidejte Folder s názvem Spawns a v něm jeden ukotvený Part na 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ě.
Explorer po tomto návodu
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.

Script v ServerScriptService s názvem Leaderstats
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.

Script v ServerScriptService s názvem RoundSystem
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 for dojde 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.

  1. V Exploreru vložte ScreenGui do StarterGui a pojmenujte ho RoundHud. ResetOnSpawn nechte zapnuté (výchozí).
  2. Vložte LocalScript do RoundHud, pojmenujte ho RoundHudClient a vložte kód níže. Nápis si vytvoří sám, takže nic dalšího kreslit nemusíte.
  3. Klikněte na Play. Nápis nahoře na obrazovce ukazuje stav a odpočet ve formátu m:ss.
LocalScript v ScreenGui RoundHud ve StarterGui s názvem RoundHudClient
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.

Okrajové případy a jak je skript kol zvládá
SituaceCo se staneKde 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 smrtiStejně jako při smrti: hráč je vyřazen.player.CharacterRemoving volá eliminate
Hráč odejde ze serveruOdebere se, jeho připojení se odpojí a další tik znovu spočítá strany.Players.PlayerRemoving volá eliminate
Hráč přijde uprostřed kolaSpawne 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řeliKolo 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.

Script v ServerScriptService s názvem GiveRoundTool
local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")

local toolTemplate = ServerStorage:WaitForChild("RoundTool") :: Tool

local function watchPlayer(player: Player)
	player:GetAttributeChangedSignal("InRound"):Connect(function()
		if player:GetAttribute("InRound") ~= true then
			return
		end
		local backpack = player:FindFirstChildOfClass("Backpack")
		if backpack then
			toolTemplate:Clone().Parent = backpack
		end
	end)
end

Players.PlayerAdded:Connect(watchPlayer)
for _, player in Players:GetPlayers() do
	watchPlayer(player)
end

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.

Napíšete

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.

RoCode udělá
  • 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í

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.

Vyzkoušejte RoCode ve své hře.

Kredity zdarma každý den, bez karty. Nainstalujte plugin, popište funkci a podívejte se, co se objeví ve Studiu.