Poradnik · Systemy gry

Jak zrobić drzwi w Roblox Studio

Działające drzwi w Roblox potrzebują trzech rzeczy: czegoś, co naciska gracz (ProximityPrompt z napisem "Open"), płynnego ruchu (TweenService) i serwera, który wprowadza zmianę, żeby wszyscy gracze widzieli te same drzwi. W tym poradniku budujemy jeden skrypt, który robi to dla każdych drzwi z tagiem, uchylnych albo przesuwnych, z opcjonalnym zamkiem na klucz: serwer sprawdza klucz, zanim cokolwiek otworzy.

Zaktualizowano 20 listopada 202619 min czytaniaAutor:

W skrócie

Zbuduj drzwi jako Part albo Model, zaznacz Anchored, przenieś ich pivot na krawędź z zawiasami (karta Model, Pivot) i dodaj tag Door w oknie Properties. Jeden Script w ServerScriptService znajduje wszystkie drzwi z tagiem przez CollectionService, dodaje ProximityPrompt ("Open", przytrzymanie E) i na event Triggered tweenuje NumberValue od 0 do 1, przesuwając drzwi przez door:PivotTo(closedPivot:Lerp(openPivot, alpha)). Atrybuty na każdych drzwiach ustawiają typ uchylny albo przesuwny, kąt, czas, automatyczne zamykanie i klucz.

  • Pozycji Model nie da się tweenować bezpośrednio: Model nie ma właściwości CFrame ani Position, a jego WorldPivot ustawia tylko miejsce pivota. Tweenuj NumberValue i przesuwaj drzwi przez PivotTo: Roblox nazywa go głównym sposobem przesuwania modeli ze skryptu.
  • Otwieraj drzwi na serwerze. Drzwi otwarte z LocalScript ruszają się tylko na ekranie tego gracza.
  • Sprawdzaj klucz i odległość na serwerze. W poradniku Roblox o bezpieczeństwie napisano, że ProximityPrompt można wykorzystać w złych zamiarach tak samo jak RemoteEvent, i podano tam przykład sprawdzenia, które musi robić serwer: czy gracz ma klucz potrzebny do otwarcia drzwi.
Na tej stronie
  1. Jak to działa
  2. 1. Budujemy drzwi
  3. 2. Skrypt drzwi
  4. Drzwi przesuwne
  5. Drzwi na klucz
  6. Stare tutoriale
  7. Granice ochrony
  8. 3. Sprawdzenie
  9. Rozbudowa
  10. Common errors
  11. Z RoCode
  12. Najczęstsze pytania
  13. Źródła i dalsza lektura

Jak działają drzwi na skrypcie

IlustracjaPrzytrzymanie E przez 0.2 sekundy otwiera drzwi w 0.6 sekundy, a 4 sekundy po pełnym otwarciu zamykają się same (tu przyspieszone). VaultDoor zostaje zamknięte dla gracza bez RedKey.

Drzwi, które działają w prawdziwej grze, musi przesuwać serwer. Jeśli przesuwa je LocalScript, drzwi otwierają się na ekranie jednego gracza i zostają zamknięte dla wszystkich innych, bo zmiana zrobiona przez klienta zostaje na tym urządzeniu (zobacz co się replikuje, a co nie). Dlatego w tym poradniku urządzenie gracza tylko pokazuje podpowiedź i zgłasza naciśnięcie klawisza, a całą resztę robi jeden serwerowy Script. Jedno użycie drzwi wygląda tak:

  1. Gracz podchodzi do drzwi bliżej niż na 8 studów i pojawia się podpowiedź z akcją Open, nazwą obiektu Door i klawiszem E na klawiaturze. Na padzie albo ekranie dotykowym Roblox pokazuje odpowiedni przycisk.
  2. Gracz przytrzymuje E przez 0.2 sekundy. Event Triggered podpowiedzi odpala się na serwerze z tym graczem.
  3. DoorService sprawdza gracza: żyje, jest dość blisko, nie spamuje podpowiedzią i ma klucz, jeśli drzwi go wymagają.
  4. Skrypt tweenuje liczbę od 0 (zamknięte) do 1 (otwarte). Przy każdej zmianie liczby przez PivotTo przesuwa drzwi o tę część drogi od pozycji zamkniętej do otwartej.
  5. Cztery sekundy po pełnym otwarciu drzwi zamykają się w ten sam sposób. Naciśnięcie w trakcie ruchu zawraca drzwi z miejsca, w którym są.
