Tutorial · Spillsystemer

Slik lager du et rundesystem i Roblox Studio

De fleste rundebaserte spill i Roblox kjører den samme løkken: venter på spillere, teller ned, laster et kart, teleporterer alle dit, kjører en timer, velger en vinner og rydder opp. I denne guiden bygger vi den løkken som ett oversiktlig serverskript, legger til en timer som hver spiller kan se, og går gjennom tilfellene der kopierte skript går i stykker: spillere som dør, forlater spillet eller kommer inn midt i en runde.

Oppdatert 20. november 202615 min lesingSkrevet av

Kort fortalt

Skriv ett server-Script i ServerScriptService som går i ring gjennom et fast sett med tilstander: pause (vent på nok spillere, deretter nedtelling), lasting av kart (klon et tilfeldig kart fra ServerStorage til Workspace), teleport (flytt hver levende karakter til en spawn-part med PivotTo), runde (la timeren gå til tiden er ute eller det bare er én spiller eller ett lag igjen) og opprydding (gi Wins, gjenoppliv de overlevende, slett kartet).

  • Kjør løkken bare på serveren. Publiser status og gjenværende sekunder som attributter på en Folder i ReplicatedStorage, og la et LocalScript vise dem.
  • Hold en tabell over dem som fortsatt er med i runden. Fjern en spiller når Humanoid-en dør, karakteren fjernes eller spilleren forlater spillet.
  • Teleporter bare spillerne som har en levende karakter når runden starter. De som kommer senere, venter i lobbyen på den neste.
På denne siden
  1. Slik fungerer det
  2. 1. Lobby og kart
  3. 2. Rundeskript
  4. Slik fungerer tilstandene
  5. 3. Timer-UI
  6. Spillere midt i en runde
  7. Slik utvider du
  8. Common errors
  9. Med RoCode
  10. Ofte stilte spørsmål
  11. Kilder og videre lesing

Slik fungerer et rundesystem

IllustrasjonDe ferdige rundeskriptene i et kjørende spill, satt opp i tempo.

Et rundesystem er en tilstandsmaskin. Til enhver tid er serveren i nøyaktig én tilstand, hver tilstand har én oppgave, og én betingelse fører den videre til den neste. Når du skriver det slik, ligger all logikken på ett sted, og den klassiske feilen der timerløkken og rundeløkken begge prøver å avslutte den samme runden, oppstår ikke.

Tilstandene i rundeløkken i denne guiden
TilstandHva serveren gjørNår den går videre
WaitingViser "Waiting for players (1/2)"Det er nok spillere på serveren
IntermissionTeller ned mens alle er i lobbyenNedtellingen er ferdig (eller tilbake til Waiting hvis spillere gikk)
StartingKopierer et tilfeldig kart til Workspace, viser navnet, ber klientene laste detEn kort "gjør dere klare"-nedtelling er ferdig
InRoundTeleporterer levende spillere, lar timeren gå, fjerner dem som døde eller gikkTiden er ute, eller det er én spiller eller ett lag igjen
ResultsGir en Win til alle som fortsatt lever, og viser hvem som vantDet har gått noen sekunder
CleanupGjenoppliver de overlevende i lobbyen og sletter kartetMed en gang, deretter starter løkken på nytt

Serveren eier hver tilstand. Klientene viser bare det serveren forteller dem. En nedtelling i et LocalScript glir bort fra den ekte, er feil for dem som kommer senere, og kan endres av en exploiter. Hvis skillet mellom server og klient er nytt for deg, les først Script vs LocalScript vs ModuleScript.

Steg 1: bygg lobbyen, kartene og Wins-statistikken

  1. Bygg en lobby i Workspace med en SpawnLocation. Sjekk at egenskapen Neutral er satt, slik at hver spiller spawner her, venter her og kommer tilbake hit etter å ha blitt slått ut.
  2. Sett inn en Folder med navnet Maps i ServerStorage. Objekter i ServerStorage sendes aldri til spillerne, så ubrukte kart koster dem ingenting.
  3. Bygg hvert kart som en Model inne i Maps med ankrede parts. Bygg det et godt stykke fra lobbyen (et par hundre studs holder), fordi kopien dukker opp nøyaktig der du bygde den, og spillere som er slått ut, ikke skal kunne gå tilbake inn.
  4. Legg inn en Folder med navnet Spawns inne i hvert kart, og i den én ankret Part for hver spiller du forventer. Sett Transparency på dem til 1, og slå av CanCollide, slik at ingen ser dem eller snubler i dem.
