رقابت شبکه ای: بازی کم تأخیر برای BBC Micro: بیت: 10 مرحله (همراه با تصاویر)

2024 نویسنده: John Day | [email protected]. آخرین اصلاح شده: 2024-01-30 08:55

در این آموزش ، نحوه پیاده سازی یک بازی چندنفره اساسی در میکرو BBC: bit را با ویژگی های زیر توضیح خواهم داد:

• رابط کاربری ساده
• تاخیر کم بین فشار دادن دکمه ها و به روزرسانی های صفحه
• تعداد انعطاف پذیر شرکت کنندگان
• کنترل آسان بر روی بازی با استفاده از دستگاه اصلی از راه دور ("root")

این بازی در اصل شبیه سازی سیاست است. همه بازیکنان بدون انتساب به هیچ تیمی شروع می کنند ، به جز دو بازیکن. یکی از این بازیکنان به تیم A و دیگری به تیم B اختصاص داده شده است.

هدف از بازی برای هر بازیکن این است که در تیم با اکثریت بازیکنان در زمانی که همه تبدیل می شوند ، حضور داشته باشد.

نمودار بالا یک ماشین حالت محدود را نشان می دهد ، یعنی مشخصاتی از حالاتی که دستگاه می تواند در آن باشد و انتقال بین این حالت ها.

یک حالت را می توان مجموعه ای از داده های فعلی دانست که حافظه دستگاه را از زمان روشن شدن توصیف می کند. بر اساس این داده ها ، دستگاه ممکن است اقدامات خاصی را انجام دهد یا به ورودی کاربر واکنش متفاوتی نشان دهد.

انتقال یک شرط منطقی است که در صورت درست بودن باعث تغییر وضعیت دستگاه می شود. انتقال می تواند از یک حالت به حالت دیگر باشد. یک حالت ممکن است چندین تغییر داشته باشد.

نمودار بالا حالات زیر را مشخص می کند:

• واگذار نشده
• به A گوش دهید
• B را بشنوید
• تیم الف
• تیم B

دستگاهی که کد بازی را اجرا می کند ممکن است در هر یک از این پنج حالت باشد ، اما فقط یکی در یک زمان ، و فقط این پنج حالت.

من در سراسر راهنما فرض می کنم که از ویرایشگر MakeCode مایکروسافت استفاده می کنید ، که در آدرس زیر قابل مشاهده است:

اجرای کامل بازی را می توانید در اینجا مشاهده کنید:

makecode.microbit.org/_CvRMtheLbRR3 ("microbit-demo-user" نام پروژه است)

و پیاده سازی کنترلر اصلی شبکه ("root") را می توانید در اینجا پیدا کنید:

makecode.microbit.org/_1kKE6TRc9TgE ("microbit-demo-root" نام پروژه است)

من در طول آموزش به این مثالها اشاره می کنم.

مرحله 1: ملاحظات طراحی تصویر بزرگ

قبل از نوشتن کد ، باید به این فکر کنیم که محصول نهایی ما چگونه می خواهد باشد. به عبارت دیگر ، الزامات برنامه چیست؟ وقتی کد دستگاه به پایان رسید کد ما باید به آن چه بگوید؟ من عملکرد برنامه اصلی را به شش دسته تقسیم کرده ام که هر کدام را می توان از منظر طراحی متفاوت در نظر گرفت.

1. ما می خواهیم اقدامات دستگاه را بر اساس وضعیت فعلی آن کنترل کنیم
2. ما می خواهیم دستگاه به ورودی کاربر واکنش نشان دهد
3. ممکن است بخواهیم انیمیشن ها و گرافیک ها را با استفاده از صفحه نمایش LED 5 * 5 نمایش دهیم
4. هنگامی که دستگاه بوت می شود ، می خواهیم مقادیر داده را در حافظه دستگاه ها مقداردهی کنیم
5. ما می خواهیم داده ها را به صورت بی سیم با استفاده از رادیوی دستگاه منتقل کنیم
6. ما می خواهیم داده ها را از طریق رادیوی دستگاه بشنویم و دریافت کنیم و بر اساس آن پردازش کنیم

