Tutorial · Sistemas de jogo

Como fazer um menu principal no Roblox Studio

Um menu principal no Roblox Studio, também chamado de menu inicial ou tela de título, é um ScreenGui com um botão Play. O que faz ele parecer pronto está em outros lugares: o jogador não deve nascer até apertar Play, a câmera deve mostrar o seu mapa e depois voltar para o personagem, e o menu nunca deve reaparecer depois de uma morte. Este guia monta tudo isso em dois scripts, feitos para mouse, toque e controle.

Atualizado em 14 de novembro de 202621 min de leituraEscrito por

Resumo

Desligue o CharacterAutoLoads no serviço Players para ninguém nascer ao entrar. Um LocalScript no StarterPlayerScripts monta o menu (um título, um botão Play e um quadro preto para os fades) em ScreenGuis com ResetOnSpawn desligado, aponta a câmera para uma part chamada MenuCamera com CameraType Scriptable e, no Play, dispara um RemoteEvent. Um Script no ServerScriptService responde com Player:LoadCharacterAsync(), e o LocalScript devolve a câmera (CameraType Custom, CameraSubject o Humanoid) e remove o menu.

  • Use Activated, não MouseButton1Click, para o Play funcionar com clique, toque e controle, e selecione o botão para quem joga com controle conseguir apertá-lo.
  • Com o CharacterAutoLoads desligado, o StarterGui só é copiado para o PlayerGui de um jogador quando o personagem dele nasce, então o menu é montado por um LocalScript no StarterPlayerScripts.
  • Com o CharacterAutoLoads desligado, o Roblox também para de fazer os jogadores renascerem, então o script de servidor faz isso depois de uma morte ou de uma queda do mapa, esperando Players.RespawnTime (5 segundos por padrão).
Nesta página
  1. Como funciona
  2. 1. Preparação
  3. 2. Script de servidor
  4. 3. Script do menu
  5. O que o servidor decide
  6. 4. Visual
  7. 5. Teste
  8. Com outros sistemas
  9. Por que menus copiados quebram
  10. Erros comuns
  11. Com o RoCode
  12. Perguntas frequentes
  13. Fontes e leitura extra

Como funciona um menu principal

IlustraçãoO menu pronto em um jogo rodando, com a espera pelo servidor acelerada: o Play escurece a tela, o servidor cria o personagem e a câmera volta para ele.

Um menu tem dois lados. O dispositivo do jogador desenha o título e o botão e move a câmera. O servidor decide quando um personagem existe. O menu em si é só uma imagem em uma tela: a mudança de verdade acontece quando o servidor cria o personagem, e o servidor é o único lado que pode fazer isso.

As peças do menu
PeçaOnde ficaO que faz
Script MenuServiceServerScriptServiceDesliga o nascimento automático, cria o PlayRequest, cria o personagem de quem aperta Play e faz os jogadores renascerem depois de uma morte ou de uma queda.
LocalScript MainMenuStarterPlayerScriptsMonta o título, o botão Play e o fade, roda a cena da câmera, pede um personagem ao servidor e devolve a câmera.
RemoteEvent PlayRequestReplicatedStorage (o MenuService cria, então não adicione um à mão)Leva uma única mensagem ao servidor: este jogador apertou Play. Não leva nenhum valor.
Part MenuCameraWorkspace (você coloca)Onde a câmera do menu fica e para onde ela olha.
CharacterAutoLoadsUma propriedade do serviço PlayersDesligada, para ninguém nascer até o servidor chamar LoadCharacterAsync.
O Explorer quando o menu está pronto. O PlayRequest aparece quando o jogo roda: o MenuService cria ele, então não adicione à mão.
Workspace
  MenuCamera Part new
ReplicatedStorage
  PlayRequest RemoteEvent new
ServerScriptService
  MenuService Script new
StarterPlayer
  StarterPlayerScripts
    MainMenu LocalScript new