Z czego składa się system drzwi
ElementGdzie jestCo robi
Script DoorServiceServerScriptServiceZnajduje wszystkie drzwi, dodaje każdym podpowiedź, sprawdza każde użycie i przesuwa drzwi. Jedyny skrypt w tym poradniku.
Tag DoorNa każdym Part albo Model drzwiOznacza, co jest drzwiami. Tagi dodaje się w oknie Properties i zapisują się razem z grą.
Atrybuty, na przykład Style i KeyNameNa każdych drzwiach (opcjonalnie)Ustawienia jednych drzwi: uchylne czy przesuwne, kąt, prędkość, automatyczne zamykanie i klucz.
ProximityPrompt DoorPromptW drzwiach (dodaje go DoorService)Pokazuje "Open" albo "Close" i odpala Triggered, gdy gracz przytrzymuje E.
NumberValue DoorProgressW drzwiach (dodaje go DoorService)Liczba, którą tween przesuwa między 0 a 1. Każda zmiana przesuwa drzwi.
Tool RedKey (opcjonalnie)StarterPack, do testówKlucz do zamkniętych drzwi. Pasuje każdy Tool, jeśli jego nazwa zgadza się z KeyName drzwi.
Explorer po przejściu poradnika. Oba drzwi mają tag Door, a VaultDoor ma jeszcze atrybuty Style = Slide i KeyName = RedKey. Gdy gra działa, DoorService dodaje DoorProgress do każdych drzwi i DoorPrompt do partu, na którym wisi podpowiedź.
Workspace
  FrontDoor Part new
  VaultDoor Model new
    Panel Part new
    Knob Part new
ServerScriptService
  DoorService Script new
StarterPack
  RedKey Tool new
    Handle Part new

Krok 1: zbuduj drzwi i ustaw zawias

  1. W Explorerze najedź kursorem na Workspace, kliknij przycisk + i wstaw Part. Nazwij go FrontDoor, ustaw Size na mniej więcej 4, 7, 0.5 (4 study szerokości, 7 wysokości, pół studa grubości) i postaw w przejściu. Drzwi z kilku partów też pasują: zaznacz je i naciśnij Ctrl+G, żeby zgrupować w Model.
  2. Zaznacz Anchored w każdym parcie drzwi i zostaw CanCollide włączone. Zakotwiczone party nigdy nie ruszają się od grawitacji ani zderzeń, ale skrypt i tak może je przesuwać, i właśnie to robi DoorService.
  3. Ustaw zawias. Zaznacz drzwi, otwórz kartę Model i włącz Pivot. Kliknij i przytrzymaj małą strzałkę w rogu przycisku Pivot i zaznacz Snap, żeby pivot przyklejał się do punktów zaczepienia na rogach, krawędziach i środkach. Przeciągnij pivot na tę krawędź drzwi, gdzie byłyby zawiasy. W drzwiach przesuwnych pivot może zostać na środku.
  4. Dodaj tag. Nie zdejmując zaznaczenia z drzwi, przewiń okno Properties do Tags, kliknij + i wpisz Door z wielkim D. Jeśli drzwi to Model, stawiaj tag na samym Model, a nie na partach w środku.
  5. Zbuduj drugie drzwi, przydadzą się w sekcjach o drzwiach przesuwnych i kluczu. Wstaw do Workspace jeszcze dwa Party: Panel o rozmiarze mniej więcej 4, 7, 0.5 i Knob mniej więcej 0.5, 0.5, 0.5, przystawiony do jednej ze ścian Panel. Zaznacz oba, naciśnij Ctrl+G i zmień nazwę nowego Model na VaultDoor. Zakotwicz oba party, postaw model w drugim przejściu i dodaj tag Door na Model. Jego pivot może zostać na środku, bo te drzwi będą przesuwne.

Pivot jest ważny, bo drzwi uchylne obracają się wokół niego. Jeśli zostawisz go na środku, drzwi będą kręcić się w miejscu jak drzwi obrotowe w sklepie. W parcie ustawiony przez ciebie pivot zapisuje się jako PivotOffset, a GetPivot go uwzględnia, więc skrypt obraca drzwi dokładnie wokół wybranego przez ciebie punktu. Jeśli Model ma PrimaryPart, pivot modelu to pivot tego partu i DoorService wiesza podpowiedź też na nim. Bez PrimaryPart podpowiedź trafia na pierwszy part znaleziony w modelu. Jeśli ustawiasz PrimaryPart, rób to, zanim przesuniesz pivot: przypisanie PrimaryPart przenosi pivot modelu do pivota tego partu, jak zaznaczono na stronie Roblox o Pivot tools.

Ustawienia drzwi (atrybuty)

Wszystkie drzwi działają z wartościami domyślnymi z tabeli niżej. Żeby zmienić jedne drzwi, zaznacz je, przewiń okno Properties do Attributes, kliknij +, wpisz nazwę, wybierz typ i kliknij Save, potem ustaw wartość. DoorService czyta atrybuty raz, gdy ustawia drzwi, więc zmieniaj je, gdy gra jest zatrzymana.

Opcjonalne atrybuty na każdych drzwiach
AtrybutTypDomyślnieCo robi
StylestringSwingSwing obraca drzwi wokół ich pivota. Slide przesuwa je w bok wzdłuż szerokości.
OpenAnglenumber90O ile stopni obracają się drzwi uchylne. Liczba ujemna otwiera je w drugą stronę. Trzymaj wartość między -179 a 179: drzwi zawsze idą krótszym łukiem, więc DoorService ogranicza kąt do tych granic.
SlideDistancenumberich szerokośćO ile studów drzwi przesuwne jadą wzdłuż swojej szerokości. Liczba ujemna przesuwa je w drugą stronę.
OpenSecondsnumber0.6Ile trwa pełne otwarcie albo zamknięcie, w granicach od 0.05 do 10.
AutoCloseSecondsnumber4Ile drzwi stoją w pełni otwarte, zanim same się zamkną. 0 zostawia je otwarte, dopóki ktoś ich nie zamknie.
KeyNamestringbrakNazwa Toola, który musi mieć gracz, żeby otworzyć drzwi, na przykład RedKey. Nie ustawiaj go dla drzwi, które może otworzyć każdy.

