Arduino Ideen

Details: Kategorie: Arduino neue Ideen; Erstellt: 11. April 2026; Zugriffe: 7

Schluss mit endlos scrollenden Welten! Bei Matrix Escape hast du echtes, actiongeladenes Level-Design auf dem Arduino. Jeder Bildschirm ist ein neuer, tückischer Raum voller Gefahren. Deine Aufgabe: Finde den richtigen Weg über die Berge, springe über brodelnde Vulkane und tiefe Gewässer. Aber trödel nicht zu lange eine zerstörerische Laser-Wand ist dir dicht auf den Pixel Fersen!

Eines von 60 Highlights aus meiner Neopixel-Spielesammlung!

Das Spielprinzip

Du steuerst deinen Charakter völlig frei durch abgeschlossene 32-Pixel-Räume. Die Berglandschaft wird für jedes Level zufällig neu generiert. Sobald du den rechten Rand erreichst, betrittst du (auf der linken Seite) das nächste Level. Doch Vorsicht: Von links nähert sich unaufhaltsam eine rote Laser-Wand, die die komplette Landschaft hinter dir verdampft. Berührt sie dich, heißt es Game Over!

Gameplay & Features

Level by Level: Keine scrollende Map. Du hast die volle Kontrolle über deine Laufgeschwindigkeit. Du steuerst deinen Pixel frei nach links und rechts, um Anlauf für schwere Sprünge zu nehmen.
Zusammenhängende Berglandschaft: Die grüne Landschaft wächst nahtlos aus dem Boden. Du musst von Plateau zu Plateau springen und dir deinen Weg bahnen.
Fatale Vulkane: Zwischen den Bergen ragen braune Vulkane empor. Diese spucken in zufälligen Abständen 3 Pixel hohes Feuer! Du musst den Rhythmus studieren und genau in der Pause darüber springen.
Tödliche Wasserstellen: Ein falscher Schritt und du landest im kühlen Nass. Fällst du in eine der blauen, animierten Wassergruben, ertrinkst du sofort.
Die rote Gefahr: Du hast nicht unendlich Zeit! Der rote Laser zwingt dich zur Eile. Mit jedem geschafften Level und sogar mit jeder Sekunde im aktuellen Raum wird der Laser minimal schneller!
Joystick-Jumps: Wie bei einem echten Jump 'n' Run springst du, indem du den Joystick nach oben drückst (kurz = flach, halten = weiter Sprung).

Verdrahtung: Arduino, Matrix und Joystickshield

Komponente	Pin am Arduino	Beschreibung
8x32 Matrix	D9	Dateneingang (DIN)
Joystick X-Achse	A0	Frei Laufen (Links / Rechts)
Joystick Y-Achse	A1	Springen (Nach oben drücken für Sprungkraft)
Button B	D3	Start / Neustart nach Game Over
Stromversorgung	5V / GND	Wichtig: Externes Netzteil verwenden, da hier fast das ganze Display leuchtet!

Der Arduino Code für das Escape Spiel

// www.kreativekiste.de // 11.04.2026 // Version 1.5
// MATRIX ESCAPE 8x32: Optischer Fix (Lücke in Reihe 7 behoben)

#include <FastLED.h>

// --- KONFIGURATION ---
const int DATA_PIN = 9;
const int NUM_LEDS = 256; 
const int BRIGHTNESS_GAME = 5; 
const int BRIGHTNESS_MENU = 10;  

const int WIDTH = 32;
const int HEIGHT = 8;
CRGB leds[NUM_LEDS];

// Pins 
const int PIN_JOY_X = A0;    
const int PIN_JOY_Y = A1;    
const int PIN_BTN_B = 3;     

// --- SPIEL-LOGIK ---
enum GameState { START, PLAYING, GAME_OVER };
GameState currentState = START;

float pX = 0; 
float pY = 5.0; 
float pVelY = 0;
bool isJumping = false;

// Physik
const float gravityNormal = 0.28; 
const float gravityLow = 0.08;    
const float jumpPower = -1.15;    
const float moveSpeed = 0.35;

int score = 0;
float laserX = -5.0;
float laserSpeed = 0.044; 

// --- LANDSCHAFT ---
int terrainH[WIDTH]; 
int currentGround[WIDTH]; 
bool isVolcano[WIDTH]; 
bool volcanoFiring[WIDTH]; 
unsigned long volcanoNextToggle[WIDTH]; 
bool isWater[WIDTH]; 

