Sketch 2026-02-22 21:31

class NPCCutter {
  constructor(x, y) {
    this.x = x;
    this.y = y;
    this.targetX = x;
    this.targetY = y;
    this.speed = random(2, 5); // Random cutting speed for each NPC
    this.isCuttingFood = false; // Flag to know if currently cutting food
    this.targetFoodIndex = -1; // Index of the specific food emoji this NPC is targeting

    this.setNewTarget(); // Set an initial target
  }

  update() {
    let d = dist(this.x, this.y, this.targetX, this.targetY);

    if (d < this.speed) {
      // Reached target, set a new one
      this.x = this.targetX;
      this.y = this.targetY;

      // If we were cutting food, mark it as no longer targeted
      if (this.isCuttingFood && this.targetFoodIndex !== -1 && displayedEmojis[this.targetFoodIndex]) {
        displayedEmojis[this.targetFoodIndex].isTargeted = false;
      }

      this.isCuttingFood = false; // Reset flag
      this.targetFoodIndex = -1; // Reset target index
      this.setNewTarget();
    } else {
      // Move towards target
      let angle = atan2(this.targetY - this.y, this.targetX - this.x);
      this.x += cos(angle) * this.speed;
      this.y += sin(angle) * this.speed;

      // "Eat" the targeted food emoji
      if (this.isCuttingFood && this.targetFoodIndex !== -1 && displayedEmojis[this.targetFoodIndex]) {
        displayedEmojis[this.targetFoodIndex].currentSize -= 0.1; // Shrink the emoji
        if (displayedEmojis[this.targetFoodIndex].currentSize <= 0) {
          displayedEmojis[this.targetFoodIndex].isTargeted = false; // Release target
          displayedEmojis.splice(this.targetFoodIndex, 1); // Remove from array
          this.isCuttingFood = false; // Stop cutting food
          this.targetFoodIndex = -1; // Reset target index
          this.setNewTarget(); // Find a new target
        }
      }
    }
  }

  setNewTarget() {
    // Randomly decide if the next cut is for the pumpkin or the food
    if (random(1) < 0.3) { // 30% chance to cut food
      // Try to find an available food emoji to target
      let availableFood = displayedEmojis.filter(emoji => !emoji.isTargeted && emoji.currentSize > 0);
      if (availableFood.length > 0) {
        let targetEmoji = random(availableFood);
        this.targetFoodIndex = displayedEmojis.indexOf(targetEmoji);
        displayedEmojis[this.targetFoodIndex].isTargeted = true; // Mark as targeted
        this.isCuttingFood = true;
        this.targetX = targetEmoji.x;
        this.targetY = targetEmoji.y;
        this.speed = random(3, 6); // Faster speed for food slicing
      } else {
        // No food available, fall back to pumpkin
        this.isCuttingFood = false;
        this.targetFoodIndex = -1;
        this.setPumpkinTarget();
      }
    } else {
      this.isCuttingFood = false;
      this.targetFoodIndex = -1;
      this.setPumpkinTarget();
    }
  }

  setPumpkinTarget() {
    // Generate a random target within the pumpkin's approximate bounds
    let angle = random(TWO_PI);
    let r = random(pumpkinWidth * 0.3, pumpkinWidth * 0.4); // Target slightly in from edge
    this.targetX = pumpkinX + cos(angle) * r;
    this.targetY = pumpkinY + sin(angle) * r;
    this.speed = random(2, 5); // Normal speed for pumpkin cutting
  }

