Arduino Ideen

Details: Kategorie: Arduino neue Ideen; Erstellt: 15. April 2026; Zugriffe: 20

Wer erinnert sich nicht an die klassischen Labyrinth-Spiele, bei denen man mit ruhiger Hand den Ausgang finden musste? Mit Labyrinth Runner bringen wir dieses zeitlose Spielprinzip auf den Arduino und eine 8x32 Neopixel-Matrix. Das Besondere: Das Labyrinth wird bei jedem Start und jedem Level-Up komplett neu generiert kein Durchgang ist wie der andere! Dank der vertikalen Ausrichtung und dem Zeitlimit ist Adrenalin pur garantiert.

Eines von 60 Highlights aus meiner Neopixel-Spielesammlung!

Das Spielprinzip

Labyrinth Runner ist ein taktisches Geschicklichkeitsspiel, das die volle Höhe der 32 Pixel nutzt. Du startest am oberen Rand und musst dich durch verschlungene Pfade zum blinkenden Ausgang am oberen Ende vorkämpfen. Doch Vorsicht: Die Zeit sitzt dir im Nacken! Ein schrumpfender Zeitbalken am rechten Displayrand zeigt dir unerbittlich an, wie lange du noch Zeit hast, den rettenden Ausgang zu erreichen. Erreichst du das Ziel, wird es sofort schwieriger und das Zeitlimit knapper.

Gameplay & Features

Das Spiel setzt auf eine saubere Pfad-Generierung und eine direkte Steuerung:

Das dynamische Labyrinth: Ein Algorithmus berechnet bei jedem Level ein neues Layout. Sackgassen und lange Umwege inklusive!
Die Orientierung: Grüner Pixel: Das bist du, der Runner.
- Dunkelblau/Violett: Die massiven Wände, die deinen Weg begrenzen.
- Blinkendes Gelb: Das Portal zum nächsten Level.
Der Zeitdruck: Am rechten Rand wandert ein grüner Balken nach unten. Wird er gelb oder gar rot, musst du dich beeilen!
Die Steuerung: Über den Joystick navigierst du flüssig durch die Gänge. Die Steuerung ist so programmiert, dass du auch "um die Ecke gleiten" kannst, ohne hängen zu bleiben.
Das Scoring: Gezählt werden die erfolgreich absolvierten Level. Nach einem Game Over leuchtet die Matrix dezent rot auf und zeigt dir deinen Rekord in weißer Schrift vertikal untereinander an.

Verdrahtung: Arduino, Neopixel und Joystick

Da das Labyrinth im Hintergrund komplex berechnet wird, ist ein Arduino R4 für einen flüssigen Aufbau des Irrgartens ideal.

Komponente	Pin am Arduino	Beschreibung
8x32 Matrix	D9	Dateneingang (DIN) – Hochkant aufgestellt
Joystick X	A0	Seitliche Bewegung im Labyrinth
Joystick Y	A1	Vorwärts & Rückwärts (hoch/runter)
Button A	D2	Start / Reset: Spiel beginnen
Button B	D3	Heller: (Nur im Startmenü)
Button C	D4	Abbruch: Zurück zum "GO"-Bildschirm
Button D	D5	Dunkler: (Nur im Startmenü)

Der Arduino Code mit FastLED

Der Code nutzt einen "Backtracking"-Algorithmus zur Labyrinth-Erzeugung. Ein technisches Highlight ist die Koordinaten-Drehung: Das Spiel berechnet das Labyrinth intern im Querformat, spiegelt es aber bei der Ausgabe für deine hochkant stehende Matrix um. So bleibt die Programmlogik einfach, während das Display optimal genutzt wird. Die Helligkeitssteuerung ist mit einem Sicherheits-Limit nach unten versehen, damit das dunkle Blau der Wände niemals komplett verschwindet.

Der Arduino Code für das Labyrinth Spiel

// www.kreativekiste.de // 15.04.2026 // Version 1.9
// LABYRINTH-RUNNER (Quer berechnet, Hochkant 8x32 gespielt)

#include <FastLED.h>

