hit the blocks

function preload() {
  // Create simple procedural sounds using p5.Sound
  // Shoot sound: short, sharp tone
  shootSound = new p5.Oscillator();
  shootSound.setType('sine');
  shootSound.freq(440); // A4
  shootSound.amp(0);
  shootSound.start(); // Start oscillator, but keep amplitude at 0

  // Hit sound: short, high-pitched tone
  hitSound = new p5.Oscillator();
  hitSound.setType('triangle');
  hitSound.freq(880); // A5
  hitSound.amp(0);
  hitSound.start(); // Start oscillator, but keep amplitude at 0

  // Game Over sound: lower, sustained tone
  gameOverSound = new p5.Oscillator();
  gameOverSound.setType('square');
  gameOverSound.freq(220); // A3
  gameOverSound.amp(0);
  gameOverSound.start(); // Start oscillator, but keep amplitude at 0
}

function setup() {
  createCanvas(windowWidth, windowHeight); // Create canvas using responsive window dimensions
  player = new Player(width / 2, height / 2); // Initialize player in the center
  userStartAudio(); // Required to enable audio playback in browsers
}

function draw() {
  background(220); // Light gray background for the game area

  if (gameState === 'playing') {
    // Update and show player
    player.update();
    player.show();

    // Spawn enemies every 60 frames (approx. 1 second at 60 FPS)
    if (frameCount % 60 === 0) {
      enemies.push(new Enemy()); // Add a new enemy to the game
    }

    // Iterate through projectiles (backwards to safely remove elements)
    for (let i = projectiles.length - 1; i >= 0; i--) {
      projectiles[i].update(); // Move projectile
      projectiles[i].show();   // Draw projectile

      // Check collision with enemies
      for (let j = enemies.length - 1; j >= 0; j--) {
        if (projectiles[i].hits(enemies[j])) {
          score += 10; // Increase score on hit
          // Play hit sound
          hitSound.amp(0.7, 0.05); // Fade in to 0.7 amplitude over 0.05 seconds
          hitSound.amp(0, 0.1, 0.05); // Fade out to 0 amplitude over 0.1 seconds, starting 0.05s later
          projectiles.splice(i, 1); // Remove projectile
          enemies.splice(j, 1);     // Remove enemy
          break; // Projectile hit one enemy, so it's gone
        }
      }

      // Remove projectiles that go off-screen
      if (projectiles[i].offScreen()) {
        projectiles.splice(i, 1);
      }
    }

    // Iterate through enemies (backwards to safely remove elements)
    for (let i = enemies.length - 1; i >= 0; i--) {
      enemies[i].update(); // Move enemy towards player
      enemies[i].show();   // Draw enemy

      // Check collision with player
      if (enemies[i].hitsPlayer(player)) {
        // Game Over condition
        gameState = 'gameOver';
        // Play game over sound
        gameOverSound.amp(0.6, 0.1); // Fade in to 0.6 amplitude over 0.1 seconds
        gameOverSound.amp(0, 0.5, 0.2); // Fade out to 0 amplitude over 0.5 seconds, starting 0.2s later
        break; // Game is over, no need to check other enemies
      }
    }

    // Display current score
    textSize(32);
    fill(0);
    text('Score: ' + score, 10, 30);
  } else if (gameState === 'gameOver') {
    // Display Game Over screen
    textSize(64);
    fill(255, 0, 0); // Red text
    textAlign(CENTER, CENTER);
    text('GAME OVER', width / 2, height / 2);
    textSize(32);
    text('Score: ' + score, width / 2, height / 2 + 50);
    text('Press R to Restart', width / 2, height / 2 + 100);
  }
}

function mousePressed() {
  if (gameState === 'playing') {
    // Create a new projectile fired from the player's position, aiming at the mouse
    projectiles.push(new Projectile(player.x, player.y, player.angle));
    // Play shoot sound
    shootSound.amp(0.5, 0.05); // Fade in to 0.5 amplitude over 0.05 seconds
    shootSound.amp(0, 0.2, 0.1); // Fade out to 0 amplitude over 0.2 seconds, starting 0.1s later
  }
}

function keyPressed() {
  if (gameState === 'gameOver' && key === 'r') {
    restartGame(); // Restart the game if 'R' is pressed on Game Over screen
  }
}

