Guide · Spelsystem

Så gör du ett rundsystem i Roblox Studio

De flesta rundbaserade spel i Roblox kör samma cykel: väntar på spelare, räknar ner till noll, laddar en karta, teleporterar dit alla, kör en timer, utser en vinnare och städar upp. I den här guiden bygger vi den cykeln som ett enda tydligt serverskript, lägger till en timer som varje spelare ser och går igenom fallen där kopierade skript går sönder: spelare som dör, lämnar eller går med mitt i en runda.

Uppdaterad 20 november 202615 min läsningSkriven av

I korthet

Skriv ett enda Script på servern i ServerScriptService som går runt genom en fast uppsättning tillstånd: paus (vänta på tillräckligt många spelare, sedan nedräkning), laddning av karta (klona en slumpad karta från ServerStorage till Workspace), teleport (flytta varje levande karaktär till en spawn-part med PivotTo), runda (låt timern ticka tills tiden är slut eller det bara är en spelare eller ett lag kvar) och städning (dela ut Wins, låt de överlevande respawna, ta bort kartan).

  • Kör cykeln bara på servern. Publicera status och återstående sekunder som attribut på en Folder i ReplicatedStorage, och låt ett LocalScript visa dem.
  • Håll en tabell över vilka som fortfarande är med i rundan. Ta bort en spelare när dess Humanoid dör, dess karaktär tas bort eller den lämnar.
  • Teleportera bara de spelare vars karaktär lever när rundan startar. Den som går med senare väntar i lobbyn på nästa.
På den här sidan
  1. Så fungerar det
  2. 1. Lobby och kartor
  3. 2. Rundskriptet
  4. Så fungerar tillstånden
  5. 3. Timer-UI
  6. Spelare mitt i en runda
  7. Så bygger du ut det
  8. Common errors
  9. Med RoCode
  10. Vanliga frågor
  11. Källor och vidare läsning

Så fungerar ett rundsystem

IllustrationDe färdiga rundskripten i ett spel som körs, uppsnabbat.

Ett rundsystem är en tillståndsmaskin. Vid varje tidpunkt befinner sig servern i exakt ett tillstånd, varje tillstånd har en uppgift, och ett villkor för det vidare till nästa. Om du skriver det så ligger all logik på ett ställe, och du slipper den klassiska buggen där timerloopen och rundloopen båda försöker avsluta samma runda.

Tillstånden i rundcykeln i den här guiden
TillståndVad servern görNär den går vidare
WaitingVisar "Waiting for players (1/2)"Det finns tillräckligt många spelare på servern
IntermissionRäknar ner tiden medan alla är i lobbynNedräkningen är slut (eller tillbaka till Waiting om spelare lämnade)
StartingKopierar en slumpad karta till Workspace, visar dess namn, ber klienterna ladda denEn kort "gör dig redo"-nedräkning är slut
InRoundTeleporterar levande spelare, låter timern ticka, tar bort dem som dog eller lämnadeTiden är slut, eller det är bara en spelare eller ett lag kvar
ResultsGer en Win till alla som fortfarande lever och visar vem som vannNågra sekunder har gått
CleanupLåter de överlevande respawna i lobbyn och tar bort kartanDirekt, därefter börjar cykeln om

Servern äger varje tillstånd. Klienterna visar bara det som servern säger till dem. En nedräkning i ett LocalScript glider ifrån den riktiga, är fel för dem som går med senare och kan ändras av en exploiter. Om uppdelningen i server och klient är ny för dig, läs först Script vs LocalScript vs ModuleScript.

Steg 1: Bygg lobbyn, kartorna och statistiken Wins

  1. Bygg en lobby i Workspace med en SpawnLocation. Kontrollera att egenskapen Neutral är markerad, så att varje spelare spawnar här, väntar här och kommer tillbaka hit efter att ha blivit utslagen.
  2. I ServerStorage, infoga en Folder som heter Maps. Objekt i ServerStorage skickas aldrig till spelarna, så kartor som inte används kostar dem ingenting.
  3. Bygg varje karta som en Model inuti Maps, med förankrade (anchored) parts. Bygg den en bit bort från lobbyn (några hundra studs räcker), eftersom kopian dyker upp exakt där du byggde den, och utslagna spelare ska inte kunna gå tillbaka in.
  4. Inuti varje karta, lägg till en Folder som heter Spawns, och i den en förankrad Part för varje spelare du väntar dig. Sätt deras Transparency till 1 och stäng av CanCollide, så att ingen ser dem eller snubblar på dem.
