Come programmare in Roblox Studio: guida per principianti

Prima di iniziare: Studio, un Baseplate e la finestra Output

Ti servono Roblox Studio e un account Roblox, e nient'altro: niente editor di codice né plugin. Tutti gli script di questa guida si scrivono nello Script Editor di Studio.

1. Installa Roblox Studio, l'app gratuita di Roblox per Windows e Mac, e accedi con il tuo account Roblox.
2. Apri Studio. La sua pagina iniziale mostra dei modelli: scegli Baseplate. Ottieni un pavimento con una texture a griglia 4x4 e uno SpawnLocation, il punto dove appare il tuo avatar quando giochi.
3. Se non vedi le finestre Explorer e Properties, aprile dal menu Window o dalla scheda Home. L'Explorer mostra ogni oggetto del tuo gioco; Properties mostra le impostazioni di quello che selezioni.
4. Apri Output dal menu Window o dalla scheda Script. Lì compaiono i messaggi e gli errori dei tuoi script.
5. Nelle opzioni di visualizzazione della finestra Output, attiva Show Context, che etichetta ogni messaggio come Client o Server, e Show Source, che mostra lo script e il numero di riga che l'ha prodotto.

Workspace
  Baseplate Part
  SpawnLocation SpawnLocation
  Part Part new
    ColourChanger Script new
  Pad Part new
    TouchPad Script new
ServerScriptService
  FirstScript Script new
StarterPlayer
  StarterPlayerScripts
    MyFirstLocalScript LocalScript new

Passo 1: scrivi il tuo primo script

1. Nell'Explorer, passa il mouse su ServerScriptService, clicca sul pulsante + e scegli Script (la scorciatoia è Ctrl+I, o ⌘I su Mac). Studio crea lo script e lo apre nello Script Editor.
2. Clicca col tasto destro sul nuovo script, scegli Rename e chiamalo FirstScript. Il nome non cambia quello che fa lo script, ma ti dice quale script ha stampato cosa.
3. Gli script nuovi partono con una riga, print("Hello world!"). Cancellala e incolla il codice qui sotto.
4. Premi Play (F5), con Test scelto nel menu a tendina alla sua sinistra. Studio avvia un test e mette il tuo avatar sullo SpawnLocation.
5. Leggi le righe dell'Output e premi Stop (Shift+F5). Stop riporta anche ogni oggetto com'era prima di premere Play, quindi tutto quello che hai spostato o ricolorato mentre giocavi torna indietro.

-- Script in ServerScriptService chiamato FirstScript.
-- Il tuo primo Luau: variabili, una funzione, un'istruzione if, un ciclo e una tabella.
-- Premi Play (F5) e leggi i risultati nella finestra Output.

-- Una variabile è un nome che contiene un valore
local gameName = "Coin Run"
local coinsToWin = 3

-- Una funzione è un blocco di codice con un nome che puoi eseguire tutte le volte che vuoi.
-- name e goal sono i suoi parametri; return restituisce un valore a chi l'ha chiamata.
local function describe(name: string, goal: number): string
	return `{name}: collect {goal} coins to win`
end

print(describe(gameName, coinsToWin)) --> Coin Run: collect 3 coins to win

-- Un'istruzione if esegue codice solo quando la sua condizione è vera
if coinsToWin > 5 then
	print("That is a long game")
elseif coinsToWin > 1 then
	print("That is a short game")
else
	print("One coin and you win")
end

-- Un ciclo for ripete il codice un numero fisso di volte
for count = 1, coinsToWin do
	print("Coin number", count)
end

-- Una tabella contiene una lista di valori; questo ciclo li visita uno per uno in ordine
local colours = { "Red", "Green", "Blue" }
for position, colour in colours do
	print(position, colour) --> 1 Red, poi 2 Green, poi 3 Blue
end

