Reckless Racer Arduino OLED Game, AdafruitGFX și Bitmaps Noțiuni de bază: 6 pași

2025 Autor: John Day | [email protected]. Modificat ultima dată: 2025-01-23 15:04

În acest tutorial ne vom uita la modul de utilizare a bitmap-urilor folosind biblioteca Adafruit_GFX.c ca un fel de sprite într-un joc. Cel mai simplu joc la care ne-am putea gândi este un joc de schimbare a benzii cu defilare laterală, în cele din urmă testerul nostru beta și asistentul nostru de codare au decis „Reckless Racer” ca nume, deoarece este destul de nesăbuit să conducă pe un drum greșit pe autostradă !!.

Proiectarea circuitului nostru este în imaginile incluse mai sus și este detaliată în ultimul nostru proiect / tutorial aici Snake Instructables care descrie modul în care funcționează circuitul.

vom cere

Adafruit_GFX

Paint.net

Arduino IDE windowslinux

și vă rugăm să aruncați o privire la tutorialul Snake pentru restul echipamentului.

Provizii

Jocul Șarpelui

Pasul 1: Instalarea Paint.net

Folosim paint.net deoarece software-ul este gratuit, așa că este complet gratuit de utilizat, puteți descărca Paint. Net de aici.

Pentru a instala paint.net, faceți dublu clic pe programul descărcat și răspundeți pozitiv la următoarea, da, ok, sunt de acord și imaginile de mai sus vă vor oferi indicații.

Pasul 2: Desenarea unui ecran simplu Splash

Când vă aflați în paint.net creați o imagine nouă făcând clic pe Fișier, apoi pe nouă, setați dimensiunea imaginii la 1260x620 (vezi prima imagine) faceți clic pe OK când aveți o pagină nouă, desenați un ecran de pornire folosind doar 2 culori alb-negru folosind creionul instrument (pic2), când ați desenat (sau ați lipit) imaginea de pe ecran, faceți clic pe imagine, apoi redimensionați (imagine4), în fereastra pop-up modificați dimensiunea de la 1260x620 la 126x62 (2 pixeli mai mici decât afișajul dvs.) (pic5) Faceți clic pe OK.

apoi faceți clic pe meniul Fișier, apoi salvați ca (pic6).

când fereastra pop-up apare în meniul derulant pentru tipul de fișier selectați BMP (bitmap).).

Pasul 3: Conversia BMP în fișierul bitmap C

Acum trebuie să ne convertim imaginea într-un format pe care arduino îl poate înțelege că există o mulțime de instrumente disponibile pentru a face acest lucru, dar locul meu „du-te la” este instrumentul de conversie bitmap al site-ului web Marlin …

marlinfw.org/tools/u8glib/converter.html

Așa că începem această secțiune folosind linkul de mai sus pentru a deschide site-ul web care este prezentat în pic1

faceți clic pe alegeți fișierul și selectați bitmap-ul pe care l-ați creat anterior (pic2)

convertorul bitmap marlin vă va converti automat imaginea în cod c stânga faceți dublu clic pe codul care ar trebui să evidențieze codul, apoi faceți clic dreapta și faceți clic pe copiere (pic3)

următor Creăm clic dreapta și creăm un document text nou (pic4)

faceți dublu clic pe noul document, când este deschis faceți clic dreapta și lipiți codul (pic5)

apoi trebuie să adăugăm linia din partea de sus a codului # include acest lucru ne permite să salvăm datele bitmap în memoria flash de pe arduino, apoi redenumim #define lățimea, înălțimea și numele în ceva mai ușor de utilizat acestea sunt evidențiate în imaginea 6, le redenumim din caracterele generate aleatoriu le redenumim în exemplul subliniat de mai jos

#define LOGOWIDTH

#define LOGOHEIGHT

const unsigned char LOGOPIC PROGMEM

apoi faceți clic pe fișier, apoi salvați ca, salvați fișierul ca logo.c închideți blocnotesul, faceți clic dreapta pe logo.c și faceți clic pe copiere.

Pasul 4: Afișarea unui LOGO folosind DrawBitmap

