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
Come funziona un sistema di round
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.
| Stato | Cosa fa il server | Quando passa avanti |
|---|---|---|
| Waiting | Mostra "Waiting for players (1/2)" | Sul server ci sono abbastanza giocatori |
| Intermission | Fa il conto alla rovescia mentre tutti sono nella lobby | Il conto è finito (o torna a Waiting se i giocatori sono usciti) |
| Starting | Copia una mappa casuale in Workspace, mostra il suo nome, chiede ai client di caricarla | È finito un breve conto "preparatevi" |
| InRound | Teletrasporta i giocatori vivi, fa scorrere il timer, rimuove chi è morto o uscito | Il tempo è scaduto, o è rimasto un solo giocatore o una sola squadra |
| Results | Dà una Win a tutti quelli ancora vivi e mostra chi ha vinto | Sono passati alcuni secondi |
| Cleanup | Fa rinascere i sopravvissuti nella lobby ed elimina la mappa | Subito, 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
- 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. - In ServerStorage inserisci una
FolderchiamataMaps. Gli oggetti in ServerStorage non vengono mai inviati ai giocatori, quindi le mappe inutilizzate non costano loro nulla. - Costruisci ogni mappa come
ModeldentroMaps, 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. - Dentro ogni mappa aggiungi una
FolderchiamataSpawns, e al suo interno unaPartancorata per ogni giocatore previsto. Imposta la loro Transparency a 1 e disattiva CanCollide, così nessuno le vede e nessuno ci inciampa.
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.
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.
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
forarriva 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.
- Nell'Explorer inserisci una ScreenGui in StarterGui e chiamala
RoundHud. Lascia ResetOnSpawn attivo (predefinito). - Inserisci un LocalScript in
RoundHud, chiamaloRoundHudCliente incolla il codice qui sotto. Crea da solo la scritta, quindi non devi disegnare nient'altro. - Premi Play. La scritta in cima allo schermo mostra lo stato e il conto alla rovescia nel formato
m:ss.
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.
| Situazione | Cosa succede | Dove 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 morire | Come per la morte: il giocatore è eliminato. | player.CharacterRemoving chiama eliminate |
| Un giocatore esce dal server | Viene tolto, le sue connessioni si scollegano, e il tick successivo riconta le parti. | Players.PlayerRemoving chiama eliminate |
| Un giocatore entra a metà round | Nasce 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 round | Non viene teletrasportato, aspetta nella lobby. | getLivingCharacter |
| Tutti sono usciti o morti | Il 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.
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.
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.
- 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
- Roblox Creator Docs: Add rounds (in inglese). il ciclo di round a squadre di Roblox nell'esempio di laser tag
- Roblox Creator Docs: PVInstance:PivotTo (in inglese). spostare modelli e personaggi da script
- Roblox Creator Docs: Player (in inglese). LoadCharacterAsync, CharacterRemoving e RequestStreamAroundAsync
- Roblox Creator Docs: Properties and attributes (in inglese). impostare attributi e seguire le modifiche
- Roblox Creator Docs: Implement teams (in inglese). aggiungere squadre e assegnazione automatica
- Roblox Creator Docs: Studio testing modes (in inglese). test con più client Server & Clients
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.