Karibal sa Network: isang Laro na Mababang Latency para sa BBC Micro: kaunti: 10 Hakbang (na may Mga Larawan)

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:13

Sa tutorial na ito, ipapaliwanag ko kung paano ipatupad ang isang pangunahing laro ng multiplayer sa BBC micro: bit sa mga sumusunod na tampok:

• Isang simpleng interface
• Mababang latency sa pagitan ng mga pagpindot sa pindutan at pag-update sa screen
• Isang nababaluktot na bilang ng mga kalahok
• Madaling kontrolin ang laro gamit ang isang master remote ("root") na aparato

Ang laro ay mahalagang isang simulation ng politika. Ang lahat ng mga manlalaro ay nagsisimulang hindi nakatalaga sa anumang koponan, maliban sa dalawang manlalaro. Ang isa sa mga manlalaro na ito ay nakatalaga sa Team A, at ang isa ay nakatalaga sa Team B.

Ang layunin ng laro para sa bawat manlalaro ay nasa koponan na may karamihan ng mga manlalaro sa oras na ang lahat ay na-convert.

Ang diagram sa itaas ay naglalarawan ng isang may takda na makina ng estado, ibig sabihin, isang pagtutukoy ng mga estado na ang aparato ay maaaring nasa at ang mga paglipat sa pagitan ng mga estado.

Ang isang estado ay maaaring isipin bilang kasalukuyang hanay ng data na naglalarawan sa memorya ng aparato mula nang ito ay nakabukas. Batay sa data na iyon, ang aparato ay maaaring magsagawa ng ilang mga pagkilos o magkakaiba ang reaksyon sa input ng gumagamit.

Ang paglipat ay isang lohikal na kondisyon na, kung totoo, ay nagiging sanhi ng aparato na baguhin ang estado nito. Ang paglipat ay maaaring mula sa isang estado patungo sa anumang iba pang estado. Ang isang estado ay maaaring magkaroon ng maraming mga pagbabago.

Ang diagram sa itaas ay tumutukoy sa mga sumusunod na estado:

• Hindi nakatalaga
• Makinig para sa A
• Makinig para sa B
• Ang Koponan A
• Ang Koponan B

Ang isang aparato na nagpapatakbo ng game code ay maaaring nasa anuman sa limang estado na ito, ngunit isa-isa lamang, at ang limang ito lamang.

Ipagpalagay ko sa buong gabay na ginagamit mo ang editor ng MakeCode ng Microsoft, na matatagpuan sa:

Ang buong pagpapatupad ng laro ay matatagpuan dito:

makecode.microbit.org/_CvRMtheLbRR3 ("microbit-demo-user" ang pangalan ng proyekto)

At ang pagpapatupad ng master ("root") network controller ay matatagpuan dito:

makecode.microbit.org/_1kKE6TRc9TgE ("microbit-demo-root" ang pangalan ng proyekto)

Titingnan ko ang mga halimbawang ito sa buong tutorial.

Hakbang 1: Mga Pagsasaalang-alang sa Malalaking Larawang Larawan

Bago kami magsulat ng anumang code, kailangan nating mag-isip tungkol sa kung ano ang nais naming hitsura ng aming end product. sa madaling salita, ano ang mga kinakailangan ng aplikasyon? Ano ang dapat sabihin sa aming code sa aparato na gawin kapag tapos na ito? Hinati ko ang pagpapaandar ng pangunahing aplikasyon sa anim na kategorya, na ang bawat isa ay maaaring isaalang-alang mula sa isang iba't ibang pananaw sa disenyo.

1. Nais naming kontrolin ang mga pagkilos ng aparato batay sa kasalukuyang estado nito
2. Nais naming mag-react ang aparato sa pag-input ng gumagamit
3. Maaaring gusto naming magpakita ng mga animasyon at grapiko gamit ang 5 x 5 LED display
4. Nais naming simulan ang mga halaga ng data sa memorya ng mga aparato kapag nag-boot ang aparato
5. Nais naming magpadala ng data nang wireless gamit ang radyo ng aparato
6. Nais naming makinig at makatanggap ng data sa radyo ng aparato at iproseso ito nang naaayon

Pahintulutan akong pumunta sa kaunti pang detalye tungkol sa bawat isa.

1. Nais naming kontrolin ang mga pagkilos ng aparato batay sa kasalukuyang estado nito

