Tutorial · Sistemi di gioco

Come fare un menu principale in Roblox Studio

Il menu principale in Roblox Studio, chiamato anche menu iniziale o schermata del titolo, è uno ScreenGui con un pulsante Play. Ma la sensazione di un gioco finito la danno altre cose: il giocatore non deve spawnare finché non preme Play, la telecamera deve mostrare la mappa e poi tornare sul personaggio, e il menu non deve mai ricomparire dopo la morte. In questa guida mettiamo insieme tutto questo in due script che funzionano con il mouse, sul touchscreen e con il gamepad.

Aggiornato il 20 novembre 202620 min di letturaScritto da

In breve

Disattiva CharacterAutoLoads nel servizio Players, così nessuno spawna all'ingresso. Un LocalScript in StarterPlayerScripts costruisce il menu (titolo, pulsante Play e un frame nero per le dissolvenze) in uno ScreenGui con ResetOnSpawn disattivato, punta la telecamera su una parte chiamata MenuCamera con CameraType Scriptable e, quando si preme Play, invia un RemoteEvent. Uno Script in ServerScriptService risponde chiamando Player:LoadCharacterAsync(), e il LocalScript restituisce la telecamera (CameraType Custom, CameraSubject è l'Humanoid) e toglie il menu.

  • Usa Activated, non MouseButton1Click, così Play funziona con clic, tocco e gamepad, e seleziona il pulsante per i giocatori con il gamepad, così possono premerlo.
  • Con CharacterAutoLoads disattivato, StarterGui viene copiato nel PlayerGui del giocatore solo quando spawna il suo personaggio, quindi il menu lo costruisce un LocalScript in StarterPlayerScripts.
  • Con CharacterAutoLoads disattivato Roblox smette anche di far rinascere i giocatori, quindi lo script server li fa rinascere da solo dopo la morte o una caduta dalla mappa, dopo aver aspettato Players.RespawnTime (di default 5 secondi).
In questa pagina
  1. Come funziona
  2. 1. Preparazione
  3. 2. Script server
  4. 3. Script del menu
  5. Cosa decide il server
  6. 4. Design
  7. 5. Verifica
  8. Con altri sistemi
  9. Perché i menu altrui si rompono
  10. Common errors
  11. Con RoCode
  12. Domande frequenti
  13. Fonti e letture

Come funziona il menu principale

IllustrazioneIl menu finito nel gioco avviato, con l'attesa del server accelerata: Play oscura lo schermo, il server fa spawnare il personaggio e la telecamera torna su di lui.

Il menu ha due lati. Il dispositivo del giocatore disegna il titolo e il pulsante e muove la telecamera. Il server decide quando compare il personaggio. Il menu in sé è solo un'immagine su uno schermo: il vero cambiamento avviene quando il server fa spawnare il personaggio, e solo il server può farlo.

Da cosa è fatto il menu
ParteDove staCosa fa
Script MenuServiceServerScriptServiceDisattiva lo spawn automatico, crea PlayRequest, fa spawnare il giocatore che ha premuto Play e fa rinascere i giocatori dopo la morte o una caduta.
LocalScript MainMenuStarterPlayerScriptsCostruisce il titolo, il pulsante Play e la dissolvenza, gestisce l'inquadratura della telecamera, chiede al server il personaggio e restituisce la telecamera.
RemoteEvent PlayRequestReplicatedStorage (lo crea MenuService, non aggiungerlo a mano)Porta al server un solo messaggio: questo giocatore ha premuto Play. Non contiene nessun valore.
Part MenuCameraWorkspace (la metti tu)Dove sta la telecamera del menu e dove guarda.
CharacterAutoLoadsProprietà del servizio PlayersDisattivata, così nessuno spawna finché il server non chiama LoadCharacterAsync.
L'Explorer quando il menu è pronto. PlayRequest compare all'avvio del gioco: lo crea MenuService, quindi non aggiungerlo a mano.
Workspace
  MenuCamera Part new
ReplicatedStorage
  PlayRequest RemoteEvent new
ServerScriptService
  MenuService Script new
StarterPlayer
  StarterPlayerScripts
    MainMenu LocalScript new