L'Output dovrebbe mostrare queste otto righe, mescolate ai messaggi di Studio. Quando print riceve più di un valore, mette uno spazio tra loro. Con Show Context e Show Source attivi, ogni riga ha in più l'etichetta Server e FirstScript con un numero di riga.

Coin Run: collect 3 coins to win
That is a short game
Coin number 1
Coin number 2
Coin number 3
1 Red
2 Green
3 Blue

Collega ogni riga al codice che l'ha stampata. Più avanti farai lo stesso con i messaggi di errore, quindi conviene abituarsi da subito.

FirstScript usa solo Luau puro, senza oggetti di Roblox, quindi funziona anche nel Luau playground gratuito nel tuo browser. Cambia un valore lì e rieseguilo per vedere cosa cambia.

Ogni blocco che inizia con function, if, for o while si chiude con end. Basta un solo end mancante per impedire che tutto lo script venga eseguito; leggere gli errori mostra il messaggio che ricevi.

Passo 2: cambia una parte da uno script

Gli script diventano utili quando cambiano le cose nel mondo. Le impostazioni che vedi nella finestra Properties, come Color, Transparency o Anchored di una parte, sono proprietà, e anche uno script può cambiarle.

1. Nella scheda Home, clicca su Part. Studio aggiunge un blocco al Workspace. Il suo nome non importa.
2. Nell'Explorer, passa il mouse sulla nuova parte, clicca su + e inserisci uno Script. Chiamalo ColourChanger e sostituisci il suo contenuto con il codice qui sotto.
3. Premi Play. La parte diventa rossa, poi blu, poi verde, cambiando una volta al secondo, e ricomincia.

-- Script dentro una Part in Workspace, chiamato ColourChanger.
-- Gli script cambiano le stesse proprietà che vedi nella finestra Properties.
-- Questo dà alla sua parte un colore nuovo ogni secondo, per tutti i giocatori.

local part = script.Parent :: BasePart -- la parte dentro cui si trova questo script

local colours = {
	Color3.fromRGB(255, 85, 85), -- rosso
	Color3.fromRGB(85, 170, 255), -- blu
	Color3.fromRGB(85, 255, 127), -- verde
}

part.Anchored = true -- una parte ancorata resta dove la metti

local index = 1
while true do
	part.Color = colours[index]
	index = index % #colours + 1 -- 1, 2, 3 e di nuovo 1
	task.wait(1) -- pausa di un secondo (il vecchio wait() è deprecato)
end

• script.Parent è l'oggetto dentro cui si trova lo script, qui la parte. Trascina lo script in un'altra parte e cambierà quella al suo posto.
• :: BasePart è una conversione di tipo (type cast). Dice allo Script Editor che il parent è una parte, così può controllare le proprietà che usi su di essa. Luau usa i tipi solo per avvisi e suggerimenti, quindi la conversione non cambia quello che fa la riga.
• part.Color e part.Anchored sono le stesse proprietà che vedi nella finestra Properties, con gli stessi nomi. Roblox usa l'ortografia americana, quindi la proprietà è Color anche se questo script si chiama ColourChanger.
• Anchored = true tiene ferma la parte: il riferimento di Roblox dice che una parte ancorata non si muove mai per gravità, collisioni o qualsiasi altra fisica.
• colours[index] legge un elemento della lista. #colours è la lunghezza della lista, 3, e % dà il resto della divisione, quindi index % #colours + 1 conta 1, 2, 3, 1, 2, 3.
• while true do si ripete per sempre, ed è per questo che conta il task.wait(1) al suo interno. La documentazione di Roblox dice di mettere sempre una pausa come task.wait() in un ciclo infinito: senza, il gioco si blocca e Studio si pianta.

ColourChanger è uno Script, quindi gira sul server, e tutti i giocatori nel gioco vedono lo stesso colore nello stesso momento. Il passo 4 mostra l'altro tipo di script.

Passo 3: reagisci a un giocatore con un evento

