מדריך · יסודות הסקריפטים

איך כותבים סקריפטים ב-Roblox Studio: מדריך למתחילים

כתיבת סקריפטים, או תכנות, ב-Roblox Studio פירושה לכתוב ב-Luau, הגרסה של Roblox לשפת Lua, בסקריפטים שאתם מוסיפים לפלייס. המדריך הזה מתחיל מ-Baseplate ריק: תפתחו את חלון ה-Output, תכתבו סקריפט ראשון, תשנו Part מתוך קוד, תגיבו לשחקן שעלה על משטח, ותנסו LocalScript, ובדרך תבינו משתנים, פונקציות, תנאים, לולאות ואירועים.

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

בקצרה

כדי לכתוב סקריפט ב-Roblox Studio, רחפו מעל ServerScriptService ב-Explorer, לחצו על + והכניסו Script. Studio יפתח אותו ב-Script Editor. כתבו Luau, למשל print("Hello"), לחצו על Play (F5) וקראו את התוצאה בחלון ה-Output (תפריט Window או הלשונית Script). Script רץ בשרת ומשנה הכול לכולם; LocalScript ב-StarterPlayerScripts רץ במכשיר של שחקן אחד.

  • קודם למדו ארבעה רעיונות: משתנים (local coins = 3), פונקציות (local function name() ... end), תנאי if ואירועים (part.Touched:Connect(...)). ארבעת הסקריפטים במדריך הזה בנויים מהם, ועוד לולאות וטבלאות.
  • השתמשו ב-task.wait(), לא ב-wait(). התיעוד של Roblox מסמן את wait() הגלובלי כמיושן וכמוחלף ב-task.wait().
  • בהגדרות התצוגה של חלון ה-Output הפעילו את Show Context, כדי שכל שורה תראה אם היא הגיעה מ-Server או מ-Client.
בעמוד הזה
  1. לפני שמתחילים
  2. 1. הסקריפט הראשון
  3. 2. לשנות Part
  4. 3. אירועים
  5. 4. ה-LocalScript הראשון
  6. 5. בדיקה
  7. איפה שמים סקריפטים
  8. קריאת שגיאות
  9. מדריכים ישנים
  10. תרגול
  11. מה הלאה
  12. Common errors
  13. עם RoCode
  14. שאלות נפוצות
  15. מקורות וקריאה נוספת

לפני שמתחילים: Studio, Baseplate וחלון ה-Output

איורארבעה סקריפטים בבדיקת משחק אחת: ה-Part בשם ColourChanger מחליף צבע כל שנייה, צעד על ה-Pad הופך אותו לצהוב ל-2 שניות לכל השחקנים וכותב את השם שלכם ב-Output, ו-E הופך את ה-Pad לשקוף יותר רק במסך הזה.

צריך Roblox Studio וחשבון Roblox, ולא יותר: לא עורך קוד ולא פלאגין. כל סקריפט במדריך הזה מוקלד ב-Script Editor של Studio עצמו.

  1. התקינו את Roblox Studio, האפליקציה החינמית של Roblox ל-Windows ול-Mac, והיכנסו עם חשבון Roblox.
  2. פתחו את Studio. בעמוד הפתיחה יש תבניות: בחרו Baseplate. תקבלו רצפה עם טקסטורת רשת של 4x4 ו-SpawnLocation, המקום שבו האווטאר שלכם מופיע כשמשחקים.
  3. אם החלונות Explorer ו-Properties לא גלויים, פתחו אותם מתפריט Window או מהלשונית Home. Explorer מפרט את כל האובייקטים בפלייס; Properties מציג את ההגדרות של האובייקט המסומן.
  4. פתחו את ה-Output מתפריט Window או מהלשונית Script. כאן מופיעות ההודעות והשגיאות של הסקריפטים שלכם.
  5. בהגדרות התצוגה של חלון ה-Output הפעילו את Show Context, שמסמן כל הודעה כ-Client או Server, ואת Show Source, שמראה את הסקריפט ואת מספר השורה שממנה היא הגיעה.
ארבעת הסקריפטים שתכתבו
סקריפטסוגאיפה הוא נמצאמה הוא מלמד
FirstScriptScriptServerScriptServiceמשתנים, פונקציה, תנאי if, לולאות וטבלה
ColourChangerScriptבתוך Part ב-Workspaceשינוי מאפיינים, script.Parent ולולאה עם המתנה
TouchPadScriptבתוך Part בשם Padאירועים, מציאת השחקן שנגע ב-Part, ו-debounce
MyFirstLocalScriptLocalScriptStarterPlayerScripts, בתוך StarterPlayerקוד במכשיר של שחקן אחד, לחיצות מקשים ומה נשאר במכשיר הזה
ה-Explorer בסוף (רק האובייקטים של המדריך הזה)
Workspace
  Baseplate Part
  SpawnLocation SpawnLocation
  Part Part new
    ColourChanger Script new
  Pad Part new
    TouchPad Script new
