Digitales Mühle Spiel mit ESP32 und P3 LED-Modul LED-Matrix-Panel

Arduino Ideen

Details: Kategorie: Arduino neue Ideen; Erstellt: 24. Oktober 2026; Zugriffe: 13

Mühle ist eines der ältesten und beliebtesten Taktikspiele der Welt einfach zu lernen, aber voller strategischer und taktischer Tiefe. Ein ESP 32 und ein P3 LED-Modul LED-Matrix-Panel mit 192X192mm und 64x64 RGB SMD Pixel eignen sich hervorragt um dieses Spiel zu digitalisieren.

Das Prinzip ist simpel: Du trittst gegen deinen Mitspieler an und versuchst, drei eigene Steine in eine Reihe zu bringen, das ist dann eine „Mühle“. Gelingt dir das, darfst du einen gegnerischen Stein vom Brett werfen. Hast du nur noch drei Steine übrig, darfst du mit deinen Steinen auf jedes freie Feld springen. Verloren hat, wer noch 2 Steine besitzt oder sich nicht mehr bewegen kann.

Ablauf des digitalen Mühle Spieles:

Phase 1: SETZEN (PHASE_SETZEN)
- Aktiver Spieler: Rot beginnt, danach abwechselnd Blau (jeder hat 9 Steine am Rand).
- Feld ansteuern: Joystick bewegt den Cursor über die 24 Punkte.
- Stein platzieren: Druck auf Button 1 (KEY1) auf einem freien Feld.
  - Stein wird gesetzt (Randstein erlischt).
  - Prüfung auf Mühle:
    - Keine Mühle geschlossen: Wechsel zum anderen Spieler.
    - Mühle geschlossen (3er-Reihe): Wechsel zu Phase: KLAUEN (PHASE_MUEHLE).
- Ende der Setzphase: Sobald alle 18 Steine auf dem Feld liegen (unplacedRed == 0 und unplacedBlue == 0), prüft das System vor dem ersten Zug:
  - Ist der aktive Spieler blockiert? Ja → Der andere Spieler gewinnt sofort (Phase: GEWONNEN).
  - Nicht blockiert: Wechsel zu Phase 2 (WÄHLEN).

Phase 2: ZIEHEN & SPRINGEN
- 2.1 Stein auswählen (PHASE_WAEHLEN)
  - Display zeigt ROT WAEHLT bzw. BLAU WAEHLT.
  - Spieler steuert einen eigenen Stein an.
  - Druck auf Button 1 nimmt den Stein auf → Stein beginnt gelb zu blinken.
  - Status wechselt zu PHASE_BEWEGEN.
- 2.2 Stein bewegen (PHASE_BEWEGEN)
  - Display zeigt ROT ZIEHT bzw. BLAU ZIEHT.
  - Spieler steuert das Zielfeld an.
  - Aktion A (Abbrechen): Klick erneut auf denselben gelben Stein → Stein wird abgelegt, zurück zu PHASE_WAEHLEN.
  - Aktion B (Setzen auf freies Feld):
    - Regelprüfung Normalzug (> 3 Steine): Zielfeld muss ein direkt verbundener Nachbar auf der Linie sein.
    - Regelprüfung Springen (≤ 3 Steine): Zielfeld darf jedes beliebige freie Feld auf dem gesamten Brett sein.
    - Ungültiger Zug: Nichts passiert.
    - Gültiger Zug: Stein wechselt die Position.
  - Prüfung nach dem Zug:
    - Mühle geschlossen: Wechsel zu Phase: KLAUEN (PHASE_MUEHLE).
    - Keine Mühle: Spielerwechsel → Blockade-Prüfung.
- 2.3 Blockade-Prüfung (Vor jedem Zugwechsel)
  - Hat der jetzt ankommende Spieler mindestens einen gültigen Zug?
  - Nein (vollständig eingesperrt und ≤ 3 Steine nicht erfüllt): Der andere Spieler gewinnt sofort (Phase: GEWONNEN).
  - Ja: Wechsel zu PHASE_WAEHLEN für den nächsten Spieler.

