Behlool chapter3 solutions

chapter3/Exercise_3_1/Exercise_3_1.pde

@@ -0,0 +1,26 @@
+PVector ballOne;
+PVector ballTwo;
+float angle = 0;
+
+
+void setup() {
+
+    size(640, 360);
+    ballOne = new PVector(0, -50);
+    ballTwo = new PVector(0, 50);
+
+}
+
+void draw() {
+    background(255);
+    fill(175);
+    strokeWeight(2);
+    pushMatrix();
+    translate(width/2, height/2);
+    rotate(angle);
+    circle(ballOne.x, ballOne.y, 20);
+    circle(ballTwo.x, ballTwo.y, 20);
+    line(ballOne.x, ballOne.y+10, ballTwo.x, ballTwo.y-10);
+    popMatrix();
+    angle += 0.1;
+}

chapter3/Exercise_3_2/Exercise_3_2.pde

@@ -0,0 +1,19 @@
+Mover ball;
+float G = (float) 0.1;
+
+void setup() {
+    size(640, 360);
+    ball = new Mover(new PVector(0, height/2), 0.5);
+    ball.applyForce(new PVector(2.5, -2.5));
+}
+
+void draw() {
+    background(255);
+    //apply weight
+    //
+    float ball_mass = (float) ball.getMass();
+
+    ball.applyForce(new PVector(0.0, G*ball_mass));
+    ball.update();
+    ball.draw();
+}

chapter3/Exercise_3_2/mover.pde

@@ -0,0 +1,55 @@
+class Mover {
+
+    PVector location;
+    PVector acceleration;
+    PVector velocity;
+    double mass;
+
+    float angle;
+    float aAcceleration;
+    float aVelocity;
+
+    public Mover(PVector location_, double mass_) {
+        this.location = location_;
+        this.acceleration = new PVector (0, 0);
+        this.velocity = new PVector(0, 0);
+        this.mass = mass_;
+    }
+
+    public void applyForce(PVector force) {
+        PVector copyForce = PVector.mult(force, 1);
+        copyForce.div((float) mass); //resultant acceleration
+        acceleration.add(copyForce);
+    }
+
+    public void update() {
+        velocity.add(acceleration);
+        location.add(velocity);
+
+        aAcceleration = acceleration.y/10.0;
+        aVelocity += aAcceleration;
+        aVelocity = constrain(aVelocity,-0.1,0.1);
+
+        acceleration.mult(0);
+
+        angle += aVelocity;
+    }
+
+    public void draw() {
+        fill(175);
+
+        pushMatrix();
+
+        translate(location.x, location.y);
+        rectMode(CENTER);
+        rotate(angle);
+        rect(0, 0, 20, 20);
+
+        popMatrix();
+    }
+
+    public double getMass() {
+        return mass;
+    }
+
+}

chapter3/Exercise_3_3/Exercise_3_3.pde

@@ -0,0 +1,26 @@
+Mover car;
+float G = (float) 0.5;
+
+void setup() {
+    size(640, 360);
+    car = new Mover(new PVector(0, height/2), 0.5);
+}
+
+void draw() {
+    background(255);
+    car.update();
+    car.draw();
+}
+
+void keyPressed() {
+    float car_mass = (float) car.getMass();
+    if (key == CODED) {
+        if (keyCode == RIGHT) {
+            car.applyForce(new PVector(G*car_mass, 0.0));
+        }
+        else if (keyCode == LEFT) {
+            car.applyForce(new PVector(-G*car_mass, 0.0));
+        }
+    }
+
+}

chapter3/Exercise_3_3/mover.pde

@@ -0,0 +1,46 @@
+class Mover {
+
+    PVector location;
+    PVector acceleration;
+    PVector velocity;
+    double mass;
+
+    public Mover(PVector location_, double mass_) {
+        this.location = location_;
+        this.acceleration = new PVector (0, 0);
+        this.velocity = new PVector(0, 0);
+        this.mass = mass_;
+    }
+
+    public void applyForce(PVector force) {
+        PVector copyForce = PVector.mult(force, 1);
+        copyForce.div((float) mass); //resultant acceleration
+        acceleration.add(copyForce);
+    }
+
+    public void update() {
+        velocity.add(acceleration);
+        location.add(velocity);
+
+        acceleration.mult(0);
+
+    }
+
+    public void draw() {
+        fill(175);
+        strokeWeight(1);
+        pushMatrix();
+        translate(location.x, location.y);
+        rectMode(CENTER);
+        rect(0, 0, 20, 20);
+        fill(0);
+        strokeWeight(2);
+        line(0, 0, 4*velocity.x, 4*velocity.y);
+        popMatrix();
+    }
+
+    public double getMass() {
+        return mass;
+    }
+
+}

chapter3/Exercise_3_4/Exercise_3_4.pde

