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 gibttrueoderfalsezurü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.

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:
- 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. Eindelay(60)ginge hier nicht: Während einer solchen Pause tut das Programm nichts anderes, und ein kurzer Druck ginge verloren. - Richtung festhalten.
lastDirmerkt sich die Richtung des letzten Schritts. Die Bedingungen wielastDir != LEFTverhindern, dass die Schlange direkt rückwärts in sich selbst läuft. - Zusammenstoß prüfen. Liefert
crash()den Werttrue, zeigt das Programm den Punktestand, wartet auf einen Druck in die Mitte und verlässt die Schleife mitbreak. Damit endetplay(), und die Schleife insetup()startet die nächste Runde. - Bewegen. Sonst rückt die Position
px,pyein Feld weiter. - Apfel prüfen. Steht auf dem neuen Feld -1, piept es, ein neuer Apfel erscheint, und
lenwächst um 1. - Kopf setzen. Das neue Feld bekommt den Wert
len. - Zeichnen und altern.
draw()zeigt das Spielfeld, danach ziehtstep()von allen Körperteilen 1 ab.
Anmerkungen
- Die ganze Spiellogik steht in
setup(), nicht inloop(): Diewhile (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. EinrandomSeed(micros());am Anfang vonsetup()ä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, istpy == 14wahr, und das Feldboard[px][15], das es gar nicht gibt, wird nicht mehr gelesen. writeScore()zerlegt den Punktestand in Ziffern:score % 10liefert die letzte Ziffer,score /= 10entfernt sie.itoa()wandelt die Ziffer in Text um, damit sich ihre Breite mitgetStrWidth()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
lenbegrenzt, nicht durch das Array: Ihr Körper besteht immer aus den Feldern mit Werten von 1 bislen.
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 auslen. - 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.