Cowboy gunslinger!

function setup() {
  createCanvas(windowWidth, windowHeight);
  textSize(24);
  textAlign(CENTER, CENTER);
  noStroke();
  restartGame(); // Initialize game state
}

function draw() {
  background(100, 150, 200); // Blue sky background

  if (!gameOver) {
    // --- Ground ---
    fill(150, 100, 50); // Brown ground
    rectMode(CORNERS); // https://p5js.org/reference/#/p5/rectMode
    rect(0, height * 0.8, width, height); // https://p5js.org/reference/#/p5/rect

    // --- Player Position ---
    playerY = height * 0.9; // Cowboy stands on the ground
    // Use touch or mouse input for horizontal aiming
    playerX = constrain(
      (touches.length > 0 ? touches[0].x : mouseX),
      width * 0.1, // Don't let cowboy go too far left
      width * 0.9  // Don't let cowboy go too far right
    );

    // --- Draw Cowboy (simple silhouette) ---
    drawCowboy(playerX, playerY);

    // --- Draw Gun (simple shape) ---
    drawGun(playerX, playerY);

    // --- Spawn Targets ---
    if (frameCount - lastTargetSpawnTime > targetSpawnInterval) {
      spawnTarget();
      lastTargetSpawnTime = frameCount;
    }

    // --- Update and Draw Targets ---
    drawTargets();

    // --- Display Score and Lives ---
    fill(0);
    text(`Score: ${score}`, width / 2, 30);
    text(`Lives: ${lives}`, width / 2, 60);

    // --- Player's Shot Effect (visual feedback) ---
    if (shotEffectAlpha > 0) {
      fill(255, 255, 0, shotEffectAlpha); // Yellow flash
      rectMode(CENTER);
      rect(width / 2, height / 2, width, height);
      shotEffectAlpha -= 20; // Fade out
    }
  } else {
    // --- Game Over Screen ---
    fill(255, 0, 0);
    textSize(48);
    text("DEAD!", width / 2, height / 2 - 50); // Changed to "DEAD!"
    fill(0);
    textSize(32);
    text(`Final Score: ${score}`, width / 2, height / 2 + 10);
    text("Tap to Restart", width / 2, height / 2 + 60);
  }
}

function drawCowboy(x, y) {
  fill(50, 25, 0); // Dark brown
  rectMode(CENTER);
  // Body
  rect(x, y - 30, 60, 80);
  // Head
  ellipse(x, y - 90, 50);
  // Hat
  rect(x, y - 120, 80, 20); // Brim
  rect(x, y - 135, 40, 30); // Crown
}

function drawGun(playerX, playerY) {
  // Position the gun relative to the cowboy
  gunX = playerX + 30;
  gunY = playerY - 50;

  // Calculate gun angle based on touch/mouse position relative to the gun
  // This makes the gun point towards where you tap/click
  let aimX = touches.length > 0 ? touches[0].x : mouseX;
  let aimY = touches.length > 0 ? touches[0].y : mouseY;
  gunAngle = atan2(aimY - gunY, aimX - gunX); // https://p5js.org/reference/#/p5/atan2

  push(); // https://p5js.org/reference/#/p5/push
  translate(gunX, gunY); // Move origin to gun position: https://p5js.org/reference/#/p5/translate
  rotate(gunAngle); // Rotate canvas for gun aiming: https://p5js.org/reference/#/p5/rotate

  fill(70); // Dark gray for gun
  rect(0, 0, 80, 20, 5); // Barrel
  rect(60, 0, 20, 30, 5); // Handle
  fill(100);
  ellipse(0, 0, 10); // Sight

  pop(); // https://p5js.org/reference/#/p5/pop
}

function drawTargetGun(x, y, angle, targetSize, isFiring) {
  push();
  translate(x, y);
  rotate(angle);

  fill(50); // Darker gray for target gun
  rect(0, 0, targetSize * 0.4, targetSize * 0.1, 2); // Barrel
  rect(targetSize * 0.3, 0, targetSize * 0.1, targetSize * 0.15, 2); // Handle

  // Muzzle flash when firing
  if (isFiring) {
    fill(255, 200, 0, 150); // Orange-yellow
    ellipse(targetSize * 0.5, 0, targetSize * 0.2, targetSize * 0.1);
  }

  pop();
}

function drawPerson(x, y, size) {
  push();
  translate(x, y);
  rectMode(CENTER);
  fill(150, 75, 0); // Brown for the person

  // Head
  ellipse(0, -size * 0.4, size * 0.6, size * 0.6);
  // Body
  rect(0, 0, size * 0.5, size * 0.8);
  // Legs
  rect(-size * 0.15, size * 0.6, size * 0.2, size * 0.4);
  rect(size * 0.15, size * 0.6, size * 0.2, size * 0.4);

  pop();
}

function touchStarted() {
  if (gameOver) {
    restartGame();
  } else {
    // Pass the touch/mouse coordinates to the shoot function
    shoot(touches.length > 0 ? touches[0].x : mouseX, touches.length > 0 ? touches[0].y : mouseY);
    shotEffectAlpha = 255; // Trigger visual shot effect for player's gun
  }
  return false; // Prevent default touch behavior (like scrolling)
}

