Tutoriaali · Pelijärjestelmät

Miten tehdä kierrosjärjestelmä Roblox Studiossa

Useimmat kierrospohjaiset Roblox-pelit pyörittävät samaa silmukkaa: odotetaan pelaajia, lasketaan nollaan, ladataan kartta, teleportataan kaikki sinne, ajetaan ajastinta, valitaan voittaja ja siivotaan. Tässä oppaassa kokoamme tämän silmukan yhdeksi selkeäksi palvelinskriptiksi, lisäämme ajastimen, jonka jokainen pelaaja näkee, ja käymme läpi tapaukset, joihin kopioidut skriptit hajoavat: pelaajat, jotka kuolevat, poistuvat tai liittyvät kesken kierroksen.

Päivitetty 20. marraskuuta 202611 min lukuaikaKirjoittaja:

Lyhyesti

Kirjoita yksi palvelimen Script ServerScriptServiceen, joka käy kehässä läpi kiinteän joukon tiloja: väliaika (odota tarvittava määrä pelaajia, sitten lähtölaskenta), kartan lataus (kloonaa satunnainen kartta ServerStoragesta Workspaceen), teleportti (siirrä jokainen elossa oleva hahmo spawn-partille PivotTo-kutsulla), kierros (aja ajastinta, kunnes aika loppuu tai jäljellä on yksi pelaaja tai yksi joukkue) ja siivous (anna Wins, herätä selviytyjät henkiin, poista kartta).

  • Aja silmukkaa vain palvelimella. Julkaise tila ja jäljellä olevat sekunnit attribuutteina ReplicatedStoragen Folderissa, ja anna LocalScriptin näyttää ne.
  • Pidä taulukkoa niistä, jotka ovat vielä kierroksessa. Poista pelaaja, kun hänen Humanoidinsa kuolee, hänen hahmonsa poistetaan tai hän poistuu.
  • Teleporttaa vain pelaajat, joiden hahmo on elossa kierroksen alkaessa. Myöhemmin liittynyt odottaa aulassa seuraavaa.
Tällä sivulla
  1. Miten se toimii
  2. 1. Aula ja kartat
  3. 2. Kierrosskripti
  4. Miten tilat toimivat
  5. 3. Ajastimen UI
  6. Pelaajat kesken kierroksen
  7. Laajentaminen
  8. Common errors
  9. RoCodella
  10. Usein kysytyt kysymykset
  11. Lähteet ja lisälukemista

Miten kierrosjärjestelmä toimii

HavainnollistusValmiit kierrosskriptit käynnissä olevassa pelissä, nopeutettuna.

Kierrosjärjestelmä on tilakone. Palvelin on joka hetki täsmälleen yhdessä tilassa, jokaisella tilalla on yksi tehtävä, ja yksi ehto siirtää sen seuraavaan. Kun kirjoitat näin, kaikki logiikka on yhdessä paikassa, eikä synny klassista bugia, jossa ajastimen silmukka ja kierroksen silmukka yrittävät molemmat lopettaa saman kierroksen.

Tämän oppaan kierrossilmukan tilat
TilaMitä palvelin tekeeMilloin siirrytään eteenpäin
WaitingNäyttää "Waiting for players (1/2)"Palvelimella on tarpeeksi pelaajia
IntermissionLaskee aikaa, kun kaikki ovat aulassaLaskenta päättyi (tai paluu Waitingiin, jos pelaajia poistui)
StartingKopioi satunnaisen kartan Workspaceen, näyttää sen nimen, pyytää asiakkaita lataamaan senLyhyt "valmistautukaa"-laskenta päättyi
InRoundTeleporttaa elossa olevat pelaajat, ajaa ajastinta, poistaa kuolleet tai poistuneetAika loppui, tai jäljellä on yksi pelaaja tai yksi joukkue
ResultsAntaa Winin kaikille vielä elossa oleville ja näyttää, kuka voittiMuutama sekunti on kulunut
CleanupHerättää selviytyjät henkiin aulaan ja poistaa kartanHeti, minkä jälkeen silmukka alkaa alusta