Krok 2: dodaj skrypt drzwi

Najedź kursorem na ServerScriptService, wstaw Script o nazwie DoorService i wklej do niego kod poniżej. Zarządza wszystkimi drzwiami w grze, niezależnie od tego, ile ich oznaczysz tagiem. Trzy ustawienia na początku działają na wszystkie drzwi; atrybuty z kroku 1 zmieniają jedne drzwi.

Script w ServerScriptService o nazwie DoorService
-- Script w ServerScriptService o nazwie DoorService.
-- Otwiera i zamyka każdy Part albo Model z tagiem "Door" podpowiedzią z przytrzymaniem E.
-- Drzwi przesuwa serwer, więc wszyscy gracze widzą te same drzwi, a serwer też
-- sprawdza odległość i klucz, więc nikt nie otworzy zamkniętych drzwi z daleka.
--
-- Opcjonalne atrybuty na każdych drzwiach (ustawiane w oknie Properties):
--   Style            string  "Swing" (domyślnie) albo "Slide"
--   OpenAngle        number  o ile stopni drzwi uchylne obracają się wokół pivota (domyślnie 90, od -179 do 179)
--   SlideDistance    number  o ile studów drzwi przesuwne jadą wzdłuż swojej szerokości (domyślnie: ich szerokość)
--   OpenSeconds      number  ile trwa otwieranie (domyślnie 0.6)
--   AutoCloseSeconds number  zamknąć znowu po tylu sekundach; 0 zostawia otwarte (domyślnie 4)
--   KeyName          string  nazwa Toola, który musi mieć gracz, na przykład "RedKey"

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

local DOOR_TAG = "Door"
local PROMPT_DISTANCE = 8 -- study
local MIN_SECONDS_BETWEEN_USES = 0.3 -- na każde drzwi, przeciw spamowaniu podpowiedzią

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 albo nieskończoność wpisane w oknie 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 -- już działające drzwi albo to nie jest part ani 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)
	-- Kopia działających drzwi przynosi ze sobą starą podpowiedź i wartość: usuwamy je
	for _, leftover in door:GetDescendants() do
		if leftover.Name == "DoorPrompt" or leftover.Name == "DoorProgress" then
			leftover:Destroy()
		end
	end

	-- Pozycję zamkniętą i otwartą liczymy raz, od miejsca, w którym drzwi stoją teraz
	local closedPivot = door:GetPivot()
	local openPivot: CFrame
	if attribute(door, "Style", "Swing") == "Slide" then
		-- Jedziemy wzdłuż dłuższego poziomego boku drzwi, czyli ich szerokości. Model jest mierzony wzdłuż
		-- boków swojego pivota, Part według własnego Size, więc nie obracaj pivota przesuwnego partu
		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 zawsze obraca krótszym łukiem, więc większy kąt otworzyłby drzwi w złą stronę
		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", "")

	-- Tweenujemy liczbę od 0 (zamknięte) do 1 (otwarte) i przesuwamy drzwi za nią.
	-- PivotTo przesuwa jeden part albo cały model wokół jego pivota.
	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) -- to mogą czytać inne skrypty
		prompt.ActionText = if open then "Close" else "Open"
		-- Nowy tween na tej samej wartości anuluje stary, więc drzwi mogą zawrócić w połowie drogi.
		-- Czas skalujemy według tego, ile jeszcze zostało im do przejścia.
		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
		-- W poradniku Roblox o bezpieczeństwie napisano, że podpowiedzi można nadużywać jak remote’ów, więc sprawdzamy tu jeszcze raz
		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 -- za daleko, żeby uczciwie użyć podpowiedzi
		end
		if keyName ~= "" and not isOpen and not hasKey(player, keyName) then
			return -- zamknięte, a ten gracz nie ma klucza
		end
		lastUse = now
		move(not isOpen)
	end)
end

-- Wszystkie drzwi z tagiem teraz i wszystkie, które dostaną tag później (łącznie z drzwiami klonowanymi przez skrypty)
for _, door in CollectionService:GetTagged(DOOR_TAG) do
	setUpDoor(door)
end
CollectionService:GetInstanceAddedSignal(DOOR_TAG):Connect(setUpDoor)

DoorService sam dodaje DoorPrompt i DoorProgress do każdych drzwi przy starcie gry, więc niczego nie trzeba wstawiać ręcznie. Trzymaj jedną kopię skryptu: już obsługuje wszystkie drzwi z tagiem.

