class flotsam extends creature
{
  mass body[];
  mass center;
  float s;
  float press;
  float sinWave;
  boolean ccw;
  flotsam(penStroke ps)
  {
    type=10;
    ps.statistics();
    press=ps.totalPress/ps.totalLength/2000;
    if(ps.points.length<=1)
    {
      killed=true;
      return;
    }
    s=constrain(ps.totalLength/800,0.02,2);
    body=bodyShape(ps);
    center=new mass(centerOfMass(body));
    for(int i=0;i<body.length;i++)
    {
      for(int s=i+1;s<body.length;s++)
      {
        if(random(100)>(85+(this.s*7)+body.length/100))
          body[i].connectSpringTo(body[s],.1);
      }
    }
    for(int i=1;i<body.length;i++)
    {
      body[i].connectSpringTo(center,.1);
      body[i].connectSpringTo(body[i-1],.2);
    }    
    body[body.length-1].connectSpringTo(body[0],.2);
    sinWave=random(100);
    int midpoint=round(body.length/2.0);
    if(CCW(body[0].p,body[midpoint].p,body[body.length-1].p)==-1)
    {
      ccw=true;
    }
    else
      ccw=false;
    if(creationInfo)
    {
      println("Creature Flotsam created...");
      println("  size: "+s);      
      println("  leaf body segments: "+body.length);
      if(ccw)
        println("  direction: counterclockwise");
      else
        println("  direction: clockwise");
    }
  }
  void update()
  {  
    if(killed)
      return;  
    p=center.p;
    m=center;
    center.update();
    float sm=.5;
    center.fluidFlow(abs((1-sm)*(1-sm)*(1-sm)));            
    center.dampScalar(1-FRICTION);
    center.affectField(0.002*(1+s)*(1+s)*(1+s)*(1+s));                      
    center.p=constrain(center.p,WORLDBORDERBUFFER);    
    for(int i=0;i<body.length;i++)
    {
      body[i].update();
      body[i].fluidFlow(abs((1-sm)*(1-sm)*(1-sm)));        
      body[i].dampScalar(1-FRICTION);      
      body[i].p=constrain(body[i].p,WORLDBORDERBUFFER);
      if(ccw)
      {
        float ang=getAng(center.p,body[i].p)+90;      
        vec vf=newVec(ang,.1/(constrain(s,1,s)));
        body[i].v.add(vf);
      }
      else
      {
        float ang=getAng(center.p,body[i].p)-90;      
        vec vf=newVec(ang,.1/(constrain(s,1,s)));
        body[i].v.add(vf);      
      }
    }
    float mult=-1;
    if(ccw)
      mult=1;
    sinWave+=mult*(s/100+random(.001));
    
    eatMush();
  }
  
  void eatMush()
  {
    for(int i=0;i<clist.length;i++)
    {
      if(clist[i]!=this&&clist[i].type==1&&clist[i]!=null)
      {
        if(p==null)
          println("rawr?");
        float distance=dist(center.p,clist[i].p);
        if(distance<100*s)
        {
          if(distance<50*s)
          {
            clist[i].killed=true;
          }
          vec vf=new vec(clist[i].p,center.p);
          if(clist[i].killed)
            vf.mul(.008*s);          
          else
            vf.mul(.005+(press*s));
          if(clist[i].m!=null)
            clist[i].m.v.add(vf);
          clist[i].runAwayFrom=this;
          if(clist[i].tail!=null)
          {
            for(int f=0;f<clist[i].tail.length;f++)
            {
              if(clist[i].tail[f]!=null)
                clist[i].tail[f].v.add(vf);
            }
          }
        }
      }
    }
  }
  
  
  void draw()
  {
    noFill();
//    drawMasses(body);
    stroke(255-100);
    if(displayUI)
      drawMasses(body);
//    drawFloraCurve(body);  
    int amount=int(30*s);
    for(int i=0;i<amount;i++)
    {
      float si=float(i);
      if(si==0)
        si=0.001;
      vec t=findPoint(body,si/amount);
      float ang=getAng(center.p,t);

      beginShape();
      vertex(t.x,t.y);
      stroke(255,0);
      vertex(center.p.x,center.p.y);
      endShape();
//      line(t,center.p);
      stroke(255-170+20*sin(radians(ang)));      
//      stroke(255-180+dist(center.p,t));        
      pushMatrix();
      translate(t);      
      scale(.1+press+constrain(sin(sinWave+i*s/5.0)*s*.2,-.05,.3));      
      rotate(radians(90-ang));      
      image(flotsamWing,origin,2);
      popMatrix();      
    }
/*    
    for(int i=0;i<body.length-1;i++)
    {
      vec t;
      float ang=0;
      pushMatrix();
      if(i==0)
      {
        t=midPoint(body[body.length-1].p,body[1].p);
//        ang=getAng(body[body.length-1].p,body[1].p)-90;    

        ang=getAng(t,center.p);        
      }
      else
      if(i==body.length-1)
      {
        t=midPoint(body[i-1].p,body[0].p);
//        ang=getAng(body[i-1].p,body[0].p)-90;    

        ang=getAng(t,center.p);                
      }
      else
      {
        t=midPoint(body[i-1].p,body[i+1].p);
//        ang=getAng(body[i-1].p,body[i+1].p)-90;    
        
        ang=getAng(t,center.p);
      }
      t.disp(ang,-constrain(40*s,0,80));
      translate(t);      
      scale(.2*s);
      rotate(radians(180-ang+90));      
      image(flotsamWing,origin,2);
      popMatrix();
    }*/
  }
}

