Arduino Ideen

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

Wer kennt nicht die süchtig machenden "Endless Jumper" vom Smartphone? Mit Pixel Jump bringen wir dieses Spielprinzip auf den Arduino und eine Neopixel-Matrix. Es ist ein Projekt, das zeigt, wie viel Dynamik und Spieltiefe man aus nur 256 Pixeln herausholen kann. Mit flüssigem Scrolling, verschiedenen Plattform-Typen und einer präzisen Steuerung ist Langzeitspaß garantiert!

Das Spielprinzip

Pixel Jump ist ein vertikales Geschicklichkeitsspiel. Dein Ziel ist einfach: Springe immer höher, erreiche neue Ebenen und versuche, nicht nach unten aus dem Bildschirm zu fallen. Was einfach beginnt, wird durch verschiedene Plattformen schnell zur Herausforderung. Das Spiel besticht durch ein animiertes Startmenü und eine direkte Score-Anzeige auf der Matrix nach einem Game Over.

Gameplay & Features

Das Spielprinzip basiert auf automatischen Sprüngen (hüpfen) und taktischer Positionierung:

Die Plattformen:
- Grün: Deine sichere Basis (3 Pixel breit).
- Blau: Schmaler und schwieriger zu treffen (2 Pixel breit).
- Weiß: Nur für Profis erfordert pixelgenaues Landen (1 Pixel breit).
- Rot: Die Einweg-Plattform. Sie verschwindet sofort nach der ersten Berührung!
Die Steuerung: Über einen Joystick steuerst du deine gelbe Spielfigur horizontal. Ein besonderes Feature ist der Wrap-Around: Läufst du links aus dem Bild, erscheinst du rechts sofort wieder.
Das Scoring: Gezählt werden nicht die Reihen, sondern die geschafften Plattformen. Jede erreichte Ebene bringt dich näher an den Highscore. Der nach einem Game Over auf der Matrix angezeigt wird.

Verdrahtung Arduino, Neopixel und Joystickshield

Komponente	Pin am Arduino	Beschreibung
Neopixel Matrix	D9	Dateneingang (DIN) der 16x16 Matrix
Joystick X	A0	Horizontale Bewegung
Button B	D3	Start / Restart (mit internem Pullup)
Stromversorgung	5V / GND	Wichtig: Externes Netzteil.

Der Arduino Code mit FastLEDe

Der Code nutzt die FastLED-Bibliothek und ein effizientes State-Management, um ruckelfreies Gameplay zu ermöglichen. Die Score-Anzeige verwendet einen eigenen 3x5 Pixel Font, um Zahlen direkt auf der Matrix darzustellen.

Der Arduino Code für das Pixel Jump Spiel

// www.kreativekiste.de // 09.04.2026 // Version 7.1
// Pixel Jump

#include <FastLED.h>

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

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

const int WIDTH = 16;
const int HEIGHT = 16;
CRGB leds[NUM_LEDS];

// --- SPIEL-LOGIK ---
enum GameState { START, PLAYING, GAME_OVER };
enum PlatformType { GREEN, BLUE, RED, WHITE };

GameState currentState = START;

float playerX = 8.0;
float playerY = 10.0;
float velocityY = 0.0;
float worldScrollY = 0.0; 
int score = 0;

const float GRAVITY = 0.07;
const float JUMP_IMPULSE = -1.1;

// --- PLATTFORMEN ---
const int MAX_PLATFORMS = 4; 
struct Platform {
  float x, y;
  bool active;
  bool scored; 
  PlatformType type;
};
Platform platforms[MAX_PLATFORMS];

// --- 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 (3x5 FONT) ---
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();
  if (s > 999) s = 999;
  int hundreds = s / 100;
  int tens = (s / 10) % 10;
  int units = s % 10;

  if (s >= 100) {
    drawDigit(hundreds, 2, 5, CRGB::White);
    drawDigit(tens, 6, 5, CRGB::White);
    drawDigit(units, 10, 5, CRGB::White);
  } else if (s >= 10) {
    drawDigit(tens, 4, 5, CRGB::White);
    drawDigit(units, 8, 5, CRGB::White);
  } else {
    drawDigit(units, 6, 5, CRGB::White);
  }
}

