Laro ng Arduino-Controlled Platformer Game Sa Joystick at IR Receiver: 3 Hakbang (na may Mga Larawan)

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

Ngayon, gagamit kami ng isang Arduino microcontroller upang makontrol ang isang simpleng laro ng platform na batay sa C #. Gumagamit ako ng Arduino upang kumuha ng input mula sa isang module ng joystick, at ipadala ang input na iyon sa application na C # na nakikinig at nagde-decode ng input sa isang koneksyon ng Serial. Bagaman hindi mo kailangan ng anumang dating karanasan sa pagbuo ng mga video game upang makumpleto ang proyekto, maaaring mangailangan ito ng kaunting oras upang makuha ang ilang mga bagay na nangyayari sa "loop ng laro," na tatalakayin natin sa paglaon.

Upang makumpleto ang proyektong ito, kakailanganin mo ang:

• Komunidad ng Visual Studio
• Isang Arduino Uno (o katulad)
• Isang module ng controller ng joystick
• Pasensya

Kung handa ka nang magsimula, magpatuloy!

Hakbang 1: I-hook Up ang Joystick at IR LED

Dito, ang hookup ay medyo simple. Nagsama ako ng mga diagram na nagpapakita lamang ng joystick na naka-hook, pati na rin ang setup na ginagamit ko, na kasama ang joystick kasama ang isang infrared LED para sa pagkontrol sa laro gamit ang isang remote control, na may kasamang maraming Arduino kit. Opsyonal ito, ngunit tila isang cool na ideya na makakagawa ng wireless gaming.

Ang mga pin na ginamit sa pag-set up ay:

• A0 (analog) <- Pahalang o X-axis
• A1 (analog) <- Vertical o Y-axis
• Pin 2 <- Input input ng Joystick
• Pin 2 <- Infrared LED input
• VCC <- 5V
• Lupa
• Lupa # 2

Hakbang 2: Lumikha ng isang Bagong Sketch

Magsisimula kami sa paglikha ng aming Arduino sketch file. Pinipili nito ang joystick para sa mga pagbabago, at ipinapadala ang mga pagbabagong iyon sa programa ng C # bawat maraming milliseconds. Sa isang aktwal na video game, susuriin namin ang serial port sa isang loop ng laro para sa pag-input, ngunit sinimulan ko ang laro bilang isang eksperimento, kaya ang framerate ay talagang batay sa bilang ng mga kaganapan sa serial port. Sinimulan ko talaga ang proyekto sa proyekto ng kapatid na Arduino, Pagproseso, ngunit lumalabas na ito ay mas, mas mabagal at hindi mahawakan ang bilang ng mga kahon sa screen.

Kaya, lumikha muna ng isang bagong Sketch sa programa ng editor ng code ng Arduino. Ipapakita ko ang aking code at pagkatapos ay ipaliwanag kung ano ang ginagawa nito:

# isama ang "IRremote.h"

