Tutorial · Sistemi di gioco

Come fare una porta in Roblox Studio

A una porta funzionante su Roblox servono tre cose: qualcosa che il giocatore preme (un ProximityPrompt con la scritta "Open"), un movimento fluido (TweenService) e un server che applica il cambiamento, così tutti i giocatori vedono la stessa porta. In questa guida costruiamo un solo script che lo fa per ogni porta con un tag, a battente o scorrevole, con una serratura a chiave opzionale: il server controlla la chiave prima di aprire qualsiasi cosa.

Aggiornato il 20 novembre 202623 min di letturaScritto da

In breve

Costruisci la porta come Part o Model, spunta Anchored, sposta il suo pivot sul bordo con i cardini (scheda Model, Pivot) e aggiungi il tag Door nella finestra Properties. Un solo Script in ServerScriptService trova tutte le porte con il tag tramite CollectionService, aggiunge un ProximityPrompt ("Open", tenere premuto E) e sull'evento Triggered fa il tween di un NumberValue da 0 a 1, muovendo la porta con door:PivotTo(closedPivot:Lerp(openPivot, alpha)). Gli attributi su ogni porta impostano il tipo a battente o scorrevole, l'angolo, il tempo, la chiusura automatica e la chiave.

  • Non puoi fare il tween della posizione di un Model direttamente: un Model non ha una proprietà CFrame o Position, e il suo WorldPivot imposta solo la posizione del pivot. Fai il tween di un NumberValue e muovi la porta con PivotTo: Roblox lo indica come il modo principale per muovere i modelli da uno script.
  • Apri le porte sul server. Una porta aperta da un LocalScript si muove solo sullo schermo di quel giocatore.
  • Controlla chiave e distanza sul server. La guida di Roblox sulla sicurezza dice che un ProximityPrompt si può sfruttare in modo malevolo proprio come un RemoteEvent, e lì stesso fa l'esempio di un controllo che il server deve fare: se il giocatore ha la chiave necessaria per aprire la porta.
In questa pagina
  1. Come funziona
  2. 1. Costruire la porta
  3. 2. Script della porta
  4. Porte scorrevoli
  5. Porte con chiave
  6. Vecchi tutorial
  7. Limiti della protezione
  8. 3. Prova
  9. Estensioni
  10. Common errors
  11. Con RoCode
  12. Domande frequenti
  13. Fonti e letture

Come funziona una porta con script

IllustrazioneTenere premuto E per 0.2 secondi apre la porta in 0.6 secondi, e 4 secondi dopo l'apertura completa si chiude da sola (qui accelerato). VaultDoor resta chiusa per un giocatore senza RedKey.

Una porta che funziona in un gioco vero la deve muovere il server. Se la muove un LocalScript, la porta si apre sullo schermo di un giocatore e resta chiusa per tutti gli altri, perché un cambiamento fatto dal client resta su quel dispositivo (vedi cosa si replica e cosa no (in inglese)). Per questo in questa guida il dispositivo del giocatore mostra solo il prompt e segnala la pressione del tasto, e tutto il resto lo fa un solo Script sul server. Un uso della porta funziona così:

  1. Il giocatore si avvicina alla porta a meno di 8 stud, e compare un prompt con l'azione Open, il nome dell'oggetto Door e il tasto E della tastiera. Su gamepad o touchscreen Roblox mostra il pulsante adatto.
  2. Il giocatore tiene premuto E per 0.2 secondi. L'evento Triggered del prompt scatta sul server con quel giocatore.
  3. DoorService controlla il giocatore: vivo, abbastanza vicino, non sta spammando il prompt e porta la chiave, se la porta la richiede.
  4. Lo script fa il tween di un numero da 0 (chiusa) a 1 (aperta). A ogni cambio del numero, con PivotTo sposta la porta di quella frazione del percorso dalla posizione chiusa a quella aperta.
  5. Quattro secondi dopo l'apertura completa la porta si chiude allo stesso modo. Una pressione durante il movimento fa tornare indietro la porta da dove si trova.