Jokaisen tilan omistaa palvelin. Asiakkaat vain näyttävät sen, mitä palvelin niille kertoo. LocalScriptin lähtölaskenta poikkeaa oikeasta, on väärä myöhemmin liittyneillä, ja huijari voi muuttaa sitä. Jos jako palvelimeen ja asiakkaaseen on sinulle uusi, lue ensin Script vs LocalScript vs ModuleScript.

Vaihe 1: kokoa aula, kartat ja Wins-tilasto

  1. Rakenna aula Workspaceen SpawnLocation-objektin kanssa. Varmista, että sen Neutral-ominaisuus on rastitettu, jotta jokainen pelaaja syntyy tänne, odottaa täällä ja palaa tänne putoamisen jälkeen.
  2. Lisää ServerStorageen Folder nimeltä Maps. ServerStoragen objekteja ei koskaan lähetetä pelaajille, joten käyttämättömät kartat eivät maksa heille mitään.
  3. Kokoa jokainen kartta Model-objektina Maps-kansion sisään ankkuroiduista parteista. Rakenna se kauas aulasta (muutama sata studia riittää), koska kopio ilmestyy täsmälleen sinne, minne rakensit sen, eikä pudonneiden pelaajien pidä päästä kävelemään takaisin.
  4. Lisää jokaisen kartan sisään Folder nimeltä Spawns ja sen sisään yksi ankkuroitu Part jokaista odotettua pelaajaa kohden. Aseta niille Transparency 1 ja poista CanCollide, jotta kukaan ei näe niitä eikä kompastu niihin.
Explorer, kun opas on käyty läpi
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

Kierrosskripti lisää 1 IntValue-arvoon nimeltä Wins pelaajan leaderstats-kansion sisällä. Jos pelissäsi ei vielä ole leaderstatsia, lisää tämä lyhyt skripti. Jos se on jo olemassa, esimerkiksi tallentava versio tulostaulukko-oppaasta, ohita se: kaksi leaderstatsia luovaa skriptiä antaa jokaiselle pelaajalle kaksi kansiota.

Script kohteessa ServerScriptService nimeltä Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- nimen on oltava juuri tämä, pienillä kirjaimilla

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

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- Studiossa voit liittyä ennen kuin tämä skripti käynnistyy, joten asetetaan kaikki, jotka ovat jo täällä
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Nämä Wins nollautuvat, kun pelaaja poistuu. Jotta ne säilyisivät istuntojen välillä, käytä DataStore-versiota tulostaulukko-oppaasta.

Vaihe 2: lisää kierrosskripti

Lisää Script ServerScriptServiceen, nimeä se RoundSystem ja liitä alla oleva koodi. Yläreunan asetukset ovat ainoat rivit, joita sinun luultavasti täytyy muuttaa. Jokainen tila on oma funktionsa, ja alareunan silmukka ajaa ne järjestyksessä loputtomasti.

Script kohteessa ServerScriptService nimeltä RoundSystem
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Asetukset
local MIN_PLAYERS = 2 -- aseta 1, kun testaat yksin
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: kierros päättyy, kun pelaajia on jäljellä vain yhdessä joukkueessa

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

-- Se, mitä jokaisen pelaajan näyttö näyttää, on tämän kansion attribuuteissa.
-- Palvelimen asettamat attribuutit replikoituvat kaikille asiakkaille, myös myöhemmin liittyneille.
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

-- Ketkä ovat vielä nykyisessä kierroksessa, ja yhteydet, jotka seuraavat kutakin heistä
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)

-- Palauttaa hahmon ja Humanoidin vain, jos pelaaja on elossa juuri nyt
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

-- Laskee kierrokseen jääneet osapuolet (pelaajat tai joukkueet, jos USE_TEAMS on päällä)
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

-- TILA: Waiting ja Intermission. Palauttaa false, jos pelaajia poistui laskennan aikana.
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

-- TILA: Starting, osa 1. Kopioidaan satunnainen kartta (ei edellistä, jos on valinnanvaraa).
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
	-- Sekoitetaan, jotta pelaajat eivät osu samaan spawniin joka kierroksella
	for i = #points, 2, -1 do
		local j = random:NextInteger(1, i)
		points[i], points[j] = points[j], points[i]
	end
	return points
end

