geo dash

function setup() {
  createCanvas(windowWidth, windowHeight);
  player = new Player();
  ground = new Ground(0, height - 50, width, 50); // Ground at the bottom

  // --- p5.sound initialization ---
  // userStartAudio() is essential for audio to play, especially in browsers
  // that block autoplay. It's usually called on a user gesture.
  userStartAudio(); // https://p5js.org/reference/p5/userStartAudio/
  beatOsc = new p5.Oscillator('sine'); // Create a sine wave oscillator
  beatOsc.freq(440); // Set frequency to A4 (440 Hz)
  beatOsc.amp(0); // Start silent
  beatOsc.start(); // Start the oscillator (but it's silent)
  // --- End p5.sound initialization ---

  textAlign(CENTER, CENTER);
  textSize(32);
  fill(255); // White text
}

function draw() {
  background(50, 100, 150); // Sky color

  if (!gameStarted) {
    drawStartScreen(); // Show start screen
  } else if (gameIsOver) {
    drawGameOverScreen(); // Show game over screen
  } else {
    // Game is playing
    updateBeat(); // Play a beat sound

    // Update and draw player
    player.update();
    player.draw();

    // Update and draw ground
    ground.draw();

    // Update and draw obstacles
    for (let i = obstacles.length - 1; i >= 0; i--) {
      obstacles[i].update();
      obstacles[i].draw();

      // Check collision with player
      if (player.collidesWith(obstacles[i])) {
        gameIsOver = true;
        beatOsc.amp(0); // Stop beat sound on game over
        console.log("Game Over! Score: " + score);
      }

      // Remove obstacles that have moved off-screen and update score
      if (obstacles[i].isOffScreen()) {
        obstacles.splice(i, 1); // Remove from array
        score++;
      }
    }

    // Generate new obstacles periodically
    // Every 60 frames (approx. 1 second at 60fps), with a 50% chance
    if (frameCount % 60 === 0 && random(1) < 0.5) {
      obstacles.push(new Obstacle(width, ground.y));
    }

    // Display current score
    text("Score: " + score, width / 2, 50);
  }
}

// Function to play a short beat sound
function updateBeat() {
  let currentTime = millis(); // Current sketch time in milliseconds
  if (currentTime - lastBeatTime > beatInterval) {
    // Fade in the beat sound quickly
    beatOsc.amp(beatVolume, 0.05); // https://p5js.org/reference/p5.Oscillator/amp/
    // Fade out after 50ms (relative to the sketch's time)
    beatOsc.amp(0, 0.2, currentTime + 50);
    lastBeatTime = currentTime;
  }
}

// Draw the start screen
function drawStartScreen() {
  background(0); // Black background
  fill(255);
  text("Geometry Dash Clone", width / 2, height / 2 - 50);
  text("Click or Space to Start", width / 2, height / 2 + 50);
}

// Draw the game over screen
function drawGameOverScreen() {
  background(255, 0, 0, 150); // Semi-transparent red overlay
  fill(255);
  text("GAME OVER!", width / 2, height / 2 - 50);
  text("Final Score: " + score, width / 2, height / 2);
  text("Click or Space to Restart", width / 2, height / 2 + 50);
}

// Handle mouse clicks
function mousePressed() {
  if (!gameStarted) {
    gameStarted = true;
    resetGame(); // Start the game
  } else if (gameIsOver) {
    resetGame(); // Restart the game
  } else {
    player.jump(); // Player jumps
  }
}

// Handle key presses (especially for spacebar)
function keyPressed() {
  if (!gameStarted && key === ' ') {
    gameStarted = true;
    resetGame(); // Start the game
  } else if (gameIsOver && key === ' ') {
    resetGame(); // Restart the game
  } else if (key === ' ') {
    player.jump(); // Player jumps
  }
}

// Reset game state
function resetGame() {
  player = new Player();
  obstacles = [];
  score = 0;
  gameIsOver = false;
  lastBeatTime = millis(); // Reset beat timer
  beatOsc.amp(beatVolume); // Start beat sound again
}

// Adjust canvas size when the window is resized
function windowResized() {
  resizeCanvas(windowWidth, windowHeight);
  // Adjust player and ground positions to stay at the bottom
  player.y = height - 50 - player.size;
  ground.y = height - 50;
  ground.w = width;
}

// --- Player Class ---
class Player {
  constructor() {
    this.size = 40;
    this.x = width / 4; // Player stays at a fixed X position
    this.y = height - 50 - this.size; // Positioned above the ground
    this.vy = 0; // Vertical velocity
    this.gravity = 0.6; // Gravity effect
    this.isJumping = false;
  }

  jump() {
    if (!this.isJumping) {
      this.vy = -12; // Apply upward velocity
      this.isJumping = true;
    }
  }

  update() {
    this.vy += this.gravity; // Apply gravity
    this.y += this.vy; // Update position

    // Prevent player from falling through the ground
    if (this.y >= height - 50 - this.size) {
      this.y = height - 50 - this.size;
      this.vy = 0;
      this.isJumping = false;
    }
  }

  draw() {
    fill(255, 200, 0); // Orange color for the player cube
    stroke(255);
    strokeWeight(3);
    rectMode(CORNER);
    rect(this.x, this.y, this.size, this.size, 5); // Rounded corners for style
  }

  // Simple Axis-Aligned Bounding Box (AABB) collision detection
  collidesWith(obstacle) {
    return (
      this.x < obstacle.x + obstacle.w &&
      this.x + this.size > obstacle.x &&
      this.y < obstacle.y && // Player's top is above obstacle's base
      this.y + this.size > obstacle.y - obstacle.h // Player's bottom is below obstacle's peak
    );
  }
}

// --- Ground Class ---
class Ground {
  constructor(x, y, w, h) {
    this.x = x;
    this.y = y;
    this.w = w;
    this.h = h;
  }

  draw() {
    fill(100, 150, 100); // Green color for the ground
    noStroke();
    rectMode(CORNER);
    rect(this.x, this.y, this.w, this.h);
  }
}

// --- Obstacle Class ---
class Obstacle {
  constructor(x, groundY) {
    this.x = x;
    // Changed to always be a 'spike'
    this.type = 'spike';
    this.groundY = groundY; // Y position of the ground

    // Set size and position based on type (now always spike)
    if (this.type === 'spike') {
      this.w = 40;
      this.h = 40; // Height of the spike triangle
      this.y = groundY; // Spike base is on the ground
    }
    // Block and tallBlock cases are removed as they are no longer generated
  }

  update() {
    this.x -= scrollSpeed; // Move obstacle left
  }

  draw() {
    fill(200, 50, 50); // Red color for obstacles
    noStroke();

    if (this.type === 'spike') {
      // Draw a triangle for the spike
      triangle(
        this.x, this.y, // Bottom-left
        this.x + this.w, this.y, // Bottom-right
        this.x + this.w / 2, this.y - this.h // Top-center
      );
    }
    // Block and tallBlock drawing cases are removed
  }

  // Check if obstacle has moved off the left side of the screen
  isOffScreen() {
    return this.x + this.w < 0;
  }
}