Come fare un gioco su Roblox Studio, passo passo

Cosa costruirai

Il gioco è un breve percorso. I giocatori partono dallo SpawnLocation, saltano tra le piattaforme sopra un pavimento di lava, raccolgono monete e toccano un traguardo verde. Il traguardo dà una Win solo a un giocatore che ha raccolto almeno 3 monete dall'ultima volta che è apparso o ha raggiunto il traguardo, e poi lo riporta all'inizio. Coins e Wins compaiono nella lista dei giocatori, e tutte le regole girano sul server.

Workspace
  Baseplate Part
  SpawnLocation SpawnLocation
  Course Folder new
    Platform Part new
    Lava Folder new
      Lava Part new
    Coins Folder new
      Coin Part new
    Finish Part new
ServerScriptService
  PlayerStats Script new
  CourseService Script new

Tutto quello che sta in Workspace lo costruisci a mano nel passo 2. I due script vanno in ServerScriptService. Roblox non invia mai ai giocatori gli script di quel contenitore, quindi nessuno può leggerli o modificarli dal proprio dispositivo.

Passo 1: installa Studio e apri un Baseplate

1. Scarica Roblox Studio dal Creator Hub di Roblox ed esegui il programma di installazione (RobloxStudio.exe su Windows, RobloxStudio.dmg su Mac). Studio è un'app gratuita per Windows e Mac.
2. Quando si apre, accedi con il tuo account Roblox. Se non ne hai uno, crealo prima su roblox.com.
3. Nella sezione Open a Template, scegli Baseplate. Parte con solo due oggetti: uno SpawnLocation, dove i personaggi appaiono e riappaiono, e il Baseplate, un pavimento con una texture a griglia 4 per 4 allineata agli stud, l'unità di lunghezza di Roblox.
4. Apri tre finestre che userai di continuo. Explorer mostra ogni oggetto del tuo gioco, e Properties modifica l'oggetto che selezioni; entrambe si aprono dal menu Window o dalla scheda Home. Output mostra gli errori dei tuoi script, e si apre dal menu Window o dalla scheda Script.

Passo 2: costruisci il percorso

1. Nell'Explorer, passa il mouse su Workspace, clicca sul pulsante + (o premi Ctrl+I, Cmd+I su Mac) e inserisci un Folder. Chiamalo Course.
2. Passa il mouse su Course, clicca su + e inserisci altri due Folder al suo interno. Chiamali Lava e Coins.
3. Costruisci il pavimento di lava. Clicca su Part nella scheda Home o Model per inserire un blocco, e usa lo strumento Scale per allungarlo fino a una lastra grande e piatta che stia sotto tutto il percorso, con molto margine su ogni lato. In Properties, imposta il suo Color su rosso e il suo Material su Neon, spunta Anchored e trascinalo nella cartella Lava. Ora un giocatore che cade in qualsiasi punto finisce nella lava, non sul Baseplate.
4. Costruisci le piattaforme. Inserisci altre parti allo stesso modo e usa gli strumenti Move e Scale per metterle sopra la lava, ognuna qualche stud più in alto, con dei vuoti da saltare tra una e l'altra. In Properties, assicurati che Anchored sia spuntato su ognuna, e trascinale in Course.
5. Costruisci le monete. Tieni premuta la freccetta del pulsante Part e scegli Cylinder. Rendilo piccolo e giallo, spunta Anchored e togli la spunta da CanCollide così i giocatori lo attraversano invece di sbatterci contro. Mettilo nella cartella Coins, premi Ctrl+D (Cmd+D su Mac) per duplicarlo fino ad averne almeno 3, e distribuiscili sulle piattaforme lungo il percorso.
6. Costruisci il traguardo. Inserisci un'ultima parte sopra la lava alla fine, abbastanza grande per atterrarci sopra, colorala di verde, spunta Anchored, chiamala esattamente Finish e trascinala direttamente in Course, non in una delle cartelle.
7. Sposta lo SpawnLocation sopra la lava all'inizio del percorso, accanto alla tua prima piattaforma, così sta sopra la lastra. Lascialo direttamente in Workspace, non dentro Course: CourseService lo cerca lì per riportare i giocatori all'inizio.

