#include <Adafruit_NeoPixel.h>
// la matrice
const size_t nbLignes = 8;
const size_t nbColonnes = 8;
const size_t nbNeopixels = (nbColonnes*nbLignes);
Adafruit_NeoPixel strip(nbNeopixels, 6, NEO_GRB + NEO_KHZ800);

const uint32_t ROUGE = strip.Color(127, 0, 0);
const uint32_t VERT = strip.Color(0, 127, 0);
const uint32_t NOIR = strip.Color(0, 0, 0);
uint32_t couleur = 0;

// Numéro des ports nécessaires
const byte brocheDroite = 10;
const byte brocheGauche = 9;
const byte brocheBas  = 8;



// Déroulement variable
byte zw1 = 0;
//int zw2 = 0; // sont utilisés dans "Sortie du terrain".
byte zw2 = 0; // sont utilisés dans "Sortie du terrain".
byte zw3 = 0; // est utilisé pour abaisser les pions
byte zw4 = 0; // Zone de départ lors du test, score
byte zw5 = 0; // Boucle interne de comptage, teste 4 champs,
byte zw6 = 0; // Boucle moyenne de comptage, teste une colonne, teste le score
byte zw7 = 0; // Boucle extérieure de comptage, teste toutes les colonnes, teste le score
byte zw8 = 0; // Pierres tombées
byte zw9 = 0; // Édition couleur gagnante
byte zw10 = 0; //Effacer l'affichage et le champ de jeu
byte zw11 = 0; //Clignotement des pierres de victoire
uint32_t couleur_1 = 0; uint32_t couleur_2 = 0; // Couleur gagnante
byte position_1 = 0; byte position_2 = 0; byte position_3 = 0; byte position_4 = 0; //Position des pions gagnants
byte resultat_zw1 = 0; // La boucle externe est utilisée pour tester le programme.
byte resultat_zw2 = 0; // le meulage interne est utilisé pour tester le programme


byte direction = 0 ; // 1 -> brocheDroite; 2 -> brocheGauche; 3 -> brocheBas
byte status_start = 1; // 1 -> ROUGE; 2 -> VERT, ne s'applique qu'aux joueurs contre les joueurs
byte status_spiel = 1 ; // 1 -> ROUGE; 2 -> VERT, ne s'applique qu'aux joueurs contre les joueurs
byte status_spiel_spieler = 0 ; //Statut de jeu pour les déplacements possibles du joueur
byte position_0 = 0; // Pointeur pour le terrain de jeu
byte test_rouge = 0; byte test_vert = 0; byte vainqueur = 0; // Nécessaire pour déterminer le vainqueur

// Calculateur variable Détermination du coup suivant

byte r_zw1 = 0; // Valeur de clôture pour copier les terrains de jeu
byte r_zw2 = 0; // nbColonnes essais Calculatrice
byte r_zw3 = 0; // Adresse de la pierre définie par l'ordinateur
byte r_zw4 = 0; // nbColonnes essais possibles Joueurs
byte r_zw5 = 0; // Adresse du pion placé par l'ordinateur pour l'essai du joueur
byte r_zw6 = 0; // Mémoire tampon Évaluation Test
byte r_zw7 = 0; // Étapes après le test
byte r_zw8 = 0; // Test de comptage pour l'évaluation
byte r_zw9 = 0; // Mémoire tampon pour zw4
byte r_zw10 = 0; // Evaluation Table évaluation_comparaison (groupe en ligne 6)
byte r_zw11_1 = 0; // Auswertung Tabelle evaluation_rouge
byte r_zw11_2 = 0; // evaluation Tabelle evaluation_rouge
byte r_zw12 = 0; // Entrée resultat de l'analyse dans evaluation_comparaison, détermination du meilleur coup
byte r_zw12_1 = 0; // Entrée resultat de l'analyse dans evaluation_comparaison, détermination du meilleur coup
byte r_zw14 = 0; // Étapes de l'abaissement
byte max_rouge = 0; // Valeur maximale d'une ligne dans un tableau evaluation_rouge
byte max_zug_1 = 0; // Détermine le meilleur coup
byte max_vert_2 = 0; // Maximum de 2 groupes pour un train
byte max_vert_3 = 0; // Maximum de 3 groupes lors d'un coup
byte max_vert_4 = 0; // Maximum de 4 groupes pour un train
byte r_test_rouge = 0; byte r_test_vert = 0; // Test du score
byte r_test_vert_1 = 0; byte r_test_vert_2 = 0; byte r_test_vert_3 = 0; byte r_test_vert_4 = 0; // Test du score par longueur de chaîne
byte spiel_art = 0; // 1-> contre calculateur, 2 -> joueur contre joueur ;
byte r_erster_zug = 0; // 0 -> le joueur commence, 1 -> l'ordinateur commence
byte r_anzahl_zuege = 0 ; //Nombre de coups pour joueur contre calculateur
byte r_alles3 = 0; // Mémoire intermédiaire pour cas particulier dans l'évaluation
byte r_alles4 = 0; // Mémoire intermédiaire pour cas particulier dans l'évaluation
byte hasard = 0; // est nécessaire pour atteindre un début indéterminé

