Quatre victoires sur le panneau de tableau LED U 64

Pendant ce temps, un vif échange d'informations par courrier électronique à nos clients a M. Sexton, qui nous devons le sablier électronique développé. Cela a blessé beaucoup de temps pour la programmation de son microcontrôleur et cette fois il « gagne quatre » Je joue le jeu pour deux joueurs sur le U 64 panneau matrice LED CJMCU 8 * 8 Moduleenvoyé avec RGBLEDs. Pour l'ensemble expérimental, j'avais toutes les parties à la maison. Alors, essayez.

Matériel utilisé

Pour l'ensemble fini illustré, vous aurez encore besoin :

Voici le schéma de câblage :

Comme souvent, les programmeurs de la société new-yorkaise Adafruit ont pris la peine de nous soulager, nous utilisateurs, de la partie la plus difficile de la programmation liée au matériel et ont développé une bibliothèque pour l'affichage LED et l'ont rendue disponible sur github ou via le gestionnaire de bibliothèque. C'est pourquoi il est inclus au début de l'esquisse avec
#include <Adafruit_NeoPixel.h>. Si ce n'est pas déjà fait, veuillez entrer NeoPixel dans la fenêtre de recherche du gestionnaire de bibliothèque (déjà installé pour moi).

Comme c'est souvent le cas, NeoPixel est une bibliothèque pour un grand nombre d'écrans RGBLED qui ont un point commun malgré leurs conceptions très différentes : Outre l'alimentation, il existe une seule ligne de données qui contrôle les RGBLED en série. Avec les lignes

 int numéro = 64;
 Adafruit_NeoPixel déshabiller(numéro, 6, NEO_GRB + NEO_KHZ800);

Nous instancions donc notre module 8x8 avec les lignes.

Huit colonnes et sept rangées sont disponibles pour le terrain de jeu, car la rangée supérieure est toujours nécessaire pour positionner la "pièce de jeu" suivante. Red commence. La LED supérieure gauche s'allume en rouge et peut être déplacée en conséquence avec les deux boutons pour la gauche (sur GPIO9) et la droite (sur GPIO10). Le déplacement est terminé avec le bouton du milieu (à GPIO8). Le point lumineux se déplace vers le bas jusqu'à ce que des champs libres deviennent disponibles. 

Après la routine de vérification pour savoir si un joueur a déjà atteint quatre cases de la même couleur horizontalement, verticalement ou en diagonale, une LED verte apparaît en haut à gauche et le deuxième joueur effectue son déplacement de la même manière. Ensuite, nous voyons une autre LED rouge en haut à gauche et ainsi de suite.

Si la routine de test aboutit à un résultat positif, les quatre LED RVB clignotent d'abord en série, puis l'ensemble de l'écran clignote dans les couleurs du gagnant. Le micro-contrôleur est alors prêt pour le prochain tour. Pour mettre fin prématurément à la partie, appuyez simultanément sur les deux touches de direction.

