class lattice
{
  cell nodes[];
  int amount=0;

  float minDistance=5;
  float maxDistance=150;
  float collisionDistance=10;
  float cohesionDistance=20;
  float tension=0.7;
  float collisionTension=.5;
  float collisionDamping=.4;
  float springDamping=.35;  
  float totalEnergy=0;
  
  boolean stable;
  
  lattice(int a)
  {
    amount=a;
    nodes=new cell[amount];
    for(int nodeIndex=0;nodeIndex<amount;nodeIndex++)
    {
      position p=new position(width/2,height/2);
      float ang=float(nodeIndex)/float(amount)*360;
      nodes[nodeIndex]=new cell(p.displace(ang,50));
    }
  }  
  
  void update(position source)
  {
    doSensors(source);
    doMuscles();
    doConnectedSprings();  
    doCollideSprings();    
    totalEnergy=0;    
    for(int i=0;i<nodes.length;i++)
    {
      nodes[i].update();
      nodes[i].n.update();      
      totalEnergy+=nodes[i].velocity.m;      
    }
    for(int v=0;v<nodes.length;v++)
    {
      nodes[v].n.updateFire();
    }    
    updateStatus();
  }
  void updateStatus()
  {
    if(totalEnergy/float(nodes.length)>60)
      stable=false;
    else
      stable=true;
  }
  void doSensors(position source)
  {
    for(int i=0;i<nodes.length;i++)
    {
      if(nodes[i].isLightSensor)
      {
        boolean lightBlocked=false;
        for(int v=0;v<nodes.length;v++)
        {
          if(v!=i&&!nodes[v].isLightSensor)
          {
            lightBlocked=clIntersect(nodes[v].p,10,source,nodes[i].p);
          }
          if(lightBlocked)
            break;
        }
        if(!lightBlocked)
        {
          signal s=new signal(.1,1);
          nodes[i].n.recieve(s);
        }
      }
    }
  }
  void doMuscles()
  {
    for(int i=0;i<nodes.length;i++)
    {
      nodes[i].c.update();
      if(nodes[i].n.firing&&nodes[i].isMuscle)
      {
        nodes[i].c.contract();
        int index=0;
        for(int v=0;v<nodes[i].c.input.length;v++)
        {
          int inputIndex=nodes[i].c.input[v];
          if(nodes[inputIndex].isMuscle)
          {
            int outIndex=0;
            for(int out=0;out<nodes[inputIndex].c.output.length;out++)
            {
              if(nodes[inputIndex].c.output[out]==i)
                outIndex=out;
            }
            nodes[inputIndex].c.m[outIndex].contract();
          }
        }
      }
    }
  }  
  void doCollideSprings()
  {
    for(int i=0;i<amount;i++)
    {
      for(int s=i;s<amount;s++)
      {                               
            float distance=dist(nodes[i].p,nodes[s].p);      
            if(s!=i)
            {
              boolean doCollide=true;              
              if(distance<collisionDistance)
              {
                for(int out=0;out<nodes[i].c.output.length;out++)
                {
                  if(nodes[i].c.output[out]==s)
                  {
                    doCollide=false;
                    break;                    
                  }
                }              
                for(int in=0;in<nodes[i].c.input.length;in++)
                {
                  if(nodes[i].c.input[in]==s)
                  {
                      doCollide=false;              
                      break;
                  }
                }       
                if(doCollide)
                {              
                  vector f=getSpringForce(nodes[i].p,nodes[s].p,collisionDistance,collisionTension);

                  float forceMag=f.m*.5*(1-collisionDamping);
                  float angle=f.a;
                  float angleOp=f.a+180;
                        
                  nodes[i].velocity=nodes[i].velocity.add(f.a,forceMag*nodes[i].resistance);
                  nodes[s].velocity=nodes[s].velocity.add(f.a,forceMag*-1);                                    
                }
            }
         }
      }
    }  
  }  
  
  void doConnectedSprings()
  {
    for(int i=0;i<amount;i++)
    { 
      if(nodes[i].c.output.length!=0)
      {
        for(int s=0;s<nodes[i].c.output.length;s++)
        {        
          cell otherNode=nodes[nodes[i].c.output[s]];
          float distance=nodes[i].c.distanceOut[s];
          if(nodes[i].isMuscle)
            distance=nodes[i].c.m[s].curLength;
//          else
//            distance=nodes[i].c.distanceOut[s];
          
          vector f=getSpringForce(nodes[i].p,otherNode.p,distance,tension);
          float forceMag=f.m;
          forceMag=f.m*.25*(1-springDamping);          
          float angle=f.a;
          float angleOp=f.a+180;
          nodes[i].velocity=nodes[i].velocity.add(f.a,forceMag*nodes[i].resistance);
          otherNode.velocity=otherNode.velocity.add(f.a,(forceMag*-1));
        }              
      }
    }    
  }

  void addNode(position pos,gene g)
  {
    if(amount<maxNodes)
    {
      amount++;
      cell tempNodes[]=new cell[amount];
//      for(int i=0;i<nodes.length;i++)
//      {
//        tempNodes[i]=nodes[i];
//      }      
      System.arraycopy(nodes,0,tempNodes,0,nodes.length); 
      cell newCell=tempNodes[amount-1];
      tempNodes[amount-1]=new cell(new position(pos.x,pos.y));                          //creates a new cell at pos
      tempNodes[amount-1].g=new gene(g);                                                //now the cell knows what cell-type it is
      tempNodes[amount-1].n=new neuron(amount-1,g.neuronWeight);      
      tempNodes[amount-1].isNeuron=g.isNeuron;
      tempNodes[amount-1].isMuscle=g.isMuscle;      
      tempNodes[amount-1].isLightSensor=g.isLightSensor;
      for(int s=0;s<nodes.length;s++)
      {
        float distance=dist(tempNodes[amount-1].p,nodes[s].p);      
//        if(distance<5)
//          distance=5;
//        if(distance==0)
//          tempNodes[amount-1].p=tempNodes[amount-1].p.displace(random(360),.5);
        if(distance<cohesionDistance)
        {      
          if(distance<minDistance)
            distance=minDistance;
          tempNodes[amount-1].c.addOutput(s,distance);        
          nodes[s].c.addInput(amount-1);
        }
      }      
      nodes=tempNodes;
    }
  }
}