Di cosa è fatto il sistema delle porte
ElementoDove si trovaCosa fa
Script DoorServiceServerScriptServiceTrova tutte le porte, aggiunge a ognuna un prompt, controlla ogni uso e muove la porta. È l'unico script di questa guida.
Tag DoorSu ogni Part o Model della portaIndica cosa è una porta. I tag si aggiungono nella finestra Properties e si salvano insieme al place.
Attributi, per esempio Style e KeyNameSu ogni porta (opzionali)Le impostazioni di una porta: a battente o scorrevole, angolo, velocità, chiusura automatica e chiave.
ProximityPrompt DoorPromptDentro la porta (lo aggiunge DoorService)Mostra "Open" o "Close" e fa scattare Triggered quando il giocatore tiene premuto E.
NumberValue DoorProgressDentro la porta (lo aggiunge DoorService)Il numero che il tween muove tra 0 e 1. Ogni cambio muove la porta.
Tool RedKey (opzionale)StarterPack, per i testLa chiave della porta chiusa a chiave. Va bene qualsiasi Tool, se il suo nome coincide con il KeyName della porta.
L'Explorer a guida finita. Entrambe le porte hanno il tag Door, e VaultDoor ha anche gli attributi Style = Slide e KeyName = RedKey. Quando il gioco è avviato, DoorService aggiunge DoorProgress a ogni porta e DoorPrompt alla parte su cui sta il 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

Passo 1: costruisci la porta e imposta il cardine

  1. Nell'Explorer passa il mouse su Workspace, clicca sul pulsante + e inserisci una Part. Chiamala FrontDoor, imposta Size a circa 4, 7, 0.5 (4 stud di larghezza, 7 di altezza, mezzo stud di spessore) e mettila nel vano della porta. Va bene anche una porta fatta di più parti: selezionale e premi Ctrl+G per raggrupparle in un Model.
  2. Spunta Anchored su ogni parte della porta e lascia CanCollide attivo. Le parti ancorate non si muovono mai per gravità o collisioni, ma uno script può comunque muoverle, ed è proprio quello che fa DoorService.
  3. Imposta il cardine. Seleziona la porta, apri la scheda Model e attiva Pivot. Clicca e tieni premuta la piccola freccia nell'angolo del pulsante Pivot e spunta Snap, così il pivot si aggancia ai punti di riferimento su angoli, spigoli e centri. Trascina il pivot sul bordo della porta dove starebbero i cardini. Per una porta scorrevole il pivot può restare al centro.
  4. Aggiungi il tag. Con la porta ancora selezionata, scorri la finestra Properties fino a Tags, clicca su + e scrivi Door con la D maiuscola. Se la porta è un Model, metti il tag sul Model stesso, non sulle parti all'interno.
  5. Costruisci una seconda porta, ti servirà nelle sezioni sulle porte scorrevoli e sulla chiave. Inserisci in Workspace altre due Part: Panel di circa 4, 7, 0.5 e Knob di circa 0.5, 0.5, 0.5, appoggiata a una delle facce di Panel. Selezionale entrambe, premi Ctrl+G e rinomina il nuovo Model in VaultDoor. Ancora entrambe le parti, metti il modello nel secondo vano e aggiungi il tag Door al Model. Il suo pivot può restare al centro, perché questa porta sarà scorrevole.

Il pivot conta perché una porta a battente ruota attorno a lui. Se lo lasci al centro, la porta girerà su se stessa come una porta girevole di un negozio. Per una parte, il pivot che imposti si salva come PivotOffset, e GetPivot ne tiene conto, quindi lo script ruota la porta esattamente attorno al punto che hai scelto. Se un Model ha una PrimaryPart, il pivot del modello è il pivot di quella parte, e DoorService mette lì anche il prompt. Senza PrimaryPart, il prompt finisce sulla prima parte trovata dentro il modello. Se imposti una PrimaryPart, fallo prima di spostare il pivot: assegnare la PrimaryPart sposta il pivot del modello su quello della parte, come nota la pagina di Roblox sui Pivot tools.

Impostazioni della porta (attributi)

Ogni porta funziona con i valori predefiniti della tabella qui sotto. Per cambiare una porta, selezionala, scorri la finestra Properties fino a Attributes, clicca su +, scrivi il nome, scegli il tipo e clicca su Save, poi imposta il valore. DoorService legge gli attributi una sola volta, quando prepara la porta, quindi cambiali a gioco fermo.

Attributi opzionali su ogni porta
AttributoTipoPredefinitoCosa fa
StylestringSwingSwing ruota la porta attorno al suo pivot. Slide la fa scorrere di lato lungo la larghezza.
OpenAnglenumber90Di quanti gradi ruota una porta a battente. Un numero negativo la apre dall'altra parte. Tieni il valore tra -179 e 179: la porta segue sempre l'arco più breve, quindi DoorService limita l'angolo a questi estremi.
SlideDistancenumberla sua larghezzaDi quanti stud scorre una porta scorrevole lungo la sua larghezza. Un numero negativo la fa scorrere dall'altra parte.
OpenSecondsnumber0.6Quanto dura un'apertura o chiusura completa, tra 0.05 e 10.
AutoCloseSecondsnumber4Quanto resta completamente aperta la porta prima di chiudersi da sola. 0 la lascia aperta finché qualcuno non la chiude.
KeyNamestringnessunoIl nome del Tool che il giocatore deve avere per aprire la porta, per esempio RedKey. Non impostarlo per una porta che può aprire chiunque.

