FlockBod flockBod;

class FlockBod {
  ArrayList boids3; // An arraylist for all the boids3

  FlockBod() {
    boids3 = new ArrayList(); // Initialize the arraylist
  }

  void run() {
    for (int i = 0; i < boids3.size(); i++) {
      Boid3 b = (Boid3) boids3.get(i);  
      b.run(boids3);  // Passing the entire list of boids3 to each boid individually
    }
  }

  void addBoid3(Boid3 b) {
    boids3.add(b);
  }

}


class Boid3 {

  Vector3Dbod loc;
  Vector3Dbod vel;
  Vector3Dbod acc;
  float r;
  float maxforce;    // Maximum steering force
  float maxspeed;    // Maximum speed

  Boid3(Vector3Dbod l, float ms, float mf) {
    acc = new Vector3Dbod(0,0);
    vel = new Vector3Dbod(random(-1,1),random(-1,1));
    loc = l.copy();
    r = 30.0f;    // size of boids3
    maxspeed = ms;
    maxforce = mf;
  }
  
  void run(ArrayList boids3) {
    flockBod(boids3);
    update();
    borders();
    render();
  }

  // We accumulate a new acceleration each time based on three rules
  void flockBod(ArrayList boids3) {
    Vector3Dbod sep = separate(boids3);   // Separation
    Vector3Dbod ali = align(boids3);      // Alignment
    Vector3Dbod coh = cohesion(boids3);   // Cohesion
    // Arbitrarily weight these forces
    sep.mult(0.1f);  // higher the number more they separate
    ali.mult(10.05f);  // higher the number the more likely to align with each other
    coh.mult(0.01f);  // higher the number the tighter they clump
    // Add the force vectors to acceleration
    acc.add(sep);
    acc.add(ali);
    acc.add(coh);
  }
  
  // Method to update location
  void update() {
    // Update velocity
    vel.add(acc);
    // Limit speed
    vel.limit(maxspeed);
    loc.add(vel);
    // Reset accelertion to 0 each cycle
    acc.setXYZ(0,0,0);
  }

  void seek(Vector3Dbod target) {
    acc.add(steer(target,false));
  }
 
  void arrive(Vector3Dbod target) {
    acc.add(steer(target,true));
  }

  // A method that calculates a steering vector towards a target
  // Takes a second argument, if true, it slows down as it approaches the target
  Vector3Dbod steer(Vector3Dbod target, boolean slowdown) {
    Vector3Dbod steer;  // The steering vector
    Vector3Dbod desired = target.sub(target,loc);  // A vector pointing from the location to the target
    float d = desired.magnitude(); // Distance from the target is the magnitude of the vector
    // If the distance is greater than 0, calc steering (otherwise return zero vector)
    if (d > 0) {
      // Normalize desired
      desired.normalize();
      // Two options for desired vector magnitude (1 -- based on distance, 2 -- maxspeed)
      if ((slowdown) && (d < 100.0f)) desired.mult(maxspeed*(d/100.0f)); // This damping is somewhat arbitrary
      else desired.mult(maxspeed);
      // Steering = Desired minus Velocity
      steer = target.sub(desired,vel);
      steer.limit(maxforce);  // Limit to maximum steering force
    } else {
      steer = new Vector3Dbod(0,0);
    }
    return steer;
  }
  
  void render() {
    // Draw a triangle rotated in the direction of velocity
    float theta = vel.heading2D() + radians(90);
    
    fill(255,100,100);  // fill colour of boids3
    stroke(170, 50, 50);  // stroke colour of the boids3  
    strokeWeight(16);
    pushMatrix();
    translate(loc.x,loc.y);
    rotate(theta); 
    beginShape();
    vertex(0, -r);
    vertex(-r+20, r-10);
    vertex(r, r);
    vertex(r+3, -r+3);
    endShape(CLOSE);
        
/*    beginShape(TRIANGLE);
    vertex(0, -r*2);
    vertex(-r, r*2);
    vertex(r, r*2);
    endShape();
 */   
    popMatrix();
  }
  
  // Wraparound
  void borders() {
    if (loc.x < -r) loc.x = width+r;
    if (loc.y < -r) loc.y = height+r;
    if (loc.x > width+r) loc.x = -r;
    if (loc.y > height+r) loc.y = -r;
  }

