Vakmerő versenyző Arduino OLED játék, AdafruitGFX és Bitmaps alapok: 6 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:40

Ebben az oktatóanyagban megvizsgáljuk, hogyan lehet bitképeket használni az Adafruit_GFX.c könyvtár használatával, mint egyfajta sprite egy játékban. A legegyszerűbb játék, amit el tudunk képzelni, egy oldalsó görgetősávváltó autójáték, végül bétatesztelőnk és asszisztenskódolónk a "Reckless Racer" nevet választotta, mivel meglehetősen vakmerő rossz úton vezetni az autópályán !!.

Az áramkörünk kialakítása a fenti képeken található, és az utolsó projektünkben/oktatóanyagunkban részletesen itt található, a Snake Instructables, amely leírja az áramkör működését.

megköveteljük

Adafruit_GFX

Paint.net

Arduino IDE windowslinux

és kérjük, nézze meg a Snake bemutatót a többi felszereléshez.

Kellékek

Kígyó játék

1. lépés: A Paint.net telepítése

A paint.net -et használjuk, mivel a szoftver ingyenes, így teljesen ingyenesen használható, és letöltheti a Paint. Net -et innen.

A paint.net telepítéséhez kattintson duplán a letöltött programra, és válaszoljon pozitívan a következőre, igen, ok, egyetértek, és a fenti képek útmutatást adnak.

2. lépés: Egyszerű splash képernyő rajzolása

Amikor a paint.net -ben dolgozik, hozzon létre egy új képet a Fájl, majd az új elemre kattintva, állítsa a képméretet 1260x620 -ra (lásd az első képet) kattintson az OK gombra, ha új oldala van, rajzoljon egy splash képernyőt, csak 2 fekete -fehér szín segítségével a ceruzával eszköz (2. kép), amikor megrajzolta (vagy beillesztette) a kezdőképernyő képét, kattintson a képre, majd méretezze át (kép4), a felugró ablakban módosítsa a méretet 1260x620 -ról 126x62 -re (2 képponttal kisebb, mint a kijelző) (5. kép) Kattintson az OK gombra.

Ezután kattintson a Fájl menüre, majd mentse el (6. kép).

amikor a felugró ablak megjelenik a fájltípus legördülő menüben, válassza a BMP (bittérkép) lehetőséget. (7. kép), írja be a fájl nevét, majd kattintson a Mentés gombra, amikor az előugró ablak 0 -ra és 8 bitre áll, kattintson az OK gombra (8. kép)).

3. lépés: A BMP konvertálása C Bitmap fájlba

Most át kell alakítanunk a képünket olyan formátumba, hogy az arduino megértse, hogy ehhez rengeteg eszköz áll rendelkezésre, de a "go to" helyem az is marlin weboldal bittérkép -konvertáló eszköze …

marlinfw.org/tools/u8glib/converter.html

Tehát ezt a részt a fenti link használatával kezdjük a weboldal megnyitásához, amely az 1. képen látható

kattintson a fájl kiválasztása gombra, és válassza ki a korábban létrehozott bitképet (2. kép)

A marlin bittérkép -átalakító automatikusan konvertálja a képet c kódba, kattintson duplán a kódra, amely kiemeli a kódot, majd kattintson a jobb egérgombbal, és kattintson a másolatra (kép 3)

Következő Létrehozunk jobb egérgombbal, és létrehozunk egy új szöveges dokumentumot (4. kép)

kattintson duplán az új dokumentumra, amikor megnyílik, kattintson jobb gombbal, és illessze be a kódot (5. kép)

ezt követően hozzá kell adnunk a sort a kód teteje közelében #include ez lehetővé teszi számunkra, hogy elmentsük a bitkép adatait az arduino flash memóriájába, majd átnevezzük a #define szélességet, magasságot és nevet valami könnyebben használhatóra, ezek kiemelve vannak a 6. képen, a véletlenszerűen generált karakterekből nevezzük át őket, az alábbi aláhúzott példára

#define LOGOWIDTH

#define LOGOHEIGHT

const unsigned char LOGOPIC PROGMEM

kattintson a következő fájlra, majd mentse másként, mentse a fájlt logo.c néven, zárja be a jegyzettömböt, kattintson a jobb gombbal a logo.c elemre, és kattintson a másolás gombra.