Passo 2: aggiungi lo script della porta

Passa il mouse su ServerScriptService, inserisci uno Script chiamato DoorService e incollaci il codice qui sotto. Gestisce tutte le porte del place, per quante ne marchi con il tag. Le tre impostazioni all'inizio valgono per tutte le porte; gli attributi del passo 1 cambiano una singola porta.

Script in ServerScriptService chiamato DoorService
-- Script in ServerScriptService chiamato DoorService.
-- Apre e chiude ogni Part o Model con il tag "Door" tramite un prompt da tenere premuto con E.
-- La porta la muove il server, quindi tutti i giocatori vedono la stessa porta, ed è sempre il server
-- a controllare distanza e chiave, così nessuno apre una porta chiusa a chiave da lontano.
--
-- Attributi opzionali su ogni porta (si impostano nella finestra Properties):
--   Style            string  "Swing" (predefinito) o "Slide"
--   OpenAngle        number  di quanti gradi la porta a battente ruota attorno al pivot (predefinito 90, da -179 a 179)
--   SlideDistance    number  di quanti stud la porta scorrevole scorre lungo la sua larghezza (predefinito: la sua larghezza)
--   OpenSeconds      number  quanto dura l'apertura (predefinito 0.6)
--   AutoCloseSeconds number  richiudi dopo questi secondi; 0 la lascia aperta (predefinito 4)
--   KeyName          string  nome del Tool che il giocatore deve avere, per esempio "RedKey"

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

local DOOR_TAG = "Door"
local PROMPT_DISTANCE = 8 -- stud
local MIN_SECONDS_BETWEEN_USES = 0.3 -- per ogni porta, contro lo spam del 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 o infinito inseriti nella finestra 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 -- è già una porta funzionante, oppure non è né una parte né un modello
	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 copia di una porta funzionante si porta dietro il vecchio prompt e il vecchio valore: li cancelliamo
	for _, leftover in door:GetDescendants() do
		if leftover.Name == "DoorPrompt" or leftover.Name == "DoorProgress" then
			leftover:Destroy()
		end
	end

	-- Calcoliamo le posizioni chiusa e aperta una volta sola, da dove si trova ora la porta
	local closedPivot = door:GetPivot()
	local openPivot: CFrame
	if attribute(door, "Style", "Swing") == "Slide" then
		-- Scorriamo lungo il lato orizzontale più lungo della porta, la sua larghezza. Un Model si misura lungo
		-- i lati del suo pivot, una Part con il proprio Size, quindi non ruotare il pivot di una parte scorrevole
		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 ruota sempre lungo l'arco più breve, quindi un angolo più grande aprirebbe la porta dalla parte sbagliata
		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", "")

	-- Facciamo il tween di un numero da 0 (chiusa) a 1 (aperta) e muoviamo la porta di conseguenza.
	-- PivotTo muove una singola parte o un intero modello attorno al suo 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) -- altri script possono leggerlo
		prompt.ActionText = if open then "Close" else "Open"
		-- Un nuovo tween sullo stesso valore annulla il vecchio, quindi la porta può tornare indietro a metà strada.
		-- Scaliamo il tempo in base a quanto le resta ancora da percorrere.
		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
		-- La guida di Roblox sulla sicurezza dice che dei prompt si può abusare come dei remote, quindi ricontrolliamo qui
		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 -- troppo lontano per usare il prompt onestamente
		end
		if keyName ~= "" and not isOpen and not hasKey(player, keyName) then
			return -- chiusa a chiave, e questo giocatore non ha la chiave
		end
		lastUse = now
		move(not isOpen)
	end)
end

-- Tutte le porte con il tag adesso e tutte quelle che lo riceveranno dopo (comprese le porte clonate dagli script)
for _, door in CollectionService:GetTagged(DOOR_TAG) do
	setUpDoor(door)
end
CollectionService:GetInstanceAddedSignal(DOOR_TAG):Connect(setUpDoor)

DoorService aggiunge da solo DoorPrompt e DoorProgress a ogni porta all'avvio del gioco, quindi non devi inserire nulla a mano. Tieni una sola copia dello script: gestisce già tutte le porte con il tag.