// --- KONFIGURATION ---
#define DATA_PIN 9
#define NUM_LEDS 256

int currentBrightness = 15;
#define MAX_BRIGHTNESS 60
#define MIN_BRIGHTNESS 10 // Untergrenze, damit das dunkle Labyrinth im Spiel sichtbar bleibt

// Pins (Dein standardisiertes Arcade Layout)
#define PIN_JOY_X A0
#define PIN_JOY_Y A1
#define PIN_BTN_A 2 // Start / Reset
#define PIN_BTN_B 3 // Heller im GO-Screen
#define PIN_BTN_C 4 // Im Spiel: Zurück zu GO
#define PIN_BTN_D 5 // Dunkler im GO-Screen

CRGB leds[NUM_LEDS];

// --- SPIEL-FARBEN ---
const CRGB COLOR_WALL   = CRGB(15, 0, 40);   
const CRGB COLOR_PLAYER = CRGB(0, 255, 0);   
const CRGB COLOR_EXIT   = CRGB(255, 200, 0); 
const CRGB COLOR_SCORE  = CRGB::White; 

// --- SPIEL-STATUS ---
enum GameState { START, PLAYING, GAMEOVER_RED, GAMEOVER_SCORE };
GameState currentState = START;

// --- DATEN ---
bool walls[32][7]; 
int playerX, playerY;
int exitX = 31, exitY = 5;

int currentLevel = 1;
unsigned long timeLimit = 30000; 
unsigned long levelStartTime = 0;

unsigned long lastMoveTime = 0;
const int moveCooldown = 130; 

// ================================================================== Hilfsfunktionen Matrix

// 1. Physische Matrix (8x32 Hochkant) - Wird für Menüs und UI verwendet
void setPhysLed(int physX, int physY, CRGB color) {
  if (physX < 0 || physX >= 8 || physY < 0 || physY >= 32) return;
  
  int flippedY = 31 - physY; 
  int idx;
  
  // Standard-Serpentine 8x32
  if (flippedY % 2 == 0) idx = (flippedY * 8) + physX;
  else                   idx = (flippedY * 8) + (7 - physX);
  
  leds[idx] = color;
}

// 2. Logische Matrix (32x8 Quer) - Wird vom Spiel für das Labyrinth genutzt
void setPixel(int logicalX, int logicalY, CRGB color) {
  if (logicalX < 0 || logicalX >= 32 || logicalY < 0 || logicalY >= 8) return;
  // Der Trick: X und Y werden getauscht, damit das Quer-Spiel Hochkant erscheint
  setPhysLed(logicalY, logicalX, color); 
}

// ================================================================== UI & Text Funktionen
void drawDigit(int num, int offsetX, int offsetY, CRGB color) {
  const uint16_t digits[10] = {
    0x7B6F, 0x2492, 0x73E7, 0x73CF, 0x5BC9, 0x79CF, 0x79EF, 0x7249, 0x7BEF, 0x7B8F
  };
  for (int i = 0; i < 15; i++) {
    if (digits[num] & (1 << (14 - i))) {
      int px = offsetX + (i % 3);
      // py erhöht sich jetzt, damit die Zahl von oben nach unten (stehend) gezeichnet wird
      int py = offsetY + (i / 3); 
      setPhysLed(px, py, color);
    }
  }
}

void displayScoreVertically() {
  int h = (currentLevel / 100) % 10;
  int t = (currentLevel / 10) % 10;
  int u = currentLevel % 10;
  
  // Hunderter oben (kleines Y), Zehner Mitte, Einer unten (großes Y)
  drawDigit(h, 2, 5, COLOR_SCORE);
  drawDigit(t, 2, 13, COLOR_SCORE);
  drawDigit(u, 2, 21, COLOR_SCORE);
}

