Arduino 🐍 Snake auf 8x32 Pixeln, pures Retro-Feeling

Arduino Ideen

Details: Kategorie: Arduino neue Ideen; Erstellt: 13. April 2026; Zugriffe: 10

Der absolute Klassiker ist zurück! Aber warum eigentlich "Klassiker"? Kaum ein Spiel verkörpert das Prinzip "Easy to learn, hard to master" so perfekt wie Snake. Spätestens seit den ersten Nokia-Handys in den späten 90ern hat wohl jeder schon einmal wütend auf Tasten eingehämmert, um den eigenen Highscore zu knacken. Es ist die pure Reduktion auf Spielspaß und Suchtfaktor. Nachdem du Tetris und Flappy Pixel bezwungen hast, darf dieses Kultspiel auf deiner 8x32 LED-Matrix natürlich auf keinen Fall fehlen. In diesem Projekt zeige ich dir, wie du die Schlange über das Display jagst und warum die Wahl der Steuerung über Sieg oder Niederlage entscheidet.

Eines von 60 Highlights aus meiner Neopixel-Spielesammlung!

Das Spielprinzip: Wie funktioniert Snake überhaupt?

Falls du die letzten 30 Jahre auf einem anderen Planeten verbracht hast, hier ein kurzes Refresh: Du steuerst eine stetig kriechende Schlange über das Spielfeld. Dein Ziel ist es, die zufällig auftauchenden "Äpfel" (leuchtende Pixel) einzusammeln. Mit jedem gefressenen Apfel wird deine Schlange um ein Segment länger – und das Navigieren damit deutlich kniffliger. Rammt der Kopf der Schlange die Spielfeldbegrenzung oder den eigenen, immer länger werdenden Körper, heißt es: Game Over!

Die Platzangst-Gefahr: Warum 8x32 so extrem schwer ist

Dein Spielfeld liegt im Querformat. 32 Pixel in der Breite klingen im ersten Moment nach richtig viel Platz für lange Sprints. Aber die Höhe von nur 8 Pixeln hat es in sich! Diese extrem geringe Bauhöhe verzeiht dir absolut keine Fehler. Bewegst du dich vertikal, bist du in einem Wimpernschlag an der Wand. Du musst blitzschnell reagieren und die Schlange rechtzeitig wieder in die Horizontale zwingen, bevor es knallt. Du hast quasi keinen Raum für Fehler nach oben und unten. Genau dieses enge Korsett macht diese Matrix-Version so unheimlich herausfordernd und schweißtreibend.

Die Herausforderung: Präzision ist alles!

Beim Programmieren habe ich zwei Versionen der Steuerung getestet:

Die Joystick-Version: Klingt im ersten Moment cool, fühlt sich aber im Spiel oft schwammig an. Das Feedback des Joysticks ist für die harten 90-Grad-Wenden bei Snake nicht präzise genug. Man lenkt oft aus Versehen schräg oder das Timing passt nicht.
Die Button-Version (Meine Empfehlung!): Hier nutzt du die Arcade-Taster deines Pults. Ein Klick = eine Richtungsänderung. Das ist knackig, direkt und gibt dir die volle Kontrolle, wenn es im Spielfeld eng wird.

Features der Snake-Edition

Liegendes Layout: Du nutzt die Matrix horizontal (32x8), perfekt für lange Sprints.
Dynamic Speed: Mit jedem Apfel wird die Schlange nicht nur länger, sondern auch schneller.
Highscore-Display: Nach dem Game Over zeigt dir die Matrix deinen Score an.
Optimierter Code: Die Eingaben werden sofort verarbeitet, ohne Verzögerung durch die LED-Ansteuerung.

Die Verdrahtung (Arcade-Standard)

Damit alle deine Spiele auf demselben Pult laufen, nutzt du am besten wieder das standardisierte Layout:

Komponente	Pin am Arduino	Funktion
8x32 Matrix	D9	Dateneingang (DIN)
Button A	D2	Hoch (UP)
Button B	D3	Runter (DOWN)
Button C	D4	Links (LEFT)
Button D	D5	Rechts (RIGHT)
Button F	D7	Start / Neustart

