Bonjour, j'ai un devoir de réaliser un projet informatique qui se porte sur le langage de programmation Java.
J'ai choisis de réaliser un jeu qui se nomme le Jeu de la Vie.

Voici les règles du jeu tirées de Wikipédia :

Citation

Le jeu se déroule sur une grille à deux dimensions, théoriquement infinie (mais de longueur et de largeur finies et plus ou moins grandes dans la pratique), dont les cases — qu’on appelle des « cellules », par analogie avec les cellules vivantes — peuvent prendre deux états distincts : « vivantes » ou « mortes ».

À chaque étape, l’évolution d’une cellule est entièrement déterminée par l’état de ses huit voisines de la façon suivante :

Une cellule morte possédant exactement trois voisines vivantes devient vivante (elle naît).
Une cellule vivante possédant deux ou trois voisines vivantes le reste, sinon elle meurt.

J'ai commencé avant hier, mais je tourne un peu en rond sans trouver l'erreur qui me turlupine depuis un moment, je commence avec la création d'une méthode qui consiste à colorier en bleu ou en blanc les cases de la grille (les valeurs de la grille sont soit 0 (blanc) ou 1 (bleu) :

private void remplissage() {

        // La case
        int laCase = 0;

        // Parcours la grille
        for (int ligneRemplissage = 0; ligneRemplissage < tableau.length; ligneRemplissage++) {
            for (int colonneRemplissage = 0; colonneRemplissage < tableau.length; colonneRemplissage++) {

                // Colorie en bleu les cases qui valent 1
                if (tableau[ligneRemplissage][colonneRemplissage] == 1) {
                    affichage.fillCercle(laCase, Color.blue);
                    // Colorie en blanc les cases qui valent 0
                } else {
                    affichage.fillRect(laCase, Color.white);
                }
                // Incrémente la case
                laCase++;
            }
        }
    }

Je continue ensuite en donnant une valeur entre 0 et 1 à mon tableau à deux dimensions (toute la grille) avec une méthode (nbAleatoire) qui génère un nombre aléatoire entre 0 et 1 :

// Tableau de base (qui ne se modifie plus!)
        for (int ligneDefinitiv = 0; ligneDefinitiv < tableau.length; ligneDefinitiv++) {
            for (int colonneDefinitiv = 0; colonneDefinitiv < tableau.length; colonneDefinitiv++) {
                tableau[ligneDefinitiv][colonneDefinitiv] = nbAleatoire();
            }
        }

        remplissage();
        affichage.repaint();

Et finalement je termine avec une implémentation des règles du jeu qui vérifie pour CHAQUE CASE, ses huit voisins et avec un boolean je vérifie si la boucle passe dans les règles, car sinon la valeur par défaut est 0, ce qui peut colorier une forme qui était déjà en couleur, et à la fin de chaque tour je remet la variable compteur à 0.
J'espère que mes commentaires sont assez explicites :

// Parcours la grille
        for (int ligneControl = 0; ligneControl < tableau.length; ligneControl++) {
            for (int colonneControl = 0; colonneControl < tableau.length; colonneControl++) {

                // Vérif. que la boucle passe dans les règles
                controle = false;

                // Point nominal
                if (ligneControl != 0 && colonneControl != 0 && ligneControl != 14 && colonneControl != 14) {

                    // SI C'EST UNE CASE REMPLIE QUI VAUT 1
                    if (tableau[ligneControl][colonneControl] == 1) {

                        // Case à gauche
                        if (tableau[ligneControl][colonneControl - 1] == 1) {
                            compteur++;
                        } // Case à droite
                        else if (tableau[ligneControl][colonneControl + 1] == 1) {
                            compteur++;
                        } // Case en haut
                        else if (tableau[ligneControl - 1][colonneControl] == 1) {
                            compteur++;
                            // Case en bas
                        } else if (tableau[ligneControl + 1][colonneControl] == 1) {
                            compteur++;
                            // Case en bas à droite
                        } else if (tableau[ligneControl + 1][colonneControl + 1] == 1) {
                            compteur++;
                            // Case en bas à gauche
                        } else if (tableau[ligneControl + 1][colonneControl - 1] == 1) {
                            compteur++;
                            // Case en haut à droite
                        } else if (tableau[ligneControl - 1][colonneControl + 1] == 1) {
                            compteur++;
                            // Case en haut à gauche
                        } else if (tableau[ligneControl + 1][colonneControl - 1] == 1) {
                            compteur++;
                        }
                    }

                    // SI C'EST UNE CASE VIDE QUI VAUT 0
                    if (tableau[ligneControl][colonneControl] == 0) {
                        // Case à gauche
                        if (tableau[ligneControl][colonneControl - 1] == 1) {
                            compteur++;
                        } // Case à droite
                        else if (tableau[ligneControl][colonneControl + 1] == 1) {
                            compteur++;
                        } // Case en haut
                        else if (tableau[ligneControl - 1][colonneControl] == 1) {
                            compteur++;
                            // Case en bas
                        } else if (tableau[ligneControl + 1][colonneControl] == 1) {
                            compteur++;
                            // Case en bas à droite
                        } else if (tableau[ligneControl + 1][colonneControl + 1] == 1) {
                            compteur++;
                            // Case en bas à gauche
                        } else if (tableau[ligneControl + 1][colonneControl - 1] == 1) {
                            compteur++;
                            // Case en haut à droite
                        } else if (tableau[ligneControl - 1][colonneControl + 1] == 1) {
                            compteur++;
                            // Case en haut à gauche
                        } else if (tableau[ligneControl + 1][colonneControl - 1] == 1) {
                            compteur++;
                        }
                    }
                    
                    // Vérif. que la boucle passe dans les règles
                    controle = true;
                    
                }

                // Si plus de trois voisins ou moins que deux voisins, et ayant passé dans les règles
                if (compteur > 3 || compteur < 2 && controle) {
                    tableau[ligneControl][colonneControl] = 0;
                }

                // Si exactement trois voisines vivantes
                if (compteur == 3 && controle) {
                    tableau[ligneControl][colonneControl] = 1;
                }

                // Remplissage des cases avec la méthode
                remplissage();
                affichage.repaint();

                // Remet le compteur à 0
                compteur = 0;

            }
        }
    }
}