Passo 1: Desligue o nascimento automático e coloque a câmera do menu

  1. No Explorer, selecione Players. Na janela Properties, desmarque CharacterAutoLoads. O MenuService também desliga, mas a caixa garante que ninguém nasça no instante antes de o script rodar.
  2. Passe o mouse sobre Workspace, clique no botão + e insira uma Part. Renomeie para MenuCamera (os nomes diferenciam maiúsculas e minúsculas) e deixe ela direto no Workspace, não dentro de uma pasta ou de um model.
  3. Nas Properties dela, marque Anchored, desmarque CanCollide e defina Transparency como 1. Ancorar importa: uma part não ancorada que não colide com nada cai através do mapa, e o Roblox remove parts que caem abaixo de Workspace.FallenPartsDestroyHeight.
  4. Mova e gire a part para a face da frente apontar para a vista que você quer. A câmera pega a posição da part e olha para o mesmo lado que a face da frente.

O jeito mais rápido de mirar: voe com a câmera do Studio até a cena que você quer, abra a Command Bar (na aba Script, ou Window, depois Script) e rode workspace.MenuCamera.CFrame = workspace.CurrentCamera.CFrame. No modo de edição, CurrentCamera é a vista pela qual você está olhando, então a part pula exatamente para essa cena.

Deixe o Workspace.StreamingEnabled como está. Places novos vêm com o instance streaming ligado, e os scripts abaixo foram feitos para ele.

Passo 2: Crie os jogadores quando eles apertam Play

Passe o mouse sobre ServerScriptService, insira um Script, chame de MenuService e cole isto:

Script em ServerScriptService chamado MenuService
-- Script no ServerScriptService chamado MenuService.
-- Os jogadores entram sem personagem. O servidor cria um quando o botão Play do menu
-- pede, e faz os jogadores renascerem depois de morrer, já que o nascimento automático está desligado.

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

-- Desmarque também o CharacterAutoLoads no serviço Players na janela Properties,
-- para ninguém nascer no instante antes de este script rodar.
Players.CharacterAutoLoads = false