Tulad ng karamihan sa iba pang mga programa, ang pagpapatupad ng mga tagubiling tinukoy ng code ay nangyayari sa bawat linya nang paisa-isa. Nais naming magpatupad ang aming aparato ng ilang mga tagubilin batay sa panloob na estado, tulad ng inilalarawan ng diagram sa tuktok ng tutorial na ito. Maaari kaming magsulat ng isang serye ng mga kundisyon pagkatapos ng bawat bloke ng code na suriin ang dapat gawin ng aparato, ngunit ang diskarte na ito ay maaaring maging napakabilis, kaya gagamitin namin ang isang walang katapusang loop na susuriin lamang ang isang variable, at batay sa variable na iyon, nagpapatupad ng isang tukoy na hanay ng mga tagubilin o wala man lang. Ang variable na ito ay makikilala ng panlapi na "_state" sa parehong application ng aming gumagamit at sa aming root application.

2. Gusto naming mag-react ang aparato sa pag-input ng gumagamit

Sa kabila ng normal na pagpapatupad ng code na magkakasunod na nangyayari, iyon ay upang sabihin, isang linya nang paisa-isa, kailangan namin ang aming aparato upang tumugon sa mga pagpindot sa pindutan habang tinutukoy ng pangunahing loop ng estado kung ano ang dapat gawin ng aparato sa anumang naibigay na sandali. Para sa hangaring iyon, ang aparato ay may kakayahang magpadala ng mga signal sa mas mababang antas ng software na nakikipag-ugnay sa hardware, na nagpapalitaw ng tinatawag na isang kaganapan. Maaari kaming magsulat ng code na nagsasabi sa aparato na gumawa ng isang bagay kapag nakakita ito ng isang tukoy na uri ng kaganapan.

3. Nais naming ipakita ang mga animasyon at grapiko gamit ang 5 x 5 LED display

Ang mekanismo upang gawin ito ay lilitaw na simple, ngunit ang block do display isang imahe ay nagdaragdag ng isang nakatagong pagkaantala ng 400 ms. Dahil nais naming magpatuloy ang pagpapatupad ng aming aparato ng state loop nito nang may kaunting latency hangga't maaari, kakailanganin naming i-edit ang javascript code upang i-minimize ang pagkaantala.

4. Nais naming simulan ang mga halaga ng data sa memorya ng mga aparato kapag nag-boot ang aparato

Bago gumawa ang aming aparato ng anumang bagay, kailangang i-load ng application ang data nito sa memorya. Kasama rito ang patuloy na mga variable na pinangalanan para sa kakayahang mabasa ang code, mga variable na naglalaman ng mga imahe, na maaaring bahagi ng isang animasyon, at mga counter na variable na kailangang magsimula sa 0 upang gumana nang maayos. Magtatapos kami sa isang mahabang listahan ng mga variable na pangalan at ang kanilang bagong itinalagang mga halaga. Bilang isang personal na pagpipilian ng estilo, isasaad ko ang pare-pareho ang mga halaga, ibig sabihin, mga halagang hindi ko na kailangang baguhin, gamit ang ALL_CAPS. Susuriin ko rin ang pangunahing mga pagkakakilanlan ng variable na may isang kategorya ng pangalan na tumutukoy sa isang uri ng bagay o uri na nahuhulog sa ilalim ng tagakilala. Ito ay sa pagtatangka upang gawing mas madaling sundin ang code. Hindi ako gagamit ng isang variable na pangalan tulad ng "item" o "x" dahil sa kalabuan na lumalabas kapag sinusubukang i-decipher ang code.

5. Nais naming magpadala ng data nang wireless gamit ang radyo ng aparato

Ito ay talagang isang simpleng gawain kapag ginagamit ang wika ng mga bloke ng MakeCode. Itinakda lamang namin ang lahat ng mga aparato sa parehong pangkat ng radyo sa oras ng pag-boot at pagkatapos ay nais naming magpadala ng isang senyas, maaari naming ipasa ang isang solong numero sa bloke na "Radio send number" na ibinigay sa amin. Mahalaga na ang nagpadala at tatanggap ay nagtatrabaho sa parehong pangkat ng radyo, dahil kung hindi, magpapadala o makakatanggap sila sa iba't ibang mga frequency, at ang komunikasyon ay hindi matagumpay.

6. Nais naming makinig para sa at makatanggap ng data sa radyo ng aparato at iproseso ito nang naaayon

Isinasaalang-alang ang parehong pagsasaalang-alang tulad ng nakaraang item, makikinig kami para sa mga papasok na pagpapadala sa parehong paraan na makikinig kami para sa pag-input ng gumagamit: na may isang handler ng kaganapan. Susulat kami ng isang bloke ng code na susuriin ang anumang papasok na mga signal at suriin kung may anumang aksyon na gagawin nang hindi ginugulo ang pangunahing loop ng estado.