Sonderzustand: KLAUEN (PHASE_MUEHLE)
- Display zeigt ROT KLAUT bzw. BLAU KLAUT. Cursor blinkt magenta.
- Aktiver Spieler steuert einen gegnerischen Stein an.
- Druck auf Button 1 prüft die Klau-Regel:
  - Stein steckt in geschlossener gegnerischer Mühle: Ungültig (darf nicht geschlagen werden).
  - Ausnahme: Hat der Gegner ausschließlich Steine in Mühlen, darf jeder Stein geschlagen werden.
- Bei gültiger Wahl: Gegnerischer Stein wird vom Brett gelöscht.
- Siegprüfung nach Klauen:
  - Hat der Gegner jetzt weniger als 3 Steine auf dem Feld?
    - Ja (nur noch 2 Steine): Aktiver Spieler gewinnt → Wechsel zu Phase: GEWONNEN.
    - Nein: Spielerwechsel → Blockade-Prüfung → zurück zu PHASE_WAEHLEN (oder weiter PHASE_SETZEN, falls noch in Phase 1).

Phase 3: SPIELENDE (PHASE_GEWONNEN)
- Textanzeige: ROT SIEGT oder BLAU SIEGT.
- Alle Spielereingaben und Cursorelemente auf dem Feld werden gesperrt.
- Neustart: Druck auf Button 1 (KEY1) setzt alle Variablen, Arrays und Steine auf den Anfangszustand zurück (Phase 1: SETZEN).

Globaler Interrupt: HARD-RESET (Jederzeit aktiv)
- Taste 2 (btn2) wird gedrückt gehalten.
- Nach 2 Sekunden Dauerbetätigung: Sofortiger Abbruch des laufenden Spiels und Rückkehr zu Phase 1: SETZEN.

Der Mühle ESP32 Code für den Empfänger

Der ESP32 DevKit liest die analogen X/Y-Werte des Joysticks sowie die beiden Tasterzustände zyklisch über die GPIOs ein. Durch die internen Pull-up-Widerstände werden keine externen Widerstände benötigt, während die Pegel im Code direkt für eine saubere Tastenlogik invertiert werden. Ein kompaktes Daten-Struct bündelt Achsen- und Tasterdaten speichereffizient in einem einzigen fest definierten Übertragungspaket. Das vorab genullte peerInfo-Struct (memset) verhindert Initialisierungsfehler und sorgt für eine saubere Kopplung im ESP-NOW-Stack. Die Steuerdaten werden alle 50 ms ohne Router direkt per ESP-NOW an das Matrix-Panel übertragen – latenzfrei und mit minimaler Funklast.

  #include <WiFi.h>
#include <esp_now.h>

// HIER DIE MAC-ADRESSE DES EMPFÄNGERS EINTRAGEN
uint8_t broadcastAddress[] = {0x14, 0xC1, 0x9F, 0xCD, 0x6D, 0x3C};

// Pin-Belegung am ESP32 DEV (Du kannst diese an deine Verkabelung anpassen)
const int PIN_JOY_X = 32; // Verbinden mit OUTX am Joystick
const int PIN_JOY_Y = 33; // Verbinden mit OUTY am Joystick
const int PIN_BTN_1 = 25; // Verbinden mit KEY1 am Joystick
const int PIN_BTN_2 = 26; // Verbinden mit KEY2 am Joystick

// Die Datenstruktur: Dieses Paket wird gesendet.
// WICHTIG: Der Empfänger braucht exakt das gleiche struct!
typedef struct struct_message {
  int x;
  int y;
  bool btn1;
  bool btn2;
} struct_message;

// Eine Variable unseres Datenpakets erstellen
struct_message myData;
esp_now_peer_info_t peerInfo;

void setup() {
  Serial.begin(115200);

  // Pin-Modus einstellen. 
  // Da Taster meistens gegen GND (Masse) schalten, nutzen wir den internen Pullup-Widerstand.
  pinMode(PIN_BTN_1, INPUT_PULLUP);
  pinMode(PIN_BTN_2, INPUT_PULLUP);

  WiFi.mode(WIFI_STA);

  if (esp_now_init() != ESP_OK) {
    Serial.println("Fehler beim Initialisieren von ESP-NOW");
    return;
  }

  // Den Matrix-ESP als Empfänger bekannt machen
  memset(&peerInfo, 0, sizeof(peerInfo)); // WICHTIG: Stellt sicher, dass das Struct sauber genullt ist
  memcpy(peerInfo.peer_addr, broadcastAddress, 6);
  peerInfo.channel = 0;  
  peerInfo.encrypt = false;
  
  if (esp_now_add_peer(&peerInfo) != ESP_OK) {
    Serial.println("Fehler beim Hinzufügen des Empfängers");
    return;
  }
}

