Útmutató · Játékrendszerek

Hogyan készíts körrendszert a Roblox Studióban

A legtöbb körökre épülő Roblox játék ugyanazt a ciklust pörgeti: játékosokra vár, visszaszámol nulláig, betölt egy pályát, mindenkit odateleportál, futtatja az időzítőt, kiválasztja a győztest, és rendet rak. Ebben az útmutatóban ezt a ciklust egyetlen érthető szerverscriptként rakjuk össze, hozzáadunk egy időzítőt, amelyet minden játékos lát, és végigvesszük azokat az eseteket, amelyeken a bemásolt scriptek elromlanak: a kör közepén meghaló, kilépő vagy belépő játékosokat.

Frissítve 2026. november 20.14 perc olvasásSzerző:

Röviden

Írj egyetlen szerveroldali Scriptet a ServerScriptService-be, amely körbe-körbe végigmegy egy rögzített állapotsoron: szünet (megvárja a szükséges számú játékost, aztán visszaszámol), pályabetöltés (egy véletlen pályát klónoz a ServerStorage-ból a Workspace-be), teleport (minden élő karaktert egy spawn partra visz a PivotTo segítségével), kör (ketyeg az időzítő, amíg le nem jár az idő, vagy csak egy játékos vagy egy csapat marad) és takarítás (kiosztja a Winst, újraéleszti a túlélőket, törli a pályát).

  • A ciklust csak a szerveren futtasd. Az állapotot és a hátralévő másodperceket egy ReplicatedStorage-beli Folder attribútumaiként tedd közzé, a megjelenítést pedig bízd egy LocalScriptre.
  • Vezess egy táblát azokról, akik még a körben vannak. Vedd ki a játékost, amikor a Humanoidja meghal, a karaktere törlődik, vagy kilép.
  • Csak azokat a játékosokat teleportáld, akiknek a karaktere a kör indulásakor él. Aki később lépett be, a lobbiban várja a következőt.
Ezen az oldalon
  1. Hogyan működik
  2. 1. Lobbi és pályák
  3. 2. Körscript
  4. Hogyan működnek az állapotok
  5. 3. Időzítő UI
  6. Játékosok a kör közepén
  7. Továbbfejlesztés
  8. Common errors
  9. RoCode-dal
  10. Gyakori kérdések
  11. Források és további olvasnivaló

Hogyan működik a körrendszer

IllusztrációA kész körscriptek a futó játékban, gyorsítva.

A körrendszer egy állapotgép. A szerver minden pillanatban pontosan egy állapotban van, minden állapotnak egy feladata van, és egy feltétel viszi át a következőbe. Ha így írod, az egész logika egy helyen van, és nem jön elő az a klasszikus hiba, amikor az időzítő ciklusa és a kör ciklusa egyszerre próbálja befejezni ugyanazt a kört.

A körciklus állapotai ebben az útmutatóban
ÁllapotMit csinál a szerverMikor lép tovább
WaitingEzt mutatja: "Waiting for players (1/2)"Elég játékos van a szerveren
IntermissionVisszaszámol, amíg mindenki a lobbiban vanVéget ért a visszaszámlálás (vagy vissza Waitingbe, ha játékosok kiléptek)
StartingEgy véletlen pályát másol a Workspace-be, kiírja a nevét, és megkéri a klienseket, hogy töltsék beVéget ért a rövid „készülj” visszaszámlálás
InRoundTeleportálja az élő játékosokat, ketyegteti az időzítőt, kiveszi azokat, akik meghaltak vagy kiléptekLejárt az idő, vagy egy játékos vagy egy csapat maradt
ResultsWint ad mindenkinek, aki még él, és kiírja, ki nyertEltelt néhány másodperc
CleanupÚjraéleszti a túlélőket a lobbiban, és törli a pályátAzonnal, utána a ciklus elölről kezdődik

