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

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

הוספת מודל תלת המימד של הדרקון

ברובלוקס סטודיו יש לנו אפשרות להוסיף מודלים חדשים למשחק שלנו ע"י חלון ה- Toolbox. בחלון הזה אנחנו יכולים להוסיף מודלים בתלת מימד, פלאגינים (תוספות/הרחבות), ודברים נוספים שיש באקוסיסטם של רובלוקס. את מודל התלת מימד של הדרקון עשו כבר בשבילנו – כל מה שאנחנו צריכים לעשות זה ללכת אל חלון ה- Toolbox שנמצא ברובלוקס סטודיו, לחפש את הדרקון שאנחנו רוצים להוסיף למשחק, ללחוץ ו.. הדרקון נוסף למשחק! לשם הפשטות, במדריך זה אשתמש במודל תלת מימד של דרקון בשם "Toothless" – דרקון שרובלוקס עצמם הכינו בשבילנו.

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

תכנות דרקון יורק אש

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

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

local head = script.Parent:WaitForChild("Head")

בשלב זה אנחנו בעצם מפעילים פונקציה בשם "WaitForChild" על המודל בסיס שלנו (הדרקון), וניגשים לאובייקט של הראש שלו. למשתנה של הראש נקרא head, נשתמש בו בהמשך כדי לקבל מידע על המיקום של הראש – כדי לדעת מאיפה לירוק את האש.

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

local sp = script.Parent

local head =sp:WaitForChild("Head")

function breatheFire()
     local fireball = Instance.new("Part", workspace)
     fireball.Name = "Fireball"
     fireball.Transparency = 1
     fireball.Shape = "Ball"
     BrickColor = BrickColor.new("Bright orange")
     fireball.size=Vector3.new(2,2,2)
     fireball.CanCollide = false
     fireball.cFrame = head.Cframe
     fireball.Velocity=head.CFrame.lookVector*math.random(30, 70)
     fireball.TopSurface = "Smooth"
     fireball.BottomSurface = "Smooth"
     local fire = Instance.new("Fire")
     fire.Parent = fireball
end

while true do
    wait(2)
    breathFire()
    breathFire()
    breathFire()
    breathFire()
end

הסבר – קוד יריקת האש

1. הגדרנו משתנה בשם sp את ה"אבא" של הסקריפט – שהוא בעצם המודל של הדרקון. מטרתה של שורה זו היא שהקוד יהיה נוח וקריא יותר כשנשתמש בדמות הדרקון.
2. הגדרנו משתנה נוסף בשם head שמכיל את הראש של הדרקון. גם בו נשתמש בהמשך הסקריפט כדי לדעת מאיפה לירוק את האש.
3. הגדרנו פונקציה חדשה בשם breathFire
4. בתוך הפונקציה אנחנו יוצרים אובייקט חדש מסוג "Part" ע"י שימוש בפונקציה Instance.new. אנחנו בעצם יוצרים מודל בסיסי כמו שעבדנו עד היום ושינינו (להיות דלת, בוסט מהירות, או כרטיס כניסה).
5. קראנו לילד בשמו – שינוי שם האובייקט ל- "Fireball".
6. הגדרנו מאפיינים נוספים כמו שקיפות, צבע (לכתום), גודל, צורה, האם הוא יכול לקפץ על הקרקע (CanCollide), מרקם (חלק).
7. הגדרנו מאיפה האש תצא – head.Cframe – את המשתנה head הגדרנו בשורה 3 בקוד. ההגדרה של המשתנה קיצרה לנו את הקוד והפכה אותו לקריא יותר – מכיוון שהשתמשנו בו יותר מפעם אחת.
8. הגדרנו את הכיוון של האש – שימו לב כי השתמשנו בפונקציה המובנית math.random כדי לייצר מספר בין 30 ל- 70, ככה שהדרקון ירק אש לכיוונים שונים ורנדומלים. לחלופין, תוכלו להגדיר את המאפיין Velocity לערך קבוע אם תרצו שהאש תגיע לכיוון אחד בלבד.
9. לבסוף, יצרנו משתנה חדש שמכיל אובייקט חדש שאנחנו יוצרים בשם Fire – נגיע אליו בהמשך, האובייקט החדש יהיה בעצם האש שלנו. את ה"אבא" של האש הגדרנו ככדור אש שהרגע יצרנו – fireball.
10. ברגע שסיימנו להגדיר את הפונקציה (end) – כתבנו קוד שרץ לנצח – וקורא לפונקציה כל 2 שניות (ז"א שהאש תצא מהפה של הדרקון כל 2 שניות. גם את זה אתם יכולים לשנות למספר השניות שתרצו).

מוזמנים ללחוץ Play ולראות את הקוד שכתבנו עד כה בפעולה. מה שעשינו עד עכשיו:

1. יצרנו אש שיוצאת מהפה של הדרקון כל פעם שקוראים לפונקציה
2. כתבנו לולאה אין-סופית שגורמת לדרקון לירות את האש כל 2 שניות

אבל מה קורה שהאש פוגעת בנו? לא יקרה לנו כלום. זה הזמן להוסיף את הפלפל – שהאש תוריד למי שהיא פוגעת בו חיים!

תכנות פגיעה והורדת חיים

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

local debounce = true;
function burn(hit)
     if hit and hit.Parent and hit.Parent.Name~="Toothless" and hit.Name~="Handle" and hit.Name~="Fireball" and debounce then
          debounce = false
          local humanoid = hit.Parent:FindFirstChild("Humanoid")
          if humanoid then
                fire.Enabled = False
          end
          sp.anchored=True
          wait(2)
          sp:destroy()
     end
end

sp.Touched:connect(burn)

הסבר

בשורה הראשונה אנחנו מגדירים משתנה בשם bounce ונותנים לו את הערך true (אמת), כדי שנוכל לזהות אם האש כבר פגעה בשחקן (זאת על מנת שכל אש תוכל לפגוע בשחקן רק פעם אחת בכל פעם – אחרת ירדו לנו חיים על כל חלק בגוף והחיים של הדמות ירדו ישר ל-0 ביריקת אש אחת)

החל מהשורה השנייה אנחנו מגדירים פונקציה, שבתוכה יש לנו משפט תנאי ארוך יחסית: אנחנו בודקים אם הייתה פגיעה בדמות אחרת (הפרמטר hit) – ויתרה מכך – אנחנו מסננים פגיעות בדרקון שלנו (Toothless), בחפצים של הדמות (Handle), ובאובייקט של כדור האש (Fireball). בנוסף אנחנו בודקים אם המשתמש debounce הוא true, שזה אומר שהאש עדיין לא פגעה בשחקן. אם היא פגעה בשחקן – אנחנו מייד מעדכנים את הערך של המשתנה ל false כדי שהיא תפגע עד פעם אחת.

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

לאחר מכן אנחנו משפרים את האש, כך שלא תעלם ישר – אלא תשאיר סוג של עשן, ותראה יותר אמיתית. בשביל זה אנחנו מגדירים את המאפיין anchored=True (ואז האש עולה לאוויר), מחכים 2 שניות, ואז מוחקים אותה.

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

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