Cosa fa ogni parte di DoorService
Parte dello scriptCosa faPerché
attribute()Legge un attributo e restituisce il valore predefinito se l'attributo manca, ha il tipo sbagliato o non è un numero vero (NaN o infinito).Un errore di battitura nella finestra Properties dà una porta con le impostazioni predefinite, non una porta rotta.
doorsSetUp e il ciclo sui leftoverPrepara ogni porta una sola volta e prima cancella DoorPrompt o DoorProgress copiati da un'altra porta.Altrimenti la copia di una porta funzionante avrebbe due prompt, uno dei quali non funzionante.
closedPivot e openPivotCalcolati una volta sola, da dove si trova la porta al momento della preparazione. Una porta a battente ruota il pivot attorno al suo asse verticale; una scorrevole lo sposta lungo il lato più lungo della porta.Il Lerp dal pivot chiuso a quello aperto tiene fermo il pivot mentre la porta ruota, quindi il bordo con i cardini non si sposta per tutta la rotazione.
DoorProgress e PivotToIl tween cambia il numero; ogni cambio mette la porta in closedPivot:Lerp(openPivot, alpha).TweenService sa fare il tween di un NumberValue, e PivotTo muove una parte o un modello con tutte le sue parti in modo che il pivot finisca su quel CFrame.
Il promptHoldDuration 0.2, MaxActivationDistance 8, RequiresLineOfSight disattivato. Una porta chiusa a chiave mostra "Needs RedKey".Con la linea di vista attiva il prompt si nasconde quando qualcosa copre la sua parte; senza, il telaio o le altre parti di una porta Model non lo nascondono.
move()Avvia il tween verso 1 o verso 0, e scala il tempo in base a quanto deve ancora percorrere la porta.Un nuovo tween sullo stesso valore annulla il vecchio, quindi una porta fatta tornare indietro a metà strada torna con fluidità e ci mette metà del tempo.
Chiusura automaticaAspetta il tempo di apertura più AutoCloseSeconds, poi chiude la porta solo se moveCount non è cambiato.Un vecchio timer non sbatterà mai una porta che nel frattempo qualcuno ha chiuso e riaperto.
Controlli in TriggeredUn uso della porta ogni 0.3 secondi, personaggio vivo, non oltre 14 stud dalla parte con il prompt, e la chiave, ma solo per aprire.Di tutto quello che può far scattare il client si può abusare, quindi il server ripete i controlli. 14 stud sono gli 8 stud del prompt più 6 di margine per un giocatore che si è spostato mentre teneva premuto E.
Attributo OpenImpostato sulla porta a ogni movimento.Gli attributi impostati sul server si replicano a tutti i giocatori, quindi altri script, LocalScript compresi, possono ascoltarlo con GetAttributeChangedSignal("Open").

Marcare tutte le porte con un tag e gestirle da un solo script è l'approccio che consiglia Roblox stesso: il riferimento di CollectionService dice che se aggiungi lo stesso script a tanti oggetti, uno script con CollectionService può essere la scelta migliore. GetTagged restituisce le porte che esistono all'avvio dello script, e GetInstanceAddedSignal cattura le porte marcate o aggiunte più tardi. Questo modo di organizzare un place è spiegato nella guida agli script client e server (in inglese).

Come fare una porta scorrevole

Seleziona VaultDoor, aggiungi un attributo di tipo string chiamato Style e imposta il valore Slide. Ora la porta non ruota ma scorre di lato: della propria larghezza, o di SlideDistance stud se lo hai impostato. Per farla scorrere dall'altra parte, imposta una distanza negativa, per esempio -4 per una porta larga 4 stud. Qualsiasi altra porta, FrontDoor compresa, diventa scorrevole allo stesso modo appena riceve questo attributo.

