Week 8: Particle String against attractor

Particle_String_with_Cons
xxxxxxxxxx
 
Particle[] particles = new Particle[300];
//Liquid liquid;
Attractor a;
 
void setup() {
  size(640,640);
  a = new Attractor();
  for (int i =0; i<particles.length; i++) {
    particles[i] = new Particle(i+2,random(.5,3));
  }
}
    //liquid = new Liquid(0,height/2, width, height/2, .1);
 
void draw() {
  background(255);
  // PVector wind = new PVector(0,0);
  a.drawAttractor();
  
  for (int i =0; i<particles.length; i++) {
    //if (liquid.contains(particles[i])) {
     // PVector dragForce = liquid.defineAirRes(particles[i]);
      //particles[i].applyForce(dragForce);
    //}
    // We scale gravity by mass to make it more realistic. Otherwise smaller objects fall faster
    // than large objects, which does not really occur in nature.
    PVector attractForce = a.defineAttractForce(particles[i],200,1,600);
    particles[i].applyForce(attractForce);
    
    float m = particles[i].mass;
    PVector gravity = new PVector(0,0.1*m);
    // Define our boundary forces to make particles stick to sides and not leave the box
    PVector n = particles[i].defineConstrainingForceNorth(35);
    PVector s = particles[i].defineConstrainingForceSouth(35);
    PVector e = particles[i].defineConstrainingForceEast(35);
    PVector w = particles[i].defineConstrainingForceWest(35);
    PVector friction = particles[i].defineFriction(.001);
    particles[i].applyForce(friction);
    particles[i].applyForce(n);
    particles[i].applyForce(s);
    particles[i].applyForce(e);
    particles[i].applyForce(w);
    // particles[i].applyForce(wind);
    particles[i].applyForce(gravity);
    particles[i].motion();
    particles[i].drawParticles();
    //particles[i].constraints();
  }
}
 
class Attractor {
  float mass;
  PVector location;
  
  Attractor() {
    location = new PVector(width/2, height/2);
    mass = 20;
  }
  
  void drawAttractor() {
    noStroke();
    fill(125 + sin(radians(frameCount))*125, 125 + cos(radians(frameCount))*125, 125 + sin(radians(-frameCount))*125);
    ellipse(location.x, location.y, mass*2, mass*2);
  }
  
  PVector defineAttractForce(Particle p, float g, float minDistance, float maxDistance) {
    
    PVector forceDir = PVector.sub(location, p.location);
    float distance = forceDir.mag();
    distance = constrain(distance, minDistance, maxDistance);
    forceDir.normalize();
    float forceMag = (g*mass * p.mass)/(distance*distance);
    PVector attractForce = PVector.mult(forceDir, forceMag); 
    return attractForce;
  }
}
class Particle {
  PVector location;
  PVector velocity;
  PVector acceleration;
  float topSpeed;
  float mass;
   
  Particle(int topSpeed_, float m) {
    location = new PVector(random(width), random(height));
    velocity = new PVector(random(-5,5),random(-5,5));
    topSpeed = topSpeed_;
    acceleration = new PVector(0,0);
    mass = m;
  }
  
  void applyForce(PVector force){
    PVector f = PVector.div(force, mass);
    acceleration.add(f);
   
  }
  
   PVector defineConstrainingForceNorth(float constantN) {
    
    float consForceMag = constantN/((dist(location.x,0,width,0)*dist(location.x,0,width,0))+1);
    PVector consForceDir = velocity.get();
    consForceDir.mult(-1);
    consForceDir.normalize();
    PVector forceNorth = PVector.mult(consForceDir,consForceMag);
    return forceNorth;
  }
  
  PVector defineConstrainingForceSouth(float constantS) {
    float consForceMag = constantS/((dist(location.x,0,0,0)*dist(location.x,0,0,0))+1);
    PVector consForceDir = velocity.get();
    consForceDir.mult(-1);
    consForceDir.normalize();
    PVector forceSouth = PVector.mult(consForceDir,consForceMag);
    return forceSouth;
    
  }
  
  PVector defineConstrainingForceEast(float constantE) {
    float consForceMag = constantE/((dist(0,location.y,0,height)*dist(0,location.y,0,height))+1);
    PVector consForceDir = velocity.get();
    consForceDir.mult(-1);
    consForceDir.normalize();
    PVector forceEast = PVector.mult(consForceDir,consForceMag);
    return forceEast;
  }
  
  PVector defineConstrainingForceWest(float constantW) {
    float consForceMag = constantW/((dist(0,location.y,0,0)*dist(0,location.y,0,0))+1);
    PVector consForceDir = velocity.get();
    consForceDir.mult(-1);
    consForceDir.normalize();
    PVector forceWest = PVector.mult(consForceDir,consForceMag);
    return forceWest;
  }
  
  PVector defineFriction( float constantC) {
    float consForceMag = constantC;
    PVector consForceDir = velocity.get();
    consForceDir.mult(-1);
    consForceDir.normalize();
    PVector friction = PVector.mult(consForceDir, consForceMag);
    return friction;
  }
    
  void motion() {
    PVector mouse = new PVector(mouseX, mouseY);
    if (mousePressed) {
    PVector dir = PVector.sub(mouse,location);
    dir.normalize();
    dir.mult(.5);
    acceleration = dir;
    }
    velocity.add(acceleration);
    velocity.limit(topSpeed/70);
    location.add(velocity);
    acceleration.mult(0);
    
  }
   
  void drawParticles() {
    noStroke();
    fill(125 + sin(radians(frameCount))*125, 125 + cos(radians(frameCount))*125, 125 + sin(radians(-frameCount))*125);
    ellipse(location.x, location.y, mass*5, mass*5
   );
  }
   
  //void constraints() {
    //if ((location.x>width) || (location.x <0)) {
      //velocity.x = velocity.x * -1;
    //}
     
    //if ((location.y>height) || (location.y <0)) {
    //  velocity.y = velocity.y * -1;
  //}
//}
}
/* 
​
class Liquid {
  float x,y,w,h;
  float c;
  
  Liquid(float x_, float y_, float w_, float h_, float c_) {
    x = x_;
    y = y_;
    w = w_;
    h = h_;
    c = c_;
  }
  
  boolean contains(Particle p) {
    PVector l = p.location;
    return l.x > x && l.x < x + w && l.y > y && l.y < y + h;
  }
  
    PVector defineAirRes(Particle p) {
​
    float speed = p.velocity.mag();
    float forceMag = c * speed * speed;
​
    PVector forceDir = p.velocity.get();
    forceDir.mult(-1);
    forceDir.normalize();
    PVector dragForce = PVector.mult(forceDir, forceMag); 
    return dragForce;
  }
  
  void drawAirPockets() {
    noStroke();
    fill(175);
    ellipse(x,y,w,h);
  }
} 
​
*/
​
​