class snakey extends creature
{
  segment head;
  segment belly;
  segment tail;
  segment body[];
  float distance;
  float muscleTension=0;
  float spinAng=0;
  float s;
  float speed;
  float headAng;
  
  boolean superSnake=false;
  float jawControl=0;
  float jawSnap=40;  
  snakey(penStroke ps)
  {
    type=5;
    vec p=new vec(ps.points[ps.points.length-1].p);
    s=ps.totalLength/1000;
    if(s>.75)
      superSnake=true;
    int sections=int(constrain(round(s*40),3,40));    
    if(superSnake)
      sections=int(sections*.9);
    body=new segment[sections];
    speed=ps.averageLength;
    speed/=9;
    speed*=speed;   
    speed=constrain(speed,0.01,100);
    if(superSnake)
      speed=speed/6;
    float sz=s;    
    float ratio=.94;
    if(superSnake)
      ratio=.95;
    for(int i=0;i<body.length;i++)
    {
      float k=float(i)/body.length;
      if(k==0)
        k=0.0001;
      drawPoint sec=findDrawPoint(ps,1-k);
      if(i>0)
      {
        float ang=getAng(sec.p,body[i-1].p);
        body[i]=new segment(sec.p,sz*=(ratio-(1-this.s)/9),ang);
      }
      else
      {
        float ang=getAng(findDrawPoint(ps,1-float(1)/body.length).p,sec.p);        
        body[i]=new segment(sec.p,sz*=(ratio-(1-this.s)/9),ang);      
      }
    }

      body[0].m1.connectSpringTo(body[0].m3,.8);
      body[0].m2.connectSpringTo(body[0].m3,.8);    
      body[0].m1.connectSpringTo(body[0].m2,.5);  

    for(int i=1;i<body.length;i++)
    {   
      segment seg=body[i];
      segment lastseg=body[i-1];
      float d=dist(body[i].p,body[i-1].p);
      
      seg.m1.connectSpringTo(seg.m3,.6);
      seg.m2.connectSpringTo(seg.m3,.6);    
      seg.m1.connectSpringTo(seg.m2,.5);      
      
      seg.m3.connectSpringTo(lastseg.m3,d,.2);
      seg.m3.connectSpringTo(lastseg.m3,d,.2);        
      
      seg.m1.connectSpringTo(lastseg.m1,d,.7);
      seg.m2.connectSpringTo(lastseg.m2,d,.7);      

      seg.m3.connectSpringTo(lastseg.m1,d+1,.5);
      seg.m3.connectSpringTo(lastseg.m2,d+1,.5);      

            
      float k=.73;
      for(int s=i-1;s>=0;s--)
      {
        float dt=dist(body[i].p,body[s].p);
        body[s].m1.connectSpringTo(body[i].m1,dt,k);
        body[s].m2.connectSpringTo(body[i].m2,dt,k);        
        k*=(k+.1);
        if(k<.1)
          break;
      }
    }
    head=body[0];
    headAng=getAng(body[1].p,head.p);    
    belly=body[int((body.length-1)/2)];
    tail=body[body.length-1];    
    if(superSnake)
    {
      for(int i=0;i<body.length;i++)
        body[i].superSegment=true;
    }
   
    
    wanderTarget=new vec(head.p);
    wander=new vec(head.p);
       
    if(creationInfo)
    {
      println("Creature Snakey created...");
      println("  size:  "+this.s);
      println("  speed: "+speed);    
    }
  }
  void update()
  {
    manageBody();
    behavior();
    p=head.p;    
    m=head.m3;
    headAng=getAng(body[1].p,head.p);
    if(superSnake)
      manageJaws();
  }
  void manageJaws()
  {
    jawControl+=(jawSnap-jawControl)/20;
    jawSnap+=(-30-jawSnap)/5;
    if(random(100)>98)
    {
      jawSnap+=random(80);
    }
  }
  void draw()
  {
    if(superSnake)
    {
      drawSuperSnake();
      return;
    }
    body[0].drawHead(spinAng);
    for(int i=1;i<body.length;i++)
    {
      body[i].draw();
    }
//    drawRig();
  }
  void drawSuperSnake()
  {
    body[0].drawSuperHead(spinAng);  
    for(int i=1;i<body.length;i++)
    {
      body[i].drawSuper();
    }  
    drawJaws();
  }
  void drawJaws()
  {

    vec hp=head.p;
    float ang=headAng;
    vec jawRight=newVec(hp,headAng-40,90*s);
    vec jawLeft=newVec(hp,headAng+40,90*s);    
    pushMatrix();
    translate(jawRight.x,jawRight.y);
    rotate(radians(90-ang+jawControl));
    scale(s);
    stroke(255-120);    
    ellipse(origin,15);
    stroke(255-90);    
    image(headTeethR,nv(2,-40),9);    
    popMatrix();
    
    pushMatrix();
    translate(jawLeft.x,jawLeft.y);
    rotate(radians(90-ang-jawControl));
    scale(s);
    stroke(255-120);
    ellipse(origin,15);
    stroke(255-90);        
    image(headTeethL,nv(2,-40),9);    
    popMatrix();    
  }
  void drawRig()
  {
    for(int i=0;i<body.length;i++)
    {
      noFill();
      stroke(150,25,25);      
      ellipse(body[i].m1.p,15);
      ellipse(body[i].m2.p,15);      
      stroke(25,25,150);
      ellipse(body[i].m3.p,15);      
    }
  }
  
  
  float wanderAng=random(360);
  vec wander;
  vec wanderTarget;
  boolean useWander=true;
  boolean follow=false;
  creature creatureToFollow=null;
  void behavior()
  {
    if(!superSnake&&random(100)>99.6)
    {  
      if(useWander)
      {
        useWander=false;
        interest=null;
/*        for(int i=0;i<clist.length;i++)
        {
          if(dist(head.p,clist[i].m.p)<250)
            if(random(100)>30)
            {
              interest=new vec(clist[i].m.p);
              break;
            }
        }
        if(interest==null)
        {
          int rd=int(random(clist.length));
          interest=new vec(clist[rd].m.p);
        }*/
      }
      else
      {
        useWander=true;
        wander=head.p;
        wanderTarget=head.p;
      }
    }
    if(!useWander)
    {
      if(creatureToFollow==null)
      {
        for(int i=0;i<clist.length;i++)
        {
          if(clist[i]!=this)
          {
            float d=dist(head.p,clist[i].p);
            if(d<300)
            {
              creatureToFollow=clist[i];
              break;
            }
          }
        }
      }
      if(creatureToFollow!=null)
      {
        vec targ=new vec(head.p,creatureToFollow.p);
        vec vf=newVec(head.p,180+targ.ang(),targ.mag()*.1);
        interest=vf;
      }
      else
        useWander=true;
    }  
    if(useWander)
    {
//      println(wander);
//      println(wanderTarget);
      wanderAng+=random(-speed*2*s,speed*2*s);
      vec loc=newVec(head.p,head.head,5);
      vec target=newVec(loc,wanderAng,speed*s);
      vec vf=new vec(head.p,target);
      vf.mul(.5);
      wanderTarget.add(vf);
      wanderTarget=constrain(wanderTarget,WORLDBORDERBUFFER-60);
      wander.add(springForce(new mass(wander),new mass(wanderTarget),0,speed/60));
      interest=wander;
    }
    pullHead(interest);  
//    wander.x=constrain(wander.x,-WORLDBORDERBUFFER,width+WORLDBORDERBUFFER);
//    wander.y=constrain(wander.y,-WORLDBORDERBUFFER,height+WORLDBORDERBUFFER);    

  }
  void manageBody()
  {
    body[0].update();
    spinAng+=head.m3.v.mag()+2;    
    for(int i=1;i<body.length;i++)
    {
      body[i].update();    
      body[i].head=getAng(body[i].p,body[i-1].p);          
    }  
  }
  void pullHead()
  {}
  void pullHead(vec p)
  {
    vec dummy=new vec(p);
    
    vec hd=new vec(head.p,dummy);  
    hd.mul(-.6);
    sfSingle(tail.m3,new mass(tail.p.x+hd.x,tail.p.y+hd.y),15,.3+speed/150);    
    hd.mul(-.6);    
    sfSingle(belly.m3,new mass(belly.p.x+hd.x,belly.p.y+hd.y),5,.1);     
    
    head.head=getAng(body[1].p,head.p);
    vec lookAhead=newVec(head.p,head.head,250*s);
    noFill();
//    ellipse(lookAhead,25);        
//    lookAhead.add(springForce(new mass(lookAhead),new mass(dummy),0,.7));
    sfSingle(head.m3,new mass(dummy),0,.7);
         
  }
}