ServerScriptService
  FirstScript Script new
StarterPlayer
  StarterPlayerScripts
    MyFirstLocalScript LocalScript new

שלב 1: כתבו את הסקריפט הראשון

  1. ב-Explorer רחפו מעל ServerScriptService, לחצו על + ובחרו Script (קיצור Ctrl+I, או ⌘I ב-Mac). Studio ייצור סקריפט ויפתח אותו ב-Script Editor.
  2. לחצו על הסקריפט החדש בכפתור הימני, בחרו Rename וקראו לו FirstScript. השם לא משנה את מה שהסקריפט עושה, אבל אומר איזה סקריפט הדפיס מה.
  3. סקריפטים חדשים מתחילים בשורה אחת, print("Hello world!"). מחקו אותה והדביקו את הקוד שלמטה.
  4. לחצו על Play (F5), כשברשימה משמאלו נבחר Test. Studio יפעיל בדיקת משחק וישים את האווטאר על ה-SpawnLocation.
  5. קראו את השורות ב-Output, ואז לחצו על Stop (Shift+F5). Stop גם מחזיר את כל האובייקטים למצב שלפני הלחיצה על Play, ולכן כל מה שהזזתם או צבעתם מחדש בזמן המשחק יחזור.
Script בתוך ServerScriptService בשם FirstScript
-- Script ב-ServerScriptService בשם FirstScript.
-- ה-Luau הראשון שלכם: משתנים, פונקציה, תנאי if, לולאה וטבלה.
-- לחצו על Play (F5) וקראו את התוצאה בחלון ה-Output.

-- משתנה הוא שם ששומר ערך
local gameName = "Coin Run"
local coinsToWin = 3

-- פונקציה היא בלוק קוד עם שם, שאפשר להריץ כמה פעמים שרוצים.
-- name ו-goal הם הפרמטרים שלה; return מחזיר ערך למי שקרא לה.
local function describe(name: string, goal: number): string
	return `{name}: collect {goal} coins to win`
end

print(describe(gameName, coinsToWin)) --> Coin Run: collect 3 coins to win

-- תנאי if מריץ קוד רק כשהתנאי אמת
if coinsToWin > 5 then
	print("That is a long game")
elseif coinsToWin > 1 then
	print("That is a short game")
else
	print("One coin and you win")
end

-- לולאת for חוזרת על קוד מספר פעמים נתון
for count = 1, coinsToWin do
	print("Coin number", count)
end

-- טבלה שומרת רשימת ערכים; הלולאה הזו עוברת עליהם לפי הסדר
local colours = { "Red", "Green", "Blue" }
for position, colour in colours do
	print(position, colour) --> 1 Red, אחר כך 2 Green, אחר כך 3 Blue
end

כל מה שאחרי -- בשורה הוא הערה: Luau מדלג עליה, ולכן אפשר להשאיר לעצמכם הערות. הערות --> מראות מה השורה מדפיסה.

ה-Output אמור להציג את שמונה השורות האלה, מעורבות בהודעות של Studio עצמו. כש-print מקבל כמה ערכים, הוא שם ביניהם רווח. עם Show Context ו-Show Source מופעלים, כל שורה מסומנת גם ב-Server וב-FirstScript עם מספר שורה.

Output (צפוי)
Coin Run: collect 3 coins to win
That is a short game
Coin number 1
Coin number 2
Coin number 3
1 Red
2 Green
3 Blue

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

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

מה עושה כל חלק ב-FirstScript
קודרעיוןמה זה אומר
local gameName = "Coin Run"משתנהשם ששומר ערך. local אומר שרק הסקריפט הזה, או הבלוק שבו הוא נמצא, יכול להשתמש בו. טקסט במרכאות הוא מחרוזת; 3 הוא מספר. השמות רגישים לאותיות גדולות וקטנות, ולכן coinsToWin ו-CoinsToWin הם שני משתנים שונים.
local function describe(name: string, goal: number): stringפונקציהבלוק קוד עם שם, שאפשר להריץ כמה פעמים שרוצים. name ו-goal הם הפרמטרים שלה: ערכים שמועברים בכל קריאה. : string ו-: number הן הערות טיפוסים לא חובה. Luau משתמש בהן כדי להזהיר על שגיאות ב-Script Editor; בלעדיהן הקוד עובד אותו דבר.
returnערך מוחזרמחזיר ערך לקוד שקרא לפונקציה. print(describe(gameName, coinsToWin)) מדפיס את מה ש-describe מחזיר.
`{name}: collect {goal} coins to win`אינטרפולציה של מחרוזותטקסט בגרשיים הפוכים יכול להכיל ערכים: Luau מחליף את {name} ואת {goal} בערכים הנוכחיים שלהם.
if, elseif, else, endתנאי ifLuau בודק תנאים מלמעלה למטה ומריץ רק את הראשון שהוא אמת. coinsToWin שווה 3, זה לא יותר מ-5, אבל יותר מ-1, ולכן מודפס רק "That is a short game".
for count = 1, coinsToWin doלולאת for מספריתמריצה את הקוד שבפנים פעם אחת לכל מספר מ-1 עד coinsToWin, כש-count שווה 1, אחר כך 2, אחר כך 3.
{ "Red", "Green", "Blue" } ו-for position, colour in colours doטבלה ולולאהטבלה כרשימה, Luau קורא לזה מערך. המיקומים מתחילים מ-1, לא מ-0. הלולאה עוברת על כל איבר ונותנת את המיקום שלו ואת הערך.