function restartGame() {
  score = 0;
  projectiles = []; // Clear all projectiles
  enemies = [];     // Clear all enemies
  player = new Player(width / 2, height / 2); // Re-initialize player
  gameState = 'playing'; // Set game state back to playing
}

function windowResized() {
  resizeCanvas(windowWidth, windowHeight); // Resize canvas to match new window dimensions
  player.x = width / 2; // Center player horizontally
  player.y = height / 2; // Center player vertically
}

class Player {
  constructor(x, y) {
    this.x = x;
    this.y = y;
    this.size = 30; // Size of the player square
    this.speed = 5; // Movement speed
    this.angle = 0; // Aiming angle
  }

  update() {
    // Movement (WASD keys)
    if (keyIsDown(87)) { // W key
      this.y -= this.speed;
    }
    if (keyIsDown(83)) { // S key
      this.y += this.speed;
    }
    if (keyIsDown(65)) { // A key
      this.x -= this.speed;
    }
    if (keyIsDown(68)) { // D key
      this.x += this.speed;
    }

    // Constrain player to stay within canvas bounds
    this.x = constrain(this.x, this.size / 2, width - this.size / 2);
    this.y = constrain(this.y, this.size / 2, height - this.size / 2);

    // Aiming: Rotate player towards the mouse position
    this.angle = atan2(mouseY - this.y, mouseX - this.x);
  }

  show() {
    push(); // Save current drawing style
    translate(this.x, this.y); // Move origin to player's position
    rotate(this.angle);        // Rotate player to face the mouse
    fill(0, 0, 255); // Blue player character
    rectMode(CENTER);
    rect(0, 0, this.size, this.size); // Draw player square
    // Add a small red rectangle to indicate the aiming direction
    fill(255, 0, 0);
    rect(this.size / 2, 0, this.size / 2, 5);
    pop(); // Restore original drawing style
  }
}

class Projectile {
  constructor(x, y, angle) {
    this.x = x;
    this.y = y;
    this.speed = 10; // Projectile speed
    this.size = 10;  // Size of the projectile circle
    // Calculate x and y velocity components based on angle
    this.vx = this.speed * cos(angle);
    this.vy = this.speed * sin(angle);
  }

  update() {
    // Move projectile
    this.x += this.vx;
    this.y += this.vy;
  }

  show() {
    fill(255, 200, 0); // Yellow projectile
    noStroke();
    ellipse(this.x, this.y, this.size); // Draw projectile as a circle
  }

  hits(enemy) {
    // Simple circle-rectangle collision detection (projectile is circle, enemy is rect)
    let d = dist(this.x, this.y, enemy.x, enemy.y);
    return d < this.size / 2 + enemy.size / 2;
  }

  offScreen() {
    // Check if projectile is outside canvas bounds
    return (this.x < -this.size || this.x > width + this.size ||
            this.y < -this.size || this.y > height + this.size);
  }
}

class Enemy {
  constructor() {
    // Spawn enemy at a random edge of the screen
    let side = floor(random(4)); // 0: top, 1: right, 2: bottom, 3: left
    if (side === 0) { // Top
      this.x = random(width);
      this.y = -20;
    } else if (side === 1) { // Right
      this.x = width + 20;
      this.y = random(height);
    } else if (side === 2) { // Bottom
      this.x = random(width);
      this.y = height + 20;
    } else { // Left
      this.x = -20;
      this.y = random(height);
    }

    this.size = 40; // Size of the enemy square
    this.speed = random(1, 3); // Random movement speed for variety
  }

  update() {
    // Move enemy towards the player's current position
    let angle = atan2(player.y - this.y, player.x - this.x);
    this.x += this.speed * cos(angle);
    this.y += this.speed * sin(angle);
  }

  show() {
    fill(255, 0, 0); // Red enemy character
    rectMode(CENTER);
    rect(this.x, this.y, this.size, this.size); // Draw enemy square
  }

  hitsPlayer(player) {
    // Simple rectangle-rectangle collision detection (enemy is rect, player is rect)
    let dx = abs(this.x - player.x);
    let dy = abs(this.y - player.y);

    if (dx > (this.size / 2 + player.size / 2)) { return false; }
    if (dy > (this.size / 2 + player.size / 2)) { return false; }

    return true; // Collision detected
  }
}