Tutorial · Sisteme de joc

Cum să faci o ușă în Roblox Studio

O ușă funcțională în Roblox are nevoie de trei lucruri: ceva ce apasă jucătorul (un ProximityPrompt cu textul "Open"), o mișcare lină (TweenService) și un server care face schimbarea, ca toți jucătorii să vadă aceeași ușă. În acest ghid construim un singur script care face asta pentru fiecare ușă cu tag, batantă sau glisantă, cu o încuietoare opțională cu cheie: serverul verifică cheia înainte să deschidă ceva.

Actualizat 20 noiembrie 202621 min de cititAutor:

Pe scurt

Construiește ușa ca Part sau Model, bifează Anchored, mută-i pivotul pe marginea cu balamale (fila Model, Pivot) și adaugă tagul Door în fereastra Properties. Un singur Script în ServerScriptService găsește toate ușile cu tag prin CollectionService, adaugă un ProximityPrompt ("Open", E ținut apăsat) și la evenimentul Triggered face tween pe un NumberValue de la 0 la 1, mișcând ușa prin door:PivotTo(closedPivot:Lerp(openPivot, alpha)). Atributele de pe fiecare ușă stabilesc tipul batant sau glisant, unghiul, timpul, închiderea automată și cheia.

  • Poziția unui Model nu se poate anima direct cu tween: un Model nu are proprietatea CFrame sau Position, iar WorldPivot-ul lui stabilește doar locul pivotului. Fă tween pe un NumberValue și mișcă ușa prin PivotTo: Roblox îl numește modul principal de a mișca modele dintr-un script.
  • Deschide ușile pe server. O ușă deschisă dintr-un LocalScript se mișcă doar pe ecranul acelui jucător.
  • Verifică cheia și distanța pe server. Ghidul de securitate Roblox spune că un ProximityPrompt poate fi folosit abuziv la fel ca un RemoteEvent și dă chiar un exemplu de verificare pe care serverul trebuie s-o facă: dacă jucătorul are cheia necesară ca să deschidă ușa.
Pe această pagină
  1. Cum funcționează
  2. 1. Construim ușa
  3. 2. Scriptul ușii
  4. Uși glisante
  5. Uși cu cheie
  6. Tutoriale vechi
  7. Limitele protecției
  8. 3. Verificare
  9. Extinderi
  10. Common errors
  11. Cu RoCode
  12. Întrebări frecvente
  13. Surse și lecturi suplimentare

Cum funcționează o ușă cu script

IlustrațieȚinerea lui E timp de 0.2 secunde deschide ușa în 0.6 secunde, iar la 4 secunde după deschiderea completă se închide singură (aici accelerat). VaultDoor rămâne închisă pentru jucătorul fără RedKey.

O ușă care funcționează într-un joc real trebuie mișcată de server. Dacă o mișcă un LocalScript, ușa se deschide pe ecranul unui singur jucător și rămâne închisă pentru toți ceilalți, pentru că o schimbare făcută de client rămâne pe acel dispozitiv (vezi ce se replică și ce nu). De aceea în acest ghid dispozitivul jucătorului doar arată promptul și raportează apăsarea tastei, iar tot restul îl face un singur Script de server. O folosire a ușii arată așa:

  1. Jucătorul se apropie de ușă la mai puțin de 8 studs și apare un prompt cu acțiunea Open, numele obiectului Door și tasta E de pe tastatură. Pe gamepad sau pe ecran tactil Roblox arată butonul potrivit.
  2. Jucătorul ține apăsat E 0.2 secunde. Evenimentul Triggered al promptului se declanșează pe server cu acest jucător.
  3. DoorService verifică jucătorul: e viu, destul de aproape, nu face spam cu promptul și poartă cheia, dacă ușa o cere.
  4. Scriptul face tween pe un număr de la 0 (închis) la 1 (deschis). La fiecare schimbare a numărului mută ușa prin PivotTo cu acea fracție din drumul de la poziția închisă la cea deschisă.
  5. La patru secunde după deschiderea completă, ușa se închide în același fel. O apăsare în timpul mișcării întoarce ușa din locul în care se află.