Bilang karagdagan, dapat nating isaalang-alang sandali ang disenyo ng higit na mas simpleng aplikasyon ng ugat, isang programa na magpapahintulot sa isang aparato na kontrolin ang buong network. Hindi ako gagastos ng maraming oras dito dahil mas simple ito kaysa sa disenyo sa itaas at ang karamihan dito ay simpleng pag-uulit. Hinati ko ang pagpapaandar ng root deice sa tatlong kategorya.

1. Gusto naming makapili ng isang senyas
2. Nais naming makapagpadala ng isang senyas

--

1. Nais naming pumili ng isang senyas

Maaari itong magawa sa pamamagitan lamang ng pagkakaroon ng isang pindutan na umuulit sa pamamagitan ng mga posibleng signal. Dahil tatlo lamang, ang pamamaraang ito ay sapat na. Sa parehong oras, maaari kaming magkaroon ng isang loop na patuloy na muling nagpapakita ng napiling signal, na nagpapahintulot sa gumagamit na pindutin ang isang pindutan at makita ang napiling signal na lilitaw sa LED display na may napakaliit na latency.

2. Nais naming makapagpadala ng isang senyas

Dahil mayroong dalawang mga pindutan, maaari naming italaga ang isa para sa pagpili at ang isa pa para sa kumpirmasyon. Tulad ng application ng gumagamit, nagpapadala lamang kami ng signal sa network bilang isang numero. Walang ibang kinakailangang impormasyon.

Magsasalita pa ako tungkol sa simpleng signal protokol sa susunod na seksyon.

Hakbang 2: Ang Signal Protocol: isang Simpleng Wika para sa Network Communication

Ang mga sumusunod na signal ay maaaring isipin bilang isang hanay ng lahat ng mga posibleng salita na maaaring magamit ng mga aparato upang makipag-usap sa bawat isa. Dahil ang network ay napaka-simple, walang masabi, at sa gayon maaari naming kumatawan sa tatlong signal na ito sa pamamagitan ng mga simpleng halaga ng integer.

0. I-reset

• Identifier sa code: SIG-R
• Halaga ng integer: 0
• Layunin: Sabihin sa lahat ng mga aparato sa loob ng saklaw na i-drop kung ano ang ginagawa nila at kumilos na parang na-boot lang. Kung ang signal na ito ay umabot sa bawat aparato sa network, ang buong network ay mai-reset at ang mga gumagamit ay maaaring magsimula ng isang bagong laro. Ang signal na ito ay maaari lamang mai-broadcast ng isang root device.

1. Pagbabago A

• Identifier sa code: SIG-A
• Halaga ng integer: 1
• Layunin: Sabihin sa anumang aparato na nasa estado na LISTEN_A, sa sandaling matanggap nila ang signal ng conversion, upang lumipat sa estado na TEAM_A.

2. Pagbabago B

1. Identifier sa code: SIG-B
2. Halaga ng integer: 2
3. Layunin: Sabihin sa anumang aparato na nasa estado na LISTEN_B, sa sandaling matanggap nila ang signal ng conversion, upang lumipat sa state TEAM_B.

Hakbang 3: Nais naming Montrol ang Mga Pagkilos ng Device Batay sa Kasalukuyang Estado Nito

Sa wakas, maaari nating simulan ang pagsulat ng code.

Una, Magbukas ng isang bagong proyekto sa Make Code

• Lumikha ng isang bagong pag-andar. Tinawag ko ang aking loop dahil ito ang pangunahing loop ng application
• Magdagdag ng isang loop block na uulit nang walang katiyakan. Ginamit ko habang (totoo) dahil ang isang literal na tunay ay hindi kailanman magiging totoo, samakatuwid ang daloy ng kontrol ng application ay hindi lalabas sa loop
• Magdagdag ng sapat na kung-block na iba pa upang suriin kung ang aparato ay nasa anuman sa limang posibleng mga estado
• Lumikha ng isang variable upang i-hold ang kasalukuyang estado ng aparato

• Lumikha ng mga variable upang kumatawan sa bawat isa sa limang mga posibleng estado

  Tandaan: OK lang na ang mga variable na ito ay wala pang itinalagang mga halaga. Darating tayo doon. Sa puntong ito, mas mahalaga na magsulat kami ng malinis, madaling basahin ang code

