Tutorial · Sistemas de juego

Cómo hacer un sistema de rondas en Roblox Studio

La mayoría de los juegos de Roblox por rondas usan el mismo bucle: esperar jugadores, contar hacia atrás, cargar un mapa, teletransportar a todos, correr un timer, coronar a un ganador y limpiar. Esta guía construye ese bucle como un solo script del servidor fácil de leer, añade un timer que ve cada jugador y cubre los casos que rompen los scripts copiados: jugadores que mueren, se van o entran a mitad de una ronda.

Actualizado el 14 de noviembre de 202617 min de lecturaEscrito por

La respuesta corta

Escribe un solo Script del servidor en ServerScriptService que recorre un conjunto fijo de estados: intermedio (esperar a que haya suficientes jugadores y luego contar hacia atrás), carga del mapa (clonar un mapa al azar de ServerStorage a Workspace), teletransporte (mover cada personaje vivo a una parte de spawn con PivotTo), ronda (avanzar un timer hasta que se acabe el tiempo o quede un solo jugador o equipo) y limpieza (dar Wins, hacer reaparecer a los supervivientes y destruir el mapa).

  • Corre el bucle solo en el servidor. Publica el estado y los segundos que quedan como atributos de una Folder en ReplicatedStorage, y deja que un LocalScript los muestre.
  • Guarda una tabla con quién sigue en la ronda. Quita a un jugador cuando su Humanoid muere, cuando se quita su personaje o cuando se va.
  • Teletransporta solo a los jugadores cuyo personaje está vivo cuando empieza la ronda. Quien entre después espera en el lobby a la siguiente.
En esta página
  1. Cómo funciona
  2. 1. Lobby y mapas
  3. 2. Script de rondas
  4. Cada estado
  5. 3. UI del timer
  6. A mitad de ronda
  7. Ampliarlo
  8. Errores comunes
  9. Con RoCode
  10. Preguntas frecuentes
  11. Fuentes y lecturas

Cómo funciona un sistema de rondas

IlustraciónLos scripts de rondas terminados en un juego en marcha, acelerado.

Un sistema de rondas es una máquina de estados. En cada momento el servidor está exactamente en un estado, cada estado tiene una sola tarea y una condición lo pasa al siguiente. Escribirlo así deja la lógica en un solo lugar, y eso evita el bug clásico de un bucle del timer y un bucle de la ronda que intentan terminar la misma ronda.

Los estados del bucle de rondas de esta guía
EstadoQué hace el servidorPasa al siguiente cuando
WaitingMuestra "Waiting for players (1/2)"Hay suficientes jugadores en el servidor
IntermissionCuenta hacia atrás mientras todos están en el lobbyTermina la cuenta atrás (o vuelve a Waiting si se van jugadores)
StartingCopia un mapa al azar a Workspace, muestra su nombre y pide a los clientes que lo carguenTermina una cuenta atrás corta de "prepárate"
InRoundTeletransporta a los jugadores vivos, avanza el timer y saca a los que mueren o se vanSe acaba el tiempo, o queda un solo jugador o equipo
ResultsDa un Win a todos los que siguen vivos y muestra quién ganóPasan unos segundos
CleanupHace reaparecer a los supervivientes en el lobby y destruye el mapaEnseguida, y luego el bucle vuelve a empezar

El servidor es dueño de cada estado. Los clientes solo muestran lo que el servidor les dice. Una cuenta atrás que corre en un LocalScript se desfasa de la real, está mal para los jugadores que entran tarde y un exploiter la puede editar. Si la separación entre servidor y cliente es nueva para ti, lee primero Script vs LocalScript vs ModuleScript (en inglés).

Paso 1: Construye el lobby, los mapas y el stat Wins

  1. Construye un lobby en Workspace con una SpawnLocation. Asegúrate de que su propiedad Neutral esté marcada, para que cada jugador aparezca aquí, espere aquí y vuelva aquí cuando lo eliminen.
  2. En ServerStorage, inserta una Folder llamada Maps. Los objetos de ServerStorage nunca se envían a los jugadores, así que los mapas que no se usan no les cuestan nada.
  3. Construye cada mapa como un Model dentro de Maps, con sus partes ancladas. Constrúyelo bien lejos del lobby (unos cientos de studs bastan), porque la copia aparece exactamente donde lo construiste y los jugadores eliminados no deberían poder volver caminando.
  4. Dentro de cada mapa, añade una Folder llamada Spawns con una Part anclada por cada jugador que esperas. Pon su Transparency en 1 y desactiva CanCollide para que nadie las vea ni tropiece con ellas.
