In het kort
Schrijf één server-Script in ServerScriptService dat steeds een vaste reeks statussen doorloopt: intermission (wachten op genoeg spelers, dan aftellen), map laden (een willekeurige map uit ServerStorage naar Workspace klonen), teleporteren (elk levend personage met PivotTo naar een spawnpart verplaatsen), ronde (de timer laten tikken tot de tijd op is of er nog één speler of één team over is) en opruimen (Wins uitdelen, overlevenden laten respawnen, de map verwijderen).
- Laat de loop alleen op de server draaien. Publiceer de status en de resterende seconden als attributen op een Folder in ReplicatedStorage, en laat een LocalScript ze tonen.
- Houd een tabel bij van wie er nog in de ronde zit. Haal een speler eruit als zijn Humanoid doodgaat, zijn personage verwijderd wordt of hij weggaat.
- Teleporteer alleen spelers van wie het personage leeft op het moment dat de ronde start. Wie later joint, wacht in de lobby op de volgende.
Op deze pagina
Hoe een rondesysteem werkt
Een rondesysteem is een state machine. Op elk moment staat de server in precies één status, elke status heeft één taak en één voorwaarde brengt hem naar de volgende. Schrijf je het zo, dan staat alle logica op één plek en krijg je niet de klassieke bug waarbij de timerloop en de rondeloop allebei dezelfde ronde proberen te beëindigen.
| Status | Wat de server doet | Wanneer hij verder gaat |
|---|---|---|
| Waiting | Toont "Waiting for players (1/2)" | Er zijn genoeg spelers op de server |
| Intermission | Telt af terwijl iedereen in de lobby is | Het aftellen is klaar (of terug naar Waiting als spelers weggingen) |
| Starting | Kopieert een willekeurige map naar Workspace, toont de naam, vraagt clients hem te laden | Een kort "maak je klaar"-aftellen is voorbij |
| InRound | Teleporteert levende spelers, laat de timer tikken, haalt wie doodging of wegging eruit | De tijd is op, of er is nog één speler of één team over |
| Results | Geeft iedereen die nog leeft een Win en toont wie er won | Er zijn een paar seconden voorbij |
| Cleanup | Laat de overlevenden in de lobby respawnen en verwijdert de map | Meteen, daarna begint de loop opnieuw |
De server is eigenaar van elke status. Clients tonen alleen wat de server ze vertelt. Een aftelling in een LocalScript loopt uit de pas met de echte, klopt niet voor wie later joint en kan door een exploiter worden aangepast. Is de scheiding tussen server en client nieuw voor je, lees dan eerst Script vs LocalScript vs ModuleScript.
Stap 1: Bouw de lobby, de maps en de stat Wins
- Bouw een lobby in Workspace met een
SpawnLocation. Controleer dat de eigenschap Neutral aangevinkt is, zodat elke speler hier spawnt, hier wacht en hier terugkomt na het uitvallen. - Voeg in ServerStorage een
Foldertoe met de naamMaps. Objecten in ServerStorage worden nooit naar spelers gestuurd, dus ongebruikte maps kosten ze niets. - Bouw elke map als een
ModelinMaps, met geanchorde parts. Bouw hem een eind van de lobby af (een paar honderd studs is genoeg), want de kopie verschijnt precies waar je hem bouwde, en uitgevallen spelers mogen niet terug kunnen lopen. - Voeg in elke map een
Foldertoe met de naamSpawns, met daarin één geanchordePartper verwachte speler. Zet hun Transparency op 1 en zet CanCollide uit, zodat niemand ze ziet of erover struikelt.
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
Het rondescript telt 1 op bij een IntValue met de naam Wins in de map leaderstats van de speler. Heeft je game nog geen leaderstats, voeg dan dit korte script toe. Heb je het al, bijvoorbeeld de versie met opslaan uit de handleiding over het leaderboard, sla het dan over: twee scripts die leaderstats maken, geven elke speler twee mappen.
local Players = game:GetService("Players")
local function setupLeaderstats(player: Player)
local leaderstats = Instance.new("Folder")
leaderstats.Name = "leaderstats" -- de naam moet precies zo zijn, in kleine letters
local wins = Instance.new("IntValue")
wins.Name = "Wins"
wins.Value = 0
wins.Parent = leaderstats
leaderstats.Parent = player
end
Players.PlayerAdded:Connect(setupLeaderstats)
-- In Studio kun je eerder joinen dan dit script start, dus we stellen iedereen in die er al is
for _, player in Players:GetPlayers() do
setupLeaderstats(player)
end
Deze Wins worden gereset als de speler weggaat. Wil je dat ze tussen sessies bewaard blijven, neem dan de versie met DataStore uit de handleiding over het leaderboard.
Stap 2: Voeg het rondescript toe
Voeg een Script toe aan ServerScriptService, noem het RoundSystem en plak de code hieronder. De instellingen bovenaan zijn de enige regels die je waarschijnlijk moet aanpassen. Elke status is een eigen functie, en de loop onderaan voert ze op volgorde uit, eindeloos.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
-- Instellingen
local MIN_PLAYERS = 2 -- zet op 1 zolang je alleen test
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: de ronde eindigt als er alleen nog spelers in één team over zijn
local mapsFolder = ServerStorage:WaitForChild("Maps")
local random = Random.new()
-- Wat het scherm van elke speler toont, staat in attributen op deze map.
-- Attributen die de server zet, worden naar alle clients gerepliceerd, ook naar wie later joint.
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
-- Wie nog in de huidige ronde zit, en de connecties die elk van hen in de gaten houden
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)
-- Geeft het personage en de Humanoid terug, alleen als de speler op dit moment leeft
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
-- Telt de kanten die nog in de ronde zitten (spelers, of teams als USE_TEAMS aan staat)
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
-- STATUS: Waiting en Intermission. Geeft false terug als spelers weggingen tijdens het aftellen.
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
-- STATUS: Starting, deel 1. Kopieer een willekeurige map (niet de vorige, als er keuze is).
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
-- Schudden, zodat spelers niet elke ronde op dezelfde spawn terechtkomen
for i = #points, 2, -1 do
local j = random:NextInteger(1, i)
points[i], points[j] = points[j], points[i]
end
return points
end
-- Hoe hoog de root part van een staand personage boven de vloer zit.
-- Formule uit de Roblox-documentatie over Humanoid.HipHeight (bij R6-rigs komt de beenhoogte erbij).
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
-- STATUS: Starting, deel 2. Klaarmaken, daarna alle levende spelers teleporteren.
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
-- Met streaming aan vragen we elke client de map te laden voordat het personage aankomt
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
-- Alleen wie nu leeft doet mee. De rest wacht op de volgende ronde.
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]
-- De pivot van een personage is zijn root part, dus we tillen hem tot stahoogte boven de part
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
-- STATUS: InRound. Eindigt als de tijd op is of er nog één kant over is.
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()
-- Een ronde die met één kant begon (alleen testen) eindigt alleen door de tijd of door doodgaan
if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
break
end
end
end
-- STATUS: Results. Iedereen die nog leeft wint.
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) -- we stoppen met ze volgen; ze blijven op de map tot het opruimen
end
setState("Results", message)
task.wait(RESULTS_SECONDS)
return winners
end
-- STATUS: Cleanup. Stuur de overlevenden terug naar de lobby en verwijder daarna de map.
local function cleanup(map: Model, survivors: { Player })
for _, player in survivors do
if player.Parent then -- nog op de 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
-- De loop: één doorgang is één ronde
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) -- nog geen maps: we proberen het zo opnieuw
end
end
end
Alles wat belangrijk is gebeurt hier, op de server: wie in de ronde zit, de timer, de winnaar en de Wins. Clients krijgen alleen drie attributen op ReplicatedStorage.RoundInfo (State, Status en TimeLeft) en een attribuut InRound op elke speler.
Hoe elke status werkt
Wachten en intermission
runIntermission houdt de loop eerst vast tot #Players:GetPlayers() bij MIN_PLAYERS komt. Daarna telt hij per seconde af met task.wait(1) en controleert bij elke tik het aantal spelers. Gaat er iemand weg en zit de server onder het minimum, dan geeft hij false terug en begint de hoofdloop opnieuw bij Waiting, zodat een ronde nooit met één persoon start.
Een map kiezen en laden
loadMap verzamelt alle Models in ServerStorage.Maps, laat de map van de vorige ronde weg als er keuze is en pakt er een met Random:NextInteger. Daarna kloont hij de map naar Workspace. Het origineel blijft onaangeroerd in ServerStorage, dus elke ronde begint met een verse kopie: alles wat spelers de vorige ronde kapotmaakten of verschoven, is weg.
In nieuwe places staat instance streaming aan: een client heeft alleen de parts in de buurt van zijn personage. Voor het teleporteren roept het script Player:RequestStreamAroundAsync aan voor elke speler, en dat vraagt de engine het gebied rond de map naar de client te sturen tijdens het "maak je klaar"-aftellen. Zonder dat kunnen spelers aankomen voordat de vloer geladen is en even bevriezen.
Spelers teleporteren met PivotTo
Na het aftellen maakt het script een lijst van deelnemers uit spelers van wie het personage bestaat, nog in de wereld is en een Humanoid heeft met meer dan 0 health en een root part. Deze controle gebeurt na het aftellen, dus wie tijdens het aftellen doodging of wegging, komt niet op de lijst.
Elke deelnemer wordt verplaatst met character:PivotTo(cframe). De documentatie van Roblox noemt PivotTo de belangrijkste manier om models vanuit een script te verplaatsen, en het verplaatst alle delen van het personage samen. HumanoidRootPart.Position zetten is niet hetzelfde: Roblox past de verbindingen zo aan dat alleen dat ene deel beweegt, en de rest van het lichaam kan achterblijven. De pivot van een personage is zijn root part, dus het doel is de CFrame van de spawnpart, opgetild met de halve hoogte van de part plus de hoogte waarop de root part boven de vloer staat. rootHeight berekent die met de formule uit de documentatie van Roblox over Humanoid.HipHeight: de halve hoogte van de root part plus HipHeight, plus de beenlengte bij R6-rigs. Zo blijven geschaalde en custom avatars niet in de part steken en vallen ze er niet van bovenaf op. De CFrame bevat ook de rotatie, dus spelers kijken dezelfde kant op als de spawnpart: draai de parts zo dat iedereen naar het midden van de map kijkt.
Zijn er meer spelers dan spawnparts, dan begint het script weer bij de eerste part en komen spelers op elkaar te staan, dus voeg minstens zoveel spawns toe als je maximum aantal spelers.
Gebruik je ook de snelheidscontrole uit de handleiding over sprinten, voeg dan player:SetAttribute("MovementCheckSkip", true) toe direct na character:PivotTo(...) in startRound, zodat de teleport niet als te hoge snelheid wordt gezien.
De rondetimer en de eindvoorwaarden
runRound tikt één keer per seconde. Bij elke tik werkt hij de status bij (hoeveel spelers er over zijn) en de resterende seconden, en telt daarna de levende kanten. De ronde eindigt op een van drie manieren:
- De tijd is op. De
for-loop komt bij 1 en stopt. - Er is nog één kant over. Een kant is een speler, of een team als
USE_TEAMSaan staat. De controle werkt alleen als de ronde met twee of meer kanten begon, dus een test in je eentje eindigt niet op hetzelfde moment dat hij begint. - Er is niemand meer. Iedereen ging dood of weg, en de ronde eindigt zonder winnaar.
Eén controle per seconde betekent dat de ronde tot een seconde na het laatste uitvallen kan doorlopen, en op een rondetimer merk je dat bijna niet.
Wins uitdelen en de uitslag tonen
De regel in dit script is simpel: iedereen die leeft op het moment dat de ronde eindigt, wint. Dat dekt de laatste overlevende speler, het laatste overlevende team en de modus "hou het vol tot de timer op is" met één regel logica. finishRound telt 1 op bij de Wins van elke winnaar, stopt met ze volgen en toont een bericht zoals "Alex wins!" gedurende RESULTS_SECONDS. Wil je dat er geen winnaar is als de tijd op is, sla dan awardWin over en verander het bericht als sidesLeft groter is dan 1. Blijf in elk geval de lijst teruggeven, want het opruimen gebruikt die om de overlevenden terug naar de lobby te brengen.
Opruimen
De overlevenden staan nog op de map, dus cleanup laat ze in de lobby respawnen met Player:LoadCharacterAsync(), dat de oude LoadCharacter vervangt, en verwijdert daarna de kopie van de map. Elke respawn loopt in een eigen task.spawn binnen een pcall, omdat de aanroep wacht tot het personage geladen is en kan mislukken als de speler precies op dat moment weggaat. Uitgevallen spelers hoeven niets: die zijn al vanzelf in de lobby gerespawnd.
Stap 3: Toon de timer en de status aan elke speler
De server publiceert drie attributen op ReplicatedStorage.RoundInfo: State (een vast woord zoals InRound, voor scripts), Status (tekst voor mensen) en TimeLeft (seconden). Attributen die een serverscript op een gerepliceerd object zet, komen vanzelf bij elke client aan, en een speler die midden in een ronde joint, krijgt meteen de huidige waarden. Daarom past dit beter bij een timer dan een remote: een RemoteEvent die verstuurd is voordat iemand joinde, komt nooit bij die speler aan.
- Voeg in Explorer een ScreenGui toe aan StarterGui en noem hem
RoundHud. Laat ResetOnSpawn aan staan (standaard). - Voeg een LocalScript toe aan
RoundHud, noem hetRoundHudClienten plak de code hieronder. Het maakt het label zelf, dus je hoeft verder niets te tekenen. - Druk op Play. Het label bovenaan het scherm toont de status en het aftellen in de vorm
m:ss.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local roundInfo = ReplicatedStorage:WaitForChild("RoundInfo")
local screenGui = script.Parent :: ScreenGui
-- Het label. Heb je een eigen TextLabel in RoundHud getekend, verwijder dan dit blok en gebruik:
-- 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 -- lange berichten lopen door naar een tweede regel
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()
Omdat ResetOnSpawn aan staat, geeft Roblox de speler bij elke spawn van zijn personage een verse kopie van RoundHud, ook bij het respawnen tijdens het opruimen. Het script leest dan opnieuw de huidige attributen, dus het label loopt nooit achter.
De client leest alleen. Niets wat een speler op zijn eigen scherm verandert, heeft invloed op de echte timer, omdat wijzigingen aan attributen vanuit een LocalScript op die ene client blijven. Voor een aftelling met tienden van seconden kan de server in plaats daarvan de eindtijd uit workspace:GetServerTimeNow() in een attribuut zetten, en trekt elke client daar elk frame zijn eigen workspace:GetServerTimeNow() van af.
Opent je game met een hoofdmenu, dan verschijnt RoundHud zodra de speler op Play drukt, omdat StarterGui pas naar de speler wordt gekopieerd nadat zijn personage spawnt. Spelers die nog in het menu zitten, hebben geen personage, dus die worden nooit naar een ronde geteleporteerd.
Spelers die midden in een ronde doodgaan, weggaan of joinen
Deze gevallen mis je makkelijk als je voor het eerst een rondescript schrijft. Wordt er een niet afgehandeld, dan zie je meestal een fout in Output of een ronde die nooit eindigt. Dit doet het script hierboven met elk ervan.
| Situatie | Wat er gebeurt | Waar in het script |
|---|---|---|
| Een speler gaat dood in de ronde (gedood, gereset, gevallen) | Hij wordt uit de ronde gehaald en respawnt in de lobby na Players.RespawnTime (standaard 5 seconden). | humanoid.Died roept eliminate aan |
| Het personage wordt verwijderd zonder dood te gaan | Net als bij doodgaan: de speler is uitgevallen. | player.CharacterRemoving roept eliminate aan |
| Een speler verlaat de server | Hij wordt eruit gehaald, zijn connecties worden losgekoppeld en de volgende tik telt de kanten opnieuw. | Players.PlayerRemoving roept eliminate aan |
| Een speler joint midden in een ronde | Hij spawnt in de lobby, ziet de live status en timer en doet mee aan de volgende ronde. | Deelnemers worden alleen in startRound gekozen |
| Een speler was dood toen de ronde startte | Hij wordt niet geteleporteerd en wacht in de lobby. | getLivingCharacter |
| Iedereen ging weg of dood | De ronde eindigt met "Nobody survived" en de loop begint opnieuw: Intermission als er nog genoeg spelers op de server zijn, anders Waiting. | sidesLeft == 0 in runRound |
eliminate is zo geschreven dat je hem veilig meerdere keren voor dezelfde speler kunt aanroepen. Een speler die doodging en respawnde, triggert zowel Died als CharacterRemoving, en iemand die weggaat kan alle drie de events triggeren; alleen de eerste aanroep doet iets.
Uitbreiden: teams, stemmen op een map en rondegebeurtenissen
Laatste overlevende team
Zet USE_TEAMS = true en voeg daarna objecten Team toe aan de service Teams in Explorer, elk met een eigen naam en TeamColor. Standaard zet Roblox elke speler die joint in het automatisch toegewezen team met de minste leden. Als spelers weggaan, verdeelt het de teams niet opnieuw, dus in lange sessies kunnen de teams ongelijk worden. Laat de SpawnLocation in de lobby op Neutral staan, zodat alle teams daar spawnen. De ronde eindigt dan als er alleen nog levende spelers in één team zijn, en de uitslag ziet eruit als "Red wins!".
Voor een "één tegen allen"-formaat (één jager, de rest overleeft) kies je in startRound één willekeurige deelnemer en zet je zijn Team voor het teleporteren op het jagersteam. Zet AutoAssignable uit voor het jagersteam, zodat nieuwe spelers er nooit in komen, en zet de jager in cleanup terug in het team van de overlevenden. Dan werken dezelfde eindvoorwaarden: de jager wint als alle overlevenden zijn uitgevallen, en de overlevenden winnen als ze het volhouden tot de timer op is, op voorwaarde dat je awardWin voor de jager overslaat als de tijd op is.
Spelers laten stemmen op een map
Voor stemmen moet de client met de server praten, en dus heb je een RemoteEvent nodig. Tijdens de intermission publiceert de server twee of drie mapnamen als attributen, elke client stuurt via de RemoteEvent de naam waarop hij klikte, en de server telt de stemmen voordat loadMap draait. De server moet elke stem controleren: dat het argument een string is, dat het een van de huidige opties is, dat de status Intermission is en dat elke speler één keer telt (bewaar de stemmen in een tabel met Player als sleutel, zodat een tweede stem de eerste vervangt, en leeg die in PlayerRemoving). De handleiding over RemoteEvent behandelt dit patroon van controles uitgebreid.
Een tool uitdelen aan het begin van de ronde
Andere scripts kunnen op de ronde reageren zonder RoundSystem aan te raken. Het rondescript zet bij elke speler het attribuut InRound als hij geteleporteerd wordt, en haalt het weg als de speler uitvalt. Dit script luistert ernaar en geeft elke speler een kopie van de Tool met de naam RoundTool die in ServerStorage ligt.
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
Er is geen code die de tool weer afpakt. Als een personage doodgaat, vervangt Roblox de Backpack door een verse, gevuld vanuit StarterPack, en LoadCharacterAsync leegt hem bij het opruimen voor de overlevenden, dus na de ronde is de tool al weg.
Wil je een wapen uitdelen, bouw dan een zwaard of een geweer met raycasts, bewaar het in ServerStorage in plaats van StarterPack en verander "RoundTool" in dit script in de naam ervan.
NPC's en andere objecten alleen tijdens de ronde
Alles wat alleen tijdens de ronde moet bestaan, kan in de model van de map zitten: vijanden, items om op te pakken, bewegende platforms. Scripts in een model in ServerStorage draaien niet; zodra de kopie in Workspace staat, starten ze, en map:Destroy() bij het opruimen verwijdert ze samen met al het andere. Wil je vijanden toevoegen die spelers achtervolgen, bouw er dan een met de handleiding over pathfinding voor NPC's en zet hem in de map. Voor een vlucht over de map aan het begin van elke ronde laat de handleiding over cutscenes zien hoe dit script via een BindableEvent een cutscene voor elke speler kan starten.
Er een module van maken
Om te beginnen heb je geen ModuleScript nodig. Eén Script is makkelijker te lezen zolang je de game bouwt. Splits het op als andere scripts functies van de ronde moeten aanroepen, of als je de instellingen naar één gedeeld ModuleScript wilt verplaatsen dat zowel de server als je UI met require kan laden. Tot die tijd werken het attribuut State op RoundInfo en het attribuut InRound op elke speler al als de openbare interface van het rondesysteem: elk script kan ernaar luisteren.
Veelvoorkomende fouten en oplossingen
Open het venster Output (via het menu Window in Studio of het tabblad Script) voordat je op Play drukt. De meeste problemen met een rondesysteem tonen daar een waarschuwing of fout met de naam van het script en het regelnummer.
Blijft hangen op "Waiting for players (1/2)"
Je test in je eentje en MIN_PLAYERS is 2. Zet het op 1 voor tests in je eentje, of test in de modus Server & Clients met 2 clients.
Infinite yield possible on 'ServerStorage:WaitForChild("Maps")'
De map ontbreekt, heeft een typfout in de naam of staat in de verkeerde service. Het moet een Folder zijn met precies de naam Maps, direct in ServerStorage. Dezelfde waarschuwing voor RoundInfo in het LocalScript betekent dat het script RoundSystem nooit zover kwam dat het die maakte: het staat uit, is met een fout gestopt of wacht nog op de map Maps.
Na het teleporteren vallen spelers door de map
De parts van de map zijn niet geanchord, dus de kopie valt uit elkaar zodra hij in Workspace staat. Selecteer de map, anchor de parts en controleer dat de spawnparts boven de vloer staan en er niet in zitten.
Uitgevallen spelers respawnen in de arena
Er zit een SpawnLocation in de map. Vervang die door een gewone Part in de map Spawns van die map.
De ronde eindigt niet als iedereen dood is
Controleer dat je schade de Humanoid echt doodt (health komt op 0) en spelers niet alleen verplaatst of anchort. Heb je de status Dead van de Humanoid uitgezet, dan gaat Died nooit af en moet de ronde doorlopen tot de timer op is.
De rondeloop stopt voorgoed na één fout
De loop draait in één thread, dus een fout in welke status dan ook beëindigt hem. Lees de fout in Output, verbeter de regel en test opnieuw. Een veelvoorkomende oorzaak: het script is zo aangepast dat het player.Character.Humanoid gebruikt zonder te controleren of het personage bestaat.
Maken met RoCode
Heb je geen zin om dit allemaal met de hand te bouwen, dan kan RoCode het doen in de place die je open hebt. Het is een AI-agent die werkt via een plugin voor Roblox Studio, dus scripts en parts verschijnen in je Explorer en niet in een chatvenster waaruit je ze zou moeten plakken.
Voeg een rondesysteem toe: een intermission van 20 seconden die 2 spelers nodig heeft, een willekeurige map uit ServerStorage.Maps, iedereen teleporteren naar de spawnparts van de map, rondes van 2 minuten waarin de laatste levende speler wint, voeg een Win toe aan leaderstats en toon de status en de timer bovenaan het scherm.
- Kan eerst je place bekijken met List Children, Search Game en Search Scripts, om je map Maps en je leaderstats-script te gebruiken in plaats van een tweede set toe te voegen
- Maakt het rondescript in ServerScriptService en het LocalScript voor de timer met Create Script en kan een arena uit zijn kant-en-klare bouwwerken neerzetten met Place Prefab als je nog geen map hebt
- Controleert de compilatie van elk script in Studio met Check Script voordat het klaar is. Dat vangt syntaxfouten, geen fouten in de logica van de ronde
- Na jouw playtest leest Check Output de regels van Server en Client uit de laatste playtest om een fout tijdens het uitvoeren te verbeteren
Met plugin 3.9 of nieuwer kan RoCode een korte playtest draaien en de fouten lezen, en met plugin 3.9.11 of nieuwer kan het één testpersonage besturen, maar met meerdere spelers test het niet, dus speel de rondes zelf door in de modus Server & Clients. Elke reeks wijzigingen is een ongedaan-maakpunt in Studio. Een rondeloop vormt de basis van veel games, en een hele Roblox-game maken met AI, systeem voor systeem begint vaak met zo'n loop. Hoe RoCode verbinding maakt met Studio.
Veelgestelde vragen
Hoe maak je een rondesysteem met teams in Roblox?
Voeg objecten Team toe aan de service Teams en zet USE_TEAMS = true in het rondescript. Roblox verdeelt spelers die joinen over het automatisch toegewezen team met de minste leden, en de ronde eindigt als er alleen nog levende spelers in één team zijn.
Hoe toon je een aftelling aan alle spelers?
Zet vanaf de server de resterende seconden als attribuut op een object in ReplicatedStorage en luister ernaar met GetAttributeChangedSignal in een LocalScript dat een TextLabel bijwerkt, zoals in stap 3. Spelers die later joinen, krijgen meteen de huidige waarde.
Wat gebruik je in een rondeloop: wait() of task.wait()?
Gebruik task.wait(). Roblox markeert de globale wait() als verouderd en vervangen door task.wait().
Hoe teleporteer je spelers voor elke ronde naar een andere place?
Dat is een ander hulpmiddel. Deze handleiding verplaatst personages binnen één server met PivotTo. Spelers naar een andere place van je experience sturen gaat via TeleportService, dat ze naar een andere server verplaatst. De handleiding over teleporteren bouwt portalen die dat doen, met nieuwe pogingen als de teleport mislukt.
Waarom bevriezen spelers even na het teleporteren?
Met instance streaming aan heeft de client de map nog niet ontvangen. De aanroep van RequestStreamAroundAsync in het script tijdens het "maak je klaar"-aftellen vraagt de engine hem vooraf te sturen; een langere GET_READY_SECONDS geeft trage verbindingen meer tijd.
Bronnen en verder lezen
- Roblox Creator Docs: Add rounds (in het Engels). de eigen teamloop voor rondes van Roblox in het lasertagvoorbeeld
- Roblox Creator Docs: PVInstance:PivotTo (in het Engels). models en personages vanuit een script verplaatsen
- Roblox Creator Docs: Player (in het Engels). LoadCharacterAsync, CharacterRemoving en RequestStreamAroundAsync
- Roblox Creator Docs: Properties and attributes (in het Engels). attributen zetten en wijzigingen volgen
- Roblox Creator Docs: Implement teams (in het Engels). teams toevoegen en automatisch toewijzen
- Roblox Creator Docs: Studio testing modes (in het Engels). testen met meerdere clients via Server & Clients
Hoe de code is gecontroleerd: elk script op deze pagina doorloopt een strikte Luau-typecontrole met de Roblox API-definities (luau-lsp, 20 november 2026). De typecontrole vangt fouten in API-namen en verkeerde types op, maar geen fouten in de gamelogica, dus test alles in Studio voordat je publiceert.