Tutorial · Spilsystemer

Sådan laver du et rundesystem i Roblox Studio

De fleste rundebaserede spil i Roblox kører den samme løkke: venter på spillere, tæller ned, indlæser et kort, teleporterer alle derhen, kører en timer, vælger en vinder og rydder op. I denne guide bygger vi den løkke som ét overskueligt server-script, tilføjer en timer, som hver spiller kan se, og gennemgår de tilfælde, hvor kopierede scripts går i stykker: spillere, der dør, forlader spillet eller kommer ind midt i en runde.

Opdateret 20. november 202615 min. læsningSkrevet af

Kort fortalt

Skriv ét server-Script i ServerScriptService, der i ring går gennem et fast sæt tilstande: pause (vent på nok spillere, derefter nedtælling), indlæsning af kort (klon et tilfældigt kort fra ServerStorage til Workspace), teleport (flyt hver levende karakter til en spawn-part med PivotTo), runde (lad timeren tikke, indtil tiden er gået, eller der kun er én spiller eller ét hold tilbage) og oprydning (giv Wins, genopliv de overlevende, slet kortet).

  • Kør kun løkken på serveren. Offentliggør status og resterende sekunder som attributter på en Folder i ReplicatedStorage, og lad et LocalScript vise dem.
  • Hold en tabel over dem, der stadig er med i runden. Fjern en spiller, når dens Humanoid dør, dens karakter fjernes, eller den forlader spillet.
  • Teleportér kun de spillere, hvis karakter er i live, når runden starter. Dem, der kommer senere, venter i lobbyen på den næste.
På denne side
  1. Sådan virker det
  2. 1. Lobby og kort
  3. 2. Rundescript
  4. Sådan virker tilstandene
  5. 3. Timer-UI
  6. Spillere midt i en runde
  7. Sådan udvider du
  8. Common errors
  9. Med RoCode
  10. Ofte stillede spørgsmål
  11. Kilder og videre læsning

Sådan virker et rundesystem

IllustrationDe færdige rundescripts i et kørende spil, sat op i tempo.

Et rundesystem er en tilstandsmaskine. På ethvert tidspunkt er serveren i præcis én tilstand, hver tilstand har én opgave, og én betingelse fører den videre til den næste. Når du skriver det sådan, ligger al logikken ét sted, og den klassiske fejl, hvor timerløkken og rundeløkken begge prøver at afslutte den samme runde, opstår ikke.

Rundeløkkens tilstande i denne guide
TilstandHvad serveren gørHvornår den går videre
WaitingViser "Waiting for players (1/2)"Der er nok spillere på serveren
IntermissionTæller ned, mens alle er i lobbyenNedtællingen er slut (eller tilbage til Waiting, hvis spillere gik)
StartingKopierer et tilfældigt kort til Workspace, viser dets navn, beder klienterne indlæse detEn kort "gør jer klar"-nedtælling er slut
InRoundTeleporterer levende spillere, lader timeren tikke, fjerner dem, der døde eller gikTiden er gået, eller der er én spiller eller ét hold tilbage
ResultsGiver en Win til alle, der stadig er i live, og viser, hvem der vandtDer er gået nogle sekunder
CleanupGenopliver de overlevende i lobbyen og sletter kortetMed det samme, hvorefter løkken starter forfra

Serveren ejer hver tilstand. Klienterne viser kun det, serveren fortæller dem. En nedtælling i et LocalScript glider væk fra den rigtige, er forkert for dem, der kommer senere, og kan ændres af en exploiter. Hvis opdelingen i server og klient er ny for dig, så læs først Script vs LocalScript vs ModuleScript.

Trin 1: byg lobbyen, kortene og Wins-statistikken

  1. Byg en lobby i Workspace med en SpawnLocation. Tjek, at egenskaben Neutral er sat, så hver spiller spawner her, venter her og vender tilbage hertil efter at være slået ud.
  2. Indsæt en Folder med navnet Maps i ServerStorage. Objekter i ServerStorage sendes aldrig til spillerne, så ubrugte kort koster dem ingenting.
  3. Byg hvert kort som en Model inde i Maps med ankrede parts. Byg det et godt stykke fra lobbyen (et par hundrede studs er nok), fordi kopien dukker op præcis der, hvor du byggede den, og spillere, der er slået ud, ikke skal kunne gå tilbage ind.
  4. Tilføj inde i hvert kort en Folder med navnet Spawns og i den én ankret Part for hver spiller, du forventer. Sæt deres Transparency til 1, og slå CanCollide fra, så ingen ser dem eller snubler over dem.
