Arduino - Mga Piano Tile: 16 Hakbang (na may Mga Larawan)

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

Kumusta mga tao sa internet, ito ay magiging tungkol sa kung paano gawin kung ano ang tiyak na hindi isang rip off ng isang mobile game sa isang arduino uno r3.

kaya upang magsimula, kakailanganin mo ang lahat ng mga bahagi, na kung saan ay ang mga sumusunod! 1x Arduino Uno r3 ($ 42)

2x LCD Keypad Shield ($ 19 bawat isa)

5x mga pindutan

5x 220Ω resistors

28x wires

Sige, kapag nakuha mo na ang lahat ng mga bahagi ay oras na upang magsimula!

Hakbang 1: Mga kable

Magsimula sa pamamagitan ng pag-wire up ng iyong arduino at mga kaibigan tulad ng ipinakita sa diagram, Siguraduhin na ang mga pindutan ay naka-link sa tamang paraan, na may mga puwang ng A0-4 sa ilalim na bahagi ng mga riles ng pindutan, o sa halip ay iisipin ng arduino na ang mga pindutan ay patuloy na pinipigilan sa halip na sa isang pindutin lamang.

Hakbang 2: Mga Pahayag ng Pagpapahayag

Ang lahat ng code dito ay dapat pumunta bago ang iyong void setup at void loop, ito ay dahil ang lahat ng mga variable at object na ito ay ginagamit sa maraming mga pagpapaandar na mai-set up namin.

Magsimula sa pamamagitan ng paglalagay ng:

# isama

sa tuktok ng iyong code, sinasabi sa arduino na gamitin ang library na "LiquidCrystal.h" at ang mga pagpapaandar na bahagi nito.

Ang susunod na hakbang ay upang tukuyin ang mga pin na ginagamit namin para sa aming mga pindutan sa pamamagitan ng paglalagay ng code na ito sa ibaba ng aming # isama:

#define btnEnter A0 # tukuyin btn1 15 #define btn2 16 #define btn3 17 #define btn4 18

Tinutukoy namin ang mga term na btnEnter at btn1 sa btn 4 upang gawing mas madali ang code na mabasa namin, o baguhin kung kinakailangan. Nangangahulugan ito na kapag nai-type namin ang btn1 malalaman ng arduino na sa katunayan ay tinutukoy natin ang pindutan na 15. Bagaman tumatawag kami sa port port 15, 16, 17 at 18, ang mga ito ay may label sa arduino bilang A1 A2 A3 at A4, ito ay dahil ang mga ito ay mga port na partikular na ginagamit para sa mga analog na input, bagaman ginagamit lamang namin ang mga ito para sa mga digital na input.

Susunod na lilikha kami ng mga bagay na makokontrol ang Mga Liquid Crystal Displays. Upang magawa ito, ilagay ang code na ito sa ibaba ng aming mga tumutukoy

LiquidCrystal lcdLeft (8, 9, 12, 10, 11, 13); LiquidCrystal lcdRight (2, 3, 4, 5, 6, 7);

Ang ginagawa nito ay sinasabi sa arduino na kapag tumawag tayo sa lcdLeft o lcdRight tumutukoy kami sa isang bagay na LiquidCrystal. Ang mga numero sa mga nakakabit na braket ay nagsasabi sa arduino kung aling mga port ang dapat gamitin ng bagay upang magpadala ng mga mensahe sa LCD kapag ginamit namin ang kanilang mga pagpapaandar.

Ngayon kailangan naming ideklara ang mga variable sa pamamagitan ng paglalagay ng susunod na piraso ng code sa ibaba ng mga pagdedeklara ng bagay:

// ang mga variable na ito ay mga pagpipilian na maaari mong baguhin - mas mataas na mga numero = mas mabilis na bilis ng laro upint intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// set up variable para sa gameboolean bolPlay; // sumusubaybay kung ang int intScore ng player; // sumusubaybay sa marka ng int intDiff ng player; // isang bagay na estetiko lamang para sa pagsasabi kung anong kahirapan ang laro sa // pag-set up ng mga variable para sa input int intEnter; // sinusubaybayan kung pinindot ng gumagamit ang enter button int intput; // sinusubaybayan kung aling mga pindutan ang pinindot ng gumagamit sa boolean bolTilePressed; // tiyaking ang manlalaro ay hindi sinasadyang pindutin ang isang pindutan na 5x at mawala / // i-set up ang mga variable para sa turn int intTick; // count up millies (per loop) hanggang intDelay int intDelay; // ang oras na naghihintay ang programa hanggang sa susunod na pagliko sa millis int intGameSpeed; // abit of debug options boolean bolSerialBoard; // kapag totoo ay mai-print ang board sa serial monitor

