Tutoriel · Systèmes de jeu

Comment faire un menu principal sur Roblox Studio

Un menu principal sur Roblox Studio, qu'on appelle aussi menu de démarrage ou écran titre, est un ScreenGui avec un bouton Play. Ce qui lui donne l'air fini se trouve ailleurs : les joueurs ne doivent pas apparaître avant d'appuyer sur Play, la caméra doit montrer ta map puis revenir au personnage, et le menu ne doit jamais réapparaître après une mort. Ce guide construit tout ça avec deux scripts, écrits pour la souris, le tactile et la manette.

Mis à jour le 14 novembre 202621 min de lectureÉcrit par

En bref

Désactive CharacterAutoLoads sur le service Players pour que personne n'apparaisse en arrivant. Un LocalScript dans StarterPlayerScripts construit le menu (un titre, un bouton Play et un Frame noir pour les fondus) dans des ScreenGuis avec ResetOnSpawn désactivé, pointe la caméra vers une part nommée MenuCamera avec CameraType sur Scriptable, et déclenche un RemoteEvent quand on appuie sur Play. Un Script dans ServerScriptService répond avec Player:LoadCharacterAsync(), puis le LocalScript rend la caméra (CameraType sur Custom, CameraSubject sur le Humanoid) et retire le menu.

  • Utilise Activated, pas MouseButton1Click, pour que Play marche avec un clic, un toucher et une manette, et sélectionne le bouton pour les joueurs à la manette pour qu'ils puissent appuyer dessus.
  • Avec CharacterAutoLoads désactivé, StarterGui n'est copié dans le PlayerGui d'un joueur que quand son personnage apparaît, donc c'est un LocalScript dans StarterPlayerScripts qui construit le menu.
  • Avec CharacterAutoLoads désactivé, Roblox arrête aussi de faire réapparaître les joueurs, donc le script serveur les fait réapparaître après une mort ou une chute hors de la map, en attendant Players.RespawnTime (5 secondes par défaut).
Sur cette page
  1. Fonctionnement
  2. 1. Préparation
  3. 2. Script serveur
  4. 3. Script du menu
  5. Ce que décide le serveur
  6. 4. Design
  7. 5. Tester
  8. Avec d'autres systèmes
  9. Pourquoi les menus copiés cassent
  10. Problèmes courants
  11. Avec RoCode
  12. Questions fréquentes
  13. Sources et lectures

Comment marche un menu principal

Illustration animéeLe menu terminé dans un jeu en cours, avec l'attente du serveur accélérée : Play fait un fondu au noir, le serveur fait apparaître le personnage et la caméra revient sur lui.

Un menu a deux côtés. L'appareil du joueur dessine le titre et le bouton, et déplace la caméra. Le serveur décide quand un personnage existe. Le menu lui-même n'est qu'une image sur un seul écran : le vrai changement a lieu quand le serveur fait apparaître le personnage, et seul le serveur peut le faire.