void loop() {
  // Joystick-Werte (0 bis 4095) auslesen und ins Paket packen
  myData.x = analogRead(PIN_JOY_X);
  myData.y = analogRead(PIN_JOY_Y);
  
  // Taster auslesen. 
  // Das Ausrufezeichen (!) invertiert den Wert: 
  // Wenn gedrückt (LOW) -> bool wird true (1). Wenn nicht gedrückt (HIGH) -> bool wird false (0).
  myData.btn1 = !digitalRead(PIN_BTN_1);
  myData.btn2 = !digitalRead(PIN_BTN_2);
  
  // Das Datenpaket absenden
  esp_err_t result = esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData));
  
  // Eine kurze Pause von 50ms reicht völlig aus. 
  // Das ergibt ca. 20 Aktualisierungen pro Sekunde – flüssig genug für ein Mühle-Spiel und müllt den Funkkanal nicht zu.
  delay(50);
}

Anschluss des Senders für die Eingabe

+-----------------------+              +-----------------------+
|  OPEN-SMART Joystick  |              |     ESP32 DevKit      |
|     Control Board     |              |                       |
|                       |              |                       |
|                   GND +--------------+ GND                   |
|                   VCC +--------------+ 3V3                   |
|                  OUTX +--------------+ GPIO 32 (ADC1_CH4)    |
|                  OUTY +--------------+ GPIO 33 (ADC1_CH5)    |
|                  OUTZ | (nicht belegt)                       |
|                  KEY1 +--------------+ GPIO 25 (Aktion)      |
|                  KEY2 +--------------+ GPIO 26 (Reset 2s)    |
|                  KEY3 | (nicht belegt)                       |
|                  KEY4 | (nicht belegt)                       |
+-----------------------+              +-----------------------+

Der Arduino Code für das Spiel

Der Empfänger-ESP steuert die 64x64 Matrix über DMA an und empfängt die Joystick- und Tastensignale latenzfrei über ESP-NOW. Alle 24 Spielfeldpunkte sind als fester Graph hinterlegt, sodass der Cursor sauber an den Linien entlang von Knoten zu Knoten springt. Ein zentraler Zustandsautomat regelt den Spielablauf vom Setzen über das Ziehen und Springen bis zum Klauen bei geschlossener Mühle. Mühlen sowie Sieg- und Blockadebedingungen werden nach jedem Zug automatisch mathematisch im Array überprüft. Zusätzlich sind ein blinkender Farbcursor für die Spielerführung sowie ein blockierungsfreier 2-Sekunden-Sicherheitsreset über Taster 2 integriert.

  #include <ESP32-HUB75-MatrixPanel-I2S-DMA.h>
#include <WiFi.h>
#include <esp_now.h>

// --- Matrix Pin-Belegung ---
const int PIN_R1  = 18; const int PIN_G1  = 8;  const int PIN_B1  = 17;
const int PIN_R2  = 16; const int PIN_G2  = 1;  const int PIN_B2  = 15;
const int PIN_A   = 7;  const int PIN_B   = 48; const int PIN_C   = 6;
const int PIN_D   = 47; const int PIN_E   = 2;
const int PIN_OE  = 4;  const int PIN_CLK = 5;  const int PIN_LAT = 21; 

MatrixPanel_I2S_DMA *dma_display = nullptr;

// --- ESP-NOW Datenstruktur ---
typedef struct struct_message {
  int x;
  int y;
  bool btn1;
  bool btn2;
} struct_message;
struct_message myData;

// --- Spiellogik & Variablen ---
uint16_t colorBoard;
uint16_t colorRed;
uint16_t colorBlue;
uint16_t colorYellow;
uint16_t colorMagenta; 

enum GamePhase {
  PHASE_SETZEN,
  PHASE_WAEHLEN,
  PHASE_BEWEGEN,
  PHASE_MUEHLE, 
  PHASE_GEWONNEN 
};
GamePhase currentPhase = PHASE_SETZEN;

int currentPlayer = 1; 
int winner = 0;        

