/*
This game was created by Benjamin Nelson in 2006 and 2007 
 You are free to post it on your website and or play it and or make modifications,
 just always credit me for my work and let me know if you do anything cool with it.
 My email is bmnelson@gmail.com
 Let me know what you think.
 Benjie
 */


int startingLevel=0; //////////////////////starting Level!


// define constants for all monsters in the game
int HERO_RADIUS=30;
int WINGMAN_DISTANCE=70;
int BUNGER = 0;
int BIPPY = 1;
int SNAKE = 2;
int LAZOR =3;
int SUCKER=4;
int OCTOPUS=5;
int BUBBLE=6;
int BUBBLESLUG=7;
int SPACEBALL=8;
int GEKKO=9;
int CHICKEN=10;
int CEGG=11;
int STARFISH=12;
int LASERBALL=13;
int CRAWCANNON=14;
int SHIELD=15;
int BIPPO=16;
int TELLY=17;
int POPPER=18;
int SPACEBLOB=19;
int SPACEBLOBDOT=20;
int FINAL=21;
int maxMonsterTypes=35;
//global variable of the player
Hero h;
ArrayList monsters=new ArrayList();
ArrayList levels;
ArrayList DebrisArray=new ArrayList();
int DEBRIS_COUNT = 15;



int currentLevelNumber=startingLevel;
Level currentLevel;

PFont font; 
boolean invincible=false;//Cheating is bad!


void setup(){
  size(1000,600);//size of game
  font = loadFont("SWGothi-37.vlw"); 
  textMode(MODEL);
  framerate(30);
  smooth();//I find that I have to call this many times, especially after text. Processing bug?
  h = new Hero((float)width/2,(float)height/2); 
  ellipseMode(CENTER);

  colorMode(HSB);
  levels=makeLevels();//Make all the monsters
  currentLevel=(Level)levels.get(startingLevel);//and load first level


}
void draw(){
  if(frameCount%15==0){
    // println(framerate);
  }

  background(0);
  h.update();
  if(currentLevel.update()&&monsters.size()==0){//calling update on currentl level return a true if the level is empty
    // and also adds random monsters to the arraylist monsters if there are monsters left in the level que
    currentLevelNumber++;//Level complete! On to the next!
    currentLevel=(Level)levels.get(currentLevelNumber);
  }
  updateMonsters();
  
  //////PLAYER IS DEAD:///////////////
  if(h.dead){
   textFont(font, 48); 
      fill(255);
      text("Click to try Again", width/2-250, height/2);
     smooth(); 
   for(int i =0; i<DebrisArray.size(); i++){
     Ship s = (Ship)DebrisArray.get(i);
     s.update();

   }
  }
}
//This function returns a vector to a random position just outside the screen of the game
//It is mostly used for spawning monsters
Vector3D pointOutside(){
  Vector3D v=new Vector3D();
  if(random(1)>.5){
    if(random(1)>.5){
      v.setXY(-10,random(0,height));
    }
    else{
      v.setXY(width+10,random(0,height));
    }
  }
  else{
    if(random(1)>.5){
      v.setXY(random(0,width),-10);
    }
    else{
      v.setXY(random(0,width),height+10);
    }
  }
  return v;
}

//This runs each monster though one timestep
void updateMonsters(){
  for(int i=0; i<monsters.size(); i++){
    Goon s = (Goon)monsters.get(i);
    s.update();
  } 
}
void mousePressed(){/////reset all!
  if(h.dead){// but only if you are dead.
    h.dead=false;
    DebrisArray=new ArrayList();
    monsters=new ArrayList(); 
    levels=makeLevels();
    currentLevel=(Level)levels.get(currentLevelNumber);
    //currentLevelNumber=startingLevel; //This is especially mean. Don't do it. 
  }
}

//OMFG!!! CHEAT CODES!!
void keyReleased(){
  if(key=='p'){
    h.dead=true;
    currentLevelNumber++;
    mousePressed();
  }
  if(key=='o'){
    h.dead=true;
    currentLevelNumber--;
    mousePressed();
  }
  if(key=='i'){
    invincible=!invincible;
    h.dead=false;
  }
}
//This guy is invisable and unkillable, basically just makes it so there is a monster in the final level
//So you never get a crash from trying to go beyond the level vector
class UnkillableFinalBadGuy extends Goon{
  UnkillableFinalBadGuy(Vector3D p){
  }
  void update(){
  }
}

