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

איך ליצור מסך טעינה משלכם ב-Roblox Studio

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

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

בקצרה

שימו LocalScript ב-ReplicatedFirst. הוא רץ לפני שכל השאר מגיע לשחקן. בתוכו צרו ScreenGui עם IgnoreGuiInset מופעל, שימו אותו ב-PlayerGui של השחקן וקראו ל-ReplicatedFirst:RemoveDefaultLoadingScreen(). אחר כך חכו ל-game.Loaded, טענו מראש את מה שחשוב דרך ContentProvider:PreloadAsync(), והשמידו את ה-ScreenGui כשתסיימו.

  • רק LocalScript ב-ReplicatedFirst רץ מוקדם מספיק. ב-StarterGui או ב-StarterPlayerScripts הוא מתחיל כשרוב המשחק כבר נטען, והמסך מופיע מאוחר מדי.
  • בנו את המסך בקוד, או שמרו ScreenGui מוכן משלכם בתוך הסקריפט. כל מה שנמצא ב-StarterGui עוד לא הגיע כשהסקריפט מתחיל.
  • אל תטענו מראש את כל המשחק אובייקט אחר אובייקט. טענו מראש בקבוצות, או רק את התמונות והסאונדים שהשחקן רואה ראשונים.
בעמוד הזה
  1. איך זה עובד
  2. 1. הסקריפט
  3. 2. עיצוב משלכם
  4. 3. בדיקה
  5. Common errors
  6. With RoCode
  7. שאלות נפוצות
  8. מקורות וקריאה נוספת

איך טעינה עובדת ב-Roblox

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

במה סקריפט מסך הטעינה משתמש
רכיבמה הוא עושה
ReplicatedFirstה-LocalScripts שלו מגיעים לשחקן ראשונים ורצים לפני ששאר המשחק נטען.
ReplicatedFirst:RemoveDefaultLoadingScreen()מסיר את מסך הטעינה הרגיל של Roblox, כדי שהשחקנים יראו את שלכם.
game:IsLoaded() ו-game.Loadedמודיעים מתי העותק הראשון של המשחק הגיע.
ContentProvider:PreloadAsync()מחכה עד שהתמונות, ה-Meshes והסאונדים של האובייקטים שהועברו יורדו, כדי שהמשחק לא יופיע עם טקסטורות אפורות.
ScreenGui עם IgnoreGuiInsetהמסך עצמו, שמכסה את כל החלון, כולל הפס למעלה.

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

שלב 1: הוסיפו את סקריפט מסך הטעינה

  1. ב-Explorer רחפו מעל ReplicatedFirst, לחצו על + והכניסו LocalScript.
  2. שנו את השם שלו ל-LoadingScreen והדביקו את הקוד שלמטה.
  3. החליפו את TITLE בשם המשחק שלכם ולחצו על Play.
LocalScript בתוך ReplicatedFirst בשם LoadingScreen
-- LocalScript ב-ReplicatedFirst בשם LoadingScreen.
-- מחליף את מסך הטעינה הרגיל של Roblox בשלכם: כותרת, פס התקדמות,
-- כפתור Skip לחיבור איטי והיעלמות הדרגתית כשהמשחק מוכן.
local ContentProvider = game:GetService("ContentProvider")
local Players = game:GetService("Players")
local ReplicatedFirst = game:GetService("ReplicatedFirst")
local TweenService = game:GetService("TweenService")

local TITLE = "My Game"
local MIN_SECONDS = 2 -- להציג את המסך לפחות כל כך הרבה זמן, כדי שלא יהבהב
local SKIP_AFTER_SECONDS = 8 -- להציג את כפתור ה-Skip אם הטעינה לוקחת יותר זמן
local STEPS = 20 -- כמה פעמים הפס זז בזמן שה-Assets נטענים מראש

local player = Players.LocalPlayer
local playerGui = player:WaitForChild("PlayerGui") :: PlayerGui

-- המסך נבנה בקוד, ולכן הוא קיים לפני שכל דבר אחר במשחק נטען
local gui = Instance.new("ScreenGui")
gui.Name = "LoadingScreen"
gui.IgnoreGuiInset = true -- לכסות גם את הפס בראש המסך
gui.DisplayOrder = 100 -- מעל כל שאר ה-ScreenGui
gui.ResetOnSpawn = false

local background = Instance.new("Frame")
background.Size = UDim2.fromScale(1, 1)
background.BackgroundColor3 = Color3.fromRGB(20, 16, 32)
background.BorderSizePixel = 0
background.Parent = gui