Din ce e alcătuit sistemul de uși
ElementUnde se aflăCe face
Script DoorServiceServerScriptServiceGăsește toate ușile, adaugă fiecăreia un prompt, verifică fiecare folosire și mișcă ușa. Singurul script din acest ghid.
Tagul DoorPe fiecare Part sau Model de ușăMarchează ce e ușă. Tagurile se adaugă în fereastra Properties și se salvează împreună cu place-ul.
Atribute, de exemplu Style și KeyNamePe fiecare ușă (opțional)Setările unei singure uși: batantă sau glisantă, unghi, viteză, închidere automată și cheie.
ProximityPrompt DoorPromptÎn ușă (îl adaugă DoorService)Arată "Open" sau "Close" și declanșează Triggered când jucătorul ține apăsat E.
NumberValue DoorProgressÎn ușă (îl adaugă DoorService)Numărul pe care tween-ul îl mișcă între 0 și 1. Fiecare schimbare mișcă ușa.
Tool RedKey (opțional)StarterPack, pentru testeCheia pentru ușa încuiată. Merge orice Tool, dacă numele lui se potrivește cu KeyName-ul ușii.
Explorer-ul după ce ai terminat ghidul. Ambele uși au tagul Door, iar VaultDoor mai are atributele Style = Slide și KeyName = RedKey. Când jocul rulează, DoorService adaugă DoorProgress în fiecare ușă și DoorPrompt în part-ul pe care stă promptul.
Workspace
  FrontDoor Part new
  VaultDoor Model new
    Panel Part new
    Knob Part new
ServerScriptService
  DoorService Script new
StarterPack
  RedKey Tool new
    Handle Part new

Pasul 1: construiește ușa și setează balamaua

  1. În Explorer treci cu mouse-ul peste Workspace, apasă butonul + și inserează un Part. Numește-l FrontDoor, setează Size la aproximativ 4, 7, 0.5 (4 studs lățime, 7 înălțime, jumătate de stud grosime) și pune-l în cadrul ușii. Merge și o ușă din mai multe part-uri: selectează-le și apasă Ctrl+G ca să le grupezi într-un Model.
  2. Bifează Anchored la fiecare part al ușii și lasă CanCollide activat. Part-urile ancorate nu se mișcă niciodată din cauza gravitației sau a coliziunilor, dar un script le poate mișca oricum, și exact asta face DoorService.
  3. Setează balamaua. Selectează ușa, deschide fila Model și activează Pivot. Apasă și ține săgeata mică din colțul butonului Pivot și bifează Snap, ca pivotul să se lipească de punctele de referință din colțuri, de pe muchii și din centre. Trage pivotul pe marginea ușii unde ar fi balamalele. La o ușă glisantă pivotul poate rămâne în centru.
  4. Adaugă tagul. Cu ușa încă selectată, derulează fereastra Properties până la Tags, apasă + și scrie Door cu D mare. Dacă ușa e un Model, pune tagul pe Model-ul însuși, nu pe part-urile din interior.
  5. Construiește o a doua ușă, îți va trebui în secțiunile despre ușile glisante și despre cheie. Inserează în Workspace încă două Part-uri: Panel de aproximativ 4, 7, 0.5 și Knob de aproximativ 0.5, 0.5, 0.5, lipit de una dintre fețele lui Panel. Selectează-le pe amândouă, apasă Ctrl+G și redenumește noul Model în VaultDoor. Ancorează ambele part-uri, pune modelul în al doilea cadru și adaugă tagul Door pe Model. Pivotul lui poate rămâne în centru, pentru că ușa asta va fi glisantă.

Pivotul contează, pentru că o ușă batantă se rotește în jurul lui. Dacă îl lași în centru, ușa se va învârti pe loc, ca o ușă rotativă de magazin. La un part, pivotul pe care l-ai setat se păstrează ca PivotOffset, iar GetPivot îl ia în calcul, așa că scriptul rotește ușa exact în jurul punctului ales de tine. Dacă un Model are PrimaryPart, pivotul modelului e pivotul acelui part, iar DoorService pune și promptul pe el. Fără PrimaryPart, promptul ajunge pe primul part găsit în model. Dacă setezi un PrimaryPart, fă-o înainte să muți pivotul: atribuirea PrimaryPart mută pivotul modelului în pivotul acelui part, cum notează pagina Roblox despre Pivot tools.

Setările ușii (atribute)

Orice ușă funcționează cu valorile implicite din tabelul de mai jos. Ca să schimbi o singură ușă, selecteaz-o, derulează fereastra Properties până la Attributes, apasă +, scrie numele, alege tipul și apasă Save, apoi setează valoarea. DoorService citește atributele o singură dată, când configurează ușa, așa că schimbă-le cât jocul e oprit.

Atribute opționale pe fiecare ușă
AtributTipImplicitCe face
StylestringSwingSwing rotește ușa în jurul pivotului ei. Slide o mută lateral de-a lungul lățimii.
OpenAnglenumber90Cu câte grade se rotește o ușă batantă. Un număr negativ o deschide în cealaltă parte. Ține valoarea între -179 și 179: ușa merge mereu pe arcul scurt, așa că DoorService limitează unghiul la aceste margini.
SlideDistancenumberlățimea eiCâți studs alunecă o ușă glisantă de-a lungul lățimii ei. Un număr negativ o mută în cealaltă parte.
OpenSecondsnumber0.6Cât durează deschiderea sau închiderea completă, între 0.05 și 10.
AutoCloseSecondsnumber4Cât stă ușa complet deschisă înainte să se închidă singură. 0 o lasă deschisă până o închide cineva.
KeyNamestringniciunulNumele Tool-ului pe care trebuie să-l aibă jucătorul ca să deschidă ușa, de exemplu RedKey. Nu-l seta pentru o ușă pe care o poate deschide oricine.