Der Arduino Code für das Snake Spiel mit Tastern

// www.kreativekiste.de // 13.04.2026 // Version 1.4
// SNAKE 


#include <FastLED.h>

// ------------------------------------------------------------------ Konfiguration
const int DATA_PIN        = 9;
const int NUM_LEDS        = 256;
const int BRIGHTNESS_GAME = 10; 

const int PIN_BTN_A = 2; 
const int PIN_BTN_B = 3; 
const int PIN_BTN_C = 4; 
const int PIN_BTN_D = 5; 
const int PIN_BTN_F = 7; // START / NEUSTART

// ------------------------------------------------------------------ Richtungen
enum Dir { UP, DOWN, LEFT, RIGHT };

// Tausche hier einfach UP, DOWN, LEFT und RIGHT aus
#define DIR_BTN_A UP
#define DIR_BTN_B RIGHT
#define DIR_BTN_C DOWN
#define DIR_BTN_D LEFT

const int WIDTH  = 32;
const int HEIGHT = 8;

CRGB leds[NUM_LEDS];

// ------------------------------------------------------------------ Farben
const CRGB COLOR_BG         = CRGB::Black;
const CRGB COLOR_SNAKE_HEAD = CRGB(  0, 255,  80);
const CRGB COLOR_SNAKE_BODY = CRGB(  0, 130,  40);
const CRGB COLOR_FOOD       = CRGB(255,  30,  10);
const CRGB COLOR_BORDER     = CRGB( 15,  15,  50);
const CRGB COLOR_SCORE      = CRGB(255, 200,   0);

// ------------------------------------------------------------------ Spielkonstanten
const int MAX_SNAKE_LEN = 100;
const int INITIAL_SPEED = 220;  
const int SPEED_STEP    = 10;   
const int MIN_SPEED     = 70;

// ================================================================== Matrix-Hilfsfunktionen
int getIndex(int x, int y) {
  if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) return -1;
  // Standard Zick-Zack Layout für liegende 32x8 Matrix
  if (x % 2 == 0) return (x * HEIGHT) + y;
  else             return (x * HEIGHT) + (HEIGHT - 1 - y);
}

void setPixel(int x, int y, CRGB color) {
  int idx = getIndex(x, y);
  if (idx >= 0) leds[idx] = color;
}

// ================================================================== Spielzustand
struct Point { int x, y; };

Point snakeBody[MAX_SNAKE_LEN];
int   snakeLen;
Dir   snakeDir;
Dir   nextDir;

Point food;
int   score;
int   speedMs;
bool  gameRunning;

unsigned long lastMoveTime;

// ================================================================== Prototypen
void resetGame();
void showGameOver();
void gameLoop();
void spawnFood();
void drawGame();
bool startButtonPressed();
Dir  readButtons();

// ================================================================== Setup
void setup() {
  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
  FastLED.setBrightness(BRIGHTNESS_GAME);
  FastLED.clear(true);

  pinMode(PIN_BTN_A, INPUT_PULLUP);
  pinMode(PIN_BTN_B, INPUT_PULLUP);
  pinMode(PIN_BTN_C, INPUT_PULLUP);
  pinMode(PIN_BTN_D, INPUT_PULLUP);
  pinMode(PIN_BTN_F, INPUT_PULLUP);
  randomSeed(analogRead(A5));

  resetGame(); 
}

// ================================================================== Loop
void loop() {
  if (!gameRunning) {
    if (startButtonPressed()) {
      gameRunning = true;
      lastMoveTime = millis();
    }
    return;
  }
  gameLoop();
}

// ================================================================== Tasten-Hilfsfunktionen

bool startButtonPressed() {
  static bool lastF = HIGH;
  bool curF = digitalRead(PIN_BTN_F);
  bool pressed = (lastF == HIGH && curF == LOW);
  lastF = curF;
  if (pressed) { delay(40); return true; } 
  return false;
}