class flora extends creature
{
  mass body[];
  vec bodyVec[];
  mass total[];
  vec intersect;
  penStroke ps;
  int ip1=0;
  int ip2=0;
  flora(penStroke ps)
  {
    this.ps=ps;
    intersect=findIntersectionPoint(ps);
    ip1=findIntersectionFirst(ps)+1;
    ip2=findIntersectionSecond(ps)+1;
//    penStroke simp=simplify(ps);
    total=new mass[ps.points.length];
    for(int i=0;i<total.length;i++)
    {
      total[i]=new mass(ps.points[i].p);
    }
    int bodySize=ip2-ip1;
    bodyVec=new vec[bodySize+1];
    bodyVec[0]=new vec(intersect);
    for(int i=1;i<bodyVec.length;i++)
    {
      bodyVec[i]=new vec(ps.points[i+ip1-1].p);
    }
    penStroke simpBody=new penStroke();
    for(int i=0;i<bodyVec.length;i++)
    {
      simpBody.points=append(simpBody.points,new drawPoint(bodyVec[i],0));
    }
    simpBody.statistics();
    simpBody=simplify(simpBody);
    body=new mass[simpBody.points.length];
    if(body.length<20)
    {
      body=new mass[bodyVec.length];
      for(int i=0;i<body.length;i++)
      {
        body[i]=new mass(bodyVec[i]);
      }  
    }
    else
    {
      for(int i=0;i<body.length;i++)
      {
        body[i]=new mass(simpBody.points[i].p);
      }  
    }
  }
  void draw()
  {
    stroke(180);
    curveDetail(3);
    beginShape();
    curveVertex(body[0].p);
    for(int i=0;i<body.length;i++)
    {
      curveVertex(body[i].p);
    }
    endShape();
  
//    code to display mass primitive
/*
    stroke(120);
    for(int i=0;i<body.length;i++)
    {
      stroke(constrain(50+i*3,0,255));    
      ellipse(body[i].p,5);
      if(i>0)
        line(body[i].p,body[i-1].p);
    }      
  
  */
  
//    stroke(220,0,0);
//    ellipse(intersect,12);

    /* code to test intersection process   
    stroke(120);
    for(int i=0;i<total.length;i++)
    {
      stroke(constrain(50+i*3,0,255));    
      if(i==ip1)
        stroke(0,220,0);
      if(i==ip2)
        stroke(0,0,220);
//      ellipse(total[i].p,5);
//      if(i>0)
//        line(total[i].p,total[i-1].p);
    }*/
  }
}













