Simulating Natural Systems in Creative Code: Butterflies;

let chrysalises = [];
let butterflies = [];
let flowers = [];
let birds = [];  // Array for birds
let aliveButterflyCount = 0;  // Track how many butterflies are alive
let firstButterflyBornTime = 0; // Time the first butterfly is born
let lastButterflyTime = 0; // Time the last butterfly is eaten
const birdDelay = 60; // Delay in frames for the first bird
const chrysalisDelay = 120; // Delay in frames for the new chrysalis

function setup() {
  createCanvas(600, 400);
  colorMode(HSB, TWO_PI, 1, 1); // Set color mode to HSB with specified ranges
  noStroke();
  
  // Start with one chrysalis
  chrysalises.push(new Chrysalis(width / 2, height / 2));
  
  // Create more flowers
  for (let i = 0; i < 20; i++) {
    flowers.push(new Flower(random(width), random(height)));
  }
}

function draw() {
  background(3.5, 0.37, 1);  // Sky blue in HSB
  
  // Display and update all flowers
  for (let flower of flowers) {
    flower.update(); // Update the regrowth timer
    flower.show();
  }
  
  // Update and display all chrysalises
  for (let i = chrysalises.length - 1; i >= 0; i--) {
    let chrysalis = chrysalises[i];
    chrysalis.update();
    chrysalis.show();
    
    if (chrysalis.isButterfly()) {
      let butterflyColor = color(random(TWO_PI), 0.5, 1); // HSB color for butterfly
      butterflies.push(new Butterfly(chrysalis.x, chrysalis.y, butterflyColor));
      chrysalises.splice(i, 1);  // Remove chrysalis after it becomes a butterfly
      aliveButterflyCount++;  // Increment the count of currently alive butterflies
      // Start the timer when the first butterfly is born
      if (firstButterflyBornTime === 0) {
        firstButterflyBornTime = frameCount; // Record the frame count
      }
    }
  }
  
  // Update and display all butterflies
  for (let i = butterflies.length - 1; i >= 0; i--) {
    let butterfly = butterflies[i];
    butterfly.update();
    butterfly.show();
    butterfly.eat(flowers);
    
    // Check if butterfly is eaten by any bird
    for (let bird of birds) {
      if (butterfly.eatenBy(bird)) {
        butterflies.splice(i, 1);  // Remove butterfly if eaten by bird
        aliveButterflyCount--;  // Decrement the count of currently alive butterflies
        break;
      }
    }
  }
  
  // Update and display all birds (predators)
  for (let bird of birds) {
    bird.update();
    bird.show();
  }
  
  // Check if the first bird should be added
  if (firstButterflyBornTime > 0 && frameCount - firstButterflyBornTime >= birdDelay && birds.length === 0) {
    birds.push(new Bird());  // Add the first bird after the delay
  }
  
  // Check if a second bird should be added or removed
  if (aliveButterflyCount >= 4 && birds.length === 1) {
    birds.push(new Bird());  // Add second bird
  } else if (aliveButterflyCount < 4 && birds.length === 2) {
    birds.pop();  // Remove second bird
  }

  // Handle the case when all butterflies and chrysalises are gone
  if (butterflies.length === 0 && chrysalises.length === 0) {
    if (lastButterflyTime === 0) {
      lastButterflyTime = frameCount; // Record the frame count when the last butterfly is eaten
    } else if (frameCount - lastButterflyTime >= chrysalisDelay) {
      chrysalises.push(new Chrysalis(random(width), random(height)));  // Add a new chrysalis after delay
      lastButterflyTime = 0; // Reset the timer
    }
  }
}

class Chrysalis {
  constructor(x, y) {
    this.x = x;
    this.y = y;
    this.timeToTransform = 100;  // Frames until transformation
  }
  
  update() {
    this.timeToTransform--;
  }
  
  show() {
    fill(0.08 * TWO_PI, 1, 0.59);  // Simple chrysalis color in HSB
    ellipse(this.x, this.y, 10, 20);  // Simple chrysalis shape
  }
  
  isButterfly() {
    return this.timeToTransform <= 0;
  }
}

class Butterfly {
  constructor(x, y, color) {
    this.position = createVector(x, y);
    this.velocity = createVector(random(-3, 3), random(-3, 3));
    this.energy = 0;  // Energy level increases when eating
    this.color = color; // Store butterfly color
    this.size = 15; // Size of the butterflies
  }
  
  update() {
    // Update position based on velocity
    this.position.add(this.velocity);
    
    // Bounce off edges of the canvas
    if (this.position.x < 0 || this.position.x > width) {
      this.velocity.x *= -1;  // Reverse direction
    }
    if (this.position.y < 0 || this.position.y > height) {
      this.velocity.y *= -1;  // Reverse direction
    }
  }
  
  show() {
    fill(this.color); // Use the stored color
    noStroke();

    // Draw the two ellipses to form an "X"
    // First ellipse (rotated)
    push();
    translate(this.position.x, this.position.y);
    rotate(PI / 4); // Rotate by 45 degrees
    ellipse(0, 0, this.size * 1.5, this.size / 3); // Draw first ellipse (longer and skinnier)
    pop();
    
    // Second ellipse (rotated)
    push();
    translate(this.position.x, this.position.y);
    rotate(-PI / 4); // Rotate by -45 degrees
    ellipse(0, 0, this.size * 1.5, this.size / 3); // Draw second ellipse (longer and skinnier)
    pop();
  }
  
  eat(flowers) {
    for (let flower of flowers) {
      let d = dist(this.position.x, this.position.y, flower.x, flower.y);
      if (d < 20 && flower.isAlive) {
        this.energy++;
        flower.eaten();  // Mark flower as eaten
        if (this.energy >= 5) {
          chrysalises.push(new Chrysalis(this.position.x, this.position.y));  // Lay a new chrysalis
          this.energy = 0;
        }
      }
    }
  }
  
  eatenBy(bird) {
    let d = dist(this.position.x, this.position.y, bird.x, bird.y);
    return d < 30;  // If butterfly is close enough to the bird, it gets eaten
  }
}

class Flower {
  constructor(x, y) {
    this.x = x;
    this.y = y;
    this.isAlive = true; // Flower is initially alive
    this.regrowthTime = 200; // Time in frames to regrow after being eaten
    this.currentTime = 0; // Timer for regrowth
  }
  
  show() {
    if (this.isAlive) {
      fill(0, 1, 1); // Flower color in HSB (Red)
      // fill(random(TWO_PI), 1, 1); Flower color is random, but glitches
      ellipse(this.x, this.y, 10, 10);  // Simple flower shape
    }
  }
  
  eaten() {
    this.isAlive = false; // Mark flower as eaten
    this.currentTime = this.regrowthTime; // Reset timer
  }
  
  update() {
    if (!this.isAlive) {
      this.currentTime--;
      if (this.currentTime <= 0) {
        this.isAlive = true; // Flower regrows
      }
    }
  }
}

class Bird {
  constructor() {
    this.x = random(width);
    this.y = random(height);
    this.speed = random(1, 3);
  }
  
  update() {
    this.x += this.speed;
    if (this.x > width) {
      this.x = 0;
      this.y = random(height);  // Bird changes altitude randomly
    }
  }
  
  show() {
    fill(0, 0, 0); // Bird color in HSB (Black)
    ellipse(this.x, this.y, 30, 15);  // Simple bird shape
  }
}