Added threads to conway, and test code to main.

src/Goldfish.java

@@ -10,11 +10,20 @@ public class Goldfish {
 
     public Goldfish () {
         _render = new Render(640, 480);
-        _grid = new Grid(640, 480);
+        _grid = new Grid(10, 10);
     }
 
     public void run () {
         //TODO: make it run.
+        for (int i = 0; i < 1; i++) {
+            for (int j = 0; j < 3; j++) { 
+                _grid.getPatch(i,j).setState(1);
+            }
+        }
+        System.out.println(_grid);
+        _grid = Conway.run(_grid);
+        System.out.println("------------");
+        System.out.println(_grid);
     }
 
     public static void main (String[] args) {

src/Patch.java

@@ -46,7 +46,7 @@ public class Patch {
     }
 
     public String toString() {
-        return _label;
+        return _label + ", " + _state;
     }
 
     public Patch[] get4Neighbors() {

src/rules/Conway.java

@@ -7,14 +7,63 @@ public class Conway extends RuleSet {
     public static int states = 2;
 
     public static Grid run (Grid g) {
+        Thread[] threads = new Thread[g.getWidth()];
         Grid newGrid = new Grid(g.getWidth(), g.getHeight());
         for (int i = 0; i < g.getWidth(); i++) {
-            for (int j = 0; j < g.getHeight(); j++) {
-                Patch[] neighbors = g.getPatch(i, j).get8Neighbors();
+            Conway.rowThread rt = new Conway.rowThread(g, newGrid, i);
+            Thread t = new Thread(rt);
+            rt.setThread(t);
+            threads[i] = t;
+            t.run();
+            //for (int j = 0; j < g.getHeight(); j++) {
+                //Patch[] neighbors = g.getPatch(i, j).get8Neighbors();
+                //int numAlive = 0;
+                //for (Patch p : neighbors)
+                    //if (p.getState() == 1) numAlive++;
+                //Patch p = g.getPatch(i,j).clone();
+                //if (numAlive < 2) {
+                    //p.setState(0); //Dies by underpopulation
+                //}
+                //if (numAlive > 3) {
+                    //p.setState(0); //Dies by overpopulation
+                //}
+                //if (numAlive == 3)
+                    //p.setState(1); //Born with 3 neighbors.
+                //newGrid.setPatch(i,j,p);
+            //}
+        }
+        boolean running = true;
+        while (running) {
+            running = false;
+            for (Thread t : threads) {
+                if (t.isAlive()) running = true;
+            }
+        }
+        return newGrid;
+    }
+
+
+    public static class rowThread implements Runnable { 
+        private Grid _original, _newGrid;
+        private int _rowNum;
+        private Thread _thread;
+
+        public rowThread (Grid orig, Grid newGrid, int rowNum) {
+            _original = orig;
+            _newGrid = newGrid;
+            _rowNum = rowNum;
+        }
+        public void setThread (Thread t) {
+            _thread = t;
+        }
+
+        public void run () {
+            for (int j = 0; j < _original.getHeight(); j++) {
+                Patch[] neighbors = _original.getPatch(_rowNum, j).get8Neighbors();
                 int numAlive = 0;
                 for (Patch p : neighbors)
                     if (p.getState() == 1) numAlive++;
-                Patch p = g.getPatch(i,j).clone();
+                Patch p = _original.getPatch(_rowNum,j).clone();
                 if (numAlive < 2) {
                     p.setState(0); //Dies by underpopulation
                 }
@@ -23,10 +72,13 @@ public class Conway extends RuleSet {
                 }
                 if (numAlive == 3)
                     p.setState(1); //Born with 3 neighbors.
-                newGrid.setPatch(i,j,p);
+                _newGrid.setPatch(_rowNum,j,p);
+            }
+            try {
+                _thread.join();
+            } catch (Exception e) {
+                e.printStackTrace();
             }
         }
-        return newGrid;
     }
-
 }