Bonjour, j'ai un devoir à rendre pour la rentrée, je dois réaliser un Puissance4 avec Processing.
Mon problème est de trouver lorsque 4 point d'une couleur sont alignés, je sais qu'on peut utiliser un tableau avec int[][] mais je ne comprends pas comment l'utiliser.
Est-ce que quelqu'un peut m'aider ?
 
Mon code :
 
int x=-50, y=-50, c, n=0, ligne1=0, ligne2=0, ligne3=0, ligne4=0, ligne5=0, ligne6=0, ligne7=0;
PImage Grille;
 
 
 
void setup()
{
  size(1200,900);
  background(#FFFFFF);
  Grille = loadImage("Grille.png" );
  image(Grille,250,200,700,650);
}
 
 
 
void mousePressed()
{
  n=n+1;
  ligne();
}
 
 
 
void draw()
{
  if(n%2==0)
  {
    if(mousePressed)
    {
      ellipse(x,y,85,88);
      fill(#F00000);
      locMouseX();
      c();
    }
  }
  else
  {
    if(mousePressed)
    {
      ellipse(x,y,85,88);
      fill(#FFF033);
      locMouseX();
      c();
    }
  }
}
 
 
//----------------------------------------------------------------------------------
 
 
void locMouseX()  // trouve la colonne de la souris  
{
  if (mouseX >= 250 && mouseX < 350)
  {
    c=1;
  }
  if (mouseX >= 350 && mouseX < 450)
  {
    c=2;
  }
  if (mouseX >= 450 && mouseX < 550)
  {
    c=3;
  }
  if (mouseX >= 550 && mouseX < 650)
  {
    c=4;
  }
  if (mouseX >= 650 && mouseX < 750)
  {
    c=5;
  }
  if (mouseX >= 750 && mouseX < 850)
  {
    c=6;
  }
  if (mouseX >= 850 && mouseX < 950)
  {
    c=7;
  }
}
 
 
//-------------------------------------------------------------------------------
 
 
void c()
{
  if (c==1)
  {
    x=301;
    y=792-ligne1;
  }
  if (c==2)
  {
    x=401;
    y=792-ligne2;
  }
  if (c==3)
  {
    x=501;
    y=792-ligne3;
  }
  if (c==4)
  {
    x=600;
    y=792-ligne4;
  }
  if (c==5)
  {
    x=699;
    y=792-ligne5;
  }
  if (c==6)
  {
    x=798;
    y=792-ligne6;
  }
  if (c==7)
  {
    x=897;
    y=792-ligne7;
  }
}
 
 
//-------------------------------------------------------------------------
 
 
void ligne()
{
  if (c==1)
  {
    if(ligne1<535)
    {
      ligne1=ligne1+107;
    }
    else
    {
      n=n+1;
    }
  }
  if (c==2)
  {
    if(ligne2<535)
    {
      ligne2=ligne2+107;
    }
    else
    {
      n=n+1;
    }
  }
  if (c==3)
  {
    if(ligne3<535)
    {
      ligne3=ligne3+107;
    }
    else
    {
      n=n+1;
    }
  }
  if (c==4)
  {
    if(ligne4<535)
    {
      ligne4=ligne4+107;
    }
    else
    {
      n=n+1;
    }
  }
  if (c==5)
  {
    if(ligne5<535)
    {
      ligne5=ligne5+107;
    }
    else
    {
      n=n+1;
    }
  }
  if (c==6)
  {
    if(ligne6<535)
    {
      ligne6=ligne6+107;
    }
    else
    {
      n=n+1;
    }
  }
  if (c==7)
  {
    if(ligne7<535)
    {
      ligne7=ligne7+107;
    }
    else
    {
      n=n+1;
    }
  }
}

C'est assez simple, tu représentes ton terrain de jeu comme un tableau de 6*7 cases, et tu définis un code, par exemple : 0 = case vide, 1 = jeton rouge, 2 = jeton jaune.
 
Tu te retrouves en mémoire avec un truc de ce genre :  
 
0000000
0000000
0000000
0001000
0012000
0121200
 
Il faut que tu fasses un algo qui recherche une suite de 4 1 ou 4 2. Pour ce faire, l'approche bête, c'est de faire le tour de ton tableau, et dès que tu croises un 1 ou un 2, tu regardes ce qu'il y a autour et t'en déduis s'il fait partie d'une série.

Je viens de me renseigner sur Processing, visiblement t'es pas un informaticien donc je vais développer un peu l'algo de recherche :

• Parcours le tableau dans un sens défini, par exemple de gauche à droite et de bas en haut (une partie de P4 commence toujours par le bas)
• Il existe 3 façons de gagner au P4 : ligne horizontale, verticale, ou diagonale. Tu peux limiter le problème en considérant que ces coups n'existent que dans une direction : une ligne horizontale tout en bas à gauche peut être vu comme un coup de la case tout en bas à gauche vers la droite, ou un coup de la case du milieu tout en bas vers la gauche, ça n'a aucune importance, c'est le même coup.
• Par conséquent, ne vérifie les coups que dans une seule direction, admettons vers la droite et vers le haut.
• De même, il n'est pas nécessaire de faire le tour de tout le tableau pour tous les coups : quand tu vérifies les coups horizontaux, les colonnes 5 6 et 7 ne peuvent être gagnantes. Lors des coups verticaux, les lignes 4 5 6 ne peuvent pas gagner non plus. Pour les diagonales, c'est la fusion des deux.

Résumé : regarde ton tableau comme ça

  1 2 3 4 5 6 7
6 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0

  1 2 3 4 5 6 7
6 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0

  1 2 3 4 5 6 7
6 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0

  1 2 3 4 5 6 7
6 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0

En vert, les cases que tu dois vérifier pour les coups verticaux, en rouge les coups horizontaux et en jaune les coups en diago. Pour chaque case, tu examines la couleur du pion (s'il y en a un), et tu regardes la couleur des pions posés sur les cases adjacentes en fonction du scénario. Si les 4 cases examinées sont de la même couleur, bingo, c'est gagné.

Edit : Il manquait les diagonales vers la gauche (en bleu)

Sans vraiment réfléchir au problème, je ferai autrement, à chaque coup joué, je vérifierai si des jetons identiques se trouvent autour en faisant des boucles tant que vers le bas jusqu'à temps d'avoir 3 autres jetons identiques ou un jeton différent. Dans le premier cas on arrête la partie, sinon on vérifie horizontalement, combien à droite ? Combien à gauche ? (boucles imbriquées pour maximiser à 3 itérations au total)
Puis de même dans les diagonales.

 
Approche globale vs contextuelle.  
 
C'est une autre solution, plus efficace mais certainement un poil plus complexe à mettre en place pour un novice total, où il devra notamment faire attention à ne pas sortir du tableau.  

Salut
 
Je ne sais pas quelle est la meilleure façon de procéder (débutant inside)
 
J'avais codé un programme pour résoudre un Boggle sur codingame, et je faisais le tour des lettres environnantes pour trouver un mot.   Pour ne pas dépasser de la grille et me retrouver avec des out of bound j'avais entouré la grille (de 4 x 4 pour un boggle) avec des tirets (-) (donc ensuite 6 x 6)
 

public static String[] makeGrid (String[] grid) {
 
        String[] newGrid = new String[6];
        newGrid[0] = newGrid[5] = "------";
        for (int i = 1 ; i < 5 ; i++) {
            newGrid[i] = "-" + grid[i-1] + "-";
        }
        return newGrid;
    }

 
Ensuite javais 4 methodes presque identiques pour passer le truc "à la moulinette"  (fallait que je gère les lettres blacklistées lorsque déja utilisées).  Je mets le code, ça peut peut être donner des idées (si c'est nul dites le je le vire )
 

public static void moulinette1 (String[] gridd, Mot momo) {   // trouver 1ere lettre
       
        if (momo.posY < 5) {
            System.err.println("mot "+momo.mot);
            
            int[] pos = {momo.posX, momo.posY};  // pour la blackliste
            boolean boolBlack = isBlackListed(pos, momo.bl);  // fouille la blackliste
            
            
            if ((gridd[momo.posY].charAt(momo.posX) == momo.mot.charAt(momo.posDsMot)) && boolBlack == false)  {
                
                momo.posXdepart = momo.posX;  // pour savoir d'ou repartir en cas d'abandon
                momo.posYdepart = momo.posY;
                momo.bl.add(pos);  // j'ajoute la pos dans la blackliste
                momo.motReconst += momo.mot.charAt(momo.posDsMot);
                momo.posDsMot++;
                System.err.println("motReconst moul1 "+momo.motReconst);  // sortie debug
 
                if (momo.mot.equals(momo.motReconst)) {
                    momo.exist = true;
                }
                else {
                    moulinette3 (gridd, momo);}
            }
            
            else { 
       
                if (momo.posX < 4) {
                    momo.posX++;
                }
                else if (momo.posX == 4) { 
                    momo.posY++; momo.posX = 1;
                }
                
                moulinette2 (gridd, momo);
            }
        }
    }

Et fallait trouver "repus" ou "super" ?