Poradnik · Systemy gry

Jak zrobić system rund w Roblox Studio

Większość gier na rundy w Roblox kręci tę samą pętlę: czeka na graczy, odlicza do zera, wczytuje mapę, teleportuje tam wszystkich, puszcza timer, wybiera zwycięzcę i sprząta. W tym poradniku budujemy tę pętlę jako jeden czytelny skrypt serwerowy, dodajemy timer, który widzi każdy gracz, i omawiamy przypadki, na których psują się skopiowane skrypty: gracze, którzy giną, wychodzą albo wchodzą w środku rundy.

Zaktualizowano 20 listopada 202613 min czytaniaAutor:

W skrócie

Napisz jeden serwerowy Script w ServerScriptService, który w kółko przechodzi przez stały zestaw stanów: przerwa (poczekać na odpowiednią liczbę graczy, potem odliczanie), wczytanie mapy (sklonować losową mapę z ServerStorage do Workspace), teleport (przenieść każdą żywą postać na part spawnu przez PivotTo), runda (tykać timerem, aż skończy się czas albo zostanie jeden gracz albo jedna drużyna) i sprzątanie (dać Wins, odrodzić ocalałych, usunąć mapę).

  • Uruchamiaj pętlę tylko na serwerze. Publikuj status i pozostałe sekundy jako atrybuty na Folder w ReplicatedStorage, a pokazywać je niech LocalScript.
  • Trzymaj tabelę tych, którzy są jeszcze w rundzie. Usuwaj gracza, gdy jego Humanoid ginie, jego postać jest usuwana albo on wychodzi.
  • Teleportuj tylko graczy, których postać żyje w chwili startu rundy. Kto wszedł później, czeka w lobby na następną.
Na tej stronie
  1. Jak to działa
  2. 1. Lobby i mapy
  3. 2. Skrypt rund
  4. Jak działają stany
  5. 3. UI timera
  6. Gracze w środku rundy
  7. Jak rozbudować
  8. Common errors
  9. Z RoCode
  10. Najczęstsze pytania
  11. Źródła i dalsza lektura

Jak działa system rund

IlustracjaGotowe skrypty rund w uruchomionej grze, przyspieszone.

System rund to maszyna stanów. W każdej chwili serwer jest dokładnie w jednym stanie, każdy stan ma jedno zadanie, a jeden warunek przenosi go do następnego. Jeśli tak piszesz, cała logika leży w jednym miejscu i nie pojawia się klasyczny bug, w którym pętla timera i pętla rundy obie próbują zakończyć tę samą rundę.

Stany pętli rund w tym poradniku
StanCo robi serwerKiedy przechodzi dalej
WaitingPokazuje "Waiting for players (1/2)"Na serwerze jest dość graczy
IntermissionOdlicza czas, gdy wszyscy są w lobbyOdliczanie się skończyło (albo powrót do Waiting, jeśli gracze wyszli)
StartingKopiuje losową mapę do Workspace, pokazuje jej nazwę, prosi klientów o jej wczytanieSkończyło się krótkie odliczanie „przygotuj się”
InRoundTeleportuje żywych graczy, tyka timerem, usuwa tych, którzy zginęli albo wyszliSkończył się czas albo został jeden gracz albo jedna drużyna
ResultsDaje Win wszystkim, którzy jeszcze żyją, i pokazuje, kto wygrałMinęło kilka sekund
CleanupOdradza ocalałych w lobby i usuwa mapęOd razu, po czym pętla zaczyna się od nowa

Każdym stanem zarządza serwer. Klienci tylko pokazują to, co mówi im serwer. Odliczanie w LocalScript rozjeżdża się z prawdziwym, jest błędne u tych, którzy weszli później, i może je zmienić exploiter. Jeśli podział na serwer i klienta jest dla ciebie nowy, najpierw przeczytaj Script vs LocalScript vs ModuleScript.