// --- INITIALISIERUNG ---
void initGame() {
  playerX = 8.0;
  playerY = 8.0;      
  velocityY = 0.0;    
  worldScrollY = 0.0;
  score = 0;

  for (int i = 0; i < MAX_PLATFORMS; i++) {
    platforms[i].x = random(2, WIDTH - 3);
    platforms[i].y = 14 - (i * 5); 
    platforms[i].active = true;
    platforms[i].scored = false;
    platforms[i].type = GREEN; 
  }
  
  platforms[0].x = 8;
  platforms[0].y = 14;
  platforms[0].scored = true; 
  
  currentState = PLAYING;
  FastLED.setBrightness(BRIGHTNESS_GAME);
}

// --- LOGIK ---
void updatePhysics() {
  velocityY += GRAVITY;
  playerY += velocityY;

  int valX = analogRead(PIN_JOY_X);
  if (valX < 400) playerX -= 0.38; 
  if (valX > 600) playerX += 0.38; 

  if (playerX < 0) playerX = WIDTH - 1;
  if (playerX >= WIDTH) playerX = 0;

  if (velocityY > 0) { 
    for (int i = 0; i < MAX_PLATFORMS; i++) {
      if (!platforms[i].active) continue;

      bool hit = false;
      float xDist = playerX - platforms[i].x;

      if (abs(playerY - platforms[i].y) < 0.5) {
        if (platforms[i].type == GREEN || platforms[i].type == RED) {
          if (xDist > -1.5 && xDist < 1.5) hit = true; 
        } 
        else if (platforms[i].type == BLUE) {
          if (xDist > -0.5 && xDist < 1.5) hit = true; 
        } 
        else if (platforms[i].type == WHITE) {
          if (xDist > -0.5 && xDist < 0.5) hit = true;
        }

        if (hit) {
          velocityY = JUMP_IMPULSE;
          playerY = platforms[i].y - 0.4; 
          
          if (!platforms[i].scored) {
            score++;
            platforms[i].scored = true;
          }

          if (platforms[i].type == RED) platforms[i].active = false;
        }
      }
    }
  }

  float screenY = playerY - worldScrollY;
  if (screenY < 6.0) {
    float diff = 6.0 - screenY;
    worldScrollY -= diff;
  }

  for (int i = 0; i < MAX_PLATFORMS; i++) {
    if (platforms[i].y - worldScrollY > 15.5) { 
      platforms[i].y -= (MAX_PLATFORMS * 5.0); 
      platforms[i].x = random(2, WIDTH - 3);
      platforms[i].active = true;
      platforms[i].scored = false; 
      
      int r = random(0, 10);
      if (r < 4) platforms[i].type = GREEN;     
      else if (r < 6) platforms[i].type = BLUE; 
      else if (r < 8) platforms[i].type = RED;  
      else platforms[i].type = WHITE;           
    }
  }

  if (playerY - worldScrollY > 15.8) {
    currentState = GAME_OVER;
  }
}

void drawGame() {
  FastLED.clear();
  for (int i = 0; i < MAX_PLATFORMS; i++) {
    if (!platforms[i].active) continue;

    int py = floor(platforms[i].y - worldScrollY);
    if (py >= 0 && py < HEIGHT) {
      int px = round(platforms[i].x);
      CRGB pColor = CRGB::Green;
      
      if (platforms[i].type == BLUE) pColor = CRGB::Blue;
      else if (platforms[i].type == RED) pColor = CRGB::Red;
      else if (platforms[i].type == WHITE) pColor = CRGB::White;

      setSafeLed(px, py, pColor);
      
      if (platforms[i].type == GREEN || platforms[i].type == RED) {
        setSafeLed(px + 1, py, pColor);
        setSafeLed(px - 1, py, pColor);
      } else if (platforms[i].type == BLUE) {
        setSafeLed(px + 1, py, pColor); 
      }
    }
  }
  
  int sy = floor(playerY - worldScrollY);
  if (sy >= 0 && sy < HEIGHT) {
    setSafeLed(round(playerX), sy, CRGB::Yellow); 
  }
}

void loop() {
  switch (currentState) {
    case START:
      {
        FastLED.clear();
        // Menü-Animation: Plattform
        for(int x = 7; x <= 9; x++) setSafeLed(x, 12, CRGB::Green);
        // Menü-Animation: Hüpfender Ball
        float menuBounce = abs(sin(millis() * 0.005)) * 5; 
        setSafeLed(8, 11 - round(menuBounce), CRGB::Yellow);

        if (digitalRead(PIN_BTN_B) == LOW) initGame();
      }
      break;

    case PLAYING:
      updatePhysics();
      drawGame();
      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_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.