-- Este script cria o PlayRequest sozinho, então não adicione um ao ReplicatedStorage à mão
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 -- um segundo clique no Play enquanto o primeiro personagem ainda carrega
	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}`)
		-- Um renascimento que falha deixaria um jogador morto travado, então tenta de novo depois de uma espera curta.
		-- O primeiro nascimento que falha não precisa de nova tentativa: o botão do menu diz 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 as conexões do personagem antigo
	end
end

-- Só um jogador ainda no menu (sem personagem) pode pedir para nascer. Um jogador
-- morto ainda tem personagem, então não consegue usar isto para pular a espera do renascimento.
playRequest.OnServerEvent:Connect(function(player: Player)
	if player.Character == nil then
		spawnCharacter(player)
	end
end)

-- Com o CharacterAutoLoads desligado, nada faz os jogadores renascerem depois de morrer, então faça aqui
local function onCharacterAdded(player: Player, character: Model)
	local respawning = false
	local function respawnLater()
		if respawning then
			return
		end
		respawning = true
		task.wait(Players.RespawnTime)
		-- Renasce só se o jogador ainda está aqui e nada criou um personagem para ele desde então
		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)
	-- Cair do mapa pode tirar o personagem do Workspace, e o Died só dispara
	-- enquanto o Humanoid está no Workspace, então isto pega esse caso também
	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)

	-- Com o streaming ligado, o mapa carrega em volta do personagem do jogador, e um jogador no
	-- menu ainda não tem um. Adiciona um foco de replicação na câmera do menu até ele nascer.
	local menuCamera = workspace:FindFirstChild("MenuCamera")
	if menuCamera and menuCamera:IsA("BasePart") then
		player:AddReplicationFocus(menuCamera)
		player.CharacterAdded:Once(function()
			player:RemoveReplicationFocus(menuCamera) -- daqui em diante o personagem é o foco
		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)

O PlayRequest não leva nenhum valor. O Roblox passa o jogador que disparou como primeiro argumento do OnServerEvent, e é só isso que o servidor precisa saber.

Quem pode nascer

O handler do PlayRequest cria um personagem só se player.Character for nil, que é o caso de um jogador ainda no menu. Um jogador que morreu continua com o personagem até o MenuService fazer ele renascer, então não consegue usar o remote para pular a espera.

A tabela spawning impede que um segundo pedido comece um segundo nascimento enquanto o primeiro ainda carrega. O LoadCharacterAsync espera até o personagem carregar, e a referência da Roblox desaconselha chamá-lo de novo para o mesmo jogador antes de o evento CharacterAppearanceLoaded dele disparar. Cada chamada roda dentro de um pcall, então um nascimento que falha, por exemplo porque o jogador saiu enquanto carregava, imprime um aviso com o nome do jogador em vez de um erro. Se um renascimento falha, o MenuService espera RespawnTime e tenta de novo, então um renascimento que falha não deixa um jogador morto travado. Um primeiro nascimento que falha não é repetido pelo servidor: o botão do menu diz Try again, e o jogador pode apertar.

Renascer depois de uma morte ou de uma queda

Com o CharacterAutoLoads desligado, o Roblox não faz ninguém renascer. O Players.RespawnTime (5 segundos por padrão) só vale sozinho enquanto o CharacterAutoLoads está ligado, então o MenuService lê esse valor, espera por conta própria e chama LoadCharacterAsync de novo. O novo personagem aparece em um SpawnLocation como sempre, e o script destrói o antigo, o que também desconecta as conexões daquele personagem.

Cair do mapa precisa de uma segunda checagem. O Roblox remove parts que caem abaixo de Workspace.FallenPartsDestroyHeight, e remove também um model quando a última part dele some, então um personagem que caiu pode sair do Workspace, e o Humanoid.Died só dispara enquanto o Humanoid está no Workspace. Por isso o MenuService também faz renascer um personagem que saiu do Workspace (AncestryChanged), e a flag respawning garante que cada personagem cause no máximo um renascimento. Depois da espera, ele faz o jogador renascer só se ele ainda está no jogo e player.Character ainda é aquele personagem ou é nil, então um jogador que nasceu de outro jeito nesse meio tempo não nasce duas vezes.

Streaming e a câmera do menu

Com o instance streaming ligado, cada cliente recebe as parts em volta do foco de replicação dele, que por padrão é a PrimaryPart do personagem. Um jogador no menu não tem personagem, e a página de técnicas de streaming da Roblox avisa que um cliente cujo personagem não nasceu não tem foco de replicação, então o mapa pode nunca carregar. A solução que essa página dá é Player:AddReplicationFocus(), que o MenuService chama com a part MenuCamera quando o jogador entra (a Roblox diz para chamar só no servidor). Quando o personagem nasce pela primeira vez, o MenuService chama RemoveReplicationFocus, para o personagem voltar a ser o único foco: cada foco extra dá mais trabalho de streaming para o servidor. O Passo 5 inclui um teste com streaming ligado para confirmar que o mapa aparece atrás do menu.

O que o servidor decide e o que um trapaceiro consegue fazer

Um trapaceiro pode rodar o próprio código no dispositivo dele. Ele pode disparar o PlayRequest quando quiser, com qualquer valor, e mudar qualquer coisa na própria tela. Veja o que cada uma dessas coisas dá a ele.

O que um trapaceiro pode tentar com o menu
Um trapaceiroO que acontece
Dispara o PlayRequest sem apertar PlayEle nasce, exatamente como se tivesse apertado Play. Pular um menu não dá vantagem nenhuma.
Dispara o PlayRequest centenas de vezesUm nascimento. Enquanto carrega, a flag spawning ignora o resto; depois disso, ele tem personagem, então todo pedido é recusado com uma única checagem. É por isso que este remote não precisa de limite de frequência.
Dispara o PlayRequest morto, para renascer antesRecusado. Um jogador morto continua com o personagem até o MenuService fazer ele renascer.
Manda valores extras com o PlayRequestIgnorados. O handler nunca lê esses valores.
Apaga o menu ou move a própria câmeraSó a tela dele muda. Ele continua sem personagem até o servidor criar um.

Dito de forma direta: o menu é uma tela, não uma tranca. Ele decide quando um jogador nasce e mais nada. Se um botão do menu algum dia der alguma coisa, como uma skin, uma porta VIP ou moedas, um Script de servidor precisa conferir isso, do jeito que o guia de loja confere cada compra. O guia de RemoteEvents mostra como conferir o que um remote recebe.

Passo 4: Deixe com a cara do seu jogo

Os scripts desenham um menu simples de propósito, para a lógica ficar fácil de seguir. Tudo abaixo muda a parte de GUI do MainMenu; deixe o código da câmera e do Play como está.

  • Uma logo no lugar do texto do título. Envie a imagem da sua logo no Studio ou no Creator Hub e troque o TextLabel do título por um ImageLabel cuja Image seja rbxassetid:// seguido do asset id da imagem. Dê a ele BackgroundTransparency 1 e ScaleType Fit para ele manter o formato.
  • Um fundo desfocado. Crie um BlurEffect no MainMenu e coloque o parent dele em workspace.CurrentCamera. A Roblox sugere isso para menus: um efeito dentro da câmera aparece só para aquele jogador. O Size dele é o raio do desfoque em pixels. Destrua ele no handler do Play, ao lado de gui:Destroy().
  • Cor. Adicione um UIGradient ao botão, ou um UIStroke para um contorno. Mantenha o texto com TextScaled para ele caber em telas pequenas.
  • Mais botões. Coloque os botões em um Frame com um UIListLayout e um pouco de Padding, e dê a cada um um handler de Activated e o próprio UISizeConstraint. Um botão de Settings ou Help pode abrir um painel só no cliente. Um botão de Shop pode abrir a janela do guia de loja, cujas compras continuam acontecendo no servidor.

Passo 5: Teste

  1. Abra a janela Output (menu Window, depois Output) e aperte Play. A tela clareia no seu título e no botão Play sobre a cena da MenuCamera, e a lista de jogadores e a mochila ficam escondidas. No Explorer, o Workspace não tem nenhum model com o seu nome: você ainda não tem personagem.
  2. Aperte o botão Play. Ele diz "Loading...", a tela escurece e depois clareia atrás do seu personagem com a câmera normal, e a lista de jogadores volta. Em Players, o seu nome, PlayerGui, não sobra nenhum MainMenu nem MenuFade.
  3. Resete o seu personagem pelo menu do jogo. Você renasce depois de uns 5 segundos, e o menu não volta.
  4. Ande ou pule para fora da borda do mapa. Quando o seu personagem tiver caído para fora do mundo, você renasce uns 5 segundos depois.
  5. Confira uma tela de celular com o Device Simulator do Studio (um beta no momento em que este guia foi escrito: ligue New Device Simulator em File, Beta Features, e reinicie o Studio). Em um celular pequeno o botão Play continua com pelo menos 160 por 56 pixels e dá para tocar nele.
  6. Confira um controle com o Controller Emulator (Controller, na aba Emulation) durante um teste. Aperte um botão no controle emulado: o Play fica selecionado, e apertar A começa o jogo. Se o Play não estiver selecionado, aperte o botão Select do controle, que seleciona um botão enquanto GuiService.AutoSelectGuiEnabled está ligado, e depois A.
  7. Com o instance streaming ligado, como vem nos places novos, confira se o mapa em volta da MenuCamera aparece atrás do menu, e não só o céu.

O Output não deve mostrar nenhum erro vermelho do MenuService ou do MainMenu em nenhum momento. Se algo não bater, veja Erros comuns.

Usando o menu com outros sistemas

Desligar o CharacterAutoLoads muda as coisas para todos os outros scripts do jogo. Se você seguiu outros guias deste site, confira estes.

O menu junto de outros sistemas
SistemaO que mudaO que fazer
Sistema de roundsJogadores ainda no menu contam para o MIN_PLAYERS, porque o round conta todo mundo no servidor, mas nunca são teleportados: o startRound só pega jogadores com um personagem vivo. Jogadores eliminados renascem pelo MenuService em vez de pelo Roblox.Nada é obrigatório. Se jogadores no menu impedem um round de começar ("Not enough players, starting over"), conte no runIntermission só os jogadores cujo Character não é nil.
Checkpoints de obby (em inglês)O ObbyCheckpoints também desliga o CharacterAutoLoads, e cria cada jogador assim que o estágio dele carrega. Com os dois scripts, os jogadores nascem no checkpoint atrás do menu, e o Play só remove o menu.Use um único spawner. Mantenha o ObbyCheckpoints e apague o MenuService. No ObbyCheckpoints, apague a linha spawnAtStage(player) no fim do onPlayerAdded. Depois, no nível de cima do script, logo acima de Players.PlayerAdded:Connect(onPlayerAdded) e não dentro do onPlayerAdded, copie a linha do ReplicatedStorage do MenuService e as linhas que criam o PlayRequest, e conecte o handler de OnServerEvent dele. No handler, chame spawnAtStage(player) só quando player.Character for nil, stageValues[player] existir e nenhum nascimento já estiver rodando para aquele jogador (uma tabela como a spawning do MenuService). Um jogador que aperta Play antes de o estágio dele carregar vê Try again e pode apertar de novo. Os renascimentos dele continuam como estão. Se o seu place usa streaming, copie também as linhas da MenuCamera do MenuService (AddReplicationFocus e RemoveReplicationFocus) para o começo do onPlayerAdded.
Scripts de leaderboard e de DataStoreEles rodam quando o jogador entra, enquanto ele está no menu.Nada. Os dados do jogador começam a carregar enquanto ele olha o menu.
GUI de lojaO ShopClient monta a janela dele assim que o jogador entra, então o botão Shop dele ficaria ao lado do menu.No ShopClient, adicione if not player.Character then player.CharacterAdded:Wait() end logo antes da linha gui.Parent = player:WaitForChild("PlayerGui"), para a loja aparecer depois do Play.
Cutscene de introduçãoO CutsceneService toca a introdução no primeiro nascimento do jogador, que com o menu é o primeiro nascimento depois do Play. O menu liga de novo as core GUIs quando o personagem aparece, então a lista de jogadores pode aparecer durante a introdução.Nada é obrigatório. A cutscene liga de novo só as core GUIs que ela mesma escondeu, então elas continuam ligadas depois da introdução.
ScreenGuis no StarterGuiEles só são copiados para o jogador quando o personagem nasce.Nada. Eles aparecem depois do Play, que normalmente é o que você quer para um HUD.

A divisão entre scripts no StarterPlayerScripts e no StarterGui é explicada em Script vs LocalScript vs ModuleScript (em inglês).

Por que scripts de menu copiados quebram

Colocar o botão na tela é a parte fácil. O problema começa depois do Play. Estes são os padrões que causam isso, e o que este guia faz no lugar.

Padrões comuns de menu e os problemas deles
PadrãoProblemaEste guia
MouseButton1Click no botão PlayA Roblox documenta esse evento para um clique com o botão esquerdo do mouse. Activated é o evento documentado para clique, toque e botão de controle.Activated, com o Play selecionado para controles
Um ScreenGui de menu no StarterGui com ResetOnSpawn ligadoO Roblox dá ao jogador uma cópia nova a cada nascimento, então o menu volta depois de cada morteResetOnSpawn desligado, e o menu é destruído depois do Play
O personagem criado e congelado atrás do menu, por exemplo com WalkSpeed 0O personagem está no mundo: os outros podem vê-lo, empurrá-lo e atacá-loNenhum personagem até o Play
player:LoadCharacter()A Roblox marca ele como substituído por LoadCharacterAsyncLoadCharacterAsync dentro de um pcall
A câmera deixada em Scriptable depois do PlayA câmera fica presa na cena do menuDesligar a função da câmera, definir CameraType como Custom e CameraSubject como o Humanoid
workspace.MenuPart lido na horaCom o streaming ligado, a part pode ainda não ter chegado ao cliente, então o script dá erroUm foco de replicação na MenuCamera adicionado no servidor, e WaitForChild com limite de 5 segundos e uma vista reserva
Loops repeat wait() until para a câmeraA Roblox marca wait() como obsoleto, substituído por task.wait()BindToRenderStep para a câmera, task.wait no resto
Renascer só no Humanoid.DiedCom o CharacterAutoLoads desligado, um jogador que cai do mapa pode nunca renascer: a queda pode tirar o personagem do Workspace, e o Died só dispara no WorkspaceRenascer também quando o personagem sai do Workspace
Um menu de free modelA Roblox avisa que models da Creator Store podem ter scripts de backdoorDois scripts curtos que você consegue ler linha por linha

Erros comuns e como resolver

Abra a janela Output (menu Window, depois Output) antes de apertar Play. A maioria dos problemas de menu imprime um aviso ou um erro ali, com o nome do script e a linha.

A câmera fica na cena do menu depois do Play

O MainMenu não chegou ao passo que devolve a câmera, ou outro script mudou a câmera depois. Procure no Output um erro vermelho do MainMenu. Se um dos seus próprios scripts também define CameraType, confira se ele não define Scriptable quando o jogador já está no jogo.

O botão diz "Loading..." e depois "Try again"

O MainMenu achou o PlayRequest, então o MenuService está rodando, mas nenhum personagem com Humanoid chegou em 15 segundos. Se você mesmo adicionou um PlayRequest ao ReplicatedStorage, apague: o MenuService cria o dele, e com dois do mesmo nome o botão pode disparar um enquanto o servidor escuta o outro. Depois procure no Output MenuService: could not spawn seguido do motivo. Se você usa um StarterCharacter personalizado, o Humanoid dele precisa se chamar Humanoid, porque os dois scripts esperam um filho com esse nome. Se o nascimento só estava lento, apertar Try again termina ele.

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

O MainMenu está esperando o RemoteEvent que o MenuService cria, então o MenuService não está rodando: está desativado, no lugar errado ou parado por um erro. O guia de erros de script explica esse aviso.

O meu personagem nasce atrás do menu

Outra coisa está criando os jogadores. Desmarque o CharacterAutoLoads no serviço Players e procure outro script que chame LoadCharacterAsync quando o jogador entra, como um script de checkpoints de obby: veja Usando o menu com outros sistemas.

O menu mostra só o céu

A câmera está usando a vista reserva, ou o mapa não carregou pelo streaming. Confira se a part se chama exatamente MenuCamera, fica direto no Workspace (não em uma pasta ou model), está ancorada e se a face da frente dela aponta para o mapa.

Depois de morrer eu nunca renasço

Agora o MenuService é a única coisa que faz os jogadores renascerem, então procure um erro dele no Output. Um renascimento que falha imprime MenuService: could not spawn e é tentado de novo depois do RespawnTime. Se o seu jogo desliga o estado Dead do Humanoid, o Died nunca dispara, então faça o jogador renascer a partir do seu próprio código de morte.

O meu HUD do StarterGui só aparece depois do Play

Isso é esperado. Com o CharacterAutoLoads desligado, o Roblox copia o StarterGui para o PlayerGui do jogador só quando o personagem nasce. Para algo que precisa aparecer no menu, monte a partir de um LocalScript no StarterPlayerScripts, como o MainMenu faz.

Crie com o RoCode

Se você prefere não montar isso à mão, o RoCode pode construir tudo no place que você tem aberto. O RoCode é um agente de IA independente para Roblox Studio, não feito pela Roblox: você descreve o recurso no chat dele na web, e o plugin dele para o Studio cria a part e os scripts no seu Explorer, então você não fica copiando código de uma janela de chat.

Você digita

Adicione um menu principal: os jogadores não devem nascer até apertarem Play. Mostre o título do meu jogo e um botão Play sobre uma cena lenta de câmera a partir de uma part chamada MenuCamera, escureça a tela, crie o jogador pelo servidor e devolva a câmera normal. Precisa funcionar no celular e com controle.

O RoCode faz
  • Pode olhar o seu place antes com Search Scripts, por exemplo atrás de um script que já desliga o CharacterAutoLoads ou faz os jogadores renascerem (um script de checkpoints de obby faz isso), para os dois não brigarem
  • Cria a part MenuCamera com Create Instance e desliga o Players.CharacterAutoLoads com Set Property
  • Escreve o MenuService e o MainMenu com Create Script
  • É instruído a checar cada script que escreve com Check Script, que compila o script dentro do Studio sem rodá-lo, e cria um ponto de desfazer antes e depois de cada lote de mudanças

O RoCode não consegue enviar uma imagem de logo ou uma música de menu por você: envie no Studio ou no Creator Hub e passe os asset ids para o RoCode. Com o plugin 3.9 ou mais recente, o RoCode pode rodar um teste curto e ler os erros, e com o plugin 3.9.15 ou mais recente o personagem de teste dele pode clicar em botões na tela, mas ele confere só o que escolheu testar, então clique pelo menu você mesmo. Para a ordem de montar um jogo inteiro, veja fazer um jogo de Roblox com IA, sistema por sistema. Como o RoCode se conecta ao Studio.

Perguntas frequentes

Como fazer o jogador não nascer até apertar Play no Roblox?

Desmarque o CharacterAutoLoads no serviço Players e depois crie o jogador a partir de um Script de servidor com player:LoadCharacterAsync() quando o RemoteEvent do botão Play chegar. Os renascimentos depois de uma morte passam a precisar da mesma chamada, que o MenuService faz.

Por que o meu menu principal volta toda vez que eu morro?

O ScreenGui dele está com ResetOnSpawn ligado, então o Roblox dá ao jogador uma cópia nova a cada nascimento. Desligue e remova o menu depois do Play, como faz o MainMenu.

Como fazer a câmera mostrar o meu mapa atrás do menu?

Em um LocalScript, defina workspace.CurrentCamera.CameraType como Scriptable e coloque o CFrame da câmera igual ao de uma part que você posicionou. Depois do Play, volte para Custom e defina o Humanoid como CameraSubject.

Como colocar uma tela de carregamento antes do menu?

O guia de telas de carregamento da Roblox usa um LocalScript no ReplicatedFirst, que chega ao jogador antes de tudo. Ele monta um ScreenGui, chama ReplicatedFirst:RemoveDefaultLoadingScreen(), espera até game:IsLoaded() e depois remove a tela. Dê a esse ScreenGui um DisplayOrder acima de 11 para ele cobrir este menu até sair. O nosso guia de tela de carregamento monta uma com barra de progresso e botão Skip, e o DisplayOrder de 100 dela já cobre o menu.

Como colocar música no menu principal?

Use um áudio que você tem permissão para usar, como uma faixa grátis da Creator Store ou um áudio que você mesmo enviou. Coloque um Sound com esse id no SoundService, marque Looped, chame :Play() nele a partir do MainMenu quando o menu aparecer e :Stop() no handler do Play. Um som tocado por um LocalScript é ouvido só por aquele jogador enquanto SoundService.RespectFilteringEnabled estiver ligado, que é o padrão.

Posso usar um menu principal de free model?

Pode, mas leia os scripts dele antes. A Roblox avisa que models da Creator Store podem ter scripts de backdoor que dão aos criadores deles acesso ao seu jogo. Um menu só precisa dos dois scripts curtos deste guia.

Fontes e leitura extra

Como o código foi verificado: todo script desta página passa no verificador de tipos estrito do Luau com as definições da API do Roblox (luau-lsp, 14 de novembro de 2026). A verificação de tipos pega APIs com nome errado e tipos incorretos, não a lógica do jogo, então teste no Studio antes de publicar.

Teste o RoCode no seu próprio jogo.

Créditos grátis todo dia, sem cartão. Instale o plugin, descreva o recurso e confira o que aparece no Studio.