/** 
 * Some experiments with Boids. 
 * Nick Selvaggio
 * Based on pseudocode from http://www.vergenet.net/~conrad/boids/pseudocode.html
 * 1.05.10
 **/

//a collection of palettes. I am using http://www.colourlovers.com/ 
color[] blues = {#00C5CC, #7CFFF4, #74E4FF, #BEFFEF, #A1F1FF, #FF0000, #FC0000}; 
color[] light = {#D8EBE0, #BADEDD, #C9BAA1}; 
color[] smlBlue = {#00C5CC}; 
color[] blacks = {#000000};
color[] reds = {#FF0000, #F60000}; 
color[] pie_crust = {#310015, #1C0B12, #C4B482, #0D0207, #17070E}; 
color[] nothing_changes = {#70074B, #110240, #FF0000, #FFD000}; 
color[] classic_holiday = {#5F0606, #DA1717, #FFF5D6, #035F0B, #013A06}; 

color[] palette = blues; 

int t; 

ArrayList boids; 
int numBoids = 50;

//multiplers. 
int m1; 


//lets set this sketch up. 
void setup() { 
  size(940,209, P2D);
  frameRate(20);  
  background(255); 
  
  t=0;       //start time at 0. 
  
  m1 = 1; 
  
  createUniverse(); 
}

//------------------------------------
void createUniverse() {
  
  createBoids();       //our initialize_positions routine. 
}

//------------------------------------
//Keep it moving... 
void draw() { 
  fill(0, 5); 
  noStroke();
  rect(0, 0, width, height); 
  //background(0); 
  
  //keep flowing out boids every 100 units of time. 
  if(t > 100) { 
     createUniverse(); 
     t = 0;  
  }
  else { 
    drawBoids();
    t++;
  } 
}


void createBoids() {
  boids = new ArrayList(); 
  Particle p; 

  for(int i = 0; i<numBoids; i++) {
    p = new Particle(new PVector(-50+random(-40,40),height/2+random(-10,10)));
    //p.loc = new PVector(20,20);    
    boids.add(p);   
  }
}


void drawBoids() {
   Particle p; 
   
   for(int i = 0; i<numBoids; i++) {     
    p = (Particle) boids.get(i);
    
    //calc each vector from a set of rules. The first three are core the Reynolds boid algorithm. 
    PVector v1 = rule1(p); 
    PVector v2 = rule2(p);
    PVector v3 = rule3(p);
    
    PVector v4 = boundBoid(p);
    PVector v5 = tendtoPlace(p);  
   
    //weight the influence of each rule with a simple multipler.   
    v1.mult(m1);  
    
    p.vel.add(v1); 
    p.vel.add(v2); 
    p.vel.add(v3); 
    //p.vel.add(v4);  
    p.vel.add(v5); 
    
    
    p.vel.x = constrain(p.vel.x, -10, 10); 
    p.vel.y = constrain(p.vel.y, -5, 5);
    
   /*
    println("Velocity X: " + p.vel.x); 
    println("Velocity Y: " + p.vel.y);  
   */ 
    
    p.loc.add(p.vel);
  
    p.render(); 
  }  
}

/******************************************
/* Boid Rules 
 ******************************************/ 
 
/**
 * calculate the percieved center of mass and move pj 1% closer to it. 
 **/ 
PVector rule1(Particle pj) { 
  Particle p; 
  PVector c;         //center of mass.  
  
  c = new PVector(0,0); 
  
  for(int i = 0; i<numBoids; i++) {     
    p = (Particle) boids.get(i);
    if(pj != p){            //perceived. do not include myself. 
       c.add(p.loc);   
    }
  }
  
  c.div(numBoids-1);
  
  c.sub(pj.loc); 
  c.div(100);
  
  return c; 
} 

/**
 * Keep the boids flying away from each other. AKA avoid collision. 
 **/
PVector rule2(Particle pj) { 
   
   Particle p; 
   PVector c = new PVector(); 
   float d;  
   
   for(int i = 0; i<numBoids; i++) {     
      p = (Particle) boids.get(i);
      if(pj != p){            //perceived. do not include myself. 
         d = pj.loc.dist(p.loc); 
         if(abs(d) < 10) {
           c.x -= p.loc.x - pj.loc.x; 
           c.y -= p.loc.y - pj.loc.y;  
         }      
      }
    }
  return c;     
}


/**
 * Keep the boids moving towards the average velocity.
 */  
PVector rule3(Particle pj) { 
   
   Particle p; 
   PVector pv = new PVector(); 
   
   for(int i = 0; i<numBoids; i++) {     
      p = (Particle) boids.get(i);
      if(pj != p){            //perceived. do not include myself. 
        pv.add(p.vel);  
      }
    }
    
    pv.div(numBoids-1); 
    pv.sub(pj.vel); 
    pv.div(8);    
    
   return pv;     
}


/**
 * Tend to some place on the screen.
 */ 
PVector tendtoPlace(Particle p) { 
  //PVector place = new PVector(mouseX, mouseY);        //we are tending to mouse. 
  PVector place = new PVector(width+100, height/2);     //we are tending to a place off to the right of the screen. 
                        
  place.sub(p.loc); 
  place.div(100); 

  return place;   
}

/**
 * Bound boid to the screen. 
 */ 
PVector boundBoid(Particle p) { 
  PVector v = new PVector(0,0); 
 
  //lets check our boundaries. 
  if(p.loc.x > width || p.loc.x < 0) { 
    v.x = -p.vel.x*2; 
  }  
   
  if(p.loc.y > height || p.loc.y < 0) { 
     v.y = -p.vel.y*2;  
  }
 
  return v; 
}


//shot out to jared tarbell... my favorite artist! 
color someColor() { 
   return palette[int(random(palette.length))];  
}

//------------------------------------

void mousePressed() { 
   
  //scatter the flock OR don't scatter the flock. 
  // m1 = -m1; 
  // createUniverse();
  //saveFrame("boid-####.png"); 
}