Sketch 2026-02-19 21:46h

function setup() {
  createCanvas(windowWidth, windowHeight);
  drawSkyAndGrass(220); // Draw initial background

  // Position the tree slightly off-center
  treeX = width / 2 + random(-100, 100);
  treeY = height * 0.7; // Base of the tree on the grass line
}

function draw() {
  // Always draw the background first based on the lightning state
  if (lightningOn) {
    // Flash the background white briefly
    if (millis() - lightningStartTime < flashDuration) {
      background(255); // White flash
    } else {
      // Return to a slightly darker sky/grass background after the flash
      drawSkyAndGrass(200);
    }
  } else {
    // Normal sky/grass background
    drawSkyAndGrass(220);
  }

  // Animate the tree falling if it has been hit
  if (treeHit) {
    let elapsedTime = millis() - treeHitTime;
    // 't' is a value between 0 and 1, representing the progress of the fall
    let t = constrain(elapsedTime / treeFallDuration, 0, 1);
    treeAngle = lerp(0, PI / 2, t); // Interpolate angle from 0 to 90 degrees (PI/2 radians)
  }

  // Draw the tree (will be rotated if treeHit is true)
  drawTree(treeX, treeY, treeAngle);

  // Check if it's time to draw lightning
  if (lightningOn) {
    drawLightningBolt(); // This function now also checks for tree collision
    // If lightning duration is over, turn it off
    if (millis() - lightningStartTime > lightningDuration) {
      lightningOn = false;
    }
  } else {
    // Randomly trigger lightning (1% chance per frame)
    // Only trigger if the tree hasn't been hit yet
    if (random() < 0.01 && !treeHit) {
      lightningOn = true;
      lightningStartTime = millis();
    }
  }
}

function drawSkyAndGrass(skyBrightness) {
  // Sky
  noStroke();
  fill(0, 0, skyBrightness); // Dark blue sky
  rect(0, 0, width, height * 0.7); // Occupies the top 70% of the canvas

  // Grass
  fill(34, 139, 34); // Forest green
  rect(0, height * 0.7, width, height * 0.3); // Occupies the bottom 30% of the canvas
}

function drawTree(x, y, angle) {
  push(); // Save current drawing state
  translate(x, y); // Move origin to the base of the tree
  rotate(angle);   // Rotate around the new origin

  // Trunk
  fill(139, 69, 19); // Brown
  noStroke();
  // Draw trunk upwards from the base (which is at (0,0) in this translated system)
  rect(-treeWidth / 4, -treeHeight, treeWidth / 2, treeHeight);

  // Canopy (simplified as two triangles)
  fill(34, 139, 34); // Forest green
  triangle(
    -treeWidth / 2, -treeHeight * 0.8,
    treeWidth / 2, -treeHeight * 0.8,
    0, -treeHeight * 1.2
  );
  triangle(
    -treeWidth * 0.6, -treeHeight * 0.6,
    treeWidth * 0.6, -treeHeight * 0.6,
    0, -treeHeight * 1.0
  );

  pop(); // Restore original drawing state
}

function drawLightningBolt() {
  let startX = width / 2; // Start in the middle top of the canvas
  let startY = 0;
  let endY = height * 0.7; // End at the grass line
  let displacement = 100; // How much the lightning can "wobble"
  let segmentLength = 20; // Length of each segment in the lightning bolt

  noFill();

  // Draw the glow effect first (thickest and most transparent)
  stroke(255, 255, 255, 50); // White with 50 alpha
  strokeWeight(10);
  drawJaggedLine(startX, startY, startX, endY, displacement * 0.3, segmentLength);

  stroke(255, 255, 255, 100); // White with 100 alpha
  strokeWeight(6);
  drawJaggedLine(startX, startY, startX, endY, displacement * 0.5, segmentLength);

  // Draw the main lightning bolt (thinnest and most opaque)
  stroke(255, 255, 255, 200); // White with 200 alpha
  strokeWeight(3);
  drawJaggedLine(startX, startY, startX, endY, displacement, segmentLength);

  // Add smaller branches to the lightning bolt
  if (random() < 0.5) { // 50% chance for a branch to appear
    let branchX = startX + random(-50, 50); // Random horizontal offset from the main bolt
    let branchY = random(height * 0.2, height * 0.5); // Random point along the main bolt's path
    let branchLength = random(50, 150);
    // Angle towards the grass, roughly between 45 and 135 degrees (PI/4 to 3*PI/4 radians)
    let branchAngle = random(PI / 4, 3 * PI / 4);
    let branchEndX = branchX + branchLength * cos(branchAngle);
    let branchEndY = branchY + branchLength * sin(branchAngle);

    // Limit the branch end to not go below the grass line
    branchEndY = min(branchEndY, endY);

    stroke(255, 255, 255, 150); // White with 150 alpha
    strokeWeight(2);
    drawJaggedLine(branchX, branchY, branchEndX, branchEndY, displacement * 0.2, segmentLength * 0.5);
  }
}

function drawJaggedLine(x1, y1, x2, y2, displace, segmentLength) {
  let distance = dist(x1, y1, x2, y2); // Calculate the length of the current segment

  // Base case: If the segment is too short or displacement is too small, draw a straight line
  if (distance < segmentLength || displace < 1) {
    line(x1, y1, x2, y2);

    // Collision check for this short segment with the tree
    // Only check if the tree hasn't been hit yet
    if (!treeHit) {
      // Check if this segment intersects the tree's x-range
      // and is above the grass (where the tree stands)
      if (
        (x1 >= treeX - treeWidth / 2 && x1 <= treeX + treeWidth / 2 && y1 < height * 0.7) ||
        (x2 >= treeX - treeWidth / 2 && x2 <= treeX + treeWidth / 2 && y2 < height * 0.7)
      ) {
        treeHit = true;
        treeHitTime = millis();
        // You could add a sound effect here if p5.sound was included
        console.log("Tree hit!"); // Log to console for debugging
      }
    }
  } else {
    let midX = (x1 + x2) / 2;
    let midY = (y1 + y2) / 2;

    // Calculate a random displacement perpendicular to the line segment
    let angle = atan2(y2 - y1, x2 - x1); // Angle of the current segment
    let displacementX = sin(angle) * random(-displace, displace);
    let displacementY = -cos(angle) * random(-displace, displace);

    midX += displacementX;
    midY += displacementY;

    // Recursively call drawJaggedLine for the two new segments
    drawJaggedLine(x1, y1, midX, midY, displace * 0.5, segmentLength); // First half
    drawJaggedLine(midX, midY, x2, y2, displace * 0.5, segmentLength); // Second half
  }
}

function windowResized() {
  resizeCanvas(windowWidth, windowHeight);
  drawSkyAndGrass(lightningOn ? 200 : 220);
  // Re-position the tree on resize to keep it relative to the canvas size
  treeX = width / 2 + random(-100, 100);
  treeY = height * 0.7;
}