כל בלוק שנפתח במילה function, if, for או while נסגר במילה end. end אחד חסר מונע מכל הסקריפט לרוץ; הפרק קריאת שגיאות מראה איזו הודעה תקבלו.

שלב 2: שנו Part מתוך סקריפט

סקריפטים נעשים שימושיים כשהם משנים משהו בעולם. ההגדרות שאתם רואים בחלון Properties, למשל Color, Transparency או Anchored של Part, הן מאפיינים, וגם סקריפט יכול לקבוע אותן.

  1. בלשונית Home לחצו על Part. Studio יוסיף בלוק ל-Workspace. השם שלו לא חשוב.
  2. ב-Explorer רחפו מעל ה-Part החדש, לחצו על + והכניסו Script. שנו את השם שלו ל-ColourChanger והחליפו את התוכן בקוד שלמטה.
  3. לחצו על Play. ה-Part נעשה אדום, אחר כך כחול, אחר כך ירוק, מתחלף פעם בשנייה, ומתחיל מחדש.
Script בתוך כל Part ב-Workspace בשם ColourChanger
-- Script בתוך Part ב-Workspace, בשם ColourChanger.
-- סקריפטים משנים את אותם מאפיינים שרואים בחלון Properties.
-- הזה נותן ל-Part שלו צבע חדש כל שנייה, לכל השחקנים.

local part = script.Parent :: BasePart -- ה-Part שבתוכו נמצא הסקריפט הזה

local colours = {
	Color3.fromRGB(255, 85, 85), -- אדום
	Color3.fromRGB(85, 170, 255), -- כחול
	Color3.fromRGB(85, 255, 127), -- ירוק
}

part.Anchored = true -- Part מעוגן נשאר במקום שבו שמתם אותו

local index = 1
while true do
	part.Color = colours[index]
	index = index % #colours + 1 -- 1, 2, 3, ואז שוב 1
	task.wait(1) -- הפסקה של שנייה אחת (wait() הישן מיושן)
end
  • script.Parent הוא האובייקט שבתוכו נמצא הסקריפט, כאן ה-Part. גררו את הסקריפט ל-Part אחר, והוא ישנה את האחר.
  • :: BasePart היא המרת טיפוס. היא אומרת ל-Script Editor שההורה הוא Part, כדי לבדוק את המאפיינים שבשימוש. Luau משתמש בטיפוסים רק לאזהרות ולהצעות, ולכן ההמרה לא משנה את מה שהשורה עושה.
  • part.Color ו-part.Anchored הם אותם מאפיינים כמו בחלון Properties, עם אותם שמות. Roblox משתמשת באיות אמריקאי, ולכן המאפיין נקרא Color, למרות שהסקריפט נקרא ColourChanger.
  • Anchored = true מחזיק את ה-Part במקום: התיעוד של Roblox אומר ש-Part מעוגן אף פעם לא זז בגלל כבידה, התנגשויות או פיזיקה אחרת.
  • colours[index] קורא איבר אחד מהרשימה. #colours הוא אורך הרשימה, 3, ו-% נותן את השארית של חילוק, ולכן index % #colours + 1 סופר 1, 2, 3, 1, 2, 3.
  • while true do חוזר בלי סוף, ולכן ה-task.wait(1) שבפנים כל כך חשוב. התיעוד של Roblox אומר תמיד לשים השהיה כמו task.wait() בלולאה אינסופית: בלעדיה המשחק נתקע, ו-Studio קורס.

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

