Útmutató · Játékrendszerek

Hogyan készíts ajtót a Roblox Studióban

Egy működő Roblox ajtóhoz három dolog kell: valami, amit a játékos megnyom (egy "Open" feliratú ProximityPrompt), sima mozgás (TweenService), és egy szerver, amely elvégzi a változtatást, hogy minden játékos ugyanazt az ajtót lássa. Ebben az útmutatóban egyetlen scriptet állítunk össze, amely ezt minden címkézett ajtóval megcsinálja, legyen az nyíló vagy tolóajtó, opcionális kulcsos zárral: a szerver ellenőrzi a kulcsot, mielőtt bármit kinyitna.

Frissítve 2026. november 20.21 perc olvasásSzerző:

Röviden

Építsd meg az ajtót Partként vagy Modelként, kapcsold be az Anchored opciót, vidd a pivotját a zsanéros élre (Model fül, Pivot), és add hozzá a Door címkét a Properties ablakban. Egyetlen Script a ServerScriptService-ben a CollectionService segítségével megtalálja az összes címkézett ajtót, hozzáad egy ProximityPromptot ("Open", E nyomva tartása), és a Triggered eseményre egy NumberValue-t tweenel 0-ról 1-re, miközben az ajtót a door:PivotTo(closedPivot:Lerp(openPivot, alpha)) hívással mozgatja. Az egyes ajtókon lévő attribútumok adják meg a nyíló vagy toló típust, a szöget, az időt, az automatikus zárást és a kulcsot.

  • Egy Model pozícióját nem lehet közvetlenül tweenelni: a Modelnek nincs CFrame vagy Position tulajdonsága, a WorldPivot pedig csak a pivot helyét adja meg. Egy NumberValue-t tweenelj, és az ajtót a PivotTo hívással mozgasd: a Roblox ezt nevezi a modellek scriptből való mozgatásának elsődleges módjának.
  • Az ajtókat a szerveren nyisd. Egy LocalScriptből kinyitott ajtó csak annak a játékosnak a képernyőjén mozdul.
  • A kulcsot és a távolságot a szerveren ellenőrizd. A Roblox biztonsági útmutatója szerint a ProximityPrompttal ugyanúgy vissza lehet élni, mint egy RemoteEventtel, és ugyanott példát is hoz egy ellenőrzésre, amelyet a szervernek kötelező elvégeznie: van-e a játékosnál kulcs, amely az ajtó kinyitásához kell.
Ezen az oldalon
  1. Hogyan működik
  2. 1. Az ajtó megépítése
  3. 2. Ajtó script
  4. Tolóajtók
  5. Kulcsos ajtók
  6. Régi oktatóanyagok
  7. A védelem határai
  8. 3. Tesztelés
  9. Bővítések
  10. Common errors
  11. RoCode-dal
  12. Gyakori kérdések
  13. Források és további olvasnivaló

Hogyan működik a scriptelt ajtó

IllusztrációAz E 0,2 másodpercig tartó nyomva tartása 0,6 másodperc alatt kinyitja az ajtót, és 4 másodperccel a teljes kinyílás után magától bezárul (itt gyorsítva). A VaultDoor zárva marad a RedKey nélküli játékos előtt.

Egy ajtót, amely valódi játékban működik, a szervernek kell mozgatnia. Ha egy LocalScript mozgatja, az ajtó egyetlen játékos képernyőjén nyílik ki, és mindenki más számára zárva marad, mert a kliens által végzett változtatás azon az eszközön marad (lásd: mi replikálódik és mi nem). Ezért ebben az útmutatóban a játékos eszköze csak megmutatja a promptot és jelzi a gombnyomást, minden mást egyetlen szerveroldali Script végez. Az ajtó egy használata így néz ki:

  1. A játékos 8 studnál közelebb megy az ajtóhoz, és megjelenik a prompt az Open művelettel, a Door objektumnévvel és a billentyűzeten az E gombbal. Kontrolleren vagy érintőképernyőn a Roblox a megfelelő gombot mutatja.
  2. A játékos 0,2 másodpercig nyomva tartja az E-t. A prompt Triggered eseménye ezzel a játékossal sül el a szerveren.
  3. A DoorService ellenőrzi a játékost: él, elég közel van, nem spameli a promptot, és nála van a kulcs, ha az ajtó megköveteli.
  4. A script egy számot tweenel 0-ról (zárva) 1-re (nyitva). A szám minden változásakor a PivotTo hívással az ajtót a zárt és a nyitott helyzet közötti út ekkora részére mozdítja.
  5. Négy másodperccel a teljes kinyílás után az ajtó ugyanígy bezárul. Ha mozgás közben valaki megnyomja, az ajtó onnan fordul vissza, ahol éppen van.
