מדריך · מערכות משחק

איך ליצור דלת ב-Roblox Studio

דלת שעובדת ב-Roblox צריכה שלושה דברים: משהו שהשחקן לוחץ עליו (ProximityPrompt עם הכיתוב "Open"), תנועה חלקה (TweenService) ושרת שמבצע את השינוי, כדי שכל השחקנים יראו את אותה דלת. במדריך הזה נבנה סקריפט אחד שעושה את זה לכל דלת עם תג, על צירים או הזזה, עם מנעול מפתח לא חובה: השרת בודק את המפתח לפני שהוא פותח משהו.

עודכן 20 בנובמבר 202617 דק׳ קריאהמאת:

בקצרה

בנו את הדלת כ-Part או כ-Model, סמנו Anchored, העבירו את ה-pivot שלה לקצה עם הצירים (לשונית Model, Pivot) והוסיפו את התג Door בחלון Properties. Script ב-ServerScriptService אחד מוצא את כל הדלתות עם התג דרך CollectionService, מוסיף ProximityPrompt ("Open", החזקת E) ובאירוע Triggered עושה טווין ל-NumberValue מ-0 ל-1, ומזיז את הדלת דרך door:PivotTo(closedPivot:Lerp(openPivot, alpha)). Attributes על כל דלת קובעים אם היא על צירים או הזזה, את הזווית, הזמן, הסגירה האוטומטית והמפתח.

  • את המיקום של Model אי אפשר לעשות לו טווין ישירות: ל-Model אין מאפיין CFrame או Position, וה-WorldPivot שלה קובע רק את מקום ה-pivot. עשו טווין ל-NumberValue והזיזו את הדלת דרך PivotTo: Roblox קוראת לו הדרך העיקרית להזיז מודלים מסקריפט.
  • פתחו דלתות בשרת. דלת שנפתחת מ-LocalScript זזה רק במסך של אותו שחקן.
  • בדקו את המפתח והמרחק בשרת. במדריך האבטחה של Roblox כתוב שאפשר לנצל ProximityPrompt לרעה בדיוק כמו RemoteEvent, ושם מובאת גם דוגמה לבדיקה שהשרת חייב לעשות: האם יש לשחקן את המפתח שנדרש כדי לפתוח את הדלת.
בעמוד הזה
  1. איך זה עובד
  2. 1. בונים את הדלת
  3. 2. סקריפט הדלת
  4. דלתות הזזה
  5. דלתות עם מפתח
  6. מדריכים ישנים
  7. גבולות ההגנה
  8. 3. בדיקה
  9. הרחבות
  10. Common errors
  11. עם RoCode
  12. שאלות נפוצות
  13. מקורות וקריאה נוספת

איך דלת עם סקריפט עובדת

איורהחזקת E במשך 0.2 שנייה פותחת את הדלת תוך 0.6 שנייה, ו-4 שניות אחרי הפתיחה המלאה היא נסגרת לבד (כאן מואץ). VaultDoor נשארת סגורה לשחקן בלי RedKey.

דלת שעובדת במשחק אמיתי חייבת לזוז על ידי השרת. אם LocalScript מזיז אותה, הדלת נפתחת במסך של שחקן אחד ונשארת סגורה לכל האחרים, כי שינוי שהלקוח עשה נשאר במכשיר הזה (ראו מה משוכפל ומה לא). לכן במדריך הזה המכשיר של השחקן רק מציג את ההנחיה ומדווח על לחיצת המקש, וכל השאר עושה Script שרת אחד. שימוש אחד בדלת נראה כך:

  1. השחקן מתקרב לדלת למרחק של פחות מ-8 studs, ומופיעה הנחיה עם הפעולה Open, שם האובייקט Door והמקש E במקלדת. בג׳ויפד או במסך מגע Roblox מציגה את הכפתור המתאים.
  2. השחקן מחזיק E במשך 0.2 שנייה. האירוע Triggered של ההנחיה נורה בשרת עם השחקן הזה.
  3. DoorService בודק את השחקן: חי, קרוב מספיק, לא מציף את ההנחיה, ונושא מפתח אם הדלת דורשת.
  4. הסקריפט עושה טווין למספר מ-0 (סגור) ל-1 (פתוח). בכל שינוי של המספר הוא מזיז דרך PivotTo את הדלת לחלק הזה של הדרך מהמצב הסגור לפתוח.
  5. ארבע שניות אחרי הפתיחה המלאה הדלת נסגרת באותה דרך. לחיצה בזמן תנועה מחזירה את הדלת אחורה מהמקום שבו היא נמצאת.