DoorService misura le due dimensioni orizzontali della porta, larghezza e spessore, e la muove lungo la maggiore. Un Model lo misura con GetExtentsSize, il cui box segue l'orientamento del pivot del modello, quindi una porta ruotata di 90 gradi dopo il raggruppamento scorre comunque lungo la larghezza e non lo spessore. Una Part la misura con il Size della parte stessa, quindi non ruotare il pivot di una parte scorrevole. Spostare quel pivot invece va bene.

  • Porte doppie: due metà con il tag una accanto all'altra, entrambe con Style uguale a Slide, e una con SlideDistance negativo, così si separano dal centro. Per porte doppie a battente metti il pivot di ogni metà sul suo bordo esterno e dai a una metà un OpenAngle negativo. Ogni metà ha il suo prompt e si apre da sola. Se le metà scorrono una dentro l'altra, sposta il segno meno sull'altra metà.
  • Cancelli che si alzano: questo script muove la porta solo lungo la larghezza. Per far alzare le porte, imposta direction nello script a Vector3.yAxis (allora tutte le porte scorrevoli andranno verso l'alto) e dai a ognuna un SlideDistance uguale alla sua altezza.
  • Porta con la fisica: il tutorial di Roblox sugli oggetti in movimento muove le parti lungo un solo asse con un PrismaticConstraint. Come la porta con cardine, è fisica, senza prompt né serratura finché non li scrivi tu.

Come chiudere una porta a chiave

Una porta chiusa a chiave si apre solo per un giocatore che ha un Tool con il nome giusto. Crea la chiave, poi di' alla porta il suo nome:

  1. Passa il mouse su StarterPack, clicca su + e inserisci un Tool chiamato RedKey. Inseriscici una Part chiamata Handle, la parte che il personaggio tiene in mano, e assicurati che non sia ancorata: una parte ancorata in uno strumento inchioda il personaggio sul posto. Togli la spunta da CanBeDropped del Tool se i giocatori non devono lasciare la chiave a qualcun altro: finché è attiva, Backspace butta lo strumento equipaggiato in Workspace.
  2. Seleziona VaultDoor, aggiungi un attributo di tipo string chiamato KeyName e imposta il valore RedKey. Ora il nome dell'oggetto nel prompt dice Needs RedKey.

DoorService cerca la chiave in due posti. Un Tool sta nel Backpack del giocatore finché non viene equipaggiato, e l'equipaggiamento lo sposta nel personaggio, quindi la porta si apre sia che la chiave sia nella hotbar sia che sia in mano. Il controllo avviene sul server, perché la guida di Roblox sulla sicurezza cita proprio questo caso, se il giocatore ha la chiave di una porta, come un permesso che il server deve controllare. La chiave serve solo per aprire: chiunque può chiudere una porta aperta, e si chiude da sola dopo AutoCloseSeconds.

StarterPack dà la chiave a tutti a ogni spawn, e per i test è proprio quello che serve. In un gioco vero assegnala in un altro modo:

  • Da un negozio: la guida alla GUI del negozio dà un Tool da ServerStorage al Backpack e allo StarterGear di chi compra.
  • Da un personaggio: la guida ai dialoghi con gli NPC dà un Tool da ServerStorage.DialogueItems quando il giocatore sceglie un'opzione con l'azione GiveItem. Metti in quella cartella un Tool chiamato RedKey e imposta per l'opzione in DialogueData action = "GiveItem" e item = "RedKey", e la chiave verrà consegnata durante la conversazione.
  • Come oggetto dell'inventario: con il sistema di inventario un oggetto chiave funziona appena il giocatore lo equipaggia, perché l'equipaggiamento mette una copia del suo Tool nel Backpack e in mano.

Una chiave nel Backpack si perde quando il personaggio muore, perché Roblox a ogni spawn riempie di nuovo il Backpack da StarterPack e StarterGear. Per conservarla, metti una copia anche nello StarterGear del giocatore, come fa la guida al negozio. Se invece vuoi che la chiave si consumi, trova il Tool della chiave nel Backpack o nel personaggio del giocatore e distruggilo nel gestore Triggered, subito dopo un controllo della chiave riuscito.

Dove sbagliano i vecchi tutorial sulle porte

Se confronti questa guida con un video o un post sul forum, ecco i metodi che causano la maggior parte delle discussioni «la mia porta non funziona», e cosa fa invece questa guida.

Metodi comuni nei tutorial sulle porte e cosa fa invece questa guida
Il tutorialIl problemaQuesta guida
Fa il tween del CFrame di una porta ModelNel riferimento di Model non esiste una proprietà CFrame o Position. Il suo WorldPivot imposta solo la posizione del pivot del modello, quindi farne il tween sposta il punto del pivot, mentre le parti restano ferme.Fa il tween di un NumberValue e muove tutto il modello con PivotTo.
Muove il modello con SetPrimaryPartCFrameObsoleto: Roblox consiglia di usare PivotTo nei nuovi progetti.Usa PivotTo, che Roblox indica come la funzione principale per muovere un Model dagli script.
Salda tutte le parti a una parte cardine e fa il tween solo del cardineFunziona quando tutti i Weld sono al loro posto, ma ogni parte non saldata resta indietro quando il cardine si muove.Tiene tutte le parti ancorate, senza Weld. PivotTo muove la porta e tutto quello che contiene.
Copia lo stesso script in ogni portaOgni correzione va ripetuta in ogni copia. Roblox suggerisce di marcare gli oggetti con tag e gestirli con un solo script tramite CollectionService.Un solo DoorService e il tag Door.
Apre la porta in un LocalScriptLa porta si apre solo sullo schermo di quel giocatore, e tutti gli altri continuano a vederla chiusa.La porta la muove il server, quindi tutti i giocatori vedono la stessa porta.
Apre la porta con TouchedTouched scatta più volte di fila per un solo contatto (pagina di Roblox sul debounce), e il dispositivo del giocatore può controllare quando Touched scatta per il proprio personaggio (documentazione di Roblox sulla sicurezza).Un prompt controllato dal server.
Muove la porta a passi in un ciclo con wait()Roblox indica wait() come sostituito da task.wait(), e il ciclo non può tornare indietro a metà strada quando qualcuno preme di nuovo.Un tween per movimento. Un nuovo tween sullo stesso valore annulla il vecchio, quindi la porta torna indietro da dove si trova.
Controlla la chiave in un LocalScript o non la controlla affattoUn cheater controlla tutto sul proprio dispositivo, quindi un controllo sul client non ferma nessuno.Il server cerca il Tool nel Backpack e nel personaggio del giocatore.
Nessun cooldown sul promptLa guida di Roblox sulla sicurezza dice che i prompt sono vulnerabili agli abusi proprio come i remote, quindi niente impedisce di farlo scattare di continuo.Un uso della porta ogni 0.3 secondi.

Cosa può e cosa non può fare un cheater

Considera che un cheater controlla tutto sul proprio dispositivo, compreso il suo personaggio. Ecco cosa significa per queste porte.

Cosa può tentare un cheater e cosa fa DoorService
Il cheater prova aRisultatoPerché
Far scattare il prompt dall'altro capo della mappaIgnorato, se il suo personaggio non è vicino alla portaDoorService misura la distanza dalla parte root del personaggio alla parte con il prompt e ignora tutto ciò che è oltre 14 stud. Un cheater può prima teletrasportare il personaggio vicino alla porta (vedi l'ultima riga), quindi il controllo della distanza protegge dall'uso a distanza, non dal teletrasporto.
Farlo scattare molte volte al secondoNon più di un uso della porta ogni 0.3 secondiIl server tiene l'ora dell'ultimo uso di ogni porta.
Aprire la porta con chiave senza chiaveRifiutatoIl server cerca il Tool nel suo Backpack e nel personaggio come li vede lui, non sullo schermo del cheater.
Usare la porta mentre il personaggio è mortoIgnoratoDoorService controlla che ci sia un Humanoid con salute maggiore di 0 e una parte root.
Passare comunque attraverso la porta chiusaPossibileLa documentazione di Roblox sulla sicurezza elenca l'aggiramento di ostacoli fisici e la modifica delle proprie collisioni tra le cose che un client può fare con il suo personaggio.
Teletrasportarsi oltre la portaPossibileLa stessa documentazione cita il teletrasporto del proprio personaggio in qualsiasi punto.