Miből áll az ajtórendszer
ElemHol vanMit csinál
DoorService ScriptServerScriptServiceMegtalálja az összes ajtót, mindegyikhez promptot ad, ellenőriz minden használatot, és mozgatja az ajtót. Az egyetlen script ebben az útmutatóban.
Door címkeMinden ajtó Partján vagy ModeljénMegjelöli, mi számít ajtónak. A címkéket a Properties ablakban adod hozzá, és a place-szel együtt mentődnek.
Attribútumok, például Style és KeyNameMinden ajtón (opcionális)Egy ajtó beállításai: nyíló vagy toló, szög, sebesség, automatikus zárás és kulcs.
DoorPrompt ProximityPromptAz ajtón belül (a DoorService adja hozzá)Az "Open" vagy "Close" feliratot mutatja, és elsüti a Triggered eseményt, amikor a játékos nyomva tartja az E-t.
DoorProgress NumberValueAz ajtón belül (a DoorService adja hozzá)Szám, amelyet a tween 0 és 1 között mozgat. Minden változása mozdít az ajtón.
RedKey Tool (opcionális)StarterPack, teszteléshezKulcs a bezárt ajtóhoz. Bármilyen Tool jó, ha a neve egyezik az ajtó KeyName értékével.
Az Explorer az útmutató végén. Mindkét ajtón ott a Door címke, a VaultDoor ajtón pedig ezen felül a Style = Slide és a KeyName = RedKey attribútum. Amikor a játék fut, a DoorService minden ajtóba betesz egy DoorProgress értéket, és egy DoorPromptot abba a partba, amelyen a prompt van.
Workspace
  FrontDoor Part new
  VaultDoor Model new
    Panel Part new
    Knob Part new
ServerScriptService
  DoorService Script new
StarterPack
  RedKey Tool new
    Handle Part new

1. lépés: építsd meg az ajtót és állítsd be a zsanért

  1. Az Explorerben vidd a kurzort a Workspace fölé, kattints a + gombra, és illessz be egy Partot. Nevezd el FrontDoor néven, állítsd a Size értékét nagyjából 4, 7, 0.5-re (4 stud széles, 7 magas, fél stud vastag), és tedd az ajtónyílásba. Több partból álló ajtó is jó: jelöld ki őket, és nyomd meg a Ctrl+G-t, hogy Modellé csoportosítsd.
  2. Kapcsold be az Anchored opciót az ajtó minden partján, a CanCollide maradjon bekapcsolva. A rögzített partokat soha nem mozdítja el a gravitáció vagy az ütközés, de a script ettől még mozgathatja őket, és a DoorService pontosan ezt teszi.
  3. Állítsd be a zsanért. Jelöld ki az ajtót, nyisd meg a Model fület, és kapcsold be a Pivot eszközt. Kattints és tartsd lenyomva a kis nyilat a Pivot gomb sarkában, és kapcsold be a Snap opciót, hogy a pivot a sarkokon, éleken és középpontokon lévő illesztési pontokhoz tapadjon. Húzd a pivotot az ajtó azon élére, ahol a zsanérok lennének. Tolóajtónál a pivot maradhat középen.
  4. Add hozzá a címkét. Az ajtó kijelölése mellett görgesd a Properties ablakot a Tags részig, kattints a + gombra, és írd be: Door, nagy D-vel. Ha az ajtó Model, a címkét magára a Modelre tedd, ne a benne lévő partokra.
  5. Építs egy második ajtót, a tolóajtókról és a kulcsról szóló részekben kell majd. Illessz be a Workspace-be még két Partot: egy Panel nevűt nagyjából 4, 7, 0.5 mérettel, és egy Knob nevűt nagyjából 0.5, 0.5, 0.5 mérettel, a Panel egyik lapjához illesztve. Jelöld ki mindkettőt, nyomd meg a Ctrl+G-t, és nevezd át az új Modelt VaultDoor névre. Rögzítsd mindkét partot, tedd a modellt a második nyílásba, és add hozzá a Door címkét a Modelhez. A pivotja maradhat középen, mert ez tolóajtó lesz.

A pivot azért fontos, mert a nyíló ajtó körülötte fordul. Ha középen hagyod, az ajtó egy helyben forog, mint egy bolti forgóajtó. Egy partnál az általad beállított pivot PivotOffset-ként mentődik, és a GetPivot figyelembe veszi, ezért a script pontosan az általad választott pont körül fordítja az ajtót. Ha egy Modelnek van PrimaryPart-ja, a modell pivotja ennek a partnak a pivotja, és a DoorService a promptot is erre teszi. PrimaryPart nélkül a prompt a modellben talált első partra kerül. Ha PrimaryPartot állítasz be, ezt a pivot mozgatása előtt tedd: a PrimaryPart megadása a modell pivotját a part pivotjára helyezi át, ahogy a Roblox Pivot tools oldala is megjegyzi.

Az ajtó beállításai (attribútumok)

Minden ajtó működik az alábbi táblázat alapértékeivel. Egy ajtó módosításához jelöld ki, görgesd a Properties ablakot az Attributes részig, kattints a + gombra, írd be a nevet, válaszd ki a típust, kattints a Save gombra, majd add meg az értéket. A DoorService egyszer olvassa be az attribútumokat, amikor beállítja az ajtót, ezért akkor módosítsd őket, amikor a játék le van állítva.

Opcionális attribútumok minden ajtón
AttribútumTípusAlapértékMit csinál
StylestringSwingA Swing a pivotja körül fordítja el az ajtót. A Slide oldalra tolja a szélessége mentén.
OpenAnglenumber90Hány fokot fordul a nyíló ajtó. Negatív szám a másik irányba nyitja. Az érték -179 és 179 között legyen: az ajtó mindig a rövidebb íven halad, ezért a DoorService ezekre a határokra korlátozza a szöget.
SlideDistancenumbera szélességeHány studot halad a tolóajtó a szélessége mentén. Negatív szám a másik irányba tolja.
OpenSecondsnumber0.6Meddig tart a teljes nyitás vagy zárás, 0.05 és 10 között.
AutoCloseSecondsnumber4Mennyi ideig áll az ajtó teljesen nyitva, mielőtt magától bezárul. A 0 nyitva hagyja, amíg valaki be nem zárja.
KeyNamestringnincsAnnak a Toolnak a neve, amely a játékosnál kell legyen az ajtó kinyitásához, például RedKey. Ne add meg olyan ajtónál, amelyet bárki kinyithat.

