Arduino Ideen

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

Klassisches Breakout kennt jeder, aber hast du schon mal versucht, dich durch ein 32 Stockwerke hohes Hochhaus aus Blöcken nach oben zu graben? In Vertical Breakout ist dein Paddel zwar unten, aber dein Ziel ist der Gipfel! In diesem Projekt zeige ich dir, wie du deine 8x32 LED-Matrix in eine vertikale Arena verwandelst, in der nicht nur Geschick, sondern auch die richtige Taktik bei den Spezial-Blöcken zählt.

Eines von 60 Highlights aus meiner Neopixel-Spielesammlung!

Der vertikale Twist: Hochkant zum Sieg

Während man beim normalen Breakout versucht, das Feld zu leeren, ist hier der Weg das Ziel. Du spielst auf einer Breite von nur 8 Pixeln das klingt wenig, sorgt aber für extrem schnelle Ballwechsel und verlangt präzises Timing am Joystick. Mit speziellen Block-Typen wie Explosiv-Ladungen oder unzerstörbarem Beton wird jede Runde zu einer neuen Herausforderung. Nimmst du die Herausforderung an und schaffst den Ausbruch nach oben?

Die Features im Überblick

Vertikaler Modus: Optimiert für die hochkant aufgestellte Matrix (Kabelanschluss unten). Maximale Höhe für maximalen Spielspaß!
Spezial-Blöcke: * Blau: Standard-Bausteine.
- Rot: Absolut unzerstörbar hier musst du geschickt drumherum spielen.
- Grün: Explosiv! Vernichtet alle Blöcke im Umkreis von 8 Pixeln.
- Gelb: Turbo-Boost! Der Ball kommt mit doppelter Geschwindigkeit zurück.
- Weiß: Der "Reihen-Killer" radiert Blöcke horizontal nach links und rechts aus.
Dynamic Speed: Jedes Mal, wenn du eine komplette horizontale Reihe leergeräumt hast, zieht das Grundtempo des Balls an.

Die Verdrahtung

Für die Steuerung nutzt du deinen Standard-Aufbau mit Joystick und vier Tastern. So hast du die volle Kontrolle über dein Paddel und die Menüführung.

Komponente	Pin am Arduino	Beschreibung
8x32 Matrix	D9	Dateneingang (DIN)
Joystick X-Achse	A0	Paddel nach links und rechts bewegen
Button A	D2	Start: Spiel beginnen / Game Over Reset
Button B	D3	Heller: (Nur im Startmenü)
Button C	D4	Abbruch: Zurück zum "GO"-Bildschirm
Button D	D5	Dunkler: (Nur im Startmenü)

Bedienungsanleitung

1. Start: Nach dem Einschalten erscheint das gelbe "GO". Jetzt ist der richtige Moment, um mit Button B und D die Helligkeit perfekt auf deine Umgebung einzustellen.

2. Loslegen: Drücke Button A, um die Kugel ins Feld zu schießen. Dein Paddel ist 4 Pixel breit und wartet unten auf deinen Einsatz.

3. Action: Bewege den Joystick, um den Ball im Spiel zu halten. Triffst du einen gelben Block, wird es brenzlig: Der Ball wird rasant schnell, bis du ihn wieder sicher mit dem Paddel parierst. Strategisches Ziel: Nutze die weißen und grünen Blöcke, um dir den Weg nach oben freizusprengen!

4. Win oder Game Over: Erreichst du den oberen Rand, leuchtet die Matrix grün auf du hast den Ausbruch geschafft!

Fällt der Ball unten durch, blitzt es kurz rot.
In beiden Fällen wird dir danach dein Score (zerstörte Blöcke) vertikal angezeigt. Mit Button A startest du die nächste Runde.

Viel Spaß beim Nachbauen und beim "Ausbrechen"! Wenn dir das Spiel zu einfach oder schwer ist dann kannst du über float baseSpeed = 0.18f; die Spielggeschwindigkeit einstellen.

🚀 Schneller

Um das Spiel schneller zu machen, musst du den Wert erhöhen.

Beispiel: float baseSpeed = 0.25f;
Warum? Der Ball springt pro Frame nun um 0,25 Pixel weiter statt nur um 0,18. Dadurch wirkt die Bewegung rasanter.

🐌 Langsamer

Um das Spiel langsamer zu machen, musst du den Wert verringern.

Beispiel: float baseSpeed = 0.12f;
Warum? Der Ball macht kleinere „Schritte“ pro Frame, wodurch er sich gemächlicher über das Display bewegt.

Was bedeutet das f am Ende?

Das f sagt dem Arduino lediglich, dass es sich um eine Floating-Point-Zahl (Fließkommazahl) handelt. Das ist wichtig, damit der Controller präzise mit den Nachkommastellen rechnen kann.

Der Arduino Code für das Breakout Spiel

// www.kreativekiste.de // 15.04.2026 // Version 1.9
// VERTICAL BREAKOUT

#include <FastLED.h>

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

int currentBrightness = 30; 
#define MAX_BRIGHTNESS 60