4. lépés: LOGÓ megjelenítése a DrawBitmap használatával

Most betöltjük az arduino IDE -t, és létrehozunk egy új vázlatot, és elmentjük logoexample.ino néven, majd az arduino ideában csalóként kattintsunk a Fájl menüre, majd mentsük el, menjünk vissza a projekt mappájába jobb gombbal és illesszük be a.c fájlba (pic2), majd kattintson a Mégse gombra, így nem kell böngésznie a mappába, amelyet be kell illesztenie a fájlba.

írja be a következő kódot az arduino IDE -be, vagy töltse le ino -ban.

(azt javasoljuk, hogy gépelés helyett másolja és illessze be, vagy használja az alábbi fájlokat, ez a legjobb módja a tanulásnak)

#include /* ez a tárolási helytől függően változhat

az ino általában a C mappában: / Users / ~ felhasználónév / Documents / Arduino / project ~ name

és így linkeljük a bitképünket */

#befoglalni

#befoglalni

uint8_t bmpX, bmpY = 0; /* tartalék memória 2 X 8 bites egész számokhoz, csak 8 bites intekre van szükségünk

mivel az érték soha nem haladja meg a 128 -at (képpont), így helyet spórolhatunk meg 8 bites (maximum 255) értékkel */

üres beállítás ()

