MY FIRST TEST

function setup() {
  createCanvas(windowWidth, windowHeight);
  robotX = width / 2;
  robotY = height / 2; // Store original Y position
  
  rectMode(CENTER); // Draw rectangles from their center
  angleMode(RADIANS); // Ensure rotation angles are in radians

  // Assign value to armAnimationAmplitude here, where PI is defined
  armAnimationAmplitude = PI / 4; // Max swing angle (e.g., 45 degrees from vertical)
}

function draw() {
  background(220); // Light gray background

  // --- Apply Bouncing Motion to the entire robot ---
  let bounceOffset = 0;
  if (isBouncing) {
    bounceOffset = sin(bouncePhase) * bounceAmplitude;
    bouncePhase += bounceSpeed;
  }
  
  // Calculate the current Y position of the robot's center, incorporating the bounce
  let currentRobotY = robotY + bounceOffset;

  // --- Draw Body ---
  fill(0, 100, 200); // Blue body
  noStroke();
  rect(robotX, currentRobotY, bodyWidth, bodyHeight); // Use currentRobotY

  // --- Draw Head (with rotation and features) ---
  fill(200, 150, 0); // Orange head
  push(); // Save current transformation state
  translate(robotX, currentRobotY + headYOffset); // Move origin to the CENTER of the head, use currentRobotY
  rotate(headAngle); // Apply head rotation
  ellipse(0, 0, headRadius * 2, headRadius * 2); // Draw head centered on new origin

  // Draw Facial Features (they will rotate with the head)
  fill(0); // Black for eyes and nose
  ellipse(-eyeOffsetX, eyeOffsetY, eyeRadius * 2, eyeRadius * 2); // Left eye
  ellipse(eyeOffsetX, eyeOffsetY, eyeRadius * 2, eyeRadius * 2); // Right eye
  rect(0, noseYOffset, noseWidth, noseHeight); // Nose

  pop(); // Restore previous transformation state

  // --- Head Rotation Logic (happens continuously in draw if isHeadRotating is true) ---
  if (isHeadRotating) {
    headAngle += headRotationSpeed; // Increment angle
    // Check if one full rotation (TWO_PI radians) is complete
    if (headAngle >= initialHeadAngle + TWO_PI) {
      headAngle = initialHeadAngle + TWO_PI; // Snap to exact 360-degree rotation
      isHeadRotating = false; // Stop rotating
    }
  }

  // --- Update Arm Angles for Animation ---
  if (isLeftArmAnimating) {
    leftArmAngle = sin(leftArmPhase) * armAnimationAmplitude;
    leftArmPhase += armAnimationSpeed;
  }
  if (isRightArmAnimating) {
    rightArmAngle = sin(rightArmPhase) * armAnimationAmplitude;
    rightArmPhase += armAnimationSpeed;
  }

  // --- Draw Left Arm (with rotation) ---
  fill(150); // Gray arms
  push();
  translate(robotX + leftArmXOffset, currentRobotY + armsYOffset); // Move origin to shoulder pivot, use currentRobotY
  rotate(leftArmAngle); // Apply arm rotation
  rect(armWidth / 2, armHeight / 2, armWidth, armHeight); // Draw arm, shoulder is at its top-left
  pop();

  // --- Draw Right Arm (with rotation) ---
  fill(150); // Gray arms
  push();
  translate(robotX + rightArmXOffset, currentRobotY + armsYOffset); // Move origin to shoulder pivot, use currentRobotY
  rotate(rightArmAngle); // Apply arm rotation
  rect(-armWidth / 2, armHeight / 2, armWidth, armHeight); // Draw arm, shoulder is at its top-right (negative width offset)
  pop();

  // --- Draw Legs ---
  fill(0, 50, 100); // Darker blue legs
  rect(robotX - legWidth / 2, currentRobotY + legsYOffset + legHeight / 2, legWidth, legHeight); // Use currentRobotY
  rect(robotX + legWidth / 2, currentRobotY + legsYOffset + legHeight / 2, legWidth, legHeight); // Use currentRobotY
}

function mousePressed() {
  // Determine the overall bounding box of the robot for bouncing
  // Note: These calculations use the base robotY, as the bounceOffset is applied in draw()
  let robotMinX = robotX - bodyWidth / 2 - armWidth / 2;
  let robotMaxX = robotX + bodyWidth / 2 + armWidth / 2;
  let robotMinY = robotY + headYOffset - headRadius;
  let robotMaxY = robotY + legsYOffset + legHeight;

  // Toggle bouncing if clicked anywhere on the robot
  if (mouseX > robotMinX && mouseX < robotMaxX &&
      mouseY > robotMinY && mouseY < robotMaxY) {
    isBouncing = !isBouncing;
    if (isBouncing) {
      bouncePhase = 0; // Reset bounce phase when starting animation
    }
  }

  // Existing click detection for head rotation
  let headCenterX = robotX;
  let headCenterY = robotY + headYOffset;
  if (dist(mouseX, mouseY, headCenterX, headCenterY) < headRadius) {
    if (!isHeadRotating) {
      isHeadRotating = true;
      initialHeadAngle = headAngle;
    }
  }

  // Existing click detection for left arm animation
  let leftArmX = robotX + leftArmXOffset - armWidth / 2;
  let leftArmY = robotY + armsYOffset - armHeight / 2;
  if (mouseX > leftArmX && mouseX < leftArmX + armWidth &&
      mouseY > leftArmY && mouseY < leftArmY + armHeight) {
    isLeftArmAnimating = !isLeftArmAnimating;
    if (isLeftArmAnimating) {
      leftArmPhase = 0;
    } else {
      leftArmAngle = 0;
    }
  }

  // Existing click detection for right arm animation
  let rightArmX = robotX + rightArmXOffset - armWidth / 2;
  let rightArmY = robotY + armsYOffset - armHeight / 2;
  if (mouseX > rightArmX && mouseX < rightArmX + armWidth &&
      mouseY > rightArmY && mouseY < rightArmY + armHeight) {
    isRightArmAnimating = !isRightArmAnimating;
    if (isRightArmAnimating) {
      rightArmPhase = 0;
    } else {
      rightArmAngle = 0;
    }
  }
}

function windowResized() {
  resizeCanvas(windowWidth, windowHeight);
  robotX = width / 2;
  robotY = height / 2; // Reset base Y position
}