void drawGO(int y) {
  // 'G' - manuell gesetzt für perfekte Ausrichtung
  setPhysLed(1, y, CRGB::Yellow); setPhysLed(2, y, CRGB::Yellow); setPhysLed(3, y, CRGB::Yellow); 
  setPhysLed(1, y+1, CRGB::Yellow); 
  setPhysLed(1, y+2, CRGB::Yellow); setPhysLed(2, y+2, CRGB::Yellow); setPhysLed(3, y+2, CRGB::Yellow); 
  setPhysLed(1, y+3, CRGB::Yellow); setPhysLed(3, y+3, CRGB::Yellow); 
  setPhysLed(1, y+4, CRGB::Yellow); setPhysLed(2, y+4, CRGB::Yellow); setPhysLed(3, y+4, CRGB::Yellow); 

  // 'O' - Symmetrisch
  setPhysLed(5, y, CRGB::Yellow); setPhysLed(6, y, CRGB::Yellow); setPhysLed(7, y, CRGB::Yellow);
  setPhysLed(5, y+1, CRGB::Yellow); setPhysLed(7, y+1, CRGB::Yellow);
  setPhysLed(5, y+2, CRGB::Yellow); setPhysLed(7, y+2, CRGB::Yellow);
  setPhysLed(5, y+3, CRGB::Yellow); setPhysLed(7, y+3, CRGB::Yellow);
  setPhysLed(5, y+4, CRGB::Yellow); setPhysLed(6, y+4, CRGB::Yellow); setPhysLed(7, y+4, CRGB::Yellow);
}

// ================================================================== Labyrinth Generierung
void generateMaze() {
  for (int x = 0; x < 32; x++) {
    for (int y = 0; y < 7; y++) walls[x][y] = true;
  }
  int sx = 1, sy = 1; walls[sx][sy] = false;
  int stackX[60], stackY[60], sp = 0;
  stackX[sp] = sx; stackY[sp] = sy; sp++;

  while (sp > 0) {
    int cx = stackX[sp - 1], cy = stackY[sp - 1];
    int dirs[4] = {0, 1, 2, 3};
    for (int i = 0; i < 4; i++) { int r = random(4); int temp = dirs[i]; dirs[i] = dirs[r]; dirs[r] = temp; }
    bool moved = false;
    for (int i = 0; i < 4; i++) {
      int nx = cx, ny = cy;
      if (dirs[i] == 0) ny -= 2; else if (dirs[i] == 1) nx += 2; else if (dirs[i] == 2) ny += 2; else if (dirs[i] == 3) nx -= 2;
      if (nx > 0 && nx < 31 && ny > 0 && ny < 7 && walls[nx][ny]) {
        walls[nx][ny] = false; walls[cx + (nx - cx) / 2][cy + (ny - cy) / 2] = false;
        stackX[sp] = nx; stackY[sp] = ny; sp++; moved = true; break;
      }
    }
    if (!moved) sp--;
  }
  walls[0][1] = false; walls[30][5] = false; walls[31][5] = false;
}

// ================================================================== Zeichenfunktion Spiel
void drawGame() {
  FastLED.clear();
  
  // Labyrinth zeichnen
  for (int x = 0; x < 32; x++) {
    for (int y = 0; y < 7; y++) { 
      if (walls[x][y]) setPixel(x, y, COLOR_WALL); 
    }
  }
  
  // Ausgang blinken lassen
  if ((millis() / 200) % 2 == 0) setPixel(exitX, exitY, COLOR_EXIT);
  
  // Spieler
  setPixel(playerX, playerY, COLOR_PLAYER);

  // Zeitbalken am rechten Rand (Nur anzeigen, wenn das Spiel läuft)
  if (currentState == PLAYING) {
    unsigned long elapsed = millis() - levelStartTime;
    int timeLeft = timeLimit - elapsed;
    if (timeLeft > 0) {
      int barLength = map(timeLeft, 0, timeLimit, 0, 32);
      CRGB barColor = (timeLeft > timeLimit / 2) ? CRGB::Green : (timeLeft > timeLimit / 4 ? CRGB::Yellow : CRGB::Red);
      for (int x = 0; x < barLength; x++) setPixel(x, 7, barColor);
    }
  }
}

