Tutorial · Sistemi di gioco

Come fare un sistema di round in Roblox Studio

La maggior parte dei giochi a round su Roblox fa girare lo stesso ciclo: aspetta i giocatori, fa il conto alla rovescia, carica una mappa, teletrasporta tutti lì, fa scorrere un timer, sceglie un vincitore e fa pulizia. In questa guida costruiamo questo ciclo come un unico script server chiaro, aggiungiamo un timer che ogni giocatore vede e analizziamo i casi su cui si rompono gli script copiati: giocatori che muoiono, escono o entrano a metà round.

Aggiornato il 20 novembre 202616 min di letturaScritto da

In breve

Scrivi un unico Script server in ServerScriptService che passa in ciclo da un insieme fisso di stati: intermissione (aspettare il numero di giocatori necessario, poi il conto alla rovescia), caricamento della mappa (clonare una mappa casuale da ServerStorage in Workspace), teletrasporto (spostare ogni personaggio vivo su una parte di spawn con PivotTo), round (far scorrere il timer finché non scade il tempo o resta un solo giocatore o una sola squadra) e pulizia (assegnare le Wins, far rinascere i sopravvissuti, eliminare la mappa).

  • Esegui il ciclo solo sul server. Pubblica lo stato e i secondi rimanenti come attributi su una Folder in ReplicatedStorage, e lascia che sia un LocalScript a mostrarli.
  • Tieni una tabella di chi è ancora nel round. Rimuovi un giocatore quando il suo Humanoid muore, il suo personaggio viene rimosso o lui esce.
  • Teletrasporta solo i giocatori il cui personaggio è vivo al momento dell'inizio del round. Chi entra dopo aspetta il prossimo nella lobby.
In questa pagina
  1. Come funziona
  2. 1. Lobby e mappe
  3. 2. Script dei round
  4. Come funzionano gli stati
  5. 3. UI del timer
  6. Giocatori a metà round
  7. Come estenderlo
  8. Common errors
  9. Con RoCode
  10. Domande frequenti
  11. Fonti e letture

Come funziona un sistema di round

IllustrazioneGli script dei round finiti in un gioco in esecuzione, accelerato.

Un sistema di round è una macchina a stati. In ogni momento il server si trova in esattamente uno stato, ogni stato ha un solo compito, e una sola condizione lo fa passare al successivo. Scrivendolo così, tutta la logica sta in un solo posto, e non nasce il classico bug in cui il ciclo del timer e il ciclo del round cercano entrambi di chiudere lo stesso round.

Gli stati del ciclo dei round in questa guida
StatoCosa fa il serverQuando passa avanti
WaitingMostra "Waiting for players (1/2)"Sul server ci sono abbastanza giocatori
IntermissionFa il conto alla rovescia mentre tutti sono nella lobbyIl conto è finito (o torna a Waiting se i giocatori sono usciti)
StartingCopia una mappa casuale in Workspace, mostra il suo nome, chiede ai client di caricarlaÈ finito un breve conto "preparatevi"
InRoundTeletrasporta i giocatori vivi, fa scorrere il timer, rimuove chi è morto o uscitoIl tempo è scaduto, o è rimasto un solo giocatore o una sola squadra
ResultsDà una Win a tutti quelli ancora vivi e mostra chi ha vintoSono passati alcuni secondi
CleanupFa rinascere i sopravvissuti nella lobby ed elimina la mappaSubito, dopodiché il ciclo ricomincia

Ogni stato è gestito dal server. I client mostrano soltanto quello che il server dice loro. Un conto alla rovescia in un LocalScript si discosta da quello vero, è sbagliato per chi entra dopo e un exploiter può modificarlo. Se la divisione tra server e client è nuova per te, leggi prima Script vs LocalScript vs ModuleScript (in inglese).