Co robi każda część DoorService
Część skryptuCo robiPo co
attribute()Czyta jeden atrybut i zwraca wartość domyślną, jeśli atrybutu nie ma, ma zły typ albo nie jest prawdziwą liczbą (NaN albo nieskończoność).Literówka w oknie Properties daje drzwi z ustawieniami domyślnymi, a nie zepsute drzwi.
doorsSetUp i pętla po leftoverUstawia każde drzwi raz i najpierw usuwa DoorPrompt albo DoorProgress skopiowane z innych drzwi.Inaczej kopia działających drzwi miałaby dwie podpowiedzi, a jedna z nich by nie działała.
closedPivot i openPivotLiczone raz, od miejsca, w którym drzwi stoją w chwili ustawienia. Drzwi uchylne obracają pivot wokół jego własnej pionowej osi; przesuwne przesuwają go wzdłuż dłuższego boku drzwi.Lerp od zamkniętego pivota do otwartego zostawia pivot w miejscu, gdy drzwi się obracają, więc krawędź z zawiasami nie przesuwa się przez cały obrót.
DoorProgress i PivotToTween zmienia liczbę; każda zmiana stawia drzwi w closedPivot:Lerp(openPivot, alpha).TweenService umie tweenować NumberValue, a PivotTo przesuwa part albo model ze wszystkimi jego partami tak, żeby pivot znalazł się w tym CFrame.
PodpowiedźHoldDuration 0.2, MaxActivationDistance 8, RequiresLineOfSight wyłączone. Zamknięte drzwi pokazują "Needs RedKey".Z włączoną bezpośrednią widocznością podpowiedź chowa się, gdy coś zasłania jej part; bez niej rama albo pozostałe części drzwi-modelu nie ukrywają podpowiedzi.
move()Uruchamia tween do 1 albo do 0, a czas skaluje według tego, ile drzwiom jeszcze zostało do przejścia.Nowy tween na tej samej wartości anuluje stary, więc drzwi zawrócone w połowie płynnie idą z powrotem i zajmuje im to połowę czasu.
Automatyczne zamykanieCzeka czas otwarcia plus AutoCloseSeconds, potem zamyka drzwi tylko wtedy, gdy moveCount się nie zmienił.Stary timer nigdy nie zatrzaśnie drzwi, które w tym czasie ktoś zamknął i otworzył ponownie.
Sprawdzenia w TriggeredJedno użycie drzwi co 0.3 sekundy, żywa postać, nie dalej niż 14 studów od partu z podpowiedzią i klucz, ale tylko do otwarcia.Wszystko, co może uruchomić klient, da się nadużyć, więc serwer powtarza sprawdzenia. 14 studów to 8 studów podpowiedzi plus 6 zapasu dla gracza, który przesunął się, przytrzymując E.
Atrybut OpenUstawiany na drzwiach przy każdym ruchu.Atrybuty ustawione na serwerze replikują się do wszystkich graczy, więc inne skrypty, łącznie z LocalScript, mogą go nasłuchiwać przez GetAttributeChangedSignal("Open").

Oznaczanie wszystkich drzwi tagiem i zarządzanie nimi z jednego skryptu to podejście, które zaleca sam Roblox: w dokumentacji CollectionService napisano, że jeśli dodajesz ten sam skrypt do wielu obiektów, skrypt na CollectionService może okazać się lepszy. GetTagged zwraca drzwi, które istnieją przy starcie skryptu, a GetInstanceAddedSignal łapie drzwi oznaczone albo dodane później. Taki sposób organizacji gry omawia poradnik o skryptach klienckich i serwerowych.

Jak zrobić drzwi przesuwne

Zaznacz VaultDoor, dodaj atrybut typu string o nazwie Style i ustaw wartość Slide. Teraz drzwi się nie obracają, tylko jadą w bok: o własną szerokość albo o SlideDistance studów, jeśli go ustawiłeś. Żeby jechały w drugą stronę, ustaw ujemną odległość, na przykład -4 dla drzwi szerokich na 4 study. Każde inne drzwi, łącznie z FrontDoor, staną się przesuwne w ten sam sposób, gdy tylko dostaną ten atrybut.

DoorService mierzy dwa poziome wymiary drzwi, szerokość i grubość, i przesuwa je wzdłuż większego. Model mierzy przez GetExtentsSize, którego pudełko idzie za orientacją pivota modelu, więc drzwi obrócone o 90 stopni po zgrupowaniu i tak jadą wzdłuż szerokości, a nie grubości. Part mierzy według własnego Size partu, więc nie obracaj pivota przesuwnego partu. Przesuwać ten pivot można.

  • Drzwi podwójne: dwie połowy z tagiem obok siebie, obie z Style równym Slide, a jedna z ujemnym SlideDistance, żeby rozjeżdżały się od środka. Dla uchylnych drzwi podwójnych postaw pivot każdej połowy na jej zewnętrznej krawędzi i daj jednej połowie ujemny OpenAngle. Każda połowa ma własną podpowiedź i otwiera się osobno. Jeśli połowy jadą na siebie, przenieś minus na drugą połowę.
  • Brama, która podnosi się do góry: ten skrypt przesuwa drzwi tylko wzdłuż szerokości. Żeby drzwi się podnosiły, ustaw direction w skrypcie na Vector3.yAxis (wtedy wszystkie drzwi przesuwne pojadą w górę) i daj każdym SlideDistance równy ich wysokości.
  • Drzwi na fizyce: tutorial Roblox o ruchomych obiektach przesuwa party wzdłuż jednej osi przez PrismaticConstraint. Tak jak drzwi na zawiasie, to fizyka, bez podpowiedzi i zamka, dopóki sam ich nie napiszesz.

