Cell.java

@@ -8,6 +8,9 @@ public class Cell {
     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,10 +39,14 @@ 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())
-		    label.setForeground(Color.red);
-		else
-		    label.setForeground(Color.white);
+		    if(g.getCell(x,y).isAlive()) {
+         if ((g.getCell(x,y).getColor()).equals("Red")) {
+             label.setForeground(Color.red); }
+            else {
+		        label.setForeground(Color.blue);} }
+		        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>.
@@ -87,7 +84,7 @@ public class Grid implements Iterable<Cell> {
      * <ul>
      * <li>Any live {@link Cell} with fewer than two live neighbours dies, i.e. underpopulation.</li>
      * <li>Any live {@link Cell} with two or three live neighbours lives on to the next
-     * generation.</li>
+     *      * generation.</li>
      * <li>Any live {@link Cell} with more than three live neighbours dies, i.e. overpopulation.</li>
      * <li>Any dead {@link Cell} with exactly three live neighbours becomes a live cell, i.e.
      * reproduction.</li>
@@ -96,31 +93,92 @@ public class Grid implements Iterable<Cell> {
     void nextGeneration() {
         goToNextState(calculateNextStates());
     }
+    public List<Cell> getNeighbours(int rowIndex, int colummIndex) {
+        List<Cell> listofNeighbours= new ArrayList<Cell>(0);
+        listofNeighbours.add(getCell(rowIndex+1,colummIndex-1));
+        listofNeighbours.add(getCell(rowIndex+1,colummIndex));
+        listofNeighbours.add(getCell(rowIndex+1,colummIndex+1));
+        listofNeighbours.add(getCell(rowIndex,colummIndex+1));
+        listofNeighbours.add(getCell(rowIndex-1,colummIndex+1));
+        listofNeighbours.add(getCell(rowIndex-1,colummIndex));
+        listofNeighbours.add(getCell(rowIndex-1,colummIndex-1));
+        listofNeighbours.add(getCell(rowIndex,colummIndex-1));
+        return listofNeighbours;
 
-    private boolean[][] calculateNextStates() {
-        return null;
     }
+    private int countAliveNeighbours(int rowIndex, int columnIndex) {
+        int AliveNeighbours=0;
+        for (Cell Neighbour  :  getNeighbours(rowIndex,columnIndex)){
+            if (Neighbour.isAlive())
+                AliveNeighbours++;
+        }
+        return AliveNeighbours;
+    }
+    private boolean calculateNextState(int rowIndex, int columnIndex){
+        if (countAliveNeighbours(rowIndex,columnIndex)==3 && !getCell(rowIndex,columnIndex).isAlive())
+            return true;
 
-    private boolean calculateNextState(int rowIndex, int columnIndex, Cell cell) {
+        if (getCell(rowIndex,columnIndex).isAlive() && (countAliveNeighbours(rowIndex,columnIndex)==2 || countAliveNeighbours(rowIndex,columnIndex) == 3))
+            return true;
+        else
             return false;
     }
 
-    private int countAliveNeighbours(int rowIndex, int columnIndex) {
-        return 0;
+    private boolean[][] calculateNextStates() {
+        boolean[][] tableau=new boolean[numberOfRows][numberOfColumns];
+        for (int row=0;row<numberOfRows;row++){
+            for (int column=0;column<numberOfColumns;column++){
+                tableau[row][column]=calculateNextState(row,column);
+            }
+        }
+        return tableau;
+    }
+    private String countColorNeighbours(int rowIndex, int columnIndex) {
+        String CounterColorCell;
+        int Red = 0;
+        int Blue = 0;
+        for (Cell NeighboursCell : this.getNeighbours(rowIndex, columnIndex)) {
+            if (NeighboursCell.isAlive()) {
+                if ((NeighboursCell.getColor()).equals("Red")) {
+                    Red+=1;
+                }
+                else {
+                    Blue+=1;
+                }
+            }
+        }
+        if (Red>Blue) {
+            CounterColorCell="Red";
+        }
+        else {
+            CounterColorCell="Blue";
         }
 
-
-    private List<Cell> getNeighbours(int rowIndex, int columnIndex) {
-	return null;
+        return CounterColorCell;
     }
 
+
+
     private void goToNextState(boolean[][] nextState) {
+        for (int i = 0; i <numberOfRows ; i++) {
+            for (int j = 0; j <numberOfColumns ; j++) {
+                if (nextState[i][j])
+                    getCell(i,j).setAlive();
+                else
+                getCell(i,j).setDead();
+            }
+        }
     }
 
     /**
      * Sets all {@link Cell}s in this {@code Grid} as dead.
      */
     void clear() {
+        for (int i = 0; i <numberOfRows ; i++) {
+            for (int j = 0; j <numberOfColumns ; j++) {
+                getCell(i,j).setDead();
+            }
+        }
     }
 
     /**
@@ -131,6 +189,16 @@ public class Grid implements Iterable<Cell> {
      */
  
     void randomGeneration(Random random) {
+        for (int i = 0; i <numberOfRows ; i++) {
+            for (int j = 0; j <numberOfColumns ; j++) {
+                if (random.nextBoolean())
+                    getCell(i,j).setAlive();
+                else
+                getCell(i,j).setDead();
+
+            }
+
+        }
     }
 
 }