a port of the Processing Visualization Language

Flocking

by Daniel Shiffman. An implementation of Craig Reynold's Boids program to simulate the flocking behavior of birds. Each boid steers itself based on rules of avoidance, alignment, and coherence. Click the mouse to add a new boid.

Original Processing.org Example: Flocking

// All Examples Written by Casey Reas and Ben Fry

// unless otherwise stated.

Flock flock;



void setup() {

  size(200,200);

  colorMode(RGB,255,255,255,100);

  flock = new Flock();

  // Add an initial set of boids into the system

  for (int i = 0; i < 50; i++) {

    flock.addBoid(new Boid(new Vector3D(width/2,height/2),2.0f,0.05f));

  }

  smooth();

}



void draw() {



  background(100);

  flock.run();

}



// Add a new boid into the System

void mousePressed() {

  flock.addBoid(new Boid(new Vector3D(mouseX,mouseY),2.0f,0.05f));

}



class Flock {

  ArrayList boids; // An arraylist for all the boids



  Flock() {

    boids = new ArrayList(); // Initialize the arraylist

  }



  void run() {

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

      Boid b = (Boid) boids.get(i);  

      b.run(boids);  // Passing the entire list of boids to each boid individually

    }

  }



  void addBoid(Boid b) {

    boids.add(b);

  }



}





class Boid {



  Vector3D loc;

  Vector3D vel;

  Vector3D acc;

  float r;

  float maxforce;    // Maximum steering force

  float maxspeed;    // Maximum speed



  Boid(Vector3D l, float ms, float mf) {

    acc = new Vector3D(0,0);

    vel = new Vector3D(random(-1,1),random(-1,1));

    loc = l.copy();

    r = 2.0f;

    maxspeed = ms;

    maxforce = mf;

  }

  

  void run(ArrayList boids) {

    flock(boids);

    update();

    borders();

    render();

  }



  // We accumulate a new acceleration each time based on three rules

  void flock(ArrayList boids) {

    Vector3D sep = separate(boids);   // Separation

    Vector3D ali = align(boids);      // Alignment

    Vector3D coh = cohesion(boids);   // Cohesion

    // Arbitrarily weight these forces

    sep.mult(2.0f);

    ali.mult(1.0f);

    coh.mult(1.0f);

    // 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(Vector3D target) {

    acc.add(steer(target,false));

  }

 

  void arrive(Vector3D 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

  Vector3D steer(Vector3D target, boolean slowdown) {

    Vector3D steer;  // The steering vector

    Vector3D 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 Vector3D(0,0);

    }

    return steer;

  }

  

  void render() {

    // Draw a triangle rotated in the direction of velocity

    float theta = vel.heading2D() + radians(90);

    fill(200);

    stroke(255);

    pushMatrix();

    translate(loc.x,loc.y);

    rotate(theta);

    beginShape(TRIANGLES);

    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 boids and steers away

  Vector3D separate (ArrayList boids) {

    float desiredseparation = 25.0f;

    Vector3D sum = new Vector3D(0,0,0);

    int count = 0;

    // For every boid in the system, check if it's too close

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

      Boid other = (Boid) boids.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

        Vector3D 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

  Vector3D align (ArrayList boids) {

    float neighbordist = 50.0f;

    Vector3D sum = new Vector3D(0,0,0);

    int count = 0;

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

      Boid other = (Boid) boids.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 boids, calculate steering vector towards that location

  Vector3D cohesion (ArrayList boids) {

    float neighbordist = 50.0f;

    Vector3D sum = new Vector3D(0,0,0);   // Start with empty vector to accumulate all locations

    int count = 0;

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

      Boid other = (Boid) boids.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 Vector3D Class 



static class Vector3D {

  float x;

  float y;

  float z;



  Vector3D(float x_, float y_, float z_) {

    x = x_; y = y_; z = z_;

  }



  Vector3D(float x_, float y_) {

    x = x_; y = y_; z = 0f;

  }

  

  Vector3D() {

    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(Vector3D v) {

    x = v.x;

    y = v.y;

    z = v.z;

  }

  

  float magnitude() {

    return (float) Math.sqrt(x*x + y*y + z*z);

  }



  Vector3D copy() {

    return new Vector3D(x,y,z);

  }



  Vector3D copy(Vector3D v) {

    return new Vector3D(v.x, v.y,v.z);

  }

  

  void add(Vector3D v) {

    x += v.x;

    y += v.y;

    z += v.z;

  }



  void sub(Vector3D 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;

  }



  Vector3D add(Vector3D v1, Vector3D v2) {

    Vector3D v = new Vector3D(v1.x + v2.x,v1.y + v2.y, v1.z + v2.z);

    return v;

  }



  Vector3D sub(Vector3D v1, Vector3D v2) {

    Vector3D v = new Vector3D(v1.x - v2.x,v1.y - v2.y,v1.z - v2.z);

    return v;

  }



  Vector3D div(Vector3D v1, float n) {

    Vector3D v = new Vector3D(v1.x/n,v1.y/n,v1.z/n);

    return v;

  }



  Vector3D mult(Vector3D v1, float n) {

    Vector3D v = new Vector3D(v1.x*n,v1.y*n,v1.z*n);

    return v;

  }



  float distance (Vector3D v1, Vector3D 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);

  }



}
Fork me on GitHub