Jak zamknąć drzwi na klucz

Zamknięte drzwi otwierają się tylko graczowi, który ma Tool o właściwej nazwie. Zrób klucz, potem podaj drzwiom jego nazwę:

  1. Najedź kursorem na StarterPack, kliknij + i wstaw Tool o nazwie RedKey. Wstaw do niego jeden Part o nazwie Handle, to part, który postać trzyma w ręce, i upewnij się, że nie jest zakotwiczony: zakotwiczony part w narzędziu przykuwa postać do miejsca. Odznacz w Toolu CanBeDropped, jeśli gracze nie powinni wyrzucać klucza dla kogoś innego: dopóki jest zaznaczone, Backspace wyrzuca założone narzędzie do Workspace.
  2. Zaznacz VaultDoor, dodaj atrybut typu string o nazwie KeyName i ustaw wartość RedKey. Teraz w nazwie obiektu na podpowiedzi jest napis Needs RedKey.

DoorService szuka klucza w dwóch miejscach. Tool leży w Backpack gracza, dopóki go nie założy, a założenie przenosi go do postaci, więc drzwi otwierają się niezależnie od tego, czy klucz jest na hotbarze, czy w ręce. Sprawdzenie odbywa się na serwerze, bo poradnik Roblox o bezpieczeństwie podaje właśnie ten przypadek, czy gracz ma klucz do drzwi, jako uprawnienie, które musi sprawdzać serwer. Klucz jest potrzebny tylko do otwarcia: otwarte drzwi może zamknąć każdy, a same zamykają się po AutoCloseSeconds.

StarterPack daje klucz wszystkim przy każdym spawnie i do testów to właśnie to, czego trzeba. W prawdziwej grze wydawaj go inaczej:

  • Ze sklepu: poradnik o GUI sklepu wydaje Tool z ServerStorage do Backpack i StarterGear kupującego.
  • Od postaci: poradnik o dialogach z NPC wydaje Tool z ServerStorage.DialogueItems, gdy gracz wybiera opcję z akcją GiveItem. Włóż do tego folderu Tool o nazwie RedKey i ustaw opcji w DialogueData action = "GiveItem" i item = "RedKey", a klucz będzie wydawany w rozmowie.
  • Jako przedmiot ekwipunku: z systemem ekwipunku przedmiot-klucz działa, gdy tylko gracz go założy, bo założenie wkłada kopię jego Toola do Backpack i do ręki.

Klucz w Backpack ginie, gdy postać umiera, bo Roblox przy każdym spawnie od nowa wypełnia Backpack ze StarterPack i StarterGear. Żeby go zachować, włóż kopię także do StarterGear gracza, tak jak robi poradnik o sklepie. Żeby klucz się zużywał, znajdź Tool klucza w Backpack albo w postaci gracza i zniszcz go w handlerze Triggered, zaraz po udanym sprawdzeniu klucza.

W czym mylą się stare tutoriale o drzwiach

Jeśli porównujesz ten poradnik z filmem albo postem na forum, oto sposoby, przez które powstaje większość wątków „nie działają mi drzwi”, i to, co ten poradnik robi zamiast nich.

Częste sposoby w tutorialach o drzwiach i co ten poradnik robi zamiast nich
TutorialProblemTen poradnik
Tweenuje CFrame drzwi-ModelW dokumentacji Model nie ma właściwości CFrame ani Position. Jego WorldPivot ustawia tylko miejsce pivota modelu, więc jego tween przesuwa punkt pivota, a party zostają w miejscu.Tweenuje NumberValue i przesuwa cały model przez PivotTo.
Przesuwa model przez SetPrimaryPartCFramePrzestarzałe: Roblox radzi w nowych projektach używać PivotTo.Używa PivotTo, który Roblox nazywa główną funkcją do przesuwania Model ze skryptów.
Przyspawa wszystkie party do jednego partu-zawiasu i tweenuje tylko zawiasDziała, gdy wszystkie Weld są na miejscu, ale każdy nieprzyspawany part zostaje w tyle, gdy zawias się rusza.Trzyma wszystkie party zakotwiczone, bez Weld. PivotTo przesuwa drzwi i wszystko, co w nich jest.
Kopiuje ten sam skrypt do każdych drzwiKażdą poprawkę trzeba powtarzać w każdej kopii. Roblox proponuje oznaczać obiekty tagami i obsługiwać je jednym skryptem przez CollectionService.Jeden DoorService i tag Door.
Otwiera drzwi w LocalScriptDrzwi otwierają się tylko na ekranie tego gracza, a wszyscy inni nadal widzą je zamknięte.Drzwi przesuwa serwer, więc wszyscy gracze widzą te same drzwi.
Otwiera drzwi przez TouchedTouched odpala się kilka razy z rzędu przy jednym dotknięciu (strona Roblox o debounce), a urządzenie gracza może sterować tym, kiedy Touched odpala się dla jego własnej postaci (dokumentacja Roblox o bezpieczeństwie).Podpowiedź, którą sprawdza serwer.
Przesuwa drzwi krokami w pętli z wait()Roblox oznacza wait() jako zastąpione przez task.wait(), a pętla nie może zawrócić w połowie, gdy ktoś naciśnie znowu.Jeden tween na ruch. Nowy tween na tej samej wartości anuluje stary, więc drzwi zawracają z miejsca, w którym są.
Sprawdza klucz w LocalScript albo wcaleOszust kontroluje wszystko na swoim urządzeniu, więc sprawdzenie na kliencie nikogo nie zatrzymuje.Serwer szuka Toola w Backpack i w postaci gracza.
Brak cooldownu na podpowiedziW poradniku Roblox o bezpieczeństwie napisano, że podpowiedzi są podatne na nadużycia tak samo jak remote’y, więc nic nie przeszkadza uruchamiać jej raz za razem.Jedno użycie drzwi co 0.3 sekundy.