La maggior parte del codice di un gioco aspetta che succeda qualcosa: un giocatore entra, una parte viene toccata, si clicca un pulsante. Roblox li chiama eventi. Per eseguire codice quando uno scatta, gli colleghi una funzione.

1. Inserisci un'altra Part e chiamala esattamente Pad, con la P maiuscola. Lasciala direttamente nel Workspace, non dentro una cartella o un modello, perché il LocalScript del passo 4 la cerca lì.
2. Trasformala in una piattaforma piatta su cui puoi salire, per esempio impostando la sua Size a 6, 1, 6 nella finestra Properties. Spostala sul pavimento vicino allo SpawnLocation e spunta Anchored così non si muove.
3. Passa il mouse su Pad, clicca su +, inserisci uno Script, chiamalo TouchPad e incolla il codice qui sotto.
4. Premi Play e sali sulla piattaforma. Diventa gialla per 2 secondi, e l'Output dice il tuo nome.

-- Script dentro una Part in Workspace chiamata Pad, script chiamato TouchPad.
-- Eventi: quando un giocatore sale sulla piattaforma, si illumina di giallo e l'Output dice chi è stato.
-- Un debounce evita che venga eseguito molte volte al secondo mentre ci sta sopra.

local Players = game:GetService("Players")

local pad = script.Parent :: BasePart
local COOLDOWN_SECONDS = 2

local normalColour = pad.Color
local busy = false

local function onTouched(otherPart: BasePart)
	if busy then
		return -- ancora in attesa dall'ultimo tocco
	end
	-- Il personaggio è il Model che contiene la parte del corpo (o il cappello) che ha toccato
	local character = otherPart:FindFirstAncestorOfClass("Model")
	local player = character and Players:GetPlayerFromCharacter(character)
	if not player then
		return -- l'ha toccata una parte sciolta o un NPC, non un giocatore
	end

	busy = true
	print(`{player.Name} stepped on the pad`)
	pad.Color = Color3.fromRGB(255, 220, 0)
	task.wait(COOLDOWN_SECONDS)
	pad.Color = normalColour
	busy = false
end

pad.Touched:Connect(onTouched)

Perché la piattaforma ha bisogno di un debounce

La pagina sul debounce di Roblox avverte che Touched scatta più volte di fila quando le parti entrano in contatto, e un personaggio che cammina ha diverse parti del corpo. Senza un controllo, un solo passo sulla piattaforma potrebbe stampare molte righe e far ripartire il bagliore giallo più e più volte.

La variabile busy è il debounce. Il primo tocco la imposta a true, e ogni tocco nei 2 secondi successivi arriva a if busy then return end e si ferma. Dopo task.wait(COOLDOWN_SECONDS) la piattaforma torna al suo colore e busy torna a false. COOLDOWN_SECONDS è in maiuscolo perché è un'impostazione che non cambia mentre il gioco gira, la convenzione che Roblox suggerisce per le costanti.

Questa piattaforma ha un solo debounce per tutti, quindi un secondo giocatore che ci sale in quei 2 secondi viene ignorato. Per una piattaforma che si illumina va bene. Una piattaforma che dà ricompense dovrebbe avere un'attesa per ogni giocatore, come fa la piattaforma delle monete della guida alla leaderboard (in inglese).

Passo 4: il tuo primo LocalScript, e perché è diverso

Un gioco in esecuzione è un server più un client per ogni giocatore. Tutto quello che hai visto finora era uno Script, che gira sul server, quindi le sue modifiche arrivano a tutti i giocatori. Un LocalScript, invece, gira sul dispositivo di un solo giocatore. Pressioni dei tasti, telecamera e menu sullo schermo si gestiscono lì, perché solo quel dispositivo li conosce.

