Tutorial · Sisteme de joc

Cum faci un sistem de runde în Roblox Studio

Cele mai multe jocuri cu runde din Roblox rulează aceeași buclă: așteaptă jucători, numără până la zero, încarcă o hartă, îi teleportează pe toți acolo, rulează un cronometru, alege un câștigător și face curat. În acest ghid construim această buclă ca un singur script de server clar, adăugăm un cronometru pe care îl vede fiecare jucător și trecem prin cazurile la care se strică scripturile copiate: jucători care mor, ies sau intră în mijlocul unei runde.

Actualizat 20 noiembrie 202615 min de cititAutor:

Pe scurt

Scrie un singur Script de server în ServerScriptService, care trece în cerc printr-un set fix de stări: pauza (așteaptă numărul necesar de jucători, apoi numărătoarea inversă), încărcarea hărții (clonează o hartă aleatorie din ServerStorage în Workspace), teleportul (mută fiecare personaj viu pe un part de spawn prin PivotTo), runda (rulează cronometrul până se termină timpul sau rămâne un singur jucător ori o singură echipă) și curățenia (dă Wins, readuce supraviețuitorii, șterge harta).

  • Rulează bucla doar pe server. Publică starea și secundele rămase ca atribute pe un Folder din ReplicatedStorage, iar afișarea las-o unui LocalScript.
  • Ține un tabel cu cei încă în rundă. Scoate un jucător când îi moare Humanoid-ul, când îi e șters personajul sau când iese.
  • Teleportează doar jucătorii al căror personaj e viu în momentul începerii rundei. Cine a intrat mai târziu așteaptă în lobby runda următoare.
Pe această pagină
  1. Cum funcționează
  2. 1. Lobby și hărți
  3. 2. Scriptul de runde
  4. Cum funcționează stările
  5. 3. UI-ul cronometrului
  6. Jucători în mijlocul rundei
  7. Cum extinzi
  8. Common errors
  9. Cu RoCode
  10. Întrebări frecvente
  11. Surse și lecturi suplimentare

Cum funcționează un sistem de runde

IlustrațieScripturile de runde gata făcute într-un joc pornit, accelerat.

Un sistem de runde e o mașină de stări. În orice moment serverul e într-o singură stare, fiecare stare are o singură sarcină, iar o singură condiție o duce în următoarea. Dacă scrii așa, toată logica stă într-un singur loc și nu apare bug-ul clasic în care bucla cronometrului și bucla rundei încearcă amândouă să termine aceeași rundă.

Stările buclei de runde din acest ghid
StareCe face serverulCând trece mai departe
WaitingArată "Waiting for players (1/2)"Pe server sunt destui jucători
IntermissionNumără timpul cât toți sunt în lobbyNumărătoarea s-a terminat (sau revine la Waiting, dacă jucătorii au ieșit)
StartingCopiază o hartă aleatorie în Workspace, îi arată numele, le cere clienților s-o încarceS-a terminat numărătoarea scurtă "pregătiți-vă"
InRoundTeleportează jucătorii vii, rulează cronometrul, îi scoate pe cei care au murit sau au ieșitS-a terminat timpul sau a rămas un singur jucător ori o singură echipă
ResultsDă un Win tuturor celor încă vii și arată cine a câștigatAu trecut câteva secunde
CleanupReaduce supraviețuitorii în lobby și șterge hartaImediat, după care bucla începe din nou

Fiecare stare e deținută de server. Clienții doar arată ce le spune serverul. O numărătoare într-un LocalScript se depărtează de cea reală, e greșită la cei intrați mai târziu și poate fi schimbată de un exploiter. Dacă împărțirea în server și client e nouă pentru tine, citește întâi Script vs LocalScript vs ModuleScript.

