class Octopus extends Goon{//          ********* ********* ********* ********* *********        OCTOPUS          *********            ////
  int legCount=8;
  int angerSpeed=25;
  ArrayList legs;
  float rotationCorrection=0;
  boolean alreadyJumped;
  int angerCounter=10;
  Octopus(Vector3D p){
    legs = new ArrayList(); 
    pos= p.copy();
    acc=new Vector3D(0,0);
    vel=new Vector3D();
    rad=40;
    mass=20000;
    type = OCTOPUS;
    for(int i=0; i<legCount;i++){

      Vector3D pl = new Vector3D(rad,legAngle(i),true);
      pl.add(pos);
      Sucker l = new Sucker(pl,this,20,0,this);
      l.setCurly(legCurl());
      l.setFirst();
      legs.add(l);
    }


  }
  float RotationAngle(){
    return ( float)(millis()%100000)/100000*TWO_PI+rotationCorrection;
  }
  float legAngle(int i){
    return TWO_PI/legCount*i+rotationCorrection;
  }
  float legCurl(){
    return random(-.4,.4); 
  }
  void render(){
    // pushMatrix();
    //  translate(pos.x,pos.y);
    //  fill(255);
    //  noStroke();
    //  ellipse(0,0,rad,rad);
    //  popMatrix(); 
  }
  void retaliate(){
    angerCounter+=int(random(1,3));
    if(!alreadyJumped){
      //Vector3D dir = h.getPosition().copy();
      //dir.sub(pos);
      //Vector3D m = new Vector3D(random(10,25),dir.heading2D(),true);
      //dir.normalize();
      //dir.mult(.4);
      //pos.add(dir);
      rotationCorrection+=random(-PI/4,PI/4);
      alreadyJumped = true;
    }
  }
  void unique(){
    alreadyJumped=false;
    
    if(angerCounter>0){
      vel=h.pos.copy();
      vel.sub(pos);
      vel.normalize();
      vel.mult(angerSpeed);
      angerCounter-=1;
    }
    else{
      vel.setXY(0,0);
    }
    if(random(1)<.03){
      alreadyJumped=true;
      Vector3D m = new Vector3D(random(10,60),random(0,TWO_PI),true);
      pos.add(m);
      rotationCorrection+=random(-PI/2,PI/2);
      if(pos.x<0){
        pos.x+=30;
      } 
      if(pos.x>width){
        pos.x-=30; 
      } 
      if(pos.y<0){
        pos.y+=30;

      } 
      if(pos.y>height){
        pos.y-=30; 
      }
    } 
  }
  void replaceRoot(Sucker newRoot, Sucker oldRoot,boolean kill){
    // println("replace Called");
    if(kill){
      legs.remove(oldRoot);
      println("kill Leg");
    }
    else{
      for(int i=0; i<legs.size(); i++){

        if(legs.get(i)==oldRoot){
          Sucker s = (Sucker)legs.get(i);
          s=newRoot;
          s.setFirst();
        }
      }
    }
    if(legs.size()==0){
      monsters.remove(this);
    }
  }

  void update(){
    movement();
    render();
    unique();
    for(int i =0; i<legs.size(); i++){
      Sucker l =(Sucker)legs.get(i);
      l.update(legAngle(i));
      Vector3D f;
      f= l.getPosition();
      f.x=pos.x;
      f.y=pos.y;
      if(random(1)<.01){
        l.setCurly(legCurl());
      }
    }
  }      
}

class Sucker extends Goon{ //          ********* ********* ********* ********* *********        SUCKER          *********            ////
  float parentDistance=1.2;
  float k=.9;
  float b=.4;
  float curlyness = 1.04;
  float rad;
  Sucker child;
  Goon parent;
  int sThreshHold=4;
  float sRatio=.89;
  boolean last;
  boolean first=false;
  float ang;
  Octopus oct;
  Sucker(Vector3D p,Goon par,float s,float a,Octopus o){
    // println("new sucker born every day");
    oct=o;
    parent =par;
    pos= p.copy();
    acc=new Vector3D(0,0);
    vel=new Vector3D();
    rad=s;
    mass=s/10;
    type = SUCKER;
    ang=a;
    if(s>sThreshHold){
      Vector3D c=new Vector3D(s,a,true);
      c.add(pos);
      child=new Sucker(c,this,s*sRatio,a,o);
      last = false;
    }
    else{
      last = true;
    }
  }
  void setFirst(){
    first =true;
  }
  void unique(){
    if(!last){
      Vector3D targetPoint=new Vector3D(rad*parentDistance,ang,true);
      targetPoint.add(pos);
      Vector3D cPos = child.getPosition();
      targetPoint.sub(cPos);
      targetPoint.mult(k);
      child.applyForce(targetPoint);  
    }

    vel.mult(b);

  }

  void setCurly(float c){
    curlyness=c;
    if(!last){
      child.setCurly(c);
    }
  }
  void checkCollision(){
    if(true||!first||last){
      if(h.hitWingMan(pos,(int)rad*2)){
         if(!first){
        oct.retaliate();
         }
        if(last){
          parent.setLast();
        }
        parent.adoptGrandkid(child,last);
        if(first){
          if(!last){
            child.setFirst();
          }
          // println(last);
          oct.replaceRoot(child,this,last); 
        }


      }
    }
  }



  void setLast(){
    last=true;
  }
  void adoptGrandkid(Sucker c, boolean la){
    child = c;
    if(!la){//if the dying sucker was not last then it is not a null child he is giving...
      c.setParent(this);
    }
  }
  void setParent(Goon g){
    parent = g;
  }

  void update(float a){
    //println("suck'er face?");
    ang=a;
    checkCollision();
    unique();
    movement();
    render();
    if(!last){
      child.update(a+curlyness);
    }
  }
  void movement(){
    vel.add(acc);
    pos.add(vel);
    // angle=vel.heading2D();//don't use it, so no need to calculate it.

  }
  void render(){
    pushMatrix();
    translate(pos.x,pos.y);
    fill(255);
    noStroke();
    Vector3D cPos;
    if(!last){
      cPos = child.getPosition();
    }
    else{
      cPos = parent.getPosition();
    }
    Vector3D v = cPos.copy();
    v.sub(pos);

    rotate(v.heading2D());
    ellipse(0,rad/2,rad,rad);
    ellipse(0,-rad/2,rad,rad);
    // fill(0);
    //  ellipse(rad/10,rad/2,.8*rad,.8*rad);
    //  ellipse(rad/10,-rad/2,.8*rad,.8*rad);
    popMatrix(); 
  }
}