Passo 1: disattiva lo spawn automatico e posiziona la telecamera del menu

  1. Nell'Explorer seleziona Players. Nella finestra Properties togli la spunta a CharacterAutoLoads. Anche MenuService la disattiva, ma la spunta garantisce che nessuno spawni nell'istante prima che lo script parta.
  2. Passa il mouse su Workspace, clicca sul pulsante + e inserisci una Part. Rinominala MenuCamera (maiuscole e minuscole nei nomi contano) e tienila direttamente in Workspace, non dentro una cartella o un modello.
  3. Nelle sue Properties spunta Anchored, togli la spunta a CanCollide e imposta Transparency a 1. L'ancoraggio è importante: una parte non ancorata che non collide con niente cade attraverso la mappa, e Roblox elimina le parti cadute sotto Workspace.FallenPartsDestroyHeight.
  4. Sposta e ruota la parte in modo che la sua faccia frontale guardi verso la vista che vuoi. La telecamera prende la posizione della parte e guarda nella stessa direzione della sua faccia frontale.

Il modo più veloce per puntarla: porta la telecamera di Studio sull'inquadratura che vuoi, apri la Command Bar (nella scheda Script o da Window, poi Script) ed esegui workspace.MenuCamera.CFrame = workspace.CurrentCamera.CFrame. In modalità di modifica CurrentCamera è la vista attraverso cui stai guardando, quindi la parte salta esattamente su quell'inquadratura.

Lascia Workspace.StreamingEnabled com'è. Nei place nuovi lo streaming delle istanze è attivo, e gli script qui sotto sono scritti tenendone conto.

Passo 2: facciamo spawnare i giocatori quando premono Play

Passa il mouse su ServerScriptService, inserisci uno Script, chiamalo MenuService e incolla questo codice:

Script in ServerScriptService chiamato MenuService
-- Script in ServerScriptService chiamato MenuService.
-- I giocatori entrano senza personaggio. Il server lo crea quando lo chiede il pulsante Play del menu,
-- e fa rinascere i giocatori dopo la morte, perché lo spawn automatico è disattivato.

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

-- Togli anche la spunta a CharacterAutoLoads nel servizio Players nella finestra Properties,
-- così nessuno spawna nell'istante prima che questo script parta.
Players.CharacterAutoLoads = false

-- Questo script crea da solo PlayRequest, quindi non aggiungerlo a mano in ReplicatedStorage
local playRequest = Instance.new("RemoteEvent")
playRequest.Name = "PlayRequest"
playRequest.Parent = ReplicatedStorage

local spawning: { [Player]: boolean } = {}

local function spawnCharacter(player: Player)
	if spawning[player] then
		return -- secondo clic su Play mentre il primo spawn sta ancora caricando
	end
	spawning[player] = true
	local oldCharacter = player.Character
	local ok, err = pcall(function()
		player:LoadCharacterAsync()
	end)
	spawning[player] = nil
	if not ok then
		warn(`MenuService: could not spawn {player.Name}: {err}`)
		-- Un respawn fallito lascerebbe bloccato un giocatore morto, quindi riproviamo dopo una breve pausa.
		-- Un primo spawn fallito non va ripetuto: il pulsante del menu scrive Try again.
		if oldCharacter then
			task.delay(Players.RespawnTime, function()
				local current = player.Character
				if player.Parent == Players and (current == oldCharacter or current == nil) then
					spawnCharacter(player)
				end
			end)
		end
	elseif oldCharacter and oldCharacter ~= player.Character then
		oldCharacter:Destroy() -- libera le connessioni del vecchio personaggio
	end
end

-- Può chiedere lo spawn solo un giocatore che è ancora nel menu (non ha ancora un personaggio). Un giocatore
-- morto ha ancora il personaggio, quindi così non si può saltare l'attesa del respawn.
playRequest.OnServerEvent:Connect(function(player: Player)
	if player.Character == nil then
		spawnCharacter(player)
	end
end)

-- Con CharacterAutoLoads disattivato nessuno fa rinascere i giocatori dopo la morte, quindi lo facciamo qui
local function onCharacterAdded(player: Player, character: Model)
	local respawning = false
	local function respawnLater()
		if respawning then
			return
		end
		respawning = true
		task.wait(Players.RespawnTime)
		-- Facciamo rinascere solo se il giocatore è ancora qui e nessuno lo ha fatto spawnare nel frattempo
		local current = player.Character
		if player.Parent == Players and (current == character or current == nil) then
			spawnCharacter(player)
		end
	end
	local humanoid = character:WaitForChild("Humanoid") :: Humanoid
	humanoid.Died:Connect(respawnLater)
	-- Una caduta dalla mappa può togliere il personaggio da Workspace, e Died scatta solo
	-- mentre l'Humanoid è in Workspace, quindi qui intercettiamo anche questo caso
	character.AncestryChanged:Connect(function()
		if not character:IsDescendantOf(workspace) then
			respawnLater()
		end
	end)