Krok 1: zbuduj lobby, mapy i statystykę Wins

  1. Zbuduj lobby w Workspace z SpawnLocation. Sprawdź, czy ma zaznaczoną właściwość Neutral, żeby każdy gracz spawnował się tutaj, tu czekał i tu wracał po odpadnięciu.
  2. W ServerStorage wstaw Folder o nazwie Maps. Obiekty w ServerStorage nigdy nie są wysyłane graczom, więc nieużywane mapy nic ich nie kosztują.
  3. Zbuduj każdą mapę jako Model w Maps, z zakotwiczonymi partami. Buduj ją daleko od lobby (kilkaset studów wystarczy), bo kopia pojawia się dokładnie tam, gdzie ją zbudowałeś, a gracze, którzy odpadli, nie powinni mieć jak wejść z powrotem.
  4. W każdej mapie dodaj Folder o nazwie Spawns, a w nim po jednym zakotwiczonym Part na każdego spodziewanego gracza. Ustaw im Transparency 1 i wyłącz CanCollide, żeby nikt ich nie widział i się o nie nie potykał.
Explorer po tym poradniku
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

Skrypt rund dodaje 1 do IntValue o nazwie Wins w folderze leaderstats gracza. Jeśli twoja gra nie ma jeszcze leaderstats, dodaj ten krótki skrypt. Jeśli już ma, na przykład wersję z zapisem z poradnika o leaderboardzie, pomiń go: dwa skrypty tworzące leaderstats dają każdemu graczowi dwa foldery.

Script w ServerScriptService o nazwie Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- nazwa musi być dokładnie taka, małymi literami

	local wins = Instance.new("IntValue")
	wins.Name = "Wins"
	wins.Value = 0
	wins.Parent = leaderstats

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- W Studio możesz wejść, zanim uruchomi się ten skrypt, więc ustawiamy wszystkich, którzy już są
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Te Wins resetują się, gdy gracz wychodzi. Żeby zapisywały się między sesjami, weź wersję z DataStore z poradnika o leaderboardzie.

Krok 2: dodaj skrypt rund

Wstaw Script do ServerScriptService, nazwij go RoundSystem i wklej kod poniżej. Ustawienia na górze to jedyne linie, które prawdopodobnie będziesz zmieniać. Każdy stan to osobna funkcja, a pętla na dole uruchamia je po kolei, bez końca.

Script w ServerScriptService o nazwie RoundSystem
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Ustawienia
local MIN_PLAYERS = 2 -- ustaw 1, gdy testujesz sam
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: runda kończy się, gdy gracze zostali tylko w jednej drużynie

local mapsFolder = ServerStorage:WaitForChild("Maps")
local random = Random.new()

-- To, co pokazuje ekran każdego gracza, jest trzymane w atrybutach na tym folderze.
-- Atrybuty ustawione przez serwer replikują się do wszystkich klientów, łącznie z tymi, którzy weszli później.
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 jest jeszcze w bieżącej rundzie i połączenia, które pilnują każdego 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)

-- Zwraca postać i Humanoid tylko wtedy, gdy gracz żyje w tej chwili
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

-- Liczy strony, które zostały w rundzie (graczy albo drużyny, jeśli włączone jest 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

-- STAN: Waiting i Intermission. Zwraca false, jeśli gracze wyszli w trakcie odliczania.
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

-- STAN: Starting, część 1. Kopiujemy losową mapę (nie poprzednią, jeśli jest wybór).
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
	-- Tasujemy, żeby gracze nie trafiali na ten sam spawn w każdej rundzie
	for i = #points, 2, -1 do
		local j = random:NextInteger(1, i)
		points[i], points[j] = points[j], points[i]
	end
	return points
end

-- Na jakiej wysokości nad podłogą jest root part stojącej postaci.
-- Wzór z dokumentacji Roblox o Humanoid.HipHeight (w rigach R6 dochodzi wysokość nogi).
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

-- STAN: Starting, część 2. Przygotować się, potem teleportować wszystkich żywych.
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

	-- Przy włączonym streamingu prosimy każdego klienta, żeby wczytał mapę przed przybyciem postaci
	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

	-- Biorą udział tylko ci, którzy żyją w tej chwili. Reszta czeka na następną rundę.
	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 postaci to jej root part, więc podnosimy go na wysokość stania 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

-- STAN: InRound. Kończy się, gdy skończył się czas albo została jedna strona.
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()
		-- Runda zaczęta przez jedną stronę (test w pojedynkę) kończy się tylko po czasie albo przez śmierć
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- STAN: Results. Wygrywają wszyscy, którzy jeszcze żyją.
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) -- przestajemy ich pilnować; zostają na mapie do sprzątania
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- STAN: Cleanup. Odsyłamy ocalałych do lobby, potem usuwamy mapę.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- jeszcze na serwerze
			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

