Туториал · Игровые системы

Как сделать систему раундов в Roblox Studio

Большинство раундовых игр в Roblox крутят один и тот же цикл: ждут игроков, считают до нуля, грузят карту, телепортируют всех туда, гоняют таймер, выбирают победителя и прибираются. В этом гайде мы собираем этот цикл как один понятный серверный скрипт, добавляем таймер, который видит каждый игрок, и разбираем случаи, на которых ломаются скопированные скрипты: игроки, которые умирают, выходят или заходят посреди раунда.

Обновлено 14 ноября 2026 г.13 мин чтенияАвтор:

Коротко

Напишите один серверный Script в ServerScriptService, который по кругу проходит фиксированный набор состояний: интермиссия (дождаться нужного числа игроков, потом обратный отсчёт), загрузка карты (клонировать случайную карту из ServerStorage в Workspace), телепорт (перенести каждого живого персонажа на спавн-парт через PivotTo), раунд (тикать таймер, пока не кончится время или не останется один игрок или одна команда) и уборка (выдать Wins, возродить выживших, удалить карту).

  • Запускайте цикл только на сервере. Публикуйте статус и оставшиеся секунды атрибутами на Folder в ReplicatedStorage, а показывать их пусть будет LocalScript.
  • Держите таблицу тех, кто ещё в раунде. Убирайте игрока, когда его Humanoid умирает, его персонаж удаляется или он выходит.
  • Телепортируйте только тех игроков, чей персонаж жив в момент старта раунда. Кто зашёл позже, ждёт в лобби следующего.
На этой странице
  1. Как это работает
  2. 1. Лобби и карты
  3. 2. Скрипт раундов
  4. Как работают состояния
  5. 3. UI таймера
  6. Игроки посреди раунда
  7. Как расширить
  8. Common errors
  9. С RoCode
  10. Частые вопросы
  11. Источники и что почитать

Как работает система раундов

ИллюстрацияГотовые скрипты раундов в запущенной игре, ускорено.

Система раундов это машина состояний. В любой момент сервер находится ровно в одном состоянии, у каждого состояния одна задача, и одно условие переводит его в следующее. Если писать так, вся логика лежит в одном месте, и не возникает классический баг, когда цикл таймера и цикл раунда оба пытаются закончить один и тот же раунд.

Состояния цикла раундов в этом гайде
СостояниеЧто делает серверКогда переходит дальше
WaitingПоказывает "Waiting for players (1/2)"На сервере достаточно игроков
IntermissionОтсчитывает время, пока все в лоббиОтсчёт закончился (или откат в Waiting, если игроки вышли)
StartingКопирует случайную карту в Workspace, показывает её название, просит клиентов её загрузитьЗакончился короткий отсчёт "приготовьтесь"
InRoundТелепортирует живых игроков, тикает таймер, убирает тех, кто умер или вышелКончилось время, или остался один игрок или одна команда
ResultsДаёт Win всем, кто ещё жив, и показывает, кто победилПрошло несколько секунд
CleanupВозрождает выживших в лобби и удаляет картуСразу, после чего цикл начинается заново

Каждым состоянием владеет сервер. Клиенты только показывают то, что им говорит сервер. Отсчёт в LocalScript расходится с настоящим, неверен у тех, кто зашёл позже, и его может изменить эксплойтер. Если разделение на сервер и клиент для вас новое, сначала прочитайте Script vs LocalScript vs ModuleScript.

Шаг 1: Соберите лобби, карты и стат Wins

  1. Постройте лобби в Workspace с SpawnLocation. Проверьте, что у него отмечено свойство Neutral, чтобы каждый игрок спавнился здесь, ждал здесь и возвращался сюда после выбывания.
  2. В ServerStorage вставьте Folder с именем Maps. Объекты в ServerStorage никогда не отправляются игрокам, поэтому неиспользуемые карты им ничего не стоят.
  3. Соберите каждую карту как Model внутри Maps, с заанкеренными партами. Стройте её подальше от лобби (нескольких сотен стадов хватит), потому что копия появляется ровно там, где вы её построили, а выбывшие игроки не должны иметь возможности зайти обратно.
  4. Внутри каждой карты добавьте Folder с именем Spawns, а в нём по одному заанкеренному Part на каждого ожидаемого игрока. Поставьте им Transparency 1 и выключите CanCollide, чтобы никто их не видел и не спотыкался о них.