به من اجازه دهید کمی بیشتر در مورد هر یک توضیح دهم.

1. ما می خواهیم اقدامات دستگاه را بر اساس وضعیت فعلی آن کنترل کنیم

مانند بسیاری از برنامه های دیگر ، اجرای دستورالعمل های مشخص شده توسط کد در یک خط انجام می شود. ما می خواهیم دستگاه ما دستورالعمل های خاصی را بر اساس وضعیت داخلی خود اجرا کند ، همانطور که در نمودار بالای این آموزش نشان داده شده است. ما می توانیم پس از هر بلاک کد که دستگاه را بررسی می کند ، یک سری شرطی بنویسیم ، اما این رویکرد می تواند خیلی سریع به هم ریخته باشد ، بنابراین ما در عوض از یک حلقه بی نهایت استفاده می کنیم که به سادگی یک متغیر را بررسی می کند و بر اساس آن متغیر ، مجموعه خاصی از دستورالعمل ها را اجرا می کند یا اصلاً کاری انجام نمی دهد. این متغیر با پسوند "_state" در برنامه کاربر و برنامه اصلی ما مشخص می شود.

2. ما می خواهیم دستگاه به ورودی کاربر واکنش نشان دهد

علیرغم اجرای عادی کد به صورت متوالی ، یعنی یک خط در یک زمان ، ما نیاز داریم که دستگاه ما در برابر فشار دکمه ها واکنش نشان دهد در حالی که حلقه حالت اصلی تعیین می کند که دستگاه در هر لحظه چه کاری باید انجام دهد. برای این منظور ، دستگاه می تواند سیگنال هایی را به نرم افزارهای سطح پایین ارسال کند که با سخت افزار در ارتباط هستند و آنچه را که رویداد نامیده می شود ، فعال می کند. ما می توانیم کدی بنویسیم که به دستگاه می گوید در صورت تشخیص نوع خاصی از رویداد ، کاری انجام دهد.

3. ما می خواهیم انیمیشن ها و گرافیک ها را با استفاده از صفحه نمایش LED 5 * 5 نمایش دهیم

به نظر می رسد مکانیسم انجام این کار ساده باشد ، اما نمایش بلوک یک تصویر تأخیر پنهان 400 میلی ثانیه را اضافه می کند. از آنجا که ما می خواهیم دستگاه ما با کمترین تأخیر به اجرای حلقه حالت خود ادامه دهد ، باید کد جاوا اسکریپت را ویرایش کنیم تا تاخیر را به حداقل برسانیم.

4. هنگامی که دستگاه بوت می شود ، می خواهیم مقادیر داده را در حافظه دستگاه ها مقداردهی کنیم

قبل از اینکه دستگاه ما کاری انجام دهد ، برنامه باید داده های خود را در حافظه بارگذاری کند. این شامل متغیرهای ثابتی است که برای خوانایی کد نامگذاری شده اند ، متغیرهایی که حاوی تصاویر هستند ، که ممکن است بخشی از یک انیمیشن باشند ، و متغیرهای شمارنده ای که برای کار صحیح باید از 0 شروع کنند. در انتها یک لیست طولانی از نام متغیرها و مقادیر تازه تعیین شده آنها به دست می آوریم. به عنوان یک انتخاب سبک شخصی ، من مقادیر ثابت را مشخص می کنم ، یعنی مقادیری که هرگز نیازی به تغییر آنها ندارم ، با استفاده از ALL_CAPS. همچنین شناسه های متغیر اصلی را با نام دسته ای که به نوعی از شیء یا نوع که شناسه در آن قرار دارد اشاره می کند. این تلاش می کند تا کد را آسان تر دنبال کنید. من هرگز از نام متغیری مانند "item" یا "x" به دلیل ابهامی که هنگام تلاش برای رمزگشایی کد ایجاد می شود ، استفاده نخواهم کرد.