-- Millä korkeudella lattian yläpuolella seisovan hahmon root part on.
-- Kaava Robloxin Humanoid.HipHeight-ohjeesta (R6-rigeillä lisätään jalan korkeus).
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

-- TILA: Starting, osa 2. Valmistaudutaan ja teleportataan sitten kaikki elossa olevat.
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

	-- Kun streaming on päällä, pyydetään jokaista asiakasta lataamaan kartta ennen hahmon saapumista
	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

	-- Mukana ovat vain ne, jotka ovat elossa juuri nyt. Muut odottavat seuraavaa kierrosta.
	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]
			-- Hahmon pivot on sen root part, joten nostetaan se seisomakorkeudelle partin yläpuolelle
			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

-- TILA: InRound. Päättyy, kun aika loppuu tai jäljellä on yksi osapuoli.
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()
		-- Yhden osapuolen aloittama kierros (testi yksin) päättyy vain ajan loppuessa tai kuolemaan
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- TILA: Results. Kaikki vielä elossa olevat voittavat.
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) -- lopetetaan heidän seurantansa; he jäävät kartalle siivoukseen asti
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- TILA: Cleanup. Lähetetään selviytyjät takaisin aulaan ja poistetaan sitten kartta.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- vielä palvelimella
			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

-- Silmukka: yksi kierros silmukassa on yksi pelikierros
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) -- karttoja ei vielä ole: yritetään pian uudelleen
		end
	end
end

Kaikki tärkeä tapahtuu tässä, palvelimella: kuka on kierroksessa, ajastin, voittaja ja Wins. Asiakkaat saavat vain kolme attribuuttia ReplicatedStorage.RoundInfo-kansiossa (State, Status ja TimeLeft) ja InRound-attribuutin jokaisessa pelaajassa.

Miten kukin tila toimii

Odotus ja väliaika

runIntermission pitää ensin silmukkaa paikallaan, kunnes #Players:GetPlayers() saavuttaa arvon MIN_PLAYERS. Sitten se laskee sekunti kerrallaan task.wait(1)-kutsulla ja tarkistaa pelaajamäärän joka tikillä. Jos joku poistui ja palvelimella on vähemmän kuin minimi, se palauttaa false, ja pääsilmukka alkaa alusta Waitingista, joten kierros ei koskaan ala yhdellä ihmisellä.

Kartan valinta ja lataus

loadMap kerää kaikki Model-objektit kansiosta ServerStorage.Maps, jättää pois edellisen kierroksen kartan, jos valinnanvaraa on, ja ottaa yhden Random:NextInteger-kutsulla. Sitten se kloonaa kartan Workspaceen. Alkuperäinen pysyy koskemattomana ServerStoragessa, joten jokainen kierros alkaa tuoreesta kopiosta: kaikki, mitä pelaajat rikkoivat tai siirsivät edellisellä kierroksella, katoaa.

Uusissa paikoissa instance streaming on päällä: asiakkaalla on vain hahmonsa lähellä olevat partit. Ennen teleporttia skripti kutsuu Player:RequestStreamAroundAsync jokaiselle pelaajalle, mikä pyytää moottoria lähettämään asiakkaalle kartan ympäristön "valmistautukaa"-laskennan aikana. Ilman sitä pelaajat voivat saapua ennen kuin lattia on latautunut ja jähmettyä hetkeksi.

Pelaajien teleporttaus PivotTolla

Laskennan jälkeen skripti kokoaa osallistujaluettelon pelaajista, joiden hahmo on olemassa, on vielä maailmassa ja jolla on Humanoid, jonka terveys on yli 0, sekä root part. Tämä tarkistus tehdään laskennan jälkeen, joten se, joka kuoli tai poistui sen aikana, ei pääse luetteloon.

