Salut,
Premièrement, la lecture du fichier devrait être faite dans une méthode à part, du type :
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 :
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 :
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 :
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 :
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 :
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
}
} |
Programmation du jeu de la vie
Répondre avec citation
La plupart des réponses à vos questions sont déjà dans les 
)
)
bouquin sur Java :
Partager