killer monkey 2.0

function preload() {
  uiFont = loadFont(
    "https://cdn.jsdelivr.net/fontsource/fonts/roboto@latest/latin-400-normal.woff"
  );
}

function setup() {
  // WEBGL renderer for 3D
  createCanvas(windowWidth, windowHeight, WEBGL);

  // Create the initial monkey (main monkey)
  monkeys.push(new Monkey(width * 0.5, height * 0.5));

  // Removed: Creation of bodyguard monkey

  textFont(uiFont);
  textSize(16);
  textAlign(CENTER, CENTER);

  lastMouseX = mouseX;
  lastMouseY = mouseY;

  newMonkeyPhrase("chase"); // Start with the main monkey chasing
}

function draw() {
  if (gameState === "play") {
    drawScene();
  } else if (gameState === "crashed") {
    drawCrashScreen();
    noLoop(); // Freeze everything = "crash"
  }
}

function drawScene() {
  // Simple background instead of heavy per-frame gradient
  background(15, 20, 35);

  // Lighting for 3D monkey
  ambientLight(80);
  directionalLight(200, 200, 230, 0.3, -0.7, -1);

  // Compute cursor "future" target for slightly smarter chase
  const mouseVel = createVector(mouseX - lastMouseX, mouseY - lastMouseY);
  let target = createVector(mouseX, mouseY);
  if (mouseVel.mag() > 0.5) {
    // Predict a bit ahead in the direction of motion
    const lead = mouseVel.copy().mult(12);
    target.add(lead);
  }

  // --- Main Monkey Logic (monkeys[0]) ---
  const mainMonkey = monkeys[0];

  // Warm point light following the main monkey
  pointLight(
    255, 190, 150,
    mainMonkey.pos.x - width / 2,
    mainMonkey.pos.y - height / 2,
    250
  );

  // The main monkey always chases the cursor, seeing it everywhere
  mainMonkey.setState("chasing");

  // AI movement for main monkey
  mainMonkey.update(target);
  mainMonkey.display3D();

  // Speech bubble logic for main monkey
  phraseTimer--;
  if (mainMonkey.justChangedState) {
    newMonkeyPhrase("chase"); // Always use chase phrases
    mainMonkey.justChangedState = false;
    phraseTimer = PHRASE_INTERVAL;
  } else if (phraseTimer <= 0) {
    newMonkeyPhrase("chase"); // Always use chase phrases
    phraseTimer = PHRASE_INTERVAL;
  }

  // After 3D drawing, switch to a 2D-style overlay
  resetMatrix();
  translate(-width / 2, -height / 2, 0);
  noLights();

  // Speech bubble (2D overlay) for main monkey
  drawSpeechBubble(
    mainMonkey.pos.x,
    mainMonkey.pos.y - mainMonkey.size * 0.8,
    currentPhrase
  );

  // Removed: Bodyguard Monkey Logic (monkeys[1])

  // --- Main Monkey Backup Trigger Logic ---
  // Ensure only the main monkey (monkeys[0]) can call for backup
  // And ensure the bodyguard is currently off-screen (inactive)
  if (monkeys[0].state === "chasing") {
    const dToMouse = dist(monkeys[0].pos.x, monkeys[0].pos.y, mouseX, mouseY);
    // Trigger backup every 15 seconds (900 frames) if backupCooldown is over
    // AND the main monkey is far from the cursor (can't catch you)
    if (backupCooldown <= 0 && dToMouse > width * 0.3) { // Use width * 0.3 as a reasonable "far" threshold
      // Removed: activateBodyguard() call
      backupCooldown = 900; // Reset cooldown to 15 seconds (900 frames)
      newMonkeyPhrase("backup"); // Main monkey says backup phrase
      console.log("Main monkey called for backup! (but no one arrived)");
    }
  }
  backupCooldown = max(0, backupCooldown - 1); // Decrement cooldown every frame

  // Console logging to help debug backup
  // console.log("dToMouse:", dToMouse.toFixed(0), "backupCooldown:", backupCooldown);

  // Removed: Projectile Logic

  // --- Collision Detection for ALL Monkeys ---
  // Increased catchRadius to account for the sword's reach
  const catchRadius = mainMonkey.size * 0.6;
  for (let monkey of monkeys) {
    const dToMouse = dist(monkey.pos.x, monkey.pos.y, mouseX, mouseY);
    if (dToMouse < catchRadius) {
      triggerCrash();
      return; // End draw loop immediately if caught
    }
  }

  // UI / Instructions
  drawHUD();

  // Save last mouse for next frame
  lastMouseX = mouseX;
  lastMouseY = mouseY;
}