2. lépés: add hozzá az ajtó scriptet

Vidd a kurzort a ServerScriptService fölé, illessz be egy Scriptet DoorService néven, és másold bele az alábbi kódot. A place összes ajtóját kezeli, akárhányat címkéztél fel. Az elején lévő három beállítás minden ajtóra érvényes; az 1. lépés attribútumai egy-egy ajtót módosítanak.

Script helye: ServerScriptService neve: DoorService
-- Script a ServerScriptService-ben, DoorService néven.
-- Minden "Door" címkéjű Partot vagy Modelt kinyit és bezár egy E nyomva tartásos prompttal.
-- Az ajtót a szerver mozgatja, ezért minden játékos ugyanazt az ajtót látja, és ugyancsak a szerver
-- ellenőrzi a távolságot és a kulcsot, így senki sem nyit ki bezárt ajtót messziről.
--
-- Opcionális attribútumok minden ajtón (a Properties ablakban adhatók meg):
--   Style            string  "Swing" (alapérték) vagy "Slide"
--   OpenAngle        number  hány fokot fordul a nyíló ajtó a pivot körül (alapérték 90, -179 és 179 között)
--   SlideDistance    number  hány studot halad a tolóajtó a szélessége mentén (alapérték: a szélessége)
--   OpenSeconds      number  meddig tart a nyitás (alapérték 0.6)
--   AutoCloseSeconds number  ennyi másodperc után újra bezár; a 0 nyitva hagyja (alapérték 4)
--   KeyName          string  annak a Toolnak a neve, amely a játékosnál kell legyen, például "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 -- ajtónként, a prompt spamelése ellen

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 -- a Properties ablakban beírt NaN vagy végtelen
	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 -- már működő ajtó, vagy se nem part, se nem modell
	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)
	-- Egy működő ajtó másolata magával hozza a régi promptot és értéket: töröljük őket
	for _, leftover in door:GetDescendants() do
		if leftover.Name == "DoorPrompt" or leftover.Name == "DoorProgress" then
			leftover:Destroy()
		end
	end

	-- A zárt és a nyitott helyzetet egyszer számoljuk ki, onnan, ahol az ajtó most áll
	local closedPivot = door:GetPivot()
	local openPivot: CFrame
	if attribute(door, "Style", "Swing") == "Slide" then
		-- Az ajtó hosszabb vízszintes oldala, a szélessége mentén haladunk. A Modelt a pivotja
		-- oldalai mentén mérjük, a Partot a saját Size-a szerint, ezért ne forgasd el a toló part pivotját
		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
		-- A Lerp mindig a rövidebb íven fordít, ezért nagyobb szög rossz irányba nyitná az ajtót
		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", "")

	-- Egy számot tweenelünk 0-ról (zárva) 1-re (nyitva), és az ajtót utána mozgatjuk.
	-- A PivotTo egyetlen partot vagy egy egész modellt mozgat a pivotja körül.
	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) -- ezt más scriptek is olvashatják
		prompt.ActionText = if open then "Close" else "Open"
		-- Egy új tween ugyanazon az értéken leállítja a régit, így az ajtó félúton is visszafordulhat.
		-- Az időt aszerint skálázzuk, mennyi út van még hátra.
		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
		-- A Roblox biztonsági útmutatója szerint a promptokkal ugyanúgy vissza lehet élni, mint a remote-okkal, ezért itt újra ellenőrzünk
		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 -- túl messze van ahhoz, hogy tisztességesen használja a promptot
		end
		if keyName ~= "" and not isOpen and not hasKey(player, keyName) then
			return -- zárva van, és ennél a játékosnál nincs kulcs
		end
		lastUse = now
		move(not isOpen)
	end)
end

-- Minden most címkézett ajtó, és minden, amely később kap címkét (a scriptek által klónozott ajtókat is beleértve)
for _, door in CollectionService:GetTagged(DOOR_TAG) do
	setUpDoor(door)
end
CollectionService:GetInstanceAddedSignal(DOOR_TAG):Connect(setUpDoor)

A DoorService a játék indulásakor maga teszi be a DoorPrompt és a DoorProgress objektumot minden ajtóba, ezért kézzel semmit sem kell beillesztened. A scriptből egy példányt tarts meg: már most kiszolgálja az összes címkézett ajtót.