// 0 -> non attestée ; 1 -> ROUGE; 2 -> VERT
byte spielfeld[(nbColonnes * nbLignes)] = {
  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
};

// Copie du terrain de jeu, nécessaire en cas de match ordinateur contre joueur.
// 0 -> pas occupé ; 1 -> ROUGE ; 2 -> VERT
byte spielfeld_r1 [(nbColonnes * nbLignes)] = {
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0
};


// L'évaluation du terrain de jeu et les conclusions sont déposées dans le champ (ordinateur contre joueur).
byte evaluation_comparaison [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 Calculateur, nbColonnes fois addirectionaire
byte evaluation_rouge [10][nbColonnes] = {
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 0, 0, 0, 0},
};


size_t zigzagVersLineaire(size_t num) {
  size_t ligne = num / nbColonnes;
  size_t colonne = num % nbColonnes;
  if (ligne % 2 == 0) colonne = nbColonnes - colonne - 1;
  return ligne * nbColonnes + colonne;
}

//*****************************************
//    SETUP
//*****************************************
void setup() {
  pinMode(brocheDroite, INPUT_PULLUP);
  pinMode(brocheGauche, INPUT_PULLUP);
  pinMode(brocheBas, INPUT_PULLUP);

  Serial.begin(115200);

  strip.begin();
  strip.clear();
  strip.show(); // Initialiser tous les pixels à "off".


  // -------------------- Choix de jeu brocheGauche à deux, brocheDroite contre calculateur --------------------

  strip.setPixelColor(zigzagVersLineaire(nbNeopixels - 1), ROUGE);
  strip.setPixelColor(zigzagVersLineaire(nbNeopixels - 2), VERT);
  strip.setPixelColor(zigzagVersLineaire(nbNeopixels - 5), ROUGE);
  strip.show();

  do {
    if ( digitalRead(brocheDroite) == LOW) spiel_art = 1;
    if ( digitalRead(brocheGauche) == LOW) spiel_art = 2;
  } while (spiel_art == 0);

  strip.setPixelColor(zigzagVersLineaire(nbNeopixels - 1), NOIR);
  strip.setPixelColor(zigzagVersLineaire(nbNeopixels - 2), NOIR);
  strip.setPixelColor(zigzagVersLineaire(nbNeopixels - 5), NOIR);
  strip.show();
  delay(1000);

  sortie_terrain_de_jeu ();
}


//*****************************************
//    LOOP
//*****************************************
void loop() {
  do {

    hasard = random(1, 20); // début indéterminé

    if (digitalRead(brocheDroite) == LOW && digitalRead(brocheGauche) == LOW) {
      zw8 = 56; // Match nul
      test_joueur ();
    }
    if ( digitalRead(brocheDroite) == LOW) {
      direction = 1;
      droite_0();
    }

    if ( digitalRead(brocheGauche) == LOW) {
      direction = 2;
      gauche_0();
    }

    if ( digitalRead(brocheBas) == LOW ) {
      if (spielfeld[position_0 + nbColonnes] == 0) {
        direction = 3;
        bas_0(); zw8 ++; // Nombre de passages + 1
        test_joueur ();

        // -------------------- Appel en cas d'ordinateur contre joueur --------------------

        if (spiel_art == 1) {
          calculatrice ();
          test_joueur ();
        }
      }
    }
  }
  while ( direction == 0);
  direction = 0; // Effacer la direction

  sortie_terrain_de_jeu ();
  delay(300);
}

// -------------------- Parties de programme Jeu Calculatrice --------------------

