import controlP5.*;
/*Firefly behavior simulated as Bouncing Balls
 
 based on 
 
 'Firefly-Inspired Sensor Network Synchronicity 
 with Realistic Radio Effects ' Werner-Allen, et. al. 
 
 and 
 
 'Synchronization of pulse-coupledbiological oscillators' R. Mirollo 
 and S. Strogatz.
 
 Basically this models the synchrony of fireflies and visualizes the synchrony by modeling each
 firefly as a bouncing ball, with the firefly flashing represented by the ball hitting the ground. 
 
 Simply put, all of the fireflies have the same period but are at different phases.  If a firefly's neighbor flashes, it 
 increments the time of the firefly to bring it closer to flashing.   
 
 The increment function is created such that if a neighbor of i flashes closer to the end of i's period, the 
 increment will be larger for firefly i.  Likewise if the neighbor flashes close to the beginning of i's period
 the increment will be less.  This behavior can be represented as a logarithmic function.  We can approximate the 
 increment function as delta_t = epsilon * t , where t is the time in a period.  The reason for this is given in the first 
 paper above on page 5. 
 
 Initially the balls will make sharp jumps, that is because one of its neighbors hit the ground (thus flashing)
 and incrementing the original ball along its period. 
 
 
 
 by Kawandeep Virdee  
 
 */


float detection_radiusI=30;
int number_firefliesI= 100;
float periodI=200;





int height = 500;  //height of the bouncing

int width = 500;

float diameter = 10;  //diameter of the circles representing the fireflies
ArrayList fireflies;

float period, detection_radius;
float epsilon = .1;  //to calculate the increment, an approximation
float accConst;  //the acceleration
float initVelocity; //initial velocity
int number_fireflies;

boolean firstRun = true; 


color backgroundColor = color(0,0,0,10);

void setup(){
  if(firstRun){
   setupGUI(); 
   firstRun = false;
  }
  detection_radius=int(detection_radiusI);  //how far does a firefly look to either side to see a neighbor flash
  number_fireflies=int(number_firefliesI); 
  period = int(periodI);  //how long the time inbetween flashes is, in this case the number of points to model the bouncing


  size(width,height);
  

  accConst = 2*(height-20)/(sq(period/2));  //equation to calculate the acceleration to go a certain height 
  //from displacement = (1/2) a t^2

    initVelocity = (accConst/2)*period;  //at time = period the ball has fallen to its initial location, we can calculate the 
  //initial velocity
  fireflies = new ArrayList();
  int j=width/4;
  for(int i=0; i<number_fireflies; ++i){
    float time = random(0, period);
    PVector pos = new PVector(j,heightCalc(time));
    fireflies.add(new Firefly(pos, time));
    j += int(detection_radius-1); //to space the fireflies out so that they can always detect a neighbor
    j=j%width;

  }
}


void draw(){
  //  frameRate(13);  //speed of vis

  smooth();

  stroke(backgroundColor);
  fill(backgroundColor);
  rect(0,0,width, height); //background color (r,g,b,alpha)

  //loop over all of the fireflies
  for (int i = 0; i< fireflies.size(); ++i){
    Firefly f = (Firefly) fireflies.get(i);

    //light firefly if it reaches peak of its motion

    if (f.time >= period){ 


      f.time=0;
      f.flash = true;
      f.position.y = heightCalc(f.time);
      f.drawFlash();
    }
    else{
      f.time +=1;
      f.flash = false;

      //check for neighbor flashing
      f.neighborsFlash(detection_radius);
      //increment if neighbor flashes
      f.time +=f.time_memory;
      f.time_memory=0;

      f.position.y = heightCalc(f.time);
      f.drawNormal();

    }
  }


}



///


class Firefly {
  PVector position;
  float time;  //current time level of the firefly
  float time_memory=0; //this will hold the delta t value
  float delta_t; //the change in t when a neighbor flashes
  boolean flash = false;
  //constructor  
  Firefly(PVector _position, float _time){

    position = _position;
    time = _time;
  }

  //check the neighbors
  ArrayList neighbors(float detection_radius){ 
    ArrayList neighbors = new ArrayList();

    for(int i = 0; i<fireflies.size(); ++i){
      Firefly f = (Firefly) fireflies.get(i);
      //make sure you're not checking the current firefly against itself
      if (!f.equals(this)){
        float distance = abs(position.x - f.position.x);
        if (distance < detection_radius) neighbors.add(f);
      }
    }
    return neighbors;
  }
  //check if one of the neighbors flashed
  void neighborsFlash(float detection_radius){ 
    ArrayList neighbors = neighbors(detection_radius);
    for (int i=0; i<neighbors.size(); ++i){

      Firefly f = (Firefly) neighbors.get(i);
      if (f.flash == true){

        time_memory += increment(time);  
      }

    }
  }
  // function to calculate increment
  float increment(float time_fire){
    //calculate change in t
    delta_t = epsilon * time_fire;
    return delta_t;
  }

  void drawNormal(){

    stroke(100);
    fill(100);
    ellipse(position.x, position.y, diameter, diameter);

  }

  void drawFlash(){
    stroke(255);
    fill(255);
    ellipse(position.x, position.y, diameter, diameter);

  }


}


//parametric equation to calculate the height of the ball at a given time  y(t) is a parabola given by y(t)= vt + 1/2 at^2  
//the height is flipped so that the balls bounce off the ground rather than the ceiling.  the acceleration is negative since
//it points in the direction opposite to that of the initial velocity
float heightCalc( float time){

  float ypos = height - (initVelocity + (-accConst/2)*time)*time;
  return ypos;

}