int unplacedRed = 9;     
int unplacedBlue = 9;
int activeRed = 0;
int activeBlue = 0;
int board[24] = {0};   

int cursorNode = 0;    
int selectedNode = -1; 

// Variablen für Taster und Timer
bool lastBtn1State = false;
unsigned long lastMoveTime = 0;
bool isBtn2Pressed = false;
unsigned long btn2PressStartTime = 0;
bool resetTriggered = false;

// Exakte X/Y Koordinaten für die 24 Mühle-Kreuzungen
const int nodesX[24] = {7, 30, 53, 15, 30, 45, 23, 30, 37, 7, 15, 23, 37, 45, 53, 23, 30, 37, 15, 30, 45, 7, 30, 53};
const int nodesY[24] = {11, 11, 11, 19, 19, 19, 27, 27, 27, 34, 34, 34, 34, 34, 34, 41, 41, 41, 49, 49, 49, 57, 57, 57};

// Navigations-Matrix: {OBEN, UNTEN, LINKS, RECHTS}
const int nav[24][4] = {
  /* 0*/ {-1,  9, -1,  1}, /* 1*/ {-1,  4,  0,  2}, /* 2*/ {-1, 14,  1, -1},
  /* 3*/ {-1, 10, -1,  4}, /* 4*/ { 1,  7,  3,  5}, /* 5*/ {-1, 13,  4, -1},
  /* 6*/ {-1, 11, -1,  7}, /* 7*/ { 4, -1,  6,  8}, /* 8*/ {-1, 12,  7, -1},
  /* 9*/ { 0, 21, -1, 10}, /*10*/ { 3, 18,  9, 11}, /*11*/ { 6, 15, 10, -1},
  /*12*/ { 8, 17, -1, 13}, /*13*/ { 5, 20, 12, 14}, /*14*/ { 2, 23, 13, -1},
  /*15*/ {11, -1, -1, 16}, /*16*/ {-1, 19, 15, 17}, /*17*/ {12, -1, 16, -1},
  /*18*/ {10, -1, -1, 19}, /*19*/ {16, 22, 18, 20}, /*20*/ {13, -1, 19, -1},
  /*21*/ { 9, -1, -1, 22}, /*22*/ {19, -1, 21, 23}, /*23*/ {14, -1, 22, -1}
};

const int mills[16][3] = {
  {0, 1, 2}, {3, 4, 5}, {6, 7, 8},          
  {9, 10, 11}, {12, 13, 14},                
  {15, 16, 17}, {18, 19, 20}, {21, 22, 23}, 
  {0, 9, 21}, {3, 10, 18}, {6, 11, 15},     
  {1, 4, 7}, {16, 19, 22},                  
  {8, 12, 17}, {5, 13, 20}, {2, 14, 23}     
};

bool checkMill(int node, int player) {
  for (int i = 0; i < 16; i++) {
    if (mills[i][0] == node || mills[i][1] == node || mills[i][2] == node) {
      if (board[mills[i][0]] == player && board[mills[i][1]] == player && board[mills[i][2]] == player) {
        return true;
      }
    }
  }
  return false;
}

// NEU: Prüft, ob der angegebene Spieler komplett eingesperrt ist
bool checkIfBlocked(int player) {
  // Wenn der Spieler noch ungesetzte Steine hat, ist er nie blockiert
  if (player == 1 && unplacedRed > 0) return false;
  if (player == 2 && unplacedBlue > 0) return false;

  // Wenn der Spieler springen darf (3 oder weniger Steine), ist er nie blockiert
  if (player == 1 && activeRed <= 3) return false;
  if (player == 2 && activeBlue <= 3) return false;

  // Prüfen, ob mindestens ein Stein des Spielers einen freien direkten Nachbarn hat
  for (int i = 0; i < 24; i++) {
    if (board[i] == player) {
      for (int d = 0; d < 4; d++) { // Alle 4 Richtungen checken
        int neighbor = nav[i][d];
        if (neighbor != -1 && board[neighbor] == 0) {
          return false; // Ein legaler Zug wurde gefunden, nicht blockiert!
        }
      }
    }
  }
  return true; // Kein einziger Zug möglich -> Eingesperrt!
}

void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) {
  memcpy(&myData, incomingData, sizeof(myData));
}

