FRACTAL GARDEN2

function setup() {
  createCanvas(windowWidth, windowHeight);
  colorMode(HSB, 360, 100, 100);
  noStroke();
  initializeSoil();
  seedSpawnTimer = floor(random(seedSpawnIntervalMin, seedSpawnIntervalMax + 1));
}

function initializeSoil() {
  rows = floor(soilHeight / cellSize);
  cols = floor(width / cellSize);
  soilGrid = Array(rows).fill(0).map((_, i) => Array(cols).fill(0).map((_, j) => {
    let initialNutrient = 50 + map(noise(j * 0.1, i * 0.1), 0, 1, -20, 20);
    return constrain(initialNutrient, 0, 100);
  }));
  nutrientWells = [];
  let numWells = floor(random(minWells, maxWells + 1));
  for (let k = 0; k < numWells; k++) {
    nutrientWells.push({
      x: random(width),
      radius: wellRadius
    });
  }
}

function updateSimulationLogic() {
  const soilStartY = height - soilHeight;
  // === Event Management ===
  if (frameCount % seedRainInterval === 0 && !droughtActive) {
    seedRainActive = true;
    seedRainTimer = seedRainCount;
  }
  if (seedRainActive && seedRainTimer > 0) {
    seeds.push(new Seed());
    seedRainTimer--;
    if (seedRainTimer <= 0) seedRainActive = false;
  }
  if (frameCount % (seedRainInterval + 500) === 0 && !droughtActive) {
    droughtActive = true;
    droughtTimer = droughtDuration;
  }
  if (droughtActive) {
    droughtTimer--;
    if (droughtTimer <= 0) droughtActive = false;
  }
  if (frameCount % bloomInterval === 0 && !droughtActive) {
    bloomActive = true;
    bloomTimer = bloomDuration;
    for (let plant of plants) {
      if (plant.isAlive) {
        plant.flowering = true;
        plant.flowerTimer = bloomDuration;
      }
    }
  }
  if (bloomActive) {
    bloomTimer--;
    if (bloomTimer <= 0) bloomActive = false;
  }
  // === Update Nutrients ===
  noiseOffset += noiseDriftRate;
  for (let i = 0; i < rows; i++) {
    for (let j = 0; j < cols; j++) {
      let noiseValue = noise(j * noiseScale, i * noiseScale + noiseOffset);
      soilGrid[i][j] += map(noiseValue, 0, 1, -noiseNutrientInfluence, noiseNutrientInfluence);
      soilGrid[i][j] = constrain(soilGrid[i][j], 0, 100);
    }
  }
  if (!droughtActive) {
    for (let well of nutrientWells) {
      for (let i = 0; i < rows; i++) {
        for (let j = 0; j < cols; j++) {
          let cellX = j * cellSize + cellSize / 2;
          let cellY = i * cellSize + cellSize / 2 + soilStartY;
          let d = dist(well.x, soilStartY + soilHeight / 2, cellX, cellY);
          if (d < well.radius) {
            let regenAmount = wellRegenRate * (1 - d / well.radius);
            soilGrid[i][j] = constrain(soilGrid[i][j] + regenAmount, 0, 100);
          }
        }
      }
    }
  }
  let nextSoilGrid = Array(rows).fill(0).map(() => Array(cols).fill(0));
  for (let i = 0; i < rows; i++) {
    for (let j = 0; j < cols; j++) {
      let currentNutrient = soilGrid[i][j];
      let neighborsNutrientSum = 0;
      let numNeighbors = 0;
      if (j > 0) { neighborsNutrientSum += soilGrid[i][j - 1]; numNeighbors++; }
      if (j < cols - 1) { neighborsNutrientSum += soilGrid[i][j + 1]; numNeighbors++; }
      if (i > 0) { neighborsNutrientSum += soilGrid[i - 1][j]; numNeighbors++; }
      if (i < rows - 1) { neighborsNutrientSum += soilGrid[i + 1][j]; numNeighbors++; }
      let avgNeighborNutrients = numNeighbors > 0 ? neighborsNutrientSum / numNeighbors : currentNutrient;
      nextSoilGrid[i][j] = constrain(currentNutrient * (1 - diffusionRate) + avgNeighborNutrients * diffusionRate, 0, 100);
    }
  }
  soilGrid = nextSoilGrid;
  lightNoiseOffset += lightDriftRate;
  let shadowMap = Array(cols).fill(0);
  let sortedPlants = [...plants].sort((a, b) => {
    if (!a.isAlive && !b.isAlive) return 0;
    if (!a.isAlive) return 1;
    if (!b.isAlive) return -1;
    let aHighestY = height;
    if (a.branches.length > 0) aHighestY = min(aHighestY, min(a.branches.map(b => min(b.startY, b.endY))));
    let bHighestY = height;
    if (b.branches.length > 0) bHighestY = min(bHighestY, min(b.branches.map(b => min(b.startY, b.endY))));
    return aHighestY - bHighestY;
  });
  for (let plant of sortedPlants) {
    if (!plant.isAlive) continue;
    let plantTotalLightExposure = 0;
    let plantBranchCount = 0;
    for (let branch of plant.branches) {
      let branchX1 = floor(min(branch.startX, branch.endX) / cellSize);
      let branchX2 = floor(max(branch.startX, branch.endX) / cellSize);
      branchX1 = constrain(branchX1, 0, cols - 1);
      branchX2 = constrain(branchX2, 0, cols - 1);
      let branchYBlock = floor(min(branch.startY, branch.endY));
      let unshadowedWidth = 0;
      let totalWidth = branchX2 - branchX1 + 1;
      for (let x = branchX1; x <= branchX2; x++) {
        if (branchYBlock < shadowMap[x]) {
          unshadowedWidth++;
        }
      }
      branch.lightExposure = unshadowedWidth / totalWidth;
      plantTotalLightExposure += branch.lightExposure;
      plantBranchCount++;
      for (let x = branchX1; x <= branchX2; x++) {
        shadowMap[x] = max(shadowMap[x], branchYBlock);
      }
    }
    plant.lightExposure = plantBranchCount > 0 ? plantTotalLightExposure / plantBranchCount : 1.0;
  }
  if (!seedRainActive) {
    seedSpawnTimer--;
    if (seedSpawnTimer <= 0) {
      seeds.push(new Seed());
      seedSpawnTimer = floor(random(seedSpawnIntervalMin, seedSpawnIntervalMax + 1));
    }
  }
  for (let i = seeds.length - 1; i >= 0; i--) {
    seeds[i].update();
    if (seeds[i].state === 'germinating' || seeds[i].y > height + seedSize) {
      seeds.splice(i, 1);
    }
  }
  let livingPlantsCount = 0;
  for (let i = plants.length - 1; i >= 0; i--) {
    plants[i].update();
    if (plants[i].isAlive) {
      livingPlantsCount++;
    } else if (plants[i].isDead()) {
      plantIDMap.delete(plants[i].id);
      plants.splice(i, 1);
    }
  }
  totalPlantsAlive = livingPlantsCount;
  for (let i = nutrientParticles.length - 1; i >= 0; i--) {
    nutrientParticles[i].update();
    if (nutrientParticles[i].isDissolved()) {
      nutrientParticles.splice(i, 1);
    }
  }
  aliveHistory.push(totalPlantsAlive);
  deadHistory.push(totalPlantsDead);
  let currentFertilitySum = 0;
  for (let i = 0; i < rows; i++) {
    for (let j = 0; j < cols; j++) {
      currentFertilitySum += soilGrid[i][j];
    }
  }
  fertilityHistory.push(currentFertilitySum / (rows * cols));
  if (aliveHistory.length > historyLength) aliveHistory.shift();
  if (deadHistory.length > historyLength) deadHistory.shift();
  if (fertilityHistory.length > historyLength) fertilityHistory.shift();
}