Jokainen osallistuja siirretään character:PivotTo(cframe)-kutsulla. Robloxin ohjeissa PivotTo mainitaan päätapana liikuttaa malleja skriptistä, ja se liikuttaa kaikkia hahmon osia yhdessä. HumanoidRootPart.Position-arvon asettaminen ei ole sama asia: Roblox säätää liitoksia niin, että vain tämä yksi osa liikkuu, ja muu keho voi jäädä jälkeen. Hahmon pivot on sen root part, joten kohde on spawn-partin CFrame nostettuna puolella partin korkeudesta plus korkeudella, jolla root part seisoo lattian yläpuolella. rootHeight laskee sen Robloxin Humanoid.HipHeight-ohjeen kaavalla: puolet root partin korkeudesta plus HipHeight, plus jalan pituus R6-rigeillä. Näin skaalatut ja mukautetut avatarit eivät juutu parttiin eivätkä putoa sen päälle ylhäältä. CFrame sisältää kierron, joten pelaajat katsovat samaan suuntaan kuin spawn-part: käännä partit niin, että kaikki katsovat kartan keskustaan.

Jos pelaajia on enemmän kuin spawn-partteja, skripti aloittaa taas ensimmäisestä partista, ja pelaajat päätyvät toistensa päälle, joten lisää spawneja vähintään yhtä monta kuin pelaajamaksimisi.

Jos käytät myös juoksuoppaan nopeustarkistusta, lisää player:SetAttribute("MovementCheckSkip", true) heti character:PivotTo(...)-kutsun jälkeen funktiossa startRound, jotta teleporttia ei tulkita ylinopeudeksi.

Kierroksen ajastin ja päättymisehdot

runRound tikittää kerran sekunnissa. Joka tikillä se päivittää tilan (montako pelaajaa on jäljellä) ja jäljellä olevat sekunnit ja laskee sitten elossa olevat osapuolet. Kierros päättyy yhdellä kolmesta tavasta:

  • Aika loppui. for-silmukka pääsee 1:een ja päättyy.
  • Jäljellä on yksi osapuoli. Osapuoli on pelaaja tai joukkue, jos USE_TEAMS on päällä. Tarkistus toimii vain, jos kierros alkoi kahdella tai useammalla osapuolella, joten testi yksin ei pääty samalla hetkellä kuin alkoi.
  • Ketään ei ole jäljellä. Kaikki kuolivat tai poistuivat, ja kierros päättyy ilman voittajaa.

Tarkistus kerran sekunnissa tarkoittaa, että kierros voi jatkua vielä enintään sekunnin viimeisen putoamisen jälkeen, mikä kierroksen ajastimessa on lähes huomaamatonta.

Winsien antaminen ja tuloksen näyttäminen

Tämän skriptin sääntö on yksinkertainen: kaikki, jotka ovat elossa kierroksen päättyessä, voittavat. Se kattaa yhdellä logiikkarivillä sekä viimeisen selviytyneen pelaajan, viimeisen selviytyneen joukkueen että tilan "kestä, kunnes ajastin loppuu". finishRound lisää 1 jokaisen voittajan Wins-arvoon, lopettaa heidän seurantansa ja näyttää viestin, kuten "Alex wins!", ajan RESULTS_SECONDS. Jos haluat, ettei ajan loppuessa ole voittajaa, ohita awardWin ja muuta viestiä, kun sidesLeft on suurempi kuin 1. Palauta luettelo joka tapauksessa, koska siivous palauttaa sen perusteella selviytyjät aulaan.

Siivous

Selviytyjät seisovat yhä kartalla, joten cleanup herättää heidät henkiin aulaan Player:LoadCharacterAsync()-kutsulla, joka korvaa vanhan LoadCharacter-kutsun, ja poistaa sitten kartan kopion. Jokainen henkiinherätys ajetaan omassa task.spawn-kutsussaan pcall-kutsun sisällä, koska kutsu odottaa hahmon latautumista ja voi epäonnistua, jos pelaaja on juuri sillä hetkellä poistumassa. Pudonneet pelaajat eivät tarvitse mitään: he ovat jo itse syntyneet uudelleen aulaan.

Vaihe 3: näytä ajastin ja tila jokaiselle pelaajalle