Les éléments du menu
ÉlémentOù il se trouveCe qu'il fait
Le Script MenuServiceServerScriptServiceDésactive l'apparition automatique, crée PlayRequest, fait apparaître un joueur qui appuie sur Play, et fait réapparaître les joueurs après une mort ou une chute.
Le LocalScript MainMenuStarterPlayerScriptsConstruit le titre, le bouton Play et le fondu, fait tourner le plan de caméra, demande un personnage au serveur et rend la caméra.
Le RemoteEvent PlayRequestReplicatedStorage (MenuService le crée, donc n'en ajoute pas à la main)Porte un seul message au serveur : ce joueur a appuyé sur Play. Il ne porte aucune valeur.
La Part MenuCameraWorkspace (c'est toi qui la places)L'endroit où se trouve la caméra du menu et la direction dans laquelle elle regarde.
CharacterAutoLoadsUne propriété du service PlayersDésactivée, pour que personne n'apparaisse avant que le serveur appelle LoadCharacterAsync.
L'Explorer une fois le menu terminé. PlayRequest apparaît quand le jeu tourne : MenuService le crée, donc ne l'ajoute pas à la main.
Workspace
  MenuCamera Part new
ReplicatedStorage
  PlayRequest RemoteEvent new
ServerScriptService
  MenuService Script new
StarterPlayer
  StarterPlayerScripts
    MainMenu LocalScript new

Étape 1 : désactiver l'apparition automatique et placer la caméra du menu

  1. Dans l'Explorer, sélectionne Players. Dans la fenêtre Properties, décoche CharacterAutoLoads. MenuService la désactive aussi, mais la case garantit que personne n'apparaît dans l'instant avant que le script tourne.
  2. Survole Workspace, clique sur le bouton + et insère une Part. Renomme-la MenuCamera (les noms tiennent compte des majuscules) et laisse-la directement dans Workspace, pas dans un dossier ni dans un modèle.
  3. Dans ses Properties, coche Anchored, décoche CanCollide et règle Transparency sur 1. L'ancrage compte : une part non ancrée qui n'entre en collision avec rien tombe à travers la map, et Roblox supprime les parts qui tombent sous Workspace.FallenPartsDestroyHeight.
  4. Déplace et tourne la part pour que sa face avant pointe vers la vue que tu veux. La caméra prend la position de la part et regarde dans la même direction que sa face avant.

Le moyen le plus rapide de la viser : déplace la caméra de Studio jusqu'au plan que tu veux, ouvre la Command Bar (dans l'onglet Script, ou Window, puis Script) et lance workspace.MenuCamera.CFrame = workspace.CurrentCamera.CFrame. En mode édition, CurrentCamera est la vue à travers laquelle tu regardes, donc la part saute exactement sur ce plan.

Laisse Workspace.StreamingEnabled tel quel. Les nouveaux jeux ont l'instance streaming activé, et les scripts ci-dessous sont écrits pour ça.

Étape 2 : faire apparaître les joueurs quand ils appuient sur Play

Survole ServerScriptService, insère un Script, nomme-le MenuService et colle ce code :

Script dans ServerScriptService nommé MenuService
-- Script dans ServerScriptService nommé MenuService.
-- Les joueurs arrivent sans personnage. Le serveur en fait apparaître un quand le bouton Play
-- du menu le demande, et fait réapparaître les joueurs après leur mort, puisque l'apparition automatique est coupée.

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

-- Décoche aussi CharacterAutoLoads sur le service Players dans la fenêtre Properties,
-- pour que personne n'apparaisse dans l'instant avant que ce script tourne.
Players.CharacterAutoLoads = false

-- Ce script crée PlayRequest lui-même, donc n'en ajoute pas un à la main dans 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 deuxième clic sur Play pendant que la première apparition charge encore
	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}`)
		-- Une réapparition ratée laisserait un joueur mort bloqué, donc on réessaie après une courte attente.
		-- Une première apparition ratée n'a pas besoin de nouvel essai : le bouton du menu affiche 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() -- libère les connexions de l'ancien personnage
	end
end

-- Seul un joueur encore dans le menu (pas encore de personnage) peut demander à apparaître. Un joueur
-- mort a encore un personnage, donc il ne peut pas s'en servir pour sauter l'attente de réapparition.
playRequest.OnServerEvent:Connect(function(player: Player)
	if player.Character == nil then
		spawnCharacter(player)
	end
end)

-- Avec CharacterAutoLoads coupé, rien ne fait réapparaître les joueurs après leur mort, donc on le fait ici
local function onCharacterAdded(player: Player, character: Model)
	local respawning = false
	local function respawnLater()
		if respawning then
			return
		end
		respawning = true
		task.wait(Players.RespawnTime)
		-- Réapparition seulement s'ils sont encore là et que rien ne les a fait apparaître depuis
		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)
	-- Tomber de la map peut retirer le personnage de Workspace, et Died ne se déclenche
	-- que pendant que le Humanoid est dans Workspace, donc ceci couvre aussi ce cas
	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)

	-- Avec le streaming activé, la map arrive autour du personnage du joueur, et un joueur dans
	-- le menu n'en a pas encore. Ajoute un focus de réplication à la caméra du menu jusqu'à son apparition.
	local menuCamera = workspace:FindFirstChild("MenuCamera")
	if menuCamera and menuCamera:IsA("BasePart") then
		player:AddReplicationFocus(menuCamera)
		player.CharacterAdded:Once(function()
			player:RemoveReplicationFocus(menuCamera) -- à partir de maintenant, le personnage est le focus
		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 ne porte aucune valeur. Roblox passe le joueur qui l'a déclenché comme premier argument de OnServerEvent, et c'est tout ce dont le serveur a besoin.

Qui peut apparaître

Le gestionnaire de PlayRequest ne fait apparaître un joueur que si player.Character vaut nil, ce qui est le cas d'un joueur encore dans le menu. Un joueur mort garde son personnage jusqu'à ce que MenuService le fasse réapparaître, donc il ne peut pas se servir du remote pour sauter l'attente.

La table spawning empêche une deuxième demande de lancer une deuxième apparition pendant que la première charge encore. LoadCharacterAsync attend que le personnage soit chargé, et la référence de Roblox déconseille de l'appeler à nouveau pour le même joueur avant que son événement CharacterAppearanceLoaded se soit déclenché. Chaque appel tourne dans un pcall, donc une apparition qui échoue, par exemple parce que le joueur est parti pendant le chargement, affiche un avertissement avec le nom du joueur au lieu d'une erreur. Si une réapparition échoue, MenuService attend RespawnTime et réessaie, pour qu'une réapparition ratée ne laisse pas un joueur mort bloqué. Une première apparition ratée n'est pas relancée par le serveur : le bouton du menu affiche Try again, et le joueur peut appuyer dessus.

Réapparaître après une mort ou une chute

Avec CharacterAutoLoads désactivé, Roblox ne fait réapparaître personne. Players.RespawnTime (5 secondes par défaut) ne s'applique tout seul que quand CharacterAutoLoads est activé, donc MenuService lit cette valeur, attend lui-même et rappelle LoadCharacterAsync. Le nouveau personnage apparaît sur une SpawnLocation comme d'habitude, et le script détruit l'ancien, ce qui déconnecte aussi les connexions de ce personnage.

La chute hors de la map demande une deuxième vérification. Roblox supprime les parts qui tombent sous Workspace.FallenPartsDestroyHeight, et supprime aussi un modèle une fois que sa dernière part a disparu, donc un personnage tombé peut quitter Workspace, et Humanoid.Died ne se déclenche que pendant que le Humanoid est dans Workspace. MenuService fait donc aussi réapparaître un personnage qui a quitté Workspace (AncestryChanged), et le flag respawning garantit que chaque personnage cause au plus une réapparition. Après l'attente, il ne fait réapparaître le joueur que s'il est encore dans le jeu et que player.Character est encore ce personnage ou vaut nil, pour qu'un joueur qu'autre chose a fait apparaître entre-temps n'apparaisse pas deux fois.

Le streaming et la caméra du menu

Avec l'instance streaming activé, chaque client reçoit les parts autour de son focus de réplication, qui est par défaut la PrimaryPart de son personnage. Un joueur dans le menu n'a pas de personnage, et la page de Roblox sur les techniques de streaming prévient qu'un client dont le personnage n'est pas encore apparu n'a pas de focus de réplication, donc la map risque de ne jamais arriver. La solution que donne cette page est Player:AddReplicationFocus(), que MenuService appelle avec la part MenuCamera quand le joueur arrive (Roblox dit de ne l'appeler que sur le serveur). Quand le personnage apparaît pour la première fois, MenuService appelle RemoveReplicationFocus, pour que le personnage redevienne le seul focus : chaque focus en plus ajoute du travail de streaming au serveur. L'étape 5 inclut un test avec le streaming activé pour vérifier que la map s'affiche derrière le menu.

Ce que le serveur décide, et ce qu'un tricheur peut faire

Un tricheur peut lancer son propre code sur son appareil. Il peut déclencher PlayRequest quand il veut, avec n'importe quelles valeurs, et changer n'importe quoi sur son propre écran. Voici ce que chacune de ces choses lui apporte.

Ce qu'un tricheur peut tenter avec le menu
Un tricheurCe qui se passe
Déclenche PlayRequest sans appuyer sur PlayIl apparaît, exactement comme s'il avait appuyé sur Play. Sauter un menu ne rapporte rien.
Déclenche PlayRequest des centaines de foisUne seule apparition. Pendant qu'elle charge, le flag spawning ignore le reste ; après, il a un personnage, donc chaque demande est refusée avec une seule vérification. C'est pour ça que ce remote n'a pas besoin de limite de fréquence.
Déclenche PlayRequest pendant qu'il est mort, pour réapparaître plus tôtRefusé. Un joueur mort garde son personnage jusqu'à ce que MenuService le fasse réapparaître.
Envoie des valeurs en plus avec PlayRequestIgnorées. Le gestionnaire ne les lit jamais.
Supprime le menu ou bouge sa propre caméraSeul son propre écran change. Il n'a toujours pas de personnage tant que le serveur n'en fait pas apparaître un.

Pour le dire simplement : le menu est un écran, pas un verrou. Il décide quand un joueur apparaît et rien d'autre. Si un bouton du menu donne un jour quelque chose, comme un skin, une porte VIP ou des pièces, un Script serveur doit le vérifier, comme le guide de la boutique vérifie chaque achat. Le guide des RemoteEvents explique comment vérifier ce que reçoit un remote.

Étape 4 : l'adapter au style de ton jeu

Les scripts dessinent exprès un menu simple, pour que la logique soit facile à suivre. Tout ce qui suit change la partie GUI de MainMenu ; laisse le code de la caméra et de Play tel quel.

  • Un logo à la place du texte du titre. Importe l'image de ton logo dans Studio ou sur le Creator Hub, puis remplace le TextLabel du titre par une ImageLabel dont l'Image est rbxassetid:// suivi de l'asset id de l'image. Donne-lui BackgroundTransparency 1 et ScaleType Fit pour qu'elle garde sa forme.
  • Un fond flou. Crée un BlurEffect dans MainMenu et mets son parent sur workspace.CurrentCamera. Roblox le suggère pour les menus : un effet sous la caméra ne s'affiche que pour ce joueur. Sa Size est le rayon du flou en pixels. Détruis-le dans le gestionnaire de Play, à côté de gui:Destroy().
  • La couleur. Ajoute un UIGradient au bouton, ou un UIStroke pour un contour. Garde le texte en TextScaled pour qu'il tienne sur les petits écrans.
  • Plus de boutons. Mets les boutons dans un Frame avec un UIListLayout et un peu de Padding, et donne à chacun un gestionnaire Activated et son propre UISizeConstraint. Un bouton Paramètres ou Aide peut ouvrir un panneau côté client seulement. Un bouton Boutique peut ouvrir la fenêtre du guide de la boutique, dont les achats se passent toujours sur le serveur.

Étape 5 : tester

  1. Ouvre la fenêtre Output (menu Window, puis Output) et appuie sur Play. L'écran sort du noir sur ton titre et le bouton Play par-dessus le plan de MenuCamera, et la liste des joueurs et le backpack sont cachés. Dans l'Explorer, Workspace n'a aucun modèle à ton nom : tu n'as pas encore de personnage.
  2. Appuie sur le bouton Play. Il affiche "Loading...", l'écran fond au noir, puis revient derrière ton personnage avec la caméra normale, et la liste des joueurs revient. Sous Players, ton nom, PlayerGui, il ne reste ni MainMenu ni MenuFade.
  3. Réinitialise ton personnage depuis le menu du jeu. Tu réapparais après environ 5 secondes, et le menu ne revient pas.
  4. Marche ou saute hors du bord de la map. Une fois ton personnage tombé hors du monde, tu réapparais environ 5 secondes plus tard.
  5. Vérifie un écran de téléphone avec le Device Simulator de Studio (une bêta au moment où ce guide est écrit : active New Device Simulator dans File, Beta Features, et redémarre Studio). Sur un petit téléphone, le bouton Play garde au moins 160 sur 56 pixels et reste facile à toucher.
  6. Vérifie une manette avec le Controller Emulator (Controller, dans l'onglet Emulation) pendant un test. Appuie sur un bouton de la manette émulée : Play est sélectionné, et appuyer sur A lance le jeu. Si Play n'est pas sélectionné, appuie sur le bouton Select de la manette, qui sélectionne un bouton tant que GuiService.AutoSelectGuiEnabled est activé, puis sur A.
  7. Avec l'instance streaming activé, comme dans les nouveaux jeux, vérifie que la map autour de MenuCamera s'affiche derrière le menu, et pas seulement le ciel.

Output ne doit afficher aucune erreur rouge de MenuService ou de MainMenu à aucun moment. Si quelque chose ne correspond pas, vois les problèmes courants.

Utiliser le menu avec d'autres systèmes

Désactiver CharacterAutoLoads change des choses pour tous les autres scripts du jeu. Si tu as suivi d'autres guides de ce site, vérifie ces points.

Le menu à côté d'autres systèmes
SystèmeCe qui changeCe qu'il faut faire
Système de manchesLes joueurs encore dans le menu comptent dans MIN_PLAYERS, parce que la manche compte tout le monde sur le serveur, mais ils ne sont jamais téléportés : startRound ne prend que les joueurs avec un personnage en vie. Les joueurs éliminés sont réapparus par MenuService au lieu de Roblox.Rien n'est obligatoire. Si des joueurs dans le menu empêchent une manche de commencer ("Not enough players, starting over"), ne compte dans runIntermission que les joueurs dont le Character ne vaut pas nil.
Checkpoints d'obby (en anglais)ObbyCheckpoints désactive aussi CharacterAutoLoads, et fait apparaître chaque joueur dès que son étape est chargée. Avec les deux scripts, les joueurs apparaissent à leur checkpoint derrière le menu, et Play ne fait que retirer le menu.Garde un seul script d'apparition. Garde ObbyCheckpoints et supprime MenuService. Dans ObbyCheckpoints, supprime la ligne spawnAtStage(player) à la fin de onPlayerAdded. Ensuite, au niveau principal du script, juste au-dessus de Players.PlayerAdded:Connect(onPlayerAdded) et pas dans onPlayerAdded, copie la ligne ReplicatedStorage de MenuService et les lignes qui créent PlayRequest, et connecte son gestionnaire OnServerEvent. Dans le gestionnaire, n'appelle spawnAtStage(player) que si player.Character vaut nil, que stageValues[player] existe et qu'aucune apparition n'est déjà en cours pour ce joueur (une table comme spawning dans MenuService). Un joueur qui appuie sur Play avant que son étape soit chargée voit Try again et peut appuyer de nouveau. Ses réapparitions restent comme elles sont. Si ton jeu utilise le streaming, copie aussi les lignes MenuCamera de MenuService (AddReplicationFocus et RemoveReplicationFocus) au début de onPlayerAdded.
Les scripts de leaderboard et de DataStoreIls tournent à l'arrivée du joueur, pendant qu'il est dans le menu.Rien. Les données du joueur commencent à charger pendant qu'il regarde le menu.
Boutique (Shop GUI)ShopClient construit sa fenêtre dès que le joueur arrive, donc son bouton Shop serait à côté du menu.Dans ShopClient, ajoute if not player.Character then player.CharacterAdded:Wait() end juste avant la ligne gui.Parent = player:WaitForChild("PlayerGui"), pour que la boutique apparaisse après Play.
Cinématique d'introCutsceneService joue son intro à la première apparition d'un joueur, qui avec le menu est la première apparition après Play. Le menu réactive les core GUIs quand le personnage apparaît, donc la liste des joueurs peut s'afficher pendant l'intro.Rien n'est obligatoire. La cinématique ne réactive que les core GUIs qu'elle a cachés elle-même, donc ils restent activés après l'intro.
Les ScreenGuis dans StarterGuiIls ne sont copiés chez le joueur que quand le personnage apparaît.Rien. Ils apparaissent après Play, et c'est en général ce que tu veux pour un HUD.

La séparation entre les scripts de StarterPlayerScripts et ceux de StarterGui est expliquée dans Script vs LocalScript vs ModuleScript (en anglais).

Pourquoi les scripts de menu copiés cassent

Afficher le bouton à l'écran, c'est la partie facile. Les ennuis commencent après Play. Voici les méthodes qui les causent, et ce que ce guide fait à la place.

Méthodes courantes de menu et leurs problèmes
MéthodeProblèmeCe guide
MouseButton1Click sur le bouton PlayRoblox le documente pour un clic gauche de souris. Activated est l'événement documenté pour un clic, un toucher et un bouton de manette.Activated, avec Play sélectionné pour les manettes
Un ScreenGui de menu dans StarterGui avec ResetOnSpawn activéRoblox donne au joueur une nouvelle copie à chaque apparition, donc le menu revient après chaque mortResetOnSpawn désactivé, et le menu détruit après Play
Le personnage apparu et figé derrière le menu, par exemple avec WalkSpeed 0Le personnage est dans le monde : les autres peuvent le voir, le pousser et l'attaquerAucun personnage avant Play
player:LoadCharacter()Roblox le marque comme remplacé par LoadCharacterAsyncLoadCharacterAsync dans un pcall
La caméra laissée sur Scriptable après PlayLa caméra reste bloquée sur le plan du menuDétacher la fonction de caméra, régler CameraType sur Custom et CameraSubject sur le Humanoid
workspace.MenuPart lu tout de suiteAvec le streaming activé, la part n'est peut-être pas encore arrivée chez le client, donc le script planteUn focus de réplication sur MenuCamera ajouté sur le serveur, et WaitForChild avec une limite de 5 secondes et une vue de secours
Des boucles repeat wait() until pour la caméraRoblox marque wait() comme obsolète, remplacé par task.wait()BindToRenderStep pour la caméra, task.wait ailleurs
Réapparition seulement sur Humanoid.DiedAvec CharacterAutoLoads désactivé, un joueur qui tombe de la map risque de ne jamais réapparaître : la chute peut retirer le personnage de Workspace, et Died ne se déclenche que dans WorkspaceRéapparition aussi quand le personnage quitte Workspace
Un menu en free modelRoblox prévient que les modèles du Creator Store peuvent contenir des scripts backdoorDeux scripts courts que tu peux lire ligne par ligne

Problèmes courants

Ouvre la fenêtre Output (menu Window, puis Output) avant d'appuyer sur Play. La plupart des problèmes de menu y affichent un avertissement ou une erreur, avec le nom du script et la ligne.

La caméra reste sur le plan du menu après Play

MainMenu n'est pas arrivé à l'étape qui rend la caméra, ou un autre script a changé la caméra après. Cherche une erreur rouge de MainMenu dans Output. Si un de tes propres scripts règle aussi CameraType, vérifie qu'il ne le met pas sur Scriptable une fois le joueur en jeu.

Le bouton affiche "Loading..." puis "Try again"

MainMenu a trouvé PlayRequest, donc MenuService tourne, mais aucun personnage avec un Humanoid n'est arrivé en 15 secondes. Si tu as ajouté toi-même un PlayRequest dans ReplicatedStorage, supprime-le : MenuService crée le sien, et avec deux objets du même nom, le bouton peut déclencher l'un pendant que le serveur écoute l'autre. Ensuite, cherche dans Output MenuService: could not spawn suivi de la raison. Si tu utilises un StarterCharacter personnalisé, son Humanoid doit s'appeler Humanoid, parce que les deux scripts attendent un enfant avec ce nom. Si l'apparition était seulement lente, appuyer sur Try again la termine.

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

MainMenu attend le RemoteEvent que crée MenuService, donc MenuService ne tourne pas : il est désactivé, au mauvais endroit, ou arrêté par une erreur. Le guide des erreurs de script explique cet avertissement.

Mon personnage apparaît derrière le menu

Autre chose fait apparaître les joueurs. Décoche CharacterAutoLoads sur le service Players, et cherche un autre script qui appelle LoadCharacterAsync à l'arrivée des joueurs, comme un script de checkpoints d'obby : vois Utiliser le menu avec d'autres systèmes.

Le menu ne montre que le ciel

La caméra utilise la vue de secours, ou la map n'est pas arrivée par streaming. Vérifie que la part s'appelle exactement MenuCamera, qu'elle est directement dans Workspace (pas dans un dossier ni un modèle), qu'elle est ancrée, et que sa face avant pointe vers la map.

Après ma mort, je ne réapparais jamais

MenuService est maintenant le seul à faire réapparaître les joueurs, donc cherche une erreur de sa part dans Output. Une réapparition ratée affiche MenuService: could not spawn et est retentée après RespawnTime. Si ton jeu désactive l'état Dead du Humanoid, Died ne se déclenche jamais, donc fais réapparaître le joueur depuis ton propre code de mort.

Mon HUD de StarterGui n'apparaît qu'après Play

C'est normal. Avec CharacterAutoLoads désactivé, Roblox ne copie StarterGui dans le PlayerGui du joueur que quand le personnage apparaît. Pour quelque chose qui doit s'afficher dans le menu, construis-le depuis un LocalScript dans StarterPlayerScripts, comme le fait MainMenu.

Le faire avec RoCode

Si tu préfères ne pas tout câbler à la main, RoCode peut le construire dans le jeu que tu as ouvert. RoCode est un agent IA indépendant pour Roblox Studio, qui n'est pas fait par Roblox : tu décris la fonctionnalité dans son chat web, et son plugin pour Studio crée la part et les scripts dans ton Explorer, donc tu ne copies pas de code depuis une fenêtre de chat.

Tu écris

Ajoute un menu principal : les joueurs ne doivent pas apparaître avant d'appuyer sur Play. Affiche le titre de mon jeu et un bouton Play sur un lent plan de caméra depuis une part nommée MenuCamera, fais un fondu au noir, fais apparaître le joueur depuis le serveur et rends la caméra normale. Ça doit marcher sur téléphone et avec une manette.

RoCode fait
  • Peut d'abord vérifier ton jeu avec Search Scripts, par exemple pour trouver un script qui désactive déjà CharacterAutoLoads ou fait réapparaître les joueurs (un script de checkpoints d'obby le fait), pour que les deux ne se gênent pas
  • Crée la part MenuCamera avec Create Instance et désactive Players.CharacterAutoLoads avec Set Property
  • Écrit MenuService et MainMenu avec Create Script
  • A pour consigne de vérifier chaque script qu'il écrit avec Check Script, qui le compile dans Studio sans le lancer, et place un point d'annulation avant et après chaque lot de changements

RoCode ne peut pas importer d'image de logo ni de musique de menu pour toi : importe-les dans Studio ou sur le Creator Hub et donne les asset ids à RoCode. Avec le plugin 3.9 ou plus récent, RoCode peut lancer un court test et lire les erreurs, et avec le plugin 3.9.15 ou plus récent son personnage de test peut cliquer sur les boutons à l'écran, mais il ne vérifie que ce qu'il a choisi de tester, donc clique toi-même dans le menu. Pour l'ordre dans lequel construire un jeu entier, vois créer un jeu Roblox avec l'IA, système par système. Comment RoCode se connecte à Studio.

Questions fréquentes

Comment faire pour que le joueur n'apparaisse pas avant d'appuyer sur Play ?

Décoche CharacterAutoLoads sur le service Players, puis fais apparaître le joueur depuis un Script serveur avec player:LoadCharacterAsync() quand le RemoteEvent du bouton Play arrive. Les réapparitions après une mort ont alors besoin du même appel, et c'est MenuService qui le fait.

Pourquoi mon menu principal revient à chaque fois que je meurs ?

Son ScreenGui a ResetOnSpawn activé, donc Roblox donne au joueur une nouvelle copie à chaque apparition. Désactive-le et retire le menu après Play, comme le fait MainMenu.

Comment montrer ma map derrière le menu avec la caméra ?

Dans un LocalScript, règle workspace.CurrentCamera.CameraType sur Scriptable et règle le CFrame de la caméra sur celui d'une part que tu as placée. Après Play, remets-le sur Custom et fais du Humanoid le CameraSubject.

Comment ajouter un écran de chargement avant le menu ?

Le guide des écrans de chargement de Roblox utilise un LocalScript dans ReplicatedFirst, qui arrive chez le joueur avant tout le reste. Il construit un ScreenGui, appelle ReplicatedFirst:RemoveDefaultLoadingScreen(), attend que game:IsLoaded() soit vrai puis retire son écran. Donne à ce ScreenGui un DisplayOrder au-dessus de 11 pour qu'il couvre ce menu jusqu'à ce qu'il parte. Notre guide de l'écran de chargement en construit un avec une barre de progression et un bouton Skip, et son DisplayOrder de 100 couvre déjà le menu.

Comment mettre de la musique dans mon menu principal ?

Utilise un audio que tu as le droit d'utiliser, comme une piste gratuite du Creator Store ou un audio que tu as importé toi-même. Mets un Sound avec cet id dans SoundService, coche Looped, appelle :Play() dessus depuis MainMenu quand le menu apparaît et :Stop() dans le gestionnaire de Play. Un son joué depuis un LocalScript n'est entendu que par ce joueur tant que SoundService.RespectFilteringEnabled est activé, ce qui est le cas par défaut.

Est-ce que je peux utiliser un menu principal en free model ?

Oui, mais lis ses scripts d'abord. Roblox prévient que les modèles du Creator Store peuvent contenir des scripts backdoor qui donnent à leurs créateurs un accès à ton jeu. Un menu n'a besoin que des deux scripts courts de ce guide.

Sources et lectures

Comment le code a été vérifié : chaque script de cette page passe le vérificateur de types strict de Luau avec les définitions de l'API Roblox (luau-lsp, 14 novembre 2026). Une vérification de types repère les API mal écrites et les mauvais types, pas la logique du jeu : teste dans Studio avant de publier.

Essaie RoCode sur ton propre jeu.

Des crédits gratuits chaque jour, sans carte. Installe le plugin, décris la fonctionnalité et vérifie ce qui arrive dans Studio.