Minden állapot a szerveré. A kliensek csak azt jelenítik meg, amit a szerver mond nekik. Egy LocalScriptben futó visszaszámlálás eltér a valóditól, a később belépőknél hibás, és egy exploiter megváltoztathatja. Ha a szerver és kliens szétválasztása új neked, előbb olvasd el a Script vs LocalScript vs ModuleScript útmutatót.

1. lépés: építsd meg a lobbit, a pályákat és a Wins statisztikát

  1. Építs egy lobbit a Workspace-ben egy SpawnLocation-nel. Ellenőrizd, hogy be van-e jelölve a Neutral tulajdonsága, hogy minden játékos itt jelenjen meg, itt várjon, és kiesés után ide térjen vissza.
  2. A ServerStorage-ba szúrj be egy Maps nevű Folder-t. A ServerStorage objektumait a játékosok soha nem kapják meg, így a nem használt pályák semmibe sem kerülnek nekik.
  3. Minden pályát Model-ként építs a Maps-en belül, rögzített (anchored) partokból. A lobbitól messzebb építsd (néhány száz stud elég), mert a másolat pontosan ott jelenik meg, ahol megépítetted, a kiesett játékosok pedig ne tudjanak visszasétálni.
  4. Minden pályán belül adj hozzá egy Spawns nevű Folder-t, benne minden várható játékosra egy rögzített Part-tal. Állítsd a Transparency értéküket 1-re, és kapcsold ki a CanCollide beállítást, hogy senki ne lássa őket, és senki ne essen el bennük.
Az Explorer az útmutató után
Workspace
  Lobby Model
    SpawnLocation SpawnLocation
ServerStorage
  Maps Folder new
    Desert Model new
      Spawns Folder new
        Spawn1 Part new
        Spawn2 Part new
    Castle Model new
      Spawns Folder new
ServerScriptService
  Leaderstats Script new
  RoundSystem Script new
StarterGui
  RoundHud ScreenGui new
    RoundHudClient LocalScript new

A körscript 1-et ad hozzá a játékos leaderstats mappájában lévő Wins nevű IntValue-hoz. Ha a játékodban még nincs leaderstats, add hozzá ezt a rövid scriptet. Ha már van, például a ranglista útmutató mentéses változata, hagyd ki: két script, amelyek leaderstatsot hoznak létre, minden játékosnak két mappát ad.

Script helye: ServerScriptService neve: Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- a névnek pontosan ilyennek kell lennie, kisbetűkkel

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

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- A Studióban előbb beléphetsz, mint ahogy ez a script elindul, ezért mindenkit beállítunk, aki már itt van
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Ezek a Winsek lenullázódnak, amikor a játékos kilép. Ha azt szeretnéd, hogy a munkamenetek között megmaradjanak, használd a ranglista útmutató DataStore-os változatát.

2. lépés: add hozzá a körscriptet

Szúrj be egy Script-et a ServerScriptService-be, nevezd el RoundSystem-nek, és illeszd be az alábbi kódot. A felül lévő beállítások az egyetlen sorok, amelyeket valószínűleg módosítanod kell. Minden állapot külön függvény, az alul lévő ciklus pedig sorban, a végtelenségig futtatja őket.

Script helye: ServerScriptService neve: RoundSystem
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Beállítások
local MIN_PLAYERS = 2 -- állítsd 1-re, amíg egyedül tesztelsz
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: a kör akkor ér véget, ha már csak egy csapatban maradtak játékosok

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

-- Amit minden játékos képernyője mutat, az ennek a mappának az attribútumaiban van.
-- A szerver által beállított attribútumok minden kliensre replikálódnak, a később belépőkre is.
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

-- Kik vannak még az aktuális körben, és a kapcsolatok, amelyek mindegyiküket figyelik
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)

-- Csak akkor adja vissza a karaktert és a Humanoidot, ha a játékos éppen most él
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

-- Megszámolja a körben maradt oldalakat (játékosokat, vagy csapatokat, ha a USE_TEAMS be van kapcsolva)
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

-- ÁLLAPOT: Waiting és Intermission. false-t ad vissza, ha játékosok kiléptek a visszaszámlálás alatt.
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