Explorer после этого гайда
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

Скрипт раундов прибавляет 1 к IntValue с именем Wins внутри папки leaderstats игрока. Если в вашей игре ещё нет leaderstats, добавьте этот короткий скрипт. Если он уже есть, например версия с сохранением из гайда по таблице лидеров, пропустите его: два скрипта, создающие leaderstats, дают каждому игроку две папки.

Script в ServerScriptService с именем Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- имя должно быть именно таким, строчными буквами

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

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- В Studio вы можете зайти раньше, чем запустится этот скрипт, поэтому настраиваем всех, кто уже здесь
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Эти Wins сбрасываются, когда игрок выходит. Чтобы они сохранялись между сессиями, возьмите версию с DataStore из гайда по таблице лидеров.

Шаг 2: Добавьте скрипт раундов

Вставьте Script в ServerScriptService, назовите его RoundSystem и вставьте код ниже. Настройки сверху это единственные строки, которые вам, скорее всего, придётся менять. Каждое состояние это отдельная функция, а цикл внизу запускает их по порядку, бесконечно.

Script в ServerScriptService с именем RoundSystem
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Настройки
local MIN_PLAYERS = 2 -- ставьте 1, пока тестируете в одиночку
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: раунд заканчивается, когда игроки остались только в одной команде

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

-- То, что показывает экран каждого игрока, хранится в атрибутах на этой папке.
-- Атрибуты, заданные сервером, реплицируются всем клиентам, включая тех, кто зашёл позже.
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

-- Кто ещё в текущем раунде, и подключения, которые следят за каждым из них
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)

-- Возвращает персонажа и Humanoid, только если игрок жив прямо сейчас
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

-- Считает стороны, оставшиеся в раунде (игроков или команды, если включён USE_TEAMS)
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

-- СОСТОЯНИЕ: Waiting и Intermission. Возвращает false, если игроки вышли во время отсчёта.
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

-- СОСТОЯНИЕ: Starting, часть 1. Копируем случайную карту (не прошлую, если есть выбор).
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
	-- Перемешиваем, чтобы игроки не попадали на один и тот же спавн каждый раунд
	for i = #points, 2, -1 do
		local j = random:NextInteger(1, i)
		points[i], points[j] = points[j], points[i]
	end
	return points
end

-- На какой высоте над полом находится root part стоящего персонажа.
-- Формула из справки Roblox по Humanoid.HipHeight (у ригов R6 добавляется высота ноги).
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

-- СОСТОЯНИЕ: Starting, часть 2. Приготовиться, потом телепортировать всех живых.
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

	-- При включённом стриминге просим каждого клиента загрузить карту до прибытия персонажа
	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

	-- Участвуют только те, кто жив прямо сейчас. Остальные ждут следующего раунда.
	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]
			-- Pivot персонажа это его root 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

-- СОСТОЯНИЕ: InRound. Заканчивается, когда кончилось время или осталась одна сторона.
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()
		-- Раунд, начатый одной стороной (тест в одиночку), заканчивается только по времени или по смерти
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- СОСТОЯНИЕ: Results. Побеждают все, кто ещё жив.
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) -- перестаём следить за ними; они остаются на карте до уборки
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- СОСТОЯНИЕ: Cleanup. Отправляем выживших обратно в лобби, потом удаляем карту.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- ещё на сервере
			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

-- Цикл: один проход это один раунд
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) -- карт пока нет: скоро попробуем снова
		end
	end
end

Всё важное происходит здесь, на сервере: кто в раунде, таймер, победитель и Wins. Клиенты получают только три атрибута на ReplicatedStorage.RoundInfo (State, Status и TimeLeft) и атрибут InRound на каждом игроке.

Как работает каждое состояние

Ожидание и интермиссия

runIntermission сначала держит цикл, пока #Players:GetPlayers() не дойдёт до MIN_PLAYERS. Потом он отсчитывает по одной секунде через task.wait(1) и на каждом тике проверяет число игроков. Если кто-то вышел и на сервере стало меньше минимума, он возвращает false, и главный цикл начинается заново с Waiting, так что раунд никогда не начнётся с одним человеком.

Выбор и загрузка карты

