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ă
Cum funcționează un sistem de runde
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ă.
| Stare | Ce face serverul | Când trece mai departe |
|---|---|---|
| Waiting | Arată "Waiting for players (1/2)" | Pe server sunt destui jucători |
| Intermission | Numără timpul cât toți sunt în lobby | Numărătoarea s-a terminat (sau revine la Waiting, dacă jucătorii au ieșit) |
| Starting | Copiază o hartă aleatorie în Workspace, îi arată numele, le cere clienților s-o încarce | S-a terminat numărătoarea scurtă "pregătiți-vă" |
| InRound | Teleportează jucătorii vii, rulează cronometrul, îi scoate pe cei care au murit sau au ieșit | S-a terminat timpul sau a rămas un singur jucător ori o singură echipă |
| Results | Dă un Win tuturor celor încă vii și arată cine a câștigat | Au trecut câteva secunde |
| Cleanup | Readuce supraviețuitorii în lobby și șterge harta | Imediat, 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
- 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. - În ServerStorage inserează un
FoldernumitMaps. Obiectele din ServerStorage nu se trimit niciodată jucătorilor, așa că hărțile nefolosite nu-i costă nimic. - Construiește fiecare hartă ca un
ModelînMaps, 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. - În fiecare hartă adaugă un
FoldernumitSpawns, iar în el câte unPartancorat 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.
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.
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.
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
forajunge 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.
- În Explorer inserează un ScreenGui în StarterGui și numește-l
RoundHud. Lasă ResetOnSpawn activat (implicit). - Inserează un LocalScript în
RoundHud, numește-lRoundHudClientși lipește codul de mai jos. Își creează singur eticheta, așa că nu mai trebuie să desenezi nimic. - Apasă Play. Eticheta din partea de sus a ecranului arată starea și numărătoarea în formatul
m:ss.
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.
| Situație | Ce 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ă moarte | La fel ca la moarte: jucătorul e eliminat. | player.CharacterRemoving apelează eliminate |
| Un jucător iese de pe server | E 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 rundei | Apare î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 runda | Nu e teleportat, așteaptă în lobby. | getLivingCharacter |
| Toți au ieșit sau au murit | Runda 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.
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.
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.
- 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
- Roblox Creator Docs: Add rounds (în engleză). bucla de runde pe echipe a Roblox din exemplul cu laser tag
- Roblox Creator Docs: PVInstance:PivotTo (în engleză). mutarea modelelor și personajelor dintr-un script
- Roblox Creator Docs: Player (în engleză). LoadCharacterAsync, CharacterRemoving și RequestStreamAroundAsync
- Roblox Creator Docs: Properties and attributes (în engleză). setarea atributelor și urmărirea schimbărilor
- Roblox Creator Docs: Implement teams (în engleză). adăugarea echipelor și auto-asignarea
- Roblox Creator Docs: Studio testing modes (în engleză). testul cu mai mulți clienți Server & Clients
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.