void setup() {
  Serial.begin(115200);

  WiFi.mode(WIFI_STA);
  if (esp_now_init() != ESP_OK) return;
  esp_now_register_recv_cb(esp_now_recv_cb_t(OnDataRecv));

  HUB75_I2S_CFG mxconfig(64, 64, 1);
  mxconfig.gpio.r1 = PIN_R1; mxconfig.gpio.g1 = PIN_G1; mxconfig.gpio.b1 = PIN_B1;
  mxconfig.gpio.r2 = PIN_R2; mxconfig.gpio.g2 = PIN_G2; mxconfig.gpio.b2 = PIN_B2;
  mxconfig.gpio.a  = PIN_A;  mxconfig.gpio.b  = PIN_B;  mxconfig.gpio.c  = PIN_C;
  mxconfig.gpio.d  = PIN_D;  mxconfig.gpio.e  = PIN_E;  
  mxconfig.gpio.lat = PIN_LAT; mxconfig.gpio.oe = PIN_OE; mxconfig.gpio.clk = PIN_CLK;
  mxconfig.driver = HUB75_I2S_CFG::FM6124;
  mxconfig.i2sspeed = HUB75_I2S_CFG::HZ_10M; 
  mxconfig.clkphase = false;
  mxconfig.double_buff = true; 

  dma_display = new MatrixPanel_I2S_DMA(mxconfig);
  dma_display->begin();
  dma_display->setBrightness8(60); 

  colorBoard   = dma_display->color565(100, 100, 100); 
  colorRed     = dma_display->color565(255, 0, 0);
  colorBlue    = dma_display->color565(0, 0, 255);
  colorYellow  = dma_display->color565(255, 255, 0);
  colorMagenta = dma_display->color565(255, 0, 255);
}

void resetGame() {
  currentPlayer = 1;
  unplacedRed = 9;     
  unplacedBlue = 9;
  activeRed = 0;
  activeBlue = 0;
  for(int i = 0; i < 24; i++) board[i] = 0;
  cursorNode = 0;    
  selectedNode = -1; 
  winner = 0;
  currentPhase = PHASE_SETZEN;
}

void drawBoard() {
  dma_display->drawRect(8, 12, 48, 48, colorBoard);
  dma_display->drawRect(9, 13, 46, 46, colorBoard);
  dma_display->drawRect(16, 20, 32, 32, colorBoard);
  dma_display->drawRect(17, 21, 30, 30, colorBoard);
  dma_display->drawRect(24, 28, 16, 16, colorBoard);
  dma_display->drawRect(25, 29, 14, 14, colorBoard);
  
  dma_display->fillRect(31, 12, 2, 16, colorBoard);
  dma_display->fillRect(31, 44, 2, 16, colorBoard);
  dma_display->fillRect(8, 35, 16, 2, colorBoard);
  dma_display->fillRect(40, 35, 16, 2, colorBoard);
}

void drawSideStones() {
  int startY = 14; 
  for(int i = 0; i < unplacedRed; i++) dma_display->fillRect(2, startY + (i * 5), 3, 3, colorRed);
  for(int i = 0; i < unplacedBlue; i++) dma_display->fillRect(59, startY + (i * 5), 3, 3, colorBlue);
}

void drawPlacedStones() {
  for(int i = 0; i < 24; i++) {
    if (i == selectedNode) continue; 
    if(board[i] == 1) dma_display->fillRect(nodesX[i], nodesY[i], 4, 4, colorRed);
    if(board[i] == 2) dma_display->fillRect(nodesX[i], nodesY[i], 4, 4, colorBlue);
  }
}