Pasul 2: adaugă scriptul ușii

Treci cu mouse-ul peste ServerScriptService, inserează un Script numit DoorService și lipește în el codul de mai jos. Controlează toate ușile din place, oricâte ai marca cu tag. Cele trei setări de la început se aplică tuturor ușilor; atributele de la pasul 1 schimbă o singură ușă.

Script în ServerScriptService cu numele DoorService
-- Script în ServerScriptService cu numele DoorService.
-- Deschide și închide fiecare Part sau Model cu tagul "Door" printr-un prompt cu E ținut apăsat.
-- Ușa o mișcă serverul, așa că toți jucătorii văd aceeași ușă, iar tot serverul
-- verifică distanța și cheia, așa că nimeni nu deschide o ușă încuiată de la distanță.
--
-- Atribute opționale pe fiecare ușă (se setează în fereastra Properties):
--   Style            string  "Swing" (implicit) sau "Slide"
--   OpenAngle        number  cu câte grade se rotește o ușă batantă în jurul pivotului (implicit 90, de la -179 la 179)
--   SlideDistance    number  câți studs alunecă o ușă glisantă de-a lungul lățimii ei (implicit: lățimea ei)
--   OpenSeconds      number  cât durează deschiderea (implicit 0.6)
--   AutoCloseSeconds number  se închide din nou după atâtea secunde; 0 o lasă deschisă (implicit 4)
--   KeyName          string  numele Tool-ului pe care trebuie să-l aibă jucătorul, de exemplu "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 -- pe fiecare ușă, contra spamului cu promptul

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 sau infinit, introduse în fereastra 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 -- e deja o ușă funcțională sau nu e nici part, nici 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)
	-- O copie a unei uși funcționale aduce cu ea vechiul prompt și vechea valoare: le ștergem
	for _, leftover in door:GetDescendants() do
		if leftover.Name == "DoorPrompt" or leftover.Name == "DoorProgress" then
			leftover:Destroy()
		end
	end

	-- Pozițiile închisă și deschisă le calculăm o dată, de la locul unde stă ușa acum
	local closedPivot = door:GetPivot()
	local openPivot: CFrame
	if attribute(door, "Style", "Swing") == "Slide" then
		-- Alunecăm de-a lungul laturii orizontale mai lungi a ușii, lățimea ei. Un Model se măsoară de-a lungul
		-- laturilor pivotului său, un Part după propriul Size, așa că nu roti pivotul unui part glisant
		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 rotește mereu pe arcul scurt, așa că un unghi mai mare ar deschide ușa în partea greșită
		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", "")

	-- Facem tween pe un număr de la 0 (închis) la 1 (deschis) și mișcăm ușa după el.
	-- PivotTo mișcă un part sau un model întreg în jurul pivotului său.
	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) -- asta pot citi alte scripturi
		prompt.ActionText = if open then "Close" else "Open"
		-- Un tween nou pe aceeași valoare îl anulează pe cel vechi, așa că ușa se poate întoarce la jumătatea drumului.
		-- Scalăm timpul după cât mai are de parcurs.
		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
		-- Ghidul de securitate Roblox spune că prompturile pot fi folosite abuziv ca remote-urile, așa că verificăm din nou aici
		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 -- prea departe ca să folosească cinstit promptul
		end
		if keyName ~= "" and not isOpen and not hasKey(player, keyName) then
			return -- încuiat, iar acest jucător nu are cheia
		end
		lastUse = now
		move(not isOpen)
	end)
end

-- Toate ușile cu tag de acum și toate care primesc tagul mai târziu (inclusiv ușile clonate de scripturi)
for _, door in CollectionService:GetTagged(DOOR_TAG) do
	setUpDoor(door)
end
CollectionService:GetInstanceAddedSignal(DOOR_TAG):Connect(setUpDoor)

DoorService adaugă singur DoorPrompt și DoorProgress în fiecare ușă la pornirea jocului, așa că nu trebuie să inserezi nimic manual. Ține o singură copie a scriptului: deservește deja toate ușile cu tag.

