מדובר בטיפ מתוך השרשור הזה.

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

הגענו לסוף המשחק (איקס עיגול...).. ויש לנו מנצח.
אני רוצה שה"חיילים" המנצחים יהבהבו.

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

קוד:

wiener = function(tor,x,y,z){
.
.
for (i=1;i+=10;i++){
???????
 }

בתוך הלולאה בפונקציה אני רוצה לגרום להיבהוב המובי קליפ, נניח של מובי קליפ מס' X.
איך אני כותבת את זה?

קוד:

_root.x._visible=!_root.x._visible;

ממ.. אוקיי, תודה.
שכחתי לציין שכשאמרתי "אינדקס" התכוונתי לpion1,pion2 וכו...
אבל הסתדרתי כמו מה שכבר לימדתם אותי.:

קוד:

_root["pion"+(x)]._visible=!_root["pion"+(x)]._visible;
  

נראה לי שזה פועל, אבל ישנה כעת בעיה אחרת. מישום מה זה גורם למחשב להאט את הפעילות שלו.
מה גורם הבעיה?
המחשב מציג לי הודעה בחלון בשם Flash Player.
ההודעה כזו:
A script in this movie is causing Flash Player to run slowly.
בהמשך הוא אומר שאם אני ממשיכה להריץ את התוכנית אז המחשב יהפוך לבלתי מגיב.
ואז הוא שואל אם אני רוצה to abrot את הסקריפט. (אין לי מושג מה זה המילה הזו.)
יש לי בחירה בין לחצן "כן" ו"לא".

ניסיתי "לא"- ופלאש נתקע. ניסיתי "כן" והמשיך לעבוד- אבל את ההרצה הוא הפסיק.

מה קורה לו??

ואז לרוץ עליו עם לולאה ולגרום להם להבהב.

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

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

המערך מול הטבלה הגראפית נראה כך:
1 2 3
4 5 6
7 8 9

אחרי כל פעם שנלחץ מובי קליפ, אני בודקת האם יש ניצחון (האם 123 זהים, או 147 וכו......).
אם יש ניצחון - הפונקציה wiener נכנסת לפעולה.
תפקידי הפונקציה: 1. להדפיס בחלון הפלט מי המנצח,
2. לגרום לחיילים המנצחים להבהב.

איך היא יודעת מי החיילים המנצחים? פשוט- הבדיקה אם יש ניצחון נעה על לולאה עבור בדיקת ניצחון בשורה, בעמודה. והאלכסונים בנפרד. כשנמצא נצחון אני שולחת את מס' החיילים המנצחים (נניח מס' 1,2,3) לפונקציה.
בפונקציה הם משמשים שוב כדי לגשת למובי קליפ שלהם- עם השם+אינדקס. (pion1,pion2,pion3).

תחל'ס הבעיה כעת היא באיך אני גורמת להם להבהב- בלי שהמחשב יתבלב מההבהוב..

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

הפלט היה מפתיע!

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

קוד:

for (i=1;i+=4;i++){
   _root["pion"+(x)]._visible=!_root["pion"+(x)]._visible;
   trace (i);
  }
  

מה בסך הכל ביקשתי ממנו?!

לפי הבדיקה תקבעי מערך של חיילים מנצחים, לדוגמא 1, 4, 7, אז:

קוד:

 win_ar = new Array(1, 4, 7)

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

נבנה פונקציה של הבהוב, ופונקציה של קריאה להבהוב, נשתמש ב setInterval, פונקציית ההבהוב תראה כך, מאוד פשוטה:

קוד:

 

function lighter(mvc:MovieClip) {
 mvc._visible = !mvc._visible
}

הפונקצייה שעושה setInterval לפונקציה של ההבהוב בשביל כל מוביקליפ:

קוד:

function mark(mvc:MovieClip) {

this[mvc._name + "Int"] = setInterval(lighter, 100, mvc)
}

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

קוד:

 
function markWinners() {
for (i = 0; i < win_ar.length; i++) {
mark(this["pion" + win_ar[i]])
}
}

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

אם הסתבכת הכנתי בשבילך קובץ שמדגים את הקוד הנ"ל:

https://2006-uploaded.fresh.co.il/2...13/69734479.fla

איזו פאדיחה!
כ"כ הרבה פעמים בדקתי ושוב בדקתי את הלולאה הזו- ולא שמתי לב!!
במיוחד בדקתי אחרי שראיתי שהבעיה טמונה בה ע"י שראיתי את הפלט המוזר..

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

לילה טוב בנתיים.

קודם כל, to abort = לבטל.

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

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

