AI Creature Evolution - xelsed.ai

constructor(x, y, parentGenes = null, generation = 0) {
    this.x = x;
    this.y = y;
    this.size = 20; // Initial size, grows with food, shrinks with hunger
    // Randomized color for visual distinction
    this.color = color(random(100, 255), random(100, 255), random(100, 255));
    this.speed = 2; // Base movement speed
    this.angle = random(TWO_PI); // Initial movement direction
    this.generation = generation; // Track which generation this creature belongs to

    // Genes (traits)
    if (parentGenes) {
      // If a parent's genes are provided, mutate them for the offspring
      this.genes = this.mutateGenes(parentGenes);
    } else {
      // First generation, randomize genes completely
      this.genes = {
        visionRadius: random(50, 200),     // How far it can see food
        hungerRate: random(0.02, 0.1),     // Size lost per frame (hunger)
        splitSize: random(35, 50),         // Size at which it splits into offspring
        mutationRate: random(0.01, 0.1),   // Probability of a gene mutating
        movementBias: random(-0.5, 0.5),   // Preference for turning left/right (-0.5 to 0.5)
        turnSpeed: random(0.02, 0.1)       // How quickly it can turn towards food/random direction
      };
    }
  }

update(foodPellets) {
    // 1. Hunger: Creature slowly shrinks over time
    this.size -= this.genes.hungerRate;

    // 2. Movement: Seek nearest food or move randomly with bias
    let nearestFood = null;
    let minDistance = this.genes.visionRadius;

    // Find the nearest food pellet within vision radius
    for (let food of foodPellets) {
      let d = dist(this.x, this.y, food.x, food.y);
      if (d < minDistance) {
        minDistance = d;
        nearestFood = food;
      }
    }

    if (nearestFood) {
      // If food is found, turn towards it
      let desiredAngle = atan2(nearestFood.y - this.y, nearestFood.x - this.x);
      // Calculate the shortest angular difference
      let angleDiff = desiredAngle - this.angle;
      angleDiff = (angleDiff + PI) % TWO_PI - PI; // Normalize angle difference to -PI to PI
      // Smoothly turn towards the food, constrained by turnSpeed
      this.angle += constrain(angleDiff, -this.genes.turnSpeed, this.genes.turnSpeed);
    } else {
      // No food in sight, move randomly with a slight bias
      this.angle += random(-this.genes.turnSpeed, this.genes.turnSpeed) + this.genes.movementBias * 0.05;
    }

    // Move the creature based on its speed and angle
    this.x += this.speed * cos(this.angle);
    this.y += this.speed * sin(this.angle);

    // 3. Boundary Wrapping: If creature goes off-screen, wrap around to the other side
    if (this.x < 0) this.x = width;
    if (this.x > width) this.x = 0;
    if (this.y < 0) this.y = height;
    if (this.y > height) this.y = 0;

    // 4. Death condition: If size falls below 5, creature dies
    if (this.size < 5) {
      return false; // Creature dies
    }

    return true; // Creature is alive
  }

show() {
    push();
    translate(this.x, this.y);
    rotate(this.angle); // Rotate to face movement direction (for eyes)

    // Body
    noStroke();
    fill(this.color);
    circle(0, 0, this.size);

    // Eyes (two small white circles offset from the center)
    fill(255);
    let eyeOffset = this.size / 4;
    let eyeSize = this.size / 8;
    circle(eyeOffset, -eyeSize, eyeSize * 1.5);
    circle(eyeOffset, eyeSize, eyeSize * 1.5);

    pop();

    // Optional: Draw vision radius for debugging (uncomment to see)
    // noFill();
    // stroke(255, 100);
    // circle(this.x, this.y, this.genes.visionRadius * 2);
  }

eat(food) {
    let d = dist(this.x, this.y, food.x, food.y);
    // Collision detection: Distance between centers is less than sum of radii
    if (d < this.size / 2 + food.size / 2) {
      this.size += 5; // Grow when eating food
      return true; // Food was eaten
    }
    return false; // Food not eaten
  }

split() {
    if (this.size > this.genes.splitSize) {
      // Create two new creatures with mutated genes and increment generation
      let offspring1 = new Creature(this.x + random(-5, 5), this.y + random(-5, 5), this.genes, this.generation + 1);
      let offspring2 = new Creature(this.x + random(-5, 5), this.y + random(-5, 5), this.genes, this.generation + 1);
      this.size /= 2; // Parent shrinks after splitting
      return [offspring1, offspring2];
    }
    return null; // Not ready to split
  }