Ce face fiecare parte din DoorService
Partea scriptuluiCe faceDe ce
attribute()Citește un atribut și returnează valoarea implicită dacă atributul lipsește, are alt tip sau nu e un număr real (NaN sau infinit).O greșeală de tastare în fereastra Properties dă o ușă cu setări implicite, nu o ușă stricată.
doorsSetUp și bucla prin leftoverConfigurează fiecare ușă o dată și șterge întâi un DoorPrompt sau DoorProgress copiat de pe altă ușă.Altfel copia unei uși funcționale ar avea două prompturi, dintre care unul nefuncțional.
closedPivot și openPivotSe calculează o dată, de la locul unde stă ușa în momentul configurării. O ușă batantă rotește pivotul în jurul propriei axe verticale; una glisantă îl mută de-a lungul laturii mai lungi a ușii.Lerp de la pivotul închis la cel deschis lasă pivotul pe loc cât se rotește ușa, așa că marginea cu balamale nu se mișcă pe toată durata rotirii.
DoorProgress și PivotToTween-ul schimbă numărul; fiecare schimbare pune ușa în closedPivot:Lerp(openPivot, alpha).TweenService știe să facă tween pe un NumberValue, iar PivotTo mută un part sau un model cu toate part-urile lui astfel încât pivotul să ajungă în acel CFrame.
PromptulHoldDuration 0.2, MaxActivationDistance 8, RequiresLineOfSight dezactivat. O ușă încuiată arată "Needs RedKey".Cu linia de vedere activă, promptul se ascunde când ceva îi acoperă part-ul; fără ea, rama sau celelalte părți ale unei uși-model nu ascund promptul.
move()Pornește tween-ul spre 1 sau spre 0, iar timpul îl scalează după cât mai are ușa de parcurs.Un tween nou pe aceeași valoare îl anulează pe cel vechi, așa că o ușă întoarsă la jumătatea drumului merge lin înapoi și are nevoie de jumătate din timp.
Închiderea automatăAșteaptă timpul de deschidere plus AutoCloseSeconds, apoi închide ușa doar dacă moveCount nu s-a schimbat.Un cronometru vechi nu va trânti niciodată o ușă pe care între timp cineva a închis-o și a deschis-o din nou.
Verificările din TriggeredO folosire a ușii la fiecare 0.3 secunde, un personaj viu, nu mai departe de 14 studs de part-ul cu promptul și cheia, dar doar pentru deschidere.Tot ce poate declanșa clientul poate fi folosit abuziv, așa că serverul repetă verificările. 14 studs înseamnă cei 8 studs ai promptului plus 6 rezervă pentru un jucător care s-a mișcat cât a ținut apăsat E.
Atributul OpenSe setează pe ușă la fiecare mișcare.Atributele setate pe server se replică la toți jucătorii, așa că alte scripturi, inclusiv LocalScript-uri, îl pot asculta prin GetAttributeChangedSignal("Open").

Să marchezi toate ușile cu un tag și să le controlezi dintr-un singur script e abordarea recomandată chiar de Roblox: referința CollectionService spune că, dacă adaugi același script în multe obiecte, un script cu CollectionService poate fi mai bun. GetTagged returnează ușile care există la pornirea scriptului, iar GetInstanceAddedSignal prinde ușile marcate sau adăugate mai târziu. Felul acesta de a organiza un place e explicat în ghidul despre scripturile de client și de server.

Cum faci o ușă glisantă

Selectează VaultDoor, adaugă un atribut de tip string numit Style și dă-i valoarea Slide. Acum ușa nu se mai rotește, ci alunecă lateral: cu propria lățime sau cu SlideDistance studs, dacă l-ai setat. Ca să alunece în cealaltă parte, setează o distanță negativă, de exemplu -4 pentru o ușă lată de 4 studs. Orice altă ușă, inclusiv FrontDoor, devine glisantă la fel imediat ce primește acest atribut.

DoorService măsoară cele două dimensiuni orizontale ale ușii, lățimea și grosimea, și o mișcă de-a lungul celei mai mari. Un Model îl măsoară prin GetExtentsSize, a cărui cutie urmează orientarea pivotului modelului, așa că o ușă rotită cu 90 de grade după grupare alunecă tot de-a lungul lățimii, nu al grosimii. Un Part îl măsoară după propriul Size, așa că nu roti pivotul unui part glisant. Să muți acel pivot e în regulă.

  • Uși duble: două jumătăți cu tag una lângă alta, ambele cu Style Slide, iar una cu un SlideDistance negativ, ca să se depărteze de la mijloc. Pentru uși duble batante pune pivotul fiecărei jumătăți pe marginea ei exterioară și dă-i unei jumătăți un OpenAngle negativ. Fiecare jumătate are propriul prompt și se deschide separat. Dacă jumătățile alunecă una spre alta, mută minusul pe cealaltă jumătate.
  • Porți care se ridică: acest script mișcă ușa doar de-a lungul lățimii. Ca ușile să se ridice, setează direction în script la Vector3.yAxis (atunci toate ușile glisante vor merge în sus) și dă-i fiecăreia un SlideDistance egal cu înălțimea ei.
  • Ușă cu fizică: tutorialul Roblox despre obiectele mobile mișcă part-uri de-a lungul unei axe printr-un PrismaticConstraint. Ca ușa cu balama, e fizică, fără prompt și încuietoare până nu le scrii singur.

