Ръководство · Игрови системи

Как да направиш система за рундове в Roblox Studio

Повечето игри с рундове в Roblox въртят един и същ цикъл: чакат играчи, броят до нула, зареждат карта, телепортират всички там, пускат таймер, избират победител и разчистват. В това ръководство изграждаме този цикъл като един ясен сървърен скрипт, добавяме таймер, който вижда всеки играч, и разглеждаме случаите, при които копираните скриптове се чупят: играчи, които умират, излизат или влизат по средата на рунда.

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

Накратко

Напиши един сървърен 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. Дотогава атрибутът 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, 20 ноември 2026 г.). Проверката на типовете хваща грешки в имената на API и грешни типове, но не и грешки в логиката на играта, затова тествай всичко в Studio, преди да публикуваш.

Пробвай RoCode в своята игра.

Безплатни кредити всеки ден, без карта. Инсталирай плъгина, опиши функцията и виж какво се е появило в Studio.