final commit

README.md

@@ -1,48 +0,0 @@
-# Programmieren 3
-
-## Assignment "Game Of Life"  
-
-### Einführung
-
-#### Game of Life
-
-Ihre Aufgabe ist es, eine Klasse <code>Life</code> zu implementieren,
-die das *Game of Life* simuliert. Beim *Game of Life* 
-werden Zellen in einem zweidimensionelen Raster angeordnet. 
-An jedem Rasterpunkt kann entweder eine lebende Zelle oder ein
-Leerraum positioniert werden.
-
-Für das Entstehen, Überleben oder Absterben einer Zelle
-ist die Anzahl der unmittelbaren Nachbarn entscheidend.
-Jeder Rasterpunkt hat 8 benachbarte Rasterpunkte 
-(links, rechts, oben, unten, oben links, oben rechts, unten links, unten rechts).
-Für die Berechnung der nachfolgenden Generation sind auf die
-aktuelle Generation folgende Regeln anzuwenden:
-
-- Eine neue Zelle an einem bisher unbelebten Rasterpunkt entsteht,
-  wenn genau drei benachbarte Rasterpunkte mit lebenden Zellen 
-  besetzt sind.
-
-- Lebende Zellen mit weniger als zwei lebenden Nachbarn sterben in der Folgegeneration an Einsamkeit.
-
-- Eine lebende Zelle mit zwei oder drei lebenden Nachbarn bleibt in der Folgegeneration am Leben.
-
-- Lebende Zellen mit mehr als drei lebenden Nachbarn sterben in der Folgegeneration an Überbevölkerung.
-
-
-#### Vorgaben
-
-Im Assignment werden Ihnen drei Code-Dateien vorgegeben:
-
-- <code>Life</code> soll später den Produktivcode enthalten.
-- <code>LifeTest</code> soll für den Testcode benutzt werden.
-- <code>ILife</code> ist ein Interface, das von der <code>Life</code>-Klasse
-  implementiert werden soll.
-
-### Aufgabenstellung
-
-Implementieren Sie die Klasse <code>Life</code> unter Nutzung der TDD-Vorgehensweise.
-Erstellen Sie für die oben genannten Regeln jeweils mindestens einen Testfall (für
-die erste Regel wurde bereits ein Testfall mitgeliefert).
-
-

src/ILife.java

@@ -7,8 +7,12 @@ public interface ILife {
 
     // Methoden zum Abfragen der aktuellen Situation
     public boolean isAlive(int x, int y);
+    public boolean isDead(int x, int y);
 
     // Methoden zum Fortschreiben der Generationen
     public ILife nextGeneration();
 
+    //Methode zum ausgeben der Welt
+    public void printWelt();
+
 }

src/Life.java