Cum încui o ușă cu cheie

O ușă încuiată se deschide doar pentru un jucător care are un Tool cu numele potrivit. Fă cheia, apoi spune-i ușii numele ei:

  1. Treci cu mouse-ul peste StarterPack, apasă + și inserează un Tool numit RedKey. Inserează în el un Part numit Handle, part-ul pe care personajul îl ține în mână, și asigură-te că nu e ancorat: un part ancorat într-un instrument țintuiește personajul pe loc. Debifează CanBeDropped la Tool dacă jucătorii nu trebuie să arunce cheia pentru altcineva: cât timp e bifat, Backspace aruncă instrumentul echipat în Workspace.
  2. Selectează VaultDoor, adaugă un atribut de tip string numit KeyName și dă-i valoarea RedKey. Acum în numele obiectului de pe prompt scrie Needs RedKey.

DoorService caută cheia în două locuri. Un Tool stă în Backpack-ul jucătorului până e echipat, iar echiparea îl mută în personaj, așa că ușa se deschide fie că cheia e în hotbar, fie în mână. Verificarea se face pe server pentru că ghidul de securitate Roblox numește exact acest caz, dacă jucătorul are cheia pentru ușă, ca drept pe care serverul trebuie să-l verifice. Cheia e necesară doar la deschidere: o ușă deschisă o poate închide oricine și se închide singură după AutoCloseSeconds.

StarterPack le dă cheia tuturor la fiecare apariție, iar pentru teste asta îți trebuie. Într-un joc real dă-o altfel:

  • Dintr-un magazin: ghidul despre GUI-ul de magazin dă un Tool din ServerStorage în Backpack-ul și StarterGear-ul cumpărătorului.
  • De la un personaj: ghidul despre dialoguri cu NPC-uri dă un Tool din ServerStorage.DialogueItems când jucătorul alege o variantă cu acțiunea GiveItem. Pune în acel folder un Tool numit RedKey și setează la varianta din DialogueData action = "GiveItem" și item = "RedKey", iar cheia va fi dată în conversație.
  • Ca obiect de inventar: cu sistemul de inventar un obiect-cheie funcționează imediat ce jucătorul îl echipează, pentru că echiparea pune o copie a Tool-ului lui în Backpack și în mână.

O cheie din Backpack se pierde când personajul moare, pentru că Roblox reumple Backpack-ul la fiecare apariție din StarterPack și StarterGear. Ca s-o păstrezi, pune o copie și în StarterGear-ul jucătorului, cum face ghidul despre magazin. Ca cheia să se consume, dimpotrivă, găsește Tool-ul cheii în Backpack-ul sau în personajul jucătorului și distruge-l în handler-ul Triggered, imediat după verificarea reușită a cheii.

Unde greșesc tutorialele vechi despre uși

Dacă compari ghidul acesta cu un videoclip sau o postare de pe forum, iată trucurile din cauza cărora apar cele mai multe subiecte „nu-mi merge ușa” și ce face ghidul acesta în locul lor.

Trucuri frecvente din tutorialele despre uși și ce face ghidul acesta în schimb
TutorialulProblemaGhidul acesta
Face tween pe CFrame-ul unei uși ModelReferința Model nu are proprietatea CFrame sau Position. WorldPivot-ul ei stabilește doar locul pivotului modelului, așa că un tween pe el mută punctul pivotului, iar part-urile rămân pe loc.Face tween pe un NumberValue și mută tot modelul prin PivotTo.
Mută modelul prin SetPrimaryPartCFrameE învechit: Roblox recomandă în proiectele noi folosirea PivotTo.Folosește PivotTo, pe care Roblox îl numește funcția principală pentru mutarea unui Model din scripturi.
Sudează toate part-urile de un part-balama și face tween doar pe balamaMerge când toate Weld-urile sunt la locul lor, dar orice part nesudat rămâne în urmă când se mișcă balamaua.Ține toate part-urile ancorate, fără Weld. PivotTo mișcă ușa și tot ce e în ea.
Copiază același script în fiecare ușăFiecare reparație trebuie repetată în fiecare copie. Roblox propune să marchezi obiectele cu taguri și să le tratezi dintr-un singur script prin CollectionService.Un singur DoorService și tagul Door.
Deschide ușa într-un LocalScriptUșa se deschide doar pe ecranul acelui jucător, iar toți ceilalți o văd în continuare închisă.Ușa o mișcă serverul, așa că toți jucătorii văd aceeași ușă.
Deschide ușa la TouchedTouched se declanșează de mai multe ori la rând la o singură atingere (pagina Roblox despre debounce), iar dispozitivul jucătorului poate controla când se declanșează Touched pentru propriul personaj (documentația de securitate Roblox).Un prompt verificat de server.
Mișcă ușa în pași, într-o buclă cu wait()Roblox marchează wait() ca înlocuit de task.wait(), iar bucla nu se poate întoarce la jumătatea drumului când cineva apasă din nou.Un tween pe mișcare. Un tween nou pe aceeași valoare îl anulează pe cel vechi, așa că ușa se întoarce din locul în care se află.
Verifică cheia într-un LocalScript sau delocUn trișor controlează tot de pe dispozitivul lui, așa că o verificare pe client nu oprește pe nimeni.Serverul caută Tool-ul în Backpack-ul și în personajul jucătorului.
Fără cooldown pe promptGhidul de securitate Roblox spune că prompturile sunt vulnerabile la abuz la fel ca remote-urile, așa că nimic nu împiedică declanșarea lui iar și iar.O folosire a ușii la fiecare 0.3 secunde.

