Mirko Pavleski
Published © GPL3+

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.

BeginnerFull instructions provided2 hours1,082
Arduino Connect4 Game- Human vs Microcontroller

Things used in this project

Hardware components

Arduino Nano R3
Arduino Nano R3
×1
8x8 RGB LED matrix with WS2812 chips
×1
Buzzer
Buzzer
×1
Pushbutton Switch, Momentary
Pushbutton Switch, Momentary
×3

Software apps and online services

Arduino IDE
Arduino IDE

Hand tools and fabrication machines

Soldering iron (generic)
Soldering iron (generic)
Solder Wire, Lead Free
Solder Wire, Lead Free

Story

Read more

Custom parts and enclosures

Grid

.stl file

Schematics

Schematic

circuit diagram,

Code

Arduino code

C/C++
code,
/* 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;
        };
...

This file has been truncated, please download it to see its full contents.

Credits

Mirko Pavleski

Mirko Pavleski

127 projects • 1192 followers

Comments