שלב 3: הגיבו לשחקן דרך אירוע

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

  1. הכניסו עוד Part ושנו את השם שלו בדיוק ל-Pad, עם P גדולה. השאירו אותו ישירות ב-Workspace, לא בתיקייה ולא במודל, כי ה-LocalScript בשלב 4 מחפש אותו שם.
  2. עשו אותו משטח שטוח שאפשר לעמוד עליו, למשל קבעו Size ל-6, 1, 6 בחלון Properties. הציבו אותו על הרצפה ליד ה-SpawnLocation, וסמנו Anchored כדי שלא יזוז.
  3. רחפו מעל ה-Pad, לחצו על +, הכניסו Script, שנו את השם שלו ל-TouchPad והדביקו את הקוד שלמטה.
  4. לחצו על Play ועמדו על המשטח. הוא מצהיב ל-2 שניות, וה-Output מציין את השם שלכם.
Script בתוך Workspace.Pad בשם TouchPad
-- Script בתוך Part ב-Workspace בשם Pad, סקריפט בשם TouchPad.
-- אירועים: כששחקן עולה על המשטח, הוא זוהר בצהוב, וה-Output כותב מי זה היה.
-- Debounce מונע מהקוד לפעול הרבה פעמים בשנייה בזמן שהשחקן עומד עליו.

local Players = game:GetService("Players")

local pad = script.Parent :: BasePart
local COOLDOWN_SECONDS = 2

local normalColour = pad.Color
local busy = false

local function onTouched(otherPart: BasePart)
	if busy then
		return -- עוד רץ זמן ההמתנה מהנגיעה הקודמת
	end
	-- הדמות היא Model שבו נמצא חלק הגוף (או הכובע) שנגע במשטח
	local character = otherPart:FindFirstAncestorOfClass("Model")
	local player = character and Players:GetPlayerFromCharacter(character)
	if not player then
		return -- נגע Part חופשי או NPC, לא שחקן
	end

	busy = true
	print(`{player.Name} stepped on the pad`)
	pad.Color = Color3.fromRGB(255, 220, 0)
	task.wait(COOLDOWN_SECONDS)
	pad.Color = normalColour
	busy = false
end

pad.Touched:Connect(onTouched)
איך TouchPad מגיע מהנגיעה לשחקן
קודמה הוא עושה
pad.Touched:Connect(onTouched)מחבר פונקציה לאירוע Touched של המשטח, ולכן Roblox מריצה את onTouched בכל פעם שמשהו נוגע במשטח, ומעבירה את ה-Part שנגע.
otherPartה-Part שנגע במשטח: כף רגל, רגל, ידית של כובע או כלי ביד של השחקן. זה אף פעם לא השחקן עצמו, ולכן שתי השורות הבאות מבררות למי הוא שייך.
otherPart:FindFirstAncestorOfClass("Model")עולה מה-Part הזה לאב הראשון שהמחלקה שלו היא בדיוק Model, כלומר לדמות. מכיוון ששם המחלקה חייב להתאים בדיוק, הוא מדלג על הכובע (המחלקה Accessory) ועל הכלי ביד (המחלקה Tool).
Players:GetPlayerFromCharacter(character)מחזיר את ה-Player שזו הדמות שלו, או nil אם זו דמות של אף אחד, למשל NPC. ה-character and שלפני מדלג על הקריאה אם לא נמצא מודל, ו-player נשאר nil.
if not player then return endנעצר כאן לכל מה שאינו שחקן. return יוצא מהפונקציה מוקדם.

למה המשטח צריך debounce

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

המשתנה busy הוא ה-debounce. הנגיעה הראשונה קובעת אותו ל-true, וכל נגיעה ב-2 השניות הבאות מגיעה ל-if busy then return end ונעצרת. אחרי task.wait(COOLDOWN_SECONDS) המשטח מחזיר את הצבע, ו-busy שוב הופך ל-false. COOLDOWN_SECONDS כתוב באותיות גדולות, כי זו הגדרה שלא משתנה בזמן המשחק: כך Roblox ממליצה לקרוא לקבועים.

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

שלב 4: ה-LocalScript הראשון ובמה הוא שונה

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

  1. ב-Explorer פתחו את StarterPlayer, רחפו מעל StarterPlayerScripts, לחצו על + והכניסו LocalScript. שנו את השם שלו ל-MyFirstLocalScript והדביקו את הקוד שלמטה.
  2. לחצו על Play. ה-Output יציג Hello, ואת השם שלכם, מסומנים ב-Client.
  3. לחצו על חלון המשחק ועל E. המשטח נעשה שקוף יותר. לחצו שוב על E כדי להחזיר אותו.
  4. בזמן שבדיקת המשחק רצה, לחצו על המתג Client/Server בפקדי הבדיקה של Studio, כדי לעבור לעותק של המשחק בשרת. שם המשטח אטום: השרת לא ידע כלום על השינוי.