class Monkey {
  constructor(x, y) { // Removed isBackup parameter
    // Keep positions in 2D screen coordinates (0..width, 0..height)
    this.pos = createVector(x, y);
    this.vel = p5.Vector.random2D().mult(2);
    this.acc = createVector(0, 0);

    // All monkeys now behave like the original main monkey
    this.maxSpeed = 4.0;
    this.maxForce = 0.2;

    this.size = 120; // All monkeys are the same size

    this.state = "chasing";   // Now always chasing
    this.justChangedState = false;

    // Removed: this.isBackup property
    // Removed: this.fireCooldown property

    // For wandering behavior (not used in this version, but kept for context)
    this.wanderTheta = random(TWO_PI);
  }

  update(target) {
    let steering;

    // Monkey always seeks the target (cursor)
    steering = this.seek(target);

    this.applyForce(steering);

    this.vel.add(this.acc);
    this.vel.limit(this.maxSpeed);
    this.pos.add(this.vel);
    this.acc.mult(0);

    // handleEdges() is still commented out for "infinite range"
    // this.handleEdges();
  }

  // Steering towards a target
  seek(target) {
    const desired = p5.Vector.sub(target, this.pos);
    const d = desired.mag();

    if (d === 0) return createVector(0, 0);

    let speed = this.maxSpeed;
    // Only slow down when very close, otherwise use maxSpeed
    if (d < 120) {
      speed = map(d, 0, 120, 0, this.maxSpeed);
    }
    desired.setMag(speed);

    const steer = p5.Vector.sub(desired, this.vel);
    steer.limit(this.maxForce * 1.8); // more aggressive steering when seeking
    return steer;
  }

