יריבות ברשת: משחק איחוי נמוך ל- BBC Micro: bit: 10 שלבים (עם תמונות)

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:15

במדריך זה אסביר כיצד ליישם משחק מרובה משתתפים בסיסי ב- micro: bit של BBC עם התכונות הבאות:

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

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

מטרת המשחק שכל שחקן יהיה בקבוצה עם רוב השחקנים בזמן שכולם מומרים.

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

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

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

התרשים לעיל מציין את המצבים הבאים:

• ללא הקצאה
• תקשיב לא
• תקשיב לב
• צוות א
• צוות ב '

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

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

יישום המשחק המלא ניתן למצוא כאן:

makecode.microbit.org/_CvRMtheLbRR3 ("microbit-demo-user" הוא שם הפרויקט)

ויישום בקר הראשי ("שורש") ניתן למצוא כאן:

makecode.microbit.org/_1kKE6TRc9TgE ("microbit-demo-root" הוא שם הפרויקט)

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

שלב 1: שיקולי עיצוב תמונה גדולה

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

1. אנו רוצים לשלוט בפעולות המכשיר על סמך מצבו הנוכחי
2. אנו רוצים שהמכשיר יגיב לקלט משתמשים
3. אולי נרצה להציג אנימציות וגרפיקה באמצעות תצוגת LED 5 x 5
4. אנו רוצים לאתחל את ערכי הנתונים בזיכרון ההתקנים כאשר המכשיר מופעל
5. אנו רוצים להעביר נתונים באופן אלחוטי באמצעות רדיו המכשיר
6. אנו רוצים להאזין ולקבל נתונים באמצעות רדיו המכשיר ולעבד אותם בהתאם

הרשה לי לפרט קצת יותר על כל אחת מהן.

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

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

2. אנו רוצים שהמכשיר יגיב לקלט משתמשים

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

3. אנו רוצים להציג אנימציות וגרפיקה באמצעות תצוגת ה- 5 x 5 LED

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

4. ברצוננו לאתחל את ערכי הנתונים בזיכרון המכשירים כאשר המכשיר מופעל

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

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

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

6. אנו רוצים להאזין ולקבל נתונים באמצעות רדיו המכשיר ולעבד אותם בהתאם

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

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

1. אנחנו רוצים להיות מסוגל לבחור אות
2. אנחנו רוצים להיות מסוגלים להעביר אות

-

1. אנו רוצים להיות מסוגלים לבחור אות

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

2. אנו רוצים להיות מסוגלים להעביר אות

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

אדבר יותר על פרוטוקול האותות הפשוט בחלק הבא.

שלב 2: פרוטוקול האותות: שפה פשוטה לתקשורת רשת

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

0. אפס

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

1. המרה א

• מזהה בקוד: SIG-A
• ערך שלם: 1
• מטרה: אמור לכל מכשיר שנמצא במצב LISTEN_A, ברגע שהם מקבלים את אות ההמרה, לעבור למצב TEAM_A.

2. המרה ב

1. מזהה בקוד: SIG-B
2. ערך שלם: 2
3. מטרה: אמור לכל מכשיר שנמצא במצב LISTEN_B, ברגע שהם מקבלים את אות ההמרה, לעבור למצב TEAM_B.

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

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

ראשית, פתח פרויקט חדש ב- Make Code

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

• צור משתנים שייצגו כל אחד מחמשת המצבים האפשריים

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

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

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

שלב 4: אנו רוצים להגיב לקלט משתמשים

כעת, אנו רוצים לספר למכשיר כיצד להתמודד עם לחיצות כפתורים. המחשבה הראשונה של אחת יכולה להיות פשוט להשתמש בלוקים "כאשר לוחצים על כפתור" בקטגוריית הקלט, אך נרצה שליטה מדויקת יותר מזה. נשתמש בבלוק "on event from (X) with value (Y)" מקטגוריית הבקרה שבקטע המתקדם, מכיוון שאנו מתקדמים במדריך זה.

• צור ארבעה בלוקים "על אירוע מ …".

  • שניים מאלה צריכים לבדוק את מקור האירוע "MICROBIT_ID_BUTTON_A"
  • שניים מאלה צריכים לבדוק את מקור האירוע "MICROBIT_ID_BUTTON_B"

  • מתוך שני האירועים המכוונים לכל כפתור:

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

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

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

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

