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, pasMouseButton1Click, 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
Comment marche un menu principal
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.
| Élément | Où il se trouve | Ce qu'il fait |
|---|---|---|
Le Script MenuService | ServerScriptService | Dé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 MainMenu | StarterPlayerScripts | Construit 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 PlayRequest | ReplicatedStorage (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 MenuCamera | Workspace (c'est toi qui la places) | L'endroit où se trouve la caméra du menu et la direction dans laquelle elle regarde. |
CharacterAutoLoads | Une propriété du service Players | Désactivée, pour que personne n'apparaisse avant que le serveur appelle LoadCharacterAsync. |
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
- 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.
- 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. - 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. - 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.
-- 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.
| Un tricheur | Ce qui se passe |
|---|---|
| Déclenche PlayRequest sans appuyer sur Play | Il apparaît, exactement comme s'il avait appuyé sur Play. Sauter un menu ne rapporte rien. |
| Déclenche PlayRequest des centaines de fois | Une 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ôt | Refusé. Un joueur mort garde son personnage jusqu'à ce que MenuService le fasse réapparaître. |
| Envoie des valeurs en plus avec PlayRequest | Ignorées. Le gestionnaire ne les lit jamais. |
| Supprime le menu ou bouge sa propre caméra | Seul 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
TextLabeldu titre par uneImageLabeldont l'Imageestrbxassetid://suivi de l'asset id de l'image. Donne-luiBackgroundTransparency1 etScaleTypeFit pour qu'elle garde sa forme. - Un fond flou. Crée un
BlurEffectdans MainMenu et mets son parent surworkspace.CurrentCamera. Roblox le suggère pour les menus : un effet sous la caméra ne s'affiche que pour ce joueur. SaSizeest le rayon du flou en pixels. Détruis-le dans le gestionnaire de Play, à côté degui:Destroy(). - La couleur. Ajoute un
UIGradientau bouton, ou unUIStrokepour un contour. Garde le texte enTextScaledpour qu'il tienne sur les petits écrans. - Plus de boutons. Mets les boutons dans un
Frameavec unUIListLayoutet un peu dePadding, et donne à chacun un gestionnaireActivatedet son propreUISizeConstraint. 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
- 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.
- 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. - Réinitialise ton personnage depuis le menu du jeu. Tu réapparais après environ 5 secondes, et le menu ne revient pas.
- 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.
- 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.
- 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.AutoSelectGuiEnabledest activé, puis sur A. - 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.
| Système | Ce qui change | Ce qu'il faut faire |
|---|---|---|
| Système de manches | Les 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 DataStore | Ils 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'intro | CutsceneService 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 StarterGui | Ils 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).
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.
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.
- 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.CharacterAutoLoadsavec 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
- Roblox Engine API : Players (en anglais). CharacterAutoLoads et RespawnTime
- Roblox Engine API : Player (en anglais). LoadCharacterAsync, son ordre de chargement, et AddReplicationFocus
- Roblox Creator Docs : On-screen UI containers (en anglais). quand StarterGui est copié, les screen insets et l'ordre d'affichage
- Roblox Engine API : LayerCollector (en anglais). ResetOnSpawn
- Roblox Engine API : Camera (en anglais). Focus, le point que la caméra regarde
- Roblox Creator Docs : Customize the camera (en anglais). scripter la caméra avec CameraType sur Scriptable
- Roblox Creator Docs : Streaming techniques and conversion (en anglais). pourquoi un client sans personnage peut ne recevoir aucune map, et le focus de réplication
- Roblox Engine API : GuiButton (en anglais). Activated pour un clic, un toucher et un bouton de manette
- Roblox Creator Docs : Loading screens (en anglais). les écrans de chargement personnalisés dans ReplicatedFirst
- Roblox Creator Docs : Vulnerabilities from third-party assets (en anglais). les scripts backdoor dans les free models
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.