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 prinPivotTo: 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ă
Cum funcționează o ușă cu script
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:
- 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.
- Jucătorul ține apăsat E 0.2 secunde. Evenimentul
Triggeredal promptului se declanșează pe server cu acest jucător. - DoorService verifică jucătorul: e viu, destul de aproape, nu face spam cu promptul și poartă cheia, dacă ușa o cere.
- Scriptul face tween pe un număr de la 0 (închis) la 1 (deschis). La fiecare schimbare a numărului mută ușa prin
PivotTocu acea fracție din drumul de la poziția închisă la cea deschisă. - 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ă.
| Element | Unde se află | Ce face |
|---|---|---|
Script DoorService | ServerScriptService | Găsește toate ușile, adaugă fiecăreia un prompt, verifică fiecare folosire și mișcă ușa. Singurul script din acest ghid. |
Tagul Door | Pe 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 KeyName | Pe 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 teste | Cheia pentru ușa încuiată. Merge orice Tool, dacă numele lui se potrivește cu KeyName-ul ușii. |
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
- În Explorer treci cu mouse-ul peste Workspace, apasă butonul + și inserează un Part. Numește-l
FrontDoor, seteazăSizela aproximativ4, 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. - 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.
- 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.
- Adaugă tagul. Cu ușa încă selectată, derulează fereastra Properties până la Tags, apasă + și scrie
Doorcu D mare. Dacă ușa e un Model, pune tagul pe Model-ul însuși, nu pe part-urile din interior. - 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:
Panelde aproximativ4, 7, 0.5șiKnobde aproximativ0.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 înVaultDoor. Ancorează ambele part-uri, pune modelul în al doilea cadru și adaugă tagulDoorpe 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.
| Atribut | Tip | Implicit | Ce face |
|---|---|---|---|
Style | string | Swing | Swing rotește ușa în jurul pivotului ei. Slide o mută lateral de-a lungul lățimii. |
OpenAngle | number | 90 | Cu 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. |
SlideDistance | number | lățimea ei | Câți studs alunecă o ușă glisantă de-a lungul lățimii ei. Un număr negativ o mută în cealaltă parte. |
OpenSeconds | number | 0.6 | Cât durează deschiderea sau închiderea completă, între 0.05 și 10. |
AutoCloseSeconds | number | 4 | Cât stă ușa complet deschisă înainte să se închidă singură. 0 o lasă deschisă până o închide cineva. |
KeyName | string | niciunul | Numele 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.
-- 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.
| Partea scriptului | Ce face | De 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 leftover | Configurează 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 openPivot | Se 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 PivotTo | Tween-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. |
| Promptul | HoldDuration 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 Triggered | O 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 Open | Se 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
StyleSlide, iar una cu unSlideDistancenegativ, 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 unOpenAnglenegativ. 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 laVector3.yAxis(atunci toate ușile glisante vor merge în sus) și dă-i fiecăreia unSlideDistanceegal 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:
- Treci cu mouse-ul peste StarterPack, apasă + și inserează un Tool numit
RedKey. Inserează în el un Part numitHandle, 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ăCanBeDroppedla Tool dacă jucătorii nu trebuie să arunce cheia pentru altcineva: cât timp e bifat, Backspace aruncă instrumentul echipat în Workspace. - Selectează VaultDoor, adaugă un atribut de tip string numit
KeyNameși dă-i valoareaRedKey. 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.DialogueItemscând jucătorul alege o variantă cu acțiuneaGiveItem. Pune în acel folder un Tool numit RedKey și setează la varianta din DialogueDataaction = "GiveItem"șiitem = "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.
| Tutorialul | Problema | Ghidul acesta |
|---|---|---|
Face tween pe CFrame-ul unei uși Model | Referinț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 SetPrimaryPartCFrame | E î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 balama | Merge 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 LocalScript | Uș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 Touched | Touched 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 deloc | Un 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 prompt | Ghidul 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.
| Trișorul încearcă | Rezultat | De ce |
|---|---|---|
| Să declanșeze promptul de la celălalt capăt al hărții | E 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 secunde | Serverul ține minte momentul ultimei folosiri a fiecărei uși. |
| Să deschidă o ușă cu cheie fără cheie | Refuz | Serverul 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 mort | E ignorat | DoorService verifică dacă există un Humanoid cu viața peste 0 și un part rădăcină. |
| Să treacă totuși prin ușa închisă | Posibil | Documentaț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șă | Posibil | Aceeași documentație menționează teleportarea propriului personaj în orice punct. |
Pasul 3: verifică
- 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.
- 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.
- 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ă.
- Verifică ușa glisantă. VaultDoor, un Model cu
StyleSlide, 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. - 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ă.
- 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.
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.
- 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
- Roblox Creator Docs: PVInstance:PivotTo (în engleză). mutarea unui part sau a unui model întreg după pivotul lui
- Roblox Creator Docs: Pivot tools (în engleză). mutarea pivotului, Snap și punctele de referință, pivotul când există PrimaryPart
- Roblox Creator Docs: Model (în engleză). WorldPivot, GetExtentsSize urmează pivotul, SetPrimaryPartCFrame e învechit
- Roblox Creator Docs: CFrame:Lerp (în engleză). rotirea se interpolează pe arcul cel mai scurt
- Roblox Creator Docs: TweenService (în engleză). pe ce se poate face tween și cum un al doilea tween pe aceeași proprietate îl anulează pe primul
- Roblox Creator Docs: Proximity prompts (în engleză). crearea și configurarea prompturilor, inputul pe orice dispozitiv și linia de vedere
- Roblox Creator Docs: ProximityPrompt (în engleză). tasta și butonul implicite, HoldDuration, MaxActivationDistance și Triggered
- Roblox Creator Docs: CollectionService (în engleză). taguri, GetTagged și GetInstanceAddedSignal
- Roblox Creator Docs: Properties window (în engleză). adăugarea tagurilor și atributelor în Studio
- Roblox Creator Docs: Securing the client-server boundary (în engleză). ProximityPrompt ca suprafață de atac și verificarea dreptului „cheie și ușă”
- Roblox Creator Docs: Network ownership, movement validation, and physics (în engleză). ce poate face clientul cu propriul personaj
- Roblox Creator Docs: Build a hinged door (în engleză). o ușă pe HingeConstraint fără cod
- Roblox Creator Docs: In-game tools (în engleză). Handle, ancorarea și StarterPack
- Roblox Creator Docs: Tool.CanBeDropped (în engleză). ce face Backspace cu un instrument echipat
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.