• הוסף גושי הקצאה המשנים את מצב המכשיר כפי שצוין בתרשים המצב שלנו

  • אנו יודעים שכאשר המכשיר נמצא במצב UNASSIGNED, המכשיר צריך להגיב על כפתור A שנלחץ על ידי מעבר למצב LISTEN_A וללחצן B שנלחץ על ידי מעבר למצב LISTEN_B
  • אנו גם יודעים שכאשר המכשיר נמצא במצב LISTEN_A או LISTEN_B, המכשיר צריך להגיב על כפתור A משוחרר ולחצן B משוחרר, בהתאמה, על ידי מעבר חזרה למצב UNASSIGNED.

  • לבסוף, אנו יודעים שכאשר המכשיר נמצא במצב TEAM_A או TEAM_B, המכשיר צריך להגיב ללחצן A שנלחץ ולחצן B נלחץ על ידי שידור SIG_A ועל ידי שידור SIG_B בהתאמה.

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

שלב 5: אנו רוצים לאתחל את ערכי הנתונים בזיכרון המכשירים כאשר המכשיר מאתחל

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

אלה הערכים שעלינו לאתחל:

• קבועי איתות, בהתאם לפרוטוקול האותות. הערכים חייבים להיות:

  • SIG_R = 0
  • SIG_A = 1
  • SIG_B = 2
  • הערה: קידמתי את הקבועים האלה עם "EnumSignals" על מנת לציין שמשתנים אלה אמורים להתנהג כאילו הם חלק מסוג מונה בשם Signals. כך ניתן ליישם משתנים אלה בשפות תכנות אחרות. ההגדרה וההסבר של סוגים מנויים הם מעבר להיקף ההדרכה שלי. אפשר לגוגל אם ירצו בכך. הקידומות הללו הן פשוט בחירות סגנוניות ואינן חיוניות כלל לתפקודה התקין של התוכנית.

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

  • UNASSIGNED = 0
  • LISTEN_A = 1
  • LISTEN_B = 2
  • TEAM_A = 3
  • TEAM_B = 4
  • הערה: קיבלתי את אותה החלטה בסגנון גם לגבי קידומות למשתנים אלה. בנוסף, אציין כי כל מה שקשור למשימות אלה, הערכים והסדר, הוא שרירותי לחלוטין. זה אפילו לא משנה שערכים אלה עקביים ממכשיר למכשיר, מכיוון שהם משמשים רק פנימית ולא לתקשורת דרך הרשת. כל מה שחשוב הוא שלמשתנים יש ערך וניתן להשוות אותם זה לזה כדי לראות אם הם שווים או לא.
• לשם קריאות, קבוע קבוע BOOT_STATE והגדר אותו ל- UNASSIGNED. זה הופך את העובדה שאנו מתאפסים למצב האתחול, במקום למצב שרירותי יותר, מפורשת יותר כאשר המכשיר מקבל אות איפוס, אותו ניישם בהמשך.

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

  • TICKS_PER_FRAME_LOADING_ANIMATION = 50
  • MS_PER_DEVICE_TICK = 10
  • MS_PER_FRAME_BROADCAST_ANIMATION = 500
  • MICROSECONDS_PER_MILLISECOND = 1000
  • NUMBER_OF_FRAMES_IN_LOADING_ANIMATION = 4

• משתנה נוסף לאנימציה, הפעם מונה שבהחלט אינו קבוע. כמו רוב המונים, אנו מאתחלים אותו ל -0

  iTickLoadingAnimation = 0

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

  צור את אותם ערכי תמונה כמו שעשיתי או צור תמונות מקוריות ומגניבות יותר

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

שלב 6: אנו רוצים להציג אנימציות וגרפיקה באמצעות תצוגת LED 5 X 5

ועכשיו למשהו שונה לגמרי.

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

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

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

  • LISTEN_A: 'א'
  • LISTEN_B: 'b'
  • TEAM_A: 'א'

  • TEAM_B: 'B'

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

• עבור למצב javascript.
• מצא כל שיחה ל- X.showImage (0) ו- basic.showString (X)

• שנה כל אחת ל- X.showImage (0, 0) או basic.showString (X, 0)

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

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

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

• הוסף גוש "המתן (לנו) (X)" לאחר כל שיחה לפונקציה של הצגת תמונות.

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

• החלף (X) ב- (MS_PER_FRAME_BROADCAST_ANIMATION x MICROSECONDS_PER_MILLISECOND)
• כעת האנימציה צריכה לפעול כראוי

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

