Návod · Herné systémy

Ako urobiť systém kôl v Roblox Studiu

Väčšina hier s kolami v Robloxe točí ten istý cyklus: čaká na hráčov, odpočíta do nuly, načíta mapu, teleportuje tam všetkých, pustí časovač, vyberie víťaza a upratuje. V tomto návode poskladáme tento cyklus ako jeden prehľadný serverový skript, pridáme časovač, ktorý vidí každý hráč, a rozoberieme prípady, na ktorých sa skopírované skripty lámu: hráči, ktorí zomrú, odídu alebo prídu uprostred kola.

Aktualizované 20. novembra 202613 min čítaniaAutor:

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
  1. Ako to funguje
  2. 1. Lobby a mapy
  3. 2. Skript kôl
  4. Ako fungujú stavy
  5. 3. UI časovača
  6. Hráči uprostred kola
  7. Ako rozšíriť
  8. Common errors
  9. S RoCode
  10. Časté otázky
  11. Zdroje a ďalšie čítanie

Ako funguje systém kôl

IlustráciaHotové skripty kôl v spustenej hre, zrýchlené.

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.

Stavy cyklu kôl v tomto návode
StavČo robí serverKedy prejde ďalej
WaitingZobrazuje "Waiting for players (1/2)"Na serveri je dosť hráčov
IntermissionOdpočítava čas, kým sú všetci v lobbyOdpočítavanie skončilo (alebo návrat do Waiting, ak hráči odišli)
StartingSkopíruje náhodnú mapu do Workspace, zobrazí jej názov, požiada klientov, aby ju načítaliSkončilo krátke odpočítavanie "pripravte sa"
InRoundTeleportuje živých hráčov, tiká časovač, odstraňuje tých, ktorí zomreli alebo odišliVypršal čas alebo zostal jeden hráč či jeden tím
ResultsDá Win všetkým, ktorí sú ešte živí, a ukáže, kto vyhralUplynulo niekoľko sekúnd
CleanupOživí preživších v lobby a vymaže mapuHneď, 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

  1. 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í.
  2. Do ServerStorage vložte Folder s názvom Maps. Objekty v ServerStorage sa hráčom nikdy neposielajú, takže nepoužívané mapy ich nič nestoja.
  3. Postavte každú mapu ako Model vnútri Maps, 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.
  4. Do každej mapy pridajte Folder s názvom Spawns a doň jeden ukotvený Part na 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.
Explorer po tomto návode
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.

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

Script v ServerScriptService s názvom RoundSystem
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 for dô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.

  1. V Exploreri vložte ScreenGui do StarterGui a pomenujte ho RoundHud. Nechajte ResetOnSpawn zapnuté (predvolene).
  2. Vložte LocalScript do RoundHud, pomenujte ho RoundHudClient a vložte doň kód nižšie. Nápis si vytvorí sám, takže nič iné kresliť netreba.
  3. Stlačte Play. Nápis hore na obrazovke ukazuje stav a odpočítavanie vo formáte m:ss.
LocalScript v ScreenGui RoundHud v StarterGui s názvom RoundHudClient
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.

Hraničné prípady a ako ich skript kôl rieši
SituáciaČo sa staneKde 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 smrtiAko pri smrti: hráč vypadol.player.CharacterRemoving zavolá eliminate
Hráč odíde zo serveraOdstráni sa, jeho pripojenia sa odpoja a ďalší tik znova spočíta strany.Players.PlayerRemoving zavolá eliminate
Hráč príde uprostred kolaSpawne 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ŕtvyNeteleportuje sa, čaká v lobby.getLivingCharacter
Všetci odišli alebo zomreliKolo 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.

Script v ServerScriptService s názvom 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, 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ť.

Napíšete

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.

RoCode urobí
  • 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

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.

Vyskúšajte RoCode vo svojej hre.

Kredity zadarmo každý deň, bez karty. Nainštalujte plugin, opíšte funkciu a pozrite sa, čo sa objaví v Studiu.