Arduino

Beispielprojekt – Snake

Ein vollständiges Spiel, gebaut aus allem, was du im Tutorial gelernt hast.

Alles zusammen

Zum Abschluss ein vollständiges Spiel: Snake. Darin steckt alles, was du in diesem Tutorial gelernt hast – Variablen, Verzweigungen, Schleifen, ein zweidimensionales Array als Spielfeld und eine ganze Reihe eigener Funktionen.

Lies den Quelltext nicht von vorn bis hinten, sondern funktionsweise. Jede Funktion erledigt eine Aufgabe:

  • initialize() – setzt Punktestand, Länge und Startposition und leert das Spielfeld.
  • putApple() – sucht ein freies Feld und legt dort einen Apfel ab (als Wert -1).
  • crash(dir) – prüft, ob der nächste Schritt in eine Wand oder in den eigenen Körper führt, und gibt true oder false zurück.
  • draw() – zeichnet Rahmen, Schlange und Apfel aus dem Array auf das Display.
  • step() – zieht von jedem Körperteil 1 ab, sodass das Ende der Schlange nachrückt.
  • writeScore() – schreibt den Punktestand seitlich neben das Spielfeld.
  • play() – eine Runde: Eingaben lesen, laufen, Apfel fressen, zeichnen, bis es knallt.

Das Spielfeld von Snake als Zahlenraster: Der Kopf trägt die größte Zahl, der Körper kleinere, der Apfel die -1, leere Felder die 0. Bei jedem Schritt wird jede Zahl um eins kleiner.
Der Trick steckt im Spielfeld board: Jedes Feld merkt sich eine Zahl. 0 heißt leer, -1 ist der Apfel, und jede positive Zahl ist ein Stück der Schlange. Der Kopf trägt dabei den größten Wert. Weil step() alle Werte um 1 verkleinert, verschwindet das Schwanzende von selbst, sobald es die 0 erreicht – so bewegt sich die Schlange, ohne dass das Programm ihre Form speichern muss.

Das Display wird hier mit U8G2_R3 hochkant genutzt: 64 Pixel breit, 128 Pixel hoch. Deshalb sind in draw() die beiden Koordinaten vertauscht. Du hältst den PicoBoy dabei trotzdem ganz normal quer, nur das Programm rechnet hochkant. Der erste Index von board zählt auf dem Display von links nach rechts, der zweite von unten nach oben. Deshalb erhöht ein Schritt nach oben den Wert py. Auch die Schrift muss mitgedreht werden, das erledigt setFontDirection(1) in setup().

#include <U8g2lib.h>
#include <SPI.h>

#define LEDR 5
#define LEDY 6
#define LEDG 7
#define SPEAKER 15

#define KEY_RIGHT 2
#define KEY_DOWN 3
#define KEY_LEFT 4
#define KEY_UP 1
#define KEY_CENTER 0

#define UP 1  // die vier Richtungen der Schlange
#define DOWN 2
#define LEFT 3
#define RIGHT 4

U8G2_SH1106_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R3, 10, 8, 9);

int board[28][15];  // 0 leer, -1 Apfel, größer als 0: Schlange
int score, len, direction, px, py;

void setup(void) {
  u8g2.begin();

  u8g2.setContrast(31);  // Display dimmen
  u8g2.clearBuffer();
  u8g2.sendBuffer();

  pinMode(KEY_RIGHT, INPUT_PULLUP);
  pinMode(KEY_DOWN, INPUT_PULLUP);
  pinMode(KEY_LEFT, INPUT_PULLUP);
  pinMode(KEY_UP, INPUT_PULLUP);
  pinMode(KEY_CENTER, INPUT_PULLUP);

  pinMode(SPEAKER, OUTPUT);
  pinMode(LEDR, OUTPUT);
  pinMode(LEDG, OUTPUT);
  pinMode(LEDY, OUTPUT);
  u8g2.setFont(u8g2_font_smart_patrol_nbp_tr);
  u8g2.setFontDirection(1);  // Schrift mitdrehen
  while (true) {  // eine Runde nach der anderen
    initialize();
    play();
  }
}