-- Pętla: jedno przejście to jedna runda
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) -- na razie nie ma map: zaraz spróbujemy znowu
		end
	end
end

Wszystko, co ważne, dzieje się tutaj, na serwerze: kto jest w rundzie, timer, zwycięzca i Wins. Klienci dostają tylko trzy atrybuty na ReplicatedStorage.RoundInfo (State, Status i TimeLeft) i atrybut InRound na każdym graczu.

Jak działa każdy stan

Czekanie i przerwa

runIntermission najpierw zatrzymuje pętlę, dopóki #Players:GetPlayers() nie dojdzie do MIN_PLAYERS. Potem odlicza po jednej sekundzie przez task.wait(1) i przy każdym tyknięciu sprawdza liczbę graczy. Jeśli ktoś wyszedł i na serwerze jest mniej niż minimum, zwraca false, a główna pętla zaczyna od nowa od Waiting, więc runda nigdy nie zacznie się z jedną osobą.

Wybór i wczytanie mapy

loadMap zbiera wszystkie Model w ServerStorage.Maps, odrzuca mapę z poprzedniej rundy, jeśli jest z czego wybierać, i bierze jedną przez Random:NextInteger. Potem klonuje mapę do Workspace. Oryginał zostaje nietknięty w ServerStorage, więc każda runda zaczyna się od świeżej kopii: wszystko, co gracze zepsuli albo przesunęli w poprzedniej rundzie, znika.

W nowych grach włączony jest streaming instancji: klient ma tylko party w pobliżu swojej postaci. Przed teleportem skrypt wywołuje Player:RequestStreamAroundAsync dla każdego gracza, co prosi silnik o wysłanie klientowi obszaru wokół mapy w trakcie odliczania „przygotuj się”. Bez tego gracze mogą dotrzeć, zanim wczyta się podłoga, i na chwilę zamarznąć.

Teleport graczy przez PivotTo

Po odliczaniu skrypt zbiera listę uczestników z graczy, których postać istnieje, jest jeszcze w świecie i ma Humanoid ze zdrowiem większym niż 0 i root part. To sprawdzenie idzie po odliczaniu, więc ten, kto zginął albo wyszedł w jego trakcie, nie trafia na listę.

Każdego uczestnika przenosi się przez character:PivotTo(cframe). Dokumentacja Roblox nazywa PivotTo głównym sposobem przesuwania modeli ze skryptu i przesuwa on wszystkie części postaci razem. Ustawienie HumanoidRootPart.Position to nie to samo: Roblox dostosowuje połączenia tak, że przesuwa się tylko ta jedna część, a reszta ciała może zostać w tyle. Pivot postaci to jej root part, więc celem jest CFrame partu spawnu podniesiony o połowę wysokości partu plus wysokość, na której root part stoi nad podłogą. rootHeight liczy ją według wzoru z dokumentacji Roblox o Humanoid.HipHeight: połowa wysokości root part plus HipHeight, plus długość nogi w rigach R6. Dzięki temu przeskalowane i własne awatary nie utykają w parcie i nie spadają na niego z góry. CFrame zawiera obrót, więc gracze patrzą tam, gdzie patrzy part spawnu: obróć party tak, żeby wszyscy patrzyli na środek mapy.

Jeśli graczy jest więcej niż partów spawnu, skrypt zaczyna znowu od pierwszego partu i gracze lądują jeden na drugim, więc dodaj nie mniej spawnów, niż wynosi twoje maksimum graczy.

Jeśli używasz też sprawdzania prędkości z poradnika o sprincie, dodaj player:SetAttribute("MovementCheckSkip", true) zaraz po character:PivotTo(...) w startRound, żeby teleport nie został uznany za przekroczenie prędkości.

Timer rundy i warunki końca