Passo 1: costruisci la lobby, le mappe e la statistica Wins

  1. Costruisci una lobby in Workspace con una SpawnLocation. Controlla che abbia la proprietà Neutral spuntata, così ogni giocatore nasce qui, aspetta qui e torna qui dopo essere stato eliminato.
  2. In ServerStorage inserisci una Folder chiamata Maps. Gli oggetti in ServerStorage non vengono mai inviati ai giocatori, quindi le mappe inutilizzate non costano loro nulla.
  3. Costruisci ogni mappa come Model dentro Maps, con le parti ancorate. Costruiscila lontano dalla lobby (bastano alcune centinaia di stud), perché la copia appare esattamente dove l'hai costruita, e i giocatori eliminati non devono poter rientrarci a piedi.
  4. Dentro ogni mappa aggiungi una Folder chiamata Spawns, e al suo interno una Part ancorata per ogni giocatore previsto. Imposta la loro Transparency a 1 e disattiva CanCollide, così nessuno le vede e nessuno ci inciampa.
L'Explorer dopo questa guida
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

Lo script dei round aggiunge 1 a un IntValue chiamato Wins dentro la cartella leaderstats del giocatore. Se il tuo gioco non ha ancora le leaderstats, aggiungi questo breve script. Se ce le ha già, per esempio la versione con salvataggio della guida alla classifica, saltalo: due script che creano le leaderstats danno a ogni giocatore due cartelle.

Script in ServerScriptService chiamato Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- il nome deve essere esattamente questo, in minuscolo

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

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- In Studio puoi entrare prima che questo script parta, quindi prepariamo chi è già qui
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Queste Wins si azzerano quando il giocatore esce. Per farle restare tra una sessione e l'altra, usa la versione con DataStore della guida alla classifica.

Passo 2: aggiungi lo script dei round

Inserisci uno Script in ServerScriptService, chiamalo RoundSystem e incolla il codice qui sotto. Le impostazioni in alto sono le uniche righe che probabilmente dovrai cambiare. Ogni stato è una funzione a sé, e il ciclo in fondo le esegue in ordine, all'infinito.

Script in ServerScriptService chiamato RoundSystem
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Impostazioni
local MIN_PLAYERS = 2 -- metti 1 finché provi da solo
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: il round finisce quando restano giocatori in una sola squadra

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

-- Quello che mostra lo schermo di ogni giocatore sta negli attributi di questa cartella.
-- Gli attributi impostati dal server si replicano su tutti i client, anche su chi entra dopo.
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

-- Chi è ancora nel round attuale, e le connessioni che seguono ognuno di loro
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)

-- Restituisce personaggio e Humanoid solo se il giocatore è vivo in questo momento
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

-- Conta le parti rimaste nel round (giocatori, o squadre se USE_TEAMS è attivo)
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

-- STATO: Waiting e Intermission. Restituisce false se i giocatori escono durante il conto.
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

-- STATO: Starting, parte 1. Copiamo una mappa casuale (non la precedente, se c'è scelta).
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
	-- Mescoliamo, così i giocatori non finiscono sullo stesso spawn a ogni round
	for i = #points, 2, -1 do
		local j = random:NextInteger(1, i)
		points[i], points[j] = points[j], points[i]
	end
	return points
end

-- A che altezza dal pavimento si trova la root part di un personaggio in piedi.
-- Formula dal riferimento Roblox su Humanoid.HipHeight (i rig R6 aggiungono l'altezza della gamba).
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

-- STATO: Starting, parte 2. Prepararsi, poi teletrasportare tutti i vivi.
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

	-- Con lo streaming attivo chiediamo a ogni client di caricare la mappa prima che arrivi il personaggio
	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

	-- Partecipa solo chi è vivo in questo momento. Gli altri aspettano il prossimo round.
	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]
			-- Il pivot del personaggio è la sua root part, quindi lo alziamo all'altezza in piedi sopra la parte
			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

-- STATO: InRound. Finisce quando scade il tempo o resta una sola parte.
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()
		-- Un round iniziato da una sola parte (test da solo) finisce solo per tempo o per morte
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- STATO: Results. Vincono tutti quelli ancora vivi.
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) -- smettiamo di seguirli; restano sulla mappa fino alla pulizia
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- STATO: Cleanup. Rimandiamo i sopravvissuti nella lobby, poi eliminiamo la mappa.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- ancora sul server
			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

