int side = 4;
int maxi = 30000;
int env = 10;

cellule[] celluleListe;
int[][][] concentrations;
int[][] celluleMap;
color[][] output;

int c,result,cycle,totale,cellule,FPS,prevT,i;

PFont infosFont;

void setup(){
  size(470,300,P3D); //500,400
  
  infosFont = loadFont("ArialMT-14.vlw");
  textFont(infosFont, 14);
  
  begginScare();
}

/////////////////////////////////////////////////

void draw(){
  if(totale < maxi){
    //updateConcentrations();
    showConcentrations();
    lowerConcentrations(5);
  
    showCellules(); 
    updateAll();
    //updateNext();
    
    output();

    cycle++;
  
    showInfos();
  }else{
    framerate(8);
  }
  
  if(mousePressed == true){
    begginScare();
  }
}

/////////////////////////////////////////////////

class cellule{ 
  int Xpos, Ypos, lifeTime; 
  color Cme,Cother,Cempty;
  
  cellule(){
  }
  
  void update(){
    //------------------------------- TEST VERSION !!
    //cellleMap : 0 = red
    //            1 = green
    //            9 = empty
    //            5 = dead
     
    if(lifeTime < 999){
      celluleMap[Xpos][Ypos] = 9;
    
      Xpos += random(-2,3);
      Ypos += random(-2,3);
      
      if(Xpos > width-1){Xpos = width-1;}
      if(Xpos < 0){Xpos = 0;}
      if(Ypos > height-1){Ypos = height-1;}
      if(Ypos < 0){Ypos = 0;}
      
      if(Cme == color(255,0,0)){
        celluleMap[Xpos][Ypos] = 0;
      }else{
        celluleMap[Xpos][Ypos] = 1;
      }
      
      updateLocalConcentrations(Xpos,Ypos);
    
      //if(random(20) < 1){changeColor();}

      if(totale < maxi){divideFree(Xpos, Ypos, Cme);}
    }else{
      celluleMap[Xpos][Ypos] = 5;
    }
  }
  
  int arounding(int zone, color type){
    int around = 0;
    for(int x=-zone; x<zone; x++){
      for(int y=-zone; y<zone; y++){
        if(get(Xpos+x, Ypos+y) == type){around ++;}
      }
    }
    return around;
  }
  
  void changeColor(){
    if(Cme == color(255,0,0)){
      Cme = color (0,255,0);
      Cother = color (255,0,0);
    }else{
      Cme = color (255,0,0);
      Cother = color (0,255,0);
    }
  }
  
  void init(int a, int b, color c){ /**/
    Xpos=a;
    Ypos=b;
    Cme = c;
    lifeTime = 0;
    if(Cme == color(255,0,0)){
      Cother = color (0,255,0);
    }else{
      Cother = color (255,0,0);
    }
    celluleMap[Xpos][Ypos] = 9;
  }
}

/////////////////////////////////////////////////

//----------------------------------------------- SHOW INFOS *
void showInfos(){
  result ++;
  if(second() != prevT){
    FPS = result;
    prevT = second();
    result = 0;
  }
  if(totale == maxi){
    text(cycle+" rT", 4, 14);
  }else{
    text(FPS+" fps ", 4, 14);
  }
  text(totale+" C", 4, 30);
}

//----------------------------------------------- BIGGIN SCARE *
void begginScare(){
  background(0);
  text("Loading ...", 4, 14);
  
  framerate(60);
  
  totale = (side*side)-1;
  cellule = 0;
  cycle = 0;
  
  celluleListe = new cellule[width*height];    //canot be more cellules than pixel on the scene
  celluleMap = new int[width][height];         //Cellule scene layer
  concentrations = new int[2][width][height];  //Concentration scene layer
  output = new color[width][height];           //Colored scene layer
  
  i = 0;
  
  //Make celluleMap empty and creat all potential cellules
  for(int x=0; x<width; x++){
    for(int y=0; y<height; y++){
      celluleMap[x][y] = 9;
      celluleListe[i] = new cellule();
      i ++;
    }
  }
  
  color c0 = color(255,0,0);
  color c1 = color(0,255,0);
  
  i = 0;
  
  //Initialize a scare of cellule on the center of the scene
  for(int x=((width/2)-(side/2)); x<((width/2)+(side/2)); x++){
    for(int y=((height/2)-(side/2)); y<((height/2)+(side/2)); y++){
      if(int(random(1,3))==1){
        celluleListe[i].init(x, y, c0);
      }else{
        celluleListe[i].init(x, y, c1);
      }
      i++;
    }
  }
  
  //Reset the concentration layer
  for(int x=0; x<width; x++){
    for(int y=0; y<height; y++){
      concentrations[0][x][y] = 0;
      concentrations[1][x][y] = 0;
    }
  }
}

