// Simple Multi-Particle Collisions.
// NOTE:
// -- this compares positions in order N^2 time, which means very slow for many particles...
// -- particles can get stuck together if they are born inside each other, or if
//    they enter the other, and when their velocity reverses due to the collision, they are
//    still inside their partner. you can fix this if you're clever. 


Blob balls[];
int nBalls;

void setup(){
  size(600,700);
  background(255);

  nBalls = 100;
  balls = new Blob[nBalls];
  for (int i=0; i<nBalls; i++){
    float rx = random(width);
    float ry = random(height);
    balls[i] = new Blob(rx, ry);
    balls[i].vx = random(-2,2);
    balls[i].vy = random(-2,2);
  }
}

void loop(){
  background(255);
  updateStuff();
  drawStuff();
}

//-------------------------------------
void updateStuff(){
  for (int i=0; i<nBalls; i++){
    balls[i].applyDragForce();
    balls[i].handleCollisionWithOthersInTheArray(balls, nBalls, i);
    balls[i].update();
  }
}



//-------------------------------------
void drawStuff(){
  for (int i=0; i<nBalls; i++){
    balls[i].render();
  }
}

void mousePressed(){
  background(255);
  for (int i=0; i<nBalls; i++){
    balls[i].px = random(width);
    balls[i].py = random(height);
    balls[i].vx = random(-2,2);
    balls[i].vy = random(-2,2);
  }
}

//-------------------------
final float GRAVITY_X = 0;
final float GRAVITY_Y = 1.0;
final float FRICTION = 0.00025;

class PhysicalThing {
  float px, py;
  float vx, vy;

  void applyGravityForce(){
    vx += GRAVITY_X;
    vy += GRAVITY_Y;
  }

  void applyDragForce(){
    float fdragx = vx * FRICTION * -1.0;
    float fdragy = vy * FRICTION * -1.0;
    vx += fdragx;
    vy += fdragy;
  }
  


  void update(){
    px += vx;
    py += vy;

    while (px > width){
      px -= width;
    }
    while (px < 0){
      px += width;
    }
    while (py > height){
      py -= height;
    }
    while (py < 0){
      py += height;
    }

  }
}

//-------------------------
class Blob extends PhysicalThing {

  boolean collide;
  float R; // radius
  color myColor;
  
  Blob(float x, float y){
    px = x; py = y;
    vx = vy = 0;
    R = random(4, 7);
    collide = false;
    myColor = color(0, random(255), random(255));
  }
  
  void handleCollisionWithOthersInTheArray (Blob[] arr, int num, int me){
    for (int i=0; i<num; i++){
      Blob otherb = arr[i];
      
      //if (i != me){ // also works
      if (otherb != this){
        
        float dx = this.px - otherb.px;
        float dy = this.py - otherb.py;
        float dh = sqrt(dx*dx + dy*dy);
        
        float testDistance = this.R + otherb.R;
        if (dh < testDistance){
          collide = true;
          
          // velocity swap if collide
          float ovx = otherb.vx;
          float ovy = otherb.vy;
          otherb.vx = this.vx;
          otherb.vy = this.vy;
          this.vx = ovx;
          this.vy = ovy;
     
        }
               
      }
    }
  }

  void render(){
    ellipseMode(CENTER_DIAMETER);
    stroke(0,0,0);
    if (collide){
      fill(255, 0, 0);
      collide = false;
    } else {
      fill(myColor);
    }
    ellipse(this.px, this.py, (R*2), (R*2));
  }

}