Reckless Racer Arduino OLED-Spiel, AdafruitGFX und Bitmaps-Grundlagen - Gunook

2025 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2025-01-23 12:52

In diesem Tutorial werden wir uns ansehen, wie man Bitmaps mit der Adafruit_GFX.c-Bibliothek als eine Art Sprite in einem Spiel verwendet. Das einfachste Spiel, das wir uns vorstellen können, ist ein Side-Scrolling-Spurwechsel-Autospiel, am Ende entschied sich unser Betatester und Codierer für "Reckless Racer" als Namen, da es ziemlich rücksichtslos ist, die Autobahn in die falsche Richtung zu fahren!!

Das Design unserer Schaltung ist in den Bildern oben enthalten und wird in unserem letzten Projekt / Tutorial hier Snake Instructables beschrieben, in dem beschrieben wird, wie die Schaltung funktioniert.

wir werden benötigen

Adafruit_GFX

Paint.net

Arduino IDE windowslinux

und werfen Sie einen Blick auf das Snake-Tutorial für die restliche Ausrüstung.

Lieferungen

Schlangenspiel

Schritt 1: Paint.net installieren

Wir verwenden paint.net, da die Software kostenlos ist. Sie können Paint. Net hier also völlig kostenlos herunterladen.

Um paint.net zu installieren, doppelklicken Sie auf das heruntergeladene Programm und antworten Sie als nächstes positiv, ja, ok, ich stimme zu und die obigen Bilder geben Ihnen eine Wegbeschreibung.

Schritt 2: Zeichnen eines einfachen Begrüßungsbildschirms

Wenn Sie sich in Paint.net befinden, erstellen Sie ein neues Bild, indem Sie auf Datei und dann auf Neu klicken. Stellen Sie die Bildgröße auf 1260 x 620 (siehe erstes Bild) Werkzeug (Bild2), Wenn Sie Ihr Begrüßungsbildschirmbild gezeichnet (oder eingefügt) haben, klicken Sie auf das Bild, dann ändern Sie die Größe (Bild4). Ändern Sie im Popup die Größe von 1260x620 auf 126x62 (2 Pixel kleiner als Ihr Display) (Bild5) Klicken Sie auf OK.

Klicken Sie als nächstes auf das Menü Datei und speichern Sie unter (Bild6).

Wenn das Popup im Dropdown-Menü für den Dateityp angezeigt wird, wählen Sie BMP (Bitmap). (Bild7), geben Sie einen Dateinamen ein und klicken Sie auf Speichern. Wenn das Popup erscheint, setzen Sie Dithering auf 0 und setzen Sie auf 8 Bit, klicken Sie auf OK).

Schritt 3: Konvertieren von BMP in eine C-Bitmap-Datei

Jetzt müssen wir unser Bild in ein Format umwandeln, das das Arduino verstehen kann.

marlinfw.org/tools/u8glib/converter.html

Also starten wir diesen Abschnitt, indem wir den obigen Link verwenden, um die Website zu öffnen, die in pic1 gezeigt ist

Klicken Sie auf Datei auswählen und wählen Sie die zuvor erstellte Bitmap aus (Bild2)

Marlin Bitmap Converter konvertiert Ihr Bild automatisch in C-Code. Doppelklicken Sie mit der linken Maustaste auf den Code, der den Code hervorheben soll, klicken Sie dann mit der rechten Maustaste und klicken Sie auf Kopieren (Bild3)

weiter Wir erstellen Rechtsklick und erstellen ein neues Textdokument (Bild4)

Doppelklicken Sie auf das neue Dokument, klicken Sie beim Öffnen mit der rechten Maustaste und fügen Sie den Code ein (Bild5)

Als nächstes müssen wir die Zeile am oberen Rand des Codes hinzufügen #include Dies ermöglicht es uns, die Bitmap-Daten im Flash-Speicher des Arduino zu speichern, dann benennen wir die #define width, height und name in etwas einfacher zu verwendendes um. Diese werden hervorgehoben auf Bild 6, wir benennen sie aus den zufällig generierten Zeichen um. Wir benennen sie in das unterstrichene Beispiel unten um

