[מדריך]בניית משחק בפלאש

[B1ackSn0w]

1. עקרונות התכנות

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

פקודות

בתכנות, הכל בנוי מרצף של פקודות שמתבצעות על ידי המחשב. הדבר דומה לאילוף של כלב. הכלב לומד מספר "פקודות", ולאחר מכן ניתן לתת לו "הוראות", למשל "ארצה" והוא ישב, או "לך תביא את המקל" והוא ירוץ ויחזור עם המקל בפיו.
בתכנות הדבר מאוד דומה. המחשב מכיר מספר פקודות, וכל פקודה תגרום לו לבצע דבר אחר. שני הבדלים עיקריים בין כלב למחשב – האחד, למחשב אין רצונות משלו, וכל דבר ש"תגידו" לו לעשות הוא יעשה. השני – למחשב לא מדברים (אתם מוזמנים לנסות, אבל זה לא עובד בדרך כלל), למחשב כותבים. בתכנות, נהוג לכתוב כל פקודה בשורה נפרדת.
אם נמיר עכשיו את פקודות הכלב שלנו לכתבה, הדבר יראה בערך כך:
* לך תביא את המקל
* ארצה
* תלחץ לי את היד
התוצאה תהיה שהכלב ירוץ ויחזור אם המקל בפיו, ישב וילחץ לך את היד. כמובן, אם זה כלב ממושמע.
רצף פקודות הגיוני בתכנות יהיה:
* תדפיס על המסך את המשפט "Hello World"
* תדפיס על המסך את המספר 3
* תדפיס על המסך את התוצאה של התרגיל 2+5
התוצאה של הרצף הזה תהיה: Hello World 3 7. אבל זאת סתם דוגמה. בעצם, זה אפילו לא קשור לפלאש – בפלאש אין פקודה שהמשמעות שלה היא "תדפיס על המסך". מה שכן חשוב זה שבפלאש, כמו בהרבה שפות תכנות\סקריפט אחרות, מעבר שורה הוא לא משהו שהמחשב מגדיר כ"סוף פקודה". זאת אומרת, שאם יש פקודה a, ואני רוצה שהמחשב עכשיו יבצע a פעמיים, אם אני אכתוב:

a
a

או:

aa

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

a;
a;

בעקרון, גם:

a;a;

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


הערות - תיעוד

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

// doing that very special thing
a; // starting the blah
b; // doing the ha
c; // create the rahhhh
// end!

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

/* this is a comment */

ההבדל הוא, שלהערה מהסוג הזה יש התחלה ויש סוג. כל מה שכתוב בין /* ל*/ הוא הערה. זאת אומרת שאפשר ככה להפוך להערה חצאי שורות ואפשר להפוך להערה כמה שורות ביחד, למשל:

/*********************************************
********************היי***********************
**********************************************/

זאת הערה. קצת מיותרת, אבל בשביל ההמחשה היא סבבה...



משתנים

משתנה הוא כל דבר שמכיל ערך. מה זאת אומרת? למשל אם יש לנו משתנה בשם X. הוא יכול להכיל את המספר 3. אולי עם דוגמה זה יהיה יותר פשוט...

X=3;

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

X="3";

במקרה הזה, X יכיל 3, אבל לא כמספר. אלא את התו 3. מה זאת אומרת? זאת אומרת שהמחשב ידע שהמשתנה X מכיל 3, אבל לא ידע שהמשתנה X מכיל את המספר 3. אני אתן לכם דוגמה קצת יותר ברורה. נשתמש עכשיו במשתנה בשם dani, בלי שום סיבה מיוחדת:

dani = "hello";

עכשיו המשתנה dani מכיל את המילה hello. מבחינת המחשב, hello זאת לא מילה אלא רצף של אותיות, או בשפה קצת יותר מקצועית, מחרוזת של תווים (או בקיצור – מחרוזת).
המחשב מתייחס לכל התווים – בין אם זה אותיות, סימנים, רווחים או מספרים – כאל תווים. וזה בדיוק ההבדל בין 3 לבין "3". 3 זה המספר 3. "3" זה מחרוזת של תווים, שבמקרה מכילה את התו 3. למה זה משנה – את זה תבינו בהמשך...
אגב, ברוב השפות, לא כל משתנה יכול להכיל גם מספרים וגם מחרוזות. אבל action script זאת שפה מאוד "רכה", ולכן אפשר לעשות בה דברים כאלה... בנוסף, משתנה יכול להכיל מספרים לא שלמים (למשל 2.5), מה שלא תמיד נכון בכל השפות.

case sensitive
action script, כמו הרבה שפות אחרות, היא case sensitive. זאת אומרת, בקיצור, שהיא מבחינה בין אותיות גדולות לקטנות. אם זה מבלבל אתכם, אני אתן דוגמה מאוד מאוד פשוטה, והפעם עם השם shmolik.
שימו לב לשורות הקוד הבאות:

shmolik = 1;
Shmolik = 2;
SHmolik = 3;
shMolik = 4;
shmoLik = 5;

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

פעולות על מספרים ומחרוזות
אני אתחיל מדוגמה:

y = 2+3;

כמו שאתם יכולים לנחש, המשתנה y מכיל עכשיו את הערך 5.
ומה במקרה הבא?

x = 2;
y = 3;
z = x-y;

המשתנה z מכיל עכשיו את המספר -1, כי 2-3=-1. פשוט...
פעולות אפשריות:
+ חיבור, - חיסור, / חילוק, * כפל
אמממ.... זהו, בגדול, אלה הפעולות החשובות, לפחות בהתחלה.
מחרוזות גם ניתן לחבר. מה יקרה במקרה הבא?

x = "1";
y = x + "1";

הגיוני לחשוב שy יכיל 1+1=2. אבל לא ככה הדבר. מכיוון שמדובר במחרוזות, המחשב לא מתייחס ל"1" כאל מספר. ולכן, y יכיל את המחרוזת "11".
כמו כן,

x = "world";
y = "hello";
z = y + " " + x; // z = "hello world"


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

x = x+1;

אבל אפשר גם לכתוב פשוט

x++;

זה קיצור שימושי מאוד.
עוד קיצורים:

x = 2;
x+=3; //x=5

x=5;
y=8;
y-=x; //y = 3

y=4;
y--; //y=3


תחשבו ששני המיני פרקים "case sensitive" ו"פעולות על מספרים ומחרוזות" בהודעות נפרדות מזאת, טוב? פשוט בטעות גזרתי גם אותם, לא שמתי לב :-\



פונקציות ופונקציות מובנות

פונקציות הן פקודות שניתן להשתמש בהן בזמן כתיבת הקוד. קצת קשה להסביר, ולכן אני אתן דוגמה במה שנקרא "אלגוריתם עברי", זאת אומרת, כשכותבים בעברית מה שרוצים שהתוכנית תעשה, בשביל לתכנן מראש מה שרוצים לתכנת:
* הדפס על המסך "hello world"
* X <- 1 (הכוונה בשורה הזאת – תציב במשתנה X את הערך 1)
* Y <- 2
* הדפס על המסך X+Y
בשביל לכתוב תוכנית כזאת, אנחנו צריכים פקודה שתגיד למחשב להדפיס מה שאנחנו רוצים שהוא ידפיס על המסך של המשתמש.
בפלאש אי אפשר פשוט להדפיס על המסך מה שרוצים, זה טיפה יותר מסובך, אבל נניח לרגע שאפשר להדפיס מה שרוצים ושהפקודה לכך נקראת print. הפקודה print צריכה לדעת מה אנחנו רוצים שהיא תדפיס על המסך, ולכן אנחנו צריכים "להגיד" לפקודה print מה להדפיס, "לשלוח" לפקודה print את מה שאנחנו רוצים שהיא תדפיס. בשביל להסביר איך עושים את זה, הנה מה שכתבנו מקודם כאלגוריתם עברי מתורגם לשפה דמיונית כלשהי, שבה הפונקצייהprint מדפיסה על המסך את מה שהיא מקבלת:

print("hello world");
X = 1;
Y = 2;
print(X+Y);

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

func(value1, value2);

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

func("blah", 2);

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

func();

הרבה פעמים פונקציות מחזירות ערך. מה זאת אומרת? זאת אומרת שלמשל אפשר לכתוב משהו כזה:

x = func(y);

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



פונקציות מובנות בסיסיות

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

trace("hello");
Name = "yossi";
trace(Name);
y = 1.5*3;
trace(y+1);

כשתריצו את הפלאש יפתח חלון קטן עם התוכן הבא:

hello
yossi
5.5

אבל מה? הפקודה trace לא תמיד עובדת. בשביל שהיא תפעל, צריך בפלאש במקום להפעיל את הפרוייקט רגיל, ללחוץ על Ctrl+Enter, או להכנס לControl->test movie. מה שעשיתם עד עכשיו יפתח, בצורה כזאת שגם פקודות trace יעבדו. אם תפעילו את המשחק רגיל, לא תראו את מה שיכתב ע"י trace. זאת אומרת, שtrace מיועדת אך ורק לצורך בדיקות שלכם!

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

objectName.functionName();