Explorer efter den här guiden
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

Rundskriptet lägger till 1 på ett IntValue som heter Wins inuti spelarens mapp leaderstats. Om ditt spel inte har leaderstats än, lägg till det här korta skriptet. Om det redan finns, till exempel versionen med sparande från guiden om topplistan, hoppa över det: två skript som skapar leaderstats ger varje spelare två mappar.

Script i ServerScriptService med namnet Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- namnet måste vara exakt så här, med små bokstäver

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

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- I Studio kan du gå med innan det här skriptet startar, så vi ställer in alla som redan är här
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

De här Wins nollställs när spelaren lämnar. För att de ska sparas mellan sessioner, använd versionen med DataStore från guiden om topplistan.

Steg 2: Lägg till rundskriptet

Infoga ett Script i ServerScriptService, döp det till RoundSystem och klistra in koden nedan. Inställningarna överst är de enda rader du troligen behöver ändra. Varje tillstånd är en egen funktion, och loopen längst ner kör dem i ordning, i all oändlighet.

Script i ServerScriptService med namnet RoundSystem
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Inställningar
local MIN_PLAYERS = 2 -- sätt 1 medan du testar ensam
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: rundan slutar när spelarna bara finns kvar i ett lag

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

-- Det som varje spelares skärm visar lagras i attribut på den här mappen.
-- Attribut som servern sätter replikeras till alla klienter, även till dem som gick med senare.
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

-- Vem som fortfarande är med i den aktuella rundan, och anslutningarna som följer var och en av dem
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)

-- Returnerar karaktären och Humanoid bara om spelaren lever just nu
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

-- Räknar sidorna som är kvar i rundan (spelare, eller lag om USE_TEAMS är påslaget)
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

-- TILLSTÅND: Waiting och Intermission. Returnerar false om spelare lämnade under nedräkningen.
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

-- TILLSTÅND: Starting, del 1. Kopiera en slumpad karta (inte den förra, om det finns ett val).
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
	-- Blanda, så att spelarna inte hamnar på samma spawn varje runda
	for i = #points, 2, -1 do
		local j = random:NextInteger(1, i)
		points[i], points[j] = points[j], points[i]
	end
	return points
end

-- På vilken höjd över golvet en stående karaktärs root part befinner sig.
-- Formeln från Roblox referens för Humanoid.HipHeight (R6-riggar lägger till benets höjd).
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

-- TILLSTÅND: Starting, del 2. Gör dig redo, teleportera sedan alla levande.
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

	-- Med streaming påslaget ber vi varje klient att ladda kartan innan karaktären kommer fram
	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

	-- Bara de som lever just nu är med. De andra väntar på nästa runda.
	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]
			-- Karaktärens pivot är dess root part, så vi lyfter den till stående höjd över parten
			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

-- TILLSTÅND: InRound. Slutar när tiden är slut eller bara en sida är kvar.
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()
		-- En runda som startades av en enda sida (test på egen hand) slutar bara när tiden är slut eller vid död
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- TILLSTÅND: Results. Alla som fortfarande lever vinner.
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) -- vi slutar följa dem; de stannar kvar på kartan tills städningen
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- TILLSTÅND: Cleanup. Skicka de överlevande tillbaka till lobbyn och ta sedan bort kartan.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- fortfarande på servern
			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

-- Loopen: ett varv är en runda
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) -- inga kartor än: vi försöker igen snart
		end
	end
end

Allt viktigt händer här, på servern: vem som är med i rundan, timern, vinnaren och Wins. Klienterna får bara tre attribut på ReplicatedStorage.RoundInfo (State, Status och TimeLeft) och attributet InRound på varje spelare.

Så fungerar varje tillstånd

Väntan och paus

runIntermission håller först cykeln tills #Players:GetPlayers() når MIN_PLAYERS. Sedan räknar den ner en sekund i taget med task.wait(1) och kontrollerar antalet spelare vid varje tick. Om någon lämnar och servern hamnar under minimum returnerar den false, och huvudloopen börjar om från Waiting, så en runda startar aldrig med en enda person.

Välja och ladda kartan