Explorer efter denne 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

Rundescriptet lægger 1 til en IntValue med navnet Wins inde i spillerens mappe leaderstats. Hvis dit spil endnu ikke har leaderstats, så tilføj dette korte script. Hvis det allerede har, for eksempel versionen med gemning fra guiden til leaderboards, så spring det over: to scripts, der opretter leaderstats, giver 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 skal være præcis sådan, med små bogstaver

	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 ind, før dette script starter, så vi sætter alle op, der allerede er her
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Disse Wins nulstilles, når spilleren forlader spillet. For at de gemmes mellem sessioner, så brug versionen med DataStore fra guiden til leaderboards.

Trin 2: tilføj rundescriptet

Indsæt et Script i ServerScriptService, kald det RoundSystem, og indsæt koden nedenfor. Indstillingerne øverst er de eneste linjer, du sandsynligvis skal ændre. Hver tilstand er en separat funktion, og løkken nederst kører dem i rækkefø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")

-- Indstillinger
local MIN_PLAYERS = 2 -- sæt 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 der kun er spillere tilbage på ét hold

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

-- Det, hver spillers skærm viser, gemmes i attributter på denne mappe.
-- Attributter, der sættes af serveren, replikeres til alle klienter, også dem, der 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 der stadig er med i den aktuelle runde, og forbindelserne, der holder øje med hver af 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, kun hvis spilleren er i live lige 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

