Neapgalvotas lenktynininkas Arduino OLED žaidimas, „AdafruitGFX“ir „Bitmaps“pagrindai: 6 žingsniai

2025 Autorius: John Day | [email protected]. Paskutinį kartą keistas: 2025-01-23 14:58

Šioje pamokoje apžvelgsime, kaip naudoti bitų žemėlapius naudojant „Adafruit_GFX.c“biblioteką kaip žaidimo spritą. Paprasčiausias žaidimas, kurį galėtume sugalvoti, yra šoninės slinkties juostos keitimo žaidimas, galų gale mūsų beta testeris ir kodavimo pagalbininkas nusprendė pavadinti „Neapgalvotas lenktynininkas“, nes gana neatsargu važiuoti greitkeliu žemyn !!.

Mūsų grandinės dizainas yra aukščiau pateiktose nuotraukose ir yra išsamiai aprašytas mūsų paskutiniame projekte/pamokoje „Snake Instructables“, kurioje aprašoma, kaip veikia grandinė.

mes pareikalausime

Adafruit_GFX

Paint.net

„Arduino IDE windowslinux“

ir prašome pažvelgti į gyvatės pamoką, skirtą likusiai įrangai.

Prekės

Gyvatės žaidimas

1 veiksmas: „Paint.net“diegimas

Mes naudojame paint.net, nes programinė įranga yra nemokama, todėl visiškai nemokama ja naudotis, galite atsisiųsti „Paint. Net“čia.

Norėdami įdiegti paint.net, dukart spustelėkite atsisiųstą programą ir toliau teigiamai atsakykite, taip, gerai, sutinku ir aukščiau pateiktos nuotraukos duos nurodymus.

2 žingsnis: pieškite paprastą ekrano vaizdą

Kai esate „paint.net“, sukurkite naują vaizdą spustelėdami Failas, tada naujas, nustatykite vaizdo dydį į 1260x620 (žr. Pirmąją nuotrauką) spustelėkite Gerai, kai turite naują puslapį, pieštuku pieškite ekrano užsklandą, naudodami tik dvi spalvas: juodą ir baltą įrankis (2 pav.), kai nupiešiate (arba įklijuojate) pradinio ekrano vaizdą, spustelėkite paveikslėlį, tada pakeiskite jo dydį (image4), iššokančiajame lange pakeiskite dydį nuo 1260x620 iki 126x62 (2 pikseliais mažesnis nei jūsų ekranas) (5 pav.) Spustelėkite Gerai.

Tada spustelėkite meniu Failas, tada išsaugokite kaip (6 pav.).

kai pasirodys iššokantis langas failo tipo išskleidžiamajame meniu, pasirinkite BMP (bitmap). (7 pav.), įveskite failo pavadinimą ir spustelėkite „Išsaugoti“. Kai pasirodys iššokantis langas, nustatykite dittering į 0 ir 8 bitų, spustelėkite gerai (8 pav.)).

3 žingsnis: BMP konvertavimas į C bitmap failą

Dabar turime konvertuoti savo atvaizdą į formatą, kurį arduino gali suprasti, kad yra daug įrankių, kaip tai padaryti, bet mano „eiti“vieta yra „marlin“tinklalapio bitmap konvertavimo įrankis …

marlinfw.org/tools/u8glib/converter.html

Taigi mes pradedame šį skyrių naudodami aukščiau pateiktą nuorodą, kad atidarytumėte svetainę, kuri parodyta 1 pav

spustelėkite pasirinkti failą ir pasirinkite bitų žemėlapį, kurį sukūrėte anksčiau (2 pav.)

„marlin bitmap converter“automatiškai pavers jūsų vaizdą į c kodą, dukart spustelėkite kodą, kuris turėtų paryškinti kodą, tada dešiniuoju pelės mygtuku spustelėkite ir nukopijuokite (pic3)

Kitas Sukuriame dešinįjį pelės klavišą ir sukuriame naują tekstinį dokumentą (4 pav.)

dukart spustelėkite naują dokumentą, atidarius dešinįjį pelės klavišą ir įklijuokite kodą (5 pav.)

