Components
	Arduino Nano R3	x 1
	8x8 RGB LED matrix with WS2812 chips	x 1
	Buzzer	x 1
	Pushbutton Switch	x 1
Tools, APP Software Used etc.
	arduino IDE Arduino
	Soldering Iron Kit
Description
Arduino Connect4 Game- Human vs Microcontroller

Connect Four is a two-player strategy game in which the players take turns dropping colored discs into a vertical grid. The objective of the game is to connect four of one's own discs of the same color vertically, horizontally, or diagonally before your opponent does.
In one of my previous videos I described a way to make such a game on a TFT touch screen. This time I will explain to you how to make a Connect4 game on an 8 x 8 pixel matrix with 5050 type LEDs with a built-in WS2812B chip.
Also now we have two game modes, player vs player and player vs microcontroller. You can find the original code at: az-delivery
, and then this code was reworked by Mr. Küster adding the ability to play against a microcontroller. I also added simple sounds with help of "NewTone" library , so the game now is even more interesting.
Otherwise, the device is very simple to build and contains several components:
- Arduino Nano microcontroller
- 8x8 RGB matrix with WS2812 led chips
- Three buttons,
- and Buzzer
Also for the led matrix I made a dedicated grid on a 3D Printer for a better visual impression. Tracing paper is placed on the grid for light diffusion, and then a protective transparent film.
Let's see how the game works in reality:
After starting the device, with the left button we select player vs player mode, while with the right button player vs microcontroller. In Player vs. Player, the starting color will be changed with each new game, and in Player vs. Microcontroller, the player always has red and begins the first game. After that, the loser always begins. First we will start a game player against the microcontroller, which is indicated by a continuous higher tone. Player is in red, and start first. At the end, if the microcontroller wins, display shows a smiling figure, and if Player win, then figure is sad.
The next mod is player vs player. This mode is indicated by a continuous lower tone. After one of the players wins, a line is indicated by three short flashes followed by a high-pitched sound, and then the entire screen lights up with the winner's color.
The device is built into a box from a my previous project , which is made of 3 and 5 mm PVC board, lined with self-adhesive colored wallpaper.
Code
Arduino code
C/C++
/* Vier gewinnt - entweder zwei Spieler (linke Richtungstaste)oder Spieler gegen MCU (rechte Richtungstaste)
 *  Bei Spieler gegen Spieler wird die Anfangsfarbe bei jedem neuer Spiel gewechselt. 
 *  Bei Spieler gegen Rechner hat der Spieler immer rot und beginnt das erste Spiel. Danach beginnt immer der Verlierer.
 *  Man benötigt: https://www.az-delivery.de/products/u-64-led-panel an 5V, GND und Pin 6
 *  https://www.az-delivery.de/products/nano-v3-0-pro
 *  sowie Spiele-Controller mit 3 Tastern (Buttons) an folgenden Pins:
 *  rechts = 10, links = 9 und runter = 8
 *  Es gibt die Möglichkeit, sich die Auswertungstabellen auf dem Bildschirm anzeigen zu lassen. 
 *  Dazu muss man in der Zeile 704 das Kommentarzeichen entfernen. 
 *  Allerdings wird dann das Programm etwas langsamer.
 *  Am Ende des Programms ist dazu noch eine kurze Erklärung.
 *  HUK Vier_gewinnt_duo_4 16.10.2021  */

#include <Adafruit_NeoPixel.h>
int anzahl = 64;
Adafruit_NeoPixel strip(anzahl, 6, NEO_GRB + NEO_KHZ800);
#include <NewTone.h>
#define TONE_PIN 2
long rot = strip.Color(5, 0, 0); long gruen = strip.Color(0, 5, 0); long farbe = 0;

// Variable Ablauf
byte zw1 = 0; int zw2 = 0; // werden in "Ausgabe Spielfeld" benutzt
byte zw3 = 0; // wird in Absenken der Spielsteine benutzt
byte zw4 = 0; // Startfeld beim Testen, Spielstand
byte zw5 = 0; // Zaehlwert innere Schleife, testet 4 Felder,
byte zw6 = 0; // Zaehlwert mittlere Schleife, testet eine Spalte, Testen Spielstand
byte zw7 = 0; // Zaehlwert aeußere Schleife, testet alle Spalten, Testen Spielstand
byte zw8 = 0; // Gefallene Steine
byte zw9 = 0; // Ausgabe Siegerfarbe
byte zw10 = 0; //Loeschen Anzeige und Spielfeld
byte zw11 = 0; //Blinken Siegersteine
long farbe_1 = 0; long farbe_2 = 0; // Siegerfarbe
byte position_1 = 0; byte position_2 = 0; byte position_3 = 0; byte position_4 = 0; //Position Gewinnersteine
byte ergebnis_zw1 = 0; // aeußere Schleife wird zum Testen des Programms benutzt
byte ergebnis_zw2 = 0; // innere Schleif wird zum Testen des Programms benutzt

byte rechts = 10; byte links = 9; byte runter = 8; // Nummer der benoetigten Ports

byte richtung = 0 ; // 1 -> rechts; 2 -> links; 3 -> runter
byte status_start = 1; // 1 -> rot; 2 -> gruen, gilt nur fur Spieler gegen Spieler
byte status_spiel = 1 ; // 1 -> rot; 2 -> gruen, gilt nur fur Spieler gegen Spieler
byte status_spiel_spieler = 0 ; //Spielstatus fur moegliche Zuege des Spielers
byte position_0 = 0; // Zeiger fuer Spielfeld
byte test_rot = 0; byte test_gruen = 0; byte sieger = 0; // Benoetigt zum Ermitteln des Siegers

// Variable Rechner Ermittlung naechter Spielzug

byte r_zw1 = 0; // Zaehlwert zum Kopieren der Spielfelder
byte r_zw2 = 0; // 8 Versuche Rechner
byte r_zw3 = 0; // Adresse des vom Rechner gesetzten Stein
byte r_zw4 = 0; // 8 mögliche Versuche Spieler
byte r_zw5 = 0; // Adresse des vom Rechner gesetzten Stein fuer Versuch Spieler
byte r_zw6 = 0; // Zwischenspeicher Auswertung Test
byte r_zw7 = 0; // Schritte nach Test
byte r_zw8 = 0; // Zaehlwert fuer Auswertung Test
byte r_zw9 = 0; // Zwischenspeicher fuer zw4
byte r_zw10 = 0; // Auswertung Tabelle auswertung_vergleich (Gruppe in Zeile 6)
byte r_zw11_1 = 0; // Auswertung Tabelle auswertung_rot
byte r_zw11_2 = 0; // Auswertung Tabelle auswertung_rot
byte r_zw12 = 0; // Eintrag Ergebnis der Analyse in auswertung_vergleich, Ermittlung bester Zug
byte r_zw12_1 = 0; // Eintrag Ergebnis der Analyse in auswertung_vergleich, Ermittlung bester Zug
byte r_zw14 = 0; // Schritte zum Absenken
byte max_rot = 0; // Maximalwert einer Zeile in Tabelle auswertung_rot
byte max_zug_1 = 0; // Ermittelt besten Zug
byte max_gruen_2 = 0; // Maximale 2-Gruppen bei einem Zug
byte max_gruen_3 = 0; // Maximale 3-Gruppen bei einem Zug
byte max_gruen_4 = 0; // Maximale 4-Gruppen bei einem Zug
byte r_test_rot = 0; byte r_test_gruen = 0; // Test Spielstand
byte r_test_gruen_1 = 0; byte r_test_gruen_2 = 0; byte r_test_gruen_3 = 0; byte r_test_gruen_4 = 0; // Test Spielstand nach Kettenlaenge
byte spiel_art = 0; // 1-> gegen Rechner, 2 -> Spieler gegen Spieler;
byte r_erster_zug = 0; // 0 -> Spieler beginnt, 1 -> Rechner beginnt
byte r_anzahl_zuege = 0 ; //Anzahl Zuege bei Spieler gegen Rechner
byte r_alles3 = 0; // Zwischenspeicher fuer Sonderfall in der Auswertung
byte r_alles4 = 0; // Zwischenspeicher fuer Sonderfall in der Auswertung
byte zufall = 0; // wird benötigt um unbestimmten Anfang zu erreichen

// 0 -> nicht belegt; 1 -> rot; 2 -> gruen
byte spielfeld [64] = {
  1, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0
};

// Kopie des Spielfeldes, wird benoetigt bei Rechner gegen Spieler
// 0 -> nicht belegt; 1 -> rot; 2 -> gruen
byte spielfeld_r1 [64] = {
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0
};