Ce poate și ce nu poate un trișor

Consideră că un trișor controlează tot de pe dispozitivul lui, inclusiv propriul personaj. Iată ce înseamnă asta pentru aceste uși.

Ce poate încerca un trișor și ce face DoorService cu asta
Trișorul încearcăRezultatDe ce
Să declanșeze promptul de la celălalt capăt al hărțiiE ignorat dacă personajul lui nu e lângă ușăDoorService măsoară distanța de la part-ul rădăcină al personajului la part-ul cu promptul și ignoră tot ce e mai departe de 14 studs. Trișorul își poate teleporta întâi personajul lângă ușă (vezi ultimul rând), așa că verificarea distanței apără de folosirea de la distanță, nu de teleport.
Să-l declanșeze de multe ori pe secundăCel mult o folosire a ușii la fiecare 0.3 secundeServerul ține minte momentul ultimei folosiri a fiecărei uși.
Să deschidă o ușă cu cheie fără cheieRefuzServerul caută Tool-ul în Backpack-ul și personajul lui acolo unde le vede el însuși, nu pe ecranul trișorului.
Să folosească ușa cât personajul e mortE ignoratDoorService verifică dacă există un Humanoid cu viața peste 0 și un part rădăcină.
Să treacă totuși prin ușa închisăPosibilDocumentația de securitate Roblox enumeră ocolirea obstacolelor fizice și schimbarea propriilor coliziuni printre lucrurile pe care clientul le poate face cu personajul lui.
Să se teleporteze dincolo de ușăPosibilAceeași documentație menționează teleportarea propriului personaj în orice punct.

Pasul 3: verifică

  1. Apasă Play (F5). Apropie-te de FrontDoor: în raza de 8 studs apare un prompt cu acțiunea Open și numele obiectului Door. Ține apăsat E. După 0.2 secunde ușa se deschide cu 90 de grade în jurul marginii cu balamale în 0.6 secunde, iar pe prompt scrie acum Close.
  2. Treci prin ușă și așteaptă. La patru secunde după deschiderea completă ușa se închide singură. Ține apăsat E cât se închide: se întoarce și se deschide din locul unde era.
  3. Verifică încuietoarea. Dacă RedKey e în StarterPack, mut-o deocamdată în ServerStorage, apasă Play și ține apăsat E lângă VaultDoor: pe prompt scrie Needs RedKey și nu se mișcă nimic. Oprește jocul, pune RedKey înapoi în StarterPack și pornește din nou: VaultDoor se deschide, fie că cheia e în hotbar, fie în mână.
  4. Verifică ușa glisantă. VaultDoor, un Model cu Style Slide, alunecă la deschidere lateral cu lățimea ei. Oprește jocul, selectează VaultDoor, rotește-o cu 90 de grade cu instrumentul Rotate și pornește din nou: trebuie să alunece în continuare de-a lungul lățimii, nu al grosimii. Când termini, rotește-o înapoi.
  5. Alege Server & Clients din lista derulantă a modurilor de test, setează 2 clienți și apasă Play. Deschide ușa în fereastra unui client: e deschisă și în cealaltă fereastră și se închide în amândouă.
  6. Oprește jocul, selectează ușa și apasă Ctrl+D ca s-o duplici, apoi mută copia în alt cadru. Verifică dacă la copie în Tags apare tot Door și apasă Play: copia funcționează fără un script suplimentar.

Ține fereastra Output deschisă (meniul Window, apoi Output). Când totul merge, DoorService nu afișează nimic. Un avertisment că o ușă "has no part to put the prompt on" înseamnă că în Model-ul cu tag nu sunt part-uri. Restul îl găsești în secțiunea Erori frecvente.

Cum extinzi

Uși automate