Pour l'instant ça me donne ça comme résultat :

http://www.noelshack.com/2012-20-1337333592-LifeGame.png

Les contours sont coloriés en bleu, et au milieu tout est colorié en blanc.
Cela fait un moment que j'essaie de trouver une solution sans succès.

Merci d'avance de votre aide.

Si je comprend bien ton problème, c'est que lors de la génération de grille, il y a uniquement les cases sur les bords qui sont coloriés ?

Sinon je crois avoir détecté un truc qui cloche lors de ton parcours de grille. Lorsque tu fais

if (ligneControl != 0 && colonneControl != 0 && ligneControl != 14 && colonneControl != 14)

tu recherche uniquement les cases A L'INTERIEUR de ta grille. Je m'explique:
- en faisant ligneControl != 0 tu l'empêche de vérifié les cases sur le bord gauche
- en faisant colonneControl != 0 tu l'empêche de vérifié les cases sur le bord haut
- en faisant colonneControl != 14 tu l'empêche de vérifié les cases sur le bord droit
- en faisant ligneControl != 14 tu l'empêche de vérifié les cases sur le bord bas

il faut que tu fasse un cas de test pour chacune des positions possible

if (ligneControl==0){
  if (colonneControle ==0){
     //fais tes tests sur les cases aux alentours
  }
  else if (colonneControle ==14){
     //fais tes tests sur les cases aux alentours
  } 
  else
     //fais tes tests sur les cases aux alentours
}
if (ligneControle==14){
  if(colonneControle==0)
     //fais tes tests sur les cases aux alentours
  else if (colonneControle==14)
     //fais tes tests sur les cases aux alentours
  else
     //fais tes tests sur les cases aux alentours
}
//...

t'as 9 test a faire

Oui j'ai fais exprès de pas vérifier le bord haut, bas, gauche, et droite, car sinon ça m'affiche une erreur.
Car par exemple si je prend la première case de la grille, les conditions if ne peuvent pas contrôler si la case à gauche par exemple est colorié, car il n'y en a tout simplement pas.

Mais si j'enlève cette condition, des rond bleu s'affichent un peu partout dans la grille :

http://www.noelshack.com/2012-20-1337335131-Capture1.png

Tout en affichant une erreur :

http://www.noelshack.com/2012-20-1337335133-Capture2.png


Edit : Merci je vais essayer.

En fait, quand tu fais tes tests, il faut juste rajouter des conditions pour vérifier que tes indices ne sortent pas de ta grille.

Ex :

if ((x - 1 >= 0) && tableau[x - 1][y] == 0)

ou

if ((y + 1 < tableau.hauteur) && tableau[x][y + 1] == 1)

exactement, dans chacun des cas, les test sont différents. Quand par exemple tu te situe en haut a gauche, tu check les cases de droite, bas et bas-droit (3 if). J'ai fait le jeu de la vie dans mon IUT, si tu veux, je pourrais t'envoyer tout mon code( si je le retrouve... )

