fly and race 2 player

function setGradient(c1, c2) {
  // Loop through each pixel row from top to bottom
  for (let y = 0; y < height; y++) {
    // Calculate the interpolation factor (0 at top, 1 at bottom)
    let inter = map(y, 0, height, 0, 1);
    
    // Lerp (linear interpolate) between the two colors based on the factor
    let c = lerpColor(c1, c2, inter);
    
    // Set the stroke color to the interpolated color and draw a line
    // This draws a thin line across the canvas for each row, creating the gradient
    stroke(c);
    line(0, y, width, y);
  }
}

function drawAirplaneShape() {
  // Main body
  fill(150, 150, 150); // Gray color
  noStroke();
  ellipse(0, 0, 100, 30); // Body (width 100, height 30)

  // Wings
  rect(-40, -15, 80, 10); // Main wing (relative to body center)
  rect(-20, 15, 40, 10); // Rear wing

  // Tail
  triangle(40, -15, 60, 0, 40, 15); // Tail fin

  // Cockpit window (optional detail)
  fill(100, 100, 200, 150); // Blueish transparent
  ellipse(-30, 0, 15, 10);
}

function setup() {
  // Make the canvas full screen
  createCanvas(windowWidth, windowHeight);
  resetRace(); // Initialize race state and positions, including countdown
}

function resetRace() {
  // Initialize airplane positions to the starting line (off-screen left)
  airplane1X = -150; 
  airplane2X = -150; // Both start at the same place

  // Reset speeds and acceleration flags
  airplane1Speed = 0;
  airplane2Speed = 0;
  player1IsAccelerating = false;
  player2IsAccelerating = false;

  isRacing = false; // Race is not active yet
  winner = ""; // Clear any previous winner
  
  // Reset countdown
  countdownValue = 3;
  countdownTimer = 0; // Ensure timer is not running initially
  
  // Set text properties for displaying messages
  textAlign(CENTER, CENTER);
  textSize(32);
}

