Накратко
Напиши един сървърен Script в ServerScriptService, който в кръг минава през фиксиран набор от състояния: пауза (изчакай нужния брой играчи, после обратно броене), зареждане на карта (клонирай случайна карта от ServerStorage в Workspace), телепорт (премести всеки жив персонаж на спаун парт с PivotTo), рунд (върти таймера, докато не свърши времето или не остане един играч или един отбор) и разчистване (дай Wins, съживи оцелелите, изтрий картата).
- Пускай цикъла само на сървъра. Публикувай статуса и оставащите секунди като атрибути на Folder в ReplicatedStorage, а LocalScript да ги показва.
- Пази таблица с тези, които още са в рунда. Махай играча, когато неговият Humanoid умре, персонажът му бъде премахнат или той излезе.
- Телепортирай само играчите, чийто персонаж е жив в момента на старта на рунда. Който е влязъл по-късно, чака в лобито следващия.
На тази страница
Как работи системата за рундове
Системата за рундове е машина на състоянията. Във всеки момент сървърът е в точно едно състояние, всяко състояние има една задача и едно условие го прехвърля в следващото. Ако пишеш така, цялата логика е на едно място и не се появява класическият бъг, при който цикълът на таймера и цикълът на рунда се опитват едновременно да приключат един и същ рунд.
| Състояние | Какво прави сървърът | Кога минава нататък |
|---|---|---|
| Waiting | Показва "Waiting for players (1/2)" | На сървъра има достатъчно играчи |
| Intermission | Отброява времето, докато всички са в лобито | Броенето е свършило (или връщане към Waiting, ако играчи са излезли) |
| Starting | Копира случайна карта в Workspace, показва името ѝ, моли клиентите да я заредят | Свършило е краткото броене "пригответе се" |
| InRound | Телепортира живите играчи, върти таймера, маха тези, които са умрели или излезли | Времето е свършило или е останал един играч или един отбор |
| Results | Дава Win на всички, които са още живи, и показва кой е победил | Минали са няколко секунди |
| Cleanup | Съживява оцелелите в лобито и изтрива картата | Веднага, след което цикълът започва отначало |
Всяко състояние е в ръцете на сървъра. Клиентите само показват това, което сървърът им казва. Броене в LocalScript се разминава с истинското, грешно е за влезлите по-късно и може да бъде променено от експлойтър. Ако разделянето на сървър и клиент е ново за теб, първо прочети Script vs LocalScript vs ModuleScript.
Стъпка 1: Направи лоби, карти и статистика Wins
- Построй лоби в Workspace със
SpawnLocation. Провери дали има отметнато свойство Neutral, за да се появява всеки играч тук, да чака тук и да се връща тук, след като отпадне. - В ServerStorage вмъкни
Folderс имеMaps. Обектите в ServerStorage никога не се изпращат на играчите, затова неизползваните карти не им струват нищо. - Направи всяка карта като
Modelвътре вMaps, със закотвени партове. Строй я далеч от лобито (няколкостотин стъда стигат), защото копието се появява точно там, където си я построил, а отпадналите играчи не трябва да могат да влязат обратно. - Във всяка карта добави
Folderс имеSpawns, а в него по един закотвенPartза всеки очакван играч. Задай им Transparency 1 и изключи CanCollide, за да не ги вижда никой и да не се спъва в тях.
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, дават на всеки играч по две папки.
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 и постави кода по-долу. Настройките горе са единствените редове, които най-вероятно ще трябва да променяш. Всяко състояние е отделна функция, а цикълът долу ги пуска по ред, безкрайно.
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, изпратен преди някой да влезе, никога няма да стигне до него.
- В Explorer вмъкни ScreenGui в StarterGui и го наречи
RoundHud. Остави ResetOnSpawn включено (по подразбиране). - Вмъкни LocalScript в
RoundHud, наречи гоRoundHudClientи постави кода по-долу. Той сам създава надписа, така че не трябва да рисуваш нищо друго. - Натисни Play. Надписът горе на екрана показва статуса и броенето във формат
m:ss.
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.
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 и покажи статуса и таймера горе на екрана.
- Може първо да прегледа плейса ти чрез 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 дава повече време на бавните връзки.
Източници и какво да прочетеш
- Roblox Creator Docs: Add rounds (на английски). собственият отборен цикъл на рундове на Roblox в примера с лазертаг
- Roblox Creator Docs: PVInstance:PivotTo (на английски). местене на модели и персонажи от скрипт
- Roblox Creator Docs: Player (на английски). LoadCharacterAsync, CharacterRemoving и RequestStreamAroundAsync
- Roblox Creator Docs: Properties and attributes (на английски). задаване на атрибути и следене на промените
- Roblox Creator Docs: Implement teams (на английски). добавяне на отбори и автоматично назначаване
- Roblox Creator Docs: Studio testing modes (на английски). тест с няколко клиента Server & Clients
Как е проверен кодът: всеки скрипт на тази страница минава строга проверка на типовете в Luau с дефинициите на Roblox API (luau-lsp, 20 ноември 2026 г.). Проверката на типовете хваща грешки в имената на API и грешни типове, но не и грешки в логиката на играта, затова тествай всичко в Studio, преди да публикуваш.