אם זה עדיין עושה לך בעיות אני אשמח לעזור (אישית אני אוהב לעבוד עם ActionScript בפלאש והצלחתי להגיע איתו לתוצאות ברמה מאוד גבוהה).

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

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

שימוש ב-onEnterFrame באמת יעבוד, אך לא יאפשר קביעת השהיה.
גם אני מעדיף לפתור ב-AS כמה שאפשר, אך צריך ללמוד לשלב AS עם אנימציה בכדי לקבל את התוצאות הרצויות.

מה גם שמשם לא נבעה הבעיה אז זה לא רלוונטי.

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

איך שאני רואה את זה, בשביל ליצור הבהוב תצטרך לשנות את מצב ה-_visible של ה-MC מספר פעמים. בשביל לגרום לזה לקרות תצטרך להשתמש באינטרבל (לא מומלץ ומיותר לחלוטין במקרה הזה), או לשנות ל-MC מצב _visible פעם בכל כניסה ל-frame (תלוי בכמה fps אתה עובד, ייתכן וזה מהיר מדי), או להשתמש באפשרות של flash ליצור מספר פריימים ב-MC שבהם יהיה הסקריפט שמשנה מצב _visible + השהיה של מספר פריימים כשבפריים האחרון הוא חוזר לשינוי מצב ה-_visivle (עדיף מאינטרבל ומאפשר השהיה לפי טעמו של המתכנת), כאשר אתה שולח את ה-MC הרצויים לפריים הנתון בכדי להתחיל את ההבהוב.

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

ציטוט:

בשביל ליצור הבהוב תצטרך לשנות את מצב ה-_visible של ה-MC מספר פעמים. בשביל לגרום לזה לקרות תצטרך להשתמש באינטרבל (לא מומלץ ומיותר לחלוטין במקרה הזה)

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

ציטוט:

או לשנות ל-MC מצב _visible פעם בכל כניסה ל-frame (תלוי בכמה fps אתה עובד, ייתכן וזה מהיר מדי)

זה ממש לא תלוי FPS שאיתו אתה עובד, אין בעיה להשהות או לעצור enterframe (למען האמת זה דורש הרבה פחות עבודה מלעשות זאת באנימציה).

ציטוט:

או להשתמש באפשרות של flash ליצור מספר פריימים ב-MC שבהם יהיה הסקריפט שמשנה מצב _visible + השהיה של מספר פריימים כשבפריים האחרון הוא חוזר לשינוי מצב ה-_visivle (עדיף מאינטרבל ומאפשר השהיה לפי טעמו של המתכנת), כאשר אתה שולח את ה-MC הרצויים לפריים הנתון בכדי להתחיל את ההבהוב.

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

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

ציטוט:

זה דורש ממך לערוך כל מוביקליפ בפני עצמו

בוא נראה.. יש לנו איקס, ויש לנו עיגול.. 2 MC בספריה, אותם אנחנו מכפילים על הבמה... כלומר הצורך הרב בעריכת מובי קליפים מסתכם סך הכל ב-2.

ציטוט:

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

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

ציטוט:

זה ממש לא תלוי FPS שאיתו אתה עובד