-- Il ciclo: un giro è un round
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) -- ancora nessuna mappa: riproviamo tra poco
		end
	end
end

Tutto quello che conta succede qui, sul server: chi è nel round, il timer, il vincitore e le Wins. I client ricevono solo tre attributi su ReplicatedStorage.RoundInfo (State, Status e TimeLeft) e un attributo InRound su ogni giocatore.

Come funziona ogni stato

Attesa e intermissione

runIntermission prima tiene fermo il ciclo finché #Players:GetPlayers() non arriva a MIN_PLAYERS. Poi conta alla rovescia un secondo alla volta con task.wait(1) e a ogni tick controlla il numero di giocatori. Se qualcuno esce e sul server si scende sotto il minimo, restituisce false e il ciclo principale ricomincia da Waiting, così un round non inizia mai con una persona sola.

Scelta e caricamento della mappa

loadMap raccoglie tutti i Model in ServerStorage.Maps, toglie la mappa del round precedente se c'è altro tra cui scegliere, e ne prende una con Random:NextInteger. Poi clona la mappa in Workspace. L'originale resta intatto in ServerStorage, quindi ogni round parte da una copia nuova: tutto quello che i giocatori hanno rotto o spostato nel round precedente sparisce.

Nei nuovi place lo streaming delle istanze è attivo: il client ha solo le parti vicine al suo personaggio. Prima del teletrasporto lo script chiama Player:RequestStreamAroundAsync per ogni giocatore, e questo chiede al motore di inviare al client la zona intorno alla mappa durante il conto "preparatevi". Senza, i giocatori possono arrivare prima che il pavimento sia caricato e bloccarsi per un istante.

Teletrasportare i giocatori con PivotTo

Dopo il conto alla rovescia lo script crea la lista dei partecipanti dai giocatori il cui personaggio esiste, è ancora nel mondo e ha un Humanoid con salute maggiore di 0 e una root part. Questo controllo avviene dopo il conto, quindi chi è morto o uscito durante il conto non entra nella lista.

Ogni partecipante viene spostato con character:PivotTo(cframe). Il riferimento di Roblox indica PivotTo come il modo principale per spostare i modelli da script, e sposta insieme tutte le parti del personaggio. Impostare HumanoidRootPart.Position non è la stessa cosa: Roblox aggiusta le giunzioni in modo che si sposti solo quella parte, e il resto del corpo può restare indietro. Il pivot del personaggio è la sua root part, quindi la destinazione è il CFrame della parte di spawn alzato di metà dell'altezza della parte più l'altezza a cui la root part sta sopra il pavimento. rootHeight la calcola con la formula del riferimento Roblox su Humanoid.HipHeight: metà dell'altezza della root part più HipHeight, più la lunghezza della gamba nei rig R6. Così gli avatar scalati e personalizzati non restano incastrati nella parte e non ci cadono sopra dall'alto. Il CFrame include la rotazione, quindi i giocatori guardano nella stessa direzione della parte di spawn: ruota le parti in modo che tutti guardino verso il centro della mappa.

Se i giocatori sono più delle parti di spawn, lo script ricomincia dalla prima parte e i giocatori finiscono uno sopra l'altro, quindi aggiungi almeno tanti spawn quanti sono i tuoi giocatori massimi.

Se usi anche il controllo della velocità della guida alla corsa, aggiungi player:SetAttribute("MovementCheckSkip", true) subito dopo character:PivotTo(...) in startRound, così il teletrasporto non viene contato come eccesso di velocità.

Il timer del round e le condizioni di fine