// In dem Feld wird die Auswertung des Spielfeldes und die Schlussfolgerungen abgelegt (Rechner gegen Spieler)
byte auswertung_vergleich [12] [10] = {
  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
  {0, 0, 0, 0, 0, 0, 0, 0, 0, 2},
  {0, 0, 0, 0, 0, 0, 0, 0, 0, 3},
  {0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
  {0, 0, 0, 0, 0, 0, 0, 0, 0, 5},
  {0, 0, 0, 0, 0, 0, 0, 0, 0, 6},
  {0, 0, 0, 0, 0, 0, 0, 0, 0, 7},
  {0, 0, 0, 0, 0, 0, 0, 0, 0, 8},
  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
};

// Position Rechner, 8 mal Gegner
byte auswertung_rot [10] [8] = {
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
};

void setup() {

  Serial.begin(9600);

  strip.begin();
  strip.show(); // Initialize all pixels to 'off'

  pinMode(rechts, INPUT); digitalWrite (rechts, HIGH);
  pinMode(links, INPUT); digitalWrite (links, HIGH);
  pinMode(runter, INPUT); digitalWrite (runter, HIGH);

  // -------------------- Spielauswahl links zu zweit, rechts gegen Rechner --------------------

  strip.setPixelColor (63 - 25, 10, 0, 0); strip.setPixelColor (63 - 26, 0, 10, 0); strip.setPixelColor (63 - 30, 10, 0, 0);
  strip.show();

  do {
    if ( digitalRead(rechts) == LOW) {
      spiel_art = 1;
      NewTone(TONE_PIN,600);
      delay(1000);
      noNewTone(TONE_PIN);
      
    }
    if ( digitalRead(links) == LOW) {
      spiel_art = 2;
       NewTone(TONE_PIN,300);
      delay(1000);
      noNewTone(TONE_PIN);
    }
  } while (spiel_art == 0);

  strip.setPixelColor (63 - 25, 0, 0, 0); strip.setPixelColor (63 - 26, 0, 0, 0); strip.setPixelColor (63 - 30, 0, 0, 0);
  strip.show();  delay(1000);

  ausgabe_spielfeld ();
}

void loop() {

  // -------------------- Abfrage Tastatur und Sprung in entsprechendes Programm --------------------
  // -------------------- Nutzung in beiden Spielarten --------------------



  do {

    zufall = random(1, 20); // unbestimmter Anfang

    if (digitalRead(rechts) == LOW && digitalRead(links) == LOW) {
      zw8 = 56; // Unentschieden
      test_spielende ();
      
    };
    if ( digitalRead(rechts) == LOW) {
      richtung = 1; rechts_0 ();

    }
    if ( digitalRead(links) == LOW) {
      richtung = 2; links_0 ();
      
    }
    if ( digitalRead(runter) == LOW ) {
      if (spielfeld [position_0 + 8] == 0) {
        richtung = 3;
        runter_0 (); zw8 ++; // Anzahl Durchlaeufe + 1
       test_spielende ();

        // --------------------  Aufruf bei Rechner gegen Spieler --------------------

        if (spiel_art == 1) {
          rechner (); test_spielende ();
        };
      };
    }
  }
  while ( richtung == 0);
  richtung = 0; // Loeschen der Richtung

  ausgabe_spielfeld ();
  delay(300);
}

// -------------------- Programmteile Spiel Rechner --------------------

// -------------- Erster Programmteil der aufgerufen wird bei Spieler gegen Rechner --------------------------
void rechner () {

  // -------------------- Laden spielfeld_r1; --------------------
  r_zw1 = 0;
  do {
    spielfeld_r1 [r_zw1] = spielfeld [r_zw1];
    r_zw1++;
  }
  while ( r_zw1 != 64);

  // -------------------- 8 Versuche Rechner, setzen einen eigenen Stein, Rechner immer gruen --------------------
  r_zw2 = 0; r_zw6 = 0; r_zw7 = 0; r_zw8 = 0;

  do {
    r_zw3 = 0;
    if (spielfeld_r1 [r_zw2 + 8] != 0) {
      r_zw3 = 0; // Es wurde kein Stein gesetzt
      auswertung_vergleich [4] [r_zw2] = 0;
      r_zw2 ++;
    }
    else {
      auswertung_vergleich [4] [r_zw2] = 1;
      if (spielfeld_r1 [r_zw2 + 16] != 0) {
        spielfeld_r1 [r_zw2 + 8] = 2; r_zw3 = r_zw2 + 8; r_zw2 ++;
      }
      else {
        if ( spielfeld_r1 [ r_zw2 + 24] != 0) {
          spielfeld_r1 [r_zw2 + 16] = 2; r_zw3 = r_zw2 + 16; r_zw2 ++;
        } else {
          if ( spielfeld_r1 [ r_zw2 + 32] != 0) {
            spielfeld_r1 [r_zw2 + 24] = 2; r_zw3 = r_zw2 + 24; r_zw2 ++;
          } else {
            if ( spielfeld_r1 [ r_zw2 + 40] != 0) {
              spielfeld_r1 [r_zw2 + 32] = 2; r_zw3 = r_zw2 + 32; r_zw2 ++;
            } else {
              if ( spielfeld_r1 [ r_zw2 + 48] != 0) {
                spielfeld_r1 [r_zw2 + 40] = 2; r_zw3 = r_zw2 + 40; r_zw2 ++;
              } else {
                if ( spielfeld_r1 [ r_zw2 + 56] != 0) {
                  spielfeld_r1 [r_zw2 + 48] = 2; r_zw3 = r_zw2 + 48; r_zw2 ++;
                } else {
                  spielfeld_r1 [r_zw2 + 56] = 2; r_zw3 = r_zw2 + 56; r_zw2 ++;
                };
              };
            };
          }
        };
      };
    }; // Ende "else" absenken ein eigener Stein

    // -------------------- Umschreiben Anzahl 1, 2, 3 und 4-Gruppen. 1 wird nicht ausgewertet. ----------
    test_spielstand_gruen ();
    auswertung_vergleich [0] [r_zw2 - 1] = r_test_gruen_1; auswertung_vergleich [1] [r_zw2 - 1] = r_test_gruen_2;
    auswertung_vergleich [2] [r_zw2 - 1] = r_test_gruen_3; auswertung_vergleich [3] [r_zw2 - 1] = r_test_gruen_4;

    // -------------------- Setzen fremden Stein --------------------
    // Es werden alle 8 Moeglichkeiten getestet (bei jedem gruenen Stein)
    r_zw4 = 0;
    do {
      r_zw5 = 0;

      if (spielfeld_r1 [r_zw4 + 8] != 0) {
        r_zw5 = 0; // Kein Stein gesetzt
        r_zw4 ++;
      }
      else {
        if (spielfeld_r1 [r_zw4 + 16] != 0) {
          spielfeld_r1 [r_zw4 + 8] = 1; r_zw5 = r_zw4 + 8; r_zw4 ++;
        }
        else {
          if ( spielfeld_r1 [ r_zw4 + 24] != 0) {
            spielfeld_r1 [r_zw4 + 16] = 1; r_zw5 = r_zw4 + 16; r_zw4 ++;
          } else {
            if ( spielfeld_r1 [ r_zw4 + 32] != 0) {
              spielfeld_r1 [r_zw4 + 24] = 1; r_zw5 = r_zw4 + 24; r_zw4 ++;
            } else {
              if ( spielfeld_r1 [ r_zw4 + 40] != 0) {
                spielfeld_r1 [r_zw4 + 32] = 1; r_zw5 = r_zw4 + 32; r_zw4 ++;
              } else {
                if ( spielfeld_r1 [ r_zw4 + 48] != 0) {
                  spielfeld_r1 [r_zw4 + 40] = 1; r_zw5 = r_zw4 + 40; r_zw4 ++;
                } else {
                  if ( spielfeld_r1 [ r_zw4 + 56] != 0) {
                    spielfeld_r1 [r_zw4 + 48] = 1; r_zw5 = r_zw4 + 48; r_zw4 ++;
                  } else {
                    spielfeld_r1 [r_zw4 + 56] = 1; r_zw5 = r_zw4 + 56; r_zw4 ++;
                  };
                };
              };
            };
          };
        };
      }; // Ende "else" absenken ein frender Stein

      test_spielstand_rot ();
      auswertung_rot [r_zw2 - 1] [r_zw4 - 1] = r_test_rot;

      spielfeld_r1 [ r_zw5] = 0; // Loeschen Teststein fremd
    }
    while (r_zw4 != 8); // ------------- Ende setzen fremder Stein-------------------

    spielfeld_r1 [ r_zw3] = 0; // Loeschen Teststein eigen
  }
  while (r_zw2 != 8); // Ende Steinsetzen zum Test

  // ( 01 ) -------------------- Ermittell von max_gruen_2, max_gruen_3, max_gruen_4, --------------------

  r_zw10 = 0; max_gruen_2 = 0; max_gruen_3 = 0; max_gruen_4 = 0;

  do {
    if (max_gruen_2 < auswertung_vergleich [1] [r_zw10]) {
      max_gruen_2 = auswertung_vergleich [1] [r_zw10];
    };
    if (max_gruen_3 < auswertung_vergleich [2] [r_zw10]) {
      max_gruen_3 = auswertung_vergleich [2] [r_zw10];
    };
    if (max_gruen_4 < auswertung_vergleich [3] [r_zw10]) {
      max_gruen_4 = auswertung_vergleich [3] [r_zw10];
    };
    r_zw10++;
  } while (r_zw10 != 8);

  auswertung_vergleich [1] [8] = max_gruen_2;
  auswertung_vergleich [2] [8] = max_gruen_3;
  auswertung_vergleich [3] [8] = max_gruen_4;


  // -------------------- Umschreiben Ergebnisse in Zeile 5 von auswertung_vergleich --------------------
  // ( 02 ) --------------------  Loeschen Zeile 5 --------------------

  r_zw10 = 0;

  do {
    auswertung_vergleich [5] [r_zw10] == 0;
    r_zw10++;
  } while (r_zw10 != 8);

  // (03 ) --------------------  Eintragen des höchsten Wertes aus den einzelnen Spalten  der Zeilen 1-3 in die Zeile 5.  --------------------

  r_zw10 = 0;
  do {
    if (auswertung_vergleich [4] [r_zw10] == 0)
    {
      auswertung_vergleich [5] [r_zw10] = 0; // Spalte voll
    }
    else {
      if (auswertung_vergleich [3] [r_zw10] > 0 && auswertung_vergleich [3] [r_zw10] == max_gruen_4)

      { auswertung_vergleich [5] [r_zw10] = 4;
      } else {
        if (auswertung_vergleich [2] [r_zw10] > 0 && auswertung_vergleich [2] [r_zw10] == max_gruen_3) {
          auswertung_vergleich [5] [r_zw10] = 3;
        } else {
          if (auswertung_vergleich [1] [r_zw10] > 0 && auswertung_vergleich [1] [r_zw10] == max_gruen_2) {
            auswertung_vergleich [5] [r_zw10] = 2;
          } else {
            auswertung_vergleich [5] [r_zw10] = 0;
          };
        };
      };
    };
    r_zw10++;
  } while (r_zw10 != 8);

  // ( 04 ) -------------------- Ermitteln und Eintragen von max_rot aus auswertung_rot nach Zeile 6 in auswertung_vergleich --------------------

  r_zw11_1 = 0;
  do {
    r_zw11_2 = 0; max_rot = 0;
    do {
      if (auswertung_rot [r_zw11_1] [r_zw11_2] > max_rot) {
        max_rot = auswertung_rot [r_zw11_1] [r_zw11_2];
      };
      r_zw11_2++;
    } while (r_zw11_2 != 8);
    auswertung_vergleich [6] [r_zw11_1] = max_rot;
    r_zw11_1++;
  } while (r_zw11_1 != 8);

  // ( 05 ) -------------------- Löschen Zeile [8] und [9] in auswertung_rot --------------------

  r_zw11_1 = 0;

  do {
    auswertung_rot [8] [r_zw11_1] = 0; auswertung_rot [9] [r_zw11_1] = 0;
    r_zw11_1++;
  } while (r_zw11_1 != 8);

  // ( 06 ) -------------------- Anzahl 3 in auswertung_rot [6] --------------------
  r_zw11_1 = 0;

  do {
    if ( auswertung_rot [r_zw11_1] [0] == 3 ) {
      auswertung_rot [8] [0] ++ ;
    };
    if ( auswertung_rot [r_zw11_1] [1] == 3 ) {
      auswertung_rot [8] [1] ++ ;
    };
    if ( auswertung_rot [r_zw11_1] [2] == 3 ) {
      auswertung_rot [8] [2] ++ ;
    };
    if ( auswertung_rot [r_zw11_1] [3] == 3 ) {
      auswertung_rot [8] [3] ++ ;
    };
    if ( auswertung_rot [r_zw11_1] [4] == 3 ) {
      auswertung_rot [8] [4] ++ ;
    };
    if ( auswertung_rot [r_zw11_1] [5] == 3 ) {
      auswertung_rot [8] [5] ++ ;
    };
    if ( auswertung_rot [r_zw11_1] [6] == 3 ) {
      auswertung_rot [8] [6] ++ ;
    };
    if ( auswertung_rot [r_zw11_1] [7] == 3 ) {
      auswertung_rot [8] [7] ++ ;
    };
    if ( auswertung_rot [r_zw11_1] [0] == 4 ) {
      auswertung_rot [9] [0] ++ ;
    };
    if ( auswertung_rot [r_zw11_1] [1] == 4 ) {
      auswertung_rot [9] [1] ++ ;
    };
    if ( auswertung_rot [r_zw11_1] [2] == 4 ) {
      auswertung_rot [9] [2] ++ ;
    };
    if ( auswertung_rot [r_zw11_1] [3] == 4 ) {
      auswertung_rot [9] [3] ++ ;
    };
    if ( auswertung_rot [r_zw11_1] [4] == 4 ) {
      auswertung_rot [9] [4] ++ ;
    };
    if ( auswertung_rot [r_zw11_1] [5] == 4 ) {
      auswertung_rot [9] [5] ++ ;
    };
    if ( auswertung_rot [r_zw11_1] [6] == 4 ) {
      auswertung_rot [9] [6] ++ ;
    };
    if ( auswertung_rot [r_zw11_1] [7] == 4 ) {
      auswertung_rot [9] [7] ++ ;
    };

    r_zw11_1 ++;

  } while (r_zw11_1 != 8);

  // ( 07 ) -------------------- Wertung auswertung_vergleich Zeile 5 und 6 zur Ermittlung bester Zug --------------------
  // -------------------- Ergebnis in auswertung_vergleich Zeile 7 --------------------

  r_zw12 = 0;

  do {
    if (auswertung_vergleich [5] [r_zw12] == 4) { // Rechner gewinnt
      auswertung_vergleich [7] [r_zw12] = 10; auswertung_vergleich [11] [0] = 1;
      
    } else {
      if (auswertung_vergleich [6] [r_zw12] == 4) { // Spieler koennte gewinnen
        auswertung_vergleich [7] [r_zw12] = 0; auswertung_vergleich [11] [1] = 1;

      } else {
        if (auswertung_vergleich [6] [r_zw12] == 3) {
          auswertung_vergleich [7] [r_zw12] = 2 + auswertung_vergleich [5] [r_zw12];
        } else {
          if (auswertung_vergleich [6] [r_zw12] == 2) {
            auswertung_vergleich [7] [r_zw12] = 6 + auswertung_vergleich [5] [r_zw12];
          } else {
            auswertung_vergleich [7] [r_zw12] = 1;
          };
        };
      };
    };
    r_zw12++;
  } while (r_zw12 != 8);

  // ( 08 )-------------------- auswertung_vergleich [6] alles 3 --------------------
  // Wenn alle auswertung_rot [6] == 3 sind, dann gibt es mehrere Moeglichkeiten fuer eine 3-Gruppe
  // Dann erfolgt ein anderer Auswertemodus statt der normalen Auswertung.

  if (auswertung_vergleich [6] [0] == 3 && auswertung_vergleich [6] [1] == 3 && auswertung_vergleich [6] [2] == 3 && auswertung_vergleich [6] [3] == 3 &&
      auswertung_vergleich [6] [4] == 3 && auswertung_vergleich [6] [5] == 3 && auswertung_vergleich [6] [6] == 3 && auswertung_vergleich [6] [7] == 3
      && auswertung_vergleich [3] [8] == 0)
  {
    r_alles3 = 1; auswertung_vergleich [11] [2] = 1;

    r_zw11_1 = 0;
    do {
      auswertung_vergleich [7] [r_zw11_1] = auswertung_rot [8] [r_zw11_1];
      r_zw11_1 ++;
    } while (r_zw11_1 != 8);
  }
  else {
    r_alles3 = 0;
  };

  // ( 09 ) -------------------- auswertung_vergleich [6] alles 4 --------------------
  // Wenn alle auswertung_rot [6] == 4 sind, dann gibt es mehrere Moeglichkeiten fuer eine 4-Gruppe
  // Dann erfolgt ein anderer Auswertemodus statt der normalen Auswertung.

  if (auswertung_vergleich [6] [0] == 4 && auswertung_vergleich [6] [1] == 4 && auswertung_vergleich [6] [2] == 4 && auswertung_vergleich [6] [3] == 4 &&
      auswertung_vergleich [6] [4] == 4 && auswertung_vergleich [6] [5] == 4 && auswertung_vergleich [6] [6] == 4 && auswertung_vergleich [6] [7] == 4) {

    if (auswertung_rot [9] [0] == 7 || auswertung_rot [9] [1] == 7 || auswertung_rot [9] [2] == 7 || auswertung_rot [9] [3] == 7 ||
        auswertung_rot [9] [4] == 7 ||  auswertung_rot [9] [5] == 7 || auswertung_rot [9] [6] == 7 || auswertung_rot [9] [7] == 7 ) {
      if (auswertung_rot [9] [0] == 7) {
        auswertung_vergleich [7] [0] = 9;
      } else {
        auswertung_vergleich [7] [0] = 0;
      };
      if (auswertung_rot [9] [1] == 7) {
        auswertung_vergleich [7] [1] = 9;
      } else {
        auswertung_vergleich [7] [1] = 0;
      };
      if (auswertung_rot [9] [2] == 7) {
        auswertung_vergleich [7] [2] = 9;
      } else {
        auswertung_vergleich [7] [2] = 0;
      };
      if (auswertung_rot [9] [3] == 7) {
        auswertung_vergleich [7] [3] = 9;
      } else {
        auswertung_vergleich [7] [3] = 0;
      };
      if (auswertung_rot [9] [4] == 7) {
        auswertung_vergleich [7] [4] = 9;
      } else {
        auswertung_vergleich [7] [4] = 0;
      };
      if (auswertung_rot [9] [5] == 7) {
        auswertung_vergleich [7] [5] = 9;
      } else {
        auswertung_vergleich [7] [5] = 0;
      };
      if (auswertung_rot [9] [6] == 7) {
        auswertung_vergleich [7] [6] = 9;
      } else {
        auswertung_vergleich [7] [6] = 0;
      };
      if (auswertung_rot [9] [7] == 7) {
        auswertung_vergleich [7] [7] = 9;
      } else {
        auswertung_vergleich [7] [7] = 0;
      };
    }
    else {
      r_zw11_1 = 0; auswertung_vergleich [11] [3] = 1;
      do {
        auswertung_vergleich [7] [r_zw11_1] = auswertung_rot [9] [r_zw11_1];
        r_zw11_1 ++;
      } while (r_zw11_1 != 8);
    };
  };

  // ( 10 ) --------------------- Sperren der vollen Spalten --------------------

  r_zw12 = 0;
  do {
    if (auswertung_vergleich [4] [r_zw12] == 0) {
      auswertung_vergleich [7] [r_zw12] = 0;
    };
    r_zw12++;
  } while (r_zw12 != 8);

  // ( 11 ) -------------------- Ermittlung hoechster Wert --------------------

  r_zw12 = 0; max_zug_1 = 0;
  do {
    if (max_zug_1 < auswertung_vergleich [7] [r_zw12]) {
      max_zug_1 = auswertung_vergleich [7] [r_zw12];
    };
    r_zw12++;
  }
  while (r_zw12 != 8);
  auswertung_vergleich [7] [8] = max_zug_1;

  // ( 12 ) --------------------  max_zug_1 = 0 --------------------
  // Kein sinnvoller Zug nach dem Auswerteschema möglich,
  // hoechter Wert aus auswertung_vergleich [1],[2] und [3] wird gesetzt.

  if (max_zug_1 == 0) {

    r_zw12 = 0; auswertung_vergleich [11] [4] = 1;
    do {

      if (auswertung_vergleich [4] [r_zw12] == 1 && auswertung_vergleich [1] [r_zw12] > 0) {
        auswertung_vergleich [7] [r_zw12] = 1;
        if (max_zug_1 < 1) {
          max_zug_1 = 1;
        };
      };

      if (auswertung_vergleich [4] [r_zw12] == 1 && auswertung_vergleich [2] [r_zw12] > 0) {
        auswertung_vergleich [7] [r_zw12] = 2;
        if (max_zug_1 < 2) {
          max_zug_1 = 2;
        };
      };

      if (auswertung_vergleich [4] [r_zw12] == 1 && auswertung_vergleich [3] [r_zw12] > 0)
      {
        auswertung_vergleich [7] [r_zw12] = 3;
        if (max_zug_1 < 3) {
          max_zug_1 = 3;
        };
      };
      r_zw12++;
    } while (r_zw12 != 8);
  };

  // ( 13 ) --------------------  Anzahl 3 in auswertung_rot [8] in allen Spalten gleich --------------------

  if ( auswertung_rot [8] [ 0 ] == auswertung_rot [8] [ 1 ] && auswertung_rot [8] [ 0 ] == auswertung_rot [8] [ 2 ] &&
       auswertung_rot [8] [ 0 ] == auswertung_rot [8] [ 3 ] && auswertung_rot [8] [ 0 ] == auswertung_rot [8] [ 4 ] &&
       auswertung_rot [8] [ 0 ] == auswertung_rot [8] [ 5 ] && auswertung_rot [8] [ 0 ] == auswertung_rot [8] [ 6 ] &&
       auswertung_rot [8] [ 0 ] == auswertung_rot [8] [ 7 ] && r_alles3 == 1)
  {
    r_zw12 = 0; max_zug_1 = 0;
    do {
      if (auswertung_vergleich [4] [r_zw12] == 1 && auswertung_vergleich [1] [r_zw12] > 0) {
        auswertung_vergleich [7] [r_zw12] = 1;
        if (max_zug_1 < 1) {
          max_zug_1 = 1;
        };
      };

      if (auswertung_vergleich [4] [r_zw12] == 1 && auswertung_vergleich [5] [r_zw12] > 0) {
        auswertung_vergleich [7] [r_zw12] = auswertung_vergleich [5] [r_zw12];
        if (max_zug_1 < auswertung_vergleich [5] [r_zw12]) {
          max_zug_1 = auswertung_vergleich [5] [r_zw12];
        };
      };

      if (auswertung_vergleich [4] [r_zw12] == 1 && auswertung_vergleich [3] [r_zw12] > 0)
      {
        auswertung_vergleich [7] [r_zw12] = auswertung_vergleich [5] [r_zw12];
        if (max_zug_1 < auswertung_vergleich [5] [r_zw12]) {
          max_zug_1 = auswertung_vergleich [5] [r_zw12];
        };
      };

      r_zw12++;
    } while (r_zw12 != 8);
  };

  // ( 14 ) --------------------  Zufall bei gleichen Ergebnissen --------------------

  r_zw12 = 0;
  do {
    if (auswertung_vergleich [7] [r_zw12] == max_zug_1) {
      auswertung_vergleich [8] [r_zw12] = auswertung_vergleich [7] [r_zw12] * random(1, 20);
    } else {
      auswertung_vergleich [8] [r_zw12] = 0;
    };
    r_zw12++;
  } while (r_zw12 != 8);

  // ( 15 ) -------------------- Setzen ersten Zug bzw. Schritte danach --------------------
  if (zw8 < 2 ) {
    if (spielfeld [59] == 0) {
      r_zw14 = 3;
    } else {
      r_zw14 = 4;
    };
  } else {

    // ( 16 ) -------------------- Schritte zum hoechsten Wert --------------------
    max_zug_1 = 0; r_zw12 = 0; r_zw14 = 0;

    do {
      if (max_zug_1 < auswertung_vergleich [8] [r_zw12]) {
        max_zug_1 = auswertung_vergleich [8] [r_zw12]; r_zw14 = r_zw12;
      };
      r_zw12++;
    }
    while (r_zw12 != 8);
  };

  // --------------------( 17 ) Gewaehlte Spalte war schon gesperrt, es wird die naechste freie Spalte genommen.--------------------
  // --------------------Das tritt nur auf, wenn alle Spalten gesperrt oder zur Niederlage des Rechners fuehren

  if (auswertung_vergleich [4][0] == 0 && r_zw14 == 0) {
    r_zw14++;
    auswertung_vergleich [11] [6]++;
  };
  if (auswertung_vergleich [4][1] == 0 && r_zw14 == 1) {
    r_zw14++;
    auswertung_vergleich [11] [6]++;
  };
  if (auswertung_vergleich [4][2] == 0 && r_zw14 == 2) {
    r_zw14++;
    auswertung_vergleich [11] [6]++;
  };
  if (auswertung_vergleich [4][3] == 0 && r_zw14 == 3) {
    r_zw14++;
    auswertung_vergleich [11] [6]++;
  };
  if (auswertung_vergleich [4][4] == 0 && r_zw14 == 4) {
    r_zw14++;
    auswertung_vergleich [11] [6]++;
  };
  if (auswertung_vergleich [4][5] == 0 && r_zw14 == 5) {
    r_zw14++;
    auswertung_vergleich [11] [6]++;
  };
  if (auswertung_vergleich [4][6] == 0 && r_zw14 == 6) {
    r_zw14++;
    auswertung_vergleich [11] [6]++;
  };

  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  // ausgabe_ergebnis (); // nur zu Testzwecken. Ist die Zeile aktiv, werden Daten der Auswertung auf den Bildaschirm ausgegeben.
  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  delay (600);

  // ( 18 ) -------------------- Ausfueren Schritte --------------------

  if (r_zw14 != 0) {
    do {
      rechts_0 (); ausgabe_spielfeld (); delay(500);
      r_zw14--;
    } while (r_zw14 != 0);
  };
  runter_0 (); zw8++;
}

// -------------------Test Spielstand -----------------------
// Uebergabewerte r_test_gruen, r_test_rot

void test_spielstand_gruen () {

  r_test_gruen = 0; r_test_gruen_1 = 0; r_test_gruen_2 = 0;  r_test_gruen_3 = 0; r_test_gruen_4 = 0;

  // --------------------  Gruen Test diagonal oben  Rechner --------------------

  zw4 = 32; // Startfeld beim Testen
  r_zw9 = zw4; // Zwischenspeicher
  zw7 = 0; // Zaehlschleife

  do {
    zw6 = 0; // Zaehlschleife
    do {

      // 1 2
      if (spielfeld_r1 [zw4] == 2 && spielfeld_r1 [zw4 - 7] == 2 && spielfeld_r1 [zw4 - 14] == 0 && spielfeld_r1 [zw4 - 21] == 0) {
        r_test_gruen_2++;
      };
      // 2 3
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 - 7] == 2 && spielfeld_r1 [zw4 - 14] == 2 && spielfeld_r1 [zw4 - 21] == 0) {
        r_test_gruen_2++;
      };
      // 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 - 7] == 0 && spielfeld_r1 [zw4 - 14] == 2 && spielfeld_r1 [zw4 - 21] == 2) {
        r_test_gruen_2++;
      };
      // 1 2 3
      if (spielfeld_r1 [zw4] == 2 && spielfeld_r1 [zw4 - 7] == 2 && spielfeld_r1 [zw4 - 14] == 2 && spielfeld_r1 [zw4 - 21] == 0 && spielfeld_r1 [zw4 - 13] != 0) {
        r_test_gruen_3++;
      };
      // 2 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 - 7] == 2 && spielfeld_r1 [zw4 - 14] == 2 && spielfeld_r1 [zw4 - 21] == 2) {
        r_test_gruen_3++;
      };
      // 1 2 3 4
      if (spielfeld_r1 [zw4] == 2 && spielfeld_r1 [zw4 - 7] == 2 && spielfeld_r1 [zw4 - 14] == 2 && spielfeld_r1 [zw4 - 21] == 2) {
        r_test_gruen_4++;
      };
      zw6 ++; zw4 = zw4 + 1;
    }
    while (zw6 != 5);

    r_zw9 = r_zw9 + 8; zw4 = r_zw9;

    zw7 ++;
  }
  while (zw7 != 4);

  // --------------------  gruen Test diagonal unten Rechner --------------------

  zw4 = 8; // Startfeld beim Testen
  r_zw9 = zw4; // Zwischenspeicher
  zw7 = 0; // Zaehlschleife

  do {
    zw6 = 0; // Zaehlschleife
    do {

      // 1 2
      if (spielfeld_r1 [zw4] == 2 && spielfeld_r1 [zw4 + 9] == 2 && spielfeld_r1 [zw4 + 18] == 0 && spielfeld_r1 [zw4 + 27] == 0) {
        r_test_gruen_2++;
      };
      // 2 3
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 9] == 2 && spielfeld_r1 [zw4 + 18] == 2 && spielfeld_r1 [zw4 + 27] == 0) {
        r_test_gruen_2++;
      };
      // 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 9] == 0 && spielfeld_r1 [zw4 + 18] == 2 && spielfeld_r1 [zw4 + 27] == 2) {
        r_test_gruen_2++;
      };
      // 1 2 3
      if (spielfeld_r1 [zw4] == 2 && spielfeld_r1 [zw4 + 9] == 2 && spielfeld_r1 [zw4 + 18] == 2 && spielfeld_r1 [zw4 + 27] == 0) {
        r_test_gruen_3++;
      };
      // (1)2 3 4
      if (spielfeld_r1 [zw4 + 8] != 0 && spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 9] == 2 && spielfeld_r1 [zw4 + 18] == 2 && spielfeld_r1 [zw4 + 27] == 2) {
        r_test_gruen_3++;
      };
      // 1 2 3 4
      if (spielfeld_r1 [zw4] == 2 && spielfeld_r1 [zw4 + 9] == 2 && spielfeld_r1 [zw4 + 18] == 2 && spielfeld_r1 [zw4 + 27] == 2) {
        r_test_gruen_4++;
      };
      zw6 ++; zw4 = zw4 + 1;
    }
    while (zw6 != 5);
    r_zw9 = r_zw9 + 8; zw4 = r_zw9;
    zw7 ++;
  }
  while (zw7 != 4);

  // --------------------  gruen Test senkrecht Rechner --------------------

  zw4 = 8; // Startfeld beim Testen
  r_zw9 = zw4; // Zwischenspeicher
  zw7 = 0; // Zaehlschleife

  do {
    zw6 = 0; // Zaehlschleife
    do {

      // 1 2
      if (spielfeld_r1 [zw4] == 2 && spielfeld_r1 [zw4 + 8] == 2 && spielfeld_r1 [zw4 + 16] == 0 && spielfeld_r1 [zw4 + 24] == 0) {
        r_test_gruen_2++;
      };
      // 2 3
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 8] == 2 && spielfeld_r1 [zw4 + 16] == 2 && spielfeld_r1 [zw4 + 24] == 0) {
        r_test_gruen_2++;
      };
      // 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 8] == 0 && spielfeld_r1 [zw4 + 16] == 2 && spielfeld_r1 [zw4 + 24] == 2) {
        r_test_gruen_2++;
      };
      // 1 2 3
      if (spielfeld_r1 [zw4] == 2 && spielfeld_r1 [zw4 + 8] == 2 && spielfeld_r1 [zw4 + 16] == 2 && spielfeld_r1 [zw4 + 24] == 0) {
        r_test_gruen_3++;
      };
      // 2 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 8] == 2 && spielfeld_r1 [zw4 + 16] == 2 && spielfeld_r1 [zw4 + 24] == 2) {
        ; r_test_gruen_3++;
      };
      // 1 2 3 4
      if (spielfeld_r1 [zw4] == 2 && spielfeld_r1 [zw4 + 8] == 2 && spielfeld_r1 [zw4 + 16] == 2 && spielfeld_r1 [zw4 + 24] == 2) {
        r_test_gruen_4++;
      };
      zw6 ++; zw4 = zw4 + 1;
    }
    while (zw6 != 8);

    r_zw9 = r_zw9 + 8; zw4 = r_zw9;
    zw7 ++;
  }
  while (zw7 != 4);

  // --------------------  gruen Test waagerecht Rechner --------------------

  zw4 = 8; // Startfeld beim Testen
  r_zw9 = zw4; // Zwischenspeicher
  zw7 = 0; // Zaehlschleife

  do {
    zw6 = 0; // Zaehlschleife
    do {

      // 1 2
      if (spielfeld_r1 [zw4] == 2 && spielfeld_r1 [zw4 + 1] == 2 && spielfeld_r1 [zw4 + 2] == 0 && spielfeld_r1 [zw4 + 3] == 0) {
        r_test_gruen_2++;
      };
      // 2 3
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 1] == 2 && spielfeld_r1 [zw4 + 2] == 2 && spielfeld_r1 [zw4 + 3] == 0) {
        r_test_gruen_2++;
      };
      // 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 1] == 0 && spielfeld_r1 [zw4 + 2] == 2 && spielfeld_r1 [zw4 + 3] == 2) {
        r_test_gruen_2++;
      };
      // 1 2 3
      if (spielfeld_r1 [zw4] == 2 && spielfeld_r1 [zw4 + 1] == 2 && spielfeld_r1 [zw4 + 2] == 2 && spielfeld_r1 [zw4 + 3] == 0) {
        r_test_gruen_3++;
      };
      // 2 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 1] == 2 && spielfeld_r1 [zw4 + 2] == 2 && spielfeld_r1 [zw4 + 3] == 2) {
        r_test_gruen_3++;
      };
      // 1 2 3 4
      if (spielfeld_r1 [zw4] == 2 && spielfeld_r1 [zw4 + 1] == 2 && spielfeld_r1 [zw4 + 2] == 2 && spielfeld_r1 [zw4 + 3] == 2) {
        r_test_gruen_4++;
      };
      zw6 ++; zw4 = zw4 + 8;
    }
    while (zw6 != 7);
    r_zw9 = r_zw9 + 1; zw4 = r_zw9; // Offset
    zw7 ++;
  }
  while (zw7 != 5);
}