Mit csinál a DoorService egyes része
A script részeMit csinálMiért
attribute()Beolvas egy attribútumot, és az alapértéket adja vissza, ha az attribútum hiányzik, rossz a típusa, vagy nem valódi szám (NaN vagy végtelen).Egy elírás a Properties ablakban alapbeállítású ajtót eredményez, nem elromlott ajtót.
doorsSetUp és a leftover ciklusMinden ajtót egyszer állít be, és előbb törli a másik ajtóról átmásolt DoorPrompt vagy DoorProgress objektumot.Különben egy működő ajtó másolatának két promptja lenne, és az egyik nem működne.
closedPivot és openPivotEgyszer számolódnak ki, onnan, ahol az ajtó a beállításkor áll. A nyíló ajtó a pivotot a saját függőleges tengelye körül fordítja el; a tolóajtó az ajtó hosszabb oldala mentén tolja el.A zárt pivottól a nyitottig tartó Lerp a pivotot a helyén tartja, amíg az ajtó fordul, így a zsanéros él a teljes fordulás alatt nem mozdul el.
DoorProgress és PivotToA tween egy számot változtat; minden változás a closedPivot:Lerp(openPivot, alpha) helyzetbe teszi az ajtót.A TweenService tud NumberValue-t tweenelni, a PivotTo pedig úgy mozgat egy partot vagy egy modellt az összes partjával együtt, hogy a pivot erre a CFrame-re kerüljön.
A promptHoldDuration 0.2, MaxActivationDistance 8, RequiresLineOfSight kikapcsolva. A bezárt ajtó a "Needs RedKey" feliratot mutatja.Bekapcsolt rálátással a prompt elrejtőzik, ha valami eltakarja a partját; nélküle a keret vagy a modell ajtó többi része nem rejti el a promptot.
move()Elindítja a tweent 1 vagy 0 felé, az időt pedig aszerint skálázza, mennyi utat kell még megtennie az ajtónak.Egy új tween ugyanazon az értéken leállítja a régit, ezért a félúton visszafordított ajtó simán megy vissza, és ehhez feleannyi idő kell.
Automatikus zárásKivárja a nyitási időt plusz az AutoCloseSeconds értéket, majd csak akkor zárja be az ajtót, ha a moveCount nem változott.Egy régi időzítő soha nem csapja be az ajtót, amelyet közben valaki bezárt és újra kinyitott.
Ellenőrzések a Triggered eseménybenAjtónként egy használat 0.3 másodpercenként, élő karakter, legfeljebb 14 stud a prompt partjától, és kulcs, de csak nyitáshoz.Mindennel, amit a kliens elindíthat, vissza lehet élni, ezért a szerver megismétli az ellenőrzéseket. A 14 stud a prompt 8 studja plusz 6 tartalék annak a játékosnak, aki elmozdult, amíg az E-t nyomva tartotta.
Az Open attribútumMinden mozgáskor beállítódik az ajtón.A szerveren beállított attribútumok minden játékoshoz replikálódnak, így más scriptek, a LocalScripteket is beleértve, a GetAttributeChangedSignal("Open") segítségével figyelhetik.

Az összes ajtó felcímkézése és egyetlen scriptből való kezelése az a megközelítés, amelyet maga a Roblox ajánl: a CollectionService leírása szerint ha ugyanazt a scriptet sok objektumba teszed, egy CollectionService-re épülő script jobb megoldás lehet. A GetTagged a script indulásakor létező ajtókat adja vissza, a GetInstanceAddedSignal pedig elkapja a később felcímkézett vagy hozzáadott ajtókat. A place ilyen szervezését a kliens- és szerverscriptekről szóló útmutató tárgyalja.

Hogyan készíts tolóajtót

Jelöld ki a VaultDoor ajtót, adj hozzá egy string típusú, Style nevű attribútumot, és állítsd az értékét Slide-ra. Mostantól az ajtó nem fordul, hanem oldalra halad: a saját szélességével, vagy SlideDistance studdal, ha megadtad. Ha a másik irányba szeretnéd tolni, adj meg negatív távolságot, például -4-et egy 4 stud széles ajtónál. Bármely más ajtó, a FrontDoort is beleértve, ugyanígy tolóajtóvá válik, amint megkapja ezt az attribútumot.

A DoorService megméri az ajtó két vízszintes méretét, a szélességét és a vastagságát, és a nagyobbik mentén mozgatja. A Modelt a GetExtentsSize segítségével méri, amelynek doboza a modell pivotjának tájolását követi, így az ajtó, amelyet a csoportosítás után 90 fokkal elfordítottak, továbbra is a szélessége mentén halad, nem a vastagsága mentén. A Partot a part saját Size értéke alapján méri, ezért ne forgasd el a toló part pivotját. Eltolni viszont szabad.

  • Dupla ajtók: két felcímkézett fél egymás mellett, mindkettőnél Style = Slide, az egyiknél pedig negatív SlideDistance, hogy középről széttávolodjanak. Nyíló dupla ajtóknál tedd mindkét fél pivotját a külső élére, és az egyik félnek adj negatív OpenAngle értéket. Mindkét félnek saját promptja van, és külön nyílik. Ha a felek egymásba haladnak, tedd át a mínuszjelet a másik félre.
  • Felfelé nyíló kapuk: ez a script az ajtót csak a szélessége mentén mozgatja. Ha azt szeretnéd, hogy az ajtók felemelkedjenek, állítsd a scriptben a direction értékét Vector3.yAxis-ra (ekkor minden tolóajtó felfelé halad), és mindegyiknek adj a magasságával egyenlő SlideDistance értéket.
  • Fizikás ajtó: a Roblox mozgó objektumokról szóló oktatóanyaga a partokat egy tengely mentén mozgatja PrismaticConstraint segítségével. A zsanéros ajtóhoz hasonlóan ez is fizika, prompt és zár nélkül, amíg meg nem írod őket magad.

Hogyan zárd be az ajtót kulccsal