Ipinahayag namin ang isang variable sa pamamagitan ng pagsasabi ng uri ng data at pagkatapos ay ang pangalan ng variable, hal. int thisIsAnInteger

Ang mga variable ng Boolean, tulad ng bolSerialBoard at bolPlay ay maaari lamang magkaroon ng isa sa dalawang mga halaga, totoo o hindi.

Ang variable ng integer (int) tulad ng intScore at intInput ay maaaring tumagal ng buong bilang bilang mga halaga, tulad ng 1, 5 o 100.

Ang ilang iba pang mga kilalang uri ng data na hindi namin ginagamit dito ay isang string, na isang piraso ng teksto, at isang float, na isang decimal number.

Ang bawat isa sa mga variable dito ay ginagamit sa iba't ibang mga lugar ng programa, narito ang isang buod ng kung ano ang ginagawa ng bawat isa

Sinasabi ng bolPlay sa programa kung dapat ipakita ang menu o kung dapat tumakbo ang aktwal na laro.

Sinusubaybayan ng intScore ang marka ng manlalaro nang tumama ang mga ito sa mga tile, Ginagamit ang intDiff sa pangunahing menu upang sabihin sa programa kung anong piraso ng teksto ang mai-print sa LCD, Ginagamit ang intEnter upang sabihin sa programa kung ang pindutang ipasok (pinakamalayo sa kaliwa) ay pinindot, Ginagamit ang intInput upang sabihin sa programa kung alin sa iba pang 4 na mga pindutan ang pinindot.

Ginagamit ang bolTilePressed upang matiyak na mababasa lamang ang programa kapag pinindot ang pindutan at hindi kapag gaganapin ito.

intGameSpeed, intGameSpeedEasy, intGameSpeedMedium at intGameSpeedHard ay ginagamit upang makontrol kung gaano kabilis ang laro ay dapat na mapabilis batay sa kung aling kahirapan ang napili.

Ang intTick at intDelay ay ginagamit upang ihinto ang programa mula sa paglipat ng board tuwing ito ay nag-loop.

Ginagamit ang bolSerialBoard upang pahintulutan kang gawin ang programa na ipadala ang board sa serial monitor ng arduino bilang isang serye ng mga numero para sa mga layunin sa pagsubok.

Sa wakas ay oras na upang ideklara ang aming board bilang isang array gamit ang code na ito:

// set up game arrayint arrGame [16] [4] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};

Ang isang array ay isang matrix na ang anumang punto kung saan maaaring tawagan para sa matematika o mabago.

Ang iyong code ay dapat na magmukhang ganito;

// isama ang mga aklatan # isama

// ang mga variable na ito ay mga pagpipilian na maaari mong baguhin - mas mataas na mga numero = mas mabilis na bilis ng laro

int intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// Tukuyin ang mga pin

#define btnEnter A0 #define btn1 15 #define btn2 16 #define btn3 17 #define btn4 18

// lumikha ng mga LCD object (n, ~, n, ~, ~, n)

LiquidCrystal lcdLeft (8, 9, 12, 10, 11, 13); LiquidCrystal lcdRight (2, 3, 4, 5, 6, 7);

// i-set up ang larong laro

int arrGame [16] [4] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};

// set up variable para sa laro

boolean bolPlay; // sumusubaybay kung ang int intScore ng player; // sumusubaybay sa marka ng int intDiff ng player; // isang bagay na estetika lamang para sa pagsasabi kung anong kahirapan ang laro

// set up variable para sa pag-input

int intEnter; // sinusubaybayan kung pinindot ng gumagamit ang enter button int intput; // sinusubaybayan kung aling mga pindutan ang pinindot ng gumagamit sa boolean bolTilePressed; // tiyakin na ang manlalaro ay hindi sinasadyang pindutin ang isang pindutan na 5x at mawala

// set up variable para sa pagliko

int intTick; // count up millies (per loop) hanggang intDelay int intDelay; // ang oras na naghihintay ang programa hanggang sa susunod na pagliko sa millis int intGameSpeed;

// abit ng mga pagpipilian sa pag-debug

boolean bolSerialBoard; // kapag totoo ay mai-print ang board sa serial monitor

Hakbang 3: Ang Pag-andar ng Pag-setup

Ang loop ng pag-setup ay isang pagpapaandar na binasa ng arduino nang isang beses lamang kapag nagsimula ito nang una.

Sa loop ng pag-set up nagtatakda lamang kami ng mga halaga ng ilan sa aming mga variable dahil sa halip na magtakda ng isang halaga sa kanila kapag idineklara ang mga ito ginagawa namin ito dito.

Magsimula sa pamamagitan ng paglalagay ng code na ito sa iyong Void Setup.

bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium;

Ang bawat linya ay nagtatakda lamang ng isang variable sa isang halaga.