function draw() {
  // --- Day-Night Cycle Logic ---
  // Update dayProgress (loops from 0 to 1)
  dayProgress += daySpeed;
  if (dayProgress > 1) {
    dayProgress = 0; // Loop back to morning/dawn
  }

  // Define colors for different times of day
  let dawnTop = color(255, 180, 100); // Warm orange for dawn top
  let dawnBottom = color(255, 220, 180); // Lighter orange for dawn horizon
  let dayTop = color(100, 150, 255); // A medium blue for the top of the day sky
  let dayBottom = color(200, 220, 255); // A lighter blue/white for the day horizon
  let nightTop = color(20, 30, 80); // Dark blue for night top
  let nightBottom = color(50, 60, 120); // Slightly lighter dark blue for night horizon

  let currentSkyTopColor;
  let currentSkyBottomColor;

  if (dayProgress < 0.5) { // Morning to Day
    // Transition from Dawn to Day colors
    let inter = map(dayProgress, 0, 0.5, 0, 1);
    currentSkyTopColor = lerpColor(dawnTop, dayTop, inter);
    currentSkyBottomColor = lerpColor(dawnBottom, dayBottom, inter);
  } else { // Day to Night
    // Transition from Day to Night colors
    let inter = map(dayProgress, 0.5, 1, 0, 1);
    currentSkyTopColor = lerpColor(dayTop, nightTop, inter);
    currentSkyBottomColor = lerpColor(dayBottom, nightBottom, inter);
  }

  // Draw the sky gradient using the current colors
  setGradient(currentSkyTopColor, currentSkyBottomColor);
  
  // --- Draw Airplane 1 (flying right) ---
  push(); // Start an isolated drawing state
  translate(airplane1X, height * 0.3); // Position the airplane horizontally and vertically
  scale(airplaneSize1); // Scale its size
  drawAirplaneShape(); // Draw the airplane shape
  pop(); // Restore the previous drawing state

  // --- Draw Airplane 2 (flying right) ---
  push(); // Start another isolated drawing state
  translate(airplane2X, height * 0.5); // Position Airplane 2
  scale(airplaneSize2); // Scale its size (no flip, both fly right for the race)
  drawAirplaneShape(); // Draw the airplane shape
  pop(); // Restore the previous drawing state

  // --- Game State Logic ---
  if (isRacing) {
    // Race is active - apply acceleration, friction, move planes, check winner
    if (player1IsAccelerating) {
      airplane1Speed += accelerationRate;
      airplane1Speed = min(airplane1Speed, maxSpeed); // Cap speed at maxSpeed
    }
    if (player2IsAccelerating) {
      airplane2Speed += accelerationRate;
      airplane2Speed = min(airplane2Speed, maxSpeed); // Cap speed at maxSpeed
    }

    // Apply friction to slow down airplanes
    airplane1Speed -= frictionRate;
    airplane1Speed = max(airplane1Speed, 0); // Speed cannot go below zero
    airplane2Speed -= frictionRate;
    airplane2Speed = max(airplane2Speed, 0); // Speed cannot go below zero

    // Move airplanes based on their current speeds
    airplane1X += airplane1Speed; 
    airplane2X += airplane2Speed; 

    // Check for a winner
    // The `winner === ""` check ensures only the first airplane to cross is declared the winner
    if (airplane1X > width + 150 && winner === "") { 
      winner = "Player 1 Wins!";
      isRacing = false; // Stop the race
    } else if (airplane2X > width + 150 && winner === "") { 
      winner = "Player 2 Wins!";
      isRacing = false; // Stop the race
    }
  } else {
    // Race is not active - display instructions, countdown, or winner
    fill(0); // Black text color
    if (winner === "") {
      // Pre-race idle state (instructions)
      if (countdownTimer === 0) { // Countdown hasn't started yet
        text("GO FLY AND WIN!", width / 2, height / 2 - 60); // Changed text here
        textSize(24);
        text(`Player 1: Press '${player1Key}' to accelerate`, width / 2, height / 2);
        text(`Player 2: Press '${player2Key}' to accelerate`, width / 2, height / 2 + 30);
        textSize(32); // Reset text size
      } else {
        // Countdown is active
        textSize(100); // Larger text for countdown numbers
        text(countdownValue, width / 2, height / 2);
        textSize(32); // Reset text size for other messages

        if (frameCount - countdownTimer >= countdownDuration) {
          countdownValue--; // Decrement the countdown number
          countdownTimer = frameCount; // Reset timer for the next number

          if (countdownValue === 0) {
            isRacing = true; // Start the race!
            countdownTimer = 0; // Clear timer as countdown is over
          }
        }
      }
    } else {
      // Post-race idle state (winner)
      text(winner, width / 2, height / 2 - 30); // Display the winner
      textSize(24);
      text("Click to Race Again!", width / 2, height / 2 + 10); // Prompt to restart
      textSize(32); // Reset text size for next race message
    }
  }
}

function keyPressed() {
  if (isRacing) { // Only allow acceleration during an active race
    if (key.toUpperCase() === player1Key) {
      player1IsAccelerating = true;
    } else if (key.toUpperCase() === player2Key) {
      player2IsAccelerating = true;
    }
  }
}

function keyReleased() {
  if (isRacing) { // Only affect acceleration during an active race
    if (key.toUpperCase() === player1Key) {
      player1IsAccelerating = false;
    } else if (key.toUpperCase() === player2Key) {
      player2IsAccelerating = false;
    }
  }
}

function mousePressed() {
  if (!isRacing && winner === "") { // If not racing and no winner displayed (either initial or countdown phase)
    if (countdownTimer === 0) { // If countdown hasn't started yet (initial instruction phase)
      // Start the countdown
      countdownTimer = frameCount;
      countdownValue = 3; // Ensure it starts from 3
    }
    // If countdown is already running, a click should not affect it.
  } else if (!isRacing && winner !== "") { // If race finished and winner is displayed
    resetRace(); // Reset for a new game, which includes resetting countdownValue and countdownTimer
  }
}

function windowResized() {
  // Make the canvas full screen on resize too
  resizeCanvas(windowWidth, windowHeight);
  // Re-initialize airplane positions and race state for a fresh start
  resetRace();
}