El Explorer cuando la guía está terminada
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

El script de rondas suma 1 a un IntValue llamado Wins dentro de la carpeta leaderstats del jugador. Si tu juego todavía no tiene leaderstats, añade este script corto. Si ya tienes uno, por ejemplo la versión que guarda datos de la guía del leaderboard, sáltalo: dos scripts que crean leaderstats le dan a cada jugador dos carpetas.

Script en ServerScriptService llamado Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- tiene que ser exactamente este nombre, todo en minúsculas

	local wins = Instance.new("IntValue")
	wins.Name = "Wins"
	wins.Value = 0
	wins.Parent = leaderstats

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- En Studio puedes entrar antes de que corra este script, así que prepara a quien ya esté aquí
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Estos Wins se reinician cuando el jugador se va. Para conservarlos entre sesiones, usa la versión con data store de la guía del leaderboard.

Paso 2: Añade el script de rondas

Inserta un Script en ServerScriptService, llámalo RoundSystem y pega el código de abajo. Los ajustes de arriba son las únicas líneas que deberías tener que cambiar. Cada estado es su propia función, y el bucle del final las corre en orden, para siempre.

Script en ServerScriptService llamado RoundSystem
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Ajustes
local MIN_PLAYERS = 2 -- ponlo en 1 mientras pruebas solo
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: la ronda termina cuando solo a un equipo le quedan jugadores

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

-- Lo que muestra la pantalla de cada jugador vive en atributos de esta carpeta.
-- Los atributos que pone el servidor se replican a todos los clientes, también a los que entran tarde.
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

-- Quién sigue en la ronda actual, y las conexiones que vigilan a cada uno
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)

-- Devuelve el personaje y el humanoid solo si el jugador está vivo ahora mismo
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

-- Cuenta los bandos que siguen en la ronda (jugadores, o equipos si USE_TEAMS está activado)
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. Devuelve false si se fueron jugadores durante la cuenta atrás.
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 un mapa al azar (no el último, si hay donde elegir).
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
	-- Mezcla, para que los jugadores no caigan en el mismo spawn cada ronda
	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 qué altura sobre el suelo queda la root part de un personaje de pie.
-- La fórmula viene de la referencia de Humanoid.HipHeight de Roblox (los rigs R6 suman la altura de la pierna).
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. Cuenta de preparados, y luego teletransporta a todos los que estén 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

	-- Con streaming activado, pide a cada cliente que cargue el mapa antes de que llegue su personaje
	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

	-- Solo participan los jugadores que están vivos ahora mismo. Los demás esperan a la siguiente ronda.
	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]
			-- El pivote de un personaje es su root part, así que súbelo a la altura de pie sobre la parte
			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. Termina cuando se acaba el tiempo o solo queda un bando.
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()
		-- Una ronda que empezó con un solo bando (una prueba en solitario) solo termina por tiempo o por muerte
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- ESTADO: Results. Gana todo el que siga vivo.
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) -- deja de vigilarlos; se quedan en el mapa hasta la limpieza
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- ESTADO: Cleanup. Devuelve a los supervivientes al lobby y luego quita el mapa.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- sigue en el 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

-- El bucle: una vuelta es una ronda
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) -- todavía no hay mapas: vuelve a intentarlo enseguida
		end
	end
end

Todo lo que importa pasa aquí, en el servidor: quién está en la ronda, el timer, el ganador y los Wins. Lo único que reciben los clientes son tres atributos en ReplicatedStorage.RoundInfo (State, Status y TimeLeft) y un atributo InRound en cada jugador.

Cómo funciona cada estado

Espera e intermedio

runIntermission primero detiene el bucle hasta que #Players:GetPlayers() llega a MIN_PLAYERS. Después cuenta hacia atrás de segundo en segundo con task.wait(1) y revisa el número de jugadores en cada tick. Si alguien se va y el servidor baja del mínimo, devuelve false y el bucle principal vuelve a empezar en Waiting, así que una ronda nunca empieza con una sola persona.

Elegir y cargar un mapa

loadMap junta cada Model de ServerStorage.Maps, descarta el que se usó en la ronda anterior si hay otro para elegir, y escoge uno con Random:NextInteger. Luego clona el mapa a Workspace. El original se queda intacto en ServerStorage, así que cada ronda empieza con una copia nueva: lo que los jugadores rompieron o movieron en la ronda anterior ya no está.