Pasul 1: construiește lobby-ul, hărțile și statistica Wins

  1. Construiește un lobby în Workspace cu un SpawnLocation. Verifică dacă are bifată proprietatea Neutral, ca fiecare jucător să apară aici, să aștepte aici și să revină aici după eliminare.
  2. În ServerStorage inserează un Folder numit Maps. Obiectele din ServerStorage nu se trimit niciodată jucătorilor, așa că hărțile nefolosite nu-i costă nimic.
  3. Construiește fiecare hartă ca un Model în Maps, cu part-uri ancorate. Construiește-o departe de lobby (câteva sute de studs ajung), pentru că o copie apare exact acolo unde ai construit-o, iar jucătorii eliminați nu trebuie să aibă cum să intre înapoi.
  4. În fiecare hartă adaugă un Folder numit Spawns, iar în el câte un Part ancorat pentru fiecare jucător așteptat. Setează-le Transparency la 1 și dezactivează CanCollide, ca nimeni să nu le vadă și să nu se împiedice de ele.
Explorer-ul după acest ghid
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

Scriptul de runde adaugă 1 la un IntValue numit Wins din folderul leaderstats al jucătorului. Dacă jocul tău nu are încă leaderstats, adaugă acest script scurt. Dacă îl are deja, de exemplu versiunea cu salvare din ghidul despre clasament, sari peste el: două scripturi care creează leaderstats îi dau fiecărui jucător două foldere.

Script în ServerScriptService cu numele Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- numele trebuie să fie exact așa, cu litere mici

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

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- În Studio poți intra înainte să pornească acest script, așa că îi configurăm pe toți cei deja aici
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Aceste Wins se resetează când jucătorul iese. Ca să se păstreze între sesiuni, ia versiunea cu DataStore din ghidul despre clasament.

Pasul 2: adaugă scriptul de runde

Inserează un Script în ServerScriptService, numește-l RoundSystem și lipește codul de mai jos. Setările de sus sunt singurele rânduri pe care probabil va trebui să le schimbi. Fiecare stare e o funcție separată, iar bucla de jos le rulează în ordine, la nesfârșit.

Script în ServerScriptService cu numele RoundSystem
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Setări
local MIN_PLAYERS = 2 -- pune 1 cât testezi singur
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: runda se termină când jucătorii au rămas într-o singură echipă

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

-- Ce arată ecranul fiecărui jucător se ține în atribute pe acest folder.
-- Atributele setate de server se replică la toți clienții, inclusiv la cei intrați mai târziu.
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

-- Cine mai e în runda curentă și conexiunile care îl urmăresc pe fiecare
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)

-- Returnează personajul și Humanoid-ul doar dacă jucătorul e viu chiar acum
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

-- Numără părțile rămase în rundă (jucători sau echipe, dacă e activat 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

-- STAREA: Waiting și Intermission. Returnează false dacă jucătorii au ieșit în timpul numărătorii.
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

-- STAREA: Starting, partea 1. Copiem o hartă aleatorie (nu pe cea de data trecută, dacă există de ales).
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
	-- Amestecăm, ca jucătorii să nu ajungă pe același spawn la fiecare rundă
	for i = #points, 2, -1 do
		local j = random:NextInteger(1, i)
		points[i], points[j] = points[j], points[i]
	end
	return points
end

-- La ce înălțime deasupra podelei stă root part-ul unui personaj în picioare.
-- Formula din referința Roblox pentru Humanoid.HipHeight (la rigurile R6 se adaugă înălțimea piciorului).
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

-- STAREA: Starting, partea 2. Pregătirea, apoi teleportăm toți cei vii.
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

	-- Cu streamingul activ, îi cerem fiecărui client să încarce harta înainte să sosească personajul
	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

	-- Participă doar cei vii chiar acum. Ceilalți așteaptă runda următoare.
	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]
			-- Pivotul personajului e root part-ul lui, așa că îl ridicăm la înălțimea de stat în picioare deasupra part-ului
			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

-- STAREA: InRound. Se termină când s-a terminat timpul sau a rămas o singură parte.
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()
		-- O rundă începută de o singură parte (test solo) se termină doar după timp sau prin moarte
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- STAREA: Results. Câștigă toți cei încă vii.
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) -- nu-i mai urmărim; rămân pe hartă până la curățenie
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- STAREA: Cleanup. Trimitem supraviețuitorii înapoi în lobby, apoi ștergem harta.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- încă pe server
			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

