class mush extends creature
{
  vec headP;
  float headAng=0;
  float bodyAng=0;
  float s;
  float speed;
  mass head[]=new mass[3];
  mass body;
  
  vec interest;
  
  float sinWave=0;
  
  float decayTimer=1;
  mush(penStroke ps)
  {    
    type=1;
    sinWave=random(10);
    s=ps.totalLength/100;
    speed=constrain(ps.averageLength/5,0.1,2);
    head[0]=new mass(findDrawPoint(ps,.99).p);
    vec p=head[0].p;
    vec lp=findDrawPoint(ps,.9).p;
    float ang=getAng(lp,p);
    head[1]=new mass(newVec(p,ang+150,25*s));
    head[2]=new mass(newVec(p,ang-150,25*s));    
    head[0].connectSpringTo(head[1],.6);
    head[0].connectSpringTo(head[2],.6);    
    head[1].connectSpringTo(head[2],.6); 
    
    headP=midPoint(head[1].p,head[2].p);
    
    body=new mass(newVec(p,ang+180,40*s));
    body.connectSpringTo(head[1],.9);
    body.connectSpringTo(head[2],.9);    
    body.connectSpringTo(head[0],.8);        
    
    int tailSegs=int(round(ps.totalLength/5));     
    tail=new mass[tailSegs];
    for(int i=0;i<tailSegs;i++)
    {
      vec ts=findDrawPoint(ps,float(i)/tailSegs).p;
      tail[i]=new mass(ts);
      if(i>0)      
        tail[i].connectSpringTo(tail[i-1],.8);
      if(i>1)
        tail[i].connectSpringTo(tail[i-2],.7);      
    }
    tail[0].connectSpringTo(body,0,.8);
    p=new vec(head[0].p);
    m=head[0];    
    wanderAngle=wanderAngleDest=ang;
    headAng=getAng(headP,head[0].p);    
    interest=headP;      
    if(creationInfo)
    {
      println("Creature Mush created...");  
      println("  size: "+s);
      println("  speed: "+speed);
      println("  tail segments: "+tailSegs);    
    }    
  }
  void update()
  {
    m=head[0];  
    if(!killed)
    {
      sinWave-=s/7;
      behavior();  
      
      pullHead(interest,.1);    
    }
    else
    {
      if(decayTimer>0)
        decayTimer-=.005;
    }
    if(decayTimer>0)
      body();    
    p=new vec(headP);
  }
  
  float flockRadius=40;
  creature flockList[];
  int maxFlockList=10;
  void flock()
  {

    flockList=new creature[0];
    for(int i=0;i<clist.length;i++)
    {
      if((clist[i].type==type||clist[i].type==5)&&clist[i].killed==false&&clist[i]!=this)
        if(dist(clist[i].p,headP)<flockRadius)
          flockList=append(flockList,clist[i]);
      if(flockList.length>maxFlockList)
        break;
    }
    if(flockList.length==0)
    {
      wander(.5*speed);
      return;
    }
    else
    {
      vec c=new vec();
      vec avgVel=new vec();
      vec keep=new vec();
      for(int i=0;i<flockList.length;i++)
      {
        c.add(flockList[i].p);
        if(dist(flockList[i].p,headP)<7)
          head[0].v.add(new vec(flockList[i].p,headP,.1+.01*flockList.length));  
//        avgVel.add(flockList[i].m.v);
        
        sfSingle(head[0],flockList[i].m,10+random(-1,1),random(.05,.2));
      }
      c.div(flockList.length);
//      avgVel.div(flockList.length);
//      vec vf=new vec(headP,c);

//      vf.mul(constrain(float(flockList.length)*.02*speed,.01,.1));
//      avgVel.mul(.3);
//      keep.mul(.02*speed);
      
//      head[0].v.add(vf);
//      head[0].v.add(avgVel);
      wander(.6*speed);      

//      head[0].v.add(keep);            
      
    }
  }
  float wanderAngle;
  float wanderAngleDest;
  void wander(float k)
  {
    wanderAngleDest+=(wanderAngle-wanderAngleDest)/10;
    wanderAngle+=random(-25,25);
    vec loc=newVec(headP,headAng,70*s);
    vec wanderP=newVec(loc,wanderAngleDest,25);
    vec vf=new vec(headP,wanderP);
    vf.mul(k);
    vec dest=new vec(headP);    
    dest.add(vf);
    dest=constrain(dest,WORLDBORDERBUFFER);         
//    head[0].v.add(vf);
    pullHead(dest,.7);
//    stroke(255);
//    ellipse(loc,50);
//    ellipse(wanderP,5);
  }
  
