import java.applet.*; 
import java.awt.*; 
import java.awt.image.*; 
import java.awt.event.*; 
import java.io.*; 
import java.net.*; 
import java.text.*; 
import java.util.*; 
import java.util.zip.*; 

public class steering4 extends BApplet {
int total = 1000;
int totalEnemy = 50;
float xStage = 800;
float yStage = 500;
boolean clear = true;
boolean click = false;
boolean renderState = false;
Wanderer[] wand = new Wanderer[total];
Enemy[] enemy = new Enemy[totalEnemy];
void setup(){
  size(800,500);
  noBackground();
  fill(100);
  noStroke();
  rect(0,0,width,height);
  ellipseMode(CENTER_RADIUS);
  
  for (int i=0; i<total; i++){
    wand[i] = new Wanderer();
  }
  for (int k=0; k<totalEnemy; k++){
    enemy[k] = new Enemy();
  }
  
}

void loop(){
  drawState();
  for (int i=0; i<total; i++){
    wand[i].exist();
  }
  for (int k=0; k<totalEnemy; k++){
    enemy[k].exist();
  }
  if (mousePressed){
    click = true;
  }
}

void mouseReleased(){
  click = false;
}

void drawState(){
  if (clear){
    fill(100,100,100,15);
    noStroke();
    rect(0,0,width,height);
  }
}

void keyReleased () {
  if (key == 'r' && renderState){
    renderState = false;
  } else if (key == 'r' && !renderState){
    renderState = true;
  }
  
  if (key == ' ' && clear) { 
    clear = false;
  } else if (key == ' ' && !clear) {
    clear = true;
  }
}

class Wanderer {
  // radius of the object
  float radius = random(1.4f,2.6f);
  float gutter = 50;
  // x and y position variables
  float xPos = random(xStage);
  float yPos = random(yStage);
  float xOld = xPos;
  float yOld = yPos;
  
  // x and y velocity variables
  float xVel = random(-5,5);
  float yVel = random(-5,5);
  float totalVel;
  
  // speed variable
  float speed = 7;
  float angle;
  float newXPos = xPos;
  float newYPos = yPos;
  float intensity = 1;
  
  float xd,yd;
  // angle variable
  float theta = random(-PI,PI);
  float vectorTheta;
  
  Orbit orbit = new Orbit();
  
  Wanderer (){}
  
  void exist(){
    findDirection();
    orbit.findCenter(xPos, yPos, theta);
    //compareAngles();
    if (renderState){
      render();
    }
    move();
  }
  
  void findDirection(){
    newXPos -= (newXPos - orbit.xPos2) * (.2f + orbit.fear);
    newYPos -= (newYPos - orbit.yPos2) * (.2f + orbit.fear);
    xd = xPos - newXPos;
    yd = yPos - newYPos;
    theta = atan2(yd,xd);
    speed = 5 + orbit.speedChange;
    xVel = -cos(theta) * speed;
    yVel = -sin(theta) * speed;
  }


  void compareAngles(){
    System.out.println ("orbit radians = " + orbit.theta + " :: angle radians = " + theta);
  }

  void move(){
    xOld = xPos - xVel;
    yOld = yPos - yVel;
    xPos += xVel;
    yPos += yVel;
    
    if (xPos < -(gutter)){
      xPos = width + (gutter);
      xOld += width + (gutter*2);
      orbit.xPos2 += width + (gutter*2);
    } else if (xPos > width + (gutter)){
      xPos = -(gutter);
      xOld -= width + (gutter*2);
      orbit.xPos2 -= width + (gutter*2);
    }
    
    if (yPos < -(gutter)){
      yPos = height + (gutter);
      yOld += height + (gutter*2);
      orbit.yPos2 += height + (gutter*2);
    } else if (yPos > height + (gutter)){
      yPos = -(gutter);
      yOld -= height + (gutter*2);
      orbit.yPos2 -= height + (gutter*2);
    }
    
    // wandering object body
    fill(255,255,255,50);
    ellipse(xPos,yPos,radius*5,radius*5);
    fill(255);
    ellipse(xPos,yPos,radius*3,radius*3);
    fill(0,0,0,10);
    ellipse(xPos,yPos,radius*2,radius*2);

  }
  
