Neapdomīga sacīkšu braucēja Arduino OLED spēle, AdafruitGFX un Bitmaps pamati: 6 soļi

2025 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2025-01-23 14:59

Šajā apmācībā mēs apskatīsim, kā izmantot bitkartes, izmantojot Adafruit_GFX.c bibliotēku kā sava veida sprites spēlē. Vienkāršākā spēle, ko mēs varētu iedomāties, ir sānu ritināšanas joslas maiņas mašīnu spēle, galu galā mūsu beta testētājs un kodētāja palīgs nolēma nosaukumu “Reckless Racer” kā nosaukumu, jo ir diezgan neapdomīgi braukt nepareizu ceļu pa automaģistrāli !!.

Mūsu ķēdes dizains ir attēlos, kas iekļauti iepriekš, un ir sīki aprakstīts mūsu pēdējā projektā/apmācībā šeit Snake Instructables, kas apraksta ķēdes darbību.

mēs prasīsim

Adafruit_GFX

Paint.net

Arduino IDE windowslinux

un, lūdzu, apskatiet čūskas apmācību par pārējo aprīkojumu.

Piegādes

Čūsku spēle

1. darbība. Paint.net instalēšana

Mēs izmantojam paint.net, jo programmatūra ir bezmaksas, tāpēc to var brīvi izmantot, lai lejupielādētu Paint. Net šeit.

Lai instalētu paint.net, veiciet dubultklikšķi uz lejupielādētās programmas un nākamreiz atbildiet pozitīvi, jā, labi, es piekrītu, un iepriekš redzamie attēli sniegs norādījumus.

2. darbība: vienkārša ekrāna uzzīmēšana

Kad atrodaties vietnē paint.net, izveidojiet jaunu attēlu, noklikšķinot uz Fails un pēc tam uz jaunu, iestatiet attēla izmēru uz 1260x620 (skatiet pirmo attēlu) noklikšķiniet uz Labi, kad esat izveidojis jaunu lapu, uzzīmējiet ekrānu, izmantojot tikai 2 melnbaltās krāsas, izmantojot zīmuli rīks (2. attēls), kad esat uzzīmējis (vai ielīmējis) savu ekrāna attēlu, noklikšķiniet uz attēla un pēc tam mainiet tā izmēru (attēls4); uznirstošajā logā mainiet izmēru no 1260x620 līdz 126x62 (par 2 pikseļiem mazāks nekā displejs) (5. attēls) Noklikšķiniet uz Labi.

Pēc tam noklikšķiniet uz izvēlnes Fails un pēc tam saglabājiet kā (6. attēls).

kad uznirstošais logs parādās faila tipa nolaižamajā izvēlnē, izvēlieties BMP (bitkarte). (7. attēls), ierakstiet faila nosaukumu un noklikšķiniet uz saglabāt, kad parādās uznirstošais logs, iestatiet dithering uz 0 un iestatiet uz 8 bitiem, noklikšķiniet uz OK (8. attēls)).

3. darbība: BMP konvertēšana uz C Bitmap failu

Tagad mums ir jāpārvērš mūsu attēls formātā, ko arduino var saprast, ka ir daudz rīku, lai to izdarītu, bet mans “iet uz” vietu ir marlin tīmekļa vietnes bitkartes pārveidotāja rīks…

marlinfw.org/tools/u8glib/converter.html

Tāpēc mēs sākam šo sadaļu, izmantojot iepriekš minēto saiti, lai atvērtu vietni, kas parādīta 1. attēlā

noklikšķiniet uz Izvēlēties failu un izvēlieties iepriekš izveidoto bitkarti (2. attēls)

marlin bitmap converter automātiski pārveidos jūsu attēlu par c kodu, veiciet dubultklikšķi uz koda, kuram vajadzētu izcelt kodu, pēc tam ar peles labo pogu noklikšķiniet un noklikšķiniet uz kopēt (pic3)

nākamais Mēs izveidojam labo klikšķi un izveidojam jaunu teksta dokumentu (4. attēls)