LocalScript בתוך StarterPlayerScripts בשם MyFirstLocalScript
-- LocalScript ב-StarterPlayer > StarterPlayerScripts בשם MyFirstLocalScript.
-- LocalScript רץ במכשיר של שחקן אחד. לחצו על E: ה-Pad נעשה שקוף יותר רק
-- במסך שלכם, כי שינוי של Part מכאן לא מגיע לא לשרת ולא לאחרים.

local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")

local player = Players.LocalPlayer
print(`Hello, {player.Name}`) -- מופיע ב-Output מסומן ב-Client

UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessed: boolean)
	if gameProcessed then
		return -- המקש הלך לדבר אחר, למשל להקלדת טקסט בצ׳אט
	end
	if input.KeyCode == Enum.KeyCode.E then
		local pad = workspace:FindFirstChild("Pad")
		if pad and pad:IsA("BasePart") then
			pad.Transparency = if pad.Transparency == 0 then 0.6 else 0
		end
	end
end)
  • Players.LocalPlayer הוא השחקן שהסקריפט רץ במכשיר שלו. Roblox מגדירה אותו רק ל-LocalScript ול-ModuleScript שהם טוענים, ולכן קוד שרת לא יכול להשתמש בו.
  • UserInputService.InputBegan נורה כשהשחקן מתחיל לחיצת מקש, קליק או מגע. gameProcessed שווה true כשהמנוע כבר השתמש בקלט הזה, למשל קליק על כפתור או מקש בשורת הצ׳אט, ולכן הסקריפט מתעלם ממנו.
  • workspace:FindFirstChild("Pad") מחזיר צאצא בשם Pad, או nil אם אין כזה. pad:IsA("BasePart") בודק שזה באמת Part, לפני שהסקריפט משנה את ה-Transparency שלו.
  • if pad.Transparency == 0 then 0.6 else 0 הוא ביטוי if: הוא בוחר אחד משני ערכים. Transparency 0 אומר גלוי לגמרי, 1 בלתי נראה.
  • סקריפט ספרינט על Shift טוב כ-LocalScript שני: הוא מאזין למקש ומשנה את ה-WalkSpeed של הדמות.
Script, LocalScript ו-ModuleScript
סוגאיפה הוא רץלאן השינויים מגיעיםבשביל מהבדרך כלל נמצא ב
Scriptבשרתלכל השחקניםחוקי המשחק: מטבעות, נזק, דלתות, סיבובים, שמירהServerScriptService, או בתוך Part בזמן הלמידה
LocalScriptבמכשיר של שחקן אחדרק למכשיר הזה, חוץ מהתנועה של הדמות שלוקלט, מצלמה, תפריטים במסך, אפקטים לשחקן אחדStarterPlayerScripts או StarterGui
ModuleScriptבצד שקורא לו require()לאותו מקום כמו של הסקריפט שטען אותוקוד משותף לכמה סקריפטיםReplicatedStorage לשני הצדדים, ServerScriptService רק לשרת

מה רמאי יכול לשנות

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

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

שלב 5: בדקו את ארבעת הסקריפטים יחד

  1. נקו את ה-Output עם Ctrl+K (⌘K ב-Mac) ולחצו על Play (F5). ה-Output יציג שמונה שורות של FirstScript מסומנות ב-Server, ואת שורת ה-Hello שלכם מסומנת ב-Client. ה-Part בשם ColourChanger מחליף צבע כל שנייה.
  2. עמדו על המשטח. הוא מצהיב ל-2 שניות, וה-Output מציג פעם אחת את השם שלכם ו-"stepped on the pad". הסתובבו עליו: שורה חדשה מופיעה לא יותר מפעם ב-2 שניות, ולא בכל פעם ש-Touched נורה.
  3. לחצו על E. המשטח נעשה חצי שקוף (Transparency 0.6). לחצו שוב על E, והוא אטום.
  4. לחצו על Stop. ברשימת הבדיקות בחרו Server & Clients, קבעו 2 לקוחות ולחצו על Play (או F7). Studio יפתח חלון שרת ושני חלונות לקוח. בלקוח אחד לחצו על E: המשטח ייעשה שקוף יותר שם, והלקוח השני והשרת יציגו אותו אטום. לחצו על End Session כשתסיימו.
  5. שברו משהו בכוונה. שנו את השם של Pad ל-Pad2 והפעילו את המשחק. צעד על המשטח עדיין הופך אותו לצהוב, כי TouchPad מוצא את ה-Part שלו דרך script.Parent, ולא לפי שם. לחיצה על E עכשיו לא עושה כלום, ואין שגיאה: FindFirstChild("Pad") החזיר nil, והבדיקה if pad and ... דילגה בשקט על השאר. הוסיפו print(pad) בשורה שאחרי FindFirstChild, הפעילו ולחצו על E: ה-Output יציג nil. print כזה הוא הדרך הכי מהירה להבין למה סקריפט לא עושה כלום. עצרו את המשחק, מחקו את שורת ה-print והחזירו ל-Part את השם Pad.