Explorer etter denne 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

Rundeskriptet legger 1 til en IntValue med navnet Wins inne i spillerens mappe leaderstats. Hvis spillet ditt ikke har leaderstats ennå, legg til dette korte skriptet. Hvis det allerede har det, for eksempel versjonen med lagring fra guiden om leaderboards, hopp over det: to skript som lager leaderstats, gir hver spiller to mapper.

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

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- navnet må være nøyaktig slik, med små bokstaver

	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 komme inn før dette skriptet starter, så vi setter opp alle som allerede er her
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Disse Wins nullstilles når spilleren forlater spillet. For at de skal lagres mellom økter, bruk versjonen med DataStore fra guiden om leaderboards.

Steg 2: legg til rundeskriptet

Sett inn et Script i ServerScriptService, kall det RoundSystem, og lim inn koden nedenfor. Innstillingene øverst er de eneste linjene du sannsynligvis må endre. Hver tilstand er en egen funksjon, og løkken nederst kjører dem i rekkefølge, i det uendelige.

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

-- Innstillinger
local MIN_PLAYERS = 2 -- sett 1 mens du tester alene
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: runden slutter når det bare er spillere igjen på ett lag

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

-- Det hver spillers skjerm viser, lagres i attributter på denne mappen.
-- Attributter som settes av serveren, replikeres til alle klienter, også dem som kommer senere.
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

-- Hvem som fortsatt er med i den aktuelle runden, og tilkoblingene som holder øye med hver 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)

-- Returnerer karakteren og Humanoid bare hvis spilleren lever akkurat nå
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

-- Teller sidene som er igjen i runden (spillere, eller lag hvis USE_TEAMS er slått på)
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

-- TILSTAND: Waiting og Intermission. Returnerer false hvis spillere gikk under nedtellingen.
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

-- TILSTAND: Starting, del 1. Kopier et tilfeldig kart (ikke det forrige, hvis det finnes valg).
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
	-- Stokk om, slik at spillerne ikke lander på den samme spawnen hver runde
	for i = #points, 2, -1 do
		local j = random:NextInteger(1, i)
		points[i], points[j] = points[j], points[i]
	end
	return points
end

-- Hvor høyt over gulvet root part på en stående karakter befinner seg.
-- Formelen fra Roblox-referansen for Humanoid.HipHeight (på R6-rigger legges beinets høyde til).
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

-- TILSTAND: Starting, del 2. Gjør klar, og teleporter deretter alle levende.
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 slått på ber vi hver klient laste kartet før karakteren ankommer
	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

	-- Bare de som lever akkurat nå, er med. Resten venter på neste 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]
			-- Pivoten til en karakter er root part, så vi løfter den til ståhøyde over 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

-- TILSTAND: InRound. Slutter når tiden er ute eller det er én side igjen.
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 runde som startet med én side (test alene), slutter bare på tid eller ved død
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- TILSTAND: Results. Alle som fortsatt 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 slutter å følge dem; de blir på kartet til oppryddingen
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- TILSTAND: Cleanup. Send de overlevende tilbake til lobbyen, og slett deretter kartet.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- fortsatt på serveren
			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

-- Løkken: én gjennomgang er én 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) -- ingen kart ennå: prøv igjen om litt
		end
	end
end

Alt viktig skjer her, på serveren: hvem som er med i runden, timeren, vinneren og Wins. Klientene får bare tre attributter på ReplicatedStorage.RoundInfo (State, Status og TimeLeft) og attributtet InRound på hver spiller.

Slik fungerer hver tilstand

Venting og pause

runIntermission holder først løkken til #Players:GetPlayers() når MIN_PLAYERS. Deretter teller den ned ett sekund om gangen med task.wait(1) og sjekker antall spillere ved hvert tikk. Hvis noen gikk og det er færre enn minimum på serveren, returnerer den false, og hovedløkken starter på nytt med Waiting, så en runde starter aldri med én person.

Valg og lasting av kart

loadMap samler alle Model i ServerStorage.Maps, fjerner kartet fra forrige runde hvis det finnes noe å velge mellom, og tar ett med Random:NextInteger. Deretter kloner den kartet til Workspace. Originalen blir liggende urørt i ServerStorage, så hver runde starter med en fersk kopi: alt spillerne ødela eller flyttet i forrige runde, er borte.