class Debris extends Ship{
  int counter=0;
  int lifespan = (int) random(10,25);
  int speed=15;
  Debris(Vector3D p){
   pos=p.copy();
   acc=new Vector3D();
   vel=new Vector3D(speed,random(0,TWO_PI),true);
  }
  void render(){
    counter++;
    if(counter>lifespan){
       DebrisArray.remove(this); 
    }
    if(frameCount%1==0){
   
    Vector3D p = pos.copy();
   p.x+=random(-10,10);
   p.y+=random(-10,10);
   Smoke s= new Smoke(p);
   DebrisArray.add(s);
    }
  }
}
class Smoke extends Ship{
  int counter =0;
  float growth=5.0;
  int maxSize=60;
  Smoke(Vector3D p){
   pos=p.copy();
   }
  void update(){
    counter+=growth;
    if(counter>maxSize){
       DebrisArray.remove(this);
    }
    noStroke();
    if(random(0,1)<.7){
    fill(255,0,255,255-255*counter/maxSize);
    }
    else{
      fill(random(5,25),255,255,255-255*counter/maxSize);
    }
    ellipse(pos.x,pos.y,counter,counter);
    }
  
}

//Class definition and behavior for all monsters and the player in SpaceGame:



class Popper extends Goon{//////////////////////////////     Popper       //////////////
int popperForce = 25000000;
  Vector3D destination;
  float moveK=.95;
  int counter=0;
  int repelCounter=0;
  int popTime=(int)random(50,200);
  int popRadius=350;
  float attackAngle=random(0,TWO_PI);
  Popper(Vector3D p){
    pos= p.copy();
    acc=new Vector3D();
    vel=new Vector3D();
    rad=17;
    type = POPPER;
    destination=new Vector3D(random(30,width-30),random(30,height-30));

  }

  void unique(){
    counter++;
    if(abs(pos.x-destination.x)<1&&abs(pos.y-destination.y)<1){

      if(counter>popTime){
        repelCounter++;
        //if(pos.distanceSquared2D(pos,h.pos)<popRadius*popRadius){
          Vector3D v=h.position();
          v.sub(pos);
          float distance=v.magnitudeSquared2D();
          v.normalize();
          v.mult(popperForce/distance);
          h.applyForce(v);
       // }
        int backrad=(int)random(25,45);
        fill(10,255,255);
        ellipse(pos.x,pos.y,backrad,backrad);
        drawCircles(1);
        drawCircles(75);
        drawCircles(100);
        drawCircles(200);
        drawCircles(300);  
        noStroke();
        if(repelCounter>17){
          repelCounter=0;
          counter=0;
          destination.setXY(random(30,width-30),random(30,height-30));
          attackAngle=random(0,TWO_PI);
        }
      }

    }
  }
  void drawCircles(int radius){
    int num=radius*radius/600;
    float deg=TWO_PI/num;
    float circleDiam=TWO_PI*radius/num;
    pushMatrix();
    translate(pos.x,pos.y);
    rotate(attackAngle);
    fill(10,255,10000/radius);
    ellipse(radius,0,circleDiam*3,circleDiam/2);
    ellipse(-radius,0,circleDiam*3,circleDiam/2);
    ellipse(0,radius,circleDiam/2,circleDiam*3);
    ellipse(0,-radius,circleDiam/2,circleDiam*3);
    
    for(int i=0; i<num; i++){
          rotate(deg);

          ellipse(radius,0,circleDiam,circleDiam);
      
    }
    popMatrix();
  }
  void movement(){
    pos.x=pos.x*moveK+destination.x*(1-moveK);
    pos.y=pos.y*moveK+destination.y*(1-moveK);
    angle=angle*.96+attackAngle*.04;
  }

  void render(){
    pushMatrix();
    noStroke();
    translate(pos.x,pos.y);
    rotate(angle);
    fill(190);
    ellipse(0,0,rad,rad);
    stroke(0);
    line(0,rad/2,0,-rad/2);
    line(-rad/2,0,rad/2,0);
    noStroke();
    fill(10,255,255*counter/popTime);
    ellipse(0,0,rad/2,rad/2);
    popMatrix();
  }
}
class Telly extends Goon{//////////////////////////////     Telly       ///////////////
  int warmup=0;
  int warmTime=20;
  int jumpDist=90;
  float attackAngle;