5. ما می خواهیم داده ها را به صورت بی سیم با استفاده از رادیوی دستگاه منتقل کنیم

این در واقع یک کار نسبتاً ساده هنگام استفاده از زبان بلوک های MakeCode است. ما به سادگی همه دستگاهها را هنگام بوت در یک گروه رادیویی تنظیم می کنیم و سپس وقتی می خواهیم سیگنالی ارسال کنیم ، می توانیم یک شماره را به بلوک "ارسال شماره رادیو" که به ما ارائه شده است منتقل کنیم. این مهم است که فرستنده و گیرنده در یک گروه رادیویی کار می کنند ، زیرا در غیر این صورت ، آنها در فرکانس های مختلف ارسال یا دریافت می کنند و ارتباط ناموفق است.

6. ما می خواهیم داده ها را از طریق رادیوی دستگاه بشنویم و دریافت کنیم و بر اساس آن پردازش کنیم

با در نظر گرفتن ملاحظات مشابه مورد قبلی ، ما به انتقالهای ورودی همانطور که برای ورودی کاربر گوش می دهیم: با یک کنترل کننده رویداد. ما یک بلوک کد می نویسیم که هرگونه سیگنال ورودی را بررسی می کند و بررسی می کند که آیا اقدامی باید انجام شود بدون اینکه مزاحم حلقه اصلی باشد.

علاوه بر این ، ما باید به طور خلاصه طراحی برنامه بسیار ساده تر root را در نظر بگیریم ، برنامه ای که به دستگاه اجازه می دهد کل شبکه را کنترل کند. من زمان زیادی را صرف این کار نمی کنم زیرا بسیار ساده تر از طرح فوق است و بیشتر آن به سادگی تکرار می شود. من عملکرد ریشه را به سه دسته تقسیم کرده ام.

1. ما می خواهیم بتوانیم یک سیگنال را انتخاب کنیم
2. ما می خواهیم قادر به ارسال سیگنال باشیم

-

1. ما می خواهیم قادر به انتخاب یک سیگنال باشیم

این را می توان به سادگی با یک دکمه که از طریق سیگنال های احتمالی تکرار می شود ، انجام داد. از آنجا که تنها سه مورد وجود دارد ، این روش کافی است. در عین حال ، می توانیم یک حلقه داشته باشیم که به طور مداوم سیگنال انتخاب شده را مجدداً نمایش می دهد و به کاربر اجازه می دهد یک دکمه را فشار داده و سیگنال انتخاب شده را با تاخیر بسیار کمی روی صفحه LED نشان دهد.

2. ما می خواهیم قادر به ارسال سیگنال باشیم

از آنجا که دو دکمه وجود دارد ، می توانیم یکی را برای انتخاب و دیگری را برای تأیید تعیین کنیم. مانند برنامه کاربر ، ما به سادگی سیگنال را از طریق شبکه به عنوان یک شماره ارسال می کنیم. هیچ اطلاعات دیگری مورد نیاز نیست.

در بخش بعدی بیشتر در مورد پروتکل سیگنال ساده صحبت خواهم کرد.

مرحله 2: پروتکل سیگنال: یک زبان ساده برای ارتباطات شبکه ای

سیگنال های زیر را می توان مجموعه ای از کلمات احتمالی دانست که دستگاه ها می توانند برای صحبت با یکدیگر استفاده کنند. از آنجا که شبکه بسیار ساده است ، چیزهای زیادی برای گفتن وجود ندارد ، بنابراین ما می توانیم این سه سیگنال را با مقادیر صحیح ساده نشان دهیم.

0. بازنشانی

• شناسه در کد: SIG-R
• مقدار صحیح: 0
• هدف: به همه دستگاه های موجود در محدوده بگویید آنچه را که انجام می دهند رها کنند و طوری عمل کنند که انگار تازه راه اندازی شده اند. اگر این سیگنال به تمام دستگاه های شبکه برسد ، کل شبکه بازنشانی می شود و کاربران می توانند یک بازی جدید را شروع کنند. این سیگنال فقط توسط یک دستگاه ریشه قابل پخش است.