@@ -1,55 +1,193 @@
+import java.util.Arrays;
+
+//Gruppe: @FrederikHagen, @DenushanJegatheeswaran, @NathanGebre-Michael, @Justus Görgens
 public class Life implements ILife {
 
-  public static void main(String[] args) {
+    static String[] welt = new String[]{
-    Life l = new Life(new String[] {  "     ",
+            "     ",
-                                      "     ",
+            "     ",
-                                      " *** ",
+            " *** ",
-                                      "     ",
+            "     ",
-                                      "     " });
+            "     "};
-    l = (Life) l.nextGeneration();
+
-  }
+    public static void main(String[] args) {
+        Life l = new Life(welt);
+        l = (Life) l.nextGeneration();
+    }
 
 
-  public Life() {
+    public Life() {
-    nukeAll();
+        nukeAll();
-  }
+    }
 
-  public Life(String[] setup) {
+    public Life(String[] setup) {
-    this();
+        this();
-    for (int y = 0; y < setup.length; y++)
+        for (int y = 0; y < setup.length; y++)
-      for (int x = 0; x < setup[y].length(); x++)
+            for (int x = 0; x < setup[y].length(); x++)
-        if (setup[y].charAt(x) != ' ')
+                if (setup[y].charAt(x) != ' ')
-          setAlive(x, y);
+                    setAlive(x, y);
-  }
+    }
 
+    public void printWelt() {
+        for (int i = 0; i < welt.length; i++)
+            System.out.println(Arrays.toString(new String[]{welt[i]}));
+    }
 
-  @Override
+    @Override
-  public void nukeAll() {
+    public void nukeAll() {
-    // TODO Auto-generated method stub
+        // TODO Auto-generated method stub
 
-  }
+        for (int y = 0; y < welt.length; y++)
+            for (int x = 0; x < welt[y].length(); x++)
+                setDead(x, y);
+    }
 
-  @Override
+    @Override
-  public void setAlive(int x, int y) {
+    public void setAlive(int x, int y) {
-    // TODO Auto-generated method stub
+        // TODO Auto-generated method stub
 
-  }
+        welt[y] = welt[y].substring(0, x) + '*' + welt[y].substring(x + 1);
+    }
 
-  @Override
+    @Override
-  public void setDead(int x, int y) {
+    public void setDead(int x, int y) {
-    // TODO Auto-generated method stub
+        // TODO Auto-generated method stub
 
-  }
+        welt[y] = welt[y].substring(0, x) + ' ' + welt[y].substring(x + 1);
+    }
 
-  @Override
+    @Override
-  public boolean isAlive(int x, int y) {
+    public boolean isAlive(int x, int y) {
-    // TODO Auto-generated method stub
+        // TODO Auto-generated method stub
-    return false;
-  }
 
-  @Override
+        if (welt[y].charAt(x) == '*')
-  public ILife nextGeneration() {
+            return true;
-    // TODO Auto-generated method stub
+        else
-    return null;
+            return false;
-  }
+    }
+
+    @Override
+    public boolean isDead(int x, int y) {
+        // TODO Auto-generated method stub
+
+        if (welt[y].charAt(x) == ' ')
+            return true;
+        else
+            return false;
+    }
+
+    @Override
+    public ILife nextGeneration() {
+        // TODO Auto-generated method stub
+
+        String[] neueWelt = new String[]{
+                "     ",
+                "     ",
+                "     ",
+                "     ",
+                "     "};
+
+        //Zellen einzeln betrachten
+        for (int y = 0; y < welt.length; y++)
+            for (int x = 0; x < welt[y].length(); x++) {
+
+                //anzahl der lebenden nachbarn
+                int nachbarn = lebendeNachbarn(y, x);
+
+                //neue Zelle
+                //TODO fehler wenn x = 0
+                if (nachbarn == 3) {
+                    if (x > 0 && x < welt[0].length() - 1) {
+                        neueWelt[y] = neueWelt[y].substring(0, x) + '*' + neueWelt[y].substring(x + 1);
+                    } else if (x == 0) {
+                        neueWelt[y] = '*' + neueWelt[y].substring(x + 1);
+                    } else {
+                        neueWelt[y] = neueWelt[y].substring(0, x) + '*';
+                    }
+                }
+
+                //eine Zelle stirbt an überpopulation oder einsamkeit
+                //TODO fehler wenn x = 0
+                if (nachbarn < 2 || nachbarn > 3) {
+                    if (x > 0 && x < welt[0].length() - 1) {
+                        neueWelt[y] = neueWelt[y].substring(0, x) + ' ' + neueWelt[y].substring(x + 1);
+                    } else if (x == 0) {
+                        neueWelt[y] = ' ' + neueWelt[y].substring(x + 1);
+                    } else {
+                        neueWelt[y] = neueWelt[y].substring(0, x) + ' ';
+                    }
+                }
+
+                //eine Zelle bleibt am Leben
+                //TODO fehler wenn x = 0
+                if ((nachbarn == 2) && (welt[y].charAt(x) == '*')) {
+                    if (x > 0 && x < welt[0].length() - 1) {
+                        neueWelt[y] = neueWelt[y].substring(0, x) + '*' + neueWelt[y].substring(x + 1);
+                    } else if (x == 0) {
+                        neueWelt[y] = '*' + neueWelt[y].substring(x + 1);
+                    } else {
+                        neueWelt[y] = neueWelt[y].substring(0, x) + '*';
+                    }
+                }
+            }
+        return new Life(neueWelt);
+    }
+
+    public int lebendeNachbarn(int y, int x) { // 1, 1
+
+        int nachbarn = 0;
+
+        //linke nachbars-spalte
+        if (x > 0) {
+            if (y > 0) {
+                if (welt[y - 1].charAt(x - 1) == '*') {
+                    nachbarn++;
+                }
+            }
+            if (welt[y].charAt(x - 1) == '*') {
+                nachbarn++;
+            }
+            if (y < welt.length - 1) {
+                if (welt[y + 1].charAt(x - 1) == '*') {
+                    nachbarn++;
+                }
+            }
+        }
+
+        //rechte nachbars-spalte
+        if (x < welt[0].length() - 1) {
+            if (y > 0) {
+                if (welt[y - 1].charAt(x + 1) == '*') {
+                    nachbarn++;
+                }
+            }
+            if (welt[y].charAt(x + 1) == '*') {
+                nachbarn++;
+            }
+            if (y < welt.length - 1) {
+                if (welt[y + 1].charAt(x + 1) == '*') {
+                    nachbarn++;
+                }
+            }
+        }
+
+        // mittlere Spalte
+        if (y > 0) {
+            if (welt[y - 1].charAt(x) == '*') {
+                nachbarn++;
+            }
+        }
+        if (y < welt.length - 1) {
+            if (welt[y + 1].charAt(x) == '*') {
+                nachbarn++;
+            }
+        }
+
+        return nachbarn;
+    }
+
+    @Override
+    public String toString() {
+        return super.toString();
+    }
 }