loadMap собирает все Model в ServerStorage.Maps, убирает карту прошлого раунда, если есть из чего выбрать, и берёт одну через Random:NextInteger. Потом клонирует карту в Workspace. Оригинал остаётся нетронутым в ServerStorage, так что каждый раунд начинается со свежей копии: всё, что игроки сломали или сдвинули в прошлом раунде, исчезает.

В новых плейсах включён стриминг инстансов: у клиента есть только парты рядом с его персонажем. Перед телепортом скрипт вызывает Player:RequestStreamAroundAsync для каждого игрока, и это просит движок отправить клиенту область вокруг карты во время отсчёта "приготовьтесь". Без этого игроки могут прибыть раньше, чем загрузился пол, и на мгновение замереть.

Телепорт игроков через PivotTo

После отсчёта скрипт собирает список участников из игроков, у которых персонаж существует, ещё находится в мире и имеет Humanoid со здоровьем больше 0 и root part. Эта проверка идёт после отсчёта, поэтому тот, кто умер или вышел во время него, не попадает в список.

Каждого участника переносят через character:PivotTo(cframe). Справка Roblox называет PivotTo основным способом двигать модели из скрипта, и он двигает все части персонажа вместе. Задать HumanoidRootPart.Position это не то же самое: Roblox подстраивает соединения так, что двигается одна эта часть, и остальное тело может остаться позади. Pivot персонажа это его root part, поэтому цель это CFrame спавн-парта, поднятый на половину высоты парта плюс высоту, на которой root part стоит над полом. rootHeight считает её по формуле из справки Roblox по Humanoid.HipHeight: половина высоты root part плюс HipHeight, плюс длина ноги у ригов R6. Так масштабированные и кастомные аватары не застревают в парте и не падают на него сверху. CFrame включает поворот, поэтому игроки смотрят туда же, куда смотрит спавн-парт: поверните парты так, чтобы все смотрели в центр карты.

Если игроков больше, чем спавн-партов, скрипт снова начинает с первого парта, и игроки оказываются друг на друге, поэтому добавьте спавнов не меньше, чем ваш максимум игроков.

Если вы также используете проверку скорости из гайда по спринту, добавьте player:SetAttribute("MovementCheckSkip", true) сразу после character:PivotTo(...) в startRound, чтобы телепорт не посчитали превышением скорости.

Таймер раунда и условия конца

runRound тикает раз в секунду. На каждом тике он обновляет статус (сколько игроков осталось) и оставшиеся секунды, а потом считает живые стороны. Раунд заканчивается одним из трёх способов:

  • Кончилось время. Цикл for доходит до 1 и завершается.
  • Осталась одна сторона. Сторона это игрок или команда, если включён USE_TEAMS. Проверка работает, только если раунд начался с двух или больше сторон, поэтому тест в одиночку не заканчивается в тот же момент, как начался.
  • Никого не осталось. Все умерли или вышли, и раунд заканчивается без победителя.

Проверка раз в секунду значит, что раунд может идти ещё до секунды после последнего выбывания, а на таймере раунда это почти незаметно.

Выдача Wins и показ результата

Правило в этом скрипте простое: побеждают все, кто жив в момент конца раунда. Это покрывает и последнего выжившего игрока, и последнюю выжившую команду, и режим "продержись, пока не кончится таймер" одной строкой логики. finishRound прибавляет 1 к Wins каждого победителя, перестаёт за ними следить и показывает сообщение вроде "Alex wins!" на RESULTS_SECONDS. Если вы хотите, чтобы при окончании времени победителя не было, пропустите awardWin и поменяйте сообщение, когда sidesLeft больше 1. В любом случае продолжайте возвращать список, потому что уборка по нему возвращает выживших в лобби.

Уборка

Выжившие всё ещё стоят на карте, поэтому cleanup возрождает их в лобби через Player:LoadCharacterAsync(), который заменяет старый LoadCharacter, а потом удаляет копию карты. Каждое возрождение идёт в своём task.spawn внутри pcall, потому что вызов ждёт загрузки персонажа и может упасть, если игрок как раз в этот момент выходит. Выбывшим игрокам ничего не нужно: они уже сами возродились в лобби.

Шаг 3: Покажите таймер и статус каждому игроку