Los places nuevos tienen el streaming de instancias activado, lo que significa que un cliente solo tiene las partes cercanas a su personaje. Antes del teletransporte, el script llama a Player:RequestStreamAroundAsync para cada jugador, que le pide al motor que envíe a ese cliente la zona del mapa durante la cuenta atrás de "prepárate". Sin eso, los jugadores pueden llegar antes de que cargue el suelo y quedarse parados un momento.

Teletransportar jugadores con PivotTo

Después de la cuenta atrás, el script arma la lista de participantes con los jugadores cuyo personaje existe, sigue en el mundo y tiene un Humanoid con vida por encima de 0 y una root part. Esa comprobación ocurre después de la cuenta atrás, así que quien murió o se fue durante ella no entra.

Cada participante se mueve con character:PivotTo(cframe). La referencia de Roblox dice que PivotTo es la forma principal de mover modelos desde un script, y mueve todas las partes del personaje juntas. Cambiar HumanoidRootPart.Position no es lo mismo: Roblox ajusta las uniones para que esa parte se mueva sola, y eso puede dejar atrás el resto del cuerpo. El pivote de un personaje es su root part, así que el destino es el CFrame de la parte de spawn subido la mitad de la altura de la parte más la altura a la que la root part queda sobre el suelo. rootHeight calcula eso con la fórmula de la referencia de Humanoid.HipHeight de Roblox: la mitad de la altura de la root part más HipHeight, más el largo de la pierna en rigs R6. Así los avatares escalados y personalizados no aparecen dentro de la parte ni caen sobre ella. Como el CFrame incluye la rotación, los jugadores miran hacia donde mira la parte de spawn, así que gira las partes para que todos apunten al centro del mapa.

Si hay más jugadores que partes de spawn, el script vuelve a la primera parte y los jugadores caen unos encima de otros, así que añade al menos tantos spawns como tu número máximo de jugadores.

Si también usas la comprobación de velocidad de la guía del sprint, añade player:SetAttribute("MovementCheckSkip", true) justo después de character:PivotTo(...) en startRound, para que el teletransporte no cuente como exceso de velocidad.

El timer de la ronda y cuándo termina

runRound avanza una vez por segundo. En cada tick actualiza el estado (cuántos jugadores quedan) y los segundos que faltan, y luego cuenta los bandos que siguen vivos. La ronda termina de una de tres formas:

  • Se acaba el tiempo. El bucle for llega a 1 y termina.
  • Queda un solo bando. Un bando es un jugador, o un equipo si USE_TEAMS está activado. La comprobación solo cuenta cuando la ronda empezó con dos o más bandos, así que una prueba en solitario no termina en cuanto empieza.
  • No queda nadie. Todos murieron o se fueron, así que la ronda termina sin ganador.

Como revisa una vez por segundo, una ronda puede seguir hasta un segundo después de la última eliminación, algo que casi no se nota en un timer de ronda.

Dar Wins y mostrar el resultado

La regla de este script es simple: gana todo el que siga vivo cuando termina la ronda. Eso cubre el último jugador en pie, el último equipo en pie y "sobrevive hasta que se acabe el timer" con una sola línea de lógica. finishRound suma 1 a los Wins de cada ganador, deja de vigilarlos y muestra un mensaje como "Alex wins!" durante RESULTS_SECONDS. Si quieres que un final por tiempo no tenga ganador, sáltate awardWin y cambia el mensaje cuando sidesLeft sea mayor que 1. Sigue devolviendo la lista en los dos casos, porque la limpieza la usa para traer a los supervivientes de vuelta al lobby.

Limpieza

Los supervivientes siguen de pie en el mapa, así que cleanup los hace reaparecer en el lobby con Player:LoadCharacterAsync(), que reemplaza al antiguo LoadCharacter, y luego destruye la copia del mapa. Cada reaparición corre en su propio task.spawn dentro de un pcall, porque la llamada espera a que cargue el personaje y puede fallar si el jugador se va en ese momento. Los jugadores eliminados no necesitan nada: ya reaparecieron solos en el lobby.

Paso 3: Muestra el timer y el estado a cada jugador