1. تبدیل A

• شناسه در کد: SIG-A
• مقدار صحیح: 1
• هدف: به هر دستگاهی که در وضعیت LISTEN_A است ، بگویید که سیگنال تبدیل را دریافت کرد ، به حالت TEAM_A تغییر وضعیت دهد.

2. تبدیل ب

1. شناسه در کد: SIG-B
2. مقدار صحیح: 2
3. هدف: به هر دستگاهی که در وضعیت LISTEN_B قرار دارد ، پس از دریافت سیگنال تبدیل ، به حالت TEAM_B تغییر دهید.

مرحله 3: ما می خواهیم اقدامات دستگاه را بر اساس وضعیت فعلی آن کنترل کنیم

در نهایت ، می توانیم نوشتن کد را شروع کنیم.

ابتدا یک پروژه جدید در Make Code باز کنید

• یک تابع جدید ایجاد کنید. من حلقه mine را صدا کردم زیرا این حلقه اصلی برنامه است
• یک حلقه بلوک اضافه کنید که به طور نامحدود تکرار می شود. من در حالی که (true) استفاده می کردم ، زیرا یک حقیقت واقعی هرگز اشتباه نخواهد بود ، بنابراین جریان کنترل برنامه هرگز از حلقه خارج نمی شود
• به اندازه کافی بلوک if-else اضافه کنید تا بررسی کنید آیا دستگاه در هر یک از پنج حالت ممکن خود قرار دارد یا خیر
• یک متغیر برای نگه داشتن وضعیت دستگاه فعلی ایجاد کنید

• متغیرهایی را برای نمایش هر یک از پنج حالت ممکن ایجاد کنید

  توجه: اشکالی ندارد که این متغیرها هنوز هیچ مقدار اختصاصی ندارند. ما به آن خواهیم رسید. در این مرحله ، مهمتر این است که ما کد تمیز و آسان برای خواندن بنویسیم

• هر شرطی را در بلوک if-else تغییر دهید تا وضعیت فعلی را با یکی از حالتهای ممکن مقایسه کنید
• در انتهای بلوک های if-else ، مکثی را برای چند میلی ثانیه اضافه کنید و یک متغیر برای نگه داشتن آن عدد ایجاد کنید. بعداً آن را راه اندازی می کنیم مطمئن شوید که متغیر دارای نام توصیفی باشد ، مانند تیک یا ضربان قلب. از آنجا که این حلقه اصلی دستگاه است ، این مکث سرعت اجرای حلقه اصلی دستگاه را تعیین می کند ، بنابراین یک مقدار بسیار مهم است و بسیار مهم است که یک عدد جادویی بدون نام باشد.

توجه: نگران بلوک های خاکستری در تصویر سوم نباشید. بعداً به آن ها می رسم.

مرحله 4: ما می خواهیم به ورودی کاربر واکنش نشان دهیم

اکنون ، ما می خواهیم به دستگاه نحوه کنترل فشارهای دکمه را بگوییم. اولین فکر ممکن است این باشد که به سادگی از بلوک های "وقتی دکمه فشار داده می شود" در رده ورودی استفاده شود ، اما ما کنترل دقیق تر از آن را می خواهیم. ما از بلوک "در رویداد از (X) با مقدار (Y)" از دسته کنترل در بخش پیشرفته استفاده می کنیم ، زیرا در این آموزش پیشرفته هستیم.