#define LOGOWIDTH

#LOGOHÖHE definieren

const unsigned char LOGOPIC PROGMEM

Als nächstes Datei anklicken, dann speichern unter, Datei als logo.c speichern Notepad schließen, Rechtsklick auf logo.c und auf Kopieren klicken.

Schritt 4: Anzeigen eines LOGOs mit DrawBitmap

Jetzt laden wir die arduino IDE und erstellen eine neue Skizze und speichern sie mit dem Namen logoexample.ino, als nächstes als Cheat in der arduino ide klicken Sie auf das Dateimenü, dann speichern unter, gehen Sie zurück zum Projektordner, klicken Sie mit der rechten Maustaste und fügen Sie die.c-Datei ein (Bild2) Klicken Sie dann auf Abbrechen. Dies erspart Ihnen das Durchsuchen des Ordners, um die Datei einzufügen.

Geben Sie den folgenden Code in die Arduino-IDE ein oder laden Sie in ino herunter.

(wir empfehlen, eher zu tippen als zu kopieren und einzufügen oder die folgenden Dateien zu verwenden, um es am besten zu lernen)

#include /* Dies hängt davon ab, wo Sie speichern

das ino normalerweise im Ordner C:\Users\~username\Documents\Arduino\project~name

und so verlinken wir zu unserer Bitmap */

#enthalten

#enthalten

uint8_t bmpX, bmpY=0; /* Speicher für 2 X 8-Bit-Integer reservieren, wir brauchen nur 8-Bit-Integer

Da der Wert nie höher als 128 (Pixel) ist, können wir mit 8-Bit-Ints (mit einem maximalen Wert von 255) Platz sparen */

Void-Setup ()

