class Particle 
{   
  color c1,c2; 
  float w,h; // radii 
  float x,y; // center point 
  float r;   // rotation 
  float t=0; //  
  float xP, yP;  // start position  
  float xS, yS; // splode position 
  float sinTransCount=0;  
  float curveTransCount=0; 
  color c=c2; 
  int colorCount=0; 
  float colorT=0; // change in color over time 
  float strokeSize=1; 
  float easing=0; 
  float inflateCount; 
  boolean toDraw = true; 
  boolean activated = false; 
  float accel=1; // acceleration value 
  float maxAccel=6; 
  float minAccel=.7; 
 
int numSplodes=6; 
  Splode[] splodes = new Splode[numSplodes]; 
 
 
 
  Particle(float X, float Y, float W, float H, float R, color C1, color C2) //constructor 
  { 
    x=X; 
    y=Y; 
    w=W; 
    h=H; 
    r=R; 
    c1=C1; 
    c2=C2; 
  } 
 
  //////////////////////////////////////////////////////////// 
  // checkColor ( wanted color , original color) 
  void checkColor(color cc1, color cc2) 
  { 
    if(colorCount>60) 
    { 
      c=c2;  
      colorCount=0; 
    } 
 
    if(c != c2) 
    { 
      colorCount++; 
    }  
 
    if(colorT<0) colorT=0; 
    if(colorT>1) colorT=1;  
  } 
 
  //////////////////////////////////////////////////////////// 
  void fillPart(color cFill, float trans) 
  { 
    noStroke(); 
    fill(cFill, trans); 
    ellipse(x,y,w-2,h-2) ; 
  } 
 
  //////////////////////////////////////////////////////////// 
  void inflate(float rate) 
  { 
    w *= rate; 
    h *= rate; 
    strokeSize*=rate; 
  } 
 
  //////////////////////////////////////////////////////////// 
  void attract(float rate) 
  { 
    activated=true; 
    x+=accel*(mouseX-x) / distance(mouseX,mouseY,x,y); 
    y+=accel*(mouseY-y) / distance(mouseX,mouseY,x,y); 
 
    if(accel<maxAccel) accel=1+rate/1.5; // allows acceleration up to some value 
    else accel=maxAccel; 
  } 
 
  ///////////////////////////////////////////////////////////// 
  void detract(float rate) 
  { 
    activated=true; 
    x-=accel*(mouseX-x) / distance(mouseX,mouseY,x,y); 
    y-=accel*(mouseY-y) / distance(mouseX,mouseY,x,y); 
 
    if(accel<maxAccel) accel=1+rate; // allows acceleration up to some value 
    else if(accel>maxAccel) accel=maxAccel; 
  } 
 
  //////////////////////////////////////////////////////////// 
  // attract (attractor X/Y) 
  void attractHome(float homeDist) 
  { 
    if(distance(xP,yP,x,y)>2) 
    { 
      x+=accel*(xP-x) / distance(xP,yP,x,y); 
      y+=accel*(yP-y) / distance(xP,yP,x,y); 
 
      if(distance(xP,yP,x,y) > homeDist*.6) 
      { 
        accel*=1.1; 
        if(accel>maxAccel) accel=maxAccel; 
      } 
      //if(distance(xP,yP,x,y) < homeDist*.5)  
      else 
      { 
        accel*=.95; 
        if(accel<minAccel) accel=minAccel; 
      } 
 
    } 
    // hack to stop particle from perpetually vibrating when at start position 
    else if(distance(xP,yP,x,y)<2) 
    { 
      x=xP; 
      y=yP; 
    } 
  } 
 
 
 
  ////////////////////////////////////////////////////////////// 
  //distance (from one point, to another point) 
  float distance(float x1, float y1, float x2, float y2) 
  { 
    float d= sqrt(pow(x2-x1,2) + pow(y2-y1,2)) ; 
    return d; 
  } 
 
 
 
  //////////////////////////////////////////////////////////// 
  // magnetTrans (mouse x, mouse y, particle x, particle y) 
  void magnetTrans(float mx, float my, float dis) 
  { 
    if(mouseButton==LEFT) 
    { 
      easing=1/dis; 
      x -= (mx-x)*easing; 
      y -= (my-y)*easing; 
    } 
    else if(mouseButton==RIGHT) 
    { 
      easing=1/dis; 
      x += (mx-x)*easing; 
      y += (my-y)*easing; 
    } 
  } 
 
