Cell.java

@@ -5,10 +5,17 @@
 public class Cell {
     private boolean isAlive;
 
+    //String qui garde la couleur de la cellule
+    private String color = "Red";
+
     public Cell(){
 	this.isAlive = false;
     }
 
+    public void setColor(String hisColor) { color = hisColor; }
+
+    public String getColor() { return color; }
+
     /**
      * Determines whether this {@link Cell} is alive or not.
      *

GameOfLifeGUI.java

@@ -39,8 +39,16 @@ public class GameOfLifeGUI extends JFrame {
         for (int x = 0; x < numberOfColumns; x++)
             for (int y = 0; y < numberOfRows; y++){
 		JLabel label = labelGrid[x][y];
-		if(g.getCell(x,y).isAlive())
+		//On regarde ici si la cellule est vivante
+		if(g.getCell(x,y).isAlive()) {
+		    //On fonction de l'instance qui gère la couleur on change sa couleur sur la grille
+            if ((g.getCell(x,y).getColor()).equals("Red")) {
                 label.setForeground(Color.red);
+            } else {
+                label.setForeground(Color.blue);
+            }
+        }
+		//sinon on l'a met blanc
 		else
 		    label.setForeground(Color.white);
 	    }

Grid.java

-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Random;
+import java.util.*;
 
 /**
  * {@code Grid} instances represent the grid in <i>The Game of Life</i>.
@@ -98,29 +95,111 @@ public class Grid implements Iterable<Cell> {
     }
 
     private boolean[][] calculateNextStates() {
-        return null;
+        //On crée une nouvelle matrice qui correspond à la prochaine grille
+        boolean[][] newState = new boolean[getNumberOfRows()][getNumberOfColumns()];
+        //On parcours toute la grille puis on fait appelle à la fonction calculateNextStates
+        for (int r=0; r<numberOfRows; r++) {
+            for (int c=0; c<numberOfColumns; c++) {
+                newState[r][c] = this.calculateNextState(r,c,this.getCell(r,c));
+            }
+        }
+
+        return newState;
+    }
+
+    private void goToNextState(boolean[][] nextState) {
+        //On utilise la nouvelle matrice pour savoir si la cellule est vivante ou non
+        for (int r=0; r<numberOfRows; r++) {
+            for (int c=0; c<numberOfColumns; c++) {
+                if (nextState[r][c]) {
+                    this.getCell(r,c).setAlive();
+                }
+                else {
+                    this.getCell(r,c).setDead();
+                }
+            }
+        }
     }
 
     private boolean calculateNextState(int rowIndex, int columnIndex, Cell cell) {
-	return false;
+        //On fait appelle à la méthode de Cell pour savoir si la cellule est vivante
+        boolean Nextstate = cell.isAliveInNextState(this.countAliveNeighbours(rowIndex, columnIndex));
+        //C'est ici aussi que l'on change la couleur de la cellule en fonction de ses voisins en appelant la méthode setColor
+            if (Nextstate) {
+                if (this.countAliveNeighbours(rowIndex, columnIndex) != 2) {
+                    cell.setColor(this.countColorNeighbours(rowIndex, columnIndex));
+                }
+            }
+
+        return Nextstate;
     }
 
     private int countAliveNeighbours(int rowIndex, int columnIndex) {
-        return 0;
+        //Ici on compte le nombre de cellules voisines vivantes
+        int CounterAliveCell = 0;
+        for (Cell NeighboursCell : this.getNeighbours(rowIndex, columnIndex)) {
+            if (NeighboursCell.isAlive()) {
+                CounterAliveCell+=1;
+            }
+        }
+        return CounterAliveCell;
+    }
+
+    private String countColorNeighbours(int rowIndex, int columnIndex) {
+        //On compte ici la couleur des voisins
+        String CounterColorCell;
+        int Red = 0;
+        int Blue = 0;
+        //On compte ici la couleur des voisins
+        for (Cell NeighboursCell : this.getNeighbours(rowIndex, columnIndex)) {
+            if (NeighboursCell.isAlive()) {
+                if ((NeighboursCell.getColor()).equals("Red")) {
+                    Red+=1;
+                }
+                else {
+                    Blue+=1;
+                }
+            }
+        }
+        //Et on fonction du nombre de couleur on change la couleur dans l'instance qui la gère
+        if (Red>Blue) {
+            CounterColorCell="Red";
+        }
+        else {
+            CounterColorCell="Blue";
+        }
+
+
+        return CounterColorCell;
     }
 
 
     private List<Cell> getNeighbours(int rowIndex, int columnIndex) {
-	return null;
+        //On crée une liste de voisin
+        List<Cell> Neighbours = new ArrayList<>();
+        //On parcours les 8 voisins, en prenant compte à ne pas prendre la cellule de base, et on les ajoutes à la liste
+        for (int r=-1; r<=1; r++) {
+            for (int c=-1; c<=1; c++) {
+                if ((r != 0) || (c != 0)) {
+                    Neighbours.add(this.getCell(rowIndex + r, columnIndex + c));
+                }
+            }
         }
 
-    private void goToNextState(boolean[][] nextState) {
+        return Neighbours;
     }
 
+
+
     /**
      * Sets all {@link Cell}s in this {@code Grid} as dead.
      */
     void clear() {
+        //On tue toutes les cellules
+        for (Iterator<Cell> it = this.iterator(); it.hasNext(); ) {
+            Cell cell = it.next();
+            cell.setDead();
+        }
     }
 
     /**
@@ -131,6 +210,23 @@ public class Grid implements Iterable<Cell> {
      */
 
     void randomGeneration(Random random) {
+        //On utilise la méthode Iterator
+        for (Iterator<Cell> it = this.iterator(); it.hasNext(); ) {
+            Cell cell = it.next();
+            //Si le hasard a décidé que la cellule est vivante, on utilise ensuite la même méthode pour mettre sa couleur
+            if (random.nextBoolean()) {
+                cell.setAlive();
+                if (random.nextBoolean()) {
+                    cell.setColor("Red");
+                }
+                else {
+                    cell.setColor("Blue");
+                }
+            }
+            else {
+                cell.setDead();
+            }
+        }
     }
 
 }
\ No newline at end of file