Tutorial · Sistemas de jogo

Como fazer uma porta no Roblox Studio

Uma porta que funciona no Roblox precisa de três coisas: algo que o jogador aperta (um ProximityPrompt que diz "Open"), um movimento suave (TweenService) e um servidor que faz a mudança, para que todos os jogadores vejam a mesma porta. Este guia monta um script que faz isso para toda porta que você marcar com uma tag, de girar ou de correr, com uma trava de chave opcional que o servidor confere antes de abrir qualquer coisa.

Atualizado em 12 de novembro de 202623 min de leituraEscrito por

Resumo

Monte a porta como uma Part ou um Model, marque Anchored, leve o pivot dela para a borda da dobradiça (aba Model, Pivot) e adicione a tag Door na janela Properties. Um Script no ServerScriptService acha toda porta com a tag usando o CollectionService, adiciona um ProximityPrompt ("Open", segurar E) e, no Triggered, faz o tween de um NumberValue de 0 a 1 enquanto move a porta com door:PivotTo(closedPivot:Lerp(openPivot, alpha)). Atributos em cada porta escolhem entre girar e deslizar, o ângulo, o tempo, o fechamento automático e a chave.

  • Não dá para fazer tween da posição de um Model diretamente: um Model não tem a propriedade CFrame nem Position, e o WorldPivot dele só define onde fica o pivot. Faça o tween de um NumberValue e mova a porta com PivotTo, que a Roblox chama de a principal forma de mover models por script.
  • Abra as portas no servidor. Uma porta aberta por um LocalScript se move só na tela daquele jogador.
  • Confira a chave e a distância no servidor. O guia de segurança da Roblox diz que ProximityPrompts podem ser abusados do mesmo jeito que RemoteEvents, e o exemplo que ele mesmo dá de uma checagem que o servidor precisa fazer é "o jogador tem a chave necessária para abrir uma porta?"
Nesta página
  1. Como funciona
  2. 1. Monte a porta
  3. 2. Script da porta
  4. Portas de correr
  5. Portas com chave
  6. Tutoriais antigos
  7. Limites contra exploits
  8. 3. Teste
  9. Indo além
  10. Erros comuns
  11. Com o RoCode
  12. Perguntas frequentes
  13. Fontes e leitura extra

Como funciona uma porta com script

IlustraçãoSegurar E por 0,2 segundo abre a porta em 0,6 segundo, e ela fecha sozinha 4 segundos depois de terminar de abrir (acelerado aqui), enquanto a VaultDoor continua fechada para um jogador sem a RedKey.

Uma porta que funciona em um jogo publicado precisa ser movida pelo servidor. Se um LocalScript a move, a porta abre na tela daquele único jogador e continua fechada para todos os outros, porque uma mudança feita por um cliente fica naquele dispositivo (veja o que replica e o que não replica (em inglês)). Por isso, neste guia o dispositivo do jogador só mostra o prompt e avisa que a tecla foi apertada, e um único Script de servidor faz todo o resto. Um uso da porta acontece assim:

  1. O jogador chega a até 8 studs da porta e aparece um prompt com a ação Open e o nome de objeto Door, com E no teclado. O Roblox mostra o botão equivalente em um controle ou em uma tela de toque.
  2. O jogador segura E por 0,2 segundo. O evento Triggered do prompt dispara no servidor com aquele jogador.
  3. O DoorService confere o jogador: vivo, perto o bastante, sem spam no prompt e com a chave, se a porta precisar de uma.
  4. Ele faz o tween de um número de 0 (fechada) a 1 (aberta). Cada vez que o número muda, ele move a porta essa fração do caminho entre a posição fechada e a aberta com PivotTo.
  5. Quatro segundos depois de a porta estar totalmente aberta, ele a fecha do mesmo jeito. Um aperto enquanto a porta está se movendo faz ela voltar de onde estiver.