void putApple() {  // freies Feld suchen, Apfel ablegen
  int rx = random(0, 28);
  int ry = random(0, 15);

  while (board[rx][ry] != 0) {  // besetzt? Neu auslosen
    rx = random(0, 28);
    ry = random(0, 15);
  }
  board[rx][ry] = -1;  // -1 ist der Apfel
}

void initialize() {  // alles für eine neue Runde vorbereiten
  score = 0;
  len = 3;
  px = 13;
  py = 8;

  for (int ix = 0; ix < 28; ix++) {
    for (int iy = 0; iy < 15; iy++) {
      board[ix][iy] = 0;
    }
  }
}

void writeScore(int score) {  // Punktestand neben das Spielfeld schreiben
  u8g2.setFont(u8g2_font_4x6_mr);
  u8g2.setCursor(57, 119);
  u8g2.println("SC");
  u8g2.setCursor(51, 119);
  u8g2.println("OR");
  u8g2.setCursor(45, 121);
  u8g2.println("E");
  u8g2.setFont(u8g2_font_smart_patrol_nbp_tr);
  int ypos = 0;
  for (int i = 0; i < 4; i++) {
    int digit = score % 10;  // letzte Ziffer
    score /= 10;             // letzte Ziffer entfernen
    char cstr[16];
    itoa(digit, cstr, 10);   // Ziffer in Text wandeln
    u8g2.setCursor(ypos, 122 - u8g2.getStrWidth(cstr) / 2);
    u8g2.println(cstr);
    ypos += 11;
  }
}

void draw() {  // Rahmen, Schlange und Apfel zeichnen
  u8g2.clearBuffer();
  u8g2.drawFrame(0, 0, 64, 116);
  for (int ix = 0; ix < 28; ix++) {
    for (int iy = 0; iy < 15; iy++) {
      if (board[ix][iy] > 0) {                         // ein Stück der Schlange
        u8g2.drawFrame(iy * 4 + 2, ix * 4 + 2, 4, 4);
        if (board[ix][iy] == len) {                    // der Kopf mit Punkt
          u8g2.drawFrame(iy * 4 + 3, ix * 4 + 3, 2, 2);
        }
      } else if (board[ix][iy] == -1) {                // der Apfel
        u8g2.drawFrame(iy * 4 + 2, ix * 4 + 3, 4, 2);
        u8g2.drawFrame(iy * 4 + 3, ix * 4 + 2, 2, 4);
      }
    }
  }
  writeScore(len - 3);  // jeder Apfel ist ein Punkt
  u8g2.sendBuffer();
}

bool crash(int dir) {  // führt der nächste Schritt in Wand oder Körper?
  if (dir == UP && (py == 14 || board[px][py + 1] > 0)) {
    return true;
  }

  if (dir == DOWN && (py == 0 || board[px][py - 1] > 0)) {
    return true;
  }

  if (dir == LEFT && (px == 0 || board[px - 1][py] > 0)) {
    return true;
  }

  if (dir == RIGHT && (px == 27 || board[px + 1][py] > 0)) {
    return true;
  }

  return false;
}

void step() {  // jedes Stück der Schlange um 1 verkleinern
  for (int ix = 0; ix < 28; ix++) {
    for (int iy = 0; iy < 15; iy++) {
      if (board[ix][iy] > 0) {
        board[ix][iy] = board[ix][iy] - 1;
      }
    }
  }
}