// -------------- Première partie du programme appelée lors d'un match joueur contre ordinateur --------------------------
void calculatrice () {

  // -------------------- Chargement terrain de jeu_r1; --------------------
  r_zw1 = 0;
  do {
    spielfeld_r1 [r_zw1] = spielfeld[r_zw1];
    r_zw1++;
  }
  //while ( r_zw1 != (nbColonnes*nbLignes));
  while ( r_zw1 != (nbColonnes * nbLignes - 1));

  // -------------------- nbColonnes tentatives Calculatrice, placer une pierre propre, calculatrice toujours verte --------------------
  r_zw2 = 0; r_zw6 = 0; r_zw7 = 0; r_zw8 = 0;

  do {
    r_zw3 = 0;
    if (spielfeld_r1 [r_zw2 + nbColonnes] != 0) {
      r_zw3 = 0; // Aucune pierre n'a été posée
      evaluation_comparaison [4][r_zw2] = 0;
      r_zw2 ++;
    }
    else {
      evaluation_comparaison [4][r_zw2] = 1;
      if (spielfeld_r1 [r_zw2 + 16] != 0) {
        spielfeld_r1 [r_zw2 + nbColonnes] = 2; r_zw3 = r_zw2 + nbColonnes; 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 ++;
                }
              }
            }
          }
        }
      }
    }

    // -------------------- Réécrire le nbNeopixels de groupes 1, 2, 3 et 4. 1 n'est pas évalué. ----------
    test_spielstand_vert ();
    evaluation_comparaison [0][r_zw2 - 1] = r_test_vert_1; evaluation_comparaison [1][r_zw2 - 1] = r_test_vert_2;
    evaluation_comparaison [2][r_zw2 - 1] = r_test_vert_3; evaluation_comparaison [3][r_zw2 - 1] = r_test_vert_4;

    // -------------------- Placer une pierre étrangère --------------------
    // Les nbColonnes possibilités sont testées (pour chaque nouvelle pierre).
    r_zw4 = 0;
    do {
      r_zw5 = 0;

      if (spielfeld_r1 [r_zw4 + nbColonnes] != 0) {
        r_zw5 = 0; // Pas de pierre posée
        r_zw4 ++;
      }
      else {
        if (spielfeld_r1 [r_zw4 + 16] != 0) {
          spielfeld_r1 [r_zw4 + nbColonnes] = 1; r_zw5 = r_zw4 + nbColonnes; 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_rouge ();
      evaluation_rouge [r_zw2 - 1][r_zw4 - 1] = r_test_rouge;

      spielfeld_r1 [ r_zw5] = 0; // Effacer la pierre de test étrangère
    }
    while (r_zw4 != nbColonnes); // ------------- Mettre fin à la pierre étrangère-------------------

    spielfeld_r1 [ r_zw3] = 0; // Loeschen Teststein eigen
  }
  while (r_zw2 != nbColonnes); // Fin de la pose de pierres pour le test

  // ( 01 ) -------------------- Détermination de max_vert_2, max_vert_3, max_vert_4, --------------------

  r_zw10 = 0; max_vert_2 = 0; max_vert_3 = 0; max_vert_4 = 0;

  do {
    if (max_vert_2 < evaluation_comparaison [1][r_zw10]) {
      max_vert_2 = evaluation_comparaison [1][r_zw10];
    }
    if (max_vert_3 < evaluation_comparaison [2][r_zw10]) {
      max_vert_3 = evaluation_comparaison [2][r_zw10];
    }
    if (max_vert_4 < evaluation_comparaison [3][r_zw10]) {
      max_vert_4 = evaluation_comparaison [3][r_zw10];
    }
    r_zw10++;
  } while (r_zw10 != nbColonnes);

  evaluation_comparaison [1][nbColonnes] = max_vert_2;
  evaluation_comparaison [2][nbColonnes] = max_vert_3;
  evaluation_comparaison [3][nbColonnes] = max_vert_4;


  // -------------------- Réécriture de resultats à la ligne 5 de evaluation_comparaison --------------------
  // ( 02 ) -------------------- Effacer la ligne 5 --------------------

  r_zw10 = 0;

  do {
    evaluation_comparaison [5][r_zw10] == 0;
    r_zw10++;
  } while (r_zw10 != nbColonnes);

  // (03 ) -------------------- Inscrire la valeur la plus élevée de chaque colonne des lignes 1 à 3 dans la ligne 5. --------------------

  r_zw10 = 0;
  do {
    if (evaluation_comparaison [4][r_zw10] == 0)
    {
      evaluation_comparaison [5][r_zw10] = 0; // Colonne pleine
    }
    else {
      if (evaluation_comparaison [3][r_zw10] > 0 && evaluation_comparaison [3][r_zw10] == max_vert_4)

      { evaluation_comparaison [5][r_zw10] = 4;
      } else {
        if (evaluation_comparaison [2][r_zw10] > 0 && evaluation_comparaison [2][r_zw10] == max_vert_3) {
          evaluation_comparaison [5][r_zw10] = 3;
        } else {
          if (evaluation_comparaison [1][r_zw10] > 0 && evaluation_comparaison [1][r_zw10] == max_vert_2) {
            evaluation_comparaison [5][r_zw10] = 2;
          } else {
            evaluation_comparaison [5][r_zw10] = 0;
          }
        }
      }
    }
    r_zw10++;
  } while (r_zw10 != nbColonnes);

  // ( 04 ) -------------------- Détermination et saisie de max_rouge à partir de evaluation_rouge après la ligne 6 dans evaluation_comparaison --------------------

  r_zw11_1 = 0;
  do {
    r_zw11_2 = 0; max_rouge = 0;
    do {
      if (evaluation_rouge [r_zw11_1][r_zw11_2] > max_rouge) {
        max_rouge = evaluation_rouge [r_zw11_1][r_zw11_2];
      }
      r_zw11_2++;
    } while (r_zw11_2 != nbColonnes);
    evaluation_comparaison [6][r_zw11_1] = max_rouge;
    r_zw11_1++;
  } while (r_zw11_1 != nbColonnes);

  // ( 05 ) -------------------- Supprimer les lignes [nbColonnes] et [9] dans evaluation_rouge --------------------

  r_zw11_1 = 0;

  do {
    evaluation_rouge [nbColonnes][r_zw11_1] = 0; evaluation_rouge [9][r_zw11_1] = 0;
    r_zw11_1++;
  } while (r_zw11_1 != nbColonnes);

  // ( 06 ) -------------------- Nombre 3 dans evaluation_rouge [6] --------------------
  r_zw11_1 = 0;

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

    r_zw11_1 ++;

  } while (r_zw11_1 != nbColonnes);

  // ( 07 ) -------------------- Evaluation_comparaison lignes 5 et 6 pour déterminer le meilleur coup --------------------
  // -------------------- resultat in evaluation_comparaison Ligne 7 --------------------

  r_zw12 = 0;

  do {
    if (evaluation_comparaison [5][r_zw12] == 4) { // La calculatrice gagne
      evaluation_comparaison [7][r_zw12] = 10; evaluation_comparaison [11][0] = 1;

    } else {
      if (evaluation_comparaison [6][r_zw12] == 4) { // Le joueur pourrait gagner
        evaluation_comparaison [7][r_zw12] = 0; evaluation_comparaison [11][1] = 1;

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

  // ( 08 )-------------------- evaluation_comparison [6] tout 3 --------------------
  // Si tous les evaluation_rouge [6] == 3, alors il y a plusieurs possibilités pour un groupe 3
  // Un autre mode d'évaluation est alors utilisé au lieu de l'évaluation normale.

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

    r_zw11_1 = 0;
    do {
      evaluation_comparaison [7][r_zw11_1] = evaluation_rouge [nbColonnes][r_zw11_1];
      r_zw11_1 ++;
    } while (r_zw11_1 != nbColonnes);
  }
  else {
    r_alles3 = 0;
  }

  // ( 09 ) -------------------- evaluation_comparison [6] alles 4 --------------------
  // Si tous les evaluation_rouge [6] == 4, alors il y a plusieurs possibilités pour un groupe de 4
  // Un autre mode d'évaluation est alors utilisé au lieu de l'évaluation normale.

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

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

  // ( 10 ) --------------------- Blocage des colonnes pleines --------------------

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

  // ( 11 ) -------------------- Détermination de la valeur la plus élevée --------------------

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

  // ( 12 ) -------------------- max_trait_1 = 0--------------------
  // Pas de coup utile possible selon le schéma d'évaluation,
  // la valeur la plus élevée de evaluation_comparaison [1], [2] et [3] est définie.

  if (max_zug_1 == 0) {

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

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

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

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

  // ( 13 ) -------------------- Nombre 3 dans evaluation_rouge [nbColonnes] égal dans toutes les colonnes --------------------

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

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

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

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

  // ( 14 ) -------------------- Le hasard pour des résultats identiques --------------------

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

  // ( 15 ) -------------------- Mettre le premier coup ou les étapes suivantes --------------------
  if (zw8 < 2 ) {
    if (spielfeld[59] == 0) {
      r_zw14 = 3;
    } else {
      r_zw14 = 4;
    }
  } else {

    // ( 16 ) -------------------- Étapes direction la valeur la plus élevée --------------------
    max_zug_1 = 0; r_zw12 = 0; r_zw14 = 0;

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

  // --------------------( 17 ) La colonne sélectionnée était déjà bloquée, la prochaine colonne libre sera utilisée..--------------------
  // --------------------Cela ne se produit que si toutes les colonnes sont bloquées ou entraînent la perte de l'ordinateur.

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

  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  // output_resultat () ; // uniquement à des fins de test. Si la ligne est active, les données de l'évaluation sont affichées sur l'écran.
  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  delay (600);

  // ( 18 ) -------------------- Étapes de l'examen --------------------

  if (r_zw14 != 0) {
    do {
      droite_0(); sortie_terrain_de_jeu (); delay(500);
      r_zw14--;
    } while (r_zw14 != 0);
  }
  bas_0(); zw8++;
}

// -------------------Test du score -----------------------
// Valeurs de transfert r_test_vert, r_test_rouge

void test_spielstand_vert () {

  r_test_vert = 0; r_test_vert_1 = 0; r_test_vert_2 = 0; r_test_vert_3 = 0; r_test_vert_4 = 0;

  // -------------------- VERT Test diagonal en haut Calculatrice --------------------

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

  do {
    zw6 = 0; // Boucles d'oreilles
    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_vert_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_vert_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_vert_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_vert_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_vert_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_vert_4++;
      }
      zw6 ++; zw4 = zw4 + 1;
    }
    while (zw6 != 5);

    r_zw9 = r_zw9 + nbColonnes; zw4 = r_zw9;

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

  // -------------------- VERT Test diagonal en brocheBas Calculatrice --------------------

  zw4 = nbColonnes; // Champ de départ lors du test
  r_zw9 = zw4; // Mémoire tampon
  zw7 = 0; // Boucles d'oreilles

  do {
    zw6 = 0; // Boucles d'oreilles
    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_vert_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_vert_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_vert_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_vert_3++;
      }
      // (1)2 3 4
      if (spielfeld_r1 [zw4 + nbColonnes] != 0 && spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + 9] == 2 && spielfeld_r1 [zw4 + 18] == 2 && spielfeld_r1 [zw4 + 27] == 2) {
        r_test_vert_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_vert_4++;
      }
      zw6 ++; zw4 = zw4 + 1;
    }
    while (zw6 != 5);
    r_zw9 = r_zw9 + nbColonnes; zw4 = r_zw9;
    zw7 ++;
  }
  while (zw7 != 4);

  // -------------------- VERT Test vertical Calculatrice --------------------

  zw4 = nbColonnes; // Champ de départ lors du test
  r_zw9 = zw4; // Mémoire tampon
  zw7 = 0; // Boucles d'oreilles

  do {
    zw6 = 0; // Boucles d'oreilles
    do {

      // 1 2
      if (spielfeld_r1 [zw4] == 2 && spielfeld_r1 [zw4 + nbColonnes] == 2 && spielfeld_r1 [zw4 + 16] == 0 && spielfeld_r1 [zw4 + 24] == 0) {
        r_test_vert_2++;
      }
      // 2 3
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + nbColonnes] == 2 && spielfeld_r1 [zw4 + 16] == 2 && spielfeld_r1 [zw4 + 24] == 0) {
        r_test_vert_2++;
      }
      // 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + nbColonnes] == 0 && spielfeld_r1 [zw4 + 16] == 2 && spielfeld_r1 [zw4 + 24] == 2) {
        r_test_vert_2++;
      }
      // 1 2 3
      if (spielfeld_r1 [zw4] == 2 && spielfeld_r1 [zw4 + nbColonnes] == 2 && spielfeld_r1 [zw4 + 16] == 2 && spielfeld_r1 [zw4 + 24] == 0) {
        r_test_vert_3++;
      }
      // 2 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + nbColonnes] == 2 && spielfeld_r1 [zw4 + 16] == 2 && spielfeld_r1 [zw4 + 24] == 2) {
        ; r_test_vert_3++;
      }
      // 1 2 3 4
      if (spielfeld_r1 [zw4] == 2 && spielfeld_r1 [zw4 + nbColonnes] == 2 && spielfeld_r1 [zw4 + 16] == 2 && spielfeld_r1 [zw4 + 24] == 2) {
        r_test_vert_4++;
      }
      zw6 ++; zw4 = zw4 + 1;
    }
    while (zw6 != nbColonnes);

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

  // -------------------- VERT Test horizontal Calculatrice --------------------

  zw4 = nbColonnes; // 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_vert_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_vert_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_vert_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_vert_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_vert_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_vert_4++;
      }
      zw6 ++; zw4 = zw4 + nbColonnes;
    }
    while (zw6 != 7);
    r_zw9 = r_zw9 + 1; zw4 = r_zw9; // Offset
    zw7 ++;
  }
  while (zw7 != 5);
}