• چهار بلوک "در رویداد از…" ایجاد کنید.

  • دو مورد از این موارد باید منبع رویداد "MICROBIT_ID_BUTTON_A" را بررسی کنند
  • دو مورد از این موارد باید منبع رویداد "MICROBIT_ID_BUTTON_B" را بررسی کنند

  • از دو رویداد که هر دکمه را هدف قرار می دهد:

    • باید رویداد نوع "MICROBIT_BUTTON_EVT_UP" را بررسی کنید
    • باید رویداد نوع "MICROBIT_BUTTON_EVT_DOWN" را بررسی کنید
  • توجه: این گزینه ها با همه حروف بزرگ برچسب هایی هستند که در کد میکرو: بیت سطح پایین استفاده می شوند. آنها به سادگی متغیرهایی هستند که بعداً با کامپایل کد به یک فایل باینری اجرایی جایگزین عدد صحیح می شوند. استفاده از این برچسب ها برای انسان ها آسان تر از جستجوی عدد صحیح است ، اگرچه هر دو به یک شکل عمل می کنند.

• من به عنوان یک سبک انتخاب کردم که هر یک از بلوک های "در رویداد از …" یک تابع را توصیف کند که رویداد مطرح شده را توصیف می کند. اگرچه به شدت ضروری نیست ، اما به نظر من این امر خوانایی را بهبود می بخشد. اگر کسی بخواهد این کار را انجام دهد ، می تواند کد مدیریت رویدادها را درون خود بلوک "on event from…" قرار دهد.

  توجه: بلوک کدی که پاسخ دستگاه را به یک رویداد کنترل می کند ، بصورت بصری "کنترل کننده رویداد" نامیده می شود

• در هر کنترل کننده رویداد ، همان ساختار if-else که برای تقسیم جریان کنترل بر اساس حالت دستگاه استفاده می شود را به ساختار موجود در حلقه حالت اصلی اضافه کنید.

• بلوک های انتسابی را اضافه کنید که حالت دستگاه را مطابق نمودار وضعیت ما تغییر می دهد

  • ما می دانیم که وقتی دستگاه در حالت UNASSIGNED باشد ، دستگاه باید به دکمه A که با انتقال به حالت LISTEN_A فشار داده می شود و دکمه B با انتقال به حالت LISTEN_B فشار داده شود واکنش نشان دهد.
  • ما همچنین می دانیم که وقتی دستگاه در حالت LISTEN_A یا LISTEN_B باشد ، دستگاه باید به ترتیب به دکمه A آزاد شده و دکمه B رها شده با برگشت به حالت UNASSIGNED واکنش نشان دهد.

  • سرانجام ، ما می دانیم که وقتی دستگاه در حالت TEAM_A یا TEAM_B است ، دستگاه باید به ترتیب با پخش SIG_A و پخش SIG_B به دکمه A فشار داده و دکمه B را فشار دهد.

    در این مرحله لازم نیست جزئیات سیگنال های پخش را پر کنید. بعداً به آن خواهیم رسید. آنچه مهم است این است که ما به این توابع دستور می دهیم از کدی که می نویسیم با دادن نام به آن بلوک اقدامات ، مانند broadcastSignalSIG_A ، که در آن مرحله باید انجام شود ، استفاده کنند

مرحله 5: ما می خواهیم مقادیر داده را در حافظه دستگاهها هنگام راه اندازی مجدد دستگاه اولیه کنیم

در این مرحله ، ما از متغیرهای زیادی (نام داده ها) استفاده کرده ایم ، اما در واقع مقادیری را به آن نام ها اختصاص نداده ایم. ما می خواهیم دستگاه هنگام بوت شدن مقادیر همه این متغیرها را در حافظه بارگذاری کند ، بنابراین مقداردهی اولیه این متغیرها را در یک بلوک "on start" قرار می دهیم.

اینها مقادیری است که باید مقداردهی کنیم:

• ثابت سیگنال ، طبق پروتکل سیگنال. مقادیر باید:

  • SIG_R = 0
  • SIG_A = 1
  • SIG_B = 2
  • توجه: من این ثابتها را با "EnumSignals" پیشوند کردم تا نشان دهم که این متغیرها باید طوری رفتار کنند که گویی بخشی از یک نوع شمارش شده به نام Signals هستند. به این ترتیب ممکن است این متغیرها در سایر زبان های برنامه نویسی پیاده سازی شوند. تعریف و توضیح انواع برشمرده خارج از محدوده آموزش من است. اگر کسی بخواهد می تواند آن را در گوگل جستجو کند. این پیشوندها صرفاً انتخابهای سبک هستند و برای عملکرد صحیح برنامه اصلاً ضروری نیستند.

• ثابت های حالت ، که می توانند دلخواه باشند به شرطی که دارای مقداری باشند. من یک سبک را انتخاب کردم تا از اعداد صحیح صعودی از 0 استفاده کنم ، مانند این:

  • اختصاص داده نشده = 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

• دو سری متغیر برای نگه داشتن فریم های متحرک ایجاد کنید. اولی ، که من آن را "بارگیری انیمیشن" می نامم ، باید دارای چهار تصویر باشد (که ممکن است در آخرین راه اندازی اولیه حدس زده باشید) ، و دومی ، که من آن را "انیمیشن پخش" می نامم ، که باید دارای سه تصویر باشد. توصیه می کنم متغیرها را متناسب با فریم های انیمیشن نامگذاری کنید ، به عنوان مثال. حلقه انیمیشن 0 ، حلقه انیمیشن 1…

  مقادیر تصویر مشابه من را ایجاد کنید یا تصاویر اصلی و خنک تری ایجاد کنید

• آخرین و مهمترین نکته این است که ما باید گروه رادیویی دستگاه را با استفاده از بلوک "گروه مجموعه رادیویی (X)" روی 0 تنظیم کنیم
• به صورت اختیاری ، پیام "Initialization complete" را در خروجی سریال بنویسید تا به کاربر بگویید همه چیز در حال انجام است.
• اکنون که راه اندازی دستگاه به پایان رسیده است ، می توانیم تابع حلقه حالت خود را فراخوانی کنیم.

مرحله 6: ما می خواهیم انیمیشن ها و گرافیک ها را با استفاده از صفحه نمایش LED 5 X 5 نمایش دهیم

و اکنون برای چیزی کاملاً متفاوت.

ما می خواهیم چند انیمیشن و چند کاراکتر نمایش دهیم ، اما نمی خواهیم حلقه حالت اصلی را قطع کنیم. متأسفانه ، بلوک هایی که تصاویر و رشته های متن را نمایش می دهند به طور پیش فرض 400 میلی ثانیه تأخیر دارند. هیچ راهی برای تغییر این مورد بدون ویرایش نمایه جاوا اسکریپت وجود ندارد. بنابراین ، این کاری است که ما انجام خواهیم داد.

• برای هر تصویر یک تابع ایجاد کنید. این به شما امکان می دهد به جای ویرایش جاوا اسکریپت هر بار از یک بلوک واحد برای نمایش تصویر استفاده کنید. در این برنامه خاص ، هیچ تصویری بیش از یک بار استفاده نمی شود ، اما هنوز فکر می کنم این سبک خواندن کد را آسان تر می کند.
• در هر عملکرد جدید ، یک بلوک "نمایش تصویر (X) در افست 0" با نام متغیر تصویر مربوطه جایگزین (X) اضافه کنید.

• ، در حلقه حالت اصلی اضافه کنید. بلوک های "نمایش رشته (X)" به هر بلوک علاوه بر بلوکی که حالت UNASSIGNED را کنترل می کند. یک کاراکتر برای نمایش دستگاه اضافه کنید تا حالت های مختلف آن را نشان دهد. در اینجا کاری است که من انجام دادم:

  • LISTEN_A: 'a'
  • LISTEN_B: 'ب'
  • TEAM_A: 'A'

  • TEAM_B: "B"

    برای حالت UNASSIGNED ، با تابع تماس بگیرید که انیمیشن بارگیری را به روز می کند. ما جزئیات این تابع را در زیر پر می کنیم