loadMap samlar alla Model i ServerStorage.Maps, tar bort förra rundans karta om det finns något annat att välja mellan, och väljer en med Random:NextInteger. Sedan klonar den kartan till Workspace. Originalet ligger kvar orört i ServerStorage, så varje runda börjar med en ny kopia: allt som spelarna förstörde eller flyttade förra rundan försvinner.

I nya places är instance streaming påslaget: klienten har bara de parts som finns nära dess karaktär. Före teleporten anropar skriptet Player:RequestStreamAroundAsync för varje spelare, och det ber motorn att skicka området runt kartan till klienten under "gör dig redo"-nedräkningen. Utan det kan spelare komma fram innan golvet har laddats och frysa en kort stund.

Teleportera spelare med PivotTo

Efter nedräkningen gör skriptet en lista över deltagare av de spelare vars karaktär finns, fortfarande är i världen och har en Humanoid med hälsa över 0 och en root part. Den kontrollen görs efter nedräkningen, så den som dog eller lämnade under den kommer inte med på listan.

Varje deltagare flyttas med character:PivotTo(cframe). Roblox referens kallar PivotTo det huvudsakliga sättet att flytta modeller från ett skript, och den flyttar alla delar av karaktären tillsammans. Att sätta HumanoidRootPart.Position är inte samma sak: Roblox justerar fogarna så att bara just den delen flyttas, och resten av kroppen kan bli kvar. En karaktärs pivot är dess root part, så målet är spawn-partens CFrame, upplyft med halva partens höjd plus höjden som root part står på ovanför golvet. rootHeight räknar ut den med formeln från Roblox referens för Humanoid.HipHeight: halva höjden av root part plus HipHeight, plus benets längd för R6-riggar. På så sätt fastnar skalade och anpassade avatarer inte i parten och faller inte ner på den ovanifrån. CFrame innehåller rotationen, så spelarna tittar åt samma håll som spawn-parten: vrid parterna så att alla tittar mot kartans mitt.

Om det finns fler spelare än spawn-parts börjar skriptet om från den första parten, och spelarna hamnar ovanpå varandra, så lägg till minst lika många spawns som ditt högsta antal spelare.

Om du också använder hastighetskontrollen från guiden om sprint, lägg till player:SetAttribute("MovementCheckSkip", true) direkt efter character:PivotTo(...) i startRound, så att teleporten inte räknas som för hög hastighet.

Rundtimer och villkor för slut

runRound tickar en gång i sekunden. Vid varje tick uppdaterar den status (hur många spelare som är kvar) och de återstående sekunderna och räknar sedan de levande sidorna. Rundan slutar på ett av tre sätt:

  • Tiden är slut. for-loopen når 1 och avslutas.
  • En sida är kvar. En sida är en spelare, eller ett lag om USE_TEAMS är påslaget. Kontrollen fungerar bara om rundan startade med två eller fler sidor, så ett test på egen hand slutar inte i samma ögonblick som det började.
  • Ingen är kvar. Alla dog eller lämnade, och rundan slutar utan vinnare.

En kontroll i sekunden betyder att rundan kan pågå upp till en sekund efter den sista utslagningen, och på en rundtimer märks det knappt.

Dela ut Wins och visa resultatet

Regeln i det här skriptet är enkel: alla som lever när rundan slutar vinner. Det täcker både den sista överlevande spelaren, det sista överlevande laget och läget "håll ut tills timern tar slut" med en enda rad logik. finishRound lägger till 1 på varje vinnares Wins, slutar följa dem och visar ett meddelande som "Alex wins!" i RESULTS_SECONDS. Om du vill att det inte ska bli någon vinnare när tiden tar slut, hoppa över awardWin och ändra meddelandet när sidesLeft är större än 1. Fortsätt i alla fall att returnera listan, eftersom städningen använder den för att skicka tillbaka de överlevande till lobbyn.

Städning

De överlevande står fortfarande på kartan, så cleanup låter dem respawna i lobbyn med Player:LoadCharacterAsync(), som ersätter det gamla LoadCharacter, och tar sedan bort kopian av kartan. Varje respawn körs i sin egen task.spawn inuti pcall, eftersom anropet väntar på att karaktären laddas och kan misslyckas om spelaren lämnar just då. Utslagna spelare behöver ingenting: de har redan respawnat i lobbyn av sig själva.

Steg 3: Visa timern och statusen för varje spelare

