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;
  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()
  {
    doConnectedSprings();  
    doCollideSprings();        
    for(int i=0;i<nodes.length;i++)
    {
      nodes[i].update();
    }
  }
  void drawLattice()
  {
    noFill();
    float t=tension*200;
    for(int i=0;i<nodes.length;i++)
    {
      for(int s=0;s<nodes[i].c.output.length;s++)
      {
        float a=255-(dist(nodes[i].p,nodes[nodes[i].c.output[s]].p)/25*255);
        if(a>15)
        {
          stroke(255,255,255,a);
//          stroke(25,220,80+t);          
          line(nodes[i].x(),nodes[i].y(),nodes[nodes[i].c.output[s]].x(),nodes[nodes[i].c.output[s]].y());  
        }
      }
      for(int v=i;v<nodes.length;v++)
      {
        boolean doCollide=true;              
        if(dist(nodes[i].p,nodes[v].p)<collisionDistance)
        {
          for(int out=0;out<nodes[i].c.output.length;out++)
          {
            if(nodes[i].c.output[out]==v)
            {
              doCollide=false;
              break;                    
            }
          }              
          for(int in=0;in<nodes[i].c.input.length;in++)
          {
            if(nodes[i].c.input[in]==v)
            {
              doCollide=false;              
              break;
            }
          }      
          if(doCollide)
          {
            float a=150-(dist(nodes[i].p,nodes[v].p)/150*255);        
            if(a>120)
            {
              stroke(150+a,125,115,a);
              line(nodes[i].x(),nodes[i].y(),nodes[v].x(),nodes[v].y());
            }
          }
        }
      }
//      noStroke();
//      fill(205);
      float vel=nodes[i].velocity.m;
//      if(i==0)
//        stroke(155+vel/5*100,40,10+t);
//      else
//        stroke(25+vel/5*100,210,220+t);        
        stroke(222,222,222+t);        
      ellipse(nodes[i].x(),nodes[i].y(),5+constrain((vel*1.5),0,4),5+constrain((vel*1.5),0,4));
    }
  }
  void drawCells()
  {
    for(int i=0;i<nodes.length;i++)
    {
      noFill();
      stroke(160);
      ellipse(nodes[i].p,10);
    }
  }
  void drawLines()
  {
    noFill();
    float t=tension*200;
    for(int i=0;i<nodes.length;i++)
    {
      for(int s=0;s<nodes[i].c.output.length;s++)
      {
        float a=255-(dist(nodes[i].p,nodes[nodes[i].c.output[s]].p)/60*255);
        if(a>15)
        {
          stroke(25,220,80+t);
          line(nodes[i].x(),nodes[i].y(),nodes[nodes[i].c.output[s]].x(),nodes[nodes[i].c.output[s]].y());  
//          noStroke();
//          fill(25,220,80+t,125);
          noFill();
          ellipse(nodes[i].p,4);
        }
      }
    }  
  }
  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[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=dist(nodes[i].p,otherNode.p);      
//          vector f=getSpringForce(nodes[i].p,otherNode.p,minDistance,tension);
          vector f=getSpringForce(nodes[i].p,otherNode.p,nodes[i].c.distanceOut[s],tension);
          float forceMag=f.m;
//          if(distance<minDistance)
//            forceMag=1/distance;
//          else
          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);
          otherNode.velocity=otherNode.velocity.add(f.a,forceMag*-1);
          
//          if(distance>maxDistance&&nodes[i].velocity.m>10)
//          {
//          }
            
        }     
      }
    }    
  }

  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];
      }
      tempNodes[amount-1]=new cell(new position(pos.x,pos.y));
      tempNodes[amount-1].g=new gene(g);
      
//      tempNodes[amount-1]=new mass(new position(mouseX,mouseY));
      for(int s=0;s<nodes.length;s++)
      {
        float distance=dist(tempNodes[amount-1].p,nodes[s].p);      
        if(distance==0)
          tempNodes[amount-1].p=tempNodes[amount-1].p.displace(new vector(random(360),1));
        if(distance<cohesionDistance)
        {      
//          if(distance<collisionDistance)
//            distance=collisionDistance;
          if(distance<minDistance)
            distance=minDistance;
          tempNodes[amount-1].c.addOutput(s,distance);        
          nodes[s].c.addInput(amount-1);
        }
      }
      nodes=tempNodes;
    }
  }
}