As peças do sistema de porta
PeçaOnde ficaO que faz
Script DoorServiceServerScriptServiceAcha toda porta, adiciona o prompt dela, confere cada uso e move a porta. O único script deste guia.
A tag DoorEm cada Part ou Model de portaMarca o que é uma porta. Você adiciona tags na janela Properties, e elas são salvas com o jogo.
Atributos como Style e KeyNameEm cada porta (opcional)Configurações de uma porta: girar ou deslizar, o ângulo, a velocidade, o fechamento automático e a chave.
ProximityPrompt DoorPromptDentro da porta (o DoorService adiciona)Mostra "Open" ou "Close" e dispara o Triggered quando um jogador segura E.
NumberValue DoorProgressDentro da porta (o DoorService adiciona)O número que o tween leva de 0 a 1. Cada mudança move a porta.
Tool RedKey (opcional)StarterPack, para testarA chave de uma porta trancada. Qualquer Tool serve se o nome dela for igual ao KeyName da porta.
O Explorer quando o guia termina. As duas portas têm a tag Door, e a VaultDoor tem os atributos Style = Slide e KeyName = RedKey. Quando o jogo roda, o DoorService adiciona o DoorProgress a cada porta e o DoorPrompt à part em que o prompt fica.
Workspace
  FrontDoor Part new
  VaultDoor Model new
    Panel Part new
    Knob Part new
ServerScriptService
  DoorService Script new
StarterPack
  RedKey Tool new
    Handle Part new

Passo 1: Monte a porta e defina a dobradiça

  1. No Explorer, passe o mouse sobre Workspace, clique no botão + e insira uma Part. Dê o nome FrontDoor, defina o Size como cerca de 4, 7, 0.5 (4 studs de largura, 7 de altura, meio stud de espessura) e leve a part até o vão da porta. Uma porta feita de várias parts também funciona: selecione todas e aperte Ctrl+G para agrupar em um Model.
  2. Marque Anchored em todas as parts da porta e deixe o CanCollide ligado. Parts ancoradas nunca se movem por gravidade ou colisão, mas um script ainda pode movê-las, e é exatamente isso que o DoorService faz.
  3. Defina a dobradiça. Selecione a porta, abra a aba Model e ligue o Pivot. Clique e segure a setinha no canto do botão Pivot e marque Snap, para o pivot grudar nos pontos de encaixe dos cantos, bordas e centros. Arraste o pivot até a borda da porta onde ficariam as dobradiças. Uma porta de correr pode ficar com o pivot no centro.
  4. Adicione a tag. Com a porta selecionada, role a janela Properties até Tags, clique em + e digite Door, com D maiúsculo. Em uma porta que é um Model, coloque a tag no Model, não nas parts de dentro.
  5. Monte uma segunda porta, para as seções de porta de correr e de chave mais adiante. Insira mais duas Parts no Workspace: Panel, com cerca de 4, 7, 0.5, e Knob, com cerca de 0.5, 0.5, 0.5, encostada em uma face do Panel. Selecione as duas, aperte Ctrl+G e renomeie o novo Model para VaultDoor. Ancore as duas parts, leve o model até um segundo vão e adicione a tag Door ao Model. O pivot dele pode ficar no centro, porque esta porta vai deslizar.

O pivot importa porque uma porta de girar vira em torno dele. Deixado no centro, a porta gira no lugar como uma porta giratória. Em uma part, o pivot que você define é salvo como o PivotOffset dela, e o GetPivot o inclui, então o script gira a porta exatamente em torno do ponto que você escolheu. Se um Model tem uma PrimaryPart, o pivot do model é o pivot dessa part, e o DoorService também coloca o prompt nela. Sem PrimaryPart, o prompt vai para a primeira part que ele achar dentro do model. Se você for definir uma PrimaryPart, defina antes de mover o pivot: atribuir uma leva o pivot do model para o pivot dessa part, como avisa a página Pivot tools da Roblox.

Configurações da porta (atributos)

Toda porta funciona com os padrões abaixo. Para mudar uma porta, selecione-a, role a janela Properties até Attributes, clique em +, digite o nome, escolha o tipo e clique em Save, depois defina o valor. O DoorService lê os atributos uma vez, quando prepara a porta, então mude-os com o jogo parado.

