class Vec{ 
  float x, y, z; 
 
  Vec(float X, float Y, float Z){ 
    x = X; 
    y = Y; 
    z = Z; 
  } 
 
  void add (Vec v){ 
    x = x + v.x; 
    y = y + v.y; 
    z = z + v.z; 
  } 
 
  void subtract(Vec v){ 
    x = x - v.x; 
    y = y - v.y; 
    z = z - v.z; 
  }    
 
  void multiply (float m){ 
    x = x*m; 
    y = y*m; 
    z = z*m; 
  } 
 
  float distance (Vec v){ 
    float d = sqrt (pow(v.x-x, 2) + pow(v.y-y, 2) + pow(v.z-z, 2)); 
    return d; 
  } 
 
  float magnitute (){ 
    float d = sqrt (pow(x, 2) + pow(y,2 ) + pow(z, 2)); 
    return d; 
  } 
 
  void set(Vec v) 
  { 
    x = v.x; 
    y = v.y; 
    z = v.z; 
  }   
 
} 

import processing.pdf.*; 
 
//PGraphics jeos; 
Particle[] p = new Particle[40]; //particle array 
Particle[] attractor = new Particle [5]; 
Particle[] staticAttractor = new Particle[5]; 
 
void setup(){ 
 
 
  size(800,800); //canvas size 
  
  ///////////////////////////////////////////////////////////////////////////////////////////////// 
 
  for(int i=0; i<p.length; i++){ // amount of particles 
    p[i]= new Particle (random(height),random(width),5,5,0,.999,0,color(242,204,47),color(255,0,0));     
  } 
 
  ////////////////////////////////////////////////////////////////////////////////////////////////////   
 
  for(int i=0; i< attractor.length; i++){  
    //int q = i%3;    
    //if (q == 0) q =1; 
    //else q = 0; 
    attractor[i]= new Particle (random(height),random(width),5,5,30,.999,0,color(245,245,245),color(255)); 
  } 
 
  ////////////////////////////////////////////////////////////////////////////////////////////////////    
 
  for (int i = 0; i < staticAttractor.length; i++) 
  { 
    float q = i; 
    staticAttractor[i] = new Particle(0.333*width,(q/staticAttractor.length)*height,1,1,0,.999,0,color(0),color(0)); 
  } 
 
} 
//////////////////////////////////////////////////////////////////////////////////////////////////////// 
 
void draw() //continuously executes the lines of code contained inside its block until the program is stopped 
{ 
  //background(0); //backgroud colour 
  fill(0,15); 
  noStroke(); 
  rect(0,0, width, height); 
  stroke(255); 
  frameRate(15); 
  /////////////////////////////////////////////////////////////////////////////////////////////////////   
 
  for(int i=0; i<p.length; i++) 
  { 
    p[i].xp=100; 
    p[i].yp=100;    
    float distance = sqrt(pow(mouseX-p[i].pos.x, 2) + pow(mouseY - p[i].pos.y, 2)); 
 
    if(distance < 100){       
      p[i].colorT+=.01; 
      //p[i].checkColor(color(255,0,0), color(255)); 
 
      //p[i].curveTranslate(p[i].pos.x, p[i].pos.y, random(.2, 2), 1.5, 3, 3, .4); 
    } 
    else{ 
      p[i].colorT-=.01; 
      //p[i].curveTranslate(p[i].pos.x, p[i].pos.y, .2, 1.5, 3, 3, .1); 
    } 
    /*for(int j=0; j<i%5; j++){ 
     if (i !=j){ 
     float pDist = p[i].pos.distance(p[j].pos); 
     if (pDist <100){ 
     line (p[i].pos.x, p[i].pos.y, p[j].pos.x, p[j].pos.y); 
     //line.c1=color(#48D0FF); 
     } 
     }  
     } */ 
    p[i].newAttract(attractor); 
    p[i].findClosestAttractor(attractor); 
    p[i].checkColor(); 
    //p[i].addLine(); 
    p[i].drawParticle();   
  } 
 
  //loops through every attractor and draws it to screen 
  for (int i = 0; i < attractor.length; i++){ 
 
    attractor[i].newAttract(staticAttractor); 
    attractor[i].findClosestAttractor(staticAttractor); 
    //attractor[i].addLine(); 
    attractor[i].checkColor(); 
    attractor[i].drawParticle(); 
  } 
 
  for (int i = 0; i < staticAttractor.length; i++){ 
    staticAttractor[i].drawParticle();  
  } 
  println(frameCount); 
 
} 
 
/* 
 void mousePressed(){ 
 save("test5.tif"); 
 } 
 */ 
 
/*void keyPressed() 
{ 
  if (key=='b' || key == 'B') 
  { 
    beginRecord(PDF,"JeosAA.pdf"); 
  } 
  else if (key=='e' || key == 'E') 
  { 
    endRecord(); 
    exit(); 
  } 
}*/ 
void mouseClicked()                           //do the following when mouse clicked 
{ 
    setup();                                  //refresh when mouse is clicked 
}  
 

class Particle //class = composite of data; Particle = name of class     
{ 
  float w; //radius1 
  float h; //radius2 
   