Сервер публикует три атрибута на ReplicatedStorage.RoundInfo: State (фиксированное слово вроде InRound, для скриптов), Status (текст для людей) и TimeLeft (секунды). Атрибуты, которые серверный скрипт задаёт на реплицируемом объекте, автоматически доходят до каждого клиента, и игрок, зашедший посреди раунда, сразу получает текущие значения. Поэтому для таймера это подходит лучше ремоута: RemoteEvent, отправленный до того, как кто-то зашёл, до него никогда не дойдёт.

  1. В Explorer вставьте ScreenGui в StarterGui и назовите его RoundHud. Оставьте ResetOnSpawn включённым (по умолчанию).
  2. Вставьте LocalScript в RoundHud, назовите его RoundHudClient и вставьте код ниже. Он сам создаёт надпись, так что больше ничего рисовать не нужно.
  3. Нажмите Play. Надпись вверху экрана показывает статус и отсчёт в формате m:ss.
LocalScript в ScreenGui RoundHud в StarterGui с именем RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Надпись. Если вы нарисовали свой TextLabel в RoundHud, удалите этот блок и используйте:
-- 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 -- длинные сообщения переносятся на вторую строку
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()

Раз ResetOnSpawn включён, Roblox даёт игроку свежую копию RoundHud при каждом спавне персонажа, включая возрождение при уборке. Скрипт тогда заново читает текущие атрибуты, так что надпись никогда не устаревает.

Клиент только читает. Ничто, что игрок поменяет на своём экране, не влияет на настоящий таймер, потому что изменения атрибутов из LocalScript остаются на этом одном клиенте. Для отсчёта с десятыми долями секунды сервер может вместо этого хранить в атрибуте время окончания из workspace:GetServerTimeNow(), а каждый клиент каждый кадр вычитает из него свой workspace:GetServerTimeNow().

Если ваша игра открывается главным меню, RoundHud появляется, когда игрок нажимает Play, потому что StarterGui копируется игроку только после спавна его персонажа. У игроков, которые ещё в меню, нет персонажа, поэтому их никогда не телепортирует в раунд.

Игроки, которые умирают, выходят или заходят посреди раунда

Эти случаи легко пропустить, когда скрипт раундов пишется впервые. Если какой-то из них не обработан, обычно вы видите ошибку в Output или раунд, который никогда не заканчивается. Вот что скрипт выше делает с каждым из них.

Крайние случаи и как с ними справляется скрипт раундов
СитуацияЧто происходитГде в скрипте
Игрок умирает в раунде (убит, сделал ресет, упал)Его убирают из раунда, и он возрождается в лобби через Players.RespawnTime (по умолчанию 5 секунд).humanoid.Died вызывает eliminate
Персонаж удалён без смертиКак и при смерти: игрок выбыл.player.CharacterRemoving вызывает eliminate
Игрок выходит с сервераЕго убирают, его подключения отключаются, и следующий тик заново считает стороны.Players.PlayerRemoving вызывает eliminate
Игрок заходит посреди раундаОн спавнится в лобби, видит живой статус и таймер и попадает в следующий раунд.Участников выбирают только в startRound
Игрок был мёртв в момент старта раундаЕго не телепортируют, он ждёт в лобби.getLivingCharacter
Все вышли или умерлиРаунд заканчивается с "Nobody survived", и цикл начинается заново: Intermission, если на сервере ещё достаточно игроков, иначе Waiting.sidesLeft == 0 в runRound

eliminate написан так, что его безопасно вызывать несколько раз для одного игрока. Игрок, который умер и возродился, вызывает и Died, и CharacterRemoving, а тот, кто выходит, может вызвать все три события; что-то делает только первый вызов.

Как расширить: команды, голосование за карту и события раунда

Последняя выжившая команда

Поставьте USE_TEAMS = true, потом добавьте объекты Team в сервис Teams в Explorer, каждому своё имя и TeamColor. По умолчанию Roblox кладёт каждого зашедшего игрока в автоназначаемую команду с наименьшим числом участников. Когда игроки выходят, он не перебалансирует команды, так что в долгих сессиях команды могут стать неравными. Оставьте SpawnLocation в лобби Neutral, чтобы все команды спавнились там. Тогда раунд заканчивается, когда живые игроки остались только в одной команде, и результат выглядит как "Red wins!".