Palvelin julkaisee kolme attribuuttia ReplicatedStorage.RoundInfo-kansiossa: State (kiinteä sana, kuten InRound, skriptejä varten), Status (teksti ihmisille) ja TimeLeft (sekunnit). Attribuutit, jotka palvelinskripti asettaa replikoituvaan objektiin, välittyvät automaattisesti jokaiselle asiakkaalle, ja kesken kierroksen liittyvä pelaaja saa heti nykyiset arvot. Siksi ajastimelle tämä sopii paremmin kuin remote: RemoteEvent, joka lähetettiin ennen kuin joku liittyi, ei koskaan tavoita häntä.

  1. Lisää Explorerissa ScreenGui StarterGuihin ja nimeä se RoundHud. Jätä ResetOnSpawn päälle (oletus).
  2. Lisää LocalScript RoundHud-objektiin, nimeä se RoundHudClient ja liitä alla oleva koodi. Se luo tekstin itse, joten muuta ei tarvitse piirtää.
  3. Paina Play. Näytön yläreunan teksti näyttää tilan ja lähtölaskennan muodossa m:ss.
LocalScript kohteessa ScreenGui RoundHud StarterGuissa nimeltä RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Teksti. Jos piirsit oman TextLabelin RoundHudiin, poista tämä lohko ja käytä:
-- 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 -- pitkät viestit rivittyvät toiselle riville
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()

Koska ResetOnSpawn on päällä, Roblox antaa pelaajalle tuoreen kopion RoundHudista aina hahmon syntyessä, myös siivouksen henkiinherätyksessä. Skripti lukee silloin nykyiset attribuutit uudelleen, joten teksti ei koskaan vanhene.

Asiakas vain lukee. Mikään, mitä pelaaja muuttaa omalla näytöllään, ei vaikuta oikeaan ajastimeen, koska LocalScriptistä tehdyt attribuuttien muutokset jäävät tälle yhdelle asiakkaalle. Sekunnin kymmenyksiä näyttävää lähtölaskentaa varten palvelin voi sen sijaan tallentaa attribuuttiin päättymisajan workspace:GetServerTimeNow()-kutsusta, ja jokainen asiakas vähentää siitä joka ruudunpäivityksellä oman workspace:GetServerTimeNow()-arvonsa.

Jos pelisi avautuu päävalikkoon, RoundHud ilmestyy, kun pelaaja painaa Play, koska StarterGui kopioidaan pelaajalle vasta hänen hahmonsa synnyttyä. Valikossa vielä olevilla pelaajilla ei ole hahmoa, joten heitä ei koskaan teleportata kierrokseen.

Pelaajat, jotka kuolevat, poistuvat tai liittyvät kesken kierroksen

Nämä tapaukset jäävät helposti huomaamatta, kun kierrosskriptiä kirjoitetaan ensimmäistä kertaa. Jos jotain niistä ei käsitellä, näet yleensä virheen Outputissa tai kierroksen, joka ei koskaan pääty. Tässä on, mitä yllä oleva skripti tekee kullekin niistä.

Reunatapaukset ja miten kierrosskripti selviää niistä
TilanneMitä tapahtuuMissä skriptissä
Pelaaja kuolee kierroksella (tapettu, teki resetin, putosi)Hänet poistetaan kierrokselta, ja hän syntyy uudelleen aulaan ajan Players.RespawnTime jälkeen (oletuksena 5 sekuntia).humanoid.Died kutsuu eliminate
Hahmo poistettu ilman kuolemaaKuten kuollessa: pelaaja on pudonnut.player.CharacterRemoving kutsuu eliminate
Pelaaja poistuu palvelimeltaHänet poistetaan, hänen yhteytensä katkaistaan, ja seuraava tikki laskee osapuolet uudelleen.Players.PlayerRemoving kutsuu eliminate
Pelaaja liittyy kesken kierroksenHän syntyy aulaan, näkee reaaliaikaisen tilan ja ajastimen ja pääsee seuraavaan kierrokseen.Osallistujat valitaan vain funktiossa startRound
Pelaaja oli kuollut kierroksen alkaessaHäntä ei teleportata, hän odottaa aulassa.getLivingCharacter
Kaikki poistuivat tai kuolivatKierros päättyy tekstiin "Nobody survived", ja silmukka alkaa alusta: Intermission, jos palvelimella on vielä tarpeeksi pelaajia, muuten Waiting.sidesLeft == 0 funktiossa runRound

