Try to get the highest score!

function drawGlowingEye(irisX, irisY, irisSize, glowColor, targetX, targetY) {
  let pupilSize = irisSize * 0.4;
  let baseGlowAmount = irisSize * 0.7; // Base blur amount for the glow
  let flickerAmount = random(-irisSize * 0.1, irisSize * 0.1); // Small random variation for flicker
  let currentGlowAmount = baseGlowAmount + flickerAmount; // Apply flicker

  // Set shadow properties for the glowing effect
  drawingContext.shadowColor = glowColor;
  drawingContext.shadowBlur = currentGlowAmount;

  // Draw the iris (the glowing part of the eye)
  fill(glowColor);
  circle(irisX, irisY, irisSize);

  // Reset shadow blur and color for the pupil
  // This ensures only the iris glows, not the pupil or other shapes
  drawingContext.shadowBlur = 0;
  drawingContext.shadowColor = 'black'; // Reset to a default or black

  // Calculate pupil position based on targetX, targetY
  // The pupil moves towards the target within a limited range
  let dx = targetX - irisX;
  let dy = targetY - irisY;
  let angle = atan2(dy, dx);
  let pupilOffset = irisSize * 0.2; // How far the pupil can move from the center
  let pupilX = irisX + cos(angle) * pupilOffset;
  let pupilY = irisY + sin(angle) * pupilOffset;

  // Draw the pupil
  fill(0); // Black pupil
  circle(pupilX, pupilY, pupilSize);
}

function setup() {
  createCanvas(windowWidth, windowHeight);
  noStroke(); // No outline for shapes

  // Initialize stars once in setup()
  for (let i = 0; i < numStars; i++) {
    stars.push({
      x: random(width),
      y: random(height),
      size: random(1, 4),
      alpha: random(100, 255) // Random transparency for twinkling
    });
  }

  // Define nebula colors
  nebulaColors.push(color(10, 0, 50, 100)); // Dark blue
  nebulaColors.push(color(50, 0, 100, 100)); // Purple
  nebulaColors.push(color(100, 0, 50, 100)); // Magenta
  nebulaColors.push(color(100, 50, 0, 100)); // Orange
  nebulaColors.push(color(0, 50, 100, 100)); // Cyan

  // Initialize entities
  entities.push({
    id: 1,
    x: width * 0.3,
    y: height * 0.5,
    bodyColor: color(50, 50, 100), // Dark blue-purple body color
    eyeColor: color(0, 255, 255), // Bright cyan eye color
    eyeSize: 60, // Size of the eyes
    eyeOffset: 40, // Distance between the two eyes
    eyeY: -30, // Vertical position of eyes relative to entity center
    boundingCircleRadius: 125, // Bounding radius for collision detection (half of ellipse width)
    isCut: false
  });

  entities.push({
    id: 2,
    x: width * 0.7,
    y: height * 0.5,
    bodyColor: color(100, 50, 50), // Dark red-brown body color
    eyeColor: color(255, 255, 0), // Bright yellow eye color
    eyeSize: 70, // Size of the eyes
    eyeOffset: 50, // Distance between the two eyes
    eyeY: -20, // Vertical position of eyes relative to entity center
    boundingCircleRadius: 110, // Bounding radius for collision detection (half of rect width)
    isCut: false
  });
}

function resetEntity(entity) {
  entity.isCut = false;
  entity.x = random(width * 0.2, width * 0.8); // New random x position
  entity.y = random(height * 0.3, height * 0.7); // New random y position
  // Optionally randomize colors/sizes for more variety
  entity.bodyColor = color(random(50, 150), random(50, 150), random(50, 150));
  entity.eyeColor = color(random(150, 255), random(150, 255), random(150, 255));
  entity.eyeSize = random(50, 80);
  entity.eyeOffset = random(30, 60);
  entity.eyeY = random(-40, -10);
  entity.boundingCircleRadius = entity.id === 1 ? random(100, 150) : random(90, 130);
}

