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

איך ליצור תפריט ראשי ב-Roblox Studio

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

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

בקצרה

כבו את 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 שניות).
בעמוד הזה
  1. איך זה עובד
  2. 1. הכנה
  3. 2. סקריפט השרת
  4. 3. סקריפט התפריט
  5. מה השרת מחליט
  6. 4. עיצוב
  7. 5. בדיקה
  8. עם מערכות אחרות
  9. למה תפריטים של אחרים נשברים
  10. Common errors
  11. עם RoCode
  12. שאלות נפוצות
  13. מקורות וקריאה נוספת

איך תפריט ראשי עובד

איורהתפריט המוכן במשחק שרץ, ההמתנה לשרת מואצת: Play מחשיך את המסך, השרת מוליד את הדמות, והמצלמה חוזרת אליה.

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

ממה התפריט מורכב
חלקאיפה הוא נמצאמה הוא עושה
MenuService ScriptServerScriptServiceמכבה לידה אוטומטית, יוצר את PlayRequest, מוליד שחקן שלחץ על Play ומחזיר שחקנים לחיים אחרי מוות או נפילה.
MainMenu LocalScriptStarterPlayerScriptsבונה את הכותרת, כפתור ה-Play וההאפלה, מוביל את שוט המצלמה, מבקש מהשרת דמות ומחזיר את המצלמה.
PlayRequest RemoteEventReplicatedStorage (נוצר על ידי MenuService, אל תוסיפו ביד)מעביר לשרת הודעה אחת: השחקן הזה לחץ על Play. אין בה שום ערכים.
MenuCamera PartWorkspace (אתם מציבים)איפה עומדת מצלמת התפריט ולאן היא מסתכלת.
CharacterAutoLoadsמאפיין של שירות Playersכבוי, ולכן אף אחד לא נולד עד שהשרת קורא ל-LoadCharacterAsync.
ה-Explorer כשהתפריט מוכן. PlayRequest מופיע כשהמשחק עולה: MenuService יוצר אותו, ולכן אל תוסיפו אותו ביד.
Workspace
  MenuCamera Part new
ReplicatedStorage
  PlayRequest RemoteEvent new
ServerScriptService
  MenuService Script new
StarterPlayer
  StarterPlayerScripts
    MainMenu LocalScript new

שלב 1: כבו לידה אוטומטית והציבו את מצלמת התפריט

  1. ב-Explorer סמנו את Players. בחלון Properties הסירו את הסימון מ-CharacterAutoLoads. גם MenuService מכבה אותו, אבל הסימון מבטיח שאף אחד לא ייוולד ברגע שלפני שהסקריפט עולה.
  2. רחפו מעל Workspace, לחצו על כפתור ה-+ והכניסו Part. שנו את השם שלו ל-MenuCamera (אותיות גדולות וקטנות בשמות חשובות) והשאירו אותו ישירות ב-Workspace, לא בתוך תיקייה או מודל.
  3. ב-Properties שלו סמנו Anchored, הסירו את הסימון מ-CanCollide וקבעו Transparency ל-1. העיגון חשוב: Part לא מעוגן שלא מתנגש בשום דבר נופל דרך המפה, ו-Roblox מוחקת Parts שנפלו מתחת ל-Workspace.FallenPartsDestroyHeight.
  4. הזיזו וסובבו את ה-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
-- 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 של התמונה. קבעו לו BackgroundTransparency 1 ו-ScaleType Fit, כדי שישמור על הפרופורציות.
  • רקע מטושטש. צרו BlurEffect ב-MainMenu ושימו אותו ב-workspace.CurrentCamera. Roblox ממליצה לעשות כך לתפריטים: אפקט מתחת למצלמה רואה רק השחקן הזה. ה-Size שלו הוא רדיוס הטשטוש בפיקסלים. השמידו אותו ב-handler של Play, ליד gui:Destroy().
  • צבע. הוסיפו לכפתור UIGradient או UIStroke למסגרת. השאירו לטקסט TextScaled, כדי שייכנס במסכים קטנים.
  • עוד כפתורים. שימו כפתורים בתוך Frame עם UIListLayout ו-Padding קטן, ותנו לכל אחד handler של Activated ו-UISizeConstraint משלו. כפתור Settings או Help יכול לפתוח חלונית בלקוח בלבד. כפתור Shop יכול לפתוח חלון מהמדריך לחנות, שבו הקניות עדיין עוברות בשרת.