  //////////////////////////////////////////////////////////// 
  void returnTrans() 
  { 
    easing = .03; 
    x += (xP-x)*easing; 
    y += (yP-y)*easing;  
  } 
 
  //////////////////////////////////////////////////////////// 
  // curveTrans( deviation x, deviation y, radius x, radius y, center x, center y, motion speed) 
  void curveTrans(float sx, float sy, float rx, float ry, float xx, float yy, float speed) 
  {  
    curveTransCount+=speed; 
    x=xx+(cos(curveTransCount*sx)*rx); 
    y=yy+(sin(curveTransCount*sy)*ry);  
  } 
 
  //////////////////////////////////////////////////////////// 
  void transParticle(float xT, float yT) 
  {   
    if(t<=1) 
    { 
      x = (1-t)*xP+t*xT; 
      y = (1-t)*yP+t*yT; 
      t+=.01; 
    } 
  } 
 
  //////////////////////////////////////////////////////////// 
  void sinTrans(float xT, float yT) 
  { 
    x = (1-t)*xP+t*xT; 
    y = (1-t)*yP+t*yT; 
    t=sin(sinTransCount); 
    sinTransCount+=.04; 
  } 
 
  ///////////////////////////////////////////////////////////// 
  void drawParticle() 
  { 
    checkColor(c1, c2); 
    for(float t=0; t<=360; t+=13) 
    { 
      float a= x + w/2 * cos(radians(t))*cos(radians(r))-h/2*sin(radians(t))*sin(radians(r)); 
      float b= y + h/2 * sin(radians(t))*cos(radians(r))+w/2*cos(radians(t))*sin(radians(r)); 
      strokeWeight(strokeSize); 
      stroke(lerpColor(c1,c2,colorT)); 
      point(a,b); 
    } 
  }  
 
  ///////////////////////////////////////////////////////////// 
  void prepSplode() 
  { 
    xS=x; 
    yS=y; 
    for (int i = 0; i < numSplodes; i++) 
    { 
      splodes[i] = new Splode(xS+random(-10,10), yS+random(-10,10), 9, i, splodes); 
    }  
  } 
 
  ///////////////////////////////////////////////////////////// 
  void drawSplode() 
  { 
    for (int i = 0; i < numSplodes; i++) 
    { 
      splodes[i].collide(numSplodes); 
      splodes[i].move(); 
      splodes[i].display();  
    } 
  } 
 
} 

Particle [] p = new Particle[225]; 
 
float aoe=150; // area of effect of particle 
float homeDist=0; 
 
void setup() 
{ 
  //smooth(); 
  size(800,800); 
  int q=0; 
 
  for(int i=0; i<225; i++) 
  { 
    p[i]= new Particle(250,250,11,11,45,color(255),color(255,255,0)); 
  } 
 
  // placing particles on grid 
  for(int i=0; i<15; i++) 
  { 
    for(int j=0; j<15; j++) 
    { 
      p[q].x=random(-aoe,aoe)+120+i*40; 
      p[q].y=random(-aoe,aoe)+120+j*40; 
      p[q].xP=120+i*40; // stores start location x 
      p[q].yP=120+j*40; // stores start location y 
      p[q].activated=true; 
      q++; 
 
    } 
  } 
} 
 