1. Nell'Explorer, espandi StarterPlayer, passa il mouse su StarterPlayerScripts, clicca su + e inserisci un LocalScript. Chiamalo MyFirstLocalScript e incolla il codice qui sotto.
2. Premi Play. L'Output mostra Hello, e il tuo nome, con l'etichetta Client.
3. Clicca nella vista del gioco e premi E. La piattaforma sfuma. Premi di nuovo E per riaverla.
4. Con il test ancora in corso, clicca sull'interruttore Client/Server nei controlli di test di Studio per passare alla copia del gioco del server. Lì la piattaforma è solida: il server non ha mai saputo della modifica.

-- LocalScript in StarterPlayer > StarterPlayerScripts chiamato MyFirstLocalScript.
-- Un LocalScript gira sul dispositivo di un giocatore. Premi E: la Pad sfuma solo sul tuo
-- schermo, perché una modifica a una parte fatta qui non arriva al server né a nessun altro.

local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")

local player = Players.LocalPlayer
print(`Hello, {player.Name}`) -- compare nell'Output, segnato come Client

UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessed: boolean)
	if gameProcessed then
		return -- il tasto è stato usato per altro, come scrivere in chat
	end
	if input.KeyCode == Enum.KeyCode.E then
		local pad = workspace:FindFirstChild("Pad")
		if pad and pad:IsA("BasePart") then
			pad.Transparency = if pad.Transparency == 0 then 0.6 else 0
		end
	end
end)

• Players.LocalPlayer è il giocatore il cui dispositivo esegue lo script. Roblox lo imposta solo per i LocalScript e i ModuleScript che questi richiedono, quindi il codice del server non può usarlo.
• UserInputService.InputBegan scatta quando il giocatore inizia a premere un tasto, a cliccare o a toccare lo schermo. gameProcessed è true quando il motore ha già usato quell'input, per esempio un clic su un pulsante o un tasto scritto nella barra della chat, quindi lo script lo ignora.
• workspace:FindFirstChild("Pad") restituisce il figlio chiamato Pad, oppure nil se non ce n'è nessuno. pad:IsA("BasePart") controlla che sia davvero una parte prima che lo script cambi la sua Transparency.
• if pad.Transparency == 0 then 0.6 else 0 è un'espressione if: sceglie uno tra due valori. Una Transparency di 0 è del tutto visibile e 1 è invisibile.
• Uno script per lo scatto con Shift (in inglese) è un buon secondo LocalScript: ascolta un tasto e cambia la WalkSpeed del tuo personaggio.

Cosa può cambiare un imbroglione

Dai per scontato che un imbroglione controlli tutto sul suo dispositivo. Può eseguire i suoi LocalScript e modificare i tuoi, quindi può far sfumare la piattaforma, o qualsiasi altra cosa, sul suo schermo. Qui è innocuo: la sfumatura è solo visiva e resta sul suo dispositivo. È anche il motivo per cui tutto ciò che conta lo decide uno Script sul server.

Nemmeno uno Script sul server è sicuro in automatico. TouchPad gira sul server, ma il dispositivo di ogni giocatore controlla la fisica del suo personaggio, e la documentazione di Roblox sulla sicurezza include il manipolare quando scatta Touched, o impedire che scatti, tra le cose che un client può fare con le parti che controlla. Per una piattaforma che si illumina non importa. Per una che paga, controlla anche qualcosa che il server gestisce da solo, come la regola della guida all'obby (in inglese) secondo cui i checkpoint contano solo in ordine.

Passo 5: prova i quattro script insieme