eliminate on kirjoitettu niin, että sitä on turvallista kutsua useita kertoja samalle pelaajalle. Pelaaja, joka kuoli ja syntyi uudelleen, laukaisee sekä Died- että CharacterRemoving-tapahtuman, ja poistuva voi laukaista kaikki kolme tapahtumaa; vain ensimmäinen kutsu tekee jotain.

Laajentaminen: joukkueet, karttaäänestys ja kierroksen tapahtumat

Viimeinen selviytynyt joukkue

Aseta USE_TEAMS = true ja lisää sitten Team-objekteja Explorerin Teams-palveluun, jokaiselle oma nimi ja TeamColor. Oletuksena Roblox laittaa jokaisen liittyvän pelaajan automaattisesti määritettävään joukkueeseen, jossa on vähiten jäseniä. Kun pelaajia poistuu, se ei tasapainota joukkueita uudelleen, joten pitkissä istunnoissa joukkueet voivat muuttua epätasaisiksi. Jätä aulan SpawnLocation Neutraliksi, jotta kaikki joukkueet syntyvät sinne. Silloin kierros päättyy, kun elossa olevia pelaajia on jäljellä vain yhdessä joukkueessa, ja tulos näyttää tältä: "Red wins!".

Muotoa "yksi kaikkia vastaan" (yksi metsästäjä, muut selviytyvät) varten valitse funktiossa startRound yksi satunnainen osallistuja ja aseta hänelle ennen teleporttia metsästäjäjoukkueen Team. Poista metsästäjäjoukkueelta AutoAssignable, jotta sinne ei koskaan päädy uusia pelaajia, ja palauta metsästäjä funktiossa cleanup selviytyjien joukkueeseen. Silloin toimivat samat päättymisehdot: metsästäjä voittaa, jos kaikki selviytyjät putosivat, ja selviytyjät voittavat, jos he kestivät ajastimen loppuun, edellyttäen että ohitat metsästäjän awardWin-kutsun, kun aika loppui.

Pelaajien karttaäänestys

Äänestystä varten asiakkaan täytyy viestiä palvelimen kanssa, joten tarvitaan RemoteEvent. Väliajan aikana palvelin julkaisee attribuutteina kahden tai kolmen kartan nimet, jokainen asiakas lähettää RemoteEventin kautta nimen, jota painoi, ja palvelin laskee äänet ennen loadMap-funktion ajamista. Palvelimen on pakko tarkistaa jokainen ääni: että argumentti on merkkijono, että se on yksi nykyisistä vaihtoehdoista, että tila on Intermission ja että jokainen pelaaja lasketaan kerran (säilytä äänet taulukossa, jonka avain on Player, jotta toinen ääni korvaa ensimmäisen, ja tyhjennä se PlayerRemoving-tapahtumassa). RemoteEvent-opas käy tämän tarkistusmallin läpi yksityiskohtaisesti.

Työkalun antaminen kierroksen alussa

Muut skriptit voivat reagoida kierrokseen koskematta RoundSystem-skriptiin. Kierrosskripti asettaa jokaiselle pelaajalle InRound-attribuutin, kun teleporttaa hänet, ja poistaa sen, kun pelaaja putoaa. Tämä skripti kuuntelee sitä ja antaa jokaiselle pelaajalle kopion ServerStoragessa olevasta Toolista nimeltä RoundTool.

Script kohteessa ServerScriptService nimeltä 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

Koodia, joka ottaa työkalun pois, ei ole. Kun hahmo kuolee, Roblox korvaa Backpackin tuoreella, joka täytetään StarterPackista, ja LoadCharacterAsync siivouksessa tyhjentää sen selviytyjiltä, joten kierroksen jälkeen työkalua ei enää ole.

Jos tarvitset annettavan aseen, kokoa miekka tai raycast-ase, pidä se ServerStoragessa StarterPackin sijaan ja vaihda tämän skriptin "RoundTool" sen nimeksi.

NPC:t ja muut objektit vain kierroksen ajaksi