function drawSpaceyBackground() {
  background(0); // Dark background for space

  // Draw stars
  for (let star of stars) {
    fill(255, star.alpha);
    circle(star.x, star.y, star.size);
  }

  // Draw nebulae using noise and blendMode
  push(); // Isolate blend mode and transformations for nebulae
  blendMode(SCREEN); // Blend mode for luminous nebulae (adds colors together)

  let nebulaDensity = 0.005; // How spread out the noise is for the nebulae
  let nebulaScale = 0.5; // Overall vertical size of nebulae
  let timeOffset = frameCount * 0.001; // Animate nebulae slowly over time

  // Draw multiple layers of nebulae
  for (let i = 0; i < 5; i++) {
    // Lerp between nebula colors for variety
    let nebulaColor = lerpColor(nebulaColors[i % nebulaColors.length], nebulaColors[(i + 1) % nebulaColors.length], noise(timeOffset + i * 10));
    fill(nebulaColor);

    beginShape();
    for (let x = 0; x <= width; x += 20) { // Draw points across the width
      // Use noise to create organic, cloud-like shapes
      let y = height / 2 +
              noise(x * nebulaDensity, i * 10, timeOffset) * height * nebulaScale -
              height * nebulaScale / 2;
      vertex(x, y);
    }
    vertex(width, height); // Close the shape at the bottom right
    vertex(0, height);     // Close the shape at the bottom left
    endShape(CLOSE);
  }

  pop(); // Reset blendMode to NORMAL and restore previous transformations
}

function drawEntity(entity) {
  push(); // Isolate transformations for this entity
  translate(entity.x, entity.y); // Move to entity's position

  if (entity.id === 1) {
    // Draw Entity 1's body/head (an ellipse with horns)
    fill(entity.bodyColor);
    ellipse(0, 0, 200, 250); // Main body/head
    triangle(-50, -125, -75, -175, -25, -175); // Left horn
    triangle(50, -125, 75, -175, 25, -175);   // Right horn

    // Draw glowing eyes for Entity 1, tracking the mouse
    drawGlowingEye(-entity.eyeOffset, entity.eyeY, entity.eyeSize, entity.eyeColor, mouseX, mouseY);
    drawGlowingEye(entity.eyeOffset, entity.eyeY, entity.eyeSize, entity.eyeColor, mouseX, mouseY);
  } else if (entity.id === 2) {
    // Draw Entity 2's body/head (a rounded rectangle with teeth)
    fill(entity.bodyColor);
    rectMode(CENTER);
    rect(0, 0, 220, 200, 20); // Main body/head (rounded rectangle)

    // Draw teeth
    fill(200); // Light gray for teeth
    triangle(-70, 70, -30, 70, -50, 90);
    triangle(-20, 70, 20, 70, 0, 90);
    triangle(30, 70, 70, 70, 50, 90);

    // Draw glowing eyes for Entity 2, tracking the mouse
    drawGlowingEye(-entity.eyeOffset, entity.eyeY, entity.eyeSize, entity.eyeColor, mouseX, mouseY);
    drawGlowingEye(entity.eyeOffset, entity.eyeY, entity.eyeSize, entity.eyeColor, mouseX, mouseY);
  }
  pop(); // Restore previous transformations
}

