Discussion :

[Taserface]

Bonjour,
j'ai fait cette implémentation du Jeu de la Vie et je veux avoir votre avis si l'implémentation est vraie ou pas.
La modularité n'est pas au rendez-vous mais je travaille dessus

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package gameoflifr;
 
import java.util.Random;
 
/**
 *
 * @author taserface
 */
public class GridLife {
    private static int generation = 1;
 
 
 
    int w = 8;
    int columns, rows;
 
    //Grille
    int[][] board;
 
 
    //Constructeur;
    public GridLife(int col, int row){
        this.columns = col;
        this.rows = row;
 
        board = new int[rows][columns];
        initialisation();
    }
 
    public void printGrid(){
        int count = 0;
        for(int i = 0; i < rows; i = i+1){
            for(int j = 0; j < columns; j = j+1){
                //System.out.print(this.board[i][j]+"   ");
                if(board[i][j] == 1){
                    count++;
                    System.out.print("# ");
                }else
                    System.out.print(". ");
            }
            System.out.println();
        }
        System.out.println("Le nombre de cellule vivante est: "+count);
    }
 
    public void initialisation(){
        Random r = new Random();
        for(int i = 0; i < this.board.length; i = i+1){
            for(int j = 1; j < this.board.length; j = j+1){
                board[i][j] = (int)r.nextInt(2); //generate number between 0 and 1
 
            }
        }
    }
 
    //compter le nombre de voisin en vie
    public int countNeighborsLive(int[][] tab, int x, int y){
        int sum = 0;
        for(int i = -1; i < 2; i = i+1){
            for(int j = -1; j < 2; j = j+1){
                //sum += tab[x+i][y+j];
                int c = (y+j+this.columns) %this.columns;
                int r = (x+i+this.rows) % this.rows;
                sum += tab[r][c];
            }
        }
 
        //ne pas compter la cellule active
        sum -= board[x][y];
        return sum;
    }
 
    //Création de la nouvelle génération
    public void nextGen() throws InterruptedException{
        int[][] next = new int[this.rows][this.columns];
        int neighbors;
        while(true){
            Thread.sleep(5000);
            printGrid();
            for(int x = 1; x < columns-1; x=x+1){
                for(int y = 1; y < rows-1; y = y+1){
 
                   /* if(x == 0 || x == this.rows-1 || y == 0 || y == this.columns-1){
                        next[x][y] = board[x][y];
                    }else{*/
                    neighbors = countNeighborsLive(this.board,x,y);
 
                    //Règle de vie
                    if((board[x][y] == 1) && (neighbors < 2 || neighbors > 3)){ //solitude
                        next[x][y] = 0;
 
                    }else if((board[x][y] == 0) && (neighbors == 3)){ //reproduction
                        next[x][y] = 1;
                    }else{
                        next[x][y] = board[x][y];
                    }
 
                //}
                }
            }
            board = next;
            System.out.println("Génération: "+GridLife.generation);
            GridLife.generation++;
        }
    }
 
}

et là la fonction main

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
public static void main(String[] args) throws InterruptedException {
        // TODO code application logic here
        GridLife gl = new GridLife(27,27);
        //System.out.println(gl);
        System.out.println(" ===============  Starting Game Of Life  ===============");
        System.out.println();
        gl.nextGen();
    }

[joel.drigo]

Salut,

Par "vraie", tu veux dire que ça réalise bien ce que ça doit, je suppose.

Un bon moyen pour vérifier le bon fonctionnement d'un jeu de la vie c'est de tester des configurations standards connues, comme un glisseur (ou planneur) par exemple.

Par exemple, tu crées un tableau (ou tu fais une petite méthode de chargement de fichier) et tu initialises ton tableau board avec :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
depart[0][1]=1;
depart[1][2]=1;
depart[2][0]=1;
depart[2][1]=1;
depart[2][2]=1;

Que constate-ton avec ce glisseur comme configuration ? Que ce glisseur ne glisse pas... donc il y a un problème ( plusieurs en fait).

Des pistes :

