Tutoriel · Systèmes de jeu

Comment faire une porte sur Roblox Studio

Une porte qui marche sur Roblox a besoin de trois choses : quelque chose sur quoi le joueur appuie (un ProximityPrompt qui affiche "Open"), un mouvement fluide (TweenService), et un serveur qui fait le changement pour que tous les joueurs voient la même porte. Ce guide construit un seul script qui fait ça pour chaque porte que tu tagues, battante ou coulissante, avec une serrure à clé en option que le serveur vérifie avant d'ouvrir quoi que ce soit.

Mis à jour le 12 novembre 202624 min de lectureÉcrit par

En bref

Construis la porte comme une Part ou un Model, coche Anchored, déplace son pivot sur le bord des charnières (onglet Model, Pivot), et ajoute le tag Door dans la fenêtre Properties. Un seul Script dans ServerScriptService trouve chaque porte taguée avec CollectionService, ajoute un ProximityPrompt ("Open", maintenir E), et sur Triggered tweene une NumberValue de 0 à 1 tout en déplaçant la porte avec door:PivotTo(closedPivot:Lerp(openPivot, alpha)). Des attributs sur chaque porte choisissent entre battante et coulissante, l'angle, la durée, la fermeture automatique et une clé.

  • Tu ne peux pas tweener directement la position d'un Model : un Model n'a pas de propriété CFrame ni Position, et son WorldPivot ne fait que définir où se trouve son pivot. Tweene une NumberValue et déplace la porte avec PivotTo, que Roblox présente comme la façon principale de déplacer des modèles depuis un script.
  • Ouvre les portes sur le serveur. Une porte ouverte par un LocalScript ne bouge que sur l'écran de ce joueur.
  • Vérifie la clé et la distance sur le serveur. Le guide de sécurité de Roblox dit que les ProximityPrompts peuvent être détournés exactement comme les RemoteEvents, et son propre exemple de vérification que le serveur doit faire est : le joueur a-t-il la clé nécessaire pour ouvrir une porte ?
Sur cette page
  1. Fonctionnement
  2. 1. Construire la porte
  3. 2. Script de porte
  4. Portes coulissantes
  5. Portes à clé
  6. Anciens tutoriels
  7. Limites face aux exploits
  8. 3. Tester
  9. Aller plus loin
  10. Problèmes courants
  11. Avec RoCode
  12. Questions fréquentes
  13. Sources et lectures

Comment marche une porte scriptée

Illustration animéeMaintenir E pendant 0,2 seconde ouvre la porte en 0,6 seconde, et elle se referme toute seule 4 secondes après la fin de l'ouverture (accéléré ici), pendant que VaultDoor reste fermée pour un joueur sans RedKey.

Une porte qui marche dans un jeu en ligne doit être déplacée par le serveur. Si un LocalScript la déplace, la porte s'ouvre sur l'écran de ce seul joueur et reste fermée pour tous les autres, parce qu'un changement fait par un client reste sur cet appareil (vois ce qui est répliqué et ce qui ne l'est pas (en anglais)). Dans ce guide, l'appareil du joueur ne fait donc qu'afficher le prompt et signaler l'appui sur la touche, et un seul Script serveur fait tout le reste. Une utilisation de la porte se passe comme ça :

  1. Le joueur arrive à moins de 8 studs de la porte et un prompt apparaît avec l'action Open et le nom d'objet Door, et la touche E sur un clavier. Roblox affiche le bouton correspondant sur une manette ou un écran tactile.
  2. Le joueur maintient E pendant 0,2 seconde. L'événement Triggered du prompt se déclenche sur le serveur avec ce joueur.
  3. DoorService vérifie le joueur : en vie, assez près, sans spammer le prompt, et avec la clé sur lui si la porte en demande une.
  4. Il tweene un nombre de 0 (fermée) à 1 (ouverte). Chaque fois que le nombre change, il déplace la porte de cette fraction du chemin entre sa position fermée et sa position ouverte avec PivotTo.
  5. Quatre secondes après l'ouverture complète, il la referme de la même façon. Un appui pendant que la porte bouge lui fait faire demi-tour depuis l'endroit où elle se trouve.