Servern publicerar tre attribut på ReplicatedStorage.RoundInfo: State (ett fast ord som InRound, för skript), Status (text för människor) och TimeLeft (sekunder). Attribut som ett serverskript sätter på ett replikerat objekt når automatiskt varje klient, och en spelare som går med mitt i en runda får direkt de aktuella värdena. Därför passar det bättre för en timer än en remote: ett RemoteEvent som skickades innan någon gick med når aldrig fram till den personen.

  1. I Explorer, infoga en ScreenGui i StarterGui och döp den till RoundHud. Låt ResetOnSpawn vara påslaget (standard).
  2. Infoga ett LocalScript i RoundHud, döp det till RoundHudClient och klistra in koden nedan. Det skapar texten själv, så du behöver inte rita något mer.
  3. Klicka på Play. Texten överst på skärmen visar status och nedräkning i formatet m:ss.
LocalScript i ScreenGui RoundHud i StarterGui med namnet RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Texten. Om du har ritat en egen TextLabel i RoundHud, ta bort det här blocket och använd:
-- 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ånga meddelanden bryts till en andra rad
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()

Eftersom ResetOnSpawn är påslaget ger Roblox spelaren en ny kopia av RoundHud varje gång karaktären spawnar, även vid respawn under städningen. Skriptet läser då de aktuella attributen igen, så texten blir aldrig inaktuell.

Klienten läser bara. Inget som spelaren ändrar på sin skärm påverkar den riktiga timern, eftersom ändringar av attribut från ett LocalScript stannar på just den klienten. För en nedräkning med tiondels sekunder kan servern i stället spara sluttiden från workspace:GetServerTimeNow() i ett attribut, och varje klient drar varje bildruta av sin egen workspace:GetServerTimeNow() från den.

Om ditt spel öppnas med en huvudmeny dyker RoundHud upp när spelaren klickar på Play, eftersom StarterGui kopieras till spelaren först när karaktären har spawnat. Spelare som fortfarande är i menyn har ingen karaktär, så de teleporteras aldrig in i en runda.

Spelare som dör, lämnar eller går med mitt i en runda

De här fallen är lätta att missa när man skriver ett rundskript för första gången. Om något av dem inte hanteras ser du oftast ett fel i Output eller en runda som aldrig tar slut. Så här hanterar skriptet ovan vart och ett av dem.

Specialfall och hur rundskriptet hanterar dem
SituationVad som händerVar i skriptet
En spelare dör i rundan (dödad, återställde sig, föll)Spelaren tas bort ur rundan och respawnar i lobbyn efter Players.RespawnTime (5 sekunder som standard).humanoid.Died anropar eliminate
Karaktären tas bort utan att döSom vid död: spelaren är utslagen.player.CharacterRemoving anropar eliminate
En spelare lämnar servernSpelaren tas bort, dess anslutningar kopplas från, och nästa tick räknar om sidorna.Players.PlayerRemoving anropar eliminate
En spelare går med mitt i en rundaSpelaren spawnar i lobbyn, ser den levande statusen och timern och kommer med i nästa runda.Deltagarna väljs bara i startRound
En spelare var död när rundan startadeSpelaren teleporteras inte utan väntar i lobbyn.getLivingCharacter
Alla lämnade eller dogRundan slutar med "Nobody survived", och cykeln börjar om: Intermission om det fortfarande finns tillräckligt många spelare på servern, annars Waiting.sidesLeft == 0 i runRound

eliminate är skrivet så att det är säkert att anropa flera gånger för samma spelare. En spelare som dog och respawnade utlöser både Died och CharacterRemoving, och den som lämnar kan utlösa alla tre eventen; bara det första anropet gör något.

Så bygger du ut det: lag, kartröstning och rundevent

Det sista överlevande laget

Sätt USE_TEAMS = true och lägg sedan till Team-objekt i tjänsten Teams i Explorer, vart och ett med sitt eget namn och TeamColor. Som standard placerar Roblox varje spelare som går med i det automatiskt tilldelade laget med minst antal medlemmar. När spelare lämnar balanserar det inte om lagen, så under långa sessioner kan lagen bli ojämna. Låt SpawnLocation i lobbyn vara Neutral, så att alla lag spawnar där. Då slutar rundan när de levande spelarna bara finns i ett lag, och resultatet ser ut som "Red wins!".