• Baguhin ang bawat kundisyon sa mga block na if-else upang ihambing ang kasalukuyang estado sa isa sa mga posibleng estado
• Sa ilalim ng mga block na kung-sino pa, magdagdag ng isang pag-pause para sa ilang bilang ng mga milliseconds, at lumikha ng isang variable upang hawakan ang numerong iyon. Sisimulan namin ito sa paglaon. Tiyaking ang variable ay may naglalarawang pangalan, tulad ng tick o heartbeat. Sapagkat ito ang pangunahing loop ng aparato, matutukoy ng pag-pause na ito ang bilis kung saan isinasagawa ng aparato ang pangunahing loop, kaya't ito ay isang napakahalagang halaga, at napakahalaga upang maging isang magic number na walang pangalan.

Tandaan: Huwag magalala tungkol sa mga grey block sa pangatlong imahe. Makakarating na ako sa mga mamaya.

Hakbang 4: Nais naming Mag-reaksyon sa Pag-input ng User

Ngayon, nais naming sabihin sa aparato kung paano hawakan ang mga pagpindot sa pindutan. Ang unang naisip ng isa ay maaaring gamitin lamang ang mga bloke na "Kapag pinindot ang pindutan" sa kategorya ng pag-input, ngunit nais namin ang higit na kontrol ng butil kaysa doon. Gagamitin namin ang "sa kaganapan mula sa (X) na may halaga (Y)" na bloke mula sa kategorya ng kontrol sa ilalim ng advanced na seksyon, dahil advanced kami sa tutorial na ito.

• Lumikha ng apat na "sa kaganapan mula sa …" na mga bloke.

  • Ang dalawa sa mga ito ay dapat na suriin ang pinagmulan ng kaganapan na "MICROBIT_ID_BUTTON_A"
  • Ang dalawa sa mga ito ay dapat na suriin ang pinagmulan ng kaganapan na "MICROBIT_ID_BUTTON_B"

  • Sa dalawang kaganapan na nagta-target sa bawat pindutan:

    • Dapat suriin ng isa ang kaganapan ng uri na "MICROBIT_BUTTON_EVT_UP"
    • Dapat suriin ng isa ang kaganapan ng uri na "MICROBIT_BUTTON_EVT_DOWN"
  • Tandaan: Ang mga pagpipiliang ito sa lahat ng mga malalaking titik ay mga label na ginagamit sa mas mababang antas ng micro: bit code. Ang mga ito ay simpleng mga placeholder na sa paglaon ay pinalitan ng mga integer kapag ang code ay naipon sa isang maipapatupad na binary. Mas madali para sa mga tao na gamitin ang mga label na ito kaysa sa maghanap ng kung aling integer ang ilalagay, kahit na pareho ang gagana sa parehong paraan.

• Pinili ko, bilang isang us aka istilo, na magkaroon ng bawat "on event from…" na tumawag sa isang pagpapaandar na naglalarawan sa itinaas na kaganapan. Habang hindi mahigpit na kinakailangan, sa palagay ko pinapabuti nito ang kakayahang mabasa. Kung nais ng isang tao na gawin ito, maaari nilang mailagay ang code sa paghawak ng kaganapan sa loob ng "sa kaganapan mula sa …" na block mismo.

  Tandaan: Ang bloke ng code na humahawak sa tugon ng aparato sa isang kaganapan ay intuitive na tinatawag na isang "handler ng kaganapan"

• Magdagdag, sa bawat handler ng kaganapan, ang parehong istraktura ng if-else na ginamit upang hatiin ang daloy ng kontrol batay sa estado ng aparato bilang istraktura sa pangunahing loop ng estado.

• Magdagdag ng mga bloke ng pagtatalaga na nagbabago sa estado ng aparato na tinukoy ng aming diagram ng estado

  • Alam namin na kapag ang aparato ay nasa estado na UNASSIGNED, dapat gumanti ang aparato sa pindutan A na pinindot ng isang paglipat sa estado ng LISTEN_A, at sa pindutan B na pinindot ng isang paglipat sa estado ng LISTEN_B
  • Alam din namin na kapag ang aparato ay nasa estado na LISTEN_A o LISTEN_B, dapat gumanti ang aparato sa pindutang A na pinakawalan at inilabas ang pindutan B, ayon sa pagkakabanggit, sa pamamagitan ng paglipat pabalik sa estado na UNASSIGNED.

  • Panghuli, alam namin na kapag ang aparato ay nasa estado na TEAM_A o TEAM_B, dapat gumanti ang aparato sa pindutan A na pinindot at pindutan B na pinindot ng pagsasahimpapaw ng SIG_A at ng pagsasahimpapawid ng SIG_B ayon sa pagkakabanggit.

    Hindi kinakailangan sa puntong ito upang punan ang mga detalye ng mga signal ng pag-broadcast. Makakarating tayo doon mamaya. Ang mahalaga ay turuan namin ang mga pagpapaandar na ito na gamitin ang code na isusulat namin sa pamamagitan ng pagbibigay ng pangalan sa block ng mga pagkilos na iyon, tulad ng broadcastSignalSIG_A, na naglalarawan kung ano ang dapat gawin sa puntong iyon