ממה מורכבת מערכת הדלתות
רכיבאיפה הוא נמצאמה הוא עושה
Script DoorServiceServerScriptServiceמוצא את כל הדלתות, מוסיף לכל אחת הנחיה, בודק כל שימוש ומזיז את הדלת. הסקריפט היחיד במדריך הזה.
התג Doorעל כל Part או Model של דלתמסמן מה הוא דלת. תגים מוסיפים בחלון Properties, והם נשמרים יחד עם הפלייס.
Attributes, למשל Style ו-KeyNameעל כל דלת (לא חובה)ההגדרות של דלת אחת: על צירים או הזזה, זווית, מהירות, סגירה אוטומטית ומפתח.
ProximityPrompt DoorPromptבתוך הדלת (DoorService מוסיף אותו)מציג "Open" או "Close" ומפעיל את Triggered כשהשחקן מחזיק E.
NumberValue DoorProgressבתוך הדלת (DoorService מוסיף אותו)מספר שהטווין מזיז בין 0 ל-1. כל שינוי מזיז את הדלת.
Tool בשם RedKey (לא חובה)StarterPack, לבדיקותמפתח לדלת נעולה. כל Tool מתאים, אם השם שלו תואם את ה-KeyName של הדלת.
ה-Explorer אחרי שסיימתם את המדריך. לשתי הדלתות יש את התג Door, ול-VaultDoor גם את ה-Attributes Style = Slide ו-KeyName = RedKey. כשהמשחק רץ, DoorService מוסיף DoorProgress לכל דלת ו-DoorPrompt ל-Part שעליו תלויה ההנחיה.
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: בנו את הדלת וקבעו את הציר

  1. ב-Explorer רחפו מעל Workspace, לחצו על כפתור ה-+ והכניסו Part. קראו לו FrontDoor, קבעו Size של בערך 4, 7, 0.5 (4 studs רוחב, 7 גובה, חצי stud עובי) והציבו אותו בפתח הדלת. גם דלת מכמה Parts תתאים: סמנו אותם ולחצו על Ctrl+G כדי לקבץ אותם ל-Model.
  2. סמנו Anchored לכל Part של הדלת, והשאירו את CanCollide מופעל. Parts מעוגנים אף פעם לא זזים מכבידה או מהתנגשויות, אבל סקריפט עדיין יכול להזיז אותם, ובדיוק את זה DoorService עושה.
  3. קבעו את הציר. סמנו את הדלת, פתחו את הלשונית Model והפעילו את Pivot. לחצו והחזיקו את החץ הקטן בפינת כפתור ה-Pivot וסמנו Snap, כדי שה-pivot יידבק לנקודות עיגון בפינות, בקצוות ובמרכזים. גררו את ה-pivot לקצה הדלת שבו היו הצירים. בדלת הזזה ה-pivot יכול להישאר במרכז.
  4. הוסיפו את התג. בלי לבטל את סימון הדלת, גללו את חלון Properties עד Tags, לחצו על + והקלידו Door עם D גדולה. אם הדלת היא Model, שימו את התג על ה-Model עצמה, לא על ה-Parts שבתוכה.
  5. בנו דלת שנייה, היא תידרש בפרקים על דלתות הזזה ועל מפתח. הכניסו ל-Workspace עוד שני Parts: Panel בגודל של בערך 4, 7, 0.5 ו-Knob של בערך 0.5, 0.5, 0.5, צמוד לאחת הפאות של Panel. סמנו את שניהם, לחצו על Ctrl+G ושנו את השם של ה-Model החדשה ל-VaultDoor. עגנו את שני ה-Parts, הציבו את המודל בפתח השני והוסיפו את התג Door על ה-Model. ה-pivot שלה יכול להישאר במרכז, כי הדלת הזו תהיה דלת הזזה.

ה-pivot חשוב, כי דלת על צירים מסתובבת סביבו. אם משאירים אותו במרכז, הדלת תסתובב במקום, כמו דלת מסתובבת בחנות. ב-Part, ה-pivot שקבעתם נשמר כ-PivotOffset, ו-GetPivot מתחשב בו, ולכן הסקריפט מסובב את הדלת בדיוק סביב הנקודה שבחרתם. אם ל-Model יש PrimaryPart, ה-pivot של המודל הוא ה-pivot של ה-Part הזה, ו-DoorService תולה עליו גם את ההנחיה. בלי PrimaryPart ההנחיה נכנסת ל-Part הראשון שנמצא בתוך המודל. אם אתם קובעים PrimaryPart, עשו את זה לפני שאתם מזיזים את ה-pivot: קביעת PrimaryPart מעבירה את ה-pivot של המודל ל-pivot של ה-Part הזה, כמו שמצוין בעמוד של Roblox על Pivot tools.

הגדרות הדלת (Attributes)

כל דלת עובדת עם ערכי ברירת המחדל מהטבלה שלמטה. כדי לשנות דלת אחת, סמנו אותה, גללו את חלון Properties עד Attributes, לחצו על +, הקלידו שם, בחרו סוג ולחצו על Save, ואז קבעו ערך. DoorService קורא את ה-Attributes פעם אחת, כשהוא מגדיר את הדלת, ולכן שנו אותם כשהמשחק עצור.

Attributes לא חובה על כל דלת
Attributeסוגברירת מחדלמה הוא עושה
StylestringSwingSwing מסובב את הדלת סביב ה-pivot שלה. Slide מזיז אותה הצידה לאורך הרוחב.
OpenAnglenumber90בכמה מעלות דלת על צירים מסתובבת. מספר שלילי פותח אותה לצד השני. השאירו את הערך בין 179- ל-179: הדלת תמיד הולכת בקשת הקצרה, ולכן DoorService מגביל את הזווית לגבולות האלה.
SlideDistancenumberהרוחב שלהכמה studs דלת הזזה נוסעת לאורך הרוחב שלה. מספר שלילי מזיז אותה לצד השני.
OpenSecondsnumber0.6כמה זמן נמשכת פתיחה או סגירה מלאה, בטווח מ-0.05 עד 10.
AutoCloseSecondsnumber4כמה זמן הדלת עומדת פתוחה לגמרי לפני שהיא נסגרת לבד. 0 משאיר אותה פתוחה עד שמישהו יסגור.
KeyNamestringאיןשם ה-Tool שצריך להיות לשחקן כדי לפתוח את הדלת, למשל RedKey. אל תקבעו אותו לדלת שכל אחד יכול לפתוח.

