Arduino Dino Run, auf einer 8x32 LED Matrix: Der Browser-Klassiker im Breitbildformat

Arduino Ideen

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

Wer kennt ihn nicht? Den kleinen Dinosaurier, der im Chrome-Browser auftaucht, wenn das Internet mal wieder Pause macht. Mit Dino Run 8x32 bringen wir diesen süchtig machenden Klassiker auf den Arduino. Durch das extrem breite 8x32 Display kommt hier echtes Arcade-Feeling auf, da man die Hindernisse schon von Weitem heranrauschen sieht!

Eines von 60 Highlights aus meiner Neopixel-Spielesammlung!

{loadposition werbung

Das Spielprinzip

Dino Run ist ein klassischer Endless Runner. Du steuerst einen kleinen Dino, der unaufhaltsam durch eine gefährliche Wüste rennt. Dein Ziel: Überlebe so lange wie möglich, indem du den auftauchenden Kakteen ausweichst. Was einfach beginnt, wird durch das ständig steigende Tempo und die unvorhersehbaren Abstände der Hindernisse schnell zu einer echten Zerreißprobe für deine Reflexe.

Gameplay & Features

Das Spiel nutzt die gesamte Breite der 32-Pixel-Matrix aus und bietet eine Tiefe, die man von so einfacher Hardware kaum erwartet:

Die Sprung-Dynamik: Das absolute Highlight! Der Dino verfügt über eine variable Sprunghöhe. Ein kurzer Tipp auf den Taster lässt ihn etwa 4 Pixel hoch hüpfen – ideal für kleine Hindernisse. Hältst du den Taster länger gedrückt, segelt der Dino bis zu 6 Pixel hoch. Diese präzise Steuerung ist der Schlüssel zum Highscore.
Multi-Hindernis-System: Es ist nicht nur ein Kaktus unterwegs. Bis zu drei Hindernisse gleichzeitig können sich auf der Matrix befinden.
Zufällige Herausforderungen: Die Kakteen erscheinen in verschiedenen Größen und in völlig zufälligen Abständen. Mal kommen sie kurz hintereinander, mal hast du eine längere Verschnaufpause.
Dino-Design: Trotz der geringen Höhe von nur 8 Pixeln hat der Dino durch seine markante Nase und die animierten Beine einen ganz eigenen Charme.
Speed-Upgrade: Mit jedem überholten Hindernis erhöht sich die Laufgeschwindigkeit minimal.

Verdrahtung: Arduino, 8x32 Matrix und Shield

Komponente	Pin am Arduino	Beschreibung
8x32 Matrix	D9	Dateneingang (DIN)
Button A	D2	Springen (kurz/lang für Dynamik)
Button B	D3	Start / Restart
Stromversorgung	5V / GND	Wichtig: Externes Netzteil bei voller Helligkeit nutzen.

Pro-Tipp: Da wir hier 256 Pixel und eine schnelle Spiellogik haben, empfehle ich dir dringend einen Arduino Uno R4 (Minima oder WiFi). Der R3 kommt bei der Menge an Pixeln und der flüssigen Berechnung der Sprungphysik oft an seine Grenzen.

Der Arduino Code für das Dino Run Spiel

// www.kreativekiste.de // 10.04.2026 // Version 1.7
// DINO RUN

#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_BTN_A = 2; // SPRINGEN
const int PIN_BTN_B = 3; // START / RESET

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

float dinoY = 5.0;
float dinoVelocity = 0;
const float gravityNormal = 0.45; 
const float gravityLow = 0.12;    
const float jumpPower = -1.25;    
const int dinoX = 4; 

int score = 0;
float gameSpeed = 0.5;
bool isJumping = false;

// --- HINDERNISSE (Multi-System) ---
const int MAX_OBSTACLES = 3; 
struct Obstacle {
  float x;
  int type; 
  bool active;
};
Obstacle obstacles[MAX_OBSTACLES];

// --- 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(int s) {
  FastLED.clear();
  int tens = (s / 10) % 10;
  int units = s % 10;
  drawDigit(tens, 12, 1, CRGB::White);
  drawDigit(units, 16, 1, CRGB::White);
}

// --- SPIEL-FUNKTIONEN ---