Co może, a czego nie może oszust

Zakładaj, że oszust kontroluje wszystko na swoim urządzeniu, łącznie ze swoją postacią. Oto co to znaczy dla tych drzwi.

Czego może spróbować oszust i co z tym robi DoorService
Oszust próbujeWynikDlaczego
Uruchomić podpowiedź z drugiego końca mapyIgnorowane, jeśli jego postać nie jest przy drzwiachDoorService mierzy odległość od głównego partu postaci do partu z podpowiedzią i ignoruje wszystko dalej niż 14 studów. Oszust może najpierw przeteleportować postać do drzwi (zobacz ostatni wiersz), więc sprawdzenie odległości chroni przed użyciem z daleka, a nie przed teleportem.
Uruchamiać ją wiele razy na sekundęNie więcej niż jedno użycie drzwi co 0.3 sekundySerwer przechowuje czas ostatniego użycia każdych drzwi.
Otworzyć drzwi na klucz bez kluczaOdmowaSerwer szuka Toola w jego Backpack i postaci tam, gdzie widzi je sam, a nie na ekranie oszusta.
Użyć drzwi, gdy postać jest martwaIgnorowaneDoorService sprawdza, czy jest Humanoid ze zdrowiem większym niż 0 i główny part.
Mimo wszystko przejść przez zamknięte drzwiMożliweDokumentacja Roblox o bezpieczeństwie wymienia omijanie fizycznych przeszkód i zmianę własnych kolizji wśród tego, co klient może robić ze swoją postacią.
Przeteleportować się za drzwiMożliweTa sama dokumentacja wspomina teleportację swojej postaci w dowolny punkt.

Krok 3: sprawdź

  1. Kliknij Play (F5). Podejdź do FrontDoor: w promieniu 8 studów pojawia się podpowiedź z akcją Open i nazwą obiektu Door. Przytrzymaj E. Po 0.2 sekundy drzwi uchylają się o 90 stopni wokół krawędzi z zawiasami w 0.6 sekundy, a na podpowiedzi jest teraz napis Close.
  2. Przejdź przez drzwi i poczekaj. Cztery sekundy po pełnym otwarciu drzwi zamykają się same. Przytrzymaj E, gdy się zamykają: zawracają i otwierają się z miejsca, w którym były.
  3. Sprawdź zamek. Jeśli RedKey leży w StarterPack, przenieś go na razie do ServerStorage, kliknij Play i przytrzymaj E przy VaultDoor: na podpowiedzi jest napis Needs RedKey i nic się nie rusza. Zatrzymaj grę, przywróć RedKey do StarterPack i uruchom znowu: VaultDoor się otwiera, niezależnie od tego, czy klucz jest na hotbarze, czy w ręce.
  4. Sprawdź drzwi przesuwne. VaultDoor, Model ze Style Slide, przy otwieraniu jedzie w bok o swoją szerokość. Zatrzymaj grę, zaznacz VaultDoor, obróć go o 90 stopni narzędziem Rotate i uruchom znowu: nadal powinien jechać wzdłuż szerokości, a nie grubości. Gdy skończysz, obróć go z powrotem.
  5. Wybierz Server & Clients na liście trybów testu, ustaw 2 klientów i kliknij Play. Otwórz drzwi w oknie jednego klienta: są otwarte też w drugim oknie i zamykają się w obu.
  6. Zatrzymaj grę, zaznacz drzwi i naciśnij Ctrl+D, żeby zrobić duplikat, potem przenieś kopię do innego przejścia. Sprawdź, czy kopia nadal ma w Tags wpisane Door, i kliknij Play: kopia działa bez dodatkowego skryptu.

Trzymaj okno Output otwarte (menu Window, potem Output). Gdy wszystko działa, DoorService nic nie wypisuje. Ostrzeżenie, że drzwi "has no part to put the prompt on", oznacza, że w Model z tagiem nie ma partów. Resztę zobacz w sekcji Częste błędy.

Jak rozbudować

Drzwi automatyczne

