Predator/Prey 02

let boids = [];

let evilBoids = [];

let food = [];

let obstacles = [];

let maxFood = 50;

let maxObstacles = 10;

​

function setup() {

  createCanvas(1800, 900);

​

  // Initialize boids and evil boids

  for (let i = 0; i < 100; i++) {

    boids.push(new Boid(random(width), random(height)));

  }

  for (let i = 0; i < 10; i++) {

    evilBoids.push(new EvilBoid(random(width), random(height)));

  }

​

  // Generate initial food and obstacles

  generateFood();

  generateObstacles();

}

​

function draw() {

  // Create impressionist background

  let bgColor = color(0, 0, 0, 2);

  noStroke();

  fill(bgColor);

  rect(0, 0, width, height);

​

  // Display and handle food

  displayFood();

  while (food.length < maxFood) {

    food.push(createVector(random(width), random(height)));

  }

​

  // Display obstacles

  displayObstacles();

​

  // Update and display boids

  for (let i = boids.length - 1; i >= 0; i--) {

    let boid = boids[i];

    boid.flock(boids);

    boid.update(food, obstacles, evilBoids);

    boid.show();

    if (boid.isDead()) {

      food.push(createVector(boid.position.x, boid.position.y)); // Return energy to ecosystem

      let offspring = boid.reproduce();

      if (offspring) boids.push(offspring);

      boids.splice(i, 1);

    }

  }

​

  // Update and display evil boids

  for (let i = evilBoids.length - 1; i >= 0; i--) {

    let evil = evilBoids[i];

    evil.update(boids, obstacles);

    evil.show();

    if (evil.isDead()) {

      let offspring = evil.reproduce();

      if (offspring) evilBoids.push(offspring);

      evilBoids.splice(i, 1);

    }

  }

}

​

class Boid {

  constructor(x, y, traits) {

    this.position = createVector(x, y);

    this.velocity = p5.Vector.random2D();

    this.acceleration = createVector();

    this.traits = traits || {

      speed: random(2, 5),

      energy: random(50, 150),

      awareness: random(50, 150),

      lifespan: random(3000, 5000),

    };

    this.energy = this.traits.energy;

    this.age = 0;

    this.maxForce = 0.2;

    this.mouthOpen = false; // State for animated mouth

    this.color = color(random(0, 50), random(100, 255), random(200, 255), 150);

  }

​

  flock(boids) {

    let separation = this.separate(boids).mult(1.5);

    let alignment = this.align(boids).mult(1.0);

    let cohesion = this.cohere(boids).mult(1.0);

​

    this.applyForce(separation);

    this.applyForce(alignment);

    this.applyForce(cohesion);

  }

​

  update(food, obstacles, predators) {

    this.age++;

    this.energy -= this.traits.speed * 0.01;

​

    this.eat(food);

    this.avoidObstacles(obstacles);

    this.flee(predators);

​

    this.velocity.add(this.acceleration);

    this.velocity.limit(this.traits.speed);

    this.position.add(this.velocity);

    this.acceleration.mult(0);

​

    this.wrapAround();

  }

​

  applyForce(force) {

    this.acceleration.add(force);

  }

​

  eat(food) {

    this.mouthOpen = false;

    for (let i = food.length - 1; i >= 0; i--) {

      let d = distSq(this.position, food[i]);

      if (d < 16) {

        this.energy += 20;

        food.splice(i, 1);

        this.mouthOpen = true;

      }

    }

  }

​

  avoidObstacles(obstacles) {

    for (let obs of obstacles) {

      let d = distSq(this.position, obs);

      if (d < 400) {

        let flee = p5.Vector.sub(this.position, obs).normalize().mult(this.traits.speed);

        this.applyForce(flee);

      }

    }

  }

​

  flee(predators) {

    for (let predator of predators) {

      let d = distSq(this.position, predator.position);

      if (d < predator.traits.awareness) {

        let flee = p5.Vector.sub(this.position, predator.position).normalize().mult(this.traits.speed);

        this.applyForce(flee);

      }

    }

  }

​

  wrapAround() {

    if (this.position.x > width) this.position.x = 0;

    if (this.position.x < 0) this.position.x = width;

    if (this.position.y > height) this.position.y = 0;

    if (this.position.y < 0) this.position.y = height;

  }

​

  isDead() {

    return this.energy <= 0 || this.age >= this.traits.lifespan;

  }

​

  reproduce() {

    if (this.age > this.traits.lifespan - 4000) {

      let mutationRate = 0.1;

      let newTraits = {

        speed: constrain(this.traits.speed + random(-mutationRate, mutationRate), 2, 5),

        energy: constrain(this.traits.energy + random(-mutationRate, mutationRate) * 20, 50, 150),

        awareness: constrain(this.traits.awareness + random(-mutationRate, mutationRate) * 10, 50, 150),

        lifespan: constrain(this.traits.lifespan + random(-mutationRate, mutationRate) * 500, 3000, 5000),

      };

      return new Boid(this.position.x, this.position.y, newTraits);

    }

    return null;

  }

​

  show() {

    push();

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

    rotate(this.velocity.heading());

    stroke(this.color);

    strokeWeight(6);

    line(0, 0, -10, 0); // Body

    fill(255);

    ellipse(-12, 0, 5, this.mouthOpen ? 10 : 5); // Mouth animation

    pop();

  }

​

  // Flocking behaviors

  separate(boids) {

    let desiredSeparation = 25;

    let steer = createVector();

    let count = 0;

    for (let other of boids) {

      let d = distSq(this.position, other.position);

      if (d > 0 && d < desiredSeparation * desiredSeparation) {

        let diff = p5.Vector.sub(this.position, other.position);

        diff.normalize();

        diff.div(sqrt(d));

        steer.add(diff);

        count++;

      }

    }

    if (count > 0) {

      steer.div(count);

    }

    if (steer.mag() > 0) {

      steer.setMag(this.traits.speed);

      steer.sub(this.velocity);

      steer.limit(this.maxForce);

    }

    return steer;

  }

​

