Bullet Bouncer

you you=new you();

ArrayList<shot> s;

ArrayList<enemy> e;

boolean tog=true;

float mouseL=8;

​

void setup() {

  size(700,700);

  //fullScreen();

  s=new ArrayList<shot>();

  e=new ArrayList<enemy>();

  noCursor();

}

​

void draw() {

  background(0);

  showMouse();

  if (tog==true) {

    you.ang=atan2(mouseY-(height/2), mouseX-(width/2));

  } else {

    you.Sang=atan2(mouseY-(height/2), mouseX-(width/2));

  }

​

  you.show();

  for (int i=0; i<s.size(); i++) {

    s.get(i).show(i);

  }

  for (int i=0; i<e.size(); i++) {

    e.get(i).update(i);

  }

}

​

void showMouse(){

  stroke(255);

  strokeWeight(.5);

  line(mouseX,mouseY-mouseL,mouseX,mouseY+mouseL);

  line(mouseX-mouseL,mouseY,mouseX+mouseL,mouseY);

  noStroke();

}

​

void keyPressed() {

  /*

  if (keyCode==LEFT) {

   you.ang-=radians(5);

   }

   if (keyCode==RIGHT) {

   you.ang+=radians(5);

   }

   if (keyCode==UP || key=='a') {

   you.Sang-=radians(15);

   }

   if (keyCode==DOWN || key=='d') {

   you.Sang+=radians(15);

   }

   */

  if(key=='r'){

    you.sHP=2;

    you.HP=1;

  }

  if (key=='e') {

    e.add(new enemy());

  }

}

​

void mouseClicked() {

  if (mouseButton==RIGHT) {

    tog=(!tog);

  }

  if (mouseButton==LEFT) {   

    s.add(new shot(degrees(you.ang), you.pos));

  }

}

​

class you {

  PVector pos=new PVector();

  float ang, Sang, Sd=37;

  int sHP=2, HP=1;

  PVector base1;

  PVector base2;

  float baseLength;

  PVector[] coords;

​

  you() {

    pos=new PVector(width/2, height/2);

    ang=0;

    Sang=0;

  }

​

  void show() {

    base1=new PVector((width/2)+((Sd+5)*cos(Sang+radians(-Sd))), (height/2)+((Sd+5)*sin(Sang+radians(-Sd))));

    base2=new PVector((width/2)+((Sd+5)*cos(Sang+radians(Sd))), (height/2)+((Sd+5)*sin(Sang+radians(Sd))));

    createVrts();

​

    if (HP>0) {

      bounce();

      if (tog==false) {

        stroke(0, 125, 255);

        strokeWeight(2);

        line(base1.x, base1.y, base2.x, base2.y);

      } else {

        stroke(0, 75, 255);

        strokeWeight(1);

        line(base1.x, base1.y, base2.x, base2.y);

      }

​

      pushMatrix();

      translate((width/2), (height/2));

      rotate(ang);

      noStroke();

      if (tog==true) {

        strokeWeight(.75);

        stroke(200);

      }

      fill(150);

      triangle(17.5, 0, -12.5, -12.5, -12.5, 12.5);

      popMatrix();

​

      noStroke();

      fill(0, 100, 255, 25+(sHP*25));

      ellipse(width/2, height/2, 42, 42);

    } else {

      s=new ArrayList<shot>();

      e=new ArrayList<enemy>();

    }

  }

​

  void bounce() {

    PVector baseDelta = PVector.sub(base2, base1);

    baseDelta.normalize();

    PVector normal = new PVector(-baseDelta.y, baseDelta.x);

​

    for (int a=0; a<s.size(); a++) {

      s.get(a).loc.add(s.get(a).vel);

    }

​

    for (int a=0; a<s.size(); a++) {

      PVector incidence = PVector.mult(s.get(a).vel, -1);

      incidence.normalize();

      for (int i=0; i<coords.length; i++) {

        if (PVector.dist(s.get(a).loc, coords[i]) < s.get(a).S) {

          float dot = incidence.dot(normal);

          s.get(a).vel.set(2*normal.x*dot - incidence.x, 2*normal.y*dot - incidence.y, 0);

          s.get(a).vel.mult(s.get(a).mult);

        }

      }

    }

  }

​

