Tutorial · Spielsysteme

Ein Rundensystem in Roblox Studio erstellen

Die meisten rundenbasierten Roblox-Spiele laufen nach derselben Schleife: auf Spieler warten, herunterzählen, eine Map laden, alle hineinteleportieren, einen Timer laufen lassen, einen Sieger küren und aufräumen. Dieser Guide baut diese Schleife als ein einziges, gut lesbares Server-Skript, fügt einen Timer hinzu, den jeder Spieler sieht, und behandelt die Fälle, an denen kopierte Skripte scheitern: Spieler, die mitten in einer Runde sterben, gehen oder beitreten.

Aktualisiert am 14. November 202615 Min. LesezeitGeschrieben von

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
  1. So funktioniert es
  2. 1. Lobby und Maps
  3. 2. Rundenskript
  4. Die Zustände
  5. 3. Timer-UI
  6. Spieler mitten in der Runde
  7. Erweitern
  8. Häufige Fehler
  9. Mit RoCode
  10. Häufige Fragen
  11. Quellen und weiterführende Links

So funktioniert ein Rundensystem

IllustrationDie fertigen Rundenskripte in einem laufenden Spiel, beschleunigt.

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.

Die Zustände der Rundenschleife in diesem Guide
ZustandWas der Server machtGeht weiter, wenn
WaitingZeigt "Waiting for players (1/2)"Genug Spieler auf dem Server sind
IntermissionZählt herunter, während alle in der Lobby sindDer Countdown endet (oder zurück zu Waiting, wenn Spieler gehen)
StartingKopiert eine zufällige Map in Workspace, zeigt ihren Namen und bittet die Clients, sie zu ladenEin kurzer Countdown zum Bereitmachen endet
InRoundTeleportiert lebende Spieler hinein, lässt den Timer laufen und nimmt Spieler raus, die sterben oder gehenDie Zeit abläuft oder nur noch ein Spieler oder Team übrig ist
ResultsGibt jedem, der noch lebt, einen Win und zeigt, wer gewonnen hatEin paar Sekunden vergangen sind
CleanupSpawnt Überlebende in der Lobby neu und zerstört die MapSofort, 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

  1. 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.
  2. Füge in ServerStorage einen Folder namens Maps ein. Objekte in ServerStorage werden nie an Spieler geschickt, also kosten ungenutzte Maps sie nichts.
  3. Bau jede Map als Model in Maps, 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.
  4. Füge in jede Map einen Folder namens Spawns ein, mit einem verankerten Part für jeden Spieler, den du erwartest. Setz ihre Transparency auf 1 und schalte CanCollide aus, damit niemand sie sieht oder darüber stolpert.
Der Explorer nach diesem Guide
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.

Script in ServerScriptService namens Leaderstats
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.

Script in ServerScriptService namens RoundSystem
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_TEAMS an 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.

  1. Füge im Explorer eine ScreenGui in StarterGui ein und nenn sie RoundHud. Lass ResetOnSpawn an (der Standard).
  2. Füge ein LocalScript in RoundHud ein, nenn es RoundHudClient und füge den Code unten ein. Es baut das Label selbst, also musst du nichts weiter zeichnen.
  3. Drück auf Play. Das Label oben auf dem Bildschirm zeigt den Status und einen Countdown im Format m:ss.
LocalScript in der ScreenGui RoundHud in StarterGui namens RoundHudClient
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.

Sonderfälle und wie das Rundenskript sie behandelt
SituationWas passiertWo 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 sterbenWie ein Tod: Er ist raus.player.CharacterRemoving ruft eliminate auf
Ein Spieler verlässt den ServerEr 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 beiEr 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 totEr wird nicht teleportiert und wartet in der Lobby.getLivingCharacter
Alle gehen oder sterbenDie 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.

Script in ServerScriptService namens GiveRoundTool
local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")

local toolTemplate = ServerStorage:WaitForChild("RoundTool") :: Tool

local function watchPlayer(player: Player)
	player:GetAttributeChangedSignal("InRound"):Connect(function()
		if player:GetAttribute("InRound") ~= true then
			return
		end
		local backpack = player:FindFirstChildOfClass("Backpack")
		if backpack then
			toolTemplate:Clone().Parent = backpack
		end
	end)
end

Players.PlayerAdded:Connect(watchPlayer)
for _, player in Players:GetPlayers() do
	watchPlayer(player)
end

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.

Du schreibst

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.

RoCode macht
  • 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

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.

Probier RoCode in deinem eigenen Spiel aus.

Jeden Tag kostenlose Credits, ohne Karte. Installiere das Plugin, beschreibe das Feature und prüfe, was in Studio ankommt.