ang bolPlay ay nakatakda sa false upang ang laro ay hindi magsimulang maglaro.

Ang intScore ay nakatakda sa 0, dahil natural na ang iyong iskor ay nagsisimula sa 0.

nagsisimula ang intTick sa 0 dahil ang programa ay kasalukuyang hindi nagbibilang ng kahit ano.

Ang intDelay ay nakatakda sa 1000 sapagkat iyon ang rate na nagsisimula ang mga tile sa.

Ang intDiff ay isang ascetic bagay lamang upang malaman ng programa kung ano ang isusulat para sa kahirapan ng laro.

Ang intGameSpeed ay nakatakda sa anumang intGameSpeedMedium, nangangahulugang ito ay itinakda sa daluyan ng kahirapan.

Susunod na ilagay ang code na ito sa Void Setup sa ibaba ng code na inilagay mo lamang.

lcdLeft.begin (16, 2); lcdRight.begin (16, 2);

Serial.begin (9600);

Sinasabi nito sa arduino upang simulang makipag-ugnay sa computer sa pamamagitan ng serial monitor (nakikita sa pamamagitan ng pag-click sa pindutan sa kanang tuktok ng arduino IDE).

Ang iyong Void Setup ay dapat na magmukhang ganito!

void setup () {Serial.begin (9600); // simulan ang serial monitor // i-set up ang mga variable na bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // start lcd's lcdLeft.begin (16, 2); lcdRight.begin (16, 2); }

Hakbang 4: Ang Pag-andar ng Loop

Ang pagpapaandar ng loop ay pinapatakbo ng arduino bawat pag-ulit ng arduino.

Kopyahin ang sumusunod na code sa iyong Void Loop.

void loop () {input (); // check for playing input if (bolPlay == true) {if (intTick> = intDelay) {// check to see if the game should play a turn or continue to wait Serial.println ("~~~~~~~ ~~ "); // print upang ipahiwatig ang paglipat ng board sa // writeSerial (); // kung pinagana ang pagpipilian isulat ang board sa mga serial buttonGame (); // check for input ng player playBoard (); // ilipat ang board at magdagdag ng isang bagong tile clearLcd (); // linisin ang mga LCD bago iguhit ang drawBoard (); // iguhit ang board papunta sa ilalim ng lcdCheck (); intTick = 0; // reset intTick} iba pa {buttonGame (); // check for player inputs clearLcd (); // linisin ang mga LCD bago iguhit ang drawBoard (); // iguhit ang board papunta sa intTick ng lcd = intTick + intGameSpeed; // add to tick}} iba pa {clearLcd (); // linisin ang mga LCD bago mag-drawing ng pamagat (); // display title and score info infoMenu (); // read player input clearBoard (); // tiyakin ang buong board = 0} pagkaantala (10); // antalahin ang arduino ng isang maikling sandali}

kapag ang bolPlay ay katumbas ng totoo nangangahulugan ito na ang laro ay naglalaro, at ang lahat ng code para sa kung naglalaro ang laro ay dapat na patakbuhin, ngunit nais lamang namin ang board na magdagdag ng isang bagong tile at lumipat pababa kapag ang intTick ay mas malaki kaysa sa aming intDelay, kung hindi man gusto pa rin naming payagan ang gumagamit na pindutin ang isang pindutan upang ma-hit ang isang tile at upang madagdagan ang bilis ng intTick.

Karamihan sa code na ito ay gumagamit ng mga pagpapaandar na gagawin pa namin, at gagawin namin ang mga ito sa mga susunod na hakbang. Ang layunin ng mga pagpapaandar na ito ay ang mga sumusunod.

Binabasa ng input kung aling mga pindutan ang pinindot ng gumagamit.

Kinokontrol ng buttonGame kung ano ang ginagawa ng mga pindutan kapag nasa laro, at wala sa menu

Nagdaragdag ang playBoard ng isang bagong tile sa board, at pagkatapos ay ilipat ang lahat sa board pababa sa isang puwang

nililinis ng clearLCD ang mga LCD upang matiyak na walang mga multo na naiwan sa likod ng mga tile

Ang drawBoard ay dumadaan sa arrGame at i-print ito sa mga LCD

Tinatanggal ng clearBoard ang buong arrGame kapag ang laro ay wala sa paglalaro

ilalimSuriin ang tsek sa ilalim ng arrGame para sa isang kondisyon ng pagkabigo

ipinapakita ng pamagat ang pamagat ng laro at impormasyon sa iskor kapag nasa menu

Kinokontrol ng menu ng mga pindutan ang ginagawa ng mga input ng gumagamit kapag nasa menu.

Ang gameOver ay isa pang pagpapaandar, bagaman hindi ito tinawag dito dahil sa halip ay tinawag ito sa ilalim na pag-check at pag-andar ng mga pindutan ng Game.

Hakbang 5: Ang Pag-andar ng ClearLCD

upang lumikha ng isang pagpapaandar nagsisimula kami sa pamamagitan ng pagdaragdag nito sa code

void functionName () {

}

ang "functionName" ay maaaring maging anumang bagay, hangga't wala ito.

Kopyahin ang code na ito sa iyong programa:

void clearLcd () {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 1; ii ++) {lcdLeft.setCursor (i, ii); lcdLeft.write (""); lcdRight.setCursor (i, ii); lcdRight.write (""); }}}

