Particle System - OpenProcessing

main
xxxxxxxxxx
 
var WIDTH = window.innerWidth, HEIGHT = window.innerHeight, PARTICLE_COUNT = 20,
    G = 6.67408e-11;
​
class Vector2D {
  
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
  
  static fromPolar(radius, angle) {
    return new Vector2D(radius * Math.cos(angle), radius * Math.sin(angle));
  }
  static dot(a, b) {
    return a.x*b.x + a.y*b.y;
  }
  
  get magnitude() {
    return Math.sqrt(this.x*this.x + this.y*this.y);
  }
  get magnitudeSquared() {
    return this.x*this.x + this.y*this.y;
  }
  get angle() {
    return Math.atan2(this.y, this.x);
  }
  
  shift(vector) {
    this.x += vector.x;
    this.y += vector.y;
  }
  getShifted(vector) {
    return new Vector2D(this.x + vector.x, this.y + vector.y);
  }
  
  scale(scalar) {
    this.x *= scalar;
    this.y *= scalar;
  }
  getScaled(scalar) {
    return new Vector2D(this.x * scalar, this.y * scalar);
  }
  
  rotate(angle) {
    var x = this.x, y = this.y;
    this.x = x * Math.cos(angle) - x * Math.sin(angle);
    this.y = y * Math.sin(angle) + y * Math.cos(angle);
  }
  getRotated(angle) {
    return new Vector2D(
      this.x * Math.cos(angle) - this.x * Math.sin(angle),
      this.y * Math.sin(angle) + this.y * Math.cos(angle)
    );
  }
  
  angleBetween(vector) {
    return Math.atan2(this.y - vector.y, this.x - vector.x);
  }
}
class Collider {
  
  constructor(parent) {
    this.parent = parent;
  }
  
  walls() {
    var leftMax   = this.parent.pos.x - this.parent.radius,
        rightMax  = this.parent.pos.x + this.parent.radius,
        topMax    = this.parent.pos.y - this.parent.radius,
        bottomMax = this.parent.pos.y + this.parent.radius;
    
    if (leftMax < -WIDTH/2 || rightMax > WIDTH/2) {
      this.parent.vel.x *= -1;
    }
    if (topMax < -HEIGHT/2 || bottomMax > HEIGHT/2) {
      this.parent.vel.y *= -1;
    }
  }
  
  _collide(object) {
    var differenceVector = object.pos.getShifted(this.parent.pos.getScaled(-1)),
        distanceSquared = differenceVector.magnitudeSquared, distance, gammaVector;
    if (distanceSquared > (this.parent.radius + object.radius)**2)
      return;
    
    distance = Math.sqrt(distanceSquared);
    if (distance == 0)
      distance = 1e-10;
    differenceVector.scale(1 / distance);
    
    // Collision mathematics for an N-Dimensional System
    gammaVector = differenceVector.getScaled(
      2 * Vector2D.dot( differenceVector, object.vel.getShifted(this.parent.vel.getScaled(-1)) ) / (this.parent.mass + object.mass)
    );
    object.vel.shift(gammaVector.getScaled(-this.parent.mass));
    this.parent.vel.shift(gammaVector.getScaled(object.mass));
    
    // Correct intersection
    var correctionDistance = (this.parent.radius + object.radius) - distance,
        correctionVector = Vector2D.fromPolar(correctionDistance, this.parent.pos.angleBetween(object.pos)), 
        thisPortion = this.parent.mass / (this.parent.mass + object.mass);
    object.pos.shift(correctionVector.getScaled(thisPortion - 1));
    this.parent.pos.shift(correctionVector.getScaled(thisPortion));
  }
  collide(objects) {
    for (var i = 0, object; i < objects.length; i++) {
      object = objects[i];
      if (object === this.parent)
        continue;
      
      this._collide(object);
    }
  }
  
  update(objects) {
    this.walls();
    this.collide(objects);
  }
}
class Gravitator {
  
  constructor(parent) {
    this.parent = parent;
  }
  
  gravitate(objects) {
    for (var i = 0, object, differenceVector, force; i < objects.length; i++) {
      object = objects[i];
      if (object === this.parent)
        continue;
      
      differenceVector = object.pos.getShifted(this.parent.pos.getScaled(-1));
      force = differenceVector.getScaled(G * object.mass * this.parent.mass / differenceVector.magnitudeSquared);
      this.parent.applyForce(force);
    }
  }
}
class Object2D {
  
  constructor(pos, vel, mass, radius) {
    this.pos = pos;
    this.vel = vel;
    this.mass = mass;
    this.radius = radius;
    this.collider = new Collider(this);
    this.gravitator = new Gravitator(this);
  }
  
  applyForce(force) {
    this.vel.shift(force.getScaled(1 / this.mass));
  }
  
  physics() {
    this.collider.update(GC.particles);
    this.gravitator.gravitate(GC.particles);
    this.pos.shift(this.vel);
  }
}
class Particle extends Object2D {
​
  display() {
    fill(0, 0, 0);
    ellipse(this.pos.x, this.pos.y, this.radius*2, this.radius*2);
  }
  
  update() {
    this.physics();
    this.display();
  }
}
​
class GameController {
  
  constructor() {
    this.particles = [];
    var speed = WIDTH / 400, angle, massMax = 2e10, mass;
    for (var i = 0; i < PARTICLE_COUNT; i++) {
      angle = Math.random() * 2*Math.PI;
      mass = Math.random() * massMax;
      this.particles.push(new Particle(
        new Vector2D((Math.random() - 1/2) * WIDTH*0.9, (Math.random() - 1/2) * HEIGHT*0.9),
        Vector2D.fromPolar(speed, angle),
        mass,
        Math.pow(mass, 1/10) * HEIGHT / 800
      ));
    }
  }
  
  update() {
    for (var i = 0, particle; i < this.particles.length; i++) {
      particle = this.particles[i];
      particle.update();
    }
  }
  
}
​
var GC = new GameController();
​
function setup() {
  createCanvas(windowWidth, windowHeight); // window.innerWidth, window.innerHeight
  noStroke();
}
​
function draw() {
  background(60, 200, 255);
  translate(windowWidth/2, windowHeight/2);
  
  GC.update();
}