toliau turime pridėti eilutę prie kodo viršaus #include tai leidžia mums išsaugoti bitų žemėlapio duomenis į „arduino“„flash“atmintį, tada pervadiname #define plotį, aukštį ir pavadinimą į ką nors lengviau naudoti, jie paryškinti 6 paveiksle, pervadiname juos iš atsitiktinai sugeneruotų simbolių, kuriuos pervadiname į žemiau paryškintą pavyzdį

#define LOGOWIDTH

#define LOGOHEIGHT

const unsigned char LOGOPINĖ PROGREMA

Kitas spustelėkite failą, tada išsaugokite kaip, išsaugokite failą kaip logo.c uždarykite užrašų knygelę, dešiniuoju pelės mygtuku spustelėkite logo.c ir spustelėkite kopijuoti.

4 veiksmas: LOGO rodymas naudojant „DrawBitmap“

Dabar mes įkeliame „arduino IDE“ir sukuriame naują eskizą ir išsaugome jį pavadinimu „logoexample.ino“, toliau kaip apgaulingas „arduino ide“spustelėkite failo meniu, tada išsaugokite kaip, grįžkite į projekto aplanką dešiniuoju pelės klavišu ir įklijuokite į.c failą (pic2), tada spustelėkite Atšaukti. Taip išvengsite naršymo aplanke, kurį norite įklijuoti į failą.

įveskite šį kodą į arduino IDE arba atsisiųskite ino.

(rekomenduojame rašyti, o ne kopijuoti ir įklijuoti arba naudoti žemiau esančius failus - tai geriausias būdas mokytis)

#include /* tai skirsis priklausomai nuo to, kur saugote

ino paprastai yra aplanke C: / Users / ~ username / Documents / Arduino / project ~ name

ir taip mes susiejame savo bitų žemėlapį */

#įtraukti

#įtraukti

uint8_t bmpX, bmpY = 0; /* rezervuokite 2 x 8 bitų sveikųjų skaičių atmintį, mums reikia tik 8 bitų colių

kadangi vertė niekada neviršija 128 (pikselių), todėl galime sutaupyti vietos naudodami 8 bitų colius (kurių didžiausia vertė yra 255) */

negaliojanti sąranka ()