Atributos opcionais em cada porta
AtributoTipoPadrãoO que faz
StylestringSwingSwing gira a porta em torno do pivot. Slide a move de lado, ao longo da largura.
OpenAnglenumber90Graus que uma porta de girar vira. Um número negativo gira para o outro lado. Mantenha entre -179 e 179: a porta sempre vai pelo caminho mais curto, então o DoorService limita a esse intervalo.
SlideDistancenumbera largura delaStuds que uma porta de correr anda ao longo da largura. Um número negativo desliza para o outro lado.
OpenSecondsnumber0.6Quanto tempo leva para abrir ou fechar por completo, mantido entre 0.05 e 10.
AutoCloseSecondsnumber4Quanto tempo a porta fica totalmente aberta antes de fechar sozinha. 0 a deixa aberta até alguém fechar.
KeyNamestringnenhumO nome de uma Tool que o jogador precisa ter para abrir a porta, como RedKey. Deixe de fora em uma porta que qualquer um pode abrir.

Passo 2: Adicione o script da porta

Passe o mouse sobre ServerScriptService, insira um Script chamado DoorService e cole o código abaixo. Ele cuida de todas as portas do jogo, não importa quantas você marque. As três configurações perto do topo valem para todas as portas; os atributos do Passo 1 mudam uma porta só.

Script em ServerScriptService chamado DoorService
-- Script no ServerScriptService chamado DoorService.
-- Abre e fecha toda Part ou Model com a tag "Door" com um prompt de segurar E.
-- O servidor move a porta, então todos os jogadores veem a mesma porta, e o servidor
-- confere a distância e a chave, então ninguém abre uma porta trancada de longe.
--
-- Atributos opcionais em cada porta (defina na janela Properties):
--   Style            string  "Swing" (padrão) ou "Slide"
--   OpenAngle        number  graus que uma porta de girar vira em torno do pivot (padrão 90, de -179 a 179)
--   SlideDistance    number  studs que uma porta de correr anda ao longo da largura (padrão: a largura dela)
--   OpenSeconds      number  quanto tempo leva para abrir (padrão 0.6)
--   AutoCloseSeconds number  fecha de novo depois desse tempo; 0 deixa aberta (padrão 4)
--   KeyName          string  o nome de uma Tool que o jogador precisa ter, como "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 -- por porta, contra spam no 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 infinito digitado na janela 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 -- já é uma porta funcionando, ou não é uma part nem um model
	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)
	-- Uma cópia de uma porta funcionando traz o prompt e o valor antigos: remova
	for _, leftover in door:GetDescendants() do
		if leftover.Name == "DoorPrompt" or leftover.Name == "DoorProgress" then
			leftover:Destroy()
		end
	end

	-- Calcula as posições fechada e aberta uma vez, a partir de onde a porta está agora
	local closedPivot = door:GetPivot()
	local openPivot: CFrame
	if attribute(door, "Style", "Swing") == "Slide" then
		-- Desliza pelo lado plano mais longo da porta, a largura. Um Model é medido pelos lados
		-- do pivot, uma Part pelo próprio Size, então não gire o pivot de uma Part de correr
		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
		-- O Lerp sempre gira pelo caminho mais curto, então um ângulo maior giraria para o lado errado
		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", "")

	-- Faz o tween de um número de 0 (fechada) a 1 (aberta) e move a porta de acordo.
	-- O PivotTo move uma part sozinha ou um model inteiro em torno do 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) -- outros scripts podem ler isto
		prompt.ActionText = if open then "Close" else "Open"
		-- Um tween novo no mesmo valor cancela o antigo, então a porta pode voltar no meio do caminho.
		-- Ajusta o tempo pelo quanto ainda falta percorrer.
		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
		-- O guia de segurança da Roblox diz que prompts podem ser abusados como remotes, então confira de novo aqui
		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 -- longe demais para ter usado o prompt honestamente
		end
		if keyName ~= "" and not isOpen and not hasKey(player, keyName) then
			return -- trancada, e este jogador não tem a chave
		end
		lastUse = now
		move(not isOpen)
	end)
end

-- Toda porta com a tag agora, e as que receberem depois (incluindo portas clonadas por scripts)
for _, door in CollectionService:GetTagged(DOOR_TAG) do
	setUpDoor(door)
end
CollectionService:GetInstanceAddedSignal(DOOR_TAG):Connect(setUpDoor)

O próprio DoorService adiciona o DoorPrompt e o DoorProgress a cada porta quando o jogo começa, então não há nada para inserir à mão. Mantenha uma cópia só do script: ele já cuida de toda porta com a tag.