@@ -0,0 +1,22 @@
+
+float theta = 0;
+float r = 75*theta;
+float a = 0.001;
+
+void setup() {
+    size(640,360);
+    background(255);
+}
+void draw() {
+    float x = r * cos(theta);
+    float y = r * sin(theta);
+
+    noStroke();
+    fill(0);
+    ellipse(x+ width/2, y+height/2, 6, 6);
+
+    theta += 0.01;
+    a+=0.001;
+    r = 75*a;
+
+}

chapter3/Exercise_3_5/Exercise_3_5.pde

@@ -0,0 +1,32 @@
+SpaceShip ship;
+
+void setup() {
+    size(640, 360);
+    ship = new SpaceShip(new PVector(0, height), 0.5);
+}
+
+void draw() {
+    background(255);
+    ship.update();
+    ship.draw();
+}
+
+void keyPressed() {
+
+    if (key == CODED) {
+        if (keyCode == RIGHT) {
+            ship.rotateClockwise();
+        }
+        else if (keyCode == LEFT) {
+            ship.rotateAntiClockwise();
+        }
+    }
+
+    else if ((key == 'Z') || (key == 'z')) {
+        PVector velocity = ship.getVelocity();
+        velocity.normalize();
+        PVector thrust = velocity.mult(1.5);
+        ship.applyForce(thrust);
+    }
+
+}

chapter3/Exercise_3_5/spaceShip.pde

@@ -0,0 +1,62 @@
+class SpaceShip {
+
+    PVector location;
+    PVector acceleration;
+    PVector velocity;
+
+    double mass;
+    float angle;
+
+    public SpaceShip(PVector location_, double mass_) {
+        this.location = location_;
+        this.acceleration = new PVector (0, 0);
+        this.velocity = new PVector(0.5, -0.25);
+        this.mass = mass_;
+        angle = 0.0;
+    }
+
+    public void applyForce(PVector force) {
+        PVector copyForce = PVector.mult(force, 1);
+        copyForce.div((float) mass); //resultant acceleration
+        acceleration.add(copyForce);
+    }
+
+    public void update() {
+        velocity.add(acceleration);
+        location.add(velocity);
+
+        acceleration.mult(0);
+
+    }
+
+    public void draw() {
+
+        fill(175);
+        pushMatrix();
+        translate(location.x, location.y);
+        rectMode(CENTER);
+        rotate(angle);
+        rect(0, 0, 20, 20);
+        popMatrix();
+
+    }
+
+    public double getMass() {
+        return mass;
+    }
+
+    public PVector getVelocity() {
+        return velocity;
+    }
+
+    public void rotateClockwise() {
+        angle += 0.1;
+        velocity.rotate(angle);
+    }
+
+    public void rotateAntiClockwise() {
+        angle -= 0.1;
+        velocity.rotate(angle);
+    }
+
+}

chapter3/Exercise_3_6/Exercise_3_6.pde

@@ -0,0 +1,25 @@
+int frameCount = 0;
+float period = 120;
+float amplitude = 100;
+
+void setup() {
+    size(640,360);
+}
+void draw() {
+    background(255);
+
+    float y = cos(TWO_PI * frameCount / period);
+
+    stroke(0);
+    fill(175);
+
+    pushMatrix();
+
+    translate(width/2,height/2);
+    float displacement = map(y, -1, 1, 0, amplitude);
+    line(0,0,0,displacement);
+    ellipse(0,displacement,20,20);
+
+    popMatrix();
+    frameCount+=1;
+}

chapter3/Exercise_3_7/Exercise_3_7.pde

@@ -0,0 +1,18 @@
+Oscillator[] oscillators = new Oscillator[10];
+
+void setup() {
+  size(640, 360);
+  // Initialize all objects
+  for (int i = 0; i < 10; i++) {
+    oscillators[i] = new Oscillator(i);
+  }
+}
+
+void draw() {
+  background(255);
+  // Run all objects
+  for (int i = 0; i < oscillators.length; i++) {
+    oscillators[i].update();
+    oscillators[i].show();
+  }
+}

chapter3/Exercise_3_7/oscillator.pde

@@ -0,0 +1,41 @@
+// The Nature of Code
+// Daniel Shiffman
+// http://natureofcode.com
+
+class Oscillator {
+  PVector angle, angleVelocity, amplitude;
+
+  public Oscillator(int index) {
+    this.angle = new PVector();
+    this.amplitude = new PVector(
+      50, 50
+    );
+    if (index <= 5) {
+      this.angleVelocity = new PVector(0.05, 0.05);
+      this.angleVelocity.rotate(-22.5*index);
+    }
+    else {
+      this.angleVelocity = new PVector(-0.05, 0.05);
+      this.angleVelocity.rotate(22.5*index);
+    }
+
+  }
+
+  void update() {
+    this.angle.add(this.angleVelocity);
+  }
+
+  void show() {
+    float x = sin(this.angle.x) * this.amplitude.x;
+    float y = sin(this.angle.y) * this.amplitude.y;
+
+    push();
+    translate(width / 2, height / 2);
+    stroke(0);
+    strokeWeight(2);
+    fill(127);
+    line(0, 0, x, y);
+    circle(x, y, 32);
+    pop();
+  }
+}