-- Bucla: o trecere înseamnă o rundă
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) -- încă nu există hărți: încercăm din nou în curând
		end
	end
end

Tot ce contează se întâmplă aici, pe server: cine e în rundă, cronometrul, câștigătorul și Wins. Clienții primesc doar trei atribute pe ReplicatedStorage.RoundInfo (State, Status și TimeLeft) și atributul InRound pe fiecare jucător.

Cum funcționează fiecare stare

Așteptarea și pauza

runIntermission ține întâi bucla până când #Players:GetPlayers() ajunge la MIN_PLAYERS. Apoi numără câte o secundă prin task.wait(1) și la fiecare tic verifică numărul de jucători. Dacă cineva a ieșit și pe server au rămas mai puțini decât minimul, returnează false, iar bucla principală începe din nou de la Waiting, așa că o rundă nu începe niciodată cu un singur om.

Alegerea și încărcarea hărții

loadMap adună toate Model-urile din ServerStorage.Maps, scoate harta din runda trecută, dacă e de unde alege, și ia una prin Random:NextInteger. Apoi clonează harta în Workspace. Originalul rămâne neatins în ServerStorage, așa că fiecare rundă începe cu o copie proaspătă: tot ce au stricat sau mutat jucătorii în runda trecută dispare.

În place-urile noi e activ instance streaming: clientul are doar part-urile din jurul personajului său. Înainte de teleport, scriptul apelează Player:RequestStreamAroundAsync pentru fiecare jucător, ceea ce îi cere motorului să trimită clientului zona din jurul hărții în timpul numărătorii "pregătiți-vă". Fără asta, jucătorii pot sosi înainte să se fi încărcat podeaua și pot îngheța o clipă.

Teleportarea jucătorilor prin PivotTo

După numărătoare, scriptul adună lista participanților din jucătorii al căror personaj există, e încă în lume și are un Humanoid cu viața peste 0 și un root part. Verificarea vine după numărătoare, așa că cine a murit sau a ieșit în timpul ei nu intră în listă.

Fiecare participant e mutat prin character:PivotTo(cframe). Referința Roblox numește PivotTo modul principal de a muta modele dintr-un script, iar el mută toate părțile personajului împreună. Setarea HumanoidRootPart.Position nu e același lucru: Roblox ajustează legăturile astfel încât se mișcă doar acea parte, iar restul corpului poate rămâne în urmă. Pivotul personajului e root part-ul lui, așa că ținta e CFrame-ul part-ului de spawn, ridicat cu jumătate din înălțimea part-ului plus înălțimea la care root part-ul stă deasupra podelei. rootHeight o calculează după formula din referința Roblox pentru Humanoid.HipHeight: jumătate din înălțimea root part-ului plus HipHeight, plus lungimea piciorului la rigurile R6. Așa avatarurile scalate și cele personalizate nu se blochează în part și nu cad pe el de sus. CFrame-ul include rotația, așa că jucătorii privesc în aceeași direcție ca part-ul de spawn: rotește part-urile astfel încât toți să privească spre centrul hărții.

Dacă sunt mai mulți jucători decât part-uri de spawn, scriptul începe din nou cu primul part, iar jucătorii ajung unii peste alții, așa că adaugă cel puțin atâtea spawn-uri câți jucători ai maxim.

Dacă folosești și verificarea vitezei din ghidul despre sprint, adaugă player:SetAttribute("MovementCheckSkip", true) imediat după character:PivotTo(...) în startRound, ca teleportul să nu fie considerat depășire de viteză.

Cronometrul rundei și condițiile de final