// Logische Dimensionen (Hochkant)
#define WIDTH 8
#define HEIGHT 32
CRGB leds[NUM_LEDS];

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

// Joystick Tuning
#define JOY_LEFT_MAX 400
#define JOY_RIGHT_MIN 600
#define PADDLE_SPEED 0.35f
#define PADDLE_WIDTH 3  // <-- Paddel-Breite zentral definiert

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

int score = 0;

// Paddel und Ball
float paddleX = 2.0f;
float ballX = 4.0f;
float ballY = 2.0f;
float ballDirX = 0.5f;
float ballDirY = 0.866f;
float baseSpeed = 0.18f;
bool isDoubleSpeed = false;

// Blöcke
uint8_t bricks[WIDTH][HEIGHT] = {0}; 
bool rowCleared[HEIGHT] = {false};

// Block-Typen
#define TYPE_EMPTY 0
#define TYPE_BLUE 1
#define TYPE_RED 2
#define TYPE_GREEN 3
#define TYPE_YELLOW 4
#define TYPE_WHITE 5

CRGB brickColors[] = {
  CRGB::Black,
  CRGB::Blue,
  CRGB::Red,
  CRGB::Green,
  CRGB::Yellow,
  CRGB::White
};

// --- MATRIX HILFSFUNKTIONEN (ROTATION) ---
int getIndex(int logicalX, int logicalY) {
  if (logicalX < 0 || logicalX >= WIDTH || logicalY < 0 || logicalY >= HEIGHT) return -1;
  int physX = logicalY; 
  int physY = logicalX; 
  if (physX % 2 == 0) return (physX * 8) + physY;
  else return (physX * 8) + (7 - physY);
}

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

// --- ZEICHEN-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);
      int py = offsetY - (i / 3); 
      setSafeLed(px, py, color);
    }
  }
}

void displayScoreVertically() {
  int h = (score / 100) % 10;
  int t = (score / 10) % 10;
  int u = score % 10;
  drawDigit(h, 2, 28, CRGB::White);
  drawDigit(t, 2, 20, CRGB::White);
  drawDigit(u, 2, 12, CRGB::White);
}

void drawGO(int y) {
  for(int i=0; i<3; i++) { setSafeLed(1+i, y+4, CRGB::Yellow); setSafeLed(1+i, y, CRGB::Yellow); }
  setSafeLed(1, y+3, CRGB::Yellow); setSafeLed(1, y+2, CRGB::Yellow); setSafeLed(3, y+2, CRGB::Yellow);
  setSafeLed(1, y+1, CRGB::Yellow); setSafeLed(3, y+1, CRGB::Yellow);
  for(int i=0; i<3; i++) { setSafeLed(5+i, y+4, CRGB::Yellow); setSafeLed(5+i, y, CRGB::Yellow); }
  for(int i=1; i<4; i++) { setSafeLed(5, y+i, CRGB::Yellow); setSafeLed(7, y+i, CRGB::Yellow); }
}

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(2, currentBrightness - 2); 
    FastLED.setBrightness(currentBrightness); delay(30); 
  }
  if (digitalRead(PIN_BTN_A) == LOW) { 
    initGame(); 
    delay(200); 
  }
}

// --- SPIEL-FUNKTIONEN ---
void initGame() {
  score = 0;
  baseSpeed = 0.3f; //erhöhen Spiel ist schneller
  isDoubleSpeed = false;
  
  paddleX = 2.0f;
  ballX = 4.0f;
  ballY = 2.0f;
  ballDirX = 0.5f;
  ballDirY = 0.866f;

  memset(bricks, 0, sizeof(bricks));
  memset(rowCleared, 0, sizeof(rowCleared));

  for (int y = 8; y <= 28; y++) {
    for (int x = 0; x < WIDTH; x++) {
      int r = random(0, 100);
      if (r < 7) bricks[x][y] = TYPE_RED;
      else if (r < 14) bricks[x][y] = TYPE_GREEN;
      else if (r < 19) bricks[x][y] = TYPE_YELLOW;
      else bricks[x][y] = TYPE_BLUE;
    }
  }

  int wX = random(0, WIDTH);
  int wY = random(8, 29);
  bricks[wX][wY] = TYPE_WHITE;

  currentState = PLAYING;
}

void checkRowCleared() {
  for (int y = 8; y <= 28; y++) {
    if (!rowCleared[y]) {
      bool empty = true;
      for (int x = 0; x < WIDTH; x++) {
        if (bricks[x][y] != TYPE_EMPTY && bricks[x][y] != TYPE_RED) { 
          empty = false; 
          break; 
        }
      }
      if (empty) {
        rowCleared[y] = true;
        baseSpeed += 0.02f;
      }
    }
  }
}

void destroyBrick(int x, int y) {
  if (x < 0 || x >= WIDTH || y < 8 || y >= HEIGHT) return;
  if (bricks[x][y] == TYPE_EMPTY || bricks[x][y] == TYPE_RED) return;
  bricks[x][y] = TYPE_EMPTY;
  score++;
}