  void render(){
    // center vector
    noFill();
    stroke(50);
    line(xPos, yPos, orbit.xPos, orbit.yPos);

    // orbital vector
    noFill();
    stroke(75);
    line(xPos, yPos, orbit.xPos2, orbit.yPos2);
    
    // speed vector
    noFill();
    stroke(150);
    line(xPos, yPos, xPos+xVel, yPos+yVel);
    
    // orbit center
    fill(100);
    noStroke();
    ellipse(orbit.xPos,orbit.yPos,2,2);
    
    // orbit circle
    noFill();
    stroke(51);
    ellipse(orbit.xPos, orbit.yPos, orbit.r, orbit.r);
    
    // orbit object
    fill(100);
    noStroke();
    ellipse(orbit.xPos2, orbit.yPos2, 2, 2);
    
    // orbit object rate
    noFill();
    stroke(51);
    ellipse(orbit.xPos2, orbit.yPos2, orbit.rate * 20, orbit.rate * 20);
    
    // orbit radius
    noFill();
    stroke(50);
    line(orbit.xPos, orbit.yPos, orbit.xPos2, orbit.yPos2);
  }
}

class Orbit {
  float r = 40;
  float d = r * sqrt(2);
  float xPos, yPos;
  float xVel, yVel;
  float xPos2 = random(width);
  float yPos2 = random(height);
  float rate = 0.6f;
  float sentTheta;
  float theta = random(-PI,PI);
  float speedChange;
  float[] xd = new float[totalEnemy];
  float[] yd = new float[totalEnemy];
  float[] dist = new float[totalEnemy];
  float fleeDistance = 100;
  float fear;

  void findCenter(float xp, float yp, float th){
    float xDelta = -cos(th) * d;
    float yDelta = -sin(th) * d;
    xPos = xp + xDelta;
    yPos = yp + yDelta;
    
    sentTheta = th;
    findDirection(sentTheta);
  }

  void findDirection(float th){
    for (int i=0; i<5; i++){
      xd[i] -= (xd[i] - (xPos2 - enemy[i].xPos)) * .4f;
      yd[i] -= (yd[i] - (yPos2 - enemy[i].yPos)) * .4f;
      dist[i] = sqrt(sq(xd[i]) + sq(yd[i]));
      
      if (dist[i] < fleeDistance){
        speedChange = (fleeDistance-dist[i])/50;
        fear = (fleeDistance-dist[i])/200;
        theta = atan2(yd[i],xd[i]) - PI;
      } else {
        speedChange = 0;
        fear = 0;
        theta += random(-rate,rate);
      }
    }
    
    if (theta < -PI){
      theta += TWO_PI;
    } else if (theta > PI){
      theta -= TWO_PI;
    }
    //System.out.println(theta);
    xVel = -cos(theta) * r;
    yVel = -sin(theta) * r;
    xPos2 = xPos + xVel;
    yPos2 = yPos + yVel;
  }
}







class Enemy {
  // radius of the object
  float radius = random(2.5f,6);
  
  // x and y position variables
  float xPos = xStage/2;
  float yPos = yStage/2;
  float xOld = xPos;
  float yOld = yPos;
  
  // x and y velocity variables
  float xVel = random(-5,5);
  float yVel = random(-5,5);
  float totalVel;
  
  // speed variable
  float speed = 4;
  float angle;
  float newXPos = xPos;
  float newYPos = yPos;
  float intensity = 1;
  float counter = 0;
  float incr = random(0.1f,0.4f);
  float xd,yd;
  // angle variable
  float theta = random(-PI,PI);
  float vectorTheta;
  
  EnemyOrbit orbit = new EnemyOrbit();
  
  Enemy (){}
  
  void exist(){
    findDirection();
    orbit.findCenter(xPos, yPos, theta);
    //compareAngles();
    if (renderState){
      render();
    }
    move();
  }
  
