Arrow.pde

// Arrow class implementing flocking behavior (Boids algorithm)
class Arrow {
  PVector position;
  PVector velocity;
  PVector acceleration;
  float maxForce;    // Maximum steering force
  float maxSpeed;    // Maximum speed
  float arrowSize;
  color arrowColor;

  Arrow(float x, float y) {
    position = new PVector(x, y);
    velocity = PVector.random2D();
    velocity.setMag(random(2, 4));
    acceleration = new PVector(0, 0);
    maxForce = 0.2;
    maxSpeed = 4;
    arrowSize = 12;
    arrowColor = color(random(200, 255), random(100, 200), random(150, 255), 200);
  }

  // Apply force to acceleration
  void applyForce(PVector force) {
    acceleration.add(force);
  }

  // Main flocking behavior
  void flock(ArrayList<Arrow> arrows) {
    PVector separation = separate(arrows);
    PVector alignment = align(arrows);
    PVector cohesion = cohere(arrows);

    // Weight these forces
    separation.mult(1.5);
    alignment.mult(1.0);
    cohesion.mult(1.0);

    // Apply all forces
    applyForce(separation);
    applyForce(alignment);
    applyForce(cohesion);
  }

  // Separation: steer to avoid crowding
  PVector separate(ArrayList<Arrow> arrows) {
    float desiredSeparation = 25.0;
    PVector steer = new PVector(0, 0);
    int count = 0;

    for (Arrow other : arrows) {
      float d = PVector.dist(position, other.position);
      if ((d > 0) && (d < desiredSeparation)) {
        PVector diff = PVector.sub(position, other.position);
        diff.normalize();
        diff.div(d); // Weight by distance
        steer.add(diff);
        count++;
      }
    }

    if (count > 0) {
      steer.div(count);
    }

    if (steer.mag() > 0) {
      steer.setMag(maxSpeed);
      steer.sub(velocity);
      steer.limit(maxForce);
    }
    return steer;
  }

  // Alignment: steer towards average heading
  PVector align(ArrayList<Arrow> arrows) {
    float neighborDist = 50;
    PVector sum = new PVector(0, 0);
    int count = 0;

    for (Arrow other : arrows) {
      float d = PVector.dist(position, other.position);
      if ((d > 0) && (d < neighborDist)) {
        sum.add(other.velocity);
        count++;
      }
    }

    if (count > 0) {
      sum.div(count);
      sum.setMag(maxSpeed);
      PVector steer = PVector.sub(sum, velocity);
      steer.limit(maxForce);
      return steer;
    }
    return new PVector(0, 0);
  }

  // Cohesion: steer towards average position
  PVector cohere(ArrayList<Arrow> arrows) {
    float neighborDist = 50;
    PVector sum = new PVector(0, 0);
    int count = 0;

    for (Arrow other : arrows) {
      float d = PVector.dist(position, other.position);
      if ((d > 0) && (d < neighborDist)) {
        sum.add(other.position);
        count++;
      }
    }

    if (count > 0) {
      sum.div(count);
      return seek(sum);
    }
    return new PVector(0, 0);
  }

  // Seek a target position
  PVector seek(PVector target) {
    PVector desired = PVector.sub(target, position);
    desired.setMag(maxSpeed);
    PVector steer = PVector.sub(desired, velocity);
    steer.limit(maxForce);
    return steer;
  }

  // Flee from a position (for mouse avoidance)
  PVector flee(PVector target) {
    PVector desired = PVector.sub(position, target);
    float d = desired.mag();

    if (d < 100) { // Only flee if mouse is close
      desired.setMag(maxSpeed);
      PVector steer = PVector.sub(desired, velocity);
      steer.limit(maxForce);
      return steer;
    }
    return new PVector(0, 0);
  }

  // Update position
  void update() {
    velocity.add(acceleration);
    velocity.limit(maxSpeed);
    position.add(velocity);
    acceleration.mult(0); // Reset acceleration
  }

  // Wrap around screen edges
  void borders() {
    if (position.x < -arrowSize) position.x = width + arrowSize;
    if (position.y < -arrowSize) position.y = height + arrowSize;
    if (position.x > width + arrowSize) position.x = -arrowSize;
    if (position.y > height + arrowSize) position.y = -arrowSize;
  }

  // Display the arrow
  void display() {
    float theta = velocity.heading() + PI/2;

    pushMatrix();
    translate(position.x, position.y);
    rotate(theta);

    fill(arrowColor);
    noStroke();

    // Draw arrow shape
    beginShape();
    vertex(0, -arrowSize);
    vertex(-arrowSize/3, arrowSize/2);
    vertex(0, arrowSize/4);
    vertex(arrowSize/3, arrowSize/2);
    endShape(CLOSE);

    popMatrix();
  }

  // Run the full arrow behavior
  void run(ArrayList<Arrow> arrows) {
    flock(arrows);
    update();
    borders();
    display();
  }
}