/*class flora extends creature
{
  mass center;
  mass tail[];
  mass body[];
  mass root;
  boolean useTail=false;
  float s;
  float floraSize;
  float floraColor;
  float averageLength;
  float heading=0;
  int ip;
  
  penStroke floraStroke;
  flora child[];
  flora(penStroke ps)
  {
    type=10;
    s=ps.totalLength/1000;
    floraSize=1;
    floraColor=1;
    penStroke dt=simplify(ps);
    floraStroke=dt;
    int intersectAt=findIntersection(dt);
    ip=intersectAt;
    ip=constrain(ip,0,ip);
    int diff=dt.points.length-intersectAt;    
    body=new mass[diff-2];        
    for(int i=0;i<body.length;i++)
    {
      body[i]=new mass(dt.points[ip+i].p);
    }
    
    
    center=new mass(centerOfMass(body));           
    averageLength=dt.averageLength*2;
    root=body[0];
    heading=getAng(center.p,root.p);
    buildSprings(floraSize);
//    makeBabies();

    if(creationInfo)
    {
      println("Creature Flora created...");
      println("  size: "+s);      
      println("  leaf body segments: "+body.length);
    }
  }
  flora(flora f,mass m,float rot)
  {
    type=10;
    s=f.s*.7;
    floraSize=f.floraSize*.7;

//    floraStroke=f.floraStroke;
//    int intersectAt=findIntersection(floraStroke);
//    ip=intersectAt;
//    ip=constrain(ip,0,ip);
//    int diff=floraStroke.points.length-intersectAt;    
//    body=new mass[diff-2];        
//    for(int i=0;i<body.length;i++)
//    {
//      body[i]=new mass(floraStroke.points[ip+i].p);
//    }
    
    body=new mass[f.body.length];    
    for(int i=0;i<body.length;i++)
    {
      body[i]=new mass(f.body[i]);      
      body[i].clearSprings();      
    }
    body=rotateMasses(body,m.p,rot);
    center=new mass(centerOfMass(body));        
    root=body[0];    
    heading=getAng(center.p,root.p);    
    buildSprings(floraSize);
    root.connectSpringTo(m,0,.3);
//    makeBabies();
  }  
  void makeBabies()
  {
    if(s<.3)
      return;
    int numChild=constrain(int(floraSize*body.length/4),0,8);
    child=new flora[numChild];    
    if(child.length==0)
    {
      child=null;
      return;
    }
    float ang=random(360);
    for(int i=0;i<child.length;i++)
    {
      int index=int(random(1,body.length-1));
      vec temp=midPoint(body[index-1].p,body[index+1].p);        
//      ang=180+heading+getAng(body[index].p,temp);

      ang+=(360.0/child.length)+random(-20,20);
      child[i]=new flora(this,root,ang);
    }
  }
  void buildSprings(float k)
  {
    k=constrain(k,0,1);
    for(int i=1;i<body.length;i++)
    {
//      body[i].connectSpringTo(center,dist(body[i].p,center.p)*k,.3*k);
        body[i].connectSpringTo(body[i-1],dist(body[i].p,body[i-1].p)*k,.3*k);
    }
  }
  void update()
  {
    m=center;
    p=m.p;
    center.update();
    center.fluidFlow(abs((1-s)*(1-s)*(1-s)));            
    center.dampScalar(1-FRICTION);      
    center.p=constrain(center.p,WORLDBORDERBUFFER);          
    for(int i=0;i<body.length;i++)
    {
      body[i].update();
      body[i].fluidFlow(abs((1-s)*(1-s)*(1-s)));            
      body[i].dampScalar(1-FRICTION);      
      body[i].p=constrain(body[i].p,WORLDBORDERBUFFER);      
    }
    if(child!=null)
    {
      for(int i=0;i<child.length;i++)
      {
        child[i].update();
      }
    }
  }
  void draw()
  {
    curveDetail(4);

//    stroke(40);
//    for(int i=0;i<innards.length;i++)
    {
//      line(innards[i],center.p);
    }
    

        
    beginShape(LINE_STRIP);
    stroke(80);
    curveVertex(body[0].p.x,body[0].p.y);    
    for(int i=0;i<body.length;i++)
      curveVertex(body[i].p.x,body[i].p.y);
    curveVertex(body[0].p.x,body[0].p.y);        
    curveVertex(body[0].p.x,body[0].p.y);       
    endShape();

    if(child!=null)
    {
      for(int i=0;i<child.length;i++)
      {
        child[i].draw();
      }
    }     
  } 
}

*/