Żeby drzwi otwierały się, gdy ktoś podchodzi, wywołuj move(true) wewnątrz setUpDoor, nie czekając na podpowiedź. Na końcu setUpDoor uruchom pętlę przez task.spawn, bo zwykła pętla nigdy by się tam nie skończyła i DoorService nie poszedłby dalej niż pierwsze drzwi. Niech działa tylko, dopóki drzwi są w grze: task.spawn(function() while door.Parent do ... task.wait(0.5) end end). W pętli sprawdzaj przez workspace:GetPartBoundsInBox, czy w pudełku wokół przejścia jest postać, i wywołuj move(true), gdy tam jest, a drzwi są zamknięte. Dalej, tak jak wcześniej, zamknie je automatyczne zamykanie. Ustaw podpowiedzi Enabled na false, jeśli drzwi mają otwierać się tylko same.

Drzwi VIP

Poradnik o game passach już buduje drzwi VIP, przez które właściciele passa przechodzą bezpośrednio, na grupach kolizji. Dla drzwi VIP, które otwierają się na E, dodaj jeszcze jedno sprawdzenie w handlerze Triggered obok sprawdzenia klucza: rób return, jeśli nie jest spełnione player:GetAttribute("OwnsPass_VIP") == true, to atrybut, który ustawia serwerowy skrypt z poradnika o game passach. Czytaj go tylko na serwerze.

Panel z kodem

Dla drzwi, które otwierają się wpisanym kodem, trzymaj kod w serwerowym Script albo w ServerStorage, których gracze nigdy nie dostają, i w żadnym wypadku nie w LocalScript, gdzie oszust może go przeczytać. LocalScript panelu wysyła przez RemoteEvent tylko wpisane cyfry. Na serwerze sprawdź, czy gracz jest przy drzwiach, ogranicz częstotliwość prób, porównaj cyfry i dopiero wtedy wywołaj move(true). Poradnik o RemoteEvent pokazuje, jak sprawdzać to, co dostaje remote.

Dźwięki

Włóż Sound do partu drzwi, żeby brzmiał z pozycji tego partu, i wywołuj jego metodę Play na początku move. Albo odtwarzaj go z LocalScript, który nasłuchuje atrybutu Open drzwi przez GetAttributeChangedSignal("Open"), bo serwer ustawia ten atrybut przy każdym ruchu.

Drzwi dodane w trakcie gry

Klonuj nowe drzwi z zamkniętego szablonu w ServerStorage. DoorService odczytuje pozycję zamkniętą drzwi w chwili ich pojawienia się, więc kopia drzwi, które w tej chwili były otwarte, uznałaby swoją pozycję otwartą za zamkniętą. Postaw kopię w przejściu przez PivotTo, zanim ustawisz jej Parent na Workspace, żeby DoorService zapamiętał to miejsce jako zamknięte. Stare podpowiedzi i wartości, które przyszły z kopią, są usuwane automatycznie. O drzwiach, które przenoszą graczy do innej strefy albo innego place, przeczytaj w poradniku o teleportach.

Częste błędy i rozwiązania

Otwórz okno Output (menu Window, potem Output) przed kliknięciem Play. Większość problemów z drzwiami bierze się z tagu, pivota albo atrybutu, które są odrobinę inne, niż oczekuje skrypt.

Przy drzwiach nie pojawia się podpowiedź

Sprawdź po kolei: DoorService to Script, a nie LocalScript, i leży bezpośrednio w ServerScriptService; drzwi mają tag Door z wielkim D, dla drzwi-modelu na samym Model; drzwi to part (Part, MeshPart albo inny BasePart) albo Model; i stoisz nie dalej niż 8 studów od partu, na którym wisi podpowiedź. Ostrzeżenie w Output, że drzwi "has no part to put the prompt on", oznacza, że w Model z tagiem nie ma partów.

Drzwi spadają, odpływają albo są popychane, gdy gra startuje

Któryś ich part nie jest zakotwiczony. Zaznacz wszystkie party drzwi i zaznacz Anchored. Zakotwiczone party nigdy nie ruszają się od fizyki, ale DoorService i tak może je przesuwać.

Zmieniłem atrybut, ale drzwi go ignorują

Sprawdź trzy rzeczy. Typ: OpenAngle, SlideDistance, OpenSeconds i AutoCloseSeconds muszą być atrybutami typu number, a Style i KeyName typu string; przy złym typie DoorService bierze wartość domyślną. Pisownia: nazwy są porównywane dokładnie, więc openAngle to inny atrybut. Wartości też są porównywane dokładnie: Style musi być Slide z wielkim S i bez spacji. Moment: DoorService czyta atrybuty raz, gdy ustawia drzwi, więc zmiana w trakcie playtestu nic nie da, dopóki nie uruchomisz gry od nowa.

Drzwi otwierają się w złą stronę albo przewracają się na bok

Żeby otwierały się w drugą stronę, ustaw OpenAngle na ujemny, na przykład -90. Jeśli obracają się wokół poziomej osi, a nie wokół pionowego zawiasu, to obrócony jest sam pivot: włącz Pivot na karcie Model i obróć pivot z powrotem, żeby stał pionowo.

Drzwi przesuwne wjeżdżają w ścianę albo przesuwają się tylko trochę