  Telly(Vector3D p){
    pos= p.copy();
    acc=new Vector3D();
    vel=new Vector3D();
    rad=25;
    type = TELLY;

  }

  void unique(){
    warmup++;
    if(warmup>warmTime){

      pos.x+=jumpDist*cos(angle);
      pos.y+=jumpDist*sin(angle);
      attackAngle=random(0,TWO_PI);
      if(pos.x<80||pos.x>width-80||pos.y<80||pos.y>height-80){
        Vector3D v=h.position();
        v.sub(pos);
        attackAngle=v.heading2D();
      }

      warmup=0; 
    }
  }
  void movement(){
    angle=angle*.8+attackAngle*.2;
  }

  void render(){
    pushMatrix();
    noStroke();
    translate(pos.x,pos.y);
    rotate(angle);
    fill(90,200,155);
    beginShape();
    vertex(rad/2,0);
    //curveVertex(0,0);
    vertex(-rad/2,-rad/2);
    vertex(0,0);
    vertex(-rad/2,rad/2);
    //curveVertex(0,0);
    // vertex(0,rad/2);
    endShape();
    fill(25,255,200);
    ellipse(-rad/2,0,rad/2,rad/2);
    fill(15,255,200);
    ellipse(-.85*rad,0,rad/4,rad/4);

    popMatrix();
  }
}
class Bippo extends Goon{//////////////////////////////                                    BIPPO                                  ///////////////
  int ACC=5;


  Bippo(Vector3D p){
    inBoss=false;
    pos= p.copy();
    acc=new Vector3D();
    vel=new Vector3D();
    rad=20;
    type = BIPPO;
  }
  // void checkWalls(){
  // if(pos.x<0||pos.x>width||pos.y<0||pos.y>height){
  //vel.setXYZ(0,0,0);
  //    }
  // }
  void unique(){
    Vector3D heroP=h.position();
    heroP.sub(pos);
    heroP.normalize();
    heroP.mult(.4);
    Vector3D damp=vel.copy();
    damp.mult(.01);
    heroP.sub(damp);
    acc=heroP;


  }
  void render(){
    pushMatrix();
    noStroke();


    translate(pos.x,pos.y);
    rotate(angle);
    fill(40,255,255);
    if(inBoss){
      fill(40,255,90);
    }
    ellipse(0,0,rad,rad);
    fill(15,255,200);
    if(inBoss){
      fill(15,255,80);
    }
    ellipse(-6,0,13,13);

    fill(0,255,255);
    if(inBoss){
      fill(0,255,80);
    }
    ellipse(-20,0,6,6);

    popMatrix();
  }
}
class Starfish extends Goon{   /////////////////////////////////   STARFISH             //////////////////////////////////////////////////////////////
  float speed=3;
  int arms=2;
  int growTime=95;
  int armLength=40;
  int maxArms=5;
  int counter=0;
  float spin=.05;
  Starfish(Vector3D p){
    pos= p.copy();
    acc=new Vector3D();
    vel=new Vector3D(speed,random(0,TWO_PI),true);
    rad=30;
    type = STARFISH;
    if(random(0,1)<.5){
      spin*=1;
    }
  }
  Starfish(Vector3D p, float a){
    pos= p.copy();
    acc=new Vector3D();
    vel=new Vector3D(speed,a,true);
    angle=a;
    rad=30;
    type = STARFISH;
  }
  void movement(){
    vel.add(acc);
    pos.add(vel);
    angle+=spin;
  }

  void unique(){
    counter++;
    if(counter==growTime){
      counter=0;
      arms++;
    }
    if(arms>maxArms){
      for(int i=0; i<maxArms; i++){
        Starfish s= new Starfish(pos,angle+TWO_PI*i/maxArms);
        monsters.add(s);
      }
      render();
      monsters.remove(this); 
    }
  }