runRound fa un tick al secondo. A ogni tick aggiorna lo stato (quanti giocatori restano) e i secondi rimanenti, poi conta le parti vive. Il round finisce in uno di tre modi:

  • Il tempo è scaduto. Il ciclo for arriva a 1 e termina.
  • È rimasta una sola parte. Una parte è un giocatore, o una squadra se USE_TEAMS è attivo. Il controllo funziona solo se il round è iniziato con due o più parti, così un test da solo non finisce nello stesso istante in cui comincia.
  • Non è rimasto nessuno. Sono tutti morti o usciti, e il round finisce senza vincitore.

Controllare una volta al secondo significa che il round può durare fino a un secondo in più dopo l'ultima eliminazione, cosa che su un timer di round quasi non si nota.

Assegnare le Wins e mostrare il risultato

La regola in questo script è semplice: vincono tutti quelli vivi al termine del round. Questo copre l'ultimo giocatore sopravvissuto, l'ultima squadra sopravvissuta e la modalità "resisti finché non scade il timer" con una sola riga di logica. finishRound aggiunge 1 alle Wins di ogni vincitore, smette di seguirli e mostra un messaggio come "Alex wins!" per RESULTS_SECONDS. Se vuoi che allo scadere del tempo non ci sia un vincitore, salta awardWin e cambia il messaggio quando sidesLeft è maggiore di 1. In ogni caso continua a restituire la lista, perché la pulizia la usa per riportare i sopravvissuti nella lobby.

Pulizia

I sopravvissuti sono ancora sulla mappa, quindi cleanup li fa rinascere nella lobby con Player:LoadCharacterAsync(), che sostituisce il vecchio LoadCharacter, e poi elimina la copia della mappa. Ogni rinascita gira nel suo task.spawn dentro un pcall, perché la chiamata aspetta il caricamento del personaggio e può fallire se il giocatore sta uscendo proprio in quel momento. Ai giocatori eliminati non serve nulla: sono già rinati da soli nella lobby.

Passo 3: mostra il timer e lo stato a ogni giocatore

Il server pubblica tre attributi su ReplicatedStorage.RoundInfo: State (una parola fissa come InRound, per gli script), Status (testo per le persone) e TimeLeft (secondi). Gli attributi che uno script server imposta su un oggetto replicato arrivano automaticamente a ogni client, e un giocatore che entra a metà round riceve subito i valori attuali. Per questo per un timer vanno meglio di un remote: un RemoteEvent inviato prima che qualcuno entrasse non gli arriverà mai.

  1. Nell'Explorer inserisci una ScreenGui in StarterGui e chiamala RoundHud. Lascia ResetOnSpawn attivo (predefinito).
  2. Inserisci un LocalScript in RoundHud, chiamalo RoundHudClient e incolla il codice qui sotto. Crea da solo la scritta, quindi non devi disegnare nient'altro.
  3. Premi Play. La scritta in cima allo schermo mostra lo stato e il conto alla rovescia nel formato m:ss.
LocalScript in ScreenGui RoundHud in StarterGui chiamato RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- La scritta. Se hai disegnato una tua TextLabel in RoundHud, elimina questo blocco e usa:
-- 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 -- i messaggi lunghi vanno a capo su una seconda riga
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()

Dato che ResetOnSpawn è attivo, Roblox dà al giocatore una copia nuova di RoundHud a ogni spawn del personaggio, inclusa la rinascita della pulizia. Lo script allora rilegge gli attributi attuali, quindi la scritta non è mai vecchia.

Il client legge soltanto. Nulla di quello che un giocatore cambia sul proprio schermo influisce sul timer vero, perché le modifiche agli attributi da un LocalScript restano su quel solo client. Per un conto alla rovescia con i decimi di secondo, il server può invece salvare in un attributo l'ora di fine presa da workspace:GetServerTimeNow(), e ogni client a ogni frame ci sottrae il proprio workspace:GetServerTimeNow().

