Röviden
Írj egyetlen szerveroldali Scriptet a ServerScriptService-be, amely körbe-körbe végigmegy egy rögzített állapotsoron: szünet (megvárja a szükséges számú játékost, aztán visszaszámol), pályabetöltés (egy véletlen pályát klónoz a ServerStorage-ból a Workspace-be), teleport (minden élő karaktert egy spawn partra visz a PivotTo segítségével), kör (ketyeg az időzítő, amíg le nem jár az idő, vagy csak egy játékos vagy egy csapat marad) és takarítás (kiosztja a Winst, újraéleszti a túlélőket, törli a pályát).
- A ciklust csak a szerveren futtasd. Az állapotot és a hátralévő másodperceket egy ReplicatedStorage-beli Folder attribútumaiként tedd közzé, a megjelenítést pedig bízd egy LocalScriptre.
- Vezess egy táblát azokról, akik még a körben vannak. Vedd ki a játékost, amikor a Humanoidja meghal, a karaktere törlődik, vagy kilép.
- Csak azokat a játékosokat teleportáld, akiknek a karaktere a kör indulásakor él. Aki később lépett be, a lobbiban várja a következőt.
Ezen az oldalon
Hogyan működik a körrendszer
A körrendszer egy állapotgép. A szerver minden pillanatban pontosan egy állapotban van, minden állapotnak egy feladata van, és egy feltétel viszi át a következőbe. Ha így írod, az egész logika egy helyen van, és nem jön elő az a klasszikus hiba, amikor az időzítő ciklusa és a kör ciklusa egyszerre próbálja befejezni ugyanazt a kört.
| Állapot | Mit csinál a szerver | Mikor lép tovább |
|---|---|---|
| Waiting | Ezt mutatja: "Waiting for players (1/2)" | Elég játékos van a szerveren |
| Intermission | Visszaszámol, amíg mindenki a lobbiban van | Véget ért a visszaszámlálás (vagy vissza Waitingbe, ha játékosok kiléptek) |
| Starting | Egy véletlen pályát másol a Workspace-be, kiírja a nevét, és megkéri a klienseket, hogy töltsék be | Véget ért a rövid „készülj” visszaszámlálás |
| InRound | Teleportálja az élő játékosokat, ketyegteti az időzítőt, kiveszi azokat, akik meghaltak vagy kiléptek | Lejárt az idő, vagy egy játékos vagy egy csapat maradt |
| Results | Wint ad mindenkinek, aki még él, és kiírja, ki nyert | Eltelt néhány másodperc |
| Cleanup | Újraéleszti a túlélőket a lobbiban, és törli a pályát | Azonnal, utána a ciklus elölről kezdődik |
Minden állapot a szerveré. A kliensek csak azt jelenítik meg, amit a szerver mond nekik. Egy LocalScriptben futó visszaszámlálás eltér a valóditól, a később belépőknél hibás, és egy exploiter megváltoztathatja. Ha a szerver és kliens szétválasztása új neked, előbb olvasd el a Script vs LocalScript vs ModuleScript útmutatót.
1. lépés: építsd meg a lobbit, a pályákat és a Wins statisztikát
- Építs egy lobbit a Workspace-ben egy
SpawnLocation-nel. Ellenőrizd, hogy be van-e jelölve a Neutral tulajdonsága, hogy minden játékos itt jelenjen meg, itt várjon, és kiesés után ide térjen vissza. - A ServerStorage-ba szúrj be egy
MapsnevűFolder-t. A ServerStorage objektumait a játékosok soha nem kapják meg, így a nem használt pályák semmibe sem kerülnek nekik. - Minden pályát
Model-ként építs aMaps-en belül, rögzített (anchored) partokból. A lobbitól messzebb építsd (néhány száz stud elég), mert a másolat pontosan ott jelenik meg, ahol megépítetted, a kiesett játékosok pedig ne tudjanak visszasétálni. - Minden pályán belül adj hozzá egy
SpawnsnevűFolder-t, benne minden várható játékosra egy rögzítettPart-tal. Állítsd a Transparency értéküket 1-re, és kapcsold ki a CanCollide beállítást, hogy senki ne lássa őket, és senki ne essen el bennük.
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
A körscript 1-et ad hozzá a játékos leaderstats mappájában lévő Wins nevű IntValue-hoz. Ha a játékodban még nincs leaderstats, add hozzá ezt a rövid scriptet. Ha már van, például a ranglista útmutató mentéses változata, hagyd ki: két script, amelyek leaderstatsot hoznak létre, minden játékosnak két mappát ad.
local Players = game:GetService("Players")
local function setupLeaderstats(player: Player)
local leaderstats = Instance.new("Folder")
leaderstats.Name = "leaderstats" -- a névnek pontosan ilyennek kell lennie, kisbetűkkel
local wins = Instance.new("IntValue")
wins.Name = "Wins"
wins.Value = 0
wins.Parent = leaderstats
leaderstats.Parent = player
end
Players.PlayerAdded:Connect(setupLeaderstats)
-- A Studióban előbb beléphetsz, mint ahogy ez a script elindul, ezért mindenkit beállítunk, aki már itt van
for _, player in Players:GetPlayers() do
setupLeaderstats(player)
end
Ezek a Winsek lenullázódnak, amikor a játékos kilép. Ha azt szeretnéd, hogy a munkamenetek között megmaradjanak, használd a ranglista útmutató DataStore-os változatát.
2. lépés: add hozzá a körscriptet
Szúrj be egy Script-et a ServerScriptService-be, nevezd el RoundSystem-nek, és illeszd be az alábbi kódot. A felül lévő beállítások az egyetlen sorok, amelyeket valószínűleg módosítanod kell. Minden állapot külön függvény, az alul lévő ciklus pedig sorban, a végtelenségig futtatja őket.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
-- Beállítások
local MIN_PLAYERS = 2 -- állítsd 1-re, amíg egyedül tesztelsz
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: a kör akkor ér véget, ha már csak egy csapatban maradtak játékosok
local mapsFolder = ServerStorage:WaitForChild("Maps")
local random = Random.new()
-- Amit minden játékos képernyője mutat, az ennek a mappának az attribútumaiban van.
-- A szerver által beállított attribútumok minden kliensre replikálódnak, a később belépőkre is.
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
-- Kik vannak még az aktuális körben, és a kapcsolatok, amelyek mindegyiküket figyelik
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)
-- Csak akkor adja vissza a karaktert és a Humanoidot, ha a játékos éppen most él
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
-- Megszámolja a körben maradt oldalakat (játékosokat, vagy csapatokat, ha a USE_TEAMS be van kapcsolva)
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
-- ÁLLAPOT: Waiting és Intermission. false-t ad vissza, ha játékosok kiléptek a visszaszámlálás alatt.
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
-- ÁLLAPOT: Starting, 1. rész. Egy véletlen pályát másolunk (nem az előzőt, ha van választás).
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
-- Megkeverjük, hogy a játékosok ne minden körben ugyanarra a spawnra kerüljenek
for i = #points, 2, -1 do
local j = random:NextInteger(1, i)
points[i], points[j] = points[j], points[i]
end
return points
end
-- Milyen magasan van egy álló karakter root partja a padló fölött.
-- A képlet a Roblox Humanoid.HipHeight referenciájából való (R6 rigeknél hozzáadódik a láb magassága).
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
-- ÁLLAPOT: Starting, 2. rész. Felkészülés, aztán minden élő játékos teleportálása.
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
-- Bekapcsolt streaming esetén megkérünk minden klienst, hogy töltse be a pályát, mielőtt a karakter megérkezik
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
-- Csak azok vesznek részt, akik éppen most élnek. A többiek a következő kört várják.
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]
-- A karakter pivotja a root partja, ezért álló magasságba emeljük a part fölé
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
-- ÁLLAPOT: InRound. Akkor ér véget, ha lejárt az idő, vagy egy oldal maradt.
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()
-- Az egy oldallal indult kör (egyszemélyes teszt) csak az idő lejártával vagy halállal ér véget
if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
break
end
end
end
-- ÁLLAPOT: Results. Mindenki nyer, aki még él.
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) -- már nem figyeljük őket; a takarításig a pályán maradnak
end
setState("Results", message)
task.wait(RESULTS_SECONDS)
return winners
end
-- ÁLLAPOT: Cleanup. A túlélőket visszaküldjük a lobbiba, aztán töröljük a pályát.
local function cleanup(map: Model, survivors: { Player })
for _, player in survivors do
if player.Parent then -- még a szerveren van
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
-- A ciklus: egy menet egy kör
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) -- még nincsenek pályák: hamarosan újra próbáljuk
end
end
end
Minden fontos dolog itt, a szerveren történik: ki van a körben, az időzítő, a győztes és a Wins. A kliensek csak három attribútumot kapnak a ReplicatedStorage.RoundInfo-n (State, Status és TimeLeft), és egy InRound attribútumot minden játékoson.
Hogyan működik az egyes állapot
Várakozás és szünet
A runIntermission először addig tartja a ciklust, amíg a #Players:GetPlayers() el nem éri a MIN_PLAYERS értéket. Aztán másodpercenként visszaszámol a task.wait(1) segítségével, és minden ütemben ellenőrzi a játékosok számát. Ha valaki kilépett, és a szerveren a minimum alá csökkent a létszám, false-t ad vissza, és a fő ciklus elölről kezdődik a Waitingtől, így a kör soha nem indul el egyetlen emberrel.
A pálya kiválasztása és betöltése
A loadMap összegyűjti az összes Model-t a ServerStorage.Maps-ben, kiveszi az előző kör pályáját, ha van miből választani, és a Random:NextInteger segítségével kiválaszt egyet. Aztán a Workspace-be klónozza a pályát. Az eredeti érintetlen marad a ServerStorage-ban, így minden kör friss másolattal indul: minden, amit a játékosok az előző körben eltörtek vagy elmozdítottak, eltűnik.
Az új place-ekben be van kapcsolva az instance streaming: a kliensnek csak a karaktere közelében lévő partjai vannak meg. A teleport előtt a script minden játékosra meghívja a Player:RequestStreamAroundAsync-et, és ez megkéri a motort, hogy a „készülj” visszaszámlálás alatt küldje el a kliensnek a pálya környékét. Enélkül a játékosok előbb érkezhetnek meg, mint ahogy a padló betöltődött, és egy pillanatra megdermedhetnek.
A játékosok teleportálása PivotTo-val
A visszaszámlálás után a script összeállítja a résztvevők listáját azokból a játékosokból, akiknek a karaktere létezik, még a világban van, és van Humanoidja 0-nál nagyobb életerővel és root partja. Ez az ellenőrzés a visszaszámlálás után történik, így aki közben meghalt vagy kilépett, nem kerül a listára.
Minden résztvevőt a character:PivotTo(cframe) visz át. A Roblox referenciája a PivotTo-t nevezi a modellek scriptből való mozgatásának fő módjaként, és a karakter minden részét együtt mozgatja. A HumanoidRootPart.Position beállítása nem ugyanaz: a Roblox úgy igazítja a kötéseket, hogy csak ez az egy rész mozdul, és a test többi része lemaradhat. A karakter pivotja a root partja, ezért a cél a spawn part CFrame-je, megemelve a part magasságának felével plusz azzal a magassággal, amelyen a root part a padló fölött áll. A rootHeight ezt a Roblox Humanoid.HipHeight referenciájának képletével számolja: a root part magasságának fele plusz a HipHeight, plusz R6 rigeknél a láb hossza. Így a méretezett és egyedi avatarok nem ragadnak bele a partba, és nem esnek rá felülről. A CFrame forgatást is tartalmaz, így a játékosok arra néznek, amerre a spawn part: fordítsd a partokat úgy, hogy mindenki a pálya közepe felé nézzen.
Ha több a játékos, mint a spawn part, a script újra az első parttól kezd, és a játékosok egymásra kerülnek, ezért legalább annyi spawnt adj hozzá, amennyi a maximális játékosszámod.
Ha a futás (sprint) útmutató sebességellenőrzését is használod, add hozzá a player:SetAttribute("MovementCheckSkip", true) sort közvetlenül a character:PivotTo(...) után a startRound-ban, hogy a teleportot ne tekintse sebességtúllépésnek.
A kör időzítője és a befejezés feltételei
A runRound másodpercenként ketyeg. Minden ütemben frissíti az állapotot (hány játékos maradt) és a hátralévő másodperceket, aztán megszámolja az élő oldalakat. A kör háromféleképpen érhet véget:
- Lejárt az idő. A
forciklus eléri az 1-et, és véget ér. - Egy oldal maradt. Az oldal egy játékos, vagy egy csapat, ha a
USE_TEAMSbe van kapcsolva. Az ellenőrzés csak akkor működik, ha a kör két vagy több oldallal indult, így egy egyszemélyes teszt nem ér véget abban a pillanatban, ahogy elkezdődött. - Senki sem maradt. Mindenki meghalt vagy kilépett, és a kör győztes nélkül ér véget.
A másodpercenkénti ellenőrzés azt jelenti, hogy a kör az utolsó kiesés után még legfeljebb egy másodpercig mehet, ami egy kör időzítőjén szinte észrevehetetlen.
A Wins kiosztása és az eredmény megjelenítése
A script szabálya egyszerű: mindenki nyer, aki a kör végén él. Ez egyetlen logikai sorral lefedi az utolsó túlélő játékost, az utolsó túlélő csapatot és a „bírd ki, amíg le nem jár az időzítő” módot is. A finishRound 1-et ad minden győztes Wins értékéhez, abbahagyja a figyelésüket, és RESULTS_SECONDS időre kiír egy üzenetet, például "Alex wins!". Ha azt szeretnéd, hogy az idő lejártakor ne legyen győztes, hagyd ki az awardWin-t, és változtasd meg az üzenetet, ha a sidesLeft nagyobb 1-nél. Mindenképp továbbra is add vissza a listát, mert a takarítás ez alapján küldi vissza a túlélőket a lobbiba.
Takarítás
A túlélők még a pályán állnak, ezért a cleanup újraéleszti őket a lobbiban a Player:LoadCharacterAsync() segítségével, amely a régi LoadCharacter-t váltja, aztán törli a pálya másolatát. Minden újraélesztés a saját task.spawn-jában fut egy pcall-on belül, mert a hívás megvárja a karakter betöltését, és meghiúsulhat, ha a játékos épp abban a pillanatban lép ki. A kiesett játékosoknak semmi sem kell: ők már maguktól újraéledtek a lobbiban.
3. lépés: mutasd az időzítőt és az állapotot minden játékosnak
A szerver három attribútumot tesz közzé a ReplicatedStorage.RoundInfo-n: State (rögzített szó, például InRound, scripteknek), Status (szöveg embereknek) és TimeLeft (másodpercek). Azok az attribútumok, amelyeket egy szerverscript egy replikált objektumon állít be, automatikusan eljutnak minden klienshez, és a kör közepén belépő játékos azonnal megkapja az aktuális értékeket. Ezért egy időzítőhöz ez jobban illik, mint egy remote: egy RemoteEvent, amelyet azelőtt küldtek el, hogy valaki belépett, soha nem jut el hozzá.
- Az Explorerben szúrj be egy ScreenGui-t a StarterGuiba, és nevezd el
RoundHud-nak. Hagyd bekapcsolva a ResetOnSpawn beállítást (ez az alapértelmezés). - Szúrj be egy LocalScript-et a
RoundHud-ba, nevezd elRoundHudClient-nek, és illeszd be az alábbi kódot. A feliratot maga hozza létre, így semmi mást nem kell megrajzolnod. - Nyomd meg a Play gombot. A képernyő tetején lévő felirat az állapotot és a visszaszámlálást mutatja
m:ssformátumban.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local roundInfo = ReplicatedStorage:WaitForChild("RoundInfo")
local screenGui = script.Parent :: ScreenGui
-- A felirat. Ha saját TextLabelt rajzoltál a RoundHudba, töröld ezt a blokkot, és használd ezt:
-- 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 -- a hosszú üzenetek második sorba törnek
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()
Mivel a ResetOnSpawn be van kapcsolva, a Roblox a karakter minden megjelenésekor friss RoundHud másolatot ad a játékosnak, a takarításkori újraélesztéskor is. A script ekkor újra kiolvassa az aktuális attribútumokat, így a felirat soha nem avul el.
A kliens csak olvas. Semmi, amit a játékos a saját képernyőjén megváltoztat, nem hat a valódi időzítőre, mert egy LocalScriptből végzett attribútummódosítás azon az egy kliensen marad. Tizedmásodperces visszaszámláláshoz a szerver ehelyett a workspace:GetServerTimeNow() szerinti befejezési időt is tárolhatja egy attribútumban, és minden kliens minden képkockában kivonja belőle a saját workspace:GetServerTimeNow() értékét.
Ha a játékod egy főmenüvel nyílik, a RoundHud akkor jelenik meg, amikor a játékos megnyomja a Play gombot, mert a StarterGui csak a karakter megjelenése után másolódik a játékoshoz. A még menüben lévő játékosoknak nincs karakterük, így őket soha nem teleportálja a körbe.
Játékosok, akik a kör közepén meghalnak, kilépnek vagy belépnek
Ezeket az eseteket könnyű kihagyni, amikor valaki először ír körscriptet. Ha valamelyiket nem kezeli, általában hibát látsz az Outputban, vagy egy kört, amely soha nem ér véget. Íme, mit csinál a fenti script mindegyikkel.
| Helyzet | Mi történik | Hol a scriptben |
|---|---|---|
| Egy játékos meghal a körben (megölték, resetelt, leesett) | Kikerül a körből, és a Players.RespawnTime után (alapból 5 másodperc) újraéled a lobbiban. | A humanoid.Died meghívja az eliminate-et |
| A karakter halál nélkül törlődik | Mint halálkor: a játékos kiesett. | A player.CharacterRemoving meghívja az eliminate-et |
| Egy játékos kilép a szerverről | Kikerül, a kapcsolatai bontódnak, és a következő ütem újraszámolja az oldalakat. | A Players.PlayerRemoving meghívja az eliminate-et |
| Egy játékos a kör közepén lép be | A lobbiban jelenik meg, látja az élő állapotot és az időzítőt, és a következő körbe kerül. | A résztvevőket csak a startRound választja ki |
| Egy játékos halott volt a kör indulásakor | Nem teleportálják, a lobbiban vár. | getLivingCharacter |
| Mindenki kilépett vagy meghalt | A kör "Nobody survived" üzenettel ér véget, és a ciklus elölről kezdődik: Intermission, ha még elég játékos van a szerveren, különben Waiting. | sidesLeft == 0 a runRound-ban |
Az eliminate úgy van megírva, hogy biztonságosan meghívható többször ugyanarra a játékosra. Egy játékos, aki meghalt és újraéledt, kiváltja a Died és a CharacterRemoving eseményt is, aki pedig kilép, mindhármat kiválthatja; csak az első hívás csinál valamit.
Továbbfejlesztés: csapatok, szavazás a pályára és körös események
Az utolsó túlélő csapat
Állítsd be a USE_TEAMS = true értéket, aztán adj hozzá Team objektumokat a Teams szolgáltatáshoz az Explorerben, mindegyiknek saját névvel és TeamColorral. Alapból a Roblox minden belépő játékost abba az automatikusan kiosztható csapatba teszi, amelyben a legkevesebb tag van. Amikor játékosok kilépnek, nem egyensúlyozza újra a csapatokat, így hosszú munkamenetekben a csapatok egyenlőtlenné válhatnak. Hagyd a lobbi SpawnLocationjét Neutral állapotban, hogy minden csapat ott jelenjen meg. Ekkor a kör akkor ér véget, ha az élő játékosok már csak egy csapatban maradtak, és az eredmény így néz ki: "Red wins!".
Az „egy mindenki ellen” formátumhoz (egy vadász, a többiek túlélnek) a startRound-ban válassz ki egy véletlen résztvevőt, és a teleport előtt állítsd a Team értékét a vadászcsapatra. Kapcsold ki a vadászcsapat AutoAssignable beállítását, hogy új játékosok soha ne kerüljenek oda, és a cleanup-ban tedd vissza a vadászt a túlélők csapatába. Ekkor ugyanazok a befejezési feltételek működnek: a vadász nyer, ha minden túlélő kiesett, a túlélők pedig akkor, ha kitartottak az időzítő végéig, feltéve, hogy az idő lejártakor kihagyod a vadász awardWin-jét.
Szavazás a pályára
A szavazáshoz a kliensnek kommunikálnia kell a szerverrel, vagyis RemoteEvent kell. A szünet alatt a szerver attribútumokként közzétesz két vagy három pályanevet, minden kliens RemoteEventen elküldi a nevet, amelyre kattintott, a szerver pedig a loadMap futtatása előtt megszámolja a szavazatokat. A szervernek minden szavazatot ellenőriznie kell: hogy az argumentum string, hogy az aktuális lehetőségek egyike, hogy az állapot Intermission, és hogy minden játékos egyszer számít (a szavazatokat egy Player kulcsú táblában tárold, hogy a második szavazat lecserélje az elsőt, és ürítsd a PlayerRemoving-ban). A RemoteEvent útmutató részletesen végigveszi ezt az ellenőrzési mintát.
Eszköz kiosztása a kör elején
Más scriptek is reagálhatnak a körre anélkül, hogy a RoundSystem-hez nyúlnának. A körscript minden játékosnak beállítja az InRound attribútumot, amikor teleportálja, és leveszi, amikor a játékos kiesik. Ez a script ezt figyeli, és minden játékosnak ad egy másolatot a ServerStorage-ban lévő RoundTool nevű Toolból.
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
Nincs olyan kód, amely elvenné az eszközt. Amikor a karakter meghal, a Roblox a Backpacket egy friss, a StarterPackből feltöltöttre cseréli, a takarításkori LoadCharacterAsync pedig a túlélőknél üríti, így a kör után az eszköz már nincs meg.
Ha kiosztható fegyver kell, építs egy kardot vagy egy raycastos fegyvert, tartsd a ServerStorage-ban a StarterPack helyett, és cseréld a scriptben a "RoundTool" nevet az ő nevére.
NPC-k és más objektumok csak a kör idejére
Minden, aminek csak a kör alatt kell léteznie, a pálya modelljén belül élhet: ellenségek, felvehető tárgyak, mozgó platformok. A ServerStorage-ban lévő modell scriptjei nem futnak; amint a másolat a Workspace-be kerül, elindulnak, a takarításkori map:Destroy() pedig mindennel együtt törli őket. Ha a játékosokat üldöző ellenségeket szeretnél, építs egyet az NPC pathfinding útmutató alapján, és tedd a pályába. Ha minden kör elején körberepülnéd a pályát, az átvezető jelenet útmutató megmutatja, hogyan indíthat ez a script minden játékosnak átvezető jelenetet egy BindableEventen keresztül.
Hogyan csinálj ebből modult
Kezdésnek nincs szükség ModuleScriptre. Egyetlen Scriptet könnyebb olvasni, amíg a játékot építed. Akkor bontsd szét, amikor más scripteknek meg kell hívniuk a kör függvényeit, vagy amikor a beállításokat egy közös ModuleScriptbe szeretnéd tenni, amelyet a szerver és a UI is betölthet require-ral. Addig a RoundInfo State attribútuma és minden játékos InRound attribútuma már a körrendszer nyilvános felületeként működik: bármelyik script figyelheti őket.
Gyakori hibák és megoldásaik
Nyisd meg az Output ablakot (a Studio Window menüjéből vagy a Script fülről) a Play megnyomása előtt. A körrendszer legtöbb problémája figyelmeztetést vagy hibát ír ki ott, a script nevével és a sor számával.
A "Waiting for players (1/2)" állapotban ragad
Egyedül tesztelsz, a MIN_PLAYERS pedig 2. Egyszemélyes tesztekhez állítsd 1-re, vagy tesztelj Server & Clients módban 2 klienssel.
Infinite yield possible on 'ServerStorage:WaitForChild("Maps")'
A mappa nem létezik, elírtad a nevét, vagy rossz szolgáltatásban van. Egy pontosan Maps nevű Foldernek kell lennie, közvetlenül a ServerStorage-ban. Ugyanez a figyelmeztetés a LocalScriptben a RoundInfo-ra azt jelenti, hogy a RoundSystem script el sem jutott a létrehozásáig: ki van kapcsolva, hibával leállt, vagy még mindig a Maps mappára vár.
A teleport után a játékosok átesnek a pályán
A pálya partjai nincsenek rögzítve, ezért a másolat szétesik, amint a Workspace-be kerül. Jelöld ki a pályát, rögzítsd a partjait, és ellenőrizd, hogy a spawn partok a padló fölött vannak, nem benne.
A kiesett játékosok az arénán élednek újra
A pályán belül van egy SpawnLocation. Cseréld le egy sima Partra a pálya Spawns mappájában.
A kör nem ér véget, amikor mindenki meghalt
Ellenőrizd, hogy a sebzésed tényleg megöli-e a Humanoidot (az életerő 0-ra csökken), és nem csak mozgatja vagy rögzíti a játékosokat. Ha kikapcsoltad a Humanoid Dead állapotát, a Died soha nem sül el, és a körnek az időzítő végéig kell mennie.
A körciklus egyetlen hiba után végleg leáll
A ciklus egyetlen szálon fut, ezért bármelyik állapotban fellépő hiba leállítja. Olvasd el a hibát az Outputban, javítsd ki a sort, és teszteld újra. Gyakori ok: a scriptet úgy módosították, hogy a player.Character.Humanoid-ot használja annak ellenőrzése nélkül, hogy a karakter létezik-e.
Elkészítés RoCode-dal
Ha nincs kedved mindezt kézzel összerakni, a RoCode megcsinálhatja a nálad nyitott place-ben. Ez egy AI-ügynök, amely egy Roblox Studio pluginon keresztül dolgozik, így a scriptek és a partok az Explorerben jelennek meg, nem egy chatablakban, ahonnan be kellene illesztened őket.
Adj hozzá egy körrendszert: 20 másodperces szünet, amelyhez 2 játékos kell, véletlen pálya a ServerStorage.Maps-ből, mindenki teleportálása a pálya spawn partjaira, 2 perces körök, ahol az utolsó élő játékos nyer, adj hozzá egy Wint a leaderstatsban, és mutasd az állapotot és az időzítőt a képernyő tetején.
- Előbb átnézheti a place-edet a List Children, a Search Game és a Search Scripts segítségével, hogy a te Maps mappádat és leaderstats scriptedet használja, és ne adjon hozzá egy második készletet
- A Create Script segítségével létrehozza a körök Scriptjét a ServerScriptService-ben és az időzítő LocalScriptjét, és a Place Prefab segítségével elhelyezhet egy arénát a saját kész építményeiből, ha még nincs pályád
- Befejezés előtt minden script fordítását ellenőrzi a Studióban a Check Scripttel. Ez a szintaktikai hibákat kapja el, nem a körlogika hibáit
- A playtested után a Check Output kiolvassa a Server és Client sorokat a legutóbbi playtestből, hogy kijavítson egy futásidejű hibát
A 3.9-es vagy újabb pluginnal a RoCode rövid playtestet indíthat és kiolvashatja a hibákat, a 3.9.11-es vagy újabb pluginnal pedig irányíthat egy tesztkaraktert, de több játékossal nem tesztel, ezért a köröket magad futtasd le Server & Clients módban. Minden változtatáscsomag egy visszavonási pont a Studióban. A körciklus sok játék alapja, és az egész Roblox játék készítése AI-val, rendszerről rendszerre gyakran egy ilyen ciklussal kezdődik. Hogyan kapcsolódik a RoCode a Studióhoz.
Gyakori kérdések
Hogyan készítsek csapatos körrendszert Robloxban?
Adj hozzá Team objektumokat a Teams szolgáltatáshoz, és állítsd be a USE_TEAMS = true értéket a körscriptben. A Roblox a belépő játékosokat abba az automatikusan kiosztható csapatba osztja, amelyben a legkevesebb tag van, a kör pedig akkor ér véget, ha az élő játékosok már csak egy csapatban maradtak.
Hogyan mutassam meg a visszaszámlálást minden játékosnak?
A szerverről állítsd be a hátralévő másodperceket egy ReplicatedStorage-beli objektum attribútumaként, és figyeld a GetAttributeChangedSignal segítségével egy LocalScriptben, amely frissít egy TextLabelt, mint a 3. lépésben. A később belépő játékosok azonnal megkapják az aktuális értéket.
Mit használjak a körciklusban: wait() vagy task.wait()?
Használd a task.wait()-et. A Roblox a globális wait()-et elavultnak és a task.wait()-tel felváltottnak jelöli.
Hogyan teleportáljam a játékosokat minden körben egy másik place-be?
Ez egy másik eszköz. Ez az útmutató egy szerveren belül viszi át a karaktereket a PivotTo segítségével. A játékosokat az experience-ed egy másik place-ébe a TeleportService küldi, amely egy másik szerverre viszi át őket. A teleport útmutató ezt végző portálokat épít, újrapróbálással, ha a teleport nem sikerült.
Miért dermednek meg a játékosok egy pillanatra a teleport után?
Bekapcsolt instance streaming mellett a kliens még nem kapta meg a pályát. A scriptben a „készülj” visszaszámlálás alatt hívott RequestStreamAroundAsync megkéri a motort, hogy előre küldje el; egy hosszabb GET_READY_SECONDS több időt ad a lassú kapcsolatoknak.
Források és további olvasnivaló
- Roblox Creator Docs: Add rounds (angolul). a Roblox saját csapatos körciklusa a lézerharcos példában
- Roblox Creator Docs: PVInstance:PivotTo (angolul). modellek és karakterek mozgatása scriptből
- Roblox Creator Docs: Player (angolul). LoadCharacterAsync, CharacterRemoving és RequestStreamAroundAsync
- Roblox Creator Docs: Properties and attributes (angolul). attribútumok beállítása és a változások figyelése
- Roblox Creator Docs: Implement teams (angolul). csapatok hozzáadása és automatikus kiosztás
- Roblox Creator Docs: Studio testing modes (angolul). teszt több klienssel: Server & Clients
Hogyan ellenőriztük a kódot: az oldalon minden script átmegy a Luau szigorú típusellenőrzésén a Roblox API definícióival (luau-lsp, 2026. november 20.). A típusellenőrzés kiszűri az elírt API-neveket és a rossz típusokat, de a játéklogikai hibákat nem, ezért publikálás előtt mindent tesztelj a Studióban.