• به حالت جاوا اسکریپت بروید.
• هر تماس با X.showImage (0) و Basic.showString (X) را پیدا کنید

• هر کدام را به X.showImage (0 ، 0) یا basic.showString (X ، 0) تغییر دهید

  • با افزودن این آرگومان اضافی ، تاخیر بعد از عمل روی 0 تنظیم می شود. به طور پیش فرض ، این مورد حذف می شود و دستگاه پس از اجرای هر یک از این بلوک ها ، 400 میلی ثانیه مکث می کند.
  • در حال حاضر ، ما یک مکانیسم تقریباً بدون تأخیر داریم تا تصاویر خود را در بلوک های متحرک خود نمایش دهیم ، که اکنون می توانیم آن را بسازیم

ابتدا ، ما عملکرد نسبتا ساده انیمیشن پخش را ایجاد می کنیم. این ساده تر است زیرا ما نمی خواهیم کاربر بتواند تا زمانی که عملکرد کامل نشده است بتواند کاری انجام دهد تا مانع از اسپم شدن عملکرد پخش شود. برای تحقق این امر ، ما می توانیم به سادگی جریان کنترل را در بلوک محدود کنیم تا زمانی که عملکرد کامل نشود ، که یک رفتار استاندارد است.

• یک تابع ایجاد کنید که انیمیشن پخش را نمایش دهد.
• در داخل آن بلوک ، سه فراخوانی تابع ، یکی به هر فریم انیمیشن ، به ترتیب نمایش داده شده ، اضافه کنید

• بلوک "wait (us) (X)" را بعد از هر تماس به یک عملکرد نمایش تصویر اضافه کنید.

  توجه: این بلوک ، از بخش کنترل پیشرفته ، حتی فراتر از "pause (ms)" خواهد بود زیرا پردازنده را تا زمان مشخص شده به طور کامل منجمد می کند. هنگامی که از بلوک مکث استفاده می شود ، ممکن است دستگاه کارهای دیگری را در پشت صحنه انجام دهد. این با بلوک انتظار غیرممکن است

• جایگزین (X) با (MS_PER_FRAME_BROADCAST_ANIMATION x MICROSECONDS_PER_MILLISECOND)
• اکنون انیمیشن باید به درستی کار کند

دوم ، ما مکانیزمی برای نمایش انیمیشن بارگذاری خواهیم ساخت. ایده پشت این است که صفحه LED را در یک بازه خاص به روز کنید ، که ما آن را در متغیر MS_PER_DEVICE_TICK تعریف می کنیم. این مقدار ، طول تیک دستگاه ، تعداد میلی ثانیه است که دستگاه پس از تکمیل هر تکرار حلقه حالت متوقف می کند. از آنجا که این مقدار به اندازه کافی کوچک است ، می توانیم صفحه نمایش را در هر تکرار حلقه نمایش یکبار به روز کنیم و به کاربر نشان داده شود که انیمیشن به طور یکپارچه در حال پیشرفت است و وقتی حالت تغییر کند ، بین ورودی کاربر تاخیر بسیار کمی وجود خواهد داشت. صفحه نمایش در حال به روز رسانی است با شمارش تیک ها ، که با متغیر iTickLoadingAnimation انجام می دهیم ، می توانیم قاب مناسب انیمیشن را نمایش دهیم.

• یک تابع ایجاد کنید که انیمیشن بارگیری را به روز کند

• یک شرط اضافه کنید تا بررسی کنید که آیا شمارنده تیک به حداکثر مقدار خود رسیده است یا خیر. اگر مقدار شمارنده تیک از تعداد فریم های موجود در انیمیشن بارگذاری ضرب در تعداد تیک برای نمایش هر فریم بیشتر باشد ، این وضعیت صادق خواهد بود.

  اگر شرط درست است ، iTickLoadingAnimation را به 0 بازنشانی کنید