A bezárt ajtó csak annak a játékosnak nyílik ki, akinél van egy megfelelő nevű Tool. Készíts kulcsot, majd add meg az ajtónak a nevét:

  1. Vidd a kurzort a StarterPack fölé, kattints a + gombra, és illessz be egy Toolt RedKey néven. Tegyél bele egy Handle nevű Partot, ezt tartja a karakter a kezében, és győződj meg róla, hogy nincs rögzítve: egy rögzített part a toolban a helyhez szögezi a karaktert. Kapcsold ki a Tool CanBeDropped opcióját, ha a játékosok nem dobhatják el a kulcsot valaki másnak: amíg be van kapcsolva, a Backspace a felszerelt toolt a Workspace-be dobja.
  2. Jelöld ki a VaultDoor ajtót, adj hozzá egy string típusú, KeyName nevű attribútumot, és állítsd az értékét RedKey-re. Mostantól a prompt objektumnevében ez áll: Needs RedKey.

A DoorService két helyen keresi a kulcsot. A Tool a játékos Backpackjében van, amíg fel nem szerelik, a felszerelés pedig a karakterbe helyezi át, ezért az ajtó akkor is kinyílik, ha a kulcs a hotbarban van, és akkor is, ha a kézben. Az ellenőrzés a szerveren történik, mert a Roblox biztonsági útmutatója éppen ezt az esetet, vagyis hogy van-e a játékosnál kulcs az ajtóhoz, nevezi olyan jogosultságnak, amelyet a szervernek kötelező ellenőriznie. A kulcs csak a nyitáshoz kell: egy nyitott ajtót bárki bezárhat, és az AutoCloseSeconds után magától is bezárul.

A StarterPack minden újraéledéskor mindenkinek kiadja a kulcsot, és teszteléshez pont ez kell. Egy igazi játékban másképp add ki:

  • Boltból: a bolt GUI útmutató a ServerStorage-ból adja ki a Toolt a vásárló Backpackjébe és StarterGearjébe.
  • Egy karaktertől: az NPC párbeszéd útmutató a ServerStorage.DialogueItems mappából ad ki egy Toolt, amikor a játékos egy GiveItem műveletű lehetőséget választ. Tegyél ebbe a mappába egy RedKey nevű Toolt, a DialogueData-ban pedig állítsd a lehetőségnél az action = "GiveItem" és az item = "RedKey" értéket, és a kulcsot beszélgetés közben kapják meg.
  • Inventory tárgyként: az inventory rendszerrel a kulcs tárgy azonnal működik, amint a játékos felszereli, mert a felszerelés a Tool egy másolatát a Backpackbe és a kézbe teszi.

A Backpackben lévő kulcs elvész, amikor a karakter meghal, mert a Roblox minden újraéledéskor újratölti a Backpacket a StarterPackből és a StarterGearből. Ha meg akarod tartani, tegyél egy másolatot a játékos StarterGearjébe is, ahogy a bolt útmutató teszi. Ha viszont azt szeretnéd, hogy a kulcs elhasználódjon, keresd meg a kulcs Toolt a játékos Backpackjében vagy karakterében, és semmisítsd meg a Triggered kezelőben, közvetlenül a sikeres kulcsellenőrzés után.

Miben tévednek a régi ajtós oktatóanyagok

Ha ezt az útmutatót egy videóval vagy fórumbejegyzéssel hasonlítod össze, itt vannak azok a módszerek, amelyek miatt a legtöbb „nem működik az ajtóm” téma születik, és amit ez az útmutató helyettük csinál.

Gyakori módszerek az ajtós oktatóanyagokban, és mit csinál helyettük ez az útmutató
OktatóanyagProblémaEz az útmutató
A Model ajtó CFrame-jét tweeneliA Model leírásában nincs CFrame vagy Position tulajdonság. A WorldPivot csak a modell pivotjának helyét adja meg, ezért a tweenelése a pivot pontját mozgatja, a partok a helyükön maradnak.Egy NumberValue-t tweenel, és az egész modellt a PivotTo hívással mozgatja.
A modellt a SetPrimaryPartCFrame hívással mozgatjaElavult: a Roblox azt tanácsolja, hogy új projektekben a PivotTo-t használd.A PivotTo-t használja, amelyet a Roblox a Model scriptből való mozgatásának elsődleges függvényének nevez.
Minden partot egy zsanér partra hegeszt, és csak a zsanért tweeneliMűködik, ha minden Weld a helyén van, de bármely nem hegesztett part lemarad, amikor a zsanér mozdul.Minden partot rögzítve tart, Weld nélkül. A PivotTo az ajtót és mindent, ami benne van, együtt mozgatja.
Ugyanazt a scriptet minden ajtóba bemásoljaMinden javítást minden példányban meg kell ismételni. A Roblox azt javasolja, hogy címkézd fel az objektumokat, és egyetlen scripttel kezeld őket a CollectionService segítségével.Egy DoorService és a Door címke.
LocalScriptben nyitja ki az ajtótAz ajtó csak annak a játékosnak a képernyőjén nyílik ki, mindenki más továbbra is zárva látja.Az ajtót a szerver mozgatja, ezért minden játékos ugyanazt az ajtót látja.
A Touched eseményre nyitja ki az ajtótA Touched egy érintésre többször is elsül egymás után (a Roblox debounce oldala), és a játékos eszköze befolyásolhatja, mikor sül el a Touched a saját karakterénél (a Roblox biztonsági dokumentációja).Egy prompt, amelyet a szerver ellenőriz.
Az ajtót egy wait() ciklusban lépésenként mozgatjaA Roblox a wait()-et a task.wait() által felváltottként jelöli, és a ciklus nem tud félúton visszafordulni, amikor valaki újra megnyomja.Mozgásonként egy tween. Egy új tween ugyanazon az értéken leállítja a régit, ezért az ajtó onnan fordul vissza, ahol éppen van.
LocalScriptben ellenőrzi a kulcsot, vagy egyáltalán nemA csaló mindent irányít a saját eszközén, ezért a kliensoldali ellenőrzés senkit sem állít meg.A szerver a játékos Backpackjében és karakterében keresi a Toolt.
Nincs cooldown a promptonA Roblox biztonsági útmutatója szerint a promptok ugyanúgy ki vannak téve a visszaélésnek, mint a remote-ok, ezért semmi sem akadályozza meg, hogy újra és újra elsüssék.Ajtónként egy használat 0.3 másodpercenként.