end

local function onPlayerAdded(player: Player)
	player.CharacterAdded:Connect(function(character: Model)
		onCharacterAdded(player, character)
	end)

	-- Con lo streaming la mappa si carica intorno al personaggio del giocatore, ma il giocatore nel
	-- menu non ce l'ha ancora. Aggiungiamo un focus di replica sulla telecamera del menu finché non spawna.
	local menuCamera = workspace:FindFirstChild("MenuCamera")
	if menuCamera and menuCamera:IsA("BasePart") then
		player:AddReplicationFocus(menuCamera)
		player.CharacterAdded:Once(function()
			player:RemoveReplicationFocus(menuCamera) -- da questo momento il focus è il personaggio
		end)
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do
	onPlayerAdded(player)
end

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

PlayRequest non passa nessun valore. Roblox passa il giocatore che ha inviato l'evento come primo argomento di OnServerEvent, ed è tutto quello che il server deve sapere.

Chi può spawnare

Il gestore di PlayRequest fa spawnare il giocatore solo se player.Character è nil, e questo succede a un giocatore che è ancora nel menu. Un giocatore morto mantiene il suo personaggio finché MenuService non lo fa rinascere, quindi tramite il remote non si può saltare l'attesa.

La tabella spawning impedisce a una seconda richiesta di avviare un secondo spawn mentre il primo sta ancora caricando. LoadCharacterAsync aspetta che il personaggio sia caricato, e il riferimento di Roblox sconsiglia di chiamarlo di nuovo per lo stesso giocatore finché non è scattato il suo evento CharacterAppearanceLoaded. Ogni chiamata è dentro un pcall, quindi uno spawn fallito, per esempio quando il giocatore esce durante il caricamento, stampa un avviso con il nome del giocatore invece di un errore. Se fallisce un respawn, MenuService aspetta RespawnTime e riprova, così un respawn fallito non lascia bloccato un giocatore morto. Un primo spawn fallito il server non lo ripete: il pulsante del menu scrive Try again, e il giocatore può premerlo.

Respawn dopo la morte o una caduta

Con CharacterAutoLoads disattivato Roblox non fa rinascere nessuno. Players.RespawnTime (di default 5 secondi) funziona da solo solo con CharacterAutoLoads attivo, quindi MenuService legge quel valore, aspetta da sé e chiama di nuovo LoadCharacterAsync. Il nuovo personaggio compare sullo SpawnLocation come al solito, e lo script distrugge quello vecchio, cosa che scollega anche le connessioni di quel personaggio.

Per la caduta dalla mappa serve un secondo controllo. Roblox elimina le parti cadute sotto Workspace.FallenPartsDestroyHeight ed elimina un modello quando sparisce la sua ultima parte, quindi un personaggio caduto può lasciare Workspace, e Humanoid.Died scatta solo mentre l'Humanoid è in Workspace. Per questo MenuService fa rinascere anche un personaggio che ha lasciato Workspace (AncestryChanged), e il flag respawning fa in modo che ogni personaggio avvii al massimo un respawn. Dopo l'attesa lo script fa rinascere il giocatore solo se è ancora in gioco e player.Character è ancora quel personaggio o nil, quindi un giocatore che nel frattempo è stato fatto spawnare in un altro modo non spawna due volte.

Streaming e telecamera del menu

Con lo streaming delle istanze ogni client riceve le parti intorno al suo focus di replica, che di default è la PrimaryPart del suo personaggio. Un giocatore nel menu non ha un personaggio, e la pagina di Roblox sulle tecniche di streaming avverte che un client senza personaggio spawnato non ha un focus di replica, quindi la mappa potrebbe non caricarsi affatto. La soluzione di quella pagina è Player:AddReplicationFocus(), che MenuService chiama con la parte MenuCamera quando il giocatore entra (Roblox dice di chiamarlo solo sul server). Quando il personaggio spawna per la prima volta, MenuService chiama RemoveReplicationFocus, e l'unico focus torna a essere il personaggio: ogni focus in più aggiunge lavoro di streaming al server. Nel passo 5 c'è un playtest con lo streaming attivo per verificare che la mappa si veda dietro il menu.