ולכן, בפונקציות של Math משתמשים ככה:

x = -4;
y = Math.abs(x); // y = 4

הדוגמה הנ"ל תחזיר ערך מוחלט של x, כלומר 4 במקרה הזה. יש עוד כל מני פונקציות כמו סינוס וקוסינוס, עיגול של מספר לא שלם, חזקה וכו'. אני לא אפרט על הכל כאן, אם אתם רוצים, אתם יכולים להעזר בHELP של הפלאש, ולכתוב Math. ולראות איך הפלאש נותן לכם להשלים את זה, יפתח חלון קטן עם כל הפונקציות של האובייקט. בנוסף, לאובייקט Math יש משתנים, כמו PI. משתנים של אובייקט הם כמו פונקציות של אובייקט. פשוט משתמשים בהם עם שם האובייקט נקודה שם המשתנה. למשל Math.PI יחזיר את המספר פאי הידוע לשמצה.

תנאים

אחד מהדברים הבסיסיים והחשובים ביותר בתכנות הוא התנאים. למשל:

if (x>y){
trace("x");
} else {
trace("y");
}

מה קורה פה?
יש פה בדיקה – האם x גדול מy? אם כן – אנחנו מדפיסים x, ואם לא, אנחנו מדפיסים y.
ועוד דוגמה:

if (x==y){
trace("yes");
}

מה שאנחנו עושים פה זה בודקים אם x שווה לy, ואם כן – מדפיסים "yes".
שימו לב למבנה:

if (תנאי){
// מה לבצע אם התנאי מתקיים
}

ואפשרות לעשות גם:

if (תנאי){
// מה לבצע אם התנאי מתקיים
} else {
// מה לבצע אם לא
}

יש גם אפשרות ליותר מזה:

if (תנאי 1){
// מה לבצע אם התנאי הראשון מתקיים
} else if (תנאי 2){
// מה לעשות אם התנאי הראשון לא מתקיים אבל התנאי השני כן
} else {
// מה לעשות אם שני התנאים לא מתקיימים
}

וכן הלאה...
בעקרון, ב{ ו} משתמשים על מנת לתחום כמה שורות קוד ביחד. זאת אומרת:

if (x==y){
a;
b;
}
c;

a וb יתבצעו רק אם x שווה לy. c יתבצע בכל מקרה.

לגבי התנאים עצמם...
אלה הדברים שאפשר לבדוק:
x>y – איקס גדול מוואי
x==y – איקס שווה לוואי (בניגוד לx=y שמשמעו להציב את הערך של y בתוך המשתנה x)
x<y – איקס קטן מוואי
x>=y – איקס גדול או שווה לוואי
x<=y – איקס קטן או שווה לוואי
x!=y – איקס שונה מוואי

שלילת תנאים:
שלילת תנאים מתבצעת ע"י שימוש בסימן !. זאת אומרת:

