int n= 3000;
boolean alive= true;
fly[] a= new fly[n];
queen queen= new queen();

void setup(){
  size(250, 250);
colorMode(HSB);
  for(int i= 0; i<n; i++){
    a[i]= new fly();
  }
}

void loop(){
  background(125, 80, 255);
  translate(queen.xpos, queen.ypos);

  for(int i= 0; i<n; i++){
    a[i].update();
  }
  if(alive== true){
    queen.update();
  }
}

class queen{

  float xpos, ypos, xnext, ynext;

  queen(){
    xpos= random(50, 200);
    ypos= random(50, 200);

  }

  void update(){

    xnext= random(-0.7, 0.7);
    ynext= random(-0.7, 0.7);

    
      xpos+= xnext;
      ypos+= ynext;
    
push();
smooth();
noStroke();
    rotateY(0.5*xnext);
    rotateX(0.5*ynext);
    push();
    translate(0, -4, 0);
    fill(255);
    scale(35, 2, 3);
    sphere(1);
    translate(0, 0, -3);
    sphere(1);
    pop();
    fill(0);
    translate(0, 0, -2);
    sphere(7);
    fill(40, 255, 255);
    translate(0, 0, 2);
    sphere(7);
    fill(100);
    translate(0, -1, 2);
    sphere(5);
    fill(0);
    translate(-4, -1, 2);
    sphere(4); 
    translate(8, 0, 0);
    sphere(4); 
    push();
    translate(-4, 8, 0);
    scale(1, 5, 1);
    sphere(1);
    pop();
    pop();
    

    if(mousePressed && mouseX>xpos-5 && mouseX<xpos+5 && mouseY>ypos-5 && mouseY<ypos+5){
      alive= false;
    }

  }
}

class fly{

  Vec2D f= new Vec2D(random(-60, 70), 0);
  float l, xnext, ynext;

  fly(){
    f.rotate(random(-PI, PI));
    l= f.getlength();
  }

  void update(){
    xnext= random(-1, 1);
    ynext= random(-1, 1);

    if(queen.xpos+f.x+xnext<width && queen.xpos+f.x+xnext>0){
      f.x+= xnext;
         if(queen.ypos+f.y+ynext<height && queen.ypos+f.y+ynext>0){
      f.y+= ynext;
       if(f.getlength()>1.2*l && alive==true) {
    f.mult(0.99);
    }
    
    if(mousePressed){
   Vec2D mouse= new Vec2D(mouseX-queen.xpos, mouseY-queen.ypos);
   mouse.sub(f);
   mouse.div(10);
   f.sub(mouse);
    }

    }
    else{
      f.y-= ynext;
    }
    }
    else{
      f.x-= xnext;
    }
    
 
    
   
    stroke(100);
    point(f.x, f.y);
  }
}

// General vector class for 2D vectors
class Vec2D {
  float x,y;

  Vec2D(float _x,float _y) {
    x=_x;
    y=_y;
  }

  Vec2D(Vec2D v) {
    x=v.x;
    y=v.y;
  }

  void set(float _x,float _y) {
    x=_x;
    y=_y;
  }

  void set(Vec2D v) {
    x=v.x;
    y=v.y;
  }

  void add(float _x,float _y) {
    x+=_x;
    y+=_y;
  }

  void add(Vec2D v) {
    x+=v.x;
    y+=v.y;
  }

  void sub(float _x,float _y) {
    x-=_x;
    y-=_y;
  }

  void sub(Vec2D v) {
    x-=v.x;
    y-=v.y;
  }

  void mult(float m) {
    x*=m;
    y*=m;
  }

  void div(float m) {
    x/=m;
    y/=m;
  }

  float getlength() {
    return sqrt(x*x+y*y);
  }

  float angle() {
    return atan2(y,x);
  }

  void normalise() {
    float l=getlength();
    if(l!=0) {
      x/=l;
      y/=l;
    }
  }

  Vec2D tangent() {
    return new Vec2D(-y,x);
  }

  void rotate(float val) {
    // Due to float not being precise enough, double is used for the calculations
    double cosval=Math.cos(val);
    double sinval=Math.sin(val);
    double tmpx=x*cosval - y*sinval;
    double tmpy=x*sinval + y*cosval;

    x=(float)tmpx;
    y=(float)tmpy;
  }
}