// IR variable variable int receiver = 3; // Signal Pin ng IR receiver IRrecv irrecv (receiver); // create instance of 'irrecv' decode_results resulta; // create instance of 'decode_results' // Joystick / game variable int xPos = 507; int yPos = 507; byte joyXPin = A0; byte joyYPin = A1; byte joySwitch = 2; pabagu-bago ng byte clickCounter = -1; int minMoveHigh = 530; int minMoveLow = 490; int currentSpeed = 550; // Default = isang average na bilis int speedIncrement = 25; // Halaga upang dagdagan / bawasan ang bilis ng Y input na hindi naka-sign mahabang kasalukuyang = 0; // Humahawak ng kasalukuyang timestamp int wait = 40; // ms upang maghintay sa pagitan ng mga mensahe [Tandaan: mas mababang paghihintay = mas mabilis na framerate] pabagu-bago ng isip bool buttonPressed = false; // Gauge kung ang pindutan ay pinindot void setup () {Serial.begin (9600); pinMode (joySwitch, INPUT_PULLUP); attachInterrupt (0, jump, FALLING); kasalukuyang = millis (); // I-set up ang kasalukuyang oras // I-set up ang infrared receiver: irrecv.enableIRIn (); // Start the receiver} // setup void loop () {int xMovement = analogRead (joyXPin); int yPos = analogRead (joyYPin); // Hawakan ang kilusan ng Joystick X anuman ang oras: kung (xMovement> minMoveHigh || xMovement current + wait) {currentSpeed = yPos> minMoveLow && yPos <minMoveHigh // Kung lumipat lamang ng kaunti…? currentSpeed // … ibalik lamang ang kasalukuyang bilis: getSpeed (yPos); // Baguhin lamang ang yPos kung ang joystick ay gumalaw nang malaki // int distansya =; Serial.print ((String) xPos + "," + (String) yPos + ',' + (String) currentSpeed + '\ n'); kasalukuyang = millis (); }} // loop int getSpeed (int yPos) {// Mga negatibong halaga ay nagpapahiwatig na lumipat ang Joystick kung (yPos 1023? 1023: currentSpeed + speedIncrement;} iba pa kung (yPos> minMoveHigh) // Nabibigyang kahulugan ang "Down" {// Protect from pagpunta sa ilalim ng 0 return currentSpeed - speedIncrement <0? 0: currentSpeed - speedIncrement;}} // getSpeed void jump () {buttonPressed = true; // Indicate button was pipied.} // jump // Kapag ang isang pindutan ay pinindot sa remote, hawakan ang wastong tugon na walang bisa translateIR (mga resulta sa pag-decode_results) // ay kumukuha ng pagkilos batay sa natanggap na IR code na {switch (results.value) {case 0xFF18E7: //Serial.println("2 "); currentSpeed + = speedIncrement * 2; break; case 0xFF10EF: //Serial.println("4 "); xPos = -900; break; case 0xFF38C7: //Serial.println("5"); jump (); break; case 0xFF5AA5: // Serial. println ("6"); xPos = 900; break; case 0xFF4AB5: //Serial.println("8 "); currentSpeed - = speedIncrement * 2; break; default: //Serial.println (" other button "); masira;} // End switch} // END translateIR

Sinubukan kong likhain ang code upang maipaliwanag ang karamihan, ngunit may ilang mga bagay na sulit na banggitin. Ang isang bagay na sinubukan kong account ay sa mga sumusunod na linya:

int minYMoveUp = 520;

int minYMoveDown = 500;

Kapag tumatakbo ang programa, ang analog na input mula sa joystick ay may posibilidad na tumalon sa paligid, karaniwang nananatili sa paligid ng 507. Upang maitama ito, ang input ay hindi nagbabago maliban kung ito ay mas malaki sa minYMoveUp, o mas maliit sa minYMoveDown.

pinMode (joySwitch, INPUT_PULLUP);

attachInterrupt (0, jump, FALLING);

Pinapayagan ka ng pamamaraang attachInterrupt () na makagambala sa normal na loop sa anumang oras, upang maaari kaming kumuha ng input, tulad ng pindutan ng pindutan kapag na-click ang pindutan ng joystick. Dito, ikinabit namin ang makagambala sa linya bago ito, gamit ang pamamaraan ng pinMode (). Ang isang mahalagang tala dito ay upang maglakip ng isang nakakagambala sa Arduino Uno, kailangan mong gumamit ng alinman sa pin 2 o 3. Ang iba pang mga modelo ay gumagamit ng iba't ibang mga nakakagambala na pin, kaya maaaring suriin mo kung aling mga pin ang ginagamit ng iyong modelo sa website ng Arduino. Ang pangalawang parameter ay para sa paraan ng callback, dito tinawag na isang ISR o isang "Makagambala sa Karaniwang Serbisyo." Hindi ito dapat tumagal ng anumang mga parameter o ibalik ang anumang bagay.

Serial.print (…)

Ito ang linya na magpapadala ng aming data sa larong C #. Dito, ipinapadala namin ang pagbabasa ng X-axis, ang pagbabasa ng Y-axis, at isang variable ng bilis sa laro. Ang mga pagbabasa na ito ay maaaring mapalawak upang maisama ang iba pang mga input at pagbabasa upang gawing mas kawili-wili ang laro, ngunit dito, gagamitin lamang namin ang isang pares.