test/LifeTest.java

@@ -1,38 +0,0 @@
-import org.junit.Test;
-import static org.junit.Assert.*;
-
-public class LifeTest {
-    
-    @Test
-    public void createNewCell() {
-        
-        // 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 drei Nachbarn sollte jetzt leben
-        assertTrue(nextGen.isAlive(1, 1));
-    }
-
-
-    @Test
-    public void destroyLonelyCell() {
-    }
-
-
-    @Test
-    public void keepAliveCell() {
-    }
-
-
-    @Test
-    public void destroyCrowdedCell() {
-    }
-
-
-}

test/LifeTestLinkerRand.java

@@ -0,0 +1,82 @@
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class LifeTestLinkerRand {
+    
+    @Test
+    public void createNewCell() {
+        
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 0);
+        l.setAlive(0, 1);
+        l.setAlive(0, 2);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(0, 1));
+    }
+
+
+    @Test
+    public void destroyLonelyCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 1);
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt ohne Nachbarn sollte jetzt tot sein
+        assertTrue(nextGen.isDead(0, 1));
+    }
+
+
+    @Test
+    public void keepAliveCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 0);
+        l.setAlive(0, 1);
+        l.setAlive(0, 2);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(0, 1));
+    }
+
+
+    @Test
+    public void destroyCrowdedCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 0);
+        l.setAlive(1, 0);
+        l.setAlive(0, 1);
+        l.setAlive(0, 2);
+        l.setAlive(1, 1);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isDead(0, 1));
+        assertTrue(nextGen.isDead(1, 1));
+    }
+
+
+}

test/LifeTestMitte.java