Kaikki, minkä pitää olla olemassa vain kierroksen aikana, voi asua kartan mallin sisällä: viholliset, kerättävät esineet, liikkuvat tasot. ServerStoragessa olevan mallin sisällä skriptit eivät toimi; heti kun kopio on Workspacessa, ne käynnistyvät, ja map:Destroy() siivouksessa poistaa ne kaiken muun mukana. Lisätäksesi vihollisia, jotka jahtaavat pelaajia, kokoa yksi NPC-pathfinding-oppaan mukaan ja laita se karttaan. Kartan ohilentoa varten jokaisen kierroksen alussa välikohtausopas näyttää, miten tämä skripti voi käynnistää välikohtauksen jokaiselle pelaajalle BindableEventin kautta.

Miten tästä tehdään moduuli

Aluksi ModuleScriptiä ei tarvita. Yhtä Scriptiä on helpompi lukea, kun kokoat peliä. Jaa se, kun muiden skriptien täytyy kutsua kierroksen funktioita tai kun haluat siirtää asetukset yhteen yhteiseen ModuleScriptiin, jonka sekä palvelin että UI:si voivat ottaa käyttöön requirella. Siihen asti RoundInfo-kansion State-attribuutti ja jokaisen pelaajan InRound-attribuutti toimivat jo kierrosjärjestelmän julkisena rajapintana: mikä tahansa skripti voi kuunnella niitä.

Yleiset virheet ja ratkaisut

Avaa Output-ikkuna (Studion Window-valikosta tai Script-välilehdeltä) ennen kuin painat Play. Useimmat kierrosjärjestelmän ongelmat tulostavat sinne varoituksen tai virheen skriptin nimen ja rivinumeron kanssa.

Jää tilaan "Waiting for players (1/2)"

Testaat yksin, ja MIN_PLAYERS on 2. Aseta 1 yksintestejä varten tai testaa Server & Clients -tilassa 2 asiakkaalla.

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

Kansiota ei ole, sen nimessä on kirjoitusvirhe tai se on väärässä palvelussa. Sen täytyy olla Folder, jonka nimi on täsmälleen Maps, suoraan ServerStoragen sisällä. Sama varoitus RoundInfo-kansiosta LocalScriptissä tarkoittaa, että RoundSystem-skripti ei koskaan päässyt sen luomiseen asti: se on pois päältä, kaatui virheeseen tai odottaa yhä Maps-kansiota.

Teleportin jälkeen pelaajat putoavat kartan läpi

Kartan partit eivät ole ankkuroituja, joten kopio hajoaa heti, kun se on Workspacessa. Valitse kartta, ankkuroi sen partit ja varmista, että spawn-partit ovat lattian yläpuolella eivätkä sen sisällä.

Pudonneet pelaajat syntyvät uudelleen areenalle

Kartan sisällä on SpawnLocation. Korvaa se tavallisella Partilla kartan Spawns-kansiossa.

Kierros ei pääty, kun kaikki kuolivat

Varmista, että vahinkosi todella tappaa Humanoidin (terveys laskee 0:aan) eikä vain liikuta tai ankkuroi pelaajia. Jos poistit Humanoidin Dead-tilan käytöstä, Died ei koskaan laukea, ja kierroksen täytyy jatkua ajastimen loppuun.

Kierrossilmukka pysähtyy pysyvästi yhden virheen jälkeen

Silmukka toimii yhdessä säikeessä, joten virhe missä tahansa tilassa lopettaa sen. Lue virhe Outputista, korjaa rivi ja testaa uudelleen. Yleinen syy: skriptiä muutettiin niin, että se käyttää player.Character.Humanoid tarkistamatta, että hahmo on olemassa.

Tee se RoCodella

Jos et halua koota tätä kaikkea käsin, RoCode voi tehdä sen paikkaan, joka sinulla on auki. Se on tekoälyagentti, joka toimii Roblox Studion lisäosan kautta, joten skriptit ja partit ilmestyvät Exploreriisi eikä chat-ikkunaan, josta ne pitäisi liittää.

Sinä kirjoitat

Lisää kierrosjärjestelmä: 20 sekunnin väliaika, joka tarvitsee 2 pelaajaa, satunnainen kartta ServerStorage.Mapsista, kaikkien teleporttaus kartan spawn-parteille, 2 minuutin kierrokset, joissa viimeinen elossa oleva pelaaja voittaa, lisää Win leaderstatsiin ja näytä tila ja ajastin näytön yläreunassa.

