Programmation du jeu de la vie

Bonjour à tous
Je suis débutante en programmation java et je suis depuis peu bloquée sur mon projet du jeu de la vie(sujet donné en cours) j'aurai donc besoin de vos conseils. Je pense que vous connaissez un peu mieux que moi les règles du jeu. En gros, le jeu se déroule dans une grille, les cases peuvent être occupées ou non par une cellule dont l'état évolue au cours du temps.
- Une cellule qui a 2 ou 3 voisins reste en vie, sinon elle disparaît.
- Si une case vide a exactement 3 voisines occupées par des cellules, il y nait une cellule.
Le calcul du nombre de voisins: pour chaque case, je dois donc calculer le nombre de cellule voisines.
J'ai donc crée une méthode.
Mes problèmes sont les suivants:
1- Je ne sais pas trop si mon calcul marche vu que je n'arrive pas à appeler la méthode dans le main.
2- Je pense être arrivée à calculer les voisines nord sud est et ouest. Mais les voisines nord-est, nord-ouest, sud-est, sud-ouest je ne sais pas trop comment y accéder. Donc si vous pouvez m'aider ce serait sympa
3- Je ne sais pas comment mon programme va pouvoir afficher des figures comme le jeu de base...
C'est un peu compliqué Java pour moi actuellement, donc soyez indulgent.
Merci d'avance :)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

//Calcul du nombre de voisin private static void nbVoisin(boolean occupe[][]) throws FileNotFoundException{ Scanner fichier = new Scanner(new File("source.txt")); int nbLignes = fichier.nextInt(); int nbColonnes = fichier.nextInt();   occupe = new boolean[nbLignes][nbColonnes]; // le nombre de cellules et les affiche int nbCellules = fichier.nextInt(); for (int i = 0; i < nbCellules; i++) { int ligne = fichier.nextInt(); int colonne = fichier.nextInt(); occupe[ligne][colonne] = true; }   int l, c; int nb = 0; for(l = 0; l < nbLignes; l++){ for(c = 0; c < nbColonnes; c++){ if((l-1)>=0 && (occupe[l][c])){ //case du dessus nb=nb+1; } else if((l-1)<nbLignes && occupe[l+1][c]){// ligne du dessous nb=nb+1; } else if((c-1)>=0 && occupe[l][c-1]){ //voisin de gauche nb=nb+1; } else if((c+1)<nbColonnes && (occupe[l][c+1])){ //voisin de droite nb=nb+1; } } }     }

---

Salut,

Premièrement, la lecture du fichier devrait être faite dans une méthode à part, du type :

Code:

---

public boolean[][] readFile(File file) throws FileNotFoundException {

---

Ensuite, tu pourras traiter ton tableau indépendamment du fichier (ou de toute autre source pour ce tableau). A noter qu'il est nécessaire de fermer le fichier à la fin de la lecture, ce que tu peux faire par cette syntaxe :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

public boolean[][] readFile(File file) throws FileNotFoundException {   try ( Scanner fichier = new Scanner( file ) {   int nbLignes = fichier.nextInt(); int nbColonnes = fichier.nextInt();   boolean[][] occupe = new boolean[nbLignes][nbColonnes]; // le nombre de cellules et les affiche int nbCellules = fichier.nextInt(); for (int i = 0; i < nbCellules; i++) { int ligne = fichier.nextInt(); int colonne = fichier.nextInt(); occupe[ligne][colonne] = true; }   return occupe;     } // ici Scanner est automatiquement fermé

---

Ensuite, tu peux faire qui gère un tour :

Code:

---

1 2 3 4 5

private static boolean[][] tour(boolean[][] occupe) {   ...   }

---

L'objectif de cette méthode de crée un nouveau tableau, dans lequel les nouvelles cellules, et les anciennes qui ne seront pas mortes au cour du tour seront mises. En effet, on est obligé de procéder dans une copie du tableau, parce que modifier le tableau d'origine va faire que certains calculs du nombre de voisins seront influencés par les variations des cellules situés au dessus et à gauche (au nord et à l'ouest si tu préfères). Il s'agit donc de parcourir toutes les cases du tableau d'origine, de calculer le nombre de voisins, et de déterminer quelle nouvelle valeur il faut mettre dans la case correspondante du tableau copie (en fonction des règles sur le nombre de voisin : mort, naissance, ou conservation).

Ensuite, pour la méthode qui calcule le nombre de voisin d'une cellule, elle devrait avoir une signature comme ça :

Code:

---

1 2 3 4 5 6 7 8 9

public int nbVoisin(boolean[][] occupe, int x, int y) {   int nb=0;   // ici on détermine pour chaque case à l'est, au sud-est, au sud, au sud-ouest, à l'ouest, au nord-ouest, au nord, et au nord-ouest, 1) si la case existe (donc si elle n'est pas dehors des limites du tableau), 2) si la case est occupée, et dans ce cas, on ajoute 1 à nb   return nb;   }

---

Ensuite, les voisines se déterminent par décalage de x et y (y les lignes, x les colonnes) :

• à l'est : x+1, y
• au sud-est : x+1, y+1
• au sud : x, y+1
• sud-ouest : x-1, y+1
• ouest x-1, y
• nord-ouest x-1, y-1
• nord : x=0, y-1
• nord-est : x+1, y-1

[EDIT]Tu peux résoudre cette partie, assez simplement, avec une boucle :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

for(int dx=-1;dx<=1; dx++) { for(int dy=-1;dy<=1; dy++) { if ( dx != 0 && dy !=0 ) { // on ne traite pas ce cas, parce qu'il s'agit de la cellule elle-même (donc pas une voisine) int vx = x + dx; int vy = y + dy; if ( vy>=0 && vy< occupe.length && vx>=0 && vx<occupe[vy].length ) { // si la cellule voisine est bien dans les limites du tableau if ( occupe[vy][vx] ) { // si la cellule voisine est occupée nb++; // on la compte } } } } }

---

[EDIT]Pour faire l'affichage, il te suffit de parcourir les cases du tableau et d'afficher un caractère pour les cases true et un autre pour les cases false, avec un passage à la ligne entre chaque ligne :

Code:

---

1 2 3 4 5 6 7 8 9

public void afficher(boolean[][] occupe) { for(boolean[] ligne : occuper) { for(boolean cellule : ligne) { if ( cellule ) System.out.print("X"); // X, par exemple, pour une case occupée else System.out.print("."); // ., par exemple, pour un case vide } System.out.prinln(); // passage à la ligne } }

---

Salut,
Pour réponse élaborée, je teste tout ceci et je reviendrai vers vous si nécessaire.
Merci encore :)

petit algo simple (avec un langage de matrices comme APL :calim2:)
un tableau à deux dimensions (mieux : un tableau "torique" dans lequel le voisin supérieur d'une case "en haut" se retrouve en bas, etc...)
s'il y a un "pion" on met 1 sinon 0.
ensuite on fait un "splash" : toute case "arrose " ses voisins (incrémente de 1 toute case adjacente dans une copie du tableau)
ensuite on repasse dans cette copie du tableau: en fonction du nombre présent dans chaque case on crée un vivant ou un tue un pion dans le tableau d'origine)
l'algo est amusant à réaliser
(ensuite on fait un jeu de la vie à 3 dimensions avec des règles différentes pour se compliquer un peu la vie :D )