Для формата "один против всех" (один охотник, остальные выживают) выберите в startRound одного случайного участника и перед телепортом поставьте ему Team команды охотника. Снимите AutoAssignable у команды охотника, чтобы туда никогда не попадали новые игроки, и в cleanup верните охотника в команду выживших. Тогда работают те же условия конца: охотник побеждает, если выбыли все выжившие, а выжившие побеждают, если продержались до конца таймера, при условии что вы пропускаете awardWin охотника, когда кончилось время.

Голосование игроков за карту

Для голосования клиент должен общаться с сервером, а значит, нужен RemoteEvent. Во время интермиссии сервер публикует атрибутами два или три названия карт, каждый клиент отправляет через RemoteEvent название, на которое нажал, и сервер считает голоса до запуска loadMap. Сервер обязан проверять каждый голос: что аргумент это строка, что это один из текущих вариантов, что состояние Intermission и что каждый игрок считается один раз (храните голоса в таблице с ключом Player, чтобы второй голос заменял первый, и очищайте её в PlayerRemoving). Гайд по RemoteEvent подробно разбирает этот шаблон проверок.

Выдача инструмента в начале раунда

Другие скрипты могут реагировать на раунд, не трогая RoundSystem. Скрипт раундов ставит каждому игроку атрибут InRound, когда его телепортирует, и снимает его, когда игрок выбывает. Этот скрипт слушает его и выдаёт каждому игроку копию Tool с именем RoundTool, который лежит в ServerStorage.

Script в ServerScriptService с именем 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

Кода, который забирает инструмент, нет. Когда персонаж умирает, Roblox заменяет Backpack свежим, заполненным из StarterPack, а LoadCharacterAsync при уборке очищает его у выживших, так что после раунда инструмента уже нет.

Если нужно оружие для выдачи, соберите меч или пушку на рейкастах, держите её в ServerStorage вместо StarterPack и поменяйте "RoundTool" в этом скрипте на её имя.

NPC и другие объекты только на время раунда

Всё, что должно существовать только во время раунда, может жить внутри модели карты: враги, подбираемые предметы, движущиеся платформы. Скрипты внутри модели в ServerStorage не работают; как только копия оказывается в Workspace, они запускаются, а map:Destroy() при уборке удаляет их вместе со всем остальным. Чтобы добавить врагов, которые гонятся за игроками, соберите одного по гайду по pathfinding для NPC и положите его в карту. Для облёта карты в начале каждого раунда гайд по катсценам показывает, как этот скрипт может запускать катсцену каждому игроку через BindableEvent.

Как сделать из этого модуль

Для начала ModuleScript не нужен. Один Script проще читать, пока вы собираете игру. Разбивайте его, когда другим скриптам нужно вызывать функции раунда или когда вы хотите вынести настройки в один общий ModuleScript, который могут подключать через require и сервер, и ваш UI. До тех пор атрибут State на RoundInfo и атрибут InRound на каждом игроке уже работают как публичный интерфейс системы раундов: любой скрипт может их слушать.

Частые ошибки и решения

Откройте окно Output (через меню Window в Studio или вкладку Script) до нажатия Play. Большинство проблем с системой раундов выводят там предупреждение или ошибку с именем скрипта и номером строки.

Висит на "Waiting for players (1/2)"

Вы тестируете в одиночку, а MIN_PLAYERS равен 2. Поставьте 1 для одиночных тестов или тестируйте в режиме Server & Clients с 2 клиентами.

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

Папки нет, у неё опечатка в имени или она не в том сервисе. Это должен быть Folder с именем ровно Maps прямо внутри ServerStorage. Такое же предупреждение для RoundInfo в LocalScript значит, что скрипт RoundSystem так и не дошёл до её создания: он выключен, упал с ошибкой или всё ещё ждёт папку Maps.

После телепорта игроки проваливаются сквозь карту

Парты карты не заанкерены, поэтому копия разваливается, как только оказывается в Workspace. Выделите карту, заанкерьте её парты и проверьте, что спавн-парты стоят над полом, а не внутри него.

Выбывшие игроки возрождаются на арене

Внутри карты есть SpawnLocation. Замените его обычным Part в папке Spawns этой карты.

Раунд не заканчивается, когда все умерли