function drawVisuals() {
  background(0, 0, 5);
  const soilStartY = height - soilHeight;
  push();
  noStroke();
  for (let x = 0; x < width; x += cellSize) {
    let brightness = map(noise(x * lightNoiseScale + lightNoiseOffset), 0, 1, lightBrightnessMin, lightBrightnessMax);
    fill(0, 0, 100, brightness);
    rect(x, 0, cellSize, height);
  }
  pop();
  for (let i = 0; i < rows; i++) {
    for (let j = 0; j < cols; j++) {
      let nutrientValue = soilGrid[i][j];
      let currentHue = map(nutrientValue, 0, 100, depletedHue, richHue);
      let currentSat = map(nutrientValue, 0, 100, depletedSat, richSat);
      let currentBright = map(nutrientValue, 0, 100, depletedBright, richBright);
      fill(currentHue, currentSat, currentBright);
      rect(j * cellSize, i * cellSize + soilStartY, cellSize, cellSize);
    }
  }
  noStroke();
  for (let particle of nutrientParticles) {
    particle.draw();
  }
  if (showGenealogyWeb) {
    push();
    stroke(0, 0, 50, 15);
    strokeWeight(0.5);
    for (let plant of plants) {
      if (plant.offspringPlantIDs.length > 0) {
        for (let offspringID of plant.offspringPlantIDs) {
          let offspring = plantIDMap.get(offspringID);
          if (offspring) {
            line(plant.x, plant.y, offspring.x, offspring.y);
          }
        }
      }
    }
    pop();
  }
  for (let plant of plants) {
    plant.draw();
  }
  noStroke();
  for (let seed of seeds) {
    seed.draw();
  }
  let hoveredPlant = null;
  for (let i = plants.length - 1; i >= 0; i--) {
    let plant = plants[i];
    if (plant.isAlive || plant.decayTimer > 0) {
      if (dist(mouseX, mouseY, plant.x, plant.y) < plantBaseLength * 2) {
        hoveredPlant = plant;
        break;
      }
    }
  }
  if (hoveredPlant) {
    push();
    translate(mouseX + 10, mouseY + 10);
    fill(0, 0, 100, 80);
    noStroke();
    rect(0, 0, 150, 80);
    fill(0);
    textSize(10);
    textFont('Arial');
    text(`Age: ${frameCount - hoveredPlant.birthFrame} frames`, 5, 15);
    text(`Seed Type: ${hoveredPlant.seedShape}`, 5, 30);
    text(`Light: ${nf(hoveredPlant.lightExposure, 1, 2)}`, 5, 45);
    text(`Alive: ${hoveredPlant.isAlive}`, 5, 60);
    if (hoveredPlant.offspringPlantIDs.length > 0) {
      push();
      stroke(0, 0, 50, 50);
      strokeWeight(1);
      for (let offspringID of hoveredPlant.offspringPlantIDs) {
        let offspring = plantIDMap.get(offspringID);
        if (offspring) {
          line(hoveredPlant.x, hoveredPlant.y, offspring.x, offspring.y);
        }
      }
      pop();
    }
    pop();
  }
  push();
  translate(0, height - timelineHeight);
  fill(0, 0, 0, 50);
  noStroke();
  rect(0, 0, width, timelineHeight);
  const maxAlive = max(aliveHistory);
  const maxDead = max(deadHistory);
  const maxFertility = max(fertilityHistory);
  const maxCombined = max(maxAlive, maxDead, maxFertility);
  noFill();
  stroke(120, 80, 70);
  strokeWeight(2);
  beginShape();
  vertex(0, timelineHeight);
  for (let i = 0; i < aliveHistory.length; i++) {
    let x = map(i, 0, historyLength - 1, 0, width);
    let y = map(aliveHistory[i], 0, maxCombined, timelineHeight, 0);
    vertex(x, y);
  }
  vertex(width, timelineHeight);
  endShape();
  stroke(0, 0, 50);
  beginShape();
  vertex(0, timelineHeight);
  for (let i = 0; i < deadHistory.length; i++) {
    let x = map(i, 0, historyLength - 1, 0, width);
    let y = map(deadHistory[i], 0, maxCombined, timelineHeight, 0);
    vertex(x, y);
  }
  vertex(width, timelineHeight);
  endShape();
  stroke(richHue, richSat, richBright);
  beginShape();
  vertex(0, timelineHeight);
  for (let i = 0; i < fertilityHistory.length; i++) {
    let x = map(i, 0, historyLength - 1, 0, width);
    let y = map(fertilityHistory[i], 0, 100, timelineHeight, 0);
    vertex(x, y);
  }
  vertex(width, timelineHeight);
  endShape();
  pop();
}

function draw() {
  let simulationSteps = fastForward ? 5 : 1;
  for (let i = 0; i < simulationSteps; i++) {
    updateSimulationLogic();
  }
  drawVisuals();
}

function windowResized() {
  resizeCanvas(windowWidth, windowHeight);
  initializeSoil();
  seeds = [];
  plants = [];
  plantIDMap.clear();
  totalPlantsAlive = 0;
  totalPlantsDead = 0;
  aliveHistory = [];
  deadHistory = [];
  fertilityHistory = [];
  seedSpawnTimer = floor(random(seedSpawnIntervalMin, seedSpawnIntervalMax + 1));
}

function keyTyped() {
  if (key === 'f' || key === 'F') {
    fastForward = !fastForward;
  }
  if (key === 'g' || key === 'G') {
    showGenealogyWeb = !showGenealogyWeb;
  }
}

function polygon(x, y, radius, npoints) {
  let angle = TWO_PI / npoints;
  beginShape();
  for (let a = 0; a < TWO_PI; a += angle) {
    let sx = x + cos(a) * radius;
    let sy = y + sin(a) * radius;
    vertex(sx, sy);
  }
  endShape(CLOSE);
}