void drawUI() {
  dma_display->setTextSize(1); 
  dma_display->setTextWrap(false);
  
  if (currentPhase == PHASE_GEWONNEN) {
    if (winner == 1) {
      dma_display->setTextColor(colorRed);
      dma_display->setCursor(5, 2); 
      dma_display->print("ROT SIEGT");
    } else {
      dma_display->setTextColor(colorBlue);
      dma_display->setCursor(2, 2); 
      dma_display->print("BLAU SIEGT");
    }
  } else {
    if(currentPlayer == 1) {
      dma_display->setTextColor(colorRed);
      dma_display->setCursor(2, 2); 
      if (currentPhase == PHASE_SETZEN)  dma_display->print("ROT SETZT");
      if (currentPhase == PHASE_WAEHLEN) dma_display->print("ROT WAEHLT");
      if (currentPhase == PHASE_BEWEGEN) dma_display->print("ROT ZIEHT");
      if (currentPhase == PHASE_MUEHLE)  dma_display->print("ROT KLAUT");
    } else {
      dma_display->setTextColor(colorBlue);
      dma_display->setCursor(2, 2); 
      if (currentPhase == PHASE_SETZEN)  dma_display->print("BLAU SETZT");
      if (currentPhase == PHASE_WAEHLEN) dma_display->print("BLAU WAEHLT");
      if (currentPhase == PHASE_BEWEGEN) dma_display->print("BLAU ZIEHT");
      if (currentPhase == PHASE_MUEHLE)  dma_display->print("BLAU KLAUT");
    }
  }
}

void finishTurn(int placedNode) {
  if (checkMill(placedNode, currentPlayer)) {
    currentPhase = PHASE_MUEHLE; 
  } else {
    currentPlayer = (currentPlayer == 1) ? 2 : 1;
    if (unplacedRed == 0 && unplacedBlue == 0) {
      // NEU: Blockade-Check vor der Wahl-Phase
      if (checkIfBlocked(currentPlayer)) {
        winner = (currentPlayer == 1) ? 2 : 1;
        currentPhase = PHASE_GEWONNEN;
      } else {
        currentPhase = PHASE_WAEHLEN;
      }
    } else {
      currentPhase = PHASE_SETZEN;
    }
  }
}

void processInput() {
  // 1. Joystick Bewegung
  if (currentPhase != PHASE_GEWONNEN && millis() - lastMoveTime > 200) {
    int next = -1;
    if (myData.y > 3000) next = nav[cursorNode][0];      
    else if (myData.y < 1000) next = nav[cursorNode][1]; 
    else if (myData.x < 1000) next = nav[cursorNode][2]; 
    else if (myData.x > 3000) next = nav[cursorNode][3]; 

    if (next != -1) {
      cursorNode = next;
      lastMoveTime = millis();
    }
  }

  // 2. Permanenter Reset über btn2 (2 Sekunden gedrückt halten)
  if (myData.btn2) {
    if (!isBtn2Pressed) {
      isBtn2Pressed = true;
      btn2PressStartTime = millis();
      resetTriggered = false;
    } else if (!resetTriggered && (millis() - btn2PressStartTime >= 2000)) {
      resetGame();
      resetTriggered = true; 
    }
  } else {
    isBtn2Pressed = false;
  }

  // 3. Normale Aktionstaste btn1
  if (myData.btn1 && !lastBtn1State) { 
    
    if (currentPhase == PHASE_GEWONNEN) {
      resetGame();
    }
    else if (currentPhase == PHASE_SETZEN) {
      if (board[cursorNode] == 0) { 
        if (currentPlayer == 1 && unplacedRed > 0) {
          board[cursorNode] = 1;
          unplacedRed--;
          activeRed++;
          finishTurn(cursorNode);
        } 
        else if (currentPlayer == 2 && unplacedBlue > 0) {
          board[cursorNode] = 2;
          unplacedBlue--;
          activeBlue++;
          finishTurn(cursorNode);
        }
      }
    }
    else if (currentPhase == PHASE_WAEHLEN) {
      if (board[cursorNode] == currentPlayer) { 
        selectedNode = cursorNode;
        currentPhase = PHASE_BEWEGEN;
      }
    }
    else if (currentPhase == PHASE_BEWEGEN) {
      if (cursorNode == selectedNode) { 
        selectedNode = -1;
        currentPhase = PHASE_WAEHLEN;
      } 
      else if (board[cursorNode] == 0) {
        bool canFly = (currentPlayer == 1 && activeRed <= 3) || (currentPlayer == 2 && activeBlue <= 3);
        bool isValidMove = false;

        if (canFly) {
          isValidMove = true; 
        } else {
          for (int i = 0; i < 4; i++) {
            if (nav[selectedNode][i] == cursorNode) isValidMove = true;
          }
        }
        
        if (isValidMove) {
          board[selectedNode] = 0;             
          board[cursorNode] = currentPlayer;   
          selectedNode = -1;                   
          finishTurn(cursorNode);              
        }
      }
    }
    else if (currentPhase == PHASE_MUEHLE) {
      int opponent = (currentPlayer == 1) ? 2 : 1;
      
      if (board[cursorNode] == opponent) {
        bool isPartofMill = checkMill(cursorNode, opponent);
        bool canSteal = true;

        if (isPartofMill) {
          canSteal = false;
          bool allInMills = true;
          for (int i = 0; i < 24; i++) {
            if (board[i] == opponent && !checkMill(i, opponent)) {
              allInMills = false;
              break;
            }
          }
          if (allInMills) canSteal = true; 
        }

        if (canSteal) {
          board[cursorNode] = 0; 
          
          if (opponent == 1) activeRed--;
          else activeBlue--;

          if (unplacedRed == 0 && activeRed < 3) {
            winner = 2; 
            currentPhase = PHASE_GEWONNEN;
          } 
          else if (unplacedBlue == 0 && activeBlue < 3) {
            winner = 1; 
            currentPhase = PHASE_GEWONNEN;
          } 
          else {
            currentPlayer = opponent;
            if (unplacedRed == 0 && unplacedBlue == 0) {
              // NEU: Blockade-Check, bevor der Bestohlene an die Reihe kommt
              if (checkIfBlocked(currentPlayer)) {
                winner = (currentPlayer == 1) ? 2 : 1;
                currentPhase = PHASE_GEWONNEN;
              } else {
                currentPhase = PHASE_WAEHLEN;
              }
            } else {
              currentPhase = PHASE_SETZEN;
            }
          }
        }
      }
    }
  }
  lastBtn1State = myData.btn1;
}