I nye places er instance streaming slått på: klienten har bare parts i nærheten av karakteren sin. Før teleporten kaller skriptet Player:RequestStreamAroundAsync for hver spiller, og det ber motoren sende området rundt kartet til klienten under "gjør dere klare"-nedtellingen. Uten det kan spillerne ankomme før gulvet er lastet, og fryse et øyeblikk.

Teleport av spillere med PivotTo

Etter nedtellingen samler skriptet listen over deltakere fra spillerne som har en karakter som finnes, fortsatt er i verden og har en Humanoid med mer enn 0 i liv og en root part. Denne sjekken skjer etter nedtellingen, så den som døde eller gikk underveis, kommer ikke med på listen.

Hver deltaker flyttes med character:PivotTo(cframe). Roblox-referansen kaller PivotTo den primære måten å flytte modeller fra et skript på, og den flytter alle karakterens deler sammen. Å sette HumanoidRootPart.Position er ikke det samme: Roblox justerer leddene slik at bare den ene delen flytter seg, og resten av kroppen kan bli igjen. Pivoten til en karakter er root part, så målet er spawn-partens CFrame løftet med halvparten av partens høyde pluss høyden root part står over gulvet. rootHeight regner den ut med formelen fra Roblox-referansen for Humanoid.HipHeight: halvparten av root parts høyde pluss HipHeight, pluss beinlengden på R6-rigger. Da setter ikke skalerte og egne avatarer seg fast i parten og faller ikke ned på den. CFrame inneholder rotasjonen, så spillerne ser samme vei som spawn-parten: drei partene slik at alle ser mot midten av kartet.

Hvis det er flere spillere enn spawn-parts, starter skriptet på nytt med den første parten, og spillerne lander oppå hverandre, så legg til minst like mange spawns som det maksimale antallet spillere ditt.

Hvis du også bruker hastighetssjekken fra sprint-guiden, legg til player:SetAttribute("MovementCheckSkip", true) rett etter character:PivotTo(...) i startRound, slik at teleporten ikke regnes som for høy hastighet.

Rundetimer og sluttbetingelser

runRound tikker én gang i sekundet. Ved hvert tikk oppdaterer den status (hvor mange spillere som er igjen) og gjenværende sekunder, og teller deretter de levende sidene. Runden slutter på en av tre måter:

  • Tiden er ute. for-løkken når 1 og avslutter.
  • Det er én side igjen. En side er en spiller, eller et lag hvis USE_TEAMS er slått på. Sjekken virker bare hvis runden startet med to eller flere sider, så en test alene slutter ikke i samme øyeblikk som den startet.
  • Det er ingen igjen. Alle døde eller gikk, og runden slutter uten vinner.

Sjekk én gang i sekundet betyr at runden kan gå opptil ett sekund etter at den siste er slått ut, noe som nesten ikke merkes på en rundetimer.

Utdeling av Wins og visning av resultatet

Regelen i dette skriptet er enkel: alle som lever når runden slutter, vinner. Det dekker både den siste overlevende spilleren, det siste overlevende laget og modusen "hold ut til timeren går ut" med én linje logikk. finishRound legger 1 til hver vinners Wins, slutter å følge dem og viser en melding som "Alex wins!" i RESULTS_SECONDS. Hvis du ikke vil ha noen vinner når tiden går ut, hopp over awardWin, og endre meldingen når sidesLeft er større enn 1. Fortsett uansett å returnere listen, fordi oppryddingen bruker den til å sende de overlevende tilbake til lobbyen.

Opprydding

De overlevende står fortsatt på kartet, så cleanup gjenoppliver dem i lobbyen med Player:LoadCharacterAsync(), som erstatter den gamle LoadCharacter, og sletter deretter kopien av kartet. Hver gjenoppliving kjører i sin egen task.spawn inne i pcall, fordi kallet venter på at karakteren lastes, og kan feile hvis spilleren forlater spillet akkurat da. Spillere som er slått ut, trenger ingenting: de har allerede gjenoppstått i lobbyen av seg selv.

Steg 3: vis timeren og status for hver spiller

Serveren publiserer tre attributter på ReplicatedStorage.RoundInfo: State (et fast ord som InRound, for skript), Status (tekst for mennesker) og TimeLeft (sekunder). Attributter som et serverskript setter på et replikert objekt, når automatisk ut til hver klient, og en spiller som kommer inn midt i en runde, får straks de aktuelle verdiene. Derfor passer det bedre for en timer enn en remote: en RemoteEvent som ble sendt før noen kom inn, når aldri frem til dem.

  1. Sett inn en ScreenGui i StarterGui i Explorer, og kall den RoundHud. La ResetOnSpawn være slått på (standard).
  2. Sett inn et LocalScript i RoundHud, kall det RoundHudClient, og lim inn koden nedenfor. Det lager teksten selv, så du trenger ikke tegne noe mer.
  3. Trykk Play. Teksten øverst på skjermen viser status og nedtelling i formatet m:ss.