1. dans l'expression tab[a][b], a est la ligne (donc normalement y, ou r, dans ton code), b est la ligne (donc normalement x ou c dans ton code)
2. Il y un problème avec next et board : ça devrait toujours être 2 tableaux différents. Dans ton programme, à la deuxième génération next et board sont le même tableau.

Autres choses :

1. Pourquoi ne pas traiter les bordures dans la boucle d'évaluation de la génération suivante ? Surtout que tu le traites dans le calcul du nombres de voisin. Il y a d'ailleurs une incohérence à ce sujet dans l'initialisation.
2. Tu n'affiches pas la dernière génération. Tu fais :
   

   Code :

   Sélectionner tout - Visualiser dans une fenêtre à part

   1
   2
   3
   4
   while( boucle ) {
      afficher génération
      calculer nouvelle génération
   }

   alors qu'il faudrait plutôt :
   afficher génération 0
   while( boucle ) {
   calculer nouvelle génération
   afficher génération
   }[/code]
3. Pourquoi attendre 5 secondes entre chaque génération, alors que ça s'affiche en console, donc forcément en séquence. Dans un affichage graphique ça pourrait avoir un sens, mais en console, pas sûr (à moins de pouvoir effacer le contenu de la console entre chaque génération, ce qui est possible avec certain shell)
4. La méthode nextGen semble vouloir dire par son nom qu'on détermine une seule prochaine génération, alors quelle calcule une infinité de génération. Pour la modularité, ce serait mieux que nextGen ne calcule qu'une seule génération, ce qui permettrait de l'appeler dans différentes configuration (calculer n générations, une infinité, etc), et de pouvoir éventuellement demander une nouvelle génération ou s'arrêter par une interaction avec l'utilisateur

[Taserface]

Merci pour ta réponse:
Alors pourquoi attendre 5s: c'est pour mieux voir le résultat et l'évolution pour le test
En effet oui t'as raison le fait d'afficher la 1ère génération avant mais je pense plus que le problème se trouve au niveau des règles du jeu et du calcul des voisins vivants.
Par exemple j'ai réecris ceci mais ça donne toujours pas l'algo si je teste sur https://www.dcode.fr/jeu-de-la-vie

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public int countAliveNeighbors(Cell[][] cel, int x , int y){
        int count = 0;
        //Cell[][] cellules = grille.getTabGrille();
        for(int i = -1; i  < 2; i = i+1){
            for(int j = -1; j  < 2; j = j+1){
                if(i == x && j == y)
                    continue;
 
                /*if(cel[x+i][y+j].isAlive())
                    count++;  
                */
                int c = (y+j+grille.getTabCols()) % grille.getTabCols();
                int r = (x+i+grille.getTabRows()) % grille.getTabCols();
 
                if(cel[r][c].isAlive()){
                    count++;
                }
            }
        }
 
        return count;
    }