Dir readButtons() {
  // Hier greift dein Mapping von oben!
  if (digitalRead(PIN_BTN_A) == LOW) return DIR_BTN_A;
  if (digitalRead(PIN_BTN_B) == LOW) return DIR_BTN_B;
  if (digitalRead(PIN_BTN_C) == LOW) return DIR_BTN_C;
  if (digitalRead(PIN_BTN_D) == LOW) return DIR_BTN_D;

  return nextDir;  
}

// ================================================================== 5-Segment Ziffer (3x5 Pixel)
const uint8_t DIGIT_FONT[10][5] = {
  {0b111, 0b101, 0b101, 0b101, 0b111}, // 0
  {0b010, 0b110, 0b010, 0b010, 0b111}, // 1
  {0b111, 0b001, 0b111, 0b100, 0b111}, // 2
  {0b111, 0b001, 0b111, 0b001, 0b111}, // 3
  {0b101, 0b101, 0b111, 0b001, 0b001}, // 4
  {0b111, 0b100, 0b111, 0b001, 0b111}, // 5
  {0b111, 0b100, 0b111, 0b101, 0b111}, // 6
  {0b111, 0b001, 0b001, 0b001, 0b001}, // 7
  {0b111, 0b101, 0b111, 0b101, 0b111}, // 8
  {0b111, 0b101, 0b111, 0b001, 0b111}, // 9
};

void drawDigit(int num, int startX, int startY, CRGB color) {
  for (int row = 0; row < 5; row++) {
    for (int col = 0; col < 3; col++) {
      if (DIGIT_FONT[num][row] & (1 << (2 - col))) {
        setPixel(startX + col, startY + row, color);
      }
    }
  }
}

// ================================================================== Spielfeld zurücksetzen
void resetGame() {
  snakeLen  = 4;
  snakeDir  = RIGHT;
  nextDir   = RIGHT;
  score     = 0;
  speedMs   = INITIAL_SPEED;
  gameRunning = false; 

  for (int i = 0; i < snakeLen; i++) {
    snakeBody[i].x = 5 - i;
    snakeBody[i].y = 3;
  }

  spawnFood();
  drawGame(); 
}

// ================================================================== Game Over
void showGameOver() {
  for (int f = 0; f < 6; f++) {
    if (f % 2 == 0) fill_solid(leds, NUM_LEDS, CRGB(50, 0, 0));
    else             FastLED.clear();
    FastLED.show();
    delay(150);
  }

  FastLED.clear();
  for (int x = 0; x < WIDTH; x++) {
    setPixel(x, 0,          COLOR_BORDER);
    setPixel(x, HEIGHT - 1, COLOR_BORDER);
  }

  int tens  = (score / 10) % 10;
  int units =  score % 10;

  drawDigit(tens,  12, 1, COLOR_SCORE);
  drawDigit(units, 16, 1, COLOR_SCORE);

  setPixel(27, 2, CRGB(200,0,0)); setPixel(29, 2, CRGB(200,0,0));
  setPixel(28, 3, CRGB(200,0,0));
  setPixel(27, 4, CRGB(200,0,0)); setPixel(29, 4, CRGB(200,0,0));

  FastLED.show();
  delay(600);
  
  while (!startButtonPressed()) delay(20);
  resetGame();
}

// ================================================================== Essen platzieren
void spawnFood() {
  bool onSnake;
  do {
    onSnake = false;
    food.x  = random(1, WIDTH  - 1);
    food.y  = random(1, HEIGHT - 1);
    for (int i = 0; i < snakeLen; i++) {
      if (snakeBody[i].x == food.x && snakeBody[i].y == food.y) {
        onSnake = true;
        break;
      }
    }
  } while (onSnake);
}

// ================================================================== Zeichnen
void drawGame() {
  FastLED.clear();

  for (int x = 0; x < WIDTH;  x++) {
    setPixel(x, 0,          COLOR_BORDER);
    setPixel(x, HEIGHT - 1, COLOR_BORDER);
  }
  for (int y = 1; y < HEIGHT - 1; y++) {
    setPixel(0,          y, COLOR_BORDER);
    setPixel(WIDTH - 1,  y, COLOR_BORDER);
  }

  for (int i = 1; i < snakeLen; i++)
    setPixel(snakeBody[i].x, snakeBody[i].y, COLOR_SNAKE_BODY);

  setPixel(snakeBody[0].x, snakeBody[0].y, COLOR_SNAKE_HEAD);
  setPixel(food.x, food.y, COLOR_FOOD);

  FastLED.show();
}