  void render(){
    pushMatrix();
    noStroke();
    fill(20,150,250);
    translate(pos.x,pos.y);
    rotate(angle);
    ellipse(0,0,rad,rad);
    for(int i=0; i<arms;i++){
      beginShape();
      vertex(0,rad/2);
      if(i==arms-1){
        vertex(-armLength*counter/growTime,0);
      }
      else{
        vertex(-armLength,0);
      }
      vertex(0,-rad/2);
      endShape();
      rotate(TWO_PI/maxArms);
    }
    fill(10,150,190);
    ellipse(0,0,rad-5,rad-5);
    popMatrix();
  }

}
class Chicken extends Goon{////////////////////////////////CHICKEN///////////////////never used
  int speed = 3;
  int eggTimer=int(random(30,50));
  Chicken(Vector3D p){
    type = CHICKEN;
    pos=p.copy();
    vel=new Vector3D(speed,random(0,TWO_PI),true);
    acc=new Vector3D();
    rad=25;
  }
  void unique(){
    if(frameCount%eggTimer==0){
      Vector3D p = pos.copy();
      Bubble b= new Bubble(p,500);
      // monsters.add(b);
    }
  }
  void render(){
    translate(pos.x,pos.y);
    rotate(angle);
    noStroke();
    fill(180,170,190);
    ellipse(0,0,rad,rad);
  }
}
class Gekko extends Goon{/////////////////////////////////GEkko
  int speed = 2;
  float dampingFactor=.8;
  boolean left;
  int uniqueTail;
  Gekko(Vector3D p){
    type = GEKKO;
    uniqueTail=(int)random(0,40);
    pos= p.copy();
    vel=new Vector3D(speed,random(0,TWO_PI),true);
    acc=new Vector3D();
    rad=20;
    left=random(1)<.5;
  }
  void unique(){
    float correction=1.5;
    WingMan target;
    if(left){
      target=h.leftWingMan;
    }
    else{
      target=h.rightWingMan;
    }
    angle = atan2(target.pos.y-pos.y,target.pos.x-pos.x)-correction;
    noSmooth();
    stroke(140,255,150);
    line(pos.x,pos.y,target.pos.x,target.pos.y);
    noStroke();
    smooth();
    target.vel.mult(dampingFactor);
    Vector3D v =pos.copy();
    v.sub(target.pos);
    v.mult(.02);
    target.pos.add(v);

  }
  void movement(){
    vel.add(acc);
    pos.add(vel);

  }
  void render(){
    pushMatrix();
    translate(pos.x,pos.y);
    rotate(angle);
    fill(130,180,200);
    beginShape();
    curveVertex(0,12);
    curveVertex(0,12);
    curveVertex(-3,13);
    curveVertex(-1,15);
    curveVertex(-1,15);
    curveVertex(-6,12);
    curveVertex(-3,10);
    curveVertex(-3,10);
    curveVertex(-15,0);
    curveVertex(-5,-12);
    curveVertex(8*sin(TWO_PI*((frameCount+uniqueTail)%40)/40),-30);
    curveVertex(5,-12);
    curveVertex(15,0);
    curveVertex(3,10);
    curveVertex(3,10);
    curveVertex(6,12);
    curveVertex(1,15);
    curveVertex(1,15);
    curveVertex(3,13);
    curveVertex(0,12);

    endShape();
    fill(140,230,200);
    ellipse(-10,0,10,10);
    ellipse(10,0,10,10);
    fill(110,250,250);
    ellipse(-3,6,3,4);
    ellipse(3,6,3,4);
    ellipse(0,2,5,5);
    ellipse(0,-2,3,3);
    ellipse(0,-8,2,2);
    ellipse(-15,-(frameCount+uniqueTail)%5,5,5);
    ellipse(15,-(frameCount+uniqueTail)%5,5,5);


    popMatrix(); 
  }

}


class BubbleSlug extends Goon{ //////////////////////////////////////////////////////   BUBBLESLUG     ////////////////////////////////
  float speed = 8;
  float changeProbability=.04;
  float angleChange=.05;
  int turnDirection =1;


  int dropSpacing=20;
  int dropCounter=dropSpacing;

  BubbleSlug(Vector3D p){
    type = BUBBLESLUG;
    pos= p.copy();
    vel=new Vector3D(speed,random(0,TWO_PI),true);
    acc=new Vector3D();
    rad=20;

  }
  void dropBubble(){
    dropCounter-=speed;
    if(dropCounter<0){
      Bubble b = new Bubble(pos);
      monsters.add(b); 
      dropCounter=dropSpacing;
    }
  }
  void unique(){
    dropBubble(); 
    if(random(1)<changeProbability){
      turnDirection*=-1;
    }
    vel.setRTheta(speed,angle+angleChange*turnDirection);
  }
  void render(){
    pushMatrix();
    translate(pos.x,pos.y);
    fill(0,255,255);
    ellipse(0,0,rad,rad);
    popMatrix();
  }
}