איפה שמים סקריפטים

מהמקום שבו סקריפט נמצא תלוי אם הוא בכלל ירוץ, ו-Studio לא מזהיר אם הוא לא ירוץ אף פעם. לסקריפטים הבאים שלכם:

איפה לשים כל סוג סקריפט
מכלמה לשיםלמה
ServerScriptServiceסקריפטים עם רוב חוקי המשחק: פרסים, סיבובים, שמירההם רצים בשרת, ושום דבר מ-ServerScriptService לא נשלח לשחקנים.
בתוך Part ב-WorkspaceScript ששייך ל-Part אחד, כמו ColourChanger ו-TouchPadבסדר בזמן הלמידה: ה-Part הוא script.Parent. לפרויקטים אמיתיים Roblox ממליצה במקום זה לסמן Parts בתגים (ראו למטה).
StarterPlayerScripts, בתוך StarterPlayerרוב ה-LocalScripts: קלט, מצלמה, אפקטים לשחקן אחדכל שחקן מקבל עותק משלו בכניסה.
StarterGuiLocalScripts בתוך ScreenGui שמנהלים תפריט במסךכל שחקן מקבל עותק משלו של הממשק.
ReplicatedStorageModuleScripts שגם קוד שרת וגם קוד לקוח טועניםשני הצדדים רואים אותו. LocalScript או Script עם הגדרות ברירת מחדל לא ירוץ כאן אף פעם.

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

כשמשהו משתבש: קראו את ה-Output

שגיאות מוצגות ב-Output באדום. כל אחת מתחילה במקום שבו היא קרתה, בשם המלא של הסקריפט ובמספר השורה, ואחר כך אומרת מה לא בסדר. לחצו על השגיאה, ו-Studio יפתח את הסקריפט בשורה הזו. למשל, אם תמחקו את הבדיקה if not player מ-TouchPad, ו-Part חופשי ייפול על המשטח, ה-Output יציג:

Output (דוגמה)
Workspace.Pad.TouchPad:22: attempt to index nil with 'Name'

שגיאות באופן שבו הקוד כתוב, למשל end חסר, נראות עוד לפני שלוחצים על Play: Script Editor מסמן אותן בקו אדום, וחלון Script Analysis (הכפתור Analysis בלשונית Script) מפרט אותן. סקריפט עם שגיאה כזו לא רץ בכלל, גם לא השורות שמעליה.

שלוש שגיאות שכדאי לזהות
הודעהמה זה אומראיך מתקנים
Colour is not a valid member of Part "Workspace.Part"לאובייקט הזה אין שום דבר בשם המדויק הזה. כאן המאפיין נכתב Color.השוו את האיות והאותיות הגדולות לחלון Properties או ל-Explorer. עוד על השגיאה הזו.
attempt to index nil with 'Name'הקוד קרא משהו, כאן .Name, מערך nil. בדוגמה שלמעלה player היה nil, כי Part חופשי נגע במשטח.בררו למה הערך nil, ובדקו אותו עם if לפני השימוש. עוד על השגיאה הזו.
Expected 'end' (to close 'then' at line 2), got <eof>ל-if בשורה 2 אין end תואם. לפונקציה ההודעה אומרת to close 'function', ו-<eof> אומר סוף הקובץ.הוסיפו את ה-end החסר, לפי השורה שבסוגריים, לא לפי האחרונה. לפעמים ההודעה נגמרת במשפט "did you forget to close ... at line N?". זה ניחוש של Luau לפי ההזחה, והוא יכול להצביע על הבלוק הלא נכון, ולכן קודם בדקו את השורה שבסוגריים. עוד על שגיאות תחביר.

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

מה מדריכים ישנים לסקריפטים עושים אחרת

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