void test_spielstand_rouge () {

  // -------------------- ROUGE Test diagonal en haut Joueur --------------------

  zw4 = 32; // Startfeld beim Testen
  r_zw9 = zw4; // Zwischenspeicher
  zw7 = 0; // Zaehlschleife
  r_test_rouge = 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_rouge < 2) {
          r_test_rouge = 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_rouge < 2) {
          r_test_rouge = 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_rouge < 2) {
          r_test_rouge = 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_rouge < 3) {
          r_test_rouge = 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_rouge < 3) {
          r_test_rouge = 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_rouge < 4) {
          r_test_rouge = 4;
        }
      }
      zw6 ++; zw4 = zw4 + 1;
    }
    while (zw6 != 5);

    r_zw9 = r_zw9 + nbColonnes; zw4 = r_zw9;
    zw7 ++;
  }

  while (zw7 != 4);

  // -------------------- ROUGE Test diagonal en brocheBas Joueur --------------------

  zw4 = nbColonnes; // 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_rouge < 2) {
          r_test_rouge = 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_rouge < 2) {
          r_test_rouge = 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_rouge < 2) {
          r_test_rouge = 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_rouge < 3) {
          r_test_rouge = 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_rouge < 3) {
          r_test_rouge = 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_rouge < 4) {
          r_test_rouge = 4;
        }
      }
      zw6 ++; zw4 = zw4 + 1;
    }
    while (zw6 != 5);

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

  // -------------------- ROUGE Test vertical Joueurs --------------------
  zw4 = nbColonnes; // 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 + nbColonnes] == 1 && spielfeld_r1 [zw4 + 16] == 0 && spielfeld_r1 [zw4 + 24] == 0) {
        if (r_test_rouge < 2) {
          r_test_rouge = 2;
        }
      }
      // 2 3
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + nbColonnes] == 1 && spielfeld_r1 [zw4 + 16] == 1 && spielfeld_r1 [zw4 + 24] == 0) {
        if (r_test_rouge < 2) {
          r_test_rouge = 2;
        }
      }
      // 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + nbColonnes] == 0 && spielfeld_r1 [zw4 + 16] == 1 && spielfeld_r1 [zw4 + 24] == 1) {
        if (r_test_rouge < 2) {
          r_test_rouge = 2;
        }
      }
      // 1 2 3
      if (spielfeld_r1 [zw4] == 1 && spielfeld_r1 [zw4 + nbColonnes] == 1 && spielfeld_r1 [zw4 + 16] == 1 && spielfeld_r1 [zw4 + 24] == 0) {
        if (r_test_rouge < 3) {
          r_test_rouge = 3;
        }
      }
      // 2 3 4
      if (spielfeld_r1 [zw4] == 0 && spielfeld_r1 [zw4 + nbColonnes] == 1 && spielfeld_r1 [zw4 + 16] == 1 && spielfeld_r1 [zw4 + 24] == 1) {
        if (r_test_rouge < 3) {
          r_test_rouge = 3;
        }
      }
      // 1 2 3 4
      if (spielfeld_r1 [zw4] == 1 && spielfeld_r1 [zw4 + nbColonnes] == 1 && spielfeld_r1 [zw4 + 16] == 1 && spielfeld_r1 [zw4 + 24] == 1) {
        if (r_test_rouge < 4) {
          r_test_rouge = 4;
        }
      }

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

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

  // -------------------- ROUGE Test horizontal Joueur --------------------

  zw4 = nbColonnes; // 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_rouge < 2) {
          r_test_rouge = 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_rouge < 2) {
          r_test_rouge = 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_rouge < 2) {
          r_test_rouge = 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_rouge < 3) {
          r_test_rouge = 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_rouge < 3) {
          r_test_rouge = 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_rouge < 4) {
          r_test_rouge = 4;
        }
      }

      zw6 ++; zw4 = zw4 + nbColonnes;
    }

    while (zw6 != 7);

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

}

