creature bestCreature;                        //a pointer to the best creature
creature tcreature;                           //a pointer to the currently tested creature
int bestCreatureID;                           //the index number for the best creature
float bestFitness=0;                          //the fitness value of the currently best creature
int sampleAmount=150;                         //the initial sample of creatures tested
creature clist[]=new creature[sampleAmount];  //the list of creatures being tested
int maxTime=500;                              //maximum amount of steps to test a creature with
int steps=0;                                  //the current step of simulation
int cc=0;                                     //id tag of current creature being tested
int mutations=0;
int maxMutations=100;

String messageBuffer[]=new String[36];
void initTextBuffer()
{
  for(int i=0;i<messageBuffer.length;i++)
  {
    messageBuffer[i]="";
  }
}
void toBuffer(String s)
{
  for(int i=0;i<messageBuffer.length-1;i++)
  {
    messageBuffer[i]=messageBuffer[i+1];
  }
  messageBuffer[messageBuffer.length-1]=s;
}
void printTextBuffer()
{
  textMode(ALIGN_LEFT);
  position p=new position(10,25);
  float kern=10;
  textFont(uiFont,12);
  fill(100);
  for(int i=0;i<messageBuffer.length;i++)
  {
    text(messageBuffer[i],p.x,p.y+12*i);
  }
}
float fitness(creature c,float timesteps,position l)
{    
  float distToLight=dist(c.p,l);
//  distToLight=constrain(distToLight,.01,10000);
//  +850-distToLight;
  float distVal=300-distToLight;
  float m=10;
  if(distVal<0)
    m=20;
  float f=(c.distanceTravelled/timesteps);//+m*distVal;//+10000000*(1/pow(distToLight,2));
  c.avgSpeed=f;  
  f=f*25;
  return f;
}
void printTopicalData()
{
  float kern=12;
  if(bestFitness>0&&bestCreature!=null)
  {
    position p=new position(width/2,height-35);  
    textFont(uiFont,15);
    textMode(ALIGN_CENTER);
    fill(180);
    text("current best fitness: "+bestFitness,p.x,p.y);
    text("creature average speed: "+bestCreature.avgSpeed+"px/frm",p.x,p.y+kern);
    text("press 'q' to see creature",p.x,p.y+kern*2);
    textMode(ALIGN_LEFT);    
  }  
}
void evolution()
{
    if(mutations>maxMutations)
    {
      simulationMode=true;                          //once all the testing is over, we see the result
      if(bestCreature==null)                        //this means no good creatures were found...      
        currentCreature=tcreature;
      else
      {       
        float success=0;
        for(int i=0;i<clist.length;i++)
        {
          if(clist[i].fitness>0)
            success++;
        }
        float ratio=success/clist.length*100;
        currentCreature=bestCreature;               //this means we found a good creature        
//        println("best creature fitness: "+bestCreature.fitness);
//        println("simulation success rate: "+ratio+"%");
        currentCreature.rebuild();        
      }    
    }
    else
    if(cc>=clist.length)
    {
      cc=0;
      mutations++;
      clist[0]=new creature(bestCreature);
      int amt=int(clist.length*.2);
//      println("generating "+amt+" mutations..");
      toBuffer("generating "+amt+" mutations..");
      for(int i=1;i<amt;i++)
      {
//        println("  making mutations "+i);
//        toBuffer("  making mutations "+i);
        clist[i]=new creature(clist[0]);
        clist[i].mutate();
//        clist[i]=new creature(clist[i]);
        clist[i].rebuild();
      }      
//      println("seeding the remaining slots...");
      toBuffer("seeding the remaining slots...");
      for(int v=amt;v<clist.length;v++)
      {
//        println("  making new random creature "+v);
//        toBuffer("  making new random creature "+v);
        clist[v]=new creature(spawnPos);
      }
    }   
    else
    {
      tcreature=clist[cc];           
//      println("testing creature "+cc+"...");
      toBuffer("testing creature "+cc+"...");
      float curFitness=0;
      float TF1=0;
      float TF2=0;
      float TF3=0;
      float TF4=0;
      int iterations=1;                             //test 4 times for all 4 light directions
      for(int i=0;i<iterations;i++)
      {  
        curFitness=0;   
        position lightDest=new position();         
        switch(i)
        {
          case 0:
            lightDest=new position(tcreature.p.displace(90,300));
            break;
          case 1:
            lightDest=new position(tcreature.p.displace(90-60,300));
            break;
          case 2:
            lightDest=new position(tcreature.p.displace(90+60,300));                  
            break;
          case 3:
            lightSource=new position(tcreature.p.displace(36*4,600));                          
            break;
        }
        lightSource=new position(tcreature.p.displace(90,300));
        tcreature.update(lightSource);        
        for(int t=0;t<maxTime;t++)
        {
          if(t%100==0)
          {
//            print("f"+t+". ");
          }
          if(!clist[cc].allTypes)
          {
//            println("    creature is incapable of motion");
            toBuffer("    creature does not have all requisite components");
            curFitness=0;
            tcreature.fitness=0;
            i=4;
            break;
          }
          if(!tcreature.checkStability())              //check if the creature is stable
          {
//            println("    creature exploded due to instability");
            toBuffer("    creature exploded due to instability");            
            curFitness=0;
            tcreature.fitness=0;            
            i=4;                                       //break out of the iteration loop as well
            break;                                     //break the simulation loop if the creature is unstable
          }       
          if(t>50&&tcreature.distanceTravelled<1)
          { 
//            println("    creature is inactive (dt: "+tcreature.distanceTravelled+")");
            toBuffer("    creature is inactive (dt: "+tcreature.distanceTravelled+")");
            curFitness=0;                              //immediately kill creatures that are not moving        
            i=4;
            break;
          }
          if(t>100)
          {
//            lightSource=lightSource.displace(getHeading(lightSource,lightDest),5);  
          }
          if(curFitness<-100)
          {
//            println("  creature is going the wrong way");
//            i=4;
//            break;
          }

          tcreature.update(lightSource);               //update the creature per time step
          curFitness=fitness(tcreature,t,lightSource);             //evaluate the creature's fitness at every time step               
        }
        switch(i)
        {
          case 0:
//            println("    trial 1 fitness: "+curFitness);
            toBuffer("    trial 1 fitness: "+curFitness);
//            println("      distance to target: "+dist(tcreature.p,lightSource));
            TF1=curFitness;
            break;
          case 1:
            println("    trial 2 fitness: "+curFitness);            
            println("      distance to target: "+dist(tcreature.p,lightSource));            
            TF2=curFitness;            
            break;
          case 2:
            println("    trial 3 fitness: "+curFitness);            
            println("      distance to target: "+dist(tcreature.p,lightSource));            
            TF3=curFitness;            
            break;
          case 3:
            println("    trial 4 fitness: "+curFitness);            
            println("      distance to target: "+dist(tcreature.p,lightSource));            
            TF4=curFitness;            
            break;
        }
        if(curFitness<bestFitness*.8)
        {
//          println("  creature disqualified because it's below 80% of best fitness");
          toBuffer("  creature disqualified because it's below 80% of best fitness");
          i=4;
        }             
        tcreature.fitness+=curFitness;  
        tcreature.distanceTravelled=0;
        tcreature.rebuild();        
      }  
      push();
      scale(.5,.5);
      translate((width/2),0);        
      push();   
      push();
      translate(0-(width*.5),0);      
      display(tcreature);             
      pop();                   
      translate(0,300);
      if(bestCreature!=null&&bestFitness>0)
        display(bestCreature);     
      pop();
      
      push();
      translate(0-(width),0);                                
      if(cc-1>=0)      
        display(clist[cc-1]);        
      pop();
      
      push();
      if(cc+1<clist.length)
        display(clist[cc+1]);
      translate((width*.5),0);                                
      if(cc+2<clist.length)
        display(clist[cc+2]);        
      translate((width*.5),0);                                
      if(cc+3<clist.length)
        display(clist[cc+3]);                
      pop();    
      pop();       
      float diff=abs(TF1-TF2)+abs(TF2-TF3)+abs(TF3-TF1);     
      diff=diff*.9;        
      tcreature.fitness=(tcreature.fitness);
//      tcreature.fitness=(tcreature.fitness);      
      if(tcreature.fitness<0)
        tcreature.fitness=0;
//      println("  simulation ended. creature fitness is "+tcreature.fitness+" (best is: "+bestFitness+")");
      toBuffer("  simulation ended. creature fitness is "+tcreature.fitness+" (best is: "+bestFitness+")");
      for(int i=0;i<clist.length;i++)
      {
        if(clist[i].fitness>bestFitness)
        {
          bestFitness=clist[i].fitness;
          bestCreature=clist[i];
//          println("  winner found. new best fitness: "+bestFitness);          
          toBuffer("  winner found. new best fitness: "+bestFitness);
        }
      }            
    }    
    cc++;    
}