Tutorial · Sisteme de joc

Cum să faci un meniu principal în Roblox Studio

Un meniu principal în Roblox Studio, numit și meniu de start sau ecran de titlu, e un ScreenGui cu un buton Play. Dar senzația de joc terminat vine din alte lucruri: jucătorul nu trebuie să apară până nu apasă Play, camera trebuie să arate harta și apoi să revină la personaj, iar meniul nu trebuie să mai apară niciodată după moarte. În acest ghid construim toate astea în două scripturi care merg cu mouse-ul, pe ecran tactil și cu gamepad-ul.

Actualizat 20 noiembrie 202619 min de cititAutor:

Pe scurt

Dezactivează CharacterAutoLoads la serviciul Players, ca nimeni să nu apară la intrare. Un LocalScript în StarterPlayerScripts construiește meniul (titlul, butonul Play și un frame negru pentru întunecări) într-un ScreenGui cu ResetOnSpawn dezactivat, îndreaptă camera spre un part numit MenuCamera prin CameraType Scriptable și, la apăsarea Play, trimite un RemoteEvent. Un Script în ServerScriptService răspunde cu un apel Player:LoadCharacterAsync(), iar LocalScript-ul readuce camera (CameraType Custom, CameraSubject e Humanoid-ul) și scoate meniul.

  • Folosește Activated, nu MouseButton1Click, ca Play să meargă la clic, la atingere și cu gamepad-ul, și selectează butonul pentru jucătorii cu gamepad, ca să-l poată apăsa.
  • Cu CharacterAutoLoads dezactivat, StarterGui se copiază în PlayerGui-ul jucătorului doar când îi apare personajul, așa că meniul îl construiește un LocalScript din StarterPlayerScripts.
  • Cu CharacterAutoLoads dezactivat, Roblox nu mai readuce nici jucătorii, așa că scriptul de server îi readuce singur după moarte sau după o cădere de pe hartă, după ce așteaptă Players.RespawnTime (implicit 5 secunde).
Pe această pagină
  1. Cum funcționează
  2. 1. Pregătire
  3. 2. Scriptul de server
  4. 3. Scriptul meniului
  5. Ce decide serverul
  6. 4. Design
  7. 5. Verificare
  8. Cu alte sisteme
  9. De ce se strică meniurile altora
  10. Common errors
  11. Cu RoCode
  12. Întrebări frecvente
  13. Surse și lecturi suplimentare

Cum funcționează un meniu principal

IlustrațieMeniul gata făcut într-un joc pornit, cu așteptarea serverului accelerată: Play întunecă ecranul, serverul face personajul să apară, iar camera revine la el.

Meniul are două părți. Dispozitivul jucătorului desenează titlul și butonul și mișcă camera. Serverul decide când apare personajul. Meniul în sine e doar o imagine pe un singur ecran: schimbarea reală se întâmplă când serverul face personajul să apară, și doar serverul poate face asta.

Din ce e alcătuit meniul
ParteUnde stăCe face
Script MenuServiceServerScriptServiceDezactivează apariția automată, creează PlayRequest, face să apară jucătorul care a apăsat Play și îi readuce pe jucători după moarte sau cădere.
LocalScript MainMenuStarterPlayerScriptsConstruiește titlul, butonul Play și întunecarea, conduce cadrul camerei, îi cere serverului personajul și readuce camera.
RemoteEvent PlayRequestReplicatedStorage (îl creează MenuService, nu-l adăuga manual)Îi transmite serverului un singur mesaj: acest jucător a apăsat Play. Nu conține nicio valoare.
Part MenuCameraWorkspace (îl pui tu)Unde stă camera meniului și unde privește.
CharacterAutoLoadsProprietate a serviciului PlayersDezactivată, așa că nimeni nu apare până nu apelează serverul LoadCharacterAsync.
Explorer-ul când meniul e gata. PlayRequest apare la pornirea jocului: îl creează MenuService, așa că nu-l adăuga manual.
Workspace
  MenuCamera Part new
ReplicatedStorage
  PlayRequest RemoteEvent new
ServerScriptService
  MenuService Script new
StarterPlayer
  StarterPlayerScripts
    MainMenu LocalScript new