  draw() {
    // The NPC icon (small red circle) is now visible again.
    push();
    translate(this.x, this.y);
    fill(200, 50, 50); // Red color for NPC
    noStroke();
    ellipse(0, 0, 15, 15); // Small circle representing the NPC
    pop();
  }

function setup() {
  // Create a canvas that fills the window
  createCanvas(windowWidth, windowHeight);

  // Ensure the canvas is landscape, as specified for your device
  if (width < height) {
    resizeCanvas(height, width);
  }

  // Calculate pumpkin size and position (left side)
  pumpkinWidth = min(width * 0.4, height * 0.7);
  pumpkinHeight = pumpkinWidth * 0.8;
  pumpkinX = width / 4; // Shift to the left
  pumpkinY = height / 2 + pumpkinHeight * 0.1;

  // Calculate food area size and position (right side)
  foodDiameter = min(width * 0.3, height * 0.5);
  foodX = (width / 4) * 3; // Shift to the right
  foodY = height / 2;

  // Populate displayedEmojis array initially
  populateEmojis(15); // Start with 15 food items

  // Initialize NPC cutters
  for (let i = 0; i < numNPCs; i++) {
    // Start NPCs at random positions within the pumpkin or food area
    let startX, startY;
    if (random(1) < 0.5) { // 50% chance to start on pumpkin
      let angle = random(TWO_PI);
      let r = random(pumpkinWidth * 0.3);
      startX = pumpkinX + cos(angle) * r;
      startY = pumpkinY + sin(angle) * r;
    } else { // 50% chance to start on food
      let angle = random(TWO_PI);
      let r = random(foodDiameter * 0.3);
      startX = foodX + cos(angle) * r;
      startY = foodY + cos(angle) * r;
    }
    npcCutters.push(new NPCCutter(startX, startY));
  }
}

function draw() {
  background(240, 248, 255); // Light blue background

  drawPumpkin(); // Draw the pumpkin
  drawFoodArea(); // Draw the food emojis
  // drawCuts() and drawFoodCuts() were already removed

  // Update and draw each NPC cutter
  for (let cutter of npcCutters) {
    cutter.update();
    cutter.draw(); // This now draws the red circle
  }

  // Respawn food if the amount drops too low
  if (displayedEmojis.length < 5) {
    populateEmojis(1); // Add one new food item at a time
  }
}

function populateEmojis(count) {
  let emojiSize = foodDiameter * 0.15; // Size of each emoji

  for (let i = 0; i < count; i++) {
    let angle = random(TWO_PI);
    let r = random(foodDiameter * 0.45); // Position within food area
    let x = foodX + cos(angle) * r;
    let y = foodY + sin(angle) * r;
    let emoji = random(foodEmojis); // Pick a random emoji
    displayedEmojis.push({
      emoji: emoji,
      x: x,
      y: y,
      initialSize: emojiSize, // Store original size
      currentSize: emojiSize, // Mutable size
      isTargeted: false // Flag to prevent multiple NPCs targeting same food
    });
  }
}

function drawPumpkin() {
  // Stem
  fill(34, 139, 34);
  noStroke();
  rect(pumpkinX - pumpkinWidth * 0.05, pumpkinY - pumpkinHeight * 0.6, pumpkinWidth * 0.1, pumpkinHeight * 0.2);

  // Pumpkin body
  fill(255, 140, 0);
  noStroke();
  ellipse(pumpkinX, pumpkinY, pumpkinWidth, pumpkinHeight);

  // Ridges
  stroke(200, 100, 0);
  strokeWeight(2);
  let numRidges = 8;
  for (let i = 0; i < numRidges; i++) {
    let angle = map(i, 0, numRidges, -HALF_PI * 0.8, HALF_PI * 0.8);
    let x1 = pumpkinX + cos(angle) * pumpkinWidth / 2;
    let y1 = pumpkinY + sin(angle) * pumpkinHeight / 2;
    let x2 = pumpkinX + cos(angle) * pumpkinWidth * 0.4;
    let y2 = pumpkinY + sin(angle) * pumpkinHeight * 0.4;
    line(x1, y1, x2, y2);
  }
}

function drawFoodArea() {
  // Draw a very light background circle just to define the area
  fill(255, 250, 240, 50); // Light cream with some transparency
  noStroke();
  ellipse(foodX, foodY, foodDiameter, foodDiameter);

  // Draw the randomly selected emojis
  textAlign(CENTER, CENTER);
  // Filter out emojis that have been completely eaten
  for (let foodItem of displayedEmojis.filter(emoji => emoji.currentSize > 0)) {
    textSize(foodItem.currentSize); // Use currentSize for scaling
    text(foodItem.emoji, foodItem.x, foodItem.y);
  }
}

function windowResized() {
  resizeCanvas(windowWidth, windowHeight);

  if (width < height) {
    resizeCanvas(height, width);
  }

  // Re-calculate pumpkin size and position
  pumpkinWidth = min(width * 0.4, height * 0.7);
  pumpkinHeight = pumpkinWidth * 0.8;
  pumpkinX = width / 4;
  pumpkinY = height / 2 + pumpkinHeight * 0.1;

  // Re-calculate food area size and position
  foodDiameter = min(width * 0.3, height * 0.5);
  foodX = (width / 4) * 3;
  foodY = height / 2;

  // Clear and re-populate emojis for the new size
  displayedEmojis = [];
  populateEmojis(15);

  // Reset NPC cutters to new positions and targets based on the resized canvas
  for (let cutter of npcCutters) {
    let startX, startY;
    if (random(1) < 0.5) { // 50% chance to start on pumpkin
      let angle = random(TWO_PI);
      let r = random(pumpkinWidth * 0.3);
      startX = pumpkinX + cos(angle) * r;
      startY = pumpkinY + sin(angle) * r;
    } else { // 50% chance to start on food
      let angle = random(TWO_PI);
      let r = random(foodDiameter * 0.3);
      startX = foodX + cos(angle) * r;
      startY = foodY + sin(angle) * r;
    }
    cutter.x = startX;
    cutter.y = startY;
    cutter.isCuttingFood = false; // Reset cutting state
    cutter.targetFoodIndex = -1; // Reset target index
    cutter.setNewTarget(); // Set a new target based on resized canvas
  }
}