void spawnObstacle(int i) {
  // Finde das am weitesten rechts stehende Hindernis
  float maxX = 31;
  for(int j=0; j<MAX_OBSTACLES; j++) {
    if(obstacles[j].active && obstacles[j].x > maxX) {
      maxX = obstacles[j].x;
    }
  }
  // Setze das neue Hindernis mit einem zufälligen, aber fairen Abstand dahinter
  obstacles[i].x = maxX + random(14, 28); 
  obstacles[i].type = random(1, 3);
  obstacles[i].active = true;
}

void initGame() {
  dinoY = 5.0;
  dinoVelocity = 0;
  score = 0;
  gameSpeed = 0.5;
  isJumping = false;
  
  for(int i=0; i<MAX_OBSTACLES; i++) {
    obstacles[i].active = false;
  }
  spawnObstacle(0); // Erstes Hindernis direkt starten
  
  currentState = PLAYING;
  FastLED.setBrightness(BRIGHTNESS_GAME);
}

void drawDino(int y, CRGB color) {
  int ry = round(y);
  setSafeLed(dinoX, ry, color);         
  setSafeLed(dinoX + 1, ry, color);     
  setSafeLed(dinoX, ry + 1, color);     
  setSafeLed(dinoX - 1, ry + 1, color); 
  setSafeLed(dinoX, ry + 2, color);     
  setSafeLed(dinoX - 1, ry + 2, color); 
}

void drawObstacles() {
  for(int i=0; i<MAX_OBSTACLES; i++) {
    if (!obstacles[i].active) continue;
    int rx = round(obstacles[i].x);
    if (rx >= 0 && rx < WIDTH) {
      if (obstacles[i].type == 1) { 
        setSafeLed(rx, 6, CRGB::Green);
        setSafeLed(rx, 7, CRGB::Green);
      } else { 
        setSafeLed(rx, 5, CRGB::Green);
        setSafeLed(rx, 6, CRGB::Green);
        setSafeLed(rx, 7, CRGB::Green);
        setSafeLed(rx + 1, 6, CRGB::Green);
      }
    }
  }
}

void updatePhysics() {
  bool btnPressed = (digitalRead(PIN_BTN_A) == LOW);

  if (btnPressed && !isJumping && dinoY >= 4.8) {
    dinoVelocity = jumpPower;
    isJumping = true;
  }

  if (btnPressed && dinoVelocity < 0) {
    dinoVelocity += gravityLow;
  } else {
    dinoVelocity += gravityNormal;
  }

  dinoY += dinoVelocity;

  if (dinoY > 5.0) {
    dinoY = 5.0;
    dinoVelocity = 0;
    isJumping = false;
  }

  // Hindernisse bewegen
  for(int i=0; i<MAX_OBSTACLES; i++) {
    if(!obstacles[i].active) {
      spawnObstacle(i); // Inaktive Slots wieder füllen
      continue;
    }

    obstacles[i].x -= gameSpeed;
    
    // Wenn Hindernis links raus ist
    if (obstacles[i].x < -3) {
      score++;
      gameSpeed = min(1.3f, gameSpeed + 0.008f);
      obstacles[i].active = false; // Wird im nächsten Frame neu gespawnt
    }

    // Kollisionsabfrage
    int rdY = round(dinoY);
    int roX = round(obstacles[i].x);
    if (roX >= dinoX - 1 && roX <= dinoX + 1) {
      if (rdY + 2 >= (obstacles[i].type == 1 ? 6 : 5)) {
         currentState = GAME_OVER;
      }
    }
  }
}

void loop() {
  switch (currentState) {
    case START:
      FastLED.clear();
      for(int i=0; i<32; i++) setSafeLed(i, 7, CRGB(20, 10, 0)); 
      drawDino(5, CRGB::Yellow);
      if (digitalRead(PIN_BTN_B) == LOW) initGame();
      break;

    case PLAYING:
      updatePhysics();
      FastLED.clear();
      for(int i=0; i<32; i++) setSafeLed(i, 7, CRGB(20, 10, 0)); 
      drawObstacles();
      drawDino(dinoY, CRGB::Yellow);
      break;

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

void setup() {
  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
  pinMode(PIN_BTN_A, INPUT_PULLUP);
  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.