mutateGenes(parentGenes) {
    let newGenes = {};
    for (let geneName in parentGenes) {
      let parentValue = parentGenes[geneName];
      let newValue = parentValue;

      // Apply mutation with a certain probability (based on parent's mutationRate)
      if (random(1) < parentGenes.mutationRate) {
        switch (geneName) {
          case 'visionRadius':
            newValue += random(-20, 20);
            newValue = constrain(newValue, 50, 300); // Clamp vision radius
            break;
          case 'hungerRate':
            newValue += random(-0.01, 0.01);
            newValue = constrain(newValue, 0.01, 0.15); // Clamp hunger rate
            break;
          case 'splitSize':
            newValue += random(-5, 5);
            newValue = constrain(newValue, 30, 60); // Clamp split size
            break;
          case 'mutationRate':
            newValue += random(-0.005, 0.005);
            newValue = constrain(newValue, 0.01, 0.1); // Clamp mutation rate
            break;
          case 'movementBias':
            newValue += random(-0.1, 0.1);
            newValue = constrain(newValue, -0.5, 0.5); // Clamp movement bias
            break;
          case 'turnSpeed':
            newValue += random(-0.01, 0.01);
            newValue = constrain(newValue, 0.01, 0.15); // Clamp turn speed
            break;
        }
      }
      newGenes[geneName] = newValue;
    }
    return newGenes;
  }

constructor(x, y) {
    this.x = x;
    this.y = y;
    this.size = 5;
    this.color = color(0, 200, 0); // Green food
  }

show() {
    noStroke();
    fill(this.color);
    circle(this.x, this.y, this.size);
  }

function setup() {
  createCanvas(windowWidth, windowHeight);
  background(0); // Dark background

  // Initialize with some first-generation creatures
  for (let i = 0; i < 10; i++) {
    creatures.push(new Creature(random(width), random(height), null, 0));
  }

  // Initialize with some food pellets
  for (let i = 0; i < 50; i++) {
    food.push(new Food(random(width), random(height)));
  }

  // Check for speech synthesis support
  if ('speechSynthesis' in window) {
    console.log("Speech synthesis is supported.");
  } else {
    console.warn("Speech synthesis not supported in this browser.");
  }

  // Initial narration
  speak("The simulation begins. Generation 0 is striving for survival.");
}

function draw() {
  background(0); // Clear background (dark)

  // Spawn new food periodically
  foodSpawnTimer++;
  if (foodSpawnTimer >= FOOD_SPAWN_INTERVAL) {
    food.push(new Food(random(width), random(height)));
    foodSpawnTimer = 0;
  }

  // Update and show food pellets
  for (let i = food.length - 1; i >= 0; i--) {
    food[i].show();
  }

  // Update and show creatures
  let newCreatures = []; // Temporary array to hold offspring
  let currentMaxGenAlive = 0; // Tracks the highest generation alive in the current frame

  for (let i = creatures.length - 1; i >= 0; i--) {
    let creature = creatures[i];
    currentMaxGenAlive = max(currentMaxGenAlive, creature.generation);

    if (creature.update(food)) {
      // Creature is alive, check for eating food
      for (let j = food.length - 1; j >= 0; j--) {
        if (creature.eat(food[j])) {
          food.splice(j, 1); // Remove eaten food
          break; // Creature can only eat one food per frame
        }
      }

      // Check for splitting
      let offspring = creature.split();
      if (offspring) {
        newCreatures.push(...offspring); // Add offspring to the temporary array
        // If a creature splits and creates a higher generation, update maxGenerationReached
        if (creature.generation + 1 > maxGenerationReached) {
          maxGenerationReached = creature.generation + 1;
          speak("A new generation emerges! Generation " + maxGenerationReached + " is now thriving.");
        }
      }
      creature.show(); // Show the creature if it's alive
    } else {
      // Creature died
      creatures.splice(i, 1);
    }
  }

  // Add all new offspring to the main creatures array
  creatures.push(...newCreatures);

  // Update the displayed generation count to the highest generation currently alive
  generation = currentMaxGenAlive;

  // Display generation, creature, and food counts
  fill(255);
  textSize(16);
  textAlign(LEFT, TOP);
  text("Generation: " + generation, 10, 10);
  text("Creatures: " + creatures.length, 10, 30);
  text("Food: " + food.length, 10, 50);

  // Occasional narration based on events or time
  if (millis() - lastSpeechTime > SPEECH_INTERVAL && !speechSynthesis.speaking) {
    let messages = [
      "The ecosystem evolves.",
      "Creatures adapt to their environment.",
      "Some species are thriving, others are perishing.",
      "Competition for resources intensifies.",
      "Diversity is key to survival.",
      "Observe the intricate dance of life.",
      "A new species with enhanced vision is gaining an advantage.",
      "The green food pellets are the lifeblood of this world.",
      "Survival of the fittest in action."
    ];
    speak(random(messages));
    lastSpeechTime = millis();
  }

  // If all creatures perish, restart the simulation
  if (creatures.length === 0) {
    speak("All creatures have perished. Restarting the simulation.");
    setup(); // Restart the simulation
  }
}

function mousePressed() {
  food.push(new Food(mouseX, mouseY)); // Spawn food at mouse position
  speak("Food spawned at " + round(mouseX) + ", " + round(mouseY) + ".");
}

function windowResized() {
  resizeCanvas(windowWidth, windowHeight); // Resize canvas on window resize
}

function speak(textToSpeak) {
  if ('speechSynthesis' in window && !speechSynthesis.speaking) {
    let utterance = new SpeechSynthesisUtterance(textToSpeak);
    utterance.volume = 1; // 0 to 1
    utterance.rate = 1;   // 0.1 to 10
    utterance.pitch = 1;  // 0 to 2
    speechSynthesis.speak(utterance);
  }
}