שלב 2: הוסיפו את סקריפט הדלת

רחפו מעל ServerScriptService, הכניסו Script בשם DoorService והדביקו בו את הקוד שלמטה. הוא מנהל את כל הדלתות בפלייס, לא משנה כמה מהן סימנתם בתג. שלוש ההגדרות בהתחלה חלות על כל הדלתות; ה-Attributes משלב 1 משנים דלת אחת.

Script בתוך ServerScriptService בשם DoorService
-- Script ב-ServerScriptService בשם DoorService.
-- פותח וסוגר כל Part או Model עם התג "Door" בהנחיה עם החזקת E.
-- השרת מזיז את הדלת, ולכן כל השחקנים רואים את אותה דלת, והשרת גם
-- בודק מרחק ומפתח, ולכן אף אחד לא יפתח דלת נעולה מרחוק.
--
-- Attributes לא חובה על כל דלת (נקבעים בחלון Properties):
--   Style            string  "Swing" (ברירת מחדל) או "Slide"
--   OpenAngle        number  בכמה מעלות דלת על צירים מסתובבת סביב ה-pivot (ברירת מחדל 90, מ-179- עד 179)
--   SlideDistance    number  כמה studs דלת הזזה נוסעת לאורך הרוחב שלה (ברירת מחדל: הרוחב שלה)
--   OpenSeconds      number  כמה זמן נמשכת הפתיחה (ברירת מחדל 0.6)
--   AutoCloseSeconds number  לסגור שוב אחרי כך וכך שניות; 0 משאיר פתוחה (ברירת מחדל 4)
--   KeyName          string  שם ה-Tool שצריך להיות לשחקן, למשל "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 -- לכל דלת, נגד הצפה של ההנחיה

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 או אינסוף שהוזנו בחלון 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 -- כבר דלת שעובדת, או שזה לא Part ולא מודל
	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)
	-- עותק של דלת שעובדת מביא איתו הנחיה וערך ישנים: מוחקים אותם
	for _, leftover in door:GetDescendants() do
		if leftover.Name == "DoorPrompt" or leftover.Name == "DoorProgress" then
			leftover:Destroy()
		end
	end

	-- את המצב הסגור והפתוח מחשבים פעם אחת, מהמקום שבו הדלת עומדת עכשיו
	local closedPivot = door:GetPivot()
	local openPivot: CFrame
	if attribute(door, "Style", "Swing") == "Slide" then
		-- נוסעים לאורך הצלע האופקית הארוכה יותר של הדלת, הרוחב שלה. Model נמדדת לאורך
		-- הצלעות של ה-pivot שלה, Part לפי ה-Size שלו, ולכן אל תסובבו את ה-pivot של Part הזזה
		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 תמיד מסובב בקשת הקצרה, ולכן זווית גדולה יותר הייתה פותחת את הדלת לצד הלא נכון
		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", "")

	-- עושים טווין למספר מ-0 (סגור) ל-1 (פתוח) ומזיזים את הדלת בעקבותיו.
	-- PivotTo מזיז Part אחד או מודל שלם סביב ה-pivot שלו.
	local progress = Instance.new("NumberValue")
	progress.Name = "DoorProgress"
	progress.Parent = door
	progress.Changed:Connect(function(alpha: number)
		door:PivotTo(closedPivot:Lerp(openPivot, alpha))
	end)

	local prompt = Instance.new("ProximityPrompt")
	prompt.Name = "DoorPrompt"
	prompt.ActionText = "Open"
	prompt.ObjectText = if keyName ~= "" then `Needs {keyName}` else "Door"
	prompt.HoldDuration = 0.2
	prompt.MaxActivationDistance = PROMPT_DISTANCE
	prompt.RequiresLineOfSight = false
	prompt.Parent = promptPart

	local isOpen = false
	local lastUse = 0
	local moveCount = 0

	local function move(open: boolean)
		isOpen = open
		moveCount += 1
		door:SetAttribute("Open", open) -- סקריפטים אחרים יכולים לקרוא את זה
		prompt.ActionText = if open then "Close" else "Open"
		-- טווין חדש על אותו ערך מבטל את הישן, ולכן הדלת יכולה להסתובב חזרה באמצע הדרך.
		-- את הזמן מתאימים לפי כמה דרך עוד נשארה לה.
		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
		-- במדריך האבטחה של Roblox כתוב שאפשר לנצל הנחיות כמו remotes, ולכן בודקים כאן שוב
		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 -- רחוק מדי כדי להשתמש בהנחיה בכנות
		end
		if keyName ~= "" and not isOpen and not hasKey(player, keyName) then
			return -- נעול, ולשחקן הזה אין מפתח
		end
		lastUse = now
		move(not isOpen)
	end)
end

-- כל הדלתות עם התג עכשיו וכל אלה שיקבלו תג אחר כך (כולל דלתות שסקריפטים משכפלים)
for _, door in CollectionService:GetTagged(DOOR_TAG) do
	setUpDoor(door)
end
CollectionService:GetInstanceAddedSignal(DOOR_TAG):Connect(setUpDoor)

DoorService מוסיף בעצמו DoorPrompt ו-DoorProgress לכל דלת כשהמשחק עולה, ולכן לא צריך להכניס כלום ביד. החזיקו עותק אחד של הסקריפט: הוא כבר משרת את כל הדלתות עם התג.