Hakbang 5: Nais Na naming Simulan ang Mga Halaga ng Data sa Mga Memory ng Mga Device Kapag Nag-boot ang Device

Sa puntong ito, gumamit kami ng maraming mga variable (mga pangalan para sa data), ngunit hindi talaga namin naitalaga ang mga halaga sa mga pangalang iyon. Nais naming i-load ng aparato ang mga halaga ng lahat ng mga variable na ito sa memorya kapag nag-boot ito, kaya inilalagay namin ang pagsisimula para sa mga variable na ito sa isang "on start" block.

Ito ang mga halagang dapat nating ipasimula:

• Mga palatandaan ng signal, ayon sa signal protokol. Ang mga halagang DAPAT ay:

  • SIG_R = 0
  • SIG_A = 1
  • SIG_B = 2
  • Tandaan: Inayos ko ang mga Constant na ito ng "EnumSignals" upang maipahiwatig na ang mga variable na ito ay kumilos na para bang bahagi sila ng isang binilang na uri na tinatawag na Signals. Ito ay kung paano maaaring ipatupad ang mga variable na ito sa iba pang mga wika ng programa. Ang kahulugan at paliwanag ng mga nabilang na uri ay lampas sa saklaw ng aking tutorial. Maaaring isa ito sa Google kung nais nila. Ang mga unlapi na ito ay simpleng mga pagpipiliang pangkakanyahan at hindi talaga mahalaga para sa wastong paggana ng programa.

• Mga Constant ng estado, na maaaring maging di-makatwiran hangga't mayroon silang isang halaga. Gumawa ako ng pagpipilian ng istilo na simpleng gamitin ang mga integer na umaakyat mula sa 0, tulad nito:

  • UNASSIGNED = 0
  • LISTEN_A = 1
  • LISTEN_B = 2
  • TEAM_A = 3
  • TEAM_B = 4
  • Tandaan: Gumawa ako ng parehong istilo ng desisyon tungkol sa mga awas para sa mga variable na ito din. Bilang karagdagan, babanggitin ko na ang lahat tungkol sa mga takdang-aralin na ito, ang mga halaga at ang pagkakasunud-sunod, ay ganap na arbitraryo. Hindi mahalaga na ang mga halagang ito ay pare-pareho mula sa aparato hanggang sa aparato, sapagkat ginagamit lamang ito sa loob at hindi para sa komunikasyon sa network. Ang mahalaga lamang ay ang mga variable ay may halaga at maaari silang ihambing sa bawat isa upang makita kung ang mga ito ay katumbas o hindi.
• Para sa kakayahang mabasa, isang pare-pareho na tinatawag na BOOT_STATE at itakda ito sa UNASSIGNED. Ginagawa nitong ang katunayan na nag-reset kami sa estado ng boot, sa halip na isang mas di-makatwirang estado, mas malinaw kapag nakatanggap ang aparato ng isang reset signal, na ipapatupad namin sa paglaon.

• Ang mga animation Constant, na ginagamit sa sumusunod na hakbang upang lumikha ng mga animasyon na nagpapahintulot sa labis na pagkakagambala ng mababang latency sa pamamagitan ng pag-input ng gumagamit. Hindi namin nagamit ang mga ito hanggang ngayon, ngunit tiyak na ipapaliwanag at gagamitin ito sa sumusunod na seksyon. Ang kahulugan ng ilan sa mga ito ay dapat na maging intuitive dahil sa kanilang mga pangalan.

  • 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

• Isa pang variable para sa animasyon, oras na ito isang counter na tiyak na hindi pare-pareho. Tulad ng karamihan sa mga counter, isinisimula namin ito sa 0

  iTickLoadingAnimation = 0

• Lumikha ng dalawang serye ng mga variable upang hawakan ang mga frame ng mga animasyon. Ang una, na tinawag kong "loading animation", ay dapat mayroong apat na mga imahe (na maaaring nahulaan mo ng huling pare-pareho na pagpapasimula), at ang pangalawa, na tinawag kong "broadcast animation", na dapat mayroong tatlong mga imahe. Inirerekumenda kong pangalanan ang mga variable upang tumutugma sa mga frame ng animasyon, hal. ringAnimation0, ringAnimation1…

  Lumikha ng parehong mga halaga ng imahe tulad ng ginawa ko o lumikha ng mas maraming orihinal at mas malamig na mga imahe