  align(boids) {

    let neighborDist = 50;

    let sum = createVector();

    let count = 0;

    for (let other of boids) {

      let d = distSq(this.position, other.position);

      if (d > 0 && d < neighborDist * neighborDist) {

        sum.add(other.velocity);

        count++;

      }

    }

    if (count > 0) {

      sum.div(count);

      sum.setMag(this.traits.speed);

      let steer = p5.Vector.sub(sum, this.velocity);

      steer.limit(this.maxForce);

      return steer;

    }

    return createVector();

  }

​

  cohere(boids) {

    let neighborDist = 50;

    let sum = createVector();

    let count = 0;

    for (let other of boids) {

      let d = distSq(this.position, other.position);

      if (d > 0 && d < neighborDist * neighborDist) {

        sum.add(other.position);

        count++;

      }

    }

    if (count > 0) {

      sum.div(count);

      return this.seek(sum);

    }

    return createVector();

  }

​

  seek(target) {

    let desired = p5.Vector.sub(target, this.position);

    desired.setMag(this.traits.speed);

    let steer = p5.Vector.sub(desired, this.velocity);

    steer.limit(this.maxForce);

    return steer;

  }

}

​

// EvilBoid class

class EvilBoid {

  constructor(x, y) {

    this.position = createVector(x, y);

    this.velocity = p5.Vector.random2D();

    this.acceleration = createVector();

    this.traits = {

      speed: random(2, 5),

      energy: random(50, 150),

      awareness: random(100, 200),

      lifespan: random(2000, 4000),

    };

    this.energy = this.traits.energy;

    this.age = 0;

    this.maxForce = 0.2;

    this.color = color(255, 0, 0, 150);

    this.mouthOpen = false;

  }

​

  update(boids, obstacles) {

    this.age++;

    this.energy -= this.traits.speed * 0.01;

    this.hunt(boids); 

    this.avoidObstacles(obstacles);

    this.velocity.add(this.acceleration);

    this.velocity.limit(this.traits.speed);

    this.position.add(this.velocity);

    this.acceleration.mult(0);

​

    this.wrapAround();

  }

​

  hunt(boids) {

    let closestBoid = null;

    let record = Infinity;

    for (let boid of boids) {

      let d = distSq(this.position, boid.position);

      if (d < record) {

        record = d;

        closestBoid = boid;

      }

    }

    if (closestBoid) {

      let seek = p5.Vector.sub(closestBoid.position, this.position);

      seek.setMag(this.traits.speed);

      let steer = p5.Vector.sub(seek, this.velocity);

      steer.limit(this.maxForce);

      this.applyForce(steer);

      this.mouthOpen = true;

      this.consume(closestBoid);

    }

  }

​

  applyForce(force) {

    this.acceleration.add(force);

  }

​

  avoidObstacles(obstacles) {

    for (let obs of obstacles) {

      let d = distSq(this.position, obs);

      if (d < 400) {

        let flee = p5.Vector.sub(this.position, obs).normalize().mult(this.traits.speed);

        this.applyForce(flee);

      }

    }

  }

​

  consume(boid) {

    let d = distSq(this.position, boid.position);

    if (d < 16) {

      this.energy += boid.energy * 0.5;

      boid.energy = 0;

    }

  }

​

  wrapAround() {

    if (this.position.x > width) this.position.x = 0;

    if (this.position.x < 0) this.position.x = width;

    if (this.position.y > height) this.position.y = 0;

    if (this.position.y < 0) this.position.y = height;

  }

​

  isDead() {

    return this.energy <= 0 || this.age >= this.traits.lifespan;

  }

​

  reproduce() {

    if (this.age > this.traits.lifespan - 3000) {

      let mutationRate = 0.1;

      let newTraits = {

        speed: constrain(this.traits.speed + random(-mutationRate, mutationRate), 2, 5),

        energy: constrain(this.traits.energy + random(-mutationRate, mutationRate) * 20, 50, 150),

        awareness: constrain(this.traits.awareness + random(-mutationRate, mutationRate) * 10, 100, 200),

        lifespan: constrain(this.traits.lifespan + random(-mutationRate, mutationRate) * 500, 2000, 4000),

      };

      return new EvilBoid(this.position.x, this.position.y, newTraits);

    }

    return null;

  }

​

  show() {

    push();

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

    rotate(this.velocity.heading());

    stroke(this.color);

    strokeWeight(6);

    line(0, 0, -10, 0); 

    fill(255);

    ellipse(-12, 0, 10, this.mouthOpen ? 12 : 8); // Mouth animation

    pop();

  }

}

​

function distSq(v1, v2) {

  return (v1.x - v2.x) * (v1.x - v2.x) + (v1.y - v2.y) * (v1.y - v2.y);

}

​

function generateFood() {

  while (food.length < maxFood) {

    food.push(createVector(random(width), random(height)));

  }

}

​

function displayFood() {

  fill(34, 139, 34, 200); // Green color

  noStroke();

  for (let i = 0; i < food.length; i++) {

    ellipse(food[i].x, food[i].y, 8, 8);

  }

}

​

function generateObstacles() {

  while (obstacles.length < maxObstacles) {

    obstacles.push(createVector(random(width), random(height)));

  }

}

​

function displayObstacles() {

  fill(0, 0, 0, 150); // Brown color

  for (let i = 0; i < obstacles.length; i++) {

    ellipse(obstacles[i].x, obstacles[i].y, 30, 30);

  }

}

​