• یک بلوک از شرایط if-else را اضافه کنید. اینها تعیین می کنند که کدام فریم از انیمیشن نمایش داده شود.

  برای هر فریم از انیمیشن ، اگر شمارنده تیک کمتر از تعداد تیک در هر انیمیشن ضرب در تعداد قاب انیمیشن است (از 1 شروع کنید) ، سپس آن قاب را نمایش دهید ، در غیر اینصورت بررسی کنید که فریم بعدی آن است نمایش داده شود

• در انتهای بلوک ، iTickLoadingAnimation را افزایش دهید
• اکنون انیمیشن باید به درستی کار کند

توجه: همه بلوک های خاکستری که در مثال من ظاهر می شوند ، زمانی ایجاد می شوند که نماینده جاوا اسکریپت یک بلوک را ویرایش کند. این بدان معناست که بلوک نشان دهنده کد جاوا اسکریپت است که نمی تواند با استفاده از مجموعه استاندارد بلوک ها نمایش داده شود و باید به صورت متن ویرایش شود.

مرحله 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: دستگاه ریشه: ما می خواهیم قادر به انتخاب سیگنال باشیم

اکنون ، ما یک برنامه ساده برای دستگاه "root" ، یعنی دستگاهی که شبکه را کنترل می کند ، می نویسیم.

این دستگاه باید دو عملکرد را انجام دهد:

• ما می خواهیم به کاربر اجازه دهیم یکی از سیگنال های ما را انتخاب کند
• ما می خواهیم به کاربر اجازه دهیم سیگنال را پخش کند

از آنجا که مشخصات این برنامه زیرمجموعه ای از برنامه قبلی است ، من یک نمای کلی از آن را ارائه می دهم اما به جزئیات قبلی نمی پردازم. تصویر بالا حاوی کد کامل این برنامه است.

برای اجازه دادن به کاربر برای انتخاب سیگنال:

1. 5 متغیر را در یک بلوک "در شروع" تنظیم کنید:

   1. سه سیگنال (0 ، 1 ، 2)
   2. تعداد سیگنالها (3)
   3. متغیری برای نگه داشتن سیگنال انتخاب شده در حال حاضر (در ابتدا روی اولین سیگنال ، 0 تنظیم شده است)

2. فشار دادن دکمه A:

   1. سیگنال انتخاب شده را افزایش دهید

   2. بررسی کنید که آیا سیگنال انتخاب شده بزرگتر یا مساوی تعداد سیگنال است

      در این صورت ، سیگنال انتخاب شده را روی 0 تنظیم کنید

3. بعد از بلوک شروع ، یک حلقه "برای همیشه" اجرا کنید که مقدار سیگنال انتخاب شده فعلی را بدون تاخیر نمایش می دهد

اجازه می دهد تا کاربر سیگنال را پخش کند

1. گروه رادیو را در بلوک "on start" روی 0 تنظیم کنید

2. دکمه B را فشار دهید:

   سیگنال انتخاب شده را با استفاده از بلوک "ارسال شماره رادیویی (X)" پخش کنید

خودشه. برنامه گره ریشه بسیار ساده است.

مرحله 10: ما به پایان رسیدیم

تصویر بالا دستگاه هایی است که برنامه را اجرا می کنند. دو در سمت راست برنامه اصلی "کاربر" را اجرا می کنند و یکی در سمت چپ برنامه "ریشه" را اجرا می کند.

من این بازی را در CS Connections 2018 ، یک کنفرانس تابستانی یک هفته ای برای معلمان راهنمایی و دبیرستان در مورد آموزش علوم کامپیوتر نشان دادم. من حدود 40 دستگاه به معلمان دادم و قوانین را توضیح دادم. اکثر آنها بازی را سرگرم کننده می دانستند و بسیاری آن را گیج می دانستند تا زمانی که به نحوه انجام بازی پی بردند. تظاهرات کوتاه بود ، اما ما دریافتیم که بازی در بین جمعیت نسبتاً متنوعی لذت بخش است.

اطلاعات بیشتر در مورد CS Connections 2018 را می توانید در اینجا پیدا کنید.