// --- MATRIX HILFSFUNKTIONEN ---
int getIndex(int x, int y) {
  if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) return -1;
  if (x % 2 == 0) return (x * HEIGHT) + y;
  else return (x * HEIGHT) + (HEIGHT - 1 - y);
}

void setSafeLed(int x, int y, CRGB color) {
  int idx = getIndex(x, y);
  if (idx != -1) leds[idx] = color;
}

// --- ZAHLEN-DISPLAY ---
void drawDigit(int num, int x, int y, 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))) {
      setSafeLed(x + (i % 3), y + (i / 3), color);
    }
  }
}

void displayScore() {
  FastLED.clear();
  int tens = (score / 10) % 10;
  int units = score % 10;
  drawDigit(tens, 12, 1, CRGB::White);
  drawDigit(units, 16, 1, CRGB::White);
}

// --- SPIEL-FUNKTIONEN ---

void spawnLevel() {
  pX = 0; 
  pY = 5.0;
  pVelY = 0;
  isJumping = false;
  
  laserX = -6.0;
  laserSpeed = 0.044 + (score * 0.005); 

  for(int x=0; x<WIDTH; x++) {
    terrainH[x] = 0;
    isVolcano[x] = false;
    volcanoFiring[x] = false;
    isWater[x] = false;
  }

  int currentH = 0;
  int x = 4;
  while(x < WIDTH) {
    int stepW = random(1, 4); 
    int stepH = random(0, 7); 
    if (stepH - currentH > 3) stepH = currentH + 3;
    
    for(int i=0; i<stepW && x < WIDTH; i++) {
      terrainH[x] = stepH;
      x++;
    }
    currentH = stepH;
  }

  // Vulkane platzieren
  int volcanosToPlace = random(0, 4);
  int placed = 0;
  int attempts = 0;
  
  while (placed < volcanosToPlace && attempts < 50) {
    int vx = random(6, WIDTH - 2); 
    if (!isVolcano[vx] && terrainH[vx] <= 3 && terrainH[vx] > 0) {
      isVolcano[vx] = true;
      
      volcanoFiring[vx] = (random(2) == 0); 
      unsigned long currentMillis = millis();
      if (volcanoFiring[vx]) {
        volcanoNextToggle[vx] = currentMillis + random(1000, 2001); 
      } else {
        volcanoNextToggle[vx] = currentMillis + random(500, 2001);  
      }
      placed++;
    }
    attempts++;
  }

  // Wasserstellen platzieren
  int waterToPlace = random(1, 4);
  placed = 0;
  attempts = 0;
  
  while (placed < waterToPlace && attempts < 50) {
    int wx = random(6, WIDTH - 3); 
    int wWidth = random(1, 3); 
    
    bool canPlace = true;
    for(int i=0; i<wWidth; i++) {
      if (isVolcano[wx+i] || isWater[wx+i] || terrainH[wx+i] > 1) canPlace = false;
    }
    
    if (canPlace) {
      for(int i=0; i<wWidth; i++) {
        isWater[wx+i] = true;
        terrainH[wx+i] = -1; 
      }
      placed++;
    }
    attempts++;
  }
}

void initGame() {
  score = 0;
  spawnLevel();
  currentState = PLAYING;
  FastLED.setBrightness(BRIGHTNESS_GAME);
}

void drawWorld() {
  for(int x=0; x<WIDTH; x++) {
    
    if (isWater[x]) {
      CRGB waterCol = ((millis() / 400 + x) % 2 == 0) ? CRGB(0, 0, 255) : CRGB(0, 150, 255);
      setSafeLed(x, 7, waterCol);
    } else {
      int h = terrainH[x];
      
      // Helleres Braun für Vulkane, Grün für Berge
      CRGB rockColor = isVolcano[x] ? CRGB(120, 50, 0) : CRGB::Green;
      
      // FIX: Die allerunterste Zeile (Y=7) jetzt IMMER in der Felsfarbe zeichnen!
      setSafeLed(x, 7, rockColor); 
      
      for(int y=0; y<h; y++) {
        setSafeLed(x, 6 - y, rockColor); 
      }

      // Feuer
      if (isVolcano[x]) {
        int cg = 7 - h; 
        if (volcanoFiring[x]) {
          for(int fy=1; fy<=3; fy++) {
            CRGB fireColor = (random(10) > 3) ? CRGB::Red : CRGB(255, 80, 0);
            setSafeLed(x, cg - fy, fireColor);
          }
        } else {
          setSafeLed(x, cg - 1, CRGB(40, 0, 0)); 
        }
      }
    }
  }

  int lx = round(laserX);
  if(lx >= 0 && lx < WIDTH) {
    for(int y=0; y<HEIGHT; y++) setSafeLed(lx, y, CRGB(150, 0, 0));
  }
}