För formatet "en mot alla" (en jägare, resten överlever), välj en slumpad deltagare i startRound och sätt före teleporten dess Team till jägarlaget. Stäng av AutoAssignable för jägarlaget, så att nya spelare aldrig hamnar där, och flytta i cleanup tillbaka jägaren till de överlevandes lag. Då fungerar samma villkor för slut: jägaren vinner om alla överlevande slagits ut, och de överlevande vinner om de håller ut tills timern tar slut, förutsatt att du hoppar över jägarens awardWin när tiden är slut.

Spelarna röstar på kartan

För en röstning måste klienten kommunicera med servern, och då behövs ett RemoteEvent. Under pausen publicerar servern två eller tre kartnamn som attribut, varje klient skickar namnet den klickade på via RemoteEvent, och servern räknar rösterna innan loadMap körs. Servern måste kontrollera varje röst: att argumentet är en sträng, att det är ett av de aktuella alternativen, att tillståndet är Intermission och att varje spelare räknas en gång (spara rösterna i en tabell med Player som nyckel, så att en andra röst ersätter den första, och töm den i PlayerRemoving). Guiden om RemoteEvent går igenom det här mönstret för kontroller i detalj.

Dela ut ett verktyg när rundan börjar

Andra skript kan reagera på rundan utan att röra RoundSystem. Rundskriptet sätter attributet InRound på varje spelare när den teleporteras och tar bort det när spelaren slås ut. Det här skriptet lyssnar på det och ger varje spelare en kopia av ett Tool som heter RoundTool och ligger i ServerStorage.

Script i ServerScriptService med namnet 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

Det finns ingen kod som tar tillbaka verktyget. När karaktären dör ersätter Roblox Backpack med en ny, fylld från StarterPack, och LoadCharacterAsync under städningen tömmer den för de överlevande, så efter rundan finns verktyget inte längre kvar.

Om du behöver ett vapen att dela ut, bygg ett svärd eller en pistol med raycasts, förvara det i ServerStorage i stället för StarterPack och byt "RoundTool" i det här skriptet mot dess namn.

NPC:er och andra objekt bara under rundan

Allt som bara ska finnas under en runda kan ligga inuti kartans modell: fiender, föremål att plocka upp, rörliga plattformar. Skript inuti en modell i ServerStorage körs inte; så snart kopian hamnar i Workspace startar de, och map:Destroy() under städningen tar bort dem tillsammans med allt annat. För att lägga till fiender som jagar spelarna, bygg en med guiden om pathfinding för NPC:er och lägg den i kartan. För en kameraflygning över kartan i början av varje runda visar guiden om cutscenes hur det här skriptet kan starta en cutscene för varje spelare via ett BindableEvent.

Så gör du en modul av det

Till att börja med behövs inget ModuleScript. Ett enda Script är lättare att läsa medan du bygger spelet. Dela upp det när andra skript behöver anropa rundans funktioner eller när du vill flytta inställningarna till ett gemensamt ModuleScript som både servern och ditt UI kan hämta med require. Fram till dess fungerar attributet State på RoundInfo och attributet InRound på varje spelare redan som rundsystemets publika gränssnitt: vilket skript som helst kan lyssna på dem.

Vanliga fel och lösningar

Öppna fönstret Output (via menyn Window i Studio eller fliken Script) innan du klickar på Play. De flesta problem med rundsystemet skriver ut en varning eller ett fel där, med skriptets namn och radnummer.

Fastnar på "Waiting for players (1/2)"

Du testar ensam, och MIN_PLAYERS är 2. Sätt 1 för tester på egen hand, eller testa i läget Server & Clients med 2 klienter.

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

Mappen finns inte, har ett felstavat namn eller ligger i fel tjänst. Det måste vara en Folder som heter exakt Maps direkt inuti ServerStorage. Samma varning för RoundInfo i ett LocalScript betyder att skriptet RoundSystem aldrig kom fram till att skapa den: det är avstängt, kraschade med ett fel eller väntar fortfarande på mappen Maps.

Spelarna faller genom kartan efter teleporten

Kartans parts är inte förankrade, så kopian faller isär så snart den hamnar i Workspace. Markera kartan, förankra dess parts och kontrollera att spawn-parterna står ovanför golvet och inte inuti det.

Utslagna spelare respawnar på arenan

Det finns en SpawnLocation inuti kartan. Byt ut den mot en vanlig Part i kartans mapp Spawns.

Rundan tar inte slut när alla har dött