Se il tuo gioco si apre con un menu principale, RoundHud compare quando il giocatore preme Play, perché StarterGui viene copiato al giocatore solo dopo lo spawn del suo personaggio. I giocatori ancora nel menu non hanno un personaggio, quindi non vengono mai teletrasportati in un round.

Giocatori che muoiono, escono o entrano a metà round

Questi casi sono facili da dimenticare quando si scrive uno script dei round per la prima volta. Se uno di loro non è gestito, di solito vedi un errore nell'Output o un round che non finisce mai. Ecco cosa fa lo script qui sopra con ciascuno.

Casi limite e come li gestisce lo script dei round
SituazioneCosa succedeDove nello script
Un giocatore muore nel round (ucciso, reset, caduto)Viene tolto dal round e rinasce nella lobby dopo Players.RespawnTime (5 secondi di default).humanoid.Died chiama eliminate
Personaggio rimosso senza morireCome per la morte: il giocatore è eliminato.player.CharacterRemoving chiama eliminate
Un giocatore esce dal serverViene tolto, le sue connessioni si scollegano, e il tick successivo riconta le parti.Players.PlayerRemoving chiama eliminate
Un giocatore entra a metà roundNasce nella lobby, vede lo stato e il timer in diretta ed entra nel round successivo.I partecipanti vengono scelti solo in startRound
Un giocatore era morto all'inizio del roundNon viene teletrasportato, aspetta nella lobby.getLivingCharacter
Tutti sono usciti o mortiIl round finisce con "Nobody survived" e il ciclo ricomincia: Intermission se sul server ci sono ancora abbastanza giocatori, altrimenti Waiting.sidesLeft == 0 in runRound

eliminate è scritta in modo che si possa chiamare più volte per lo stesso giocatore senza problemi. Un giocatore che muore e rinasce attiva sia Died sia CharacterRemoving, e chi esce può attivare tutti e tre gli eventi; solo la prima chiamata fa qualcosa.

Come estenderlo: squadre, voto della mappa ed eventi del round

Ultima squadra sopravvissuta

Imposta USE_TEAMS = true, poi aggiungi oggetti Team al servizio Teams nell'Explorer, ognuno con il suo nome e TeamColor. Di default Roblox mette ogni giocatore che entra nella squadra ad assegnazione automatica con meno membri. Quando i giocatori escono, non ribilancia le squadre, quindi nelle sessioni lunghe le squadre possono diventare sbilanciate. Lascia Neutral la SpawnLocation della lobby, così tutte le squadre nascono lì. A quel punto il round finisce quando i giocatori vivi restano in una sola squadra, e il risultato appare come "Red wins!".

Per un formato "uno contro tutti" (un cacciatore, gli altri sopravvivono) scegli in startRound un partecipante casuale e prima del teletrasporto imposta il suo Team sulla squadra del cacciatore. Togli AutoAssignable alla squadra del cacciatore, così i nuovi giocatori non ci finiscono mai, e in cleanup riporta il cacciatore nella squadra dei sopravvissuti. Così funzionano le stesse condizioni di fine: il cacciatore vince se tutti i sopravvissuti sono eliminati, e i sopravvissuti vincono se resistono fino alla fine del timer, a patto che tu salti awardWin per il cacciatore quando scade il tempo.

Voto dei giocatori per la mappa

Per il voto il client deve parlare con il server, quindi serve un RemoteEvent. Durante l'intermissione il server pubblica come attributi due o tre nomi di mappe, ogni client invia con il RemoteEvent il nome che ha cliccato, e il server conta i voti prima di eseguire loadMap. Il server deve controllare ogni voto: che l'argomento sia una stringa, che sia una delle opzioni attuali, che lo stato sia Intermission e che ogni giocatore conti una sola volta (salva i voti in una tabella con chiave Player, così un secondo voto sostituisce il primo, e svuotala in PlayerRemoving). La guida ai RemoteEvent spiega in dettaglio questo schema di controlli.

Dare uno strumento all'inizio del round