runRound ticăie o dată pe secundă. La fiecare tic actualizează starea (câți jucători au rămas) și secundele rămase, apoi numără părțile vii. Runda se termină într-unul din trei feluri:

  • S-a terminat timpul. Bucla for ajunge la 1 și se termină.
  • A rămas o singură parte. O parte e un jucător sau o echipă, dacă e activat USE_TEAMS. Verificarea funcționează doar dacă runda a început cu două sau mai multe părți, așa că un test solo nu se termină în momentul în care a început.
  • Nu a mai rămas nimeni. Toți au murit sau au ieșit, iar runda se termină fără câștigător.

Verificarea o dată pe secundă înseamnă că runda poate mai dura până la o secundă după ultima eliminare, iar la un cronometru de rundă asta aproape nu se observă.

Darea Wins și afișarea rezultatului

Regula din acest script e simplă: câștigă toți cei vii în momentul în care se termină runda. Asta acoperă și ultimul jucător rămas în viață, și ultima echipă rămasă, și modul "rezistă până se termină cronometrul", cu un singur rând de logică. finishRound adaugă 1 la Wins fiecărui câștigător, nu-i mai urmărește și arată un mesaj ca "Alex wins!" timp de RESULTS_SECONDS. Dacă vrei ca la expirarea timpului să nu existe câștigător, sari peste awardWin și schimbă mesajul când sidesLeft e mai mare decât 1. Oricum, returnează în continuare lista, pentru că curățenia o folosește ca să-i readucă pe supraviețuitori în lobby.

Curățenia

Supraviețuitorii stau încă pe hartă, așa că cleanup îi readuce în lobby prin Player:LoadCharacterAsync(), care înlocuiește vechiul LoadCharacter, apoi șterge copia hărții. Fiecare readucere rulează în propriul task.spawn într-un pcall, pentru că apelul așteaptă încărcarea personajului și poate eșua dacă jucătorul iese tocmai atunci. Jucătorii eliminați nu au nevoie de nimic: au reapărut deja singuri în lobby.

Pasul 3: arată cronometrul și starea fiecărui jucător

Serverul publică trei atribute pe ReplicatedStorage.RoundInfo: State (un cuvânt fix ca InRound, pentru scripturi), Status (text pentru oameni) și TimeLeft (secunde). Atributele pe care un script de server le setează pe un obiect replicat ajung automat la fiecare client, iar un jucător care intră în mijlocul rundei primește imediat valorile curente. De aceea pentru un cronometru se potrivesc mai bine decât un remote: un RemoteEvent trimis înainte să intre cineva nu ajunge niciodată la el.

  1. În Explorer inserează un ScreenGui în StarterGui și numește-l RoundHud. Lasă ResetOnSpawn activat (implicit).
  2. Inserează un LocalScript în RoundHud, numește-l RoundHudClient și lipește codul de mai jos. Își creează singur eticheta, așa că nu mai trebuie să desenezi nimic.
  3. Apasă Play. Eticheta din partea de sus a ecranului arată starea și numărătoarea în formatul m:ss.
LocalScript în ScreenGui-ul RoundHud din StarterGui cu numele RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Eticheta. Dacă ți-ai desenat propriul TextLabel în RoundHud, șterge acest bloc și folosește:
-- 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 -- mesajele lungi trec pe al doilea rând
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()

Pentru că ResetOnSpawn e activat, Roblox îi dă jucătorului o copie nouă a RoundHud la fiecare apariție a personajului, inclusiv la readucerea de la curățenie. Scriptul citește atunci din nou atributele curente, așa că eticheta nu se învechește niciodată.

Clientul doar citește. Nimic din ce schimbă jucătorul pe ecranul lui nu afectează cronometrul real, pentru că schimbările de atribute dintr-un LocalScript rămân pe acel singur client. Pentru o numărătoare cu zecimi de secundă, serverul poate ține în schimb într-un atribut momentul de final din workspace:GetServerTimeNow(), iar fiecare client scade din el, la fiecare cadru, propriul workspace:GetServerTimeNow().

Dacă jocul tău se deschide cu un meniu principal, RoundHud apare când jucătorul apasă Play, pentru că StarterGui se copiază la jucător doar după apariția personajului. Jucătorii încă în meniu nu au personaj, așa că nu sunt niciodată teleportați în rundă.