-- ÁLLAPOT: Starting, 1. rész. Egy véletlen pályát másolunk (nem az előzőt, ha van választás).
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
	-- Megkeverjük, hogy a játékosok ne minden körben ugyanarra a spawnra kerüljenek
	for i = #points, 2, -1 do
		local j = random:NextInteger(1, i)
		points[i], points[j] = points[j], points[i]
	end
	return points
end

-- Milyen magasan van egy álló karakter root partja a padló fölött.
-- A képlet a Roblox Humanoid.HipHeight referenciájából való (R6 rigeknél hozzáadódik a láb magassága).
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

-- ÁLLAPOT: Starting, 2. rész. Felkészülés, aztán minden élő játékos teleportálása.
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

	-- Bekapcsolt streaming esetén megkérünk minden klienst, hogy töltse be a pályát, mielőtt a karakter megérkezik
	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

	-- Csak azok vesznek részt, akik éppen most élnek. A többiek a következő kört várják.
	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]
			-- A karakter pivotja a root partja, ezért álló magasságba emeljük a part fölé
			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

-- ÁLLAPOT: InRound. Akkor ér véget, ha lejárt az idő, vagy egy oldal maradt.
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()
		-- Az egy oldallal indult kör (egyszemélyes teszt) csak az idő lejártával vagy halállal ér véget
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- ÁLLAPOT: Results. Mindenki nyer, aki még él.
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) -- már nem figyeljük őket; a takarításig a pályán maradnak
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- ÁLLAPOT: Cleanup. A túlélőket visszaküldjük a lobbiba, aztán töröljük a pályát.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- még a szerveren van
			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

-- A ciklus: egy menet egy kör
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ég nincsenek pályák: hamarosan újra próbáljuk
		end
	end
end

Minden fontos dolog itt, a szerveren történik: ki van a körben, az időzítő, a győztes és a Wins. A kliensek csak három attribútumot kapnak a ReplicatedStorage.RoundInfo-n (State, Status és TimeLeft), és egy InRound attribútumot minden játékoson.

Hogyan működik az egyes állapot

Várakozás és szünet

A runIntermission először addig tartja a ciklust, amíg a #Players:GetPlayers() el nem éri a MIN_PLAYERS értéket. Aztán másodpercenként visszaszámol a task.wait(1) segítségével, és minden ütemben ellenőrzi a játékosok számát. Ha valaki kilépett, és a szerveren a minimum alá csökkent a létszám, false-t ad vissza, és a fő ciklus elölről kezdődik a Waitingtől, így a kör soha nem indul el egyetlen emberrel.

A pálya kiválasztása és betöltése

A loadMap összegyűjti az összes Model-t a ServerStorage.Maps-ben, kiveszi az előző kör pályáját, ha van miből választani, és a Random:NextInteger segítségével kiválaszt egyet. Aztán a Workspace-be klónozza a pályát. Az eredeti érintetlen marad a ServerStorage-ban, így minden kör friss másolattal indul: minden, amit a játékosok az előző körben eltörtek vagy elmozdítottak, eltűnik.

Az új place-ekben be van kapcsolva az instance streaming: a kliensnek csak a karaktere közelében lévő partjai vannak meg. A teleport előtt a script minden játékosra meghívja a Player:RequestStreamAroundAsync-et, és ez megkéri a motort, hogy a „készülj” visszaszámlálás alatt küldje el a kliensnek a pálya környékét. Enélkül a játékosok előbb érkezhetnek meg, mint ahogy a padló betöltődött, és egy pillanatra megdermedhetnek.

A játékosok teleportálása PivotTo-val

A visszaszámlálás után a script összeállítja a résztvevők listáját azokból a játékosokból, akiknek a karaktere létezik, még a világban van, és van Humanoidja 0-nál nagyobb életerővel és root partja. Ez az ellenőrzés a visszaszámlálás után történik, így aki közben meghalt vagy kilépett, nem kerül a listára.