veiciet dubultklikšķi uz jaunā dokumenta, atverot to ar peles labo pogu un ielīmējiet kodu (5. attēls)

Tālāk mums jāpievieno rinda koda augšdaļas tuvumā #iekļaujiet, tas ļauj mums saglabāt bitkartes datus arduino zibatmiņā, pēc tam mēs pārdēvējam #define platumu, augstumu un nosaukumu uz kaut ko vieglāk lietojamu, tie ir iezīmēti 6. attēlā, mēs tos pārdēvējam no nejauši ģenerētām rakstzīmēm, kuras pārdēvējam par zemāk pasvītroto piemēru

#definējiet LOGOWIDTH

#define LOGOHEIGHT

const unsigned char LOGOPIC PROGMĒMA

noklikšķiniet uz faila, pēc tam saglabājiet kā, saglabājiet failu kā logo.c aizveriet piezīmju grāmatiņu, ar peles labo pogu noklikšķiniet uz logo.c un noklikšķiniet uz kopēt.

4. solis: LOGO parādīšana, izmantojot DrawBitmap

Tagad mēs ielādējam arduino IDE un izveidojam jaunu skici un saglabājam to ar nosaukumu logoexample.ino, pēc tam kā krāpnieks arduino ide noklikšķiniet uz faila izvēlnes, pēc tam saglabājiet kā, atgriezieties projekta mapē ar peles labo pogu noklikšķiniet un ielīmējiet.c failā (pic2), pēc tam noklikšķiniet uz Atcelt, tādējādi jums nav nepieciešams pārlūkot mapi, lai to ielīmētu failā.

ierakstiet šādu kodu arduino IDE vai lejupielādējiet ino.

(labākais veids, kā mācīties, ir rakstīt, nevis kopēt un ielīmēt vai izmantot zemāk esošos failus)

#include /* tas var atšķirties atkarībā no uzglabāšanas vietas

ino parasti atrodas mapē C: / Users / ~ lietotājvārds / Documents / Arduino / project ~ name

un tā mēs izveidojam saiti uz savu bitkarti */

#iekļaut

#iekļaut

uint8_t bmpX, bmpY = 0; /* rezervējiet atmiņu 2 X 8 bitu veseliem skaitļiem, mums ir nepieciešami tikai 8 bitu collas

Tā kā vērtība nekad nav augstāka par 128 (pikseļiem), mēs varam ietaupīt vietu, izmantojot 8 bitu collas (maksimālā vērtība ir 255) */

anulēts iestatījums ()

