class armor extends creature
{  
  mass head;
  mass spine[];
  mass bodyL[];
  mass bodyR[];
  float s;
  float sinWave;
  float muscleWave;
  vec headP;
  float headAng;
  float spineLength;
  
  float leftWave=1;
  float rightWave=1;
  
  float fatness=0;
  armor(penStroke ps)
  {  
    type=2;
    ps.statistics();
    fatness=.8;
    s=ps.totalLength/250;
    s=constrain(s,.6,2);
    int segments=int(ps.totalLength/20);
    segments=constrain(segments,10,18);
    spine=new mass[segments];
    bodyL=new mass[segments];
    bodyR=new mass[segments];
    for(int i=0;i<spine.length;i++)
    {
      float si=i;
      if(si==0)
        si=0.001;
      float k=si/spine.length;
      k=1-k;
      vec sec=findVecPoint(ps,k);
      spine[i]=new mass(sec);
    }
    float segSize=(fatness*fatness)/100;
    segSize=constrain(segSize,20*s,100*s);
    for(int i=0;i<spine.length;i++)
    {
      float ang=0;
      if(i==0)
        ang=getAng(spine[1].p,spine[0].p);
      else
        ang=getAng(spine[i].p,spine[i-1].p);
      vec vecL=newVec(spine[i].p,ang-100,segSize);
      vec vecR=newVec(spine[i].p,ang+100,segSize);            
      bodyL[i]=new mass(vecL);
      bodyR[i]=new mass(vecR);
      
      spine[i].connectSpringTo(bodyL[i],.7);
      spine[i].connectSpringTo(bodyR[i],.7);   
      
      if(i>0)   
      {
        spine[i].connectSpringTo(bodyL[i-1],.5);
        spine[i].connectSpringTo(bodyR[i-1],.5);               
      }
      segSize*=.86;
    }
    for(int i=0;i<spine.length-1;i++)
    {
      spine[i].connectSpringTo(bodyL[i+1],.5);
      spine[i].connectSpringTo(bodyR[i+1],.5);                     
    }    
    spineLength=dist(spine[0].p,spine[1].p);

    for(int i=1;i<spine.length;i++)
    {
      spine[i].connectSpringTo(spine[i-1],.5);
//      bodyL[i].connectSpringTo(bodyL[i-1],spineDistance,.5);
//      bodyR[i].connectSpringTo(bodyR[i-1],spineDistance,.5);      
      if(i>1)
      {
//        bodyL[i].connectSpringTo(bodyL[i-2],spineDistance*2,.2);
//        bodyR[i].connectSpringTo(bodyR[i-2],spineDistance*2,.2);      
      }      
    }
    
    for(int i=0;i<spine.length;i++)
    {
      bodyL[i].connectSpringTo(bodyR[i],.4);
    }    
    
    head=spine[0];
    headP=spine[0].p;
    headAng=getAng(spine[1].p,spine[0].p);
    if(creationInfo)
    {
      println("Creature Armor created...");
      println("  size: "+s);      
      println("  segments: "+segments);
    }    
    sinWave=random(10);
  }  
  void update()
  {
    for(int i=0;i<spine.length;i++)
    {      
      spine[i].dampScalar(1-FRICTION);                  
      bodyL[i].dampScalar(1-FRICTION);            
      bodyR[i].dampScalar(1-FRICTION);    
      float sm=s/2;
      spine[i].fluidFlow(abs((1-sm)*(1-sm)*(1-sm)));                    
      bodyL[i].fluidFlow(abs((1-sm)*(1-sm)*(1-sm)));             
      bodyR[i].fluidFlow(abs((1-sm)*(1-sm)*(1-sm)));  
      
      spine[i].affectField(0.002*(1+sm)*(1+sm)*(1+sm)*(1+sm));          
//      bodyL[i].affectField(0.002*(1+s)*(1+s)*(1+s)*(1+s));          
//      bodyR[i].affectField(0.002*(1+s)*(1+s)*(1+s)*(1+s));          
      
      spine[i].p=constrain(spine[i].p,WORLDBORDERBUFFER);                                                 
      bodyL[i].p=constrain(bodyL[i].p,WORLDBORDERBUFFER);                                                 
      bodyR[i].p=constrain(bodyR[i].p,WORLDBORDERBUFFER);                                                 
                                    
      if(i>0)
      {                                    
        float delta=sin(muscleWave+i*.5)*4;
        sfDouble(bodyL[i],bodyL[i-1],spineLength+delta*leftWave,.7);
        sfDouble(bodyR[i],bodyR[i-1],spineLength+delta*rightWave,.7);        
      }                                    

      spine[i].update();
      bodyL[i].update();
      bodyR[i].update();      
      
      m=head;
      p=headP;
    }  
    if(random(100)>98)
    {
      if(random(100)>50)
        leftWave+=random(-2,2);
      else
        rightWave+=random(-2,2);    
    }
    
    leftWave+=(1-leftWave)/100;    
    rightWave+=(1-rightWave)/100;
    
    
    sinWave+=s/30;
    muscleWave+=s/15;
    headAng=getAng(spine[1].p,spine[0].p);    
    headP=spine[0].p;    
    head=spine[0];    
    pullHead();
  }
  void pullHead()
  {
    vec vf=newVec(headP,headAng+random(-3,3),6*s);
    sfSingle(head,new mass(vf),0,.5);
  }
  void draw()
  {       
    noFill();  
    float dt=30*(s+.3);
    float sx=25*(s-.4);
    float sy=12*(s-.4);
    stroke(100*sin(sinWave)+160);
    vec p1=newVec(headP,headAng+50,dt);
    pushMatrix();
    translate(p1.x,p1.y);
    rotate(radians(90-headAng-50));
    ellipse(0,0,sx,sy);
    popMatrix();
    vec p2=newVec(headP,headAng-50,dt);
    pushMatrix();
    translate(p2.x,p2.y);
    rotate(radians(90-headAng+50));
    ellipse(0,0,sx,sy);
    popMatrix();    
    vec p3=newVec(headP,headAng,dt);
    pushMatrix();
    translate(p3.x,p3.y);
    rotate(radians(90-headAng));    
    ellipse(0,0,sx,sy);
    popMatrix();    
    for(int i=0;i<spine.length;i++)
    {
      float ang=0;
      if(i>0)
        ang=getAng(bodyL[i].p,bodyR[i].p)-90;
      //  ang=getAng(spine[i].p,spine[i-1].p);      
      else
        ang=headAng;
      float len=dist(bodyL[i].p,bodyR[i].p);
      pushMatrix();
      translate(spine[i].p.x,spine[i].p.y);
      rotate(radians(90-ang));           
      float ss=s/2*len/100;
      scale(ss);     
      
      int r=int(ss*30);
      r=constrain(r,3,7);
      
      stroke(200);
      pushMatrix();
      translate(0,35);
      image(armorBodyDetail2,origin,r-1);      
      popMatrix();
                
            
      stroke(120);
      pushMatrix();
      translate(0,-15);
      if(i==0)
        scale(.6+(sin(sinWave+i/2)/3));
      else
        scale(.8+(sin(sinWave+i/2)/3));      
      image(armorBodyDetail,origin,r-1);      
      popMatrix();
                
      stroke(40);          
      if(i==0)
        image(armorHeadBase,origin,r+1);      
      else
        image(armorBodyBase,origin,r);
      
      popMatrix();
    }
//    drawMasses(spine);
//    drawMasses(bodyL);    
//    drawMasses(bodyR);    
  }
}