מה עושה כל חלק ב-DoorService
חלק בסקריפטמה הוא עושהלמה
attribute()קורא Attribute אחד ומחזיר ערך ברירת מחדל אם אין Attribute, אם הסוג שלו שגוי או אם זה לא מספר אמיתי (NaN או אינסוף).שגיאת הקלדה בחלון Properties נותנת דלת עם הגדרות ברירת מחדל, לא דלת שבורה.
doorsSetUp והלולאה על leftoverמגדיר כל דלת פעם אחת, וקודם מוחק DoorPrompt או DoorProgress שהועתקו מדלת אחרת.אחרת לעותק של דלת שעובדת היו שתי הנחיות, ואחת מהן לא עובדת.
closedPivot ו-openPivotמחושבים פעם אחת, מהמקום שבו הדלת עומדת ברגע ההגדרה. דלת על צירים מסובבת את ה-pivot סביב הציר האנכי שלו עצמו; דלת הזזה מזיזה אותו לאורך הצלע הארוכה יותר של הדלת.Lerp מה-pivot הסגור לפתוח משאיר את ה-pivot במקום בזמן שהדלת מסתובבת, ולכן הקצה עם הצירים לא זז לאורך כל הסיבוב.
DoorProgress ו-PivotToהטווין משנה מספר; כל שינוי מציב את הדלת ב-closedPivot:Lerp(openPivot, alpha).TweenService יודע לעשות טווין ל-NumberValue, ו-PivotTo מזיז Part או מודל עם כל ה-Parts שלו כך שה-pivot יגיע ל-CFrame הזה.
ההנחיהHoldDuration 0.2, MaxActivationDistance 8, RequiresLineOfSight כבוי. דלת נעולה מציגה "Needs RedKey".כשקו הראייה מופעל, ההנחיה מוסתרת כשמשהו מסתיר את ה-Part שלה; בלעדיו, המסגרת או שאר החלקים של דלת-מודל לא מסתירים את ההנחיה.
move()מפעיל טווין ל-1 או ל-0, ומתאים את הזמן לפי כמה דרך עוד נשארה לדלת.טווין חדש על אותו ערך מבטל את הישן, ולכן דלת שהסתובבה חזרה באמצע הדרך הולכת אחורה בצורה חלקה ומשקיעה בזה חצי מהזמן.
סגירה אוטומטיתמחכה לזמן הפתיחה ועוד AutoCloseSeconds, ואז סוגר את הדלת, רק אם moveCount לא השתנה.טיימר ישן אף פעם לא יטרוק דלת שמישהו סגר ופתח שוב בינתיים.
הבדיקות ב-Triggeredשימוש אחד בדלת כל 0.3 שנייה, דמות חיה, לא יותר מ-14 studs מה-Part עם ההנחיה, ומפתח, אבל רק לפתיחה.כל מה שלקוח יכול להפעיל אפשר לנצל לרעה, ולכן השרת חוזר על הבדיקות. 14 studs הם 8 ה-studs של ההנחיה ועוד 6 מרווח לשחקן שזז בזמן שהחזיק E.
ה-Attribute בשם Openנקבע על הדלת בכל תנועה.Attributes שנקבעו בשרת משוכפלים לכל השחקנים, ולכן סקריפטים אחרים, כולל LocalScript, יכולים להאזין לו דרך GetAttributeChangedSignal("Open").

לסמן את כל הדלתות בתג ולנהל אותן מסקריפט אחד זו הגישה ש-Roblox עצמה ממליצה עליה: בתיעוד של CollectionService כתוב שאם אתם מוסיפים את אותו סקריפט להרבה אובייקטים, סקריפט על CollectionService עשוי להיות עדיף. GetTagged מחזיר את הדלתות שקיימות כשהסקריפט עולה, ו-GetInstanceAddedSignal תופס דלתות שסומנו או נוספו מאוחר יותר. הדרך הזו לארגן פלייס מפורטת במדריך לסקריפטים של לקוח ושרת.

איך ליצור דלת הזזה

סמנו את VaultDoor, הוסיפו Attribute מסוג string בשם Style וקבעו את הערך Slide. עכשיו הדלת לא מסתובבת אלא נוסעת הצידה: ברוחב שלה, או SlideDistance studs אם קבעתם. כדי שתיסע לצד השני, קבעו מרחק שלילי, למשל -4 לדלת ברוחב 4 studs. כל דלת אחרת, כולל FrontDoor, תהפוך לדלת הזזה באותה דרך ברגע שתקבל את ה-Attribute הזה.

DoorService מודד את שני הממדים האופקיים של הדלת, רוחב ועובי, ומזיז אותה לאורך הגדול מביניהם. Model הוא מודד דרך GetExtentsSize, שהקופסה שלו עוקבת אחרי הכיוון של ה-pivot של המודל, ולכן דלת שסובבה ב-90 מעלות אחרי הקיבוץ עדיין נוסעת לאורך הרוחב ולא העובי. Part הוא מודד לפי ה-Size של ה-Part עצמו, ולכן אל תסובבו את ה-pivot של Part הזזה. להזיז את ה-pivot הזה מותר.

  • דלתות כפולות: שני חצאים עם תג זה ליד זה, לשניהם Style שווה Slide, ולאחד מהם SlideDistance שלילי, כדי שייפרדו מהאמצע. לדלתות כפולות על צירים, שימו את ה-pivot של כל חצי בקצה החיצוני שלו ותנו לחצי אחד OpenAngle שלילי. לכל חצי הנחיה משלו, והוא נפתח בנפרד. אם החצאים נוסעים זה לתוך זה, העבירו את המינוס לחצי השני.
  • שערים שעולים למעלה: הסקריפט הזה מזיז את הדלת רק לאורך הרוחב. כדי שדלתות יעלו, קבעו את direction בסקריפט ל-Vector3.yAxis (אז כל דלתות ההזזה ייסעו למעלה), ותנו לכל אחת SlideDistance ששווה לגובה שלה.
  • דלת על פיזיקה: המדריך של Roblox על אובייקטים זזים מזיז Parts לאורך ציר אחד דרך PrismaticConstraint. כמו הדלת על ציר, זו פיזיקה, בלי הנחיה ומנעול עד שתכתבו אותם בעצמכם.