class Bubble extends Bunger{                ///////////////////////////////////              BUBBLE                    /////////////////////
  int age=0;
  int maxAge=150;
  float rad=20;
  Bubble(Vector3D p,int mAge){
    super(p);
    maxAge=mAge;
    age=(int)random(maxAge/3);
    following=false;
    pos= p.copy();
    acc=new Vector3D();
    vel=new Vector3D();
  }
  Bubble(Vector3D p){

    super(p);
    age=(int)random(50);
    following=false;
    pos= p.copy();
    acc=new Vector3D();
    vel=new Vector3D();
  }
  void unique(){
    age++;
    if(age>maxAge){
      alive=false;
      monsters.remove(this);

    }
    rad=15.0-age*15.0/maxAge+5;
  }
  void render(){
    pushMatrix();
    translate(pos.x,pos.y);
    fill(130+age*125/maxAge,255,255-age);
    if(!alive){
      fill(255);
    }
    ellipse(0,0,rad,rad);
    popMatrix();
  }
}





/******************************************************LAZOR**********************************************************/
class Lazor extends Goon{
  Lazor partner;
  boolean ready;
  String uniqueName;
  int state;
  int ACC = 0;
  int DECC = 1;
  int SPINNING = 2;
  int SHOOTING = 3;
  int topSpeed=10;
  int ShootingTimer=0;
  int ShootingMaxTime=4;
  float changeProbabilityToSpin=.02;
  float changeProbabilityToMove=.1;
  float thrust=.3;
  float angleChange = .06;
  boolean partnered;
  int numberToCheck=10;
  Lazor(Vector3D p){
    uniqueName="bob"+random(1); //eveyone is named bob! How unique!
    state = 2;
    type = LAZOR;
    pos= p.copy();
    vel=new Vector3D();
    acc=new Vector3D(thrust,radians(45),true);
    angle=45;
    partnered=false;
    rad=25;
    ready=false;

  }

  void checkCollision(){
    if(h.hitWingMan(pos,rad)){
      monsters.remove(this);
      alive = false;
      if(partnered){
        partner.goodbye();
      }
    }
  }
  void unique(){
    if(!partnered){
      switch(state){

      case 0:

        if(random(1)<changeProbabilityToSpin||vel.magnitude()>topSpeed){
          acc.setRTheta(thrust,angle+PI);
          state++;


        }
        break;

      case 1://currently accellerating
        float speed = vel.magnitude();
        // pos.setXY(70,70);
        if(speed>topSpeed){//if going too fast, slow down! This is hacky. I should get more elegant...
          acc.setRTheta(thrust,angle+PI);
        }
        if(speed<.1){//if slowed down enough, start spinning or shooting
          acc.setXY(0,0);
          vel.setRTheta(.2,angle);
          state++;
          if(pos.x>0+30&&pos.y>0+30&&pos.x<width-30&&pos.y<height-30){
            for(int i=0;i<numberToCheck;i++){
              Goon g = (Goon)monsters.get((int)random(0,monsters.size()));
              if(g.type()==LAZOR){
                partner=(Lazor)g;
                if(partner.hello(this,uniqueName)){
                  partnered=true;
                }

                break;
              } 
            }
          }

        }

        break;

      case 2://currently spinning
        vel.setRTheta(.01,angle+angleChange);
        if(random(1)<changeProbabilityToMove){//if random go back to accellerating
          acc.setRTheta(thrust,angle);
          state=0;



        }
        break;

      default:
        println("dame");
        break;

      }
    }
    else{                                                                        ///WE HAVE A PARTNER   YEEEHAH!
      Vector3D pPos= partner.getPosition();
      float angleToPartner = atan2((pPos.y-pos.y),(pPos.x-pos.x));
      if(vel.magnitude()<1){
        vel.setRTheta(.01,angle);
        acc.setXY(0,0);
        if(abs(angle-angleToPartner)<angleChange){
          ready=true;//be ready!

          if(partner.ready()){
            stroke(0,255,255);
            line(pos.x,pos.y,pPos.x,pPos.y);
            float distance = sqrt(sq(pos.x-pPos.x)+sq(pos.y-pPos.y));
            checkAlongLine(pos,pPos,distance);
            if(ShootingTimer>ShootingMaxTime){
            ready=false;
            partnered=false;
            partner.goodbye();
            ShootingTimer=0;
            }
            ShootingTimer++;
          }

          //wait for partner to get ready
        }

        else{//turn the correct direction


          vel.setRTheta(.01,angle-angleChange);


        }
      }
      else{//if going too fast
        acc.setRTheta(thrust,angle+PI);
      }
    }

  }
  boolean ready(){
    return ready;
  }
  void goodbye(){
    ready=false;
    partnered=false;
  }
  boolean hello(Lazor l, String name){
    boolean b= (name!=uniqueName&&pos.x>0+30&&pos.y>0+30&&pos.x<width-30&&pos.y<height-30&&!partnered);
    if(b){
      partnered=true;
      partner =l;
    }
    return b;
  }

