Resumo
Escreva um único Script de servidor no ServerScriptService que passa por um conjunto fixo de estados: intermission (espera jogadores suficientes e depois faz a contagem), carregar o mapa (clona um mapa aleatório do ServerStorage para o Workspace), teleporte (move cada personagem vivo para uma part de spawn com PivotTo), round (conta o timer até o tempo acabar ou sobrar um jogador ou time) e limpeza (dá as Wins, faz os sobreviventes renascerem e destrói o mapa).
- Rode o loop só no servidor. Publique o status e os segundos restantes como atributos em uma Folder no ReplicatedStorage, e deixe um LocalScript mostrar esses valores.
- Guarde uma tabela de quem ainda está no round. Tire um jogador quando o Humanoid dele morrer, quando o personagem for removido ou quando ele sair.
- Teleporte só os jogadores com personagem vivo quando o round começa. Quem entrar depois espera no lobby pelo próximo.
Nesta página
Como funciona um sistema de rounds
Um sistema de rounds é uma máquina de estados. Em qualquer momento o servidor está em exatamente um estado, cada estado tem uma função, e uma condição leva ao próximo. Escrever assim deixa a lógica em um lugar só, o que evita o bug clássico de um loop de timer e um loop de round tentando terminar o mesmo round.
| Estado | O que o servidor faz | Passa para o próximo quando |
|---|---|---|
| Waiting | Mostra "Waiting for players (1/2)" | Há jogadores suficientes no servidor |
| Intermission | Faz a contagem enquanto todos estão no lobby | A contagem acaba (ou volta para Waiting se jogadores saírem) |
| Starting | Copia um mapa aleatório para o Workspace, mostra o nome dele e pede aos clientes que o carreguem | Uma contagem curta de "prepare-se" acaba |
| InRound | Teleporta os jogadores vivos, conta o timer e tira quem morre ou sai | O tempo acaba, ou sobra um jogador ou time |
| Results | Dá uma Win para todos que ainda estão vivos e mostra quem venceu | Passam alguns segundos |
| Cleanup | Faz os sobreviventes renascerem no lobby e destrói o mapa | Na hora, e o loop começa de novo |
O servidor controla todos os estados. Os clientes só mostram o que o servidor manda. Uma contagem que roda em um LocalScript se afasta da real, fica errada para quem entra atrasado e pode ser editada por um exploiter. Se a divisão entre servidor e cliente é novidade para você, leia antes Script vs LocalScript vs ModuleScript (em inglês).
Passo 1: Monte o lobby, os mapas e a stat de Wins
- Monte um lobby no Workspace com uma
SpawnLocation. Confira se a propriedade Neutral dela está marcada, para todo jogador nascer aqui, esperar aqui e voltar para cá depois de ser eliminado. - No ServerStorage, insira uma
FolderchamadaMaps. Objetos no ServerStorage nunca são enviados aos jogadores, então mapas sem uso não pesam nada para eles. - Monte cada mapa como um
Modeldentro deMaps, com as parts ancoradas. Construa longe do lobby (algumas centenas de studs bastam), porque a cópia aparece exatamente onde você construiu, e jogadores eliminados não devem conseguir voltar andando. - Dentro de cada mapa, adicione uma
FolderchamadaSpawnscom umaPartancorada para cada jogador que você espera. Coloque a Transparency delas em 1 e desligue o CanCollide, para ninguém ver nem tropeçar nelas.
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
O script de round soma 1 a um IntValue chamado Wins dentro da pasta leaderstats do jogador. Se o seu jogo ainda não tem leaderstats, adicione este script curto. Se você já tem um, por exemplo a versão que salva do guia de leaderboard, pule este: dois scripts criando leaderstats dão duas pastas para cada jogador.
local Players = game:GetService("Players")
local function setupLeaderstats(player: Player)
local leaderstats = Instance.new("Folder")
leaderstats.Name = "leaderstats" -- precisa ser exatamente este nome, tudo minúsculo
local wins = Instance.new("IntValue")
wins.Name = "Wins"
wins.Value = 0
wins.Parent = leaderstats
leaderstats.Parent = player
end
Players.PlayerAdded:Connect(setupLeaderstats)
-- No Studio você pode entrar antes de este script rodar, então prepare quem já está aqui
for _, player in Players:GetPlayers() do
setupLeaderstats(player)
end
Essas Wins zeram quando o jogador sai. Para guardar entre sessões, use a versão com data store do guia de leaderboard.
Passo 2: Adicione o script de round
Insira um Script no ServerScriptService, chame de RoundSystem e cole o código abaixo. As configurações no topo são as únicas linhas que você deve precisar mudar. Cada estado é uma função própria, e o loop no final roda elas em ordem, para sempre.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
-- Configurações
local MIN_PLAYERS = 2 -- use 1 enquanto testa sozinho
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: o round acaba quando só um time ainda tem jogadores
local mapsFolder = ServerStorage:WaitForChild("Maps")
local random = Random.new()
-- O que a tela de cada jogador mostra fica em atributos nesta pasta.
-- Atributos definidos pelo servidor replicam para todos os clientes, inclusive quem entra depois.
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
-- Quem ainda está no round atual, e as conexões que vigiam cada um
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)
-- Retorna o personagem e o humanoid só se o jogador estiver vivo agora
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
-- Conta os lados ainda no round (jogadores, ou times quando USE_TEAMS está ligado)
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
-- ESTADO: Waiting e Intermission. Retorna false se jogadores saíram durante a contagem.
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
-- ESTADO: Starting, parte 1. Copia um mapa aleatório (não o último, se houver escolha).
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
-- Embaralha, para os jogadores não caírem no mesmo spawn todo round
for i = #points, 2, -1 do
local j = random:NextInteger(1, i)
points[i], points[j] = points[j], points[i]
end
return points
end
-- A altura em que a root part de um personagem em pé fica acima do chão.
-- A fórmula vem da referência de Humanoid.HipHeight da Roblox (rigs R6 somam a altura da perna).
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
-- ESTADO: Starting, parte 2. Prepare-se, depois teleporta todos que estão vivos.
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
-- Com streaming ligado, pede a cada cliente que carregue o mapa antes de o personagem chegar
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
-- Só jogadores vivos agora participam. Todos os outros esperam o próximo round.
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]
-- O pivot de um personagem é a root part, então eleva até a altura de quem está em pé sobre a part
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
-- ESTADO: InRound. Acaba quando o tempo esgota ou sobra só um lado.
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()
-- Um round que começou com um lado (um teste sozinho) só acaba pelo tempo ou por morte
if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
break
end
end
end
-- ESTADO: Results. Todos que ainda estão vivos vencem.
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) -- para de vigiar; eles ficam no mapa até a limpeza
end
setState("Results", message)
task.wait(RESULTS_SECONDS)
return winners
end
-- ESTADO: Cleanup. Manda os sobreviventes de volta ao lobby e remove o mapa.
local function cleanup(map: Model, survivors: { Player })
for _, player in survivors do
if player.Parent then -- ainda está no servidor
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
-- O loop: cada volta é um round
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) -- ainda sem mapas: tenta de novo em breve
end
end
end
Tudo o que importa acontece aqui, no servidor: quem está no round, o timer, o vencedor e as Wins. A única coisa que os clientes recebem são três atributos em ReplicatedStorage.RoundInfo (State, Status e TimeLeft) e um atributo InRound em cada jogador.
Como cada estado funciona
Waiting e intermission
Primeiro, runIntermission segura o loop até #Players:GetPlayers() chegar a MIN_PLAYERS. Depois faz a contagem de um em um segundo com task.wait(1), conferindo o número de jogadores a cada tick. Se alguém sai e o servidor fica abaixo do mínimo, ela retorna false e o loop principal recomeça em Waiting, então um round nunca começa com uma pessoa só.
Escolher e carregar um mapa
loadMap junta todo Model em ServerStorage.Maps, tira o que foi usado no último round se houver outro para escolher, e sorteia um com Random:NextInteger. Depois clona o mapa para o Workspace. O original fica intacto no ServerStorage, então todo round começa com uma cópia nova: o que os jogadores quebraram ou moveram no último round some.
Places novos vêm com o instance streaming ligado, o que quer dizer que um cliente só tem as parts perto do personagem dele. Antes do teleporte, o script chama Player:RequestStreamAroundAsync para cada jogador, o que pede à engine que envie para aquele cliente a área em volta do mapa durante a contagem de "prepare-se". Sem isso, jogadores podem chegar antes de o chão carregar e travar por um instante.
Teleportar jogadores com PivotTo
Depois da contagem, o script monta a lista de participantes com os jogadores cujo personagem existe, ainda está no mundo e tem um Humanoid com vida acima de 0 e uma root part. Essa checagem acontece depois da contagem, então quem morreu ou saiu durante ela fica de fora.
Cada participante é movido com character:PivotTo(cframe). A referência da Roblox chama o PivotTo de a principal forma de mover models por script, e ele move todas as parts do personagem juntas. Definir HumanoidRootPart.Position não é a mesma coisa: o Roblox ajusta as juntas para que só aquela part se mova, o que pode deixar o resto do corpo para trás. O pivot de um personagem é a root part dele, então o destino é o CFrame da part de spawn elevado pela metade da altura da part mais a altura em que a root part fica acima do chão. A rootHeight calcula isso com a fórmula da referência de Humanoid.HipHeight da Roblox: metade da altura da root part mais o HipHeight, mais o comprimento da perna em rigs R6. Assim, avatares com escala ou personalizados não caem dentro da part nem despencam em cima dela. Como o CFrame inclui rotação, os jogadores ficam virados para onde a part de spawn está virada, então gire as parts para apontar todo mundo para o centro do mapa.
Se houver mais jogadores do que parts de spawn, o script volta para a primeira part e os jogadores caem uns em cima dos outros, então adicione pelo menos tantos spawns quanto o seu número máximo de jogadores.
Se você também usa a checagem de velocidade do guia de corrida, adicione player:SetAttribute("MovementCheckSkip", true) logo depois de character:PivotTo(...) em startRound, para o teleporte não ser marcado como excesso de velocidade.
O timer do round e as condições de fim
runRound roda uma vez por segundo. A cada tick ela atualiza o status (quantos jogadores restam) e os segundos que faltam, e depois conta os lados ainda vivos. O round acaba de um destes três jeitos:
- O tempo acaba. O loop
forchega a 1 e termina. - Sobra um lado. Um lado é um jogador, ou um time quando
USE_TEAMSestá ligado. A checagem só vale quando o round começou com dois lados ou mais, então um teste sozinho não acaba no momento em que começa. - Não sobra ninguém. Todos morreram ou saíram, então o round acaba sem vencedor.
Conferir uma vez por segundo quer dizer que um round pode durar até um segundo a mais depois da última eliminação, o que quase nunca dá para notar em um timer de round.
Dar Wins e mostrar o resultado
A regra deste script é simples: todos que ainda estão vivos quando o round acaba vencem. Isso cobre último jogador de pé, último time de pé e "sobreviva até o timer acabar" com uma linha de lógica. finishRound soma 1 às Wins de cada vencedor, para de vigiá-los e mostra uma mensagem como "Alex wins!" por RESULTS_SECONDS. Se você quer que um fim por tempo não tenha vencedor, pule o awardWin e mude a mensagem quando sidesLeft for maior que 1. Continue retornando a lista de qualquer jeito, porque a limpeza usa ela para trazer os sobreviventes de volta ao lobby.
Limpeza
Os sobreviventes ainda estão em pé no mapa, então cleanup faz eles renascerem no lobby com Player:LoadCharacterAsync(), que substitui o antigo LoadCharacter, e depois destrói a cópia do mapa. Cada respawn roda no próprio task.spawn dentro de um pcall, porque a chamada espera o personagem carregar e pode falhar se o jogador sair naquele momento. Jogadores eliminados não precisam de nada: eles já renasceram no lobby sozinhos.
Passo 3: Mostre o timer e o status para todo jogador
O servidor publica três atributos em ReplicatedStorage.RoundInfo: State (uma palavra fixa como InRound, para scripts), Status (texto para pessoas) e TimeLeft (segundos). Atributos que um script de servidor define em um objeto replicado chegam a todo cliente automaticamente, e um jogador que entra no meio recebe os valores atuais na hora. Por isso isso funciona melhor que um RemoteEvent para um timer: um RemoteEvent disparado antes de alguém entrar nunca chega a essa pessoa.
- No Explorer, insira uma ScreenGui no StarterGui e chame de
RoundHud. Deixe o ResetOnSpawn ligado (o padrão). - Insira um LocalScript em
RoundHud, chame deRoundHudCliente cole o código abaixo. Ele cria o texto sozinho, então não há mais nada para desenhar. - Aperte Play. O texto no topo da tela mostra o status e uma contagem
m:ss.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local roundInfo = ReplicatedStorage:WaitForChild("RoundInfo")
local screenGui = script.Parent :: ScreenGui
-- O texto. Se você desenhou o seu próprio TextLabel no RoundHud, apague este bloco e use:
-- 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 -- mensagens mais longas usam uma segunda linha
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()
Como o ResetOnSpawn está ligado, o Roblox dá ao jogador uma cópia nova do RoundHud cada vez que o personagem nasce, inclusive no respawn da limpeza. O script então lê os atributos atuais de novo, então o texto nunca fica desatualizado.
O cliente só lê. Nada que um jogador muda na própria tela afeta o timer real, porque mudanças de atributo feitas por um LocalScript ficam naquele único cliente. Para uma contagem que mostra décimos de segundo, o servidor pode guardar em um atributo um horário de fim tirado de workspace:GetServerTimeNow(), e cada cliente subtrai o próprio workspace:GetServerTimeNow() a cada frame.
Se o seu jogo abre em um menu principal, o RoundHud aparece quando o jogador aperta Play, porque o StarterGui só é copiado para um jogador quando o personagem dele nasce. Jogadores que ainda estão no menu não têm personagem, então nunca são teleportados para um round.
Jogadores que morrem, saem ou entram no meio do round
É fácil esquecer esses casos quando se escreve um script de round pela primeira vez. Quando um deles não é tratado, você normalmente vê um erro no Output ou um round que nunca acaba. Veja o que o script acima faz com cada um.
| Situação | O que acontece | Onde no script |
|---|---|---|
| Um jogador morre no round (morto, reset, caiu) | Ele sai do round e renasce no lobby depois de Players.RespawnTime (5 segundos por padrão). | humanoid.Died chama eliminate |
| Um personagem é removido sem morrer | Igual a uma morte: ele está fora. | player.CharacterRemoving chama eliminate |
| Um jogador sai do servidor | Ele é removido, as conexões dele são desconectadas, e o próximo tick reconta os lados. | Players.PlayerRemoving chama eliminate |
| Um jogador entra no meio do round | Ele nasce no lobby, vê o status e o timer ao vivo, e entra no próximo round. | Os participantes só são escolhidos em startRound |
| Um jogador estava morto quando o round começou | Ele não é teleportado e espera no lobby. | getLivingCharacter |
| Todos saem ou morrem | O round acaba com "Nobody survived" e o loop começa de novo: Intermission se ainda houver jogadores suficientes no servidor, Waiting se não houver. | sidesLeft == 0 em runRound |
eliminate foi escrita para ser segura mesmo se for chamada mais de uma vez para o mesmo jogador. Um jogador que morre e depois renasce dispara tanto Died quanto CharacterRemoving, e um que sai pode disparar os três eventos; só a primeira chamada faz alguma coisa.
Indo além: times, votação de mapa e eventos de round
Último time de pé
Defina USE_TEAMS = true e depois adicione objetos Team no serviço Teams no Explorer, cada um com nome e TeamColor próprios. Por padrão o Roblox coloca cada jogador que entra no time auto-atribuível com menos membros. Ele não rebalanceia quando jogadores saem, então times desiguais podem acontecer em sessões longas. Deixe a SpawnLocation do lobby como Neutral para todo time nascer lá. O round então acaba quando só um time tem jogadores vivos, e o resultado mostra "Red wins!".
Para um formato um contra muitos (um caçador, todos os outros sobrevivem), sorteie um participante em startRound e defina o Team dele como um time de caçador antes do teleporte. Desmarque AutoAssignable no time de caçador para jogadores novos nunca caírem nele, e leve o caçador de volta ao time dos sobreviventes em cleanup. As mesmas condições de fim funcionam: o caçador vence se todo sobrevivente estiver fora, e os sobreviventes vencem se durarem até o timer acabar, desde que você pule o awardWin do caçador em um fim por tempo.
Deixar os jogadores votarem no mapa
Uma votação precisa que o cliente fale com o servidor, o que quer dizer um RemoteEvent. Durante a intermission o servidor publica dois ou três nomes de mapa como atributos, cada cliente dispara o RemoteEvent com o nome em que clicou, e o servidor conta os votos antes de loadMap rodar. O servidor precisa conferir todo voto: que o argumento é uma string, que é uma das opções atuais, que o estado é Intermission e que cada jogador conta uma vez (guarde os votos em uma tabela com o Player como chave, para um segundo voto substituir o primeiro, e limpe no PlayerRemoving). O guia de RemoteEvents cobre esse padrão de validação por completo.
Dar uma tool aos jogadores quando o round começa
Outros scripts podem reagir ao round sem mexer no RoundSystem. O script de round define um atributo InRound em cada jogador quando ele é teleportado e limpa quando ele é eliminado. Este script escuta isso e entrega a cada jogador uma cópia de uma Tool chamada RoundTool guardada no 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
Não há código para tirar a tool. Quando um personagem morre, o Roblox troca a Backpack por uma nova preenchida pelo StarterPack, e o LoadCharacterAsync da limpeza esvazia a dos sobreviventes, então a tool some quando o round termina.
Para ter uma arma para entregar, monte a espada ou a arma com raycast (em inglês), guarde no ServerStorage em vez do StarterPack, e troque "RoundTool" neste script pelo nome dela.
NPCs e outros objetos só do round
Qualquer coisa que deve existir só durante um round pode ficar dentro do model do mapa: inimigos, itens para pegar, plataformas que se movem. Scripts dentro de um model no ServerStorage não rodam; quando a cópia está no Workspace eles começam, e o map:Destroy() da limpeza remove eles junto com todo o resto. Para adicionar inimigos que perseguem os jogadores, monte um com o guia de pathfinding de NPC e coloque em um mapa. Para um sobrevoo do mapa no começo de cada round, o guia de cutscene mostra como este script pode iniciar uma cutscene para cada jogador por um BindableEvent.
Transformar em um módulo
Você não precisa de um ModuleScript para começar. Um único Script é mais fácil de ler enquanto você monta o jogo. Divida quando outros scripts precisarem chamar funções do round, ou quando você quiser as configurações em um ModuleScript compartilhado que tanto o servidor quanto a sua UI podem dar require. Até lá, o atributo State em RoundInfo e o atributo InRound em cada jogador já funcionam como a interface pública do sistema de rounds: qualquer script pode escutar os dois.
Erros comuns e como resolver
Abra a janela Output (pelo menu Window do Studio ou pela aba Script) antes de apertar Play. A maioria dos problemas de sistema de rounds mostra um aviso ou um erro ali, com o nome do script e o número da linha.
Travado em "Waiting for players (1/2)"
Você está testando sozinho e MIN_PLAYERS é 2. Coloque 1 para testes sozinho, ou teste com Server & Clients e 2 clientes.
Infinite yield possible on 'ServerStorage:WaitForChild("Maps")'
A pasta está faltando, com o nome errado ou no serviço errado. Ela precisa ser uma Folder chamada exatamente Maps direto dentro do ServerStorage. O mesmo aviso para RoundInfo em um LocalScript quer dizer que o script RoundSystem nunca chegou a criá-la: ele está desativado, deu erro ou ainda está esperando a pasta Maps.
Os jogadores caem através do mapa depois do teleporte
As parts do mapa não estão ancoradas, então a cópia desmonta assim que entra no Workspace. Selecione o mapa, ancore as parts dele e confira se as parts de spawn estão acima do chão, não dentro dele.
Jogadores eliminados renascem dentro da arena
Há uma SpawnLocation dentro de um mapa. Troque por uma Part comum na pasta Spawns do mapa.
O round nunca acaba depois que todos morrem
Confira se o seu dano realmente mata o Humanoid (a vida chega a 0) em vez de mover ou ancorar os jogadores. Se você desativou o estado Dead do humanoid, o Died nunca dispara e o round precisa ir até o fim do timer.
O loop de round para de vez depois de um erro
O loop roda em uma thread só, então um erro dentro de qualquer estado acaba com ele. Leia o erro no Output, corrija a linha e teste de novo. Uma causa comum é editar o script para usar player.Character.Humanoid sem conferir se o personagem existe.
Crie com o RoCode
Se você prefere não montar isso à mão, o RoCode pode construir tudo no jogo que você tem aberto. Ele é um agente de IA que trabalha por um plugin do Roblox Studio, então os scripts e as parts aparecem no seu Explorer em vez de em uma janela de chat para você colar.
Adicione um sistema de rounds: uma intermission de 20 segundos que precisa de 2 jogadores, um mapa aleatório de ServerStorage.Maps, teleporte todo mundo para as parts de spawn do mapa, rounds de 2 minutos em que o último jogador vivo vence, some uma Win no leaderstats e mostre o status e o timer no topo da tela.
- Pode olhar o seu jogo antes com List Children, Search Game e Search Scripts, para usar a sua pasta Maps e o seu script de leaderstats que já existem em vez de adicionar um segundo conjunto
- Cria o Script de round no ServerScriptService e o LocalScript do timer com Create Script, e pode colocar uma arena das estruturas prontas dele com Place Prefab se você ainda não tem mapa
- Checa a compilação de cada script dentro do Studio com Check Script antes de terminar. Isso pega erros de sintaxe, não a lógica do round
- Depois que você testa, o Check Output lê as linhas de Server e Client do seu último teste para poder corrigir um erro em tempo de execução
Com o plugin 3.9 ou mais recente, o RoCode pode rodar um teste curto e ler os erros, e com o plugin 3.9.11 ou mais recente ele pode controlar um personagem de teste, mas ele não testa com vários jogadores, então você mesmo roda os rounds com Server & Clients. Cada lote de mudanças é um ponto de desfazer no Studio. Um loop de round é o núcleo de muitos jogos, e fazer um jogo inteiro de Roblox com IA, sistema por sistema muitas vezes começa por um assim. Como o RoCode se conecta ao Studio.
Perguntas frequentes
Como fazer um sistema de rounds com times no Roblox?
Adicione objetos Team no serviço Teams e defina USE_TEAMS = true no script de round. O Roblox coloca os jogadores que entram no time auto-atribuível com menos membros, e o round acaba quando só um time tem jogadores vivos.
Como mostrar uma contagem regressiva para todos os jogadores?
No servidor, defina os segundos restantes como um atributo em um objeto no ReplicatedStorage, e escute com GetAttributeChangedSignal em um LocalScript que atualiza um TextLabel, como no Passo 3. Quem entra atrasado recebe o valor atual na hora.
Uso wait() ou task.wait() em um loop de round?
Use task.wait(). A Roblox marca o wait() global como deprecated e substituído por task.wait().
Como teleportar os jogadores para outro place a cada round?
Isso é outra ferramenta. Este guia move personagens dentro de um servidor com PivotTo. Mandar jogadores para outro place da sua experiência usa o TeleportService, que leva eles para outro servidor. O guia de teleporte monta portais que fazem isso, com novas tentativas quando um teleporte falha.
Por que os jogadores travam por um instante depois do teleporte?
Com o instance streaming ligado, o cliente ainda não recebeu o mapa. A chamada RequestStreamAroundAsync do script durante a contagem de "prepare-se" pede à engine que envie antes; um GET_READY_SECONDS maior dá mais tempo a conexões lentas.
Fontes e leitura extra
- Roblox Creator Docs: Add rounds (em inglês). o loop de rounds com times da própria Roblox no exemplo de laser tag
- Roblox Creator Docs: PVInstance:PivotTo (em inglês). mover models e personagens por script
- Roblox Creator Docs: Player (em inglês). LoadCharacterAsync, CharacterRemoving e RequestStreamAroundAsync
- Roblox Creator Docs: Properties and attributes (em inglês). definir atributos e detectar mudanças
- Roblox Creator Docs: Implement teams (em inglês). adicionar times e a atribuição automática
- Roblox Creator Docs: Studio testing modes (em inglês). o teste com vários clientes em Server & Clients
Como o código foi verificado: todo script desta página passa no verificador de tipos estrito do Luau com as definições da API do Roblox (luau-lsp, 14 de novembro de 2026). A verificação de tipos pega APIs com nome errado e tipos incorretos, não a lógica do jogo, então teste no Studio antes de publicar.