בקצרה
כבו את CharacterAutoLoads בשירות Players, כדי שאף אחד לא ייוולד בכניסה. LocalScript ב-StarterPlayerScripts בונה את התפריט (כותרת, כפתור Play ו-Frame שחור להאפלות) ב-ScreenGui עם ResetOnSpawn כבוי, מכוון את המצלמה ל-Part בשם MenuCamera דרך CameraType Scriptable, ובלחיצה על Play שולח RemoteEvent. Script ב-ServerScriptService עונה בקריאה ל-Player:LoadCharacterAsync(), וה-LocalScript מחזיר את המצלמה (CameraType Custom, CameraSubject הוא ה-Humanoid) ומסיר את התפריט.
- השתמשו ב-
Activated, לא ב-MouseButton1Click, כדי ש-Play יעבוד בלחיצת עכבר, בהקשה ובג׳ויפד, וסמנו את הכפתור לשחקנים עם ג׳ויפד כדי שיוכלו ללחוץ עליו. - כש-CharacterAutoLoads כבוי, StarterGui מועתק ל-PlayerGui של השחקן רק כשהדמות שלו נולדת, ולכן את התפריט בונה LocalScript ב-StarterPlayerScripts.
- כש-CharacterAutoLoads כבוי, Roblox גם מפסיקה להחזיר שחקנים לחיים, ולכן סקריפט השרת מחזיר אותם בעצמו אחרי מוות או נפילה מהמפה, אחרי המתנה של
Players.RespawnTime(ברירת מחדל 5 שניות).
בעמוד הזה
איך תפריט ראשי עובד
לתפריט יש שני צדדים. המכשיר של השחקן מצייר את הכותרת והכפתור ומזיז את המצלמה. השרת מחליט מתי הדמות מופיעה. התפריט עצמו הוא רק תמונה במסך אחד: השינוי האמיתי קורה כשהשרת מוליד את הדמות, ורק השרת יכול לעשות את זה.
| חלק | איפה הוא נמצא | מה הוא עושה |
|---|---|---|
MenuService Script | ServerScriptService | מכבה לידה אוטומטית, יוצר את PlayRequest, מוליד שחקן שלחץ על Play ומחזיר שחקנים לחיים אחרי מוות או נפילה. |
MainMenu LocalScript | StarterPlayerScripts | בונה את הכותרת, כפתור ה-Play וההאפלה, מוביל את שוט המצלמה, מבקש מהשרת דמות ומחזיר את המצלמה. |
PlayRequest RemoteEvent | ReplicatedStorage (נוצר על ידי MenuService, אל תוסיפו ביד) | מעביר לשרת הודעה אחת: השחקן הזה לחץ על Play. אין בה שום ערכים. |
MenuCamera Part | Workspace (אתם מציבים) | איפה עומדת מצלמת התפריט ולאן היא מסתכלת. |
CharacterAutoLoads | מאפיין של שירות Players | כבוי, ולכן אף אחד לא נולד עד שהשרת קורא ל-LoadCharacterAsync. |
Workspace
MenuCamera Part new
ReplicatedStorage
PlayRequest RemoteEvent new
ServerScriptService
MenuService Script new
StarterPlayer
StarterPlayerScripts
MainMenu LocalScript new
שלב 1: כבו לידה אוטומטית והציבו את מצלמת התפריט
- ב-Explorer סמנו את Players. בחלון Properties הסירו את הסימון מ-CharacterAutoLoads. גם MenuService מכבה אותו, אבל הסימון מבטיח שאף אחד לא ייוולד ברגע שלפני שהסקריפט עולה.
- רחפו מעל Workspace, לחצו על כפתור ה-+ והכניסו Part. שנו את השם שלו ל-
MenuCamera(אותיות גדולות וקטנות בשמות חשובות) והשאירו אותו ישירות ב-Workspace, לא בתוך תיקייה או מודל. - ב-Properties שלו סמנו Anchored, הסירו את הסימון מ-CanCollide וקבעו Transparency ל-1. העיגון חשוב: Part לא מעוגן שלא מתנגש בשום דבר נופל דרך המפה, ו-Roblox מוחקת Parts שנפלו מתחת ל-
Workspace.FallenPartsDestroyHeight. - הזיזו וסובבו את ה-Part כך שהפאה הקדמית שלו תסתכל על התצוגה הרצויה. המצלמה לוקחת את המיקום של ה-Part ומסתכלת לאותו כיוון כמו הפאה הקדמית שלו.
הדרך הכי מהירה לכוון אותו: הטיסו את מצלמת Studio לשוט הרצוי, פתחו את Command Bar (בלשונית Script או דרך Window, ואז Script) והריצו workspace.MenuCamera.CFrame = workspace.CurrentCamera.CFrame. במצב עריכה CurrentCamera היא התצוגה שדרכה אתם מסתכלים, ולכן ה-Part קופץ בדיוק לשוט הזה.
השאירו את Workspace.StreamingEnabled כמו שהוא. בפלייסים חדשים instance streaming מופעל, והסקריפטים שלמטה נכתבו בהתחשב בזה.
שלב 2: מולידים שחקנים בלחיצה על Play
רחפו מעל ServerScriptService, הכניסו Script, קראו לו MenuService והדביקו את הקוד הזה:
-- Script ב-ServerScriptService בשם MenuService.
-- שחקנים נכנסים בלי דמות. השרת יוצר אותה כשכפתור ה-Play בתפריט מבקש,
-- ומחזיר שחקנים לחיים אחרי מוות, כי הלידה האוטומטית כבויה.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- הסירו גם את הסימון מ-CharacterAutoLoads בשירות Players בחלון Properties,
-- כדי שאף אחד לא ייוולד ברגע שלפני שהסקריפט הזה עולה.
Players.CharacterAutoLoads = false
-- הסקריפט הזה יוצר את PlayRequest בעצמו, אז אל תוסיפו אותו ל-ReplicatedStorage ביד
local playRequest = Instance.new("RemoteEvent")
playRequest.Name = "PlayRequest"
playRequest.Parent = ReplicatedStorage
local spawning: { [Player]: boolean } = {}
local function spawnCharacter(player: Player)
if spawning[player] then
return -- לחיצה שנייה על Play בזמן שהלידה הראשונה עוד נטענת
end
spawning[player] = true
local oldCharacter = player.Character
local ok, err = pcall(function()
player:LoadCharacterAsync()
end)
spawning[player] = nil
if not ok then
warn(`MenuService: could not spawn {player.Name}: {err}`)
-- לידה מחדש שנכשלה הייתה משאירה שחקן מת תקוע, ולכן מנסים שוב אחרי הפסקה קצרה.
-- לידה ראשונה שנכשלה לא צריך לנסות שוב: כפתור התפריט כותב Try again.
if oldCharacter then
task.delay(Players.RespawnTime, function()
local current = player.Character
if player.Parent == Players and (current == oldCharacter or current == nil) then
spawnCharacter(player)
end
end)
end
elseif oldCharacter and oldCharacter ~= player.Character then
oldCharacter:Destroy() -- משחרר את החיבורים של הדמות הישנה
end
end
-- לבקש לידה יכול רק שחקן שעדיין בתפריט (עוד אין לו דמות). לשחקן מת
-- עדיין יש דמות, ולכן כך אי אפשר לדלג על ההמתנה ללידה מחדש.
playRequest.OnServerEvent:Connect(function(player: Player)
if player.Character == nil then
spawnCharacter(player)
end
end)
-- כש-CharacterAutoLoads כבוי, אף אחד לא מחזיר שחקנים לחיים אחרי מוות, ולכן עושים את זה כאן
local function onCharacterAdded(player: Player, character: Model)
local respawning = false
local function respawnLater()
if respawning then
return
end
respawning = true
task.wait(Players.RespawnTime)
-- מחזירים לחיים רק אם השחקן עדיין כאן ואף אחד לא הוליד אותו מאז
local current = player.Character
if player.Parent == Players and (current == character or current == nil) then
spawnCharacter(player)
end
end
local humanoid = character:WaitForChild("Humanoid") :: Humanoid
humanoid.Died:Connect(respawnLater)
-- נפילה מהמפה יכולה להסיר את הדמות מ-Workspace, ו-Died נורה רק
-- כל עוד ה-Humanoid ב-Workspace, ולכן כאן תופסים גם את המקרה הזה
character.AncestryChanged:Connect(function()
if not character:IsDescendantOf(workspace) then
respawnLater()
end
end)
end
local function onPlayerAdded(player: Player)
player.CharacterAdded:Connect(function(character: Model)
onCharacterAdded(player, character)
end)
-- עם סטרימינג המפה נטענת סביב הדמות של השחקן, ולשחקן ב-
-- תפריט עוד אין דמות. מוסיפים פוקוס שכפול ליד מצלמת התפריט עד שהוא נולד.
local menuCamera = workspace:FindFirstChild("MenuCamera")
if menuCamera and menuCamera:IsA("BasePart") then
player:AddReplicationFocus(menuCamera)
player.CharacterAdded:Once(function()
player:RemoveReplicationFocus(menuCamera) -- מעכשיו הפוקוס הוא הדמות
end)
end
end
Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do
onPlayerAdded(player)
end
Players.PlayerRemoving:Connect(function(player: Player)
spawning[player] = nil
end)
PlayRequest לא מעביר שום ערכים. Roblox מעבירה את השחקן ששלח את האירוע כארגומנט הראשון של OnServerEvent, וזה כל מה שהשרת צריך לדעת.
למי מותר להיוולד
ה-handler של PlayRequest מוליד שחקן רק אם player.Character שווה nil, וכך זה אצל שחקן שעדיין בתפריט. שחקן שמת שומר על הדמות שלו עד ש-MenuService מחזיר אותו לחיים, ולכן דרך ה-remote אי אפשר לדלג על ההמתנה.
הטבלה spawning לא נותנת לבקשה שנייה להתחיל לידה שנייה בזמן שהראשונה עוד נטענת. LoadCharacterAsync מחכה עד שהדמות נטענת, והתיעוד של Roblox לא ממליץ לקרוא לו שוב לאותו שחקן לפני שהאירוע CharacterAppearanceLoaded שלו נורה. כל קריאה עוברת בתוך pcall, ולכן לידה שנכשלה, למשל כששחקן יצא בזמן הטעינה, מדפיסה אזהרה עם שם השחקן, ולא שגיאה. אם לידה מחדש נכשלה, MenuService מחכה RespawnTime ומנסה שוב, כך שלידה מחדש שנכשלה לא משאירה שחקן מת תקוע. לידה ראשונה שנכשלה השרת לא מנסה שוב: כפתור התפריט כותב Try again, והשחקן יכול ללחוץ עליו.
לידה מחדש אחרי מוות או נפילה
כש-CharacterAutoLoads כבוי, Roblox לא מחזירה אף אחד לחיים. Players.RespawnTime (ברירת מחדל 5 שניות) עובד לבד רק כש-CharacterAutoLoads מופעל, ולכן MenuService קורא את הערך הזה, מחכה בעצמו וקורא שוב ל-LoadCharacterAsync. הדמות החדשה מופיעה על ה-SpawnLocation כרגיל, והסקריפט משמיד את הישנה, מה שגם מנתק את החיבורים של הדמות הזו.
לנפילה מהמפה צריך בדיקה שנייה. Roblox מוחקת Parts שנפלו מתחת ל-Workspace.FallenPartsDestroyHeight, ומוחקת מודל כשה-Part האחרון שלו נעלם, ולכן דמות שנפלה יכולה לעזוב את ה-Workspace, ו-Humanoid.Died נורה רק כל עוד ה-Humanoid ב-Workspace. לכן MenuService מחזיר לחיים גם דמות שעזבה את ה-Workspace (AncestryChanged), והדגל respawning דואג שכל דמות תגרום ללא יותר מלידה מחדש אחת. אחרי ההמתנה הסקריפט מחזיר שחקן לחיים רק אם הוא עדיין במשחק ו-player.Character עדיין הדמות הזו או nil, ולכן שחקן שבינתיים נולד בדרך אחרת לא נולד פעמיים.
סטרימינג ומצלמת התפריט
עם instance streaming כל לקוח מקבל Parts סביב פוקוס השכפול שלו, וכברירת מחדל זה ה-PrimaryPart של הדמות שלו. לשחקן בתפריט אין דמות, והעמוד של Roblox על טכניקות סטרימינג מזהיר שללקוח בלי דמות שנולדה אין פוקוס שכפול, כך שהמפה עלולה בכלל לא להיטען. הפתרון מאותו עמוד הוא Player:AddReplicationFocus(), ש-MenuService קורא לו עם ה-Part בשם MenuCamera כשהשחקן נכנס (Roblox אומרת לקרוא לו רק בשרת). כשהדמות נולדת בפעם הראשונה, MenuService קורא ל-RemoveReplicationFocus, והדמות שוב הופכת לפוקוס היחיד: כל פוקוס מיותר מוסיף לשרת עבודת סטרימינג. בשלב 5 יש בדיקת משחק עם סטרימינג מופעל, כדי לוודא שהמפה גלויה מאחורי התפריט.
מה השרת מחליט ומה רמאי יכול לעשות
רמאי יכול להריץ קוד משלו במכשיר שלו. הוא יכול לשלוח PlayRequest מתי שירצה, עם כל ערך, ולשנות כל דבר במסך שלו. זה מה שזה נותן לו.
| רמאי | מה קורה |
|---|---|
| שולח PlayRequest בלי ללחוץ על Play | הוא נולד, בדיוק כאילו לחץ על Play. דילוג על התפריט לא נותן כלום. |
| שולח PlayRequest מאות פעמים | לידה אחת. בזמן שהיא נטענת, הדגל spawning מתעלם מהשאר; אחריה יש לשחקן דמות, וכל בקשה נדחית בבדיקה אחת. לכן ה-remote הזה לא צריך מגבלת קצב. |
| שולח PlayRequest כשהוא מת, כדי לחזור לחיים מוקדם יותר | סירוב. שחקן שמת שומר על הדמות עד ש-MenuService מחזיר אותו לחיים. |
| שולח ערכים מיותרים עם PlayRequest | מתעלמים. ה-handler אף פעם לא קורא אותם. |
| מוחק את התפריט או מזיז את המצלמה שלו | משתנה רק המסך שלו. דמות עדיין אין לו, עד שהשרת מוליד אותה. |
בואו נגיד את זה ישר: תפריט הוא מסך, לא מנעול. הוא מחליט מתי השחקן נולד, ולא יותר. אם כפתור בתפריט נותן משהו, למשל סקין, דלת VIP או מטבעות, Script של שרת צריך לבדוק את זה, בדיוק כמו שהמדריך לחנות בודק כל קנייה. בדיקה של מה ש-remote מקבל מפורטת במדריך ל-RemoteEvent.
שלב 4: עצבו את התפריט בסגנון המשחק שלכם
הסקריפטים מציירים בכוונה תפריט פשוט, כדי שיהיה קל להבין את הלוגיקה. כל מה שלמטה משנה רק את חלק ה-GUI של MainMenu; את קוד המצלמה ואת Play השאירו כמו שהם.
- לוגו במקום טקסט הכותרת. העלו את תמונת הלוגו ל-Studio או ל-Creator Hub, ואז החליפו את ה-
TextLabelשל הכותרת ב-ImageLabel, שה-Imageשלו הואrbxassetid://ועוד ה-Asset ID של התמונה. קבעו לוBackgroundTransparency1 ו-ScaleTypeFit, כדי שישמור על הפרופורציות. - רקע מטושטש. צרו
BlurEffectב-MainMenu ושימו אותו ב-workspace.CurrentCamera. Roblox ממליצה לעשות כך לתפריטים: אפקט מתחת למצלמה רואה רק השחקן הזה. ה-Sizeשלו הוא רדיוס הטשטוש בפיקסלים. השמידו אותו ב-handler של Play, לידgui:Destroy(). - צבע. הוסיפו לכפתור
UIGradientאוUIStrokeלמסגרת. השאירו לטקסטTextScaled, כדי שייכנס במסכים קטנים. - עוד כפתורים. שימו כפתורים בתוך
FrameעםUIListLayoutו-Paddingקטן, ותנו לכל אחד handler שלActivatedו-UISizeConstraintמשלו. כפתור Settings או Help יכול לפתוח חלונית בלקוח בלבד. כפתור Shop יכול לפתוח חלון מהמדריך לחנות, שבו הקניות עדיין עוברות בשרת.
שלב 5: בדקו
- פתחו את חלון ה-Output (תפריט Window, ואז Output) ולחצו על Play. המסך מאיר על הכותרת ועל כפתור ה-Play שלכם מעל שוט ה-MenuCamera, ורשימת השחקנים והתרמיל מוסתרים. ב-Explorer, ב-Workspace אין מודל עם השם שלכם: עוד אין לכם דמות.
- לחצו על כפתור ה-Play. מופיע עליו "Loading...", המסך מחשיך, ואז מאיר מאחורי הדמות שלכם עם המצלמה הרגילה, ורשימת השחקנים חוזרת. ב-
Players, השם שלכם,PlayerGuiכבר אין לא MainMenu ולא MenuFade. - אפסו את הדמות דרך תפריט המשחק. אתם חוזרים לחיים אחרי בערך 5 שניות, והתפריט לא חוזר.
- רדו או קפצו מקצה המפה. כשהדמות תיפול מהעולם, תחזרו לחיים אחרי בערך 5 שניות.
- בדקו את מסך הטלפון ב-Device Simulator ב-Studio (נכון לזמן הכתיבה זו בטא: הפעילו את New Device Simulator ב-File, Beta Features והפעילו מחדש את Studio). בטלפון קטן כפתור ה-Play נשאר לא קטן מ-160 על 56 פיקסלים, ואפשר לפגוע בו באצבע.
- בדקו ג׳ויפד ב-Controller Emulator (Controller בלשונית Emulation) בזמן בדיקת משחק. לחצו על כפתור כלשהו בג׳ויפד המדומה: Play מסומן, ולחיצה על A מתחילה את המשחק. אם Play לא מסומן, לחצו בג׳ויפד על Select, שמסמן את הכפתור כל עוד
GuiService.AutoSelectGuiEnabledמופעל, ואז על A. - כש-instance streaming מופעל, כמו בפלייסים חדשים, בדקו שמאחורי התפריט נראית המפה שסביב MenuCamera, ולא רק שמיים.
ב-Output בשום רגע לא אמורות להיות שגיאות אדומות מ-MenuService או מ-MainMenu. אם משהו לא מסתדר, ראו שגיאות נפוצות.
התפריט יחד עם מערכות אחרות
CharacterAutoLoads כבוי משנה את ההתנהגות של כל שאר הסקריפטים במשחק. אם עשיתם מדריכים אחרים מהאתר הזה, בדקו את אלה.
| מערכת | מה משתנה | מה לעשות |
|---|---|---|
| מערכת סיבובים | שחקנים בתפריט נספרים ל-MIN_PLAYERS, כי הסיבוב סופר את כל מי שבשרת, אבל אף פעם לא משוגרים: startRound לוקח רק שחקנים עם דמות חיה. שחקנים שהודחו מחזיר לחיים MenuService, לא Roblox. | לא חובה לעשות כלום. אם שחקנים בתפריט מפריעים לסיבוב להתחיל ("Not enough players, starting over"), ספרו ב-runIntermission רק שחקנים שה-Character שלהם לא nil. |
| צ׳קפוינטים באובי | ObbyCheckpoints גם מכבה את CharacterAutoLoads ומוליד כל שחקן ברגע שהשלב שלו נטען. עם שני הסקריפטים שחקנים נולדים בצ׳קפוינט שלהם מאחורי התפריט, ו-Play רק מסיר את התפריט. | השאירו מוליד אחד. שמרו את ObbyCheckpoints ומחקו את MenuService. ב-ObbyCheckpoints מחקו את השורה spawnAtStage(player) בסוף onPlayerAdded. אחר כך ברמה העליונה של הסקריפט, ממש מעל Players.PlayerAdded:Connect(onPlayerAdded) ולא בתוך onPlayerAdded, העתיקו מ-MenuService את השורה עם ReplicatedStorage ואת השורות שיוצרות את PlayRequest, וחברו את ה-handler של OnServerEvent שלו. ב-handler קראו ל-spawnAtStage(player) רק כש-player.Character שווה nil, stageValues[player] קיים ולא רצה לידה לשחקן הזה (טבלה כמו spawning מ-MenuService). שחקן שלחץ על Play לפני שהשלב שלו נטען רואה Try again ויכול ללחוץ שוב. הלידות מחדש בו נשארות כמו שהן. אם בפלייס מופעל סטרימינג, העתיקו גם את שורות ה-MenuCamera מ-MenuService (AddReplicationFocus ו-RemoveReplicationFocus) לתחילת onPlayerAdded. |
| הסקריפטים של טבלת המובילים ושל DataStore | הם רצים בכניסה, בזמן שהשחקן בתפריט. | כלום. נתוני השחקן מתחילים להיטען בזמן שהוא מסתכל על התפריט. |
| GUI של חנות | ShopClient בונה את החלון שלו מיד כשהשחקן נכנס, ולכן כפתור ה-Shop שלו היה מופיע ליד התפריט. | ב-ShopClient הוסיפו if not player.Character then player.CharacterAdded:Wait() end ממש לפני השורה gui.Parent = player:WaitForChild("PlayerGui"), כדי שהחנות תופיע אחרי Play. |
| סצנת פתיחה | CutsceneService מציג את הפתיחה בלידה הראשונה של השחקן, ועם התפריט זו הלידה הראשונה אחרי Play. התפריט מפעיל שוב את ה-core GUI כשהדמות מופיעה, ולכן בזמן הפתיחה רשימת השחקנים עלולה להיות גלויה. | לא חובה לעשות כלום. הסצנה מפעילה שוב רק את ה-core GUI שהיא עצמה הסתירה, ולכן אחרי הפתיחה הם נשארים מופעלים. |
| ScreenGui ב-StarterGui | הם מועתקים לשחקן רק כשהדמות נולדת. | כלום. הם מופיעים אחרי Play, ול-HUD זה בדרך כלל בדיוק מה שצריך. |
ההבדל בין סקריפטים ב-StarterPlayerScripts וב-StarterGui מוסבר במדריך Script vs LocalScript vs ModuleScript.
שגיאות נפוצות ופתרונות
פתחו את חלון ה-Output (תפריט Window, ואז Output) לפני שלוחצים על Play. רוב הבעיות עם תפריטים מדפיסות שם אזהרה או שגיאה עם שם הסקריפט ומספר השורה.
המצלמה נשארת על שוט התפריט אחרי Play
MainMenu לא הגיע לשלב שמחזיר את המצלמה, או שסקריפט אחר שינה את המצלמה אחרי זה. חפשו ב-Output שגיאה אדומה מ-MainMenu. אם סקריפט כלשהו שלכם גם קובע את CameraType, ודאו שהוא לא קובע Scriptable כשהשחקן כבר במשחק.
על הכפתור "Loading...", ואחר כך "Try again"
MainMenu מצא את PlayRequest, כלומר MenuService עובד, אבל דמות עם Humanoid לא הופיעה תוך 15 שניות. אם הוספתם PlayRequest ל-ReplicatedStorage בעצמכם, מחקו אותו: MenuService יוצר אחד משלו, ועם שני אובייקטים באותו שם הכפתור עלול לשלוח לאחד בזמן שהשרת מאזין לשני. אחר כך חפשו ב-Output את MenuService: could not spawn ואת הסיבה שאחריו. אם אתם משתמשים ב-StarterCharacter משלכם, ה-Humanoid שלו חייב להיקרא Humanoid, כי שני הסקריפטים מחכים לילד בשם הזה. אם הלידה פשוט הייתה איטית, לחיצה על Try again תסיים אותה.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("PlayRequest")'
MainMenu מחכה ל-RemoteEvent ש-MenuService יוצר, כלומר MenuService לא עובד: הוא כבוי, נמצא במקום הלא נכון או נעצר בשגיאה. האזהרה הזו מפורטת במדריך לשגיאות בסקריפטים.
הדמות שלי נולדת מאחורי התפריט
משהו אחר מוליד שחקנים. הסירו את הסימון מ-CharacterAutoLoads בשירות Players, וחפשו סקריפט אחר שקורא ל-LoadCharacterAsync בכניסה, למשל סקריפט צ׳קפוינטים לאובי: ראו התפריט יחד עם מערכות אחרות.
בתפריט רואים רק שמיים
המצלמה משתמשת בתצוגת הגיבוי, או שהמפה לא נטענה. בדקו שה-Part נקרא בדיוק MenuCamera, נמצא ישירות ב-Workspace (לא בתיקייה או במודל), מעוגן, והפאה הקדמית שלו מסתכלת על המפה.
אחרי מוות אני לא חוזר לחיים
עכשיו רק MenuService מחזיר שחקנים לחיים, אז חפשו ב-Output שגיאה ממנו. לידה מחדש שנכשלה מדפיסה MenuService: could not spawn וחוזרת אחרי RespawnTime. אם המשחק שלכם מכבה ב-Humanoid את המצב Dead, Died אף פעם לא נורה, ולכן החזירו את השחקן לחיים מקוד המוות שלכם.
ה-HUD שלי מ-StarterGui מופיע רק אחרי Play
ככה זה אמור להיות. כש-CharacterAutoLoads כבוי, Roblox מעתיקה את StarterGui ל-PlayerGui של השחקן רק כשהדמות נולדת. את מה שצריך להיות גלוי בתפריט, בנו מ-LocalScript ב-StarterPlayerScripts, כמו ש-MainMenu עושה.
לעשות עם RoCode
אם לא בא לכם לבנות את כל זה ביד, RoCode יכול לעשות את זה בפלייס שפתוח אצלכם. RoCode הוא סוכן AI עצמאי ל-Roblox Studio, לא של Roblox: אתם מתארים את הפיצ׳ר בצ׳אט שלו באתר, והפלאגין שלו ל-Studio יוצר את ה-Part והסקריפטים ב-Explorer שלכם, כך שלא תצטרכו להעתיק קוד מחלון הצ׳אט.
תוסיף תפריט ראשי: שחקנים לא אמורים להיוולד עד שהם לוחצים על Play. תציג את שם המשחק שלי וכפתור Play מעל שוט מצלמה איטי מה-Part בשם MenuCamera, תחשיך את המסך, תוליד את השחקן מהשרת ותחזיר את המצלמה הרגילה. זה צריך לעבוד בטלפונים ועם ג׳ויפד.
- יכול קודם לבדוק את הפלייס שלכם עם Search Scripts, למשל אם יש סקריפט שכבר מכבה את CharacterAutoLoads או מחזיר שחקנים לחיים (כמו שסקריפט הצ׳קפוינטים לאובי עושה), כדי ששני הסקריפטים לא יתנגשו
- יוצר את ה-Part בשם MenuCamera עם Create Instance ומכבה את
Players.CharacterAutoLoadsעם Set Property - כותב את MenuService ואת MainMenu עם Create Script
- הוא מונחה לבדוק כל סקריפט שכתב עם Check Script, שמקמפל אותו ב-Studio בלי להריץ, ומציב נקודת ביטול לפני ואחרי כל קבוצת שינויים
RoCode לא יכול להעלות בשבילכם תמונת לוגו או מוזיקה לתפריט: העלו אותן ל-Studio או ל-Creator Hub ותנו ל-RoCode את ה-Asset IDs. עם פלאגין 3.9 ומעלה RoCode יכול להריץ בדיקת משחק קצרה ולקרוא את השגיאות, ועם פלאגין 3.9.15 ומעלה דמות הבדיקה שלו יכולה ללחוץ על כפתורים במסך, אבל הוא בודק רק את מה שהוא עצמו החליט לבדוק, אז לחצו בעצמכם על כל התפריט. באיזה סדר לבנות משחק שלם, ראו במדריך איך ליצור משחק ב-Roblox עם AI, מערכת אחר מערכת. איך RoCode מתחבר ל-Studio.
שאלות נפוצות
איך גורמים לשחקן לא להיוולד עד שהוא לוחץ על Play?
הסירו את הסימון מ-CharacterAutoLoads בשירות Players, ואז הולידו את השחקן מ-Script של שרת דרך player:LoadCharacterAsync() כשמגיע RemoteEvent מכפתור ה-Play. לידה מחדש אחרי מוות צריכה אז את אותה קריאה, ו-MenuService עושה אותה.
למה התפריט הראשי מופיע שוב אחרי כל מוות?
ב-ScreenGui שלו מופעל ResetOnSpawn, ולכן Roblox נותנת לשחקן עותק חדש בכל לידה. כבו אותו והסירו את התפריט אחרי Play, כמו ש-MainMenu עושה.
איך גורמים למצלמה להראות את המפה מאחורי התפריט?
ב-LocalScript קבעו את workspace.CurrentCamera.CameraType ל-Scriptable ותנו למצלמה את ה-CFrame של ה-Part שהצבתם. אחרי Play החזירו ל-Custom והפכו את ה-Humanoid לערך של CameraSubject.
איך מוסיפים מסך טעינה לפני התפריט?
המדריך של Roblox למסכי טעינה משתמש ב-LocalScript ב-ReplicatedFirst, שמגיע לשחקן לפני כל השאר. הוא בונה ScreenGui, קורא ל-ReplicatedFirst:RemoveDefaultLoadingScreen(), מחכה ל-game:IsLoaded(), ואז מסיר את המסך שלו. תנו ל-ScreenGui הזה DisplayOrder גבוה מ-11, כדי שיכסה את התפריט הזה עד שייעלם. המדריך שלנו למסך טעינה בונה מסך כזה עם פס התקדמות וכפתור Skip, וה-DisplayOrder 100 שלו כבר מכסה את התפריט.
איך מוסיפים מוזיקה לתפריט הראשי?
השתמשו באודיו שיש לכם זכויות עליו, למשל טרק חינמי מה-Creator Store או אודיו שהעליתם בעצמכם. שימו Sound עם ה-ID הזה ב-SoundService, סמנו Looped, קראו ל-:Play() שלו מ-MainMenu כשהתפריט מופיע, ול-:Stop() ב-handler של Play. סאונד שמופעל מ-LocalScript שומע רק השחקן הזה, כל עוד SoundService.RespectFilteringEnabled מופעל, והוא מופעל כברירת מחדל.
אפשר לקחת תפריט ראשי ממודל חינמי?
אפשר, אבל קודם קראו את הסקריפטים שלו. Roblox מזהירה שמודלים מה-Creator Store עלולים להכיל סקריפטים עם דלת אחורית, שנותנים ליוצרים שלהם גישה למשחק שלכם. תפריט צריך רק את שני הסקריפטים הקצרים מהמדריך הזה.
מקורות וקריאה נוספת
- Roblox Engine API: Players (באנגלית). CharacterAutoLoads ו-RespawnTime
- Roblox Engine API: Player (באנגלית). LoadCharacterAsync, סדר הטעינה ו-AddReplicationFocus
- Roblox Creator Docs: On-screen UI containers (באנגלית). מתי StarterGui מועתק, שולי מסך וסדר תצוגה
- Roblox Engine API: LayerCollector (באנגלית). ResetOnSpawn
- Roblox Engine API: Camera (באנגלית). Focus, הנקודה שהמצלמה מסתכלת עליה
- Roblox Creator Docs: Customize the camera (באנגלית). שליטה במצלמה מסקריפט דרך CameraType Scriptable
- Roblox Creator Docs: Streaming techniques and conversion (באנגלית). למה לקוח בלי דמות עלול לא לקבל את המפה, ופוקוס שכפול
- Roblox Engine API: GuiButton (באנגלית). Activated ללחיצה, להקשה ולכפתור ג׳ויפד
- Roblox Creator Docs: Loading screens (באנגלית). מסכי טעינה משלכם ב-ReplicatedFirst
- Roblox Creator Docs: Vulnerabilities from third-party assets (באנגלית). סקריפטים עם דלת אחורית במודלים חינמיים
איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.