• צור פונקציה שתעדכן את הנפשת הטעינה

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

  אם התנאי נכון, אפס את iTickLoadingAnimation ל -0

• הוסף גוש של תנאים אם-אחר. אלה יקבעו איזו מסגרת של האנימציה להציג.

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

• בתחתית הבלוק, יש להגדיל את iTickLoadingAnimation
• כעת האנימציה צריכה לפעול כראוי

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

שלב 7: אנו רוצים להעביר נתונים באופן אלחוטי באמצעות רדיו המכשיר

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

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

• כפתור A נלחץ:

  • אם המכשיר נמצא במצב TEAM_A:

    אות שידור SIG_A

• על כפתור B נלחץ:

  • אם המכשיר נמצא במצב TEAM_B

    אות שידור SIG_B

צור פונקציות אלה אם הן אינן קיימות כבר.

בכל פונקציה:

• התקשר לפונקציית האנימציה המשודרת. זה יחסום כל דבר אחר שיקרה עד להשלמתו, אשר תהיה ב- MS_PER_FRAME_BROADCAST_ANIMATION * 3 = 1.5 שניות. הקבוע מוכפל בשלוש מכיוון שישנן שלוש מסגרות בהנפשה. זה שרירותי וניתן להוסיף עוד אם השדרוג האסתטי מספיק גדול. מטרה שנייה של אנימציה זו היא למנוע ממשתמש לדואר זבל על פונקציית השידור.
• הוסף בלוק "מספר שליחת רדיו (X)", היכן נקבע קבוע האות בשם הפונקציה

זה כל מה שצריך לשדר ברדיו.

שלב 8: אנו רוצים להאזין ולקבל נתונים דרך הרדיו של המכשיר ולעבד אותם בהתאם

זהו השלב האחרון ליצירת האפליקציה הראשית.

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

ראשון:

1. צור גוש קוד המתחיל בגוש "ברדיו שהתקבל (X)".
2. לחלופין, הקצה את הערך המתקבל למשתנה אחר בעל שם יותר תיאורי.
3. התקשר לפונקציה שתעבד את האות

שנית, בפונקציית עיבוד האותות:

1. צור בלוק של הצהרות if-else שמעבירות את זרימת השליטה בהתבסס על ערך האות.

2. אם האות היה SIG_R

   הגדר את מצב המכשיר ל- BOOT_STATE (זו הסיבה שיצרנו את הקבוע הזה קודם לכן)

3. אם האות היה SIG_A ואם המצב הנוכחי הוא LISTEN_A

   הגדר את מצב המכשיר ל TEAM_A

4. אם האות היה SIG_B ואם המצב הנוכחי הוא LISTEN_B

   הגדר את מצב המכשיר ל TEAM_B

זהו זה. הבקשה הסתיימה.

שלב 9: מכשיר שורש: אנו רוצים להיות מסוגלים לבחור אות

כעת, נכתוב יישום פשוט למכשיר "שורש", כלומר מכשיר שישלוט ברשת.

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

• אנו רוצים לאפשר למשתמש לבחור באחד האותות שלנו
• אנו רוצים לאפשר למשתמש לשדר את האות

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

כדי לאפשר למשתמש לבחור אות:

1. אתחל 5 משתנים בבלוק "בהתחלה":

   1. שלושת האותות (0, 1, 2)
   2. מספר האותות (3)
   3. משתנה להחזקת האות שנבחר כעת (נקבע לראשונה לאות הראשון, 0)

2. לטפל בלחיצה על כפתור A:

   1. הגדל את האות שנבחר

   2. בדוק אם האות שנבחר גדול או שווה למספר האותות

      אם כן, הגדר את האות שנבחר ל -0

3. לאחר בלוק ההתחלה, הפעל לולאה "לנצח" המציגה את ערך האות הנוכחי שנבחר ללא עיכוב

כדי לאפשר למשתמש לשדר אות

1. הגדר את קבוצת הרדיו ל -0 בלוק "בהתחלה"

2. לטפל בלחיצת כפתור B:

   שדר את האות שנבחר באמצעות בלוק "מספר שליחת רדיו (X)"

זהו זה. יישום צומת השורש הוא פשוט ביותר.

שלב 10: סיימנו

למעלה תמונה של המכשירים שמריצים את היישום. השניים מימין מפעילים את יישום ה"משתמש "הראשי, והאחד משמאל מפעיל את היישום" שורש ".

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

מידע נוסף אודות חיבורי CS 2018 ניתן למצוא כאן.