add tests coverage for gameRules and fix gameRules logic

fredx30 · fredx30 · commit dcfe0aab3d1c · 2021-01-02T14:28:58.000+01:00
diff --git a/app/src/main/java/core/JFXApp.java b/app/src/main/java/core/JFXApp.java
@@ -13,7 +13,7 @@
 public class JFXApp extends Application {
 
     public static void main(String[] args) {
-        EntityGrid.getEntityGrid().addEntityToGrid(30, 30, SpaceShip.GLIDER);
+        EntityGrid.getEntityGrid().addEntityToGrid(32, 32, SpaceShip.GLIDER);
 
         Thread frontendApp = new Thread(()-> {
             JFXApp.launch(args);
diff --git a/app/src/main/java/core/entities/EntityGrid.java b/app/src/main/java/core/entities/EntityGrid.java
@@ -1,5 +1,7 @@
 package core.entities;
 
+import java.util.concurrent.atomic.AtomicInteger;
+
 /**
  * This class will represent the abstract 2d plane on which the game of life takes place. For the first implementation
  * this will be limited to a static grid size outside of which the entities will no longer be simulated. Increasing the
@@ -68,9 +70,11 @@ public void startSimulation() {
         Thread gameSimulationRunner = new Thread(() -> {
             try {
                 Thread.sleep(1000);
+                AtomicInteger iteratation = new AtomicInteger();
+                iteratation.set(0);
                 while (gameRunning) {
                     Thread.sleep(gameSpeed);
-                    EntityGrid.getEntityGrid().executeSimulationTick();
+                    EntityGrid.getEntityGrid().executeSimulationTick(iteratation);
                 }
             } catch (InterruptedException e) {
                 e.printStackTrace();
@@ -94,8 +98,8 @@ public void setSimulationSpeed(int speed) {
         EntityGrid.getEntityGrid().gameSpeed = speed;
     }
 
-    private void executeSimulationTick() {
-        this.entityGrid = ruleSet.applyRulesToGrid(this.entityGrid);
+    private void executeSimulationTick(AtomicInteger iteration) {
+        this.entityGrid = ruleSet.applyRulesToGrid(this.entityGrid, iteration);
     }
 
 
diff --git a/app/src/main/java/core/entities/EntityUtility.java b/app/src/main/java/core/entities/EntityUtility.java
@@ -5,6 +5,7 @@
 import java.io.FileWriter;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Scanner;
 
 public class EntityUtility {
@@ -103,4 +104,14 @@ public static boolean[][] loadEntityFromString(String[] entityRows) {
         return outputEntity;
     }
 
+    /**
+     * Deep clones an array.
+     * From <a href=https://stackoverflow.com/questions/1564832/how-do-i-do-a-deep-copy-of-a-2d-array-in-java>Stackoverflow question ref</a>
+     * @param matrix Array to clone.
+     * @return Cloned array.
+     */
+    public static boolean[][] deepCopy(boolean[][] matrix) {
+        return Arrays.stream(matrix).map(boolean[]::clone).toArray($ -> matrix.clone());
+    }
+
 }
diff --git a/app/src/main/java/core/entities/GameOfLifeRules.java b/app/src/main/java/core/entities/GameOfLifeRules.java
@@ -1,82 +1,99 @@
 package core.entities;
 
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicInteger;
+
 public class GameOfLifeRules {
 
     /**
      * See class GameOfLifeRules for rules. This method takes a simulated grid and updates the status 1 tick in accordance to the game rules.
      * @param grid A game of life grid.
+     * @param iteration a tracker for checking the age of the simulation.
      * @return The simulated game of life grid one game tick forward.
      */
-    public boolean[][] applyRulesToGrid(boolean[][] grid) {
+    public boolean[][] applyRulesToGrid(boolean[][] grid, AtomicInteger iteration) {
         /*
          * To ensure all square updates are applied at the same time we clone the simulated grid.
          * This allows for applying the updates in bulk by replacing the simulated grid with the altered grid
          * on an event of our choosing.
+         * Alternatively this could be created as a queue of changes (more work needed). This would allow for
+         * changes to be streamed and would avoid the need for cloning the original array. This way even a large
+         * grid could remain responsive. Streaming changes as nodes would also allow for backtracking.
          */
-        boolean[][] outputGrid = grid.clone();
+        boolean[][] outputGrid = EntityUtility.deepCopy(grid);
         for (int rowIndex = 0; rowIndex < outputGrid.length; rowIndex++) {
             for (int colIndex = 0; colIndex < outputGrid[0].length; colIndex++) {
-                boolean squareActiveStatus = outputGrid[rowIndex][colIndex];
+                boolean squareActiveStatus = grid[rowIndex][colIndex];
                 int neighborCount = countActiveNeighbors(grid,colIndex,rowIndex);
                 if (squareActiveStatus) {
                     // Square is active
                     switch (neighborCount) {
                         case 0:
                         case 1:
                             // Death by solitude
-                            outputGrid[rowIndex][colIndex] = applyDeathBySolitude();
-                            break;
+                            outputGrid[rowIndex][colIndex] = applyDeathBySolitude(iteration, colIndex,rowIndex);
+                            continue;
                         case 2:
                         case 3:
                             // Cell survives
-                            break;
+                            continue;
                         case 4:
                         case 5:
                         case 6:
                         case 7:
                         case 8:
                             // Death by overpopulation
-                            outputGrid[rowIndex][colIndex] = applyDeathByOverPopulation();
-                            break;
+                            outputGrid[rowIndex][colIndex] = applyDeathByOverPopulation(iteration, colIndex,rowIndex);
                     }
                 } else {
                     // Square is not active
                     if (neighborCount == 3) {
                         // Cell becomes active
-                        outputGrid[rowIndex][colIndex] = applyGrowPopulation();
-                        break;
+                        outputGrid[rowIndex][colIndex] = applyGrowPopulation(iteration, colIndex,rowIndex);
                     }
                 }
             }
         }
+        iteration.incrementAndGet();
         return outputGrid;
     }
 
-    private boolean applyDeathBySolitude() {
+    private boolean applyDeathBySolitude(AtomicInteger iteration, int x, int y) {
+        reportToConsole("Cell killed due to solitude at (" + x + ", " + y + ") during iteration " + iteration.get());
         return false;
         // FIXME: Amend with logic to handle cases around the edges of the boundaries of SIMULATED_GRID.
     }
 
-    private boolean applyDeathByOverPopulation() {
+    private boolean applyDeathByOverPopulation(AtomicInteger iteration, int x, int y) {
+        reportToConsole("Cell killed due to overpopulation at (" + x + ", " + y + ") during iteration " + iteration.get());
         return false;
         // FIXME: Amend with logic to handle cases around the edges of the boundaries of SIMULATED_GRID.
     }
 
-    private boolean applyGrowPopulation() {
+    private boolean applyGrowPopulation(AtomicInteger iteration, int x, int y) {
+        reportToConsole("Cell grown at (" + x + ", " + y + ") during iteration " + iteration.get());
         return true;
         // FIXME: Amend with logic to handle cases around the edges of the boundaries of SIMULATED_GRID.
     }
 
+    /**
+     * Counts the number of active cells within a 3x3 grid centered on x,y.
+     * @param grid the simulation grid.
+     * @param x the center x index
+     * @param y the center y index
+     * @return count of active cells within a 3x3 grid centered on x,y
+     */
     private int countActiveNeighbors(boolean[][] grid, int x, int y) {
         int neighborIterator = 0;
-        for (int rowIndex = x-1; rowIndex <= x+3; rowIndex++) {
+        for (int rowIndex = y-1; rowIndex <= y+1; rowIndex++) {
             // Indexes outside the scope of the simulation will be treated as dead.
-            if (rowIndex < 0 || rowIndex >= EntityGrid.getEntityGrid().getGridSize()){
+            if (rowIndex < 0 || rowIndex >= grid.length){
                 continue;
             }
-            for (int colIndex = y-1; colIndex <= y+3; colIndex++) {
+            for (int colIndex = x-1; colIndex <= x+1; colIndex++) {
                 // Indexes outside the scope of the simulation will be treated as dead.
-                if (colIndex < 0 || colIndex >= EntityGrid.getEntityGrid().getGridSize()){
+                // FIXME in certain cases this could result in spaceships that turn on the simulation edge. This shouldn't happen.
+                if (colIndex < 0 || colIndex >= grid[rowIndex].length){
                     continue;
                 }
                 // Only count neighbor cells so we skip the center of the 3x3
@@ -91,4 +108,8 @@ private int countActiveNeighbors(boolean[][] grid, int x, int y) {
         // FIXME: Amend with logic to handle cases around the edges of the boundaries of SIMULATED_GRID.
         return neighborIterator;
     }
+
+    private void reportToConsole(String s) {
+        System.out.println(s);
+    }
 }
diff --git a/app/src/test/java/core/entities/GameOfLifeRulesTest.java b/app/src/test/java/core/entities/GameOfLifeRulesTest.java
@@ -0,0 +1,72 @@
+package core.entities;
+
+import org.junit.Test;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.junit.Assert.*;
+
+public class GameOfLifeRulesTest {
+    private final static String[] STILL_LIFE_STRING_ARRAY_CONFIGURATION = {
+            "-+-",
+            "+-+",
+            "+-+",
+            "-+-",
+    };
+    private final static String[] OSCILLATOR_STRING_ARRAY_CONFIGURATION = {
+            "-+-",
+            "-+-",
+            "-+-",
+    };
+    private final static String[] EMPTY_STRING_ARRAY_CONFIGURATION = {
+            "---",
+            "---",
+            "---",
+    };
+
+    @Test
+    public void testEmptyGrid() {
+        GameOfLifeRules gameOfLifeRules = new GameOfLifeRules();
+        AtomicInteger simulationAge = new AtomicInteger(0);
+        boolean[][] emptyGrid = gameOfLifeRules.applyRulesToGrid(EntityUtility.loadEntityFromString(EMPTY_STRING_ARRAY_CONFIGURATION), simulationAge);
+        assertEquals(1, simulationAge.get());
+        assertArrayEquals( new boolean[3][3], emptyGrid);
+    }
+
+    @Test
+    public void testStillLife() {
+        GameOfLifeRules gameOfLifeRules = new GameOfLifeRules();
+        AtomicInteger simulationAge = new AtomicInteger(0);
+        boolean[][] stillLifeGrid = gameOfLifeRules.applyRulesToGrid(EntityUtility.loadEntityFromString(STILL_LIFE_STRING_ARRAY_CONFIGURATION), simulationAge);
+        boolean[][] expectedGrid = {
+                {false,true,false,},
+                {true,false,true},
+                {true,false,true,},
+                {false,true,false,},
+        };
+        assertEquals(1, simulationAge.get());
+        assertArrayEquals(expectedGrid, stillLifeGrid);
+    }
+
+    @Test
+    public void testOscillator() {
+        GameOfLifeRules gameOfLifeRules = new GameOfLifeRules();
+        AtomicInteger simulationAge = new AtomicInteger(0);
+        boolean[][] oscillatorGrid = gameOfLifeRules.applyRulesToGrid(EntityUtility.loadEntityFromString(OSCILLATOR_STRING_ARRAY_CONFIGURATION), simulationAge);
+        boolean[][] expectedOddIteration = {
+                {false,false,false,},
+                {true,true,true},
+                {false,false,false,},
+        };
+        boolean[][] expectedEvenIteration = {
+                {false,true,false,},
+                {false,true,false},
+                {false,true,false,},
+        };
+        assertEquals(1, simulationAge.get());
+        assertArrayEquals(expectedOddIteration, oscillatorGrid);
+        oscillatorGrid = gameOfLifeRules.applyRulesToGrid(oscillatorGrid, simulationAge);
+        assertEquals(2, simulationAge.get());
+        assertArrayEquals(expectedEvenIteration, oscillatorGrid);
+    }
+}
