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
Slik fungerer et rundesystem
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.
| Tilstand | Hva serveren gjør | Når den går videre |
|---|---|---|
| Waiting | Viser "Waiting for players (1/2)" | Det er nok spillere på serveren |
| Intermission | Teller ned mens alle er i lobbyen | Nedtellingen er ferdig (eller tilbake til Waiting hvis spillere gikk) |
| Starting | Kopierer et tilfeldig kart til Workspace, viser navnet, ber klientene laste det | En kort "gjør dere klare"-nedtelling er ferdig |
| InRound | Teleporterer levende spillere, lar timeren gå, fjerner dem som døde eller gikk | Tiden er ute, eller det er én spiller eller ett lag igjen |
| Results | Gir en Win til alle som fortsatt lever, og viser hvem som vant | Det har gått noen sekunder |
| Cleanup | Gjenoppliver de overlevende i lobbyen og sletter kartet | Med 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
- 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. - Sett inn en
Foldermed navnetMapsi ServerStorage. Objekter i ServerStorage sendes aldri til spillerne, så ubrukte kart koster dem ingenting. - Bygg hvert kart som en
Modelinne iMapsmed 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. - Legg inn en
Foldermed navnetSpawnsinne i hvert kart, og i den én ankretPartfor hver spiller du forventer. Sett Transparency på dem til 1, og slå av CanCollide, slik at ingen ser dem eller snubler i dem.
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.
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.
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_TEAMSer 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.
- Sett inn en ScreenGui i StarterGui i Explorer, og kall den
RoundHud. La ResetOnSpawn være slått på (standard). - Sett inn et LocalScript i
RoundHud, kall detRoundHudClient, og lim inn koden nedenfor. Det lager teksten selv, så du trenger ikke tegne noe mer. - Trykk Play. Teksten øverst på skjermen viser status og nedtelling i formatet
m:ss.
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.
| Situasjon | Hva som skjer | Hvor 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 serveren | Spilleren fjernes, tilkoblingene kobles fra, og neste tikk teller sidene på nytt. | Players.PlayerRemoving kaller eliminate |
| En spiller kommer inn midt i en runde | Spilleren 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 startet | Spilleren teleporteres ikke og venter i lobbyen. | getLivingCharacter |
| Alle gikk eller døde | Runden 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.
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.
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.
- 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
- Roblox Creator Docs: Add rounds (på engelsk). Roblox sin egen lagbaserte rundeløkke i laser tag-eksempelet
- Roblox Creator Docs: PVInstance:PivotTo (på engelsk). flytting av modeller og karakterer fra et skript
- Roblox Creator Docs: Player (på engelsk). LoadCharacterAsync, CharacterRemoving og RequestStreamAroundAsync
- Roblox Creator Docs: Properties and attributes (på engelsk). sett attributter, og hold øye med endringer
- Roblox Creator Docs: Implement teams (på engelsk). å legge til lag og automatisk tildeling
- Roblox Creator Docs: Studio testing modes (på engelsk). test med flere klienter, Server & Clients
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.