//  'Difference Between Neighbours' 
//  by Daniel Piker 12/11/08 - spacesymmetrystructure.wordpress.com
//  Have fun. Please let me know about any cool variations or developments you make
//  (email danielpiker--at--yahoo--dot--co--dot--uk)
//  This code is a little messy. If you're looking to learn from or adapt this, I recommend
//  looking first at the earlier version 'fizzynumbers' which is also on the openprocessing site.
//  Its a bit tidier and more clearly annotated. The only real difference here is the quad and vector stuff.
int CellSize = 17;
int CellsAcross = 30;
int CellsDown = 30;
int BrushSize = 2;
int BrushStrength = 35;
int Calm = 130;        // The higher this is, the longer it seems to take to turn chaotic

float[] CellVal = new float[CellsAcross*CellsDown]; int CellIndex = 0;

void setup() {

  colorMode(HSB, 100);  
  size(560,560);//(50+CellsAcross * CellSize,50+ CellsDown * CellSize);
  noStroke();
}

void draw() {
  fill(0,0,0);
  rect (0,0,50+CellsAcross * CellSize,50+ CellsDown * CellSize);
  for (int i = 0; i < CellsAcross; i++) {
    for (int j = 0; j < CellsDown; j++) {
      
      CellIndex = (CellIndex+1)%(CellsAcross*CellsDown);
      
int      klimp  = round(((CellVal[CellIndex])*2.1)%100);       
int      nifna  = round(((CellVal[CellIndex])*2.2)%100);
int      blugg  = round(((CellVal[CellIndex])*2.4)%100);
      // making these 3 values close but not equal factors of the cellvalue puts them out of synch - so they combine to give many colour variations
      // try changing the factors for different palettes      
   
int   below      = (CellIndex+1)%(CellsAcross*CellsDown);
int   above      = (CellIndex+(CellsAcross*CellsDown)-1)%(CellsAcross*CellsDown);
int   left       = (CellIndex+(CellsAcross*CellsDown)-CellsDown)%(CellsAcross*CellsDown);
int   right      = (CellIndex+CellsDown)%(CellsAcross*CellsDown);
int   aboveright = ((CellIndex-1) + CellsDown +(CellsAcross*CellsDown))%(CellsAcross*CellsDown);
int   aboveleft  = ((CellIndex-1) - CellsDown +(CellsAcross*CellsDown))%(CellsAcross*CellsDown);
int   belowright = ((CellIndex+1) + CellsDown +(CellsAcross*CellsDown))%(CellsAcross*CellsDown);
int   belowleft  = ((CellIndex+1) - CellsDown +(CellsAcross*CellsDown))%(CellsAcross*CellsDown);

float CellVectorX   = (CellVal[right]-CellVal[left]); 
float CellVectorY   = (CellVal[above]-CellVal[below]);

   drawCell(i+2, j+2, klimp, nifna, blugg, CellVectorX, CellVectorY);  
      
// These next 2 lines are the real heart of this sketch.
// By messing around with different factors and functions here, you can get wildly different results

float  NeighbourMix       =    pow((CellVal[left]*CellVal[right]*CellVal[above]*CellVal[below]*CellVal[belowleft]*CellVal[belowright]*CellVal[aboveleft]*CellVal[aboveright]),0.125);
       CellVal[CellIndex] = ((((sqrt(1*CellVal[CellIndex]))*(sqrt(NeighbourMix*1)))/1)+0.5)%Calm; 
   
    }
  }
}

   void drawCell(int x, int y, int klimpyness, int nifnacity, int bluggification, float VectorX, float VectorY) { 
    fill(klimpyness,80,100);
  //  noStroke();
//    rect(x*CellSize, y*CellSize, CellSize, CellSize);  
    
    quad(                  x*CellSize+CellSize*0.7*(VectorX/pow((sq(VectorX)+sq(VectorY)),0.35)),
                           y*CellSize+CellSize*0.7*(VectorY/pow((sq(VectorX)+sq(VectorY)),0.35)),
                           
                           x*CellSize+CellSize*0.2*(VectorY/pow((sq(VectorX)+sq(VectorY)),0.5)),
                           y*CellSize-CellSize*0.2*(VectorX/pow((sq(VectorX)+sq(VectorY)),0.5)),
                           
                           x*CellSize-CellSize*0*(VectorX/pow((sq(VectorX)+sq(VectorY)),0.7)),
                           y*CellSize-CellSize*0*(VectorY/pow((sq(VectorX)+sq(VectorY)),0.7)),
                           
                           x*CellSize-CellSize*0.2*(VectorY/pow((sq(VectorX)+sq(VectorY)),0.5)),
                           y*CellSize+CellSize*0.2*(VectorX/pow((sq(VectorX)+sq(VectorY)),0.5))
                           );
    
    
    //stroke(0,0,0);
   // triangle((x*CellSize)-(VectorX/10), (y*CellSize)-(VectorY/10),(x*CellSize)+(VectorX/10), (y*CellSize)+(VectorY/10),(x*CellSize)-(VectorY/10), (y*CellSize)-(VectorX/10));
   //triangle(x*CellSize+0.3*(rightb-leftb),y*CellSize+0.3*(aboveb-belowb),x*CellSize+5,y*CellSize+5,x*CellSize,y*CellSize);
   //line(x*CellSize, y*CellSize, x*CellSize+  CellSize*(VectorX/ pow((sq(VectorX)+sq(VectorY)),0.4) )   , y*CellSize+CellSize*(VectorY/ pow((sq(VectorX)+sq(VectorY)),0.4) ));
}

void mouseDragged() {
    for (int i = 1-BrushSize; i < BrushSize; i++) {
    for (int j = 1-BrushSize; j < BrushSize; j++) {
if (mouseButton == LEFT) {
      drawCell(mouseX / CellSize + i, mouseY / CellSize + j, 100, 100,100,0,0);
      CellVal[getCellIndex (mouseX/CellSize + i,mouseY/CellSize + j)]         =  100; 
  } 
else if (mouseButton == RIGHT) {
  drawCell(mouseX / CellSize + i, mouseY / CellSize + j, 100, 0,0,0,0);
      CellVal[getCellIndex (mouseX/CellSize + i,mouseY/CellSize + j)]         =  0;             
      } 
    }
  }
}

  public int getCellIndex(int x, int y) {
    return abs(constrain(((x%CellsAcross) * CellsDown + (y%CellsDown)),0,(CellsAcross*CellsDown)));
}