// ── SHOOTER — Core Loop (runs 60× per second) ──────────
// Phaser 3 Arcade Physics Scene

class ShooterScene extends Phaser.Scene {

  create() {
    // Spawn the player ship in the centre
    this.player = this.physics.add.image(320, 200, 'player');
    this.player.setDrag(180);        // slows the ship down
    this.player.setMaxVelocity(400); // speed cap

    // Group to hold all bullet objects
    this.bullets = this.physics.add.group();

    // Enemy timer — fires every spawnDelay ms
    this.spawnTimer = this.time.addEvent({
      delay: liveConfig.spawnDelay,
      loop: true,
      callback: this._spawnEnemy, callbackScope: this
    });
  }

  update() {
    // Rotate ship left / right
    if (LEFT)  this.player.setAngularVelocity(-liveConfig.rotateSpeed);
    if (RIGHT) this.player.setAngularVelocity(+liveConfig.rotateSpeed);
    else       this.player.setAngularVelocity(0);

    // Thrust forward in the direction the ship faces
    if (UP) {
      this.physics.velocityFromRotation(
        this.player.rotation,
        liveConfig.speed,
        this.player.body.acceleration
      );
    }

    // Shoot a bullet on SPACE (with cooldown)
    if (SPACE && canFire) {
      const bullet = this.bullets.create(x, y, 'laser');
      this.physics.velocityFromRotation(
        this.player.rotation,
        liveConfig.bulletSpeed,
        bullet.body.velocity
      );
    }
  }
}

// ── PLATFORMER — Core Loop ──────────────────────────────

create() {
  // Enable gravity on the player
  this.player = this.physics.add.image(100, 300, 'player');
  this.player.body.setGravityY(liveConfig.gravity);

  // Static platforms group (they don't move)
  this.platforms = this.physics.add.staticGroup();
  this.physics.add.collider(this.player, this.platforms);
}

update() {
  // Horizontal movement
  if      (LEFT)  this.player.body.setVelocityX(-liveConfig.speed);
  else if (RIGHT) this.player.body.setVelocityX(+liveConfig.speed);
  else            this.player.body.setVelocityX(0);

  // Jump only if touching the ground (onFloor)
  if (UP && this.player.body.onFloor()) {
    this.player.body.setVelocityY(-liveConfig.jumpForce);
  }

  // Double jump (if liveConfig.doubleJump is on)
  if (UP && liveConfig.doubleJump && !onFloor && !usedDouble) {
    this.player.body.setVelocityY(-liveConfig.jumpForce * 0.85);
    usedDouble = true;
  }
}

// ── DODGE — Core Loop ───────────────────────────────────

create() {
  this.player = this.physics.add.image(320, 340, 'player');
  this.items  = this.physics.add.group();

  // Spawn hazards + stars on a repeating timer
  this.time.addEvent({
    delay: liveConfig.spawnDelay,
    loop: true,
    callback: () => {
      const isStar = Math.random() < liveConfig.dodgeStarRatio / 100;
      const item = this.items.create(randomX, -20, isStar ? 'star' : 'enemy');
      item.isStar = isStar;
      item.setVelocityY(liveConfig.enemySpeed);
    }
  });
}

update() {
  // Player only moves left and right
  if      (LEFT)  player.x -= liveConfig.speed * delta;
  else if (RIGHT) player.x += liveConfig.speed * delta;

  // Items speed up over time with difficultyScale
  item.velocityY = liveConfig.enemySpeed
    + score * liveConfig.difficultyScale * 0.2;
}

// ── BREAKER — Core Loop ─────────────────────────────────

create() {
  // Paddle (player-controlled)
  this.paddle = this.physics.add.image(320, 370, 'block');
  this.paddle.body.setImmovable(true); // won't be pushed by ball

  // Ball — starts stationary, launched on first input
  this.ball = this.physics.add.image(320, 350, 'laser');
  this.ball.setBounce(1); // perfectly elastic
  this.ball.setCollideWorldBounds(true);

  // Brick grid — rows & columns of static images
  this.bricks = this.physics.add.staticGroup();
  for (let r=0; r<4; r++) for (let c=0; c<8; c++) {
    this.bricks.create(70+c*75, 60+r*28, 'block');
  }

  // Ball bounces off bricks and destroys them
  this.physics.add.collider(this.ball, this.bricks,
    (ball, brick) => {
      brick.destroy();
      score += liveConfig.pointsPerKill;
    }
  );
}