@@ -0,0 +1,83 @@
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class LifeTestMitte {
+
+    @Test
+    public void createNewCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(2, 0);
+        l.setAlive(2, 1);
+        l.setAlive(2, 2);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(1, 1));
+        assertTrue(nextGen.isAlive(2, 1));
+        assertTrue(nextGen.isAlive(3, 1));
+    }
+
+    @Test
+    public void destroyLonelyCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(2, 1);
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt ohne Nachbarn sollte jetzt tot sein
+        assertTrue(nextGen.isDead(2, 1));
+    }
+
+
+    @Test
+    public void keepAliveCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(2, 0);
+        l.setAlive(2, 1);
+        l.setAlive(2, 2);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(2, 1));
+    }
+
+
+    @Test
+    public void destroyCrowdedCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(2, 0);
+        l.setAlive(1, 0);
+        l.setAlive(2, 1);
+        l.setAlive(2, 2);
+        l.setAlive(1, 1);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isDead(2, 1));
+        assertTrue(nextGen.isDead(1, 1));
+    }
+
+
+}

test/LifeTestObererRand.java

@@ -0,0 +1,82 @@
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class LifeTestObererRand {
+
+    @Test
+    public void createNewCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 0);
+        l.setAlive(1, 0);
+        l.setAlive(2, 0);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(1, 0));
+    }
+
+
+    @Test
+    public void destroyLonelyCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(1, 0);
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt ohne Nachbarn sollte jetzt tot sein
+        assertTrue(nextGen.isDead(1, 0));
+    }
+
+
+    @Test
+    public void keepAliveCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 0);
+        l.setAlive(1, 0);
+        l.setAlive(2, 0);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(1, 0));
+    }
+
+
+    @Test
+    public void destroyCrowdedCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 0);
+        l.setAlive(0, 1);
+        l.setAlive(1, 0);
+        l.setAlive(2, 0);
+        l.setAlive(1, 1);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isDead(1, 0));
+        assertTrue(nextGen.isDead(1, 1));
+    }
+
+
+}

test/LifeTestRechterRand.java

@@ -0,0 +1,82 @@
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class LifeTestRechterRand {
+
+    @Test
+    public void createNewCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(4, 0);
+        l.setAlive(4, 1);
+        l.setAlive(4, 2);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(4, 1));
+    }
+
+    @Test
+    public void destroyLonelyCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(4, 1);
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt ohne Nachbarn sollte jetzt tot sein
+        assertTrue(nextGen.isDead(4, 1));
+    }
+
+
+    @Test
+    public void keepAliveCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(4, 0);
+        l.setAlive(4, 1);
+        l.setAlive(4, 2);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(4, 1));
+    }
+
+
+    @Test
+    public void destroyCrowdedCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(4, 0);
+        l.setAlive(3, 0);
+        l.setAlive(4, 1);
+        l.setAlive(4, 2);
+        l.setAlive(3, 1);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isDead(4, 1));
+        assertTrue(nextGen.isDead(3, 1));
+    }
+
+
+}
+

test/LifeTestUntererRand.java

@@ -0,0 +1,82 @@
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class LifeTestUntererRand {
+
+    @Test
+    public void createNewCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 4);
+        l.setAlive(1, 4);
+        l.setAlive(2, 4);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(1, 4));
+    }
+
+    @Test
+    public void destroyLonelyCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(1, 4);
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt ohne Nachbarn sollte jetzt tot sein
+        assertTrue(nextGen.isDead(1, 4));
+    }
+
+
+    @Test
+    public void keepAliveCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 4);
+        l.setAlive(1, 4);
+        l.setAlive(2, 4);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isAlive(1, 4));
+    }
+
+
+    @Test
+    public void destroyCrowdedCell() {
+
+        // Arrange: drei lebende Zellen
+        Life l = new Life();
+        l.setAlive(0, 4);
+        l.setAlive(0, 3);
+        l.setAlive(1, 4);
+        l.setAlive(2, 4);
+        l.setAlive(1, 3);
+        l.printWelt();
+
+        // Act: Berechnung der Folgegeneration
+        ILife nextGen = l.nextGeneration();
+        nextGen.printWelt();
+
+        // Assert: Rasterpunkt mit drei Nachbarn sollte jetzt leben
+        assertTrue(nextGen.isDead(1, 4));
+        assertTrue(nextGen.isDead(1, 3));
+    }
+
+
+}
+