//----------------------------------------------- UPDATE NEXT *
void updateNext(){
  celluleListe[cellule].update();
  cellule ++;
  if(cellule >= totale){
    cellule = 0;
  }
}

//----------------------------------------------- UPDATE ALL *
void updateAll(){
  int temp_totale = totale;
  for(int c=0; c<totale; c++){ //or "c<temp_totale" to prevent from updating the new cellules
    celluleListe[c].update();
  }
}

//----------------------------------------------- UPDATE CONCENTRATIONS *
void updateConcentrations(){
  float result;

  for(int x=0; x<width; x++){
    for(int y=0; y<height; y++){
      
      if(celluleMap[x][y] == 0){
        for(int xn=x-env; xn<x+env; xn++){
          for(int yn=y-env; yn<y+env; yn++){
            if(xn > 0 && xn < width && yn > 0 && yn < height){
              result = env-abs(sqrt(sq(x-xn)+sq(y-yn)));
              if(result > 0){concentrations[0][xn][yn] += result;}
            }
          }
        } 
      }
      
      else if(celluleMap[x][y] == 1){
        for(int xn=x-env; xn<x+env; xn++){
          for(int yn=y-env; yn<y+env; yn++){
            if(xn > 0 && xn < width && yn > 0 && yn < height){
              result = env-abs(sqrt(sq(x-xn)+sq(y-yn)));
              if(result > 0){concentrations[1][xn][yn] += result;}
            }
          }
        }
      }
      
    }
  }
}

//----------------------------------------------- UPDATE LOCAL CONCENTRATIONS *
void updateLocalConcentrations(int x, int y){  
  float result;

  if(celluleMap[x][y] == 0){
    for(int xn=x-env; xn<x+env; xn++){
      for(int yn=y-env; yn<y+env; yn++){
        if(xn > 0 && xn < width && yn > 0 && yn < height){
          result = env-abs(sqrt(sq(x-xn)+sq(y-yn)));
          if(result > 0){concentrations[0][xn][yn] += result;}
        }
      }
    }
  }
  
  else if(celluleMap[x][y] == 1){
    for(int xn=x-env; xn<x+env; xn++){
      for(int yn=y-env; yn<y+env; yn++){
        if(xn > 0 && xn < width && yn > 0 && yn < height){
          result = env-abs(sqrt(sq(x-xn)+sq(y-yn)));
          if(result > 0){concentrations[1][xn][yn] += result;}
        }
      }
    }
  } 
}

//----------------------------------------------- LOWER CONCENTRATIONS *
void lowerConcentrations(int amount){
  for(int x=0; x<width; x++){
    for(int y=0; y<height; y++){
      if(concentrations[0][x][y] > 0){concentrations[0][x][y] -= amount;}
      if(concentrations[1][x][y] > 0){concentrations[1][x][y] -= amount;}
    }
  }
}

//----------------------------------------------- SHOW CONCENTRATIONS *
void showConcentrations(){
  for(int x=0; x<width; x++){
    for(int y=0; y<height; y++){
      if(concentrations[0][x][y]>0 || concentrations[1][x][y]>0){ //get faster
        output[x][y] = color(concentrations[0][x][y],concentrations[1][x][y],0);
      }
    }
  }
}

//----------------------------------------------- SHOW CELLULES *
void showCellules(){
  for(int x=0; x<width; x++){
    for(int y=0; y<height; y++){
      if(celluleMap[x][y] == 0){
        output[x][y] = color(255,0,0);
      }else if(celluleMap[x][y] == 1){
        output[x][y] = color(0,255,0);
      }
    }
  }
}

//----------------------------------------------- DIVIDE FREE *
void divideFree(int x, int y, color c){
  int[] freeX = new int[8];
  int[] freeY = new int[8];
  int i = 0;
  
  for(int xn=x-1; xn<=x+1; xn++){
    for(int yn=y-1; yn<=y+1; yn++){
      if(xn >= 0 && xn < width && yn >= 0 && yn < height){
        if(celluleMap[xn][yn] == 9){
          freeX[i] = xn;
          freeY[i] = yn;
          i++;
        }
      }
    }
  }
  
  if(i > 0){
    int val = int(random(i));
    totale ++;
    celluleListe[totale].init(freeX[val], freeY[val], c);
  }
}

//----------------------------------------------- OUTPUT *
void output(){
  loadPixels();
  for(int x=0; x<width; x++){
    for(int y=0; y<height; y++){
      pixels[(width*y) + x] = output[x][y];
    }
  }
  updatePixels();
}