O que cada parte do DoorService faz
Parte do scriptO que fazPor quê
attribute()Lê um atributo e usa o padrão quando ele falta, é do tipo errado ou não é um número de verdade (NaN ou infinito).Um erro de digitação na janela Properties dá uma porta com as configurações padrão em vez de uma porta quebrada.
doorsSetUp e o loop das sobrasPrepara cada porta uma vez, e antes remove qualquer DoorPrompt ou DoorProgress copiado de outra porta.Sem isso, uma cópia de uma porta funcionando teria dois prompts, um deles morto.
closedPivot e openPivotCalculados uma vez, a partir de onde a porta está quando é preparada. Girar vira o pivot em torno do próprio eixo vertical; deslizar o move ao longo do lado mais longo da porta.Interpolar do pivot fechado ao aberto mantém o pivot no lugar enquanto a porta gira, então a borda da dobradiça fica parada durante todo o giro.
DoorProgress e PivotToO tween muda um número; cada mudança move a porta para closedPivot:Lerp(openPivot, alpha).O TweenService consegue fazer tween de um NumberValue, e o PivotTo move uma part, ou um model com todas as parts, para que o pivot caia naquele CFrame.
O promptHoldDuration 0.2, MaxActivationDistance 8, RequiresLineOfSight desligado. Uma porta trancada mostra "Needs RedKey".Com a linha de visão ligada, o prompt some quando algo bloqueia a visão da part dele; desligar evita que o batente ou o resto de um model de porta o esconda.
move()Começa um tween em direção a 1 ou 0, com o tempo ajustado pelo quanto a porta ainda precisa percorrer.Um tween novo no mesmo valor cancela o antigo, então uma porta que volta no meio do caminho inverte suavemente e leva metade do tempo.
Fechamento automáticoEspera o tempo de abertura mais o AutoCloseSeconds, depois fecha a porta só se o moveCount não mudou.Um timer antigo nunca fecha uma porta que alguém fechou e abriu de novo nesse meio tempo.
As checagens do TriggeredUm uso por porta a cada 0,3 segundo, um personagem vivo, a até 14 studs da part do prompt, e a chave, mas só para abrir.Tudo o que um cliente pode disparar pode ser abusado, então o servidor repete as checagens. Os 14 studs são os 8 do prompt mais 6 de folga para um jogador que andou enquanto segurava E.
O atributo OpenDefinido na porta a cada movimento.Atributos definidos no servidor replicam para todos os jogadores, então outros scripts, inclusive LocalScripts, podem escutar com GetAttributeChangedSignal("Open").

Marcar toda porta com uma tag e cuidar delas com um script só é o padrão que a Roblox recomenda: a referência do CollectionService diz que, se você se pegar adicionando o mesmo script a muitos objetos, um script que usa o CollectionService pode ser melhor. O GetTagged devolve as portas que existem quando o script começa, e o GetInstanceAddedSignal pega as portas que recebem a tag ou são adicionadas depois. O guia de scripts de cliente e servidor (em inglês) explica esse jeito de organizar um jogo.

Como fazer uma porta de correr

Selecione a VaultDoor, adicione um atributo string chamado Style e defina como Slide. A porta passa a se mover de lado em vez de girar: pela própria largura, ou por SlideDistance studs, se você definir esse atributo. Para deslizar para o outro lado, use uma distância negativa, como -4 em uma porta de 4 studs. Qualquer outra porta, inclusive a FrontDoor, desliza do mesmo jeito assim que tiver esse atributo.

O DoorService mede os dois tamanhos horizontais da porta, a largura e a espessura, e desliza ao longo do maior. Em um Model ele mede com GetExtentsSize, cuja caixa segue a orientação do pivot do model, então uma porta girada 90 graus depois de agrupada continua deslizando pela largura e não pela espessura. Em uma Part ele mede o próprio Size da part, então não gire o pivot de uma part de correr. Mover esse pivot não tem problema.

  • Portas duplas: duas metades com a tag, lado a lado, as duas com Style Slide, e uma delas com SlideDistance negativo, para se separarem no meio. Para portas duplas de girar, ponha o pivot de cada metade na borda de fora e dê a uma delas um OpenAngle negativo. Cada metade tem o próprio prompt e abre sozinha. Se as metades se moverem uma contra a outra, passe o sinal de menos para a outra metade.
  • Um portão que sobe: este script só desliza ao longo da largura da porta. Para levantar portas, defina direction no script como Vector3.yAxis (aí toda porta de correr sobe) e dê a cada uma um SlideDistance igual à altura dela.
  • Uma porta de física: o tutorial de objetos móveis da Roblox move parts ao longo de um eixo com um PrismaticConstraint. Como a porta com dobradiça, isso é física, sem prompt nem trava, a não ser que você programe.