runRound tyka raz na sekundę. Przy każdym tyknięciu aktualizuje status (ilu graczy zostało) i pozostałe sekundy, a potem liczy żywe strony. Runda kończy się na jeden z trzech sposobów:

  • Skończył się czas. Pętla for dochodzi do 1 i się kończy.
  • Została jedna strona. Strona to gracz albo drużyna, jeśli włączone jest USE_TEAMS. Sprawdzenie działa tylko wtedy, gdy runda zaczęła się od dwóch lub więcej stron, więc test w pojedynkę nie kończy się w tej samej chwili, w której się zaczął.
  • Nikt nie został. Wszyscy zginęli albo wyszli i runda kończy się bez zwycięzcy.

Sprawdzanie raz na sekundę oznacza, że runda może trwać jeszcze do sekundy po ostatnim odpadnięciu, a przy timerze rundy jest to prawie niezauważalne.

Dawanie Wins i pokazywanie wyniku

Zasada w tym skrypcie jest prosta: wygrywają wszyscy, którzy żyją w chwili końca rundy. To obejmuje i ostatniego ocalałego gracza, i ostatnią ocalałą drużynę, i tryb „przetrwaj, aż skończy się timer” jedną linią logiki. finishRound dodaje 1 do Wins każdego zwycięzcy, przestaje ich pilnować i pokazuje komunikat w rodzaju "Alex wins!" przez RESULTS_SECONDS. Jeśli chcesz, żeby po upływie czasu nie było zwycięzcy, pomiń awardWin i zmień komunikat, gdy sidesLeft jest większe niż 1. W każdym razie dalej zwracaj listę, bo sprzątanie według niej odsyła ocalałych do lobby.

Sprzątanie

Ocalali wciąż stoją na mapie, więc cleanup odradza ich w lobby przez Player:LoadCharacterAsync(), który zastępuje stary LoadCharacter, a potem usuwa kopię mapy. Każde odrodzenie idzie we własnym task.spawn wewnątrz pcall, bo wywołanie czeka na wczytanie postaci i może się wywalić, jeśli gracz akurat w tej chwili wychodzi. Gracze, którzy odpadli, niczego nie potrzebują: sami już odrodzili się w lobby.

Krok 3: pokaż timer i status każdemu graczowi

Serwer publikuje trzy atrybuty na ReplicatedStorage.RoundInfo: State (stałe słowo w rodzaju InRound, dla skryptów), Status (tekst dla ludzi) i TimeLeft (sekundy). Atrybuty, które serwerowy skrypt ustawia na replikowanym obiekcie, automatycznie docierają do każdego klienta, a gracz, który wszedł w środku rundy, od razu dostaje bieżące wartości. Dlatego do timera nadaje się to lepiej niż remote: RemoteEvent wysłany, zanim ktoś wszedł, nigdy do niego nie dotrze.

  1. W Explorerze wstaw ScreenGui do StarterGui i nazwij go RoundHud. Zostaw ResetOnSpawn włączone (domyślnie).
  2. Wstaw LocalScript do RoundHud, nazwij go RoundHudClient i wklej kod poniżej. Sam tworzy napis, więc niczego więcej nie trzeba rysować.
  3. Kliknij Play. Napis na górze ekranu pokazuje status i odliczanie w formacie m:ss.
LocalScript w ScreenGui RoundHud w StarterGui o nazwie RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local roundInfo = ReplicatedStorage:WaitForChild("RoundInfo")
local screenGui = script.Parent :: ScreenGui

-- Napis. Jeśli narysowałeś własny TextLabel w RoundHud, usuń ten blok i użyj:
-- 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 -- długie komunikaty przechodzą do drugiej linii
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()

Skoro ResetOnSpawn jest włączone, Roblox daje graczowi świeżą kopię RoundHud przy każdym spawnie postaci, łącznie z odrodzeniem przy sprzątaniu. Skrypt wtedy od nowa czyta bieżące atrybuty, więc napis nigdy się nie dezaktualizuje.

Klient tylko czyta. Nic, co gracz zmieni na swoim ekranie, nie wpływa na prawdziwy timer, bo zmiany atrybutów z LocalScript zostają na tym jednym kliencie. Do odliczania z dziesiątymi częściami sekundy serwer może zamiast tego trzymać w atrybucie czas zakończenia z workspace:GetServerTimeNow(), a każdy klient co klatkę odejmuje od niego swój workspace:GetServerTimeNow().

Jeśli twoja gra otwiera się menu głównym, RoundHud pojawia się, gdy gracz kliknie Play, bo StarterGui kopiuje się do gracza dopiero po spawnie jego postaci. Gracze, którzy są jeszcze w menu, nie mają postaci, więc nigdy nie zostaną przeteleportowani na rundę.