Ca ușa să se deschidă când se apropie cineva, apelează move(true) din setUpDoor, fără să aștepți promptul. La finalul setUpDoor pornește o buclă prin task.spawn, pentru că o buclă obișnuită acolo nu se termină niciodată, iar DoorService n-ar trece mai departe de prima ușă. Las-o să ruleze doar cât ușa există în joc: task.spawn(function() while door.Parent do ... task.wait(0.5) end end). În buclă verifică prin workspace:GetPartBoundsInBox dacă e un personaj în cutia din jurul cadrului și apelează move(true) când e acolo, iar ușa e închisă. Mai departe o închide, ca înainte, închiderea automată. Setează Enabled-ul promptului la false dacă ușa trebuie să se deschidă doar singură.

Uși VIP

Ghidul despre gamepass-uri construiește deja o ușă VIP prin care proprietarii pass-ului trec direct, pe grupuri de coliziune. Pentru o ușă VIP care se deschide pe E, adaugă încă o verificare în handler-ul Triggered, lângă verificarea cheii: fă return dacă nu e îndeplinită condiția player:GetAttribute("OwnsPass_VIP") == true, atributul setat de scriptul de server din ghidul despre gamepass-uri. Citește-l doar pe server.

Panou cu cod

Pentru o ușă care se deschide cu un cod introdus, ține codul într-un Script de server sau în ServerStorage, pe care jucătorii nu le primesc niciodată, și în niciun caz într-un LocalScript, unde un trișor îl poate citi. LocalScript-ul panoului trimite printr-un RemoteEvent doar cifrele introduse. Pe server verifică dacă jucătorul e lângă ușă, limitează frecvența încercărilor, compară cifrele și abia apoi apelează move(true). Ghidul despre RemoteEvent arată cum verifici ce primește un remote.

Sunete

Pune un Sound în part-ul ușii, ca să sune din poziția acelui part, și apelează-i metoda Play la începutul move. Sau redă-l dintr-un LocalScript care ascultă atributul Open al ușii prin GetAttributeChangedSignal("Open"), pentru că serverul setează acest atribut la fiecare mișcare.

Uși adăugate în timpul jocului

Clonează ușile noi dintr-un șablon închis din ServerStorage. DoorService citește poziția închisă a ușii în momentul apariției ei, așa că o copie a unei uși care în acel moment era deschisă ar considera poziția deschisă ca fiind cea închisă. Pune copia în cadru prin PivotTo înainte să-i setezi Parent-ul la Workspace, ca DoorService să rețină acel loc ca închis. Prompturile și valorile vechi venite cu copia se șterg automat. Despre o ușă care duce jucătorii în altă zonă sau alt place citește în ghidul despre teleporturi.

Erori frecvente și soluții

Deschide fereastra Output (meniul Window, apoi Output) înainte să apeși Play. Cele mai multe probleme cu ușile apar din cauza unui tag, unui pivot sau unui atribut care nu e chiar cum îl așteaptă scriptul.

La ușă nu apare promptul

Verifică în ordine: DoorService e un Script, nu un LocalScript, și stă direct în ServerScriptService; ușa are tagul Door cu D mare, iar la o ușă-model pe Model-ul însuși; ușa e un part (Part, MeshPart sau alt BasePart) ori un Model; și stai la cel mult 8 studs de part-ul pe care e promptul. Un avertisment în Output că ușa "has no part to put the prompt on" înseamnă că în Model-ul cu tag nu sunt part-uri.

Ușa cade, plutește sau e împinsă când pornește jocul

Unul dintre part-urile ei nu e ancorat. Selectează toate part-urile ușii și bifează Anchored. Part-urile ancorate nu se mișcă niciodată din cauza fizicii, dar DoorService le poate mișca oricum.

Am schimbat un atribut, dar ușa îl ignoră

Verifică trei lucruri. Tipul: OpenAngle, SlideDistance, OpenSeconds și AutoCloseSeconds trebuie să fie atribute de tip number, iar Style și KeyName de tip string; la un tip greșit DoorService ia valoarea implicită. Scrierea: numele se compară exact, așa că openAngle e alt atribut. Și valorile se compară exact: Style trebuie să fie Slide cu S mare și fără spații. Momentul: DoorService citește atributele o dată, când configurează ușa, așa că o schimbare în timpul unui playtest nu are efect până nu pornești din nou jocul.

Ușa se deschide în partea greșită sau cade pe o parte

Ca să se deschidă în cealaltă parte, fă OpenAngle negativ, de exemplu -90. Dacă se rotește în jurul unei axe orizontale, nu în jurul balamalei verticale, înseamnă că pivotul însuși e rotit: activează Pivot în fila Model și rotește pivotul înapoi, ca să stea vertical.

Ușa glisantă intră în perete sau se mișcă foarte puțin