Minden résztvevőt a character:PivotTo(cframe) visz át. A Roblox referenciája a PivotTo-t nevezi a modellek scriptből való mozgatásának fő módjaként, és a karakter minden részét együtt mozgatja. A HumanoidRootPart.Position beállítása nem ugyanaz: a Roblox úgy igazítja a kötéseket, hogy csak ez az egy rész mozdul, és a test többi része lemaradhat. A karakter pivotja a root partja, ezért a cél a spawn part CFrame-je, megemelve a part magasságának felével plusz azzal a magassággal, amelyen a root part a padló fölött áll. A rootHeight ezt a Roblox Humanoid.HipHeight referenciájának képletével számolja: a root part magasságának fele plusz a HipHeight, plusz R6 rigeknél a láb hossza. Így a méretezett és egyedi avatarok nem ragadnak bele a partba, és nem esnek rá felülről. A CFrame forgatást is tartalmaz, így a játékosok arra néznek, amerre a spawn part: fordítsd a partokat úgy, hogy mindenki a pálya közepe felé nézzen.

Ha több a játékos, mint a spawn part, a script újra az első parttól kezd, és a játékosok egymásra kerülnek, ezért legalább annyi spawnt adj hozzá, amennyi a maximális játékosszámod.

Ha a futás (sprint) útmutató sebességellenőrzését is használod, add hozzá a player:SetAttribute("MovementCheckSkip", true) sort közvetlenül a character:PivotTo(...) után a startRound-ban, hogy a teleportot ne tekintse sebességtúllépésnek.

A kör időzítője és a befejezés feltételei

A runRound másodpercenként ketyeg. Minden ütemben frissíti az állapotot (hány játékos maradt) és a hátralévő másodperceket, aztán megszámolja az élő oldalakat. A kör háromféleképpen érhet véget:

  • Lejárt az idő. A for ciklus eléri az 1-et, és véget ér.
  • Egy oldal maradt. Az oldal egy játékos, vagy egy csapat, ha a USE_TEAMS be van kapcsolva. Az ellenőrzés csak akkor működik, ha a kör két vagy több oldallal indult, így egy egyszemélyes teszt nem ér véget abban a pillanatban, ahogy elkezdődött.
  • Senki sem maradt. Mindenki meghalt vagy kilépett, és a kör győztes nélkül ér véget.

A másodpercenkénti ellenőrzés azt jelenti, hogy a kör az utolsó kiesés után még legfeljebb egy másodpercig mehet, ami egy kör időzítőjén szinte észrevehetetlen.

A Wins kiosztása és az eredmény megjelenítése

A script szabálya egyszerű: mindenki nyer, aki a kör végén él. Ez egyetlen logikai sorral lefedi az utolsó túlélő játékost, az utolsó túlélő csapatot és a „bírd ki, amíg le nem jár az időzítő” módot is. A finishRound 1-et ad minden győztes Wins értékéhez, abbahagyja a figyelésüket, és RESULTS_SECONDS időre kiír egy üzenetet, például "Alex wins!". Ha azt szeretnéd, hogy az idő lejártakor ne legyen győztes, hagyd ki az awardWin-t, és változtasd meg az üzenetet, ha a sidesLeft nagyobb 1-nél. Mindenképp továbbra is add vissza a listát, mert a takarítás ez alapján küldi vissza a túlélőket a lobbiba.

Takarítás

A túlélők még a pályán állnak, ezért a cleanup újraéleszti őket a lobbiban a Player:LoadCharacterAsync() segítségével, amely a régi LoadCharacter-t váltja, aztán törli a pálya másolatát. Minden újraélesztés a saját task.spawn-jában fut egy pcall-on belül, mert a hívás megvárja a karakter betöltését, és meghiúsulhat, ha a játékos épp abban a pillanatban lép ki. A kiesett játékosoknak semmi sem kell: ők már maguktól újraéledtek a lobbiban.

3. lépés: mutasd az időzítőt és az állapotot minden játékosnak

