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, nonMouseButton1Click, 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
Come funziona il menu principale
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.
| Parte | Dove sta | Cosa fa |
|---|---|---|
Script MenuService | ServerScriptService | Disattiva 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 MainMenu | StarterPlayerScripts | Costruisce il titolo, il pulsante Play e la dissolvenza, gestisce l'inquadratura della telecamera, chiede al server il personaggio e restituisce la telecamera. |
RemoteEvent PlayRequest | ReplicatedStorage (lo crea MenuService, non aggiungerlo a mano) | Porta al server un solo messaggio: questo giocatore ha premuto Play. Non contiene nessun valore. |
Part MenuCamera | Workspace (la metti tu) | Dove sta la telecamera del menu e dove guarda. |
CharacterAutoLoads | Proprietà del servizio Players | Disattivata, così nessuno spawna finché il server non chiama LoadCharacterAsync. |
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
- 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.
- 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. - 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. - 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.
-- 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.
| Il cheater | Cosa succede |
|---|---|
| Invia PlayRequest senza premere Play | Spawna, esattamente come se avesse premuto Play. Saltare il menu non dà nulla. |
| Invia PlayRequest centinaia di volte | Un 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 prima | Rifiutato. Un giocatore morto mantiene il personaggio finché MenuService non lo fa rinascere. |
| Invia valori in più con PlayRequest | Ignorati. Il gestore non li legge mai. |
| Elimina il menu o muove la propria telecamera | Cambia 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
TextLabeldel titolo con unaImageLabella cuiImageèrbxassetid://seguito dall'ID dell'asset dell'immagine. ImpostaleBackgroundTransparencya 1 eScaleTypea Fit, così mantiene le proporzioni. - Sfondo sfocato. Crea un
BlurEffectin MainMenu e mettilo inworkspace.CurrentCamera. Roblox consiglia di farlo così per i menu: un effetto sotto la telecamera lo vede solo quel giocatore. Il suoSizeè il raggio della sfocatura in pixel. Distruggilo nel gestore di Play, accanto agui:Destroy(). - Colore. Aggiungi al pulsante un
UIGradiento unUIStrokeper il contorno. Lascia al testoTextScaled, così ci sta sugli schermi piccoli. - Più pulsanti. Metti i pulsanti in un
Framecon unUIListLayoute un piccoloPadding, e dai a ciascuno un gestoreActivatede un proprioUISizeConstraint. 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
- 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.
- 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,PlayerGuinon ci sono più né MainMenu né MenuFade. - Resetta il personaggio dal menu del gioco. Rinasci dopo circa 5 secondi, e il menu non torna.
- Scendi o salta giù dal bordo della mappa. Quando il personaggio cade fuori dal mondo, rinasci dopo circa 5 secondi.
- 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.
- 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. - 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.
| Sistema | Cosa cambia | Cosa fare |
|---|---|---|
| Sistema di round | I 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 DataStore | Partono all'ingresso, mentre il giocatore è nel menu. | Niente. I dati del giocatore iniziano a caricarsi mentre guarda il menu. |
| GUI del negozio | ShopClient 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 introduttiva | CutsceneService 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 StarterGui | Vengono 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).
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.
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.
- 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.CharacterAutoLoadscon 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
- Roblox Engine API: Players (in inglese). CharacterAutoLoads e RespawnTime
- Roblox Engine API: Player (in inglese). LoadCharacterAsync, ordine di caricamento e AddReplicationFocus
- Roblox Creator Docs: On-screen UI containers (in inglese). quando viene copiato StarterGui, margini dello schermo e ordine di visualizzazione
- Roblox Engine API: LayerCollector (in inglese). ResetOnSpawn
- Roblox Engine API: Camera (in inglese). Focus, il punto verso cui guarda la telecamera
- Roblox Creator Docs: Customize the camera (in inglese). controllare la telecamera da script con CameraType Scriptable
- Roblox Creator Docs: Streaming techniques and conversion (in inglese). perché un client senza personaggio potrebbe non ricevere la mappa, e il focus di replica
- Roblox Engine API: GuiButton (in inglese). Activated per clic, tocco e tasto del gamepad
- Roblox Creator Docs: Loading screens (in inglese). schermate di caricamento personalizzate in ReplicatedFirst
- Roblox Creator Docs: Vulnerabilities from third-party assets (in inglese). script backdoor nei modelli gratuiti
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.