Tranque uma porta com chave

Uma porta trancada abre só para um jogador que tem uma Tool com o nome certo. Faça a chave, depois diga o nome dela à porta:

  1. Passe o mouse sobre StarterPack, clique em + e insira uma Tool chamada RedKey. Insira nela uma Part chamada Handle, a part que o personagem segura, e confira que essa part não está ancorada: uma part ancorada em uma tool prende o personagem no lugar. Desmarque também o CanBeDropped da Tool se os jogadores não devem poder largar a chave para outra pessoa: enquanto ele está marcado, Backspace larga a tool equipada no Workspace.
  2. Selecione a VaultDoor, adicione um atributo string chamado KeyName e defina como RedKey. O nome de objeto do prompt passa a dizer Needs RedKey.

O DoorService procura a chave em dois lugares. Uma Tool fica na Backpack do jogador até ele equipar, e equipar a leva para o personagem, então a porta abre com a chave na barra de itens ou na mão. A checagem roda no servidor porque o guia de segurança da Roblox cita exatamente este caso, "o jogador tem a chave necessária para abrir uma porta?", como uma permissão que o servidor precisa verificar. Só abrir exige a chave: qualquer um pode fechar uma porta aberta, e ela fecha sozinha depois de AutoCloseSeconds.

O StarterPack dá a chave para todo mundo a cada spawn, o que serve para testar. Em um jogo de verdade, entregue a chave de outro jeito:

  • Por uma loja: o guia de GUI de loja entrega Tools do ServerStorage para a Backpack e o StarterGear de quem compra.
  • Por um personagem: o guia de diálogo de NPC entrega uma Tool de ServerStorage.DialogueItems quando o jogador escolhe uma opção com a ação GiveItem. Coloque uma Tool chamada RedKey nessa pasta e dê a uma opção do DialogueData action = "GiveItem" e item = "RedKey", e a chave vem de uma conversa.
  • Como item de inventário: com o sistema de inventário, um item de chave funciona assim que o jogador o equipa, porque equipar coloca uma cópia da Tool dele na Backpack e na mão.

Uma chave na Backpack se perde quando o personagem morre, porque o Roblox enche a Backpack de novo a partir do StarterPack e do StarterGear a cada spawn. Para mantê-la, coloque também uma cópia no StarterGear do jogador, como faz o guia da loja. Para gastar a chave no uso, ache a Tool da chave na Backpack ou no personagem do jogador e destrua no handler do Triggered, logo depois que a checagem da chave passar.

O que os tutoriais antigos de porta erram

Se você está comparando este guia com um vídeo ou um post de fórum, estes são os padrões que causam a maioria dos tópicos de "minha porta não funciona", e o que este guia faz no lugar.

Padrões comuns em tutoriais de porta, e o que este guia faz no lugar
O tutorialO problemaEste guia
Faz tween do CFrame de um Model de portaA referência do Model não lista a propriedade CFrame nem Position. O WorldPivot só define onde fica o pivot do model, então fazer tween dele move o ponto do pivot e deixa as parts onde estão.Faz tween de um NumberValue e move o model inteiro com PivotTo.
Move um model com SetPrimaryPartCFrameSubstituído: a Roblox manda usar PivotTo em trabalhos novos.Usa PivotTo, que a Roblox chama de a principal função para mover Models por script.
Solda toda part a uma part de dobradiça e faz tween só da dobradiçaFunciona quando todo weld está certo, mas qualquer part sem weld fica para trás quando a dobradiça se move.Mantém toda part ancorada, sem welds. O PivotTo move a porta e tudo o que há dentro dela.
Copia o mesmo script para dentro de cada portaCada correção precisa ser repetida em toda cópia. A Roblox sugere marcar os objetos com uma tag e cuidar deles com um script só, com o CollectionService.Um DoorService e uma tag Door.
Abre a porta em um LocalScriptA porta abre só na tela daquele jogador, e todos os outros continuam vendo a porta fechada.O servidor move a porta, então todos os jogadores veem a mesma porta.
Abre a porta pelo TouchedO Touched dispara várias vezes seguidas em um único contato (página de debounce da Roblox), e o dispositivo de um jogador pode controlar quando o Touched dispara para o próprio personagem (documentação de segurança da Roblox).Um prompt que o servidor confere.
Move a porta passo a passo em um loop com wait()A Roblox marca o wait() como substituído pelo task.wait(), e um loop não consegue voltar no meio do caminho quando alguém aperta de novo.Um tween por movimento. Um tween novo no mesmo valor cancela o antigo, então a porta volta de onde está.
Confere a chave em um LocalScript, ou nem confereUm trapaceiro controla tudo no próprio dispositivo, então uma checagem no cliente não segura ninguém.O servidor procura a Tool na Backpack e no personagem do jogador.
Nenhum cooldown no promptO guia de segurança da Roblox diz que prompts estão abertos a abuso do mesmo jeito que remotes, então nada impede que um seja disparado sem parar.Um uso por porta a cada 0,3 segundo.