Passo 3: prova

  1. Premi Play (F5). Avvicinati a FrontDoor: entro 8 stud compare un prompt con l'azione Open e il nome dell'oggetto Door. Tieni premuto E. Dopo 0.2 secondi la porta si spalanca di 90 gradi attorno al bordo con i cardini in 0.6 secondi, e ora il prompt dice Close.
  2. Attraversa la porta e aspetta. Quattro secondi dopo l'apertura completa la porta si chiude da sola. Tieni premuto E mentre si chiude: torna indietro e si apre da dove si trovava.
  3. Prova la serratura. Se RedKey è in StarterPack, spostala per ora in ServerStorage, premi Play e tieni premuto E davanti a VaultDoor: il prompt dice Needs RedKey, e non si muove nulla. Ferma il gioco, rimetti RedKey in StarterPack e riavvia: VaultDoor si apre sia che la chiave sia nella hotbar sia che sia in mano.
  4. Prova la porta scorrevole. VaultDoor, un Model con Style Slide, all'apertura scorre di lato della sua larghezza. Ferma il gioco, seleziona VaultDoor, ruotala di 90 gradi con lo strumento Rotate e riavvia: deve comunque scorrere lungo la larghezza, non lo spessore. Quando hai finito, rimettila com'era.
  5. Scegli Server & Clients nel menu a tendina delle modalità di test, imposta 2 client e premi Play. Apri la porta nella finestra di un client: è aperta anche nell'altra finestra e si chiude in entrambe.
  6. Ferma il gioco, seleziona una porta e premi Ctrl+D per duplicarla, poi sposta la copia in un altro vano. Controlla che nei Tags della copia ci sia ancora Door e premi Play: la copia funziona senza nessuno script in più.

Tieni aperta la finestra Output (menu Window, poi Output). Quando tutto funziona, DoorService non stampa nulla. Un avviso che dice che una porta "has no part to put the prompt on" significa che dentro il Model con il tag non ci sono parti. Per il resto vedi la sezione Errori comuni.