Dă-i un SlideDistance negativ, ca să alunece în cealaltă parte. Dacă se mișcă prea puțin sau prea mult, pune în SlideDistance numărul de studs dorit și nu te baza pe lățimea măsurată.

Am cheia, dar ușa nu se deschide

Cheia trebuie să fie un Tool, nu un Part sau Model, iar numele ei trebuie să se potrivească exact cu KeyName, inclusiv majusculele. Trebuie să fie în Backpack-ul tău sau în mână. Verifică și dacă KeyName de pe ușă e un atribut de tip string.

Fă-o cu RoCode

Dacă nu ai chef să configurezi toate astea manual, RoCode le poate construi în place-ul pe care îl ai deschis. RoCode este un agent AI independent pentru Roblox Studio, nu de la Roblox: descrii modificarea în chatul web, iar pluginul lui pentru Studio creează scripturile și obiectele în Explorer-ul tău, așa că nu trebuie să lipești cod.

Tu scrii

Fă ca ușile cu tagul Door să se deschidă printr-un prompt cu E ținut apăsat: rotire cu 90 de grade în jurul pivotului în 0.6 secunde, închidere după 4 secunde, glisare în loc de rotire când atributul Style e Slide, iar ușa rămâne închisă dacă jucătorul nu are un Tool cu numele din KeyName. Totul pe server, cu verificarea distanței.

RoCode face
  • Poate să se uite prin place-ul tău când un pas o cere, prin Search Game și Search Scripts, ca să se sprijine pe obiectele, remote-urile sau codul de salvare existente, nu să adauge un al doilea sistem
  • Scrie un Script în ServerScriptService prin Create Script, poate crea part-ul ușii prin Create Instance și poate seta pe el atribute precum Style și KeyName
  • Are instrucțiuni să verifice compilarea fiecărui script scris prin Check Script, care îl compilează în Studio fără să-l ruleze
  • Pune un punct de anulare înainte și după fiecare lot de modificări, așa că Ctrl+Z anulează câte un lot

Înainte de test verifică pivotul fiecărei uși cu instrumentul Pivot din Studio: ușa se rotește în jurul lui. Cu pluginul 3.9 sau mai nou, RoCode poate porni un playtest scurt și citi erorile, iar cu pluginul 3.9.15 sau mai nou poate controla un personaj de test care merge și apasă taste, dar verifică doar ce a hotărât el să testeze, așa că du-te singur la fiecare ușă și ține apăsat E. Cum se conectează RoCode la Studio.

Întrebări frecvente

Cum fac o ușă să se deschidă pe E în Roblox Studio?

Pune un ProximityPrompt în ușă și conectează-i evenimentul Triggered într-un Script de server care mișcă ușa. DoorService le face pe amândouă pentru fiecare ușă cu tagul Door. E e tasta implicită a promptului, iar Roblox arată inputul potrivit pentru tastaturi, gamepad-uri și ecrane tactile.

De ce se învârte ușa mea în jurul mijlocului?

Pivotul ei e încă în centru. Activează Pivot în fila Model și trage pivotul pe marginea cu balamale; scriptul rotește ușa în jurul pivotului.

Cum faci o ușă glisantă?

Dă-i atributului Style al ușii valoarea Slide. Alunecă lateral cu lățimea ei sau cu SlideDistance studs; o distanță negativă o mută în cealaltă parte.

Pot face o ușă fără scripturi?

Da. Tutorialul Roblox despre ușa cu balama prinde o ușă neancorată de ramă printr-un HingeConstraint cu limite, iar jucătorii o deschid împingând-o cu corpul. O astfel de ușă nu are prompt, încuietoare și închidere automată.

Cum fac o ușă pe care o pot deschide doar VIP-urile?

Ia ușa VIP din ghidul despre gamepass-uri, prin care trec proprietarii pass-ului, sau adaugă în handler-ul Triggered din DoorService o verificare care, înainte de deschidere, citește pe server dacă jucătorul deține pass-ul, de exemplu atributul OwnsPass_VIP setat de acel ghid.

De ce se deschide ușa la mine, dar nu și la ceilalți jucători?

O deschide un LocalScript, iar o schimbare făcută de un LocalScript rămâne pe dispozitivul acelui jucător. Mută codul de deschidere într-un Script de server, ca în DoorService, ca schimbarea să ajungă la toți.

Surse și lecturi suplimentare

Cum a fost verificat codul: fiecare script de pe această pagină trece printr-o verificare strictă a tipurilor Luau cu definițiile API Roblox (luau-lsp, 20 noiembrie 2026). Verificarea tipurilor prinde nume greșite de API și tipuri greșite, dar nu și greșelile de logică a jocului, așa că testează totul în Studio înainte să publici.

Încearcă RoCode în jocul tău.

Credite gratuite în fiecare zi, fără card. Instalează pluginul, descrie o funcție și verifică ce a apărut în Studio.