1. Pulisci l'Output con Ctrl+K (⌘K su Mac) e premi Play (F5). L'Output mostra le otto righe di FirstScript con l'etichetta Server, e la tua riga Hello con l'etichetta Client. La parte di ColourChanger cambia colore ogni secondo.
2. Sali sulla piattaforma. Diventa gialla per 2 secondi e l'Output mostra il tuo nome e "stepped on the pad" una volta. Continua a camminarci sopra: compare una nuova riga al massimo una volta ogni 2 secondi, non ogni volta che scatta Touched.
3. Premi E. La piattaforma sfuma fino a una Transparency di 0.6. Premi di nuovo E ed è solida.
4. Premi Stop. Nel menu a tendina dei test scegli Server & Clients, imposta 2 client e premi Play (o F7). Studio apre una finestra server e due finestre client. In un client premi E: lì la piattaforma sfuma, mentre l'altro client e il server continuano a vederla solida. Premi End Session quando hai finito.
5. Rompi qualcosa apposta. Cambia il nome di Pad in Pad2 e gioca. Salirci sopra la fa ancora diventare gialla, perché TouchPad trova la sua parte con script.Parent, non per nome. Premere E adesso non fa niente, e non c'è nessun errore: FindFirstChild("Pad") ha restituito nil, e il controllo if pad and ... ha saltato il resto senza dire nulla. Aggiungi print(pad) nella riga dopo FindFirstChild, gioca e premi E: l'Output mostra nil. Un print così è il modo più veloce per capire perché uno script non fa nulla. Premi Stop, cancella la riga del print e richiama la parte Pad.

Dove vanno gli script

Dove si trova uno script decide se verrà eseguito, e Studio non ti avvisa quando non succederà mai. Per gli script che scriverai dopo:

La pagina di Roblox sulle posizioni degli script consiglia di non mettere script direttamente dentro le parti in Workspace: etichetta le parti e gestiscile da un unico ModuleScript usando CollectionService. Uno script dentro una parte resta comunque il modo più facile per iniziare, e va bene per uno o due oggetti mentre impari. La guida alle porte mostra lo schema con le etichette, con un solo script per tutte le porte, e la guida a client e server (entrambe in inglese) ha la tabella completa di quali contenitori eseguono quali script.

Quando qualcosa va storto: leggi l'Output

Gli errori compaiono in rosso nell'Output. Ognuno inizia con dove è successo, il nome completo dello script e il numero di riga, e poi dice cosa è andato storto. Clicca sull'errore e Studio apre quello script a quella riga. Per esempio, se cancellassi il controllo if not player da TouchPad e una parte sciolta cadesse sulla piattaforma, l'Output mostrerebbe:

Workspace.Pad.TouchPad:22: attempt to index nil with 'Name'

Gli errori nel modo in cui è scritto il codice, come un end mancante, compaiono prima di premere Play: lo Script Editor li sottolinea in rosso, e la finestra Script Analysis (il pulsante Analysis nella scheda Script) li elenca. Uno script con uno di questi errori non viene eseguito per niente, nemmeno le righe che vengono prima.

Quando uno script non fa nulla e nemmeno l'Output mostra nulla, di solito si trova in un posto dove non viene mai eseguito, oppure aspetta un evento che non scatta mai. La guida agli errori degli script (in inglese) ha una lista per gli script silenziosi e approfondisce come leggere l'Output.

Cosa fanno di diverso i vecchi tutorial di scripting

Se impari anche con video e post nei forum, troverai schemi vecchi. Questi sono quelli che contano, con il motivo per cui ognuno è un problema.

Pratica: tre modifiche da provare

Cambiare il codice insegna più che leggerlo. Prova queste nel tuo gioco, una alla volta, e premi Play dopo ognuna.

• Fai dare un punto alla piattaforma. Aggiungi lo script Leaderstats del passo 1 della guida alla leaderboard (in inglese). Poi in TouchPad, dopo busy = true, cerca la cartella leaderstats del giocatore e aggiungi 1 al suo valore Coins. Suggerimento: player:FindFirstChild("leaderstats"), poi leaderstats:FindFirstChild("Coins"), poi coins.Value += 1. La piattaforma delle monete della guida alla leaderboard ne è una versione finita, con un'attesa per ogni giocatore.
• Fai sfumare anche il cambia colore. Fai in modo che ColourChanger cambi anche la Transparency della parte ogni secondo. Suggerimento: aggiungi una seconda tabella di numeri tra 0 e 1, come { 0, 0.3, 0.6 }, e imposta part.Transparency da questa nella riga dopo part.Color, usando lo stesso index.
• Stampa il colore della piattaforma. Fai in modo che MyFirstLocalScript stampi il Color della piattaforma quando premi E. Suggerimento: print(pad.Color) dentro il blocco if pad and pad:IsA("BasePart"). Premi E mentre la piattaforma è gialla: il client vede il colore impostato dal server, perché le modifiche fatte sul server arrivano a tutti i client.