  void findDirection(){
    newXPos -= (newXPos - orbit.xPos2) * .2f;
    newYPos -= (newYPos - orbit.yPos2) * .2f;
    xd = xPos - newXPos;
    yd = yPos - newYPos;
    theta = atan2(yd,xd);

    xVel = -cos(theta) * speed;
    yVel = -sin(theta) * speed;
  }


  void compareAngles(){
    System.out.println ("orbit radians = " + orbit.theta + " :: angle radians = " + theta);
  }

  void move(){
    xOld = xPos - xVel*2;
    yOld = yPos - yVel*2;
    xPos += xVel;
    yPos += yVel;
    
    if (xPos < -150){
      xPos = width + 150;
      xOld += width + 300;
      orbit.xPos2 += width + 300;
    } else if (xPos > width + 150){
      xPos = -150;
      xOld -= width + 300;
      orbit.xPos2 -= width + 300;
    }
    
    if (yPos < -(radius*2)){
      yPos = height + 150;
      yOld += height + 300;
      orbit.yPos2 += height + 300;
    } else if (yPos > height + 150){
      yPos = -150;
      yOld -= height + 300;
      orbit.yPos2 -= height + 300;
    }
    radius += (sin(counter)/5);
    counter += incr;
    // wandering object body
    fill(255,255,255,50);
    ellipse(xPos,yPos,radius*5,radius*5);
    fill(0,0,0,15);
    ellipse(xPos-1,yPos-1,radius*4,radius*4);
    fill(200,200,200,50);
    ellipse(xPos+2,yPos+2,radius*2.5f,radius*2.5f);
    fill(180,180,180,50);
    ellipse(xPos,yPos,radius*2,radius*2);
    fill(255,255,255,50);
    ellipse(xPos,yPos,radius,radius);
  }
  
  void render(){
    // center vector
    noFill();
    stroke(50,0,0);
    line(xPos, yPos, orbit.xPos, orbit.yPos);

    // orbital vector
    noFill();
    stroke(75,0,0);
    line(xPos, yPos, orbit.xPos2, orbit.yPos2);
    
    // speed vector
    noFill();
    stroke(150,0,0);
    line(xPos, yPos, xPos+xVel, yPos+yVel);
    
    // orbit center
    fill(100,0,0);
    noStroke();
    ellipse(orbit.xPos,orbit.yPos,2,2);
    
    // orbit circle
    noFill();
    stroke(51,0,0);
    ellipse(orbit.xPos, orbit.yPos, orbit.r, orbit.r);
    
    // orbit object
    fill(100,0,0);
    noStroke();
    ellipse(orbit.xPos2, orbit.yPos2, 2, 2);
    
    // orbit object rate
    noFill();
    stroke(51,0,0);
    ellipse(orbit.xPos2, orbit.yPos2, orbit.rate * 20, orbit.rate * 20);
    
    // orbit radius
    noFill();
    stroke(50,0,0);
    line(orbit.xPos, orbit.yPos, orbit.xPos2, orbit.yPos2);
  }
}

class EnemyOrbit {
  float r = 40;
  float d = r * sqrt(2);
  float xPos, yPos;
  float xVel, yVel;
  float xPos2 = random(width);
  float yPos2 = random(height);
  float rate = 0.6f;
  float sentTheta, theta;
  
  float xd, yd;

  void findCenter(float xp, float yp, float th){
    float xDelta = -cos(th) * d;
    float yDelta = -sin(th) * d;
    xPos = xp + xDelta;
    yPos = yp + yDelta;
    
    sentTheta = th;
    findDirection(sentTheta);
  }

  void findDirection(float th){

    if (click){
      xd -= (xd - (xPos2 - mouseX)) * .2f;
      yd -= (yd - (yPos2 - mouseY)) * .2f;
      theta = atan2(yd,xd);
    } else {
      theta += random(-rate,rate);
    }
    
    if (theta < -PI){
      theta += TWO_PI;
    } else if (theta > PI){
      theta -= TWO_PI;
    }
    //System.out.println(theta);
    xVel = -cos(theta) * r;
    yVel = -sin(theta) * r;
    xPos2 = xPos + xVel;
    yPos2 = yPos + yVel;
  }
}

}