Mit tud és mit nem tud egy csaló

Számolj azzal, hogy a csaló mindent irányít a saját eszközén, a saját karakterét is beleértve. Ezeknél az ajtóknál ez a következőt jelenti.

Mit próbálhat meg egy csaló, és mit kezd ezzel a DoorService
A csaló megpróbáljaEredményMiért
A térkép másik végéről elsütni a promptotFigyelmen kívül marad, ha a karaktere nincs az ajtónálA DoorService megméri a távolságot a karakter gyökérpartjától a prompt partjáig, és mindent figyelmen kívül hagy, ami 14 studnál messzebb van. A csaló előbb az ajtóhoz teleportálhatja a karakterét (lásd az utolsó sort), ezért a távolság-ellenőrzés a messziről való használat ellen véd, nem a teleport ellen.
Másodpercenként sokszor elsütniAjtónként legfeljebb egy használat 0.3 másodpercenkéntA szerver minden ajtónál tárolja az utolsó használat idejét.
Kulcs nélkül kinyitni a kulcsos ajtótElutasítvaA szerver a csaló Backpackjében és karakterében keresi a Toolt ott, ahol maga látja őket, nem a csaló képernyőjén.
Használni az ajtót, amíg a karaktere halottFigyelmen kívül maradA DoorService ellenőrzi, hogy van-e 0-nál nagyobb életerejű Humanoid és gyökérpart.
Mégis átmenni a zárt ajtónLehetségesA Roblox biztonsági dokumentációja a fizikai akadályok kikerülését és a saját ütközések módosítását is felsorolja azok között, amiket a kliens a saját karakterével megtehet.
Az ajtó mögé teleportálniLehetségesUgyanez a dokumentáció említi a saját karakter tetszőleges pontra teleportálását.

3. lépés: teszteld

  1. Nyomd meg a Play gombot (F5). Menj a FrontDoor ajtóhoz: 8 studon belül megjelenik a prompt az Open művelettel és a Door objektumnévvel. Tartsd nyomva az E-t. 0,2 másodperc után az ajtó 0,6 másodperc alatt 90 fokkal kitárul a zsanéros él körül, és a promptban most Close áll.
  2. Menj át az ajtón, és várj. Négy másodperccel a teljes kinyílás után az ajtó magától bezárul. Tartsd nyomva az E-t, miközben záródik: visszafordul, és onnan nyílik ki, ahol volt.
  3. Teszteld a zárat. Ha a RedKey a StarterPackben van, tedd át egyelőre a ServerStorage-ba, nyomd meg a Play gombot, és tartsd nyomva az E-t a VaultDoor ajtónál: a promptban Needs RedKey áll, és semmi sem mozdul. Állítsd le a játékot, tedd vissza a RedKey-t a StarterPackbe, és indítsd újra: a VaultDoor kinyílik, akár a hotbarban van a kulcs, akár a kézben.
  4. Teszteld a tolóajtót. A VaultDoor, egy Style = Slide beállítású Model, nyitáskor a szélességével oldalra halad. Állítsd le a játékot, jelöld ki a VaultDoor ajtót, fordítsd el 90 fokkal a Rotate eszközzel, és indítsd újra: továbbra is a szélessége mentén kell haladnia, nem a vastagsága mentén. Ha végeztél, fordítsd vissza.
  5. Válaszd a Server & Clients lehetőséget a tesztmódok legördülő listájában, állíts be 2 klienst, és nyomd meg a Play gombot. Nyisd ki az ajtót az egyik kliens ablakában: a másik ablakban is nyitva van, és mindkettőben bezárul.
  6. Állítsd le a játékot, jelölj ki egy ajtót, nyomd meg a Ctrl+D-t a duplikáláshoz, majd vidd a másolatot egy másik nyílásba. Ellenőrizd, hogy a másolat Tags részében továbbra is ott van-e a Door, és nyomd meg a Play gombot: a másolat külön script nélkül működik.

Tartsd nyitva az Output ablakot (Window menü, majd Output). Ha minden működik, a DoorService semmit sem ír ki. Ha egy figyelmeztetés szerint egy ajtónak "has no part to put the prompt on", az azt jelenti, hogy a címkézett Modelben nincsenek partok. A többit lásd a Gyakori hibák részben.

Hogyan bővítsd

Automatikus ajtók