void test_spielstand_rot () {

  // --------------------  rot Test diagonal oben Spieler --------------------

  zw4 = 32; // Startfeld beim Testen
  r_zw9 = zw4; // Zwischenspeicher
  zw7 = 0; // Zaehlschleife
  r_test_rot = 0;

  do {
    zw6 = 0; // Zaehlschleife
    do {

      // 1 2
      if (spielfeld_r1 [zw4] == 1 && spielfeld_r1 [zw4 - 7] == 1 && spielfeld_r1 [zw4 - 14] == 0 && spielfeld_r1 [zw4 - 21] == 0) {
        if (r_test_rot < 2) {
          r_test_rot = 2;
        };
      };
      // 2 3
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 - 7] == 1 && spielfeld_r1 [zw4 - 14] == 1 && spielfeld_r1 [zw4 - 21] == 0) {
        if (r_test_rot < 2) {
          r_test_rot = 2;
        };
      };
      // 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 - 7] == 0 && spielfeld_r1 [zw4 - 14] == 1 && spielfeld_r1 [zw4 - 21] == 1) {
        if (r_test_rot < 2) {
          r_test_rot = 2;
        };
      };
      // 1 2 3
      if (spielfeld_r1 [zw4] == 1 && spielfeld_r1 [zw4 - 7] == 1 && spielfeld_r1 [zw4 - 14] == 1 && spielfeld_r1 [zw4 - 21] == 0) {
        if (r_test_rot < 3) {
          r_test_rot = 3;
        };
      };
      // 2 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 - 7] == 1 && spielfeld_r1 [zw4 - 14] == 1 && spielfeld_r1 [zw4 - 21] == 1) {
        if (r_test_rot < 3) {
          r_test_rot = 3;
        };
      };
      // 1 2 3 4
      if (spielfeld_r1 [zw4] == 1 && spielfeld_r1 [zw4 - 7] == 1 && spielfeld_r1 [zw4 - 14] == 1 && spielfeld_r1 [zw4 - 21] == 1) {
        if (r_test_rot < 4) {
          r_test_rot = 4;
        };
      };
      zw6 ++; zw4 = zw4 + 1;
    }
    while (zw6 != 5);

    r_zw9 = r_zw9 + 8; zw4 = r_zw9;
    zw7 ++;
  }

  while (zw7 != 4);

  // --------------------  rot Test diagonal unten Spieler --------------------

  zw4 = 8; // Startfeld beim Testen
  r_zw9 = zw4; // Zwischenspeicher
  zw7 = 0; // Zaehlschleife

  do {
    zw6 = 0; // Zaehlschleife
    do {

      // 1 2
      if (spielfeld_r1 [zw4] == 1 && spielfeld_r1 [zw4 + 9] == 1 && spielfeld_r1 [zw4 + 18] == 0 && spielfeld_r1 [zw4 + 27] == 0) {
        if (r_test_rot < 2) {
          r_test_rot = 2;
        };
      };
      // 2 3
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 9] == 1 && spielfeld_r1 [zw4 + 18] == 1 && spielfeld_r1 [zw4 + 27] == 0) {
        if (r_test_rot < 2) {
          r_test_rot = 2;
        };
      };
      // 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 9] == 0 && spielfeld_r1 [zw4 + 18] == 1 && spielfeld_r1 [zw4 + 27] == 1) {
        if (r_test_rot < 2) {
          r_test_rot = 2;
        };
      };
      // 1 2 3
      if (spielfeld_r1 [zw4] == 1 && spielfeld_r1 [zw4 + 9] == 1 && spielfeld_r1 [zw4 + 18] == 1 && spielfeld_r1 [zw4 + 27] == 0) {
        if (r_test_rot < 3) {
          r_test_rot = 3;
        };
      };
      // 2 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 9] == 1 && spielfeld_r1 [zw4 + 18] == 1 && spielfeld_r1 [zw4 + 27] == 1) {
        if (r_test_rot < 3) {
          r_test_rot = 3;
        };
      };
      // 1 2 3 4
      if (spielfeld_r1 [zw4] == 1 && spielfeld_r1 [zw4 + 9] == 1 && spielfeld_r1 [zw4 + 18] == 1 && spielfeld_r1 [zw4 + 27] == 1) {
        if (r_test_rot < 4) {
          r_test_rot = 4;
        };
      };
      zw6 ++; zw4 = zw4 + 1;
    }
    while (zw6 != 5);

    r_zw9 = r_zw9 + 8; zw4 = r_zw9;
    zw7 ++;
  }
  while (zw7 != 4);

  // --------------------  rot Test senkrecht Spieler --------------------
  zw4 = 8; // Startfeld beim Testen
  r_zw9 = zw4; // Zwischenspeicher
  zw7 = 0; // Zaehlschleife

  do {
    zw6 = 0; // Zaehlschleife
    do {

      // 1 2
      if (spielfeld_r1 [zw4] == 1 && spielfeld_r1 [zw4 + 8] == 1 && spielfeld_r1 [zw4 + 16] == 0 && spielfeld_r1 [zw4 + 24] == 0) {
        if (r_test_rot < 2) {
          r_test_rot = 2;
        };
      };
      // 2 3
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 8] == 1 && spielfeld_r1 [zw4 + 16] == 1 && spielfeld_r1 [zw4 + 24] == 0) {
        if (r_test_rot < 2) {
          r_test_rot = 2;
        };
      };
      // 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 8] == 0 && spielfeld_r1 [zw4 + 16] == 1 && spielfeld_r1 [zw4 + 24] == 1) {
        if (r_test_rot < 2) {
          r_test_rot = 2;
        };
      };
      // 1 2 3
      if (spielfeld_r1 [zw4] == 1 && spielfeld_r1 [zw4 + 8] == 1 && spielfeld_r1 [zw4 + 16] == 1 && spielfeld_r1 [zw4 + 24] == 0) {
        if (r_test_rot < 3) {
          r_test_rot = 3;
        };
      };
      // 2 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 8] == 1 && spielfeld_r1 [zw4 + 16] == 1 && spielfeld_r1 [zw4 + 24] == 1) {
        if (r_test_rot < 3) {
          r_test_rot = 3;
        };
      };
      // 1 2 3 4
      if (spielfeld_r1 [zw4] == 1 && spielfeld_r1 [zw4 + 8] == 1 && spielfeld_r1 [zw4 + 16] == 1 && spielfeld_r1 [zw4 + 24] == 1) {
        if (r_test_rot < 4) {
          r_test_rot = 4;
        };
      };

      zw6 ++; zw4 = zw4 + 1;
    }
    while (zw6 != 8);

    r_zw9 = r_zw9 + 8; zw4 = r_zw9;
    zw7 ++;
  }
  while (zw7 != 4);

  // --------------------  rot Test waagerecht Spieler --------------------

  zw4 = 8; // Startfeld beim Testen
  r_zw9 = zw4; // Zwischenspeicher
  zw7 = 0; // Zaehlschleife

  do {
    zw6 = 0; // Zaehlschleife
    do {

      // 1 2
      if (spielfeld_r1 [zw4] == 1 && spielfeld_r1 [zw4 + 1] == 1 && spielfeld_r1 [zw4 + 2] == 0 && spielfeld_r1 [zw4 + 3] == 0) {
        if (r_test_rot < 2) {
          r_test_rot = 2;
        };
      };
      // 2 3
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 1] == 1 && spielfeld_r1 [zw4 + 2] == 1 && spielfeld_r1 [zw4 + 3] == 0) {
        if (r_test_rot < 2) {
          r_test_rot = 2;
        };
      };
      // 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 1] == 0 && spielfeld_r1 [zw4 + 2] == 1 && spielfeld_r1 [zw4 + 3] == 1) {
        if (r_test_rot < 2) {
          r_test_rot = 2;
        };
      };
      // 1 2 3
      if (spielfeld_r1 [zw4] == 1 && spielfeld_r1 [zw4 + 1] == 1 && spielfeld_r1 [zw4 + 2] == 1 && spielfeld_r1 [zw4 + 3] == 0) {
        if (r_test_rot < 3) {
          r_test_rot = 3;
        };
      };
      // 2 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 1] == 1 && spielfeld_r1 [zw4 + 2] == 1 && spielfeld_r1 [zw4 + 3] == 1) {
        if (r_test_rot < 3) {
          r_test_rot = 3;
        };
      };
      // 1 2 3 4
      if (spielfeld_r1 [zw4] == 1 && spielfeld_r1 [zw4 + 1] == 1 && spielfeld_r1 [zw4 + 2] == 1 && spielfeld_r1 [zw4 + 3] == 1) {
        if (r_test_rot < 4) {
          r_test_rot = 4;
        };
      };

      zw6 ++; zw4 = zw4 + 8;
    }

    while (zw6 != 7);

    r_zw9 = r_zw9 + 1; zw4 = r_zw9; // Offset
    zw7 ++;
  }
  while (zw7 != 5);

}