// ================================================================== Start Screen
void handleStartScreen() {
  FastLED.clear();
  drawGO(14); 
  FastLED.show(); 
  
  if (digitalRead(PIN_BTN_B) == LOW) { 
    currentBrightness = min(MAX_BRIGHTNESS, currentBrightness + 2); 
    FastLED.setBrightness(currentBrightness); delay(30); 
  }
  if (digitalRead(PIN_BTN_D) == LOW) { 
    currentBrightness = max(MIN_BRIGHTNESS, currentBrightness - 2); 
    FastLED.setBrightness(currentBrightness); delay(30); 
  }
  if (digitalRead(PIN_BTN_A) == LOW) { 
    initGame(); 
    delay(200); 
  }
}

// ================================================================== Spielablauf Logik
void initGame() {
  currentLevel = 1;
  timeLimit = 30000;
  generateMaze();
  playerX = 0; 
  playerY = 1;
  levelStartTime = millis();
  currentState = PLAYING;
}

void updateGame() {
  unsigned long currentTime = millis();
  
  // Timeout - Game Over Check
  if (currentTime - levelStartTime >= timeLimit) {
    currentState = GAMEOVER_RED;
    return;
  }

  // Bewegung
  if (currentTime - lastMoveTime > moveCooldown) {
    int joyX = analogRead(PIN_JOY_X);
    int joyY = analogRead(PIN_JOY_Y);
    int dx = 0, dy = 0;

    // Joystick Y (Hoch/Runter) steuert die lange Achse (Logisch X)
    if (joyY < 400) dx = 1;       // Vorwärts
    else if (joyY > 600) dx = -1; // Rückwärts

    // Joystick X (Links/Rechts) steuert die kurze Achse (Logisch Y)
    if (joyX < 400) dy = -1;      // Links
    else if (joyX > 600) dy = 1;  // Rechts

    if (dx != 0 || dy != 0) {
      bool moved = false;
      // Slide-Logik (Erlaubt flüssiges Um-die-Ecke-gehen)
      if (dx != 0 && playerX+dx >= 0 && playerX+dx <= 31 && !walls[playerX+dx][playerY]) {
        playerX += dx; moved = true;
      } else if (dy != 0 && playerY+dy >= 0 && playerY+dy <= 6 && !walls[playerX][playerY+dy]) {
        playerY += dy; moved = true;
      }
      if (moved) lastMoveTime = currentTime;
    }
  }

  // Ziel erreicht (Level Up)
  if (playerX == exitX && playerY == exitY) {
    fill_solid(leds, NUM_LEDS, CRGB(0, 20, 0)); 
    FastLED.show(); 
    delay(500);
    currentLevel++;
    timeLimit = max(8000UL, timeLimit - 2000); 
    generateMaze(); playerX = 0; playerY = 1;
    levelStartTime = millis();
  }
}

// ================================================================== Hauptschleife
void setup() {
  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
  
  pinMode(PIN_BTN_A, INPUT_PULLUP);
  pinMode(PIN_BTN_B, INPUT_PULLUP);
  pinMode(PIN_BTN_C, INPUT_PULLUP);
  pinMode(PIN_BTN_D, INPUT_PULLUP);
  
  randomSeed(analogRead(A5));
  FastLED.setBrightness(currentBrightness);
}

void loop() {
  switch (currentState) {
    case START:
      handleStartScreen();
      break;

    case PLAYING:
      if (digitalRead(PIN_BTN_C) == LOW) { 
        currentState = START; 
        delay(200); 
        break; 
      }
      updateGame();
      if (currentState == PLAYING) {
        drawGame();
        FastLED.show();
      }
      break;

    case GAMEOVER_RED:
      fill_solid(leds, NUM_LEDS, CRGB(20, 0, 0)); 
      FastLED.show(); 
      delay(1000);
      currentState = GAMEOVER_SCORE;
      break;

    case GAMEOVER_SCORE:
      FastLED.clear();
      displayScoreVertically();
      FastLED.show();
      
      if (digitalRead(PIN_BTN_A) == LOW) {
        currentState = START;
        delay(200);
      }
      break;
  }
  delay(15);
}

Kontakt

Ronnie

schwäbischer tüftler und bastler, kraftsportler, neurodivers, 45 Jahre, 1 Frau, 5 Kinder und 1003 Ideen.