תבניות ממדריכים ישנים ומה המדריך הזה עושה במקומן
מדריךבעיההמדריך הזה
עושה הפסקה דרך wait(1)התיעוד של Roblox מסמן את wait() הגלובלי כמיושן ואומר ש-task.wait() החליף אותו.task.wait(1)
מוצא את הדמות דרך otherPart.Parent, כמו בשיעור של Roblox על לבהכשכובע או כלי ביד נוגעים ב-Part, otherPart.Parent הוא Accessory או Tool, לא הדמות, ולכן ה-Humanoid לא נמצא והנגיעה הולכת לאיבוד.FindFirstAncestorOfClass("Model"), ואז GetPlayerFromCharacter
משתמש ב-Touched בלי debounceTouched נורה כמה פעמים ברצף בצעד אחד, ולכן הקוד רץ שוב ושוב.הדגל busy וזמן המתנה
שם LocalScript בתוך Part ב-WorkspaceLocalScript שם אף פעם לא רץ. הוא עובד רק ממקומות ששייכים לשחקן אחד.LocalScript ב-StarterPlayerScripts (למה)
כותב part.Touched:connect(...) או table.getn(list)מדריך השמות של Roblox אומר ש-API ב-camelCase ברובם מיושנים, והתיעוד מפרט רק את Connect. table.getn מיושן לטובת #list.:Connect(...) ו-#list
משנה מטבעות או גורם נזק ב-LocalScriptהשינוי נשאר במכשיר של השחקן הזה, ולכן אף אחד אחר לא רואה אותו, והשרת לא מתחשב בו.חוקי המשחק ב-Script בשרת

תרגול: שלושה שינויים שכדאי לנסות

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

  • שהמשטח ייתן נקודה. הוסיפו את הסקריפט Leaderstats משלב 1 במדריך לטבלת מובילים. אחר כך ב-TouchPad, אחרי busy = true, מצאו את התיקייה leaderstats של השחקן והוסיפו 1 לערך Coins. רמז: player:FindFirstChild("leaderstats"), ואז leaderstats:FindFirstChild("Coins"), ואז coins.Value += 1. משטח המטבעות במדריך לטבלת מובילים הוא הגרסה המוכנה, עם זמן המתנה לכל שחקן.
  • שה-ColourChanger ישנה גם שקיפות. גרמו ל-ColourChanger לשנות כל שנייה גם את ה-Transparency של ה-Part. רמז: הוסיפו טבלה שנייה של מספרים בין 0 ל-1, למשל { 0, 0.3, 0.6 }, וקבעו ממנה את part.Transparency בשורה שאחרי part.Color, עם אותו index.
  • הדפיסו את הצבע של המשטח. גרמו ל-MyFirstLocalScript להדפיס את ה-Color של המשטח בלחיצה על E. רמז: print(pad.Color) בתוך הבלוק if pad and pad:IsA("BasePart"). לחצו על E בזמן שהמשטח צהוב: הלקוח רואה את הצבע שהשרת קבע, כי שינויים בשרת מגיעים לכל הלקוחות.

מה ללמוד הלאה

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

  1. LocalScript vs Script vs ModuleScript: איפה רץ כל סוג סקריפט ומה הוא יכול לשנות, לעומק יותר משלב 4.
  2. RemoteEvents: איך LocalScript מבקש מהשרת לעשות משהו, ואיך השרת בודק את הבקשה.
  3. טבלת מובילים: המאפיינים הראשונים שלכם, שנוצרים ומשתנים בשרת.
  4. המשחק הראשון שלכם: מסלול קצר עם לבה, מטבעות ומשטח סיום על שני סקריפטים של שרת, ואז פרסום.
  5. אחר כך בחרו מערכת: GUI של חנות, מערכת סיבובים, צ׳קפוינטים באובי, מסך טעינה או אנימציה בלחיצת מקש. כשמשהו נשבר, המדריך לשגיאות בסקריפטים עוזר לקרוא את ההודעה. המדריך לצ׳קפוינטים בינתיים באנגלית.

המדריכים של Roblox עצמה, Coding fundamentals (באנגלית), משלימים היטב את המדריך הזה: שש סדרות ממשתנים ופונקציות, דרך תנאים, לולאות, מערכים ומילונים, ועד ארגון קוד ב-ModuleScript, עם פרויקטים קטנים ב-Studio.

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

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

Studio נתקע או מפסיק להגיב כשלוחצים על Play

בלולאת while true do אין המתנה, ולכן שום דבר אחר לא יכול לרוץ. התיעוד של Roblox אומר שלולאה אינסופית בלי השהיה כמו task.wait() תוקעת את המשחק ומפילה את Studio. שימו task.wait() בכל לולאה אינסופית, כמו ב-ColourChanger.

שום דבר לא קורה כשאני עומד על המשטח

בדקו ש-TouchPad הוא Script, לא LocalScript, נמצא ישירות בתוך ה-Part בשם Pad, לא מושבת, ושהמאפיין CanTouch של המשטח מסומן. אחר כך הפכו את print("touched", otherPart.Name) לשורה הראשונה בתוך onTouched. אם זה לא מודפס, האירוע לא נורה; אם זה מודפס, הבעיה נמצאת למטה יותר.

לחיצה על E לא עושה כלום