// --------------------  Programme algemein --------------------

//  --------------------  Test ob es einen Sieger gibt  --------------------
//   Programm wird nach Absenken eines Steines aufgerufen
void test_spielende () {

  // --------------------  Test diagonal oben --------------------
  // 3 verschaltelte Zyklen

  zw4 = 32; // Startfeld beim Testen
  sieger = 0; zw7 = 0;

  do {
    zw6 = 0;

    do {
      zw5 = 0; // Zaehlschleife
      test_rot = 0; test_gruen = 0;

      // -------------------- Testen 4 Zellen diegonal oben --------------------
      do {
        if ( spielfeld [zw4] == 1) {
          test_rot ++;
        };
        if ( spielfeld [zw4] == 2) {
          test_gruen ++;
        };

        // -------------------- Merken der Position beim Sieg --------------------
        if (sieger == 0) {
          if (zw5 == 0) {
            position_1 = zw4;
          };
          if (zw5 == 1) {
            position_2 = zw4;
          };
          if (zw5 == 2) {
            position_3 = zw4;
          };
          if (zw5 == 3) {
            position_4 = zw4;
          };
        };

        zw4 = zw4 - 7; zw5++;
      }
      while (zw5 != 4);

      if (test_rot == 4) {
        sieger = 1;
      } else {
        test_rot = 0;
        
      };
      if (test_gruen == 4) {
        sieger = 2;
      } else {
        test_gruen = 0;
        
      };
      zw4 = zw4 + 36; zw6++;
      if (sieger != 0) {
        zw6 = 4;
      };
    }
    while ( zw6 != 4);

    zw4 = zw4 - 31; zw7++;
    if (sieger != 0) {
      zw7 = 5;
    };
  }
  while (zw7 != 5);

  // --------------------  Test diagonal unten --------------------
  // 3 verschaltelte Zyklen

  zw4 = 8; // Startfeld beim Testen
  zw7 = 0;

  do {
    zw6 = 0;
    do {
      zw5 = 0; //Zaehlschleife
      test_rot = 0; test_gruen = 0;

      do {
        if ( spielfeld [zw4] == 1) {
          test_rot ++;
        };
        if ( spielfeld [zw4] == 2) {
          test_gruen ++;
        };

        // -------------------- Merken der Position beim Sieg --------------------
        if (sieger == 0) {
          if (zw5 == 0) {
            position_1 = zw4;
          };
          if (zw5 == 1) {
            position_2 = zw4;
          };
          if (zw5 == 2) {
            position_3 = zw4;
          };
          if (zw5 == 3) {
            position_4 = zw4;
          };
        };

        zw4 = zw4 + 9; zw5++;
      }
      while (zw5 != 4);

      if (test_rot == 4) {
        sieger = 1;
      } else {
        test_rot = 0;
      };
      if (test_gruen == 4) {
        sieger = 2;
      } else {
        test_gruen = 0;
      };
      zw4 = zw4 - 28; zw6++;
      if (sieger != 0) {
        zw6 = 4;
      };
    }
    while ( zw6 != 4);

    zw4 = zw4 - 31; zw7++;
    if (sieger != 0) {
      zw7 = 5;
    };
  }
  while (zw7 != 5);

  // --------------------  Test senkrecht --------------------
  // 3 verschaltelte Zyklen

  zw4 = 8; // Startfeld beim Testen
  zw7 = 0;
  do {
    zw6 = 0;

    do {
      zw5 = 0; //Zaehlschleife
      test_rot = 0; test_gruen = 0;

      do {
        if ( spielfeld [zw4] == 1) {
          test_rot ++;
        };
        if ( spielfeld [zw4] == 2) {
          test_gruen ++;
        };

        // -------------------- Merken der Position beim Sieg --------------------
        if (sieger == 0) {
          if (zw5 == 0) {
            position_1 = zw4;
          };
          if (zw5 == 1) {
            position_2 = zw4;
          };
          if (zw5 == 2) {
            position_3 = zw4;
          };
          if (zw5 == 3) {
            position_4 = zw4;
          };
        };

        zw4 = zw4 + 8; zw5++;
      }
      while (zw5 != 4);

      if (test_rot == 4) {
        sieger = 1;
      } else {
        test_rot = 0;
      };
      if (test_gruen == 4) {
        sieger = 2;
      } else {
        test_gruen = 0;
      };
      zw4 = zw4 - 24; zw6++;
      if (sieger != 0) {
        zw6 = 4;
      };
    }
    while ( zw6 != 4);

    zw4 = zw4 - 31; zw7++;
    if (sieger != 0) {
      zw7 = 8;
    };
  }
  while (zw7 != 8);

  // --------------------  Test wagerecht --------------------
  // 3 verschaltelte Zyklen
  zw4 = 8; // Startfeld beim Testen
  zw7 = 0;
  do {
    zw6 = 0;

    do {
      zw5 = 0;
      test_rot = 0; test_gruen = 0;
      do {
        if ( spielfeld [zw4] == 1) {
          test_rot ++;
        };
        if ( spielfeld [zw4] == 2) {
          test_gruen ++;
        };

        // -------------------- Merken der Position beim Sieg --------------------
        if (sieger == 0) {
          if (zw5 == 0) {
            position_1 = zw4;
          };
          if (zw5 == 1) {
            position_2 = zw4;
          };
          if (zw5 == 2) {
            position_3 = zw4;
          };
          if (zw5 == 3) {
            position_4 = zw4;
          };
        };

        zw4++; zw5++;
      }
      while (zw5 != 4);

      if (test_rot == 4) {
        sieger = 1;
      } else {
        test_rot = 0;
      };
      if (test_gruen == 4) {
        sieger = 2;
      } else {
        test_gruen = 0;
      };
      zw4 = zw4 + 4; zw6++;
      if (sieger != 0) {
        zw6 = 7;
      };
    }
    while ( zw6 != 7);

    zw4 = zw4 - 55; zw7++;
    if (sieger != 0) {
      zw7 = 5;
    };
  }
  while (zw7 != 5);

  // -------------------- Festlegen Siegerfarben --------------------

  if ( spiel_art == 1) {

    //-------------------- Siegerfarben Spieler gegen Rechner --------------------

    if (sieger == 1) {
      farbe_1 = rot;
      farbe_2 = rot;
      ende (); // Ausgabe Siegerfarbe Rot
    };
    if (sieger == 2) {
      farbe_1 = gruen;
      farbe_2 = gruen;
      ende (); // Ausgabe Siegerfarbe Gruen
    };
    if (zw8 == 56 ) {
      farbe_1 = gruen;
      farbe_2 = rot;
      ende (); // Ausgabe Unentschieden
    };

    position_1 = 0; position_2 = 0; position_3 = 0; position_4 = 0;
    test_rot = 0; test_gruen = 0;

  } else {

    //-------------------- Siegerfarben Spieler gegen Spieler --------------------
    if (sieger == 1) {
      farbe_1 = rot;
      farbe_2 = rot;
      ende (); // Ausgabe Siegerfarbe Rot
    };
    if (sieger == 2) {
      farbe_1 = gruen;
      farbe_2 = gruen;
      ende (); // Ausgabe Siegerfarbe Gruen
    };
    if (zw8 == 56 ) {
      farbe_1 = gruen;
      farbe_2 = rot;
      ende (); // Ausgabe Unentschieden
    };

    position_1 = 0; position_2 = 0; position_3 = 0; position_4 = 0;
    test_rot = 0; test_gruen = 0;

  };
}