Kontrollera att din skada verkligen dödar Humanoid (hälsan når 0) och inte flyttar eller förankrar spelarna. Om du har stängt av tillståndet Dead för Humanoid utlöses Died aldrig, och rundan måste köras tills timern tar slut.

Rundcykeln stannar för gott efter ett enda fel

Cykeln körs i en enda tråd, så ett fel i vilket tillstånd som helst avslutar den. Läs felet i Output, rätta raden och testa igen. En vanlig orsak: skriptet har ändrats så att det använder player.Character.Humanoid utan att kontrollera att karaktären finns.

Gör det med RoCode

Om du inte vill bygga allt det här för hand kan RoCode göra det i den place du har öppen. Det är en AI-agent som arbetar via ett plugin för Roblox Studio, så skripten och parterna dyker upp i din Explorer och inte i ett chattfönster som du skulle behöva klistra in dem från.

Du skriver

Lägg till ett rundsystem: en paus på 20 sekunder som kräver 2 spelare, en slumpad karta från ServerStorage.Maps, teleportera alla till kartans spawn-parts, rundor på 2 minuter där den sista levande spelaren vinner, lägg till en Win i leaderstats och visa status och timer överst på skärmen.

RoCode gör
  • Kan först titta igenom din place med List Children, Search Game och Search Scripts för att använda din Maps-mapp och ditt leaderstats-skript i stället för att lägga till en andra uppsättning
  • Skapar rundans Script i ServerScriptService och timerns LocalScript med Create Script, och kan placera en arena från sina färdiga konstruktioner med Place Prefab om du inte har någon karta än
  • Kontrollerar att varje skript kompilerar inuti Studio med Check Script innan den avslutar. Det fångar syntaxfel, inte fel i rundans logik
  • Efter ditt speltest läser Check Output raderna Server och Client från det senaste speltestet för att rätta ett fel under körning

Med plugin 3.9 eller nyare kan RoCode köra ett kort speltest och läsa felen, och med plugin 3.9.11 eller nyare kan den styra en enda testkaraktär, men den testar inte med flera spelare, så kör rundorna själv i läget Server & Clients. Varje omgång ändringar är en ångrapunkt i Studio. En rundcykel ligger till grund för många spel, och att skapa ett helt Roblox-spel med AI, system för system börjar ofta med en sådan cykel. Så ansluter RoCode till Studio.

Vanliga frågor

Hur gör jag ett rundsystem med lag i Roblox?

Lägg till Team-objekt i tjänsten Teams och sätt USE_TEAMS = true i rundskriptet. Roblox fördelar spelare som går med till det automatiskt tilldelade laget med minst antal medlemmar, och rundan slutar när de levande spelarna bara finns i ett lag.

Hur visar jag en nedräkning för alla spelare?

Sätt de återstående sekunderna från servern som ett attribut på ett objekt i ReplicatedStorage och lyssna på det med GetAttributeChangedSignal i ett LocalScript som uppdaterar en TextLabel, som i steg 3. Spelare som går med senare får direkt det aktuella värdet.

Ska jag använda wait() eller task.wait() i en rundloop?

Använd task.wait(). Roblox markerar den globala wait() som föråldrad och ersatt av task.wait().

Hur teleporterar jag spelare till en annan place för varje runda?

Det är ett annat verktyg. Den här guiden flyttar karaktärer inom samma server med PivotTo. Att skicka spelare till en annan place i din experience görs med TeleportService, som flyttar dem till en annan server. Guiden om teleporter bygger portaler som gör det, med nya försök om teleporten misslyckas.

Varför fryser spelarna en kort stund efter teleporten?

Med instance streaming påslaget har klienten ännu inte fått kartan. Anropet RequestStreamAroundAsync i skriptet under "gör dig redo"-nedräkningen ber motorn att skicka den i förväg; en längre GET_READY_SECONDS ger långsamma anslutningar mer tid.

Källor och vidare läsning

Så kontrollerades koden: varje skript på den här sidan klarar strikt Luau-typkontroll mot Roblox API-definitionerna (luau-lsp, 20 november 2026). Typkontrollen fångar felstavade API-namn och fel typer, men inte fel i spellogiken, så testa allt i Studio innan du publicerar.

Testa RoCode i ditt eget spel.

Gratis krediter varje dag, inget kort krävs. Installera pluginet, beskriv en funktion och kontrollera vad som dök upp i Studio.