Cell.java

 /**
  * {@link Cell} instances represent the cells of <i>The Game of Life</i>.
  */
-
 public class Cell {
     private boolean isAlive;
-
+    private boolean isRed;
     public Cell(){
         this.isAlive = false;
     }
 
+    public void setisRed(boolean bool){
+        this.isRed = bool;
+    }
+
+    public boolean isRed(){
+        return this.isRed;
+    }
+
     /**
      * Determines whether this {@link Cell} is alive or not.
      *
      * @return {@code true} if this {@link Cell} is alive and {@code false} otherwise
      */
-
     public boolean isAlive() {
         return this.isAlive;
     }
@@ -24,7 +30,6 @@ public class Cell {
      *
      * @return {@code true} if this {@link Cell} is dead and {@code false} otherwise
      */
-
     public boolean isDead() {
         return !this.isAlive;
     }
@@ -32,9 +37,7 @@ public class Cell {
     /**
      * Sets the state of this {@link Cell} to alive.
      *
-     * @param cellState the new state of this {@link Cell}
      */
-
     public void setAlive() {
         this.isAlive = true;
     }
@@ -42,18 +45,14 @@ public class Cell {
     /**
      * Sets the state of this {@link Cell} to dead.
      *
-     * @param cellState the new state of this {@link Cell}
      */
-
     public void setDead() {
         this.isAlive = false;
     }
 
-
     /**
      * Change the state of this {@link Cell} from ALIVE to DEAD or from DEAD to ALIVE.
      */
-
     public void toggleState() {
         if(this.isAlive)
             this.isAlive = false;
@@ -63,7 +62,7 @@ public class Cell {
 
     public boolean isAliveInNextState(int numberOfAliveNeighbours) {
         if(isAlive()){
-	    if (numberOfAliveNeighbours == 2 ||  numberOfAliveNeighbours == 3)
+            if ((numberOfAliveNeighbours == 2) ||  (numberOfAliveNeighbours == 3))
                 return true;
             else
                 return false;
@@ -76,3 +75,4 @@ public class Cell {
         }
     }
 }
+

GameOfLife.java

@@ -47,7 +47,6 @@ public class GameOfLife {
     public Grid getGrid() {
         return grid;
     }
-
     /**
      * Plays the game.
      */

GameOfLifeGUI.java

@@ -11,22 +11,31 @@ public class GameOfLifeGUI extends JFrame {
     private JPanel gridPanel;
     private JFrame frame;
     
+
     public GameOfLifeGUI(Grid g) {
         this.numberOfRows = g.getNumberOfRows();
         this.numberOfColumns = g.getNumberOfColumns();
+
         gridLayout = new GridLayout(numberOfRows, numberOfColumns);
         gridPanel = new JPanel(gridLayout);
         labelGrid = new JLabel[numberOfRows][numberOfColumns];
-        for (int x = 0; x < numberOfColumns; x++)
+
+        for (int x = 0; x < numberOfColumns; x++){
             for (int y = 0; y < numberOfRows; y++){
                 labelGrid[x][y] = new JLabel("*");
-		JLabel label;
-		if(g.getCell(x,y).isAlive())
-		   labelGrid[x][y].setForeground(Color.red);
+                JLabel label = labelGrid[x][y];
+                Cell cell = g.getCell(x,y);
+                if(cell.isAlive()) {
+                    if (cell.isRed())
+                        label.setForeground(Color.red);
                     else
-		    labelGrid[x][y].setForeground(Color.white);
+                        label.setForeground(Color.blue);
+                }else{
+                    label.setForeground(Color.white);
+                }
                 gridPanel.add(labelGrid[x][y]);
             }
+        }
         frame = new JFrame("Game of Life");
         frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
         frame.setContentPane(gridPanel);
@@ -36,13 +45,19 @@ public class GameOfLifeGUI extends JFrame {
     }
 
     public void update(Grid g){
-        for (int x = 0; x < numberOfColumns; x++)
+        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())
+                Cell cell = g.getCell(x,y);
+                if(cell.isAlive()) {
+                    if (cell.isRed())
                         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>.
  */
+
+
 public class Grid implements Iterable<Cell> {
 
     private final int numberOfRows;
@@ -86,11 +85,9 @@ public class Grid implements Iterable<Cell> {
      * <p>The following rules are applied:
      * <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>
+     * <li>Any live {@link Cell} with two or three live neighbours lives on to the next 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>
+     * <li>Any dead {@link Cell} with exactly three live neighbours becomes a live cell, i.e. reproduction.</li>
      * </ul>
      */
     void nextGeneration() {
@@ -98,29 +95,83 @@ public class Grid implements Iterable<Cell> {
     }
 
     private boolean[][] calculateNextStates() {
-        return null;
+        boolean [][] nextState = new boolean[getNumberOfRows()][getNumberOfColumns()];
+        for(int rowIndex=0; rowIndex<getNumberOfRows(); rowIndex++){
+            for (int columnIndex = 0; columnIndex < getNumberOfColumns(); columnIndex++) {
+                nextState[rowIndex][columnIndex] = calculateNextState(rowIndex,columnIndex);
+            }
+        }
+        return nextState;
     }
 
-    private boolean calculateNextState(int rowIndex, int columnIndex, Cell cell) {
-	return false;
+    private boolean calculateNextState(int rowIndex, int columnIndex) {
+        Cell cell = getCell(rowIndex, columnIndex);
+        int numberOfAliveNeighbours = countAliveNeighbours(rowIndex, columnIndex);
+        return cell.isAliveInNextState(numberOfAliveNeighbours);
     }
 
     private int countAliveNeighbours(int rowIndex, int columnIndex) {
-        return 0;
+        List<Cell> neighboursList = getNeighbours(rowIndex, columnIndex);
+        Iterator<Cell> iterator = neighboursList.iterator();
+        int counter = 0;
+        while(iterator.hasNext()) {
+            if(iterator.next().isAlive())
+                counter++;
+        }
+        return counter;
     }
 
+    private boolean aliveNeighboursMajColor(int rowIndex, int columnIndex){
+        List<Cell> neighboursList = getNeighbours(rowIndex, columnIndex);
+        int count = countAliveNeighbours(rowIndex, columnIndex);
+        Iterator<Cell> iterator = neighboursList.iterator();
+        int redCount = 0;
+        while(iterator.hasNext()) {
+            Cell cell = iterator.next();
+            if (cell.isAlive() && cell.isRed())
+                redCount++;
+        }
+        return (redCount>(count/2));
+    }
 
     private List<Cell> getNeighbours(int rowIndex, int columnIndex) {
-	return null;
+        List<Cell> neighboursList = new ArrayList<Cell>();
+        neighboursList.add(getCell(rowIndex, columnIndex+1));
+        neighboursList.add(getCell(rowIndex, columnIndex-1));
+        neighboursList.add(getCell(rowIndex+1, columnIndex));
+        neighboursList.add(getCell(rowIndex-1, columnIndex));
+        neighboursList.add(getCell(rowIndex+1, columnIndex+1));
+        neighboursList.add(getCell(rowIndex+1, columnIndex-1));
+        neighboursList.add(getCell(rowIndex-1, columnIndex+1));
+        neighboursList.add(getCell(rowIndex-1, columnIndex-1));
+        return neighboursList;
     }
 
     private void goToNextState(boolean[][] nextState) {
+        for(int rowIndex=0; rowIndex<this.numberOfRows; rowIndex++) {
+            for (int columnIndex = 0; columnIndex < this.numberOfColumns; columnIndex++) {
+                Cell cell = getCell(rowIndex, columnIndex);
+                if (nextState[rowIndex][columnIndex]) {
+                    if(cell.isDead()) {
+                        boolean redColor = aliveNeighboursMajColor(rowIndex, columnIndex);
+                        cell.setisRed(redColor);
+                    }
+                    cell.setAlive();
+                }else{
+                    cell.setDead();
+                }
+            }
+        }
     }
 
     /**
      * Sets all {@link Cell}s in this {@code Grid} as dead.
      */
     void clear() {
+        for (Iterator<Cell> gridIt = iterator(); gridIt.hasNext(); ) {
+            Cell cell = gridIt.next();
+            cell.setDead();
+        }
     }
 
     /**
@@ -131,6 +182,31 @@ public class Grid implements Iterable<Cell> {
      */
 
     void randomGeneration(Random random) {
+        Iterator<Cell> gridIt = iterator();
+        while (gridIt.hasNext()) {
+            Cell cell = gridIt.next();
+            boolean randomStat = random.nextBoolean();
+            if (randomStat) {
+                cell.setAlive();
+                randomStat = random.nextBoolean();
+                if (randomStat)
+                    cell.setisRed(true);
+                else
+                    cell.setisRed(false);
+            }else {
+                cell.setDead();
+            }
+        }
+        // Spaceships Test
+        /*
+        Cell cell0 = getCell(1,1);
+        Cell cell1 = getCell(2,2);
+        Cell cell2 = getCell(1,3);
+        Cell cell3 = getCell(2,3);
+        Cell cell4 = getCell(3,2);
+        cell0.setAlive();cell1.setAlive();cell2.setAlive();cell3.setAlive();cell4.setAlive();
+        */
+
     }
 
 }
\ No newline at end of file

GridIterator.java

@@ -8,11 +8,12 @@ public class GridIterator implements Iterator<Cell> {
     private int columnIndex;
     private Grid grid;
 
+
     GridIterator(Grid grid) {
         this.rowIndex = 0;
         this.columnIndex = 0;
-        this.grid = grid;
-    }
+        this.grid = grid; }
+
 
     @Override
     public boolean hasNext() {