A szerver három attribútumot tesz közzé a ReplicatedStorage.RoundInfo-n: State (rögzített szó, például InRound, scripteknek), Status (szöveg embereknek) és TimeLeft (másodpercek). Azok az attribútumok, amelyeket egy szerverscript egy replikált objektumon állít be, automatikusan eljutnak minden klienshez, és a kör közepén belépő játékos azonnal megkapja az aktuális értékeket. Ezért egy időzítőhöz ez jobban illik, mint egy remote: egy RemoteEvent, amelyet azelőtt küldtek el, hogy valaki belépett, soha nem jut el hozzá.

  1. Az Explorerben szúrj be egy ScreenGui-t a StarterGuiba, és nevezd el RoundHud-nak. Hagyd bekapcsolva a ResetOnSpawn beállítást (ez az alapértelmezés).
  2. Szúrj be egy LocalScript-et a RoundHud-ba, nevezd el RoundHudClient-nek, és illeszd be az alábbi kódot. A feliratot maga hozza létre, így semmi mást nem kell megrajzolnod.
  3. Nyomd meg a Play gombot. A képernyő tetején lévő felirat az állapotot és a visszaszámlálást mutatja m:ss formátumban.
LocalScript helye: RoundHud ScreenGui a StarterGuiban neve: RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- A felirat. Ha saját TextLabelt rajzoltál a RoundHudba, töröld ezt a blokkot, és használd ezt:
-- 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 -- a hosszú üzenetek második sorba törnek
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()

Mivel a ResetOnSpawn be van kapcsolva, a Roblox a karakter minden megjelenésekor friss RoundHud másolatot ad a játékosnak, a takarításkori újraélesztéskor is. A script ekkor újra kiolvassa az aktuális attribútumokat, így a felirat soha nem avul el.

A kliens csak olvas. Semmi, amit a játékos a saját képernyőjén megváltoztat, nem hat a valódi időzítőre, mert egy LocalScriptből végzett attribútummódosítás azon az egy kliensen marad. Tizedmásodperces visszaszámláláshoz a szerver ehelyett a workspace:GetServerTimeNow() szerinti befejezési időt is tárolhatja egy attribútumban, és minden kliens minden képkockában kivonja belőle a saját workspace:GetServerTimeNow() értékét.

Ha a játékod egy főmenüvel nyílik, a RoundHud akkor jelenik meg, amikor a játékos megnyomja a Play gombot, mert a StarterGui csak a karakter megjelenése után másolódik a játékoshoz. A még menüben lévő játékosoknak nincs karakterük, így őket soha nem teleportálja a körbe.

Játékosok, akik a kör közepén meghalnak, kilépnek vagy belépnek

Ezeket az eseteket könnyű kihagyni, amikor valaki először ír körscriptet. Ha valamelyiket nem kezeli, általában hibát látsz az Outputban, vagy egy kört, amely soha nem ér véget. Íme, mit csinál a fenti script mindegyikkel.

Szélsőséges esetek, és hogyan kezeli őket a körscript
HelyzetMi történikHol a scriptben
Egy játékos meghal a körben (megölték, resetelt, leesett)Kikerül a körből, és a Players.RespawnTime után (alapból 5 másodperc) újraéled a lobbiban.A humanoid.Died meghívja az eliminate-et
A karakter halál nélkül törlődikMint halálkor: a játékos kiesett.A player.CharacterRemoving meghívja az eliminate-et
Egy játékos kilép a szerverrőlKikerül, a kapcsolatai bontódnak, és a következő ütem újraszámolja az oldalakat.A Players.PlayerRemoving meghívja az eliminate-et
Egy játékos a kör közepén lép beA lobbiban jelenik meg, látja az élő állapotot és az időzítőt, és a következő körbe kerül.A résztvevőket csak a startRound választja ki
Egy játékos halott volt a kör indulásakorNem teleportálják, a lobbiban vár.getLivingCharacter
Mindenki kilépett vagy meghaltA kör "Nobody survived" üzenettel ér véget, és a ciklus elölről kezdődik: Intermission, ha még elég játékos van a szerveren, különben Waiting.sidesLeft == 0 a runRound-ban