  int polarity; 
  float attractionForce; 
  float accel = .5; //particle acceleratioin 
  float r;  //rotation       
  float xp, yp;// to help determine the ellipse last location 
  float t=0;  //start 
  float sinTranslatecount=0; 
  float curveTranslateCount=0; // global called in order to start the count... 
  float colorT=0; 
  float factor = 15.0; 
  
 color baseColor; 
color lerpToColor;  
 
  float prevX, prevY; 
  
  Vec closestVec; 
  Vec pos = new Vec(0,0,0); //center  
  Vec v= new Vec(0,0,0); 
 
  Vec ppos; 
   
    Particle(float X, float Y, float W, float H, float R,float gravityWeight, int Polarity , color BaseColor, color LerpToColor) 
    { 
      pos.x=X; //definition 
      pos.y=Y; //definition 
      w=W; //definition 
      h=H; //definition 
      r=R; //definition 
      attractionForce = gravityWeight; 
      polarity = Polarity; 
      baseColor = BaseColor; 
      lerpToColor = LerpToColor; 
     } 
  
  /////////////////////////////////////////////////////////////////////////////////////////////////// 
  
  void newAttract(Particle[] a){ 
      for(int i=0; i <a.length; i++){ 
         float d =pos.distance(a[i].pos); 
           
    if (a[i].polarity == 0) 
    { 
           if(d < 90){ 
              v.x -= accel * (a[i].pos.x - pos.x) / d; 
              v.y -= accel * (a[i].pos.y - pos.y) / d; 
              p[i].inflate(1.025); 
            } 
           
          else{ 
              v.x += (accel * (a[i].pos.x - pos.x) / d)/a.length; 
              v.y += (accel * (a[i].pos.y - pos.y) / d)/a.length; 
              
            } 
             
          
            if (accel < .1) accel = .1; 
            if (accel > 2) accel = 2; 
 
            if (d<90) accel =.94;  
           else accel =1.001; 
          
       } 
       
       else{ 
           if(d > 90){ 
              v.x += accel * (a[i].pos.x - pos.x) / d; 
              v.y += accel * (a[i].pos.y - pos.y) / d; 
              p[i].inflate(.987); 
              }           
          else{ 
              v.x -= (accel * (a[i].pos.x - pos.x) / d)/a.length; 
              v.y -= (accel * (a[i].pos.y - pos.y) / d)/a.length; 
                
              } 
          
            if (accel < .1) accel = .1; 
            if (accel > 2) accel = 2; 
          
            //if(mousePressed == true && shOn== false) shOn = true;//accel*=.95; look here............. 
            //if( mousePressed == true && shOn == true ) shOn = false; 
            //if (shOn == true)accel*=.95; 
            //if (shOn == false)accel*=1.01; 
          
            if (d<10) accel =.995;  
            else accel =1.001; 
          //else accel*=1.01; 
            } 
     v.multiply(attractionForce); 
    } 
  } 
   
 /////////////////////////////////////////////////////////////////////////////////////////////////////// 
  
  void inflate(float rate) // first function 
  { 
    w=w*rate;  
    h=h*rate; 
     
    if (w>50) w = 50; 
    if (h>50) h = 50; 
   
}  
 
/////////////////////////////////////////////////////////////////////////////////////////////////////// 
 
void checkColor() 
{ 
 
  //float shiftExtent = ((w+h)/2)*factor; 
  float shiftExtent = 100; 
   
  float closeDistance = pos.distance(closestVec); 
   
  if (closeDistance < shiftExtent) 
  { 
    //colorT = 1 - (closeDistance/shiftExtent); 
colorT += .1; 
 
if (colorT > 1) colorT = 1.0; 
 
} 
 
  else 
  { 
    colorT -= .05; 
    if (colorT < 0) colorT = 0; 
  } 
} 
       
  void drawParticle(){ // rotate function 
    //checkColor(color(255,0,0), color(255)); 
    float s= 60.0/((w+h)/2); 
    pos.add(v); 
    
    for (float t=0; t<=360; t=t+s) 
    { 
       float a = pos.x + w/2 * cos( radians(t))* cos( radians(r))-h/2*sin( radians(t))*sin(radians(r)); 
       float b = pos.y + h/2 * sin( radians(t))* cos( radians(r))-h/2*cos( radians(t))*sin(radians(r)); 
       stroke(lerpColor(baseColor,lerpToColor,colorT)); 
       point(a,b); 
     } 
  } 
   
  void addLine() 
  { 
   
    checkColor(); 
     
   prevX = pos.x; 
  prevY  = pos.y; 
  
 pos.add(v); 
  stroke(lerpColor(baseColor,lerpToColor,colorT)); 
  line(prevX,prevY,pos.x,pos.y); 
  
  } 
   
    void findClosestAttractor(Particle[] a) 
  { 
    closestVec = a[0].pos; 
     
    float d1 = a[0].pos.distance(a[0].pos); 
 
    for (int i = 1; i < a.length; i++) 
    { 
      
      float d2 = a[i].pos.distance(a[i].pos); 
 
      if (d1 > d2) 
      { 
        closestVec = a[i].pos; 
        d1 = d2;  
      } 
    } 
  } 
 
}