Jucători care mor, ies sau intră în mijlocul rundei

Cazurile acestea sunt ușor de ratat când scrii prima dată un script de runde. Dacă unul dintre ele nu e tratat, de obicei vezi o eroare în Output sau o rundă care nu se mai termină. Iată ce face scriptul de mai sus cu fiecare.

Cazuri limită și cum le tratează scriptul de runde
SituațieCe se întâmplăUnde în script
Un jucător moare în rundă (ucis, a dat reset, a căzut)E scos din rundă și reapare în lobby după Players.RespawnTime (implicit 5 secunde).humanoid.Died apelează eliminate
Personajul e șters fără moarteLa fel ca la moarte: jucătorul e eliminat.player.CharacterRemoving apelează eliminate
Un jucător iese de pe serverE scos, conexiunile lui se deconectează, iar următorul tic numără din nou părțile.Players.PlayerRemoving apelează eliminate
Un jucător intră în mijlocul rundeiApare în lobby, vede starea și cronometrul live și intră în runda următoare.Participanții sunt aleși doar în startRound
Un jucător era mort când a început rundaNu e teleportat, așteaptă în lobby.getLivingCharacter
Toți au ieșit sau au muritRunda se termină cu "Nobody survived", iar bucla începe din nou: Intermission, dacă pe server mai sunt destui jucători, altfel Waiting.sidesLeft == 0 în runRound

eliminate e scris așa încât e sigur să fie apelat de mai multe ori pentru același jucător. Un jucător care a murit și a reapărut declanșează și Died, și CharacterRemoving, iar unul care iese poate declanșa toate trei evenimentele; face ceva doar primul apel.

Cum extinzi: echipe, vot pentru hartă și evenimente de rundă

Ultima echipă rămasă

Setează USE_TEAMS = true, apoi adaugă obiecte Team în serviciul Teams din Explorer, fiecăruia cu propriul nume și TeamColor. Implicit, Roblox pune fiecare jucător care intră în echipa auto-asignabilă cu cei mai puțini membri. Când jucătorii ies, nu reechilibrează echipele, așa că în sesiunile lungi echipele pot ajunge inegale. Lasă SpawnLocation-ul din lobby Neutral, ca toate echipele să apară acolo. Atunci runda se termină când jucătorii vii au rămas într-o singură echipă, iar rezultatul arată ca "Red wins!".

Pentru formatul "unul contra tuturor" (un vânător, restul supraviețuiesc), alege în startRound un participant aleatoriu și, înainte de teleport, setează-i Team-ul la echipa vânătorului. Debifează AutoAssignable la echipa vânătorului, ca jucătorii noi să nu ajungă niciodată acolo, iar în cleanup mută vânătorul înapoi în echipa supraviețuitorilor. Atunci funcționează aceleași condiții de final: vânătorul câștigă dacă au fost eliminați toți supraviețuitorii, iar supraviețuitorii câștigă dacă au rezistat până la finalul cronometrului, cu condiția să sari peste awardWin-ul vânătorului când s-a terminat timpul.

Votul jucătorilor pentru hartă

Pentru vot, clientul trebuie să comunice cu serverul, deci ai nevoie de un RemoteEvent. În timpul pauzei, serverul publică prin atribute două sau trei nume de hărți, fiecare client trimite prin RemoteEvent numele pe care a apăsat, iar serverul numără voturile înainte să pornească loadMap. Serverul trebuie să verifice fiecare vot: că argumentul e un șir, că e una dintre variantele curente, că starea e Intermission și că fiecare jucător contează o singură dată (ține voturile într-un tabel cu cheia Player, ca al doilea vot să-l înlocuiască pe primul, și golește-l în PlayerRemoving). Ghidul despre RemoteEvent explică în detaliu acest tipar de verificări.

Darea unui instrument la începutul rundei

Alte scripturi pot reacționa la rundă fără să atingă RoundSystem. Scriptul de runde setează fiecărui jucător atributul InRound când îl teleportează și îl scoate când jucătorul e eliminat. Scriptul acesta îl ascultă și îi dă fiecărui jucător o copie a unui Tool numit RoundTool, care stă în ServerStorage.