  void checkAlongLine(Vector3D p1,Vector3D p2,float distance){
    int circleFactor=15;
    Vector3D pm = p1.copy();
    pm.add(p2);
    pm.mult(.5);
    h.hitWingMan(pm,(int)distance/circleFactor);
    noStroke();
    fill(distance/circleFactor,255,255);
    ellipse(pm.x,pm.y,distance/circleFactor,distance/circleFactor);
    if(distance>12){
      checkAlongLine(p1,pm,distance/2);///recursion w00t!
      checkAlongLine(pm,p2,distance/2);
    }
  }

  void checkWalls(){
    if(pos.x<0){
      vel.x=abs(vel.x);
      if(state==1){ 
        acc.setRTheta(thrust,vel.heading2D()+PI);
      }
      else{
        acc.setRTheta(thrust,vel.heading2D());
      }
    } 
    if(pos.x>width){
      vel.x=-abs(vel.x); 
      if(state==1){ 
        acc.setRTheta(thrust,vel.heading2D());
      } 
      else{
        acc.setRTheta(thrust,vel.heading2D()+PI);
      }
    }
    if(pos.y<0){
      vel.y=abs(vel.y); 
      if(state==1){ 
        acc.setRTheta(thrust,vel.heading2D()+PI);
      }
      else{
        acc.setRTheta(thrust,vel.heading2D());
      }
    } 
    if(pos.y>height){
      vel.y=-abs(vel.y); 
      if(state==1){ 
        acc.setRTheta(thrust,vel.heading2D());
      }
      else{
        acc.setRTheta(thrust,vel.heading2D()+PI);
      }
    }

  }
  void render(){
    pushMatrix();
    noStroke();
    fill(150);
    translate(pos.x,pos.y);
    rotate(angle);
    ellipse(0,0,rad,rad);
    fill(0,255,150);
    if(partnered){
      fill(80,255,255);
      stroke(80,255,255);
      line(20,0,75,0);
    }
    noStroke();
    ellipse(-6,0,8,8);
    ellipse(2,0,6,6);
    ellipse(10,0,4,4);
    fill(0,255,255);
    ellipse(17,0,2,2);
    fill(0);
    pushMatrix();
    rotate(-.3);
    rect(-5,6,12,2);
    rotate(.6);
    rect(-5,-8,12,2);
    popMatrix();
    popMatrix();
  } 

}




class Snake extends Goon{   ///////////////////////////////////////////////        SNAKE             /////////////////////////////////////
  int startingSize =5;
  float speed = 5;
  float changeProbability=.04;
  float angleChange=.05;
  int turnDirection =1;
  float spacing = .85;
  ArrayList followers;
  Vector3D fPos;
  float eyeAngle=0;
  boolean started=false;

  Snake(Vector3D p){
    type = SNAKE;
    pos= p.copy();
    vel=new Vector3D(speed,random(0,TWO_PI),true);
    acc=new Vector3D();
    rad=40;
    followers = new ArrayList();

  }
  void unique(){
    if(!started){
      for(int i= 0;i<startingSize;i++){
        Vector3D p =pos.copy();
        Bunger g =new Bunger(p);
        monsters.add(g);
      }
      started=true; 
    }
    if(random(1)<changeProbability){
      turnDirection*=-1;
    }
    vel.setRTheta(speed,angle+angleChange*turnDirection);
    for(int i = monsters.size()-1; i>=0; i--){
      Goon g = (Goon) monsters.get(i);
      fPos=g.getPosition();
      float biteSize=2;
      if (g.type()==BUNGER&&fPos.x>pos.x-rad*biteSize&&fPos.x<pos.x+rad*biteSize&&fPos.y>pos.y-rad*biteSize&&fPos.y<pos.y+rad*biteSize&&!g.following()){
        // monsters.remove(g);
        followers.add(g); 
        g.setFollowing(true);
        fPos=g.getVelocity();
        fPos.setXY(0,0);
      }
    }
    if(followers.size()>0){
      followLeader(0,pos);
    }
  }