//-----------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------









class segment
{
  mass m1;           //physics handler
  mass m2;
  mass m3;
  vec p;             //current position
  float head;        //orientation
  float distance;    //distance two masses are kept
  float s;           //scale
  float sd;          //scale default

  float sinWave=0;
  boolean superSegment=false;
  segment(vec p,float s,float ang)
  {
    head=ang;      
    m3=new mass(p.x,p.y);        
    this.p=new vec(p);    
    this.s=sd=s;
    distance=120*s;     
    setMasses();
  }  
  void setMasses()
  {
    m1=new mass(newVec(m3.p,head-60,distance*.6));    
    m2=new mass(newVec(m3.p,head+60,distance*.6));   

       
  }
  void update()
  { 
  
    m1.fluidFlow(abs((1-s)*(1-s)*(1-s)));
    m1.dampScalar(1-FRICTION);      
    
    m2.fluidFlow(abs((1-s)*(1-s)*(1-s)));            
    m2.dampScalar(1-FRICTION);
        
    m3.affectField(0.01*(1+s)*(1+s)*(1+s)*(1+s));    
    m3.dampScalar(1-FRICTION);
    
    m1.update();        
    m2.update();        
    m3.update();    
    
                       
    p=midPoint(m1.p,m2.p);

    
    sinWave+=.02;
  }

