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

  float minDistance=20;          //The minimal distance two cells can bond by spring. If less than this, it will MAKE the cells equal this distance
  float maxDistance=150;
  float collisionDistance;   //Distance where collisions between cells will happen
  float cohesionDistance;       //Distance where cells are able to attatch to each other via spring. Default value found on Creature class
  float tension=0.7;
  float collisionTension=.5;
  float collisionDamping=.4;
  float springDamping=.35;
  float totalEnergy=0;

  boolean stable=true;

  float mostDistant=0;
  position averagePos;
  
  int numExposed=0;

  lattice(lattice l,creature pa)
  {
    nodes=new cell[l.nodes.length];
    amount=l.amount;
    System.arraycopy(l.nodes,0,nodes,0,nodes.length);
    parent=pa;
    cohesionDistance=l.cohesionDistance;
    collisionDistance=l.collisionDistance;
  }
  lattice(int a,creature pa)
  {
    parent=pa;
    amount=a;
    nodes=new cell[amount];
    cohesionDistance=pa.cohesionDistance;
    collisionDistance=pa.collisionDistance;
  }
  void update()
  {
    doMuscles();
    doConnectedSprings();
    doCollideSprings();
    mostDistant=0;
    totalEnergy=0;
    float avx=0;
    float avy=0;
    for(int i=0;i<nodes.length;i++)
    {
      nodes[i].update();
      nodes[i].n.update();
      totalEnergy+=nodes[i].velocity.m;
      avx+=nodes[i].x();
      avy+=nodes[i].y();
    }
    averagePos=new position(avx/nodes.length,avy/nodes.length);
    for(int v=0;v<nodes.length;v++)
    {
      nodes[v].n.updateFire();
      float tempDist=dist(nodes[v].p,averagePos);
      if(mostDistant<tempDist)
      mostDistant=tempDist;

    }
    updateStatus();
  }
  void update(position source)
  {
//    doSurface();
    doSensors(source);
    doMuscles();
    doConnectedSprings();
    doCollideSprings();
    mostDistant=0;
    totalEnergy=0;
    float avx=0;
    float avy=0;
    for(int i=0;i<nodes.length;i++)
    {
      nodes[i].update();
      nodes[i].n.update();
      totalEnergy+=nodes[i].velocity.m;
      avx+=nodes[i].x();
      avy+=nodes[i].y();
    }
    averagePos=new position(avx/nodes.length,avy/nodes.length);
    for(int v=0;v<nodes.length;v++)
    {
      nodes[v].n.updateFire();
      float tempDist=dist(nodes[v].p,averagePos);
      if(mostDistant<tempDist)
      mostDistant=tempDist;

    }
    updateStatus();
  }
  void updateStatus()
  {
    if(totalEnergy/float(nodes.length)>160)
    stable=false;
    else
    stable=true;
  }
  boolean allTypes()
  {
    boolean hasNeurons=false;
    boolean hasSensors=false;
    boolean hasMuscle=false;
    for(int i=0;i<nodes.length;i++)
    {
      if(nodes[i].isNeuron&&!nodes[i].isLightSensor)
        hasNeurons=true;
      if(nodes[i].isLightSensor)
        hasSensors=true;
      if(nodes[i].isMuscle)
        hasMuscle=true;
    }
    boolean hasAll=false;
    if(hasNeurons&&hasSensors&&hasMuscle)
      hasAll=true;
    return hasAll;
  }
  void doSurface()
  {
    numExposed=nodes.length;
    position A=new position(-10000,-10000);
    position B=new position(10000,-10000);
    position C=new position(-10000,10000);
    position D=new position(10000,10000);
    for(int i=0;i<nodes.length;i++)
    {
      nodes[i].exposed=true;
      for(int v=0;v<nodes.length;v++)
      {
        if(i!=v)
        {
          if(
          clIntersect(nodes[v].p,12,nodes[i].p,A)&&
          clIntersect(nodes[v].p,12,nodes[i].p,B)&&
          clIntersect(nodes[v].p,12,nodes[i].p,C)&&
          clIntersect(nodes[v].p,12,nodes[i].p,D))
          {
            nodes[i].exposed=false;
            numExposed--;
            break;          
          }                        
        }
      }
    }
  }
  
  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,parent.collisionDistance,source,nodes[i].p);
          if(lightBlocked)
            break;
        }
        if(!lightBlocked)
        {
          float distance=dist(nodes[i].p,source);
//          distance=constrain(distance,.1,10000);
          float strength=(600-distance)/300;         
          signal s=new signal(strength,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(nodes[i].isMuscle&&nodes[s].isMuscle)
//                doCollide=false;
              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*.3*(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=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*.2*(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<parent.maxNodes)
    {
      amount++;
      cell tempNodes[]=new cell[amount];
      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=g;                                                //now the cell knows what cell-type it is   
      tempNodes[amount-1].n=new neuron(amount-1,g.neuronWeight,g.neuronPower);      
      tempNodes[amount-1].isNeuron=g.isNeuron;
      tempNodes[amount-1].isMuscle=g.isMuscle;
      tempNodes[amount-1].isLightSensor=g.isLightSensor;
      if(g.isLightSensor)
      {
        tempNodes[amount-1].n.refractMax=5;
        tempNodes[amount-1].n.weight=1;
        tempNodes[amount-1].n.bidirectional=true;
        tempNodes[amount-1].n.isLightSensor=true;
      }
      if(g.bidirectional)
      tempNodes[amount-1].n.bidirectional=g.bidirectional;
      for(int s=0;s<nodes.length;s++)
      {
        float distance=dist(tempNodes[amount-1].p,nodes[s].p);
        if(distance<cohesionDistance)
        {
          tempNodes[amount-1].c.addOutput(s,distance);
          nodes[s].c.addInput(amount-1);
        }
      }
      nodes=tempNodes;
    }
  }
}