Ha azt szeretnéd, hogy az ajtó kinyíljon, amikor valaki odamegy, hívd a move(true) függvényt a setUpDoor belsejéből, a promptra várás nélkül. A setUpDoor végén a task.spawn segítségével indíts egy ciklust, mert egy sima ciklus ott soha nem érne véget, és a DoorService nem jutna túl az első ajtón. Csak addig fusson, amíg az ajtó a játékban van: task.spawn(function() while door.Parent do ... task.wait(0.5) end end). A cikluson belül a workspace:GetPartBoundsInBox segítségével ellenőrizd, van-e karakter a nyílás körüli dobozban, és hívd a move(true) függvényt, ha van, az ajtó pedig zárva van. Utána, mint eddig, az automatikus zárás csukja be. Állítsd a prompt Enabled értékét false-ra, ha az ajtó csak magától nyílhat.

VIP ajtók

A game pass útmutató már épít egy VIP ajtót ütközési csoportokkal, amelyen a pass tulajdonosai egyszerűen átsétálnak. Egy E-re nyíló VIP ajtóhoz adj még egy ellenőrzést a Triggered kezelőhöz a kulcsellenőrzés mellé: térj vissza (return), ha nem teljesül a player:GetAttribute("OwnsPass_VIP") == true feltétel, ezt az attribútumot a game pass útmutató szerverscriptje állítja be. Csak a szerveren olvasd.

Kódpanel

Egy beírt kóddal nyíló ajtónál a kódot egy szerveroldali Scriptben vagy a ServerStorage-ban tárold, amelyeket a játékosok soha nem kapnak meg, és semmiképp ne LocalScriptben, ahol a csaló kiolvashatja. A panel LocalScriptje RemoteEventen keresztül csak a beírt számjegyeket küldi el. A szerveren ellenőrizd, hogy a játékos az ajtó közelében van-e, korlátozd a próbálkozások gyakoriságát, hasonlítsd össze a számjegyeket, és csak utána hívd a move(true) függvényt. A RemoteEvent útmutató megmutatja, hogyan ellenőrizd, amit egy remote kap.

Hangok

Tegyél egy Soundot az ajtó partjába, hogy annak a partnak a helyéről szóljon, és a move elején hívd meg a Play metódusát. Vagy játszd le egy LocalScriptből, amely a GetAttributeChangedSignal("Open") segítségével figyeli az ajtó Open attribútumát, hiszen a szerver ezt az attribútumot minden mozgáskor beállítja.

Játék közben hozzáadott ajtók

Az új ajtókat egy zárt sablonból klónozd a ServerStorage-ban. A DoorService az ajtó zárt helyzetét abban a pillanatban olvassa be, amikor megjelenik, ezért egy olyan ajtó másolata, amely akkor éppen nyitva volt, a nyitott helyzetét tekintené zártnak. Tedd a másolatot a nyílásba a PivotTo hívással, mielőtt a Parent értékét Workspace-re állítanád, hogy a DoorService ezt a helyet jegyezze meg zártként. A másolattal érkező régi promptok és értékek automatikusan törlődnek. Az olyan ajtóról, amely a játékosokat egy másik zónába vagy place-be viszi, a teleport útmutatóban olvashatsz.

Gyakori hibák és megoldásaik

Nyisd meg az Output ablakot (Window menü, majd Output), mielőtt megnyomod a Play gombot. Az ajtós problémák többsége egy címkéből, pivotból vagy attribútumból ered, amely egy kicsit eltér attól, amit a script vár.

Nem jelenik meg a prompt az ajtónál

Ellenőrizd sorban: a DoorService Script, nem LocalScript, és közvetlenül a ServerScriptService-ben van; az ajtón ott a Door címke nagy D-vel, modell ajtónál magán a Modelen; az ajtó part (Part, MeshPart vagy más BasePart) vagy Model; és legfeljebb 8 studra állsz attól a parttól, amelyen a prompt van. Ha az Outputban egy figyelmeztetés szerint az ajtónak "has no part to put the prompt on", az azt jelenti, hogy a címkézett Modelben nincsenek partok.

Az ajtó leesik, elúszik, vagy eltolják, amikor a játék elindul

Valamelyik partja nincs rögzítve. Jelöld ki az ajtó összes partját, és kapcsold be az Anchored opciót. A rögzített partokat soha nem mozdítja el a fizika, de a DoorService ettől még mozgathatja őket.

Módosítottam egy attribútumot, de az ajtó figyelmen kívül hagyja

Ellenőrizz három dolgot. Típus: az OpenAngle, a SlideDistance, az OpenSeconds és az AutoCloseSeconds number típusú attribútum kell legyen, a Style és a KeyName pedig string típusú; rossz típusnál a DoorService az alapértéket használja. Írásmód: a neveket pontosan hasonlítja össze, ezért az openAngle egy másik attribútum. Az értékeket is pontosan hasonlítja össze: a Style értéke Slide legyen, nagy S-sel és szóközök nélkül. Időpont: a DoorService egyszer olvassa be az attribútumokat, amikor beállítja az ajtót, ezért a játékteszt közbeni módosításnak nincs hatása, amíg újra nem indítod a játékot.

Az ajtó rossz irányba nyílik, vagy oldalra dől

Ha a másik irányba szeretnéd nyitni, tedd negatívvá az OpenAngle értékét, például -90-re. Ha egy vízszintes tengely körül fordul a függőleges zsanér helyett, akkor maga a pivot van elforgatva: kapcsold be a Pivot eszközt a Model fülön, és fordítsd vissza a pivotot, hogy függőlegesen álljon.

A tolóajtó a falba szalad, vagy csak egészen kicsit mozdul

Adj neki negatív SlideDistance értéket, hogy a másik irányba haladjon. Ha túl keveset vagy túl messzire mozdul, add meg a SlideDistance-ben a kívánt studszámot, és ne hagyatkozz a mért szélességre.