Cosa imparare dopo

Hai già usato i pezzi con cui si costruisce la maggior parte degli script dei giochi. Un buon ordine per quello che viene dopo:

1. LocalScript vs Script vs ModuleScript: dove gira ogni tipo di script e cosa può cambiare, più nel dettaglio del passo 4.
2. RemoteEvents: come un LocalScript chiede al server di fare qualcosa, e come il server controlla la richiesta.
3. Una classifica: le tue prime statistiche, create e modificate sul server.
4. Il tuo primo gioco: un breve percorso con lava, monete e un traguardo, gestito da due script server, e poi pubblicato.
5. Poi scegli un sistema da aggiungere: un negozio con GUI, un sistema di round, dei checkpoint per obby, una schermata di caricamento o un'animazione alla pressione di un tasto. Quando qualcosa si rompe, la guida agli errori degli script ti aiuta a leggere il messaggio. Queste guide sono in inglese.

I tutorial Coding fundamentals di Roblox (in inglese) sono un buon complemento: sei serie che vanno da variabili e funzioni a condizioni, cicli, array e dizionari, fino a organizzare il codice con i ModuleScript, con piccoli progetti da costruire in Studio.

Errori comuni e soluzioni

La maggior parte dei problemi con un primo script è un nome che non coincide, uno script nel posto sbagliato o un ciclo senza attesa. Tieni aperto l'Output mentre provi.

Sbloccarti con RoCode

Se ti blocchi con uno script nel tuo gioco, RoCode può leggerlo con te. RoCode è un agente IA indipendente per Roblox Studio, non è fatto da Roblox: scrivi in una chat web e il suo plugin per Studio crea e modifica gli script nel tuo Explorer.

Mentre impari, la modalità utile è Ask: gli script continui a scriverli tu, e RoCode legge quello che c'è già e risponde alle tue domande.

In modalità Build 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 non fa screenshot mentre il gioco gira, quindi sulla piattaforma continui a salire tu. Come si collega RoCode a Studio.

Domande frequenti

Fonti e letture

• Roblox Creator Docs: Luau (in inglese). cos'è Luau e da dove viene
• Roblox Creator Docs: Roblox Studio setup (in inglese). Windows e Mac, e i requisiti di sistema
• Roblox Creator Docs: Output (in inglese). aprire l'Output, filtri, Show Context e Show Source
• Roblox Creator Docs: Studio testing modes (in inglese). Play, Run, Stop, l'interruttore Client/Server e Server & Clients
• Roblox Creator Docs: Script Editor (in inglese). dove si aprono gli script nuovi, e Script Analysis
• Roblox Creator Docs: Script types and locations (in inglese). dove gira ogni tipo di script, ed etichettare le parti invece di metterci dentro gli script
• Roblox Creator Docs: Script (in inglese). quando inizia a girare uno Script
• Roblox Creator Docs: Control structures (in inglese). istruzioni if, cicli, e perché un ciclo infinito ha bisogno di un'attesa
• Roblox Creator Docs: Events (in inglese). Connect, e cosa passa Touched alla tua funzione
• Roblox Creator Docs: Debounce patterns (in inglese). perché Touched scatta più volte per un solo contatto
• Roblox Creator Docs: wait (in inglese). il wait() globale e task.wait()
• Roblox Creator Docs: Network ownership, movement validation and physics exploits (in inglese). cosa può fare un client con il proprio personaggio
• Roblox Creator Docs: Coding fundamentals (in inglese). la serie per principianti di Roblox

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.