tumatakbo ito sa buong array sa pamamagitan ng paggamit ng 2 binibilang na mga loop upang dumaan sa bawat punto sa mga LCD at magsulat ng isang puwang.

Nang hindi nai-reset sa wala, panatilihin ng LCD ang anumang nakasulat dati

Hakbang 6: Ang DrawBoard Function

kopyahin ang code na ito sa iyong programa

void drawBoard () {for (int i = 1; i <= 15; i ++) {// draw collums 1 and 2 on the left LCD // if the tile = 0 magsulat wala, = 1 isulat ang "#", = 2 isulat ang "@" lcdLeft.setCursor (i, 1); // set to the first collumn (far farest left) if (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // set to the second collumn (center left) if (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // set to the third collumn (center right) if (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // itakda sa ika-apat na collumn (pinakamalayo sa kanan) kung (arrGame [3] == 1) {lcdRight.write ("#");} kung (arrGame [3] == 2) {lcdRight.sulat ("@");}}}

gumagamit ito ng isang loop upang dumaan sa bawat hilera ng board, pagkatapos ay suriin ito upang makita kung ang anumang haligi sa hilera ay katumbas ng 1 o 2, batay sa pag-print nito sa LCD alinman sa isang hashtag, para sa isang tile na maging hit, o isang @ para sa isang hit tile.

Hakbang 7: Ang PlayBoard Function

kopyahin ang code na ito sa iyong programa.

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // clear the top row arrGame [0] [random (0, 4)] = 1; // magtakda ng isang random point sa tuktok na hilera upang maging isang tile para sa (int i = 15; i> = 1; i -) {// nagtatrabaho mula sa ilalim ng board hanggang sa itaas para sa (int ii = 0; ii <= 3; ii ++) {// para sa bawat collum arrGame [ii] = arrGame [i - 1] [ii]; }}}

nagsisimula ang code na ito sa pamamagitan ng pag-clear sa buong tuktok na hilera sa 0, o walang tile, at pagkatapos ay nagtatakda ng isang random na tile na maging isang 1, at i-tile ang tile.

Pagkatapos ay dumadaan ito sa isang binibilang na loop sa kabaligtaran, mula 15 hanggang 1, na itinatakda ang hilera sa pantay na anuman ang hilera sa itaas nito ay katumbas, na ginagawang pababa ng board ang LCD

Hakbang 8: Ang ClearBoard Function

kopyahin ang code na ito sa iyong programa.

void clearBoard () {// reset tick at antala ang mga halaga intTick = 0; intDelay = 1000; // dumaan sa board at itakda ang lahat sa 0 para (int i = 0; i <= 15; i ++) {para (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

Tumatakbo ang code na ito kapag ang laro ay hindi naglalaro upang matiyak na ang buong arrGame ay nakatakda sa 0, o walang mga tile, sa pamamagitan ng paggamit ng binibilang na mga loop upang dumaan sa array.

Nire-reset din ng code ang mga halaga ng intDelay at intTick.

Hakbang 9: Ang Pag-andar ng Pamagat

kopyahin ang sumusunod na code sa iyong programa

walang bisa na pamagat () {// sumulat ng pamagat sa LCD at puwang para sa iskor lcdRight.setCursor (0, 0); lcdRight.write ("Piano Tiles"); lcdRight.setCursor (0, 1); lcdRight.write ("Iskor:"); // convert the score into a string char strScore [3]; sprintf (strScore, "% d", intScore); // display score papunta sa LCD lcdRight.write (strScore); // idagdag ang diffictuly lcdRight.setCursor (10, 1); kung (intDiff == 0) {lcdRight.write ("Madali"); } kung (intDiff == 1) {lcdRight.write ("Medium"); } kung (intDiff == 2) {lcdRight.write ("Hard"); } // Pindutin ang kaunting tagubilin lcdLeft.setCursor (0, 0); lcdLeft.write ("Pindutin ang Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write ("upang magsimula!"); }

Sinusulat ng code na ito ang pamagat ng laro at ang iskor sa mga LCD, ginagawa ito sa pamamagitan ng pagsasabi sa LCD kung saan magsisimulang magta-type gamit ang LCD.setCursor at pagkatapos ay isulat ang string sa LCD. Magsulat.

Ang isang bagong variable ay nilikha din dito, strScore, ginagamit ito upang i-convert ang intScore sa isang string o uri ng data ng char gamit ang pagpapaandar ng sprintf.

Ginagamit din ang intDiff dito, batay sa mga halaga nito ay nai-print nito ang iba't ibang mga pagpipilian sa paghihirap.

Hakbang 10: Ang ButtonsMenu Function

ipasok ang sumusunod na code sa iyong programa

void pindutanMenu () {// kapag ipinasok ay pinindot simulan ang laro at i-reset ang halaga ng puntos kung (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // kapag pinindot ang pindutan 3 buksan ang pagpipiliang pag-debug ng pag-print ng board sa serial kung (intInput == 3) {kung (bolSerialBoard == false) {Serial.println ("Aktibo ng Serial Board"); bolSerialBoard = totoo; } iba pa {Serial.println ("Hindi pinagana ang Serial Board"); bolSerialBoard = false; }} // itakda ang bilis ng laro sa madaling kahirapan kung (intInput == 0) {Serial.print ("Game set to easy ("); Serial.print (intGameSpeedEasy); Serial.println ("ms acceleration)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // itakda ang bilis ng laro sa katamtamang kahirapan kung (intInput == 1) {Serial.print ("Game set to medium ("); Serial.print (intGameSpeedMedium); Serial.println ("ms acceleration)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // itakda ang bilis ng laro sa mahirap na kahirapan kung (intInput == 2) {Serial.print ("Game set to hard ("); Serial.print (intGameSpeedHard); Serial.println ("ms acceleration)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

Ang code na ito ay tatakbo lamang kapag ang bolPlay ay katumbas ng false sa void Loop

kung ang intEnter ay nakatakda sa 1 nangangahulugan ito na ang pindutan ng enter ay naitulak, kung pinipindot ang programa ay nagtatakda ng bolPlay sa totoo at nagsisimula ang laro.

Basahin ng programa kung ano ang katumbas ng intInput. kung ito ay katumbas ng 0 ang unang pindutan mula sa kaliwa ay pinindot, pagpunta sa kanan hanggang sa 3. Kung ang intInput ay katumbas ng 4 walang pindutan ay pinindot.

kung ang mga pindutan na 0-2 ay pinindot ang laro ay nagbabago ng kahirapan, inaayos din ang halaga ng bilis ng laro, nangangahulugang mas mabilis itong magpapabilis.

kung ang pindutan 3 ay pinindot ang laro ay magpapagana o magpapagana ng isang debug mode kung saan ang buong board ay naka-print sa serial monitor upang tumulong sa paghahanap ng mga isyu sa programa.

Hakbang 11: Ang ButtonsGame Function

kopyahin ang sumusunod na code sa iyong programa

void pindutanGame () {kung (intInput! = 4) {// kung ang isang pindutan ay pinindot kung (bolTilePressed == maling) {// kung ang bolTilePressed ay maling pagkilos na pag-trigger para sa pag-check sa isang pindutan pindutin ang bolTilePressed = totoo; // pagkatapos ay itakda ang bolTilePressed to true upang matiyak na hindi ito aksidentilly na nai-trigger muli int intLowestTile = 0; // upang maitakda sa tile na may pinakamababang tile int intCheckedTile = 15; // upang subaybayan kung aling mga tile ang nasuri habang (intLowestTile == 0) {// hangga't hindi ito nakatakda sa anumang suriin ang mga tile para sa (int i = 0; i 100) {// basta int ang pagkaantala ay hindi mas mababa sa 100 intDelay = intDelay - 20; // kumuha ng halaga mula rito}} iba pa {Serial.println ("Maling pindutan na pinindot"); tapos na ang laro(); // otherwise game over}}}}}

Tumatakbo lamang ang code kapag ang bolPlay ay katumbas ng totoo sa walang bisa na Loop.

Tulad ng mga pindutanMenu batay sa halaga ng intInput sinusuri nito upang makita kung ang manlalaro ay na-hit ang isang tile o napalampas na isa.

Ginagawa ito sa pamamagitan ng pagdaan sa arrGame mula sa ibaba hanggang sa tuktok gamit ang isang habang loop upang hanapin kung aling hilera ang pinakamababa na may isang hindi na-tile na tile. Sinuri nito upang makita kung ang lugar sa hilera na naaayon sa pindutan na itinulak ay isang tile na hindi nakasakit o hindi, kung ito ay hindi mapansin ito ay itinatakda nito sa pantay na 2 sa halip na 1, nangangahulugang ito ay ipapakita bilang isang @, kung hindi man ay nagpapalitaw ito ng laro pagpapaandar na gagawin pa natin.

Gumagamit din ang pagpapaandar na ito ng variable ng bolTilePressed sa pamamagitan ng pagtatakda nito sa totoo kapag ang isang pindutan ay pinindot at hindi totoo kapag walang pindutan na pinindot. Ito ay upang matiyak na hindi aksidenteng maluwag ng gumagamit ang laro dahil naisip ng programa na pinindot nila ang pindutan nang maraming beses nang pinigilan nila ito.

Hakbang 12: Ang GameOver Function

Kopyahin ang sumusunod na code sa iyong programa

void gameOver () {Serial.println ("Game Over!"); Serial.print ("Ang iyong iskor ay:"); Serial.println (intScore); Serial.print ("Ang bilis mo ay:"); Serial.println (intDelay); bolPlay = false; }

Ito ay na-trigger ng alinman sa checkBottom o mga pag-andar ng pindutan ng Laro at pinapagana ang pagtatapos nito ng laro sa pamamagitan ng pagtatakda ng bolPlay na maging mali.

Nagpi-print din ito ng isang mensahe sa serial monitor para sa marka ng mga gumagamit at ang mga tile ng bilis ay idinagdag sa milliseconds.

Hakbang 13: Ang Pag-andar ng Input

Kopyahin ang sumusunod na code sa iyong programa.

void input () {intEnter = digitalRead (btnEnter); // read enter // read which of the other inputs, or if none set to 4 if (digitalRead (btn1) == HIGH) {intInput = 0;} else {if (digitalRead (btn2) == MATAAS) {intInput = 1;} iba pa {kung (digitalRead (btn3) == TAAS) {intInput = 2;} iba pa {kung (digitalRead (btn4) == TAAS) {intInput = 3;} iba pa {intInput = 4; }}}} // serial print the inputs if (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } iba pa {// kung walang pindutan na pinindot i-reset ang bolTilePressed bolTilePressed = false; }}

Ang code na ito ay ginagamit sa mga pag-andar ng pindutan ng Laro at mga pindutan ngMenu. batay sa mga pindutan na pinindot ng gumagamit ay itinatakda nito ang halaga ng intInput, o kung walang pinindot ang pindutan nagtatakda ito ng intInput sa pantay na 4.

Kung walang pinindot na pindutan na ito ay kung saan nai-reset ang bolTilePressed para sa pag-andar ng mga pindutan.

Nagpi-print din ito ng isang mensahe sa serial monitor kung aling pindutan ang pinindot.

Hakbang 14: Ang Pag-andar ng BottomCheck

kopyahin ang sumusunod na code sa iyong programa.

void bottomCheck () {para sa (int i = 0; i <= 3; i ++) {// para sa 4 na mga kolum kung (arrGame [15] == 1) {// kung ang isang tile ay nasa ilalim ng Serial.println ("Tile sa ilalim"); arrGame [15] = 2; drawBoard (); pagkaantala (400); arrGame [15] = 1; drawBoard (); pagkaantala (400); arrGame [15] = 2; drawBoard (); pagkaantala (400); arrGame [15] = 1; drawBoard (); pagkaantala (400); tapos na ang laro(); }}}

gamit ang isang loop ang code na ito ay sumusuri sa ilalim na hilera ng arrGame para sa anumang mga hindi nakabagabag na mga tile (mga tile na katumbas ng 1), kung mayroong isang hindi nakagagambalang tile sa ilalim ng screen ay i-flash nito ang tile at pagkatapos ay mapalitaw ang laro sa pag-andar.

Hakbang 15: Ang WritingSerial Function

kopyahin ang sumusunod na code sa iyong programa

void writeSerial () {if (bolSerialBoard == true) {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {Serial.print (arrGame [ii]); Serial.print (","); } Serial.println (""); }}}

Ito ang pagpapaandar na sinusundan ng pagpipiliang pag-debug na maaaring paganahin sa pag-andar ng mga pindutan ngMenu. Kung ang bolSerialBoard ay nakatakda sa totoo sa pagpapaandar na iyon dumadaan ito sa arrGame at mai-print ang buong board sa serial monitor para sa mga layunin sa pagsubok sa pamamagitan ng paggamit ng isang array.

Hakbang 16: Pagkumpleto

Ang lahat ng iyong code ay hindi dapat kumpleto at magmukhang ganito!

/ * * Pangalan - Mga Piano Tile; Arduino * Ni - Domenic Marulli * Petsa - 11 / *

/ isama ang mga aklatan

# isama

// ang mga variable na ito ay mga pagpipilian na maaari mong baguhin - mas mataas na mga numero = mas mabilis na bilis ng laro

int intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// Tukuyin ang mga pin

#define btnEnter A0 #define btn1 15 #define btn2 16 #define btn3 17 #define btn4 18

// lumikha ng mga LCD object (n, ~, n, ~, ~, n)

LiquidCrystal lcdLeft (8, 9, 12, 10, 11, 13); LiquidCrystal lcdRight (2, 3, 4, 5, 6, 7);

// i-set up ang larong laro

int arrGame [16] [4] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};

// set up variable para sa laro

boolean bolPlay; // sumusubaybay kung ang int intScore ng player; // sumusubaybay sa marka ng int intDiff ng player; // isang bagay na estetika lamang para sa pagsasabi kung anong kahirapan ang laro

// set up variable para sa pag-input

int intEnter; // sinusubaybayan kung pinindot ng gumagamit ang enter button int intput; // sinusubaybayan kung aling mga pindutan ang pinindot ng gumagamit sa boolean bolTilePressed; // tiyakin na ang manlalaro ay hindi sinasadyang pindutin ang isang pindutan na 5x at mawala

// set up variable para sa pagliko

int intTick; // count up millies (per loop) hanggang intDelay int intDelay; // ang oras na naghihintay ang programa hanggang sa susunod na pagliko sa millis int intGameSpeed;

// abit ng mga pagpipilian sa pag-debug

boolean bolSerialBoard; // kapag totoo ay mai-print ang board sa serial monitor

// ang setup na tatakbo nang isang beses

void setup () {Serial.begin (9600); // simulan ang serial monitor // i-set up ang mga variable na bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // start lcd's lcdLeft.begin (16, 2); lcdRight.begin (16, 2); }

// ang loop na tatakbo bawat 10 millisecons

void loop () {input (); // check for playing input if (bolPlay == true) {if (intTick> = intDelay) {// check to see if the game should play a turn or continue to wait Serial.println ("~~~~~~~ ~~ "); // print upang ipahiwatig ang paglipat ng board sa // writeSerial (); // kung pinagana ang pagpipilian isulat ang board sa mga serial buttonGame (); // check for input ng player playBoard (); // ilipat ang board at magdagdag ng isang bagong tile clearLcd (); // linisin ang mga LCD bago iguhit ang drawBoard (); // iguhit ang board papunta sa ilalim ng lcdCheck (); intTick = 0; // reset intTick} iba pa {buttonGame (); // check for player inputs clearLcd (); // linisin ang mga LCD bago iguhit ang drawBoard (); // iguhit ang board papunta sa intTick ng lcd = intTick + intGameSpeed; // add to tick}} iba pa {clearLcd (); // linisin ang mga LCD bago mag-drawing ng pamagat (); // display title and score info infoMenu (); // read player input clearBoard (); // tiyakin ang buong board = 0} pagkaantala (10); // antalahin ang arduino ng isang maikling sandali}

// nililinis ang lcd, kung kaya't ang anumang mga hindi nakapunta na mga cell ay hindi naiwan doon

void clearLcd () {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 1; ii ++) {lcdLeft.setCursor (i, ii); lcdLeft.write (""); lcdRight.setCursor (i, ii); lcdRight.write (""); }}}

// iginuhit ang board papunta sa lcd's

void drawBoard () {for (int i = 1; i <= 15; i ++) {// draw collums 1 and 2 on the left LCD // if the tile = 0 magsulat wala, = 1 isulat ang "#", = 2 isulat ang "@" lcdLeft.setCursor (i, 1); // set to the first collumn (far farest left) if (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // set to the second collumn (center left) if (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // set to the third collumn (center right) if (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // itakda sa ika-apat na collumn (pinakamalayo sa kanan) kung (arrGame [3] == 1) {lcdRight.write ("#");} kung (arrGame [3] == 2) {lcdRight.sulat ("@");}}}

// inililipat ang board pababa at naglalagay ng isang random na halaga upang maging isang tile

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // clear the top row arrGame [0] [random (0, 4)] = 1; // magtakda ng isang random point sa tuktok na hilera upang maging isang tile para sa (int i = 15; i> = 1; i -) {// nagtatrabaho mula sa ilalim ng board hanggang sa itaas para sa (int ii = 0; ii <= 3; ii ++) {// para sa bawat collum arrGame [ii] = arrGame [i - 1] [ii]; }}}

// itinakda ang buong board sa 0 at i-reset ang mga variable sa pagkabinata

void clearBoard () {// reset tick at antala ang mga halaga intTick = 0; intDelay = 1000; // dumaan sa board at itakda ang lahat sa 0 para (int i = 0; i <= 15; i ++) {para (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

// ipinapakita ang Pangunahing Menu sa LCD's

walang bisa na pamagat () {// sumulat ng pamagat sa LCD at puwang para sa iskor lcdRight.setCursor (0, 0); lcdRight.write ("Piano Tiles"); lcdRight.setCursor (0, 1); lcdRight.write ("Iskor:"); // convert the score into a string char strScore [3]; sprintf (strScore, "% d", intScore); // display score papunta sa LCD lcdRight.write (strScore); // idagdag ang diffictuly lcdRight.setCursor (10, 1); kung (intDiff == 0) {lcdRight.write ("Madali"); } kung (intDiff == 1) {lcdRight.write ("Medium"); } kung (intDiff == 2) {lcdRight.write ("Hard"); } // Pindutin ang kaunting tagubilin lcdLeft.setCursor (0, 0); lcdLeft.write ("Pindutin ang Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write ("upang magsimula!"); }

// sinusuri ang mga pindutan at kung ano ang gagawin para sa kanila habang wala sa laro

void pindutanMenu () {// kapag ipinasok ay pinindot simulan ang laro at i-reset ang halaga ng puntos kung (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // kapag pinindot ang pindutan 3 buksan ang pagpipiliang pag-debug ng pag-print ng board sa serial kung (intInput == 3) {kung (bolSerialBoard == false) {Serial.println ("Aktibo ng Serial Board"); bolSerialBoard = totoo; } iba pa {Serial.println ("Hindi pinagana ang Serial Board"); bolSerialBoard = false; }} // itakda ang bilis ng laro sa madaling kahirapan kung (intInput == 0) {Serial.print ("Game set to easy ("); Serial.print (intGameSpeedEasy); Serial.println ("ms acceleration)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // itakda ang bilis ng laro sa katamtamang kahirapan kung (intInput == 1) {Serial.print ("Game set to medium ("); Serial.print (intGameSpeedMedium); Serial.println ("ms acceleration)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // itakda ang bilis ng laro sa mahirap na kahirapan kung (intInput == 2) {Serial.print ("Game set to hard ("); Serial.print (intGameSpeedHard); Serial.println ("ms acceleration)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

// sinusuri ang mga pindutan at kung ano ang gagawin para sa kanila habang nasa laro

void pindutanGame () {kung (intInput! = 4) {// kung ang isang pindutan ay pinindot kung (bolTilePressed == maling) {// kung ang bolTilePressed ay maling pagkilos na pag-trigger para sa pag-check sa isang pindutan pindutin ang bolTilePressed = totoo; // pagkatapos ay itakda ang bolTilePressed to true upang matiyak na hindi ito aksidentilly na nai-trigger muli int intLowestTile = 0; // upang maitakda sa tile na may pinakamababang tile int intCheckedTile = 15; // upang subaybayan kung aling mga tile ang nasuri habang (intLowestTile == 0) {// hangga't hindi ito nakatakda sa anumang suriin ang mga tile para sa (int i = 0; i 100) {// basta int ang pagkaantala ay hindi mas mababa sa 100 intDelay = intDelay - 20; // kumuha ng halaga mula rito}} iba pa {Serial.println ("Maling pindutan na pinindot"); tapos na ang laro(); // otherwise game over}}}}}

void gameOver () {

Serial.println ("Game Over!"); Serial.print ("Ang iyong iskor ay:"); Serial.println (intScore); Serial.print ("Ang bilis mo ay:"); Serial.println (intDelay); bolPlay = false; }

// check for input player

void input () {intEnter = digitalRead (btnEnter); // read enter // read which of the other inputs, or if none set to 4 if (digitalRead (btn1) == HIGH) {intInput = 0;} else {if (digitalRead (btn2) == MATAAS) {intInput = 1;} iba pa {kung (digitalRead (btn3) == TAAS) {intInput = 2;} iba pa {kung (digitalRead (btn4) == TAAS) {intInput = 3;} iba pa {intInput = 4; }}}} // serial print the inputs if (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } iba pa {// kung walang pindutan na pinindot i-reset ang bolTilePressed bolTilePressed = false; }}

// sinusuri ang ilalim ng board para sa pagkabigo

void bottomCheck () {para sa (int i = 0; i <= 3; i ++) {// para sa 4 na mga kolum kung (arrGame [15] == 1) {// kung ang isang tile ay nasa ilalim ng Serial.println ("Tile sa ilalim"); arrGame [15] = 2; drawBoard (); pagkaantala (400); arrGame [15] = 1; drawBoard (); pagkaantala (400); arrGame [15] = 2; drawBoard (); pagkaantala (400); arrGame [15] = 1; drawBoard (); pagkaantala (400); tapos na ang laro(); }}}

// print ang board sa serial monitor kung totoo ang bolSerialBoard

void writeSerial () {if (bolSerialBoard == true) {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {Serial.print (arrGame [ii]); Serial.print (","); } Serial.println (""); }}}

Kapag naipasok na ang lahat ng code, mag-upload sa iyong arduino at mag-enjoy!