איך נועלים דלת עם מפתח

דלת נעולה נפתחת רק לשחקן שיש לו Tool עם השם הנכון. צרו מפתח, ואז אמרו לדלת את השם שלו:

  1. רחפו מעל StarterPack, לחצו על + והכניסו Tool בשם RedKey. הכניסו לתוכו Part אחד בשם Handle, זה ה-Part שהדמות מחזיקה ביד, וודאו שהוא לא מעוגן: Part מעוגן בכלי מקבע את הדמות למקום. הסירו את הסימון מ-CanBeDropped של ה-Tool אם שחקנים לא אמורים לזרוק את המפתח בשביל מישהו אחר: כל עוד הוא מסומן, Backspace זורק את הכלי המצויד ל-Workspace.
  2. סמנו את VaultDoor, הוסיפו Attribute מסוג string בשם KeyName וקבעו את הערך RedKey. עכשיו בשם האובייקט על ההנחיה כתוב Needs RedKey.

DoorService מחפש את המפתח בשני מקומות. Tool נמצא ב-Backpack של השחקן עד שמצטיידים בו, וההצטיידות מעבירה אותו לדמות, ולכן הדלת נפתחת בין אם המפתח בסרגל הכלים ובין אם ביד. הבדיקה נעשית בשרת, כי מדריך האבטחה של Roblox מציין בדיוק את המקרה הזה, האם יש לשחקן מפתח לדלת, כהרשאה שהשרת חייב לבדוק. המפתח נדרש רק לפתיחה: דלת פתוחה כל אחד יכול לסגור, והיא נסגרת לבד אחרי AutoCloseSeconds.

StarterPack נותן את המפתח לכולם בכל לידה, ולבדיקות זה בדיוק מה שצריך. במשחק אמיתי תנו אותו בדרך אחרת:

  • מחנות: המדריך ל-GUI של חנות נותן Tool מ-ServerStorage ל-Backpack ול-StarterGear של הקונה.
  • מדמות: המדריך לדיאלוג עם NPC נותן Tool מ-ServerStorage.DialogueItems כשהשחקן בוחר אפשרות עם הפעולה GiveItem. שימו בתיקייה הזו Tool בשם RedKey, וקבעו לאפשרות ב-DialogueData את action = "GiveItem" ו-item = "RedKey", והמפתח יינתן בשיחה.
  • כפריט מלאי: עם מערכת מלאי פריט-מפתח עובד ברגע שהשחקן מצטייד בו, כי ההצטיידות שמה עותק של ה-Tool שלו ב-Backpack וביד.

מפתח ב-Backpack הולך לאיבוד כשהדמות מתה, כי Roblox ממלאת מחדש את ה-Backpack מ-StarterPack ומ-StarterGear בכל לידה. כדי לשמור אותו, שימו עותק גם ב-StarterGear של השחקן, כמו שהמדריך לחנות עושה. כדי שהמפתח דווקא ייגמר, מצאו את ה-Tool של המפתח ב-Backpack או בדמות של השחקן והשמידו אותו ב-handler של Triggered, מיד אחרי שבדיקת המפתח הצליחה.

במה מדריכים ישנים לדלתות טועים

אם אתם משווים את המדריך הזה לסרטון או לפוסט בפורום, אלה הטריקים שבגללם מופיעים רוב השרשורים "הדלת שלי לא עובדת", ומה המדריך הזה עושה במקומם.

טריקים נפוצים במדריכים לדלתות ומה המדריך הזה עושה במקומם
מדריךבעיההמדריך הזה
עושה טווין ל-CFrame של דלת-Modelבתיעוד של Model אין מאפיין CFrame או Position. ה-WorldPivot שלה קובע רק את מקום ה-pivot של המודל, ולכן טווין שלו מזיז את נקודת ה-pivot, וה-Parts נשארים במקום.עושה טווין ל-NumberValue ומזיז את כל המודל דרך PivotTo.
מזיז את המודל דרך SetPrimaryPartCFrameמיושן: Roblox ממליצה להשתמש בפרויקטים חדשים ב-PivotTo.משתמש ב-PivotTo, ש-Roblox קוראת לו הפונקציה העיקרית להזזת Model מסקריפטים.
מרתך את כל ה-Parts ל-Part ציר אחד ועושה טווין רק לצירעובד כשכל ה-Welds במקום, אבל כל Part שלא מרותך נשאר מאחור כשהציר זז.מחזיק את כל ה-Parts מעוגנים, בלי Weld. PivotTo מזיז את הדלת ואת כל מה שבתוכה.
מעתיק את אותו סקריפט לכל דלתכל תיקון צריך לחזור עליו בכל עותק. Roblox מציעה לסמן אובייקטים בתגים ולטפל בהם בסקריפט אחד דרך CollectionService.DoorService אחד והתג Door.
פותח את הדלת ב-LocalScriptהדלת נפתחת רק במסך של אותו שחקן, וכל האחרים עדיין רואים אותה סגורה.השרת מזיז את הדלת, ולכן כל השחקנים רואים את אותה דלת.
פותח את הדלת ב-TouchedTouched נורה כמה פעמים ברצף בנגיעה אחת (העמוד של Roblox על debounce), והמכשיר של השחקן יכול לשלוט מתי Touched נורה לדמות שלו עצמו (תיעוד האבטחה של Roblox).הנחיה שהשרת בודק.
מזיז את הדלת בצעדים בלולאה עם wait()Roblox מסמנת את wait() כמוחלף ב-task.wait(), ולולאה לא יכולה להסתובב חזרה באמצע הדרך כשמישהו לוחץ שוב.טווין אחד לכל תנועה. טווין חדש על אותו ערך מבטל את הישן, ולכן הדלת מסתובבת חזרה מהמקום שבו היא נמצאת.
בודק את המפתח ב-LocalScript או לא בודק בכללרמאי שולט בכל דבר במכשיר שלו, ולכן בדיקה בלקוח לא עוצרת אף אחד.השרת מחפש את ה-Tool ב-Backpack ובדמות של השחקן.
אין זמן המתנה על ההנחיהבמדריך האבטחה של Roblox כתוב שהנחיות פגיעות לניצול לרעה בדיוק כמו remotes, ולכן שום דבר לא מונע להפעיל אותה שוב ושוב.שימוש אחד בדלת כל 0.3 שנייה.