I nomi contano

CourseService trova il percorso per nome: una cartella chiamata Course direttamente in Workspace, le cartelle Lava e Coins al suo interno, e una parte chiamata Finish al suo interno. Scrivili esattamente così, con le stesse maiuscole. I nomi delle parti di lava e delle monete non contano: ogni parte direttamente dentro Lava è lava, e ogni parte direttamente dentro Coins è una moneta.

Passo 3: aggiungi Coins e Wins alla lista dei giocatori

Nell'Explorer, passa il mouse su ServerScriptService, clicca su +, inserisci uno Script e chiamalo PlayerStats. Sostituisci tutto il suo contenuto con questo:

-- Script in ServerScriptService chiamato PlayerStats.
-- Dà a ogni giocatore una statistica Coins e una Wins. Una cartella chiamata leaderstats dentro il
-- giocatore fa sì che Roblox mostri questi valori nella lista dei giocatori, in alto a destra.

local Players = game:GetService("Players")

local function onPlayerAdded(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- deve essere scritto esattamente così

	local coins = Instance.new("IntValue")
	coins.Name = "Coins"
	coins.Value = 0
	coins.Parent = leaderstats

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

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do -- chi è entrato prima che venisse eseguita questa riga
	onPlayerAdded(player)
end

Ogni giocatore riceve un Folder chiamato leaderstats con dentro due oggetti IntValue. Un IntValue contiene un numero intero, che è tutto ciò che serve a un contatore di monete. Il ciclo alla fine prepara ogni giocatore entrato prima che venisse eseguita la riga di PlayerAdded, così nessuno resta fuori.

La guida alla leaderboard (in inglese) costruisce la stessa cartella più nel dettaglio, e poi aggiunge il salvataggio e una top 10 globale.

Passo 4: fai funzionare la lava, le monete e il traguardo

Inserisci un secondo Script in ServerScriptService, chiamalo CourseService e incolla questo. È l'unico posto dove cambiano Coins e Wins. Le due impostazioni in cima sono i numeri pensati per essere cambiati da te.

-- Script in ServerScriptService chiamato CourseService.
-- Gestisce il percorso sul server, così tutti vedono la stessa cosa e nessuno può
-- darsi monete da solo: le parti di lava fanno ripartire i giocatori, le monete pagano 1 Coin e tornano,
-- e il traguardo dà una Win ai giocatori che hanno raccolto abbastanza monete in questo giro.

local Players = game:GetService("Players")

local COINS_TO_FINISH = 3 -- monete che un giocatore deve raccogliere in un giro prima che il traguardo conti
local COIN_RESPAWN_SECONDS = 10

local course = workspace:WaitForChild("Course")
local lavaFolder = course:WaitForChild("Lava")
local coinFolder = course:WaitForChild("Coins")
local finish = course:WaitForChild("Finish") :: BasePart
local spawnLocation = workspace:FindFirstChildOfClass("SpawnLocation")
if not spawnLocation then
	warn("CourseService: no SpawnLocation directly in Workspace, so the Finish cannot send players back")
end

-- Monete raccolte in questo giro: da quando il giocatore è apparso l'ultima volta o ha raggiunto il traguardo
local runCoins: { [Player]: number } = {}

-- Trova il giocatore il cui personaggio ha toccato una parte, o nil per qualsiasi altra cosa
local function playerFromHit(otherPart: BasePart): Player?
	local character = otherPart:FindFirstAncestorOfClass("Model")
	return if character then Players:GetPlayerFromCharacter(character) else nil
end

local function addStat(player: Player, statName: string, amount: number)
	local leaderstats = player:FindFirstChild("leaderstats")
	local stat = leaderstats and leaderstats:FindFirstChild(statName)
	if stat and stat:IsA("IntValue") then
		stat.Value += amount
	end
end

-- Lava: qualsiasi parte della cartella Lava fa ripartire il giocatore che la tocca
for _, lava in lavaFolder:GetChildren() do
	if lava:IsA("BasePart") then
		lava.Touched:Connect(function(otherPart: BasePart)
			local character = otherPart:FindFirstAncestorOfClass("Model")
			local humanoid = character and character:FindFirstChildOfClass("Humanoid")
			if humanoid and humanoid.Health > 0 then
				humanoid.Health = 0
			end
		end)
	end
end

-- Monete: il primo giocatore che tocca una moneta la prende, poi si nasconde finché non riappare
for _, coin in coinFolder:GetChildren() do
	if coin:IsA("BasePart") then
		local shownTransparency = coin.Transparency
		local taken = false
		coin.Touched:Connect(function(otherPart: BasePart)
			local player = playerFromHit(otherPart)
			if not player or taken then
				return -- non è un giocatore, oppure questa moneta è già stata presa
			end
			taken = true
			coin.Transparency = 1
			addStat(player, "Coins", 1)
			runCoins[player] = (runCoins[player] or 0) + 1
			task.delay(COIN_RESPAWN_SECONDS, function()
				coin.Transparency = shownTransparency
				taken = false
			end)
		end)
	end
end

-- Traguardo: una Win per i giocatori che hanno fatto il percorso, e ritorno all'inizio
finish.Touched:Connect(function(otherPart: BasePart)
	local player = playerFromHit(otherPart)
	if not player or (runCoins[player] or 0) < COINS_TO_FINISH then
		return
	end
	runCoins[player] = 0 -- prima questo, così toccare di nuovo il traguardo non conta due volte
	addStat(player, "Wins", 1)
	local character = player.Character
	if character and spawnLocation then
		character:PivotTo(spawnLocation.CFrame + Vector3.new(0, 4, 0))
		player:SetAttribute("MovementCheckSkip", true) -- per uno script di controllo della velocità, se ne aggiungi uno
	end
end)

-- Un personaggio nuovo (dopo una ripartenza o una caduta) inizia un giro nuovo
local function onPlayerAdded(player: Player)
	runCoins[player] = 0
	player.CharacterAdded:Connect(function()
		runCoins[player] = 0
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do -- chi è entrato mentre questo script aspettava Course
	onPlayerAdded(player)
end

Players.PlayerRemoving:Connect(function(player: Player)
	runCoins[player] = nil
end)

La lava imposta Health a 0, come fa il tutorial sulla lava di Roblox. Un personaggio nuovo ha un ForceField per 10 secondi dopo essere apparso su uno SpawnLocation, per impostazione predefinita, e Humanoid:TakeDamage non fa nulla mentre un ForceField lo protegge. Impostare Health direttamente ignora i ForceField, quindi la lava funziona anche subito dopo la ricomparsa.

Il traguardo sposta il personaggio con character:PivotTo(...), che il riferimento di Roblox definisce il modo principale per spostare un modello da uno script. Cambiare la posizione della parte radice del personaggio, invece, stacca quella parte dal resto del corpo.

La riga MovementCheckSkip da sola non fa nulla. Serve per il controllo della velocità sul server della guida allo scatto (in inglese): se aggiungi quel controllo più avanti, il teletrasporto del traguardo non viene segnalato come eccesso di velocità.

Perché le regole girano sul server

Tutte le regole di questo percorso stanno in CourseService, uno Script server, ed è voluto. Se fosse un LocalScript ad aggiungere la moneta, il nuovo valore di Coins esisterebbe solo sul dispositivo di quel giocatore: il server e gli altri giocatori non lo vedrebbero mai. E tutto quello che c'è sul dispositivo di un giocatore si può modificare. La guida di Roblox sulla sicurezza dice che un exploiter ha il controllo totale sul suo stato locale e sul suo traffico di rete, quindi è il server a dover prendere tutte le decisioni che contano.

Quindi la regola delle monete ferma il trucco più semplice, saltare dritti alla fine, e poco altro. È normale in un primo gioco. I livelli successivi sono un controllo sul server che un personaggio sia davvero vicino a una moneta o al traguardo prima di pagare, come la guida di Roblox sulla sicurezza controlla la distanza di un giocatore da un negozio; checkpoint da raggiungere in ordine, come nella guida ai checkpoint per obby; e un controllo del movimento come quello della guida allo scatto. Cosa si replica e cosa no spiega più nel dettaglio la divisione tra client e server. Queste guide sono in inglese.

Passo 5: provalo

1. Assicurati che Test sia selezionato nel menu a tendina della modalità di test e premi Play (F5). Il tuo nome compare nella lista dei giocatori con Coins 0 e Wins 0.
2. Cammina verso una moneta. Coins passa a 1 e la moneta sparisce. Aspetta 10 secondi e torna. Toccala di nuovo: Coins sale a 2.
3. Tocca la lava. Il tuo personaggio cade e riappare sullo SpawnLocation dopo 5 secondi, il tempo di ricomparsa predefinito di Roblox. Coins nella lista dei giocatori non cambia, ma il tuo conteggio di questo giro torna a 0.
4. Tocca il traguardo con meno di 3 monete in questo giro: non succede nulla. Raccogli 3 monete e toccalo: Wins passa a 1 e torni allo SpawnLocation.
5. Premi Stop (Shift+F5). Scegli Server & Clients nel menu a tendina, imposta 2 client e premi Play (o F7). Raccogli una moneta in una finestra client e guarda l'altra: la moneta è sparita anche lì, perché il server l'ha nascosta per tutti.

Tieni la finestra Output sempre aperta. Questi due script non stampano nulla quando funzionano, quindi qualsiasi avviso o errore rosso da PlayerStats o CourseService è un problema vero. Guarda gli errori comuni.

Passo 6: pubblica il tuo gioco

1. Apri il menu File e scegli Publish. Si apre la finestra Game details.
2. Scrivi un Name, scegli un Genre (il Subgenre è facoltativo) e scrivi una breve Description di cosa fanno i giocatori. Qui puoi anche caricare un'icona e una miniatura. Controlla prima le loro dimensioni con il controllo delle dimensioni di miniature e icone gratuito.
3. Clicca su Save. Roblox pubblica il gioco nel cloud e lo collega al tuo account, così puoi aprirlo da qualsiasi computer.
4. Il gioco ora è pubblicato ma privato. Solo tu, le persone con accesso Edit e i membri del gruppo con i ruoli giusti possono giocarci.
5. Vuoi dei pareri prima di lanciarlo? Scegli File > Invite early testers e scegli fino a 10 amici di età simile. Se non hai ancora completato una verifica dell'età, Roblox ti chiede di farne una prima. I tester vedono una filigrana che dice loro che il gioco è un'anteprima.

Da qui in avanti, salvare su Roblox dal menu File conserva una versione del tuo gioco nel cloud. File > Publish è quello che cambia la versione che ricevono i giocatori. Ogni tanto gioca la copia pubblicata da Roblox, fuori da Studio, per controllare che corrisponda a quello che hai provato.

Passo 7: lancialo (rendi pubblico il tuo gioco)

Lanciare il gioco è il modo in cui lo rendi pubblico, così possono giocarci persone diverse da te e dai tuoi collaboratori. Prima di iniziare, controlla i requisiti: il tuo account deve essere in regola e avere almeno 2 giorni, e ti serve una verifica dell'età, fatta con la stima facciale dell'età o un documento d'identità ufficiale.

1. Apri il menu File e scegli di nuovo Publish. Si apre la finestra Publish.
2. Clicca su Continue. (Il pulsante Invite lì accanto invita invece dei tester.)
3. Rispondi alla prima domanda del Maturity & Compliance Questionnaire di Roblox: il tuo gioco contiene contenuti con limiti di età? Rispondi in base a quello che il tuo gioco contiene davvero. Se rispondi Yes, compili il questionario completo.
4. Clicca su Publish.

Per far entrare solo i tuoi amici, apri la Creator Dashboard, seleziona il gioco, vai su Publish settings > Manage Audience, clicca su Manage access, attiva Friends nella scheda Public e clicca su Save Changes. Con Friends attivo, possono giocare solo i tuoi amici e le persone nella scheda Playtest.

Gli stessi requisiti valgono per ogni azione di lancio: il primo lancio, lanciare una nuova versione di un gioco già uscito, lanciare su un altro gioco con Publish As e cambiare chi può giocare.

Fallo con gli amici

Gli strumenti di collaborazione di Studio permettono a te e a un amico di modificare lo stesso gioco contemporaneamente. Per un gioco tuo:

1. Con il gioco aperto in Studio, clicca su Collaborate sul lato destro della barra superiore (mezzanine), la barra che sul lato sinistro ha il pulsante Play.
2. Cerca il tuo amico, selezionalo, scegli Edit nel menu a tendina dei permessi e clicca su Save. In un gioco tuo, solo gli amici di Roblox possono avere accesso Edit.
3. Il tuo amico apre il gioco dalla Creator Dashboard, e lavorate tutti e due sullo stesso gioco contemporaneamente.

Per collaborare con altri creator, prima completi una verifica dell'età, con un documento o la stima facciale dell'età. Dopo, per impostazione predefinita, Studio ti fa collaborare solo con creator di fasce d'età compatibili. Puoi usare Team Create da solo senza verifica dell'età. Durante una sessione di collaborazione, Studio salva il gioco nel cloud ogni quattro minuti.

Trasformalo in un gioco vero

Il percorso è un ciclo completo: giocare, raccogliere, arrivare al traguardo, vincere. Ognuna di queste guide (in inglese, tranne la prima) aggiunge un sistema sopra.

• Nuovo con gli script? Programmare su Roblox per principianti copre variabili, funzioni, eventi e cicli, i pezzi con cui è fatto CourseService.
• Salva Coins e Wins tra una sessione e l'altra con il passo 3 della guida alla leaderboard. Il suo script di salvataggio sostituisce uno script di Coins e Wins come PlayerStats, quindi cancella PlayerStats quando lo aggiungi. Il tutorial sui DataStore spiega il salvataggio a fondo.
• Checkpoint in ordine, con una statistica Stage e ricomparsa all'ultimo checkpoint: la guida ai checkpoint per obby. Il suo script crea la sua cartella leaderstats, quindi copia le righe di Coins e Wins da PlayerStats in quella cartella e cancella PlayerStats. Due script che creano ognuno una leaderstats danno due cartelle a ogni giocatore, e Coins e Wins possono smettere di cambiare.
• Spendi le Coins in un negozio con GUI. Usa il valore Coins di leaderstats, quindi salta il suo script Leaderstats: PlayerStats crea già Coins.
• Vendi un vantaggio per Robux con un game pass. Prima di fissare un prezzo, il calcolatore della tassa sui Robux gratuito mostra quanto ti paga ogni vendita dopo la quota di Roblox, e il calcolatore DevEx quanto valgono quei Robux in dollari USA.
• Una schermata del titolo con un pulsante Play: la guida al menu principale.
• Round con intervallo, mappe casuali e timer: la guida al sistema di round, che aggiunge allo stesso valore Wins. Salta il suo script di leaderstats, perché PlayerStats crea già Wins.
• Una cutscene introduttiva con inquadrature, sottotitoli e un pulsante Skip: la guida alle cutscene.
• Una porta verso una zona segreta che si apre con E, con una serratura a chiave facoltativa: la guida alle porte.
• Piattaforme di teletrasporto tra zone della mappa, o un menu di teletrasporto: la guida ai teletrasporti.
• Scatto con Shift su tastiera, telefono e controller, con il controllo del movimento sul server: la guida allo scatto. Il suo controllo del movimento legge l'attributo MovementCheckSkip impostato dal traguardo.
• Un combattimento o un ciclo diverso: dai ai giocatori una spada o un'arma con raycast, oppure inizia un gioco nuovo in cui i giocatori cliccano per guadagnare monete, comprano potenziamenti e fanno rebirth, con la guida al gioco simulatore.

Errori comuni e soluzioni

Apri la finestra Output (menu Window o scheda Script) prima di premere Play. La maggior parte dei problemi di questo percorso stampa lì un avviso o un errore, oppure nasce da un nome che non coincide.

Con RoCode

Se preferisci descrivere il gioco invece di costruire ogni pezzo a mano, RoCode può costruirlo nel gioco che hai aperto. RoCode è un agente IA indipendente per Roblox Studio, non è fatto da Roblox: descrivi la funzione nella sua chat web e il suo plugin per Studio crea le parti e gli script nel tuo Explorer, così non copi codice da una finestra di chat.

Costruiscilo in Studio ↗

Con il plugin 3.9 o successivo RoCode può fare un breve test e leggere gli errori, e con il plugin 3.9.11 o successivo guidare un personaggio di prova per verificare che il gioco funzioni, ma controlla solo quello che ha deciso di testare, quindi a giocare sei tu. Costruire un gioco intero con RoCode funziona così, un sistema per prompt. Come si collega RoCode a Studio.

Domande frequenti

Fonti e letture

• Roblox Creator Docs: Roblox Studio setup (in inglese). Studio è un'app gratuita per Windows e Mac; installazione e accesso
• Roblox Creator Docs: Create and publish games and places (in inglese). modelli, File > Publish, privato di default, tester, lancio al pubblico, requisiti di lancio, il limite giornaliero e Manage Audience
• Roblox Creator Docs: Templates (in inglese). cosa contiene il modello Baseplate
• Roblox Creator Docs: Explorer window (in inglese). inserire oggetti, cartelle e duplicare
• Roblox Creator Docs: Parts (in inglese). inserire parti, cilindri, spostare, scalare e colore
• Roblox Creator Docs: Deadly lava tutorial (in inglese). una parte di lava che imposta Health a 0 al tocco
• Roblox Creator Docs: Create a coin collection mechanic (in inglese). monete con CanCollide disattivato e Anchored attivato
• Roblox Creator Docs: Score points tutorial (in inglese). la cartella leaderstats e il suo nome esatto
• Roblox Creator Docs: BasePart.CanTouch (in inglese). collegare Touched a una parte con CanTouch disattivato lancia un errore
• Roblox Creator Docs: Studio testing modes (in inglese). Test, Play (F5), Stop e Server & Clients
• Roblox Creator Docs: Humanoid:TakeDamage (in inglese). la protezione del ForceField, e impostare Health direttamente
• Roblox Creator Docs: PVInstance:PivotTo (in inglese). il modo di spostare un modello da uno script
• Roblox Creator Docs: Version History (in inglese). versioni salvate e le versioni pubblicate che ricevono i giocatori
• Roblox Creator Docs: Security tactics and cheat mitigation (in inglese). non fidarti mai del client; eventi Touched a qualsiasi distanza
• Roblox Creator Docs: Network ownership, movement validation, and physics (in inglese). un client può teletrasportare e far volare il proprio personaggio
• Roblox Creator Docs: Defensive design (in inglese). il caso dell'obby con teletrasporto alla fine
• Roblox Creator Docs: Collaboration (in inglese). il pulsante Collaborate, l'accesso Edit, la verifica dell'età e il salvataggio automatico

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, 26 ottobre 2026). Il controllo dei tipi trova API scritte male e tipi sbagliati, non la logica del gioco, quindi provalo in Studio prima di pubblicare.