Come estenderla

Porte automatiche

Per far aprire la porta quando qualcuno si avvicina, chiama move(true) dall'interno di setUpDoor, senza aspettare il prompt. Alla fine di setUpDoor avvia un ciclo con task.spawn, perché un ciclo normale lì non finirebbe mai, e DoorService non andrebbe oltre la prima porta. Fallo girare solo finché la porta è nel gioco: task.spawn(function() while door.Parent do ... task.wait(0.5) end end). Dentro il ciclo controlla con workspace:GetPartBoundsInBox se c'è un personaggio dentro un box attorno al vano, e chiama move(true) quando c'è e la porta è chiusa. Poi, come prima, la chiuderà la chiusura automatica. Imposta Enabled del prompt a false se la porta deve aprirsi solo da sola.

Porte VIP

La guida ai game pass (in inglese) costruisce già una porta VIP che i possessori del pass attraversano direttamente, con i gruppi di collisione. Per una porta VIP che si apre con E, aggiungi un altro controllo nel gestore Triggered accanto al controllo della chiave: fai return se non vale player:GetAttribute("OwnsPass_VIP") == true, l'attributo che imposta lo script del server della guida ai game pass. Leggilo solo sul server.

Tastierino con codice

Per una porta che si apre inserendo un codice, tieni il codice in uno Script del server o in ServerStorage, che i giocatori non ricevono mai, e mai in un LocalScript, dove un cheater può leggerlo. Il LocalScript del tastierino invia tramite un RemoteEvent solo le cifre inserite. Sul server controlla che il giocatore sia vicino alla porta, limita la frequenza dei tentativi, confronta le cifre e solo allora chiama move(true). La guida ai RemoteEvent mostra come controllare quello che riceve un remote.

Suoni

Metti un Sound dentro una parte della porta, così suona dalla posizione di quella parte, e chiama il suo metodo Play all'inizio di move. Oppure riproducilo da un LocalScript che ascolta l'attributo Open della porta con GetAttributeChangedSignal("Open"), visto che il server imposta questo attributo a ogni movimento.

Porte aggiunte durante il gioco

Clona le nuove porte da un modello chiuso in ServerStorage. DoorService legge la posizione chiusa di una porta nel momento in cui compare, quindi la copia di una porta che in quel momento era aperta prenderebbe la sua posizione aperta per quella chiusa. Metti la copia nel vano con PivotTo prima di impostare il suo Parent a Workspace, così DoorService ricorda quel punto come chiuso. I vecchi prompt e valori arrivati con la copia vengono cancellati automaticamente. Per una porta che porta i giocatori in un'altra zona o in un altro place, leggi la guida al teletrasporto.

Errori comuni e soluzioni

Apri la finestra Output (menu Window, poi Output) prima di premere Play. La maggior parte dei problemi con le porte nasce da un tag, un pivot o un attributo appena diversi da quello che lo script si aspetta.

Il prompt non compare sulla porta

Controlla in ordine: DoorService è uno Script, non un LocalScript, e sta direttamente in ServerScriptService; la porta ha il tag Door con la D maiuscola, e per una porta Model sul Model stesso; la porta è una parte (Part, MeshPart o un altro BasePart) o un Model; e sei a non più di 8 stud dalla parte su cui sta il prompt. Un avviso nell'Output che dice che la porta "has no part to put the prompt on" significa che dentro il Model con il tag non ci sono parti.

La porta cade, scivola via o viene spinta quando il gioco parte

Una sua parte non è ancorata. Seleziona tutte le parti della porta e spunta Anchored. Le parti ancorate non si muovono mai per la fisica, ma DoorService può comunque muoverle.

Ho cambiato un attributo, ma la porta lo ignora

Controlla tre cose. Il tipo: OpenAngle, SlideDistance, OpenSeconds e AutoCloseSeconds devono essere attributi di tipo number, e Style e KeyName di tipo string; con il tipo sbagliato DoorService usa il valore predefinito. La scrittura: i nomi si confrontano esattamente, quindi openAngle è un altro attributo. Anche i valori si confrontano esattamente: Style deve essere Slide con la S maiuscola e senza spazi. Il momento: DoorService legge gli attributi una sola volta, quando prepara la porta, quindi un cambio durante il playtest non ha effetto finché non riavvii il gioco.

La porta si apre dalla parte sbagliata o si inclina di lato

Per farla aprire dall'altra parte, rendi OpenAngle negativo, per esempio -90. Se ruota attorno a un asse orizzontale invece che attorno al cardine verticale, è il pivot stesso a essere ruotato: attiva Pivot nella scheda Model e ruota il pivot finché non torna verticale.