  void followLeader(int i, Vector3D target){
    Goon g = (Goon)followers.get(i);
    fPos=g.getPosition(); 
    fPos.setXY((fPos.x*spacing+target.x*(1-spacing)),(fPos.y*spacing+target.y*(1-spacing)));
    if(!g.alive()){
      followers.remove(g);
    }
    i++;
    // g.update();
    if(i<followers.size()){
      followLeader(i,fPos);
    }
  }

  void checkCollision(){
    if(h.hitWingMan(pos,rad)){
      monsters.remove(this);
      for(int i=0; i<followers.size(); i++){
        // monsters.add(followers.get(i));
        Bunger g = (Bunger)followers.get(i);
        fPos=g.getVelocity();
        fPos.setRTheta(speed,random(0,TWO_PI));
        g.setFollowing(false);

      } 
    }
  }

  void render(){
    pushMatrix();
    noStroke();
    fill(180,255,100);
    translate(pos.x,pos.y);
    rotate(angle);
    beginShape();
    vertex(rad/2,19);
    vertex(0,rad/2);//,rad/2,rad/2,-rad/2,rad/2);
    vertex(-rad/2,0);//,-rad/2,rad/2,-rad/2,-rad/2);
    vertex(0,-rad/2);//,rad/2,-rad/2,-rad/2,-rad/2);
    vertex(rad/2,-19);
    curveVertex(rad/2,-19);
    curveVertex(rad/2,-19);
    curveVertex(-7,0);
    curveVertex(rad/2,19);
    curveVertex(rad/2,19);
    vertex(rad/2,19);
    endShape();
    fill(255);
    pushMatrix();
    translate(rad/5,0);
    rotate(eyeAngle);
    ellipse(-rad/2.7,0,rad/5,rad/5);
    eyeAngle=constrain(eyeAngle-.1*turnDirection,-.9,.9);

    popMatrix();


    popMatrix();
  }
}

class Bippy extends Goon{//////////////////////////////                                    BIPPY                                  ///////////////
  int ACC=5;


  Bippy(Vector3D p){
    pos= p.copy();
    acc=new Vector3D();
    vel=new Vector3D();
    rad=20;
    type = BIPPY;
  }
  void unique(){
    Vector3D heroP=h.position();
    heroP.sub(pos);
    heroP.normalize();
    heroP.mult(5);
    vel=heroP;

  }
  void render(){
    pushMatrix();
    noStroke();
    fill(0,255,100);
    translate(pos.x,pos.y);
    rotate(angle);
    ellipse(0,0,rad,rad);
    fill(0,255,150);
    ellipse(-6,0,13,13);
    fill(50,255,255);
    ellipse(-20,0,6,6);

    popMatrix();
  }
}


class Bunger extends Goon{   /////////////////////////////////   BUNGER             //////////////////////////////////////////////////////////////
  int ACC=5;
  boolean following;


  Bunger(Vector3D p){
    inBoss=false;
    following=false;
    pos= p.copy();
    acc=new Vector3D();
    vel=new Vector3D(random(-ACC,ACC),random(-ACC,ACC));
    while(abs(vel.x)<.1||abs(vel.y)<.1){
      vel.setXY(random(-ACC,ACC),random(-ACC,ACC));
    }
    rad=20;
    type = BUNGER;
  }
  boolean following(){
    return following;
  }
  void setFollowing(boolean b){
    following=b;
  }


  void render(){
    pushMatrix();
    noStroke();
    fill(150,150,150);
    if(inBoss){
      fill(150,150,50);
    }
    translate(pos.x,pos.y);
    rotate(angle+(millis()%2000)*TWO_PI/2000);
    ellipse(0,0,rad,rad);
    fill(130,80,80);
    if(inBoss){
      fill(150,150,30);
    }
    ellipse(-rad/3,0,rad/2,rad/2);

    popMatrix();
  }

}




