Kurz gesagt
Schreib ein einziges Server-Script in ServerScriptService, das eine feste Reihe von Zuständen durchläuft: Intermission (auf genug Spieler warten, dann herunterzählen), Map laden (eine zufällige Map aus ServerStorage in Workspace klonen), Teleport (jeden lebenden Charakter mit PivotTo auf einen Spawn-Part setzen), Runde (einen Timer laufen lassen, bis die Zeit abläuft oder nur noch ein Spieler oder Team übrig ist) und Aufräumen (Wins vergeben, Überlebende neu spawnen, die Map zerstören).
- Lass die Schleife nur auf dem Server laufen. Veröffentliche den Status und die restlichen Sekunden als Attribute an einem Folder in ReplicatedStorage und lass ein LocalScript sie anzeigen.
- Führ eine Tabelle, wer noch in der Runde ist. Entferne einen Spieler, wenn sein Humanoid stirbt, sein Charakter entfernt wird oder er das Spiel verlässt.
- Teleportiere nur Spieler, deren Charakter beim Rundenstart lebt. Wer später beitritt, wartet in der Lobby auf die nächste Runde.
Auf dieser Seite
So funktioniert ein Rundensystem
Ein Rundensystem ist ein Zustandsautomat (State Machine). Der Server ist zu jedem Zeitpunkt in genau einem Zustand, jeder Zustand hat eine Aufgabe, und eine Bedingung führt zum nächsten. So geschrieben bleibt die Logik an einer Stelle, und du vermeidest den klassischen Fehler, dass eine Timer-Schleife und eine Runden-Schleife beide versuchen, dieselbe Runde zu beenden.
| Zustand | Was der Server macht | Geht weiter, wenn |
|---|---|---|
| Waiting | Zeigt "Waiting for players (1/2)" | Genug Spieler auf dem Server sind |
| Intermission | Zählt herunter, während alle in der Lobby sind | Der Countdown endet (oder zurück zu Waiting, wenn Spieler gehen) |
| Starting | Kopiert eine zufällige Map in Workspace, zeigt ihren Namen und bittet die Clients, sie zu laden | Ein kurzer Countdown zum Bereitmachen endet |
| InRound | Teleportiert lebende Spieler hinein, lässt den Timer laufen und nimmt Spieler raus, die sterben oder gehen | Die Zeit abläuft oder nur noch ein Spieler oder Team übrig ist |
| Results | Gibt jedem, der noch lebt, einen Win und zeigt, wer gewonnen hat | Ein paar Sekunden vergangen sind |
| Cleanup | Spawnt Überlebende in der Lobby neu und zerstört die Map | Sofort, dann beginnt die Schleife von vorn |
Der Server besitzt jeden Zustand. Clients zeigen nur an, was der Server ihnen sagt. Ein Countdown in einem LocalScript weicht vom echten ab, stimmt für Spieler nicht, die später beitreten, und lässt sich von einem Exploiter ändern. Wenn die Trennung zwischen Server und Client neu für dich ist, lies zuerst Script vs LocalScript vs ModuleScript (auf Englisch).
Schritt 1: Lobby, Maps und den Wins-Wert bauen
- Bau in Workspace eine Lobby mit einer
SpawnLocation. Achte darauf, dass ihre Eigenschaft Neutral angehakt ist, damit jeder Spieler hier spawnt, hier wartet und hierher zurückkommt, nachdem er ausgeschieden ist. - Füge in ServerStorage einen
FoldernamensMapsein. Objekte in ServerStorage werden nie an Spieler geschickt, also kosten ungenutzte Maps sie nichts. - Bau jede Map als
ModelinMaps, mit verankerten Parts (Anchored). Bau sie weit weg von der Lobby (ein paar hundert Studs reichen), weil die Kopie genau dort erscheint, wo du sie gebaut hast, und ausgeschiedene Spieler nicht zurück hineinlaufen sollen. - Füge in jede Map einen
FoldernamensSpawnsein, mit einem verankertenPartfür jeden Spieler, den du erwartest. Setz ihre Transparency auf 1 und schalte CanCollide aus, damit niemand sie sieht oder darüber stolpert.
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
Das Rundenskript addiert 1 zu einem IntValue namens Wins im Ordner leaderstats des Spielers. Wenn dein Spiel noch keine leaderstats hat, füge dieses kurze Skript hinzu. Wenn du schon eins hast, zum Beispiel die Version mit Speichern aus dem Leaderboard-Guide, lass es weg: Zwei Skripte, die leaderstats erstellen, geben jedem Spieler zwei Ordner.
local Players = game:GetService("Players")
local function setupLeaderstats(player: Player)
local leaderstats = Instance.new("Folder")
leaderstats.Name = "leaderstats" -- muss genau so heißen, alles kleingeschrieben
local wins = Instance.new("IntValue")
wins.Name = "Wins"
wins.Value = 0
wins.Parent = leaderstats
leaderstats.Parent = player
end
Players.PlayerAdded:Connect(setupLeaderstats)
-- In Studio kannst du beitreten, bevor dieses Skript läuft, also alle einrichten, die schon da sind
for _, player in Players:GetPlayers() do
setupLeaderstats(player)
end
Diese Wins werden zurückgesetzt, wenn der Spieler das Spiel verlässt. Um sie zwischen Sitzungen zu behalten, nimm die DataStore-Version aus dem Leaderboard-Guide.
Schritt 2: Das Rundenskript hinzufügen
Füge ein Script in ServerScriptService ein, nenn es RoundSystem und füge den Code unten ein. Die Einstellungen oben sind die einzigen Zeilen, die du ändern solltest. Jeder Zustand ist eine eigene Funktion, und die Schleife ganz unten führt sie der Reihe nach aus, für immer.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
-- Einstellungen
local MIN_PLAYERS = 2 -- auf 1 setzen, solange du allein testest
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: Die Runde endet, wenn nur noch ein Team Spieler übrig hat
local mapsFolder = ServerStorage:WaitForChild("Maps")
local random = Random.new()
-- Was der Bildschirm jedes Spielers anzeigt, steht in Attributen an diesem Ordner.
-- Attribute, die der Server setzt, werden an alle Clients repliziert, auch an Spieler, die später beitreten.
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
-- Wer noch in der aktuellen Runde ist, und die Verbindungen, die jeden davon beobachten
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)
-- Gibt Charakter und Humanoid nur zurück, wenn der Spieler gerade lebt
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
-- Zählt die Seiten, die noch in der Runde sind (Spieler, oder Teams, wenn USE_TEAMS an ist)
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
-- ZUSTAND: Waiting und Intermission. Gibt false zurück, wenn während des Countdowns Spieler gegangen sind.
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
-- ZUSTAND: Starting, Teil 1. Eine zufällige Map kopieren (nicht die letzte, wenn es eine Auswahl gibt).
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
-- Mischen, damit Spieler nicht jede Runde auf demselben Spawn landen
for i = #points, 2, -1 do
local j = random:NextInteger(1, i)
points[i], points[j] = points[j], points[i]
end
return points
end
-- Wie hoch der Root-Part eines stehenden Charakters über dem Boden sitzt.
-- Die Formel stammt aus der Roblox-Referenz zu Humanoid.HipHeight (bei R6-Rigs kommt die Beinlänge dazu).
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
-- ZUSTAND: Starting, Teil 2. Bereitmachen, dann alle teleportieren, die leben.
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
-- Mit Streaming jeden Client bitten, die Map zu laden, bevor sein Charakter ankommt
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
-- Nur Spieler, die gerade leben, machen mit. Alle anderen warten auf die nächste Runde.
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]
-- Der Pivot eines Charakters ist sein Root-Part, also auf Standhöhe über den Part anheben
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
-- ZUSTAND: InRound. Endet, wenn die Zeit abläuft oder nur noch eine Seite übrig ist.
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()
-- Eine Runde, die mit einer Seite begann (ein Solotest), endet nur durch Zeit oder Tod
if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
break
end
end
end
-- ZUSTAND: Results. Alle, die noch leben, gewinnen.
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) -- nicht mehr beobachten; sie bleiben bis zum Aufräumen auf der Map
end
setState("Results", message)
task.wait(RESULTS_SECONDS)
return winners
end
-- ZUSTAND: Cleanup. Überlebende zurück in die Lobby schicken, dann die Map entfernen.
local function cleanup(map: Model, survivors: { Player })
for _, player in survivors do
if player.Parent then -- noch auf dem 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
-- Die Schleife: ein Durchlauf ist eine Runde
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) -- noch keine Maps: gleich noch mal versuchen
end
end
end
Alles, was zählt, passiert hier auf dem Server: wer in der Runde ist, der Timer, der Sieger und die Wins. Clients bekommen nur drei Attribute an ReplicatedStorage.RoundInfo (State, Status und TimeLeft) und ein Attribut InRound an jedem Spieler.
So funktioniert jeder Zustand
Warten und Intermission
runIntermission hält die Schleife zuerst an, bis #Players:GetPlayers() den Wert MIN_PLAYERS erreicht. Dann zählt es mit task.wait(1) Sekunde für Sekunde herunter und prüft bei jedem Tick die Spielerzahl. Geht jemand und der Server fällt unter das Minimum, gibt es false zurück, und die Hauptschleife beginnt wieder bei Waiting. So startet nie eine Runde mit nur einer Person.
Eine Map auswählen und laden
loadMap sammelt jedes Model in ServerStorage.Maps, lässt die Map der letzten Runde weg, wenn es eine andere zur Auswahl gibt, und wählt eine mit Random:NextInteger. Dann klont es die Map in Workspace. Das Original bleibt unberührt in ServerStorage, also beginnt jede Runde mit einer frischen Kopie: Alles, was Spieler in der letzten Runde kaputt gemacht oder verschoben haben, ist weg.
In neuen Places ist Instance Streaming eingeschaltet, das heißt, ein Client hat nur die Parts in der Nähe seines Charakters. Vor dem Teleport ruft das Skript für jeden Spieler Player:RequestStreamAroundAsync auf. Das bittet die Engine, diesem Client während des Countdowns zum Bereitmachen den Bereich um die Map zu schicken. Ohne das können Spieler ankommen, bevor der Boden geladen ist, und kurz hängen bleiben.
Spieler mit PivotTo teleportieren
Nach dem Countdown baut das Skript die Liste der Teilnehmer aus Spielern, deren Charakter existiert, noch in der Welt ist und einen Humanoid mit mehr als 0 Leben und einen Root-Part hat. Diese Prüfung passiert nach dem Countdown, also ist niemand dabei, der währenddessen gestorben ist oder gegangen ist.
Jeder Teilnehmer wird mit character:PivotTo(cframe) bewegt. Die Roblox-Referenz nennt PivotTo den wichtigsten Weg, Models per Skript zu bewegen, und es bewegt alle Parts des Charakters zusammen. HumanoidRootPart.Position zu setzen ist nicht dasselbe: Roblox passt dabei die Gelenke so an, dass sich nur dieser eine Part bewegt, was den Rest des Körpers zurücklassen kann. Der Pivot eines Charakters ist sein Root-Part, also ist das Ziel die CFrame des Spawn-Parts, angehoben um die halbe Höhe des Parts plus die Höhe, in der der Root-Part über dem Boden steht. rootHeight berechnet das mit der Formel aus der Roblox-Referenz zu Humanoid.HipHeight: die halbe Höhe des Root-Parts plus HipHeight, plus die Beinlänge bei R6-Rigs. So landen skalierte und eigene Avatare weder im Part noch fallen sie darauf. Weil die CFrame auch die Drehung enthält, schauen Spieler in die Richtung, in die der Spawn-Part zeigt, also dreh die Parts so, dass alle zur Mitte der Map schauen.
Gibt es mehr Spieler als Spawn-Parts, fängt das Skript wieder beim ersten Part an, und Spieler landen übereinander. Füge also mindestens so viele Spawns hinzu, wie du höchstens Spieler hast.
Wenn du auch die Geschwindigkeitsprüfung aus dem Sprint-Guide benutzt, füge in startRound direkt nach character:PivotTo(...) die Zeile player:SetAttribute("MovementCheckSkip", true) ein, damit der Teleport nicht als zu schnell gemeldet wird.
Der Rundentimer und die Endbedingungen
runRound tickt einmal pro Sekunde. Bei jedem Tick aktualisiert es den Status (wie viele Spieler übrig sind) und die restlichen Sekunden und zählt dann die Seiten, die noch leben. Die Runde endet auf eine von drei Arten:
- Die Zeit läuft ab. Die
for-Schleife erreicht 1 und ist fertig. - Eine Seite ist übrig. Eine Seite ist ein Spieler, oder ein Team, wenn
USE_TEAMSan ist. Die Prüfung gilt nur, wenn die Runde mit zwei oder mehr Seiten begann, damit ein Solotest nicht im selben Moment endet, in dem er anfängt. - Niemand ist übrig. Alle sind gestorben oder gegangen, also endet die Runde ohne Sieger.
Weil nur einmal pro Sekunde geprüft wird, kann eine Runde bis zu einer Sekunde nach dem letzten Ausscheiden weiterlaufen. Bei einem Rundentimer fällt das kaum auf.
Wins vergeben und das Ergebnis zeigen
Die Regel in diesem Skript ist einfach: Wer am Ende der Runde noch lebt, gewinnt. Das deckt den letzten Spieler, das letzte Team und "überleb, bis der Timer abläuft" mit einer einzigen Logik ab. finishRound addiert 1 zu den Wins jedes Siegers, beobachtet ihn nicht mehr und zeigt für RESULTS_SECONDS eine Nachricht wie "Alex wins!". Wenn eine abgelaufene Zeit keinen Sieger haben soll, lass awardWin weg und ändere die Nachricht, wenn sidesLeft größer als 1 ist. Gib die Liste trotzdem zurück, weil das Aufräumen sie braucht, um Überlebende in die Lobby zurückzubringen.
Aufräumen
Überlebende stehen noch auf der Map, also spawnt cleanup sie mit Player:LoadCharacterAsync() in der Lobby neu, das das ältere LoadCharacter ersetzt, und zerstört dann die Kopie der Map. Jeder Respawn läuft in seinem eigenen task.spawn in einem pcall, weil der Aufruf wartet, bis der Charakter geladen ist, und fehlschlagen kann, wenn der Spieler genau dann geht. Ausgeschiedene Spieler brauchen nichts: Sie sind schon von selbst in der Lobby neu gespawnt.
Schritt 3: Timer und Status für jeden Spieler anzeigen
Der Server veröffentlicht drei Attribute an ReplicatedStorage.RoundInfo: State (ein festes Wort wie InRound, für Skripte), Status (Text für Menschen) und TimeLeft (Sekunden). Attribute, die ein Server-Skript an einem replizierten Objekt setzt, erreichen automatisch jeden Client, und ein Spieler, der mitten in der Runde beitritt, bekommt sofort die aktuellen Werte. Deshalb passt das für einen Timer besser als ein RemoteEvent: Ein RemoteEvent, das gefeuert wurde, bevor jemand beigetreten ist, erreicht ihn nie.
- Füge im Explorer eine ScreenGui in StarterGui ein und nenn sie
RoundHud. Lass ResetOnSpawn an (der Standard). - Füge ein LocalScript in
RoundHudein, nenn esRoundHudClientund füge den Code unten ein. Es baut das Label selbst, also musst du nichts weiter zeichnen. - Drück auf Play. Das Label oben auf dem Bildschirm zeigt den Status und einen Countdown im Format
m:ss.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local roundInfo = ReplicatedStorage:WaitForChild("RoundInfo")
local screenGui = script.Parent :: ScreenGui
-- Das Label. Wenn du ein eigenes TextLabel in RoundHud gestaltet hast, lösch diesen Block und nimm:
-- 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 -- längere Nachrichten nutzen eine zweite Zeile
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()
Weil ResetOnSpawn an ist, gibt Roblox dem Spieler bei jedem Spawn seines Charakters eine frische Kopie von RoundHud, auch beim Respawn im Aufräumen. Das Skript liest dann die aktuellen Attribute neu, also ist das Label nie veraltet.
Der Client liest nur. Nichts, was ein Spieler auf seinem eigenen Bildschirm ändert, beeinflusst den echten Timer, weil Attributänderungen durch ein LocalScript auf diesem einen Client bleiben. Für einen Countdown mit Zehntelsekunden kann der Server stattdessen eine Endzeit aus workspace:GetServerTimeNow() in einem Attribut speichern, und jeder Client zieht in jedem Frame sein eigenes workspace:GetServerTimeNow() davon ab.
Wenn dein Spiel mit einem Hauptmenü startet, erscheint RoundHud, wenn der Spieler auf Play drückt, weil StarterGui erst zu einem Spieler kopiert wird, wenn sein Charakter spawnt. Spieler, die noch im Menü sind, haben keinen Charakter, also werden sie nie in eine Runde teleportiert.
Spieler, die mitten in der Runde sterben, gehen oder beitreten
Diese Fälle übersieht man leicht, wenn man zum ersten Mal ein Rundenskript schreibt. Wird einer nicht behandelt, siehst du meistens einen Fehler im Output oder eine Runde, die nie endet. So geht das Skript oben mit jedem um.
| Situation | Was passiert | Wo im Skript |
|---|---|---|
| Ein Spieler stirbt in der Runde (getötet, Reset, heruntergefallen) | Er fliegt aus der Runde und spawnt nach Players.RespawnTime (standardmäßig 5 Sekunden) in der Lobby neu. | humanoid.Died ruft eliminate auf |
| Ein Charakter wird entfernt, ohne zu sterben | Wie ein Tod: Er ist raus. | player.CharacterRemoving ruft eliminate auf |
| Ein Spieler verlässt den Server | Er wird entfernt, seine Verbindungen werden getrennt, und der nächste Tick zählt die Seiten neu. | Players.PlayerRemoving ruft eliminate auf |
| Ein Spieler tritt mitten in der Runde bei | Er spawnt in der Lobby, sieht den aktuellen Status und Timer und spielt in der nächsten Runde mit. | Teilnehmer werden nur in startRound ausgewählt |
| Ein Spieler war beim Rundenstart tot | Er wird nicht teleportiert und wartet in der Lobby. | getLivingCharacter |
| Alle gehen oder sterben | Die Runde endet mit "Nobody survived", und die Schleife beginnt von vorn: bei Intermission, wenn noch genug Spieler auf dem Server sind, sonst bei Waiting. | sidesLeft == 0 in runRound |
eliminate ist so geschrieben, dass man es für denselben Spieler mehrmals aufrufen kann. Ein Spieler, der stirbt und dann neu spawnt, feuert sowohl Died als auch CharacterRemoving, und einer, der geht, kann alle drei Events feuern; nur der erste Aufruf bewirkt etwas.
Erweitern: Teams, Map-Abstimmung und Runden-Events
Letztes Team gewinnt
Setz USE_TEAMS = true und füge dann im Explorer unter dem Service Teams Team-Objekte hinzu, jedes mit eigenem Namen und eigener TeamColor. Standardmäßig setzt Roblox jeden neuen Spieler in das automatisch zuweisbare Team mit den wenigsten Mitgliedern. Es gleicht nicht neu aus, wenn Spieler gehen, also können in langen Sitzungen ungleiche Teams entstehen. Lass die SpawnLocation der Lobby Neutral, damit jedes Team dort spawnt. Die Runde endet dann, wenn nur noch ein Team lebende Spieler hat, und das Ergebnis lautet "Red wins!".
Für ein Format einer gegen viele (ein Jäger, alle anderen überleben) wählst du in startRound vor dem Teleport einen zufälligen Teilnehmer und setzt sein Team auf ein Jäger-Team. Entferne beim Jäger-Team den Haken bei AutoAssignable, damit neue Spieler nie hineinkommen, und setz den Jäger in cleanup zurück ins Team der Überlebenden. Dann funktionieren dieselben Endbedingungen: Der Jäger gewinnt, wenn alle Überlebenden raus sind, und die Überlebenden gewinnen, wenn sie bis zum Ablauf des Timers durchhalten, solange du bei abgelaufener Zeit das awardWin des Jägers weglässt.
Spieler über die Map abstimmen lassen
Für eine Abstimmung muss der Client mit dem Server reden, und dafür brauchst du ein RemoteEvent. Während der Intermission veröffentlicht der Server zwei oder drei Map-Namen als Attribute, jeder Client feuert das RemoteEvent mit dem Namen, den er angeklickt hat, und der Server zählt die Stimmen, bevor loadMap läuft. Der Server muss jede Stimme prüfen: dass das Argument ein String ist, dass es eine der aktuellen Optionen ist, dass der Zustand Intermission ist und dass jeder Spieler einmal zählt (speichere die Stimmen in einer Tabelle mit dem Player als Schlüssel, damit eine zweite Stimme die erste ersetzt, und leere sie bei PlayerRemoving). Der Guide zu RemoteEvents erklärt dieses Prüfmuster ausführlich.
Spielern zum Rundenstart ein Tool geben
Andere Skripte können auf die Runde reagieren, ohne RoundSystem anzufassen. Das Rundenskript setzt an jedem Spieler ein Attribut InRound, wenn er hineinteleportiert wird, und löscht es, wenn er ausscheidet. Dieses Skript hört darauf und gibt jedem Spieler eine Kopie eines Tools namens RoundTool, das in ServerStorage liegt.
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
Es gibt keinen Code, der das Tool wieder wegnimmt. Wenn ein Charakter stirbt, ersetzt Roblox den Backpack durch einen frischen, der aus StarterPack gefüllt wird, und LoadCharacterAsync beim Aufräumen leert ihn für Überlebende, also ist das Tool weg, wenn die Runde vorbei ist.
Als Waffe zum Verteilen baust du das Schwert oder die Raycast-Waffe (auf Englisch), legst sie statt in StarterPack in ServerStorage und änderst "RoundTool" in diesem Skript auf ihren Namen.
NPCs und andere Objekte nur für die Runde
Alles, was nur während einer Runde existieren soll, kann im Map-Model liegen: Gegner, Pickups, bewegliche Plattformen. Skripte in einem Model in ServerStorage laufen nicht; sobald die Kopie in Workspace ist, starten sie, und map:Destroy() beim Aufräumen entfernt sie zusammen mit allem anderen. Für Gegner, die Spieler verfolgen, bau einen mit dem Guide zu NPC-Pathfinding und leg ihn in eine Map. Für einen Flug über die Map zu Beginn jeder Runde zeigt der Cutscene-Guide, wie dieses Skript über ein BindableEvent für jeden Spieler eine Cutscene startet.
Ein Modul daraus machen
Für den Anfang brauchst du kein ModuleScript. Ein einzelnes Script ist leichter zu lesen, solange du das Spiel baust. Teil es auf, wenn andere Skripte Rundenfunktionen aufrufen müssen oder wenn du die Einstellungen in einem gemeinsamen ModuleScript haben willst, das sowohl der Server als auch dein UI per require laden kann. Bis dahin sind das Attribut State an RoundInfo und das Attribut InRound an jedem Spieler schon die öffentliche Schnittstelle des Rundensystems: Jedes Skript kann auf sie hören.
Häufige Fehler und Lösungen
Öffne das Output-Fenster (über das Menü Window oder den Tab Script in Studio), bevor du auf Play drückst. Die meisten Probleme mit Rundensystemen geben dort eine Warnung oder einen Fehler aus, mit dem Namen des Skripts und der Zeilennummer.
Hängt bei "Waiting for players (1/2)" fest
Du testest allein, und MIN_PLAYERS ist 2. Setz den Wert für Solotests auf 1 oder teste mit Server & Clients und 2 Clients.
Infinite yield possible on 'ServerStorage:WaitForChild("Maps")'
Der Ordner fehlt, ist falsch geschrieben oder liegt im falschen Service. Es muss ein Folder namens genau Maps direkt in ServerStorage sein. Dieselbe Warnung für RoundInfo in einem LocalScript bedeutet, dass das Skript RoundSystem nie so weit gekommen ist, ihn zu erstellen: Es ist deaktiviert, hatte einen Fehler oder wartet noch auf den Ordner Maps.
Spieler fallen nach dem Teleport durch die Map
Die Parts der Map sind nicht verankert, also fällt die Kopie auseinander, sobald sie in Workspace ist. Wähl die Map aus, verankere ihre Parts und prüf, dass die Spawn-Parts über dem Boden sind, nicht darin.
Ausgeschiedene Spieler spawnen in der Arena neu
In einer Map liegt eine SpawnLocation. Ersetz sie durch einen einfachen Part im Spawns-Ordner der Map.
Die Runde endet nie, nachdem alle gestorben sind
Prüf, ob dein Schaden den Humanoid wirklich tötet (Health erreicht 0), statt Spieler nur zu bewegen oder zu verankern. Wenn du den Humanoid-Zustand Dead deaktiviert hast, feuert Died nie, und die Runde muss bis zum Ablauf des Timers laufen.
Die Rundenschleife stoppt nach einem Fehler für immer
Die Schleife läuft in einem einzigen Thread, also beendet ein Fehler in irgendeinem Zustand sie. Lies den Fehler im Output, korrigiere die Zeile und teste noch mal. Eine häufige Ursache ist, das Skript so zu ändern, dass es player.Character.Humanoid nutzt, ohne zu prüfen, ob der Charakter existiert.
Mit RoCode bauen
Wenn du das lieber nicht von Hand zusammenbauen willst, kann RoCode es in dem Spiel bauen, das du offen hast. RoCode ist ein KI-Agent, der über ein Roblox-Studio-Plugin arbeitet, also erscheinen die Skripte und Parts in deinem Explorer und nicht in einem Chatfenster, aus dem du sie einfügen musst. Prompts kannst du auf Deutsch schreiben.
Füge ein Rundensystem hinzu: eine Intermission von 20 Sekunden, die 2 Spieler braucht, eine zufällige Map aus ServerStorage.Maps, alle auf die Spawn-Parts der Map teleportieren, Runden von 2 Minuten, in denen der letzte lebende Spieler gewinnt, einen Win in leaderstats addieren, und Status und Timer oben auf dem Bildschirm anzeigen.
- Kann dein Spiel zuerst mit List Children, Search Game und Search Scripts durchsehen, damit es deinen vorhandenen Maps-Ordner und dein leaderstats-Skript nutzt, statt einen zweiten Satz hinzuzufügen
- Erstellt das Rundenskript in ServerScriptService und das Timer-LocalScript mit Create Script und kann mit Place Prefab eine Arena aus seinen fertigen Strukturen setzen, wenn du noch keine Map hast
- Prüft jedes Skript in Studio mit Check Script auf Kompilierfehler, bevor es fertig ist. Das findet Syntaxfehler, keine Fehler in der Rundenlogik
- Nachdem du einen Playtest gemacht hast, liest Check Output die Server- und Client-Zeilen deines letzten Playtests, damit es einen Laufzeitfehler beheben kann
Mit Plugin 3.9 oder neuer kann RoCode einen kurzen Playtest machen und die Fehler lesen, und mit Plugin 3.9.11 oder neuer kann es einen Test-Charakter steuern, aber es testet nicht mit mehreren Spielern, also spielst du die Runden selbst mit Server & Clients. Jede Änderungsrunde ist in Studio ein Undo-Punkt. Eine Rundenschleife ist der Kern vieler Spiele, und ein ganzes Roblox-Spiel mit KI bauen, System für System beginnt oft mit einer wie dieser. Wie sich RoCode mit Studio verbindet.
Häufige Fragen
Wie mache ich ein Rundensystem mit Teams?
Füge unter dem Service Teams Team-Objekte hinzu und setz im Rundenskript USE_TEAMS = true. Roblox setzt neue Spieler in das automatisch zuweisbare Team mit den wenigsten Mitgliedern, und die Runde endet, wenn nur noch ein Team lebende Spieler hat.
Wie zeige ich jedem Spieler einen Countdown?
Setz die restlichen Sekunden vom Server aus als Attribut an einem Objekt in ReplicatedStorage und hör in einem LocalScript mit GetAttributeChangedSignal darauf, das ein TextLabel aktualisiert, wie in Schritt 3. Spieler, die später beitreten, bekommen sofort den aktuellen Wert.
Soll ich in einer Rundenschleife wait() oder task.wait() benutzen?
Nimm task.wait(). Roblox führt das globale wait() als veraltet und abgelöst durch task.wait().
Wie teleportiere ich Spieler für jede Runde an einen anderen Place?
Das ist ein anderes Werkzeug. Dieser Guide bewegt Charaktere innerhalb eines Servers mit PivotTo. Spieler an einen anderen Place deines Erlebnisses zu schicken, geht mit TeleportService, das sie auf einen anderen Server bringt. Der Teleporter-Guide baut Portale, die das machen, mit Wiederholungen, wenn ein Teleport fehlschlägt.
Warum frieren meine Spieler nach dem Teleport kurz ein?
Mit Instance Streaming hat der Client die Map noch nicht bekommen. Der Aufruf von RequestStreamAroundAsync im Skript während des Countdowns zum Bereitmachen bittet die Engine, sie früher zu schicken; ein längeres GET_READY_SECONDS gibt langsamen Verbindungen mehr Zeit.
Quellen und weiterführende Links
- Roblox Creator Docs: Add rounds (auf Englisch). die eigene Rundenschleife von Roblox mit Teams im Laser-Tag-Beispiel
- Roblox Creator Docs: PVInstance:PivotTo (auf Englisch). Models und Charaktere per Skript bewegen
- Roblox Creator Docs: Player (auf Englisch). LoadCharacterAsync, CharacterRemoving und RequestStreamAroundAsync
- Roblox Creator Docs: Properties and attributes (auf Englisch). Attribute setzen und Änderungen erkennen
- Roblox Creator Docs: Implement teams (auf Englisch). Teams hinzufügen und automatische Zuweisung
- Roblox Creator Docs: Studio testing modes (auf Englisch). der Test mit mehreren Clients über Server & Clients
So wurde der Code geprüft: Jedes Skript auf dieser Seite besteht die strikte Typprüfung von Luau mit den Roblox API-Definitionen (luau-lsp, 14. November 2026). Eine Typprüfung findet falsch geschriebene APIs und falsche Typen, aber keine Fehler in der Spiellogik. Teste also in Studio, bevor du veröffentlichst.