Tutorial · Sistemas de jogo

Como fazer um sistema de rounds no Roblox Studio

A maioria dos jogos de rounds no Roblox roda o mesmo loop: espera jogadores, faz a contagem, carrega um mapa, teleporta todo mundo, roda um timer, escolhe um vencedor e arruma tudo. Este guia monta esse loop como um único script de servidor fácil de ler, adiciona um timer que todo jogador vê e cuida dos casos que quebram scripts copiados: jogadores que morrem, saem ou entram no meio de um round.

Atualizado em 14 de novembro de 202616 min de leituraEscrito por

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
  1. Como funciona
  2. 1. Lobby e mapas
  3. 2. Script de round
  4. Como cada estado funciona
  5. 3. UI do timer
  6. Jogadores no meio do round
  7. Indo além
  8. Erros comuns
  9. Com o RoCode
  10. Perguntas frequentes
  11. Fontes e leitura extra

Como funciona um sistema de rounds

IlustraçãoOs scripts de round prontos em um jogo rodando, acelerado.

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.

Os estados do loop de round deste guia
EstadoO que o servidor fazPassa para o próximo quando
WaitingMostra "Waiting for players (1/2)"Há jogadores suficientes no servidor
IntermissionFaz a contagem enquanto todos estão no lobbyA contagem acaba (ou volta para Waiting se jogadores saírem)
StartingCopia um mapa aleatório para o Workspace, mostra o nome dele e pede aos clientes que o carreguemUma contagem curta de "prepare-se" acaba
InRoundTeleporta os jogadores vivos, conta o timer e tira quem morre ou saiO tempo acaba, ou sobra um jogador ou time
ResultsDá uma Win para todos que ainda estão vivos e mostra quem venceuPassam alguns segundos
CleanupFaz os sobreviventes renascerem no lobby e destrói o mapaNa 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

  1. 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.
  2. No ServerStorage, insira uma Folder chamada Maps. Objetos no ServerStorage nunca são enviados aos jogadores, então mapas sem uso não pesam nada para eles.
  3. Monte cada mapa como um Model dentro de Maps, 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.
  4. Dentro de cada mapa, adicione uma Folder chamada Spawns com uma Part ancorada para cada jogador que você espera. Coloque a Transparency delas em 1 e desligue o CanCollide, para ninguém ver nem tropeçar nelas.
O Explorer depois deste guia
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.

Script em ServerScriptService chamado Leaderstats
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.

Script em ServerScriptService chamado RoundSystem
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 for chega a 1 e termina.
  • Sobra um lado. Um lado é um jogador, ou um time quando USE_TEAMS está 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.

  1. No Explorer, insira uma ScreenGui no StarterGui e chame de RoundHud. Deixe o ResetOnSpawn ligado (o padrão).
  2. Insira um LocalScript em RoundHud, chame de RoundHudClient e cole o código abaixo. Ele cria o texto sozinho, então não há mais nada para desenhar.
  3. Aperte Play. O texto no topo da tela mostra o status e uma contagem m:ss.
LocalScript em a ScreenGui RoundHud no StarterGui chamado RoundHudClient
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.

Casos especiais e como o script de round lida com eles
SituaçãoO que aconteceOnde 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 morrerIgual a uma morte: ele está fora.player.CharacterRemoving chama eliminate
Um jogador sai do servidorEle é 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 roundEle 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çouEle não é teleportado e espera no lobby.getLivingCharacter
Todos saem ou morremO 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.

Script em ServerScriptService chamado GiveRoundTool
local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")

local toolTemplate = ServerStorage:WaitForChild("RoundTool") :: Tool

local function watchPlayer(player: Player)
	player:GetAttributeChangedSignal("InRound"):Connect(function()
		if player:GetAttribute("InRound") ~= true then
			return
		end
		local backpack = player:FindFirstChildOfClass("Backpack")
		if backpack then
			toolTemplate:Clone().Parent = backpack
		end
	end)
end

Players.PlayerAdded:Connect(watchPlayer)
for _, player in Players:GetPlayers() do
	watchPlayer(player)
end

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.

Você digita

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.

O RoCode faz
  • 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

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.

Teste o RoCode no seu próprio jogo.

Créditos grátis todo dia, sem cartão. Instale o plugin, descreva o recurso e confira o que aparece no Studio.