//The weapons of the hero
class WingMan extends Ship{///////////   *******************************     Wing Man ************************////////////////
  float  k=.06;
  float b =.1;
  WingMan(float x, float y){
    pos=new Vector3D(x,y);
    vel=new Vector3D();
    acc=new Vector3D(0,0);
    rad=7;
    angle=0;
    mass=1;


  }
  boolean hit(Vector3D qPos, int qRad){
    return(qPos.distanceSquared2D(qPos,pos)<qRad*qRad/4+rad*rad/4+300); 
  }
  void render(){

    pushMatrix();
    noStroke();
    fill(26,230,230);
    translate(pos.x,pos.y);
    rotate(angle);
    ellipse(0,0,rad,rad);
    stroke(255,0,255);
    line(-10,0,0,0);
    popMatrix();
  }
  void update(float tarX, float tarY){
    Vector3D f = new Vector3D(tarX-pos.x,tarY-pos.y);
    f.mult(k);
    applyForce(f);
    f=vel.copy();
    f.mult(-b);
    applyForce(f);
    movement();
    render();
  }
}
//user controlled character
class Hero extends Ship{ ////////////////////////////////////HERO/////////////////////////////////////
  public boolean dead;
  float  k=2;//.06;//spring constant to mouse
  float b =3;//.4;//damper to mouse
  public WingMan leftWingMan;
  public WingMan rightWingMan;
  Hero(float x, float y){
    pos=new Vector3D(x,y);
    vel=new Vector3D();
    acc=new Vector3D(0,0);
    rad=HERO_RADIUS;
    angle=0;
    mass=5;
    dead=false;
    leftWingMan=new WingMan(x-WINGMAN_DISTANCE,y);
    rightWingMan=new WingMan(x+WINGMAN_DISTANCE,y);


  }
  Vector3D position(){
    return(pos.copy());
  }
  boolean hitWingMan(Vector3D queryPos, int queryRad){//Checks for both bad guy being hit by wingman and player death
    if(!dead){ 
      float d=queryPos.distanceSquared2D(queryPos,pos);//distance to goon
      if(d<(rad*rad/2)+(queryRad*queryRad/4)){//////PLAYER DEATH!!!!!!
        for(int i =0; i< DEBRIS_COUNT; i++){
          Debris deb = new Debris(pos);
          DebrisArray.add(deb);  
        }
        dead = true; 
      }
      return(leftWingMan.hit(queryPos, queryRad)||rightWingMan.hit(queryPos, queryRad));//return (wingman hits goon)



    }
    else{
      return false; 
    }
  }
  void render(){

    pushMatrix();
    noStroke();
    fill(255);
    translate(pos.x,pos.y);
    rotate(angle);
    ellipse(0,0,rad,rad);

    fill(180,255,255);
    ellipse(10,0,10,10);
    popMatrix();

  }
  void update(){
    if(!dead||invincible){
      leftWingMan.update(pos.x+WINGMAN_DISTANCE*sin(angle),pos.y-WINGMAN_DISTANCE*cos(angle));
      rightWingMan.update(pos.x-WINGMAN_DISTANCE*sin(angle),pos.y+WINGMAN_DISTANCE*cos(angle));


      Vector3D f = new Vector3D(mouseX-pos.x,mouseY-pos.y);//define a vector to the mouse
      //and then have the hero attract to it
      f.mult(k);
      applyForce(f);
      f=vel.copy();
      f.mult(-b);
      applyForce(f);
      movement();
      render();
      Vector3D l = leftWingMan.pos.copy();
      Vector3D r = rightWingMan.pos.copy();
      l.sub(pos);
      r.sub(pos);

    }
  }
}



class Ship{                //////////////////SHIP///////////////////////////////
  Vector3D pos;
  Vector3D vel;
  Vector3D acc;
  float mass=1;
  int rad;
  float angle;

  Vector3D getPosition(){
    return pos;
  }
  Vector3D getVelocity(){
    return vel;
  }


  void update(){
    movement();
    render(); 
    //acc.setXYZ(0,0,0);
  }
  void movement(){
    vel.add(acc);
    pos.add(vel);
    angle=vel.heading2D();

  }
  void render(){
  }
  void applyForce(Vector3D f){
    f.div(mass);

    vel.add(f);
  }
}