  // Separation
  // Method checks for nearby boids3 and steers away
  Vector3Dbod separate (ArrayList boids3) {
    float desiredseparation = 25.0f;
    Vector3Dbod sum = new Vector3Dbod(0,0,0);
    int count = 0;
    // For every boid in the system, check if it's too close
    for (int i = 0 ; i < boids3.size(); i++) {
      Boid3 other = (Boid3) boids3.get(i);
      float d = loc.distance(loc,other.loc);
      // If the distance is greater than 0 and less than an arbitrary amount (0 when you are yourself)
      if ((d > 0) && (d < desiredseparation)) {
        // Calculate vector pointing away from neighbor
        Vector3Dbod diff = loc.sub(loc,other.loc);
        diff.normalize();
        diff.div(d);        // Weight by distance
        sum.add(diff);
        count++;            // Keep track of how many
      }
    }
    // Average -- divide by how many
    if (count > 0) {
      sum.div((float)count);
    }
    return sum;
  }
  
  // Alignment
  // For every nearby boid in the system, calculate the average velocity
  Vector3Dbod align (ArrayList boids3) {
    float neighbordist = 50.0f;
    Vector3Dbod sum = new Vector3Dbod(0,0,0);
    int count = 0;
    for (int i = 0 ; i < boids3.size(); i++) {
      Boid3 other = (Boid3) boids3.get(i);
      float d = loc.distance(loc,other.loc);
      if ((d > 0) && (d < neighbordist)) {
        sum.add(other.vel);
        count++;
      }
    }
    if (count > 0) {
      sum.div((float)count);
      sum.limit(maxforce);
    }
    return sum;
  }

  // Cohesion
  // For the average location (i.e. center) of all nearby boids3, calculate steering vector towards that location
  Vector3Dbod cohesion (ArrayList boids3) {
    float neighbordist = 50.0f;
    Vector3Dbod sum = new Vector3Dbod(0,0,0);   // Start with empty vector to accumulate all locations
    int count = 0;
    for (int i = 0 ; i < boids3.size(); i++) {
      Boid3 other = (Boid3) boids3.get(i);
      float d = loc.distance(loc,other.loc);
      if ((d > 0) && (d < neighbordist)) {
        sum.add(other.loc); // Add location
        count++;
      }
    }
    if (count > 0) {
      sum.div((float)count);
      return steer(sum,false);  // Steer towards the location
    }
    return sum;
  }
}

// Simple Vector3Dbod Class 

static class Vector3Dbod {
  float x;
  float y;
  float z;

  Vector3Dbod(float x_, float y_, float z_) {
    x = x_; y = y_; z = z_;
  }

  Vector3Dbod(float x_, float y_) {
    x = x_; y = y_; z = 0f;
  }
  
  Vector3Dbod() {
    x = 0f; y = 0f; z = 0f;
  }

  void setX(float x_) {
    x = x_;
  }

  void setY(float y_) {
    y = y_;
  }

  void setZ(float z_) {
    z = z_;
  }
  
  void setXY(float x_, float y_) {
    x = x_;
    y = y_;
  }
  
  void setXYZ(float x_, float y_, float z_) {
    x = x_;
    y = y_;
    z = z_;
  }

  void setXYZ(Vector3Dbod v) {
    x = v.x;
    y = v.y;
    z = v.z;
  }
  
  float magnitude() {
    return (float) Math.sqrt(x*x + y*y + z*z);
  }

  Vector3Dbod copy() {
    return new Vector3Dbod(x,y,z);
  }

  Vector3Dbod copy(Vector3Dbod v) {
    return new Vector3Dbod(v.x, v.y,v.z);
  }
  
  void add(Vector3Dbod v) {
    x += v.x;
    y += v.y;
    z += v.z;
  }

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

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

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

  void normalize() {
    float m = magnitude();
    if (m > 0) {
       div(m);
    }
  }

  void limit(float max) {
    if (magnitude() > max) {
      normalize();
      mult(max);
    }
  }

  float heading2D() {
    float angle = (float) Math.atan2(-y, x);
    return -1*angle;
  }

  Vector3Dbod add(Vector3Dbod v1, Vector3Dbod v2) {
    Vector3Dbod v = new Vector3Dbod(v1.x + v2.x,v1.y + v2.y, v1.z + v2.z);
    return v;
  }

  Vector3Dbod sub(Vector3Dbod v1, Vector3Dbod v2) {
    Vector3Dbod v = new Vector3Dbod(v1.x - v2.x,v1.y - v2.y,v1.z - v2.z);
    return v;
  }

  Vector3Dbod div(Vector3Dbod v1, float n) {
    Vector3Dbod v = new Vector3Dbod(v1.x/n,v1.y/n,v1.z/n);
    return v;
  }

  Vector3Dbod mult(Vector3Dbod v1, float n) {
    Vector3Dbod v = new Vector3Dbod(v1.x*n,v1.y*n,v1.z*n);
    return v;
  }

  float distance (Vector3Dbod v1, Vector3Dbod v2) {
    float dx = v1.x - v2.x;
    float dy = v1.y - v2.y;
    float dz = v1.z - v2.z;
    return (float) Math.sqrt(dx*dx + dy*dy + dz*dz);
  }

}