LocalScript i ScreenGui RoundHud i StarterGui med navnet RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Teksten. Hvis du har tegnet din egen TextLabel i RoundHud, slett denne blokken og bruk:
-- local label = screenGui:WaitForChild("StatusLabel") :: TextLabel
local label = Instance.new("TextLabel")
label.Name = "StatusLabel"
label.AnchorPoint = Vector2.new(0.5, 0)
label.Position = UDim2.new(0.5, 0, 0, 12)
label.Size = UDim2.fromOffset(320, 44)
label.BackgroundColor3 = Color3.fromRGB(20, 14, 32)
label.BackgroundTransparency = 0.2
label.TextColor3 = Color3.new(1, 1, 1)
label.Font = Enum.Font.BuilderSansBold
label.TextSize = 22
label.TextWrapped = true -- lange meldinger brytes over på en ny linje
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()

Siden ResetOnSpawn er slått på, gir Roblox spilleren en fersk kopi av RoundHud ved hver karakterspawn, også ved gjenopplivingen under oppryddingen. Skriptet leser da de aktuelle attributtene på nytt, så teksten blir aldri utdatert.

Klienten bare leser. Ingenting spilleren endrer på skjermen sin, påvirker den ekte timeren, fordi endringer av attributter fra et LocalScript blir værende på den ene klienten. For en nedtelling med tideler av sekunder kan serveren i stedet lagre sluttidspunktet fra workspace:GetServerTimeNow() i et attributt, og hver klient trekker hver frame sin egen workspace:GetServerTimeNow() fra det.

Hvis spillet ditt åpner med en hovedmeny, dukker RoundHud opp når spilleren trykker Play, fordi StarterGui først kopieres til spilleren etter at karakteren har spawnet. Spillere som fortsatt er i menyen, har ingen karakter, så de teleporteres aldri inn i en runde.

Spillere som dør, går eller kommer inn midt i en runde

Disse tilfellene er lette å overse når man skriver et rundeskript for første gang. Hvis ett av dem ikke håndteres, ser du som regel en feil i Output eller en runde som aldri slutter. Her er hva skriptet ovenfor gjør med hvert av dem.

Grensetilfeller, og hvordan rundeskriptet håndterer dem
SituasjonHva som skjerHvor i skriptet
En spiller dør i runden (drept, tok reset, falt)Spilleren fjernes fra runden og gjenoppstår i lobbyen etter Players.RespawnTime (som standard 5 sekunder).humanoid.Died kaller eliminate
Karakteren fjernes uten å døSom ved død: spilleren er slått ut.player.CharacterRemoving kaller eliminate
En spiller forlater serverenSpilleren fjernes, tilkoblingene kobles fra, og neste tikk teller sidene på nytt.Players.PlayerRemoving kaller eliminate
En spiller kommer inn midt i en rundeSpilleren spawner i lobbyen, ser aktuell status og timer og blir med i neste runde.Deltakere velges bare i startRound
En spiller var død da runden startetSpilleren teleporteres ikke og venter i lobbyen.getLivingCharacter
Alle gikk eller dødeRunden slutter med "Nobody survived", og løkken starter på nytt: Intermission hvis det fortsatt er nok spillere på serveren, ellers Waiting.sidesLeft == 0 i runRound

eliminate er skrevet slik at det er trygt å kalle den flere ganger for samme spiller. En spiller som døde og gjenoppsto, utløser både Died og CharacterRemoving, og en som går, kan utløse alle tre eventene; bare det første kallet gjør noe.

Slik utvider du: lag, avstemning om kart og runde-events

Det siste overlevende laget

Sett USE_TEAMS = true, og legg deretter til Team-objekter i tjenesten Teams i Explorer, hvert med eget navn og TeamColor. Som standard plasserer Roblox hver spiller som kommer inn, på det automatisk tildelte laget med færrest medlemmer. Når spillere går, balanserer den ikke lagene på nytt, så i lange økter kan lagene bli skjeve. La SpawnLocation i lobbyen være Neutral, slik at alle lag spawner der. Da slutter runden når det bare er levende spillere igjen på ett lag, og resultatet ser ut som "Red wins!".

