Arduino Ideen

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

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!

Eines von 60 Highlights aus meiner Neopixel-Spielesammlung!

Der Startbildschirm, ein Pixel hüpft auf einem Brett.........

Das Spielprinzip

Pixel Jump ist ein vertikales Geschicklichkeitsspiel, das sich für die 32x8 Pixel ideal anbietet. Das Ziel ist einfach: Springe immer höher, erreiche neue Ebenen und versuche, nicht nach unten aus dem Pixelrand zu fallen. Was einfach beginnt, wird durch verschiedene Plattformen schnell zur Herausforderung. Das Spiel besticht durch ein animiertes Startmenü und eine direkte Score-Anzeige nach einem Game Over, die auf dem "als kleiner Spaß" Kopf zu lesen ist.

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 R4 (R3 ist zu lahm)	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 Tower Power Spiel

// www.kreativekiste.de // 13.04.2026 // Version 7.8
// Pixel Jump - Tower Power

#include <FastLED.h>

// --- KONFIGURATION ---
#define DATA_PIN 9
#define NUM_LEDS 256
#define BRIGHTNESS_GAME 5
#define BRIGHTNESS_MENU 8

#define PIN_JOY_X A0
#define PIN_BTN_B 3

#define WIDTH 8
#define HEIGHT 32
CRGB leds[NUM_LEDS];

// Joystick: Deadzone (neutral 400–600), sanfte Beschleunigung
#define JOY_LEFT_MAX 400
#define JOY_RIGHT_MIN 600
#define JOY_MAX_SPEED 0.35f
#define JOY_ACCEL 0.22f

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

GameState currentState = START;

float playerX = 4.0;
float playerY = 24.0;
float lastPlayerY = 24.0;
float velocityY = 0.0;
float playerVelX = 0.0f;
float worldScrollY = 0.0;
int score = 0;

#define GRAVITY 0.075f
#define JUMP_IMPULSE -1.18f
#define MAX_FALL_SPEED 1.8f   // FIX: Terminalgeschwindigkeit verhindert Durchfallen

// --- PLATTFORMEN ---
#define MAX_PLATFORMS 6
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 (y % 2 == 0) return (y * WIDTH) + x;
  else return (y * WIDTH) + (WIDTH - 1 - x);
}

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

int wrapX(int x) {
  while (x < 0) x += WIDTH;
  while (x >= WIDTH) x -= WIDTH;
  return x;
}

bool platformHitsPlayerX(const Platform& p, int playerPixelX) {
  int px = round(p.x);

  if (p.type == GREEN || p.type == RED) {
    return playerPixelX == wrapX(px - 1) ||
           playerPixelX == wrapX(px) ||
           playerPixelX == wrapX(px + 1);
  } else if (p.type == BLUE) {
    return playerPixelX == wrapX(px) ||
           playerPixelX == wrapX(px + 1);
  } else {
    return playerPixelX == wrapX(px);
  }
}

// --- 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();
  if (s > 99) s = 99;
  int tens = (s / 10) % 10;
  int units = s % 10;
  if (s >= 10) {
    drawDigit(tens, 0, 13, CRGB::White);
    drawDigit(units, 4, 13, CRGB::White);
  } else {
    drawDigit(units, 2, 13, CRGB::White);
  }
}

void initGame() {
  playerX = 4.0;
  playerY = 24.0;
  lastPlayerY = 24.0;
  velocityY = 0.0;
  playerVelX = 0.0f;
  worldScrollY = 0.0;
  score = 0;

  for (int i = 0; i < MAX_PLATFORMS; i++) {
    platforms[i].x = random(1, WIDTH - 2);
    platforms[i].y = 28 - (i * 6);
    platforms[i].active = true;
    platforms[i].scored = false;
    platforms[i].type = GREEN;
  }
  platforms[0].x = 4;
  platforms[0].y = 28;
  platforms[0].scored = true;

  currentState = PLAYING;
  FastLED.setBrightness(BRIGHTNESS_GAME);
}

void updateJoystick() {
  int valX = analogRead(PIN_JOY_X);

  float targetVel = 0.0f;
  if (valX < JOY_LEFT_MAX) targetVel = JOY_MAX_SPEED;
  else if (valX > JOY_RIGHT_MIN) targetVel = -JOY_MAX_SPEED;

  playerVelX += (targetVel - playerVelX) * JOY_ACCEL;
  if (playerVelX > JOY_MAX_SPEED) playerVelX = JOY_MAX_SPEED;
  if (playerVelX < -JOY_MAX_SPEED) playerVelX = -JOY_MAX_SPEED;

  playerX += playerVelX;

  if (playerX < 0) playerX += WIDTH;
  if (playerX >= WIDTH) playerX -= WIDTH;
}

void updatePhysics() {
  lastPlayerY = playerY;
  velocityY += GRAVITY;

  // FIX: Terminalgeschwindigkeit – verhindert, dass der Spieler bei langem
  // Fall in einem einzigen Frame durch eine Plattform hindurchrauscht
  if (velocityY > MAX_FALL_SPEED) velocityY = MAX_FALL_SPEED;

  playerY += velocityY;

  updateJoystick();

  if (velocityY > 0) {
    int playerPixelX = wrapX(round(playerX));

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

      float py = platforms[i].y;

      // FIX: Robusterer Swept-Check – prüft ob der Spieler in diesem Frame
      // die Plattform-Ebene von oben nach unten überquert hat
      bool crossedPlatform = (lastPlayerY < py + 0.3f) && (playerY >= py - 0.3f);
      if (!crossedPlatform) continue;

      if (platformHitsPlayerX(platforms[i], playerPixelX)) {
        velocityY = JUMP_IMPULSE;
        playerY = py - 0.01f;
        if (!platforms[i].scored) {
          score++;
          platforms[i].scored = true;
        }
        if (platforms[i].type == RED) platforms[i].active = false;
        break;
      }
    }
  }

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

  for (int i = 0; i < MAX_PLATFORMS; i++) {
    if (platforms[i].y - worldScrollY > 33.0) {
      platforms[i].y -= (MAX_PLATFORMS * 6.0);
      platforms[i].x = random(1, WIDTH - 2);
      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 > 33.0) 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) {
        // FIX: wrapX sichert korrekte Darstellung am linken/rechten Rand
        setSafeLed(wrapX(px + 1), py, pColor);
        setSafeLed(wrapX(px - 1), py, pColor);
      } else if (platforms[i].type == BLUE) {
        setSafeLed(wrapX(px + 1), py, pColor);
      }
    }
  }

  int sy = floor(playerY - worldScrollY);
  if (sy >= 0 && sy < HEIGHT) {
    // FIX: wrapX stellt sicher, dass Darstellung und Kollision identisch sind
    setSafeLed(wrapX(round(playerX)), sy, CRGB::Yellow);
  }
}

void loop() {
  switch (currentState) {
    case START:
      FastLED.clear();
      for (int x = 3; x <= 5; x++) setSafeLed(x, 26, CRGB::Green);
      setSafeLed(4, 25 - round(abs(sin(millis() * 0.005)) * 4), 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.