// ── RUNNER — Core Loop ──────────────────────────────────

create() {
  // Player is fixed on X; world scrolls past
  this.player = this.physics.add.image(80, 300, 'player');
  this.player.body.setGravityY(liveConfig.gravity);

  // Obstacles scroll in from the right
  this.obstacles = this.physics.add.group();
  this.time.addEvent({
    delay: liveConfig.spawnDelay, loop: true,
    callback: () => {
      const obs = this.obstacles.create(680, 320, 'block');
      obs.setVelocityX(-liveConfig.obstacleSpeed);
    }
  });
}

update() {
  // Only one input: jump!
  if (SPACE && this.player.body.onFloor()) {
    this.player.body.setVelocityY(-liveConfig.jumpForce);
  }
  // Score goes up every second you survive
  score += delta * 0.01;
}

// ── FLAPPY BIRD — Core Loop ─────────────────────────────

create() {
  this.bird = this.physics.add.image(100, 200, 'player');
  this.bird.body.setGravityY(liveConfig.gravity);

  // Pipes spawn every 2.2 seconds
  this.time.addEvent({
    delay: 2200, loop: true,
    callback: this._spawnPipes, callbackScope: this
  });
}

_spawnPipes() {
  const gapY  = Phaser.Math.Between(80, 280);
  const half  = liveConfig.pipeGap / 2;

  // Top pipe (hangs down from ceiling)
  this.pipes.create(680, gapY - half - 100, 'block')
    .setVelocityX(-liveConfig.obstacleSpeed);

  // Bottom pipe (rises from floor)
  this.pipes.create(680, gapY + half + 100, 'block')
    .setVelocityX(-liveConfig.obstacleSpeed);
}

update() {
  // Tap = flap upward!
  if (SPACE) this.bird.body.setVelocityY(-liveConfig.jumpForce);
}

// ── SPACE INVADERS — Core Loop ──────────────────────────

create() {
  // Build 5×4 enemy grid
  this.enemies = this.physics.add.group();
  for (let r=0; r<4; r++) {
    for (let c=0; c<5; c++) {
      this.enemies.create(120 + c*90, 60 + r*42, 'enemy');
    }
  }

  // Formation steps on a timer
  this.moveTimer = this.time.addEvent({
    delay: 700, loop: true,
    callback: this._stepFormation, callbackScope: this
  });
}

_stepFormation() {
  // Move right; if any enemy hits edge → flip direction & descend
  this.enemies.getChildren().forEach(e => e.x += direction * 18);
  if (hitEdge) {
    direction *= -1;
    this.enemies.getChildren().forEach(e => e.y += 18);
  }
  // Speed up as fewer enemies remain!
  this.moveTimer.delay = 700 / (1 + (20 - remaining) * 0.1);
}

// ── PONG — Core Loop ────────────────────────────────────

create() {
  // Two paddles + one ball
  this.paddle  = this.physics.add.image(20, 200, 'block');
  this.aiPaddle= this.physics.add.image(620, 200, 'block');
  this.ball    = this.physics.add.image(320, 200, 'laser');
  this.ball.setBounce(1).setCollideWorldBounds(true);
  this.ball.setVelocity(200, 150); // launch!
}

update() {
  // Player paddle — UP key moves up, SPACE moves down
  if      (UP)    this.paddle.body.setVelocityY(-liveConfig.speed);
  else if (SPACE) this.paddle.body.setVelocityY(+liveConfig.speed);
  else            this.paddle.body.setVelocityY(0);

  // AI paddle — slowly tracks the ball's Y
  const diff = this.ball.y - this.aiPaddle.y;
  this.aiPaddle.body.setVelocityY(
    Math.sign(diff) * Math.min(Math.abs(diff) * 4, liveConfig.enemySpeed)
  );
}