RoCode tekee
  • Voi ensin käydä paikkasi läpi List Childrenillä, Search Gamella ja Search Scriptsillä käyttääkseen Maps-kansiotasi ja leaderstats-skriptiäsi eikä lisätäkseen toista sarjaa
  • Luo kierrosten Scriptin ServerScriptServiceen ja ajastimen LocalScriptin Create Scriptillä ja voi asettaa areenan valmiista rakennelmistaan Place Prefabilla, jos sinulla ei vielä ole karttaa
  • Tarkistaa ennen lopettamista jokaisen skriptin kääntymisen Studion sisällä Check Scriptillä. Se löytää syntaksivirheet, ei kierroslogiikan virheitä
  • Pelitestisi jälkeen Check Output lukee Server- ja Client-rivit viimeisimmästä pelitestistä korjatakseen ajonaikaisen virheen

Lisäosalla 3.9 tai uudemmalla RoCode voi ajaa lyhyen pelitestin ja lukea virheet, ja lisäosalla 3.9.11 tai uudemmalla se voi ohjata yhtä testihahmoa, mutta se ei testaa usealla pelaajalla, joten aja kierrokset itse Server & Clients -tilassa. Jokainen muutoserä on kumouspiste Studiossa. Kierrossilmukka on monen pelin perustana, ja kokonaisen Roblox-pelin tekeminen tekoälyllä järjestelmä kerrallaan alkaa usein tällaisesta silmukasta. Miten RoCode yhdistyy Studioon.

Usein kysytyt kysymykset

Miten tehdä joukkueellinen kierrosjärjestelmä Robloxissa?

Lisää Team-objekteja Teams-palveluun ja aseta kierrosskriptissä USE_TEAMS = true. Roblox jakaa liittyvät pelaajat automaattisesti määritettävään joukkueeseen, jossa on vähiten jäseniä, ja kierros päättyy, kun elossa olevia pelaajia on jäljellä vain yhdessä joukkueessa.

Miten näyttää lähtölaskenta kaikille pelaajille?

Aseta palvelimelta jäljellä olevat sekunnit attribuutiksi ReplicatedStoragessa olevaan objektiin ja kuuntele sitä GetAttributeChangedSignal-kutsulla LocalScriptissä, joka päivittää TextLabelin, kuten vaiheessa 3. Myöhemmin liittyneet pelaajat saavat heti nykyisen arvon.

Kumpaa kierrossilmukassa käytetään: wait() vai task.wait()?

Käytä task.wait(). Roblox merkitsee globaalin wait()-funktion vanhentuneeksi ja korvatuksi task.wait()-funktiolla.

Miten teleportata pelaajat toiseen paikkaan joka kierroksella?

Se on eri työkalu. Tämä opas siirtää hahmoja yhden palvelimen sisällä PivotTo-kutsulla. Pelaajien lähettäminen experiencesi toiseen paikkaan tehdään TeleportService-palvelulla, joka siirtää heidät toiselle palvelimelle. Teleporttiopas kokoaa portaalit, jotka tekevät tämän, uudelleenyrityksillä, jos teleportti epäonnistuu.

Miksi pelaajat jähmettyvät hetkeksi teleportin jälkeen?

Kun instance streaming on päällä, asiakas ei ole vielä saanut karttaa. Skriptin RequestStreamAroundAsync-kutsu "valmistautukaa"-laskennan aikana pyytää moottoria lähettämään sen etukäteen; pidempi GET_READY_SECONDS antaa hitaille yhteyksille enemmän aikaa.

Lähteet ja lisälukemista

Miten koodi tarkistettiin: jokainen tämän sivun skripti läpäisee Luaun tiukan tyyppitarkistuksen Roblox API:n määrittelyillä (luau-lsp, 20. marraskuuta 2026). Tyyppitarkistus löytää virheet API-nimissä ja väärät tyypit, mutta ei pelilogiikan virheitä, joten testaa kaikki Studiossa ennen julkaisua.

Kokeile RoCodea omassa pelissäsi.

Ilmaisia krediittejä joka päivä, ei korttia. Asenna lisäosa, kuvaile ominaisuus ja katso, mitä Studioon ilmestyi.