שלב 5: בדקו

  1. פתחו את חלון ה-Output (תפריט Window, ואז Output) ולחצו על Play. המסך מאיר על הכותרת ועל כפתור ה-Play שלכם מעל שוט ה-MenuCamera, ורשימת השחקנים והתרמיל מוסתרים. ב-Explorer, ב-Workspace אין מודל עם השם שלכם: עוד אין לכם דמות.
  2. לחצו על כפתור ה-Play. מופיע עליו "Loading...", המסך מחשיך, ואז מאיר מאחורי הדמות שלכם עם המצלמה הרגילה, ורשימת השחקנים חוזרת. ב-Players, השם שלכם, PlayerGui כבר אין לא MainMenu ולא MenuFade.
  3. אפסו את הדמות דרך תפריט המשחק. אתם חוזרים לחיים אחרי בערך 5 שניות, והתפריט לא חוזר.
  4. רדו או קפצו מקצה המפה. כשהדמות תיפול מהעולם, תחזרו לחיים אחרי בערך 5 שניות.
  5. בדקו את מסך הטלפון ב-Device Simulator ב-Studio (נכון לזמן הכתיבה זו בטא: הפעילו את New Device Simulator ב-File, Beta Features והפעילו מחדש את Studio). בטלפון קטן כפתור ה-Play נשאר לא קטן מ-160 על 56 פיקסלים, ואפשר לפגוע בו באצבע.
  6. בדקו ג׳ויפד ב-Controller Emulator (Controller בלשונית Emulation) בזמן בדיקת משחק. לחצו על כפתור כלשהו בג׳ויפד המדומה: Play מסומן, ולחיצה על A מתחילה את המשחק. אם Play לא מסומן, לחצו בג׳ויפד על Select, שמסמן את הכפתור כל עוד GuiService.AutoSelectGuiEnabled מופעל, ואז על A.
  7. כש-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.

למה סקריפטי תפריט מועתקים נשברים

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

תבניות תפריט נפוצות והבעיות שלהן
תבניתבעיהבמדריך הזה
MouseButton1Click על כפתור ה-PlayRoblox מתארת אותו ללחיצה בכפתור השמאלי של העכבר. Activated הוא האירוע שמתואר ללחיצה, להקשה ולכפתור ג׳ויפד.Activated, ו-Play מסומן לג׳ויפדים
ScreenGui של התפריט ב-StarterGui עם ResetOnSpawn מופעלRoblox נותנת לשחקן עותק טרי בכל לידה, ולכן התפריט חוזר אחרי כל מוותResetOnSpawn כבוי, והתפריט מושמד אחרי Play
הדמות נולדה והוקפאה מאחורי התפריט, למשל עם WalkSpeed 0הדמות נמצאת בעולם: אחרים רואים אותה, דוחפים ותוקפים אותהאין דמות עד Play
player:LoadCharacter()Roblox מציינת שהוא הוחלף ב-LoadCharacterAsyncLoadCharacterAsync בתוך pcall
המצלמה נשארה Scriptable אחרי Playהמצלמה נתקעת על שוט התפריטלנתק את פונקציית המצלמה, לקבוע את CameraType ל-Custom ואת CameraSubject ל-Humanoid
workspace.MenuPart נקרא מידעם סטרימינג ה-Part עלול עוד לא להגיע ללקוח, והסקריפט נופל עם שגיאהפוקוס שכפול ליד MenuCamera שנוסף בשרת, ו-WaitForChild עם מגבלה של 5 שניות ותצוגת גיבוי
לולאות repeat wait() until למצלמהRoblox מסמנת את wait() כמיושן, ו-task.wait() החליף אותוBindToRenderStep למצלמה, task.wait בשאר המקומות
לידה מחדש רק לפי Humanoid.Diedכש-CharacterAutoLoads כבוי, שחקן שנפל מהמפה עלול לא לחזור לחיים אף פעם: הנפילה יכולה להסיר את הדמות מ-Workspace, ו-Died נורה רק ב-Workspaceלהחזיר לחיים גם כשהדמות עוזבת את ה-Workspace
תפריט ממודל חינמיRoblox מזהירה שמודלים מה-Creator Store עלולים להכיל סקריפטים עם דלת אחוריתשני סקריפטים קצרים שאפשר לקרוא שורה אחר שורה

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

פתחו את חלון ה-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, תחשיך את המסך, תוליד את השחקן מהשרת ותחזיר את המצלמה הרגילה. זה צריך לעבוד בטלפונים ועם ג׳ויפד.

RoCode עושה
  • יכול קודם לבדוק את הפלייס שלכם עם 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 עלולים להכיל סקריפטים עם דלת אחורית, שנותנים ליוצרים שלהם גישה למשחק שלכם. תפריט צריך רק את שני הסקריפטים הקצרים מהמדריך הזה.

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

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

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

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