// ── SNAKE — Core Loop ───────────────────────────────────

create() {
  const CELL = liveConfig.snakeCellSize; // grid size in px
  this.snake = [{ x: 10, y: 10 }];      // array of {x,y} cells
  this.dir   = { x: 1, y: 0 };          // moving right
  this.food  = this._placeFood();

  // Move on a repeating timer (not every frame)
  this.moveTimer = this.time.addEvent({
    delay: Math.max(60, 320 - liveConfig.speed * 0.8),
    loop: true, callback: this._step, callbackScope: this
  });
}

_step() {
  // New head = old head + direction
  let head = { x: snake[0].x + dir.x, y: snake[0].y + dir.y };

  // Wall wrap (if enabled)
  if (liveConfig.snakeWallWrap) {
    head.x = (head.x + cols) % cols;
    head.y = (head.y + rows) % rows;
  } else if (outOfBounds) {
    gameOver(); return;
  }

  // Ate food? Grow. Otherwise pop the tail.
  if (head.x === food.x && head.y === food.y) {
    score++; food = placeFood(); // grow!
  } else {
    snake.pop(); // remove tail
  }
  snake.unshift(head); // add new head
}

// ── ASTEROIDS — Core Loop ───────────────────────────────

create() {
  this.ship = this.physics.add.image(320, 200, 'player');
  this.ship.setDrag(40).setMaxVelocity(400);

  // Spawn starting asteroids
  for (let i = 0; i < liveConfig.asteroidCount; i++) {
    this._spawnRock('large');
  }
}

_spawnRock(size) {
  const rock = rocks.create(randomEdgeX, randomEdgeY, 'enemy');
  rock.size = size;
  rock.setVelocity(Phaser.Math.Between(-80,80), Phaser.Math.Between(-80,80));
  rock.setCollideWorldBounds(false); // wrap instead
}

_onBulletHit(bullet, rock) {
  bullet.destroy();
  // Split large → 2 medium, medium → 2 small, small → gone
  if (rock.size === 'large')  { spawnTwo('medium'); score += 10; }
  if (rock.size === 'medium') { spawnTwo('small');  score += 20; }
  if (rock.size === 'small')  {                        score += 30; }
  rock.destroy();
}

// ── ROGUELIKE — Turn-Based Core ─────────────────────────

create() {
  // Generate dungeon: BSP → rooms → corridors
  this.rooms = generateRooms(liveConfig.rogueRooms);
  this.rooms.forEach((r, i) => {
    if (i < this.rooms.length - 1)
      connectWithCorridor(r, this.rooms[i + 1]);
  });

  // Spawn enemies based on density setting
  this.rooms.forEach(room => {
    if (Math.random() < liveConfig.rogueDensity)
      spawnEnemy(room);
  });

  this.hp = liveConfig.rogueStartHp; // player HP
}

_handleInput(dir) {
  const nx = player.gx + dir.x;
  const ny = player.gy + dir.y;

  const enemy = enemyAt(nx, ny);
  if (enemy) {
    enemy.hp -= 1;            // BUMP ATTACK
    if (enemy.hp <= 0) { enemy.destroy(); score += 10; }
  } else if (isWalkable(nx, ny)) {
    player.gx = nx; player.gy = ny; // move
  }
  _enemyTurns(); // enemies move after player
}

// ── RACING — Car Physics Core ───────────────────────────

update(time, delta) {
  const dt = delta / 1000;

  // Rotation-based forward vector
  const rad = Phaser.Math.DegToRad(car.angle);
  const fwdX = Math.sin(rad), fwdY = -Math.cos(rad);

  // Steer
  if (LEFT)  car.setAngularVelocity(-155);
  if (RIGHT) car.setAngularVelocity(+155);

  // Thrust
  if (UP) { velX += fwdX * 600 * dt; velY += fwdY * 600 * dt; }

  // Grip/drag
  velX *= grip; velY *= grip;

  // Off-road slowdown
  if (!onRoad) { velX *= 0.92; velY *= 0.92; }

  // Lap detection
  if (nearStartFinish && checkpointPassed) completeLap();
}