Script în ServerScriptService cu numele 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

Nu există cod care ia instrumentul înapoi. Când personajul moare, Roblox înlocuiește Backpack-ul cu unul nou, umplut din StarterPack, iar LoadCharacterAsync de la curățenie îl golește la supraviețuitori, așa că după rundă instrumentul nu mai e.

Dacă ai nevoie de o armă de dat, construiește o sabie sau o armă pe raycast, ține-o în ServerStorage în loc de StarterPack și schimbă "RoundTool" din acest script în numele ei.

NPC-uri și alte obiecte doar pe durata rundei

Tot ce trebuie să existe doar în timpul rundei poate trăi în modelul hărții: inamici, obiecte de ridicat, platforme mobile. Scripturile dintr-un model din ServerStorage nu rulează; imediat ce copia ajunge în Workspace, pornesc, iar map:Destroy() de la curățenie le șterge împreună cu tot restul. Ca să adaugi inamici care urmăresc jucătorii, construiește unul după ghidul de pathfinding pentru NPC și pune-l în hartă. Pentru un survol al hărții la începutul fiecărei runde, ghidul despre cutscene-uri arată cum poate acest script să pornească un cutscene pentru fiecare jucător printr-un BindableEvent.

Cum faci din asta un modul

La început nu ai nevoie de un ModuleScript. Un singur Script e mai ușor de citit cât construiești jocul. Împarte-l când alte scripturi trebuie să apeleze funcțiile rundei sau când vrei să muți setările într-un ModuleScript comun pe care îl pot include prin require și serverul, și UI-ul tău. Până atunci, atributul State de pe RoundInfo și atributul InRound de pe fiecare jucător funcționează deja ca interfața publică a sistemului de runde: orice script le poate asculta.

Erori frecvente și soluții

Deschide fereastra Output (din meniul Window din Studio sau din fila Script) înainte să apeși Play. Cele mai multe probleme cu sistemul de runde afișează acolo un avertisment sau o eroare cu numele scriptului și numărul rândului.

Rămâne la "Waiting for players (1/2)"

Testezi singur, iar MIN_PLAYERS e 2. Pune 1 pentru testele solo sau testează în modul Server & Clients cu 2 clienți.

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

Folderul lipsește, are o greșeală în nume sau e în alt serviciu. Trebuie să fie un Folder numit exact Maps, direct în ServerStorage. Același avertisment pentru RoundInfo într-un LocalScript înseamnă că scriptul RoundSystem nu a ajuns niciodată să-l creeze: e dezactivat, a căzut cu o eroare sau încă așteaptă folderul Maps.

După teleport jucătorii cad prin hartă

Part-urile hărții nu sunt ancorate, așa că o copie se dezmembrează imediat ce ajunge în Workspace. Selectează harta, ancorează-i part-urile și verifică dacă part-urile de spawn stau deasupra podelei, nu în ea.

Jucătorii eliminați reapar în arenă

În hartă e un SpawnLocation. Înlocuiește-l cu un Part obișnuit în folderul Spawns al acelei hărți.

Runda nu se termină când toți au murit

Verifică dacă daunele tale chiar omoară Humanoid-ul (viața ajunge la 0), nu doar mută sau ancorează jucătorii. Dacă ai dezactivat starea Dead la Humanoid, Died nu se declanșează niciodată, iar runda trebuie să meargă până la finalul cronometrului.

Bucla de runde se oprește definitiv după o eroare

Bucla rulează pe un singur fir, așa că o eroare în orice stare o termină. Citește eroarea din Output, repară rândul și testează din nou. O cauză frecventă: scriptul a fost schimbat să folosească player.Character.Humanoid fără să verifice dacă personajul există.

Fă-o cu RoCode