void updatePhysics() {
  unsigned long currentMillis = millis();

  // 1. VULKAN-TIMER
  for(int x=0; x<WIDTH; x++) {
    if (isVolcano[x]) {
      if (currentMillis >= volcanoNextToggle[x]) {
        volcanoFiring[x] = !volcanoFiring[x]; 
        if (volcanoFiring[x]) {
          volcanoNextToggle[x] = currentMillis + random(1000, 2001); 
        } else {
          volcanoNextToggle[x] = currentMillis + random(500, 2001);  
        }
      }
    }
  }

  // 2. LASER
  laserSpeed += 0.00005; 
  laserX += laserSpeed;
  
  int lx_int = round(laserX);
  if (lx_int >= 0 && lx_int < WIDTH) {
    for(int x=0; x<=lx_int; x++) {
      terrainH[x] = 0; 
      isVolcano[x] = false; 
      isWater[x] = false; 
    }
  }

  if (round(pX) <= lx_int) {
    currentState = GAME_OVER; 
    return;
  }

  // 3. KOLLISIONS-BODEN 
  for(int x=0; x<WIDTH; x++) {
    currentGround[x] = 7 - terrainH[x]; 
  }

  // 4. HORIZONTALES LAUFEN
  int joyX = analogRead(PIN_JOY_X);
  if (joyX > 600) {
    int nextX = round(pX + moveSpeed);
    if (nextX < WIDTH) {
      if (round(pY) + 1 < currentGround[nextX]) {
        pX += moveSpeed;
      } else {
        pX = round(pX); 
      }
    } else {
      score++;
      spawnLevel();
      return; 
    }
  }
  if (joyX < 400) {
    int nextX = round(pX - moveSpeed);
    if (nextX >= 0) {
      if (round(pY) + 1 < currentGround[nextX]) {
        pX -= moveSpeed;
      } else {
        pX = round(pX); 
      }
    }
  }

  // 5. SPRINGEN & SCHWERKRAFT
  int joyY = analogRead(PIN_JOY_Y);
  bool jumpInput = (joyY > 600); 
  
  int pX_int = round(pX);
  bool onGround = (round(pY) + 1 >= currentGround[pX_int] - 1);

  if (jumpInput && onGround && !isJumping) {
    pVelY = jumpPower;
    isJumping = true;
  }

  if (jumpInput && pVelY < 0) pVelY += gravityLow; 
  else pVelY += gravityNormal;

  pY += pVelY;

  // 6. BODEN-KOLLISION (Y-Achse)
  pX_int = round(pX); 
  if (round(pY) + 1 >= currentGround[pX_int] - 1) {
    pY = currentGround[pX_int] - 2; 
    pVelY = 0;
    isJumping = false;
  }

  // 7. FEUER-KOLLISION
  if (isVolcano[pX_int] && volcanoFiring[pX_int]) {
    int cg = currentGround[pX_int]; 
    int playerTop = round(pY);
    int playerBottom = round(pY) + 1;
    if (playerBottom >= cg - 3 && playerTop <= cg - 1) {
      currentState = GAME_OVER; 
    }
  }

  // 8. WASSER-KOLLISION
  if (isWater[pX_int] && round(pY) + 1 >= 7) {
    currentState = GAME_OVER; 
  }
}

void loop() {
  switch (currentState) {
    case START:
      FastLED.clear();
      // Demo-Ansicht im Startscreen anpassen
      for(int x=0; x<WIDTH; x++) setSafeLed(x, 7, CRGB::Green); 
      setSafeLed(0, 5, CRGB::Cyan); 
      setSafeLed(0, 6, CRGB::Cyan);
      if (digitalRead(PIN_BTN_B) == LOW) initGame();
      break;

    case PLAYING:
      updatePhysics();
      FastLED.clear();
      drawWorld();
      setSafeLed(round(pX), round(pY), CRGB::Cyan);
      setSafeLed(round(pX), round(pY) + 1, CRGB::Cyan);
      break;

    case GAME_OVER:
      displayScore();
      if (digitalRead(PIN_BTN_B) == LOW) initGame();
      break;
  }
  FastLED.show();
  delay(20); 
}

void setup() {
  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
  pinMode(PIN_BTN_B, INPUT_PULLUP);
  randomSeed(analogRead(A5));
  FastLED.setBrightness(BRIGHTNESS_MENU);
  FastLED.clear();
  FastLED.show();
}

Kontakt

Ronnie

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