// ── HOPPER — Endless Vertical Hopper ──────────────────────

// Doodle Jump style: bounce off platforms, go up forever
const BOUNCE = 560; // launch velocity on platform land
const GAP    = 72;  // max vertical gap between platforms

// One-way collider — only bounce when falling DOWN
addCollider(player, platforms, (p, plat) => {
  if (p.body.velocity.y > 0) {
    p.setVelocityY(-BOUNCE);
    plat.getData('crumble') && plat.destroy();
  }
});

// Score = height gained
score = Math.floor((startY - player.y) / 8);

// ── BEAT 'EM UP — Combo Brawler ───────────────────────────

// Z = normal punch, X = heavy punch (wider range)
_doPunch(range) {
  const dir   = player.flipX ? -1 : 1;
  const hitX  = player.x + dir * range;
  enemies.forEach(e => {
    if (Math.abs(e.x - hitX) < range &&
        Math.abs(e.y - player.y) < 32)
      _hitEnemy(e);
  });
}

// Combo = chain hits within 2.2s
combo++;
score += 100 * Math.max(1, Math.floor(combo / 3));

// ── PUZZLE — Sokoban Push Logic ────────────────────────────

// Tile types: 0=floor 1=wall 2=crate 3=target 4=crate-on-target
_tryMove(dx, dy) {
  const nx = px + dx, ny = py + dy;
  if (grid[ny][nx] === 1) return; // wall

  if (grid[ny][nx] === 2 || grid[ny][nx] === 4) {
    // Push crate — check cell beyond it
    const cx = nx+dx, cy = ny+dy;
    if (grid[cy][cx] === 1 || grid[cy][cx] === 2) return;
    grid[cy][cx] = (grid[cy][cx]===3) ? 4 : 2;
    grid[ny][nx] = (grid[ny][nx]===4) ? 3 : 0;
  }
  px = nx; py = ny; moves++;
  // Win check: no tile === 2 (un-placed crate)
  if (!grid.flat().includes(2)) winLevel();
}

// ── RHYTHM — 4-Lane Note Highway ──────────────────────────

// Notes fall at 260px/s; hit window = ±36px
_judge(lane) {
  const note = closestNote(lane);
  const dist = Math.abs(note.y - HIT_Y);
  if      (dist < 18) { combo++; score += 100 * combo; }
  else if (dist < 36) { combo++; score += 50; }
  else               { combo = 0; misses++; }
}

// Load from Music Sequencer pattern:
if (liveConfig.seqPattern)
  useSequencerPattern(liveConfig.seqPattern);

// ── TOWER DEFENSE — Grid + Wave System ────────────────────

// T key = placement mode; click = build tower
_placeTower(col, row) {
  if (gold < 50 || onPath(col,row)) return;
  gold -= 50;
  towers.push({col, row, range: 120, rate: 900});
}

// Enemy follows waypoints along pre-set path
_moveEnemy(e, dt) {
  const next = path[e.pathIdx + 1];
  e.moveToward(next, e.speed * dt);
  if (e.reached(next)) e.pathIdx++;
  if (e.pathIdx >= path.length) { lives--; e.destroy(); }
}

// Waves: each one adds 2 enemies + 8 speed
gold += 30 + wave * 10; score += 100 * wave;

// ── PINBALL — Flippers · Bumpers · Targets ─────────────────

// Z / ← = left flipper · X / → = right flipper
// Flipper angle animates up when held, springs back on release
if (leftDown)  lfAngle = Math.max(lfAngle - 450*dt, -28);
else           lfAngle = Math.min(lfAngle + 450*dt,  28);

// Bumper hit: bounce ball away + add score
const spd = Math.max(spd + 200, 400);
ball.setVelocity((dx/dist)*spd, (dy/dist)*spd);
score += bumper.pts;

// Drain: ball falls below table → lose life
if (ball.y > GH + 20) { lives--; resetBall(); }
if (lives <= 0) showGameOver(score);