local title = Instance.new("TextLabel")
title.Text = TITLE
title.Font = Enum.Font.GothamBold
title.TextSize = 42
title.TextColor3 = Color3.new(1, 1, 1)
title.BackgroundTransparency = 1
title.AnchorPoint = Vector2.new(0.5, 0.5)
title.Position = UDim2.fromScale(0.5, 0.42)
title.Size = UDim2.fromOffset(600, 60)
title.Parent = background

local barBack = Instance.new("Frame")
barBack.AnchorPoint = Vector2.new(0.5, 0.5)
barBack.Position = UDim2.fromScale(0.5, 0.54)
barBack.Size = UDim2.fromOffset(320, 10)
barBack.BackgroundColor3 = Color3.fromRGB(60, 52, 84)
barBack.BorderSizePixel = 0
barBack.Parent = background

local barFill = Instance.new("Frame")
barFill.Size = UDim2.fromScale(0, 1)
barFill.BackgroundColor3 = Color3.fromRGB(160, 120, 255)
barFill.BorderSizePixel = 0
barFill.Parent = barBack

local status = Instance.new("TextLabel")
status.Text = "Loading..."
status.Font = Enum.Font.Gotham
status.TextSize = 18
status.TextColor3 = Color3.fromRGB(200, 190, 230)
status.BackgroundTransparency = 1
status.AnchorPoint = Vector2.new(0.5, 0)
status.Position = UDim2.fromScale(0.5, 0.57)
status.Size = UDim2.fromOffset(320, 24)
status.Parent = background

local skip = Instance.new("TextButton")
skip.Text = "Skip"
skip.Font = Enum.Font.GothamBold
skip.TextSize = 18
skip.TextColor3 = Color3.new(1, 1, 1)
skip.BackgroundColor3 = Color3.fromRGB(60, 52, 84)
skip.AnchorPoint = Vector2.new(0.5, 0)
skip.Position = UDim2.fromScale(0.5, 0.64)
skip.Size = UDim2.fromOffset(120, 36)
skip.Visible = false
skip.Parent = background

gui.Parent = playerGui
ReplicatedFirst:RemoveDefaultLoadingScreen()

local started = os.clock()
local skipped = false
skip.Activated:Connect(function()
	skipped = true
end)
task.delay(SKIP_AFTER_SECONDS, function()
	skip.Visible = true
end)

-- מחכים עד שהעותק הראשון של המשחק יגיע מהשרת
if not game:IsLoaded() then
	game.Loaded:Wait()
end