function draw() {
  drawSpaceyBackground(); // Draw the spacey background first

  if (!gameActive) {
    // Start screen
    fill(255);
    textSize(40);
    textAlign(CENTER, CENTER);
    text("Click to Start\nCut the Entities!", width / 2, height / 2 - 50);
    textSize(20);
    text("Left-click and drag to swing your sword.", width / 2, height / 2 + 50);
    cursor(ARROW); // Show cursor on start screen
    return; // Stop draw loop if game not active
  }

  // Hide default mouse cursor during gameplay
  noCursor();

  // --- Timer Logic ---
  let elapsedTime = millis() - gameStartTime;
  let remainingTime = gameDuration - elapsedTime;

  if (remainingTime <= 0) {
    gameOver = true;
    remainingTime = 0;
  }

  // Display timer
  fill(255);
  textSize(32);
  textAlign(LEFT, TOP);
  text(`Time: ${nf(remainingTime / 1000, 1, 1)}s`, 20, 20);

  // Display score
  fill(255);
  textSize(32);
  textAlign(RIGHT, TOP);
  text(`Score: ${score}`, width - 20, 20);

  if (gameOver) {
    // Game Over screen
    fill(255, 0, 0); // Red color for game over text
    textSize(64);
    textAlign(CENTER, CENTER);
    text("GAME OVER!", width / 2, height / 2 - 50);
    fill(255);
    textSize(40);
    text(`Final Score: ${score}`, width / 2, height / 2 + 20);
    textSize(20);
    text("Click to play again!", width / 2, height / 2 + 80);
    cursor(ARROW); // Show cursor on game over screen
    return; // Stop draw loop if game is over
  }

  // Draw entities if they haven't been cut
  for (let entity of entities) {
    if (!entity.isCut) {
      drawEntity(entity);
    }
  }

  // --- Sword Logic ---
  if (mouseIsPressed && mouseButton === LEFT) {
    // Draw the glowing sword line
    stroke(255, 200, 0); // Orange-yellow color for the sword
    strokeWeight(5); // Thickness of the sword line
    drawingContext.shadowColor = color(255, 200, 0); // Glowing effect for the sword
    drawingContext.shadowBlur = 10;
    line(pmouseX, pmouseY, mouseX, mouseY); // Line from previous to current mouse position
    drawingContext.shadowBlur = 0; // Reset shadow blur
    noStroke(); // Reset stroke

    // Check for collision with entities
    for (let entity of entities) {
      // Only check collision if the entity is NOT already cut
      if (!entity.isCut) {
        // Use lineCircle for collision detection
        if (lineCircle(pmouseX, pmouseY, mouseX, mouseY, entity.x, entity.y, entity.boundingCircleRadius)) {
          score++; // Increment score
          resetEntity(entity); // Reset the entity (make it reappear)
        }
      }
    }
  }
}

function mousePressed() {
  if (!gameActive) {
    gameActive = true;
    gameStartTime = millis();
    score = 0;
    gameOver = false;
    // Reset all entities at game start
    for (let entity of entities) {
      resetEntity(entity);
    }
  } else if (gameOver) {
    // Restart the game
    gameStartTime = millis();
    score = 0;
    gameOver = false;
    // Reset all entities at game restart
    for (let entity of entities) {
      resetEntity(entity);
    }
  }
}

function pointOnLineSegment(px, py, x1, y1, x2, y2) {
  // Check if the point is within the bounding box of the line segment
  if (px < min(x1, x2) || px > max(x1, x2) || py < min(y1, y2) || py > max(y1, y2)) {
    return false;
  }
  // Check if the point lies on the line (cross product close to zero)
  const crossProduct = (py - y1) * (x2 - x1) - (px - x1) * (y2 - y1);
  const epsilon = 0.1; // Tolerance for floating point comparisons
  return abs(crossProduct) < epsilon;
}

function lineCircle(x1, y1, x2, y2, cx, cy, r) {
  // is either end inside the circle?
  const d1 = dist(cx, cy, x1, y1);
  const d2 = dist(cx, cy, x2, y2);
  if (d1 < r || d2 < r) return true;

  // get length of the line
  const len = dist(x1, y1, x2, y2);
  if (len === 0) return false; // Avoid division by zero for zero-length line

  // get dot product of the line and circle
  const dot = (((cx - x1) * (x2 - x1)) + ((cy - y1) * (y2 - y1))) / (len * len);

  // find the closest point on the line to the circle
  const closestX = x1 + (dot * (x2 - x1));
  const closestY = y1 + (dot * (y2 - y1));

  // is the closest point on the line segment?
  // if not, the point is outside the line segment, so we're done
  if (!pointOnLineSegment(closestX, closestY, x1, y1, x2, y2)) return false;

  // get distance to closest point
  const distance = dist(closestX, closestY, cx, cy);

  if (distance <= r) {
    return true;
  }
  return false;
}

function windowResized() {
  resizeCanvas(windowWidth, windowHeight);
  // Re-initialize stars for the new canvas size
  stars = [];
  for (let i = 0; i < numStars; i++) {
    stars.push({
      x: random(width),
      y: random(height),
      size: random(1, 4),
      alpha: random(100, 255)
    });
  }

  // Update entity positions for new canvas size if game not active or game over
  if (!gameActive || gameOver) {
    entities[0].x = width * 0.3;
    entities[0].y = height * 0.5;
    entities[1].x = width * 0.7;
    entities[1].y = height * 0.5;
  } else {
    // If game is active, just reset entities randomly
    for (let entity of entities) {
      resetEntity(entity);
    }
  }
}