El servidor publica tres atributos en ReplicatedStorage.RoundInfo: State (una palabra fija como InRound, para los scripts), Status (texto para las personas) y TimeLeft (segundos). Los atributos que un script del servidor pone en un objeto replicado llegan a cada cliente automáticamente, y un jugador que entra a mitad de ronda recibe los valores actuales enseguida. Por eso encaja mejor que un RemoteEvent para un timer: un RemoteEvent disparado antes de que alguien entrara nunca le llega.

  1. En el Explorer, inserta un ScreenGui en StarterGui y llámalo RoundHud. Deja ResetOnSpawn activado (es el valor por defecto).
  2. Inserta un LocalScript en RoundHud, llámalo RoundHudClient y pega el código de abajo. Crea la etiqueta él mismo, así que no hay nada más que dibujar.
  3. Pulsa Play. La etiqueta de arriba de la pantalla muestra el estado y una cuenta atrás en formato m:ss.
LocalScript en el ScreenGui RoundHud en StarterGui llamado RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local roundInfo = ReplicatedStorage:WaitForChild("RoundInfo")
local screenGui = script.Parent :: ScreenGui

-- La etiqueta. Si diseñaste tu propio TextLabel en RoundHud, borra este bloque y usa:
-- 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 -- los mensajes más largos usan una segunda línea
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 ResetOnSpawn está activado, Roblox le da al jugador una copia nueva de RoundHud cada vez que aparece su personaje, también al reaparecer en la limpieza. El script vuelve a leer los atributos actuales, así que la etiqueta nunca queda desactualizada.

El cliente solo lee. Nada de lo que un jugador cambie en su propia pantalla afecta al timer real, porque los cambios de atributos que hace un LocalScript se quedan en ese cliente. Para una cuenta atrás que muestre décimas de segundo, el servidor puede guardar en un atributo una hora de fin sacada de workspace:GetServerTimeNow(), y cada cliente le resta su propio workspace:GetServerTimeNow() en cada frame.

Si tu juego abre con un menú principal, RoundHud aparece cuando el jugador pulsa Play, porque StarterGui solo se copia a un jugador cuando aparece su personaje. Los jugadores que siguen en el menú no tienen personaje, así que nunca los teletransportan a una ronda.

Jugadores que mueren, se van o entran a mitad de ronda

Estos casos son fáciles de pasar por alto cuando escribes un script de rondas por primera vez. Cuando uno no está cubierto, lo normal es ver un error en Output o una ronda que nunca termina. Esto es lo que hace el script de arriba en cada uno.

Casos especiales y cómo los maneja el script de rondas
SituaciónQué pasaDónde en el script
Un jugador muere en la ronda (lo matan, se resetea, se cae)Sale de la ronda y reaparece en el lobby después de Players.RespawnTime (5 segundos por defecto).humanoid.Died llama a eliminate
Se quita un personaje sin que mueraIgual que una muerte: queda fuera.player.CharacterRemoving llama a eliminate
Un jugador se va del servidorSale de la ronda, sus conexiones se desconectan y el siguiente tick vuelve a contar los bandos.Players.PlayerRemoving llama a eliminate
Un jugador entra a mitad de rondaAparece en el lobby, ve el estado y el timer en vivo y entra en la siguiente ronda.Los participantes solo se eligen en startRound
Un jugador estaba muerto cuando empezó la rondaNo lo teletransportan y espera en el lobby.getLivingCharacter
Todos se van o muerenLa ronda termina con "Nobody survived" y el bucle vuelve a empezar: Intermission si siguen quedando suficientes jugadores en el servidor, Waiting si no.sidesLeft == 0 en runRound

eliminate está escrito para que sea seguro llamarlo más de una vez para el mismo jugador. Un jugador que muere y luego reaparece dispara Died y CharacterRemoving, y uno que se va puede disparar los tres eventos; solo la primera llamada hace algo.

Cómo ampliarlo: equipos, votación de mapas y eventos de ronda

Último equipo en pie

Pon USE_TEAMS = true y luego añade objetos Team bajo el servicio Teams en el Explorer, cada uno con su propio nombre y TeamColor. Por defecto Roblox pone a cada jugador que entra en el equipo auto-asignable con menos miembros. No reequilibra cuando se van jugadores, así que en sesiones largas pueden quedar equipos desiguales. Deja la SpawnLocation del lobby en Neutral para que todos los equipos aparezcan ahí. Así la ronda termina cuando solo un equipo tiene jugadores vivos, y el resultado dice "Red wins!".

