互动编程习作——表现随机行为及牛顿运动学

互动编程习作——表现随机行为及牛顿运动学

主题：创作一组编程习作，体现随机行为及牛顿运动学

要求：

编程语言与工具：编程工具不限；
作品：参考《代码本色》的第0~4章内容及其实例程序（自行在processing内下载），针对这5章分别编写1个习作（一共5个），每个习作都有不少于2个案例参考，且必须有一定的拓展；

第0章 引言

float yoff = 0.0;        

void setup() {
  size(800,600);
  }

void draw() {
  clear();
  background(255);
  strokeWeight(5);
  stroke(0,71,157);
  fill(0,160,233);
  beginShape();
  float xoff = 0;   
  for (float x = 0; x <= width; x += 5) {
    float y = map(noise(xoff,yoff),0,1,150,250 );     
    vertex(x, y);      
    xoff += 0.05;
  }
   for (float x2 = width; x2 >=0; x2 -= 5) {      
     float y2 = map(noise(xoff, yoff),0,1,350,450);      
     vertex(x2, y2);    
     xoff += 0.05;
   }
   yoff += 0.01;
   endShape(CLOSE);  
 }

第1章 向量

class Mover {
  PVector position;
  PVector velocity;
  PVector acceleration;
  float topspeed;

  Mover() {
    position = new PVector(random(width),random(height));
    velocity = new PVector(0,0);
    topspeed = 5;
  }

  void update() {
    PVector mouse = new PVector(mouseX,mouseY);
    acceleration = PVector.sub(mouse,position);  
    acceleration.normalize();
    acceleration.mult(0.1);
    velocity.add(acceleration);
    topspeed= 5;
    velocity.limit(topspeed); 
    position.add(velocity);
  }

  void display() {
    rectMode(CENTER);
    fill(0);
    ellipse(position.x,position.y,100,100);
  }
}

Mover movers = new Mover();
void setup() {
  size(800,800);
  movers = new Mover(); 
}

void draw() {
  background(255);
  movers.update();
  movers.display(); 
}

第2章 力

void setup() {
  size(800,800);
  int n = 10;
  particles = new Particle[n];
  
  for (int i = 0; i < n; i++) {
    PVector p = new PVector(random(0, width), random(0, height));
    particles[i] = new Particle(p);
  }
}

Particle[] particles;
void sence1() {
  int n = 10;
  background(0);
  for (int i = 0; i < n; i++) {
    particles[i].addForce(particles[i].attractTo(mouseX, mouseY));
    particles[i].run();
  }
}

class Particle {
  PVector acc, vel, pos;
  float  incr, ang;

  Particle(PVector p) {
    pos = p.get();
    acc =  new PVector();
    vel = new PVector();
    ang = 0;
    incr = random(0.1, 0.1);   
  }

  void run() {
    update();
    render();
  }

  void update() {
    vel.add(acc);
    vel.limit(4);
    pos.add(vel);
    acc.mult(0);
  }

  void render() {
    float r = random(255);
    float g = random(255);
    float b = random(255);
    rectMode(CENTER);
    fill(r,g,b);
    ang += incr;
    pushMatrix();
    translate(pos.x, pos.y);
    rotate(degrees(ang));
    ellipse(0, 0, 100, 100);
    popMatrix();
  }

  void addForce(PVector force) {
    PVector f = PVector.div(force, 2);
    acc.add(f);
  }
  PVector attractTo(float x, float y) {
    PVector mousePos = new PVector(x, y);
    PVector dir = PVector.sub(mousePos, pos);
    float dist = dir.mag();
    dist = constrain(dist, 15, 25);
    dir.normalize();
    float f = 50/(dist*dist);
    dir.mult(f);
    return dir;
  }
}

void draw() {
  background(255);
  sence1();
}

第3章 振荡

class Pendulum {
  PVector position;   
  PVector origin;     
  float r;             
  float angle;        
  float aVelocity;     
  float aAcceleration;    
  float damping;       
  float angle_m=0; 
  
  Pendulum(PVector origin_, float r_) {
    position = new PVector();
    origin = origin_;
    r = r_;
    angle = PI/8;
    aVelocity = 0.0;
    aAcceleration = 0.0;
    damping = 1;  
  }