Cosa decide il server e cosa può fare un cheater

Un cheater può eseguire il proprio codice sul proprio dispositivo. Può inviare PlayRequest quando vuole, con qualsiasi valore, e cambiare qualsiasi cosa sul proprio schermo. Ecco cosa ci guadagna.

Cosa può provare un cheater con il menu
Il cheaterCosa succede
Invia PlayRequest senza premere PlaySpawna, esattamente come se avesse premuto Play. Saltare il menu non dà nulla.
Invia PlayRequest centinaia di volteUn solo spawn. Mentre carica, il flag spawning ignora le altre richieste; dopo, il giocatore ha un personaggio e ogni richiesta viene rifiutata da un solo controllo. Per questo a questo remote non serve un limite di frequenza.
Invia PlayRequest da morto per rinascere primaRifiutato. Un giocatore morto mantiene il personaggio finché MenuService non lo fa rinascere.
Invia valori in più con PlayRequestIgnorati. Il gestore non li legge mai.
Elimina il menu o muove la propria telecameraCambia solo il suo schermo. Un personaggio comunque non ce l'ha, finché il server non lo fa spawnare.

Diciamolo chiaramente: il menu è una schermata, non un lucchetto. Decide quando il giocatore spawna, e nient'altro. Se un pulsante del menu dà qualcosa, per esempio una skin, una porta VIP o monete, deve controllarlo uno Script server, così come la guida al negozio controlla ogni acquisto. Il controllo di ciò che riceve un remote è spiegato nella guida ai RemoteEvent.

Passo 4: dai al menu lo stile del tuo gioco

Gli script disegnano apposta un menu semplice, così la logica è facile da capire. Tutto quello che segue cambia solo la parte GUI di MainMenu; il codice della telecamera e di Play lascialo com'è.

  • Un logo al posto del testo del titolo. Carica l'immagine del logo in Studio o nel Creator Hub, poi sostituisci la TextLabel del titolo con una ImageLabel la cui Image è rbxassetid:// seguito dall'ID dell'asset dell'immagine. Impostale BackgroundTransparency a 1 e ScaleType a Fit, così mantiene le proporzioni.
  • Sfondo sfocato. Crea un BlurEffect in MainMenu e mettilo in workspace.CurrentCamera. Roblox consiglia di farlo così per i menu: un effetto sotto la telecamera lo vede solo quel giocatore. Il suo Size è il raggio della sfocatura in pixel. Distruggilo nel gestore di Play, accanto a gui:Destroy().
  • Colore. Aggiungi al pulsante un UIGradient o un UIStroke per il contorno. Lascia al testo TextScaled, così ci sta sugli schermi piccoli.
  • Più pulsanti. Metti i pulsanti in un Frame con un UIListLayout e un piccolo Padding, e dai a ciascuno un gestore Activated e un proprio UISizeConstraint. Un pulsante Settings o Help può aprire un pannello solo sul client. Un pulsante Shop può aprire la finestra della guida al negozio, dove gli acquisti passano comunque dal server.

Passo 5: verifica

  1. Apri la finestra Output (menu Window, poi Output) e premi Play. Lo schermo appare sul tuo titolo e sul pulsante Play sopra l'inquadratura di MenuCamera, e la lista dei giocatori e lo zaino sono nascosti. Nell'Explorer in Workspace non c'è nessun modello con il tuo nome: un personaggio non ce l'hai ancora.
  2. Premi il pulsante Play. Sul pulsante compare "Loading...", lo schermo si oscura, poi riappare dietro il tuo personaggio con la telecamera normale, e la lista dei giocatori torna. In Players, il tuo nome, PlayerGui non ci sono più né MainMenu né MenuFade.
  3. Resetta il personaggio dal menu del gioco. Rinasci dopo circa 5 secondi, e il menu non torna.
  4. Scendi o salta giù dal bordo della mappa. Quando il personaggio cade fuori dal mondo, rinasci dopo circa 5 secondi.
  5. Prova lo schermo di un telefono nel Device Simulator di Studio (al momento della stesura è una beta: attiva New Device Simulator in File, Beta Features e riavvia Studio). Su un telefono piccolo il pulsante Play resta di almeno 160 per 56 pixel, e si riesce a toccarlo con un dito.
  6. Prova il gamepad nel Controller Emulator (Controller nella scheda Emulation) durante un playtest. Premi un tasto qualsiasi sul gamepad emulato: Play è selezionato, e premendo A parte il gioco. Se Play non è selezionato, premi Select sul gamepad, che seleziona il pulsante finché GuiService.AutoSelectGuiEnabled è attivo, e poi A.
  7. Con lo streaming delle istanze attivo, come nei place nuovi, verifica che dietro il menu si veda la mappa intorno a MenuCamera, e non solo il cielo.