-- Tæller de sider, der er tilbage i runden (spillere eller hold, hvis USE_TEAMS er slået til)
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 gik under nedtællingen.
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. Kopiér et tilfældigt kort (ikke det forrige, hvis der er 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
	-- Bland, så spillerne ikke lander på den samme spawn 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øjt over gulvet root part på en stående karakter befinder sig.
-- Formlen fra Roblox-referencen for Humanoid.HipHeight (på R6-rigs lægges benets højde 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. Gør klar, og teleportér derefter 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ået til beder vi hver klient indlæse kortet, 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

	-- Kun dem, der er i live lige nu, deltager. Resten venter på næste 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]
			-- Karakterens pivot er dens root part, så vi løfter den til ståhøjde 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 gået, eller der er én side tilbage.
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, der startede med én side (test alene), slutter kun på tid eller ved død
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- TILSTAND: Results. Alle, der stadig er i live, vinder.
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 holder op med at følge dem; de bliver på kortet indtil oprydning
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- TILSTAND: Cleanup. Send de overlevende tilbage til lobbyen, og slet derefter kortet.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- stadig 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 gennemgang 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 kort endnu: prøv igen om lidt
		end
	end
end

Alt vigtigt sker her, på serveren: hvem der er med i runden, timeren, vinderen og Wins. Klienterne får kun tre attributter på ReplicatedStorage.RoundInfo (State, Status og TimeLeft) og attributten InRound på hver spiller.

Sådan virker hver tilstand

Venten og pause

runIntermission holder først løkken, indtil #Players:GetPlayers() når MIN_PLAYERS. Derefter tæller den ned ét sekund ad gangen med task.wait(1) og tjekker antallet af spillere ved hvert tik. Hvis nogen gik, og der er færre end minimum på serveren, returnerer den false, og hovedløkken starter forfra med Waiting, så en runde starter aldrig med én person.

Valg og indlæsning af kort

loadMap samler alle Model i ServerStorage.Maps, fjerner kortet fra forrige runde, hvis der er noget at vælge imellem, og tager et med Random:NextInteger. Derefter kloner den kortet til Workspace. Originalen bliver urørt i ServerStorage, så hver runde starter med en frisk kopi: alt, hvad spillerne ødelagde eller flyttede i forrige runde, er væk.

I nye places er instance streaming slået til: klienten har kun parts i nærheden af sin karakter. Før teleporten kalder scriptet Player:RequestStreamAroundAsync for hver spiller, og det beder motoren sende området omkring kortet til klienten under "gør jer klar"-nedtællingen. Uden det kan spillerne ankomme, før gulvet er indlæst, og fryse et øjeblik.

Teleport af spillere med PivotTo

Efter nedtællingen samler scriptet listen over deltagere fra de spillere, hvis karakter findes, stadig er i verden og har en Humanoid med mere end 0 i liv og en root part. Dette tjek sker efter nedtællingen, så den, der døde eller gik under den, kommer ikke med på listen.

Hver deltager flyttes med character:PivotTo(cframe). Roblox-referencen kalder PivotTo den primære måde at flytte modeller fra et script på, og den flytter alle karakterens dele sammen. At sætte HumanoidRootPart.Position er ikke det samme: Roblox tilpasser samlingerne, så kun den ene del flytter sig, og resten af kroppen kan blive tilbage. En karakters pivot er dens root part, så målet er spawn-partens CFrame løftet med halvdelen af partens højde plus den højde, root part står over gulvet. rootHeight beregner den med formlen fra Roblox-referencen for Humanoid.HipHeight: halvdelen af root parts højde plus HipHeight, plus benlængden på R6-rigs. Så sidder skalerede og egne avatarer ikke fast i parten og falder ikke ned på den. CFrame indeholder rotationen, så spillerne kigger samme vej som spawn-parten: drej parterne, så alle kigger mod kortets midte.

Hvis der er flere spillere end spawn-parts, starter scriptet forfra med den første part, og spillerne lander oven på hinanden, så tilføj mindst lige så mange spawns som dit maksimale antal spillere.

Hvis du også bruger hastighedstjekket fra sprint-guiden, så tilføj player:SetAttribute("MovementCheckSkip", true) lige efter character:PivotTo(...) i startRound, så teleporten ikke regnes som for høj hastighed.

Rundetimer og slutbetingelser

runRound tikker én gang i sekundet. Ved hvert tik opdaterer den status (hvor mange spillere der er tilbage) og de resterende sekunder og tæller derefter de levende sider. Runden slutter på en af tre måder:

  • Tiden er gået. for-løkken når 1 og afslutter.
  • Der er én side tilbage. En side er en spiller eller et hold, hvis USE_TEAMS er slået til. Tjekket virker kun, hvis runden startede med to eller flere sider, så en test alene slutter ikke i samme øjeblik, som den startede.
  • Der er ingen tilbage. Alle døde eller gik, og runden slutter uden vinder.

Tjek én gang i sekundet betyder, at runden kan køre op til et sekund efter den sidste er slået ud, hvilket næsten ikke kan mærkes på en rundetimer.

Uddeling af Wins og visning af resultatet

Reglen i dette script er enkel: alle, der er i live, når runden slutter, vinder. Det dækker både den sidste overlevende spiller, det sidste overlevende hold og tilstanden "hold ud, til timeren løber ud" med én linje logik. finishRound lægger 1 til hver vinders Wins, holder op med at følge dem og viser en besked som "Alex wins!" i RESULTS_SECONDS. Hvis du ikke vil have nogen vinder, når tiden løber ud, så spring awardWin over, og ændr beskeden, når sidesLeft er større end 1. Bliv under alle omstændigheder ved med at returnere listen, fordi oprydningen bruger den til at sende de overlevende tilbage til lobbyen.

Oprydning

De overlevende står stadig på kortet, så cleanup genopliver dem i lobbyen med Player:LoadCharacterAsync(), som erstatter den gamle LoadCharacter, og sletter derefter kortets kopi. Hver genoplivning kører i sin egen task.spawn inde i pcall, fordi kaldet venter på, at karakteren indlæses, og kan fejle, hvis spilleren netop forlader spillet i det øjeblik. Spillere, der er slået ud, behøver ingenting: de er allerede selv genopstået i lobbyen.

Trin 3: vis timeren og status til hver spiller

Serveren offentliggør tre attributter på ReplicatedStorage.RoundInfo: State (et fast ord som InRound, til scripts), Status (tekst til mennesker) og TimeLeft (sekunder). Attributter, som et server-script sætter på et replikeret objekt, når automatisk ud til hver klient, og en spiller, der kommer ind midt i en runde, får straks de aktuelle værdier. Derfor egner det sig bedre til en timer end en remote: en RemoteEvent, der blev sendt, før nogen kom ind, når aldrig frem til dem.

  1. Indsæt en ScreenGui i StarterGui i Explorer, og kald den RoundHud. Lad ResetOnSpawn være slået til (standard).
  2. Indsæt et LocalScript i RoundHud, kald det RoundHudClient, og indsæt koden nedenfor. Det opretter selv teksten, så du behøver ikke at tegne noget mere.
  3. Tryk på Play. Teksten øverst på skærmen viser status og nedtælling 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, så slet denne blok, og brug:
-- 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 beskeder brydes over på en anden 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()

Da ResetOnSpawn er slået til, giver Roblox spilleren en frisk kopi af RoundHud ved hver karakterspawn, også ved genoplivningen under oprydning. Scriptet læser så de aktuelle attributter igen, så teksten bliver aldrig forældet.

Klienten læser kun. Intet, spilleren ændrer på sin skærm, påvirker den rigtige timer, fordi ændringer af attributter fra et LocalScript bliver på den ene klient. Til en nedtælling med tiendedele sekunder kan serveren i stedet gemme sluttidspunktet fra workspace:GetServerTimeNow() i en attribut, og hver klient trækker hvert frame sin egen workspace:GetServerTimeNow() fra det.

Hvis dit spil åbner med en hovedmenu, dukker RoundHud op, når spilleren trykker på Play, fordi StarterGui først kopieres til spilleren, efter at karakteren er spawnet. Spillere, der stadig er i menuen, har ingen karakter, så de teleporteres aldrig ind i en runde.

Spillere, der dør, går eller kommer ind midt i en runde

Disse tilfælde er nemme at overse, når man skriver et rundescript første gang. Hvis et af dem ikke håndteres, ser du som regel en fejl i Output eller en runde, der aldrig slutter. Her er, hvad scriptet ovenfor gør med hvert af dem.

Grænsetilfælde, og hvordan rundescriptet håndterer dem
SituationHvad der skerHvor i scriptet
En spiller dør i runden (dræbt, lavede reset, faldt)Spilleren fjernes fra runden og genopstår i lobbyen efter Players.RespawnTime (som standard 5 sekunder).humanoid.Died kalder eliminate
Karakteren fjernes uden at døSom ved død: spilleren er slået ud.player.CharacterRemoving kalder eliminate
En spiller forlader serverenSpilleren fjernes, dens forbindelser afbrydes, og næste tik tæller siderne igen.Players.PlayerRemoving kalder eliminate
En spiller kommer ind midt i en rundeSpilleren spawner i lobbyen, ser den aktuelle status og timer og kommer med i næste runde.Deltagere vælges kun i startRound
En spiller var død, da runden startedeSpilleren teleporteres ikke og venter i lobbyen.getLivingCharacter
Alle gik eller dødeRunden slutter med "Nobody survived", og løkken starter forfra: Intermission, hvis der stadig er nok spillere på serveren, ellers Waiting.sidesLeft == 0 i runRound

eliminate er skrevet, så det er sikkert at kalde den flere gange for den samme spiller. En spiller, der døde og genopstod, udløser både Died og CharacterRemoving, og en, der går, kan udløse alle tre events; kun det første kald gør noget.

Sådan udvider du: hold, afstemning om kort og runde-events

Det sidste overlevende hold

Sæt USE_TEAMS = true, og tilføj derefter Team-objekter i servicen Teams i Explorer, hvert med sit eget navn og TeamColor. Som standard placerer Roblox hver spiller, der kommer ind, på det automatisk tildelte hold med færrest medlemmer. Når spillere går, ombalancerer den ikke holdene, så i lange sessioner kan holdene blive skæve. Lad SpawnLocation i lobbyen være Neutral, så alle hold spawner der. Så slutter runden, når der kun er levende spillere tilbage på ét hold, og resultatet ser ud som "Red wins!".

Til formatet "én mod alle" (én jæger, resten overlever) vælger du i startRound én tilfældig deltager og sætter dens Team til jægerholdet før teleporten. Fjern AutoAssignable fra jægerholdet, så nye spillere aldrig havner der, og sæt i cleanup jægeren tilbage på de overlevendes hold. Så virker de samme slutbetingelser: jægeren vinder, hvis alle overlevende er slået ud, og de overlevende vinder, hvis de holder ud, til timeren er slut, forudsat at du springer jægerens awardWin over, når tiden er gået.

Spillerne stemmer om kortet

Til en afstemning skal klienten tale med serveren, og det kræver en RemoteEvent. Under pausen offentliggør serveren to eller tre kortnavne som attributter, hver klient sender det navn, den klikkede på, via RemoteEvent, og serveren tæller stemmerne, før loadMap kører. Serveren skal tjekke hver stemme: at argumentet er en streng, at det er en af de aktuelle muligheder, at tilstanden er Intermission, og at hver spiller tæller én gang (gem stemmerne i en tabel med Player som nøgle, så en anden stemme erstatter den første, og ryd den i PlayerRemoving). Guiden til RemoteEvent gennemgår dette mønster af tjek i detaljer.

Uddeling af et tool ved rundens start

Andre scripts kan reagere på runden uden at røre RoundSystem. Rundescriptet sætter attributten InRound på hver spiller, når den teleporteres, og fjerner den, når spilleren er slået ud. Dette script lytter efter den og giver hver spiller en kopi af det Tool med navnet RoundTool, der 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

Der er ingen kode, der tager toolet igen. Når en karakter dør, erstatter Roblox Backpack med en frisk, fyldt fra StarterPack, og LoadCharacterAsync under oprydningen tømmer den for de overlevende, så efter runden er toolet allerede væk.

Hvis du har brug for et våben at dele ud, så byg et sværd eller en pistol med raycasts, gem det i ServerStorage i stedet for StarterPack, og erstat "RoundTool" i dette script med dets navn.

NPC'er og andre objekter kun under runden

Alt, der kun skal findes under runden, kan ligge inde i kortmodellen: fjender, genstande til at samle op, bevægelige platforme. Scripts inde i en model i ServerStorage kører ikke; så snart kopien er i Workspace, starter de, og map:Destroy() under oprydningen sletter dem sammen med alt det andet. For at tilføje fjender, der jagter spillere, bygger du en efter guiden til pathfinding for NPC'er og lægger den i kortet. Til en flyvetur over kortet i starten af hver runde viser cutscene-guiden, hvordan dette script kan starte en cutscene for hver spiller via en BindableEvent.

Sådan laver du et modul ud af det

Til at starte med behøver du ikke et ModuleScript. Ét Script er nemmere at læse, mens du bygger spillet. Del det op, når andre scripts skal kalde rundefunktioner, eller når du vil flytte indstillingerne til ét fælles ModuleScript, som både serveren og din UI kan hente med require. Indtil da virker attributten State på RoundInfo og attributten InRound på hver spiller allerede som rundesystemets offentlige grænseflade: ethvert script kan lytte efter dem.

Almindelige fejl og løsninger

Åbn Output-vinduet (via menuen Window i Studio eller fanen Script), før du trykker på Play. De fleste problemer med rundesystemet skriver en advarsel eller en fejl der med scriptets navn og linjenummer.

Hænger på "Waiting for players (1/2)"

Du tester alene, og MIN_PLAYERS er 2. Sæt 1 til test alene, eller test i tilstanden Server & Clients med 2 klienter.

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

Mappen mangler, har en tastefejl i navnet eller ligger i den forkerte service. Det skal være en Folder med navnet præcis Maps direkte inde i ServerStorage. Den samme advarsel for RoundInfo i LocalScriptet betyder, at scriptet RoundSystem aldrig nåede at oprette den: det er slået fra, er gået ned med en fejl eller venter stadig på mappen Maps.

Efter teleporten falder spillerne gennem kortet

Kortets parts er ikke ankret, så kopien falder fra hinanden, så snart den er i Workspace. Markér kortet, ankr dets parts, og tjek, at spawn-parterne står over gulvet og ikke inde i det.

Spillere, der er slået ud, genopstår på arenaen

Der er en SpawnLocation inde i kortet. Erstat den med en almindelig Part i kortets mappe Spawns.

Runden slutter ikke, når alle er døde

Tjek, at din skade faktisk dræber Humanoid (livet når 0) og ikke bare flytter eller ankrer spillerne. Hvis du har slået tilstanden Dead fra på Humanoid, udløses Died aldrig, og runden må køre til timeren er slut.

Rundeløkken stopper for altid efter én fejl

Løkken kører i én tråd, så en fejl i en hvilken som helst tilstand afslutter den. Læs fejlen i Output, ret linjen, og test igen. En almindelig årsag: scriptet er ændret, så det bruger player.Character.Humanoid uden at tjekke, at karakteren findes.

Lav det med RoCode

Hvis du ikke har lyst til at bygge alt det her i hånden, kan RoCode gøre det i det place, du har åbent. Det er en AI-agent, der arbejder via et plugin til Roblox Studio, så scripts og parts dukker op i din Explorer og ikke i et chatvindue, hvorfra du skulle indsætte dem.

Du skriver

Tilføj et rundesystem: en pause på 20 sekunder, der kræver 2 spillere, et tilfældigt kort fra ServerStorage.Maps, teleport af alle til kortets spawn-parts, runder på 2 minutter, hvor den sidste levende spiller vinder, læg en Win til i leaderstats, og vis status og timer øverst på skærmen.

RoCode gør
  • Kan først gennemse dit place med List Children, Search Game og Search Scripts for at bruge din mappe Maps og dit leaderstats-script i stedet for at tilføje et ekstra sæt
  • Opretter rundernes Script i ServerScriptService og timerens LocalScript med Create Script og kan sætte en arena ind fra sine færdige konstruktioner med Place Prefab, hvis du endnu ikke har et kort
  • Tjekker kompileringen af hvert script inde i Studio med Check Script, før den afslutter. Det fanger syntaksfejl, ikke fejl i rundelogikken
  • Efter din playtest læser Check Output Server- og Client-linjerne fra den seneste playtest for at rette en køretidsfejl

Med plugin 3.9 eller nyere kan RoCode køre en kort playtest og læse fejlene, og med plugin 3.9.11 eller nyere kan den styre én testfigur, men den tester ikke med flere spillere, så kør selv runderne igennem i tilstanden Server & Clients. Hver pakke ændringer er et fortrydelsespunkt i Studio. Rundeløkken ligger til grund for mange spil, og at lave et helt Roblox-spil med AI, system for system starter ofte med sådan en løkke. Sådan forbinder RoCode til Studio.

Ofte stillede spørgsmål

Hvordan laver jeg et rundesystem med hold i Roblox?

Tilføj Team-objekter i servicen Teams, og sæt USE_TEAMS = true i rundescriptet. Roblox fordeler spillere, der kommer ind, på det automatisk tildelte hold med færrest medlemmer, og runden slutter, når der kun er levende spillere tilbage på ét hold.

Hvordan viser jeg en nedtælling til alle spillere?

Sæt de resterende sekunder fra serveren som en attribut på et objekt i ReplicatedStorage, og lyt efter den med GetAttributeChangedSignal i et LocalScript, der opdaterer en TextLabel, som i trin 3. Spillere, der kommer senere, får straks den aktuelle værdi.

Hvad skal jeg bruge i rundeløkken: wait() eller task.wait()?

Brug task.wait(). Roblox markerer den globale wait() som forældet og erstattet af task.wait().

Hvordan teleporterer jeg spillere til et andet place for hver runde?

Det er et andet værktøj. Denne guide flytter karakterer inden for én server med PivotTo. At sende spillere til et andet place i din experience sker med TeleportService, der flytter dem til en anden server. Teleport-guiden bygger portaler, der gør det, med nye forsøg, hvis teleporten fejler.

Hvorfor fryser spillerne et øjeblik efter teleporten?

Med instance streaming slået til har klienten endnu ikke fået kortet. Kaldet RequestStreamAroundAsync i scriptet under "gør jer klar"-nedtællingen beder motoren sende det på forhånd; en længere GET_READY_SECONDS giver langsomme forbindelser mere tid.

Kilder og videre læsning

Sådan blev koden tjekket: hvert script på denne side gennemgår streng Luau-typekontrol med Roblox API-definitionerne (luau-lsp, 20. november 2026). Typekontrollen fanger fejl i API-navne og forkerte typer, men ikke fejl i spillogikken, så test alt i Studio, før du udgiver.

Prøv RoCode i dit eget spil.

Gratis credits hver dag, intet kort. Installér pluginet, beskriv en funktion, og se hvad der dukker op i Studio.