Nálam van a kulcs, de az ajtó nem nyílik ki

A kulcsnak Toolnak kell lennie, nem Partnak vagy Modelnek, és a nevének pontosan egyeznie kell a KeyName értékkel, a nagybetűket is beleértve. A Backpackedben vagy a kezedben kell lennie. Ellenőrizd azt is, hogy az ajtón a KeyName string típusú attribútum-e.

Elkészítés RoCode-dal

Ha nincs kedved mindezt kézzel beállítani, a RoCode meg tudja építeni a nálad nyitott place-ben. A RoCode egy független AI-ügynök a Roblox Studióhoz, nem a Robloxtól: a webes chatben leírod a változtatást, a Studio pluginja pedig létrehozza a scripteket és objektumokat az Explorerben, így semmilyen kódot nem kell beillesztened.

Te írod

Csináld meg, hogy a Door címkéjű ajtók E nyomva tartásos promptra nyíljanak: 90 fokos fordulás a pivot körül 0,6 másodperc alatt, bezárás 4 másodperc után, fordulás helyett eltolás, ha a Style attribútum Slide, és az ajtó zárva marad, ha a játékosnál nincs a KeyName szerinti nevű Tool. Minden a szerveren, távolság-ellenőrzéssel.

A RoCode elvégzi
  • Ha egy lépéshez kell, a Search Game és a Search Scripts eszközzel átnézheti a place-edet, hogy a meglévő tárgyakra, remote-okra vagy mentési kódra építsen, ahelyett hogy egy második rendszert adna hozzá
  • A Scriptet a Create Script eszközzel írja a ServerScriptService-be, a Create Instance eszközzel létrehozhatja az ajtó partját, és beállíthatja rajta az attribútumokat, például a Style és a KeyName értékét
  • Az a feladata, hogy minden megírt script fordítását ellenőrizze a Check Scripttel, amely futtatás nélkül lefordítja a Studióban
  • Minden módosításcsomag előtt és után visszavonási pontot tesz, így a Ctrl+Z egyszerre egy csomagot von vissza

Tesztelés előtt ellenőrizd minden ajtó pivotját a Studio Pivot eszközével: az ajtó körülötte fordul. 3.9-es vagy újabb pluginnal a RoCode rövid játéktesztet indíthat és kiolvashatja a hibákat, 3.9.15-ös vagy újabb pluginnal pedig irányíthat egy tesztkaraktert, amely sétál és billentyűket nyom, de csak azt ellenőrzi, amit maga választott ki tesztelésre, ezért menj oda minden ajtóhoz, és tartsd nyomva az E-t te is. Hogyan csatlakozik a RoCode a Studióhoz.

Gyakori kérdések

Hogyan érhetem el, hogy az ajtó E-re nyíljon a Roblox Studióban?

Tegyél egy ProximityPromptot az ajtóba, és kösd a Triggered eseményét egy szerveroldali Scripthez, amely mozgatja az ajtót. A DoorService mindkettőt elvégzi minden Door címkéjű ajtónál. Az E a prompt alapértelmezett billentyűje, és a Roblox a billentyűzetekhez, kontrollerekhez és érintőképernyőkhöz a megfelelő bevitelt mutatja.

Miért forog az ajtóm a közepe körül?

A pivotja még mindig középen van. Kapcsold be a Pivot eszközt a Model fülön, és húzd a pivotot a zsanéros élre; a script a pivot körül fordítja az ajtót.

Hogyan készíts tolóajtót?

Állítsd az ajtó Style attribútumát Slide-ra. A szélességével vagy SlideDistance studdal oldalra halad; negatív távolság a másik irányba tolja.

Lehet ajtót készíteni scriptek nélkül?

Igen. A Roblox zsanéros ajtóról szóló oktatóanyaga egy nem rögzített ajtót köt a kerethez HingeConstraint segítségével, korlátokkal, és a játékosok a testükkel tolva nyitják ki. Egy ilyen ajtónak nincs promptja, zárja és automatikus zárása.

Hogyan készíts ajtót, amelyet csak a VIP-ek nyithatnak ki?

Használd a game pass útmutató VIP ajtaját, amelyen a pass tulajdonosai átsétálnak, vagy adj a DoorService Triggered kezelőjéhez egy ellenőrzést, amely nyitás előtt a szerveren kiolvassa, hogy a játékosnak megvan-e a pass, például az OwnsPass_VIP attribútumot, amelyet az az útmutató állít be.

Miért nyílik ki az ajtó nálam, de a többi játékosnál nem?

Egy LocalScript nyitja ki, a LocalScript által végzett változtatás pedig annak a játékosnak az eszközén marad. Tedd át a nyitó kódot egy szerveroldali Scriptbe, ahogy a DoorService-ben, hogy a változás mindenkihez eljusson.

Források és további olvasnivaló

Hogyan ellenőriztük a kódot: az oldalon minden script átmegy a Luau szigorú típusellenőrzésén a Roblox API definícióival (luau-lsp, 2026. november 20.). A típusellenőrzés kiszűri az elírt API-neveket és a rossz típusokat, de a játéklogikai hibákat nem, ezért publikálás előtt mindent tesztelj a Studióban.

Próbáld ki a RoCode-ot a saját játékodban.

Ingyenes kreditek minden nap, bankkártya nélkül. Telepítsd a plugint, írd le a funkciót, és nézd meg, mi jelenik meg a Studióban.