Kung handa ka nang subukan ang iyong code, i-upload ito sa Arduino, at pindutin ang [Shift] + [Ctrl] + [M] upang buksan ang serial monitor at makita kung nakakakuha ka ng anumang output. Kung nakakatanggap ka ng data mula sa Arduino, handa kaming lumipat sa bahagi ng C # ng code …

Hakbang 3: Lumikha ng C # Project

Upang maipakita ang aming mga graphic, una akong nagsimula ng isang proyekto sa Pagproseso, ngunit kalaunan ay nagpasya na ito ay masyadong mabagal upang ipakita ang lahat ng mga bagay na kailangan naming ipakita. Kaya, pinili kong gumamit ng C #, na naging mas makinis at mas tumutugon kapag hinahawakan ang aming input.

Para sa bahagi ng C # ng proyekto, pinakamahusay na i-download lamang ang.zip file at i-extract ito sa sarili nitong folder, pagkatapos ay baguhin ito. Mayroong dalawang mga folder sa zip file. Upang buksan ang proyekto sa Visual Studio, ipasok ang RunnerGame_CSharp folder sa Windows Explorer. Dito, i-double click ang.sln (solution) file, at mai-load ng VS ang proyekto.

Mayroong ilang iba't ibang mga klase na nilikha ko para sa laro. Hindi ko sasabihin sa lahat ng mga detalye tungkol sa bawat klase, ngunit bibigyan ko ng isang pangkalahatang ideya kung para saan ang mga pangunahing klase.

Ang Klase ng Kahon

Nilikha ko ang kahon ng kahon upang payagan kang lumikha ng mga simpleng bagay na parihaba na maaaring iguhit sa-screen sa isang form na windows. Ang ideya ay upang lumikha ng isang klase na maaaring mapalawak gamit ang iba pang mga klase na maaaring gumuhit ng ilang uri ng graphics. Ginamit ang keyword na "virtual" upang ang iba pang mga klase ay maaaring lumampas sa kanila (gamit ang keyword na "override"). Sa ganoong paraan, makakakuha tayo ng parehong pag-uugali para sa klase ng Player at klase sa Platform kapag kailangan namin, at baguhin din ang mga bagay subalit kailangan namin.

Huwag mag-alala ng labis tungkol sa lahat ng mga pag-aari at gumuhit ng mga tawag. Sinulat ko ang klase na ito upang maipahaba ko ito para sa anumang programang pang-laro o grapiko na maaaring gusto kong gawin sa hinaharap. Kung kailangan mong gumuhit lamang ng isang rektanggulo sa mabilisang, hindi mo kailangang magsulat ng isang malaking klase na tulad nito. Ang dokumentasyong C # ay may magagandang halimbawa kung paano ito gawin.

Gayunpaman, ilalagay ko ang ilan sa lohika ng aking "Kahon" na klase:

pampublikong virtual bool IsCollidedX (Box otherObject) {…}

Sinusuri namin dito ang mga pagkakabangga ng mga bagay sa direksyon na X, dahil kailangan lamang suriin ng manlalaro ang mga banggaan sa direksyon ng Y (pataas at pababa) kung siya ay nakahanay dito sa screen.

pampublikong virtual bool IsCollidedY (Box otherObject) {…}

Kapag natapos na kami o nasa ilalim ng isa pang object ng laro, sinusuri namin ang mga banggaan ng Y.

pampublikong virtual bool IsCollided (Box otherObject) {…}

Pinagsasama nito ang mga banggaan ng X at Y, na ibinabalik kung may anumang bagay na nakabanggaan ng isang ito.

pampublikong virtual na walang bisa ng OnPaint (Mga graphic na graphic) {…}

Gamit ang pamamaraang nasa itaas, ipinapasa namin ang anumang object ng graphics at ginagamit ito habang tumatakbo ang programa. Lumilikha kami ng anumang mga parihaba na maaaring kailanganing iguhit. Maaari itong magamit para sa iba't ibang mga animasyon. Para sa aming mga layunin, ang mga rektanggulo ay makakabuti para sa parehong mga platform at player.

Ang Klase ng Character