For formatet "én mot alle" (én jeger, resten overlever) velger du i startRound én tilfeldig deltaker og setter Team til jegerlaget før teleporten. Fjern AutoAssignable fra jegerlaget, slik at nye spillere aldri havner der, og sett i cleanup jegeren tilbake på de overlevendes lag. Da virker de samme sluttbetingelsene: jegeren vinner hvis alle overlevende er slått ut, og de overlevende vinner hvis de holder ut til timeren er ferdig, forutsatt at du hopper over jegerens awardWin når tiden er ute.

Spillerne stemmer over kartet

For en avstemning må klienten snakke med serveren, og det krever en RemoteEvent. Under pausen publiserer serveren to eller tre kartnavn som attributter, hver klient sender navnet den klikket på via RemoteEvent, og serveren teller stemmene før loadMap kjører. Serveren må sjekke hver stemme: at argumentet er en streng, at det er ett av de aktuelle valgene, at tilstanden er Intermission, og at hver spiller teller én gang (lagre stemmene i en tabell med Player som nøkkel, slik at en ny stemme erstatter den første, og tøm den i PlayerRemoving). Guiden om RemoteEvent går gjennom dette mønsteret av sjekker i detalj.

Utdeling av et tool ved rundestart

Andre skript kan reagere på runden uten å røre RoundSystem. Rundeskriptet setter attributtet InRound på hver spiller når den teleporteres, og fjerner det når spilleren er slått ut. Dette skriptet lytter etter det og gir hver spiller en kopi av Tool-en med navnet RoundTool som ligger i ServerStorage.

Script i ServerScriptService med navnet 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 finnes ingen kode som tar toolet tilbake. Når en karakter dør, erstatter Roblox Backpack med en fersk, fylt fra StarterPack, og LoadCharacterAsync under oppryddingen tømmer den for de overlevende, så etter runden er toolet allerede borte.

Hvis du trenger et våpen å dele ut, bygg et sverd eller en pistol med raycasts, lagre det i ServerStorage i stedet for StarterPack, og bytt ut "RoundTool" i dette skriptet med navnet på det.

NPC-er og andre objekter bare under runden

Alt som bare skal finnes under runden, kan ligge inne i kartmodellen: fiender, ting å plukke opp, bevegelige plattformer. Skript inne i en modell i ServerStorage kjører ikke; så snart kopien er i Workspace, starter de, og map:Destroy() under oppryddingen sletter dem sammen med alt det andre. For å legge til fiender som jager spillere, bygger du en etter guiden om pathfinding for NPC-er og legger den i kartet. For en flytur over kartet i starten av hver runde viser cutscene-guiden hvordan dette skriptet kan starte en cutscene for hver spiller via en BindableEvent.

Slik gjør du det om til en modul

Til å begynne med trenger du ikke et ModuleScript. Ett Script er lettere å lese mens du bygger spillet. Del det opp når andre skript skal kalle rundefunksjoner, eller når du vil flytte innstillingene til ett felles ModuleScript som både serveren og UI-en din kan hente med require. Inntil da fungerer attributtet State på RoundInfo og attributtet InRound på hver spiller allerede som rundesystemets offentlige grensesnitt: ethvert skript kan lytte etter dem.

Vanlige feil og løsninger

Åpne Output-vinduet (via menyen Window i Studio eller fanen Script) før du trykker Play. De fleste problemer med rundesystemet skriver en advarsel eller en feil der, med skriptets navn og linjenummer.

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

Du tester alene, og MIN_PLAYERS er 2. Sett 1 for test alene, eller test i modusen Server & Clients med 2 klienter.

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

Mappen mangler, har en skrivefeil i navnet eller ligger i feil tjeneste. Det må være en Folder med navnet nøyaktig Maps rett inne i ServerStorage. Den samme advarselen for RoundInfo i LocalScriptet betyr at skriptet RoundSystem aldri rakk å lage den: det er slått av, har krasjet med en feil eller venter fortsatt på mappen Maps.

Etter teleporten faller spillerne gjennom kartet

Partene i kartet er ikke ankret, så kopien faller fra hverandre så snart den er i Workspace. Merk kartet, ankre partene, og sjekk at spawn-partene står over gulvet og ikke inne i det.

Spillere som er slått ut, gjenoppstår på arenaen

Det ligger en SpawnLocation inne i kartet. Bytt den ut med en vanlig Part i mappen Spawns i kartet.

Runden slutter ikke når alle er døde