Nell'Output in nessun momento devono esserci errori rossi da MenuService o MainMenu. Se qualcosa non torna, vedi gli errori comuni.

Il menu insieme ad altri sistemi

CharacterAutoLoads disattivato cambia il comportamento di tutti gli altri script del gioco. Se hai seguito altre guide di questo sito, controlla queste.

Il menu accanto ad altri sistemi
SistemaCosa cambiaCosa fare
Sistema di roundI giocatori nel menu contano per MIN_PLAYERS, perché il round conta tutti quelli sul server, ma non li teletrasporta mai: startRound prende solo i giocatori con un personaggio vivo. I giocatori eliminati li fa rinascere MenuService, non Roblox.Non è obbligatorio fare nulla. Se i giocatori nel menu impediscono al round di partire ("Not enough players, starting over"), in runIntermission conta solo i giocatori il cui Character non è nil.
Checkpoint per obby (in inglese)Anche ObbyCheckpoints disattiva CharacterAutoLoads e fa spawnare ogni giocatore appena si è caricato il suo livello. Con entrambi gli script i giocatori spawnano sul loro checkpoint dietro il menu, e Play toglie solo il menu.Tieni un solo spawner. Conserva ObbyCheckpoints ed elimina MenuService. In ObbyCheckpoints elimina la riga spawnAtStage(player) alla fine di onPlayerAdded. Poi al livello più alto dello script, subito sopra Players.PlayerAdded:Connect(onPlayerAdded) e non dentro onPlayerAdded, copia da MenuService la riga con ReplicatedStorage e le righe che creano PlayRequest, e collega il suo gestore OnServerEvent. Nel gestore chiama spawnAtStage(player) solo quando player.Character è nil, stageValues[player] esiste e per quel giocatore non c'è uno spawn in corso (una tabella come spawning di MenuService). Un giocatore che ha premuto Play prima che si caricasse il suo livello vede Try again e può premere di nuovo. I respawn al suo interno restano come sono. Se nel place lo streaming è attivo, copia anche le righe di MenuCamera da MenuService (AddReplicationFocus e RemoveReplicationFocus) all'inizio di onPlayerAdded.
Script della classifica e del DataStorePartono all'ingresso, mentre il giocatore è nel menu.Niente. I dati del giocatore iniziano a caricarsi mentre guarda il menu.
GUI del negozioShopClient costruisce la sua finestra appena il giocatore entra, quindi il suo pulsante Shop finirebbe accanto al menu.In ShopClient aggiungi if not player.Character then player.CharacterAdded:Wait() end subito prima della riga gui.Parent = player:WaitForChild("PlayerGui"), così il negozio compare dopo Play.
Cutscene introduttivaCutsceneService mostra l'intro al primo spawn del giocatore, e con il menu è il primo spawn dopo Play. Il menu riattiva le core GUI quando compare il personaggio, quindi durante l'intro potrebbe vedersi la lista dei giocatori.Non è obbligatorio fare nulla. La cutscene riattiva solo le core GUI che aveva nascosto lei, quindi dopo l'intro restano attive.
ScreenGui in StarterGuiVengono copiati al giocatore solo quando spawna il personaggio.Niente. Compaiono dopo Play, e per un HUD di solito è proprio quello che serve.

La differenza tra gli script in StarterPlayerScripts e in StarterGui è spiegata nella guida Script vs LocalScript vs ModuleScript (in inglese).

Perché gli script di menu copiati si rompono

Mostrare un pulsante sullo schermo è facile. I problemi iniziano dopo Play. Ecco gli schemi che li causano, e cosa fa invece questa guida.

