Week 11 - OpenProcessing

colliding_particles
xxxxxxxxxx
 
ArrayList particles = new ArrayList();
void setup() {
  size(640, 640);
  noStroke();
  fill(0);
  for (int i = 0; i < 25; i++) {
    particles.add(new Particle(new PVector(random(width), height/2), PVector.random2D(), 25));
  }
}
​
void draw() {
  background(255);
  for (int i = 0; i < particles.size(); i++) {
    Particle p = (Particle) particles.get(i);
    p.drawParticles();
    p.boundaryConstraints();
    p.move();
  }
  for (int i = 0; i < particles.size(); i++) {
    Particle p = (Particle) particles.get(i);
    p.collide();
  }
}
class Particle {
  PVector location;
  PVector velocity;
​
  float radius;
​
  Particle(PVector location_, PVector velocity_, float radius_) {
    location = location_;
    velocity = velocity_; 
    radius = radius_;
  }
  void move() {
    location.add(velocity);
  }
  
  // We offset the bouncing point by the radii of the particles, namely, radius.
  void boundaryConstraints() {
    if (location.x < radius) {
      location.x = radius;
      velocity.x *= -1;
    }
    if (location.x > width-radius) {
      location.x = width-radius;
      velocity.x *= -1;
    }
    if (location.y < radius) {
      location.y = radius;
      velocity.y *= -1;
    }
    if (location.y > height-radius) {
      location.y = height-radius;
      velocity.y *= -1;
    }
  }
  
  void collide() {
     for (int j = 0; j < particles.size(); j++) {
      Particle p = (Particle) particles.get(j);
      if (!this.equals(p) && location.dist(p.location) < (radius+p.radius)) {
        bounce(this, p);
      }
     }
  }
  
  
  void drawParticles() {
    noStroke();
    fill(125 + sin(radians(frameCount))*125, 125 + cos(radians(frameCount))*125, 125 + sin(radians(-frameCount))*125);
    ellipse(location.x, location.y, radius*2, radius*2);
  }
  
  void bounce(Particle p, Particle p2) {
    // Get direction from one center of an object to the center of the other.
    PVector direction = PVector.sub(p.location, p2.location);
    // Normalize Direction
    direction.normalize();
    // While particles are touching
    while (p.location.dist(p2.location) < (p.radius+p2.radius)) {
      // Add the direction
      // Keep the particles apart
      p.location.add(direction);
    }
    // Find the difference in velocities assuming one object is still
    PVector u = PVector.sub(p.velocity, p2.velocity);
    // This function I find the trickiest to understand
    PVector un = componentVector(u, direction);
    // Other component
    u.sub(un);
    // New velocities + velocity of the object we asumed stationary
    p.velocity = PVector.add(u, p2.velocity);
    p2.velocity = PVector.add(un, p2.velocity);
  }
​
  PVector componentVector (PVector vector, PVector directionVector) {
    directionVector.normalize();
    directionVector.mult(vector.dot(directionVector));
    return directionVector;
  }
}
​
​