/** A little test to see if processing.js is really that good...
                    -  So, not to break with tradition I wrote my usual Hello World
                    - Conway's Game of Life
                    -
                    - It has a couple of optimizations, namely calculating the new
                    - matrix and visualizing them is done at the same time.
                    - The matrix consists of a ring of 'death'cells as a safe sandbox
                    - to avoid memory errors
                    - The 2 matrices are not copied over after calculating, but they
                    - are swapped.
                    -   Loops are run in reverse because it's faster to check a value to
                    -   zero than to another value (w&h).

                    Author: Ezra Pool (ezra@tsdme.nl);
                    Version: 0.4
                */
      int a,b,w,h;
      int[][][] m;

      void setup() {
        h=250;w=250;a=0;b=1;
        m = new int[2][w+1][h+1];

        size(w, h);
        frameRate(5);

        spawn();

      }
      void draw() {

          background(255);
          lifedeathandshow();

      }
      void spawn(){
        int i,j;

        /**
                    -   Apparantly it's faster to run a loop in reverse because checking to see
                    -   if a value is zero is faster than checking another value (w & h).
                    -
                    -   Testing results:
                    -   normalloop: 148ms
                    -   reverseloop: 145ms
//*/
        for(i=1;i0;i--){
          for(j=h-1;j>0;j--){
            m[a][i][j] = floor(random(0,2));
          }
        }
      }

      void lifedeathandshow(){
        int c,i,j,n;

      /**
                    -   Apparantly it's faster to run a loop in reverse because checking to see
                    -   if a value is zero is faster than checking another value (w & h).
                    -
                    -   Testing results don't show much improvement, some rounds are faster
                    -   some are slower, but this is mostly due to the complexity of some of
                    -   the iterations. (More alive or dead cells).

        for(i=1;i< 2 || n > 3){
                m[b][i][j] = 0;
              }else{
                m[b][i][j] = m[a][i][j];
                point(i,j);
              }
            }else{
              if(n == 3){
                m[b][i][j] = 1;
                point(i,j);
              }else{
                m[b][i][j] = m[a][i][j];
              }
            }
          }
        }
        //*/

        for(i=w-1;i>0;i--){
          for(j=h-1;j>0;j--){
            n = neighbours(i,j);
            if(m[a][i][j] == 1){
              if(n < 2 || n > 3){
                m[b][i][j] = 0;
              }else{
                m[b][i][j] = m[a][i][j];
                point(i,j);
              }
            }else{
              if(n == 3){
                m[b][i][j] = 1;
                point(i,j);
              }else{
                m[b][i][j] = m[a][i][j];
              }
            }
          }
        }

        /** I don't know which of the two versions is faster in javascript/processing...
                          - is the temp variable one faster or the XOR swap??
                          -
                          -   Testing with Firebug in Mozilla/5.0 Gecko/2008062505 GranParadiso/3.0.1pre
                          -   Results
                          -   tempvar: 171ms (10.000 iterations)
                          -   xorswap: 203ms (10.000 iterations)
                      */

        c=b;
        b=a;
        a=c;

        //a ^= b;
        //b ^= a;
        //a ^= b;
      }
      int neighbours(int i, int j){
        return m[a][i-1][j-1] +
                m[a][i][j-1] +
                m[a][i+1][j-1] +
                m[a][i-1][j] +
                m[a][i][j] +
                m[a][i+1][j] +
                m[a][i-1][j+1] +
                m[a][i][j+1] +
                m[a][i+1][j+1];
      }