// Soul by Anders Sandberg // largely based on Flock by Daniel Shiffman. import processing.pdf.*; Flock flock; PFont fontA; String[] lines; int nlines; int makePDF; float desiredseparation = 20.0; void setup() { size(640, 640); fontA = loadFont("Corbel-10.vlw"); textFont(fontA, 10); lines = loadStrings("text.txt"); nlines=lines.length; makePDF=0; flock = new Flock(); // Add an initial set of boids into the system for (int i = 0; i < 350; i++) { flock.addBoid(new Boid(new PVector(width/2+random(-2,2),height/2+random(-2,2)), 3.0, 0.05)); } smooth(); } void draw() { if (makePDF==1) { beginRecord(PDF, "frame-####.pdf"); } background(0); flock.run(); if (makePDF==1) { endRecord(); makePDF=0; } } // Add a new boid into the System void mousePressed() { flock.addBoid(new Boid(new PVector(mouseX,mouseY),2.0f,0.05f)); //makePDF = 1; desiredseparation = random(10,30); } // The Boid class class Boid { PVector loc; PVector vel; PVector acc; float r; float maxforce; // Maximum steering force float maxspeed; // Maximum speed int cindex; int col; Boid(PVector l, float ms, float mf) { acc = new PVector(0,0); vel = new PVector(random(-1,1),random(-1,1)); cindex = int(random(nlines)); col=int(random(0,255)); loc = l.get(); r = 2.0; 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) { PVector sep = separate(boids); // Separation PVector ali = align(boids); // Alignment PVector coh = cohesion(boids); // Cohesion // Arbitrarily weight these forces sep.mult(1.5); ali.mult(1.0); coh.mult(1.0); // 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.mult(0); } void seek(PVector target) { acc.add(steer(target,false)); } void arrive(PVector 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 PVector steer(PVector target, boolean slowdown) { PVector steer; // The steering vector PVector desired = target.sub(target,loc); // A vector pointing from the location to the target float d = desired.mag(); // 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.0)) desired.mult(maxspeed*(d/100.0)); // 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 PVector(0,0); } return steer; } void render() { float theta = vel.heading2D() + PI/2; fill(128+128*vel.x/maxspeed,128+128*vel.y/maxspeed,col); col=constrain(col+2,0,255); pushMatrix(); translate(loc.x,loc.y); rotate(theta+PI/2); textFont(fontA); text(lines[cindex], 0, 0); 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 PVector separate (ArrayList boids) { PVector steer = new PVector(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 = PVector.dist(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 PVector diff = PVector.sub(loc,other.loc); diff.normalize(); diff.div(d); // Weight by distance steer.add(diff); count++; // Keep track of how many } } // Average -- divide by how many if (count > 0) { steer.div((float)count); col=constrain(col-count,0,255); } // As long as the vector is greater than 0 if (steer.mag() > 0) { // Implement Reynolds: Steering = Desired - Velocity steer.normalize(); steer.mult(maxspeed); steer.sub(vel); steer.limit(maxforce); } return steer; } // Alignment // For every nearby boid in the system, calculate the average velocity PVector align (ArrayList boids) { float neighbordist = 25.0; PVector steer = new PVector(0,0,0); int count = 0; for (int i = 0 ; i < boids.size(); i++) { Boid other = (Boid) boids.get(i); float d = PVector.dist(loc,other.loc); if ((d > 0) && (d < neighbordist)) { steer.add(other.vel); count++; } } if (count > 0) { steer.div((float)count); } // As long as the vector is greater than 0 if (steer.mag() > 0) { // Implement Reynolds: Steering = Desired - Velocity steer.normalize(); steer.mult(maxspeed); steer.sub(vel); steer.limit(maxforce); } return steer; } // Cohesion // For the average location (i.e. center) of all nearby boids, calculate steering vector towards that location PVector cohesion (ArrayList boids) { float neighbordist = 25.0; PVector sum = new PVector(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.dist(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; } } // The Flock (a list of Boid objects) 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); } }