Para un formato de uno contra muchos (un cazador y todos los demás sobreviven), elige un participante al azar en startRound y pon su Team en un equipo de cazador antes del teletransporte. Desmarca AutoAssignable en el equipo del cazador para que nunca metan ahí a jugadores nuevos, y devuelve al cazador al equipo de los supervivientes en cleanup. Las mismas condiciones de fin siguen funcionando: el cazador gana si todos los supervivientes quedan fuera, y los supervivientes ganan si aguantan hasta que se acaba el timer, siempre que te saltes el awardWin del cazador cuando se acaba el tiempo.

Dejar que los jugadores voten un mapa

Una votación necesita que el cliente hable con el servidor, y eso significa un RemoteEvent. Durante el intermedio el servidor publica dos o tres nombres de mapas como atributos, cada cliente dispara el RemoteEvent con el nombre en el que hizo clic, y el servidor cuenta los votos antes de que corra loadMap. El servidor tiene que comprobar cada voto: que el argumento es un string, que es una de las opciones actuales, que el estado es Intermission y que cada jugador cuenta una sola vez (guarda los votos en una tabla con el Player como clave, para que un segundo voto reemplace al primero, y bórralo en PlayerRemoving). La guía de RemoteEvents explica ese patrón de validación completo.

Dar una tool a los jugadores cuando empieza la ronda

Otros scripts pueden reaccionar a la ronda sin tocar RoundSystem. El script de rondas pone un atributo InRound en cada jugador cuando lo teletransporta y lo quita cuando lo eliminan. Este script escucha ese atributo y le da a cada jugador una copia de una Tool llamada RoundTool guardada en ServerStorage.

Script en ServerScriptService llamado 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

No hay código para quitar la tool. Cuando un personaje muere, Roblox reemplaza el Backpack por uno nuevo lleno desde StarterPack, y LoadCharacterAsync en la limpieza lo vacía para los supervivientes, así que la tool desaparece cuando termina la ronda.

Si quieres repartir un arma, construye la espada o el arma con raycast (en inglés), guárdala en ServerStorage en vez de StarterPack y cambia "RoundTool" en este script por su nombre.

NPCs y otros objetos solo para la ronda

Todo lo que deba existir solo durante una ronda puede vivir dentro del modelo del mapa: enemigos, objetos para recoger, plataformas que se mueven. Los scripts dentro de un modelo en ServerStorage no corren; cuando la copia está en Workspace empiezan a correr, y map:Destroy() en la limpieza los quita junto con todo lo demás. Para añadir enemigos que persigan a los jugadores, construye uno con la guía de pathfinding de NPCs y ponlo en un mapa. Para un vuelo de cámara sobre el mapa al empezar cada ronda, la guía de cinemáticas muestra cómo este script puede iniciar una cinemática para cada jugador con un BindableEvent.

Convertirlo en un módulo

No necesitas un ModuleScript para empezar. Un solo Script es más fácil de leer mientras construyes el juego. Divídelo cuando otros scripts necesiten llamar a funciones de la ronda, o cuando quieras los ajustes en un ModuleScript compartido que puedan usar con require tanto el servidor como tu UI. Hasta entonces, el atributo State de RoundInfo y el atributo InRound de cada jugador ya funcionan como la interfaz pública del sistema de rondas: cualquier script puede escucharlos.

Errores comunes y soluciones

Abre la ventana Output (desde el menú Window de Studio o la pestaña Script) antes de pulsar Play. La mayoría de los problemas de un sistema de rondas imprimen ahí una advertencia o un error, con el nombre del script y el número de línea.

Se queda en "Waiting for players (1/2)"

Estás probando solo y MIN_PLAYERS es 2. Ponlo en 1 para las pruebas en solitario, o prueba con Server & Clients y 2 clientes.

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

Falta la carpeta, está mal escrita o está en el servicio equivocado. Tiene que ser una Folder llamada exactamente Maps directamente dentro de ServerStorage. La misma advertencia para RoundInfo en un LocalScript significa que el script RoundSystem nunca llegó a crearla: está desactivado, dio un error o sigue esperando la carpeta Maps.

Los jugadores atraviesan el mapa después del teletransporte

Las partes del mapa no están ancladas, así que la copia se desarma en cuanto está en Workspace. Selecciona el mapa, ancla sus partes y comprueba que las partes de spawn estén por encima del suelo, no dentro de él.

Los jugadores eliminados reaparecen dentro de la arena

Hay una SpawnLocation dentro de un mapa. Cámbiala por una Part normal en la carpeta Spawns del mapa.

La ronda nunca termina después de que todos mueren