EDIT: voici mon code (c'était du c++ et je débutais en programmation: à adapter en somme)

int cpt=0;
    for (int i=0;i<_nbCol;i++) {
        for (int j=0;j<_nbLig;j++) {
            cpt=0;
            if (i==0) {
                if (j==0) {		
                    if (_matrice[i][j+1].getLife())
                        cpt++;
                    if (_matrice[i+1][j+1].getLife())
                        cpt++;
                    if (_matrice[i+1][j].getLife())
                        cpt++;
                }
                else if (j==_nbCol-1) {	
                    if (_matrice[i][j-1].getLife())
                        cpt++;
                    if (_matrice[i+1][j-1].getLife())
                        cpt++;
                    if (_matrice[i+1][j].getLife())
                        cpt++;
                }
                else { 
                    if (_matrice[i][j+1].getLife())
                        cpt++;
                    if (_matrice[i+1][j+1].getLife())
                        cpt++;
                    if (_matrice[i+1][j].getLife())
                        cpt++;
                    if (_matrice[i][j-1].getLife())
                        cpt++;
                    if (_matrice[i+1][j-1].getLife())
                        cpt++;
                }
            }

            else if (i==_nbCol-1) {
                if (j==0) {	
                    if (_matrice[i][j+1].getLife())
                        cpt++;
                    if (_matrice[i-1][j+1].getLife())
                        cpt++;
                    if (_matrice[i-1][j].getLife())
                        cpt++;
                }
                else if (j==_nbLig-1) { 
                    if (_matrice[i][j-1].getLife())
                        cpt++;
                    if (_matrice[i-1][j-1].getLife())
                        cpt++;
                    if (_matrice[i-1][j].getLife())
                        cpt++;
                }
                else { 
                    if (_matrice[i][j+1].getLife())
                        cpt++;
                    if (_matrice[i-1][j+1].getLife())
                        cpt++;
                    if (_matrice[i-1][j].getLife())
                        cpt++;
                    if (_matrice[i][j-1].getLife())
                        cpt++;
                    if (_matrice[i-1][j-1].getLife())
                        cpt++;
                }
            }


            else if (j==0) {
                if (_matrice[i-1][j].getLife())
                    cpt++;
                if (_matrice[i-1][j+1].getLife())
                    cpt++;
                if (_matrice[i][j+1].getLife())
                    cpt++;
                if (_matrice[i+1][j+1].getLife())
                    cpt++;
                if (_matrice[i+1][j].getLife())
                    cpt++;
            }
            else if (j==_nbLig-1) {
                if (_matrice[i-1][j].getLife())
                    cpt++;
                if (_matrice[i-1][j-1].getLife())
                    cpt++;
                if (_matrice[i][j-1].getLife())
                    cpt++;
                if (_matrice[i+1][j-1].getLife())
                    cpt++;
                if (_matrice[i+1][j].getLife())
                    cpt++;
            }
            else {
                if (_matrice[i-1][j].getLife())
                    cpt++;
                if (_matrice[i-1][j-1].getLife())
                    cpt++;
                if (_matrice[i][j-1].getLife())
                    cpt++;
                if (_matrice[i+1][j-1].getLife())
                    cpt++;
                if (_matrice[i+1][j].getLife())
                    cpt++;
                if (_matrice[i-1][j+1].getLife())
                    cpt++;
                if (_matrice[i][j+1].getLife())
                    cpt++;
                if (_matrice[i+1][j+1].getLife())
                    cpt++;
            }
        }
    }

la fonction getLife renvoie un booléen qui indique si la case est vivant (1) ou non (0).

Je vais tester tout ça !
Sinon oui ça serait bien si tu pouvais m'envoyer juste la méthode getLife pour voir un peu comment se passe les choses !

Pour optimiser, tu peux aussi faire 2 simples boucles for avec x variant de max(0, x-1) à min(x+1, largeur-1) et y de max(0, y-1) à min(y+1, hauteur-1)

y'a toujours cette possibilité en effet. Sa allège le code.

_matrice est un tableau 2D de type Cellule. Le getLife() c'est l'équivalent de ==0 ou ==1. Rien de plus

Je vais un peu optimiser à la fin quand ça marchera.

ellirar, de la ligne 68 à 111, que fait ton code ?

de 5 à 35: tout le bord haut
de 36 à 65: tout le flanc bas
de 68 à 79: le flanc gauche
de 80 à 91: le flanc droit
le reste: la partie intérieur de la matrice (tout sauf les bords)

EDIT: check tes mp

Ah mais oui, suis-je bête...
Bon, j'ai un peu remis de l'ordre dans mon code !
Mais au niveau de l'affichage j'ai un regroupement de rond bleu au milieu et dans les coins, c'est un peu dégagé, 50% du blanc 50% du bleu...

EDIT : Ah oui excuse-moi, j'avais pas vu mes mp !


EDIT 2 : Y a moyen de faire défiler la grille le nombre de fois que la boucle tourne, en cliquant qu'une seule fois sur le bouton qui permet de lancer le jeu ?

Avec un timer. Je t'ai envoyé ton projet fini. Marque le sujet comme résolu ! Enjoy