  void createVrts() {

    baseLength = PVector.dist(base1, base2);

​

    // fill base top coordinate array

    coords = new PVector[ceil(baseLength)];

    for (int i=0; i<coords.length; i++) {

      coords[i] = new PVector();

      coords[i].x = base1.x + ((base2.x-base1.x)/baseLength)*i;

      coords[i].y = base1.y + ((base2.y-base1.y)/baseLength)*i;

    }

  }

}

​

class shot {

  PVector loc=new PVector(), vel=new PVector(0, 0);

  float ang=0, mult=8, mxB=10, S=7;

​

  shot(float a, PVector l) {

    ang=you.ang;

    vel=new PVector(mult*cos(ang), mult*sin(ang));

    loc=new PVector((width/2)+(16*cos(ang)), (height/2)+(16*sin(ang)));

  }

​

  void show(int i) {

​

    if ((loc.x<2 || loc.x>(width-2))) {

      vel.x*=(-1);

      ang*=(-1);

      if (mxB<=0) {

        s.remove(i);

      }

      mxB--;

    }

    if ((loc.y<2 || loc.y>(height-2))) {

      vel.y*=(-1);

      ang*=(-1);

      if (mxB<=0) {

        s.remove(i);

      }

      mxB--;

    }

​

    if (abs(dist(loc.x, loc.y, width/2, height/2))<=15) {

      s.remove(i);

      if (you.sHP>0) {

        you.sHP--;

      } else {

        you.HP--;

      }

    } else {    

      noStroke();

      fill(255, 0, 0);

      ellipse(loc.x, loc.y, S, S);

    }

  }

}

​

class enemy {

  PVector pos=new PVector(), vel=new PVector(),sPos;

  float mult=7, S=15;

  enemy() {

    int b=(int)random(1, 5);

​

    switch(b) {

    case 1:

      pos=new PVector(S, random(S, height-S));

      break;

    case 2:

      pos=new PVector(width-S, random(S, height-S));

      break;

    case 3:

      pos=new PVector(random(S, width-S), S);

      break;

    case 4:

      pos=new PVector(random(S, width-S), height-S);

      break;

    }

    sPos=pos;

    vel=PVector.fromAngle(atan2((height/2)-pos.y, (width/2)-pos.x)).normalize();

  }

​

  void update(int i) {

    pos.add(vel);

    if (dist(pos.x, pos.y, width/2, height/2)<=15) {

      e.remove(i);

      if (you.sHP>=0) {

        you.sHP--;

      } else {

        you.HP--;

      }

    }

    for (int j=0; j<s.size(); j++) {

      if (abs(s.get(j).loc.dist(pos))<((S/2)+(s.get(j).S/2))) {

        float angle = atan2(s.get(j).loc.y-pos.y, s.get(j).loc.x-pos.x);

        PVector tanPos=new PVector(pos.x - S * cos(angle), pos.y - S * sin(angle));

        VectorLine vLine = new VectorLine(tanPos, 10, 1);

        vLine.rotation = angle + HALF_PI;

        PVector lineStart = vLine.getOneEnd();

        PVector lineEnd = vLine.getOtherEnd();

        PVector normalToLine = new PVector(-(lineStart.y - lineEnd.y), lineStart.x - lineEnd.x);

        normalToLine.normalize();

        PVector incidence = new PVector(-s.get(j).vel.x, -s.get(j).vel.y);

        float incidenceDOTline = incidence.dot(normalToLine);

        PVector temp = PVector.mult(normalToLine, (2*incidenceDOTline));

        s.get(j).vel = PVector.sub(temp, incidence);

        e.remove(i);

        s.get(j).mxB--;

        if (s.get(j).mxB<0) {

          s.remove(j);

        }

      }

    }    

    fill(0, 255, 0);

    noStroke();

    ellipse(pos.x, pos.y, S, S);

  }

}

​

class VectorLine

{

  PVector position;

  float lineLength;

  float lineWidth;

  float rotation = 0;

  float rotationInc;

​

  VectorLine(PVector position, float lineLength, float lineWidth)

  {

    this.position = position;

    this.lineLength = lineLength;

    this.lineWidth = lineWidth;

  }

​

  float getRotation()

  {

    return rotation;

  }

​

  PVector getOneEnd()

  {

    float xbit = position.x - cos(rotation) * lineLength/2;

    float ybit = position.y - sin(rotation) * lineLength/2;

    return new PVector(xbit, ybit);

  }

  PVector getOtherEnd()

  {

    float xbit = position.x + cos(rotation) * lineLength/2;

    float ybit = position.y + sin(rotation) * lineLength/2;

    return new PVector(xbit, ybit);

  }

}