Comprueba que tu daño de verdad mata al Humanoid (la vida llega a 0) en vez de mover o anclar a los jugadores. Si desactivaste el estado Dead del humanoid, Died nunca se dispara y la ronda tiene que esperar al timer.

El bucle de rondas se para para siempre después de un error

El bucle corre en un solo hilo, así que un error dentro de cualquier estado lo termina. Lee el error en Output, arregla la línea y vuelve a probar. Una causa frecuente es editar el script para usar player.Character.Humanoid sin comprobar que el personaje existe.

Constrúyelo con RoCode

Si prefieres no montar esto a mano, RoCode puede construirlo en el place que tienes abierto. Es un agente de IA que trabaja a través de un plugin de Roblox Studio, así que los scripts y las partes aparecen en tu Explorer en vez de en una ventana de chat para que los pegues.

Tú escribes

Añade un sistema de rondas: un intermedio de 20 segundos que necesita 2 jugadores, un mapa al azar de ServerStorage.Maps, teletransporta a todos a las partes de spawn del mapa, rondas de 2 minutos donde gana el último jugador vivo, suma un Win en leaderstats y muestra el estado y el timer arriba de la pantalla.

RoCode hace
  • Puede revisar tu place primero con List Children, Search Game y Search Scripts, para usar tu carpeta Maps y tu script de leaderstats en vez de añadir otros
  • Crea el Script de rondas en ServerScriptService y el LocalScript del timer con Create Script, y puede colocar una arena de sus estructuras listas con Place Prefab si todavía no tienes mapa
  • Comprueba que cada script compila dentro de Studio con Check Script antes de terminar. Eso detecta errores de sintaxis, no la lógica de la ronda
  • Después de que pruebes el juego, Check Output lee las líneas de Server y Client de tu última prueba para poder arreglar un error en tiempo de ejecución

Con el plugin 3.9 o posterior RoCode puede hacer una prueba corta y leer los errores, y con el plugin 3.9.11 o posterior puede controlar un personaje de prueba, pero no prueba con varios jugadores, así que las rondas las corres tú con Server & Clients. Cada lote de cambios es un punto de deshacer en Studio. Un bucle de rondas es el centro de muchos juegos, y hacer un juego entero de Roblox con IA, sistema por sistema (en inglés) muchas veces empieza con uno como este. Cómo se conecta RoCode a Studio.

Preguntas frecuentes

¿Cómo hago un sistema de rondas con equipos en Roblox?

Añade objetos Team bajo el servicio Teams y pon USE_TEAMS = true en el script de rondas. Roblox pone a los jugadores que entran en el equipo auto-asignable con menos miembros, y la ronda termina cuando solo un equipo tiene jugadores vivos.

¿Cómo muestro una cuenta atrás a todos los jugadores?

Pon los segundos que quedan como atributo de un objeto en ReplicatedStorage desde el servidor, y escúchalo con GetAttributeChangedSignal en un LocalScript que actualice un TextLabel, como en el Paso 3. Los jugadores que entran tarde reciben el valor actual enseguida.

¿Uso wait() o task.wait() en un bucle de rondas?

Usa task.wait(). Roblox marca el wait() global como obsoleto y reemplazado por task.wait().

¿Cómo teletransporto a los jugadores a otro place en cada ronda?

Eso es otra herramienta. Esta guía mueve personajes dentro de un mismo servidor con PivotTo. Enviar jugadores a otro place de tu experiencia usa TeleportService, que los mueve a otro servidor. La guía del teletransportador construye portales que hacen eso, con reintentos cuando falla un teletransporte.

¿Por qué mis jugadores se congelan un momento después del teletransporte?

Con el streaming de instancias activado, el cliente todavía no recibió el mapa. La llamada a RequestStreamAroundAsync del script durante la cuenta atrás de "prepárate" le pide al motor que lo envíe antes; un GET_READY_SECONDS más largo da más tiempo a las conexiones lentas.

Fuentes y lecturas

Cómo se comprobó el código: cada script de esta página pasa el verificador de tipos estricto de Luau con las definiciones de la API de Roblox (luau-lsp, 14 de noviembre de 2026). Una verificación de tipos detecta APIs mal escritas y tipos incorrectos, no la lógica del juego, así que pruébalo en Studio antes de publicar.

Prueba RoCode en tu propio juego.

Créditos gratis cada día, sin tarjeta. Instala el plugin, describe la función y revisa lo que aparece en Studio.