  void update() {
    float gravity = 1;                        
    aAcceleration = (-1 * gravity / r) * sin(angle);  
    aVelocity += aAcceleration;              
    aVelocity *= damping;                    
    angle += aVelocity;                        
    angle_m+=0.02;
  }

  void display() {
    position.set(r*sin(angle), r*cos(angle), 0);         
    position.add(origin);                          

    stroke(0);
    strokeWeight(5);
    pushMatrix(); 
    translate(width/2,height/2);
    rotate(angle_m);
    line(origin.x, origin.y, position.x, position.y);
    ellipseMode(CENTER);
    fill(230,0,18);
    ellipse(position.x, position.y, 100, 100);
    popMatrix();
  }
}

Pendulum p;
void setup() {
  size(800,800);
  p = new Pendulum(new PVector(0,0),250);
}

void draw() {
  background(255);
  p.update();
  p.display();
}

第4章 粒子系统

import java.util.Iterator;

ArrayList<ParticleSystem> systems;

void setup() {
  size(800,800);
  systems = new ArrayList<ParticleSystem>();
}

void draw() {
  background(255);
  PVector g = new PVector(0,0.1);
  for(ParticleSystem ps : systems) {  
    ps.applyForce(g);                
    ps.run();
    ps.addParticle();
  }
}

void mousePressed() {
  systems.add(new ParticleSystem(1,new PVector(mouseX,mouseY)));
}

class ParticleSystem {
  ArrayList<Particle> particles;
  PVector origin;
  
  ParticleSystem(int num,PVector v) {
    particles = new ArrayList<Particle>();
    origin = v.get();
    
    for(int i = 0; i < num; i++) {
      particles.add(new Particle(origin)); 
    }
  }
  
  void addParticle() {
    particles.add(new Particle(origin)); 
  }
  
  void addParticle(Particle p) {
    particles.add(p); 
  }
  
  void applyForce(PVector f){
    for(Particle p : particles){
      p.applyForce(f);
    }
  }
  
  void run() {
    Iterator<Particle> it = particles.iterator();  
    while(it.hasNext()) {
      Particle p = it.next();
      p.run();
      if(p.isDead()) {
        it.remove(); 
      }
    }    
  }
  
  boolean dead() {
    if(particles.isEmpty()) {
      return true; 
    }
    else {
      return false; 
    }
  }
}

class Particle {
  PVector location;
  PVector velocity;
  PVector acceleration;
  
  float lifespan;
  float mass=1;
  
  color c;
  
  Particle(PVector l) {
    acceleration = new PVector(0,0);
    velocity = new PVector(random(-1,1),random(-2,0));
    location = l.get();        
    lifespan = 255;
    
    c = color(random(255),random(255),random(255));
  }
  
  void run() {
    update();
    display();
  }
  
  void applyForce(PVector force) {
    PVector f=force.get();
    f.div(mass);
    acceleration.add(f);
  }
  
  void update() {
    velocity.add(acceleration);
    location.add(velocity);
    acceleration.mult(0);
    lifespan -= 2.0;
  }
  
  void display() {
    stroke(c,lifespan);
    strokeWeight(5);
    fill(c,lifespan);
    point(location.x,location.y);
  }
  
  boolean isDead() {
    if(lifespan < 0.0) {
      return true; 
    } else {
      return false; 
    }
  }
}


class PVector {
  float x;
  float y;
  
  PVector() {
    x = 0;
    y = 0;
  }
  
  PVector(float x_,float y_) {
    x = x_;
    y = y_;
  }
  
  PVector get() {
    PVector newVector = new PVector(x,y);
    return newVector;
  }
  
  void add(PVector v) {
    x = x + v.x; 
    y = y + v.y;
  }
  
  void sub(PVector v) {
    x = x - v.x;
    y = y - v.y;
  }
  
  void mult(float n) {
    x = x * n;
    y = y * n;
  }
  
  void div(float n) {
    x = x / n;
    y = y / n;
  }
  
  float mag() {
     return sqrt(x * x + y * y); 
  }
  
  void normalize() {
    float m = mag();
    if(m != 0) {
      div(m);  
    }
  }
  
  void limit(float max) {
    if(mag() > max) {
      normalize();
      mult(max);
    }
  }
  
  float heading2D() {
    return atan2(x,y); 
  }

}