Dacă nu ai chef să construiești toate astea manual, RoCode le poate face în place-ul pe care îl ai deschis. E un agent AI care lucrează printr-un plugin pentru Roblox Studio, așa că scripturile și part-urile apar în Explorer-ul tău, nu într-o fereastră de chat de unde ar trebui să le lipești.

Tu scrii

Adaugă un sistem de runde: o pauză de 20 de secunde care are nevoie de 2 jucători, o hartă aleatorie din ServerStorage.Maps, teleportul tuturor pe part-urile de spawn ale hărții, runde de 2 minute în care câștigă ultimul jucător rămas în viață, adaugă un Win în leaderstats și arată starea și cronometrul în partea de sus a ecranului.

RoCode face
  • Poate să se uite întâi prin place-ul tău cu List Children, Search Game și Search Scripts, ca să-ți folosească folderul Maps și scriptul de leaderstats, nu să adauge un al doilea set
  • Creează Script-ul de runde în ServerScriptService și LocalScript-ul cronometrului prin Create Script și poate pune o arenă din construcțiile lui gata făcute prin Place Prefab, dacă încă nu ai o hartă
  • Verifică în Studio compilarea fiecărui script prin Check Script înainte să termine. Asta prinde erorile de sintaxă, nu greșelile din logica rundei
  • După playtestul tău, Check Output citește rândurile Server și Client din ultimul playtest, ca să repare o eroare din timpul rulării

Cu pluginul 3.9 sau mai nou, RoCode poate porni un playtest scurt și citi erorile, iar cu pluginul 3.9.11 sau mai nou poate controla un singur personaj de test, dar nu testează cu mai mulți jucători, așa că rulează singur rundele în modul Server & Clients. Fiecare lot de modificări e un punct de anulare în Studio. Bucla de runde stă la baza multor jocuri, iar crearea unui joc Roblox întreg cu AI, sistem cu sistem începe adesea cu o astfel de buclă. Cum se conectează RoCode la Studio.

Întrebări frecvente

Cum faci un sistem de runde cu echipe în Roblox?

Adaugă obiecte Team în serviciul Teams și setează USE_TEAMS = true în scriptul de runde. Roblox repartizează jucătorii care intră în echipa auto-asignabilă cu cei mai puțini membri, iar runda se termină când jucătorii vii au rămas într-o singură echipă.

Cum arăți o numărătoare inversă tuturor jucătorilor?

Setează de pe server secundele rămase ca atribut pe un obiect din ReplicatedStorage și ascultă-l prin GetAttributeChangedSignal într-un LocalScript care actualizează un TextLabel, ca la pasul 3. Jucătorii intrați mai târziu primesc imediat valoarea curentă.

Ce folosesc în bucla de runde: wait() sau task.wait()?

Folosește task.wait(). Roblox marchează funcția globală wait() ca învechită și înlocuită de task.wait().

Cum teleportez jucătorii în alt place la fiecare rundă?

E alt instrument. Ghidul acesta mută personajele pe același server prin PivotTo. Trimiterea jucătorilor în alt place al experienței tale se face prin TeleportService, care îi mută pe alt server. Ghidul despre teleporturi construiește portaluri care fac asta, cu reîncercări dacă teleportul a eșuat.

De ce îngheață jucătorii o clipă după teleport?

Cu instance streaming activ, clientul nu a primit încă harta. Apelul RequestStreamAroundAsync din script, în timpul numărătorii "pregătiți-vă", îi cere motorului s-o trimită din timp; un GET_READY_SECONDS mai lung le dă conexiunilor lente mai mult timp.

Surse și lecturi suplimentare

Cum a fost verificat codul: fiecare script de pe această pagină trece printr-o verificare strictă a tipurilor Luau cu definițiile API Roblox (luau-lsp, 20 noiembrie 2026). Verificarea tipurilor prinde nume greșite de API și tipuri greșite, dar nu și greșelile de logică a jocului, așa că testează totul în Studio înainte să publici.

Încearcă RoCode în jocul tău.

Credite gratuite în fiecare zi, fără card. Instalează pluginul, descrie o funcție și verifică ce a apărut în Studio.