{késleltetés (100); // a kijelzőnek stb. időt ad a kijelző bekapcsolásához.begin (SSD1306_SWITCHCAPVCC, 0x3C); // ez a kijelző inicializálása.clearDisplay (); // kezdje üres képernyővel}

/* Kérjük, vegye figyelembe, hogy ezeket a megjegyzéseket nem kell begépelni, mert csak hivatkozásként szolgálnak …………..

a parancs, amelyre összpontosítunk, a display.drawBitmap, ez rajzolja meg a kezdőképernyőt. (bmpX, az X tengely értéke a képernyőn, ahol a bitkép X rögzítési pontja lesz, és bmpX és bmpY azok az értékek, amelyek érdekelnek minket a mozgás létrehozásában (bmpY, az Y tengely értéke azon a képernyőn, ahol az Y horgony A bittérkép pontja az lesz, hogy megkapjuk a referencianeveket, ahogy azokat a logóban definiáltuk. c (LOGOPIC, a bitkép neve a #included fájl logójában. bittérkép a rögzítési pontból (LOGOHEIGHT, hány képponttal lefelé (Y) kell lehúzni a bitképet a rögzítési pontból, az X és Y képpontokat kézzel lehet megadni, de egyszerűbb használni az előre definiált képeket, mint emlékezni rájuk (1, az utolsó érték a szín, mivel a képernyő mono 0 fekete 1 fehér. Rendben, kezdje el a gépelést a következő sorból: ¬D lol*/ void loop () {display.clearDisplay (); // üres a képernyő // bittérkép bal felső sarok, x, y, bittérkép neve, szélesség X, Y magasság, színes kijelző.drawBitmap (bmpX, bmpY, LOGOPIC, LOGOWIDTH, LOGOHEIGHT, 1); display.display (); // ez valóban vonzza a puffert a kijelzőre valaha}

töltse fel az arduino kódját, és erősítse meg, hogy működik (3. kép).

5. lépés: Bitmap Sprite mozgatása

használja a korábbi utasításokat a paint.net használatával, és készítsen egy új fájlt 30x15 képpont méretűvé (pic1), és rajzoljon egy durva autót, amelyet fiatal tervezőnk először a szélvédővel kezd (2. és 3. kép).

mentse el újra Windows bmp fájlként (mint a 2. lépésben), konvertálja C bittérképbe (3. lépés), és helyezze el a car.c fájlt (vagy bármit is), ugyanabban a mappában, mint az újonnan létrehozott arduino ino (vázlat) fájlt.

(p.s. ne felejtse el hozzáadni az #include sort az autóhoz. c ez gyakran elkapott minket)

Először linkelje be az autó megfelelőjét. C

#befoglalni

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

Adafruit_SSD1306 kijelző (128, 64); // állítsa be a kijelző felbontását

/* bmpX/bmpY ezeknek változóknak kell lennünk, mivel megváltoztatjuk ezeket az értékeket és átrajzoljuk

mozgásanimációs hatást hozunk létre a képernyőn. hitSide és hitTop így tartjuk a sprite -t a képernyőn */ uint8_t bmpX, bmpY = 0; // tartalék memória 2 8 bites ints (0-255) nem kell nagyobb 128 lesz a legnagyobb szám használt bool hitSide = 0; bool hitTop = 0;

üres beállítás ()

{késleltetés (100); // a kijelzőnek stb. időt ad a kijelző bekapcsolásához.begin (SSD1306_SWITCHCAPVCC, 0x3C); // ez a kijelző inicializálása.clearDisplay (); // üres képernyővel kezdje

}

üres hurok ()

{display.clearDisplay (); // kiüríti a képernyőt // a bal felső részből rajzolt bitkép, x, y, bitkép neve, szélessége X, magasság Y, színes kijelző.drawBitmap (bmpX, bmpY, CARSPRITE, CARWIDTH, CARHEIGHT, 1); // display.display (); // ez valójában mindig vonzza a puffert a kijelzőre/ * így követjük nyomon a képernyő szélét, és eldöntjük, hogy hozzáadunk -e egy képpontot, hogy felülről lefelé mozogjunk), vagy eltávolítsunk egy képpontot (alulról felfelé) */ kapcsoló (hitSide) // ez a boole alapján választja ki az autó irányát {case 0: bmpX ++; szünet;

1. eset:

bmpX--; szünet; } // ez a 2 if utasítás állítja a bólt igazra vagy hamisra, ha (bmpX == 0) {hitSide = 0; } if (bmpX == 96) // a képernyő szélessége mínusz az autó {hitSide = 1; } // ugyanaz, mint fent az Y tengelyen, ha (bmpY == 0) {hitTop = 0; } if (bmpY == 49) // képernyőmagasság mínusz az autó magassága {hitTop = 1; } switch (hitTop) {case 0: bmpY ++; szünet; 1. eset: bmpY--; szünet; }

}

a mellékelt videóban láthatja a program működését

6. lépés: A vezetési játék elkészítése

Először is néhány különböző autót vagy akadályt rajzolunk, mint az oktatóanyag korábbi szakaszaiban, így 30x15 képpont méretűek. Ezután konvertáljuk őket c bittérképekké, és linkeljük be a kódot.

#include // ezeknek az útvonalaknak változniuk kell

// a fájlok tárolási helyén // szerkesztés: most tudtam meg, hogy ha lecseréled // a "" kifejezésre, akkor nem kell a teljes elérési út // // saját könyvtáraiddal #include

#befoglalni

#befoglalni #befoglalni

#befoglalni

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

Adafruit_SSD1306 kijelző (128, 64); // definiálja a megjelenítési paramétereket

határozza meg a változókat és a rögzített értékeket

// definiálja a bemeneti csapokat ezek az arduino érintkezői, amelyeket soha nem változtat DWNPIN 5 #define LFTPIN 6 #define RHTPIN 7 #define SND 9 // irányok meghatározása

#define DIRUP 1 // ezeket az értékeket nézi a "kígyó", hogy eldöntse, #define DIRDOWN 2 // a kígyó haladási iránya #define DIRLEFT 3 #define DIRRIGHT 4

uint8_t dirPressed = 0; // érték az irány regisztrálásához, hogy továbbléphessünk, melyik csap magasra került

// booleans tárolja, melyik tű magasra került

bool BUTUP = 0; bool BUTDWN = 0; bool BUTLFT = 0; bool BUTRHT = 0; // vars az autó helyzetére uint8_t carPosX = 1; uint8_t carPosY = {0, 16, 32, 48}; // értékre van szüksége a tömbben

uint8_t lanePosArr = {0, 16, 32, 48}; // tömb az egyes sávok tárolására

uint8_t carPosYCnt = 0; uint8_t carYTmp = 0; // az út vonalainak változói uint8_t roadLineX1 = 51; // ezek eleinte előre definiáltak, majd a sorok zökkenőmentesen jelennek meg uint8_t roadLineX2 = 102; uint8_t roadLineX3 = 153; uint8_t roadLineX4 = 254; uint8_t roadLineX5 = 200;

// ennyi pixel mozog egyszerre a játékterület

uint8_t drawSpeed = 4;

// vars az ellenségért0

uint8_t ellenség0PosX = 255; uint8_t ellenség0PosY = 0; uint8_t ellenség1PosX = 255; uint8_t ellenség1PosY = 0; uint8_t ellenség2PosX = 255; uint8_t ellenség2PosY = 0;

// változó véletlenszerűhez rendeljen sávszámot az akadályokhoz

uint8_t laneGen = 0;

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

// pontszámláló

hosszú pontszám = 0; // ez a pontszám:/ lol hosszú összehasonlítás = 0; // ez tárolja a pontszámot az utolsó szinten, hogy összehasonlítsuk a hosszú magas pontszámmal = 25; uint8_t metreCnt = 0;

itt kezdjük a függvényeket

// ez a parancskészlet, ha a megszakítás aktiválva van void interruptressed () {delay (150); updateDirection (); } // frissítse a var irányú értéket a DIR bools ellenőrzésével // -------------------------- UPDATE DIRECTION (lejátszó)- ------------------------- void updateDirection () {//Serial.println("updateDirection Called "); BUTUP = digitalRead (UPPIN); BUTDWN = digitalRead (DWNPIN); BUTLFT = digitalRead (LFTPIN); BUTRHT = digitalRead (RHTPIN); if (BUTUP == igaz) {dirPressed = DIRUP; } if (BUTDWN == true) {dirPressed = DIRDOWN; } if (BUTLFT == igaz) {dirPressed = DIRLEFT; } if (BUTRHT == igaz) {dirPressed = DIRRIGHT; }

}

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

// ez frissíti a képernyőt az autó sprite mozgatója számára

void moveCar ()

{switch (dirPressed) {case DIRUP: carPosYCnt--; carPosY [carPosYCnt]; hang (SND, 100, 100); if (carPosYCnt == 255) {carPosYCnt = 0; } carYTmp = carPosY [carPosYCnt]; dirPressed = 0; // Serial.println ("carPosY up"); // Serial.println (carPosYCnt); szünet; tok DIRDOWN: carPosYCnt ++; hang (SND, 100, 100); if (carPosYCnt == 4) {carPosYCnt = 3; } // Serial.println ("carPosY"); // Serial.println (carPosYCnt); carYTmp = carPosY [carPosYCnt]; dirPressed = 0; szünet; // megjegyezte, hogy a bal és jobb oldali ütközésérzékelő autó még nem olyan jó /* eset DIRLEFT: carPosX--; if (carPosX == 0) {carPosX = 1; } // Serial.println ("carPosX"); // Serial.println (carPosX); dirPressed = 0; szünet; */ tok DIRRIGHT: // csak szórakozásból, ha jobbra nyomod, a játék zajos hangot ad (SND, 100, 50); // carPosX ++; // if (carPosX == 128) // {// carPosX = 127; //} // Serial.println ("carPosX"); // Serial.println (carPosX); // dirPressed = 0; szünet; } updateDisplay (); }

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

uint8_t randomPosX () // ez a 2 rutin csak véletlenszerű pozíciót generál az akadályokhoz

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

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

uint8_t randomPosY ()

{uint8_t laneVal = 0; laneVal = véletlenszerű (0, 4); // adjon hozzá egy további sávot a véletlenszerűséghez, azaz ne legyen objektum a képernyőn, amíg az adott sávban van //Serial.println("RandomY "); //Serial.println(lanePosArr[laneVal]); return (lanePosArr [laneVal]); }// ------------------------------- JÁTÉK SEBESSÉG BEÁLLÍTÁSA -------------- -------------- void setGameSpeed () // ez megakadályozza, hogy a szint 20 fölé emelkedjen, így a játék nem játszható le {if (drawSpeed <21) {drawSpeed = drawSpeed+2; }}// ------------------------------------ DESECT CRASH ---------- ----------------------- void detectCrash () {

if (ellenség0PosX = 0 &&ellenség0PosY == autóYTmp)

{// Serial.println ("Játék CRAASSSSHHHHHHEEEEDDD -vel a Traffic 0 -ba"); játék vége(); } if (ellenség1PosX = 0 && ellenség1PosY == autóYTmp) {//Serial.println("Game Over CRAASSSSHHHHHHEEEEDDD a forgalomba 1 "); játék vége(); } if (ellenség2PosX = 0 && ellenség2PosY == autóTemp) {//Serial.println("Game Over CRAASSSSHHHHHHEEEEDDD a forgalomba 2 "); játék vége(); }}

ezek a rutinok rajzolják a kijelzőt.

// ------------------------------- DRAW ROAD --------------- --------------------- void drawRoad () // X, Y, length, width {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 ellenségek ---- --------------------------------------- void enemysDraw () {// X, Y, bmp név, szélesség, magasság, színes kijelző.drawBitmap (ellenség0PosX, ellenség0PosY, ENEMY0, ENEMY0_WIDTH, ENEMY0_HEIGHT, 1); ellenség0PosX = ellenség0PosX-drawSpeed; display.drawBitmap (ellenség1PosX, ellenség1PosY, ENEMY1, ENEMY1_WIDTH, ENEMY1_HEIGHT, 1); ellenség1PosX = ellenség1PosX-drawSpeed; display.drawBitmap (ellenség2PosX, ellenség2PosY, ENEMY2, ENEMY2_SZÉLESSÉG, ENEMY2_HEIGHT, 1); ellenség2PosX = ellenség2PosX-drawSpeed; display.display (); if (ellenség0PosX> 231 && ellenség0PosX231 && ellenség1PosX <255) {ellenség1PosX = véletlenszerűPosX (); ellenség1PosY = randomPosY (); checkDuplicate (); }

if (ellenség2PosX> 231 && ellenség2PosX <255) {ellenség2PosX = véletlenszerűPosX (); ellenség2PosY = randomPosY (); }} // ------------------------------------ UPDATE DISPLAY -------- ---------------------------------------- void updateDisplay () {display.clearDisplay (); display.drawBitmap (carPosX, carPosY [carPosYCnt], CARSPRITE, 30, 15, 1); display.fillRect (100, 0, 28, 10, FEKETE); display.setCursor (100, 0); display.setTextColor (FEHÉR, FEKETE); display.println (pontszám); display.display ();

}

// ------------------------- várja a sajtó ciklusát ------------------- ------

// ez a kezdőképernyő kódja void waitForPress () {splashScreen (); bool várakozás = 0; // a ciklus akkor fejeződik be, ha ez igaz display.clearDisplay (); amíg (várakozás == 0) {

display.fillRect (19, 20, 90, 32, FEKETE); // üres szövegháttér

display.setTextColor (FEHÉR); display.setCursor (23, 24); display.setTextSize (0); display.println ("Meggondolatlan"); display.setCursor (36, 34); display.println ("Racer"); display.drawBitmap (74, 24, CARSPRITE, CARWIDTH, CARHEIGHT, 1); // x y w h r col display.drawRoundRect (21, 21, 86, 23, 4, WHITE); // szegély Snake display.drawRect (19, 20, 90, 33, WHITE); // szegélydoboz - 3 display.setCursor (25, 43); display.setTextSize (0); // font vissza a normál kijelzőre.println ("nyomja meg bármelyik gombot"); display.fillRect (0, 0, 127, 8, FEKETE); display.setCursor (10, 0); display.print ("Magas pontszám:"); // a magas pontszámok megjelenítése. print (highScore); display.display (); várakozás = digitalRead (INTPIN); // ellenőrizze, hogy a várva lenyomott billentyű 1 -re végződik -e, míg dirPressed = 0; // reset gomb megnyomása semmilyen irányba}} // -------------------------------------- ----- UPDATE GAME ---------------------------------------- void updateGame () {moveCar (); drawRoad (); enemysDraw (); // ellenség1Draw (); // ellenség2Draw (); metreCnt ++; detectCrash (); if (metreCnt == 5) // minden 10 ciklushoz hozzáad egy pontot a pontszám növeléséhez {metreCnt = 0; pontszám ++; } if (pontszám == összehasonlítás+5) // 5 pontonként felgyorsítja a játékot, maximum 20 sebességre {összehasonlítás = pontszám; setGameSpeed (); } noTone (SND); updateDisplay ();

}

// ------------------------------ JÁTÉK VÉGE---------------- ------------------------------

// ez a rutin húzza a vonalakat a halott hős autó körül, majd megjeleníti a játékot a képernyőn

void gameOver ()

{hang (SND, 200, 200); // hang lejátszása uint8_t linePosX, linePosY, pixwidth, pixheight = 0; // beállítja a varsokat, hogy rajzoljon dobozokat az autóvonal körülPosX = carPosY; linePosY = carYTmp; pixwidth = 30; pixmagasság = 15; display.drawRect (linePosX, linePosY, pixwidth, pixheight, WHITE); display.display (); for (int i = 0; i <= 26; i ++) // ez robbantást szimuláló téglalapokban veszi körül az autót {linePosX = linePosX-2; linePosY = linePosY-2; pixwidth = pixwidth+4; pixmagasság = pixmagasság+4; display.drawRect (linePosX, linePosY, pixwidth, pixheight, BLACK); display.drawRect (linePosX, linePosY, pixwidth, pixheight, WHITE); display.display (); hang (SND, i*20, 50); késleltetés (10); } display.setTextSize (2); display.setTextColor (FEHÉR, FEKETE); display.setCursor (10, 23); hang (SND, 50, 500); display.print ("GAME"); display.display (); késleltetés (500); hang (SND, 40, 500); display.print ("OVER"); display.setTextSize (0); display.display (); késleltetés (3000); restartGame (); waitForPress (); }

// ----------------------------------------- RESTART JÁTÉK ----- -------------------------------------------------- -----

void restartGame () // ez másolja a magas pontszámot, és visszaállítja az összes statisztikát, és véletlenszerű pozíciókat generál

{if (score> = highScore) // ellenőrizze, hogy a pontszám magasabb -e a magas pontszámnál {highScore = score; // egyetlen, ha állítás a magas pontszám frissítésére}

pontszám = 0;

drawSpeed = 4; metreCnt = 0; carPosYCnt = 0; ellenség0PosX = randomPosX (); ellenség0PosY = randomPosY (); ellenség1PosX = randomPosX (); ellenség1PosY = randomPosY (); ellenség2PosX = randomPosX (); ellenség2PosY = randomPosY (); noTone (SND);

checkDuplicate ();

}

// ------------------------------------------------ -ELLENŐRIZZE A DUPLIKÁT ----------------------------------------------- ------ void checkDuplicate () // ezek ellenőrzik, hogy az akadályok elfoglalják-e ugyanazt a játékteret {// Serial.println ("duplicate check"); if (ellenség2PosX> 230 && ellenség2PosX <255) {while (ellenség2PosY == ellenség1PosY || ellenség2PoszY == ellenség0PoszY) {ellenség2PoszY = véletlenPozY (); }}

if (ellenség0PosX> 230 && ellenség0PosX230 && ellenség2PosXenemy1PosX && ellenség2PosX230 && ellenség0PosXenemy1PosX && ellenség0PosX

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

void splashScreen ()

{display.clearDisplay (); display.drawBitmap (0, 0, CRASH, CRASHWIDTH, CRASHHEIGHT, 1); display.display (); késleltetés (2000); } // ----------------------------------------------- BEÁLLÍT ------------------------------------------------- ----------- void setup () {delay (100); // hadd induljanak a dolgok // Serial.begin (9600); // kommentálja ezt és az összes sorozatot. parancsok a hiba diag display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay (); display.setTextColor (FEHÉR, FEKETE); display.setTextWrap (hamis); display.dim (0); pinMode (INTPIN, INPUT); pinMode (UPPIN, INPUT); pinMode (DWNPIN, INPUT); pinMode (LFTPIN, INPUT); pinMode (RHTPIN, INPUT);

attachInterrupt (digitalPinToInterrupt (INTPIN), megszakítva, RISING);

// véletlenszerűen elhelyezett akadályok ellenség0PosX = randomPosX (); ellenség0PosY = randomPosY (); ellenség1PosX = randomPosX (); ellenség1PosY = randomPosY (); ellenség2PosX = randomPosX (); ellenség2PosY = randomPosY (); checkDuplicate (); // ismétlődő helyek keresése // Serial.println ("telepítés kész"); splashScreen (); waitForPress (); } // ----------------------------------------------- ----- LOOP -------------------------------------------- ----------

üres hurok ()

{updateGame (); }

és nagyjából ennyi, minden módosítást és visszajelzést szívesen fogadunk. A képernyő villódzásával foglalkozó kérdésekben meg kell vizsgálnunk, hogyan csökkenthetjük azt, és az ellenséges autók még mindig képesek ugyanazt a helyet elfoglalni.