Pasul 1: dezactivează apariția automată și pune camera meniului

  1. În Explorer selectează Players. În fereastra Properties debifează CharacterAutoLoads. MenuService o dezactivează și el, dar bifa garantează că nimeni nu apare în clipa dinaintea pornirii scriptului.
  2. Treci cu mouse-ul peste Workspace, apasă butonul + și inserează un Part. Redenumește-l în MenuCamera (majusculele din nume contează) și ține-l direct în Workspace, nu într-un folder sau model.
  3. În Properties-ul lui bifează Anchored, debifează CanCollide și setează Transparency la 1. Ancorarea contează: un part neancorat care nu se lovește de nimic cade prin hartă, iar Roblox șterge part-urile căzute sub Workspace.FallenPartsDestroyHeight.
  4. Mută și rotește part-ul astfel încât fața lui din față să privească spre vederea dorită. Camera ia poziția part-ului și privește în aceeași direcție ca fața lui din față.

Cel mai rapid mod de a-l îndrepta: zboară cu camera Studio la cadrul dorit, deschide Command Bar (în fila Script sau prin Window, apoi Script) și rulează workspace.MenuCamera.CFrame = workspace.CurrentCamera.CFrame. În modul de editare, CurrentCamera e vederea prin care te uiți, așa că part-ul sare exact în acest cadru.

Lasă Workspace.StreamingEnabled cum e. În place-urile noi, instance streaming e activ, iar scripturile de mai jos sunt scrise ținând cont de asta.

Pasul 2: facem jucătorii să apară la apăsarea Play

Treci cu mouse-ul peste ServerScriptService, inserează un Script, numește-l MenuService și lipește acest cod:

Script în ServerScriptService cu numele MenuService
-- Script în ServerScriptService cu numele MenuService.
-- Jucătorii intră fără personaj. Serverul îl creează când îl cere butonul Play din meniu
-- și îi readuce pe jucători după moarte, pentru că apariția automată e dezactivată.

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

-- Debifează și CharacterAutoLoads la serviciul Players în fereastra Properties,
-- ca nimeni să nu apară în clipa dinaintea pornirii acestui script.
Players.CharacterAutoLoads = false

-- Scriptul acesta creează singur PlayRequest, așa că nu-l adăuga manual în 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 -- un al doilea clic pe Play cât prima apariție încă se încarcă
	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 eșuat ar lăsa un jucător mort blocat, așa că încercăm din nou după o pauză scurtă.
		-- O primă apariție eșuată nu trebuie repetată: butonul din meniu scrie 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() -- eliberează conexiunile personajului vechi
	end
end

-- Poate cere o apariție doar un jucător care e încă în meniu (încă fără personaj). Un jucător
-- mort are încă personaj, așa că nu poate sări așa peste așteptarea respawn-ului.
playRequest.OnServerEvent:Connect(function(player: Player)
	if player.Character == nil then
		spawnCharacter(player)
	end
end)