• Huling ngunit hindi pa huli, dapat naming itakda ang pangkat ng radyo ng aparato sa 0 gamit ang "radio set group (X)" block
• Opsyonal, isulat ang mensahe na "Kumpleto ang Initialization" sa serial output upang sabihin sa gumagamit na ang lahat ay lumalangoy.
• Ngayon na tapos na kaming mag-set up ng aparato, maaari na naming tawagan ang pagpapaandar ng aming estado.

Hakbang 6: Nais naming Magpakita ng Mga Animation at Graphics Gamit ang 5 X 5 LED Display

At ngayon para sa isang bagay na ganap na naiiba.

Nais naming ipakita ang ilang mga animasyon at ilang mga character, ngunit hindi namin nais na makagambala sa pangunahing loop ng estado. Sa kasamaang palad, ang mga bloke na nagpapakita ng mga imahe at mga string ng teksto ay may isang pagkaantala ng 400 ms bilang default. Walang paraan upang baguhin ito nang hindi na-edit ang javascript na representasyon ng code. Kaya, ito ang gagawin namin.

• Lumikha ng isang pagpapaandar para sa bawat imahe. Papayagan nito ang isa na gumamit ng isang solong bloke upang maipakita ang imahe sa halip na mag-edit ng javascript tuwing. Sa tukoy na program na ito, walang imahe na ginamit nang higit sa isang beses, ngunit sa palagay ko pa rin ang istilong ito ay ginagawang mas madaling basahin ang code.
• Magdagdag, sa bawat bagong pagpapaandar, isang bloke na "ipakita ang imahe (X) sa offset 0" na may kaukulang pangalan ng variable ng imahe na pumapalit (X)

• Idagdag, sa pangunahing loop ng estado. "Ipakita ang mga bloke ng string (X)" sa bawat bloke bukod sa isa na humahawak sa state UNASSIGNED. Magdagdag ng isang character para sa aparato upang ipakita upang ipahiwatig ang iba't ibang mga estado. Narito ang ginawa ko:

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

  • TEAM_B: 'B'

    Para sa state UNASSIGNED, tumawag sa isang pagpapaandar na mag-a-update sa pag-load ng animasyon. Punan namin ang mga detalye ng pagpapaandar na ito sa ibaba

• Lumipat sa javascript mode.
• Hanapin ang bawat tawag sa X.showImage (0) at basic.showString (X)

• Baguhin ang bawat solong isa sa alinman sa X.showImage (0, 0) o basic.showString (X, 0)

  • Ang pagdaragdag ng labis na argument na ito ay magtatakda ng pagkaantala pagkatapos ng pagkilos sa 0. Bilang default, ito ay naiwan, at ang aparato ay i-pause para sa 400 ms pagkatapos ng pagpapatupad ng bawat isa sa mga bloke na ito.
  • Ngayon, mayroon kaming isang malapit na latency-free na mekanismo upang ipakita ang aming mga imahe sa aming mga bloke ng animasyon, na maaari na naming mabuo

Una, bubuo kami ng medyo simpleng pag-andar ng animasyon sa pag-broadcast. Mas simple ito sapagkat hindi namin nais na magawa ng gumagamit ang anumang bagay hanggang sa makumpleto ang pagpapaandar, upang mapahinto sila sa pag-spam sa pagpapaandar ng broadcast. Upang magawa ito, mapapanatili lamang namin ang kontrol ng daloy ng kontrol sa block hanggang sa makumpleto ang pagpapaandar, na karaniwang pamantayan sa pag-uugali.

• Lumikha ng isang pagpapaandar na magpapakita ng broadcast ng animasyon.
• Sa loob ng bloke na iyon, magdagdag ng tatlong mga tawag sa pag-andar, isa sa bawat frame ng animasyon, sa pagkakasunud-sunod na dapat ipakita ang mga ito

• Magdagdag ng isang "maghintay (sa amin) (X)" na bloke pagkatapos ng bawat tawag sa isang pagpapaandar na nagpapakita ng imahe.

  Tandaan: Ang bloke na ito, mula sa advanced na seksyon ng kontrol, ay lalayo pa sa "pause (ms)" na ganap nitong i-freeze ang processor hanggang sa lumipas ang tinukoy na oras. Kapag ginamit ang pag-pause block, posible na magsagawa ang aparato ng iba pang mga gawain sa likod ng mga eksena. Imposible ito sa paghihintay