Gracze, którzy giną, wychodzą albo wchodzą w środku rundy

Te przypadki łatwo przeoczyć, gdy pisze się skrypt rund pierwszy raz. Jeśli któryś nie jest obsłużony, zwykle widzisz błąd w Output albo rundę, która nigdy się nie kończy. Oto co skrypt wyżej robi z każdym z nich.

Przypadki brzegowe i jak radzi sobie z nimi skrypt rund
SytuacjaCo się dziejeGdzie w skrypcie
Gracz ginie w rundzie (zabity, zrobił reset, spadł)Zostaje usunięty z rundy i odradza się w lobby po Players.RespawnTime (domyślnie 5 sekund).humanoid.Died wywołuje eliminate
Postać usunięta bez śmierciJak przy śmierci: gracz odpadł.player.CharacterRemoving wywołuje eliminate
Gracz wychodzi z serweraZostaje usunięty, jego połączenia się rozłączają, a następne tyknięcie liczy strony od nowa.Players.PlayerRemoving wywołuje eliminate
Gracz wchodzi w środku rundySpawnuje się w lobby, widzi bieżący status i timer i trafia do następnej rundy.Uczestników wybiera się tylko w startRound
Gracz był martwy w chwili startu rundyNie jest teleportowany, czeka w lobby.getLivingCharacter
Wszyscy wyszli albo zginęliRunda kończy się z "Nobody survived", a pętla zaczyna się od nowa: Intermission, jeśli na serwerze jest jeszcze dość graczy, inaczej Waiting.sidesLeft == 0 w runRound

eliminate jest napisany tak, że można go bezpiecznie wywołać kilka razy dla jednego gracza. Gracz, który zginął i się odrodził, wywołuje i Died, i CharacterRemoving, a ten, kto wychodzi, może wywołać wszystkie trzy eventy; coś robi tylko pierwsze wywołanie.

Jak rozbudować: drużyny, głosowanie na mapę i eventy rundy

Ostatnia ocalała drużyna

Ustaw USE_TEAMS = true, potem dodaj obiekty Team do serwisu Teams w Explorerze, każdemu własną nazwę i TeamColor. Domyślnie Roblox wkłada każdego wchodzącego gracza do automatycznie przydzielanej drużyny z najmniejszą liczbą członków. Gdy gracze wychodzą, nie wyrównuje drużyn, więc w długich sesjach drużyny mogą stać się nierówne. Zostaw SpawnLocation w lobby jako Neutral, żeby wszystkie drużyny spawnowały się tam. Wtedy runda kończy się, gdy żywi gracze zostali tylko w jednej drużynie, a wynik wygląda jak "Red wins!".

Dla formatu „jeden przeciw wszystkim” (jeden łowca, reszta przetrwa) wybierz w startRound jednego losowego uczestnika i przed teleportem ustaw mu Team drużyny łowcy. Odznacz AutoAssignable w drużynie łowcy, żeby nigdy nie trafiali tam nowi gracze, a w cleanup przywróć łowcę do drużyny ocalałych. Wtedy działają te same warunki końca: łowca wygrywa, jeśli odpadli wszyscy ocalali, a ocalali wygrywają, jeśli przetrwali do końca timera, pod warunkiem że pomijasz awardWin łowcy, gdy skończył się czas.

Głosowanie graczy na mapę

Do głosowania klient musi komunikować się z serwerem, czyli potrzebny jest RemoteEvent. Podczas przerwy serwer publikuje atrybutami dwie albo trzy nazwy map, każdy klient wysyła przez RemoteEvent nazwę, którą kliknął, a serwer liczy głosy przed uruchomieniem loadMap. Serwer musi sprawdzać każdy głos: czy argument to string, czy to jedna z bieżących opcji, czy stan to Intermission i czy każdy gracz jest liczony raz (trzymaj głosy w tabeli z kluczem Player, żeby drugi głos zastępował pierwszy, i czyść ją w PlayerRemoving). Poradnik o RemoteEvent szczegółowo omawia ten wzorzec sprawdzeń.

Dawanie narzędzia na początku rundy