Az eliminate úgy van megírva, hogy biztonságosan meghívható többször ugyanarra a játékosra. Egy játékos, aki meghalt és újraéledt, kiváltja a Died és a CharacterRemoving eseményt is, aki pedig kilép, mindhármat kiválthatja; csak az első hívás csinál valamit.

Továbbfejlesztés: csapatok, szavazás a pályára és körös események

Az utolsó túlélő csapat

Állítsd be a USE_TEAMS = true értéket, aztán adj hozzá Team objektumokat a Teams szolgáltatáshoz az Explorerben, mindegyiknek saját névvel és TeamColorral. Alapból a Roblox minden belépő játékost abba az automatikusan kiosztható csapatba teszi, amelyben a legkevesebb tag van. Amikor játékosok kilépnek, nem egyensúlyozza újra a csapatokat, így hosszú munkamenetekben a csapatok egyenlőtlenné válhatnak. Hagyd a lobbi SpawnLocationjét Neutral állapotban, hogy minden csapat ott jelenjen meg. Ekkor a kör akkor ér véget, ha az élő játékosok már csak egy csapatban maradtak, és az eredmény így néz ki: "Red wins!".

Az „egy mindenki ellen” formátumhoz (egy vadász, a többiek túlélnek) a startRound-ban válassz ki egy véletlen résztvevőt, és a teleport előtt állítsd a Team értékét a vadászcsapatra. Kapcsold ki a vadászcsapat AutoAssignable beállítását, hogy új játékosok soha ne kerüljenek oda, és a cleanup-ban tedd vissza a vadászt a túlélők csapatába. Ekkor ugyanazok a befejezési feltételek működnek: a vadász nyer, ha minden túlélő kiesett, a túlélők pedig akkor, ha kitartottak az időzítő végéig, feltéve, hogy az idő lejártakor kihagyod a vadász awardWin-jét.

Szavazás a pályára

A szavazáshoz a kliensnek kommunikálnia kell a szerverrel, vagyis RemoteEvent kell. A szünet alatt a szerver attribútumokként közzétesz két vagy három pályanevet, minden kliens RemoteEventen elküldi a nevet, amelyre kattintott, a szerver pedig a loadMap futtatása előtt megszámolja a szavazatokat. A szervernek minden szavazatot ellenőriznie kell: hogy az argumentum string, hogy az aktuális lehetőségek egyike, hogy az állapot Intermission, és hogy minden játékos egyszer számít (a szavazatokat egy Player kulcsú táblában tárold, hogy a második szavazat lecserélje az elsőt, és ürítsd a PlayerRemoving-ban). A RemoteEvent útmutató részletesen végigveszi ezt az ellenőrzési mintát.

Eszköz kiosztása a kör elején

Más scriptek is reagálhatnak a körre anélkül, hogy a RoundSystem-hez nyúlnának. A körscript minden játékosnak beállítja az InRound attribútumot, amikor teleportálja, és leveszi, amikor a játékos kiesik. Ez a script ezt figyeli, és minden játékosnak ad egy másolatot a ServerStorage-ban lévő RoundTool nevű Toolból.

Script helye: ServerScriptService neve: 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

Nincs olyan kód, amely elvenné az eszközt. Amikor a karakter meghal, a Roblox a Backpacket egy friss, a StarterPackből feltöltöttre cseréli, a takarításkori LoadCharacterAsync pedig a túlélőknél üríti, így a kör után az eszköz már nincs meg.

Ha kiosztható fegyver kell, építs egy kardot vagy egy raycastos fegyvert, tartsd a ServerStorage-ban a StarterPack helyett, és cseréld a scriptben a "RoundTool" nevet az ő nevére.

NPC-k és más objektumok csak a kör idejére