function spawnTarget() {
  let size = random(targetSizeMin, targetSizeMax);
  let x = random(size / 2, width - size / 2);
  let y = height * 0.8; // Start on the ground
  let lifetime = targetLifetime; // How long target stays active
  let id = frameCount; // Unique ID for target
  targets.push({
    id, x, y, size, lifetime, isHit: false, spawnFrame: frameCount,
    targetGunAngle: 0,
    targetGunX: 0,
    targetGunY: 0,
    nextShotFrame: frameCount + random(targetShootIntervalMin, targetShootIntervalMax),
    isFiring: false
  });
}

function drawTargets() {
  for (let i = targets.length - 1; i >= 0; i--) {
    let target = targets[i];

    if (!target.isHit) {
      // Move target upwards
      target.y -= targetMoveSpeed;

      // Also move horizontally towards the player's x position
      let targetHorizontalSpeed = targetMoveSpeed * 0.5; // Adjust horizontal speed
      if (target.x < playerX) {
        target.x += targetHorizontalSpeed;
      } else if (target.x > playerX) {
        target.x -= targetHorizontalSpeed;
      }
      target.x = constrain(target.x, target.size / 2, width - target.size / 2);

      // Check if target reached the top (miss)
      if (target.y + target.size / 2 < 0 || frameCount - target.spawnFrame > target.lifetime) {
        lives--;
        targets.splice(i, 1); // Remove missed target
        checkGameOver();
        continue; // Go to next target
      }

      // Check for target-player collision (run into player)
      // Player body approx: x: playerX-30, y: playerY-70, w:60, h:80
      // Target body approx: x: target.x - target.size*0.25, y: target.y - target.size*0.4, w: target.size*0.5, h: target.size*0.8
      if (
        target.y - target.size * 0.4 <= playerY - 70 && // Target's head/upper body reaches player's chest
        dist(target.x, target.y, playerX, playerY) < (target.size * 0.4 + playerCollisionRadius) // Horizontal proximity
      ) {
        lives--;
        targets.splice(i, 1); // Remove target that ran into player
        checkGameOver();
        continue;
      }

      // Draw active target as a person
      drawPerson(target.x, target.y, target.size);

      // --- Target Shooting Logic ---
      // Target gun position relative to target body
      target.targetGunX = target.x - target.size * 0.15;
      target.targetGunY = target.y - target.size * 0.1;

      // Aim target gun at player's head (approx playerY - 90)
      target.targetGunAngle = atan2((playerY - 90) - target.targetGunY, playerX - target.targetGunX);

      // Target shoots only when in a certain vertical range and not hit yet
      if (target.y < height * 0.7 && target.y > height * 0.3) {
        if (frameCount > target.nextShotFrame) {
          lives--; // Player loses a life!
          target.nextShotFrame = frameCount + random(targetShootIntervalMin, targetShootIntervalMax);
          target.isFiring = true; // Trigger muzzle flash
          checkGameOver();
        }
      }

      // Draw target's gun
      drawTargetGun(target.targetGunX, target.targetGunY, target.targetGunAngle, target.size, target.isFiring);

      // Reset firing state for muzzle flash (only lasts one frame)
      if (target.isFiring) {
        target.isFiring = false;
      }

    } else {
      // Draw hit target (e.g., faded or with a cross)
      fill(100, 100, 100, 150); // Faded gray for hit targets
      ellipse(target.x, target.y, target.size); // Still using ellipse for hit visual
      fill(255);
      stroke(255);
      strokeWeight(2);
      line(target.x - target.size / 4, target.y - target.size / 4, target.x + target.size / 4, target.y + target.size / 4);
      line(target.x + target.size / 4, target.y - target.size / 4, target.x - target.size / 4, target.y + target.size / 4);
      noStroke();

      // Remove hit target after a short delay for visual feedback
      if (frameCount - target.spawnFrame > 30) { // Keep hit target on screen for 30 frames
        targets.splice(i, 1);
      }
    }
  }
}

function shoot(shotX, shotY) {
  let hit = false;
  for (let i = targets.length - 1; i >= 0; i--) {
    let target = targets[i];
    if (!target.isHit) {
      // Check if shot hits the target (simple distance check)
      let d = dist(shotX, shotY, target.x, target.y); // https://p5js.org/reference/#/p5/dist
      if (d < target.size / 2) { // Collision is still based on the target's original circular bounding box
        score++;
        target.isHit = true; // Mark target as hit
        hit = true;
        break; // Only hit one target per shot
      }
    }
  }

  // If no target was hit, lose a life
  if (!hit) {
    lives--;
    checkGameOver();
  }
}

function checkGameOver() {
  if (lives <= 0) {
    gameOver = true;
  }
}

function restartGame() {
  score = 0;
  lives = 3;
  gameOver = false;
  targets = [];
  targetSpawnInterval = 60; // Reset difficulty
  targetMoveSpeed = 1.5; // Reset difficulty
  lastTargetSpawnTime = frameCount;
}

function windowResized() {
  resizeCanvas(windowWidth, windowHeight);
  // Re-center player/gun position based on new canvas size
  playerY = height * 0.9;
}