להזכירך, U did it עובדת עם המדריך הזה ליצירת הבהוב, בו נאמר במפורש שיש להשתמש ב-onEnterFrame, כלומר הפונקציה המודבקת לארוע מתבצעת פעם אחת בכל פריים (בד"כ 20+ פעמים בשנייה, אך כפי שאמרתי תלוי בערך שהמתכנת הציב).

ציטוט:

אין בעיה להשהות או לעצור enterframe (למען האמת זה דורש הרבה פחות עבודה מלעשות זאת באנימציה).

השהיה בתןך onEnterFrame, כלומר לספור מספר פריימים בהם תבוצע ההשהיה ?
הרבה יותר פשוט יהיה לפתוח את ה-MC, להוסיף מספר פריימים ל-timeLine (לחיצה על F5 מספר פעמים) וקביעת keyFrame במקום הרצוי (לחיצה על F6) ולהוסיף 2 שורות קוד

קוד:

 this._visible = !this._visible;
this.gotoAndPlay(2); 

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

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

ציטוט:

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

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

ציטוט:

בוא נראה.. יש לנו איקס, ויש לנו עיגול.. 2 MC בספריה, אותם אנחנו מכפילים על הבמה... כלומר הצורך הרב בעריכת מובי קליפים מסתכם סך הכל ב-2.

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

ציטוט:

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

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

ציטוט:

להזכירך, U did it עובדת עם המדריך הזה ליצירת הבהוב, בו נאמר במפורש שיש להשתמש ב-onEnterFrame, כלומר הפונקציה המודבקת לארוע מתבצעת פעם אחת בכל פריים (בד"כ 20+ פעמים בשנייה, אך כפי שאמרתי תלוי בערך שהמתכנת הציב).

אני יודע בדיוק מה כתוב שם, אחרי הכל, אני הו זה שכתב את זה (זה אני בכינוי הקודם שלי).
לא כתוב שם במפורש להשתמש בenterframe, רק השתמשתי בזה על מנת להסביר את הקוד עצמו שהוא השורה הקטנה והפשוטה
_visible=!_visible.
ובכל מקרה, גם במקרה שלה זה נכון לעבוד עם enterframe (כמה פעמים לחזור?) אבל זה לא אומר שאי אפשר להשהות בעזרת קאונטר או delete את הenterframe כשצריך. כך שבסופו של דבר זה לא תלוי בfps.

ציטוט:

השהיה בתןך onEnterFrame, כלומר לספור מספר פריימים בהם תבוצע ההשהיה ? הרבה יותר פשוט יהיה לפתוח את ה-MC, להוסיף מספר פריימים ל-timeLine (לחיצה על F5 מספר פעמים) וקביעת keyFrame במקום הרצוי (לחיצה על F6) ולהוסיף 2 שורות קוד

לא, זה לא יותר פשוט וזה הרבה פחות גמיש.

ציטוט:

בכדי לא לסבך את U did it עם כל מיני ספירות פריימים למיניהן בתוך הפונקציה של onEnterFrame בכדי ליצור השהייה מלאכותית, הצעתי את הדרך הפשוטה והנגישה ביותר תוך שימוש בשיטה שהיא רצתה לעבוד בה. אל תהיה נעול על ליצור הכל ב-AS, משום שהשילוב בין AS לבין אנימציה הוא הדרך הטובה ביותר לפתרון בעיות מסויימות.

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

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

סוף שבוע נעים

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

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

ציטוט:

במקור נכתב על ידי -FoxyBrain- ותאמין לי שיש ל U did it מספיק ידע ורצון ללמוד (על פי מה שראיתי בימים האחרונים) כדי להבין ולהצליח בדרך "הנכונה" לביצוע הפעולה המבוקשת.

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

מקווה שלא איכזבתי
אני ממש לא חושבת שאני יודעת קמצוץ של משהו ממה שצריך לדעת- אבל זה נכון שיש לי את הרצון ללמוד.

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

מממ.. אני חושבת שכרגע מה שחסר זו השהיה.

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

קוד:

wiener = function(tor,x,y,z){
  win_ar = new Array(x, y, z);
  if (tor){ 
	trace ("עיגול הוא המנצח!"); 
  }
  else{
	trace ("איקס הוא המנצח!"); 
  }
 
//כאן אני רוצה שתיהיה לולאת וואיל:"כל עוד כפתור האיתחול לא נלחץ בצע:
	for (i=0;i<3;i++){
	  _root["pion" + win_ar[i]]._visible=!_root["pion" + win_ar[i]]._visible;
	  trace (i);
	}
 
  trace (x+","+y+","+z);
 
};
 

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

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

לילה טוב...

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

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

קוד:

 
for (i=0;i<3;i++){
  _root["pion" + win_ar[i]].onEnterFrame = function()
  {
	this._visible = !this._visible;
  }
}

בצורה זו, ע"י הרצה אחת של לולאת ה-for את קובעת פונקציה שמתבצעת בכל פעם שה-mc עובר פריים (אם ה-mc כולל פריים 1 אז המעבר עדיין מתבצע. כשה-mc נגמר הוא חוזר להתחלה - פריים 1).

בהתחשב ב-fps שקבעת ייתכן וזה יהיה יותר מדי מהיר (בד"כ 20 פעמים לשנייה).

קוד:

win(true, aClips, 5);
function win(bType, aWinners, nBlinkDelay){
	if(bType){
		trace ("[O] wins"); 
	}
	else{
		trace ("[X] wins"); 
	}
	
	blink(a, 5);
}

function blink(aWinners, nBlinkDelay){
	for(var i=0; i<aWinners.length; i++){
		aWinners[i].counter = 1;
		aWinners[i].onEnterFrame = function(){
			if(this.counter >= nBlinkDelay){
				this._visible = !this._visible;
				this.counter  = 1;
			}
			this.counter++;
		}
	}
}

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

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

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

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

אתה שלחת מערך שלם אל הפונקציה בעוד שאני שלחתי את המנצחים- מה עדיף ולמה?

תודה על התגובה.