מה רמאי יכול ומה לא

הניחו שרמאי שולט בכל דבר במכשיר שלו, כולל הדמות שלו. זה מה שזה אומר לגבי הדלתות האלה.

מה רמאי יכול לנסות ומה DoorService עושה עם זה
רמאי מנסהתוצאהלמה
להפעיל את ההנחיה מהצד השני של המפהמתעלמים, אם הדמות שלו לא ליד הדלתDoorService מודד את המרחק מה-Part הראשי של הדמות ל-Part עם ההנחיה ומתעלם מכל מה שרחוק יותר מ-14 studs. רמאי יכול קודם לשגר את הדמות לדלת (ראו את השורה האחרונה), ולכן בדיקת המרחק מגינה מפני שימוש מרחוק, לא מפני טלפורט.
להפעיל אותה הרבה פעמים בשנייהלא יותר משימוש אחד בדלת כל 0.3 שנייההשרת שומר את זמן השימוש האחרון בכל דלת.
לפתוח דלת עם מפתח בלי מפתחסירובהשרת מחפש את ה-Tool ב-Backpack ובדמות שלו במקום שבו הוא עצמו רואה אותם, לא במסך של הרמאי.
להשתמש בדלת כשהדמות מתהמתעלמיםDoorService בודק שיש Humanoid עם חיים מעל 0 ו-Part ראשי.
לעבור בכל זאת דרך דלת סגורהאפשריתיעוד האבטחה של Roblox מונה עקיפה של מכשולים פיזיקליים ושינוי ההתנגשויות של עצמו בין הדברים שלקוח יכול לעשות עם הדמות שלו.
להשתגר אל מאחורי הדלתאפשריאותו תיעוד מזכיר שיגור של הדמות לכל נקודה.

שלב 3: בדקו

  1. לחצו על Play (F5). התקרבו ל-FrontDoor: בטווח של 8 studs מופיעה הנחיה עם הפעולה Open ושם האובייקט Door. החזיקו E. אחרי 0.2 שנייה הדלת נפתחת ב-90 מעלות סביב הקצה עם הצירים תוך 0.6 שנייה, ועל ההנחיה כתוב עכשיו Close.
  2. עברו בדלת וחכו. ארבע שניות אחרי הפתיחה המלאה הדלת נסגרת לבד. החזיקו E בזמן שהיא נסגרת: היא מסתובבת חזרה ונפתחת מהמקום שבו הייתה.
  3. בדקו את המנעול. אם RedKey נמצא ב-StarterPack, העבירו אותו בינתיים ל-ServerStorage, לחצו על Play והחזיקו E ליד VaultDoor: על ההנחיה כתוב Needs RedKey, ושום דבר לא זז. עצרו את המשחק, החזירו את RedKey ל-StarterPack והפעילו שוב: VaultDoor נפתחת, בין אם המפתח בסרגל הכלים ובין אם ביד.
  4. בדקו את דלת ההזזה. VaultDoor, Model עם Style Slide, נוסעת בפתיחה הצידה ברוחב שלה. עצרו את המשחק, סמנו את VaultDoor, סובבו אותה ב-90 מעלות עם הכלי Rotate והפעילו שוב: היא עדיין אמורה לנסוע לאורך הרוחב, לא העובי. כשתסיימו, סובבו אותה חזרה.
  5. בחרו Server & Clients ברשימה הנפתחת של מצבי הבדיקה, קבעו 2 לקוחות ולחצו על Play. פתחו את הדלת בחלון של לקוח אחד: היא פתוחה גם בחלון השני ונסגרת בשניהם.
  6. עצרו את המשחק, סמנו דלת ולחצו על Ctrl+D כדי לשכפל, ואז העבירו את העותק לפתח אחר. בדקו שבעותק עדיין מופיע Door ב-Tags, ולחצו על Play: העותק עובד בלי סקריפט נוסף.

השאירו את חלון ה-Output פתוח (תפריט Window, ואז Output). כשהכול עובד, DoorService לא מדפיס כלום. אזהרה שלדלת "has no part to put the prompt on" אומרת שבתוך ה-Model עם התג אין Parts. לכל השאר ראו את הפרק שגיאות נפוצות.

