בקצרה
בנו את הדלת כ-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, ושם מובאת גם דוגמה לבדיקה שהשרת חייב לעשות: האם יש לשחקן את המפתח שנדרש כדי לפתוח את הדלת.
בעמוד הזה
איך דלת עם סקריפט עובדת
דלת שעובדת במשחק אמיתי חייבת לזוז על ידי השרת. אם LocalScript מזיז אותה, הדלת נפתחת במסך של שחקן אחד ונשארת סגורה לכל האחרים, כי שינוי שהלקוח עשה נשאר במכשיר הזה (ראו מה משוכפל ומה לא). לכן במדריך הזה המכשיר של השחקן רק מציג את ההנחיה ומדווח על לחיצת המקש, וכל השאר עושה Script שרת אחד. שימוש אחד בדלת נראה כך:
- השחקן מתקרב לדלת למרחק של פחות מ-8 studs, ומופיעה הנחיה עם הפעולה Open, שם האובייקט Door והמקש E במקלדת. בג׳ויפד או במסך מגע Roblox מציגה את הכפתור המתאים.
- השחקן מחזיק E במשך 0.2 שנייה. האירוע
Triggeredשל ההנחיה נורה בשרת עם השחקן הזה. - DoorService בודק את השחקן: חי, קרוב מספיק, לא מציף את ההנחיה, ונושא מפתח אם הדלת דורשת.
- הסקריפט עושה טווין למספר מ-0 (סגור) ל-1 (פתוח). בכל שינוי של המספר הוא מזיז דרך
PivotToאת הדלת לחלק הזה של הדרך מהמצב הסגור לפתוח. - ארבע שניות אחרי הפתיחה המלאה הדלת נסגרת באותה דרך. לחיצה בזמן תנועה מחזירה את הדלת אחורה מהמקום שבו היא נמצאת.
| רכיב | איפה הוא נמצא | מה הוא עושה |
|---|---|---|
Script DoorService | ServerScriptService | מוצא את כל הדלתות, מוסיף לכל אחת הנחיה, בודק כל שימוש ומזיז את הדלת. הסקריפט היחיד במדריך הזה. |
התג Door | על כל Part או Model של דלת | מסמן מה הוא דלת. תגים מוסיפים בחלון Properties, והם נשמרים יחד עם הפלייס. |
Attributes, למשל Style ו-KeyName | על כל דלת (לא חובה) | ההגדרות של דלת אחת: על צירים או הזזה, זווית, מהירות, סגירה אוטומטית ומפתח. |
ProximityPrompt DoorPrompt | בתוך הדלת (DoorService מוסיף אותו) | מציג "Open" או "Close" ומפעיל את Triggered כשהשחקן מחזיק E. |
NumberValue DoorProgress | בתוך הדלת (DoorService מוסיף אותו) | מספר שהטווין מזיז בין 0 ל-1. כל שינוי מזיז את הדלת. |
Tool בשם RedKey (לא חובה) | StarterPack, לבדיקות | מפתח לדלת נעולה. כל Tool מתאים, אם השם שלו תואם את ה-KeyName של הדלת. |
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: בנו את הדלת וקבעו את הציר
- ב-Explorer רחפו מעל Workspace, לחצו על כפתור ה-+ והכניסו Part. קראו לו
FrontDoor, קבעוSizeשל בערך4, 7, 0.5(4 studs רוחב, 7 גובה, חצי stud עובי) והציבו אותו בפתח הדלת. גם דלת מכמה Parts תתאים: סמנו אותם ולחצו על Ctrl+G כדי לקבץ אותם ל-Model. - סמנו Anchored לכל Part של הדלת, והשאירו את CanCollide מופעל. Parts מעוגנים אף פעם לא זזים מכבידה או מהתנגשויות, אבל סקריפט עדיין יכול להזיז אותם, ובדיוק את זה DoorService עושה.
- קבעו את הציר. סמנו את הדלת, פתחו את הלשונית Model והפעילו את Pivot. לחצו והחזיקו את החץ הקטן בפינת כפתור ה-Pivot וסמנו Snap, כדי שה-pivot יידבק לנקודות עיגון בפינות, בקצוות ובמרכזים. גררו את ה-pivot לקצה הדלת שבו היו הצירים. בדלת הזזה ה-pivot יכול להישאר במרכז.
- הוסיפו את התג. בלי לבטל את סימון הדלת, גללו את חלון Properties עד Tags, לחצו על + והקלידו
Doorעם D גדולה. אם הדלת היא Model, שימו את התג על ה-Model עצמה, לא על ה-Parts שבתוכה. - בנו דלת שנייה, היא תידרש בפרקים על דלתות הזזה ועל מפתח. הכניסו ל-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 פעם אחת, כשהוא מגדיר את הדלת, ולכן שנו אותם כשהמשחק עצור.
| Attribute | סוג | ברירת מחדל | מה הוא עושה |
|---|---|---|---|
Style | string | Swing | Swing מסובב את הדלת סביב ה-pivot שלה. Slide מזיז אותה הצידה לאורך הרוחב. |
OpenAngle | number | 90 | בכמה מעלות דלת על צירים מסתובבת. מספר שלילי פותח אותה לצד השני. השאירו את הערך בין 179- ל-179: הדלת תמיד הולכת בקשת הקצרה, ולכן DoorService מגביל את הזווית לגבולות האלה. |
SlideDistance | number | הרוחב שלה | כמה studs דלת הזזה נוסעת לאורך הרוחב שלה. מספר שלילי מזיז אותה לצד השני. |
OpenSeconds | number | 0.6 | כמה זמן נמשכת פתיחה או סגירה מלאה, בטווח מ-0.05 עד 10. |
AutoCloseSeconds | number | 4 | כמה זמן הדלת עומדת פתוחה לגמרי לפני שהיא נסגרת לבד. 0 משאיר אותה פתוחה עד שמישהו יסגור. |
KeyName | string | אין | שם ה-Tool שצריך להיות לשחקן כדי לפתוח את הדלת, למשל RedKey. אל תקבעו אותו לדלת שכל אחד יכול לפתוח. |
שלב 2: הוסיפו את סקריפט הדלת
רחפו מעל ServerScriptService, הכניסו Script בשם DoorService והדביקו בו את הקוד שלמטה. הוא מנהל את כל הדלתות בפלייס, לא משנה כמה מהן סימנתם בתג. שלוש ההגדרות בהתחלה חלות על כל הדלתות; ה-Attributes משלב 1 משנים דלת אחת.
-- 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 לכל דלת כשהמשחק עולה, ולכן לא צריך להכניס כלום ביד. החזיקו עותק אחד של הסקריפט: הוא כבר משרת את כל הדלתות עם התג.
| חלק בסקריפט | מה הוא עושה | למה |
|---|---|---|
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 עם השם הנכון. צרו מפתח, ואז אמרו לדלת את השם שלו:
- רחפו מעל StarterPack, לחצו על + והכניסו Tool בשם
RedKey. הכניסו לתוכו Part אחד בשםHandle, זה ה-Part שהדמות מחזיקה ביד, וודאו שהוא לא מעוגן: Part מעוגן בכלי מקבע את הדמות למקום. הסירו את הסימון מ-CanBeDroppedשל ה-Tool אם שחקנים לא אמורים לזרוק את המפתח בשביל מישהו אחר: כל עוד הוא מסומן, Backspace זורק את הכלי המצויד ל-Workspace. - סמנו את 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 | הדלת נפתחת רק במסך של אותו שחקן, וכל האחרים עדיין רואים אותה סגורה. | השרת מזיז את הדלת, ולכן כל השחקנים רואים את אותה דלת. |
פותח את הדלת ב-Touched | Touched נורה כמה פעמים ברצף בנגיעה אחת (העמוד של Roblox על debounce), והמכשיר של השחקן יכול לשלוט מתי Touched נורה לדמות שלו עצמו (תיעוד האבטחה של Roblox). | הנחיה שהשרת בודק. |
מזיז את הדלת בצעדים בלולאה עם wait() | Roblox מסמנת את wait() כמוחלף ב-task.wait(), ולולאה לא יכולה להסתובב חזרה באמצע הדרך כשמישהו לוחץ שוב. | טווין אחד לכל תנועה. טווין חדש על אותו ערך מבטל את הישן, ולכן הדלת מסתובבת חזרה מהמקום שבו היא נמצאת. |
| בודק את המפתח ב-LocalScript או לא בודק בכלל | רמאי שולט בכל דבר במכשיר שלו, ולכן בדיקה בלקוח לא עוצרת אף אחד. | השרת מחפש את ה-Tool ב-Backpack ובדמות של השחקן. |
| אין זמן המתנה על ההנחיה | במדריך האבטחה של Roblox כתוב שהנחיות פגיעות לניצול לרעה בדיוק כמו remotes, ולכן שום דבר לא מונע להפעיל אותה שוב ושוב. | שימוש אחד בדלת כל 0.3 שנייה. |
מה רמאי יכול ומה לא
הניחו שרמאי שולט בכל דבר במכשיר שלו, כולל הדמות שלו. זה מה שזה אומר לגבי הדלתות האלה.
| רמאי מנסה | תוצאה | למה |
|---|---|---|
| להפעיל את ההנחיה מהצד השני של המפה | מתעלמים, אם הדמות שלו לא ליד הדלת | DoorService מודד את המרחק מה-Part הראשי של הדמות ל-Part עם ההנחיה ומתעלם מכל מה שרחוק יותר מ-14 studs. רמאי יכול קודם לשגר את הדמות לדלת (ראו את השורה האחרונה), ולכן בדיקת המרחק מגינה מפני שימוש מרחוק, לא מפני טלפורט. |
| להפעיל אותה הרבה פעמים בשנייה | לא יותר משימוש אחד בדלת כל 0.3 שנייה | השרת שומר את זמן השימוש האחרון בכל דלת. |
| לפתוח דלת עם מפתח בלי מפתח | סירוב | השרת מחפש את ה-Tool ב-Backpack ובדמות שלו במקום שבו הוא עצמו רואה אותם, לא במסך של הרמאי. |
| להשתמש בדלת כשהדמות מתה | מתעלמים | DoorService בודק שיש Humanoid עם חיים מעל 0 ו-Part ראשי. |
| לעבור בכל זאת דרך דלת סגורה | אפשרי | תיעוד האבטחה של Roblox מונה עקיפה של מכשולים פיזיקליים ושינוי ההתנגשויות של עצמו בין הדברים שלקוח יכול לעשות עם הדמות שלו. |
| להשתגר אל מאחורי הדלת | אפשרי | אותו תיעוד מזכיר שיגור של הדמות לכל נקודה. |
שלב 3: בדקו
- לחצו על Play (F5). התקרבו ל-FrontDoor: בטווח של 8 studs מופיעה הנחיה עם הפעולה Open ושם האובייקט Door. החזיקו E. אחרי 0.2 שנייה הדלת נפתחת ב-90 מעלות סביב הקצה עם הצירים תוך 0.6 שנייה, ועל ההנחיה כתוב עכשיו Close.
- עברו בדלת וחכו. ארבע שניות אחרי הפתיחה המלאה הדלת נסגרת לבד. החזיקו E בזמן שהיא נסגרת: היא מסתובבת חזרה ונפתחת מהמקום שבו הייתה.
- בדקו את המנעול. אם RedKey נמצא ב-StarterPack, העבירו אותו בינתיים ל-ServerStorage, לחצו על Play והחזיקו E ליד VaultDoor: על ההנחיה כתוב Needs RedKey, ושום דבר לא זז. עצרו את המשחק, החזירו את RedKey ל-StarterPack והפעילו שוב: VaultDoor נפתחת, בין אם המפתח בסרגל הכלים ובין אם ביד.
- בדקו את דלת ההזזה. VaultDoor, Model עם
StyleSlide, נוסעת בפתיחה הצידה ברוחב שלה. עצרו את המשחק, סמנו את VaultDoor, סובבו אותה ב-90 מעלות עם הכלי Rotate והפעילו שוב: היא עדיין אמורה לנסוע לאורך הרוחב, לא העובי. כשתסיימו, סובבו אותה חזרה. - בחרו Server & Clients ברשימה הנפתחת של מצבי הבדיקה, קבעו 2 לקוחות ולחצו על Play. פתחו את הדלת בחלון של לקוח אחד: היא פתוחה גם בחלון השני ונסגרת בשניהם.
- עצרו את המשחק, סמנו דלת ולחצו על 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. הכול בשרת, עם בדיקת מרחק.
- יכול לסרוק את הפלייס שלכם כששלב צריך את זה, עם 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, כדי שהשינוי יגיע לכולם.
מקורות וקריאה נוספת
- Roblox Creator Docs: PVInstance:PivotTo (באנגלית). הזזת Part או מודל שלם לפי ה-pivot שלו
- Roblox Creator Docs: Pivot tools (באנגלית). העברת pivot, Snap ונקודות עיגון, pivot כשיש PrimaryPart
- Roblox Creator Docs: Model (באנגלית). WorldPivot, GetExtentsSize עוקב אחרי ה-pivot, SetPrimaryPartCFrame מיושן
- Roblox Creator Docs: CFrame:Lerp (באנגלית). הסיבוב מאונטרפל בקשת הקצרה ביותר
- Roblox Creator Docs: TweenService (באנגלית). מה אפשר לעשות טווין ואיך טווין שני על אותו מאפיין מבטל את הראשון
- Roblox Creator Docs: Proximity prompts (באנגלית). יצירה והגדרה של הנחיות, קלט בכל מכשיר וקו ראייה
- Roblox Creator Docs: ProximityPrompt (באנגלית). המקש והכפתור כברירת מחדל, HoldDuration, MaxActivationDistance ו-Triggered
- Roblox Creator Docs: CollectionService (באנגלית). תגים, GetTagged ו-GetInstanceAddedSignal
- Roblox Creator Docs: Properties window (באנגלית). הוספת תגים ו-Attributes ב-Studio
- Roblox Creator Docs: Securing the client-server boundary (באנגלית). ProximityPrompt כמשטח תקיפה ובדיקת ההרשאה "מפתח ודלת"
- Roblox Creator Docs: Network ownership, movement validation, and physics (באנגלית). מה הלקוח יכול לעשות עם הדמות שלו
- Roblox Creator Docs: Build a hinged door (באנגלית). דלת על HingeConstraint בלי קוד
- Roblox Creator Docs: In-game tools (באנגלית). Handle, עיגון ו-StarterPack
- Roblox Creator Docs: Tool.CanBeDropped (באנגלית). מה Backspace עושה לכלי מצויד
איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.