Inne skrypty mogą reagować na rundę, nie dotykając RoundSystem. Skrypt rund ustawia każdemu graczowi atrybut InRound, gdy go teleportuje, i zdejmuje go, gdy gracz odpada. Ten skrypt go nasłuchuje i daje każdemu graczowi kopię Toola o nazwie RoundTool, który leży w ServerStorage.

Script w ServerScriptService o nazwie 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

Nie ma kodu, który zabiera narzędzie. Gdy postać ginie, Roblox zastępuje Backpack świeżym, wypełnionym ze StarterPack, a LoadCharacterAsync przy sprzątaniu czyści go u ocalałych, więc po rundzie narzędzia już nie ma.

Jeśli potrzebujesz broni do rozdania, zbuduj miecz albo broń na raycastach, trzymaj ją w ServerStorage zamiast StarterPack i zmień "RoundTool" w tym skrypcie na jej nazwę.

NPC i inne obiekty tylko na czas rundy

Wszystko, co ma istnieć tylko w trakcie rundy, może żyć w modelu mapy: wrogowie, przedmioty do podniesienia, ruchome platformy. Skrypty w modelu w ServerStorage nie działają; gdy tylko kopia trafi do Workspace, uruchamiają się, a map:Destroy() przy sprzątaniu usuwa je razem z całą resztą. Żeby dodać wrogów, którzy gonią graczy, zbuduj jednego według poradnika o pathfindingu NPC i włóż go do mapy. Dla przelotu nad mapą na początku każdej rundy poradnik o cutscenkach pokazuje, jak ten skrypt może uruchamiać cutscenkę każdemu graczowi przez BindableEvent.

Jak zrobić z tego moduł

Na początek ModuleScript nie jest potrzebny. Jeden Script łatwiej czytać, gdy budujesz grę. Dziel go, gdy inne skrypty muszą wywoływać funkcje rundy albo gdy chcesz przenieść ustawienia do jednego wspólnego ModuleScript, który mogą podłączać przez require i serwer, i twoje UI. Do tego czasu atrybut State na RoundInfo i atrybut InRound na każdym graczu już działają jako publiczny interfejs systemu rund: każdy skrypt może ich nasłuchiwać.

Częste błędy i rozwiązania

Otwórz okno Output (przez menu Window w Studio albo kartę Script) przed kliknięciem Play. Większość problemów z systemem rund wypisuje tam ostrzeżenie albo błąd z nazwą skryptu i numerem linii.

Wisi na "Waiting for players (1/2)"

Testujesz sam, a MIN_PLAYERS wynosi 2. Ustaw 1 do testów w pojedynkę albo testuj w trybie Server & Clients z 2 klientami.

Infinite yield possible on 'ServerStorage:WaitForChild("Maps")'

Folderu nie ma, ma literówkę w nazwie albo jest w złym serwisie. Musi to być Folder o nazwie dokładnie Maps bezpośrednio w ServerStorage. Takie samo ostrzeżenie dla RoundInfo w LocalScript oznacza, że skrypt RoundSystem nigdy nie doszedł do jego utworzenia: jest wyłączony, wywalił się z błędem albo wciąż czeka na folder Maps.

Po teleporcie gracze spadają przez mapę

Party mapy nie są zakotwiczone, więc kopia rozpada się, gdy tylko trafi do Workspace. Zaznacz mapę, zakotwicz jej party i sprawdź, czy party spawnu stoją nad podłogą, a nie w niej.

Gracze, którzy odpadli, odradzają się na arenie

W mapie jest SpawnLocation. Zastąp go zwykłym Part w folderze Spawns tej mapy.

Runda się nie kończy, gdy wszyscy zginęli

Sprawdź, czy twoje obrażenia naprawdę zabijają Humanoid (zdrowie dochodzi do 0), a nie przesuwają albo kotwiczą graczy. Jeśli wyłączyłeś stan Dead w Humanoid, Died nigdy się nie odpala i runda musi trwać do końca timera.

Pętla rund zatrzymuje się na dobre po jednym błędzie

Pętla działa w jednym wątku, więc błąd w dowolnym stanie ją kończy. Przeczytaj błąd w Output, popraw linię i przetestuj ponownie. Częsta przyczyna: skrypt zmieniono tak, że używa player.Character.Humanoid bez sprawdzenia, czy postać istnieje.