-- טוענים מראש את התמונות, ה-Meshes והסאונדים ב-Workspace ב-STEPS קבוצות, ומזיזים את הפס אחרי כל אחת
local items = workspace:GetDescendants()
local perStep = math.max(1, math.ceil(#items / STEPS))
for first = 1, #items, perStep do
	if skipped then
		break
	end
	ContentProvider:PreloadAsync(table.move(items, first, math.min(first + perStep - 1, #items), 1, {}))
	local done = math.min(first + perStep - 1, #items) / #items
	barFill.Size = UDim2.fromScale(done, 1)
	status.Text = string.format("Loading %d%%", math.floor(done * 100))
end

local shownFor = os.clock() - started
if shownFor < MIN_SECONDS and not skipped then
	task.wait(MIN_SECONDS - shownFor)
end

-- מסתירים הכול בהדרגה, ואז מוחקים את המסך
local fade = TweenInfo.new(0.5)
for _, object in gui:GetDescendants() do
	if object:IsA("TextLabel") or object:IsA("TextButton") then
		TweenService:Create(object, fade, { TextTransparency = 1, BackgroundTransparency = 1 }):Play()
	elseif object:IsA("Frame") then
		TweenService:Create(object, fade, { BackgroundTransparency = 1 }):Play()
	end
end
task.wait(0.5)
gui:Destroy()

PreloadAsync מחכה לכל Asset באובייקטים שהועברו. אם מעבירים את כל ה-Workspace בקריאה אחת, הפס יעמוד על 0% עד הסוף ממש, ולכן הסקריפט מחלק אותו ל-STEPS קבוצות ומזיז את הפס אחרי כל אחת.

המסך מושם ישירות ב-PlayerGui, כי כשהסקריפט הזה רץ, StarterGui עוד לא הועתק לשחקן. ResetOnSpawn כבוי, כדי שהמסך ישרוד את הופעת הדמות שמתחתיו.

שלב 2: השתמשו במסך שציירתם ב-Studio

לבנות את המסך בקוד זה מהיר, אבל אולי תרצו לצייר אותו ב-Studio עם תמונות ופריסה משלכם. צרו אותו כ-ScreenGui ב-StarterGui, קראו לו LoadingScreen, ואז גררו אותו אל ה-LocalScript בשם LoadingScreen ב-ReplicatedFirst, כדי שיהפוך לילד של הסקריפט ויגיע יחד איתו. השתמשו בסקריפט הקצר הזה במקום הסקריפט משלב 1:

LocalScript בתוך ReplicatedFirst בשם LoadingScreen
-- LocalScript ב-ReplicatedFirst בשם LoadingScreen, ובתוכו ה-ScreenGui שלכם בשם
-- LoadingScreen (ציירו אותו ב-StarterGui, ואז גררו אותו אל הסקריפט הזה).
local Players = game:GetService("Players")
local ReplicatedFirst = game:GetService("ReplicatedFirst")

local MIN_SECONDS = 2

local playerGui = Players.LocalPlayer:WaitForChild("PlayerGui") :: PlayerGui
local gui = (script:WaitForChild("LoadingScreen") :: ScreenGui):Clone()
gui.IgnoreGuiInset = true
gui.DisplayOrder = 100
gui.ResetOnSpawn = false
gui.Parent = playerGui
ReplicatedFirst:RemoveDefaultLoadingScreen()

local started = os.clock()
if not game:IsLoaded() then
	game.Loaded:Wait()
end
local shownFor = os.clock() - started
if shownFor < MIN_SECONDS then
	task.wait(MIN_SECONDS - shownFor)
end
gui:Destroy()

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

שלב 3: בדקו

  1. פתחו את חלון ה-Output (תפריט Window, ואז Output) ולחצו על Play. המסך שלכם אמור להופיע, הפס אמור להתמלא, ואחרי בערך MIN_SECONDS המסך ייעלם בהדרגה.
  2. ל-Studio כבר יש את כל ה-Assets במחשב שלכם, ולכן הפס מתמלא כמעט מיד. קבעו את MIN_SECONDS ל-8 והפעילו שוב, כדי לבדוק שכפתור ה-Skip מופיע ועובד.
  3. פרסמו את המשחק והיכנסו מאפליקציית Roblox בטלפון, כדי לראות את המסך כמו שהשחקנים יראו אותו.

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

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

עדיין מוצג מסך הטעינה הרגיל של Roblox

הסקריפט הוא לא LocalScript ב-ReplicatedFirst, או שהוא נופל עם שגיאה לפני הקריאה ל-RemoveDefaultLoadingScreen(). חפשו בחלון ה-Output שורה אדומה עם השם LoadingScreen.

המסך שלי מופיע מאוחר, כשהמשחק כבר גלוי

הסקריפט נמצא ב-StarterGui או ב-StarterPlayerScripts. העבירו אותו ל-ReplicatedFirst.

Infinite yield possible on 'ReplicatedFirst.LoadingScreen:WaitForChild("LoadingScreen")'

הסקריפט משלב 2 לא מוצא את ה-ScreenGui שלכם. הוא חייב להיות ילד של הסקריפט ולהיקרא בדיוק LoadingScreen.

המסך אף פעם לא נעלם

משהו אחרי game.Loaded נפל עם שגיאה או לא הסתיים אף פעם. בדקו את ה-Output; כפתור ה-Skip בשלב 1 נועד גם לכך שהשחקן אף פעם לא ייתקע.

רואים רווח בראש המסך

קבעו את IgnoreGuiInset ל-true ב-ScreenGui, כמו ששני הסקריפטים עושים.

בנו את זה עם RoCode

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

אתם כותבים

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

RoCode עושה
  • כותב LocalScript ב-ReplicatedFirst ובונה את ה-ScreenGui
  • בוחר את הצבעים והגופן שאתם מבקשים, ויכול להשתמש ב-ScreenGui שכבר ציירתם
  • בודק את הסקריפטים שכתב בתוך Studio לפני שהוא מסיים

ללחוץ על Play ולבדוק שהמסך נראה טוב בטלפון ובמחשב עדיין צריכים אתם. איך RoCode מתחבר ל-Studio.

שאלות נפוצות

איפה שמים את סקריפט מסך הטעינה ב-Roblox?

ב-ReplicatedFirst, כ-LocalScript. זה המקום היחיד שבו סקריפט רץ לפני ששאר המשחק נטען.

איך מסירים את מסך הטעינה הרגיל של Roblox?

קראו ל-game:GetService("ReplicatedFirst"):RemoveDefaultLoadingScreen() מ-LocalScript ב-ReplicatedFirst, כשהמסך שלכם כבר מוצג.

מסך טעינה מאיץ את טעינת המשחק?

לא. הוא מכסה את ההמתנה. כדי לקצר אותה, השתמשו בפחות תמונות, Meshes וסאונדים ליד נקודת ההופעה, ועשו אותם קלים יותר.

למה ב-Studio מסך הטעינה שלי מוצג רק לרגע?

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

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

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

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

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