  void draw()
  {
    noFill();
    pushMatrix();
    translate(p.x,p.y);
    rotate(radians(90-head));
    scale(s);
    int r=int(25*s);
    stroke(255-230);    
    image(segBase,origin,r);
    stroke(255-120);
//    if(tester)
      image(segDetail,origin,r);
    popMatrix();
  }
  void drawHead(float ang)
  {  
    int r=int(25*s);      
    noFill();
    pushMatrix();
    translate(p.x,p.y);
    rotate(radians(90-head));
    scale(s);
    stroke(255-230);    
    image(headBase,origin,r+1);    
    stroke(255-120);
    image(headDetail1,origin,r);
    stroke(255-230);    
    image(headDetail2,nv(0,-84),r);    
    vec spinP=nv(0,-108);
    translate(spinP.x,spinP.y);
    rotate(radians(ang));
    stroke(255-190+sin(radians(ang))*40);
    image(spinner,origin,r);
    popMatrix();
  }  
  void drawSuper()
  {
    noFill();
    pushMatrix();
    translate(p.x,p.y);
    rotate(radians(90-head));
    scale(s);
    int r=int(25*s);
    if(s>.1)
    {    
      stroke(295-240*s);
      image(segDetail2,origin,r);        
    }
    
    stroke(255-120);
    image(segDetail,origin,r);
    
    stroke(255-230);    
    image(segBase,origin,r);

    if(s>.1)
    {
      stroke(255-160);        
      float es=25*sin(sinWave+s*5);
      ellipse(-73,45,es,es);
      ellipse(73,45,es,es);    
    }
    popMatrix();  
  }
  void drawSuperHead(float ang)
  {
    int r=int(25*s);      
    noFill();
    pushMatrix();
    translate(p.x,p.y);
    rotate(radians(90-head));
    scale(s);
    stroke(295-240*s);
    image(headDetail3,nv(0,0),r);        

    stroke(255-230);    
    image(headDetail2,nv(0,-84),r);    

    stroke(255-120);
    image(headDetail1,origin,r);


    stroke(255-230);        
    image(headBase,origin,r+1);    

    stroke(255-160);        
    float es=25*sin(sinWave+s*5);
    ellipse(-73,45,es,es);
    ellipse(73,45,es,es);        
    
    vec spinP=nv(0,-108);
    translate(spinP.x,spinP.y);
    rotate(radians(ang));
    stroke(255-190+sin(radians(ang))*40);
    image(spinner,origin,r);
    
    popMatrix();  
  }
}