void draw() 
{ 
  //background(0); 
 
  fill(0,75); 
  noStroke(); 
  rect(0,0,width,height); 
 
 
  stroke(255); 
  for(int i=0; i<225; i++) 
  { 
 
    float mouseDist = sqrt(pow(mouseX-p[i].x,2)+pow(mouseY-p[i].y,2)); 
 
    if(mouseDist<=aoe) 
    { 
      if(mousePressed==true) 
      { 
 
        p[i].colorT+=.05; 
        float normDist = (aoe-mouseDist)/aoe*4; 
 
        // only inflate up until entity is some max value and constrain inflate rate 
        if(p[i].w<121) p[i].inflate(constrain(1+(1/mouseDist),0,2)); 
        p[i].inflateCount++; 
 
        // particles are attracted, checks edge of screen 
        if(mouseButton==LEFT) 
        { 
          if(p[i].x >= (0+p[i].w) && p[i].x <= (width-p[i].w) && p[i].y >= (0+p[i].h) && p[i].y <= (height-p[i].h))  
            p[i].attract(normDist); 
        } 
        // particles are repulsed, checks edge of screen 
        else if(mouseButton==RIGHT) 
        { 
          if(p[i].x >= (0+p[i].w) && p[i].x <= (width-p[i].w) && p[i].y >= (0+p[i].h) && p[i].y <= (height-p[i].h))  
            p[i].detract(normDist); 
        } 
 
        // if a particle has been activated for some length of time, destroy it by not drawing it and store position 
        if(p[i].inflateCount==80) 
        { 
          p[i].toDraw=false; 
          p[i].prepSplode(); 
        } 
      } 
      else p[i].accel=1; 
 
      if(p[i].toDraw==true) p[i].fillPart(color(255,0,0) , (aoe-mouseDist)/aoe*255);       
    } 
    else 
    { 
      p[i].colorT-=.01; 
 
      // only runs once, the moment a particle goes from attracted/detracted to not 
      if(p[i].activated==true) 
      { 
        homeDist = sqrt(pow(p[i].xP-p[i].x,2)+pow(p[i].yP-p[i].y,2)); 
        //line(p[i].xP, p[i].yP, p[i].x, p[i].y); 
        p[i].activated=false; 
      } 
 
      // particles slowly return to their start location if their current pos != start positions 
      if(p[i].x != p[i].xP && p[i].y != p[i].yP) p[i].attractHome(homeDist); 
 
      // only deflate if entity larger than start size 
      if(p[i].w>11) p[i].inflate(.97); 
      if(p[i].inflateCount>=0) p[i].inflateCount--; 
    } 
 
 
    // connect by lines 
    for (int j=0; j<p.length; j++) 
    { 
      if(i != j)  
      { 
        float lineDist= dist(p[i].x, p[i].y, p[j].x, p[j].y); 
        if(lineDist<38 && p[i].toDraw==true && p[j].toDraw==true) 
        {  
          strokeWeight(1); 
          connectLine(p[i].x, p[i].y, p[j].x, p[j].y, color(255)); // cur_pos to cur_pos 
          connectLine(p[i].xP, p[i].yP, p[j].xP, p[j].yP, color(255,0,255)); // start_pos to start pos 
        } 
      } 
    } 
 
    if(p[i].toDraw==true) 
    { 
      p[i].drawParticle(); 
      connectLine(p[i].xP, p[i].yP, p[i].x, p[i].y, color(150)); 
    } 
 
    if(p[i].toDraw==false) 
    { 
      noStroke(); 
      p[i].drawSplode(); 
    } 
  } 
 
} 
 
//////////////////////////////////////////////////////////////// 
void connectLine(float x1, float y1, float x2, float y2, color c) 
{ 
  stroke(c); 
  line(x1,y1,x2,y2);  
} 

class Splode  
{ 
  float x, y; 
  float diameter; 
  float vx = 0; 
  float vy = 0; 
  int id; 
  Splode[] others; 
  float spring = 0.5; 
 
  Splode(float xin, float yin, float din, int idin, Splode[] oin) { 
    x = xin; 
    y = yin; 
    diameter = din; 
    id = idin; 
    others = oin; 
  }  
 
  void collide(int numSplodes) { 
    for (int i = id + 1; i < numSplodes; i++) { 
      float dx = others[i].x - x; 
      float dy = others[i].y - y; 
      float distance = sqrt(dx*dx + dy*dy); 
      float minDist = others[i].diameter/2 + diameter/2; 
      if (distance < minDist) {  
        float angle = atan2(dy, dx); 
        float targetX = x + cos(angle) * minDist; 
        float targetY = y + sin(angle) * minDist; 
        float ax = (targetX - others[i].x) * spring; 
        float ay = (targetY - others[i].y) * spring; 
        vx -= ax; 
        vy -= ay; 
        others[i].vx += ax; 
        others[i].vy += ay; 
      } 
    }    
  } 
 
  void move() { 
    x += vx; 
    y += vy; 
    if (x + diameter/2 > width) { 
      x = width - diameter/2; 
      vx += -0.9;  
    } 
    else if (x - diameter/2 < 0) { 
      x = diameter/2; 
      vx *= -0.9; 
    } 
    if (y + diameter/2 > height) { 
      y = height - diameter/2; 
      vy *= -0.9;  
    }  
    else if (y - diameter/2 < 0) { 
      y = diameter/2; 
      vy *= -0.9; 
    } 
  } 
 
  void display() { 
    fill(255,0,0); 
    ellipse(x, y, diameter, diameter); 
  } 
}