void loop() {
  processInput();

  dma_display->clearScreen();
  drawBoard();
  drawSideStones();
  drawPlacedStones();
  drawUI();

  if (currentPhase != PHASE_GEWONNEN) {
    if (selectedNode != -1) {
      if ((millis() / 200) % 2 == 0) {
        dma_display->fillRect(nodesX[selectedNode], nodesY[selectedNode], 4, 4, colorYellow);
      } else {
        uint16_t pColor = (currentPlayer == 1) ? colorRed : colorBlue;
        dma_display->fillRect(nodesX[selectedNode], nodesY[selectedNode], 4, 4, pColor);
      }
    }

    if ((millis() / 300) % 2 == 0) {
      if (currentPhase == PHASE_MUEHLE) {
        dma_display->drawRect(nodesX[cursorNode]-1, nodesY[cursorNode]-1, 6, 6, colorMagenta);
      } else {
        uint16_t cColor = (currentPlayer == 1) ? colorRed : colorBlue;
        if (board[cursorNode] == 0) {
          dma_display->fillRect(nodesX[cursorNode], nodesY[cursorNode], 4, 4, cColor);
        } else {
          dma_display->drawRect(nodesX[cursorNode]-1, nodesY[cursorNode]-1, 6, 6, dma_display->color565(0,255,0)); 
        }
      }
    }
  }

  dma_display->flipDMABuffer();
  delay(30); 
}

Anschluss des Empfängers für die Ausgabe

+-----------------------+
|  5V Netzteil (>= 4A)  |
+-----------+-----------+
            |
            | 5V & GND (Schraubklemmen / Hohlstecker)
            v
+-----------+-----------------------------------------------+
|     SEENGREAT Adapter Board REV 2.2                       |
|                                                           |
|   [ Eingesteckter ESP32-S3-DevKitC-1 ]                    |
|   (Empfängt Steuersignale kabellos über ESP-NOW)          |
|                                                           |
|   [5V Ausgangsklemmen]              [HUB75 Flachband-     |
|                                      Wannenstecker 16P]   |
+-----------+----------------------------------+------------+
            |                                  |
            | 5V Stromversorgung               | 16-poliges
            | (Rot/Schwarz Litzen)             | HUB75 Datenkabel
            v                                  v
+-----------+----------------------------------+------------+
|             64x64 RGB LED Matrix Panel                    |
|                                                           |
|             [Strom-Eingang]       [HUB75 DATA IN]         |
+-----------------------------------------------------------+

Ronnie

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

logickiste

Blockly für Arduino: Grafische Programmierung als echtes C++ Werkzeug
für deine eigenen, kreativen Projekte und Ideen auf hohem Niveau.

https://www.logickiste.de/

blockly for arduino