Altri script possono reagire al round senza toccare RoundSystem. Lo script dei round imposta l'attributo InRound su ogni giocatore quando lo teletrasporta, e lo toglie quando il giocatore viene eliminato. Questo script lo ascolta e dà a ogni giocatore una copia di un Tool chiamato RoundTool che sta in ServerStorage.

Script in ServerScriptService chiamato 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

Non c'è codice che tolga lo strumento. Quando un personaggio muore, Roblox sostituisce il Backpack con uno nuovo riempito da StarterPack, e LoadCharacterAsync della pulizia lo svuota per i sopravvissuti, quindi dopo il round lo strumento non c'è più.

Se ti serve un'arma da dare, costruisci una spada o una pistola a raycast (in inglese), tienila in ServerStorage invece che in StarterPack e cambia "RoundTool" in questo script con il suo nome.

NPC e altri oggetti solo per la durata del round

Tutto quello che deve esistere solo durante il round può vivere dentro il modello della mappa: nemici, oggetti da raccogliere, piattaforme mobili. Gli script dentro un modello in ServerStorage non girano; appena la copia è in Workspace partono, e map:Destroy() nella pulizia li elimina insieme a tutto il resto. Per aggiungere nemici che inseguono i giocatori, costruiscine uno con la guida al pathfinding degli NPC e mettilo nella mappa. Per un sorvolo della mappa all'inizio di ogni round, la guida alle cutscene mostra come questo script può avviare una cutscene per ogni giocatore con un BindableEvent.

Trasformarlo in un modulo

Per iniziare non serve un ModuleScript. Un solo Script è più facile da leggere mentre costruisci il gioco. Dividilo quando altri script devono chiamare funzioni del round o quando vuoi spostare le impostazioni in un unico ModuleScript condiviso che sia il server sia la tua UI possono caricare con require. Fino ad allora l'attributo State su RoundInfo e l'attributo InRound su ogni giocatore funzionano già come interfaccia pubblica del sistema di round: qualsiasi script può ascoltarli.

Errori comuni e soluzioni

Apri la finestra Output (dal menu Window di Studio o dalla scheda Script) prima di premere Play. La maggior parte dei problemi con un sistema di round stampa lì un avviso o un errore con il nome dello script e il numero di riga.

Bloccato su "Waiting for players (1/2)"

Stai provando da solo e MIN_PLAYERS vale 2. Metti 1 per i test da solo, oppure prova in modalità Server & Clients con 2 client.

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

La cartella non c'è, ha un errore di battitura nel nome o è nel servizio sbagliato. Deve essere una Folder chiamata esattamente Maps direttamente dentro ServerStorage. Lo stesso avviso per RoundInfo nel LocalScript significa che lo script RoundSystem non è mai arrivato a crearla: è disattivato, si è fermato con un errore o sta ancora aspettando la cartella Maps.

Dopo il teletrasporto i giocatori cadono attraverso la mappa

Le parti della mappa non sono ancorate, quindi la copia si sfascia appena arriva in Workspace. Seleziona la mappa, ancora le sue parti e controlla che le parti di spawn stiano sopra il pavimento, non dentro.

I giocatori eliminati rinascono nell'arena

Dentro la mappa c'è una SpawnLocation. Sostituiscila con una Part normale nella cartella Spawns di quella mappa.

Il round non finisce quando sono tutti morti

Controlla che il tuo danno uccida davvero lo Humanoid (la salute arriva a 0) e non si limiti a spostare o ancorare i giocatori. Se hai disattivato lo stato Dead dello Humanoid, Died non scatta mai, e il round deve arrivare alla fine del timer.

Il ciclo dei round si ferma per sempre dopo un errore

Il ciclo gira in un solo thread, quindi un errore in qualsiasi stato lo termina. Leggi l'errore nell'Output, correggi la riga e prova di nuovo. Una causa frequente: lo script è stato modificato in modo da usare player.Character.Humanoid senza controllare che il personaggio esista.

