בקצרה
כדי לכתוב סקריפט ב-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.
בעמוד הזה
לפני שמתחילים: Studio, Baseplate וחלון ה-Output
צריך Roblox Studio וחשבון Roblox, ולא יותר: לא עורך קוד ולא פלאגין. כל סקריפט במדריך הזה מוקלד ב-Script Editor של Studio עצמו.
- התקינו את Roblox Studio, האפליקציה החינמית של Roblox ל-Windows ול-Mac, והיכנסו עם חשבון Roblox.
- פתחו את Studio. בעמוד הפתיחה יש תבניות: בחרו Baseplate. תקבלו רצפה עם טקסטורת רשת של 4x4 ו-SpawnLocation, המקום שבו האווטאר שלכם מופיע כשמשחקים.
- אם החלונות Explorer ו-Properties לא גלויים, פתחו אותם מתפריט Window או מהלשונית Home. Explorer מפרט את כל האובייקטים בפלייס; Properties מציג את ההגדרות של האובייקט המסומן.
- פתחו את ה-Output מתפריט Window או מהלשונית Script. כאן מופיעות ההודעות והשגיאות של הסקריפטים שלכם.
- בהגדרות התצוגה של חלון ה-Output הפעילו את Show Context, שמסמן כל הודעה כ-Client או Server, ואת Show Source, שמראה את הסקריפט ואת מספר השורה שממנה היא הגיעה.
| סקריפט | סוג | איפה הוא נמצא | מה הוא מלמד |
|---|---|---|---|
FirstScript | Script | ServerScriptService | משתנים, פונקציה, תנאי if, לולאות וטבלה |
ColourChanger | Script | בתוך Part ב-Workspace | שינוי מאפיינים, script.Parent ולולאה עם המתנה |
TouchPad | Script | בתוך Part בשם Pad | אירועים, מציאת השחקן שנגע ב-Part, ו-debounce |
MyFirstLocalScript | LocalScript | StarterPlayerScripts, בתוך StarterPlayer | קוד במכשיר של שחקן אחד, לחיצות מקשים ומה נשאר במכשיר הזה |
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: כתבו את הסקריפט הראשון
- ב-Explorer רחפו מעל ServerScriptService, לחצו על + ובחרו Script (קיצור Ctrl+I, או ⌘I ב-Mac). Studio ייצור סקריפט ויפתח אותו ב-Script Editor.
- לחצו על הסקריפט החדש בכפתור הימני, בחרו Rename וקראו לו
FirstScript. השם לא משנה את מה שהסקריפט עושה, אבל אומר איזה סקריפט הדפיס מה. - סקריפטים חדשים מתחילים בשורה אחת,
print("Hello world!"). מחקו אותה והדביקו את הקוד שלמטה. - לחצו על Play (F5), כשברשימה משמאלו נבחר Test. Studio יפעיל בדיקת משחק וישים את האווטאר על ה-SpawnLocation.
- קראו את השורות ב-Output, ואז לחצו על Stop (Shift+F5). Stop גם מחזיר את כל האובייקטים למצב שלפני הלחיצה על Play, ולכן כל מה שהזזתם או צבעתם מחדש בזמן המשחק יחזור.
-- 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 עם מספר שורה.
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 בדפדפן. שנו שם ערך והריצו שוב, כדי לראות מה ישתנה.
| קוד | רעיון | מה זה אומר |
|---|---|---|
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 | תנאי if | Luau בודק תנאים מלמעלה למטה ומריץ רק את הראשון שהוא אמת. 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, הן מאפיינים, וגם סקריפט יכול לקבוע אותן.
- בלשונית Home לחצו על Part. Studio יוסיף בלוק ל-Workspace. השם שלו לא חשוב.
- ב-Explorer רחפו מעל ה-Part החדש, לחצו על + והכניסו Script. שנו את השם שלו ל-
ColourChangerוהחליפו את התוכן בקוד שלמטה. - לחצו על Play. ה-Part נעשה אדום, אחר כך כחול, אחר כך ירוק, מתחלף פעם בשנייה, ומתחיל מחדש.
-- 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 קוראת לזה אירועים. כדי להריץ קוד כשאירוע נורה, מחברים אליו פונקציה.
- הכניסו עוד Part ושנו את השם שלו בדיוק ל-
Pad, עם P גדולה. השאירו אותו ישירות ב-Workspace, לא בתיקייה ולא במודל, כי ה-LocalScript בשלב 4 מחפש אותו שם. - עשו אותו משטח שטוח שאפשר לעמוד עליו, למשל קבעו
Sizeל-6, 1, 6בחלון Properties. הציבו אותו על הרצפה ליד ה-SpawnLocation, וסמנו Anchored כדי שלא יזוז. - רחפו מעל ה-Pad, לחצו על +, הכניסו Script, שנו את השם שלו ל-
TouchPadוהדביקו את הקוד שלמטה. - לחצו על Play ועמדו על המשטח. הוא מצהיב ל-2 שניות, וה-Output מציין את השם שלכם.
-- 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)
| קוד | מה הוא עושה |
|---|---|
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 רץ במכשיר של שחקן אחד. לחיצות מקשים, המצלמה ותפריטים במסך מטופלים שם, כי רק המכשיר הזה יודע עליהם.
- ב-Explorer פתחו את StarterPlayer, רחפו מעל StarterPlayerScripts, לחצו על + והכניסו LocalScript. שנו את השם שלו ל-
MyFirstLocalScriptוהדביקו את הקוד שלמטה. - לחצו על Play. ה-Output יציג
Hello,ואת השם שלכם, מסומנים ב-Client. - לחצו על חלון המשחק ועל E. המשטח נעשה שקוף יותר. לחצו שוב על E כדי להחזיר אותו.
- בזמן שבדיקת המשחק רצה, לחצו על המתג Client/Server בפקדי הבדיקה של Studio, כדי לעבור לעותק של המשחק בשרת. שם המשטח אטום: השרת לא ידע כלום על השינוי.
-- 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 | בשרת | לכל השחקנים | חוקי המשחק: מטבעות, נזק, דלתות, סיבובים, שמירה | ServerScriptService, או בתוך Part בזמן הלמידה |
| LocalScript | במכשיר של שחקן אחד | רק למכשיר הזה, חוץ מהתנועה של הדמות שלו | קלט, מצלמה, תפריטים במסך, אפקטים לשחקן אחד | StarterPlayerScripts או StarterGui |
| ModuleScript | בצד שקורא לו require() | לאותו מקום כמו של הסקריפט שטען אותו | קוד משותף לכמה סקריפטים | ReplicatedStorage לשני הצדדים, ServerScriptService רק לשרת |
מה רמאי יכול לשנות
הניחו שרמאי שולט בכל דבר במכשיר שלו. הוא יכול להריץ LocalScripts משלו ולשנות את שלכם, ולכן יכול להפוך את המשטח לשקוף, או כל דבר אחר במסך שלו. כאן זה לא מזיק: השקיפות היא רק בשביל המראה ונשארת במכשיר שלו. בדיוק בגלל זה כל דבר חשוב מחליט Script בשרת.
גם Script בשרת לא בטוח אוטומטית. TouchPad רץ בשרת, אבל המכשיר של כל שחקן שולט בפיזיקה של הדמות שלו, ותיעוד האבטחה של Roblox מונה בין הדברים שלקוח יכול לעשות עם Parts שבשליטתו שליטה ברגע שבו Touched נורה, או חסימה מלאה שלו. למשטח זוהר זה לא חשוב. למשטח שמשלם, בדקו גם את מה שהשרת עוקב אחריו בעצמו, כמו הכלל במדריך לאובי שלפיו צ׳קפוינטים נחשבים רק לפי הסדר.
שלב 5: בדקו את ארבעת הסקריפטים יחד
- נקו את ה-Output עם Ctrl+K (⌘K ב-Mac) ולחצו על Play (F5). ה-Output יציג שמונה שורות של FirstScript מסומנות ב-Server, ואת שורת ה-Hello שלכם מסומנת ב-Client. ה-Part בשם ColourChanger מחליף צבע כל שנייה.
- עמדו על המשטח. הוא מצהיב ל-2 שניות, וה-Output מציג פעם אחת את השם שלכם ו-"stepped on the pad". הסתובבו עליו: שורה חדשה מופיעה לא יותר מפעם ב-2 שניות, ולא בכל פעם ש-Touched נורה.
- לחצו על E. המשטח נעשה חצי שקוף (Transparency 0.6). לחצו שוב על E, והוא אטום.
- לחצו על Stop. ברשימת הבדיקות בחרו Server & Clients, קבעו 2 לקוחות ולחצו על Play (או F7). Studio יפתח חלון שרת ושני חלונות לקוח. בלקוח אחד לחצו על E: המשטח ייעשה שקוף יותר שם, והלקוח השני והשרת יציגו אותו אטום. לחצו על End Session כשתסיימו.
- שברו משהו בכוונה. שנו את השם של 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 ב-Workspace | Script ששייך ל-Part אחד, כמו ColourChanger ו-TouchPad | בסדר בזמן הלמידה: ה-Part הוא script.Parent. לפרויקטים אמיתיים Roblox ממליצה במקום זה לסמן Parts בתגים (ראו למטה). |
| StarterPlayerScripts, בתוך StarterPlayer | רוב ה-LocalScripts: קלט, מצלמה, אפקטים לשחקן אחד | כל שחקן מקבל עותק משלו בכניסה. |
| StarterGui | LocalScripts בתוך ScreenGui שמנהלים תפריט במסך | כל שחקן מקבל עותק משלו של הממשק. |
| ReplicatedStorage | ModuleScripts שגם קוד שרת וגם קוד לקוח טוענים | שני הצדדים רואים אותו. LocalScript או Script עם הגדרות ברירת מחדל לא ירוץ כאן אף פעם. |
העמוד של Roblox על מיקום סקריפטים ממליץ בכלל לא לשים סקריפטים ישירות ב-Parts ב-Workspace: סמנו Parts בתגים ועבדו איתם מ-ModuleScript אחד דרך CollectionService. סקריפט בתוך Part הוא עדיין ההתחלה הכי פשוטה, ולאובייקט אחד או שניים בזמן הלמידה זה בסדר. המדריך לדלתות מראה את התבנית עם תגים, עם סקריפט אחד לכל הדלתות, והמדריך על לקוח ושרת מכיל טבלה מלאה של אילו מכלים מריצים אילו סקריפטים.
כשמשהו משתבש: קראו את ה-Output
שגיאות מוצגות ב-Output באדום. כל אחת מתחילה במקום שבו היא קרתה, בשם המלא של הסקריפט ובמספר השורה, ואחר כך אומרת מה לא בסדר. לחצו על השגיאה, ו-Studio יפתח את הסקריפט בשורה הזו. למשל, אם תמחקו את הבדיקה if not player מ-TouchPad, ו-Part חופשי ייפול על המשטח, ה-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 בלי debounce | Touched נורה כמה פעמים ברצף בצעד אחד, ולכן הקוד רץ שוב ושוב. | הדגל busy וזמן המתנה |
| שם LocalScript בתוך Part ב-Workspace | LocalScript שם אף פעם לא רץ. הוא עובד רק ממקומות ששייכים לשחקן אחד. | 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 בזמן שהמשטח צהוב: הלקוח רואה את הצבע שהשרת קבע, כי שינויים בשרת מגיעים לכל הלקוחות.
מה ללמוד הלאה
עכשיו השתמשתם בחלקים שמהם בנויים רוב סקריפטי המשחק. סדר טוב להמשך:
- LocalScript vs Script vs ModuleScript: איפה רץ כל סוג סקריפט ומה הוא יכול לשנות, לעומק יותר משלב 4.
- RemoteEvents: איך LocalScript מבקש מהשרת לעשות משהו, ואיך השרת בודק את הבקשה.
- טבלת מובילים: המאפיינים הראשונים שלכם, שנוצרים ומשתנים בשרת.
- המשחק הראשון שלכם: מסלול קצר עם לבה, מטבעות ומשטח סיום על שני סקריפטים של שרת, ואז פרסום.
- אחר כך בחרו מערכת: 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.
- במצב 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?
אף אחד לא ייתן מספר כן: זה תלוי בכמה אתם בונים. הכי עוזר לכתוב לעיתים קרובות סקריפטים קטנים בפלייס שלכם. שנו את ארבעת הסקריפטים מכאן, נסו את משימות התרגול, ואז עברו על המדריך למשחק הראשון והוסיפו מערכת אחת בכל פעם.
מקורות וקריאה נוספת
- Roblox Creator Docs: Luau (באנגלית). מה זה Luau ומאיפה היא באה
- Roblox Creator Docs: Roblox Studio setup (באנגלית). Windows ו-Mac, דרישות מערכת
- Roblox Creator Docs: Output (באנגלית). פתיחת ה-Output, מסננים, Show Context ו-Show Source
- Roblox Creator Docs: Studio testing modes (באנגלית). Play, Run, Stop, המתג Client/Server ו-Server & Clients
- Roblox Creator Docs: Script Editor (באנגלית). איפה נפתחים סקריפטים חדשים, ו-Script Analysis
- Roblox Creator Docs: Script types and locations (באנגלית). איפה רץ כל סוג סקריפט, ותגים במקום סקריפטים ב-Parts
- Roblox Creator Docs: Script (באנגלית). מתי Script מתחיל לרוץ
- Roblox Creator Docs: Control structures (באנגלית). תנאים, לולאות ולמה לולאה אינסופית צריכה המתנה
- Roblox Creator Docs: Events (באנגלית). Connect ומה Touched מעביר לפונקציה
- Roblox Creator Docs: Debounce patterns (באנגלית). למה Touched נורה כמה פעמים בנגיעה אחת
- Roblox Creator Docs: wait (באנגלית). wait() הגלובלי ו-task.wait()
- Roblox Creator Docs: Network ownership, movement validation and physics exploits (באנגלית). מה הלקוח יכול לעשות עם הדמות שלו
- Roblox Creator Docs: Coding fundamentals (באנגלית). הסדרה של Roblox למתחילים
איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.