I korthet
Skriv ett enda Script på servern i ServerScriptService som går runt genom en fast uppsättning tillstånd: paus (vänta på tillräckligt många spelare, sedan nedräkning), laddning av karta (klona en slumpad karta från ServerStorage till Workspace), teleport (flytta varje levande karaktär till en spawn-part med PivotTo), runda (låt timern ticka tills tiden är slut eller det bara är en spelare eller ett lag kvar) och städning (dela ut Wins, låt de överlevande respawna, ta bort kartan).
- Kör cykeln bara på servern. Publicera status och återstående sekunder som attribut på en Folder i ReplicatedStorage, och låt ett LocalScript visa dem.
- Håll en tabell över vilka som fortfarande är med i rundan. Ta bort en spelare när dess Humanoid dör, dess karaktär tas bort eller den lämnar.
- Teleportera bara de spelare vars karaktär lever när rundan startar. Den som går med senare väntar i lobbyn på nästa.
På den här sidan
Så fungerar ett rundsystem
Ett rundsystem är en tillståndsmaskin. Vid varje tidpunkt befinner sig servern i exakt ett tillstånd, varje tillstånd har en uppgift, och ett villkor för det vidare till nästa. Om du skriver det så ligger all logik på ett ställe, och du slipper den klassiska buggen där timerloopen och rundloopen båda försöker avsluta samma runda.
| Tillstånd | Vad servern gör | När den går vidare |
|---|---|---|
| Waiting | Visar "Waiting for players (1/2)" | Det finns tillräckligt många spelare på servern |
| Intermission | Räknar ner tiden medan alla är i lobbyn | Nedräkningen är slut (eller tillbaka till Waiting om spelare lämnade) |
| Starting | Kopierar en slumpad karta till Workspace, visar dess namn, ber klienterna ladda den | En kort "gör dig redo"-nedräkning är slut |
| InRound | Teleporterar levande spelare, låter timern ticka, tar bort dem som dog eller lämnade | Tiden är slut, eller det är bara en spelare eller ett lag kvar |
| Results | Ger en Win till alla som fortfarande lever och visar vem som vann | Några sekunder har gått |
| Cleanup | Låter de överlevande respawna i lobbyn och tar bort kartan | Direkt, därefter börjar cykeln om |
Servern äger varje tillstånd. Klienterna visar bara det som servern säger till dem. En nedräkning i ett LocalScript glider ifrån den riktiga, är fel för dem som går med senare och kan ändras av en exploiter. Om uppdelningen i server och klient är ny för dig, läs först Script vs LocalScript vs ModuleScript.
Steg 1: Bygg lobbyn, kartorna och statistiken Wins
- Bygg en lobby i Workspace med en
SpawnLocation. Kontrollera att egenskapen Neutral är markerad, så att varje spelare spawnar här, väntar här och kommer tillbaka hit efter att ha blivit utslagen. - I ServerStorage, infoga en
Foldersom heterMaps. Objekt i ServerStorage skickas aldrig till spelarna, så kartor som inte används kostar dem ingenting. - Bygg varje karta som en
ModelinutiMaps, med förankrade (anchored) parts. Bygg den en bit bort från lobbyn (några hundra studs räcker), eftersom kopian dyker upp exakt där du byggde den, och utslagna spelare ska inte kunna gå tillbaka in. - Inuti varje karta, lägg till en
Foldersom heterSpawns, och i den en förankradPartför varje spelare du väntar dig. Sätt deras Transparency till 1 och stäng av CanCollide, så att ingen ser dem eller snubblar på dem.
Workspace
Lobby Model
SpawnLocation SpawnLocation
ServerStorage
Maps Folder new
Desert Model new
Spawns Folder new
Spawn1 Part new
Spawn2 Part new
Castle Model new
Spawns Folder new
ServerScriptService
Leaderstats Script new
RoundSystem Script new
StarterGui
RoundHud ScreenGui new
RoundHudClient LocalScript new
Rundskriptet lägger till 1 på ett IntValue som heter Wins inuti spelarens mapp leaderstats. Om ditt spel inte har leaderstats än, lägg till det här korta skriptet. Om det redan finns, till exempel versionen med sparande från guiden om topplistan, hoppa över det: två skript som skapar leaderstats ger varje spelare två mappar.
local Players = game:GetService("Players")
local function setupLeaderstats(player: Player)
local leaderstats = Instance.new("Folder")
leaderstats.Name = "leaderstats" -- namnet måste vara exakt så här, med små bokstäver
local wins = Instance.new("IntValue")
wins.Name = "Wins"
wins.Value = 0
wins.Parent = leaderstats
leaderstats.Parent = player
end
Players.PlayerAdded:Connect(setupLeaderstats)
-- I Studio kan du gå med innan det här skriptet startar, så vi ställer in alla som redan är här
for _, player in Players:GetPlayers() do
setupLeaderstats(player)
end
De här Wins nollställs när spelaren lämnar. För att de ska sparas mellan sessioner, använd versionen med DataStore från guiden om topplistan.
Steg 2: Lägg till rundskriptet
Infoga ett Script i ServerScriptService, döp det till RoundSystem och klistra in koden nedan. Inställningarna överst är de enda rader du troligen behöver ändra. Varje tillstånd är en egen funktion, och loopen längst ner kör dem i ordning, i all oändlighet.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
-- Inställningar
local MIN_PLAYERS = 2 -- sätt 1 medan du testar ensam
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: rundan slutar när spelarna bara finns kvar i ett lag
local mapsFolder = ServerStorage:WaitForChild("Maps")
local random = Random.new()
-- Det som varje spelares skärm visar lagras i attribut på den här mappen.
-- Attribut som servern sätter replikeras till alla klienter, även till dem som gick med senare.
local roundInfo = Instance.new("Folder")
roundInfo.Name = "RoundInfo"
roundInfo.Parent = ReplicatedStorage
local function setState(state: string, status: string)
roundInfo:SetAttribute("State", state)
roundInfo:SetAttribute("Status", status)
roundInfo:SetAttribute("TimeLeft", 0)
end
local function setTimeLeft(seconds: number)
roundInfo:SetAttribute("TimeLeft", seconds)
end
-- Vem som fortfarande är med i den aktuella rundan, och anslutningarna som följer var och en av dem
local alive: { [Player]: boolean } = {}
local watchers: { [Player]: { RBXScriptConnection } } = {}
local function eliminate(player: Player)
if not alive[player] then
return
end
alive[player] = nil
player:SetAttribute("InRound", false)
local connections = watchers[player]
if connections then
for _, connection in connections do
connection:Disconnect()
end
watchers[player] = nil
end
end
Players.PlayerRemoving:Connect(eliminate)
-- Returnerar karaktären och Humanoid bara om spelaren lever just nu
local function getLivingCharacter(player: Player): (Model?, Humanoid?)
local character = player.Character
if not character or not character.Parent then
return nil, nil
end
local humanoid = character:FindFirstChildOfClass("Humanoid")
if not humanoid or humanoid.Health <= 0 or not humanoid.RootPart then
return nil, nil
end
return character, humanoid
end
-- Räknar sidorna som är kvar i rundan (spelare, eller lag om USE_TEAMS är påslaget)
local function countSides(): (number, number)
local sides: { [Instance]: boolean } = {}
local sideCount = 0
local playerCount = 0
for player in alive do
playerCount += 1
local team = player.Team
local side: Instance = if USE_TEAMS and team then team else player
if not sides[side] then
sides[side] = true
sideCount += 1
end
end
return sideCount, playerCount
end
-- TILLSTÅND: Waiting och Intermission. Returnerar false om spelare lämnade under nedräkningen.
local function runIntermission(): boolean
while #Players:GetPlayers() < MIN_PLAYERS do
setState("Waiting", `Waiting for players ({#Players:GetPlayers()}/{MIN_PLAYERS})`)
task.wait(1)
end
setState("Intermission", "Intermission")
for secondsLeft = INTERMISSION_SECONDS, 1, -1 do
if #Players:GetPlayers() < MIN_PLAYERS then
return false
end
setTimeLeft(secondsLeft)
task.wait(1)
end
return true
end
-- TILLSTÅND: Starting, del 1. Kopiera en slumpad karta (inte den förra, om det finns ett val).
local lastMapName = ""
local function loadMap(): Model?
local allMaps: { Model } = {}
local freshMaps: { Model } = {}
for _, child in mapsFolder:GetChildren() do
if child:IsA("Model") then
table.insert(allMaps, child)
if child.Name ~= lastMapName then
table.insert(freshMaps, child)
end
end
end
local choices = if #freshMaps > 0 then freshMaps else allMaps
if #choices == 0 then
warn("RoundSystem: add at least one map Model to ServerStorage > Maps")
return nil
end
local chosen = choices[random:NextInteger(1, #choices)]
lastMapName = chosen.Name
local map = chosen:Clone()
map.Parent = workspace
return map
end
local function getSpawnPoints(map: Model): { BasePart }
local points: { BasePart } = {}
local folder = map:FindFirstChild("Spawns")
if folder then
for _, child in folder:GetChildren() do
if child:IsA("BasePart") then
table.insert(points, child)
end
end
end
-- Blanda, så att spelarna inte hamnar på samma spawn varje runda
for i = #points, 2, -1 do
local j = random:NextInteger(1, i)
points[i], points[j] = points[j], points[i]
end
return points
end
-- På vilken höjd över golvet en stående karaktärs root part befinner sig.
-- Formeln från Roblox referens för Humanoid.HipHeight (R6-riggar lägger till benets höjd).
local function rootHeight(character: Model, humanoid: Humanoid, rootPart: BasePart): number
local height = rootPart.Size.Y / 2 + humanoid.HipHeight
if humanoid.RigType == Enum.HumanoidRigType.R6 then
local leg = character:FindFirstChild("Left Leg")
if leg and leg:IsA("BasePart") then
height += leg.Size.Y
end
end
return height
end
-- TILLSTÅND: Starting, del 2. Gör dig redo, teleportera sedan alla levande.
local function startRound(map: Model): boolean
local spawnPoints = getSpawnPoints(map)
if #spawnPoints == 0 then
warn(`RoundSystem: {map.Name} needs a Spawns folder with at least one part in it`)
return false
end
-- Med streaming påslaget ber vi varje klient att ladda kartan innan karaktären kommer fram
if workspace.StreamingEnabled then
local mapPosition = map:GetPivot().Position
for _, player in Players:GetPlayers() do
task.spawn(function()
pcall(function()
player:RequestStreamAroundAsync(mapPosition, GET_READY_SECONDS)
end)
end)
end
end
setState("Starting", `Map: {map.Name}`)
for secondsLeft = GET_READY_SECONDS, 1, -1 do
setTimeLeft(secondsLeft)
task.wait(1)
end
-- Bara de som lever just nu är med. De andra väntar på nästa runda.
local participants: { Player } = {}
for _, player in Players:GetPlayers() do
if getLivingCharacter(player) then
table.insert(participants, player)
end
end
if #participants < MIN_PLAYERS then
setState("Waiting", "Not enough players, starting over")
task.wait(2)
return false
end
for index, player in participants do
local character, humanoid = getLivingCharacter(player)
local rootPart = if humanoid then humanoid.RootPart else nil
if character and humanoid and rootPart then
local spawnPart = spawnPoints[(index - 1) % #spawnPoints + 1]
-- Karaktärens pivot är dess root part, så vi lyfter den till stående höjd över parten
local height = spawnPart.Size.Y / 2 + rootHeight(character, humanoid, rootPart)
character:PivotTo(spawnPart.CFrame + Vector3.new(0, height, 0))
alive[player] = true
player:SetAttribute("InRound", true)
watchers[player] = {
humanoid.Died:Connect(function()
eliminate(player)
end),
player.CharacterRemoving:Connect(function()
eliminate(player)
end),
}
end
end
return true
end
-- TILLSTÅND: InRound. Slutar när tiden är slut eller bara en sida är kvar.
local function runRound()
setState("InRound", "Round in progress")
local startingSides = countSides()
for secondsLeft = ROUND_SECONDS, 1, -1 do
local _, playersLeft = countSides()
roundInfo:SetAttribute("Status", `{playersLeft} left`)
setTimeLeft(secondsLeft)
task.wait(1)
local sidesLeft = countSides()
-- En runda som startades av en enda sida (test på egen hand) slutar bara när tiden är slut eller vid död
if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
break
end
end
end
-- TILLSTÅND: Results. Alla som fortfarande lever vinner.
local function awardWin(player: Player)
local leaderstats = player:FindFirstChild("leaderstats")
local wins = leaderstats and leaderstats:FindFirstChild("Wins")
if wins and wins:IsA("IntValue") then
wins.Value += 1
end
end
local function finishRound(): { Player }
local sidesLeft = countSides()
local winners: { Player } = {}
for player in alive do
table.insert(winners, player)
end
local message = `{#winners} players survived!`
local firstTeam = if #winners > 0 then winners[1].Team else nil
if #winners == 0 then
message = "Nobody survived"
elseif USE_TEAMS and sidesLeft == 1 and firstTeam then
message = `{firstTeam.Name} wins!`
elseif #winners == 1 then
message = `{winners[1].DisplayName} wins!`
end
for _, player in winners do
awardWin(player)
eliminate(player) -- vi slutar följa dem; de stannar kvar på kartan tills städningen
end
setState("Results", message)
task.wait(RESULTS_SECONDS)
return winners
end
-- TILLSTÅND: Cleanup. Skicka de överlevande tillbaka till lobbyn och ta sedan bort kartan.
local function cleanup(map: Model, survivors: { Player })
for _, player in survivors do
if player.Parent then -- fortfarande på servern
task.spawn(function()
local ok, err = pcall(function()
player:LoadCharacterAsync()
end)
if not ok then
warn(`RoundSystem: could not respawn {player.Name}: {err}`)
end
end)
end
end
map:Destroy()
end
-- Loopen: ett varv är en runda
while true do
if runIntermission() then
local map = loadMap()
if map then
local survivors: { Player } = {}
if startRound(map) then
runRound()
survivors = finishRound()
end
cleanup(map, survivors)
else
task.wait(5) -- inga kartor än: vi försöker igen snart
end
end
end
Allt viktigt händer här, på servern: vem som är med i rundan, timern, vinnaren och Wins. Klienterna får bara tre attribut på ReplicatedStorage.RoundInfo (State, Status och TimeLeft) och attributet InRound på varje spelare.
Så fungerar varje tillstånd
Väntan och paus
runIntermission håller först cykeln tills #Players:GetPlayers() når MIN_PLAYERS. Sedan räknar den ner en sekund i taget med task.wait(1) och kontrollerar antalet spelare vid varje tick. Om någon lämnar och servern hamnar under minimum returnerar den false, och huvudloopen börjar om från Waiting, så en runda startar aldrig med en enda person.
Välja och ladda kartan
loadMap samlar alla Model i ServerStorage.Maps, tar bort förra rundans karta om det finns något annat att välja mellan, och väljer en med Random:NextInteger. Sedan klonar den kartan till Workspace. Originalet ligger kvar orört i ServerStorage, så varje runda börjar med en ny kopia: allt som spelarna förstörde eller flyttade förra rundan försvinner.
I nya places är instance streaming påslaget: klienten har bara de parts som finns nära dess karaktär. Före teleporten anropar skriptet Player:RequestStreamAroundAsync för varje spelare, och det ber motorn att skicka området runt kartan till klienten under "gör dig redo"-nedräkningen. Utan det kan spelare komma fram innan golvet har laddats och frysa en kort stund.
Teleportera spelare med PivotTo
Efter nedräkningen gör skriptet en lista över deltagare av de spelare vars karaktär finns, fortfarande är i världen och har en Humanoid med hälsa över 0 och en root part. Den kontrollen görs efter nedräkningen, så den som dog eller lämnade under den kommer inte med på listan.
Varje deltagare flyttas med character:PivotTo(cframe). Roblox referens kallar PivotTo det huvudsakliga sättet att flytta modeller från ett skript, och den flyttar alla delar av karaktären tillsammans. Att sätta HumanoidRootPart.Position är inte samma sak: Roblox justerar fogarna så att bara just den delen flyttas, och resten av kroppen kan bli kvar. En karaktärs pivot är dess root part, så målet är spawn-partens CFrame, upplyft med halva partens höjd plus höjden som root part står på ovanför golvet. rootHeight räknar ut den med formeln från Roblox referens för Humanoid.HipHeight: halva höjden av root part plus HipHeight, plus benets längd för R6-riggar. På så sätt fastnar skalade och anpassade avatarer inte i parten och faller inte ner på den ovanifrån. CFrame innehåller rotationen, så spelarna tittar åt samma håll som spawn-parten: vrid parterna så att alla tittar mot kartans mitt.
Om det finns fler spelare än spawn-parts börjar skriptet om från den första parten, och spelarna hamnar ovanpå varandra, så lägg till minst lika många spawns som ditt högsta antal spelare.
Om du också använder hastighetskontrollen från guiden om sprint, lägg till player:SetAttribute("MovementCheckSkip", true) direkt efter character:PivotTo(...) i startRound, så att teleporten inte räknas som för hög hastighet.
Rundtimer och villkor för slut
runRound tickar en gång i sekunden. Vid varje tick uppdaterar den status (hur många spelare som är kvar) och de återstående sekunderna och räknar sedan de levande sidorna. Rundan slutar på ett av tre sätt:
- Tiden är slut.
for-loopen når 1 och avslutas. - En sida är kvar. En sida är en spelare, eller ett lag om
USE_TEAMSär påslaget. Kontrollen fungerar bara om rundan startade med två eller fler sidor, så ett test på egen hand slutar inte i samma ögonblick som det började. - Ingen är kvar. Alla dog eller lämnade, och rundan slutar utan vinnare.
En kontroll i sekunden betyder att rundan kan pågå upp till en sekund efter den sista utslagningen, och på en rundtimer märks det knappt.
Dela ut Wins och visa resultatet
Regeln i det här skriptet är enkel: alla som lever när rundan slutar vinner. Det täcker både den sista överlevande spelaren, det sista överlevande laget och läget "håll ut tills timern tar slut" med en enda rad logik. finishRound lägger till 1 på varje vinnares Wins, slutar följa dem och visar ett meddelande som "Alex wins!" i RESULTS_SECONDS. Om du vill att det inte ska bli någon vinnare när tiden tar slut, hoppa över awardWin och ändra meddelandet när sidesLeft är större än 1. Fortsätt i alla fall att returnera listan, eftersom städningen använder den för att skicka tillbaka de överlevande till lobbyn.
Städning
De överlevande står fortfarande på kartan, så cleanup låter dem respawna i lobbyn med Player:LoadCharacterAsync(), som ersätter det gamla LoadCharacter, och tar sedan bort kopian av kartan. Varje respawn körs i sin egen task.spawn inuti pcall, eftersom anropet väntar på att karaktären laddas och kan misslyckas om spelaren lämnar just då. Utslagna spelare behöver ingenting: de har redan respawnat i lobbyn av sig själva.
Steg 3: Visa timern och statusen för varje spelare
Servern publicerar tre attribut på ReplicatedStorage.RoundInfo: State (ett fast ord som InRound, för skript), Status (text för människor) och TimeLeft (sekunder). Attribut som ett serverskript sätter på ett replikerat objekt når automatiskt varje klient, och en spelare som går med mitt i en runda får direkt de aktuella värdena. Därför passar det bättre för en timer än en remote: ett RemoteEvent som skickades innan någon gick med når aldrig fram till den personen.
- I Explorer, infoga en ScreenGui i StarterGui och döp den till
RoundHud. Låt ResetOnSpawn vara påslaget (standard). - Infoga ett LocalScript i
RoundHud, döp det tillRoundHudClientoch klistra in koden nedan. Det skapar texten själv, så du behöver inte rita något mer. - Klicka på Play. Texten överst på skärmen visar status och nedräkning i formatet
m:ss.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local roundInfo = ReplicatedStorage:WaitForChild("RoundInfo")
local screenGui = script.Parent :: ScreenGui
-- Texten. Om du har ritat en egen TextLabel i RoundHud, ta bort det här blocket och använd:
-- local label = screenGui:WaitForChild("StatusLabel") :: TextLabel
local label = Instance.new("TextLabel")
label.Name = "StatusLabel"
label.AnchorPoint = Vector2.new(0.5, 0)
label.Position = UDim2.new(0.5, 0, 0, 12)
label.Size = UDim2.fromOffset(320, 44)
label.BackgroundColor3 = Color3.fromRGB(20, 14, 32)
label.BackgroundTransparency = 0.2
label.TextColor3 = Color3.new(1, 1, 1)
label.Font = Enum.Font.BuilderSansBold
label.TextSize = 22
label.TextWrapped = true -- långa meddelanden bryts till en andra rad
label.Text = ""
label.Parent = screenGui
local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(0, 10)
corner.Parent = label
local function formatTime(seconds: number): string
return string.format("%d:%02d", seconds // 60, seconds % 60)
end
local function update()
local status = roundInfo:GetAttribute("Status")
local timeLeft = roundInfo:GetAttribute("TimeLeft")
local text = if type(status) == "string" then status else ""
if type(timeLeft) == "number" and timeLeft > 0 then
text ..= " " .. formatTime(timeLeft)
end
label.Text = text
end
roundInfo:GetAttributeChangedSignal("Status"):Connect(update)
roundInfo:GetAttributeChangedSignal("TimeLeft"):Connect(update)
update()
Eftersom ResetOnSpawn är påslaget ger Roblox spelaren en ny kopia av RoundHud varje gång karaktären spawnar, även vid respawn under städningen. Skriptet läser då de aktuella attributen igen, så texten blir aldrig inaktuell.
Klienten läser bara. Inget som spelaren ändrar på sin skärm påverkar den riktiga timern, eftersom ändringar av attribut från ett LocalScript stannar på just den klienten. För en nedräkning med tiondels sekunder kan servern i stället spara sluttiden från workspace:GetServerTimeNow() i ett attribut, och varje klient drar varje bildruta av sin egen workspace:GetServerTimeNow() från den.
Om ditt spel öppnas med en huvudmeny dyker RoundHud upp när spelaren klickar på Play, eftersom StarterGui kopieras till spelaren först när karaktären har spawnat. Spelare som fortfarande är i menyn har ingen karaktär, så de teleporteras aldrig in i en runda.
Spelare som dör, lämnar eller går med mitt i en runda
De här fallen är lätta att missa när man skriver ett rundskript för första gången. Om något av dem inte hanteras ser du oftast ett fel i Output eller en runda som aldrig tar slut. Så här hanterar skriptet ovan vart och ett av dem.
| Situation | Vad som händer | Var i skriptet |
|---|---|---|
| En spelare dör i rundan (dödad, återställde sig, föll) | Spelaren tas bort ur rundan och respawnar i lobbyn efter Players.RespawnTime (5 sekunder som standard). | humanoid.Died anropar eliminate |
| Karaktären tas bort utan att dö | Som vid död: spelaren är utslagen. | player.CharacterRemoving anropar eliminate |
| En spelare lämnar servern | Spelaren tas bort, dess anslutningar kopplas från, och nästa tick räknar om sidorna. | Players.PlayerRemoving anropar eliminate |
| En spelare går med mitt i en runda | Spelaren spawnar i lobbyn, ser den levande statusen och timern och kommer med i nästa runda. | Deltagarna väljs bara i startRound |
| En spelare var död när rundan startade | Spelaren teleporteras inte utan väntar i lobbyn. | getLivingCharacter |
| Alla lämnade eller dog | Rundan slutar med "Nobody survived", och cykeln börjar om: Intermission om det fortfarande finns tillräckligt många spelare på servern, annars Waiting. | sidesLeft == 0 i runRound |
eliminate är skrivet så att det är säkert att anropa flera gånger för samma spelare. En spelare som dog och respawnade utlöser både Died och CharacterRemoving, och den som lämnar kan utlösa alla tre eventen; bara det första anropet gör något.
Så bygger du ut det: lag, kartröstning och rundevent
Det sista överlevande laget
Sätt USE_TEAMS = true och lägg sedan till Team-objekt i tjänsten Teams i Explorer, vart och ett med sitt eget namn och TeamColor. Som standard placerar Roblox varje spelare som går med i det automatiskt tilldelade laget med minst antal medlemmar. När spelare lämnar balanserar det inte om lagen, så under långa sessioner kan lagen bli ojämna. Låt SpawnLocation i lobbyn vara Neutral, så att alla lag spawnar där. Då slutar rundan när de levande spelarna bara finns i ett lag, och resultatet ser ut som "Red wins!".
För formatet "en mot alla" (en jägare, resten överlever), välj en slumpad deltagare i startRound och sätt före teleporten dess Team till jägarlaget. Stäng av AutoAssignable för jägarlaget, så att nya spelare aldrig hamnar där, och flytta i cleanup tillbaka jägaren till de överlevandes lag. Då fungerar samma villkor för slut: jägaren vinner om alla överlevande slagits ut, och de överlevande vinner om de håller ut tills timern tar slut, förutsatt att du hoppar över jägarens awardWin när tiden är slut.
Spelarna röstar på kartan
För en röstning måste klienten kommunicera med servern, och då behövs ett RemoteEvent. Under pausen publicerar servern två eller tre kartnamn som attribut, varje klient skickar namnet den klickade på via RemoteEvent, och servern räknar rösterna innan loadMap körs. Servern måste kontrollera varje röst: att argumentet är en sträng, att det är ett av de aktuella alternativen, att tillståndet är Intermission och att varje spelare räknas en gång (spara rösterna i en tabell med Player som nyckel, så att en andra röst ersätter den första, och töm den i PlayerRemoving). Guiden om RemoteEvent går igenom det här mönstret för kontroller i detalj.
Dela ut ett verktyg när rundan börjar
Andra skript kan reagera på rundan utan att röra RoundSystem. Rundskriptet sätter attributet InRound på varje spelare när den teleporteras och tar bort det när spelaren slås ut. Det här skriptet lyssnar på det och ger varje spelare en kopia av ett Tool som heter RoundTool och ligger i ServerStorage.
local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")
local toolTemplate = ServerStorage:WaitForChild("RoundTool") :: Tool
local function watchPlayer(player: Player)
player:GetAttributeChangedSignal("InRound"):Connect(function()
if player:GetAttribute("InRound") ~= true then
return
end
local backpack = player:FindFirstChildOfClass("Backpack")
if backpack then
toolTemplate:Clone().Parent = backpack
end
end)
end
Players.PlayerAdded:Connect(watchPlayer)
for _, player in Players:GetPlayers() do
watchPlayer(player)
end
Det finns ingen kod som tar tillbaka verktyget. När karaktären dör ersätter Roblox Backpack med en ny, fylld från StarterPack, och LoadCharacterAsync under städningen tömmer den för de överlevande, så efter rundan finns verktyget inte längre kvar.
Om du behöver ett vapen att dela ut, bygg ett svärd eller en pistol med raycasts, förvara det i ServerStorage i stället för StarterPack och byt "RoundTool" i det här skriptet mot dess namn.
NPC:er och andra objekt bara under rundan
Allt som bara ska finnas under en runda kan ligga inuti kartans modell: fiender, föremål att plocka upp, rörliga plattformar. Skript inuti en modell i ServerStorage körs inte; så snart kopian hamnar i Workspace startar de, och map:Destroy() under städningen tar bort dem tillsammans med allt annat. För att lägga till fiender som jagar spelarna, bygg en med guiden om pathfinding för NPC:er och lägg den i kartan. För en kameraflygning över kartan i början av varje runda visar guiden om cutscenes hur det här skriptet kan starta en cutscene för varje spelare via ett BindableEvent.
Så gör du en modul av det
Till att börja med behövs inget ModuleScript. Ett enda Script är lättare att läsa medan du bygger spelet. Dela upp det när andra skript behöver anropa rundans funktioner eller när du vill flytta inställningarna till ett gemensamt ModuleScript som både servern och ditt UI kan hämta med require. Fram till dess fungerar attributet State på RoundInfo och attributet InRound på varje spelare redan som rundsystemets publika gränssnitt: vilket skript som helst kan lyssna på dem.
Vanliga fel och lösningar
Öppna fönstret Output (via menyn Window i Studio eller fliken Script) innan du klickar på Play. De flesta problem med rundsystemet skriver ut en varning eller ett fel där, med skriptets namn och radnummer.
Fastnar på "Waiting for players (1/2)"
Du testar ensam, och MIN_PLAYERS är 2. Sätt 1 för tester på egen hand, eller testa i läget Server & Clients med 2 klienter.
Infinite yield possible on 'ServerStorage:WaitForChild("Maps")'
Mappen finns inte, har ett felstavat namn eller ligger i fel tjänst. Det måste vara en Folder som heter exakt Maps direkt inuti ServerStorage. Samma varning för RoundInfo i ett LocalScript betyder att skriptet RoundSystem aldrig kom fram till att skapa den: det är avstängt, kraschade med ett fel eller väntar fortfarande på mappen Maps.
Spelarna faller genom kartan efter teleporten
Kartans parts är inte förankrade, så kopian faller isär så snart den hamnar i Workspace. Markera kartan, förankra dess parts och kontrollera att spawn-parterna står ovanför golvet och inte inuti det.
Utslagna spelare respawnar på arenan
Det finns en SpawnLocation inuti kartan. Byt ut den mot en vanlig Part i kartans mapp Spawns.
Rundan tar inte slut när alla har dött
Kontrollera att din skada verkligen dödar Humanoid (hälsan når 0) och inte flyttar eller förankrar spelarna. Om du har stängt av tillståndet Dead för Humanoid utlöses Died aldrig, och rundan måste köras tills timern tar slut.
Rundcykeln stannar för gott efter ett enda fel
Cykeln körs i en enda tråd, så ett fel i vilket tillstånd som helst avslutar den. Läs felet i Output, rätta raden och testa igen. En vanlig orsak: skriptet har ändrats så att det använder player.Character.Humanoid utan att kontrollera att karaktären finns.
Gör det med RoCode
Om du inte vill bygga allt det här för hand kan RoCode göra det i den place du har öppen. Det är en AI-agent som arbetar via ett plugin för Roblox Studio, så skripten och parterna dyker upp i din Explorer och inte i ett chattfönster som du skulle behöva klistra in dem från.
Lägg till ett rundsystem: en paus på 20 sekunder som kräver 2 spelare, en slumpad karta från ServerStorage.Maps, teleportera alla till kartans spawn-parts, rundor på 2 minuter där den sista levande spelaren vinner, lägg till en Win i leaderstats och visa status och timer överst på skärmen.
- Kan först titta igenom din place med List Children, Search Game och Search Scripts för att använda din Maps-mapp och ditt leaderstats-skript i stället för att lägga till en andra uppsättning
- Skapar rundans Script i ServerScriptService och timerns LocalScript med Create Script, och kan placera en arena från sina färdiga konstruktioner med Place Prefab om du inte har någon karta än
- Kontrollerar att varje skript kompilerar inuti Studio med Check Script innan den avslutar. Det fångar syntaxfel, inte fel i rundans logik
- Efter ditt speltest läser Check Output raderna Server och Client från det senaste speltestet för att rätta ett fel under körning
Med plugin 3.9 eller nyare kan RoCode köra ett kort speltest och läsa felen, och med plugin 3.9.11 eller nyare kan den styra en enda testkaraktär, men den testar inte med flera spelare, så kör rundorna själv i läget Server & Clients. Varje omgång ändringar är en ångrapunkt i Studio. En rundcykel ligger till grund för många spel, och att skapa ett helt Roblox-spel med AI, system för system börjar ofta med en sådan cykel. Så ansluter RoCode till Studio.
Vanliga frågor
Hur gör jag ett rundsystem med lag i Roblox?
Lägg till Team-objekt i tjänsten Teams och sätt USE_TEAMS = true i rundskriptet. Roblox fördelar spelare som går med till det automatiskt tilldelade laget med minst antal medlemmar, och rundan slutar när de levande spelarna bara finns i ett lag.
Hur visar jag en nedräkning för alla spelare?
Sätt de återstående sekunderna från servern som ett attribut på ett objekt i ReplicatedStorage och lyssna på det med GetAttributeChangedSignal i ett LocalScript som uppdaterar en TextLabel, som i steg 3. Spelare som går med senare får direkt det aktuella värdet.
Ska jag använda wait() eller task.wait() i en rundloop?
Använd task.wait(). Roblox markerar den globala wait() som föråldrad och ersatt av task.wait().
Hur teleporterar jag spelare till en annan place för varje runda?
Det är ett annat verktyg. Den här guiden flyttar karaktärer inom samma server med PivotTo. Att skicka spelare till en annan place i din experience görs med TeleportService, som flyttar dem till en annan server. Guiden om teleporter bygger portaler som gör det, med nya försök om teleporten misslyckas.
Varför fryser spelarna en kort stund efter teleporten?
Med instance streaming påslaget har klienten ännu inte fått kartan. Anropet RequestStreamAroundAsync i skriptet under "gör dig redo"-nedräkningen ber motorn att skicka den i förväg; en längre GET_READY_SECONDS ger långsamma anslutningar mer tid.
Källor och vidare läsning
- Roblox Creator Docs: Add rounds (på engelska). Roblox egen lagbaserade rundcykel i exemplet med lasertag
- Roblox Creator Docs: PVInstance:PivotTo (på engelska). flytta modeller och karaktärer från ett skript
- Roblox Creator Docs: Player (på engelska). LoadCharacterAsync, CharacterRemoving och RequestStreamAroundAsync
- Roblox Creator Docs: Properties and attributes (på engelska). sätta attribut och följa ändringar
- Roblox Creator Docs: Implement teams (på engelska). lägga till lag och automatisk tilldelning
- Roblox Creator Docs: Studio testing modes (på engelska). test med flera klienter, Server & Clients
Så kontrollerades koden: varje skript på den här sidan klarar strikt Luau-typkontroll mot Roblox API-definitionerna (luau-lsp, 20 november 2026). Typkontrollen fångar felstavade API-namn och fel typer, men inte fel i spellogiken, så testa allt i Studio innan du publicerar.