// -------------------- Ausgabe Siegerfarbe, Vorbereitung neuer Start --------------------

void ende () {

  if (spiel_art == 1) {

    // -------------------- Ausgabe Siegerfarbe Spieler gegen Rechner --------------------

    zw11 = 0;

    if (zw8 != 56 ) {
      do {
        strip.setPixelColor (63 - position_1, 0, 0, 0);
        strip.setPixelColor (63 - position_2, 0, 0, 0);
        strip.setPixelColor (63 - position_3, 0, 0, 0);
        strip.setPixelColor (63 - position_4, 0, 0, 0);
        strip.show(); delay(200);
        strip.setPixelColor (63 - position_1, farbe_1);
        strip.setPixelColor (63 - position_2, farbe_1);
        strip.setPixelColor (63 - position_3, farbe_1);
        strip.setPixelColor (63 - position_4, farbe_1);
        strip.show(); delay(200);
        zw11++;

      NewTone(TONE_PIN,3000);
      delay(500);
      noNewTone(TONE_PIN);
      }

      while ( zw11 != 3);

    }

    zw9 = 0;
    do {
      strip.setPixelColor (63 - zw9, farbe_1); zw9++;
      strip.setPixelColor (63 - zw9, farbe_2); zw9++;
    }
    while (zw9 != 64);
    strip.show();

    delay(2000);

    zw10 = 0;
    do {
      strip.setPixelColor (63 - zw10, 0, 0, 0); spielfeld [zw10] = 0;
      zw10++;
    }
    while ( zw10 != 64);
    strip.show();

    if (sieger == 2) {
      zw10 = 0;

      do {
        strip.setPixelColor (63 - 2, 0, 5, 0); strip.setPixelColor (63 - 3, 0, 5, 0); strip.setPixelColor (63 - 4, 0, 5, 0); strip.setPixelColor (63 - 5, 0, 5, 0);
        strip.setPixelColor (63 - 9, 0, 5, 0); strip.setPixelColor (63 - 14, 0, 5, 0); strip.setPixelColor (63 - 16, 0, 5, 0); strip.setPixelColor (63 - 17, 0, 0, 5);
        strip.setPixelColor (63 - 18, 0, 0, 5); strip.setPixelColor (63 - 21, 0, 0, 5); strip.setPixelColor (63 - 22, 0, 0, 5); strip.setPixelColor (63 - 23, 0, 5, 0);
        strip.setPixelColor (63 - 24, 0, 5, 0); strip.setPixelColor (63 - 25, 0, 0, 5); strip.setPixelColor (63 - 26, 0, 0, 5); strip.setPixelColor (63 - 29, 0, 0, 5);
        strip.setPixelColor (63 - 30, 0, 0, 5); strip.setPixelColor (63 - 31, 0, 5, 0); strip.setPixelColor (63 - 32, 0, 5, 0); strip.setPixelColor (63 - 39, 0, 5, 0);
        strip.setPixelColor (63 - 40, 0, 5, 0); strip.setPixelColor (63 - 42, 5, 0, 0); strip.setPixelColor (63 - 45, 5, 0, 0); strip.setPixelColor (63 - 47, 0, 5, 0);
        strip.setPixelColor (63 - 49, 0, 5, 0); strip.setPixelColor (63 - 51, 5, 0, 0); strip.setPixelColor (63 - 52, 5, 0, 0); strip.setPixelColor (63 - 54, 0, 5, 0);
        strip.setPixelColor (63 - 58, 0, 5, 0); strip.setPixelColor (63 - 59, 0, 5, 0); strip.setPixelColor (63 - 60, 0, 5, 0); strip.setPixelColor (63 - 61, 0, 5, 0);
        strip.show(); delay(1000);

        strip.setPixelColor (63 - 21, 0, 0, 0); strip.setPixelColor (63 - 30, 0, 0, 0); strip.setPixelColor (63 - 59, 5, 0, 0); strip.setPixelColor (63 - 60, 5, 0, 0);
        strip.show(); delay(1000);
        zw10++;
      }
      while (zw10 != 2);
    }
    else {
      strip.setPixelColor (63 - 2, 0, 5, 0); strip.setPixelColor (63 - 3, 0, 5, 0); strip.setPixelColor (63 - 4, 0, 5, 0); strip.setPixelColor (63 - 5, 0, 5, 0);
      strip.setPixelColor (63 - 9, 0, 5, 0); strip.setPixelColor (63 - 14, 0, 5, 0); strip.setPixelColor (63 - 16, 0, 5, 0); strip.setPixelColor (63 - 17, 0, 0, 5);
      strip.setPixelColor (63 - 18, 0, 0, 5); strip.setPixelColor (63 - 21, 0, 0, 5); strip.setPixelColor (63 - 22, 0, 0, 5); strip.setPixelColor (63 - 23, 0, 5, 0);
      strip.setPixelColor (63 - 24, 0, 5, 0); strip.setPixelColor (63 - 25, 0, 0, 5); strip.setPixelColor (63 - 26, 0, 0, 5); strip.setPixelColor (63 - 29, 0, 0, 5);
      strip.setPixelColor (63 - 30, 0, 0, 5); strip.setPixelColor (63 - 31, 0, 5, 0); strip.setPixelColor (63 - 32, 0, 5, 0); strip.setPixelColor (63 - 39, 0, 5, 0);
      strip.setPixelColor (63 - 40, 0, 5, 0); strip.setPixelColor (63 - 50, 5, 0, 0); strip.setPixelColor (63 - 53, 5, 0, 0); strip.setPixelColor (63 - 47, 0, 5, 0);
      strip.setPixelColor (63 - 49, 0, 5, 0); strip.setPixelColor (63 - 43, 5, 0, 0); strip.setPixelColor (63 - 44, 5, 0, 0); strip.setPixelColor (63 - 54, 0, 5, 0);
      strip.setPixelColor (63 - 58, 0, 5, 0); strip.setPixelColor (63 - 59, 0, 5, 0); strip.setPixelColor (63 - 60, 0, 5, 0); strip.setPixelColor (63 - 61, 0, 5, 0);
      strip.show(); delay(2000);

    };

    // -------------------- Vorbereitung neuer Start Spieler gegen Rechner --------------------

    spielfeld [0] = 1; ausgabe_spielfeld ();
    zw1 = 0; zw2 = 0; zw3 = 0; zw4 = 0; zw5 = 0; zw6 = 0; zw7 = 0; zw8 = 0; zw9 = 0; zw10 = 0;
    position_1 = 0; position_2 = 0; position_3 = 0; position_4 = 0;
    position_0 = 0;

    // Wechsel Start-Spielfarbe
    farbe_1 = 0; farbe_2 = 0; sieger = 0;

    ausgabe_spielfeld ();

  } else {

    // -------------------- Ausgabe Siegerfarbe Spieler gegen Spieler --------------------

    zw11 = 0;

    if (zw8 != 56 ) {
      do {
        strip.setPixelColor (63 - position_1, 0, 0, 0);
        strip.setPixelColor (63 - position_2, 0, 0, 0);
        strip.setPixelColor (63 - position_3, 0, 0, 0);
        strip.setPixelColor (63 - position_4, 0, 0, 0);
        strip.show(); delay(200);
        strip.setPixelColor (63 - position_1, farbe_1);
        strip.setPixelColor (63 - position_2, farbe_1);
        strip.setPixelColor (63 - position_3, farbe_1);
        strip.setPixelColor (63 - position_4, farbe_1);
        strip.show(); delay(200);
        zw11++;

       NewTone(TONE_PIN,3000);
      delay(500);
      noNewTone(TONE_PIN);
      }
      while ( zw11 != 3);
    }

    zw9 = 0;
    do {
      strip.setPixelColor (63 - zw9, farbe_1); zw9++;
      strip.setPixelColor (63 - zw9, farbe_2); zw9++;
    }
    while (zw9 != 64);
    strip.show();
    delay(2000);
    
    // -------------------- Vorbereitung neuer Start Spieler gegen Spieler --------------------

    zw10 = 0;
    do {
      strip.setPixelColor (63 - zw10, 0, 0, 0); spielfeld [zw10] = 0;
      zw10++;
    }
    while ( zw10 != 64);
    strip.show();

    spielfeld [0] = 1; ausgabe_spielfeld ();
    zw1 = 0; zw2 = 0; zw3 = 0; zw4 = 0; zw5 = 0; zw6 = 0; zw7 = 0; zw8 = 0; zw9 = 0; zw10 = 0;
    position_1 = 0; position_2 = 0; position_3 = 0; position_4 = 0;
    position_0 = 0;

    // Wechsel Start-Spielfarbe
    farbe_1 = 0; farbe_2 = 0; sieger = 0;

    if (status_start == 1) {
      farbe = gruen; status_spiel = 2; status_start = 2;
      spielfeld [0] = 2;
    } else {
      farbe = rot;
      spielfeld [0] = 1; status_spiel = 1; status_start = 1;
    };

    ausgabe_spielfeld ();
  };
}