• Palitan (X) ng (MS_PER_FRAME_BROADCAST_ANIMATION x MICROSECONDS_PER_MILLISECOND)
• Dapat na gumana nang maayos ang animasyon

Pangalawa, bubuo kami ng mekanismo para sa pagpapakita ng pag-load ng animasyon. Ang ideya sa likod nito ay upang i-update ang LED display sa isang tukoy na agwat, na tinukoy namin sa variable na MS_PER_DEVICE_TICK. Ang halagang ito, ang haba ng tsek ng aparato, ay ang bilang ng mga millisecond na na-pause ng aparato pagkatapos makumpleto ang bawat pag-ulit ng loop ng estado. Sapagkat ang halagang ito ay sapat na maliit, maaari naming mai-update ang display nang isang beses sa bawat pag-ulit ng display loop at lilitaw sa gumagamit na ang animation ay umuunlad nang maayos, at kapag nagbago ang estado, magkakaroon ng napakaliit na latency sa pagitan ng input ng gumagamit ina-update ang display. Sa pamamagitan ng pagbibilang ng mga ticks, na ginagawa namin sa variable ng iTickLoadingAnimation, maaari nating ipakita ang naaangkop na frame ng animasyon.

• Lumikha ng isang pagpapaandar na mag-a-update sa pag-load ng animasyon

• Magdagdag ng isang kundisyon upang suriin kung ang tick counter ay umabot sa maximum na halaga. Ang kondisyong ito ay magiging totoo kung ang halaga ng tick counter ay mas malaki kaysa sa bilang ng mga frame sa paglo-load ng animasyon na pinarami ng bilang ng mga ticks upang maipakita ang bawat frame

  Kung totoo ang kundisyon, i-reset ang ltickLoadingAnimation sa 0

• Magdagdag ng isang bloke ng kung-ibang mga kundisyon. Tutukuyin nito kung aling frame ng animasyon ang ipapakita.

  Para sa bawat frame ng animation, kung ang tick counter ay mas mababa kaysa sa bilang ng mga ticks sa bawat animasyon na pinarami ng frame number ng animasyon (simula sa 1), pagkatapos ay ipakita ang frame na iyon, kung hindi man suriin kung ang susunod na frame ay ang maipakita

• Sa ilalim ng bloke, dagdagan ang iTickLoadingAnimation
• Dapat na gumana nang maayos ang animasyon

Tandaan: Ang lahat ng mga grey block na lilitaw sa aking halimbawa ay nabuo kapag na-edit ng isang tao ang representasyon ng javascript ng isang bloke. Nangangahulugan lamang ito na ang bloke ay kumakatawan sa javascript code na hindi maaaring kinatawan gamit ang karaniwang hanay ng mga bloke at dapat na mai-edit sa form ng teksto.

Hakbang 7: Nais Na naming Magsalin ng Data nang Walang Wireless Gamit ang Radyo ng Device

Ang hakbang na ito ay mas maikli kaysa sa nakaraang. Sa katunayan, marahil ito ang pinakamaikling hakbang sa buong tutorial na ito.

Alalahanin na noong na-program namin ang tugon ng aparato sa pag-input ng gumagamit, mayroon akong dalawang mga bloke sa screenshot na hindi ipinaliwanag sa seksyong iyon. Ito ang mga tawag sa mga pagpapaandar na nagpapadala ng mga signal sa radyo. Mas partikular:

• Ang pindutang A ay pinindot:

  • Kung ang aparato ay nasa estado na TEAM_A:

    I-broadcast ang signal SIG_A

• Ang pindutan ng B ay pinindot:

  • Kung ang aparato ay nasa estado na TEAM_B

    I-broadcast ang signal SIG_B

Lumikha ng mga pagpapaandar na ito kung wala pa sila.

Sa bawat pag-andar:

• Tumawag sa pagpapaandar ng pag-broadcast ng animasyon. Hahadlangan nito ang anumang mangyari pa hanggang sa makumpleto nito, na nasa MS_PER_FRAME_BROADCAST_ANIMATION * 3 = 1.5 segundo. Ang pare-pareho ay pinarami ng tatlo dahil mayroong tatlong mga frame sa animasyon. Ito ay arbitrary at higit pa ay maaaring maidagdag kung ang pag-upgrade ng aesthetic ay sapat na mahusay. Ang pangalawang layunin ng animasyong ito ay upang maiwasan ang isang gumagamit na mag-spam sa pagpapaandar ng broadcast.
• Magdagdag ng isang bloke na "radio send number (X)", kung saan ang palaging signal na nabanggit sa pangalan ng pag-andar

Iyon lang ang kailangan ng isang mag-broadcast sa radyo.