MyFirstLocalScript חייב להיות LocalScript בתוך StarterPlayerScripts: LocalScript ב-Workspace או ב-ServerScriptService אף פעם לא רץ. ה-Part חייב להיקרא בדיוק Pad ולהיות ישירות ב-Workspace. קודם לחצו על חלון המשחק וודאו שאתם לא מקלידים בצ׳אט, כי הסקריפט מתעלם ממקשים שהמשחק כבר השתמש בהם.

ה-Part משתנה במסך שלי, אבל לא אצל שחקנים אחרים

את השינוי עשה LocalScript, ולכן הוא נשאר במכשיר שלכם. עשו אותו ב-Script של שרת, או תנו ל-LocalScript לבקש מהשרת דרך RemoteEvent.

ColourChanger עובד בתוך Part, אבל נשבר ב-ServerScriptService

הוא משתמש ב-script.Parent כ-Part שלו. ב-ServerScriptService ההורה הוא ServerScriptService, שאין לו Anchored או Color, ולכן ה-Output מציג את השגיאה "not a valid member". השאירו אותו בתוך Part, או תנו ל-Part שם וחפשו אותו לפי השם, למשל local part = workspace:WaitForChild("ColourPart") :: BasePart.

ה-Output לא מציג בכלל כלום

בדקו שחלון ה-Output פתוח (תפריט Window או הלשונית Script) ושאין מסנן: את ה-Output אפשר לסנן לפי סוג הודעות, לפי Client או Server ולפי טקסט. אם הוא פתוח ועדיין ריק, הסקריפט כנראה לא רץ. ראו רשימת בדיקה לסקריפטים שלא עושים כלום.

אם נתקעתם: RoCode

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

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

אתם כותבים

תסביר שורה אחר שורה מה הסקריפט TouchPad בתוך ה-Part בשם Pad עושה, ולמה משתמשים בו ב-debounce.

RoCode עושה
  • במצב Ask משתמש רק בכלי קריאה, למשל Search Scripts ו-Read Script, ולא משנה כלום בפלייס
  • אם משהו צריך תיקון, אומר מה ואיפה הוא היה משנה, ומציע לעבור ל-Build
  • במצב Build עורך סקריפטים במקום, ואז בודק כל אחד עם Check Script. זו בדיקת קומפילציה, לא בדיקת טיפוסים ולא בדיקת משחק
  • קורא את ה-Output של Studio עם הכלי Check Output, כולל שורות Server ו-Client מבדיקת המשחק האחרונה שלכם, גם אחרי לחיצה על Stop

במצב Build עם פלאגין 3.9 ומעלה RoCode יכול להריץ בדיקת משחק קצרה ולקרוא את השגיאות, ועם 3.9.11 ומעלה לשלוט בדמות בדיקה, אבל בזמן המשחק הוא לא מצלם מסך, ולכן על המשטח אתם עדיין עולים בעצמכם. איך RoCode מתחבר ל-Studio.

שאלות נפוצות

איפה כותבים סקריפטים ב-Roblox Studio?

ב-Explorer רחפו מעל מכל, למשל ServerScriptService, לחצו על + ובחרו Script. Studio יפתח אותו ב-Script Editor, שם כותבים Luau. סקריפטים של שרת בדרך כלל נמצאים ב-ServerScriptService; LocalScripts ב-StarterPlayerScripts או ב-StarterGui.

איך מריצים סקריפט ב-Roblox Studio?

לחצו על Play (F5). Studio יפעיל בדיקת משחק, וכל Script מופעל ב-ServerScriptService או ב-Workspace ירוץ מיד כשהמשחק עולה; LocalScripts ב-StarterPlayerScripts ירוצו כשתיכנסו לבדיקת המשחק. Run (בחרו ברשימה שליד Play, או לחצו על F8) מפעיל את המשחק בלי אווטאר, ולכן למדריך הזה השתמשו ב-Play. Stop (Shift+F5) מסיים את הבדיקה. כדי לפתוח סקריפט קיים, לחצו עליו פעמיים ב-Explorer.

באיזו שפת תכנות Roblox משתמשת?

Luau. Roblox מתארת אותה כשפת סקריפטים מהירה, קטנה ובטוחה עם טיפוסים הדרגתיים, שמקורה ב-Lua 5.1, ולכן רוב המדריכים ל-Lua עדיין שימושיים. Luau מוסיפה יכולות כמו אינטרפולציה של מחרוזות בגרשיים הפוכים והערות טיפוסים לא חובה, ו-Roblox מוסיפה ספריות ואובייקטים משלה, למשל task.wait.

במה Script שונה מ-LocalScript?

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

אפשר לכתוב סקריפטים ב-Roblox Studio בטלפון או ב-iPad?

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

למה הסקריפט שלי לא עושה כלום ולא מציג שגיאה?

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

כמה זמן לוקח ללמוד סקריפטים ב-Roblox?

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

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

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

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

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