Et pour le calcul de la nouvelle génération

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
public void nextGeneration() throws InterruptedException{
        Cell[][] cellules = grille.getTabGrille();
        int neighbors;
        grille.printGrille(); //print the grille
         System.out.println("Génération: "+GameRuleImplementation.generation);
        while(true){
 
 
            for(int i = 1; i < cellules.length; i = i+1){
                for(int j = 1; j < cellules.length; j = j+1){
 
                    //count the alive neigbors
                    neighbors = countAliveNeighbors(cellules, i, j);
 
                    //rules of game
                    if(cellules[i][j].isAlive() && neighbors < 2){
                        cellules[i][j].setState(false);
                    }else if(cellules[i][j].isAlive() && (neighbors > 3)){
                        cellules[i][j].setState(false);
                    }else if(!cellules[i][j].isAlive() && neighbors == 3){
                        cellules[i][j].setState(true);
                    }
 
 
                }
            }
 
            Thread.sleep(5000);
            GameRuleImplementation.generation++;
            //grille.printGrille();
            //System.out.println("Génération: "+GameRuleImplementation.generation);
        }

j'oubliais voici le Type Cell et TabularGrille

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
private boolean state;
    //private ArrayList<Cell> neighborhood;
 
    public Cell(){
        Random r = new Random();
        state = r.nextBoolean();
 
    }

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
public class TabularGrille {
 
    private Cell[][] tabGrille;
 
    public Cell[][] getTabGrille() {
        return tabGrille.clone();
    }
 
    private int tabRows, tabCols;
 
    public int getTabRows() {
        return tabRows;
    }
 
    public int getTabCols() {
        return tabCols;
    }
 
    public TabularGrille(int rows){
        this.tabRows = rows;
        this.tabCols = rows;
        this.tabGrille = new Cell[rows][rows];
 
        //on initialise le tableau avec un random
        for(int i = 0; i < rows; i = i+1){
            for(int j = 0; j < rows; j = j+1){
                tabGrille[i][j] = new Cell();
            }
        }
 
    }

[joel.drigo]

Oui, enfin, là tu as tout refait. J'ai déjà passé du temps pour analyser le premier programme et je t'ai donné 2 pistes (il suffit de corriger et il n'y a pas grand chose à faire pour que ça fonctionne). Je vais pas relire tout le nouveau code maintenant. Déjà, je vois qu'il y a un problème similaire à ce qu'il y avait dans le premier programme : sauf que là tu as carrément supprimé la possibilité que ça marche, alors qu'avant il suffit de déplacer une ligne de code. Il est important que toute nouvelle génération soit calculée par rapport à l'état précédent complet non partiellement modifié (de toutes les cellules).

sinon ça c'est pas bon (i et j varient de -1 à 1) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
if(i == x && j == y)
                    continue;

ça non plus :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
int c = (y+j+grille.getTabCols()) % grille.getTabCols();
                int r = (x+i+grille.getTabRows()) % grille.getTabCols();

Et je t'ai donné une piste dans mon précédent message. Rappel : x=colonne, y=ligne.

Pour mieux souligner l'incohérence :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
neighbors = countAliveNeighbors(cellules, i, j);
 
                    //rules of game
                    if(cellules[i][j].isAlive() && neighbors < 2){

à mettre en rapport i, x, et c...

Et ce qui suite ne fonctionne que par hasard (si le nombre de colonnes et de lignes est le même) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

     int r = (x+i+grille.getTabRows()) % grille.getTabCols();

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
for(int i = 1; i < cellules.length; i = i+1){
                for(int j = 1; j < cellules.length; j = j+1){

[professeur shadoko]

deux petits trucs pour s'amuser avec un jeu de la vie:
- faire un espace torique (le suivant du bas du tableau est en haut, et le suivant à droite est à gauche , etc...)
- faire un algo de "caillou dans la mare (plouf!)" -> deux tableaux: sur le tableau A quand tu as une cellule vivante faire +1 sur tous les voisins de la même cellule dans le tableau B .... à la fin tu repasses sur le tableau B et en fonction du nombre trouvé dans la cellule x tu sais remettre un vivant ou un mort dans tableau A ... on efface et on recommence.
Bon d'accord c'est un algo plus facile à implanter dans un langage spécialisé dans les matrices comme feu APL mais ça doit être amusant à implanter en java.

[Taserface]

@joel.drigo en effet oui le nombre de lignes est toujours égal au nombre de colonne et dans cette config j'veux que le suivant ou le précedent d'une cellule au bord soit celle se trouvant à son côté opposé comme @professeur shadako l'a mentionné
Et pourquoi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

board = next;

pourque next représente la génération suivante de board donc il faudrait que board soit égal à next pour qu'on puisse calculer la prochaine génération à partir de la nouvelle valeur de board(celle calculé avec next)
Et pour finir dans ce cas-ci x et y étant égales tab[x][y] == tab[y][x].
Sinon pour le reste j'ai pas trop bien saisi

[joel.drigo]

deux petits trucs pour s'amuser avec un jeu de la vie:

Dans les trucs marrants, hormis les glisseurs, lance-glisseurs (ou canon), absorbeur ou anti-canons, etc, un truc sur laquelle j'avais travaillé en projet qui était bien sympa, c'était de refaire des circuits logiques de base (portes ET, OU, NON, etc), des registres binaires, puis de faire des opérateurs de registre (addition, soustraction, multiplication, etc), puis de simuler un petit calculateur/ordinateur, avec une simulation de clavier (utilisant le système de "plouf" comme tu dis), d'écran avec des stabiliseurs, etc.