Acum încărcăm IDE-ul arduino și creăm o schiță nouă și îl salvăm denumit logoexample.ino, apoi ca un trișor în ideul arduino, faceți clic pe meniul fișierului, apoi salvați ca, reveniți la folderul proiectului faceți clic dreapta și lipiți în fișierul.c (pic2), apoi faceți clic pe anulare, ceea ce vă scutește de a naviga la folderul de lipit în fișier.

tastați următorul cod în IDE-ul arduino sau descărcați ino.

(vă recomandăm să tastați mai degrabă decât să copiați și să lipiți sau să folosiți fișierele de mai jos, cel mai bun mod de a învăța)

#include / * acest lucru va varia în funcție de locul în care stocați

ino de obicei în folderul C: / Users / ~ nume de utilizator / Documents / Arduino / proiect ~ nume

și așa ne conectăm la bitmap-ul nostru * /

#include

#include

uint8_t bmpX, bmpY = 0; / * rezervă memorie pentru 2 X 8 biți întregi, avem nevoie doar de 8 biți ints

deoarece valoarea nu este niciodată mai mare de 128 (pixeli), astfel putem economisi spațiu folosind 8 biți de inți (care are o valoare maximă de 255) * /

configurare nulă ()

{întârziere (100); // acordați afișajului etc. timp pentru pornire display.begin (SSD1306_SWITCHCAPVCC, 0x3C); // aceasta este pentru a inițializa afișajul display.clearDisplay (); // începe cu un ecran gol}

/ * Vă rugăm să rețineți că nu trebuie să introduceți aceste comentarii pentru ca acestea să fie de referință …………..

comanda pe care ne vom concentra este display.drawBitmap, acesta este ceea ce ne atrage ecranul de pornire. (bmpX, este valoarea axei X pe ecran unde va fi punctul de ancorare X al bitmap-ului și bmpX și bmpY sunt valorile care ne interesează pentru a crea mișcare (bmpY, este valoarea axei Y de pe ecran unde ancorarea Y punctul bitmap-ului va fi obținem numele de referință așa cum le-am definit în logo.c (LOGOPIC, este numele bitmap-ului din fișierul #include logo.c (LOGOWIDTH, este numărul de pixeli care traversează (X) pentru a desena harta de biți din punctul de ancorare (LOGOHEIGHT, este numărul de pixeli în jos (Y) pentru a desena harta de biți din punctul de ancorare, pixelii X și Y pot fi introduși manual, dar este mai ușor de folosit cei predefiniți decât să-i amintiți pe toți (1, ultima valoare este culoarea deoarece ecranul este mono 0 negru 1 alb. Bine începeți să tastați de la următoarea linie: ¬D lol * / bucla void () {display.clearDisplay (); // goliți ecranul // bitmap desenat din sus stânga, x, y, numele bitmap-ului, lățimea X, înălțimea Y, afișare color.drawBitmap (bmpX, bmpY, LOGOPIC, LOGOWIDTH, LOGOHEIGHT, 1); display.display (); // acest lucru atrage de fapt bufferul pe afișaj vreodată}

încărcați codul dvs. arduino și confirmați că funcționează (pic3).

Pasul 5: Mutarea unui Sprite Bitmap

folosind instrucțiunile anterioare, folosiți paint.net și creați un fișier nou, faceți-l 30x15 pixeli (pic1) și desenați o mașină dură tânărul nostru designer începe cu parbrizul în primul rând (imaginile 2 și 3).

salvați-l din nou ca fișier Windows bmp (ca la pasul 2), convertiți-l într-o bitmap C (pasul 3) și plasați fișierul car.c (sau ce veți decide vreodată) în același folder cu un nou arduino ino (schiță) fişier.

(pag. amintiți-vă să adăugați linia #include în mașină.c folosită pentru a ne prinde des)

Mai întâi conectați-vă echivalentul car.c

#include

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

Display Adafruit_SSD1306 (128, 64); // setați rezoluția afișajului

/ * bmpX / bmpY avem nevoie ca acestea să fie variabile ca schimbarea acestor valori și redesențierea

ecranul este modul în care creăm efect de animație de mișcare. hitSide și hitTop este modul în care păstrăm sprite în ecran * / uint8_t bmpX, bmpY = 0; // rezervați memorie pentru 2 8 biți inți (0-255) nu avem nevoie de mai mare 128 va fi cel mai mare număr folosit bool hitSide = 0; bool hitTop = 0;

configurare nulă ()

{întârziere (100); // acordați afișajului etc. timp pentru pornire display.begin (SSD1306_SWITCHCAPVCC, 0x3C); // aceasta este pentru a inițializa afișajul display.clearDisplay (); // începe cu un ecran gol

}

bucla nulă ()

{display.clearDisplay (); // goliți ecranul // bitmap desenat din stânga sus, x, y, numele bitmap-ului, lățime X, înălțime Y, afișare color.drawBitmap (bmpX, bmpY, CARSPRITE, CARWIDTH, CARHEIGHT, 1); // display.display (); // aceasta atrage de fapt bufferul pe afișaj vreodată / * așa urmărim marginea ecranului și decidem dacă adăugăm un pixel mutați de sus în jos) sau îndepărtați un pixel (mutați de jos în sus) * / switch (hitSide) // aceasta alege direcția mașinii în funcție de boole {caz 0: bmpX ++; pauză;

cazul 1:

bmpX--; pauză; } // aceste 2 if declarații setează boolul la true sau false if (bmpX == 0) {hitSide = 0; } if (bmpX == 96) // lățimea ecranului minus mașina {hitSide = 1; } // la fel ca mai sus pentru axa Y dacă (bmpY == 0) {hitTop = 0; } if (bmpY == 49) // înălțimea ecranului minus înălțimea mașinii {hitTop = 1; } switch (hitTop) {case 0: bmpY ++; pauză; cazul 1: bmpY--; pauză; }

}

puteți vedea programul funcționând în videoclipul atașat

Pasul 6: Realizarea jocului de conducere

Mai întâi Începem prin a desena câteva mașini sau obstacole diferite, cum ar fi în etapele anterioare ale tutorialului, făcându-le 30x15 pixeli. Apoi le convertim în bitmaps c și le conectăm în cod.

#include // aceste căi vor trebui să se schimbe dependente

// unde stocați fișierele // editați: tocmai am aflat dacă înlocuiți // cu „” nu aveți nevoie de calea completă // cu propriile biblioteci #include

#include

#include #include

#include

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

Display Adafruit_SSD1306 (128, 64); // definiți parametrii de afișare

definiți variabilele și valorile fixe

// definesc pinii de intrare aceștia sunt pinii de pe arduino ei nu se schimbă niciodată așa că # define # define INTPIN 3 // numai pinii 2 și 3 pot fi interrupți pinii de pe UNO #define UPPIN 4 // aceștia sunt pinii conectați tp comutator relevant #define DWNPIN 5 #define LFTPIN 6 #define RHTPIN 7 #define SND 9 // define direcții

#define DIRUP 1 // aceste valori este ceea ce „șarpele” privește pentru a decide-

#define DIRDOWN 2 // direcția în care va călători șarpele #define DIRLEFT 3 #define DIRRIGHT 4

uint8_t dirPressed = 0; // valoare pentru a înregistra direcția pentru a vă deplasa pe care pin a mers sus

// magazinul booleenilor care pin a fost ridicat

bool BUTUP = 0; bool BUTDWN = 0; bool BUTLFT = 0; bool BUTRHT = 0; // varuri pentru poziția mașinii uint8_t carPosX = 1; uint8_t carPosY = {0, 16, 32, 48}; // are nevoie de valoare cahnging matrice

uint8_t lanePosArr = {0, 16, 32, 48}; // matrice pentru a stoca unde este fiecare bandă

uint8_t carPosYCnt = 0; uint8_t carYTmp = 0; // variabile pentru liniile din drum uint8_t roadLineX1 = 51; // acestea sunt predefinite la început, apoi liniile apar perfect uint8_t roadLineX2 = 102; uint8_t roadLineX3 = 153; uint8_t roadLineX4 = 254; uint8_t roadLineX5 = 200;

// acesta este numărul de pixeli care se mișcă zona de joc odată

uint8_t drawSpeed = 4;

// vars pentru inamic0

uint8_t malamic0PosX = 255; uint8_t malamic0PosY = 0; uint8_t malamic1PosX = 255; uint8_t malamic1PosY = 0; uint8_t malamic2PosX = 255; uint8_t malamic2PosY = 0;

// variabil pentru a atribui aleatoriu un număr de bandă obstacolelor

uint8_t laneGen = 0;

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

// contor de scoruri

scor lung = 0; // acesta este scorul: / lol long compare = 0; // acesta stochează scorul la ultimul nivel pentru a se compara înapoi cu highScore lung = 25; uint8_t metreCnt = 0;

de aici începem funcțiile

// acesta este setul de comenzi dacă întreruperea este activată void interruptressed () {delay (150); updateDirection (); } // actualizați care valoare este în direcția var verificând DIR bools // -------------------------- ACTUALIZARE DIRECȚIE (jucător) - ------------------------- 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; }

}

// ------------------------------- MUTĂ AUTO --------------- -------------------------

// acest lucru va actualiza ecranul mutator sprite auto

void moveCar ()

{switch (dirPressed) {case DIRUP: carPosYCnt--; carPosY [carPosYCnt]; ton (SND, 100, 100); if (carPosYCnt == 255) {carPosYCnt = 0; } carYTmp = carPosY [carPosYCnt]; dirPressed = 0; // Serial.println ("carPosY up"); // Serial.println (carPosYCnt); pauză; caz DIRDOWN: carPosYCnt ++; ton (SND, 100, 100); if (carPosYCnt == 4) {carPosYCnt = 3; } // Serial.println ("carPosY"); // Serial.println (carPosYCnt); carYTmp = carPosY [carPosYCnt]; dirPressed = 0; pauză; // a comentat mașina capabilă să se deplaseze la detectarea coliziunilor la stânga și la dreapta încă nu este atât de bună / * caz DIRLEFT: carPosX--; if (carPosX == 0) {carPosX = 1; } // Serial.println ("carPosX"); // Serial.println (carPosX); dirPressed = 0; pauză; * / carcasa DIRRIGHT: // doar pentru distracție, dacă apăsați dreapta, jocul va emite un ton de zgomot (SND, 100, 50); // carPosX ++; // if (carPosX == 128) // {// carPosX = 127; //} // Serial.println ("carPosX"); // Serial.println (carPosX); // dirPressed = 0; pauză; } updateDisplay (); }

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

uint8_t randomPosX () // aceste 2 rutine generează doar o poziție aleatorie pentru obstacole

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

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

uint8_t randomPosY ()

{uint8_t laneVal = 0; laneVal = aleatoriu (0, 4); // adăugați o bandă suplimentară pentru aleatoriu, adică niciun obiect pe ecran în timp ce se află pe banda respectivă //Serial.println("RandomY "); //Serial.println(lanePosArr[laneVal]); return (lanePosArr [laneVal]); }// ------------------------------- SET VITEZA JOCULUI -------------- -------------- void setGameSpeed () // acest lucru împiedică nivelul să depășească 20, făcând jocul să nu poată fi jucat {if (drawSpeed <21) {drawSpeed = drawSpeed + 2; }}// ------------------------------------ DETECȚIONAȚI CRASH ---------- ----------------------- void detectCrash () {

if (inamic0PosX = 0 && inamic0PosY == mașinăYTmp)

{// Serial.println („Game Over CRAASSSSHHHHHHHEEEEDDD în Traffic 0”); joc încheiat(); } if (enemic1PosX = 0 && malamic1PosY == carYTmp) {//Serial.println("Game Over CRAASSSSHHHHHHHEEEEEDDD în trafic 1 "); joc încheiat(); } if (malamic2PosX = 0 && enemic2PosY == carYTmp) {//Serial.println("Game Over CRAASSSSHHHHHHHEEEEEDDD în trafic 2 "); joc încheiat(); }}

acestea sunt rutinele care atrag afișajul.

// ------------------------------- DRAW ROAD --------------- --------------------- void drawRoad () // X, Y, lungime, lățime {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 (); } // ----------------------------------------- DRAW enemys ---- --------------------------------------- void enemysDraw () {// X, Y, nume bmp, lățime, înălțime, afișare color.drawBitmap (enemic0PosX, inamic0PosY, ENEMY0, ENEMY0_WIDTH, ENEMY0_HEIGHT, 1); inamicul0PosX = inamicul0PosX-drawSpeed; display.drawBitmap (enemic1PosX, inamic1PozY, ENEMY1, ENEMY1_WIDTH, ENEMY1_HEIGHT, 1); malamic1PosX = malamic1PosX-drawSpeed; display.drawBitmap (enemic2PosX, malamic2PosY, ENEMY2, ENEMY2_WIDTH, ENEMY2_HEIGHT, 1); malamic2PosX = inamic2PosX-drawSpeed; display.display (); if (inamic0PosX> 231 && inamic0PosX231 && inamic1PosX <255) {inamic1PosX = randomPosX (); malamic1PosY = randomPosY (); checkDuplicate (); }

if (inamic2PosX> 231 && inamic2PosX <255) {inamic2PosX = randomPosX (); malamic2PosY = randomPosY (); }} // ------------------------------------ ACTUALIZARE DISPLAY -------- ---------------------------------------- void updateDisplay () {display.clearDisplay (); display.drawBitmap (carPosX, carPosY [carPosYCnt], CARSPRITE, 30, 15, 1); display.fillRect (100, 0, 28, 10, NEGRU); display.setCursor (100, 0); display.setTextColor (ALB, NEGRU); display.println (scor); display.display ();

}

// ------------------------- așteptați apăsarea buclei ------------------- ------

// acesta este codul ecranului de pornire void waitForPress () {splashScreen (); bool de așteptare = 0; // bucla se termină atunci când este adevărat display.clearDisplay (); în timp ce (așteaptă == 0) {

display.fillRect (19, 20, 90, 32, NEGRU); // fundal gol pentru text

display.setTextColor (ALB); display.setCursor (23, 24); display.setTextSize (0); display.println ("Reckless"); display.setCursor (36, 34); display.println ("Racer"); display.drawBitmap (74, 24, CARSPRITE, CARWIDTH, CARHEIGHT, 1); // x y w h r r display.drawRoundRect (21, 21, 86, 23, 4, ALB); // border Snake display.drawRect (19, 20, 90, 33, WHITE); // caseta de margine - 3 display.setCursor (25, 43); display.setTextSize (0); // fontul revine la afișajul normal.println („apăsați orice tastă”); display.fillRect (0, 0, 127, 8, NEGRU); display.setCursor (10, 0); display.print ("Punctaj înalt:"); // afișează scorul maxim display.print (highScore); display.display (); waiting = digitalRead (INTPIN); // verificați dacă tasta apăsată în așteptare se va schimba la sfârșitul 1 în timp ce dirPressed = 0; // butonul de resetare apăsați la nici o direcție}} // -------------------------------------- ----- UPDATE GAME ----------------------------------------- nul updateGame () {moveCar (); drawRoad (); enemysDraw (); // malamic1Draw (); // malamic2Draw (); metreCnt ++; detectCrash (); if (metreCnt == 5) // adaugă un punct pentru fiecare 10 cicluri pentru a atinge scorul {metreCnt = 0; scor ++; } if (scor == compara + 5) // accelereaza jocul la fiecare 5 puncte la maxim 20 de viteze {compara = scor; setGameSpeed (); } noTone (SND); updateDisplay ();

}

// ------------------------------ JOC ÎNCHEIAT---------------- ------------------------------

// această rutină trasează liniile din jurul mașinii erou moarte, apoi afișează jocul pe ecran

void gameOver ()

{ton (SND, 200, 200); // redarea sunetului uint8_t linePosX, linePosY, pixwidth, pixheight = 0; // setați varele pentru a desena cutii în jurul mașinii linePosX = carPosY; linePosY = carYTmp; lățime pix = 30; pixheight = 15; display.drawRect (linePosX, linePosY, pixwidth, pixheight, WHITE); display.display (); pentru (int i = 0; i <= 26; i ++) // aceasta înconjoară mașina în dreptunghiuri care simulează explozia {linePosX = linePosX-2; linePosY = linePosY-2; pixwidth = pixwidth + 4; pixheight = pixheight + 4; display.drawRect (linePosX, linePosY, pixwidth, pixheight, BLACK); display.drawRect (linePosX, linePosY, pixwidth, pixheight, WHITE); display.display (); ton (SND, i * 20, 50); întârziere (10); } display.setTextSize (2); display.setTextColor (ALB, NEGRU); display.setCursor (10, 23); ton (SND, 50, 500); display.print ("JOC"); display.display (); întârziere (500); ton (SND, 40, 500); display.print ("PESTE"); display.setTextSize (0); display.display (); întârziere (3000); restartGame (); waitForPress (); }

// ----------------------------------------- RESTART JOC ----- -------------------------------------------------- -----

void restartGame () // acesta copiază un scor mare și resetează toate statisticile și generează poziții aleatorii

{if (scor> = scor înalt) // verificați dacă scor mai mare decât scor mare {scor înalt = scor; // unic dacă mențiune pentru a actualiza scorul maxim}

scor = 0;

drawSpeed = 4; metreCnt = 0; carPosYCnt = 0; malamic0PosX = randomPosX (); inamic0PosY = randomPosY (); malamic1PosX = randomPosX (); malamic1PosY = randomPosY (); malamic2PosX = randomPosX (); malamic2PosY = randomPosY (); noTone (SND);

checkDuplicate ();

}

// ------------------------------------------------ - VERIFICĂ DUPLICATUL ----------------------------------------------- ------ void checkDuplicate () // acestea verifică pentru a vedea dacă obstacolele ocupă același spațiu de joc {// Serial.println ("duplicat verificat"); if (inamic2PosX> 230 && inimă2PosX <255) {while (inamic2PosY == inamic1PosY || inamic2PosY == inamic0PosY) {inamic2PosY = randomPosY (); }}

if (inamic0PosX> 230 && inamic0PosX230 && inamic2PosXenemy1PosX && inamic2PosX230 && inamic0PosXenemy1PosX && inamic0PosX

//------------------------------------------- ECRAN SPLASH --- --------------------------------

void splashScreen ()

{display.clearDisplay (); display.drawBitmap (0, 0, CRASH, CRASHWIDTH, CRASHHEIGHT, 1); display.display (); întârziere (2000); } // ----------------------------------------------- ÎNFIINȚAT ------------------------------------------------- ----------- void setup () {întârziere (100); // lasă lucrurile să înceapă // Serial.begin (9600); // decomentează acest serial și toate serialele. comenzi pentru afișarea diag. defect.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay (); display.setTextColor (ALB, NEGRU); display.setTextWrap (fals); display.dim (0); pinMode (INTPIN, INPUT); pinMode (UPPIN, INPUT); pinMode (DWNPIN, INPUT); pinMode (LFTPIN, INPUT); pinMode (RHTPIN, INPUT);

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

// puneți aleatoriu obstacole inamic0PosX = randomPosX (); inamic0PosY = randomPosY (); malamic1PosX = randomPosX (); malamic1PosY = randomPosY (); malamic2PosX = randomPosX (); malamic2PosY = randomPosY (); checkDuplicate (); // verificați locațiile duplicate // Serial.println ("setup Complete"); ecran splash(); waitForPress (); } // ----------------------------------------------- ----- LOOP -------------------------------------------- ----------

bucla nulă ()

{updateGame (); }

și cam asta este, orice modificare și feedback vor fi binevenite. Problemele pe care trebuie să le abordăm pâlpâirea ecranului, trebuie să analizăm cum să o diminuăm, iar mașinile inamice sunt încă capabile să ocupe același spațiu.