Hardware components | ||||||
 |
| × | 1 | |||
| × | 1 | ||||
 |
| × | 1 | |||
 |
| × | 3 | |||
Software apps and online services | ||||||
 |
| |||||
Hand tools and fabrication machines | ||||||
 |
| |||||
 |
| |||||
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.
/* 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.
Comments