  // 3D monkey model with sword
  display3D() {
    push();

    // Convert from screen coords (0..width, 0..height) to WEBGL coords (centered)
    translate(this.pos.x - width / 2, this.pos.y - height / 2, 0);

    // Small up‑down bob
    const bob = sin(frameCount * 0.08 + this.pos.x * 0.01) * 4;
    translate(0, bob, 0);

    // Slight Y rotation based on velocity (leans when moving left/right)
    const yaw = map(this.vel.x, -this.maxSpeed, this.maxSpeed, -0.5, 0.5);
    rotateY(yaw);

    // Body color changes slightly when chasing (always chasing now)
    let bodyR = 180;
    let bodyG = 110;
    let bodyB = 60;

    // Removed: Temporary debug color for isBackup

    // --- Body ---
    push();
    translate(0, this.size * 0.25, 0);
    ambientMaterial(bodyR, bodyG, bodyB);
    // Reduced detailX from 32 to 24 to remove console warning
    sphere(this.size * 0.4, 24, 24);
    pop();

    // --- Head ---
    push();
    ambientMaterial(bodyR, bodyG, bodyB);
    translate(0, -this.size * 0.05, 0);
    // Reduced detailX from 32 to 24 to remove console warning
    sphere(this.size * 0.35, 24, 24);

    // Ears
    push();
    ambientMaterial(130, 80, 45);
    translate(-this.size * 0.32, -this.size * 0.02, -this.size * 0.05);
    sphere(this.size * 0.16, 20, 16);
    pop();

    push();
    ambientMaterial(130, 80, 45);
    translate(this.size * 0.32, -this.size * 0.02, -this.size * 0.05);
    sphere(this.size * 0.16, 20, 16);
    pop();

    // Inner ears
    push();
    ambientMaterial(190, 140, 90);
    translate(-this.size * 0.32, -this.size * 0.02, 0);
    sphere(this.size * 0.1, 18, 14);
    pop();

    push();
    ambientMaterial(190, 140, 90);
    translate(this.size * 0.32, -this.size * 0.02, 0);
    sphere(this.size * 0.1, 18, 14);
    pop();

    // Face / muzzle patch
    push();
    ambientMaterial(220, 190, 150);
    translate(0, this.size * 0.05, this.size * 0.24);
    sphere(this.size * 0.24, 24, 18);
    pop();

    // Eyes (white)
    const eyeOffsetX = this.size * 0.16;
    const eyeOffsetY = -this.size * 0.04;
    const eyeZ = this.size * 0.34;

    push();
    ambientMaterial(255);
    translate(-eyeOffsetX, eyeOffsetY, eyeZ);
    sphere(this.size * 0.08, 16, 12);
    pop();

    push();
    ambientMaterial(255);
    translate(eyeOffsetX, eyeOffsetY, eyeZ);
    sphere(this.size * 0.08, 16, 12);
    pop();

    // Pupils look toward mouse (2D direction mapped to small offset)
    const look = createVector(mouseX - this.pos.x, mouseY - this.pos.y);
    look.limit(this.size * 0.06);

    const pupilOffsetX = look.x * 0.15;
    const pupilOffsetY = look.y * 0.15;

    push();
    ambientMaterial(0);
    translate(
      -eyeOffsetX + pupilOffsetX,
      eyeOffsetY + pupilOffsetY,
      eyeZ + this.size * 0.03
    );
    sphere(this.size * 0.03, 10, 8);
    pop();

    push();
    ambientMaterial(0);
    translate(
      eyeOffsetX + pupilOffsetY,
      eyeOffsetY + pupilOffsetY,
      eyeZ + this.size * 0.03
    );
    sphere(this.size * 0.03, 10, 8);
    pop();

    // Nose
    push();
    ambientMaterial(80, 50, 40);
    translate(0, this.size * 0.11, this.size * 0.35);
    sphere(this.size * 0.06, 16, 12);
    pop();

    // Simple mouth: a darker patch that changes size when chasing
    push();
    ambientMaterial(90, 40, 30); // Always chasing now
    translate(0, this.size * 0.18, this.size * 0.36);
    sphere(this.size * 0.08, 16, 12);
    pop();

    pop(); // end head

    // Tail
    push();
    ambientMaterial(bodyR, bodyG, bodyB);
    translate(0, this.size * 0.3, -this.size * 0.35);
    rotateX(-PI / 3);
    cylinder(this.size * 0.05, this.size * 0.8, 8, 1);
    pop();

    // --- Sword (held/mounted in front, between head and torso) ---
    push();
    ambientMaterial(180, 180, 180); // Metallic gray for blade and crossguard
    translate(0, 0, this.size * 0.1); // Slightly in front of the origin (neck area)
    rotateX(PI / 2); // Rotate to point forward along Z-axis

    // Now, the "origin" for the sword is where the handle meets the crossguard.
    // The handle extends downwards from this point.
    // The blade extends upwards from this point.

    // Handle
    push();
    ambientMaterial(100, 70, 40); // Brown handle
    translate(0, this.size * 0.075, 0); // Move down half its length from sword origin
    cylinder(this.size * 0.06, this.size * 0.15, 12, 1);
    pop();

    // Crossguard (already at sword origin)
    ambientMaterial(180, 180, 180); // Metallic gray
    box(this.size * 0.12, this.size * 0.03, this.size * 0.03);

    // Blade
    push();
    translate(0, -this.size * 0.25, 0); // Move up half its length from sword origin
    ambientMaterial(220, 220, 220); // Lighter metallic gray for blade
    cylinder(this.size * 0.03, this.size * 0.5, 10, 1);
    pop();

    pop(); // End sword

    pop();
  }

function newMonkeyPhrase(mode) {
  let pool;
  if (mode === "chase") {
    pool = monkeyChaseWords.concat(monkeyGlitchWords);
  } else if (mode === "backup") {
    pool = monkeyBackupWords.concat(monkeyGlitchWords); // Use backup words when calling backup
  } else {
    // Should not happen in this version, but fallback
    pool = monkeyIdleWords.concat(monkeyChaseWords, monkeyGlitchWords);
  }

  const wordCount = floor(random(3, 7));
  let words = [];
  for (let i = 0; i < wordCount; i++) {
    words.push(random(pool));
  }

  let phrase = words.join(" ");
  // Random punctuation
  const punct = random(["!", "!!", "?!", "...", ""]);
  currentPhrase = phrase + punct;
}

function drawSpeechBubble(x, y, txt) {
  push();
  textAlign(LEFT, TOP);
  textSize(14);

  const padding = 8;
  const maxWidth = 220;

  const lines = splitIntoLines(txt, maxWidth);
  const lineHeight = 18;
  const bubbleW = maxWidth + padding * 2;
  const bubbleH = lines.length * lineHeight + padding * 2;

  const bx = constrain(x - bubbleW * 0.5, 10, width - bubbleW - 10);
  const by = constrain(y - bubbleH - 20, 10, height - bubbleH - 10);

  // Bubble
  noStroke();
  fill(255, 240, 220, 235);
  rect(bx, by, bubbleW, bubbleH, 10);

  // Tail toward monkey head
  fill(255, 240, 220, 235);
  triangle(
    x, y - 10,
    bx + bubbleW * 0.3, by + bubbleH,
    bx + bubbleW * 0.35, by + bubbleH
  );

  // Text
  fill(40);
  let ty = by + padding;
  for (let line of lines) {
    text(line, bx + padding, ty);
    ty += lineHeight;
  }

  pop();
}

function splitIntoLines(str, maxWidth) {
  const words = str.split(" ");
  let lines = [];
  let current = "";

  for (let w of words) {
    const test = current === "" ? w : current + " " + w;
    if (textWidth(test) > maxWidth) {
      if (current !== "") lines.push(current);
      current = w;
    } else {
      current = test;
    }
  }
  if (current !== "") lines.push(current);
  return lines;
}

function drawHUD() {
  push();
  textAlign(LEFT, TOP);
  textSize(16);
  fill(255, 240);
  text("3D AI Monkey: avoid letting it touch your cursor!", 16, 16);
  text("It now holds a sword and has a slightly longer reach!", 16, 36);
  text("Move the mouse. If it catches you, the game crashes.", 16, 56);
  text("The monkey now sees you everywhere and calls for backup!", 16, 76);
  text("No bodyguard monkeys or banana projectiles in this version.", 16, 96);
  pop();
}

function triggerCrash() {
  gameState = "crashed";
  // One last special phrase
  currentPhrase = "monkey.exe has stopped your game";
}

function drawCrashScreen() {
  background(10);

  resetMatrix();
  translate(-width / 2, -height / 2, 0);
  noLights();

  // Flash effect
  const flashes = 40;
  for (let i = 0; i < flashes; i++) {
    const x = random(width);
    const y = random(height);
    const w = random(20, 200);
    const h = random(5, 40);
    const alpha = random(80, 200);
    fill(random(200, 255), random(0, 50), random(0, 50), alpha);
    noStroke();
    rect(x, y, w, h);
  }

  fill(255, 40, 40);
  textAlign(CENTER, CENTER);
  textSize(48);
  text("GAME CRASHED", width / 2, height / 2 - 20);

  textSize(20);
  fill(240);
  text("The AI monkey caught your cursor with its sword.", width / 2, height / 2 + 20);
  text("Reload to try again.", width / 2, height / 2 + 50);
}

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