Les éléments du système de porte
ÉlémentOù il se trouveCe qu'il fait
Le Script DoorServiceServerScriptServiceTrouve chaque porte, ajoute son prompt, vérifie chaque utilisation et déplace la porte. Le seul script de ce guide.
Le tag DoorSur chaque Part ou Model de porteMarque ce qui est une porte. Tu ajoutes les tags dans la fenêtre Properties, et ils sont enregistrés avec le jeu.
Des attributs comme Style et KeyNameSur chaque porte (facultatif)Les réglages d'une porte : battante ou coulissante, l'angle, la vitesse, la fermeture automatique et la clé.
Le ProximityPrompt DoorPromptDans la porte (DoorService l'ajoute)Affiche "Open" ou "Close" et déclenche Triggered quand un joueur maintient E.
La NumberValue DoorProgressDans la porte (DoorService l'ajoute)Le nombre que le tween fait varier entre 0 et 1. Chaque changement déplace la porte.
Le Tool RedKey (facultatif)StarterPack, pour testerLa clé d'une porte verrouillée. N'importe quel Tool convient si son nom correspond au KeyName de la porte.
L'Explorer une fois le guide terminé. Les deux portes ont le tag Door, et VaultDoor a les attributs Style = Slide et KeyName = RedKey. Quand le jeu tourne, DoorService ajoute DoorProgress à chaque porte et DoorPrompt à la part qui porte le prompt.
Workspace
  FrontDoor Part new
  VaultDoor Model new
    Panel Part new
    Knob Part new
ServerScriptService
  DoorService Script new
StarterPack
  RedKey Tool new
    Handle Part new

Étape 1 : construire la porte et régler sa charnière

  1. Dans l'Explorer, survole Workspace, clique sur le bouton + et insère une Part. Nomme-la FrontDoor, règle sa Size sur environ 4, 7, 0.5 (4 studs de large, 7 de haut, un demi-stud d'épaisseur) et place-la dans ton encadrement de porte. Une porte faite de plusieurs parts marche aussi : sélectionne-les et appuie sur Ctrl+G pour les grouper dans un Model.
  2. Coche Anchored sur chaque part de la porte et laisse CanCollide activé. Les parts ancrées ne bougent jamais à cause de la gravité ou des collisions, mais un script peut quand même les déplacer, et c'est exactement ce que fait DoorService.
  3. Règle la charnière. Sélectionne la porte, ouvre l'onglet Model et active Pivot. Clique et maintiens la petite flèche dans le coin du bouton Pivot et coche Snap, pour que le pivot s'aimante aux points d'accroche des coins, des bords et des centres. Fais glisser le pivot jusqu'au bord de la porte où seraient les charnières. Une porte coulissante peut garder son pivot au centre.
  4. Ajoute le tag. Avec la porte sélectionnée, fais défiler la fenêtre Properties jusqu'à Tags, clique sur + et tape Door, avec un D majuscule. Pour une porte en Model, tague le Model, pas les parts qu'il contient.
  5. Construis une deuxième porte, pour les parties sur la porte coulissante et la clé plus loin. Insère deux autres Parts dans Workspace : Panel, d'une taille d'environ 4, 7, 0.5, et Knob, d'environ 0.5, 0.5, 0.5, posée contre une face de Panel. Sélectionne les deux, appuie sur Ctrl+G et renomme le nouveau Model VaultDoor. Ancre les deux parts, place le modèle dans un deuxième encadrement et ajoute le tag Door au Model. Son pivot peut rester au centre, parce que cette porte va coulisser.

Le pivot compte parce qu'une porte battante tourne autour de lui. Laissé au centre, il fait tourner la porte sur place comme une porte tambour. Pour une part, le pivot que tu règles est enregistré dans son PivotOffset, et GetPivot en tient compte, donc le script fait tourner la porte exactement autour du point que tu as choisi. Si un Model a une PrimaryPart, le pivot du modèle est celui de cette part, et DoorService met aussi le prompt sur cette part. Sans PrimaryPart, le prompt va sur la première part qu'il trouve dans le modèle. Si tu définis une PrimaryPart, fais-le avant de déplacer le pivot : en assigner une déplace le pivot du modèle sur celui de cette part, comme le note la page Pivot tools de Roblox.

Réglages de la porte (attributs)

Chaque porte marche avec les valeurs par défaut ci-dessous. Pour changer une porte, sélectionne-la, fais défiler la fenêtre Properties jusqu'à Attributes, clique sur +, saisis le nom, choisis le type et clique sur Save, puis règle la valeur. DoorService lit les attributs une seule fois, quand il prépare la porte, donc change-les quand le jeu est arrêté.

Attributs facultatifs sur chaque porte
AttributTypePar défautCe qu'il fait
StylestringSwingSwing fait tourner la porte autour de son pivot. Slide la déplace sur le côté, dans le sens de sa largeur.
OpenAnglenumber90Les degrés dont tourne une porte battante. Un nombre négatif la fait tourner dans l'autre sens. Reste entre -179 et 179 : la porte prend toujours le chemin le plus court, donc DoorService la limite à cette plage.
SlideDistancenumbersa largeurLes studs dont une porte coulissante se déplace dans le sens de sa largeur. Un nombre négatif la fait coulisser dans l'autre sens.
OpenSecondsnumber0.6La durée d'une ouverture ou d'une fermeture complète, gardée entre 0,05 et 10.
AutoCloseSecondsnumber4Le temps que la porte reste complètement ouverte avant de se refermer toute seule. 0 la garde ouverte jusqu'à ce que quelqu'un la ferme.
KeyNamestringaucuneLe nom d'un Tool que le joueur doit avoir pour ouvrir la porte, par exemple RedKey. Ne le mets pas pour une porte que tout le monde peut ouvrir.

Étape 2 : ajouter le script de porte

Survole ServerScriptService, insère un Script nommé DoorService et colle le code ci-dessous. Il gère toutes les portes du jeu, quel que soit le nombre que tu tagues. Les trois réglages près du haut s'appliquent à toutes les portes ; les attributs de l'étape 1 changent une seule porte.

Script dans ServerScriptService nommé DoorService
-- Script dans ServerScriptService nommé DoorService.
-- Ouvre et ferme chaque Part ou Model tagué "Door" avec un prompt où on maintient E.
-- Le serveur déplace la porte, donc tous les joueurs voient la même porte, et le serveur
-- vérifie la distance et la clé, donc personne ne peut ouvrir de loin une porte verrouillée.
--
-- Attributs facultatifs sur chaque porte (règle-les dans la fenêtre Properties) :
--   Style            string  "Swing" (par défaut) ou "Slide"
--   OpenAngle        number  degrés dont une porte battante tourne autour de son pivot (90 par défaut, de -179 à 179)
--   SlideDistance    number  studs dont une porte coulissante se déplace dans sa largeur (par défaut : sa largeur)
--   OpenSeconds      number  durée de l'ouverture (0.6 par défaut)
--   AutoCloseSeconds number  se referme après ce délai ; 0 la garde ouverte (4 par défaut)
--   KeyName          string  le nom d'un Tool que le joueur doit avoir, par exemple "RedKey"

local CollectionService = game:GetService("CollectionService")
local TweenService = game:GetService("TweenService")

local DOOR_TAG = "Door"
local PROMPT_DISTANCE = 8 -- studs
local MIN_SECONDS_BETWEEN_USES = 0.3 -- par porte, contre le spam du prompt

local doorsSetUp: { [Instance]: boolean } = {}

local function attribute(door: Instance, name: string, default: any): any
	local value = door:GetAttribute(name)
	if value == nil or typeof(value) ~= typeof(default) then
		return default
	end
	if typeof(value) == "number" and (value ~= value or math.abs(value) == math.huge) then
		return default -- NaN ou infini tapé dans la fenêtre Properties
	end
	return value
end

local function hasKey(player: Player, keyName: string): boolean
	local backpack = player:FindFirstChildOfClass("Backpack")
	local character = player.Character
	local inBackpack = backpack and backpack:FindFirstChild(keyName)
	local held = character and character:FindFirstChild(keyName)
	return (inBackpack ~= nil and inBackpack:IsA("Tool")) or (held ~= nil and held:IsA("Tool"))
end

local function setUpDoor(door: Instance)
	if doorsSetUp[door] or not (door:IsA("BasePart") or door:IsA("Model")) then
		return -- déjà une porte qui marche, ou ni une part ni un modèle
	end
	local promptPart = if door:IsA("Model") then (door.PrimaryPart or door:FindFirstChildWhichIsA("BasePart", true)) else door
	if not (promptPart and promptPart:IsA("BasePart")) then
		warn(`DoorService: {door:GetFullName()} has no part to put the prompt on`)
		return
	end

	doorsSetUp[door] = true
	door.Destroying:Connect(function()
		doorsSetUp[door] = nil
	end)
	-- La copie d'une porte qui marche apporte l'ancien prompt et l'ancienne valeur : supprime-les
	for _, leftover in door:GetDescendants() do
		if leftover.Name == "DoorPrompt" or leftover.Name == "DoorProgress" then
			leftover:Destroy()
		end
	end

	-- Calcule une seule fois les positions fermée et ouverte, depuis l'endroit où la porte est placée maintenant
	local closedPivot = door:GetPivot()
	local openPivot: CFrame
	if attribute(door, "Style", "Swing") == "Slide" then
		-- Coulisse le long du plus grand côté horizontal de la porte, sa largeur. Un Model se mesure le long
		-- des côtés de son pivot, une Part par sa propre Size, donc ne tourne pas le pivot d'une Part coulissante
		local size = if door:IsA("Model") then door:GetExtentsSize() else (door :: BasePart).Size
		local alongX = size.X >= size.Z
		local width = if alongX then size.X else size.Z
		local direction = if alongX then Vector3.xAxis else Vector3.zAxis
		openPivot = closedPivot * CFrame.new(direction * attribute(door, "SlideDistance", width))
	else
		-- Lerp tourne toujours par le chemin le plus court, donc un angle plus grand tournerait dans le mauvais sens
		local angle = math.clamp(attribute(door, "OpenAngle", 90), -179, 179)
		openPivot = closedPivot * CFrame.Angles(0, math.rad(angle), 0)
	end
	local openSeconds = math.clamp(attribute(door, "OpenSeconds", 0.6), 0.05, 10)
	local autoClose = math.max(attribute(door, "AutoCloseSeconds", 4), 0)
	local keyName = attribute(door, "KeyName", "")

	-- Tweene un nombre de 0 (fermée) à 1 (ouverte) et déplace la porte en fonction.
	-- PivotTo déplace une seule part ou un modèle entier autour de son pivot.
	local progress = Instance.new("NumberValue")
	progress.Name = "DoorProgress"
	progress.Parent = door
	progress.Changed:Connect(function(alpha: number)
		door:PivotTo(closedPivot:Lerp(openPivot, alpha))
	end)

	local prompt = Instance.new("ProximityPrompt")
	prompt.Name = "DoorPrompt"
	prompt.ActionText = "Open"
	prompt.ObjectText = if keyName ~= "" then `Needs {keyName}` else "Door"
	prompt.HoldDuration = 0.2
	prompt.MaxActivationDistance = PROMPT_DISTANCE
	prompt.RequiresLineOfSight = false
	prompt.Parent = promptPart

	local isOpen = false
	local lastUse = 0
	local moveCount = 0

	local function move(open: boolean)
		isOpen = open
		moveCount += 1
		door:SetAttribute("Open", open) -- d'autres scripts peuvent lire ça
		prompt.ActionText = if open then "Close" else "Open"
		-- Un nouveau tween sur la même valeur annule l'ancien, donc une porte peut faire demi-tour à mi-chemin.
		-- Adapte la durée au chemin qu'il lui reste à faire.
		local target = if open then 1 else 0
		local seconds = openSeconds * math.abs(target - progress.Value)
		TweenService:Create(progress, TweenInfo.new(seconds, Enum.EasingStyle.Quad, Enum.EasingDirection.Out), { Value = target }):Play()

		if open and autoClose > 0 then
			local thisMove = moveCount
			task.delay(openSeconds + autoClose, function()
				if moveCount == thisMove and isOpen then
					move(false)
				end
			end)
		end
	end

	prompt.Triggered:Connect(function(player: Player)
		local now = os.clock()
		if now - lastUse < MIN_SECONDS_BETWEEN_USES then
			return
		end
		-- Le guide de sécurité de Roblox dit que les prompts peuvent être détournés comme les remotes, donc revérifie ici
		local character = player.Character
		local humanoid = character and character:FindFirstChildOfClass("Humanoid")
		local rootPart = humanoid and humanoid.RootPart
		if not (humanoid and rootPart) or humanoid.Health <= 0 then
			return
		end
		if (rootPart.Position - promptPart.Position).Magnitude > PROMPT_DISTANCE + 6 then
			return -- trop loin pour avoir utilisé le prompt honnêtement
		end
		if keyName ~= "" and not isOpen and not hasKey(player, keyName) then
			return -- verrouillée, et ce joueur n'a pas la clé
		end
		lastUse = now
		move(not isOpen)
	end)
end

-- Chaque porte taguée maintenant, et celles taguées plus tard (y compris les portes clonées par des scripts)
for _, door in CollectionService:GetTagged(DOOR_TAG) do
	setUpDoor(door)
end
CollectionService:GetInstanceAddedSignal(DOOR_TAG):Connect(setUpDoor)

DoorService ajoute lui-même DoorPrompt et DoorProgress à chaque porte au démarrage du jeu, donc il n'y a rien à insérer à la main. Garde un seul exemplaire du script : il gère déjà toutes les portes taguées.

Ce que fait chaque partie de DoorService
Partie du scriptCe qu'elle faitPourquoi
attribute()Lit un attribut et retombe sur la valeur par défaut quand il manque, qu'il a le mauvais type ou que ce n'est pas un vrai nombre (NaN ou infini).Une faute de frappe dans la fenêtre Properties donne une porte avec les réglages par défaut au lieu d'une porte cassée.
doorsSetUp et la boucle des restesPrépare chaque porte une seule fois, et supprime d'abord tout DoorPrompt ou DoorProgress copié depuis une autre porte.Sinon, la copie d'une porte qui marche aurait deux prompts, dont un mort.
closedPivot et openPivotCalculés une seule fois, à partir de l'endroit où se trouve la porte quand elle est préparée. Une porte battante fait tourner le pivot autour de son propre axe vertical ; une porte coulissante le déplace le long du côté le plus long de la porte.Faire un Lerp du pivot fermé au pivot ouvert garde le pivot en place pendant que la porte tourne, donc le bord des charnières ne bouge pas pendant tout le mouvement.
DoorProgress et PivotToLe tween change un nombre ; chaque changement déplace la porte vers closedPivot:Lerp(openPivot, alpha).TweenService peut tweener une NumberValue, et PivotTo déplace une part, ou un modèle avec toutes ses parts, pour que son pivot arrive sur ce CFrame.
Le promptHoldDuration 0.2, MaxActivationDistance 8, RequiresLineOfSight désactivé. Une porte verrouillée affiche "Needs RedKey".Avec la ligne de vue activée, le prompt se cache quand quelque chose bloque la vue de sa part ; la désactiver empêche le cadre ou le reste d'une porte en Model de le cacher.
move()Lance un tween vers 1 ou 0, avec une durée proportionnelle au chemin qu'il reste à la porte.Un nouveau tween sur la même valeur annule l'ancien, donc une porte qui fait demi-tour à mi-chemin s'inverse en douceur et met moitié moins de temps.
Fermeture automatiqueAttend la durée d'ouverture plus AutoCloseSeconds, puis ne ferme la porte que si moveCount n'a pas changé.Un vieux minuteur ne ferme jamais une porte que quelqu'un a fermée puis rouverte entre-temps.
Les vérifications de TriggeredUne utilisation par porte toutes les 0,3 seconde, un personnage en vie, à moins de 14 studs de la part du prompt, et la clé, mais seulement pour ouvrir.Tout ce qu'un client peut déclencher peut être détourné, donc le serveur refait les vérifications. Les 14 studs sont les 8 du prompt plus 6 de marge pour un joueur qui a bougé en maintenant E.
L'attribut OpenRéglé sur la porte à chaque mouvement.Les attributs réglés sur le serveur sont répliqués à tous les joueurs, donc d'autres scripts, LocalScripts compris, peuvent écouter avec GetAttributeChangedSignal("Open").

Taguer chaque porte et les gérer depuis un seul script est la méthode que Roblox recommande : sa référence de CollectionService dit que si tu te retrouves à ajouter le même script à beaucoup d'objets, un script qui utilise CollectionService est peut-être préférable. GetTagged renvoie les portes qui existent quand le script démarre, et GetInstanceAddedSignal attrape les portes taguées ou ajoutées plus tard. Le guide des scripts client et serveur (en anglais) couvre cette façon d'organiser un jeu.

Faire une porte coulissante

Sélectionne VaultDoor, ajoute un attribut string nommé Style et règle-le sur Slide. La porte se déplace alors sur le côté au lieu de tourner : de sa propre largeur, ou de SlideDistance studs si tu le règles. Pour la faire coulisser dans l'autre sens, utilise une distance négative, par exemple -4 pour une porte de 4 studs. N'importe quelle autre porte, FrontDoor comprise, coulisse de la même façon une fois qu'elle a cet attribut.

DoorService mesure les deux dimensions horizontales de la porte, sa largeur et son épaisseur, et la fait coulisser le long de la plus grande. Pour un Model, il mesure avec GetExtentsSize, dont la boîte suit l'orientation du pivot du modèle, donc une porte tournée de 90 degrés après que tu l'as groupée coulisse toujours dans le sens de sa largeur et non de son épaisseur. Pour une Part, il mesure la Size de la part elle-même, donc ne tourne pas le pivot d'une part coulissante. Tu peux le déplacer sans problème.

  • Portes doubles : deux moitiés taguées côte à côte, toutes les deux avec Style Slide, et l'une avec une SlideDistance négative pour qu'elles s'écartent au milieu. Pour des portes doubles battantes, mets le pivot de chaque moitié sur son bord extérieur et donne à l'une un OpenAngle négatif. Chaque moitié a son propre prompt et s'ouvre séparément. Si les moitiés se rentrent dedans, passe le signe moins sur l'autre moitié.
  • Une grille qui monte : ce script ne fait coulisser que dans le sens de la largeur de la porte. Pour lever les portes, règle direction dans le script sur Vector3.yAxis (toutes les portes coulissantes montent alors) et donne à chacune une SlideDistance égale à sa hauteur.
  • Une porte physique : le tutoriel de Roblox sur les objets mobiles déplace des parts le long d'un axe avec une PrismaticConstraint. Comme la porte à charnière, c'est de la physique, sans prompt ni serrure à moins que tu en scriptes un.

Verrouiller une porte avec une clé

Une porte verrouillée ne s'ouvre que pour un joueur qui a un Tool avec le bon nom. Crée la clé, puis donne son nom à la porte :

  1. Survole StarterPack, clique sur + et insère un Tool nommé RedKey. Insère dedans une Part nommée Handle, la part que tient le personnage, et vérifie que cette part n'est pas ancrée : une part ancrée dans un Tool cloue le personnage sur place. Décoche aussi CanBeDropped sur le Tool si les joueurs ne doivent pas pouvoir lâcher la clé pour quelqu'un d'autre : tant que c'est coché, Retour arrière lâche un Tool équipé dans Workspace.
  2. Sélectionne VaultDoor, ajoute un attribut string nommé KeyName et règle-le sur RedKey. Le nom d'objet du prompt affiche maintenant Needs RedKey.

DoorService cherche la clé à deux endroits. Un Tool reste dans le Backpack du joueur jusqu'à ce qu'il l'équipe, et l'équiper le déplace dans son personnage, donc la porte s'ouvre que la clé soit dans la barre d'objets ou dans sa main. La vérification se fait sur le serveur parce que le guide de sécurité de Roblox cite exactement ce cas, la clé nécessaire pour ouvrir une porte, comme une permission que le serveur doit vérifier. Seule l'ouverture demande la clé : n'importe qui peut fermer une porte ouverte, et elle se referme toute seule après AutoCloseSeconds.

StarterPack donne la clé à tout le monde à chaque apparition, ce qui convient pour tester. Dans un vrai jeu, distribue-la plutôt autrement :

  • Depuis une boutique : le guide de l'interface de boutique donne des Tools de ServerStorage au Backpack et au StarterGear de l'acheteur.
  • Depuis un personnage : le guide des dialogues de PNJ donne un Tool de ServerStorage.DialogueItems quand le joueur choisit une réponse avec l'action GiveItem. Mets un Tool nommé RedKey dans ce dossier et donne à un choix de DialogueData action = "GiveItem" et item = "RedKey", et la clé vient d'une conversation.
  • Comme objet d'inventaire : avec le système d'inventaire, un objet clé marche dès que le joueur l'équipe, parce que l'équiper met une copie de son Tool dans son Backpack et dans sa main.

Une clé dans le Backpack est perdue quand le personnage meurt, parce que Roblox remplit à nouveau le Backpack à partir de StarterPack et de StarterGear à chaque apparition. Pour la garder, mets aussi une copie dans le StarterGear du joueur, comme le fait le guide de la boutique. Pour consommer une clé au contraire, trouve le Tool de la clé dans le Backpack ou le personnage du joueur et détruis-le dans le gestionnaire de Triggered, juste après que la vérification de la clé a réussi.

Les erreurs des anciens tutoriels de porte

Si tu compares ce guide avec une vidéo ou un message de forum, voici les méthodes à l'origine de la plupart des sujets "ma porte ne marche pas", et ce que ce guide fait à la place.

Méthodes courantes des tutoriels de porte, et ce que ce guide fait à la place
Le tutorielLe problèmeCe guide
Tweene le CFrame d'un Model de porteLa référence de Model ne liste aucune propriété CFrame ni Position. Son WorldPivot ne fait que définir où se trouve le pivot du modèle, donc le tweener déplace le point de pivot et laisse les parts où elles sont.Tweene une NumberValue et déplace le modèle entier avec PivotTo.
Déplace un modèle avec SetPrimaryPartCFrameRemplacé : Roblox dit d'utiliser PivotTo pour tout nouveau travail.Utilise PivotTo, que Roblox présente comme la fonction principale à utiliser pour déplacer des Models par script.
Soude chaque part à une part charnière et ne tweene que la charnièreMarche quand chaque soudure est bonne, mais toute part oubliée reste en arrière quand la charnière bouge.Garde chaque part ancrée, sans soudure. PivotTo déplace la porte et tout ce qu'elle contient.
Copie le même script dans chaque porteChaque correction doit être refaite dans chaque copie. Roblox conseille de taguer les objets et de les gérer depuis un seul script avec CollectionService.Un seul DoorService et un tag Door.
Ouvre la porte dans un LocalScriptLa porte ne s'ouvre que sur l'écran de ce joueur, et tous les autres la voient encore fermée.Le serveur déplace la porte, donc tous les joueurs voient la même porte.
Ouvre la porte depuis TouchedTouched se déclenche plusieurs fois de suite très vite pour un seul contact (page de Roblox sur le debounce), et l'appareil d'un joueur peut contrôler quand Touched se déclenche pour son propre personnage (documentation de sécurité de Roblox).Un prompt que le serveur vérifie.
Déplace la porte pas à pas dans une boucle avec wait()Roblox indique que wait() est remplacé par task.wait(), et une boucle ne peut pas faire demi-tour à mi-chemin quand quelqu'un appuie de nouveau.Un tween par mouvement. Un nouveau tween sur la même valeur annule l'ancien, donc la porte fait demi-tour depuis l'endroit où elle est.
Vérifie la clé dans un LocalScript, ou pas du toutUn tricheur contrôle tout sur son propre appareil, donc une vérification côté client n'arrête personne.Le serveur cherche le Tool dans le Backpack et le personnage du joueur.
Pas de délai sur le promptLe guide de sécurité de Roblox dit que les prompts peuvent être détournés exactement comme les remotes, donc rien n'empêche d'en déclencher un encore et encore.Une utilisation par porte toutes les 0,3 seconde.

Ce qu'un tricheur peut faire et ne peut pas faire

Pars du principe qu'un tricheur contrôle tout sur son propre appareil, y compris son personnage. Voici ce que ça veut dire pour ces portes.

Ce qu'un tricheur peut tenter, et ce que DoorService fait contre ça
Un tricheur essaie deRésultatPourquoi
Déclencher le prompt depuis l'autre bout de la carteIgnoré sauf si son personnage est devant la porteDoorService mesure de la part racine de son personnage à la part du prompt et ignore tout ce qui dépasse 14 studs. Il peut d'abord téléporter son personnage à côté de la porte (vois la dernière ligne), donc la vérification de distance empêche l'utilisation de loin, pas la téléportation.
Le déclencher plusieurs fois par secondeAu plus une utilisation par porte toutes les 0,3 secondeLe serveur garde l'heure de la dernière utilisation de chaque porte.
Ouvrir une porte à clé sans la cléRefuséLe serveur cherche le Tool dans son Backpack et son personnage, là où lui les voit, pas sur l'écran du joueur.
Utiliser la porte alors que son personnage est mortIgnoréDoorService vérifie qu'il y a un Humanoid avec plus de 0 de vie et une part racine.
Traverser quand même une porte ferméePossibleLa documentation de sécurité de Roblox cite le contournement des obstacles physiques et la modification de ses propres collisions parmi ce qu'un client peut faire avec son propre personnage.
Se téléporter de l'autre côté de la portePossibleLa même documentation cite la téléportation de son propre personnage vers n'importe quelle position.

Étape 3 : tester

  1. Appuie sur Play (F5). Approche-toi de FrontDoor : à moins de 8 studs, un prompt apparaît avec l'action Open et le nom d'objet Door. Maintiens E. Après 0,2 seconde, la porte pivote de 90 degrés autour du bord des charnières en 0,6 seconde, et le prompt affiche maintenant Close.
  2. Passe et attends. Quatre secondes après la fin de l'ouverture, la porte se referme toute seule. Maintiens E pendant qu'elle se ferme : elle fait demi-tour et s'ouvre depuis l'endroit où elle était.
  3. Teste la serrure. Si RedKey est dans StarterPack, déplace-la dans ServerStorage pour l'instant, appuie sur Play et maintiens E devant VaultDoor : le prompt affiche Needs RedKey et rien ne bouge. Arrête, remets RedKey dans StarterPack et relance : VaultDoor s'ouvre, que la clé soit dans ta barre d'objets ou dans ta main.
  4. Vérifie le coulissement. VaultDoor, un Model avec Style Slide, se déplace sur le côté de sa propre largeur quand elle s'ouvre. Arrête, sélectionne VaultDoor, tourne-la de 90 degrés avec l'outil Rotate et relance : elle doit toujours coulisser dans le sens de sa largeur, pas de son épaisseur. Remets-la en place quand tu as fini.
  5. Choisis Server & Clients dans le menu déroulant du mode de test, règle 2 clients et appuie sur Play. Ouvre une porte dans une fenêtre client : elle est ouverte dans l'autre fenêtre aussi, et elle se ferme dans les deux.
  6. Arrête le jeu, sélectionne une porte et appuie sur Ctrl+D pour la dupliquer, puis place la copie dans un autre encadrement. Vérifie que la copie liste toujours Door sous Tags, puis appuie sur Play : la copie marche sans script en plus.

Garde la fenêtre Output ouverte (menu Window, puis Output). DoorService n'affiche rien quand tout marche. Un avertissement disant qu'une porte "has no part to put the prompt on" veut dire qu'un Model tagué ne contient aucune part. Vois les problèmes courants pour le reste.

Aller plus loin

Portes automatiques

Pour une porte qui s'ouvre quand quelqu'un s'approche, appelle move(true) depuis l'intérieur de setUpDoor au lieu d'attendre le prompt. À la fin de setUpDoor, lance une boucle avec task.spawn, parce qu'une boucle simple à cet endroit ne finit jamais et DoorService ne dépasserait jamais la première porte. Ne la laisse tourner que tant que la porte est dans le jeu : task.spawn(function() while door.Parent do ... task.wait(0.5) end end). Dans la boucle, vérifie avec workspace:GetPartBoundsInBox si un personnage se trouve dans une boîte autour de l'encadrement, et appelle move(true) quand c'est le cas et que la porte est fermée. La fermeture automatique la referme ensuite comme avant. Règle Enabled du prompt sur false si la porte ne doit s'ouvrir que toute seule.

Portes VIP

Le guide des game pass (en anglais) construit déjà une porte VIP que les détenteurs du pass traversent directement, avec des groupes de collision. Pour une porte VIP qui s'ouvre avec E, ajoute une vérification de plus dans le gestionnaire de Triggered, à côté de celle de la clé : fais un return sauf si player:GetAttribute("OwnsPass_VIP") == true, l'attribut que règle le script serveur du guide des game pass. Ne le lis que sur le serveur.

Un digicode

Pour une porte qui s'ouvre avec un code tapé, garde le code dans un Script serveur ou dans ServerStorage, que les joueurs ne reçoivent jamais, et jamais dans un LocalScript, où un tricheur peut le lire. Le LocalScript du digicode n'envoie que les chiffres tapés par un RemoteEvent. Sur le serveur, vérifie que le joueur est près de la porte, limite la fréquence de ses essais, compare les chiffres, et seulement ensuite appelle move(true). Le guide des RemoteEvents montre comment vérifier ce qu'un remote reçoit.

Sons

Mets un Sound dans la part de la porte, pour qu'il soit joué depuis la position de cette part, et appelle sa méthode Play au début de move. Ou joue-le depuis un LocalScript qui écoute l'attribut Open de la porte avec GetAttributeChangedSignal("Open"), puisque le serveur règle cet attribut à chaque mouvement.

Portes ajoutées pendant que le jeu tourne

Clone les nouvelles portes à partir d'un modèle fermé rangé dans ServerStorage. DoorService lit la position fermée d'une porte quand la porte apparaît, donc la copie d'une porte qui était ouverte à ce moment-là prendrait sa position ouverte pour la position fermée. Place la copie dans son encadrement avec PivotTo avant de régler son Parent sur Workspace, pour que DoorService enregistre cet endroit comme fermé. Les anciens prompts et valeurs qui viennent avec une copie sont supprimés automatiquement. Pour une porte qui emmène les joueurs dans une autre zone ou un autre emplacement (place), vois le guide du téléporteur.

Problèmes courants

Ouvre la fenêtre Output (menu Window, puis Output) avant d'appuyer sur Play. La plupart des problèmes de porte viennent d'un tag, d'un pivot ou d'un attribut qui n'est pas tout à fait ce que le script attend.

Aucun prompt n'apparaît devant la porte

Vérifie dans l'ordre : DoorService est un Script, pas un LocalScript, directement dans ServerScriptService ; la porte a le tag Door avec un D majuscule, sur le Model lui-même pour une porte en Model ; la porte est une part (une Part, un MeshPart ou une autre BasePart) ou un Model ; et tu es à moins de 8 studs de la part qui porte le prompt. Un avertissement dans Output disant que la porte "has no part to put the prompt on" veut dire que le Model tagué ne contient aucune part.

La porte tombe, dérive ou se fait pousser quand le jeu démarre

Une de ses parts n'est pas ancrée. Sélectionne chaque part de la porte et coche Anchored. Les parts ancrées ne bougent jamais à cause de la physique, mais DoorService peut quand même les déplacer.

J'ai changé un attribut mais la porte l'ignore

Vérifie trois choses. Le type : OpenAngle, SlideDistance, OpenSeconds et AutoCloseSeconds doivent être des attributs number, et Style et KeyName des attributs string ; DoorService utilise la valeur par défaut quand le type est mauvais. L'orthographe : les noms sont comparés exactement, donc openAngle est un autre attribut. Les valeurs sont comparées exactement aussi : Style doit valoir Slide avec un S majuscule et sans espace. Le moment : DoorService lit les attributs une seule fois, quand il prépare la porte, donc un changement fait pendant un test ne fait rien tant que tu ne relances pas le jeu.

La porte tourne dans le mauvais sens, ou bascule sur le côté

Pour la faire tourner dans l'autre sens, rends OpenAngle négatif, par exemple -90. Si elle tourne autour d'un axe couché au lieu d'une charnière verticale, c'est le pivot lui-même qui a été tourné : active Pivot dans l'onglet Model et retourne le pivot pour qu'il soit de nouveau droit.

Une porte coulissante rentre dans le mur ou ne bouge qu'un peu

Donne-lui une SlideDistance négative pour coulisser dans l'autre sens. Si elle bouge trop peu ou trop loin, règle SlideDistance sur le nombre de studs que tu veux au lieu de compter sur la largeur mesurée.

J'ai la clé mais la porte reste fermée

La clé doit être un Tool, pas une Part ni un Model, et son nom doit correspondre exactement à KeyName, majuscules comprises. Elle doit être dans ton Backpack ou dans ta main. Vérifie aussi que KeyName sur la porte est un attribut string.

Le faire avec RoCode

Si tu préfères ne pas mettre tout ça en place à 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 le changement dans un chat web, et son plugin pour Studio crée les scripts et les instances dans ton Explorer, donc il n'y a pas de code à coller.

Tu écris

Fais que les portes taguées Door s'ouvrent avec un prompt où on maintient E : rotation de 90 degrés autour du pivot en 0,6 seconde, fermeture après 4 secondes, coulissement quand l'attribut Style vaut Slide, et porte fermée tant que le joueur n'a pas le Tool nommé dans KeyName. Tout sur le serveur, avec une vérification de distance.

RoCode fait
  • Peut parcourir ton jeu quand une étape le demande, avec Search Game et Search Scripts, pour s'appuyer sur les objets, les remotes ou le code de sauvegarde que tu as déjà au lieu d'ajouter un deuxième système
  • Écrit le Script dans ServerScriptService avec Create Script, et peut créer une part de porte avec Create Instance et régler dessus des attributs comme Style et KeyName
  • A pour consigne de vérifier la compilation de chaque script qu'il écrit avec Check Script, qui le compile dans Studio sans le lancer
  • Place un point d'annulation avant et après chaque lot de changements, donc Ctrl+Z revient en arrière un lot à la fois

Vérifie le pivot de chaque porte avec l'outil Pivot de Studio avant de tester : la porte tourne autour de lui. 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 il peut contrôler un personnage de test qui marche et appuie sur des touches, mais il ne vérifie que ce qu'il a choisi de tester, donc approche-toi de chaque porte et maintiens E toi-même. Comment RoCode se connecte à Studio.

Questions fréquentes

Comment faire une porte qui s'ouvre avec E sur Roblox Studio ?

Mets un ProximityPrompt dans la porte et connecte son événement Triggered dans un Script serveur, qui déplace la porte. DoorService fait les deux pour chaque porte taguée Door. E est la touche par défaut du prompt, et Roblox affiche la bonne commande pour les claviers, les manettes et les écrans tactiles.

Pourquoi ma porte tourne-t-elle autour de son milieu ?

Son pivot est encore au centre. Active Pivot dans l'onglet Model et fais glisser le pivot jusqu'au bord des charnières ; le script fait tourner la porte autour du pivot.

Comment faire une porte coulissante ?

Règle l'attribut Style de la porte sur Slide. Elle se déplace sur le côté de sa propre largeur, ou de SlideDistance studs ; utilise une distance négative pour coulisser dans l'autre sens.

Peut-on faire une porte sans script ?

Oui. Le tutoriel de la porte à charnière de Roblox relie une porte non ancrée à son cadre avec une HingeConstraint, avec des limites, donc les joueurs la poussent en marchant dedans. Cette porte n'a ni prompt, ni serrure, ni fermeture automatique.

Comment faire une porte que seuls les VIP peuvent ouvrir ?

Utilise la porte VIP du guide des game pass (en anglais), qui laisse passer les détenteurs du pass, ou ajoute au gestionnaire de Triggered de DoorService une vérification qui lit sur le serveur si le joueur possède le pass avant d'ouvrir, par exemple l'attribut OwnsPass_VIP que règle ce guide.

Pourquoi ma porte s'ouvre pour moi mais pas pour les autres joueurs ?

Elle est ouverte dans un LocalScript, et un changement fait par un LocalScript reste sur l'appareil de ce joueur. Déplace le code d'ouverture dans un Script serveur, comme le fait DoorService, pour que le changement arrive chez tout le monde.

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, 12 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.