Farlo con RoCode

Se non hai voglia di costruire tutto questo a mano, RoCode può farlo nel place che hai aperto. È un agente IA che lavora tramite un plugin per Roblox Studio, quindi script e parti compaiono nel tuo Explorer, non in una finestra di chat da cui dovresti incollarli.

Tu scrivi

Aggiungi un sistema di round: intermissione di 20 secondi che richiede 2 giocatori, mappa casuale da ServerStorage.Maps, teletrasporto di tutti sulle parti di spawn della mappa, round da 2 minuti in cui vince l'ultimo giocatore vivo, aggiungi una Win alle leaderstats e mostra stato e timer in cima allo schermo.

RoCode fa
  • Può prima esaminare il tuo place con List Children, Search Game e Search Scripts, per usare la tua cartella Maps e il tuo script leaderstats invece di aggiungerne un secondo set
  • Crea lo Script dei round in ServerScriptService e il LocalScript del timer con Create Script, e può piazzare un'arena dalle sue costruzioni pronte con Place Prefab se non hai ancora una mappa
  • Controlla che ogni script compili dentro Studio con Check Script prima di finire. Questo trova gli errori di sintassi, non gli errori nella logica del round
  • Dopo il tuo playtest, Check Output legge le righe Server e Client dell'ultimo playtest per correggere un errore in esecuzione

Con il plugin 3.9 o più recente RoCode può avviare un breve playtest e leggere gli errori, e con il plugin 3.9.11 o più recente può controllare un personaggio di prova, ma non fa test con più giocatori, quindi prova tu i round in modalità Server & Clients. Ogni gruppo di modifiche è un punto di annullamento in Studio. Un ciclo di round è alla base di molti giochi, e creare un intero gioco Roblox con l'IA, un sistema alla volta spesso parte da un ciclo come questo. Come RoCode si collega a Studio.

Domande frequenti

Come si fa un sistema di round con le squadre su Roblox?

Aggiungi oggetti Team al servizio Teams e imposta USE_TEAMS = true nello script dei round. Roblox mette i giocatori che entrano nella squadra ad assegnazione automatica con meno membri, e il round finisce quando i giocatori vivi restano in una sola squadra.

Come mostro un conto alla rovescia a tutti i giocatori?

Imposta dal server i secondi rimanenti come attributo su un oggetto in ReplicatedStorage e ascoltalo con GetAttributeChangedSignal in un LocalScript che aggiorna una TextLabel, come nel passo 3. I giocatori che entrano dopo ricevono subito il valore attuale.

Nel ciclo dei round va usato wait() o task.wait()?

Usa task.wait(). Roblox indica il wait() globale come deprecato e sostituito da task.wait().

Come teletrasporto i giocatori in un altro place a ogni round?

È uno strumento diverso. Questa guida sposta i personaggi dentro lo stesso server con PivotTo. Mandare i giocatori in un altro place della tua experience si fa con TeleportService, che li sposta su un altro server. La guida al teletrasporto costruisce portali che lo fanno, con nuovi tentativi se il teletrasporto fallisce.

Perché i giocatori si bloccano per un istante dopo il teletrasporto?

Con lo streaming delle istanze attivo il client non ha ancora ricevuto la mappa. La chiamata RequestStreamAroundAsync nello script durante il conto "preparatevi" chiede al motore di inviarla in anticipo; un GET_READY_SECONDS più lungo dà più tempo alle connessioni lente.

Fonti e letture

Come è stato controllato il codice: ogni script di questa pagina supera il controllo dei tipi rigoroso di Luau con le definizioni dell'API di Roblox (luau-lsp, 20 novembre 2026). Il controllo dei tipi trova API scritte male e tipi sbagliati, non la logica del gioco, quindi provalo in Studio prima di pubblicare.

Prova RoCode nel tuo gioco.

Crediti gratis ogni giorno, senza carta. Installa il plugin, descrivi la funzione e controlla cosa compare in Studio.