constructor(x, y, color) {

    this.pos = createVector(x, y);

    this.vel = createVector(0, 0);

    this.acc = createVector(0, 0);

    this.maxSpeed = 8;

    this.maxForce = 0.5;

    this.r = 24;

    this.color = color;

    this.xoff = 0.0;

  }

​

  applyForce(force) {

    this.acc.add(force);

  }

​

  arrive(target) {

    // 2nd argument true enables the arrival behavior

    return this.seek(target, true);

  }

​

  evade(vehicle) {

    let pursuit = this.pursue(vehicle);

    pursuit.mult(-1);

    return pursuit;

  }

​

  follow(path) {

    // Path following algorithm here!!

​

    // Step 1 calculate future position

    let future = this.vel.copy();

    future.mult(20);

    future.add(this.pos);

    if (debug) {

      fill(255, 127);

      noStroke();

      circle(future.x, future.y, 16);

    }

​

    // Step 2 Is future on path?

    let target = findProjection(path.start, future, path.end);

    if (debug) {

      fill(0, 255, 0);

      noStroke();

      circle(target.x, target.y, 16);

    }

    let d = p5.Vector.dist(future, target);

    if (d > path.radius) {

      return this.seek(target);

    } else {

      return createVector(0, 0);

    }

  }

​

  pursue(vehicle) {

    let target = vehicle.pos.copy();

    let prediction = vehicle.vel.copy();

    prediction.mult(2);

    target.add(prediction);

    return this.seek(target);

  }

​

  flee(target) {

    //oposite of seek

    return this.seek(target).mult(-1);

  }

​

  seek(target, arrival = false) {

    let force = p5.Vector.sub(target, this.pos);

    let desiredSpeed = this.maxSpeed;

    if (arrival) {

      let slowRadius = 100;

      let distance = force.mag();

      if (distance < this.slowRadius) {

        desiredSpeed = map(distance, 0, slowRadius, 0, this.maxSpeed);

      }

    }

    force.setMag(desiredSpeed);

    force.sub(this.vel);

    force.limit(this.maxForce);

    return force;

  }

​

  show() {

    //stroke(0);

    noStroke();

    fill(this.color);

    push();

    translate(this.pos.x, this.pos.y);

    rotate(this.vel.heading());

    triangle(

      -this.r,

      -this.r / 2,

      -this.r,

      this.r / 2,

      map(this.vel.mag(), 0, this.maxSpeed, 0, this.r),

      0

    );

    pop();

  }

​

  edges() {

    if (this.pos.x > width + this.r) {

      this.pos.x -= this.r;

      this.vel.mult(-1);

    } else if (this.pos.x < -this.r) {

      this.pos.x += this.r;

      this.vel.mult(-1);

    }

    if (this.pos.y > height + this.r) {

      this.pos.y -= this.r;

      this.vel.mult(-1);

    } else if (this.pos.y < -this.r) {

      this.pos.x += this.r;

      this.vel.mult(-1);

    }

  }

​

  wander() {

    // let force = p5.Vector.random2D();

    // this.applyForce(force);

    let wanderPoint = this.vel.copy();

    wanderPoint.setMag(10);

    wanderPoint.add(this.pos);

​

    let wanderRadius = 50;

    if (debug) {

      noFill();

      stroke(255, 127, 127);

      circle(wanderPoint.x, wanderPoint.y, 8);

      line(this.pos.x, this.pos.y, wanderPoint.x, wanderPoint.y);

      stroke(127, 255, 127);

      circle(wanderPoint.x, wanderPoint.y, wanderRadius * 2);

    }

​

    //let theta = noise(this.xoff) + this.vel.heading();

    let theta = random(0,1) + this.vel.heading();

    let x = wanderRadius * cos(theta);

    let y = wanderRadius * sin(theta);

​

    wanderPoint.add(x, y);

    if (debug) {

      stroke(127, 127, 255);

      circle(wanderPoint.x, wanderPoint.y, 8);

      line(this.pos.x, this.pos.y, wanderPoint.x, wanderPoint.y);

    }

    let steer = wanderPoint.sub(this.pos);

    steer.setMag(this.maxForce);

    this.applyForce(steer);

  }

​

  update() {

    this.vel.add(this.acc);

    this.vel.limit(this.maxSpeed);

    this.pos.add(this.vel);

    this.acc.set(0, 0);

    //this.xoff = this.xoff + 0.1; //for perlin noise

  }

}

​