{kavēšanās (100); // dodiet displejam utt. laiku displeja ieslēgšanai.begin (SSD1306_SWITCHCAPVCC, 0x3C); // tas ir inicializēt displeja displeju.clearDisplay (); // sāciet ar tukšu ekrānu}

/* lūdzu, ņemiet vērā, ka šie komentāri nav jāievada, lai tie būtu atsauce …………..

komanda, uz kuru mēs koncentrēsimies, ir display.drawBitmap, tas ir tas, kas zīmē mūsu šļakatu ekrānu. (bmpX, ir X ass vērtība ekrānā, kur atradīsies bitkartes X stiprinājuma punkts, un bmpX un bmpY ir vērtības, kas mūs interesē, lai radītu kustību (bmpY, ir Y ass vērtība ekrānā, kur Y enkurs bitkartes punkts būs tas, ka mēs saņemsim atsauces nosaukumus, kā mēs tos definējām logotipā. c (LOGOPIC, ir bitkartes nosaukums #included faila logotipā. c (LOGOWIDTH, ir, cik pikseļu ir (X), lai zīmētu bitkarte no enkura punkta (LOGOHEIGHT, ir, cik pikseļu uz leju (Y), lai zīmētu bitkarti no stiprinājuma punkta, ko X un Y pikseļi var ievadīt manuāli, taču ir vieglāk izmantot iepriekš definētos, nekā atcerēties tos visus (1, pēdējā vērtība ir krāsa, jo ekrāns ir mono 0 melns 1 balts. labi, sāciet rakstīt no nākamās rindas: ¬D lol*/ void loop () {display.clearDisplay (); // tukšs ekrāns // bitkarte, kas iegūta no augšējā kreisajā stūrī, x, y, bitkartes nosaukums, platums X, augstums Y, krāsu displejs.drawBitmap (bmpX, bmpY, LOGOPIC, LOGOWIDTH, LOGOHEIGHT, 1); display.display (); // tas faktiski piesaista buferi uz displeja jebkad}

augšupielādējiet savu arduino kodu un apstipriniet, ka tas darbojas (3. attēls).

5. solis: Bitmap Sprite pārvietošana

izmantojot iepriekšējos norādījumus, izmantojiet krāsu paint.net un izveidojiet jaunu failu, lai tas būtu 30x15 pikseļi (pic1), un uzzīmējiet aptuvenu automašīnu, kuru mūsu jaunais dizainers vispirms sāk ar vējstiklu (2. un 3. attēls).

vēlreiz saglabājiet to kā Windows bmp failu (kā 2. solī), pārvēršiet to C bitkartē (3. darbība) un ievietojiet failu car.c (vai to, ko kādreiz izlemjat) tajā pašā mapē kā jaunizveidotais arduino ino (skice) failu.

(p.s. atcerieties automašīnā pievienot rindiņu #include.c tas mūs bieži pamanīja)

Vispirms saistiet savu automašīnas ekvivalentu. C

#iekļaut

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

Adafruit_SSD1306 displejs (128, 64); // iestatiet displeja izšķirtspēju

/* bmpX/bmpY mums ir jābūt mainīgajiem, mainot šīs vērtības un pārzīmējot

ekrāns ir tas, kā mēs izveidojam kustības animācijas efektu. hitSide un hitTop ir tas, kā mēs saglabājam sprite ekrānā */ uint8_t bmpX, bmpY = 0; // rezervējiet atmiņu 2 8 bitu collām (0-255), mums nav nepieciešams lielāks 128 būs lielākais izmantoto bool hitSide = 0; bool hitTop = 0;

anulēts iestatījums ()

{kavēšanās (100); // dodiet displejam utt. laiku displeja ieslēgšanai.begin (SSD1306_SWITCHCAPVCC, 0x3C); // tas ir inicializēt displeja displeju.clearDisplay (); // sāciet ar tukšu ekrānu

}

tukša cilpa ()

{display.clearDisplay (); // tukšs ekrāns // bitkarte, kas zīmēta no augšējā kreisā stūra, x, y, bitkartes nosaukums, platums X, augstums Y, krāsu displejs.drawBitmap (bmpX, bmpY, CARSPRITE, CARWIDTH, CARHEIGHT, 1); // display.display (); // tas patiesībā piesaista buferi displejam/ * šādā veidā mēs izsekojam ekrāna malām un izlemjam, vai pievienot pikseļus, pārvietojoties no augšas uz leju) vai noņemt pikseļus (pārvietot no apakšas uz augšu) */ slēdzis (hitSide) // tas izvēlas automašīnas virzienu, pamatojoties uz boole {case 0: bmpX ++; pārtraukums;

1. gadījums:

bmpX--; pārtraukums; } // šie 2 if paziņojumi nosaka bolu kā patiesu vai nepatiesu, ja (bmpX == 0) {hitSide = 0; } if (bmpX == 96) // ekrāna platums mīnus automašīna {hitSide = 1; } // tāds pats kā iepriekš Y asij, ja (bmpY == 0) {hitTop = 0; } if (bmpY == 49) // ekrāna augstums mīnus automašīnas augstums {hitTop = 1; } slēdzis (hitTop) {gadījums 0: bmpY ++; pārtraukums; 1. gadījums: bmpY--; pārtraukums; }

}

programmu var redzēt pievienotajā video

6. darbība: braukšanas spēles izveide

Vispirms mēs sākam zīmēt dažas dažādas automašīnas vai šķēršļus, piemēram, apmācības iepriekšējos posmos, padarot tos par 30x15 pikseļiem. Tad mēs tos pārvēršam par c bitkartēm un saistām kodu.

#include // šie ceļi būs jāmaina atkarībā

// kur glabājat failus // rediģēt: es tikko uzzināju, ka, ja jūs // aizstājat ar "", jums nav nepieciešams pilns ceļš // ar savām bibliotēkām #include

#iekļaut

#iekļaut #iekļaut

#iekļaut

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

Adafruit_SSD1306 displejs (128, 64); // definējiet displeja parametrus

definēt mainīgos un fiksētās vērtības

// definējiet ievades tapas, tās ir arduino tapas, kuras tās nekad nemainās, tāpēc #define #define INTPIN 3 // tikai 2. un 3. tapas var būt savstarpējas tapas UNO #define UPPIN 4 // tās ir savienotas tapas tp attiecīgais slēdzis #define DWNPIN 5 #define LFTPIN 6 #define RHTPIN 7 #define SND 9 // norādiet virzienus

#define DIRUP 1 // uz šīm vērtībām “čūska” skatās, lai izlemtu-

#define DIRDOWN 2 // virziens, kurā čūska brauks #define DIRLEFT 3 #define DIRRIGHT 4

uint8_t dirPressed = 0; // vērtība, lai reģistrētu virzienu, lai pārietu uz to, kura tapa bija augsta

// Būla preču veikals, kura tapa bija augsta

bool BUTUP = 0; bool BUTDWN = 0; bool BUTLFT = 0; bool BUTRHT = 0; // vars par automašīnas stāvokli uint8_t carPosX = 1; uint8_t carPosY = {0, 16, 32, 48}; // masīvam nepieciešama vērtība

uint8_t lanePosArr = {0, 16, 32, 48}; // masīvs, lai saglabātu, kur atrodas katra josla

uint8_t carPosYCnt = 0; uint8_t carYTmp = 0; // mainīgie ceļa līnijām uint8_t roadLineX1 = 51; // tie ir iepriekš definēti sākumā, tad līnijas parādās bez problēmām uint8_t roadLineX2 = 102; uint8_t roadLineX3 = 153; uint8_t roadLineX4 = 254; uint8_t roadLineX5 = 200;

// tas ir, cik pikseļu pārvietojas spēles laukums vienlaikus

uint8_t drawSpeed = 4;

// vars ienaidniekam0

uint8_t ienaidnieks0PosX = 255; uint8_t ienaidnieks0PosY = 0; uint8_t ienaidnieks1PosX = 255; uint8_t ienaidnieks1PosY = 0; uint8_t ienaidnieks2PosX = 255; uint8_t ienaidnieks2PosY = 0;

// mainīgs pēc nejaušības principa piešķir šķēršļiem joslas numuru

uint8_t laneGen = 0;

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

// rezultātu skaitītājs

garš rādītājs = 0; // tas ir rezultāts:/ lol ilgi salīdzināt = 0; // tas saglabā rezultātu pēdējā līmenī, lai to salīdzinātu ar garu augstu rezultātu = 25; uint8_t metreCnt = 0;

šeit mēs sākam funkcijas

// tas ir komandu kopums, ja pārtraukums ir aktivizēts void interruptressed () {delay (150); updateDirection (); } // atjauniniet, kura vērtība ir virzienā var, pārbaudot DIR bools // -------------------------- UPDATE DIRECTION (atskaņotājs)- ------------------------- void updateDirection () {//Serial.println("updateDirection Called "); BUTUP = digitalRead (UPPIN); BUTDWN = digitalRead (DWNPIN); BUTLFT = digitalRead (LFTPIN); BUTRHT = digitalRead (RHTPIN); ja (BUTUP == true) {dirPressed = DIRUP; } ja (BUTDWN == true) {dirPressed = DIRDOWN; } ja (BUTLFT == true) {dirPressed = DIRLEFT; } ja (BUTRHT == true) {dirPressed = DIRRIGHT; }

}

// ------------------------------- PĀRVIETOT AUTO --------------- -------------------------

// tas atjauninās ekrānu, lai pārvietotu automašīnas sprite

void moveCar ()

{switch (dirPressed) {case DIRUP: carPosYCnt--; carPosY [carPosYCnt]; tonis (SND, 100, 100); ja (carPosYCnt == 255) {carPosYCnt = 0; } carYTmp = carPosY [carPosYCnt]; dirPressed = 0; // Serial.println ("carPosY up"); // Serial.println (carPosYCnt); pārtraukums; korpuss DIRDOWN: carPosYCnt ++; tonis (SND, 100, 100); ja (carPosYCnt == 4) {carPosYCnt = 3; } // Serial.println ("carPosY"); // Serial.println (carPosYCnt); carYTmp = carPosY [carPosYCnt]; dirPressed = 0; pārtraukums; // komentēja automašīnu, kas spēj pārvietoties pa kreisi un pa labi, sadursmes noteikšana vēl nav tik laba /* lieta DIRLEFT: carPosX--; ja (carPosX == 0) {carPosX = 1; } // Serial.println ("carPosX"); // Serial.println (carPosX); dirPressed = 0; pārtraukums; */ lieta DIRRIGHT: // tikai prieka pēc, ja nospiežat pa labi, spēle radīs trokšņa signālu (SND, 100, 50); // carPosX ++; // ja (carPosX == 128) // {// carPosX = 127; //} // Serial.println ("carPosX"); // Serial.println (carPosX); // dirPressed = 0; pārtraukums; } updateDisplay (); }

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

uint8_t randomPosX () // šīs 2 rutīnas vienkārši rada nejaušu šķēršļu pozīciju

{uint8_t posValTmp = 0; posValTmp = nejaušs (129, 230); //Serial.println("random x "); //Serial.println(posValTmp); atgriešanās (posValTmp); }

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

uint8_t randomPosY ()

{uint8_t laneVal = 0; laneVal = nejaušs (0, 4); // nejaušībai pievienojiet papildu joslu, ti, šajā joslā ekrānā nav neviena objekta //Serial.println("RandomY "); //Serial.println(lanePosArr[laneVal]); atgriešanās (lanePosArr [laneVal]); }// ------------------------------- SET SPEED ĀTRUMS -------------- -------------- void setGameSpeed () // tas pārtrauc līmeņa paaugstināšanos virs 20, padarot spēli neiespējamu {ja (drawSpeed <21) {drawSpeed = drawSpeed+2; }}// ------------------------------------ DETECT CRASH ---------- ----------------------- void detectCrash () {

ja (ienaidnieks0PosX = 0 && ienaidnieks0PosY == autoYTmp)

{// Serial.println ("Spēle pāri CRAASSSSHHHHHHEEEEDDD satiksmē 0"); spēle beigusies(); } ja (ienaidnieks1PosX = 0 && ienaidnieks1PosY == automašīnaTmp) {//Serial.println("Spēle pāri CRAASSSSHHHHHHEEEEDDD satiksmē 1 "); spēle beigusies(); } ja (ienaidnieks2PosX = 0 && ienaidnieks2PosY == autoYTmp) {//Serial.println("Spēle pāri CRAASSSSHHHHHHEEEEDDD satiksmē 2 "); spēle beigusies(); }}

tās ir rutīnas, kas zīmē displeju.

// ------------------------------- ZĪMĒŠANAS CEĻŠ --------------- --------------------- void drawRoad () // X, Y, garums, platums {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 (); } // ---------------------------------------- IZVĒLĒT ienaidniekus ---- --------------------------------------- tukši ienaidniekiDraw () {// X, Y, bmp nosaukums, platums, augstums, krāsu displejs.drawBitmap (ienaidnieks0PosX, ienaidnieks0PosY, ENEMY0, ENEMY0_WIDTH, ENEMY0_HEIGHT, 1); ienaidnieks0PosX = ienaidnieks0PosX-drawSpeed; display.drawBitmap (ienaidnieks1PosX, ienaidnieks1PosY, ENEMY1, ENEMY1_WIDTH, ENEMY1_HEIGHT, 1); ienaidnieks1PosX = ienaidnieks1PosX-drawSpeed; display.drawBitmap (ienaidnieks2PosX, ienaidnieks2PosY, ENEMY2, ENEMY2_WIDTH, ENEMY2_HEIGHT, 1); ienaidnieks2PosX = ienaidnieks2PosX-drawSpeed; display.display (); if (ienaidnieks0PosX> 231 && ienaidnieks0PosX231 && ienaidnieks1PosX <255) {ienaidnieks1PosX = izlasesPosX (); ienaidnieks1PosY = randomPosY (); checkDuplicate (); }

if (ienaidnieks2PosX> 231 && ienaidnieks2PosX <255) {ienaidnieks2PosX = izlasesPosX (); ienaidnieks2PosY = randomPosY (); }} // ------------------------------------ UPDATE DISPLAY -------- ---------------------------------------- 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 (BALTS, MELTS); display.println (rezultāts); display.display ();

}

// ------------------------- gaidiet preses cilpu ------------------- ------

// tas ir sākuma ekrāna kods void waitForPress () {splashScreen (); bool gaidīšana = 0; // cilpa beidzas, kad tas ir patiess display.clearDisplay (); kamēr (gaida == 0) {

display.fillRect (19, 20, 90, 32, BLACK); // tukšs teksta fons

display.setTextColor (BALTS); display.setCursor (23, 24); display.setTextSize (0); display.println ("Pārgalvīgs"); display.setCursor (36, 34); display.println ("Racer"); display.drawBitmap (74, 24, CARSPRITE, CARWIDTH, CARHEIGHT, 1); // x y w h r col displejs.drawRoundRect (21, 21, 86, 23, 4, WHITE); // robeža Snake display.drawRect (19, 20, 90, 33, WHITE); // apmales kaste - 3 display.setCursor (25, 43); display.setTextSize (0); // fonts atpakaļ normālā displejā.println ("nospiediet jebkuru taustiņu"); display.fillRect (0, 0, 127, 8, BLACK); display.setCursor (10, 0); display.print ("High Score:"); // parādīt augstu rezultātu displeju.print (highScore); display.display (); gaidīšana = digitalRead (INTPIN); // pārbaudiet, vai nospiežot taustiņu gaidīšana, mainīsies uz 1 beigām, kamēr dirPressed = 0; // atiestatīšanas pogu nospiediet bez virziena}} // -------------------------------------- ----- UPDATE GAME ----------------------------------------- void updateGame () {moveCar (); drawRoad (); enemysDraw (); // ienaidnieks1Draw (); // ienaidnieks2Draw (); metreCnt ++; detectCrash (); if (metreCnt == 5) // pievieno punktu par katriem 10 cikliem, lai palielinātu rezultātu {metreCnt = 0; rezultāts ++; } ja (rezultāts == salīdzināt+5) // paātrina spēli ik pēc 5 punktiem līdz maksimāli 20 ātrumiem {salīdzināt = rezultāts; setGameSpeed (); } noTone (SND); updateDisplay ();

}

// ------------------------------ SPĒLE BEIGUSIES---------------- ------------------------------

// šī rutīna velk līnijas ap mirušo varoņa automašīnu, pēc tam ekrānā parāda spēli

void gameOver ()

{tonis (SND, 200, 200); // atskaņot skaņu uint8_t linePosX, linePosY, pixwidth, pixheight = 0; // iestatiet vars, lai zīmētu kastes ap automašīnas līnijuPosX = carPosY; linePosY = carYTmp; pikseļu platums = 30; pikseļa augstums = 15; display.drawRect (linePosX, linePosY, pikseļa platums, pikseļa augstums, BALTS); display.display (); for (int i = 0; i <= 26; i ++) // tas ieskauj automašīnu taisnstūros, kas imitē sprādzienu {linePosX = linePosX-2; linePosY = linePosY-2; pikseļa platums = pikseļa platums+4; pikseļa augstums = pikseļa augstums+4; display.drawRect (linePosX, linePosY, pixwidth, pixheight, BLACK); display.drawRect (linePosX, linePosY, pikseļa platums, pikseļa augstums, BALTS); display.display (); tonis (SND, i*20, 50); kavēšanās (10); } display.setTextSize (2); display.setTextColor (BALTS, MELTS); display.setCursor (10, 23); tonis (SND, 50, 500); display.print ("SPĒLE"); display.display (); kavēšanās (500); tonis (SND, 40, 500); display.print ("OVER"); display.setTextSize (0); display.display (); kavēšanās (3000); restartGame (); waitForPress (); }

// ----------------------------------------- ATKĀRTOTA SPĒLE ----- -------------------------------------------------- -----

void restartGame () // tas kopē augstu rezultātu un atiestata visu statistiku un ģenerē nejaušas pozīcijas

{if (score> = highScore) // pārbaudiet, vai rezultāts ir augstāks par augstu rezultātu {highScore = score; // viens, ja apgalvojums, lai atjauninātu augstu rezultātu}

rezultāts = 0;

drawSpeed = 4; metreCnt = 0; carPosYCnt = 0; ienaidnieks0PosX = randomPosX (); ienaidnieks0PosY = randomPosY (); ienaidnieks1PosX = randomPosX (); ienaidnieks1PosY = randomPosY (); ienaidnieks2PosX = randomPosX (); ienaidnieks2PosY = randomPosY (); noTone (SND);

checkDuplicate ();

}

// ------------------------------------------------ -PĀRBAUDIET DUPLIKĀTU ----------------------------------------------- ------ void checkDuplicate () // šīs pārbaudes, lai noskaidrotu, vai šķēršļi aizņem to pašu spēles vietu {// Serial.println ("pārbaudīts dublikāts"); if (ienaidnieks2PosX> 230 && ienaidnieks2PosX <255) {while (ienaidnieks2PosY == ienaidnieks1PosY || ienaidnieks2PosY == ienaidnieks0PosY) {ienaidnieks2PosY = izlasesPozY (); }}

ja (ienaidnieks0PosX> 230 && ienaidnieks0PosX230 && ienaidnieks2PosXenemy1PosX && ienaidnieks2PosX230 && ienaidnieks0PosXenemy1PosX && ienaidnieks0PosX

// ------------------------------------------- SPLASH SCREEN --- --------------------------------

void splashScreen ()

{display.clearDisplay (); display.drawBitmap (0, 0, CRASH, CRASHWIDTH, CRASHHEIGHT, 1); display.display (); kavēšanās (2000); } // ----------------------------------------------- UZSTĀDĪT ------------------------------------------------- ----------- void setup () {kavēšanās (100); // ļauj lietām sākt // Serial.begin (9600); // komentēt šo un visu sēriju. komandas kļūdu diagnostikai displejā.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay (); display.setTextColor (BALTS, MELTS); display.setTextWrap (nepatiess); displejs.dim (0); pinMode (INTPIN, INPUT); pinMode (UPPIN, INPUT); pinMode (DWNPIN, INPUT); pinMode (LFTPIN, INPUT); pinMode (RHTPIN, INPUT);

attachInterrupt (digitalPinToInterrupt (INTPIN), pārtraukts, RISING);

// nejauši novietot šķēršļus ienaidnieks0PosX = randomPosX (); ienaidnieks0PosY = randomPosY (); ienaidnieks1PosX = randomPosX (); ienaidnieks1PosY = randomPosY (); ienaidnieks2PosX = randomPosX (); ienaidnieks2PosY = randomPosY (); checkDuplicate (); // pārbaudīt atrašanās vietu dublikātus // Serial.println ("iestatīšana pabeigta"); splashScreen (); waitForPress (); } // ----------------------------------------------- ----- LOOP -------------------------------------------- ----------

tukša cilpa ()

{updateGame (); }

un tas ir gandrīz viss, visas izmaiņas un atsauksmes būs laipni gaidītas. Jautājumi, kas mums jārisina ekrāna mirgošanas laikā, mums ir jāizpēta, kā to samazināt, un ienaidnieka automašīnas joprojām spēj aizņemt to pašu vietu.