O que um trapaceiro consegue e não consegue fazer

Parta do princípio de que um trapaceiro controla tudo no próprio dispositivo, inclusive o personagem dele. Veja o que isso significa para estas portas.

O que um trapaceiro pode tentar, e o que o DoorService faz a respeito
O trapaceiro tentaResultadoPor quê
Disparar o prompt do outro lado do mapaIgnorado, a não ser que o personagem dele esteja na portaO DoorService mede da root part do personagem até a part do prompt e ignora tudo além de 14 studs. Ele pode teleportar o personagem para o lado da porta antes (veja a última linha), então a checagem de distância impede o uso de longe, não o teleporte.
Disparar muitas vezes por segundoNo máximo um uso por porta a cada 0,3 segundoO servidor guarda a hora do último uso de cada porta.
Abrir uma porta com chave sem a chaveRecusadoO servidor procura a Tool na Backpack e no personagem dele, onde o servidor os enxerga, não na tela dele.
Usar a porta com o personagem mortoIgnoradoO DoorService confere se há um Humanoid com vida acima de 0 e uma root part.
Atravessar uma porta fechada mesmo assimPossívelA documentação de segurança da Roblox lista atravessar obstáculos físicos e mudar a própria colisão entre as coisas que um cliente pode fazer com o próprio personagem.
Teleportar para além da portaPossívelA mesma documentação lista teleportar o próprio personagem para qualquer posição.

Passo 3: Teste

  1. Aperte Play (F5). Ande até a FrontDoor: a até 8 studs, aparece um prompt com a ação Open e o nome de objeto Door. Segure E. Depois de 0,2 segundo a porta gira 90 graus em torno da borda da dobradiça em 0,6 segundo, e o prompt passa a dizer Close.
  2. Passe pela porta e espere. Quatro segundos depois de terminar de abrir, a porta fecha sozinha. Segure E enquanto ela está fechando: ela volta e abre de onde estava.
  3. Teste a trava. Se a RedKey está no StarterPack, mova para o ServerStorage por enquanto, aperte Play e segure E na VaultDoor: o prompt diz Needs RedKey e nada se move. Pare, ponha a RedKey de volta no StarterPack e jogue de novo: a VaultDoor abre, com a chave na barra de itens ou na mão.
  4. Confira o deslizar. A VaultDoor, um Model com Style Slide, anda de lado pela própria largura quando abre. Pare, selecione a VaultDoor, gire 90 graus com a ferramenta Rotate e jogue de novo: ela ainda deve deslizar pela largura, não pela espessura. Gire de volta quando terminar.
  5. Escolha Server & Clients no menu de modo de teste, defina 2 clientes e aperte Play. Abra uma porta na janela de um cliente: ela está aberta na outra janela também, e fecha nas duas.
  6. Pare o jogo, selecione uma porta e aperte Ctrl+D para duplicar, depois leve a cópia para outro vão. Confira que a cópia ainda lista Door em Tags, depois aperte Play: a cópia funciona sem nenhum script a mais.

Mantenha a janela Output aberta (menu Window, depois Output). O DoorService não imprime nada quando funciona. Um aviso de que uma porta "has no part to put the prompt on" quer dizer que um Model com a tag não tem parts dentro. Veja os Erros comuns para o resto.