// ================================================================== Spiellogik
void gameLoop() {
  Dir btn = readButtons();
  
  if (!((btn == LEFT  && snakeDir == RIGHT) ||
        (btn == RIGHT && snakeDir == LEFT ) ||
        (btn == UP    && snakeDir == DOWN ) ||
        (btn == DOWN  && snakeDir == UP   ))) {
    nextDir = btn;
  }

  unsigned long now = millis();
  if (now - lastMoveTime < (unsigned long)speedMs) {
    return;
  }
  lastMoveTime = now;

  snakeDir = nextDir;

  Point newHead = snakeBody[0];
  switch (snakeDir) {
    case UP:    newHead.y--; break;
    case DOWN:  newHead.y++; break;
    case LEFT:  newHead.x--; break;
    case RIGHT: newHead.x++; break;
  }

  if (newHead.x <= 0 || newHead.x >= WIDTH  - 1 ||
      newHead.y <= 0 || newHead.y >= HEIGHT - 1) {
    gameRunning = false;
    showGameOver();
    return;
  }

  for (int i = 0; i < snakeLen; i++) {
    if (snakeBody[i].x == newHead.x && snakeBody[i].y == newHead.y) {
      gameRunning = false;
      showGameOver();
      return;
    }
  }

  bool ate = (newHead.x == food.x && newHead.y == food.y);

  if (!ate) {
    for (int i = snakeLen - 1; i > 0; i--)
      snakeBody[i] = snakeBody[i - 1];
  } else {
    if (snakeLen < MAX_SNAKE_LEN) {
      for (int i = snakeLen; i > 0; i--)
        snakeBody[i] = snakeBody[i - 1];
      snakeLen++;
    } else {
      for (int i = snakeLen - 1; i > 0; i--)
        snakeBody[i] = snakeBody[i - 1];
    }
    score++;
    speedMs = max(MIN_SPEED, speedMs - SPEED_STEP);
    spawnFood();
  }
  snakeBody[0] = newHead;

  drawGame();
}

Der Arduino Code für das Snake Spiel mit Joystick

// www.kreativekiste.de // 13.04.2026 // Version 1.1
// SNAKE 

#include <FastLED.h>

// ------------------------------------------------------------------ Konfiguration
const int DATA_PIN        = 9;
const int NUM_LEDS        = 256;
const int BRIGHTNESS_GAME = 13; // Helligkeit für das gesamte Spiel

const int PIN_JOY_X = A0;    
const int PIN_JOY_Y = A1;    
const int PIN_BTN_A = 2; 
const int PIN_BTN_B = 3; 
const int PIN_BTN_C = 4; // Start / Neustart
const int PIN_BTN_D = 5; 

const int WIDTH  = 32;
const int HEIGHT = 8;

CRGB leds[NUM_LEDS];

// ------------------------------------------------------------------ Farben
const CRGB COLOR_BG         = CRGB::Black;
const CRGB COLOR_SNAKE_HEAD = CRGB(  0, 255,  80);
const CRGB COLOR_SNAKE_BODY = CRGB(  0, 130,  40);
const CRGB COLOR_FOOD       = CRGB(255,  30,  10);
const CRGB COLOR_BORDER     = CRGB( 15,  15,  50);
const CRGB COLOR_SCORE      = CRGB(255, 200,   0);

// ------------------------------------------------------------------ Spielkonstanten
const int MAX_SNAKE_LEN = 100;
const int INITIAL_SPEED = 220;  // ms pro Schritt
const int SPEED_STEP    = 10;   // ms schneller pro Apfel
const int MIN_SPEED     = 70;

// ------------------------------------------------------------------ Richtungen
enum Dir { UP, DOWN, LEFT, RIGHT };