{ Verzögerung (100); // Anzeige usw. Zeit zum Einschalten geben display.begin (SSD1306_SWITCHCAPVCC, 0x3C); // Dies dient der Initialisierung der Anzeige display.clearDisplay(); // starte mit einem leeren Bildschirm }

/* Bitte beachten Sie, dass Sie diese Kommentare nicht eingeben müssen, sie dienen als Referenz…………..

Der Befehl, auf den wir uns konzentrieren werden, ist display.drawBitmap, der unseren Begrüßungsbildschirm zeichnet. (bmpX, ist der X-Achsen-Wert auf dem Bildschirm, wo der X-Ankerpunkt der Bitmap sein wird und bmpX und bmpY sind die Werte, an denen wir interessiert sind, um Bewegung zu erzeugen (bmpY, ist der Y-Achsen-Wert auf dem Bildschirm, wo der Y-Anker Punkt der Bitmap werden wir die Referenznamen erhalten, wie wir sie in logo.c definiert haben (LOGOPIC, ist der Name der Bitmap in der #included-Datei logo.c (LOGOWIDTH, ist die Anzahl der Pixel über (X), um die zu zeichnen Bitmap vom Ankerpunkt (LOGOHEIGHT, ist wie viele Pixel nach unten (Y) um die Bitmap vom Ankerpunkt zu zeichnen die X- und Y-Pixel können manuell eingegeben werden, aber es ist einfacher, die vordefinierten zu verwenden, als sich alle zu merken (1, der letzte Wert ist die Farbe, da der Bildschirm mono ist 0 schwarz 1 weiß Okay beginne mit der Eingabe ab der nächsten Zeile:¬D lol*/ void loop() { display.clearDisplay(); // leere den Bildschirm // Bitmap aus dem oben links, x, y, Name der Bitmap, Breite X, Höhe Y, Farbe display.drawBitmap(bmpX, bmpY, LOGOPIC, LOGOWIDTH, LOGOHEIGHT, 1); display.display(); // dies zieht den Puffer tatsächlich immer zur Anzeige }

Laden Sie Ihren Arduino-Code hoch und bestätigen Sie, dass er funktioniert (Bild3).

Schritt 5: Verschieben eines Bitmap-Sprites

Verwenden Sie die früheren Anweisungen, verwenden Sie paint.net und erstellen Sie eine neue Datei, erstellen Sie 30x15 Pixel (Bild1) und zeichnen Sie ein grobes Auto. Unser junger Designer beginnt zuerst mit der Windschutzscheibe (Bilder 2 und 3).

Speichern Sie es erneut als Windows-BMP-Datei (wie in Schritt 2), konvertieren Sie es in eine C-Bitmap (Schritt 3) und legen Sie die Datei car.c (oder was auch immer Sie sich entscheiden) im selben Ordner wie ein neu erstelltes Arduino-Ino (Skizze) ab Datei.

(ps. denken Sie daran, die #include-Zeile in car.c hinzuzufügen, die uns oft erwischt hat)

Verlinken Sie zuerst Ihr Äquivalent zu car.c

#enthalten

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

Adafruit_SSD1306-Anzeige (128, 64); // die Auflösung des Displays einstellen

/* bmpX/bmpY wir brauchen diese Variablen, um diese Werte zu ändern und neu zu zeichnen

der Bildschirm ist, wie wir Bewegungsanimationseffekte erzeugen. hitSide und hitTop halten Sprite im Bildschirm */ uint8_t bmpX, bmpY=0; // Speicher für 2 8-Bit-Ints (0-255) reservieren wir brauchen nicht größer 128 wird die größte Anzahl verwendet bool hitSide=0; bool hitTop=0;

Void-Setup ()

{ Verzögerung (100); // Anzeige usw. Zeit zum Einschalten geben display.begin (SSD1306_SWITCHCAPVCC, 0x3C); // Dies dient der Initialisierung des Displays display.clearDisplay(); // mit einem leeren Bildschirm beginnen

}

Leere Schleife ()

{display.clearDisplay(); // Bildschirm leeren // Bitmap von oben links gezeichnet, x, y, Name der Bitmap, Breite X, Höhe Y, Farbe display.drawBitmap(bmpX, bmpY, CARSPRITE, CARWIDTH, CARHEIGHT, 1); // display.display(); // dies zieht den Puffer tatsächlich immer auf die Anzeige /* so verfolgen wir den Rand des Bildschirms und entscheiden, ob wir ein Pixel hinzufügen, von oben nach unten verschieben) oder ein Pixel entfernen (von unten nach oben verschieben) */ switch (hitSide.)) // dies wählt die Richtung des Autos basierend auf dem booleschen Wert { case 0: bmpX++; brechen;

Fall 1:

bmpX--; brechen; } // diese 2 if-Anweisungen setzen den bool auf true oder false if(bmpX==0) { hitSide=0; } if(bmpX==96) // die Breite des Bildschirms minus das Auto { hitSide=1; } // wie oben für die Y-Achse if(bmpY==0) { hitTop=0; aufrechtzuerhalten. If (bmpY==49) // Bildschirmhöhe minus Autohöhe { hitTop = 1; } Schalter (hitTop) { Fall 0: bmpY++; brechen; Fall 1: bmpY--; brechen; }

}

Sie können sehen, wie das Programm im angehängten Video funktioniert

Schritt 6: Erstellen des Fahrspiels

Zuerst beginnen wir damit, ein paar verschiedene Autos oder Hindernisse zu zeichnen, wie in den früheren Phasen des Tutorials, und machen sie 30x15 Pixel. Dann konvertieren wir sie in c-Bitmaps und verlinken sie im Code.

#include // diese Pfade müssen sich abhängig ändern

// wo Sie die Dateien speichern //bearbeiten: Ich habe gerade herausgefunden, dass Sie // durch " " ersetzen, Sie nicht den vollständigen Pfad benötigen //mit Ihren eigenen Bibliotheken #include

#enthalten

#einschließen #einschließen

#enthalten

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

Adafruit_SSD1306-Anzeige (128, 64); // Definiere die Anzeigeparameter

Definieren Sie die Variablen und Festwerte

// Eingangspins definieren Dies sind die Pins auf dem Arduino, die sich nie ändern DWNPIN 5 #define LFTPIN 6 #define RHTPIN 7 #define SND 9 // Richtungen definieren

#define DIRUP 1 // nach diesen Werten sucht die "Schlange" um zu entscheiden-

#define DIRDOWN 2 // die Richtung, in die sich die Schlange bewegt #define DIRLEFT 3 #define DIRRIGHT 4

uint8_t dirPressed =0; // Wert, um die Richtung zu registrieren, um sich zu bewegen, auf welchem Pin hoch gegangen ist

// Boolesche Werte speichern, welcher Pin hoch gegangen ist

bool BUTUP =0; bool BUTDWN=0; bool BUTLFT=0; bool BUTRHT=0; // vars für die Position des Autos uint8_t carPosX=1; uint8_t carPosY ={0, 16, 32, 48}; // benötigt Wertänderung des Arrays

uint8_t LanePosArr={0, 16, 32, 48}; // Array zum Speichern, wo jede Spur ist

uint8_t carPosYCnt =0; uint8_t carYTmp=0; // Variablen für die Linien in der Straße uint8_t roadLineX1=51; // diese sind am anfang vordefiniert dann erscheinen die linien fugenlos uint8_t roadLineX2=102; uint8_t roadLineX3=153; uint8_t roadLineX4=254; uint8_t roadLineX5=200;

// so viele Pixel bewegt sich der Spielbereich gleichzeitig

uint8_t drawSpeed = 4;

// Vars für Feind0

uint8_t Feind0PosX=255; uint8_t Feind0PosY=0; uint8_t Feind1PosX=255; uint8_t Feind1PosY=0; uint8_t Feind2PosX=255; uint8_t Feind2PosY=0;

// Variable auf zufällige Weise Hindernissen eine Spurnummer zuordnen

uint8_t LaneGen=0;

uint8_t LaneGen0=0; uint8_t LaneGen1=0; uint8_t SpurGen2=0;

// Punktezähler

lange Punktzahl = 0; // das ist die Punktzahl:/ lol long vergleichen=0; // dies speichert die Punktzahl auf der letzten Stufe, um sie mit long zu vergleichen highScore=25; uint8_t meterCnt=0;

hier starten wir die Funktionen

// Dies ist der Satz von Befehlen, wenn der Interrupt aktiviert ist Void interrupttressed () { delay (150); updateDirection(); } // aktualisiere, welcher Wert in Richtung var liegt, indem du die DIR-Bools prüfst //------------------------- UPDATE DIRECTION (player) - -------------------------- void updateDirection() { //Serial.println("updateDirection Called"); ABER = 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; }

}

//------------------------------ AUTO BEWEGEN --------------- --------------------------

// dies aktualisiert den Bildschirm der Mover das Auto-Sprite

void moveCar()

{ switch (dirPressed) { case DIRUP: carPosYCnt--; carPosY[carPosYCnt]; Ton (SND, 100, 100); wenn (carPosYCnt ==255) {carPosYCnt=0; } carYTmp=carPosY[carPosYCnt]; dirPressed=0; // Serial.println ("carPosY up"); // Serial.println (carPosYCnt); brechen; case DIRDOWN: carPosYCnt++; Ton (SND, 100, 100); if (carPosYCnt==4) { carPosYCnt=3; } // Serial.println ("carPosY"); // Serial.println (carPosYCnt); carYTmp=carPosY[carPosYCnt]; dirPressed=0; brechen; // auskommentiertes Auto kann sich nach links und rechts bewegen Kollisionserkennung noch nicht so gut /* case DIRLEFT: carPosX--; if (carPosX==0) { carPosX=1; } // Serial.println ("carPosX"); // Serial.println (carPosX); dirPressed=0; brechen; */ case DIRRIGHT: // nur zum Spaß, wenn du rechts drückst, macht das Spiel einen Geräuschton (SND, 100, 50); // carPosX++; // wenn (carPosX==128) // { // carPosX=127; //} // Serial.println ("carPosX"); // Serial.println (carPosX); // dirPressed=0; brechen; } updateDisplay(); }

//-------------------------- ZUFÄLLIGE POS X ------------------- ------------

uint8_t randomPosX() // diese 2 Routinen generieren nur zufällige Positionen für die Hindernisse

{ uint8_t posValTmp=0; posValTmp = zufällig (129, 230); //Seriell.println("zufälliges x"); //Seriell.println(posValTmp); return(posValTmp); }

//--------------------------- ZUFÄLLIGE POS Y------------------ ------------------

uint8_t randomPosY()

{ uint8_t LaneVal = 0; LaneVal = zufällig (0, 4); // fügen Sie eine zusätzliche Spur für den Zufall hinzu, dh kein Objekt auf dem Bildschirm, während Sie sich in dieser Spur befinden //Serial.println("RandomY"); //Serial.println (LanePosArr[LaneVal]); return(spurPosArr[spurVal]); }//------------------------------- SPIELGESCHWINDIGKEIT EINSTELLEN------------- -------------- void setGameSpeed() // Dies verhindert, dass das Level höher als 20 wird und das Spiel unspielbar wird {if (drawSpeed <21) { drawSpeed = drawSpeed + 2; } }// ------------------------------------ ABSTURZ ERKENNEN---------- ----------------------- void DetectCrash() {

if(enemy0PosX=0&&enemy0PosY==carYTmp)

{//Serial.println ("Spiel über CRAASSSSHHHHHHHEEEDDD in Verkehr 0"); Spiel ist aus(); } if(enemy1PosX=0&&enemy1PosY==carYTmp) {//Serial.println("Game Over CRAASSSSHHHHHHHEEEDDD in Verkehr 1"); Spiel ist aus(); } if(enemy2PosX=0&&enemy2PosY==carYTmp) {//Serial.println("Game Over CRAASSSSHHHHHHHEEEDDD in Verkehr 2"); Spiel ist aus(); } }

Dies sind die Routinen, die die Anzeige zeichnen.

//------------------------------ STRASSE ZEICHNEN--------------- --------------------- void drawRoad() // X, Y, Länge, Breite { display.fillRect(roadLineX1, 15, 30, 4, WHITE); display.fillRect(roadLineX1, 30, 30, 4, WEISS); display.fillRect(roadLineX1, 45, 30, 4, WEISS); display.fillRect(roadLineX2, 15, 30, 4, WEISS); display.fillRect(roadLineX2, 30, 30, 4, WEISS); display.fillRect(roadLineX2, 45, 30, 4, WEISS); display.fillRect(roadLineX3, 15, 30, 4, WEISS); display.fillRect(roadLineX3, 30, 30, 4, WEISS); display.fillRect(roadLineX3, 45, 30, 4, WEISS); display.fillRect(roadLineX4, 15, 30, 4, WEISS); display.fillRect(roadLineX4, 30, 30, 4, WEISS); display.fillRect(roadLineX4, 45, 30, 4, WEISS); display.fillRect(roadLineX5, 15, 30, 4, WEISS); display.fillRect(roadLineX5, 30, 30, 4, WEISS); display.fillRect(roadLineX5, 45, 30, 4, WEISS);

roadLineX1=roadLineX1-drawSpeed;

roadLineX2=roadLineX2-drawSpeed; roadLineX3=roadLineX3-drawGeschwindigkeit; roadLineX4=roadLineX4-drawGeschwindigkeit; roadLineX5=roadLineX5-drawSpeed; display.display(); } //-------------------------------------------- Feinde ziehen ---- --------------------------------------- void FeindesDraw() { // X, Y, bmp-Name, Breite, Höhe, Farbe display.drawBitmap(enemy0PosX, Feind0PosY, ENEMY0, ENEMY0_WIDTH, ENEMY0_HEIGHT, 1); Feind0PosX=enemy0PosX-drawSpeed; display.drawBitmap(enemy1PosX, Feind1PosY, ENEMY1, ENEMY1_WIDTH, ENEMY1_HEIGHT, 1); Feind1PosX=enemy1PosX-drawSpeed; display.drawBitmap(enemy2PosX, Feind2PosY, ENEMY2, ENEMY2_WIDTH, ENEMY2_HEIGHT, 1); Feind2PosX=enemy2PosX-DrawSpeed; display.display(); if(enemy0PosX>231&&enemy0PosX231&&enemy1PosX<255) { Feind1PosX=randomPosX(); Feind1PosY=randomPosY(); checkDuplicate(); }

if(enemy2PosX>231&&enemy2PosX<255) { Feind2PosX=randomPosX(); Feind2PosY=randomPosY(); } } //------------------------------------------------ ANZEIGE AKTUALISIEREN-------- ---------------------------------------- void updateDisplay() { display.clearDisplay(); display.drawBitmap(carPosX, carPosY[carPosYCnt], CARSPRITE, 30, 15, 1); display.fillRect(100, 0, 28, 10, SCHWARZ); display.setCursor(100, 0); display.setTextColor (WEISS, SCHWARZ); display.println (Score); display.display();

}

//-------------------------wartet auf Pressen-Schleife ------------------- ------

// Dies ist der Startbildschirmcode void waitForPress() { splashScreen(); bool warten=0; // Schleife endet, wenn dies wahr ist display.clearDisplay(); während(wartet==0) {

display.fillRect(19, 20, 90, 32, SCHWARZ); // leerer Hintergrund für Text

display.setTextColor (WEISS); display.setCursor(23, 24); display.setTextSize(0); display.println("rücksichtslos"); 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, WEISS); // Rahmen Schlange display.drawRect(19, 20, 90, 33, WEISS); // Rahmenbox - 3 display.setCursor(25, 43); display.setTextSize(0); // Schriftart zurück zum normalen display.println("beliebige Taste drücken"); display.fillRect(0, 0, 127, 8, SCHWARZ); display.setCursor(10, 0); display.print("Highscore:"); // den Highscore anzeigen display.print(highScore); display.display(); warten = digitalRead (INTPIN); // Überprüfen Sie, ob die gedrückte Taste beim Warten auf 1 endet, während dirPressed=0; // Reset-Taste in keine Richtung drücken } } //-------------------------------------- -----UPDATE GAME----------------------------------------------------- void updateGame () {MoveCar(); drawRoad(); FeindeDraw(); //enemy1Draw(); // Feind2Draw(); meterCnt++; DetectCrash(); if(metreCnt==5) // fügt alle 10 Zyklen einen Punkt hinzu, um die Punktzahl zu erhöhen { meterCnt=0; Punktzahl++; } if(score==compare+5) // Beschleunigt das Spiel alle 5 Punkte auf maximal 20 speed {vergleiche=score; setGameSpeed(); } kein Ton (SND); updateDisplay();

}

// ------------------------------ SPIEL IST AUS---------------- ------------------------------------------

// Diese Routine zeichnet die Linien um das tote Heldenauto und zeigt dann das Spiel über dem Bildschirm an

void gameOver()

{ Ton (SND, 200, 200); // Ton abspielen uint8_t linePosX, linePosY, pixwidth, pixheight=0; // setze vars um Kästchen um das Auto zu zeichnen linePosX=carPosY; linePosY=carYTmp; Pixelbreite = 30; Pixelhöhe = 15; display.drawRect(linePosX, linePosY, Pixelbreite, Pixelhöhe, WEISS); display.display(); for(int i=0;i<=26;i++) // dies umgibt das Auto in Rechtecken, die eine Explosion simulieren { linePosX=linePosX-2; linePosY=linePosY-2; Pixelbreite = Pixelbreite + 4; Pixelhöhe = Pixelhöhe + 4; display.drawRect(linePosX, linePosY, pixwidth, pixheight, BLACK); display.drawRect(linePosX, linePosY, Pixelbreite, Pixelhöhe, WEISS); display.display(); Ton (SND, i*20, 50); Verzögerung(10); } display.setTextSize(2); display.setTextColor (WEISS, SCHWARZ); display.setCursor(10, 23); Ton (SND, 50, 500); display.print("SPIEL"); display.display(); Verzögerung (500); Ton (SND, 40, 500); display.print("ÜBER"); display.setTextSize(0); display.display(); Verzögerung (3000); Spiel neustarten(); waitForPress(); }

// ----------------------------------------- SPIEL NEUSTARTEN ----- -------------------------------------------------- -----

void restartGame() // Dies kopiert den Highscore und setzt alle Statistiken zurück und generiert zufällige Positionen

{ if(score>=highScore) //Überprüfen, ob die Punktzahl höher als die hohe Punktzahl ist { highScore=score; //Single if-Statement zum Aktualisieren des Highscores}

Punktzahl = 0;

DrawSpeed=4; MeterCnt=0; carPosYCnt=0; Feind0PosX=zufälligPosX(); Feind0PosY=randomPosY(); Feind1PosX=zufälligPosX(); Feind1PosY=randomPosY(); Feind2PosX=zufälligPosX(); Feind2PosY=randomPosY(); kein Ton (SND);

checkDuplicate();

}

//------------------------------------------------ - DUPLIKAT PRÜFEN---------------------------------------------------------- ------ Void checkDuplicate () // Diese prüfen, ob Hindernisse den gleichen Spielraum belegen {// Serial.println ("Duplikat geprüft"); if(enemy2PosX>230&&enemy2PosX<255) { while(enemy2PosY==enemy1PosY||enemy2PosY==enemy0PosY) { Feind2PosY=randomPosY(); } }

if(enemy0PosX>230&&enemy0PosX230&&enemy2PosXenemy1PosX&&enemy2PosX230&&enemy0PosXenemy1PosX&&enemy0PosX

//------------------------------------------- BEGRÜSSUNGSBILDSCHIRM --- --------------------------------

void splashScreen()

{display.clearDisplay(); display.drawBitmap(0, 0, ABSTURZ, CRASHWIDTH, CRASHHEIGHT, 1); display.display(); Verzögerung (2000); } //----------------------------------------------------------- ERSTELLEN ------------------------------------------------- ------------ Void setup () { Verzögerung (100); // lassen Sie die Dinge starten // Serial.begin (9600); // Entkommentieren Sie dies und alle Serial. Befehle für die Fehlerdiagnose display.begin(SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay(); display.setTextColor (WEISS, SCHWARZ); display.setTextWrap(false); display.dim(0); pinMode (INTPIN, EINGANG); pinMode (UPPIN, EINGANG); pinMode (DWNPIN, EINGANG); pinMode (LFTPIN, EINGANG); pinMode (RHTPIN, EINGANG);

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

// Hindernisse zufällig platzieren Feind0PosX=randomPosX(); Feind0PosY=randomPosY(); Feind1PosX=zufälligPosX(); Feind1PosY=randomPosY(); Feind2PosX=zufälligPosX(); Feind2PosY=randomPosY(); checkDuplicate(); // auf doppelte Speicherorte prüfen // Serial.println ("setup Complete"); Begrüßungsbildschirm(); waitForPress(); } //----------------------------------------------------------- ----- SCHLEIFE -------------------------------------------------------- ----------

Leere Schleife ()

{ updateGame(); }

und das war's so ziemlich alles, alle Änderungen und Rückmeldungen sind willkommen. Probleme, die wir beheben müssen, um Bildschirmflimmern zu beheben, müssen wir untersuchen, wie wir es verringern können, und die feindlichen Autos können immer noch denselben Platz einnehmen.