Indo além

Portas automáticas

Para uma porta que abre quando alguém chega perto, chame move(true) de dentro do setUpDoor em vez de esperar o prompt. No fim do setUpDoor, comece um loop com task.spawn, porque um loop comum ali nunca termina e o DoorService nunca passaria da primeira porta. Deixe o loop rodando só enquanto a porta estiver no jogo: task.spawn(function() while door.Parent do ... task.wait(0.5) end end). Dentro do loop, confira com workspace:GetPartBoundsInBox se há um personagem dentro de uma caixa em volta do vão, e chame move(true) quando houver e a porta estiver fechada. O fechamento automático a fecha como antes. Defina o Enabled do prompt como false se a porta só deve abrir sozinha.

Portas VIP

O guia de game pass (em inglês) já monta uma porta VIP que os donos do passe atravessam direto, usando collision groups. Para uma porta VIP que abre com E, adicione mais uma checagem no handler do Triggered, ao lado da checagem da chave: retorne a não ser que player:GetAttribute("OwnsPass_VIP") == true, o atributo que o script de servidor do guia de game pass define. Leia esse atributo só no servidor.

Um teclado de código

Para uma porta que abre com um código digitado, guarde o código em um Script de servidor ou no ServerStorage, que os jogadores nunca recebem, e nunca em um LocalScript, onde um trapaceiro consegue ler. O LocalScript do teclado envia só os dígitos digitados por um RemoteEvent. No servidor, confira se o jogador está perto da porta, limite a frequência das tentativas, compare os dígitos e só então chame move(true). O guia de RemoteEvents mostra como conferir o que um remote recebe.

Sons

Coloque um Sound dentro da part da porta, para ele tocar a partir da posição dessa part, e chame o método Play dele no começo do move. Ou toque o som em um LocalScript que escuta o atributo Open da porta com GetAttributeChangedSignal("Open"), já que o servidor define esse atributo a cada movimento.

Portas adicionadas com o jogo rodando

Clone portas novas a partir de um modelo fechado no ServerStorage. O DoorService lê a posição fechada de uma porta quando ela aparece, então a cópia de uma porta que estava aberta naquele momento trataria a posição aberta como fechada. Leve a cópia até o vão dela com PivotTo antes de definir o Parent como Workspace, para o DoorService registrar aquele lugar como fechado. Prompts e valores antigos que vêm com uma cópia são removidos automaticamente. Para uma porta que leva os jogadores a outra área ou a outro place, veja o guia de teleporte.

Erros comuns e como resolver

Abra a janela Output (menu Window, depois Output) antes de apertar Play. A maioria dos problemas de porta vem de uma tag, um pivot ou um atributo que não está bem como o script espera.

Nenhum prompt aparece na porta

Confira nesta ordem: o DoorService é um Script, não um LocalScript, direto no ServerScriptService; a porta tem a tag Door com D maiúsculo, no próprio Model quando a porta é um Model; a porta é uma part (uma Part, MeshPart ou outra BasePart) ou um Model; e você está a até 8 studs da part em que o prompt fica. Um aviso no Output de que a porta "has no part to put the prompt on" quer dizer que o Model com a tag não tem parts dentro.

A porta cai, desliza sozinha ou é empurrada quando o jogo começa

Alguma part dela não está ancorada. Selecione todas as parts da porta e marque Anchored. Parts ancoradas nunca se movem pela física, mas o DoorService ainda consegue movê-las.

Mudei um atributo, mas a porta ignora

Confira três coisas. O tipo: OpenAngle, SlideDistance, OpenSeconds e AutoCloseSeconds precisam ser atributos number, e Style e KeyName precisam ser atributos string; o DoorService usa o padrão quando o tipo está errado. A grafia: os nomes são comparados exatamente, então openAngle é outro atributo. Os valores também são comparados exatamente: Style precisa ser Slide com S maiúsculo e sem espaços. O momento: o DoorService lê os atributos uma vez, quando prepara a porta, então uma mudança feita durante um teste não faz nada até você jogar de novo.

A porta gira para o lado errado, ou tomba de lado