Daj im ujemny SlideDistance, żeby jechały w drugą stronę. Jeśli przesuwają się za mało albo za daleko, ustaw w SlideDistance potrzebną liczbę studów i nie polegaj na zmierzonej szerokości.

Mam klucz, ale drzwi się nie otwierają

Klucz musi być Tool, a nie Part ani Model, a jego nazwa musi dokładnie zgadzać się z KeyName, łącznie z wielkimi literami. Musi leżeć w twoim Backpack albo być w ręce. Sprawdź też, czy KeyName na drzwiach to atrybut typu string.

Zrób to z RoCode

Jeśli nie chce ci się ustawiać tego wszystkiego ręcznie, RoCode może to zbudować w grze, którą masz otwartą. RoCode to niezależny agent AI do Roblox Studio, nie robi go Roblox: opisujesz zmianę na czacie w przeglądarce, a jego plugin do Studio tworzy skrypty i obiekty w twoim Explorerze, więc nie musisz wklejać kodu.

Ty piszesz

Spraw, żeby drzwi z tagiem Door otwierały się podpowiedzią z przytrzymaniem E: obrót o 90 stopni wokół pivota w 0.6 sekundy, zamknięcie po 4 sekundach, przesunięcie zamiast obrotu, gdy atrybut Style to Slide, a drzwi zostają zamknięte, jeśli gracz nie ma Toola o nazwie z KeyName. Wszystko na serwerze, ze sprawdzeniem odległości.

RoCode robi
  • Może przejrzeć twoją grę, gdy krok tego wymaga, przez Search Game i Search Scripts, żeby oprzeć się na istniejących przedmiotach, remote’ach albo kodzie zapisu, zamiast dodawać drugi system
  • Pisze Script w ServerScriptService przez Create Script, może utworzyć part drzwi przez Create Instance i ustawić na nim atrybuty, takie jak Style i KeyName
  • Ma polecone sprawdzać kompilację każdego napisanego skryptu przez Check Script, który kompiluje go w Studio bez uruchamiania
  • Stawia punkt cofania przed i po każdej paczce zmian, więc Ctrl+Z cofa po jednej paczce

Przed testem sprawdź pivot każdych drzwi narzędziem Pivot w Studio: drzwi obracają się wokół niego. Z pluginem 3.9 lub nowszym RoCode może uruchomić krótki playtest i przeczytać błędy, a z pluginem 3.9.15 lub nowszym może sterować testową postacią, która chodzi i naciska klawisze, ale sprawdza tylko to, co sam postanowił przetestować, więc podejdź do każdych drzwi i przytrzymaj E sam. Jak RoCode łączy się ze Studio.

Najczęstsze pytania

Jak sprawić, żeby drzwi otwierały się na E w Roblox Studio?

Włóż ProximityPrompt do drzwi i podłącz jego event Triggered w serwerowym Script, który przesuwa drzwi. DoorService robi jedno i drugie dla każdych drzwi z tagiem Door. E to domyślny klawisz podpowiedzi, a Roblox pokazuje właściwe wejście dla klawiatur, padów i ekranów dotykowych.

Dlaczego moje drzwi kręcą się wokół swojego środka?

Ich pivot jest wciąż na środku. Włącz Pivot na karcie Model i przeciągnij pivot na krawędź z zawiasami; skrypt obraca drzwi wokół pivota.

Jak zrobić drzwi przesuwne?

Ustaw atrybut Style drzwi na Slide. Jadą w bok o swoją szerokość albo o SlideDistance studów; ujemna odległość przesuwa je w drugą stronę.

Czy można zrobić drzwi bez skryptów?

Tak. Tutorial Roblox o drzwiach na zawiasie mocuje niezakotwiczone drzwi do ramy przez HingeConstraint z ograniczeniami, a gracze otwierają je, pchając ciałem. Takie drzwi nie mają podpowiedzi, zamka ani automatycznego zamykania.

Jak zrobić drzwi, które mogą otworzyć tylko VIP?

Weź drzwi VIP z poradnika o game passach, przez które przechodzą właściciele passa, albo dodaj w handlerze Triggered w DoorService sprawdzenie, które przed otwarciem czyta na serwerze, czy gracz ma passa, na przykład atrybut OwnsPass_VIP, który ustawia tamten poradnik.

Dlaczego drzwi otwierają się u mnie, ale nie u innych graczy?

Otwiera je LocalScript, a zmiana zrobiona przez LocalScript zostaje na urządzeniu tego gracza. Przenieś kod otwierania do serwerowego Script, jak w DoorService, żeby zmiana dotarła do wszystkich.

Źródła i dalsza lektura

Jak sprawdziliśmy kod: każdy skrypt na tej stronie przechodzi ścisłe sprawdzanie typów Luau z definicjami API Robloxa (luau-lsp, 20 listopada 2026). Sprawdzanie typów wyłapuje źle wpisane API i błędne typy, ale nie logikę gry, więc przetestuj go w Studio przed publikacją.

Wypróbuj RoCode we własnej grze.

Darmowe kredyty codziennie, bez karty. Zainstaluj plugin, opisz funkcję i sprawdź, co pojawi się w Studio.