-- Cu CharacterAutoLoads dezactivat, nimeni nu-i readuce pe jucători după moarte, așa că o facem aici
local function onCharacterAdded(player: Player, character: Model)
	local respawning = false
	local function respawnLater()
		if respawning then
			return
		end
		respawning = true
		task.wait(Players.RespawnTime)
		-- Readucem doar dacă jucătorul e încă aici și nu l-a făcut nimeni să apară între timp
		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)
	-- O cădere de pe hartă poate scoate personajul din Workspace, iar Died se declanșează doar
	-- cât Humanoid-ul e în Workspace, așa că prindem aici și acest caz
	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)

	-- Cu streaming, harta se încarcă în jurul personajului jucătorului, dar un jucător din
	-- meniu încă nu îl are. Adăugăm un focus de replicare la camera meniului până apare.
	local menuCamera = workspace:FindFirstChild("MenuCamera")
	if menuCamera and menuCamera:IsA("BasePart") then
		player:AddReplicationFocus(menuCamera)
		player.CharacterAdded:Once(function()
			player:RemoveReplicationFocus(menuCamera) -- de acum focusul e personajul
		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 nu transmite nicio valoare. Roblox transmite jucătorul care a trimis evenimentul ca prim argument al OnServerEvent, și asta e tot ce trebuie să știe serverul.

Cine are voie să apară

Handler-ul PlayRequest face jucătorul să apară doar dacă player.Character e nil, iar așa e la un jucător care e încă în meniu. Un jucător mort își păstrează personajul până îl readuce MenuService, așa că prin remote nu se poate sări peste așteptare.

Tabelul spawning împiedică o a doua cerere să pornească o a doua apariție cât prima încă se încarcă. LoadCharacterAsync așteaptă să se încarce personajul, iar referința Roblox nu recomandă să-l apelezi din nou pentru același jucător până nu s-a declanșat evenimentul lui CharacterAppearanceLoaded. Fiecare apel e într-un pcall, așa că o apariție eșuată, de exemplu când jucătorul a ieșit în timpul încărcării, afișează un avertisment cu numele jucătorului, nu o eroare. Dacă un respawn eșuează, MenuService așteaptă RespawnTime și încearcă din nou, așa că un respawn eșuat nu lasă un jucător mort blocat. O primă apariție eșuată serverul nu o repetă: butonul din meniu scrie Try again, iar jucătorul îl poate apăsa.

Respawn după moarte sau cădere

Cu CharacterAutoLoads dezactivat, Roblox nu readuce pe nimeni. Players.RespawnTime (implicit 5 secunde) funcționează singur doar cu CharacterAutoLoads activat, așa că MenuService citește această valoare, așteaptă singur și apelează din nou LoadCharacterAsync. Noul personaj apare pe SpawnLocation ca de obicei, iar scriptul îl distruge pe cel vechi, ceea ce deconectează și conexiunile acelui personaj.

Pentru o cădere de pe hartă e nevoie de o a doua verificare. Roblox șterge part-urile căzute sub Workspace.FallenPartsDestroyHeight și șterge un model când i-a dispărut ultimul part, așa că un personaj căzut poate părăsi Workspace, iar Humanoid.Died se declanșează doar cât Humanoid-ul e în Workspace. De aceea MenuService readuce și un personaj care a părăsit Workspace (AncestryChanged), iar flagul respawning are grijă ca fiecare personaj să provoace cel mult un respawn. După așteptare, scriptul readuce jucătorul doar dacă e încă în joc și player.Character e încă acel personaj sau nil, așa că un jucător făcut să apară între timp altfel nu apare de două ori.

Streaming și camera meniului

Cu instance streaming, fiecare client primește part-urile din jurul focusului lui de replicare, iar implicit acesta e PrimaryPart-ul personajului. Un jucător din meniu nu are personaj, iar pagina Roblox despre tehnicile de streaming avertizează că un client fără personaj apărut nu are focus de replicare, așa că harta poate să nu se încarce deloc. Soluția de pe acea pagină e Player:AddReplicationFocus(), pe care MenuService îl apelează cu part-ul MenuCamera la intrarea jucătorului (Roblox spune să-l apelezi doar pe server). Când personajul apare prima dată, MenuService apelează RemoveReplicationFocus, iar singurul focus redevine personajul: fiecare focus în plus adaugă muncă de streaming pe server. La pasul 5 e un playtest cu streamingul activ, ca să te asiguri că harta se vede în spatele meniului.

Ce decide serverul și ce poate face un trișor

Un trișor își poate rula propriul cod pe dispozitivul lui. Poate trimite PlayRequest oricând, cu orice valori, și poate schimba orice pe ecranul lui. Iată ce îi aduce asta.

Ce poate încerca un trișor cu meniul
TrișorulCe se întâmplă
Trimite PlayRequest fără să apese PlayApare, exact ca și cum ar fi apăsat Play. Sărirea peste meniu nu-i aduce nimic.
Trimite PlayRequest de sute de oriO singură apariție. Cât se încarcă, flagul spawning le ignoră pe celelalte; după ea jucătorul are personaj, iar fiecare cerere e respinsă de o singură verificare. De aceea acest remote nu are nevoie de limită de frecvență.
Trimite PlayRequest când e mort, ca să revină mai devremeRefuz. Un jucător mort își păstrează personajul până îl readuce MenuService.
Trimite valori în plus cu PlayRequestIgnorate. Handler-ul nu le citește niciodată.
Șterge meniul sau își mișcă cameraSe schimbă doar propriul ecran. Oricum nu are personaj până nu-l face serverul să apară.

Să fim direcți: meniul e un ecran, nu o încuietoare. Decide când apare jucătorul, și nimic altceva. Dacă un buton din meniu dă ceva, de exemplu un skin, o ușă VIP sau monede, asta trebuie verificat de un Script de server, exact cum ghidul despre magazin verifică fiecare cumpărare. Verificarea a ce primește un remote e explicată în ghidul despre RemoteEvent.

Pasul 4: fă meniul în stilul jocului tău

Scripturile desenează intenționat un meniu simplu, ca logica să fie ușor de înțeles. Tot ce urmează schimbă doar partea de GUI din MainMenu; codul camerei și al butonului Play lasă-l cum e.

  • Un logo în loc de textul titlului. Încarcă imaginea logo-ului în Studio sau în Creator Hub, apoi înlocuiește TextLabel-ul titlului cu un ImageLabel al cărui Image e rbxassetid:// plus ID-ul asset-ului imaginii. Dă-i BackgroundTransparency 1 și ScaleType Fit, ca să-și păstreze proporțiile.
  • Fundal estompat. Creează un BlurEffect în MainMenu și pune-l în workspace.CurrentCamera. Roblox recomandă asta pentru meniuri: un efect sub cameră îl vede doar acel jucător. Size-ul lui e raza estompării în pixeli. Distruge-l în handler-ul Play, lângă gui:Destroy().
  • Culoare. Adaugă butonului un UIGradient sau un UIStroke pentru contur. Lasă textul cu TextScaled, ca să încapă pe ecranele mici.
  • Mai multe butoane. Pune butoanele într-un Frame cu un UIListLayout și un Padding mic și dă-i fiecăruia un handler Activated și propriul UISizeConstraint. Un buton Settings sau Help poate deschide un panou doar pe client. Un buton Shop poate deschide fereastra din ghidul despre magazin, unde cumpărăturile trec oricum prin server.

Pasul 5: verifică

  1. Deschide fereastra Output (meniul Window, apoi Output) și apasă Play. Ecranul se luminează pe titlul tău și pe butonul Play peste cadrul MenuCamera, iar lista de jucători și rucsacul sunt ascunse. În Explorer, în Workspace nu e niciun model cu numele tău: încă nu ai personaj.
  2. Apasă butonul Play. Pe el apare "Loading...", ecranul se întunecă, apoi se luminează în spatele personajului tău, cu camera obișnuită, iar lista de jucători revine. În Players, numele tău, PlayerGui nu mai sunt nici MainMenu, nici MenuFade.
  3. Resetează-ți personajul din meniul jocului. Revii după aproximativ 5 secunde, iar meniul nu se întoarce.
  4. Coboară sau sari de pe marginea hărții. Când personajul cade din lume, revii după aproximativ 5 secunde.
  5. Verifică ecranul de telefon în Device Simulator din Studio (la momentul scrierii e beta: activează New Device Simulator în File, Beta Features și repornește Studio). Pe un telefon mic, butonul Play rămâne de cel puțin 160 pe 56 de pixeli și îl poți nimeri cu degetul.
  6. Verifică gamepad-ul în Controller Emulator (Controller în fila Emulation) în timpul unui playtest. Apasă orice buton pe gamepad-ul emulat: Play e selectat, iar apăsarea lui A pornește jocul. Dacă Play nu e selectat, apasă pe gamepad Select, care selectează butonul cât e activ GuiService.AutoSelectGuiEnabled, apoi A.
  7. Cu instance streaming activ, ca în place-urile noi, verifică dacă în spatele meniului se vede harta din jurul MenuCamera, nu doar cerul.

În Output nu trebuie să apară în niciun moment erori roșii de la MenuService sau MainMenu. Dacă ceva nu se potrivește, vezi erorile frecvente.

Meniul împreună cu alte sisteme

CharacterAutoLoads dezactivat schimbă comportamentul tuturor celorlalte scripturi din joc. Dacă ai urmat alte ghiduri de pe acest site, verifică-le pe acestea.

Meniul alături de alte sisteme
SistemCe se schimbăCe faci
Sistem de rundeJucătorii din meniu contează la MIN_PLAYERS, pentru că runda îi numără pe toți de pe server, dar nu-i teleportează niciodată: startRound ia doar jucătorii cu personaj viu. Jucătorii eliminați îi readuce MenuService, nu Roblox.Nu e obligatoriu să faci nimic. Dacă jucătorii din meniu împiedică începerea rundei ("Not enough players, starting over"), numără în runIntermission doar jucătorii al căror Character nu e nil.
Checkpointuri în obbyObbyCheckpoints dezactivează și el CharacterAutoLoads și face fiecare jucător să apară imediat ce i s-a încărcat etapa. Cu ambele scripturi, jucătorii apar la checkpointul lor în spatele meniului, iar Play doar scoate meniul.Păstrează un singur sistem de apariție. Păstrează ObbyCheckpoints și șterge MenuService. În ObbyCheckpoints șterge rândul spawnAtStage(player) de la finalul onPlayerAdded. Apoi, la nivelul de sus al scriptului, chiar deasupra Players.PlayerAdded:Connect(onPlayerAdded) și nu în onPlayerAdded, copiază din MenuService rândul cu ReplicatedStorage și rândurile care creează PlayRequest și conectează-i handler-ul OnServerEvent. În handler apelează spawnAtStage(player) doar când player.Character e nil, stageValues[player] există și pentru acest jucător nu e în curs o apariție (un tabel ca spawning din MenuService). Un jucător care a apăsat Play înainte să i se încarce etapa vede Try again și poate apăsa din nou. Respawn-urile din el rămân cum sunt. Dacă place-ul are streamingul activ, copiază și rândurile MenuCamera din MenuService (AddReplicationFocus și RemoveReplicationFocus) la începutul onPlayerAdded.
Scripturile de clasament și DataStorePornesc la intrare, cât jucătorul e în meniu.Nimic. Datele jucătorului încep să se încarce cât se uită la meniu.
GUI de magazinShopClient își construiește fereastra imediat la intrarea jucătorului, așa că butonul lui Shop ar ajunge lângă meniu.În ShopClient adaugă if not player.Character then player.CharacterAdded:Wait() end chiar înainte de rândul gui.Parent = player:WaitForChild("PlayerGui"), ca magazinul să apară după Play.
Cutscene de introCutsceneService arată introul la prima apariție a jucătorului, iar cu meniul aceasta e prima apariție după Play. Meniul reactivează core GUI-ul când apare personajul, așa că în timpul introului poate fi vizibilă lista de jucători.Nu e obligatoriu să faci nimic. Cutscene-ul reactivează doar core GUI-urile pe care le-a ascuns el, așa că după intro rămân activate.
ScreenGui-uri din StarterGuiSe copiază la jucător doar la apariția personajului.Nimic. Apar după Play, iar pentru un HUD de obicei asta și vrei.

Diferența dintre scripturile din StarterPlayerScripts și cele din StarterGui e explicată în ghidul Script vs LocalScript vs ModuleScript.

De ce se strică scripturile de meniu copiate

Să pui un buton pe ecran e ușor. Problemele încep după Play. Iată tiparele care le provoacă și ce face ghidul acesta în schimb.

Tipare frecvente de meniu și problemele lor
TiparProblemaÎn acest ghid
MouseButton1Click pe butonul PlayRoblox îl descrie pentru clicul cu butonul stâng al mouse-ului. Activated e evenimentul descris pentru clic, atingere și butonul de gamepad.Activated, iar Play e selectat pentru gamepad-uri
ScreenGui-ul meniului în StarterGui cu ResetOnSpawn activatRoblox îi dă jucătorului o copie nouă la fiecare apariție, așa că meniul revine după fiecare moarteResetOnSpawn e dezactivat, iar meniul e distrus după Play
Personajul apărut și înghețat în spatele meniului, de exemplu cu WalkSpeed 0Personajul e în lume: ceilalți îl văd, îl împing și îl atacăNu există personaj până la Play
player:LoadCharacter()Roblox notează că a fost înlocuit de LoadCharacterAsyncLoadCharacterAsync în pcall
Camera rămasă Scriptable după PlayCamera rămâne blocată pe cadrul meniuluiDeconectezi funcția camerei, setezi CameraType la Custom și CameraSubject pe Humanoid
workspace.MenuPart citit imediatCu streaming, part-ul poate să nu fi ajuns încă la client, iar scriptul cade cu o eroareUn focus de replicare pe MenuCamera, adăugat pe server, și WaitForChild cu limită de 5 secunde și o vedere de rezervă
Bucle repeat wait() until pentru camerăRoblox marchează wait() ca învechit, înlocuit de task.wait()BindToRenderStep pentru cameră, task.wait în rest
Respawn doar la Humanoid.DiedCu CharacterAutoLoads dezactivat, un jucător căzut de pe hartă poate să nu mai revină: căderea poate scoate personajul din Workspace, iar Died se declanșează doar în WorkspaceReadu-l și când personajul părăsește Workspace
Meniu dintr-un model gratuitRoblox avertizează că modelele din Creator Store pot conține scripturi backdoorDouă scripturi scurte pe care le poți citi rând cu rând

Erori frecvente și soluții

Deschide fereastra Output (meniul Window, apoi Output) înainte să apeși Play. Cele mai multe probleme cu meniul afișează acolo un avertisment sau o eroare cu numele scriptului și numărul rândului.

Camera rămâne pe cadrul meniului după Play

MainMenu nu a ajuns la pasul care readuce camera sau alt script a schimbat camera după asta. Caută în Output o eroare roșie de la MainMenu. Dacă un script de-al tău setează și el CameraType, asigură-te că nu pune Scriptable când jucătorul e deja în joc.

Pe buton scrie "Loading...", apoi "Try again"

MainMenu a găsit PlayRequest, deci MenuService rulează, dar un personaj cu Humanoid nu a apărut în 15 secunde. Dacă ai adăugat singur PlayRequest în ReplicatedStorage, șterge-l: MenuService își creează propriul, iar cu două obiecte cu același nume butonul poate trimite într-unul cât serverul ascultă altul. Apoi caută în Output MenuService: could not spawn și cauza de după. Dacă folosești propriul StarterCharacter, Humanoid-ul lui trebuie să se numească Humanoid, pentru că ambele scripturi așteaptă un copil cu acest nume. Dacă apariția a fost doar lentă, apăsarea Try again o termină.

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

MainMenu așteaptă RemoteEvent-ul creat de MenuService, deci MenuService nu rulează: e dezactivat, stă în locul greșit sau a fost oprit de o eroare. Acest avertisment e explicat în ghidul despre erorile din scripturi.

Personajul meu apare în spatele meniului

Jucătorii sunt făcuți să apară de altceva. Debifează CharacterAutoLoads la serviciul Players și caută alt script care apelează LoadCharacterAsync la intrare, de exemplu scriptul de checkpointuri din obby: vezi Meniul împreună cu alte sisteme.

În meniu se vede doar cerul

Camera folosește vederea de rezervă sau harta nu s-a încărcat. Verifică dacă part-ul se numește exact MenuCamera, stă direct în Workspace (nu într-un folder sau model), e ancorat și fața lui din față privește spre hartă.

După moarte nu revin

Acum jucătorii îi readuce doar MenuService, așa că caută în Output o eroare de la el. Un respawn eșuat afișează MenuService: could not spawn și se repetă după RespawnTime. Dacă jocul tău dezactivează starea Dead a Humanoid-ului, Died nu se declanșează niciodată, așa că readu jucătorul din propriul tău cod de moarte.

HUD-ul meu din StarterGui apare doar după Play

Așa trebuie. Cu CharacterAutoLoads dezactivat, Roblox copiază StarterGui în PlayerGui-ul jucătorului doar la apariția personajului. Ce trebuie să se vadă în meniu construiește dintr-un LocalScript din StarterPlayerScripts, cum face MainMenu.

Fă-o cu RoCode

Dacă nu ai chef să construiești toate astea manual, RoCode le poate face în place-ul pe care îl ai deschis. RoCode este un agent AI independent pentru Roblox Studio, nu de la Roblox: descrii funcția în chatul lui web, iar pluginul lui pentru Studio creează part-ul și scripturile în Explorer-ul tău, așa că nu trebuie să copiezi cod din fereastra de chat.

Tu scrii

Adaugă un meniu principal: jucătorii nu trebuie să apară până nu apasă Play. Arată numele jocului meu și un buton Play peste un cadru lent de cameră din part-ul MenuCamera, întunecă ecranul, fă jucătorul să apară de pe server și readu camera obișnuită. Trebuie să meargă pe telefoane și cu gamepad.

RoCode face
  • Poate verifica întâi place-ul tău prin Search Scripts, de exemplu după un script care dezactivează deja CharacterAutoLoads sau readuce jucătorii (așa face scriptul de checkpointuri din obby), ca două scripturi să nu intre în conflict
  • Creează part-ul MenuCamera prin Create Instance și dezactivează Players.CharacterAutoLoads prin Set Property
  • Scrie MenuService și MainMenu prin Create Script
  • Are instrucțiuni să verifice fiecare script scris prin Check Script, care îl compilează în Studio fără să-l ruleze, și pune un punct de anulare înainte și după fiecare lot de modificări

RoCode nu poate încărca pentru tine imaginea logo-ului sau muzica meniului: încarcă-le în Studio sau în Creator Hub și dă-i lui RoCode ID-urile asset-urilor. Cu pluginul 3.9 sau mai nou, RoCode poate porni un playtest scurt și citi erorile, iar cu pluginul 3.9.15 sau mai nou personajul lui de test poate apăsa butoane de pe ecran, dar verifică doar ce a hotărât el să verifice, așa că trece singur prin meniu. În ce ordine construiești un joc întreg vezi în ghidul cum faci un joc în Roblox cu AI, sistem cu sistem. Cum se conectează RoCode la Studio.

Întrebări frecvente

Cum fac ca jucătorul să nu apară până nu apasă Play?

Debifează CharacterAutoLoads la serviciul Players, apoi fă jucătorul să apară dintr-un Script de server prin player:LoadCharacterAsync(), când vine RemoteEvent-ul de la butonul Play. Respawn-ul după moarte are atunci nevoie de același apel, iar MenuService îl face.

De ce reapare meniul principal după fiecare moarte?

ScreenGui-ul lui are ResetOnSpawn activat, așa că Roblox îi dă jucătorului o copie nouă la fiecare apariție. Dezactivează-l și scoate meniul după Play, cum face MainMenu.

Cum fac camera să arate harta în spatele meniului?

Într-un LocalScript setează workspace.CurrentCamera.CameraType la Scriptable și dă-i camerei CFrame-ul unui part pe care l-ai pus. După Play readu Custom și fă Humanoid-ul valoarea CameraSubject.

Cum adaug un ecran de încărcare înaintea meniului?

Ghidul Roblox despre ecranele de încărcare folosește un LocalScript din ReplicatedFirst, care ajunge la jucător înaintea oricărui altceva. Construiește un ScreenGui, apelează ReplicatedFirst:RemoveDefaultLoadingScreen(), așteaptă până la game:IsLoaded() și apoi își scoate ecranul. Dă-i acestui ScreenGui un DisplayOrder mai mare decât 11, ca să acopere acest meniu până dispare. Ghidul nostru despre ecranul de încărcare construiește un astfel de ecran cu bară de progres și buton Skip, iar DisplayOrder-ul lui de 100 acoperă deja meniul.

Cum adaug muzică în meniul principal?

Folosește audio pentru care ai drepturi, de exemplu o piesă gratuită din Creator Store sau un audio încărcat de tine. Pune un Sound cu acest ID în SoundService, bifează Looped, apelează-i :Play() din MainMenu când apare meniul și :Stop() în handler-ul Play. Un sunet pornit dintr-un LocalScript îl aude doar acel jucător, cât e activ SoundService.RespectFilteringEnabled, iar implicit e activ.

Pot lua meniul principal dintr-un model gratuit?

Poți, dar citește-i întâi scripturile. Roblox avertizează că modelele din Creator Store pot conține scripturi backdoor care le dau autorilor acces la jocul tău. Un meniu are nevoie doar de cele două scripturi scurte din acest ghid.

Surse și lecturi suplimentare

Cum a fost verificat codul: fiecare script de pe această pagină trece printr-o verificare strictă a tipurilor Luau cu definițiile API Roblox (luau-lsp, 20 noiembrie 2026). Verificarea tipurilor prinde nume greșite de API și tipuri greșite, dar nu și greșelile de logică a jocului, așa că testează totul în Studio înainte să publici.

Încearcă RoCode în jocul tău.

Credite gratuite în fiecare zi, fără card. Instalează pluginul, descrie o funcție și verifică ce a apărut în Studio.