Minden, aminek csak a kör alatt kell léteznie, a pálya modelljén belül élhet: ellenségek, felvehető tárgyak, mozgó platformok. A ServerStorage-ban lévő modell scriptjei nem futnak; amint a másolat a Workspace-be kerül, elindulnak, a takarításkori map:Destroy() pedig mindennel együtt törli őket. Ha a játékosokat üldöző ellenségeket szeretnél, építs egyet az NPC pathfinding útmutató alapján, és tedd a pályába. Ha minden kör elején körberepülnéd a pályát, az átvezető jelenet útmutató megmutatja, hogyan indíthat ez a script minden játékosnak átvezető jelenetet egy BindableEventen keresztül.

Hogyan csinálj ebből modult

Kezdésnek nincs szükség ModuleScriptre. Egyetlen Scriptet könnyebb olvasni, amíg a játékot építed. Akkor bontsd szét, amikor más scripteknek meg kell hívniuk a kör függvényeit, vagy amikor a beállításokat egy közös ModuleScriptbe szeretnéd tenni, amelyet a szerver és a UI is betölthet require-ral. Addig a RoundInfo State attribútuma és minden játékos InRound attribútuma már a körrendszer nyilvános felületeként működik: bármelyik script figyelheti őket.

Gyakori hibák és megoldásaik

Nyisd meg az Output ablakot (a Studio Window menüjéből vagy a Script fülről) a Play megnyomása előtt. A körrendszer legtöbb problémája figyelmeztetést vagy hibát ír ki ott, a script nevével és a sor számával.

A "Waiting for players (1/2)" állapotban ragad

Egyedül tesztelsz, a MIN_PLAYERS pedig 2. Egyszemélyes tesztekhez állítsd 1-re, vagy tesztelj Server & Clients módban 2 klienssel.

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

A mappa nem létezik, elírtad a nevét, vagy rossz szolgáltatásban van. Egy pontosan Maps nevű Foldernek kell lennie, közvetlenül a ServerStorage-ban. Ugyanez a figyelmeztetés a LocalScriptben a RoundInfo-ra azt jelenti, hogy a RoundSystem script el sem jutott a létrehozásáig: ki van kapcsolva, hibával leállt, vagy még mindig a Maps mappára vár.

A teleport után a játékosok átesnek a pályán

A pálya partjai nincsenek rögzítve, ezért a másolat szétesik, amint a Workspace-be kerül. Jelöld ki a pályát, rögzítsd a partjait, és ellenőrizd, hogy a spawn partok a padló fölött vannak, nem benne.

A kiesett játékosok az arénán élednek újra

A pályán belül van egy SpawnLocation. Cseréld le egy sima Partra a pálya Spawns mappájában.

A kör nem ér véget, amikor mindenki meghalt

Ellenőrizd, hogy a sebzésed tényleg megöli-e a Humanoidot (az életerő 0-ra csökken), és nem csak mozgatja vagy rögzíti a játékosokat. Ha kikapcsoltad a Humanoid Dead állapotát, a Died soha nem sül el, és a körnek az időzítő végéig kell mennie.

A körciklus egyetlen hiba után végleg leáll

A ciklus egyetlen szálon fut, ezért bármelyik állapotban fellépő hiba leállítja. Olvasd el a hibát az Outputban, javítsd ki a sort, és teszteld újra. Gyakori ok: a scriptet úgy módosították, hogy a player.Character.Humanoid-ot használja annak ellenőrzése nélkül, hogy a karakter létezik-e.

Elkészítés RoCode-dal

Ha nincs kedved mindezt kézzel összerakni, a RoCode megcsinálhatja a nálad nyitott place-ben. Ez egy AI-ügynök, amely egy Roblox Studio pluginon keresztül dolgozik, így a scriptek és a partok az Explorerben jelennek meg, nem egy chatablakban, ahonnan be kellene illesztened őket.

Te írod

Adj hozzá egy körrendszert: 20 másodperces szünet, amelyhez 2 játékos kell, véletlen pálya a ServerStorage.Maps-ből, mindenki teleportálása a pálya spawn partjaira, 2 perces körök, ahol az utolsó élő játékos nyer, adj hozzá egy Wint a leaderstatsban, és mutasd az állapotot és az időzítőt a képernyő tetején.