איך להרחיב

דלתות אוטומטיות

כדי שדלת תיפתח כשמישהו מתקרב, קראו ל-move(true) מתוך setUpDoor, בלי לחכות להנחיה. בסוף setUpDoor הפעילו לולאה דרך task.spawn, כי לולאה רגילה שם לא תסתיים אף פעם, ו-DoorService לא היה מתקדם הלאה מהדלת הראשונה. שתרוץ רק כל עוד הדלת קיימת במשחק: task.spawn(function() while door.Parent do ... task.wait(0.5) end end). בתוך הלולאה בדקו דרך workspace:GetPartBoundsInBox אם יש דמות בתוך קופסה סביב הפתח, וקראו ל-move(true) כשהיא שם והדלת סגורה. משם, כמו קודם, הסגירה האוטומטית תסגור אותה. קבעו להנחיה Enabled ל-false אם הדלת צריכה להיפתח רק לבד.

דלתות VIP

המדריך ל-Game Passes כבר בונה דלת VIP שבעלי ה-pass עוברים דרכה ישירות, על קבוצות התנגשות. לדלת VIP שנפתחת על E, הוסיפו עוד בדיקה ב-handler של Triggered ליד בדיקת המפתח: עשו return אם לא מתקיים player:GetAttribute("OwnsPass_VIP") == true, ה-Attribute שסקריפט השרת מהמדריך ל-Game Passes קובע. קראו אותו רק בשרת.

לוח קוד

לדלת שנפתחת לפי קוד שמקלידים, שמרו את הקוד ב-Script של שרת או ב-ServerStorage, ששחקנים אף פעם לא מקבלים, ובשום אופן לא ב-LocalScript, שבו רמאי יכול לקרוא אותו. ה-LocalScript של הלוח שולח דרך RemoteEvent רק את הספרות שהוקלדו. בשרת בדקו שהשחקן ליד הדלת, הגבילו את קצב הניסיונות, השוו את הספרות ורק אז קראו ל-move(true). המדריך ל-RemoteEvent מראה איך לבדוק את מה ש-remote מקבל.

סאונד

שימו Sound בתוך ה-Part של הדלת כדי שיישמע מהמיקום של ה-Part הזה, וקראו לשיטה Play שלו בתחילת move. או הפעילו אותו מ-LocalScript שמאזין ל-Attribute בשם Open של הדלת דרך GetAttributeChangedSignal("Open"), כי השרת קובע את ה-Attribute הזה בכל תנועה.

דלתות שנוספות בזמן המשחק

שכפלו דלתות חדשות מתבנית סגורה ב-ServerStorage. DoorService קורא את המצב הסגור של דלת ברגע שהיא מופיעה, ולכן עותק של דלת שהייתה פתוחה באותו רגע היה מחשיב את המצב הפתוח שלו כסגור. הציבו את העותק בפתח דרך PivotTo לפני שאתם קובעים לו Parent ששווה Workspace, כדי ש-DoorService יזכור את המקום הזה כסגור. הנחיות וערכים ישנים שהגיעו עם העותק נמחקים אוטומטית. על דלת שמעבירה שחקנים לאזור אחר או לפלייס אחר קראו במדריך לטלפורטים.

שגיאות נפוצות ופתרונות

פתחו את חלון ה-Output (תפריט Window, ואז Output) לפני שלוחצים על Play. רוב הבעיות עם דלתות נובעות מתג, pivot או Attribute שהם קצת לא כמו שהסקריפט מצפה.

לדלת לא מופיעה הנחיה

בדקו לפי הסדר: DoorService הוא Script, לא LocalScript, ונמצא ישירות ב-ServerScriptService; לדלת יש את התג Door עם D גדולה, ולדלת-מודל על ה-Model עצמה; הדלת היא Part (Part, MeshPart או BasePart אחר) או Model; ואתם עומדים לא יותר מ-8 studs מה-Part שעליו תלויה ההנחיה. אזהרה ב-Output שלדלת "has no part to put the prompt on" אומרת שבתוך ה-Model עם התג אין Parts.

הדלת נופלת, נסחפת או נדחפת כשהמשחק עולה

Part כלשהו שלה לא מעוגן. סמנו את כל ה-Parts של הדלת וסמנו Anchored. Parts מעוגנים אף פעם לא זזים מפיזיקה, אבל DoorService עדיין יכול להזיז אותם.

שיניתי Attribute, אבל הדלת מתעלמת ממנו

בדקו שלושה דברים. הסוג: OpenAngle, SlideDistance, OpenSeconds ו-AutoCloseSeconds חייבים להיות Attributes מסוג number, ו-Style ו-KeyName מסוג string; בסוג שגוי DoorService לוקח את ערך ברירת המחדל. האיות: השמות מושווים במדויק, ולכן openAngle הוא Attribute אחר. גם הערכים מושווים במדויק: Style חייב להיות Slide עם S גדולה ובלי רווחים. התזמון: DoorService קורא את ה-Attributes פעם אחת, כשהוא מגדיר את הדלת, ולכן שינוי בזמן בדיקת משחק לא עושה כלום עד שתפעילו את המשחק מחדש.

הדלת נפתחת לצד הלא נכון או נופלת על הצד

כדי שתיפתח לצד השני, הפכו את OpenAngle לשלילי, למשל 90-. אם היא מסתובבת סביב ציר אופקי ולא סביב ציר אנכי, ה-pivot עצמו מסובב: הפעילו Pivot בלשונית Model וסובבו את ה-pivot בחזרה כך שיעמוד אנכית.