La porta scorrevole entra nel muro o si sposta pochissimo

Dalle un SlideDistance negativo, così scorre dall'altra parte. Se si sposta troppo poco o troppo, imposta in SlideDistance il numero di stud che vuoi invece di affidarti alla larghezza misurata.

Ho la chiave, ma la porta non si apre

La chiave deve essere un Tool, non una Part o un Model, e il suo nome deve coincidere esattamente con KeyName, maiuscole comprese. Deve stare nel tuo Backpack o essere in mano. Controlla anche che KeyName sulla porta sia un attributo di tipo string.

Farlo con RoCode

Se non hai voglia di preparare tutto questo a mano, RoCode può costruirlo nel place che hai aperto. RoCode è un agente IA indipendente per Roblox Studio, non di Roblox: descrivi la modifica nella chat web, e il suo plugin per Studio crea script e oggetti nel tuo Explorer, quindi non devi incollare codice.

Tu scrivi

Fai in modo che le porte con il tag Door si aprano con un prompt da tenere premuto con E: rotazione di 90 gradi attorno al pivot in 0.6 secondi, chiusura dopo 4 secondi, scorrimento invece della rotazione quando l'attributo Style è Slide, e la porta resta chiusa se il giocatore non ha un Tool con il nome di KeyName. Tutto sul server, con controllo della distanza.

RoCode fa
  • Può esaminare il tuo place quando un passo lo richiede, con Search Game e Search Scripts, per basarsi su oggetti, remote o codice di salvataggio che hai già invece di aggiungere un secondo sistema
  • Scrive lo Script in ServerScriptService con Create Script, può creare la parte della porta con Create Instance e impostarci attributi come Style e KeyName
  • Ha l'istruzione di controllare la compilazione di ogni script che scrive con Check Script, che lo compila in Studio senza eseguirlo
  • Mette un punto di annullamento prima e dopo ogni blocco di modifiche, quindi Ctrl+Z annulla un blocco alla volta

Prima di provare, controlla il pivot di ogni porta con lo strumento Pivot di Studio: la porta ruota attorno a lui. Con il plugin 3.9 o successivo RoCode può avviare un breve playtest e leggere gli errori, e con il plugin 3.9.15 o successivo può guidare un personaggio di test che cammina e preme tasti, ma controlla solo quello che ha deciso di testare, quindi avvicinati a ogni porta e tieni premuto E tu stesso. Come RoCode si collega a Studio.

Domande frequenti

Come faccio ad aprire una porta con E in Roblox Studio?

Metti un ProximityPrompt nella porta e collega il suo evento Triggered in uno Script del server che muove la porta. DoorService fa entrambe le cose per ogni porta con il tag Door. E è il tasto predefinito del prompt, e Roblox mostra l'input giusto per tastiere, gamepad e touchscreen.

Perché la mia porta gira attorno al suo centro?

Il suo pivot è ancora al centro. Attiva Pivot nella scheda Model e trascina il pivot sul bordo con i cardini; lo script ruota la porta attorno al pivot.

Come faccio una porta scorrevole?

Imposta l'attributo Style della porta a Slide. Scorre di lato della sua larghezza o di SlideDistance stud; una distanza negativa la fa scorrere dall'altra parte.

Si può fare una porta senza script?

Sì. Il tutorial di Roblox sulla porta con cardine attacca una porta non ancorata al telaio con un HingeConstraint con dei limiti, e i giocatori la aprono spingendola col corpo. Una porta così non ha prompt, serratura né chiusura automatica.

Come faccio una porta che possono aprire solo i VIP?

Usa la porta VIP della guida ai game pass (in inglese), che i possessori del pass attraversano, oppure aggiungi nel gestore Triggered di DoorService un controllo che prima dell'apertura legge sul server se il giocatore possiede il pass, per esempio l'attributo OwnsPass_VIP che imposta quella guida.

Perché la porta si apre per me ma non per gli altri giocatori?

La apre un LocalScript, e un cambiamento fatto da un LocalScript resta sul dispositivo di quel giocatore. Sposta il codice di apertura in uno Script del server, come in DoorService, così il cambiamento arriva a tutti.

Fonti e letture

Come è stato controllato il codice: ogni script di questa pagina supera il controllo dei tipi rigoroso di Luau con le definizioni dell'API di Roblox (luau-lsp, 20 novembre 2026). Il controllo dei tipi trova API scritte male e tipi sbagliati, non la logica del gioco, quindi provalo in Studio prima di pubblicare.

Prova RoCode nel tuo gioco.

Crediti gratis ogni giorno, senza carta. Installa il plugin, descrivi la funzione e controlla cosa compare in Studio.