{uždelsimas (100); // suteikti ekranui ir pan. laiko įjungti ekraną.begin (SSD1306_SWITCHCAPVCC, 0x3C); // tai inicijuoti ekrano rodymą.clearDisplay (); // pradėk nuo tuščio ekrano}

/* atkreipkite dėmesį, kad jums nereikia įvesti šių komentarų, nes jie yra nuoroda …………..

komanda, į kurią ketiname sutelkti dėmesį, yra „display.drawBitmap“, tai atkreipia mūsų ekrano vaizdą. (bmpX, yra X ašies vertė ekrane, kurioje bus bitų žemėlapio X inkaro taškas, o bmpX ir bmpY - tai vertės, kuriomis norime sukurti judesį (bmpY, yra Y ašies vertė ekrane, kuriame yra Y inkaras) bitų žemėlapio taškas bus tas, kad mes gausime nuorodų pavadinimus, kaip mes juos apibrėžėme logotipe. c (LOGOPIC, yra bitų žemėlapio pavadinimas #included failo logotipe. c (LOGOWIDTH, kiek pikselių yra (X) bitų žemėlapis iš tvirtinimo taško (LOGOHEIGHT, kiek pikselių žemyn (Y), kad būtų galima nubrėžti bitų žemėlapį iš tvirtinimo taško, kuriame X ir Y pikseliai gali būti įvesti rankiniu būdu, tačiau paprasčiau naudoti iš anksto nustatytus, nei prisiminti juos visus (1, paskutinė vertė yra spalva, nes ekranas yra nespalvotas 0 juoda 1 balta. gerai, pradėkite rašyti iš kitos eilutės: ¬D lol*/ void loop () {display.clearDisplay (); // tuščias ekranas // bitkartė, paimta iš viršuje kairėje, x, y, bitmap pavadinimas, plotis X, aukštis Y, spalvotas ekranas.drawBitmap (bmpX, bmpY, LOGOPIC, LOGOWIDTH, LOGOHEIGHT, 1); display.display (); // tai iš tikrųjų pritraukia buferį į ekraną}

įkelkite kodą arduino ir patvirtinkite, kad jis veikia (3 pav.).

5 žingsnis: „Bitmap Sprite“perkėlimas

naudodamiesi ankstesnėmis instrukcijomis, naudokite paint.net ir sukurkite naują failą, kad jis taptų 30x15 pikselių (1 pav.) ir nupieškite šiurkštų automobilį, kurį mūsų jaunasis dizaineris pirmiausia pradeda nuo priekinio stiklo (2 ir 3 nuotraukos).

dar kartą išsaugokite jį kaip „Windows bmp“failą (kaip 2 veiksme), konvertuokite į C bitų žemėlapį (3 veiksmas) ir įdėkite failą „car.c“(arba ką tik nuspręsite) į tą patį aplanką kaip ir naujai sukurtas „arduino ino“(eskizas) failą.

(p.s. nepamirškite automobilyje pridėti eilutės #include.c tai dažnai mus pastebėjo)

Pirmiausia susiekite savo automobilio ekvivalentą.c

#įtraukti

#include #include Adafruit_GFX.h> // https://github.com/adafruit/Adafruit-GFX-Library #include Adafruit_SSD1306 //

„Adafruit_SSD1306“ekranas (128, 64); // nustatyti ekrano skiriamąją gebą

/* bmpX/bmpY mums reikia, kad jie būtų kintamieji, keičiant šias vertes ir perbraižant

ekranas yra tai, kaip mes sukuriame judesio animacijos efektą. hitSide ir hitTop yra tai, kaip mes palaikome sprite ekrane */ uint8_t bmpX, bmpY = 0; // rezervuokite atmintį 2 8 bitų coliams (0–255) mums nereikia didesnės 128 bus didžiausias panaudotas bool hitSide = 0; bool hitTop = 0;

negaliojanti sąranka ()

{uždelsimas (100); // suteikti ekranui ir pan. laiko įjungti ekraną.begin (SSD1306_SWITCHCAPVCC, 0x3C); // tai inicijuoti ekrano rodymą.clearDisplay (); // pradėk nuo tuščio ekrano

}

tuštumos kilpa ()

{display.clearDisplay (); // tuščias ekranas // bitkartė, nubrėžta iš viršaus kairėje, x, y, bitmap pavadinimas, plotis X, aukštis Y, spalvotas ekranas.drawBitmap (bmpX, bmpY, CARSPRITE, CARWIDTH, CARHEIGHT, 1); // display.display (); // tai iš tikrųjų visada pritraukia buferį į ekraną/ * taip mes stebime ekrano kraštą ir nusprendžiame, ar pridėti pikselį, perkelti iš viršaus į apačią), ar pašalinti pikselį (perkelti iš apačios į viršų) */ jungiklis (hitSide) // tai pasirenka automobilio kryptį pagal boole {case 0: bmpX ++; pertrauka;

1 atvejis:

bmpX--; pertrauka; } // šie 2 if teiginiai nustato, kad bool yra teisinga arba klaidinga, jei (bmpX == 0) {hitSide = 0; } if (bmpX == 96) // ekrano plotis atėmus automobilį {hitSide = 1; } // tas pats kaip ir Y ašyje, jei (bmpY == 0) {hitTop = 0; } if (bmpY == 49) // ekrano aukštis atėmus automobilio aukštį {hitTop = 1; } switch (hitTop) {atvejis 0: bmpY ++; pertrauka; 1 atvejis: bmpY--; pertrauka; }

}

veikiančią programą galite pamatyti pridėtame vaizdo įraše

6 žingsnis: sukurkite vairavimo žaidimą

Pirmiausia pradedame nupiešdami kelis skirtingus automobilius ar kliūtis, kaip ankstesnėse mokymo pamokose, kad jie taptų 30x15 pikselių. Tada mes juos konvertuojame į c bitų žemėlapius ir susiejame kodą.

#include // šie keliai turės keistis priklausomai

// kur saugote failus // redaguoti: ką tik sužinojau, jei pakeisite // "", jums nereikia viso kelio // savo bibliotekomis #include

#įtraukti

#įtraukti #įtraukti

#įtraukti

#įtraukimas // https://github.com/adafruit/Adafruit-GFX-Library #include <Adafruit_SSD1306 //

„Adafruit_SSD1306“ekranas (128, 64); // apibrėžti rodymo parametrus

apibrėžti kintamuosius ir fiksuotas vertes

// apibrėžti įvesties kaiščius tai yra arduino kaiščiai, kurių jie niekada nesikeičia, taigi #define #define INTPIN 3 // tik 2 ir 3 kaiščiai gali būti pertraukiami kaiščiai UNO #define UPPIN 4 // tai yra kaiščiai, prijungti prie atitinkamo jungiklio #define DWNPIN 5 #define LFTPIN 6 #define RHTPIN 7 #define SND 9 // apibrėžti kryptis

#define DIRUP 1 // į šias vertybes žiūri „gyvatė“, #define DIRDOWN 2 // gyvatės kelionės kryptis #define DIRLEFT 3 #define DIRRIGHT 4

uint8_t dirPressed = 0; // reikšmė užregistruoti kryptį judėti, kuris kaištis pakilo aukštai

// booleans parduotuvė, kurios smeigtukas pakilo aukštai

bool BUTUP = 0; bool BUTDWN = 0; bool BUTLFT = 0; bool BUTRHT = 0; // vars automobilio vietai uint8_t carPosX = 1; uint8_t carPosY = {0, 16, 32, 48}; // reikia masyvo vertės

uint8_t lanePosArr = {0, 16, 32, 48}; // masyvas saugoti, kur yra kiekviena juosta

uint8_t carPosYCnt = 0; uint8_t carYTmp = 0; // kintamieji eilučių kelyje uint8_t roadLineX1 = 51; // jie yra iš anksto apibrėžti pradžioje, tada linijos atrodo vientisos uint8_t roadLineX2 = 102; uint8_t roadLineX3 = 153; uint8_t roadLineX4 = 254; uint8_t roadLineX5 = 200;

// tai kiek pikselių vienu metu juda žaidimo zona

uint8_t drawSpeed = 4;

// vars priešui0

uint8_t priešininkas0PosX = 255; uint8_t priešininkas0PosY = 0; uint8_t priešininkas1PosX = 255; uint8_t priešininkas1PosY = 0; uint8_t priešininkas2PosX = 255; uint8_t priešininkas2PosY = 0;

// kintamasis atsitiktinai priskirkite kliūčių juostos numerį

uint8_t laneGen = 0;

uint8_t laneGen0 = 0; uint8_t laneGen1 = 0; uint8_t laneGen2 = 0;

// balų skaitiklis

ilgas rezultatas = 0; // tai yra rezultatas:/ lol long palyginti = 0; // tai išsaugo rezultatą paskutiniame lygyje, kad būtų galima palyginti su ilgu aukštu rezultatu = 25; uint8_t metreCnt = 0;

čia mes pradedame funkcijas

// tai komandų rinkinys, jei pertraukimas įjungtas void interruptressed () {delay (150); updateDirection (); } // atnaujinkite, kuri reikšmė yra var kryptimi, patikrindami DIR bools // -------------------------- UPDATE DIRECTION (player)- ------------------------- void updateDirection () {//Serial.println("updateDirection Called "); BUTUP = digitalRead (UPPIN); BUTDWN = digitalRead (DWNPIN); BUTLFT = digitalRead (LFTPIN); BUTRHT = digitalRead (RHTPIN); if (BUTUP == true) {dirPressed = DIRUP; } if (BUTDWN == true) {dirPressed = DIRDOWN; } if (BUTLFT == true) {dirPressed = DIRLEFT; } if (BUTRHT == true) {dirPressed = DIRRIGHT; }

}

// ------------------------------- MOVE CAR --------------- -------------------------

// tai atnaujins automobilio judėjimo ekraną

void moveCar ()

{switch (dirPressed) {case DIRUP: carPosYCnt--; carPosY [carPosYCnt]; tonas (SND, 100, 100); if (carPosYCnt == 255) {carPosYCnt = 0; } carYTmp = carPosY [carPosYCnt]; dirPressed = 0; // Serial.println ("carPosY up"); // Serial.println (carPosYCnt); pertrauka; DIRDOWN dėklas: carPosYCnt ++; tonas (SND, 100, 100); jei (carPosYCnt == 4) {carPosYCnt = 3; } // Serial.println ("carPosY"); // Serial.println (carPosYCnt); carYTmp = carPosY [carPosYCnt]; dirPressed = 0; pertrauka; // pakomentavo automobilį, galintį judėti į kairę ir į dešinę, susidūrimo aptikimas dar nėra toks geras /* atvejis DIRLEFT: carPosX--; if (carPosX == 0) {carPosX = 1; } // Serial.println ("carPosX"); // Serial.println (carPosX); dirPressed = 0; pertrauka; */ atvejis DIRRIGHT: // tik linksmybėms, jei paspausite dešinį žaidimą, jis skleis triukšmą (SND, 100, 50); // carPosX ++; // if (carPosX == 128) // {// carPosX = 127; //} // Serial.println ("carPosX"); // Serial.println (carPosX); // dirPressed = 0; pertrauka; } updateDisplay (); }

// -------------------------- RANDOM POS X ------------------- -----------

uint8_t randomPosX () // šios 2 rutinos tiesiog sukuria atsitiktinę kliūčių padėtį

{uint8_t posValTmp = 0; posValTmp = atsitiktinis (129, 230); //Serial.println("random x "); //Serial.println(posValTmp); return (posValTmp); }

// --------------------------- RANDOM POS Y ------------------ ------------------

uint8_t randomPosY ()

{uint8_t laneVal = 0; laneVal = atsitiktinis (0, 4); // pridėkite papildomą eismo juostą atsitiktinumui, ty nėra jokio objekto ekrane, o toje juostoje //Serial.println("RandomY "); //Serial.println(lanePosArr[laneVal]); return (lanePosArr [laneVal]); }// ------------------------------- ŽAIDIMO GREITIS -------------- -------------- void setGameSpeed () // tai sustabdo aukštesnį nei 20 lygį, todėl žaidimo negalima žaisti {if (drawSpeed <21) {drawSpeed = drawSpeed+2; }}// ------------------------------------ DETECT CRASH ---------- ----------------------- void detectCrash () {

jei (priešas0PosX = 0 ir priešas0PosY == automobilisTmp)

{// Serial.println ("Žaidimas per CRAASSSSHHHHHHEEEEDDD į srautą 0"); žaidimas baigtas(); } if (priešas1PosX = 0 ir & priešas1PosY == automobilisTmp) {//Serial.println("Game Over CRAASSSSHHHHHHEEEEDDD į srautą 1 "); žaidimas baigtas(); } jei (priešas2PosX = 0 ir & priešas2PosY == automobilisTmp) {//Serial.println("Game Over CRAASSSSHHHHHHEEEEDDD į srautą 2 "); žaidimas baigtas(); }}

tai yra rutina, kuria piešiamas ekranas.

// ------------------------------- TRAŠYMO KELIAS --------------- --------------------- void drawRoad () // X, Y, ilgis, plotis {display.fillRect (roadLineX1, 15, 30, 4, WHITE); display.fillRect (roadLineX1, 30, 30, 4, WHITE); display.fillRect (roadLineX1, 45, 30, 4, WHITE); display.fillRect (roadLineX2, 15, 30, 4, WHITE); display.fillRect (roadLineX2, 30, 30, 4, WHITE); display.fillRect (roadLineX2, 45, 30, 4, WHITE); display.fillRect (roadLineX3, 15, 30, 4, WHITE); display.fillRect (roadLineX3, 30, 30, 4, WHITE); display.fillRect (roadLineX3, 45, 30, 4, WHITE); display.fillRect (roadLineX4, 15, 30, 4, WHITE); display.fillRect (roadLineX4, 30, 30, 4, WHITE); display.fillRect (roadLineX4, 45, 30, 4, WHITE); display.fillRect (roadLineX5, 15, 30, 4, WHITE); display.fillRect (roadLineX5, 30, 30, 4, WHITE); display.fillRect (roadLineX5, 45, 30, 4, WHITE);

roadLineX1 = roadLineX1-drawSpeed;

roadLineX2 = roadLineX2-drawSpeed; roadLineX3 = roadLineX3-drawSpeed; roadLineX4 = roadLineX4-drawSpeed; roadLineX5 = roadLineX5-drawSpeed; display.display (); } // ---------------------------------------- TRAŠYTI priešus ---- --------------------------------------- tušti priešaiDraw () {// X, Y, bmp pavadinimas, plotis, aukštis, spalvotas ekranas.drawBitmap (ellenis0PosX, priešas0PosY, ENEMY0, ENEMY0_WIDTH, ENEMY0_HEIGHT, 1); priešas0PosX = priešas0PosX-drawSpeed; display.drawBitmap (priešas1PosX, priešas1PosY, ENEMY1, ENEMY1_WIDTH, ENEMY1_HEIGHT, 1); priešas1PosX = priešas1PosX-drawSpeed; display.drawBitmap (priešas2PosX, priešas2PosY, ENEMY2, ENEMY2_WIDTH, ENEMY2_HEIGHT, 1); priešas2PosX = priešas2PosX-drawSpeed; display.display (); if (priešas0PosX> 231 && priešininkas0PosX231 && priešininkas1PosX <255) {priešininkas1PosX = atsitiktinisPosX (); priešas1PosY = atsitiktinisPosY (); checkDuplicate (); }

if (priešas2PosX> 231 && priešininkas2PosX <255) {priešininkas2PosX = atsitiktinisPosX (); priešas2PosY = atsitiktinisPosY (); }} // ------------------------------------ ATNAUJINIMO EKRANAS -------- ---------------------------------------- void updateDisplay () {display.clearDisplay (); display.drawBitmap (carPosX, carPosY [carPosYCnt], CARSPRITE, 30, 15, 1); display.fillRect (100, 0, 28, 10, BLACK); display.setCursor (100, 0); display.setTextColor (BALTA, JUODA); display.println (rezultatas); display.display ();

}

// ------------------------- laukti spaudos ciklo ------------------- ------

// tai yra pagrindinio ekrano kodas void waitForPress () {splashScreen (); bool laukimas = 0; // kilpa baigiasi, kai tai yra tikrasis ekranas.clearDisplay (); kol (laukiu == 0) {

display.fillRect (19, 20, 90, 32, BLACK); // tuščias teksto fonas

display.setTextColor (BALTA); display.setCursor (23, 24); display.setTextSize (0); display.println („Apgalvotas“); display.setCursor (36, 34); display.println („Lenktynininkas“); display.drawBitmap (74, 24, CARSPRITE, CARWIDTH, CARHEIGHT, 1); // x y w h r col display.drawRoundRect (21, 21, 86, 23, 4, WHITE); // pasienio gyvatės ekranas.drawRect (19, 20, 90, 33, BALTA); // ribos langelis - 3 ekranas.setCursor (25, 43); display.setTextSize (0); // šriftas atgal į įprastą ekraną.println ("paspauskite bet kurį klavišą"); display.fillRect (0, 0, 127, 8, BLACK); display.setCursor (10, 0); display.print („Aukščiausias balas:“); // rodyti aukštų rezultatų ekraną.print (highScore); display.display (); laukia = digitalRead (INTPIN); // patikrinkite, ar paspaudus laukimo klavišą pasikeis į 1 pabaigą, kol dirPressed = 0; // atstatymo mygtukas paspauskite be krypties}} // -------------------------------------- ----- UPDATE GAME ----------------------------------------- void updateGame () {moveCar (); drawRoad (); enemysDraw (); // priešas1Piešimas (); // priešas2Draw (); metreCnt ++; detectCrash (); if (metreCnt == 5) // prideda tašką už kiekvieną 10 ciklų, kad pasiektų rezultatą {metreCnt = 0; rezultatas ++; } if (rezultatas == palyginti+5) // pagreitina žaidimą kas 5 taškus iki maksimaliai 20 greičių {palyginti = rezultatas; setGameSpeed (); } noTone (SND); updateDisplay ();

}

// ------------------------------ ŽAIDIMAS BAIGTAS---------------- ------------------------------

// ši rutina nubrėžia linijas aplink mirusį herojaus automobilį, tada ekrane rodomas žaidimas

void gameOver ()

{tonas (SND, 200, 200); // leisti garsą uint8_t linePosX, linePosY, pixwidth, pixheight = 0; // nustatyti vars piešti langelius aplink automobilio linijąPosX = carPosY; linePosY = carYTmp; pikselių plotis = 30; pikselių aukštis = 15; display.drawRect (linePosX, linePosY, pixwidth, pixheight, WHITE); display.display (); for (int i = 0; i <= 26; i ++) // tai supa automobilį stačiakampiais, imituojančiais sprogimą {linePosX = linePosX-2; linePosY = linePosY-2; pikselių plotis = pikselių plotis+4; pikselių aukštis = pikselių aukštis+4; display.drawRect (linePosX, linePosY, pixwidth, pixheight, BLACK); display.drawRect (linePosX, linePosY, pixwidth, pixheight, WHITE); display.display (); tonas (SND, i*20, 50); vėlavimas (10); } display.setTextSize (2); display.setTextColor (BALTA, JUODA); display.setCursor (10, 23); tonas (SND, 50, 500); display.print („ŽAIDIMAS“); display.display (); vėlavimas (500); tonas (SND, 40, 500); display.print („PABAIGA“); display.setTextSize (0); display.display (); vėlavimas (3000); restartGame (); waitForPress (); }

// ----------------------------------------- RESTART GAME ----- -------------------------------------------------- -----

void restartGame () // tai nukopijuoja aukštą rezultatą ir iš naujo nustato visą statistiką bei sugeneruoja atsitiktines pozicijas

{if (score> = highScore) // patikrinkite, ar balas didesnis už aukštą balą {highScore = score; // vienas, jei teiginys atnaujins aukštą rezultatą}

balas = 0;

drawSpeed = 4; metreCnt = 0; carPosYCnt = 0; priešas0PosX = atsitiktinisPosX (); priešas0PosY = atsitiktinisPosY (); priešas1PosX = atsitiktinisPosX (); priešas1PosY = atsitiktinisPosY (); priešas2PosX = atsitiktinisPosX (); priešas2PosY = atsitiktinisPosY (); noTone (SND);

checkDuplicate ();

}

// ------------------------------------------------ -PATIKRINKITE DUPLIKATĄ ----------------------------------------------- ------ void checkDuplicate () // šie patikrina, ar kliūtys neužima tos pačios žaidimo vietos {// Serial.println ("patikrinta dublikatas"); if (priešas2PosX> 230 && priešininkas2PosX <255) {tuo tarpu (priešas2PosY == priešas1PosY || priešas2PosY == priešas0PosY) {priešas2PosY = atsitiktinisPozY (); }}

if (ellenis0PosX> 230 && priešas0PosX230 && priešininkas2PosXenemy1PosX && priešininkas2PosX230 && priešas0PosXenemy1PosX && priešininkas0PosX

//------------------------------------------- EKRANO UŽSKLANDA --- --------------------------------

void splashScreen ()

{display.clearDisplay (); display.drawBitmap (0, 0, CRASH, CRASHWIDTH, CRASHHEIGHT, 1); display.display (); vėlavimas (2000 m.); } // ----------------------------------------------- NUSTATYMAS ------------------------------------------------- ----------- void setup () {delay (100); // tegul viskas prasideda // Serial.begin (9600); // nekomentuokite šio ir viso serijos. gedimų diag. display.begin komandos (SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay (); display.setTextColor (BALTA, JUODA); display.setTextWrap (klaidinga); display.dim (0); pinMode (INTPIN, INPUT); pinMode (UPPIN, INPUT); pinMode (DWNPIN, INPUT); pinMode (LFTPIN, INPUT); pinMode (RHTPIN, INPUT);

attachInterrupt (digitalPinToInterrupt (INTPIN), pertrauktas, RISING);

// atsitiktinai uždėti kliūtis priešas0PosX = randomPosX (); priešas0PosY = atsitiktinisPosY (); priešas1PosX = atsitiktinisPosX (); priešas1PosY = atsitiktinisPosY (); priešas2PosX = atsitiktinisPosX (); priešas2PosY = atsitiktinisPosY (); checkDuplicate (); // patikrinti pasikartojančias vietas // Serial.println ("sąranka baigta"); ekrano užsklanda(); waitForPress (); } // ----------------------------------------------- ----- LOOP -------------------------------------------- ----------

tuštumos kilpa ()

{updateGame (); }

ir viskas, visi pakeitimai ir atsiliepimai bus laukiami. Problemos, kurias turime išspręsti ekrano mirgėjimo metu, turime išsiaiškinti, kaip jį sumažinti, o priešo automobiliai vis dar gali užimti tą pačią erdvę.