void hitBrick(int x, int y) {
  int type = bricks[x][y];
  if (type == TYPE_RED) return;

  destroyBrick(x, y);

  if (type == TYPE_GREEN) {
    for (int i = x - 1; i <= x + 1; i++)
      for (int j = y - 1; j <= y + 1; j++)
        if (i != x || j != y) destroyBrick(i, j);
  } 
  else if (type == TYPE_WHITE) {
    for (int i = x - 3; i <= x + 3; i++)
      if (i != x) destroyBrick(i, y);
  }
  else if (type == TYPE_YELLOW) {
    isDoubleSpeed = true;
  }

  checkRowCleared();
}

void updatePhysics() {
  // --- Paddel Steuerung ---
  int joyX = analogRead(PIN_JOY_X);
  if (joyX < JOY_LEFT_MAX) paddleX -= PADDLE_SPEED;
  if (joyX > JOY_RIGHT_MIN) paddleX += PADDLE_SPEED;
  // Rand einhalten: Paddel darf nicht über rechten Rand (Breite 3)
  if (paddleX < 0.0f) paddleX = 0.0f;
  if (paddleX > (float)(WIDTH - PADDLE_WIDTH)) paddleX = (float)(WIDTH - PADDLE_WIDTH);

  // --- Ball Bewegung ---
  float currentSpeed = baseSpeed * (isDoubleSpeed ? 2.0f : 1.0f);
  float nextX = ballX + ballDirX * currentSpeed;
  float nextY = ballY + ballDirY * currentSpeed;

  // --- Wand Links/Rechts ---
  if (nextX < 0.0f) { 
    nextX = 0.0f; 
    ballDirX = fabs(ballDirX); // immer nach rechts
  } else if (nextX > (float)(WIDTH - 1)) { 
    nextX = (float)(WIDTH - 1); 
    ballDirX = -fabs(ballDirX); // immer nach links
  }

  // --- Gewonnen: Ausbruch nach oben ---
  if (nextY >= HEIGHT) {
    currentState = GAMEWIN_GREEN;
    return;
  }

  // --- Paddel Kollision / Game Over ---
  if (nextY < 1.0f) {
    float paddleLeft  = paddleX - 0.5f;
    float paddleRight = paddleX + (float)PADDLE_WIDTH - 0.5f;

    if (nextX >= paddleLeft && nextX <= paddleRight) {
      nextY = 1.0f;
      ballDirY = fabs(ballDirY); // Ball immer nach oben abprallen

      // Winkel abhängig vom Treffpunkt
      float hitOffset = (nextX - paddleX) / (float)(PADDLE_WIDTH - 1); // 0.0 .. 1.0
      ballDirX = (hitOffset - 0.5f) * 1.8f;

      // Vektor normalisieren
      float mag = sqrt(ballDirX * ballDirX + ballDirY * ballDirY);
      if (mag > 0.0f) { ballDirX /= mag; ballDirY /= mag; }

      isDoubleSpeed = false;
    } else if (nextY < 0.0f) {
      currentState = GAMEOVER_RED;
      return;
    }
  }

  // --- Block Kollision ---
  int nx = constrain((int)round(nextX), 0, WIDTH - 1);
  int ny = constrain((int)round(nextY), 0, HEIGHT - 1);
  int cx = constrain((int)round(ballX),  0, WIDTH - 1);
  int cy = constrain((int)round(ballY),  0, HEIGHT - 1);

  if (ny >= 8 && ny < HEIGHT && bricks[nx][ny] != TYPE_EMPTY) {
    hitBrick(nx, ny);

    if (cx != nx && cy == ny) {
      ballDirX *= -1; // seitlicher Treffer
    } else if (cy != ny && cx == nx) {
      ballDirY *= -1; // Treffer von oben/unten
    } else {
      ballDirY *= -1; // Standardfall
    }
  }

  ballX = nextX;
  ballY = nextY;
}

void drawGame() {
  FastLED.clear();

  // Blöcke zeichnen
  for (int y = 8; y < HEIGHT; y++)
    for (int x = 0; x < WIDTH; x++)
      if (bricks[x][y] != TYPE_EMPTY)
        setSafeLed(x, y, brickColors[bricks[x][y]]);

  // Paddel zeichnen (3 Pixel breit, Weiß)
  int pX = round(paddleX);
  for (int i = 0; i < PADDLE_WIDTH; i++)
    setSafeLed(pX + i, 0, CRGB::White);

  // Ball zeichnen (Cyan)
  setSafeLed(round(ballX), round(ballY), CRGB::Cyan);

  FastLED.show();
}

// --- 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);
  FastLED.clear();
  FastLED.show();
}

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

    case PLAYING:
      if (digitalRead(PIN_BTN_C) == LOW) { 
        currentState = START; 
        delay(200); 
        break; 
      }
      updatePhysics();
      if (currentState == PLAYING) drawGame(); 
      break;

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

    case GAMEWIN_GREEN:
      fill_solid(leds, NUM_LEDS, CRGB::Green);
      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(20); 
}

Kontakt

Ronnie

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