  creature localCreature[];
  float interestDistance=200;
  boolean useFlock=true;
  void behavior()
  {
    if(random(100)>99)
      useFlock=toggle(useFlock);  
    float returnBuffer=20;
    if(headP.x>width-returnBuffer||headP.x<returnBuffer||headP.y>height-returnBuffer||headP.y<returnBuffer)
    {
/*      vec targ=nv(width/2+random(-400,400),height/2+random(-400,400));  
      vec delta=new vec(headP,targ);
      vec returnVec=newVec(headP,delta.ang(),delta.mag()*.5);
//      returnVec.mul(0.1);
      interest=returnVec;
      headAng=returnVec.ang()+random(-30,30);        */
      wander(.8);
      return;
    }
    if(runAwayFrom!=null)
    {
      vec delta=new vec(runAwayFrom.p,headP);
      float d=delta.mag();
      if(d>200)
      {
        runAwayFrom=null;
        return;
      }            
      if(d==0)
        d=0.0001;
      vec vf=newVec(360-delta.ang()+random(-30,30),170*s);
      vec targ=new vec(headP);
      targ.add(vf);
      interest=targ;
      headAng=delta.ang()+random(-30,30);

      return;
    }  
    localCreature=new creature[0];
    for(int i=0;i<clist.length;i++)
    {
      if(clist[i].type!=type&&clist[i].type!=2&&clist[i].type!=10&&clist[i]!=this)
        if(dist(clist[i].p,headP)<interestDistance)
          localCreature=append(localCreature,clist[i]);
    }  
    if(interest==null&&localCreature.length>0&&random(100)>99)
      interest=localCreature[int(random(localCreature.length))].p;
      
    if(useFlock)
    {
      interest=null;
      flock();
      return;
    }
    
    if(dist(interest,headP)>interestDistance||interest==null)
    {
      flock();
      return;
    }    
      
    
    return;
      
//    if(dist(interest,headP)>interestDistance||interest==null||useFlock)
//      flock();
//    else
//      pullHead(interest,.1);

  }
  
  void pullHead(vec dp,float k)
  {
    if(dp==null)
      return;
    sfSingle(head[0],new mass(dp),5,k);
  }
  
  void body()
  {
    for(int i=0;i<head.length;i++)
    {
      head[i].update();
      head[i].fluidFlow(abs((1-s)*(1-s)*(1-s)));            
      head[i].dampScalar(1-FRICTION);      
      head[i].p=constrain(head[i].p,WORLDBORDERBUFFER);
    }
    body.update();
    body.fluidFlow(abs((1-s)*(1-s)*(1-s)));            
    body.dampScalar(1-FRICTION);         
    body.p=constrain(body.p,WORLDBORDERBUFFER);     
    for(int i=0;i<tail.length;i++)
    {
      tail[i].update();
      tail[i].fluidFlow(abs((1-s)*(1-s)*(1-s)));            
      tail[i].dampScalar(1-FRICTION);          
      tail[i].p=constrain(tail[i].p,WORLDBORDERBUFFER);      
    }
    headP=midPoint(head[1].p,head[2].p);
    headAng=getAng(headP,head[0].p);        
    bodyAng=getAng(body.p,headP);  
  }
  
  void draw()
  {
    if(decayTimer<=0)
      return;
    noFill();
    pushMatrix();
    stroke(255-210*decayTimer);    
    translate(headP.x,headP.y);
    rotate(radians(90-headAng));
    scale(s/4);    
    image(mushHeadBase,origin,2);
    popMatrix();
    
    pushMatrix();
    stroke(255-210*decayTimer);    
    translate(body.p.x,body.p.y);
    rotate(radians(90-bodyAng));
    scale(s/4);    
    image(mushBodyBase,origin,2);
    popMatrix();  
    
    stroke(255-120*decayTimer);
    ellipse(headP,5);    
    ellipse(body.p,5);
    
    stroke(255-220*decayTimer);
    for(int i=0;i<tail.length;i++)
    {      
      ellipse(tail[i].p,-1.4*sin(sinWave+i)+.5*(tail.length-i));
    }  
  }
}