// ================================================================== 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 setPixel(int x, int y, CRGB color) {
  int idx = getIndex(x, y);
  if (idx >= 0) leds[idx] = color;
}

// ================================================================== Spielzustand
struct Point { int x, y; };

Point snakeBody[MAX_SNAKE_LEN];
int   snakeLen;
Dir   snakeDir;
Dir   nextDir;

Point food;
int   score;
int   speedMs;
bool  gameRunning;

unsigned long lastMoveTime;

// ================================================================== Prototypen
void resetGame();
void showGameOver();
void gameLoop();
void spawnFood();
void drawGame();
bool startButtonPressed();
Dir  readButtons();

// ================================================================== Setup
void setup() {
  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
  FastLED.setBrightness(BRIGHTNESS_GAME);
  FastLED.clear(true);

  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));

  resetGame(); // Zeigt direkt das wartende Spielfeld
}

// ================================================================== Loop
void loop() {
  if (!gameRunning) {
    if (startButtonPressed()) {
      gameRunning = true;
      lastMoveTime = millis();
    }
    return;
  }
  gameLoop();
}

// ================================================================== Tasten-Hilfsfunktionen
// Taste C: START / NEUSTART (flankengetriggert)
bool startButtonPressed() {
  static bool lastC = HIGH;
  bool curC = digitalRead(PIN_BTN_C);
  bool pressed = (lastC == HIGH && curC == LOW);
  lastC = curC;
  if (pressed) { delay(40); return true; }
  return false;
}

// Richtung per Joystick lesen (X/Y Achsen)
Dir readButtons() {
  int joyX = analogRead(PIN_JOY_X);
  int joyY = analogRead(PIN_JOY_Y);

  if (joyY > 600) return UP;
  if (joyY < 400) return DOWN;
  if (joyX < 400) return LEFT;
  if (joyX > 600) return RIGHT;

  return snakeDir; 
}

// ================================================================== 5-Segment Ziffer (3x5 Pixel)
const uint8_t DIGIT_FONT[10][5] = {
  {0b111, 0b101, 0b101, 0b101, 0b111}, // 0
  {0b010, 0b110, 0b010, 0b010, 0b111}, // 1
  {0b111, 0b001, 0b111, 0b100, 0b111}, // 2
  {0b111, 0b001, 0b111, 0b001, 0b111}, // 3
  {0b101, 0b101, 0b111, 0b001, 0b001}, // 4
  {0b111, 0b100, 0b111, 0b001, 0b111}, // 5
  {0b111, 0b100, 0b111, 0b101, 0b111}, // 6
  {0b111, 0b001, 0b001, 0b001, 0b001}, // 7
  {0b111, 0b101, 0b111, 0b101, 0b111}, // 8
  {0b111, 0b101, 0b111, 0b001, 0b111}, // 9
};

void drawDigit(int num, int startX, int startY, CRGB color) {
  for (int row = 0; row < 5; row++) {
    for (int col = 0; col < 3; col++) {
      if (DIGIT_FONT[num][row] & (1 << (2 - col))) {
        setPixel(startX + col, startY + row, color);
      }
    }
  }
}

// ================================================================== Spielfeld zurücksetzen
void resetGame() {
  snakeLen  = 4;
  snakeDir  = RIGHT;
  nextDir   = RIGHT;
  score     = 0;
  speedMs   = INITIAL_SPEED;
  gameRunning = false; // Wartet auf Button C

  // Schlange startet links-mitte
  for (int i = 0; i < snakeLen; i++) {
    snakeBody[i].x = 5 - i;
    snakeBody[i].y = 3;
  }

  spawnFood();
  drawGame(); 
}