// -------------------- Programmes en général --------------------

// -------------------- Tester s'il y a un vainqueur --------------------
//  Le programme est appelé après l'abaissement d'une pierre
void test_joueur () {

  // -------------------- Test diagonal en haut --------------------
  // 3 cycles coffrés

  zw4 = 32; // Champ de départ lors du test
  vainqueur = 0; zw7 = 0;

  do {
    zw6 = 0;

    do {
      zw5 = 0; // Zaehlschleife
      test_rouge = 0; test_vert = 0;

      // -------------------- Tester 4 cellules diagonales en haut --------------------
      do {
        if ( spielfeld[zw4] == 1) {
          test_rouge ++;
        }
        if ( spielfeld[zw4] == 2) {
          test_vert ++;
        }

        // -------------------- Mémoriser la position lors de la victoire --------------------
        if (vainqueur == 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_rouge == 4) {
        vainqueur = 1;
      } else {
        test_rouge = 0;

      }
      if (test_vert == 4) {
        vainqueur = 2;
      } else {
        test_vert = 0;

      }
      zw4 = zw4 + 36; zw6++;
      if (vainqueur != 0) {
        zw6 = 4;
      }
    }
    while ( zw6 != 4);

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

  // -------------------- Test en diagonale direction le brocheBas --------------------
  // 3 cycles coffrés

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

  do {
    zw6 = 0;
    do {
      zw5 = 0; //Zaehlschleife
      test_rouge = 0; test_vert = 0;

      do {
        if ( spielfeld[zw4] == 1) {
          test_rouge ++;
        }
        if ( spielfeld[zw4] == 2) {
          test_vert ++;
        }

        // -------------------- Mémoriser la position lors de la victoire --------------------
        if (vainqueur == 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_rouge == 4) {
        vainqueur = 1;
      } else {
        test_rouge = 0;
      }
      if (test_vert == 4) {
        vainqueur = 2;
      } else {
        test_vert = 0;
      }
      zw4 = zw4 - 28; zw6++;
      if (vainqueur != 0) {
        zw6 = 4;
      }
    }
    while ( zw6 != 4);

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

  // -------------------- Test vertical --------------------
  // 3 cycles coffrés

  zw4 = nbColonnes; // Champ de départ lors des essais
  zw7 = 0;
  do {
    zw6 = 0;

    do {
      zw5 = 0; //Zaehlschleife
      test_rouge = 0; test_vert = 0;

      do {
        if ( spielfeld[zw4] == 1) {
          test_rouge ++;
        }
        if ( spielfeld[zw4] == 2) {
          test_vert ++;
        }

        // -------------------- Mémoriser la position lors de la victoire --------------------
        if (vainqueur == 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 + nbColonnes; zw5++;
      }
      while (zw5 != 4);

      if (test_rouge == 4) {
        vainqueur = 1;
      } else {
        test_rouge = 0;
      }
      if (test_vert == 4) {
        vainqueur = 2;
      } else {
        test_vert = 0;
      }
      zw4 = zw4 - 24; zw6++;
      if (vainqueur != 0) {
        zw6 = 4;
      }
    }
    while ( zw6 != 4);

    zw4 = zw4 - 31; zw7++;
    if (vainqueur != 0) {
      zw7 = nbColonnes;
    }
  }
  while (zw7 != nbColonnes);

  // -------------------- Test à l'horizontale --------------------
  // 3 cycles coffrés
  zw4 = nbColonnes; // Startfeld beim Testen
  zw7 = 0;
  do {
    zw6 = 0;

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

        // -------------------- Mémoriser la position lors de la victoire --------------------
        if (vainqueur == 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_rouge == 4) {
        vainqueur = 1;
      } else {
        test_rouge = 0;
      }
      if (test_vert == 4) {
        vainqueur = 2;
      } else {
        test_vert = 0;
      }
      zw4 = zw4 + 4; zw6++;
      if (vainqueur != 0) {
        zw6 = 7;
      }
    }
    while ( zw6 != 7);

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

  // -------------------- Déterminer le couplé gagnant --------------------

  if ( spiel_art == 1) {

    //-------------------- Couleur gagnante Joueur contre Calculateur --------------------

    if (vainqueur == 1) {
      couleur_1 = ROUGE;
      couleur_2 = ROUGE;
      ende (); // Édition Couleur vainqueur ROUGE
    }
    if (vainqueur == 2) {
      couleur_1 = VERT;
      couleur_2 = VERT;
      ende (); // Édition Couleur gagnante verte
    }
    if (zw8 == 56 ) {
      couleur_1 = VERT;
      couleur_2 = ROUGE;
      ende (); // Édition Match nul
    }

    position_1 = 0; position_2 = 0; position_3 = 0; position_4 = 0;
    test_rouge = 0; test_vert = 0;

  } else {

    //-------------------- Couleur gagnante joueur contre joueur --------------------
    if (vainqueur == 1) {
      couleur_1 = ROUGE;
      couleur_2 = ROUGE;
      ende (); // Édition Couleur vainqueur ROUGE
    }
    if (vainqueur == 2) {
      couleur_1 = VERT;
      couleur_2 = VERT;
      ende (); // Édition Couleur gagnante verte
    }
    if (zw8 == 56 ) {
      couleur_1 = VERT;
      couleur_2 = ROUGE;
      ende (); // Édition Match nul
    }

    position_1 = 0; position_2 = 0; position_3 = 0; position_4 = 0;
    test_rouge = 0; test_vert = 0;

  }
}

// -------------------- Édition du Couleur des vainqueurs, préparation du nouveau départ --------------------
void ende () {

  if (spiel_art == 1) {

    // -------------------- Édition Couleur gagnante Joueur contre Calculateur --------------------

    zw11 = 0;

    if (zw8 != 56 ) {
      do {
        strip.setPixelColor((nbColonnes * nbLignes - 1) - position_1, NOIR);
        strip.setPixelColor((nbColonnes * nbLignes - 1) - position_2, NOIR);
        strip.setPixelColor((nbColonnes * nbLignes - 1) - position_3, NOIR);
        strip.setPixelColor((nbColonnes * nbLignes - 1) - position_4, NOIR);
        strip.show(); delay(200);
        strip.setPixelColor((nbColonnes * nbLignes - 1) - position_1, couleur_1);
        strip.setPixelColor((nbColonnes * nbLignes - 1) - position_2, couleur_1);
        strip.setPixelColor((nbColonnes * nbLignes - 1) - position_3, couleur_1);
        strip.setPixelColor((nbColonnes * nbLignes - 1) - position_4, couleur_1);
        strip.show(); delay(200);
        zw11++;
        delay(500);
      }

      while ( zw11 != 3);

    }

    zw9 = 0;
    do {
      strip.setPixelColor((nbColonnes * nbLignes - 1) - zw9, couleur_1); zw9++;
      strip.setPixelColor((nbColonnes * nbLignes - 1) - zw9, couleur_2); zw9++;
    }
    while (zw9 != (nbColonnes * nbLignes));
    strip.show();

    delay(2000);

    zw10 = 0;
    do {
      strip.setPixelColor((nbColonnes * nbLignes - 1) - zw10, 0, 0, 0); spielfeld[zw10] = 0;
      zw10++;
    }
    while ( zw10 != (nbColonnes * nbLignes));
    strip.show();

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

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

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

    }

    // -------------------- Préparation du nouveau départ Joueur contre Calculateur --------------------

    spielfeld[0] = 1; sortie_terrain_de_jeu ();
    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;

    // Changement de couleur de jeu au départ
    couleur_1 = 0; couleur_2 = 0; vainqueur = 0;

    sortie_terrain_de_jeu ();

  } else {

    // -------------------- Édition Couleur gagnante Joueur contre Joueur --------------------

    zw11 = 0;

    if (zw8 != 56 ) {
      do {
        strip.setPixelColor((nbColonnes * nbLignes - 1) - position_1, NOIR);
        strip.setPixelColor((nbColonnes * nbLignes - 1) - position_2, NOIR);
        strip.setPixelColor((nbColonnes * nbLignes - 1) - position_3, NOIR);
        strip.setPixelColor((nbColonnes * nbLignes - 1) - position_4, NOIR);
        strip.show(); delay(200);
        strip.setPixelColor((nbColonnes * nbLignes - 1) - position_1, couleur_1);
        strip.setPixelColor((nbColonnes * nbLignes - 1) - position_2, couleur_1);
        strip.setPixelColor((nbColonnes * nbLignes - 1) - position_3, couleur_1);
        strip.setPixelColor((nbColonnes * nbLignes - 1) - position_4, couleur_1);
        strip.show(); delay(200);
        zw11++;


        delay(500);

      }
      while ( zw11 != 3);
    }

    zw9 = 0;
    do {
      strip.setPixelColor((nbColonnes * nbLignes - 1) - zw9, couleur_1); zw9++;
      strip.setPixelColor((nbColonnes * nbLignes - 1) - zw9, couleur_2); zw9++;
    }
    while (zw9 != (nbColonnes * nbLignes));
    strip.show();
    delay(2000);

    // -------------------- Préparation du nouveau départ Joueur contre Joueur --------------------

    zw10 = 0;
    do {
      strip.setPixelColor((nbColonnes * nbLignes - 1) - zw10, 0, 0, 0); spielfeld[zw10] = 0;
      zw10++;
    }
    while ( zw10 != (nbColonnes * nbLignes));
    strip.show();

    spielfeld[0] = 1;
    sortie_terrain_de_jeu ();
    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;

    // Changement de couleur de jeu au départ
    couleur_1 = 0; couleur_2 = 0; vainqueur = 0;

    if (status_start == 1) {
      couleur = VERT; status_spiel = 2; status_start = 2;
      spielfeld[0] = 2;
    } else {
      couleur = ROUGE;
      spielfeld[0] = 1; status_spiel = 1; status_start = 1;
    }

    sortie_terrain_de_jeu ();
  }
}

// -------------------- Un pas direction la brocheGauche --------------------
void gauche_0() {
  if (position_0 != 0) {        // si on peut aller à gauche
    spielfeld[position_0] = 0;  // on efface la position courante
    position_0--;               // et on va à gauche
    spielfeld[position_0] = status_spiel;
    delay(30);
  }
}

// -------------------- Un pas direction la brocheDroite --------------------
void  droite_0() {
  if (position_0 != nbColonnes - 1) { // si on peut aller à droite
    spielfeld[position_0] = 0;        // on efface la position courante
    position_0++;                     // et on va à droite
    spielfeld[position_0] = status_spiel;
    delay(30);
  }
}

// -------------------- Abaissement du pion --------------------
void bas_0() {
  zw3 = 0;
  do {
    if (spielfeld[position_0 + nbColonnes] == 0 ) { // si la case en dessous est libre
      spielfeld[position_0] = 0;                    // on efface la position en cours
      position_0 += nbColonnes;                     // on passe à la case du dessous
      spielfeld[position_0] = status_spiel;         // et on mémorise que le pion est là
      zw3++;
      sortie_terrain_de_jeu ();
      delay(200);
    }
    else break;
  }  while (zw3 != (nbColonnes - 1)) ;

  direction = 0;
  position_0 = 0;
  if (status_spiel == 1 ) {
    status_spiel = 2;
    spielfeld[position_0] = 2;
  } else {
    status_spiel = 1;
    spielfeld[position_0] = 1;
  }
  sortie_terrain_de_jeu ();
}

// -------------------- Sortie du terrain --------------------
void sortie_terrain_de_jeu () {
  zw1 = 0;
  do {
    switch (spielfeld[zw1]) {
      case 0: strip.setPixelColor(zigzagVersLineaire((nbColonnes * nbLignes - 1) - zw1), NOIR); break;
      case 1: strip.setPixelColor(zigzagVersLineaire((nbColonnes * nbLignes - 1) - zw1), ROUGE); break;
      case 2: strip.setPixelColor(zigzagVersLineaire((nbColonnes * nbLignes - 1) - zw1), VERT); break;
    }
    zw1++;
  } while (zw1 != (nbColonnes * nbLignes));
  strip.show();
}