void play() {  // eine Runde, bis die Schlange anstößt
  uint32_t lastTime = 0;
  int lastDir = 0;
  direction = random(1, 5);
  putApple();

  while (true) {
    while (millis() < lastTime + 60) {  // 60 ms lang auf Eingaben warten
      if (digitalRead(KEY_RIGHT) == LOW && lastDir != LEFT) {
        direction = RIGHT;
      }
      if (digitalRead(KEY_LEFT) == LOW && lastDir != RIGHT) {
        direction = LEFT;
      }
      if (digitalRead(KEY_DOWN) == LOW && lastDir != UP) {
        direction = DOWN;
      }
      if (digitalRead(KEY_UP) == LOW && lastDir != DOWN) {
        direction = UP;
      }
    }

    lastDir = direction;  // Richtung dieses Schritts merken

    if (!crash(direction)) {  // kein Zusammenstoß: ein Feld weiter
      if (direction == LEFT) {
        px--;
      }
      if (direction == RIGHT) {
        px++;
      }
      if (direction == DOWN) {
        py--;
      }
      if (direction == UP) {
        py++;
      }
    } else {  // Zusammenstoß: Punktestand zeigen
      u8g2.setDrawColor(0);         // mit Schwarz ...
      u8g2.drawBox(1, 1, 62, 114);  // ... das Spielfeld löschen
      u8g2.setDrawColor(1);         // wieder weiß zeichnen

      u8g2.setCursor(40, 58 - u8g2.getStrWidth("YOUR") / 2);
      u8g2.println("YOUR");
      u8g2.setCursor(25, 58 - u8g2.getStrWidth("SCORE") / 2);
      u8g2.println("SCORE");
      char cstr[16];
      itoa(len - 3, cstr, 10);
      u8g2.setCursor(10, 58 - u8g2.getStrWidth(cstr) / 2);
      u8g2.println(cstr);
      u8g2.sendBuffer();
      delay(250);

      while (digitalRead(KEY_CENTER) == HIGH) {}  // auf die Mitte warten
      break;  // Schleife verlassen, damit endet play()
    }

    if (board[px][py] == -1) {   // Apfel gefressen
      tone(SPEAKER, 6500, 10);   // kurzer Piep
      putApple();
      len++;                     // die Schlange wird länger
    }

    board[px][py] = len;         // neuer Kopf

    draw();
    step();

    lastTime = millis();
  }
}

void loop() {}

Ein Schritt in play(), der Reihe nach

Die große Schleife in play() steuert das Spiel. Jeder Durchlauf ist ein Schritt der Schlange:

  1. Warten und Joystick lesen. Die innere while-Schleife läuft 60 Millisekunden lang und fragt dabei ständig den Joystick ab. millis() liefert die Zeit in Millisekunden seit dem Start. Ein delay(60) ginge hier nicht: Während einer solchen Pause tut das Programm nichts anderes, und ein kurzer Druck ginge verloren.
  2. Richtung festhalten. lastDir merkt sich die Richtung des letzten Schritts. Die Bedingungen wie lastDir != LEFT verhindern, dass die Schlange direkt rückwärts in sich selbst läuft.
  3. Zusammenstoß prüfen. Liefert crash() den Wert true, zeigt das Programm den Punktestand, wartet auf einen Druck in die Mitte und verlässt die Schleife mit break. Damit endet play(), und die Schleife in setup() startet die nächste Runde.
  4. Bewegen. Sonst rückt die Position px, py ein Feld weiter.
  5. Apfel prüfen. Steht auf dem neuen Feld -1, piept es, ein neuer Apfel erscheint, und len wächst um 1.
  6. Kopf setzen. Das neue Feld bekommt den Wert len.
  7. Zeichnen und altern. draw() zeigt das Spielfeld, danach zieht step() von allen Körperteilen 1 ab.

Anmerkungen

  • Die ganze Spiellogik steht in setup(), nicht in loop(): Die while (true)-Schleife dort startet nach jedem verlorenen Spiel die nächste Runde. loop() bleibt deshalb leer.
  • random() liefert nach jedem Einschalten dieselbe Zahlenfolge, weil der Zufallsgenerator immer gleich startet. Die Äpfel liegen also nach jedem Einschalten wieder an denselben Stellen. Ein randomSeed(micros()); am Anfang von setup() ändert das.
  • In crash() ist die Reihenfolge wichtig. || prüft von links nach rechts und hört auf, sobald das Ergebnis feststeht. Steht die Schlange am oberen Rand, ist py == 14 wahr, und das Feld board[px][15], das es gar nicht gibt, wird nicht mehr gelesen.
  • writeScore() zerlegt den Punktestand in Ziffern: score % 10 liefert die letzte Ziffer, score /= 10 entfernt sie. itoa() wandelt die Ziffer in Text um, damit sich ihre Breite mit getStrWidth() messen lässt.
  • u8g2.setContrast(31) dimmt das Display. Stelle den Wert höher (bis 255), wenn es dir zu dunkel ist.
  • Die Schlange ist durch len begrenzt, nicht durch das Array: Ihr Körper besteht immer aus den Feldern mit Werten von 1 bis len.