Para girar para o outro lado, deixe o OpenAngle negativo, por exemplo -90. Se ela gira em torno de um eixo deitado em vez de uma dobradiça em pé, o próprio pivot foi girado: ligue o Pivot na aba Model e gire o pivot de volta até ele ficar em pé.

Uma porta de correr entra na parede ou anda só um pouco

Dê a ela um SlideDistance negativo para deslizar para o outro lado. Se ela anda de menos ou demais, defina o SlideDistance com o número de studs que você quer em vez de depender da largura medida.

Tenho a chave, mas a porta continua fechada

A chave precisa ser uma Tool, não uma Part nem um Model, e o nome dela precisa ser igual ao KeyName exatamente, inclusive as maiúsculas. Ela precisa estar na sua Backpack ou na sua mão. Confira também se o KeyName da porta é um atributo string.

Crie com o RoCode

Se você prefere não montar isso à mão, o RoCode pode construir tudo no jogo que você tem aberto. O RoCode é um agente de IA independente para Roblox Studio, não feito pela Roblox: você descreve a mudança em um chat na web, e o plugin dele para o Studio cria os scripts e as instâncias no seu Explorer, então não há código para colar.

Você digita

Faça as portas com a tag Door abrirem com um prompt de segurar E: girar 90 graus em torno do pivot em 0,6 segundo, fechar depois de 4 segundos, deslizar quando o atributo Style for Slide, e continuar fechadas a não ser que o jogador tenha a Tool com o nome que está em KeyName. Tudo no servidor, com checagem de distância.

O RoCode faz
  • Pode olhar o seu jogo quando um passo precisa, com Search Game e Search Scripts, para aproveitar itens, remotes ou código de salvamento que você já tem em vez de adicionar um segundo sistema
  • Escreve o Script no ServerScriptService com Create Script, e pode criar uma part de porta com Create Instance e definir nela atributos como Style e KeyName
  • É instruído a checar a compilação de cada script que escreve com Check Script, que compila o script no Studio sem rodá-lo
  • Cria um ponto de desfazer antes e depois de cada lote de mudanças, então Ctrl+Z volta um lote de cada vez

Confira o pivot de cada porta com a ferramenta Pivot do Studio antes de testar: a porta gira em torno dele. Com o plugin 3.9 ou mais recente, o RoCode pode rodar um teste curto e ler os erros, e com o plugin 3.9.15 ou mais recente ele pode controlar um personagem de teste que anda e aperta teclas, mas ele confere só o que escolheu testar, então ande até cada porta e segure E você mesmo. Como o RoCode se conecta ao Studio.

Perguntas frequentes

Como fazer uma porta abrir com E no Roblox Studio?

Coloque um ProximityPrompt na porta e conecte o evento Triggered dele em um Script de servidor, que move a porta. O DoorService faz as duas coisas para toda porta com a tag Door. E é a tecla padrão do prompt, e o Roblox mostra a entrada certa para teclados, controles e telas de toque.

Por que a minha porta gira em torno do meio?

O pivot dela ainda está no centro. Ligue o Pivot na aba Model e arraste o pivot até a borda da dobradiça; o script gira a porta em torno do pivot.

Como fazer uma porta de correr?

Defina o atributo Style da porta como Slide. Ela anda de lado pela própria largura, ou por SlideDistance studs; use uma distância negativa para deslizar para o outro lado.

Dá para fazer uma porta sem script?

Sim. O tutorial de porta com dobradiça da Roblox prende uma porta não ancorada ao batente com um HingeConstraint, com limites, então os jogadores a empurram ao andar contra ela. Essa porta não tem prompt, trava nem fechamento automático.

Como fazer uma porta que só VIPs conseguem abrir?

Use a porta VIP do guia de game pass (em inglês), que deixa os donos do passe atravessarem, ou adicione ao handler do Triggered do DoorService uma checagem que lê no servidor se o jogador tem o passe antes de abrir, como o atributo OwnsPass_VIP que aquele guia define.

Por que a minha porta abre para mim, mas não para os outros jogadores?

Ela está sendo aberta em um LocalScript, e uma mudança feita por um LocalScript fica no dispositivo daquele jogador. Leve o código de abrir para um Script de servidor, como faz o DoorService, para a mudança chegar a todos.

Fontes e leitura extra

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

Teste o RoCode no seu próprio jogo.

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