דלת ההזזה נוסעת לתוך הקיר או זזה רק קצת

תנו לה SlideDistance שלילי כדי שתיסע לצד השני. אם היא זזה מעט מדי או רחוק מדי, קבעו ב-SlideDistance את מספר ה-studs הרצוי ואל תסמכו על הרוחב שנמדד.

יש לי מפתח, אבל הדלת לא נפתחת

המפתח חייב להיות Tool, לא Part ולא Model, והשם שלו חייב להתאים בדיוק ל-KeyName, כולל אותיות גדולות. הוא צריך להיות ב-Backpack שלכם או ביד. בדקו גם שה-KeyName על הדלת הוא Attribute מסוג string.

לעשות עם RoCode

אם לא בא לכם להגדיר את כל זה ביד, RoCode יכול לבנות את זה בפלייס שפתוח אצלכם. RoCode הוא סוכן AI עצמאי ל-Roblox Studio, לא של Roblox: אתם מתארים את השינוי בצ׳אט באתר, והפלאגין שלו ל-Studio יוצר סקריפטים ואובייקטים ב-Explorer שלכם, כך שלא צריך להדביק קוד.

אתם כותבים

תגרום לדלתות עם התג Door להיפתח בהנחיה עם החזקת E: סיבוב של 90 מעלות סביב ה-pivot תוך 0.6 שנייה, סגירה אחרי 4 שניות, הזזה במקום סיבוב כשה-Attribute בשם Style שווה Slide, והדלת נשארת סגורה אם לשחקן אין Tool עם השם מ-KeyName. הכול בשרת, עם בדיקת מרחק.

RoCode עושה
  • יכול לסרוק את הפלייס שלכם כששלב צריך את זה, עם Search Game ו-Search Scripts, כדי להישען על פריטים, remotes או קוד שמירה שכבר קיימים, ולא להוסיף מערכת שנייה
  • כותב Script ב-ServerScriptService עם Create Script, יכול ליצור Part של דלת עם Create Instance ולקבוע עליו Attributes כמו Style ו-KeyName
  • הוא מונחה לבדוק את הקומפילציה של כל סקריפט שכתב עם Check Script, שמקמפל אותו ב-Studio בלי להריץ
  • מציב נקודת ביטול לפני ואחרי כל קבוצת שינויים, ולכן Ctrl+Z מחזיר קבוצה אחת בכל פעם

לפני הבדיקה, בדקו את ה-pivot של כל דלת עם הכלי Pivot ב-Studio: הדלת מסתובבת סביבו. עם פלאגין 3.9 ומעלה RoCode יכול להריץ בדיקת משחק קצרה ולקרוא את השגיאות, ועם פלאגין 3.9.15 ומעלה יכול לשלוט בדמות בדיקה שהולכת ולוחצת על מקשים, אבל הוא בודק רק את מה שהוא עצמו החליט לבדוק, אז גשו לכל דלת והחזיקו E בעצמכם. איך RoCode מתחבר ל-Studio.

שאלות נפוצות

איך גורמים לדלת להיפתח על E ב-Roblox Studio?

שימו ProximityPrompt בדלת וחברו את האירוע Triggered שלו ב-Script של שרת שמזיז את הדלת. DoorService עושה את שניהם לכל דלת עם התג Door. E הוא מקש ההנחיה כברירת מחדל, ו-Roblox מציגה את הקלט המתאים למקלדות, לג׳ויפדים ולמסכי מגע.

למה הדלת שלי מסתובבת סביב האמצע שלה?

ה-pivot שלה עדיין במרכז. הפעילו Pivot בלשונית Model וגררו את ה-pivot לקצה עם הצירים; הסקריפט מסובב את הדלת סביב ה-pivot.

איך יוצרים דלת הזזה?

קבעו ל-Attribute בשם Style של הדלת את הערך Slide. היא נוסעת הצידה ברוחב שלה, או SlideDistance studs; מרחק שלילי מזיז אותה לצד השני.

אפשר ליצור דלת בלי סקריפטים?

כן. המדריך של Roblox לדלת על ציר מחבר דלת לא מעוגנת למסגרת דרך HingeConstraint עם הגבלות, ושחקנים פותחים אותה בדחיפה עם הגוף. לדלת כזו אין הנחיה, מנעול וסגירה אוטומטית.

איך יוצרים דלת שרק VIP יכולים לפתוח?

קחו את דלת ה-VIP מהמדריך ל-Game Passes, שבעלי ה-pass עוברים דרכה, או הוסיפו ל-handler של Triggered ב-DoorService בדיקה שקוראת בשרת לפני הפתיחה אם השחקן הוא הבעלים של ה-pass, למשל ה-Attribute בשם OwnsPass_VIP שהמדריך ההוא קובע.

למה הדלת נפתחת אצלי, אבל לא אצל שחקנים אחרים?

LocalScript פותח אותה, ושינוי ש-LocalScript עושה נשאר במכשיר של אותו שחקן. העבירו את קוד הפתיחה ל-Script של שרת, כמו ב-DoorService, כדי שהשינוי יגיע לכולם.

מקורות וקריאה נוספת

איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.

נסו את RoCode במשחק שלכם.

קרדיטים חינמיים בכל יום, בלי כרטיס אשראי. התקינו את הפלאגין, תארו פיצ'ר ובדקו מה מופיע ב-Studio.