neues Programm

src/Life.java

+import java.util.Arrays;
+
 public class Life implements ILife {
-  
+
+  String[] lifeArray;
+
   public static void main(String[] args) {
     Life l = new Life(new String[] {  "     ",
-                                      "     ",
-                                      " *** ",
-                                      "     ",
-                                      "     " });
+            "     ",
+            " *** ",
+            "     ",
+            "     " });
     l = (Life) l.nextGeneration();
   }
 
 
-  public Life() {
-    nukeAll();
-  }
+  public Life() { nukeAll(); }
 
   public Life(String[] setup) {
     this();
   @Override
   public void nukeAll() {
     // TODO Auto-generated method stub
-
+    lifeArray = new String[] { "     ",
+            "     ",
+            "     ",
+            "     ",
+            "     "};
   }
 
   @Override
   public void setAlive(int x, int y) {
     // TODO Auto-generated method stub
+    String newString = "";
+
+    newString = lifeArray[y].substring(0, x) + "*" + lifeArray[y].substring(x);
+
+    lifeArray[y] = newString;
+
 
   }
 
   @Override
   public void setDead(int x, int y) {
     // TODO Auto-generated method stub
+    String newString = "";
+
+    newString = lifeArray[y].substring(0, x) + " " + lifeArray[y].substring(x);
+
+    lifeArray[y] = newString;
 
   }
 
   @Override
   public boolean isAlive(int x, int y) {
     // TODO Auto-generated method stub
+    if(lifeArray[y].charAt(x) == '*')
+      return true;
     return false;
   }
 
   @Override
   public ILife nextGeneration() {
     // TODO Auto-generated method stub
-    return null;
+    Life newLife = new Life();
+    for(int y = 0; y < lifeArray.length; y++) {
+      for(int x = 0; x < lifeArray[y].length(); x++) {
+        int neighbors = countNeighbors(x, y);
+
+        writeNewGen(neighbors, newLife, x, y);
+      }
+    }
+
+    return newLife;
+  }
+
+  private void writeNewGen(int neighbors, Life newLife, int x, int y) {
+
+    //if the space is alive...
+    if(isAlive(x, y)) {
+
+      //...and has more than three or less than two neighbors, it dies
+      if (neighbors > 3 || neighbors < 2)
+        newLife.setDead(x, y);
+
+      //...and has 2 to 3 neighbors, it survives
+      if (neighbors == 3 || neighbors == 2)
+        newLife.setAlive(x, y);
+    }
+
+    //if the space is dead...
+    if(!isAlive(x, y)) {
+
+      //and has 3 neighbors, it comes to life
+      if (neighbors == 3) {
+        newLife.setAlive(x, y);
+      } else {
+        //and has anything but 3 neighbors, it stays dead
+        newLife.setDead(x, y);
+      }
+    }
+  }
+
+  private int countNeighbors(int x, int y) {
+    int counter = 0;
+
+    //count three above
+    counter += countAbove(x, y);
+
+    //count three below
+    counter += countBelow(x, y);
+
+    //count two sides
+    counter += countSides(x, y);
+
+    return counter;
+  }
+
+  private int countSides(int x, int y) {
+    int counter = 0;
+
+    //is the space left us within the playing field and alive?
+    if(x-1 >= 0 && isAlive(x-1, y))
+      counter++;
+
+    //is the space right us within the playing field and alive?
+    if(x+1 < lifeArray[y].length() && isAlive(x+1, y))
+      counter++;
+
+    return counter;
+  }
+
+  private int countBelow(int x, int y) {
+    int counter = 0;
+
+    //is the line below us within the playing field?
+    if(y+1 < lifeArray.length) {
+      for (int i = x-1; i <= x+1; i++) {
+
+        //are the spaces on our left, middle and right bottom within the playing field alive?
+        if (i >= 0 && i < lifeArray[y+1].length() && isAlive(i, y + 1))
+          counter++;
+      }
+    }
+    return counter;
+  }
+
+  private int countAbove(int x, int y) {
+    int counter = 0;
+
+    //is the line above us within the playing field?
+    if(y-1 >= 0) {
+      for (int i = x-1; i <= x+1; i++) {
+
+        //are the spaces on our left, middle and right top within the playing field alive?
+        if (i >= 0 && i < lifeArray[y-1].length() && isAlive(i, y - 1))
+          counter++;
+      }
+    }
+    return counter;
+  }
+
+  public void showBoard() {
+    for(int y = 0; y < lifeArray.length-1; y++)
+      System.out.println(Arrays.toString(new String[] {lifeArray[y]}));
   }
 }

test/LifeTest.java

 import static org.junit.Assert.*;
 
 public class LifeTest {
-    
+
     @Test
     public void createNewCell() {
-        
+
         // Arrange: drei lebende Zellen
         Life l = new Life();
         l.setAlive(0, 0);
         // Act: Berechnung der Folgegeneration
         ILife nextGen = l.nextGeneration();
 
+
         // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
         assertTrue(nextGen.isAlive(1, 1));
     }
 
     @Test
     public void destroyLonelyCell() {
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 0);
+        l.setAlive(0, 1);
+        l.setAlive(0, 2);
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+
+
+        // Assert: Rasterpunkt mit einem Nachbar soll tot sein
+        assertFalse(nextGen.isAlive(0, 2));
     }
 
 
     @Test
     public void keepAliveCell() {
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 0);
+        l.setAlive(0, 1);
+        l.setAlive(0, 2);
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+
+
+        // Assert: Rasterpunkt mit zwei Nachbarn sollte jetzt am Leben bleiben
+        assertTrue(nextGen.isAlive(0, 1));
     }
 
 
     @Test
     public void destroyCrowdedCell() {
+        // Arrange: fünf lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 0);
+        l.setAlive(0, 1);
+        l.setAlive(0, 2);
+        l.setAlive(1, 1);
+        l.setAlive(1, 0);
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+
+
+        // Assert: Rasterpunkt mit vier Nachbarn sollte jetzt tot sein
+        assertFalse(nextGen.isAlive(0, 1));
     }