if (!(תנאי){
trace("a");
}

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

if ((תנאי 1) && (תנאי 2)){
trace("b");
}

יודפס b אם גם תנאי 1 וגם תנאי 2 מתקיימים. ואלה הפעולות שאפשר לבצע בין תנאים:
תנאי 1 && תנאי 2 – שני התנאים מתקיימים ("וגם", and)
תנאי 1 || תנאי 2 – אחד מהתנאים מתקיים ("או", or)




הזחה\עימוד

בפרק על תנאים היו כמה בלוקים של קוד. בשביל "להבדיל" אותם משאר השורה, בתחילת כל שורה היה רווח. אני השתמשתי ב4 רווחים, אבל בדרך כלל משתמשים בזיח שנעשה ע"י מקש הTAB. למה זה טוב? לפלאש לא איכפת מכמה רווחים משתמשים ואיפה (כל עוד זה לא באמצע שם של פקודה או משתנה). אבל זה עוזר לנו לקרוא את הקוד. תנסו לקרוא את הקוד הבא:

if (a==b){
trace("a");
trace("b");
a--;
if (a>2){
if (c<8){
trace("z");
} else {
if(c==b){
b = -Math.abs(y);
}
} else {
trace("k");
}
} else {
trace("m");
}

לא ממש מובן מה קשור למה, נכון?
אבל תנסו עכשיו:

if (a==b){
trace("a");
trace("b");
a--;
if (a>2){
if (c<8){
trace("z");
} else {
if(c==b){
b = -Math.abs(y);
}
} else {
trace("k");
}
} else {
trace("m");
}

זה הרבה יותר ברור... לא ככה?



משתנים בוליאנים

משתנים בוליאנים הם משתנים שמכילים "אמת" או "שקר", true או false. אל תטעו, לא "true" ו"false", אלא true וfalse. זאת אומרת:

a = true;

כשרוצים להשתמש במשתנים בוליאנים בתנאים, אפשר לעשות:

if (a==true)

אבל זה מיותר.
אפשר פשוט לעשות:

if (a)

בשביל לבדוק אם הוא שווה לtrue, ו

if (!a)

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

a = y==x;
b = !((r>h) || (h>x));

והם יקבלו true או false בהתאם.
אפשר לשלוח משתנים בולאנים לtrace על מנת לבדוק את הערך שלהם.



לולאות

בלולאות משתמשים על מנת להריץ קטעי קוד מספר פעמים. למשל:

trace("a");
trace("a");
trace("a");
trace("a");
trace("a");
trace("a");
trace("a");
trace("a");
trace("a");
trace("a");

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

for (var i=0; i<10; i++){
trace("a");
}

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

var a;

בשורה הזאת הגדרנו משתנה בשם a. בשפות תכנות "אמיתיות" חייבים להגדיר משתנים לפני שמשתמשים בהם, אבל בפלאש זה לא חובה. מה שכן, משתמשים בזה בשביל להגדיר משתנים כגלובאליים ולוקליים למשל, אבל לזה עוד לא הגענו!.
חלקי הfor מופרדים ע"י ;, כמו פקודות.
מה שעשינו זה הגדרנו משתנה בשם i כ0, התנאי שנתנו הוא i<10 והפקודה לביצוע בסוף הלולאה – להעלות את i באחד. זאת אומרת: המחשב יגדיר את המשתנה איי ויציב בו את הערך 0. המחשב יבדוק אם איי קטן מ10. איי אכן קטן מ10, ולכן המחשב יבצע את הפקודות (במקרה שלנו – להדפיס a) ויעלה את איי ב-1. אז המחשב יבדוק שוב אם התנאי מתקיים, ואם כן – יבצע שוב את הפקודות ושוב יעלה את איי באחד. וחוזר חלילה. במקרה שלנו זה יקרה 10 פעמים. כמובן שבאותה מידה זה יכול לקרות גם 100 פעמים, מיליון פעמים או X פעמים (כלומר – כשX הוא משתנה). עוד דבר שאפשר לעשות זה למשל:

for(var i=0; i<=100; i+=2){
trace(i);
}

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

סוג נוסף של לולאות הוא לולאת הwhile. זאת לולאה קצת יותר פשוטה אבל משמשת למקרים קצת יותר מסובכים...
למשל:

var i = 0;
while (i<10){
trace("a");
i++;
}

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

1 1 2 3 5 8 13 21

כי:

1
1
1+1=2
2+1=3
3+2=5
5+3=8
8+5=13
13+8=21

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

prevNum = 1;
Num = 1;
trace(num);
while (num<1000){
trace(num);
num += prevNum;
prevNum = num - prevNum;
}

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

var i = 8;
while (i<9){
trace(i);
}

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




מערכים

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

var myArray = new Array();

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

myArray[0]

שזה התא הראשון המערך. התא השני הוא

myArray[1]

וכן הלאה. חשוב לזכור שמערכים מתחילים מ0 ולא מ1. זה לא ככה בכל השפות, אבל בחלקן הגדול.
דוגמה לקוד:

myArray = new Array();
myArray[0] = 1;
myArray[1] = 2;
trace (myArray[0]+myArray[1]);

הקוד הזה יחזיר 3.
דרך נוספת להגדיר מערך בפלאש:

myArr = new Array(8)

יגדיר לנו מערך בגודל של 8 תאים, זאת אומרת, 0 עד 7.
והדרך האחרונה היא משהו כזה:

myArr = new Array("helo", "hello", "helllo", "hellllo");

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

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

myArr.length()

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

for (var i=0; i<myArr.length(); i++){
trace(myArr[i]);
}


פונקציות משתמש

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

for(var i=0; i<10; i++){
trace(1106);
}

אבל אם אנחנו רוצים לעשות את זה כמה פעמים בתוכנית שלנו? נוכל בקלות להפוך את זה לפונקציה:

function forum(){
for(var i=0; i<10; i++){
trace(1106);
}
}

יצרנו פה פונקציה בשם forum. עכשיו כל פעם שנקרא לה, זאת אומרת נכתוב:

furom();

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

function forum(num){
for(var i=0; i<num; i++){
trace(1106);
}
}

עכשיו כל מה שנשאר לנו הוא לעשות משהו כזה:

forum(15);

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

function isGreaterThenForum(num){
if (num>=1106){
// true
} else {
// false
}
}

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

function isGreaterThenForum(num){
if (num>=1106){
return true;
} else {
return false;
}
}

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

function isGreaterThenForum(num){
if (num>=1106){
return true;
}
return false;
}


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

function isGreaterThenForum(num){
return num>=1106;
}

בעצם התנאי עצמו יחזיר לנו true או false, ואנחנו רק צריכים להחזיר את מה שהוא מחזיר. אם נרצה ההפך, נוכל לעשות:

function isGreaterThenForum(num){
return !num>=1106;
}

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

function myFunc(){
if (a==2){
trace("a=2");
}
}
a = 2;
myFunc();
a++;
myFunc();

מה יקרה פה? התוכנית בעצם מגדירה משתנה בשם a. המשתנה הזה הוא גלובאלי, זאת אומרת שמתוך הפונקציה myFunc אני יכול לבדוק אותו, לשנות את ערכו וכו'.
לעומת זאת, תסתכלו על התוכנית הבאה:

function myFunc(){
var b = 2;
}
myFunc();
trace(b);

אנחנו קוראים לפונקציה. הפונקציה מגדירה משתנה בשם b. אחרי זה אנחנו מבקשים להציג את ערכו של המשתנה b. מה יוחזר? הגיוני לחשוב שעל המסך, בחלונית הקטנה הזאת של הפלאש, יוצג המספר 2. אבל לא. בחלונית הזאת יהיה כתוב unidentified. זה כי התוכנית לא מכירה את המשתנה b. למה? כי המשתנה b הוא משתני מקומי, לואקלי, של הפונקציה myFunc. מה זאת אומרת? זאת אומרת שרק מתוך הפונקציה אפשר להשתמש בו. מחוץ לפונקציה הוא לא מוכר.
בשביל להגדיר משתנה לוקאלי צריך להגדיר אותו בתוך הפונקציה, עם הפקודה var. אם נעשה דבר כזה:

function myFunc(){
b = 2;
}
myFunc();
trace(b);

המשתנה b יהיה גלובאלי ולא לוקאלי, כי הוא אמנם הוגדר בתוך הפונקציה, אבל לא עם var.
עוד דבר.... בקוד הזה:

function myFunc(){
trace(b);
var b = 2;
trace(b);
}
var b = 3;
trace(b);
myFunc();
trace(b);

התוצאה תהיה:

3
3
2
3

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

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




2. עבודה בפלאש

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

אם אתם יודעים לעבוד עם פלאש...
יש לנו כמה הגדרות לסדר.
הדבר הראשון, בתפריט הmodify -> document אנחנו צריכים להגדיר דברים עבור המסמך שלנו. יש שם את גודל הפלאש, את רקע הפלאש ואת הFPS. רקע הפלאש זה דבר עיצובי בלבד, ולכן אין לי מה להרחיב לגביו. לגבי הגודל והFrames Per Second...
קודם כל אתם צריכים להחליט אם אתם רוצים משחק דפדפן או משחק עצמאי. משחק דפדפן הוא משחק שנמצא בתוך אתר אינטרנט ולא מורידים קובץ כלשהו כדי לשחק בו. צריך נגן של פלאש כדי לשחק בו. משחק עצמאי הוא משחק שמורידים כקובץ למחשב, ומשחקים בו, בלי קשר לדפדפן או לנגן פלאש.
אם אתם רוצים לבנות משחק אינטרנטי (שעובד על הדפדפן), אתם יכולים לבחור איזה מידות שאתם רוצים. שימו לב שאחת הגדולות של פלאש היא הגרפיקה הווקטורית. המשמעות היא שאם אתם מציירים עיגול הוא נשמר כעיגול ולא כמפה של נקודות בצבעים שונים (פיקסלים), ולכן אם תעשו את המשחק שלכם בגודל של 100 על 100 ולאחר מכן תגדילו את החלון לגודל של 200 על 200, העיגול לא יהרס אלא יגדל בהתאם. כל זה לא תקף אם לא משתמשים באנימציה ווקטורית. זאת אומרת, שאם אתם למשל מדביקים תמונה כלשהי בתוך הפלאש – היא נשמרת כתמונה רגילה, כלומר כאוסף של נקודות צבעוניות, ואם תגדילו את חלון המשחק, האיכות תרד והתמונה תהיה מטושטשת. לכן, אם אתם רוצים להשתמש בגרפיקה לא ווקטורית (למשל תמונות או דברים שנעשים בתוכנות שלא תומכות בכך), שימו לב שהגודל שתקבעו יהיה הגודל המקסימלי שאליו יוכל המשחק שלכם לגדול מבלי לאבד מאיכותו הגרפית. אם אתם משתמשים בגרפיקה ווקטורית (כלומר דברים שמצויירים מצורות), תוכלו להגדיל את חלון המשחק כאוות נפשכם, עם עדיפות, כמובן, לשמור על היחס המקורי.
במקרה שאתם רוצים שהמשחק יהיה עצמאי, המצב קצת שונה. זה חשוב בעיקר אם אתם רוצים שהמשחק יעבוד על חלון מלא. המידות שלכם צריכות להיות ביחס של 8:6. זאת אומרת, הרזולוציה הכי נמוכה היום היא 640 על 480. הרזולוציה שאחריה, שהיא הרבה יותר נפוצה, היא 800 על 600, ואני ממליץ לכם להשתמש בה. רזולוציות גבוהות יותר הן למשל 1024 על 768 או 1600 על 1200. אבל אין לכם סיבה להשתמש בהן, זה רק יקשה עליכם, ויהיה מיותר.
אם אתם לא מתכוונים שהמשחק יעבוד במסך מלא, עדיין יהיה טוב לשמור על היחס הזה, וגם במשחקי WEB זה יהיה לא רע. אבל זה הרבה פחות קריטי...
הדבר השני שצריך לבחור בחלון הזה הוא הFrames per second. המשמעות די ברורה – פריימים לשנייה. זאת אומרת, כמה פריימים יראו בשנייה, או כל כמה זמן הפלאש יתעדכן.
סרטי קולנוע, למשל, עובדים ב24 פריימים בשנייה. ככל שיש יותר פריימים לשנייה, האנימציה נראית חלקה יותר. אבל שימו לב שאם תבחרו להשתמש למשל ב24 פריימים בשנייה, ותעשו הכל, ואז תעברו ל32 פריימים לשנייה – הכל יהיה מהיר יותר. לכן חשוב לבחור עם כמה פריימים לשנייה לעבוד. אני אישית אוהב לעבוד בקצב של 32 פריימים לשנייה – זה לא רע. יש גם הרבה משחקים שעובדים בקצב של 80 או 100 פריימים לשנייה, אלה בדרך כלל המשחקים היותר ריאליסטיים, שעובדים גם בסביבה תלת מימדית.

עוד הגדרות שיש לנו לעשות נמצאות בfile -> publish settings. פה אנחנו מחליטים בפועל אם זה יהיה משחק WEB או משחק עצמאי. אם אנחנו רוצים משחק עצמאי, נבטל את הVים ליד HTML וSWF ונסמן V ליד WINDOWS PROJECTOR (אם רוצים משחק למקינטוש ולא לwindows נבחר באפשרות המתאימה). אם אנחנו רוצים שזה יהיה משחק WEB, נשאיר את הVים ונלך להגדרות של הSWF ושל הHTML. שם יש לנו כל מני הגדרות לשחק איתן – גירסאת הפלאש, איכות התמונות (שלא מורכבות מצורות, כלומר ווקטוריות, אלא תמונות רגילות), איכות הקול אם יש, גודל על הדפדפן וכו' וכו'. רק תעברו על ההגדרות ולשחקו איתן קצת בשביל לגלות מה כל אחת עושה.

כשתרצו ליצור את הקבצים של המשחק שלכם, תוכלו לעשות file->publish. יווצרו הקבצים המתאימים: EXE (או HQX) למשחקים עצמאיים או SWF וHTML למשחקי WEB. אגב, חשוב שתדעו – קובץ הSWF הוא הקובץ של המשחק שלכם. קובץ הHTML הוא קובץ של עמוד אינטרנט שמכיל את המשחק. הSWF יכול לעבוד עצמאית בנגן של פלאש (או בדפדפן ע"י הנגן של פלאש). בכל מקרה, כשתעלו את המשחק לאינטרנט, תצטרכו להעלות את קבצי הSWF לשרת, ולהדביק את קוד הHTML במקום המתאים באתר.
אם אתם רוצים לבדוק את המשחק תוך כדי העבודה, אתם יכולים ללחוץ על F12. הפלאש יצור את הקבצים הרלוונטיים ויפעיל אותם, וככה תוכלו לבדוק את מה שעשיתם.

[B1ackSn0w]

3. מתחילים לתכנת בפלאש - טקסט

עד עכשיו למדנו איך לתכנת, אבל לא למדנו איך זה מתקשר לפלאש. בפרק הזה נלמד קצת על איך מכניסים פקודות של Action script, ואיך עובדים עם תיבות טקסט.
בtimeline של הפלאש יש את כל הפריימים. אנחנו יכולים להוסיף קוד שאנחנו רוצים שיתבצע בכל פריים, אם הוא keyframe. הכוונה היא לפריים שחוצץ בין הפריימים שהיו עד כה ובין המשך הפריימים באותו layer. פריים שהוא לא קיפריים מכיל בדיוק את אותה גרפיקה ובדיוק את אותם דברים כמו הפריים שקדם לו באותו layer. ולכם הוא גם לא יכול להכיל פקודות משל עצמו. אם רוצים להפוך פריים לkeyfram, צריך ללחוץ עליו עם הלחצן הימני של העכבר ולבחורinsert keyframe. הkeyframe האחרון יעתיק את עצמו לפריים הנוכחי. אם אתם רוצים ליצור keyframe ריק, אתם יכולים לבחור בinsert blank keyframe.
בכל מקרה, כל עוד יש לכם keyframe, אם תעמדו עליו ותלחצו על F9, יפתח חלון הaction script. בחלון הזה אתם יכולים לכתוב פקודות. שימו לב שפקודות שנכתבות בפריימים ככה הן פקודות שנכתבות על הבמה הראשית. זה יהיה רלוונטי בפרקים הבאים. בכל מקרה, אתם יכולים להגדיר פונקציות, להשתמש במשתנים ולעשות כל מה שהסברתי בפרק הראשון. אם אתם רוצים לעשות בדיקות עם trace, אל תשכחו להפעיל את העבודה שלכם עם Ctrl+enter. אם אתם רוצים לבדוק דברים בפלאש אתם יכולים להשתמש בF12, כמו שהסברתי בפרק הקודם.

הדבר הבא שאני עומד להסביר הוא איך לעבוד עם תיבות טקסט בפלאש. הכלי שאיתו יוצרים תיבת טקסט בפלאש הוא הText Tool, שסימונו בסרגל הכלים A (קיצור דרך ע"י המקלדת – T). בחלון הproperties יש לכם אפשרות לבחור את סוג תיבת הטקסט – static זה סתם טקסט, אלמנט עיצובי; dynamic זאת תיבת טקסט שאתם יכולים לשנות את תוכנה בעזרת action script; input הינה תיבת טקסט שהמשתמש רושם לתוכה, ואתם יכולים לקלוט את התוכן שלה.
על static, כמובן, אין לי מה להסביר.
dynamic זה הסוג הראשון שאני עומד להסביר עליו. כשאתם יוצרים תיבת טקסט מסוג dynamic, יש לכם אפשרות להגדיר בחלון הproperties שני מאפיינים חשובים שאני רוצה לדבר (ז"א לכתוב) עליהם – הvar והinstance name. בעצם זה אותו דבר גם לגבי הinput text, אז אני אדבר על שניהם במקביל...
הvar עובד כמו var בaction script. זאת אומרת, אם נגדיר בvar את השם myText, נוכל בaction script לכתוב:

myText = "hello world";

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

if (myText == "hello world"){
trace("oh, yea!");
} else {
trace("oh, damnit…");
}

גם ערך של dynamic text נוכל לבדוק באותה שיטה, אבל זה משהו שלרוב לא נצטרך לעשות. input text מיועדת על מנת לקלוט טקסט מהמשתמש, וdynamic text בדרך כלל על מנת להציג טקסט למשתמש.

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

myTextField.textColor = 0xFF0000;

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

myTextField.text = "hello";

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

myTextField.onChanged = function(){
trace(myTextField.text);
}

זאת דוגמה לevent.
הכוונה בevent היא שאחרי מאורע כלשהו יקרה משהו. במקרה הזה השתמשתי בevent שנקרא onChanged. המשמעות היא שאחרי שישנו את התוכן של תיבת הטקסט (כשמדובר בתיבת טקסט מסוג input), יקרה משהו. מה שבחרתי שיקרה בדוגמה הזאת זה שיודפס בtrace תוכן התיבה. אתם מוזמנים לנסות את זה.
onChanged זה evet של תיבות טקסט. אנחנו יכולים להגדיר לכל תיבת טקסט מה יקרה בכל מני מצבים – המשתמש בחר את תיבת הטקסט, המשתמש הקליד משהו בתיבת הטקסט וכו'.
באופן כללי, פה מגיע החלק שבו אני מפסיק להסביר על נושא מסויים. כי זה כבר לא משנה. כל עוד אתם מבינים את העקרון, בפלאש יש reference מאוד טוב. מה זאת אומרת? זאת אומרת שבחלון שבו כותבים את פקודות הaction script, יש בצד רשימה של כל הפקודות שקיימות בפלאש, מחולקות לנושאים. אם תמצאו שם את החלק שמדבר על Text Fields, תמצאו שם רשימה של כל המאפיינים והפקודות הקיימות. כל מה שתצטרכו לעשות זה לבחור פקודה כלשהי וללוץ על F1 על מנת לקבל הסבר עליה, כולל דוגמאות של איך משתמשים בה. השלב הבא זה פשוט לעשות ניסיונות.
בעקרון, הפקודות גם מאוד ברורות. למשל, זה די ברור שtextColor הוא מאפיין שמגדיר את צבע הטקסט.
ועכשיו אני אגלה לכם סוג. אני לא מכיר את כל הפקודות בפלאש, ויש פקודות שרשמתי עליהן כאן במדריך שאף פעם לא השתמשתי בהן לפני, ואף פעם לא ידעתי שהן קיימות לפני כן. אבל זה לא הפריע לי לקרוא את הHELP ולהבין את המשמעות שלהן, ומיד אחרי זה לעשות ניסוי קטן ולכתוב עליהן במדריך. מה שאני רוצה להגיד זה שהרבה דברים שרוצים לעשות בפלאש אפשר ללמוד בזריזות בעזרת הHELP של הפלאש. המדריך הזה שאני רושם רק נותן דוגמאות והסברים כלליים. אבל כשתתקדמו ותתחילו לבנות משחקים בעצמכם, תוכלו להעזר בהוראות של פלאש וללמוד פקודות תוך כדי. זאת הדרך המועדפת עלי ללמידה – תוך כדי הכתיבה צריכים פקודה כלשהי, אז עוברים על רשימת הפקודות ומאתרים את הפקודה המתאימה. ככה לומדים להשתמש בעוד ועוד פקודות עם הזמן.

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




4. עצמים וכפתורים

אפשר להגיד שמשחק בנוי מכל מני עצמים. זאת אומרת – הרקע הוא עצם, הדמויות הן עצמים, הכדור הוא עצם, הפאדלים (מחבטים) הם עצמים וכו' וכו'.
בשביל ליצור עצמים כאלה משתמשים בפלאש בסימבולים, symbols. בתפריט insert בחרו בnew symbol. בחלון שנפתח יש שני דברים שאתם צריכים לעשות – לבחור שם ולבחור סוג.
השם כמובן צריך לתאר את מה שהעצם מכיל, למשל:
hero, ball, paddle, tree, audience, bad guy, creature, bonus
וכו'. השם הזה, כמובן, ישמש רק אתכם ולא את הפלאש (כמה מפתיע). אבל חשוב לתת שמות משמעותיים כדי שתוכלו אחרי זה להבין מה זה מה ויהיה לכם קל לעבוד.
כל סימבול מכיל timeline משלו, כמו העבודה כולה. זאת אומרת, כל סימבול מכיל אנימציות משלו וכל סימבול לא תלוי בעבודה הכללית.
את הסימבולים אנחנו אחרי זה מדביקים על הבמה הראשית, על הפריימים של המשחק שלנו.
יש שלושה סוגים של סימבולים: מובי קליפ, כפתור וסימבול גרפי.
על הסימבול הגרפי אין לי מה להגיד. הוא מיועד רק על מנת להיות גרפיקה או אנימציה. אי אפשר לשלוט עליו בעזרת action script והוא פשוט הולך "עם הסרט" – אם הסרט רץ – הוא רץ, אם הסרט עוצר – הוא עוצר. פשוט מאוד. לא מיוחד. משעמם...
מובי קליפ זה כבר עולם אחר לגמרי. מובי קליפ הוא כאילו סרטון בפני עצמו. בעזרת action script אפשר להתחיל ולהפסיק את האנימציה שלו. יותר מזה – אפשר גם להזיז אותו על המסמך, לשנות לו את הגודל, להפוך אותו לחצי שקוף, להעלים, לעוות ומה לא. אבל על מוביקליפס אני אדבר בפרק הבא, כי באמת יש הרבה מה להגיד עליהם.
כפתורים.... הם כפתורים, ועליהם אני אסביר עכשיו. בדרך כלל הם משמשים בבניית אתרים מבוססי פלאש, ואפשר להשתמש בהם במשחקים בשלל דרכים – לתפריטים, לאפשרויות או כחלק מהמשחק. אפשר גם להתייחס לכפתורים כאל מוביקליפס ולהזיז אותם על המסך, לשנות להם את הגודל וכו', אבל זה כבר נכלל בפרק הבא.
בכל מקרה, יש כמה דברים שצריך לדעת כשעובדים עם כפתורים. נתחיל מההתחלה.
דבר ראשון, צרו כפתור. לאחר יצירה של symbol, מגיעים לעריכה של הsymbol, זאת אומרת, מבחינה גרפית וכו'. בעקרון כשעורכים את הסימבול בהתחלה, "מתנתקים" מהפלאש הכללי ועובדים רק על הסימבול בנפרד. אחרי זה אפשר להדביק את הסימבול על הבמה הראשית, וע"י לחיצה כפולה עליו להכנס שוב לעריכה, אבל הפעם – כשכל שאר הבמה נראית מאחורה.
בניגוד לבמה הכללית, הtimeline של הכפתור קצת שונה. הוא מחולק לארבע – Up, Over, Down, Hit. לכל אחד מהפריימים המיוחדים האלה תפקיד משלו.
Up – הדרך שבה הכפתור יראה "בטבעיות".
Over – הצורה שבה יראה הכפתור כשעוברים עליו.
Down – הצורה שבה יראה הכפתור בזמן שלוחצים עליו.
Hit – את עניין הHIT קצת מסובך יותר להסביר. בעקרון, HIT זה האזור שבו הכפתור יוגדר כלחיץ. זאת אומרת, אם נניח ציירנו את הכפתור כריבוע, ובHIT עשינו עיגול, אז רק העיגול הזה יחשב בתור הכפתור. הריבוע זה רק מה שהמשתמש רואה, והHIT זה מה שהפלאש מזהה ככפתור. דוגמה קלאסית ונפוצה לשימוש בHIT היא כשהכפתור הוא בעצם טקסט. מה שרוצים זה שהמשתמש לא יהיה חייב ללחוץ בדיוק-בדיוק על האותיות, כי זה מקשה עליו. לכן בHIT מציירים ריבוע קצת גדול יותר מהטקסט, ואז האיזור של הכפתור יותר גדול ויותר נח ללחוץ עליו. דוגמה נוספת היא כאשר רוצים לעשות כפתור שקוף – משאירים את הפריימים האחרים ריקים, ובHIT מציירים את הכפתור עצמו. המשתמש לא יראה את הכפתור, אבל הפלאש ידע שהוא שם.
אחרי שיצרנו את הכפתור, אנחנו רוצים לשים אותו על הבמה שלנו. כל הסימבולים שאנחנו יוצרים נמצאים בספרייה שלנו (Library). אם לא רואים אותה, אפשר להעזר בקיצור Alt+L על מנת להציג ולהסתיר אותה. כל מה שצריך לעשות זה לקחת את הסימבול שיצרנו מהספרייה ו"לגרור" אותו אל הבמה. אחרי זה הוא פשוט יופיע עליה. כשתשימו אותו תוכלו לראות שגם לכפתור ניתן להגדיר Instance Name. אבל זה לא מעניין אותנו כרגע, זה יעניין אותנו בפרק הבא. כרגע מה שמעניין אותנו זה איך לגרום לכפתור לעבוד, משמע – כשלוחצים עליו – שיקרה משהו. או כשעוברים עליו – שיקרה משהו אחר. זה אותו דבר כמו מה שהסברתי בפרק הקודם עם הeventים, אבל קצת יותר פשוט. למה? כי כפתורים בנויים במיוחד בשביל זה, אז יותר פשוט לעשות את זה בהם.
קודם כל, אני רוצה שתלחצו על הפריים שבו שמתם את הכפתור, תכנסו לחלון הaction script (F9) ותכתבו:

stop();

מה שזה עושה זה לגרום לכך שהפלאש יעצר כשהוא יגיע לפריים הזה. אחרת, הפלאש ינגן את כל הפלאשים ברצף, ויתחיל מההתחלה כשהוא יגיע לסוף. הפקודה stop היא פקודה ששולטת על הtimeline, והמשמעות שלה – לעצור את הניגון של הפריימים.
עכשיו. נניח שאנחנו רוצים לעשות כפתור שיתחיל מחדש את הניגון של הפריימים. נשים את הכפתור. עכשיו אנחנו צריכים לכתוב action script שמתייחס לכפתור עצמו ולא לבמה הראשית. נסמן את הכפתור ונלחץ על F9. תוכלו לראות שהפקודה stop שכתבתם לא מופיעה שם, כיוון שאנחנו עכשיו במקום אחר – לא בaction script של הפריים אלא בaction script שמתייחס לכפתור עצמו. זה כנראה משהו שתתרגלו אליו עם הזמן, לכל סימבול (שהוא לא גרפיק) יש actions script נפרד מהבמה הראשית.
הפקודה שמתחילה את ניגון הפריימים היא, באופן מפתיע, play. אם פשוט תכתבו עכשיו

play();

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

on (אירוע){
// Code to do
}

כלומר – אנחנו צריכים לבחור איזשהו אירוע שיקרה על מנת שהקוד שלנו יפעל.
כשתכתבו on, הפלאש יקפיץ חלונית קטנה עם כל מני אירועים אפשריים. החשובים שבהם:
release – המשתמש לחץ על הכפתור ועזב את הלחצן של העכבר. ככה פועל כפתור "רגיל" וסטנדרטי.
press – המשתמש לחץ על הכפתור (אין אפשרות להתחרט)
rollOver – העכבר עלה על הכפתור
rollOut – העכבר יצא מתחום הכפתור
keyPress "…" – המשתמש לחץ על כפתור מסויים, כמפורט. זה למקרה שאתם רוצים למשל שיהיה אפשר להפעיל את הכפתור גם בעזרת קיצור דרך במקלדת.
ניתן גם להתייחס לכמה אירועים. למשל:

on(keyPress "<Enter>", release)
play();
}

בלחיצה על הכפתור או בלחיצה על מקש הEnter, תתבצע הפקודה play, והסרט ימשיך להתנגן.
שימו לב, שאם היינו כותבים את הפקודה הזאת ישר בפריים עצמו, הפלאש לא היה יודע לשייך אותה לכפתור המתאים. ולכן, היינו מקבלים הודעת שגיאה. קוד כזה צריך להכתב בתוך הכפתור עצמו.
אם כבר הזכרנו את play וstop, אפשר להזכיר גם את gotoAndPlay, gotoAndStop, prevFrame, nextFrame, prevScene, nextScene. חפשו עליהם בHELP של פלאש!




5. מוביקליפס

בפרק הקודם למדנו על סימבולס מסוג אחד – כפתורים. השליטה בכפתורים מאוד פשוטה, ובכלל כל הרעיון של כפתורים מאוד פשוט. במקרה של Movie Clips המצב קצת יותר מסובך, אבל אני מקווה שאני אצליח להסביר את זה כמו שצריך.
Movie Clips הם כמו סרטי פלאש בפני עצמם. לMovie Clips יש timeline כמו זה של הפלאש הראשי, ואפשר לשלוט עליהם באותה דרך. בתוך הMovie Clips, כמו בתוך הפלאש הראשי, אפשר לשים Movie Clips. יש רק הגבלה אחד – שMovie Clip לא יהיה בתוך עצמו (זה גם די הגיוני...).
אז למה צריך בעצם Movie Clips?
להכל!
כל עצם שרוצים ליצור במשחק – כדור, דמות, עץ – הכל בנוי מMovie Clipים.
אבל בשביל שהכל יהיה ברור יותר, אני אסביר את זה תוך כדי דוגמה.
צרו Movie Clip ותקראו לו, נניח, myMC (כשMC זה קיצור של Movie Clip).
בתוכו אתם יכולים לעשות מה שאתם רוצים. רק בשביל הדוגמה, תעשו בתוכו איזשהי אנימציה – נניח ריבוע שזז מצד לצד.
עכשיו שימו את הmovie clip על הבמה הראשית, כלומר, בפריים על המסמך שלכם. אבל, אני רוצה שעל הבמה הראשית יהיה רק פריים אחד, שבתוכו יהיה הmovie clip, כדי להראות משהו.
עכשיו תפעילו את הפלאש (תצוגה מקדימה כלשהי).
מה יקרה?
הmovieClip יעשה את האנימציה שלו, וזה כל מה שתראו.
עכשיו אני רוצה שתוסיפו לבמה הראשית עוד פריימים, אבל בפריים הראשון תעשו stop (זאת אומרת, הפקודה stop בaction script). תפעילו את הפלאש.
אם עקבתם אחרי ההוראות כמו שצריך, עכשיו אתם אמורים לראות שהפלאש עצמו לא מתנגן, אבל הmovie clip כן.
מה שאני מנסה להסביר בכל זה זה שהmovie clip לא מושפע מהסרט כולו. הסרט יכול להתנגן או לעצור, או אפילו להתנגן אחורה. הmovie clip פועל באופן עצמאי.
עכשיו אני רוצה שבmovie clip שלכם תהיה אנימציה בת 8 פריימים, ובפלאש הראשי גם כן 8 פריימים. אבל, אני רוצה שאחרי 4 פריימים בסרט הראשי, תוסיפו keyframe, בצורה כזאת שעד לאותו פריים הmovie clip יהיה קיים, ומאחריו הוא יהיה קיים בkeyframe אחר (ואם אתם לא מבינים למה הכוונה, כנראה שלא למדתם פלאש מספיק טוב לפני קריאת המדריך).
אם תריצו את הסרט עכשיו, אתם תראו שהmovie clip יבצע חצי אנימציה ויתחיל מההתחלה. למה? כי ברגע שאתם עושים keyframe חדש, הmovie clip נמחק. אחרי זה אתם יכולים לשים אותו שוב, אבל זה לא יהיה בדיוק אותו אחד, זה יהיה movie clip זהה שיווצר מחדש. שימו לב שהכוונה היא רק אם הkeyframe הוא בשכבה שבה נמצא הMC, אם יש keyframe חדש בשכבה אחרת זה לא משפיע על הmovie clip...
עכשיו אני רוצה שתעשו שוב stop בפריים הראשון של הסרט, ושתצרו עוד movie clip. את הmovie clip הזה אני רוצה שתשימו בשני מקומות – קודם כל על הבמה הראשית, ליד הmovie clip שכבר יש לכם, ודבר שני – בתוך הmovie clip הראשון, אבל בפריים השני. איך עושים את זה? בספרייה שלכם (הlibrary) תלחצו על השם של הmovie clip הראשון עם הלחצן הימני של העכבר ותבחרו edit. אפשרות נוספת היא ללחוץ לחיצה כפולה על המובי קליפ הראשון בתוך המסמך.
תסתכלו מה קורה. אני חושב שזה כבר לא דורש הסבר...
עכשיו אני רוצה שתעשו משהו אחר. אני רוצה שתכנסו לעריכה של המובי קליפ השני, ובפריים הראשון תוסיף את פקודת הaction sctip:

stop();

עכשיו תריצו את הסרט. אתם יכולים לראות (שוב, אם עשיתם הכל כמו שצריך), שהmovie clip השני לא זז. למה זה? כי עצרתם אותו.
מה למדנו? למדנו שאפשר לשלוט על כל movie clip בנפרד בעזרת action script.
עכשיו נראה מה עוד אפשר לעשות עם action script.
אני רוצה שתסמנו את הmovie clip הראשון על המסמך ובחלונית הproperties תתנו לו instance name, כמו שעשינו עם תיבות הטקסט. לצורך הדוגמה נשתמש בשם MC1.
עכשיו תוכלו לשלוט עליו מבחוץ.
למשל, בפריים שלכם (של הסרט הראשי, לא של אחד הmovie clipים) תוסיפו את הפקודה:

MC1.gotoAndStop(3);

מה יקרה? הmovie clip הראשון יעבור מיד לפריים השלישי וייעצר.



עכשיו כשהבנו פחות או יותר מה אפשר לעשות עם מוביקליפים, אני רוצה שתפתחו מסמך חדש, ונעשה בו עוד דוגמה (זה כי כבר עשיתי בלאגן במסמך הקודם ואני לא יודע איך לצאת ממנו )
צרו movie clip. בתוכו צרו איזשהי אנימציה עם 10 פריימים.
בבמה הראשית צרו שני layerים. בכל אחד מהם 20 פריימים. בlayer אחד שימו את המובי קליפ, ובשני צרו איזשהי אנימציה על מנת שנוכל לעקוב אחרי ההתקדמות שלהסרט.
תבדקו שהכל עובד כמו שצריך.
עכשיו, אני רוצה שכשהmovie clip יגיע לפריים מספר 4 הסרט הראשי ייעצר (הmovie clip ימשיך לרוץ), וכשהוא יגיע לפריים מספר 8 – הסרט הראשי ירוץ שוב. איך עושים את זה?
למדנו שעל מנת לשלוט על movie clip מתוך הבמה הראשית שלנו עושים:

instanceName.action;

אבל איך עושים את ההפך?
על מנת לשלוט על הבמה הראשית מתוך MC עושים:

_root.action;

זאת אומרת, שבפריים מספר 4 נוסיף:

_root.stop();

ובפריים מספר 8:

_root.play();

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

_root.stop();
…
_root.play();

אז למה עשינו את זה? המטרה שלי היא להסביר שroot תמיד מתייחס לבמה הראשית.
אבל מה אם אנחנו רוצים שהMC השני יפסיק ויתחיל את הMC הראשון?
פה הגיע הזמן ללמוד על parent. משתמשים בו כמו בroot:

_parent.action;

מה זה parent? כשכותבים parent הפלאש יתייחס תמיד לאובייקט שמכיל את האובייקט הנוכחי. למה הכוונה? אם יש לנו:
במה ראשית -> מובי קליפ I -> מובי קליפ II
כלומר: במה ראשית שבתוכה יש מובי קליפ I ובתוכו יש מובי קליפ II
הparent של מובי קליפ I הוא הבמה הראשית. זאת אומרת, שמבחינת מובי קליפ I, parent וroot הם אותו דבר.
אבל עבור מובי קליפ II, הparent הוא מובי קליפ I, והבמה הראשי היא root.
ובדוגמה הבאה:
במה ראשית -> מובי קליפ I -> מובי קליפ II -> מובי קליפ III
הparent של מובי קליפ III הוא מובי קליפ II.
ואם מובי קליפ III רוצי להתייחס למובי קליפ I מה עושים? עושים:

_parent._parent.action;

זאת אומרת, אפשר להתייחס לparent של הparent. אפשר להגיד שאנחנו "עולים" שתי רמות למעלה.
בקיצור, אתם מוזמנים לנסות לעשות כל מני ניסויים עם root ועם parent. וכשתבינו את העיקרון, תמשיכו...
אוקיי, סיימתם? יופי. עכשיו אני רוצה להסביר קצת על eventים של movie clip. בפרק הקודם, כשעסקנו בכפתורים, ראינו שמאוד פשוט להגדיר משהו שיקרה כשלוחצים על הכפתור:

on(release)

במקרה של movie clips יש לנו גם כן כמה eventים שמאוד פשוט להשתמש בהם. בmovie clips זה עובד ככה:

onClipEvent(אירוע){
// קוד
}

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

onClipEvent(load)

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

onClipEvent(load){
x = 0;
}

ואז אפשר, למשל, לספור כמה פעמים המובי קליפ שלנו רץ, אם נוסיף בפריים הראשון שלו:

trace(x);
x++;

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

x=0;

המשתנה היה מתאפס בכל פעם, ולכן לא היה סופר את מספר הריצות של הmovie clip. ושוב אני שולח אתכם לנסות את זה.
משהו חשוב שצריך לדעת לגבי משתנים של movie clip זה שהם שייכים רק לmovie clip. זאת אומרת, X שהוגדרת על הבמה הראשית הוא לא X שהוגדר בתוך movie clip!
עוד דוגמה למשהו שאפשר לעשות בload זה לעבור לפריים אקראי. בשביל זה אני אלמד עכשיו על פקודה בשם random.
random היא פקודה שמגרילה מספר. הפקודה random מקבלת כפרמטר (זה מה ששולחים לפונקצייה בהפעלה שלה) את מספר האפשרויות האפשריות שהיא תחזיר. משפט די מבלבל, לא? נניח שאנחנו רוצים שהיא תחזיר לנו אחד מהמספרים: 0, 1, 2. או אם אנחנו רוצים שהיא תחזיר לנו אחד מהמספרים: 1, 2, 3. או אם אנחנו רוצים אחד מהמספרים: 99, 100, 101. או אפילו: 2, 4, 6. בכל המקרים הנ"ל אנחנו רוצים אחד משלושה מספרים, ולכן נשלח לפונקצייה:

random(3);

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

random(3); // can be 0/1/2
random(10); // can be 0/1/2/3/4/5/6/7/8/9

אחרי שאנחנו עושים את הrandom אנחנו רוצים הרבה פעמים לעשות משהו עם המספר, למשל:

x = random(3)+1; // x=1/2/3
x = random(3)+99; // x=99/100/101
x = (random(3)+1)*2; // x=2/4/6

עכשיו, נניח שיש לנו 10 פריימים. אנחנו יכולים לעשות דבר כזה בaction script של הmovie clip:

onClipEvent(load){
gotoAndStop(random(10)+1);
}

שימו לה שמספרי הפריימים מתחילים מ1 ולא מ0!


הדבר הבא שאני רוצה לעשות זה לשלוט על movie clip מתוך movie clip.
נניח שיש לנו שני movie clipים. ונניח שסרט הראשי שלנו לא מתנגן, ככה שהם לא נמחקים ונוצרים מחדש כל פעם (אל תניחו, תעשו את זה...).
עכשיו, אנחנו רוצים שכMC1 יגיע לפריים מספר 2 הוא יעצור את MC2, וכשMC1 יגיע לפריים 6 הוא ימשיך את MC2.
איך עושים את זה?
ניתן לMC2, איך לא, instance name. למשל movieClip2.
עכשיו, ננסה לרשום בפריימים המתאימים של MC1:

movieClip2.action;

אבל זה לא יעבוד. למה? זה היה עובד אם המצב היה:

root->MC1->MC2

אבל זה לא המצב. המצב הוא:

root->MC1
root->MC2

ולכן, על מנת לפנות לMC2 מתוך MC1, נעשה:

_root.movieClip2.action;

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

x=0;

ובתוך הmovie clip, וזה לא משנה אם באחד הפריימים או בonClipEvent של load, אנחנו כותבים:

x=2;

אז x של הבמה הראשית הוא 0 וx של הmovie clip הוא 2. אין שום קשר בינהם.
מה שכן, אפשר להתייחס למשתנה של הבמה הראשית מתוך MC וההפך.
התייחסות למשתנה של הבמה הראשית מתוך MC:

_root.x

וההפך:

myMC.x

וכמובן, אפשר מתוך MC להתייחס למשתנה של MC אחר ככה:

_root.myMC.x

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

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

_alpha = 50;

זאת אומרת, או:

onClipEvent(load){
_alpha = 50;
}

בAS (קיצור לaction script) של המובי קליפ, או:

myMC._alpha = 50;

על הבמה הראשית (לא לשכוח להגדיר instance name), או בפריים הראשון (בתור התחלה), פשוט:

_alpha = 50;

עכשיו תריצו את הסרט. הפלא ופלא! הmovie clip שלכם יראה חצי שקוף!
למה?
כי alpha זה מאפיין של המובי קליפ שמגדיר את רמת השקיפות שלו. אם אתם מגדירים אותו כ50, המובי קליפ יהיה 50% שקוף!
עכשיו תעשו למובי קליפ דבר כזה:

_x = 100;
_y = 100;

המובי קליפ ישנה את מקומו! למה? כי אלה מאפיינים שמשפיעים על מיקומו של המובי קליפ.
איך זה עובד? הפינה העליונה השמאלית במסך היא נקודת האפס. ממנה מתחילים לספור ימינה ולמטה. x קובע את המיקום על הציר האופקי (x גדול יותר -> המובי קליפ יהיה ימינה יותר), וy קובע את המיקום על הציר האנכי (y גדול יותר -> המובי קליפ יהיה למטה יותר על המסך).
לגבי האובייקט עצמו. כשאתם יוצרים אובייקט יש נקודה קטנה במרכז האובייקט. את אותה נקודה אפשר לראות גם כשממקמים אותו על המסך שלנו, בזמן שהמובי קליפ מסומן. הנקודה הזאת היא הנקודה הנשלטת. זאת אומרת, שאם מזיזים את האובייקט לנקודה מסויימת על המסך, אותה נקודה היא זאת שזזה לנקודה הזאת, והגרפיקה\אנימציה זזה בהתאם לנקודה.
התמונה המצורפת נועדה להמחיש את זה. ניתן לראות בה את הסרגלים (ניתן להוסיף אותם למסך מתוך תפריט הview), שמראים לנו את המיקום על הפריים שלנו. ניתן לראות שהנקודה העליונה השמאלית היא נקודת ה0 בשני הצירים. באמצע האובייקט שלנו ניתן לראות עיגול לבן קטן עם + שחור בתוכו – זאת הנקודה שהפלאש מתייחס אליה. זאת אומרת, שהמובי קליפ שלנו נמצא בערך במיקום של 90 על ציר הX ו70 על ציר הY. שימו לב שאלה לא המידות שמופיעות בחלונית של הproperties, אבל אלא המידות שיופיעו אם תעשו:

trace(_x + " " + _y);

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

_width (רוחב)
_height (גובה)
_xscale (רוחב באחוזים)
_yscale (גובה באחוזים)
_visible (הסתרה של המובי קליפ)
_rotation (סיבוב של המובי קליפ, במעלות)
_currenframe (הפריים הנוכחי של המובי קליפ)

ויש עוד...

[B1ackSn0w]

6. תזמון

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

_alpha = 0;

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

_alpha++;

כל הזמן.
מחשב נכונה תהיה:

while (_alpha < 100){
_alpha++;
}

אם נשים את זה למשל בload של הmovie clip, זה אכן יעלה את רמת השקיפות עד שהMC יגיע למצב שרואים אותו. אבל זה לא טוב לנו. למה? כי למחשב זה יקח בדיוק ננושנייה לעשות את זה. אנחנו בכלל לא נשים לב שמשהו קרה, אנחנו רק נראה שהמובי קליפ לא שקוף – אנחנו פשוט נראה אותו.
מה שאנחנו צריכים זה שהפעולה תקרה כל פרק זמן מסויים. קצר, אבל קיים.
הדרך שאנחנו יודעים לעשות בעזרתה את זה תהיה להוסיף עוד movie clip, עם שני פריימים. אם הFPS שלנו (פריימים לשנייה) הוא 32, אז 16 פעמים בשנייה הפלאש תגיע לפריים השני של הMC הזה. אז אנחנו יכולים להוסיף בפריים השני את הAS:

_root.myMC._alpha++;

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

onClipEvent(enterFrame){
// code
}

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

onClipEvent(load){
_alpha=0;
}
onClipEvent(enterFrame){
if(_alpha<100){
_alpha++;
}
}

קודם אנחנו מגדירים את המובי קליפ כשקוף ואז מעלים את רמת השקיפות עד שהיא מגיעה ל100%.



עכשיו ניתן עוד דוגמה. נניח אנחנו רוצים לעשות דבר כזה:
מובי קליפ שכל פעם הופך להיות יותר ויותר שקוף
כשהוא מגיע להיות שקוף הוא חוזר מהר להיות אטום (לא מיידית אבל מהר)
כל פעם שהוא חוזר להיות אטום – מספר כלשהו, שמופיע בתיבת טקסט, עולה ב-1
מובי קליפ אחר מחכה שהמספר הזה יגיע ל5 ואז עובר לפריים הבא.
מה אנחנו צריכים לעשות?
אז ככה...
קודם כל ניצור:
* מובי קליפ שיהפוך לשקוף ולאטום
* תיבת טקסט שתכיל את המספר שלנו
* מובי קליפ עם שני פריימים שיחליף לפריים הבא שלו כשהמספר מגיע ל5
נתחיל מתיבת הטקסט
ניצור תיבת טקסט, וניתן לה בvar שם של משתנה, למשל – num.
עכשיו, בAS של הפריים הראשי נגדיר:

num = 0;

עכשיו, נעבוד על המובי קליפ שמשנה את השקיפות שלו.
נשים אותו על הבמה.
עכשיו, למובי קליפ הזה צריכים להיות שני מצבים – מצב שבו הalpha קטנה (כלומר – הוא הופך להיות שקוף) ומצב בפוך (כשהוא הופך להיות אטום). אנחנו רוצים גם שכשהוא הופך משקוף לאטום זה ילך יותר מהר, את זה עושים ע"י קפיצות גדולות יותר (במקום להעלות ב-1 כל פעם מעלים ב5 כל פעם, למשל).
עכשיו, בשביל שנדע בכל פעם באיזה מצב אנחנו, נגדיר משתנה בוליאני:

onClipEvent(load){
goingTransparent = true;
}

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

onClipEvent(enterFrame){
if (goingTransparent){
_alpha--;
} else {
_alpha+=5;
}
}

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

onClipEvent(enterFrame){
if (goingTransparent){
_alpha--;
if (_alpha<=0){
goingTransparent = false;
}
} else {
_alpha+=5;
if (_alpha>=100){
goingTransparent = true;
}
}
}

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

_root.num++;

אבל איפה נשים אותה?
אנחנו יודעים את שתי נקודות הקצה שלנו – כשאנחנו מחליפים מצבים. ככה שבעצם זה די פשוט. נוסיף את זה תחת התנאי:

if (_alpha>=100)

עכשיו מה שאנחנו רוצים זה את המובי קליפ שיעבור לפריים 2 שלו כשהמספר מגיע ל5.
בעקרון, הדרך הכי יעילה לעשות את זה תהיה לעשות את הבדיקה כל פעם שאנחנו מעלים את num ב1.
זאת אומרת:
* תעלה את num ב-1
* אם num שווה ל5:
* תעביר את MC2 לפריים מספר 2.
למה זאת הדרך הכי יעילה? כי אנחנו לא עושים דברים שאנחנו לא צריכים לעשות.
אבל אני רוצה להראות איך שאפשר לקשר בין כמה מוביקליפים.
לכן, את הבדיקה לnum נעשה דווקא במובי קליפ השני.
קודם כל אנחנו צריכים לעצור אותו (בload), ודבר שני כל הזמן לבדוק את num. הקוד צריך להיות בסופו של דבר משהו כזה:

onClipEvent(load){
stop();
}
onClipEvent(enterFrame){
if(_root.num==5){
nextFrame();
}
}

למה זה לא יעיל?
כי הבדיקה במקרה הזה תעשה כל פריים.
במקרה היעיל יותר היא תעשה בערך כל 120 פריימים – כי 100 פריימים המובי קליפ הופך להיות שקוף ועוד 20 פריימים הוא חוזר להיות אטום, ורק פעם אחת תעשה בדיקה.
יעילות זה משהו מאוד חשוב כשבונים משחקים (ובכלל). במקרה הזה, כשמדובר על פקודה אחת זניחה, זה לא כל כך משנה, ורציתי לתת פה דוגמה לאיך ששני מובי קליפים עובדים במקביל על אותו משתנה. אבל בעקרון כשבונים משחק תמיד צריך לחשוב איך לקצר במספר הפקודות ואיך לגרום לדברים לעבוד כמה שפחות פעמים, כדי שהמשחק לא יאמץ את המחשב ויהיה איטי.
יש עוד דרך לעשות תזמון של פעולות. הדרך הזאת קשה יותר אבל נותנת לנו יותר חופש.
הדרך הזאת נקראת intervalים. interval היא פקודה שמתרחשת כל זמן מסויים. יש שתי פונקציות חשובות כשעובדים עם intervalים: setInterval וclearInterval. ויש עוד פקודה אחת שקשורה באופן עקיף, אבל עוד נגיע לזה...
ההגדרה של interval היא כזאת:

setInterval(action, time);

במקום action כותבים איזה פונקציה צריכה להתבצע ובמקום time כותבים כל כמה זמן היא צריכה להתבצע. הזמן הוא במילי שניות, כלומר – 1000 מילישניות = 1 שנייה, 500 מילישניות = חצי שנייה וכו'. לכן, השליטה שלנו על התזמון בצורה כזאת הרבה יותר גבוהה.
תמיד כדאי לשמור את הinterval במשתנה. מה זאת אומרת? זאת אומרת:

myInterval = setInterval(action, time);

בצורה כזאת לא רק שיצרנו את האינטרבל אלא גם שמרנו אותו בmyInterval. זה עוזר לנו כי אחרי זה אנחנו יכולים לעשות:

clearInterval(myInterval);

ולבטל את הפעולה.
ניתן דוגמה:

myInterval = setInterval(function(){
trace('hi!');
}, 500);

הפקודה הזאת תקפיץ הודעה על חצי שנייה.
דוגמה לשינוי של גודל של אובייקט על מאית שנייה:

myInterval = setInterval(function(){
myMC._width++;
}, 10);

כשmyMC הוא כמובן instance name של מובי קליפ.
עכשיו, אם תפעיל סרטון פלאש עם הפקודה הזאת אתם תגלו שזה בכלל לא עובד חלק. יש בעייה עם הפקודה הזאת במצבה הנוכחי.
הגדרנו פה שהמובי קליפ יגדל כל מאית שנייה. אבל אם נניח הFPS (פריימים לשנייה) שלנו הם 12, הפלאש מתעדכן רק כל 80 מילישניות! זאת אומרת שאנחנו נראה את ההשפעה של האינטרבל רק אחרי 8 פעמים שהוא באמת יקרה.
מה שבעצם קורה זה שהאינטרבל אכן קורה כל 10 מילישניות, אבל המשתמש רואה שינוי בתמונה שעל המסך רק כל 80 מילישניות. מה שאנחנו צריכים לעשות זה לאלץ את הפלאש לעדכן את התצוגה אחרי כל פעם!
בשביל זה הומצאה הפקודה updateAfterEvent. היא פשוט מעדכנת את התצוגה של הפלאש. לכן, אם נעשה:

myInterval = setInterval(function(){
&nb



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

myInterval = setInterval(function(){
myMC._width++;
updateAfterEvent();
}, 10);

האנימציה תהיה חלקה הרבה יותר. אתם מוזמנים לעשות ניסוי עם ובלי ולראות את ההבדל!




7. תזוזת מובי קליפס

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

onClipEvent(enterFrame){
_x += 5;
}

או על ציר הY (למעלה ולמטה):

onClipEvent(enterFrame){
_y -= 5;
}

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

onClipEvent(load){
speedX = 0;
speedY = 0;
}
onClipEvent(enterFrame){
_y += speedY;
_x += speedX;
}

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

speedX++;
speedY++;

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

speedX += 0.5;

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

speedY += 0.3;

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

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

_xmouse
_ymouse

כשכמובן הם מחזירים את המיקום של סמן העכבר על ציר הX ועל ציר הY. בעקרון אם קוראים למאפיינים האלה מתוך movie clip הם יחזירו את המיקום של העכבר ביחס למובי קליפ (כלומר, ביחס לאותה נקודה שעליה דיברנו כמה פרקים קודם לכן). אם רוצים את המיקום של העכבר ביחס לנקודת האפס של הפלאש שלנו (הנקודה השמאלית העליונה), נקרא להם ככה:

_root._xmouse
_root._ymouse

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

onClipEvent(enterFrame){
_x = _root._xmouse;
_y = _root._ymouse;
}

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

onClipEvent(load){
startDrag();
}

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

startDrag(lockCenter, left, top, right, bottom)

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



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

Key.isDown(…)
Key.getAscii()
Key.getCode()

שימו לב שאלה פונקציות של האובייקט Key, שזה אובייקט של פלאש שאחראי על כל נושא ה... מקלדת.
כמה הסברים לפני שניגשים לעבודה.
יש טבלה שמכילה את כל התווים במחשב (אותיות גדולות וקטנות באנגלית, אותיות בעברית (אם מדובר במחשב שהשפה העברית מותקנת בו), סימנים, מספרים, רווחים – הכל). הטבלה הזאת נקראת טבלת ASCII. לכל תו בטבלה יש מספר. למשל 121 זה y (סתם דוגמה אקראית שלקחתי).
דבר נוסף זה שלכל מקש במקלדת יש קוד מספרי. למשל הקוד של המקש אנטר הוא 13.
עכשיו, איך כל זה קשור אלינו?
זה חשוב בשביל העבודה עם הפונקציות שהזכרתי למעלה.
הפונקציה הראשון היא הפונקציה שאני אישית משתמש בה הכי הרבה (ויש לזה גם סיבה הגיונית, נגיע לזה). הפונקציה isDown מקבלת מספר של מקש ובודקת אם הוא לחוץ או לא (מחזירה true/false). לכן, אנחנו יכולים לעשות דבר כזה:

if(Key.isDown(ימינה)){
// Code to move right
}

אבל איך נדע מה המקש של ימינה?
בשביל זה יש לKey כמה דברים שיכולים לעזור לנו. למשל, בשביל למצוא את הקוד של המקש ימינה, אנחנו רק צריכים לכתוב:

Key.RIGHT

זאת אומרת, שאם נעשה:

if(Key.isDown(Key.RIGHT)){
// Code to move right
}

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

if (Key.getAscii()==121){
// last key pressed was y
}

if (Key.getCode() == Key.ENTER){
// last key pressed was Enter
}


עכשיו, השאלה היותר קריטית היא איך מגלים את הקוד אסקי של תו או את התו לפי הקוד אסקי שלו?
בשביל זה אנחנו צריכים להשתמש בפונקציות של האובייקט String. בעקרון סטרינג זה משתנה שמכיל בתוכו מחרוזת של תווים (למשל "a", "yossi" או "43"). יש כמה פונקציות די שימושיות שאפשר לעשות על משתנים שמכילים תווים. אני עכשיו אתמקד במציאת קוד לפי תו או תו לפי קוד, כי זה מה שמעניין אותי.
בשביל למצוא תו לפי קוד האסקי שלו, נעשה דבר כזה:

String.fromCharCode(NUM)

כשבמקום NUM נכתוב את קוד הASCII הרצוי. אנחנו משתמשים באובייקט String.
זאת אומרת, שאנחנו יכולים לעשות דבר כזה:

trace(String.fromCharCode(Key.getAscii()));

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

abcdef

המחרוזת הזאת מכילה 6 תווים. כל תו נמצא במקום כלשהו במחרוזת. התו a נמצא במקום ה0. התו c נמצא במקום ה1. התו e נמצא במקום ה4.
למה זה חשוב?
כי הפונקצייה שמחזירה לנו את הקוד של תו מחזירה לנו את "הקוד של התו שנמצא במקום ה_".
מה זאת אומרת?
למשל:

var myStr = "abcdef";
trace(myStr.charCodeAt(1));

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

"abcdef".charCodeAt(1);

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

x = "y".charCodeAt(0); // x = 121

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

if (Key.getAscii() == "m".charCodeAt(0)){
// m was the last key pressed
}

לגבי הקוד של מקשים, לא מצאתי דרך לגלות את הקוד של מקשים אחרים חוץ מאלה שיש ברשימה. מה שאתם יכולים לעשות זה לעשות trace לKey.getCode ולבדוק את הקוד של מקשים שלכם, ולהוסיף את זה בקוד שלכם, בKey.isDown או להשוות את זה לKey.getCode.
אבל אני שוב רוצה להדגיש את ההבדל:
Key.isDown מקבל כפתור ובודק אם הוא לחוץ כרגע
שתי הפונקציות האחרות מקבלות כפתור ובודקות אם הוא היה הכפתור האחרון שהיה לחוץ. זאת אומרת שגם אם כבר לא לוחצים עליו הוא יוחזר מהפונקציות האלה.


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

קרדיט ל freak2100 מתפוז


תהנו!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

[amitTTT]

חח רק לקרוא את זה.!
זה היה בסוף החופש הגדול

[B1ackSn0w]

חחח בסדר אבל אם אתה רוצה לבנות משחק.....
הרבה עבודה

[Joni]

אנשים פה בקושי יודעים להעביר פריים

[B1ackSn0w]

אנשים פה בקושי יודעים להעביר פריים

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

[lironl1l]

תודה אחי

[B1ackSn0w]

הקפצה, נעול.

אזהרה.