// ================================================================== Game Over
void showGameOver() {
  // Rote Blink-Animation
  for (int f = 0; f < 6; f++) {
    if (f % 2 == 0) fill_solid(leds, NUM_LEDS, CRGB(50, 0, 0));
    else             FastLED.clear();
    FastLED.show();
    delay(150);
  }

  // Score anzeigen
  FastLED.clear();
  for (int x = 0; x < WIDTH; x++) {
    setPixel(x, 0,          COLOR_BORDER);
    setPixel(x, HEIGHT - 1, COLOR_BORDER);
  }

  int tens  = (score / 10) % 10;
  int units =  score % 10;

  drawDigit(tens,  12, 1, COLOR_SCORE);
  drawDigit(units, 16, 1, COLOR_SCORE);

  // "X" ganz rechts
  setPixel(27, 2, CRGB(200,0,0)); setPixel(29, 2, CRGB(200,0,0));
  setPixel(28, 3, CRGB(200,0,0));
  setPixel(27, 4, CRGB(200,0,0)); setPixel(29, 4, CRGB(200,0,0));

  FastLED.show();
  delay(600);
  
  // Warten bis C gedrückt wird, dann Feld wieder aufbauen
  while (!startButtonPressed()) delay(20);
  resetGame();
}

// ================================================================== Essen platzieren
void spawnFood() {
  bool onSnake;
  do {
    onSnake = false;
    food.x  = random(1, WIDTH  - 1);
    food.y  = random(1, HEIGHT - 1);
    for (int i = 0; i < snakeLen; i++) {
      if (snakeBody[i].x == food.x && snakeBody[i].y == food.y) {
        onSnake = true;
        break;
      }
    }
  } while (onSnake);
}

// ================================================================== Zeichnen
void drawGame() {
  FastLED.clear();

  for (int x = 0; x < WIDTH;  x++) {
    setPixel(x, 0,          COLOR_BORDER);
    setPixel(x, HEIGHT - 1, COLOR_BORDER);
  }
  for (int y = 1; y < HEIGHT - 1; y++) {
    setPixel(0,          y, COLOR_BORDER);
    setPixel(WIDTH - 1,  y, COLOR_BORDER);
  }

  for (int i = 1; i < snakeLen; i++)
    setPixel(snakeBody[i].x, snakeBody[i].y, COLOR_SNAKE_BODY);

  setPixel(snakeBody[0].x, snakeBody[0].y, COLOR_SNAKE_HEAD);
  setPixel(food.x, food.y, COLOR_FOOD);

  FastLED.show();
}

// ================================================================== Spiellogik
void gameLoop() {
  Dir joy = readButtons();
  if (!((joy == LEFT  && snakeDir == RIGHT) ||
        (joy == RIGHT && snakeDir == LEFT ) ||
        (joy == UP    && snakeDir == DOWN ) ||
        (joy == DOWN  && snakeDir == UP   ))) {
    nextDir = joy;
  }

  unsigned long now = millis();
  if (now - lastMoveTime < (unsigned long)speedMs) {
    drawGame();
    return;
  }
  lastMoveTime = now;

  snakeDir = nextDir;

  Point newHead = snakeBody[0];
  switch (snakeDir) {
    case UP:    newHead.y--; break;
    case DOWN:  newHead.y++; break;
    case LEFT:  newHead.x--; break;
    case RIGHT: newHead.x++; break;
  }

  if (newHead.x <= 0 || newHead.x >= WIDTH  - 1 ||
      newHead.y <= 0 || newHead.y >= HEIGHT - 1) {
    gameRunning = false;
    showGameOver();
    return;
  }

  for (int i = 0; i < snakeLen; i++) {
    if (snakeBody[i].x == newHead.x && snakeBody[i].y == newHead.y) {
      gameRunning = false;
      showGameOver();
      return;
    }
  }

  bool ate = (newHead.x == food.x && newHead.y == food.y);

  if (!ate) {
    for (int i = snakeLen - 1; i > 0; i--)
      snakeBody[i] = snakeBody[i - 1];
  } else {
    if (snakeLen < MAX_SNAKE_LEN) {
      for (int i = snakeLen; i > 0; i--)
        snakeBody[i] = snakeBody[i - 1];
      snakeLen++;
    } else {
      for (int i = snakeLen - 1; i > 0; i--)
        snakeBody[i] = snakeBody[i - 1];
    }
    score++;
    speedMs = max(MIN_SPEED, speedMs - SPEED_STEP);
    spawnFood();
  }
  snakeBody[0] = newHead;

  drawGame();
}

Kontakt

Ronnie

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