// --------------------  Ein Schritt nach Links --------------------
void links_0 () {
  if (position_0 != 0) {
    spielfeld [position_0] = 0;
    position_0--;
    spielfeld [ position_0 ] = status_spiel;

      NewTone(TONE_PIN,1000);
      delay(100);
      noNewTone(TONE_PIN);
    
  };
}

// --------------------  Ein Schritt nach Rechts --------------------
void rechts_0 () {
  if (position_0 != 7) {
    spielfeld [position_0] = 0;
    position_0++;
    spielfeld [ position_0 ] = status_spiel;

      NewTone(TONE_PIN,1000);
      delay(100);
      noNewTone(TONE_PIN);
    
  };
}

// --------------------  Absenken des Spielsteines --------------------
void runter_0 () {
  zw3 = 0;
  do {
    if (spielfeld [position_0 + 8] == 0 ) {
      spielfeld [position_0] = 0; position_0 = position_0 + 8; spielfeld [position_0] = status_spiel;
      zw3++;
      NewTone(TONE_PIN,1000);
      delay(100);
      noNewTone(TONE_PIN);
      
      ausgabe_spielfeld (); delay(200);
    }
    else {
      zw3 = 7;
    }
  }
  while (zw3 != 7) ;
  richtung = 0; position_0 = 0;
  if (status_spiel == 1 ) {
    status_spiel = 2;
    spielfeld [position_0] = 2;
  } else {
    status_spiel = 1;
    spielfeld [position_0] = 1;
  };
  ausgabe_spielfeld ();
}