Hakbang 8: Nais naming Makinig para sa at Makatanggap ng Data Sa Radyo ng Device at iproseso Ito Alinsunod dito

Ito ang pangwakas na hakbang upang likhain ang pangunahing aplikasyon.

Sasabihin namin sa aparato kung paano iproseso ang mga papasok na signal ng radyo. Una, papangalanan ng aming aparato ang natanggap na signal. Pagkatapos, batay sa halaga ng signal na iyon, magpapasya kung anong aksyon ang gagawin, kung mayroon man.

Una:

1. Lumikha ng isang bloke ng code na nagsisimula sa isang "sa radio na natanggap (X)" na bloke.
2. Bilang pagpipilian, italaga ang natanggap na halaga sa isa pang variable na may isang mas mapaglarawang pangalan.
3. Tumawag sa isang pagpapaandar na magpoproseso ng signal

Pangalawa, sa pagpapaandar ng signal signal:

1. Lumikha ng isang bloke ng mga kung-ibang pahayag na dumadaloy ang kontrol ng sangay batay sa halaga ng signal.

2. Kung ang signal ay SIG_R

   Itakda ang estado ng aparato sa BOOT_STATE (ito ang dahilan kung bakit nilikha namin ito palagi)

3. Kung ang signal ay SIG_A at kung ang kasalukuyang estado ay LISTEN_A

   Itakda ang estado ng aparato sa TEAM_A

4. Kung ang signal ay SIG_B at kung ang kasalukuyang estado ay LISTEN_B

   Itakda ang estado ng aparato sa TEAM_B

Ayan yun. Tapos na ang application.

Hakbang 9: Root Device: Nais naming Maging Makakapili ng isang Signal

Ngayon, magsusulat kami ng isang simpleng application para sa isang "root" na aparato, iyon ay upang sabihin, isang aparato na makokontrol ang network.

Kailangang magsagawa ang aparatong ito ng dalawang pag-andar:

• Nais naming payagan ang gumagamit na pumili ng isa sa aming mga signal
• Nais naming payagan ang gumagamit na mag-broadcast ng signal

Sapagkat ang pagtutukoy ng application na ito ay isang subset ng nakaraang, magbibigay ako ng isang pangkalahatang ideya ngunit hindi ko bibigyan ang detalyeng tulad ng dati ko. Naglalaman ang imahe sa itaas ng kumpletong code para sa application na ito.

Upang payagan ang gumagamit na pumili ng isang senyas:

1. Simulan ang 5 mga variable sa isang bloke na "on start":

   1. Ang tatlong signal (0, 1, 2)
   2. Ang bilang ng mga signal (3)
   3. Isang variable upang hawakan ang kasalukuyang napiling signal (una na itinakda sa unang signal, 0)

2. Pangasiwaan ang isang pagpindot sa pindutan ng A:

   1. Palakihin ang napiling signal

   2. Suriin kung ang napiling signal ay mas malaki kaysa o katumbas ng bilang ng mga signal

      Kung gayon, itakda ang napiling signal sa 0

3. Matapos ang start block, magpatakbo ng isang "magpakailanman" na loop na nagpapakita ng kasalukuyang napiling halaga ng signal nang walang pagkaantala

Upang payagan ang gumagamit na mag-broadcast ng isang senyas

1. Itakda ang pangkat ng radyo sa 0 sa block na "on start"

2. Hawakan ang isang pindutin ng pindutan ng B:

   I-broadcast ang napiling signal gamit ang isang "radio send number (X)" block

Ayan yun. Ang application ng root node ay lubos na simple.

Hakbang 10: Tapos Na Kami

Sa itaas ay isang larawan ng mga aparato na nagpapatakbo ng application. Ang dalawa sa kanan ay nagpapatakbo ng pangunahing application na "gumagamit", at ang isa sa kaliwa ay tumatakbo ang application na "root".

Ipinakita ko ang larong ito sa CS Connections 2018, isang linggong kumperensya sa tag-init para sa mga guro sa gitna at high school tungkol sa edukasyon sa agham ng computer. Nagbigay ako ng halos 40 aparato sa mga guro at ipinaliwanag ang mga patakaran. Karamihan sa mga natagpuan ang laro na nakakaaliw, at marami ang nahanap na nakalilito hanggang sa malaman nila kung paano maglaro. Ang demonstrasyon ay maikli, ngunit nakita namin ang laro na kasiya-siya sa gitna ng isang medyo magkakaibang mga tao.

Higit pang impormasyon tungkol sa Mga Koneksyon sa CS 2018 ay matatagpuan dito.