Schemi di menu comuni e i loro problemi
SchemaProblemaIn questa guida
MouseButton1Click sul pulsante PlayRoblox lo descrive per il clic con il tasto sinistro del mouse. Activated è l'evento descritto per clic, tocco e tasto del gamepad.Activated, e Play selezionato per i gamepad
ScreenGui del menu in StarterGui con ResetOnSpawn attivoRoblox dà al giocatore una copia nuova a ogni spawn, quindi il menu torna dopo ogni morteResetOnSpawn disattivato, e il menu viene distrutto dopo Play
Personaggio spawnato e congelato dietro il menu, per esempio con WalkSpeed 0Il personaggio si trova nel mondo: gli altri lo vedono, lo spingono e lo attaccanoNessun personaggio prima di Play
player:LoadCharacter()Roblox indica che è stato sostituito da LoadCharacterAsyncLoadCharacterAsync dentro un pcall
Telecamera rimasta Scriptable dopo PlayLa telecamera resta bloccata sull'inquadratura del menuScollegare la funzione della telecamera, mettere CameraType a Custom e CameraSubject sull'Humanoid
workspace.MenuPart letto subitoCon lo streaming la parte potrebbe non essere ancora arrivata al client, e lo script si ferma con un erroreFocus di replica su MenuCamera aggiunto sul server, e WaitForChild con un limite di 5 secondi e una vista di riserva
Cicli repeat wait() until per la telecameraRoblox indica wait() come deprecato, sostituito da task.wait()BindToRenderStep per la telecamera, task.wait nel resto
Respawn solo su Humanoid.DiedCon CharacterAutoLoads disattivato un giocatore caduto dalla mappa potrebbe non rinascere mai: la caduta può togliere il personaggio da Workspace, e Died scatta solo in WorkspaceFar rinascere anche quando il personaggio lascia Workspace
Menu da un modello gratuitoRoblox avverte che i modelli del Creator Store possono contenere script backdoorDue script brevi che si possono leggere riga per riga

Errori comuni e soluzioni

Apri la finestra Output (menu Window, poi Output) prima di premere Play. La maggior parte dei problemi con il menu stampa lì un avviso o un errore con il nome dello script e il numero di riga.

La telecamera resta sull'inquadratura del menu dopo Play

MainMenu non è arrivato al passo che restituisce la telecamera, oppure un altro script ha cambiato la telecamera dopo. Cerca nell'Output un errore rosso da MainMenu. Se un tuo script imposta anche CameraType, assicurati che non metta Scriptable quando il giocatore è già in gioco.

Sul pulsante "Loading...", e poi "Try again"

MainMenu ha trovato PlayRequest, quindi MenuService funziona, ma un personaggio con un Humanoid non è comparso entro 15 secondi. Se hai aggiunto tu PlayRequest in ReplicatedStorage, eliminalo: MenuService crea il suo, e con due oggetti con lo stesso nome il pulsante potrebbe inviare a uno mentre il server ascolta l'altro. Poi cerca nell'Output MenuService: could not spawn e il motivo che segue. Se usi un tuo StarterCharacter, il suo Humanoid deve chiamarsi Humanoid, perché entrambi gli script aspettano un figlio con quel nome. Se lo spawn era solo lento, premere Try again lo completa.

Infinite yield possible on 'ReplicatedStorage:WaitForChild("PlayRequest")'

MainMenu aspetta il RemoteEvent che crea MenuService, quindi MenuService non funziona: è disattivato, è nel posto sbagliato o è fermo per un errore. Questo avviso è spiegato nella guida agli errori degli script.

Il mio personaggio spawna dietro il menu

Qualcos'altro fa spawnare i giocatori. Togli la spunta a CharacterAutoLoads nel servizio Players e cerca un altro script che chiama LoadCharacterAsync all'ingresso, per esempio uno script di checkpoint per obby: vedi Il menu insieme ad altri sistemi.

Nel menu si vede solo il cielo

La telecamera usa la vista di riserva, o la mappa non si è caricata. Verifica che la parte si chiami esattamente MenuCamera, stia direttamente in Workspace (non in una cartella o un modello), sia ancorata e la sua faccia frontale guardi la mappa.

Dopo la morte non rinasco

Ora i giocatori li fa rinascere solo MenuService, quindi cerca nell'Output un suo errore. Un respawn fallito stampa MenuService: could not spawn e si ripete dopo RespawnTime. Se il tuo gioco disattiva lo stato Dead dell'Humanoid, Died non scatta mai, quindi fai rinascere il giocatore dal tuo codice di morte.

Il mio HUD di StarterGui compare solo dopo Play

È normale. Con CharacterAutoLoads disattivato Roblox copia StarterGui nel PlayerGui del giocatore solo quando spawna il personaggio. Quello che deve vedersi nel menu costruiscilo da un LocalScript in StarterPlayerScripts, come fa MainMenu.