// --------------------  Ausgabe Spielfeld --------------------
void ausgabe_spielfeld () {
  zw1 = 0;

  do {
    zw2 = spielfeld [zw1];
    if (zw2 == 0) {
      strip.setPixelColor (63 - zw1, 0, 0, 0);
    };
    if (zw2 == 1) {
      strip.setPixelColor (63 - zw1, rot);
    };
    if (zw2 == 2) {
      strip.setPixelColor (63 - zw1, gruen);
    };
    zw1++;
  }
  while (zw1 != 64);
  strip.show();
}



// ++++++++++++++++++++ Beschreibung Testtabellen ++++++++++++++++++++
//
// auswertung_vergleich
// Zeile 1 bis 3
// Spalten: 1 - 8 Ergebnisse nach Setzen, 9 Maximum, 10 laufende Zeilennummer
//
// Zeilen:
// Zeile 1 -> 2-Gruppe, Zeile 2 -> 3-Gruppe, Zeile 3 -> 4-Gruppe
// Zeile 4 = 1 -> setzen moeglich
//
// Zeile 5 -> hoechste Gruppe von gruen in der betreffenden Spalte
// Zeile 6 -> Uebertrag hoechste Gruppe aus auswertung_rot
// Zeile 7 -> Wertung aus Zeile 5 und 6
//
// Zeile 8 -> der höchste Wert in Zeile 7 wird mit einer Zufallzahl multipliziert");
// Damit wird bei mehreren Maxima ein Wert zufaellig ausgewaehlt");
//
// Beim ersten Zug wird die Auswertung nicht berueksichtigt");
//
// Zeile [11] in auswertung _vergleich
//
// Spalte [0] = 1 -> Rechner gewinnt. (7)
// Spalte [1] = 1 -> Spieler kann gewinnen. (7)
// Spalte [2] = 1 -> auswahl_vergleich Zeile [6] (hoechste Wert aus auswertung_rot) alles 3. (8)
// Spalte [3] = 1 -> Spieler gewinnt auf jeden Fall. (9)
// Spalte [4] = 1 -> max_zug_1 (beste Zug) in allen Spalten gleich 0 (12)
// Spalte [5] = 1 -> auswertung_rot [8] alles 3. (13)
// Spalte [6]     -> Anzahl der Verschiebungen, gewaelte Spalte war gesperrt.(16)
//
// auwertung_rot
// Zeile 1 - 8
// Eine Zeile entspricht den 8 Möglichkeiten von Rot bei einer Spalte von Gruen.
// Es wird immer die groeste moegliche Gruppe gespeichert.
// Zeile 9 -> Die Anzahl der Dreien in einer Spalte.
// Zeile 10 -> Die Anzahl der Vieren in einer Spalte.
Schematic and Layout
Schematic
Schematic.jpg
CAD-Custom parts and enclosures
grid
mesh8x8.stl
May 26,2023
468 views
Arduino Connect4 Game- Human vs Microcontroller

Connect4 game on an 8 x 8 pixel matrix with 5050 type LEDs with a built-in WS2812B chip.
468
Published: May 26,2023
PCBWay Donate 10% cost To Author
Add to cart
*PCBWay community is a sharing platform. We are not responsible for any design issues and parameter issues (board thickness, surface finish, etc.) you choose.
Copy this HTML into your page to embed a link to order this shared project
Copy