A RoCode elvégzi
  • Előbb átnézheti a place-edet a List Children, a Search Game és a Search Scripts segítségével, hogy a te Maps mappádat és leaderstats scriptedet használja, és ne adjon hozzá egy második készletet
  • A Create Script segítségével létrehozza a körök Scriptjét a ServerScriptService-ben és az időzítő LocalScriptjét, és a Place Prefab segítségével elhelyezhet egy arénát a saját kész építményeiből, ha még nincs pályád
  • Befejezés előtt minden script fordítását ellenőrzi a Studióban a Check Scripttel. Ez a szintaktikai hibákat kapja el, nem a körlogika hibáit
  • A playtested után a Check Output kiolvassa a Server és Client sorokat a legutóbbi playtestből, hogy kijavítson egy futásidejű hibát

A 3.9-es vagy újabb pluginnal a RoCode rövid playtestet indíthat és kiolvashatja a hibákat, a 3.9.11-es vagy újabb pluginnal pedig irányíthat egy tesztkaraktert, de több játékossal nem tesztel, ezért a köröket magad futtasd le Server & Clients módban. Minden változtatáscsomag egy visszavonási pont a Studióban. A körciklus sok játék alapja, és az egész Roblox játék készítése AI-val, rendszerről rendszerre gyakran egy ilyen ciklussal kezdődik. Hogyan kapcsolódik a RoCode a Studióhoz.

Gyakori kérdések

Hogyan készítsek csapatos körrendszert Robloxban?

Adj hozzá Team objektumokat a Teams szolgáltatáshoz, és állítsd be a USE_TEAMS = true értéket a körscriptben. A Roblox a belépő játékosokat abba az automatikusan kiosztható csapatba osztja, amelyben a legkevesebb tag van, a kör pedig akkor ér véget, ha az élő játékosok már csak egy csapatban maradtak.

Hogyan mutassam meg a visszaszámlálást minden játékosnak?

A szerverről állítsd be a hátralévő másodperceket egy ReplicatedStorage-beli objektum attribútumaként, és figyeld a GetAttributeChangedSignal segítségével egy LocalScriptben, amely frissít egy TextLabelt, mint a 3. lépésben. A később belépő játékosok azonnal megkapják az aktuális értéket.

Mit használjak a körciklusban: wait() vagy task.wait()?

Használd a task.wait()-et. A Roblox a globális wait()-et elavultnak és a task.wait()-tel felváltottnak jelöli.

Hogyan teleportáljam a játékosokat minden körben egy másik place-be?

Ez egy másik eszköz. Ez az útmutató egy szerveren belül viszi át a karaktereket a PivotTo segítségével. A játékosokat az experience-ed egy másik place-ébe a TeleportService küldi, amely egy másik szerverre viszi át őket. A teleport útmutató ezt végző portálokat épít, újrapróbálással, ha a teleport nem sikerült.

Miért dermednek meg a játékosok egy pillanatra a teleport után?

Bekapcsolt instance streaming mellett a kliens még nem kapta meg a pályát. A scriptben a „készülj” visszaszámlálás alatt hívott RequestStreamAroundAsync megkéri a motort, hogy előre küldje el; egy hosszabb GET_READY_SECONDS több időt ad a lassú kapcsolatoknak.

Források és további olvasnivaló

Hogyan ellenőriztük a kódot: az oldalon minden script átmegy a Luau szigorú típusellenőrzésén a Roblox API definícióival (luau-lsp, 2026. november 20.). A típusellenőrzés kiszűri az elírt API-neveket és a rossz típusokat, de a játéklogikai hibákat nem, ezért publikálás előtt mindent tesztelj a Studióban.

Próbáld ki a RoCode-ot a saját játékodban.

Ingyenes kreditek minden nap, bankkártya nélkül. Telepítsd a plugint, írd le a funkciót, és nézd meg, mi jelenik meg a Studióban.