Farlo con RoCode

Se non hai voglia di costruire tutto questo a mano, RoCode può farlo nel place che hai aperto. RoCode è un agente IA indipendente per Roblox Studio, non di Roblox: descrivi la funzione nella sua chat web, e il suo plugin per Studio crea la parte e gli script nel tuo Explorer, così non devi copiare codice dalla finestra della chat.

Tu scrivi

Aggiungi un menu principale: i giocatori non devono spawnare finché non premono Play. Mostra il nome del mio gioco e un pulsante Play sopra una lenta inquadratura della telecamera dalla parte MenuCamera, oscura lo schermo, fai spawnare il giocatore dal server e ripristina la telecamera normale. Deve funzionare sui telefoni e con il gamepad.

RoCode fa
  • Può prima controllare il tuo place con Search Scripts, per esempio per uno script che disattiva già CharacterAutoLoads o fa rinascere i giocatori (come fa lo script dei checkpoint per obby), così due script non vanno in conflitto
  • Crea la parte MenuCamera con Create Instance e disattiva Players.CharacterAutoLoads con Set Property
  • Scrive MenuService e MainMenu con Create Script
  • Gli è indicato di controllare ogni script scritto con Check Script, che lo compila in Studio senza eseguirlo, e mette un punto di annullamento prima e dopo ogni blocco di modifiche

RoCode non può caricare al posto tuo l'immagine del logo o la musica del menu: caricale in Studio o nel Creator Hub e dai a RoCode gli ID degli asset. Con il plugin 3.9 o successivo RoCode può avviare un breve playtest e leggere gli errori, e con il plugin 3.9.15 o successivo il suo personaggio di test può premere i pulsanti sullo schermo, ma controlla solo quello che ha deciso lui di controllare, quindi prova tu stesso il menu cliccando. In che ordine costruire un gioco intero lo trovi nella guida come fare un gioco su Roblox con l'IA, sistema per sistema. Come RoCode si collega a Studio.

Domande frequenti

Come faccio a non far spawnare il giocatore finché non preme Play?

Togli la spunta a CharacterAutoLoads nel servizio Players, poi fai spawnare il giocatore da uno Script server con player:LoadCharacterAsync() quando arriva il RemoteEvent dal pulsante Play. A quel punto anche il respawn dopo la morte richiede la stessa chiamata, che fa MenuService.

Perché il menu principale ricompare dopo ogni morte?

Il suo ScreenGui ha ResetOnSpawn attivo, quindi Roblox dà al giocatore una nuova copia a ogni spawn. Disattivalo e togli il menu dopo Play, come fa MainMenu.

Come faccio a far mostrare alla telecamera la mappa dietro il menu?

In un LocalScript imposta workspace.CurrentCamera.CameraType a Scriptable e dai alla telecamera il CFrame di una parte che hai posizionato. Dopo Play rimetti Custom e metti l'Humanoid come valore di CameraSubject.

Come aggiungo una schermata di caricamento prima del menu?

La guida di Roblox sulle schermate di caricamento usa un LocalScript in ReplicatedFirst, che arriva al giocatore prima di tutto il resto. Costruisce uno ScreenGui, chiama ReplicatedFirst:RemoveDefaultLoadingScreen(), aspetta che game:IsLoaded() e poi toglie la sua schermata. Dai a quello ScreenGui un DisplayOrder superiore a 11, così copre questo menu finché non sparisce. La nostra guida alla schermata di caricamento costruisce una schermata così con una barra di avanzamento e un pulsante Skip, e il suo DisplayOrder 100 copre già il menu.

Come aggiungo la musica al menu principale?

Usa un audio di cui hai i diritti, per esempio una traccia gratuita del Creator Store o un audio che hai caricato tu. Metti un Sound con quell'ID in SoundService, spunta Looped, chiama il suo :Play() da MainMenu quando compare il menu e :Stop() nel gestore di Play. Un suono avviato da un LocalScript lo sente solo quel giocatore, finché SoundService.RespectFilteringEnabled è attivo, e lo è di default.

Posso prendere il menu principale da un modello gratuito?

Puoi, ma prima leggi i suoi script. Roblox avverte che i modelli del Creator Store possono contenere script backdoor che danno ai loro autori accesso al tuo gioco. Al menu servono solo i due script brevi di questa guida.

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.