Проверьте, что ваш урон действительно убивает Humanoid (здоровье доходит до 0), а не двигает или анкерит игроков. Если вы отключили состояние Dead у Humanoid, Died никогда не срабатывает, и раунду приходится идти до конца таймера.

Цикл раундов насовсем останавливается после одной ошибки

Цикл работает в одном потоке, поэтому ошибка в любом состоянии его завершает. Прочитайте ошибку в Output, исправьте строку и протестируйте снова. Частая причина: скрипт поменяли так, что он использует player.Character.Humanoid без проверки, что персонаж существует.

Сделать с RoCode

Если не хочется собирать всё это вручную, RoCode может сделать это в открытом у вас плейсе. Это ИИ-агент, который работает через плагин для Roblox Studio, поэтому скрипты и парты появляются в вашем Explorer, а не в окне чата, откуда их пришлось бы вставлять.

Вы пишете

Добавь систему раундов: интермиссия 20 секунд, которой нужно 2 игрока, случайная карта из ServerStorage.Maps, телепорт всех на спавн-парты карты, раунды по 2 минуты, где побеждает последний живой игрок, добавь Win в leaderstats и покажи статус и таймер вверху экрана.

RoCode делает
  • Может сначала просмотреть ваш плейс через List Children, Search Game и Search Scripts, чтобы взять вашу папку Maps и скрипт leaderstats, а не добавлять второй набор
  • Создаёт Script раундов в ServerScriptService и LocalScript таймера через Create Script и может поставить арену из своих готовых построек через Place Prefab, если карты у вас пока нет
  • Проверяет компиляцию каждого скрипта внутри Studio через Check Script перед завершением. Это ловит синтаксические ошибки, а не ошибки логики раунда
  • После вашего плейтеста Check Output читает строки Server и Client из последнего плейтеста, чтобы исправить ошибку во время выполнения

С плагином 3.9 или новее RoCode может запустить короткий плейтест и прочитать ошибки, а с плагином 3.9.11 или новее может управлять одним тестовым персонажем, но с несколькими игроками он не тестирует, поэтому раунды прогоняйте сами в режиме Server & Clients. Каждая пачка изменений это точка отмены в Studio. Цикл раундов лежит в основе многих игр, и создание целой игры Roblox с ИИ, система за системой часто начинается с такого цикла. Как RoCode подключается к Studio.

Частые вопросы

Как сделать систему раундов с командами в Roblox?

Добавьте объекты Team в сервис Teams и поставьте USE_TEAMS = true в скрипте раундов. Roblox распределяет зашедших игроков в автоназначаемую команду с наименьшим числом участников, а раунд заканчивается, когда живые игроки остались только в одной команде.

Как показать обратный отсчёт всем игрокам?

Задавайте с сервера оставшиеся секунды атрибутом на объекте в ReplicatedStorage и слушайте его через GetAttributeChangedSignal в LocalScript, который обновляет TextLabel, как в шаге 3. Игроки, зашедшие позже, сразу получают текущее значение.

Что использовать в цикле раундов: wait() или task.wait()?

Используйте task.wait(). Roblox помечает глобальный wait() как устаревший и заменённый на task.wait().

Как телепортировать игроков в другой плейс на каждый раунд?

Это другой инструмент. Этот гайд переносит персонажей внутри одного сервера через PivotTo. Отправка игроков в другой плейс вашего experience идёт через TeleportService, который переносит их на другой сервер. Гайд по телепортам собирает порталы, которые это делают, с повторными попытками, если телепорт не удался.

Почему игроки на мгновение замирают после телепорта?

При включённом стриминге инстансов клиент ещё не получил карту. Вызов RequestStreamAroundAsync в скрипте во время отсчёта "приготовьтесь" просит движок отправить её заранее; более длинный GET_READY_SECONDS даёт медленным соединениям больше времени.

Источники и что почитать

Как проверялся код: каждый скрипт на этой странице проходит строгую проверку типов Luau с определениями Roblox API (luau-lsp, 14 ноября 2026 г.). Проверка типов ловит опечатки в API и неверные типы, но не ошибки игровой логики, поэтому протестируйте всё в Studio перед публикацией.

Попробуйте RoCode в своей игре.

Бесплатные кредиты каждый день, без карты. Установите плагин, опишите функцию и проверьте, что появилось в Studio.