Sjekk at skaden din faktisk dreper Humanoid (livet når 0) og ikke bare flytter eller ankrer spillerne. Hvis du har slått av tilstanden Dead på Humanoid, utløses aldri Died, og runden må gå til timeren er ferdig.

Rundeløkken stopper for godt etter én feil

Løkken kjører i én tråd, så en feil i hvilken som helst tilstand avslutter den. Les feilen i Output, rett linjen, og test igjen. En vanlig årsak: skriptet er endret slik at det bruker player.Character.Humanoid uten å sjekke at karakteren finnes.

Lag det med RoCode

Hvis du ikke har lyst til å bygge alt dette for hånd, kan RoCode gjøre det i placen du har åpen. Det er en AI-agent som jobber via en plugin for Roblox Studio, så skript og parts dukker opp i Explorer hos deg og ikke i et chatvindu du må lime dem inn fra.

Du skriver

Legg til et rundesystem: en pause på 20 sekunder som krever 2 spillere, et tilfeldig kart fra ServerStorage.Maps, teleport av alle til spawn-partene i kartet, runder på 2 minutter der den siste levende spilleren vinner, legg til en Win i leaderstats, og vis status og timer øverst på skjermen.

RoCode gjør
  • Kan først se gjennom placen din med List Children, Search Game og Search Scripts for å bruke mappen Maps og leaderstats-skriptet ditt i stedet for å legge til et ekstra sett
  • Lager rundenes Script i ServerScriptService og timerens LocalScript med Create Script, og kan sette inn en arena fra sine ferdige konstruksjoner med Place Prefab hvis du ikke har et kart ennå
  • Sjekker kompileringen av hvert skript inne i Studio med Check Script før den avslutter. Det fanger syntaksfeil, ikke feil i rundelogikken
  • Etter playtesten din leser Check Output Server- og Client-linjene fra den siste playtesten for å rette en kjøretidsfeil

Med plugin 3.9 eller nyere kan RoCode kjøre en kort playtest og lese feilene, og med plugin 3.9.11 eller nyere kan den styre én testfigur, men den tester ikke med flere spillere, så kjør gjennom rundene selv i modusen Server & Clients. Hver pakke med endringer er et angrepunkt i Studio. Rundeløkken ligger til grunn for mange spill, og å lage et helt Roblox-spill med AI, system for system starter ofte med en slik løkke. Slik kobler RoCode seg til Studio.

Ofte stilte spørsmål

Hvordan lager jeg et rundesystem med lag i Roblox?

Legg til Team-objekter i tjenesten Teams, og sett USE_TEAMS = true i rundeskriptet. Roblox fordeler spillere som kommer inn, på det automatisk tildelte laget med færrest medlemmer, og runden slutter når det bare er levende spillere igjen på ett lag.

Hvordan viser jeg en nedtelling til alle spillere?

Sett de gjenværende sekundene fra serveren som et attributt på et objekt i ReplicatedStorage, og lytt etter det med GetAttributeChangedSignal i et LocalScript som oppdaterer en TextLabel, som i steg 3. Spillere som kommer senere, får straks den aktuelle verdien.

Hva skal jeg bruke i rundeløkken: wait() eller task.wait()?

Bruk task.wait(). Roblox merker den globale wait() som utdatert og erstattet av task.wait().

Hvordan teleporterer jeg spillere til en annen place for hver runde?

Det er et annet verktøy. Denne guiden flytter karakterer innenfor én server med PivotTo. Å sende spillere til en annen place i experiencen din gjøres med TeleportService, som flytter dem til en annen server. Teleport-guiden bygger portaler som gjør det, med nye forsøk hvis teleporten feiler.

Hvorfor fryser spillerne et øyeblikk etter teleporten?

Med instance streaming slått på har klienten ikke fått kartet ennå. Kallet RequestStreamAroundAsync i skriptet under "gjør dere klare"-nedtellingen ber motoren sende det på forhånd; en lengre GET_READY_SECONDS gir trege tilkoblinger mer tid.

Kilder og videre lesing

Slik ble koden sjekket: hvert skript på denne siden går gjennom streng Luau-typesjekk med Roblox API-definisjonene (luau-lsp, 20. november 2026). Typesjekken fanger feil i API-navn og feil typer, men ikke feil i spillogikken, så test alt i Studio før du publiserer.

Prøv RoCode i ditt eget spill.

Gratis credits hver dag, uten kort. Installer pluginen, beskriv en funksjon og se hva som dukker opp i Studio.