Pinahaba ng klase ng Character ang aking klase sa Kahon, kaya mayroon kaming tiyak na pisika na wala sa kahon. Nilikha ko ang pamamaraang "CheckForCollision" upang mabilis na suriin ang lahat ng mga platform na nilikha namin para sa isang banggaan. Itinatakda ng pamamaraang "Tumalon" ang pataas na tulin ng manlalaro sa variable na JumpSpeed, na pagkatapos ay binago ng frame-by-frame sa klase ng MainWindow.

Ang mga banggaan ay hinahawakan nang bahagyang naiiba dito kaysa sa klase sa Kahon. Nagpasya ako sa larong ito na kung tumatalon paitaas, maaari kaming tumalon sa pamamagitan ng isang platform, ngunit mahuhuli nito ang aming manlalaro na pababa kung makabangga nito.

Ang Klase sa Platform

Sa larong ito, ginagamit ko lamang ang tagabuo ng klase na ito na tumatagal ng isang X-coordinate bilang isang input, kinakalkula ang lahat ng mga lokasyon ng X ng mga platform sa klase ng MainWindow. Ang bawat platform ay naka-set up sa isang random na Y-coordinate mula 1/2 sa screen hanggang 3/4 ng taas ng screen. Ang taas, lapad, at kulay ay random na nabuo din.

Ang Klase ng MainWindow

Dito namin inilalagay ang lahat ng lohika na gagamitin habang tumatakbo ang laro. Una, sa tagapagbuo, nai-print namin ang lahat ng mga COM port na magagamit sa programa.

maaga (string port sa SerialPort. GetPortNames ())

Console. WriteLine ("AVAILABLE PORTS:" + port);

Pipiliin namin kung alin ang tatanggapin namin ang mga komunikasyon, alinsunod sa kung aling port ang ginagamit na ng iyong Arduino:

SerialPort = bagong SerialPort (SerialPort. GetPortNames () [2], 9600, Parity. None, 8, StopBits. One);

Bigyang pansin ang utos: SerialPort. GetPortNames () [2]. Ang [2] ay nangangahulugang aling serial port ang gagamitin. Halimbawa, kung ang programa ay nakalimbag ng "COM1, COM2, COM3", nakikinig kami sa COM3 dahil ang pagnunumero ay nagsisimula sa 0 sa array.

Gayundin sa tagapagbuo, nilikha namin ang lahat ng mga platform na may semi-random spacing at pagkakalagay sa direksyon ng Y sa screen. Ang lahat ng mga platform ay idinagdag sa isang listahan ng Listahan, na sa C # ay isang napaka-user-friendly at mahusay na paraan ng pamamahala ng isang tulad-istrakturang istraktura ng data. Pagkatapos ay nilikha namin ang Player, na kung saan ay ang aming object ng Character, itakda ang iskor sa 0 at itakda ang GameOver sa false.

pribadong static na walang bisa DataReceived (nagpadala ng object, SerialDataReceivedEventArgs e)

Ito ang pamamaraan na kung tawagin kapag natanggap ang data sa Serial port. Dito namin inilalapat ang lahat ng aming pisika, nagpapasya kung ipapakita ang laro, ilipat ang mga platform, atbp. Kung nakagawa ka na ng isang laro, sa pangkalahatan ay mayroon kang tinatawag na "game loop", na tinatawag na sa tuwing ang frame nagre-refresh Sa larong ito, ang pamamaraang DataReceived ay kumikilos bilang loop ng laro, manipulahin lamang ang pisika bilang data na natanggap mula sa controller. Maaaring mas mahusay itong gumana upang mag-set up ng isang Timer sa pangunahing window, at i-refresh ang mga bagay batay sa natanggap na data, ngunit dahil ito ay isang proyekto ng Arduino, nais kong gumawa ng isang laro na talagang tumakbo batay sa data na nagmumula dito.

Bilang konklusyon, ang setup na ito ay nagbibigay ng isang mahusay na batayan para sa pagpapalawak ng laro sa isang bagay na magagamit. Kahit na ang pisika ay hindi lubos na perpekto, gumagana ito ng maayos para sa aming mga layunin, na kung saan ay ang paggamit ng Arduino para sa isang bagay na gusto ng lahat: naglalaro ng mga laro!