Ideen zum Weiterbauen

  • Lass die LEDs mitspielen – sie sind im Programm schon als Ausgänge eingerichtet, werden aber nie benutzt. Zum Beispiel ein kurzes Aufblitzen beim Apfel oder rot beim Verlieren.
  • Mach das Spiel schneller, je länger die Schlange wird. Die 60 in play() ist die Wartezeit pro Schritt – rechne sie aus len.
  • Speichere den höchsten Punktestand und zeige ihn auf dem Startbildschirm an.
  • Baue einen zweiten Apfel ein, der nach einigen Sekunden wieder verschwindet.

Ton und Sensor in eigenen Programmen

Zwei Bauteile kamen im Tutorial bisher kaum vor: der Lautsprecher und der Beschleunigungssensor.

tone(SPEAKER, 6500, 10) aus dem Spiel erzeugt einen Ton. Die drei Angaben sind der Pin, die Tonhöhe in Hertz und die Dauer in Millisekunden. tone() wartet nicht, bis der Ton zu Ende ist, das Programm läuft sofort weiter. Für mehrere Töne nacheinander brauchst du deshalb ein delay():

tone(SPEAKER, 440, 200);    // 440 Hertz, 200 Millisekunden lang
delay(250);                 // tone() wartet nicht, das übernimmt delay()
tone(SPEAKER, 660, 200);
delay(250);

Lässt du die Dauer weg, läuft der Ton, bis du noTone(SPEAKER) aufrufst.

Für den Sensor liegt im gExample die Datei STK8BA58.h. Kopiere sie in den Ordner deines Programms. Sie stellt die Befehle xAccG(), yAccG() und zAccG() bereit, die die Beschleunigung in g liefern. xAcc(), yAcc() und zAcc() liefern sie in m/s². Das folgende Programm lässt ein Quadrat der Neigung folgen:

#include <U8g2lib.h>
#include <SPI.h>
#include "STK8BA58.h"  // liegt im selben Ordner wie das Programm

U8G2_SH1106_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, 10, 8, 9);
STK8BA58 sensor;  // Das Objekt sensor steht für den Beschleunigungssensor

int xPos = 60;
int yPos = 28;

void setup(void) {
  u8g2.begin();
  sensor.init();                           // Verbindung zum Sensor starten
}

void loop() {
  xPos = xPos + int(sensor.xAccG() * 4);   // stärkere Neigung, größerer Schritt
  yPos = yPos + int(sensor.yAccG() * 4);
  xPos = constrain(xPos, 0, 120);          // xPos bleibt zwischen 0 und 120
  yPos = constrain(yPos, 0, 56);           // yPos bleibt zwischen 0 und 56

  u8g2.clearBuffer();
  u8g2.drawBox(xPos, yPos, 8, 8);
  u8g2.sendBuffer();
  delay(30);
}

int(…) macht aus der Kommazahl eine ganze Zahl, sodass kleine Neigungen zu 0 werden und das Quadrat in Ruhe bleibt. constrain() begrenzt einen Wert auf einen Bereich. Was der Sensor genau misst, erklärt das Kapitel Kippen und Piepsen aus dem MicroPython-Tutorial. Die Achsen sind dieselben.

Als Ausgangspunkt für eigene Projekte eignet sich die Vorlage, in der alle Anschlüsse bereits festgelegt sind. Willst du den Beschleunigungssensor nutzen, findest du im gExample ein fertiges Beispiel. Weitere Quelltexte liegen auf GitHub.