Zrób to z RoCode

Jeśli nie chce ci się składać tego wszystkiego ręcznie, RoCode może to zrobić w grze, którą masz otwartą. To agent AI, który działa przez plugin do Roblox Studio, więc skrypty i party pojawiają się w twoim Explorerze, a nie w oknie czatu, skąd trzeba by je wklejać.

Ty piszesz

Dodaj system rund: przerwa 20 sekund, która potrzebuje 2 graczy, losowa mapa z ServerStorage.Maps, teleport wszystkich na party spawnu mapy, rundy po 2 minuty, w których wygrywa ostatni żywy gracz, dodaj Win w leaderstats i pokaż status i timer na górze ekranu.

RoCode robi
  • Może najpierw przejrzeć twoją grę przez List Children, Search Game i Search Scripts, żeby wziąć twój folder Maps i skrypt leaderstats, zamiast dodawać drugi zestaw
  • Tworzy Script rund w ServerScriptService i LocalScript timera przez Create Script i może postawić arenę ze swoich gotowych budowli przez Place Prefab, jeśli nie masz jeszcze mapy
  • Sprawdza kompilację każdego skryptu wewnątrz Studio przez Check Script przed zakończeniem. To wyłapuje błędy składni, a nie błędy logiki rundy
  • Po twoim playteście Check Output czyta linie Server i Client z ostatniego playtestu, żeby naprawić błąd w trakcie działania

Z pluginem 3.9 lub nowszym RoCode może uruchomić krótki playtest i przeczytać błędy, a z pluginem 3.9.11 lub nowszym może sterować jedną testową postacią, ale z kilkoma graczami nie testuje, więc rundy przepuszczaj sam w trybie Server & Clients. Każda paczka zmian to punkt cofania w Studio. Pętla rund leży u podstaw wielu gier, a tworzenie całej gry Roblox z AI, system po systemie często zaczyna się od takiej pętli. Jak RoCode łączy się ze Studio.

Najczęstsze pytania

Jak zrobić system rund z drużynami w Roblox?

Dodaj obiekty Team do serwisu Teams i ustaw USE_TEAMS = true w skrypcie rund. Roblox przydziela wchodzących graczy do automatycznie przydzielanej drużyny z najmniejszą liczbą członków, a runda kończy się, gdy żywi gracze zostali tylko w jednej drużynie.

Jak pokazać odliczanie wszystkim graczom?

Ustawiaj z serwera pozostałe sekundy atrybutem na obiekcie w ReplicatedStorage i nasłuchuj go przez GetAttributeChangedSignal w LocalScript, który aktualizuje TextLabel, jak w kroku 3. Gracze, którzy weszli później, od razu dostają bieżącą wartość.

Czego używać w pętli rund: wait() czy task.wait()?

Używaj task.wait(). Roblox oznacza globalne wait() jako przestarzałe i zastąpione przez task.wait().

Jak teleportować graczy do innego place na każdą rundę?

To inne narzędzie. Ten poradnik przenosi postacie w obrębie jednego serwera przez PivotTo. Wysyłanie graczy do innego place twojego experience idzie przez TeleportService, który przenosi ich na inny serwer. Poradnik o teleportach buduje portale, które to robią, z ponownymi próbami, jeśli teleport się nie udał.

Dlaczego gracze na chwilę zamierają po teleporcie?

Przy włączonym streamingu instancji klient nie dostał jeszcze mapy. Wywołanie RequestStreamAroundAsync w skrypcie w trakcie odliczania „przygotuj się” prosi silnik o wysłanie jej z wyprzedzeniem; dłuższe GET_READY_SECONDS daje wolnym łączom więcej czasu.

Źródła i dalsza lektura

Jak sprawdziliśmy kod: każdy skrypt na tej stronie przechodzi ścisłe sprawdzanie typów Luau z definicjami API Robloxa (luau-lsp, 20 listopada 2026). Sprawdzanie typów wyłapuje źle wpisane API i błędne typy, ale nie logikę gry, więc przetestuj go w Studio przed publikacją.

Wypróbuj RoCode we własnej grze.

Darmowe kredyty codziennie, bez karty. Zainstaluj plugin, opisz funkcję i sprawdź, co pojawi się w Studio.