Voici l'esquisse dans son intégralité et en téléchargement :

 #include 
 int numéro = 64;
 Adafruit_NeoPixel déshabiller(numéro, 6, NEO_GRB + NEO_KHZ800);
 ​
 longue rouge = déshabiller.Couleur(5, 0, 0); longue vert = déshabiller.Couleur(0, 5, 0); longue Couleur = 0;
 octet zw1 = 0; int ZW2 = 0; // utilisé dans « champ de sortie »
 octet ZW3 = 0; // utilisé pour abaisser les pièces de jeu
 octet ZW4 = 0; // commencer les tests sur le terrain
 octet zw5 = 0; // champs de test de boucle interne Zaelwert 4
 octet ZW6 = 0; // Zaelwert boucle du milieu, tester une colonne
 octet ZW7 = 0; // Zaelwert boucle extérieure qui teste toutes les colonnes
 octet zw8 = 0; // pierres Déchus
 octet zw9 = 0; // gagnant de sortie couleur
 octet zw10 = 0; // affichage Supprimer et sur le terrain
 octet ZW11 = 0; // clignotant pierres vainqueur
 longue farbe_1 = 0; longue farbe_2 = 0; // Vainqueur Couleur
 octet position 1 = 0; octet position_2 = 0; octet position_3 = 0; octet position_4 = 0; // Position pierres vainqueur
 ​
 // 0 -> Non utilisé; 1 -> rouge; 2 -> vert
 octet champcorrespondant [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
 };
 ​
 octet droite = 10; octet La gauche = 9; octet vers le bas = 8; // nombre de ports de quantité nécessaire
 ​
 octet direction = 0 ; // 1 -> droite; 2 -> gauche; 3 -> vers le bas
 octet status_start = 1; // 1 -> rouge; 2 -> vert
 octet status_spiel = 1 ; // 1 -> rouge; 2 -> vert
 octet position_0 = 0; // pointeur pour le champ
 octet test_rot = 0; octet test_gruen = 0; octet gagnant = 0; // Nécessite pour déterminer le gagnant
 ​
 annuler installer() {
 ​
   En série.commencer(9600);
 ​
   déshabiller.commencer();
   déshabiller.spectacle(); // Initialiser tous les pixels à « off »
 ​
   pinMode(droite, SAISIR); digitalWrite (droite, HAUTE);
   pinMode(La gauche, SAISIR); digitalWrite (La gauche, HAUTE);
   pinMode(vers le bas, SAISIR); digitalWrite (vers le bas, HAUTE);
 ​
   ausgabe_spielfeld ();
 }
 ​
 annuler boucle() {
 ​
   // clavier de requête et saut dans le programme correspondant
   faire {
     
     si (lecture numérique(droite) == FAIBLE && lecture numérique(La gauche) == FAIBLE) {
       zw8 = 56;
       test_spielende ();
     };
     si ( lecture numérique(droite) == FAIBLE) {
       direction = 1; rechts_0 ();
     }
     si ( lecture numérique(La gauche) == FAIBLE) {
       direction = 2; links_0 ();
     }
     si ( lecture numérique(vers le bas) == FAIBLE) {
       si (champcorrespondant [position_0 + 8] == 0) {
         direction = 3;
         runter_0 (); zw8 ++; // Nombre Durchlaeufe + 1
         test_spielende ();
       };
     }
   }
   tandis que ( direction == 0);
   direction = 0; // direction Loesch Ender
 ​
 ​
   ausgabe_spielfeld ();
   retard(300);
 }
 ​
 // ------------- tester s'il y a un gagnant ------------------
 // ---------- programme est appelé après l'abaissement d'une pierre
 annuler test_spielende () {
 ​
   // ----------- ------------ test ci-dessus en diagonale
   // ---------- ---------- 3 verschaltelte cycles
 ​
   ZW4 = 32; // commencer les tests sur le terrain
   gagnant = 0; ZW7 = 0;
 ​
   faire {
     ZW6 = 0;
 ​
     faire {
       zw5 = 0; // Zaelschleife
       test_rot = 0; test_gruen = 0;
 ​
       // Test de 4 cellules diegonal ci-dessus
       faire {
         si ( champcorrespondant [ZW4] == 1) {
           test_rot ++;
         };
         si ( champcorrespondant [ZW4] == 2) {
           test_gruen ++;
         };
 ​
         // Notez la position de la victoire
         si (gagnant == 0) {
           si (zw5 == 0) {
             position 1 = ZW4;
           };
           si (zw5 == 1) {
             position_2 = ZW4;
           };
           si (zw5 == 2) {
             position_3 = ZW4;
           };
           si (zw5 == 3) {
             position_4 = ZW4;
           };
         };
 ​
         ZW4 = ZW4 - 7; zw5++;
       }
       tandis que (zw5 != 4);
 ​
       si (test_rot == 4) {
         gagnant = 1;
       } autre {
         test_rot = 0;
       };
       si (test_gruen == 4) {
         gagnant = 2;
       } autre {
         test_gruen = 0;
       };
       ZW4 = ZW4 + 36; ZW6++;
       si (gagnant != 0) {
         ZW6 = 4;
       };
     }
     tandis que ( ZW6 != 4);
 ​
     ZW4 = ZW4 - 31; ZW7++;
     si (gagnant != 0) {
       ZW7 = 5;
     };
   }
   tandis que (ZW7 != 5);
 ​
   // ----------- ----------- test diagonale vers le bas
   // ---------- ---------- 3 cycles imbriqués
 ​
   ZW4 = 8; // commencer les tests sur le terrain
   ZW7 = 0;
 ​
   faire {
     ZW6 = 0;
 ​
     faire {
       zw5 = 0; // boucle de comptage
       test_rot = 0; test_gruen = 0;
 ​
       // cellules de test 4 en diagonale vers le bas
       faire {
         si ( champcorrespondant [ZW4] == 1) {
           test_rot ++;
         };
         si ( champcorrespondant [ZW4] == 2) {
           test_gruen ++;
         };
 ​
         // Notez la position de la victoire
         si (gagnant == 0) {
           si (zw5 == 0) {
             position 1 = ZW4;
           };
           si (zw5 == 1) {
             position_2 = ZW4;
           };
           si (zw5 == 2) {
             position_3 = ZW4;
           };
           si (zw5 == 3) {
             position_4 = ZW4;
           };
         };
 ​
         ZW4 = ZW4 + 9; zw5++;
       }
       tandis que (zw5 != 4);
 ​
       si (test_rot == 4) {
         gagnant = 1;
       } autre {
         test_rot = 0;
       };
       si (test_gruen == 4) {
         gagnant = 2;
       } autre {
         test_gruen = 0;
       };
       ZW4 = ZW4 - 28; ZW6++;
       si (gagnant != 0) {
         ZW6 = 4;
       };
     }
     tandis que ( ZW6 != 4);
 ​
     ZW4 = ZW4 - 31; ZW7++;
     si (gagnant != 0) {
       ZW7 = 5;
     };
   }
   tandis que (ZW7 != 5);
 ​
   // ------------ perpendiculaire test ---------------
   // ---------- ---------- 3 verschaltelte cycles
 ​
   ZW4 = 8; // commencer les tests sur le terrain
   ZW7 = 0;
   faire {
     ZW6 = 0;
 ​
     faire {
       zw5 = 0; // zaelschleife
       test_rot = 0; test_gruen = 0;
 ​
       // tester 4 cellules perpendiculaires
       faire {
         si ( champcorrespondant [ZW4] == 1) {
           test_rot ++;
         };
         si ( champcorrespondant [ZW4] == 2) {
           test_gruen ++;
         };
 ​
         // Notez la position de la victoire
         si (gagnant == 0) {
           si (zw5 == 0) {
             position 1 = ZW4;
           };
           si (zw5 == 1) {
             position_2 = ZW4;
           };
           si (zw5 == 2) {
             position_3 = ZW4;
           };
           si (zw5 == 3) {
             position_4 = ZW4;
           };
         };
 ​
         ZW4 = ZW4 + 8; zw5++;
       }
       tandis que (zw5 != 4);
 ​
       si (test_rot == 4) {
         gagnant = 1;
       } autre {
         test_rot = 0;
       };
       si (test_gruen == 4) {
         gagnant = 2;
       } autre {
         test_gruen = 0;
       };
       ZW4 = ZW4 - 24; ZW6++;
       si (gagnant != 0) {
         ZW6 = 4;
       };
     }
     tandis que ( ZW6 != 4);
 ​
     ZW4 = ZW4 - 31; ZW7++;
     si (gagnant != 0) {
       ZW7 = 8;
     };
   }
   tandis que (ZW7 != 8);
 ​
   // ------------- -------------- Niveau d'essai
   // ---------- ---------- 3 cycles imbriqués
   ZW4 = 8; // commencer les tests sur le terrain
   ZW7 = 0;
   faire {
     ZW6 = 0;
 ​
     faire {
       zw5 = 0;
       test_rot = 0; test_gruen = 0;
 ​
       // test 4 cellules horizontalement
       faire {
         si ( champcorrespondant [zw4] == 1) {
           test_rot ++;
         };
         si ( champcorrespondant [zw4] == 2) {
           test_gruen ++;
         };
 ​
         // Notez la position de la victoire
         si (gagnant == 0) {
           si (ZW5 == 0) {
             position 1 = zw4;
           };
           si (ZW5 == 1) {
             Position_2 = zw4;
           };
           si (ZW5 == 2) {
             Position_3 = zw4;
           };
           si (ZW5 == 3) {
             Position_4 = zw4;
           };
         };
 ​
         zw4++; ZW5++;
       }
       tandis que (ZW5 != 4);
 ​
       si (test_rot == 4) {
         gagnant = 1;
       } autre {
         test_rot = 0;
       };
       si (test_gruen == 4) {
         gagnant = 2;
       } autre {
         test_gruen = 0;
       };
       zw4 = zw4 + 4; zw6++;
       si (gagnant != 0) {
         zw6 = 7;
       };
     }
     tandis que ( zw6 != 7);
 ​
     zw4 = zw4 - 55; zw7++;
     si (gagnant != 0) {
       zw7 = 5;
     };
   }
   tandis que (zw7 != 5);
 ​
   // Couleurs gagnant
   si (gagnant == 1) {
     COLOR_1 = rouge;
     COLOR_2 = rouge;
     La fin (); // gagnant de sortie rouge
   };
   si (gagnant == 2) {
     COLOR_1 = vert;
     COLOR_2 = vert;
     La fin (); // gagnant de sortie Couleur Vert
   };
   si (zw8 == 56 ) {
     COLOR_1 = vert;
     COLOR_2 = rouge;
     La fin (); // affiche dessiner
   };
 ​
   position 1 = 0; Position_2 = 0; Position_3 = 0; Position_4 = 0;
   test_rot = 0; test_gruen = 0;
 }
 ​
 // ---------- ---------- couleur gagnants édition
 ​
 annuler La fin () {
   SW11 = 0;
 ​
   si (zw8 != 56 ) {
     faire {
       déshabiller.setPixelColor ( position 1, 0, 0, 0);
       déshabiller.setPixelColor ( Position_2, 0, 0, 0);
       déshabiller.setPixelColor ( Position_3, 0, 0, 0);
       déshabiller.setPixelColor ( Position_4, 0, 0, 0);
       déshabiller.spectacle(); retard(200);
       déshabiller.setPixelColor ( position 1, COLOR_1);
       déshabiller.setPixelColor ( Position_2, COLOR_1);
       déshabiller.setPixelColor ( Position_3, COLOR_1);
       déshabiller.setPixelColor ( Position_4, COLOR_1);
       déshabiller.spectacle(); retard(200);
       SW11++;
     }
     tandis que ( SW11 != 5);
   }
 ​
   zwart = 0;
   faire {
     déshabiller.setPixelColor ( zwart, COLOR_1); zwart++;
     déshabiller.setPixelColor ( zwart, COLOR_2); zwart++;
   }
   tandis que (zwart != 64);
   déshabiller.spectacle();
 ​
   retard(2000);
 ​
   // ---------- ----------- préparation nouveau départ
 ​
   ZW10 = 0;
   faire {
     déshabiller.setPixelColor ( ZW10, 0, 0, 0); champcorrespondant [ZW10] = 0;
     ZW10++;
   }
   tandis que ( ZW10 != 64);
   déshabiller.spectacle();
 ​
   champcorrespondant [0] = 1; ausgabe_spielfeld ();
   zw1 = 0; ZW2 = 0; ZW3 = 0; zw4 = 0; ZW5 = 0; zw6 = 0; zw7 = 0; zw8 = 0; zwart = 0; ZW10 = 0;
   position 1 = 0; Position_2 = 0; Position_3 = 0; Position_4 = 0;
   position_0 = 0;
 ​
   // changement Démarrer couleur jeu
   COLOR_1 = 0; COLOR_2 = 0; gagnant = 0;  
 ​
   si (status_start == 1) {
     Couleur = vert; status_spiel = 2;status_start=2;
     champcorrespondant [0] = 2;
   } autre {
     Couleur = rouge;
     champcorrespondant [0] = 1; status_spiel = 1;status_start=1;
   };
   
   ausgabe_spielfeld ();
 }
 ​
 // ---------- ---------- Un pas à gauche
 annuler links_0 () {
   si (position_0 != 0) {
     champcorrespondant [position_0] = 0;
     position_0--;
     champcorrespondant [ position_0 ] = status_spiel;
   };
 }
 ​
 // ---------- ---------- Une étape vers la droite
 annuler rechts_0 () {
   si (position_0 != 7) {
     champcorrespondant [position_0] = 0;
     position_0++;
     champcorrespondant [ position_0 ] = status_spiel;
   };
 }
 ​
 // ---------- ---------- abaisser la pièce de jeu
 annuler runter_0 () {
   ZW3 = 0;
   faire {
     si (champcorrespondant [position_0 + 8] == 0 ) {
       champcorrespondant [position_0] = 0; position_0 = position_0 + 8; champcorrespondant [position_0] = status_spiel;
       ZW3++;
       ausgabe_spielfeld (); retard(200);
     }
     autre {
       ZW3 = 7;
     }
   }
   tandis que (ZW3 != 7) ;
   direction = 0; position_0 = 0;
   si (status_spiel == 1 ) {
     status_spiel = 2;
     champcorrespondant [position_0] = 2;
   } autre {
     status_spiel = 1;
     champcorrespondant [position_0] = 1;
   };
   ausgabe_spielfeld ();
 }
 ​
 // ---------- ---------- champ de sortie
 annuler ausgabe_spielfeld () {
   zw1 = 0;
 ​
   faire {
     ZW2 = champcorrespondant [zw1];
     si (ZW2 == 0) {
       déshabiller.setPixelColor ( zw1, 0, 0, 0);
     };
     si (ZW2 == 1) {
       déshabiller.setPixelColor ( zw1, rouge);
     };
     si (ZW2 == 2) {
       déshabiller.setPixelColor ( zw1, vert);
     };
     zw1++;
   }
   tandis que (zw1 != 64);
   déshabiller.spectacle();
 }
 ​
 // HUK Vier_gewinnt_4.4 27/07/2021

Vous pouvez également jouer à Four Wins sur la tablette murale AZ-Touch. Jörn Weise avait présenté cette option dans son blog le 3 juillet 2021.

Les deux versions présentées sont conçues pour deux joueurs et, outre le joli affichage, offrent la routine de vérification si un joueur a déjà gagné. Pour ceux qui veulent jouer contre un ordinateur avec un jeu fort, la version d'Al Sweigart sur le Raspberry Pi est recommandée. A ma grande honte, je dois admettre que je perds de temps en temps. Vous préférez donc jouer contre ma petite-fille avec le sketch de M. Küster sur le module U 64 LED Matrix Panel CJMCU-8 * 8 ?

Amusez-vous bien à reconstruire et à jouer.