script.js

const canvas = document.getElementById("game");
const ctx = canvas.getContext("2d");
const pixelToggle = document.getElementById("pixelToggle");
canvas.width = 800;
canvas.height = 400;
let pixelMode = false;
const editorPreviewMode = new URLSearchParams(window.location.search).has('editorPreview');

const TARGET_FPS = 60;
const FRAME_DURATION = 1000 / TARGET_FPS; // ~16.67ms per frame
let lastFrameTime = 0;
let deltaTime = 0;
let fpsSampleTime = 0;
let fpsFrameCount = 0;
let fpsDisplay = 60;

function isEffectVisibleInWorld(x, y, width = 0, height = 0, padding = 96) {
  if (typeof devMapView !== 'undefined' && devMapView) return true;
  return (
    x + width >= camera.x - padding &&
    x <= camera.x + canvas.width + padding &&
    y + height >= camera.y - padding &&
    y <= camera.y + canvas.height + padding
  );
}

// --- Intro / load screen + hold-to-skip logic ---
const _INTRO_HOLD_KEYS = new Set(["Space", "Enter", "ShiftLeft", "ShiftRight"]);
const INTRO_HOLD_MS = 600; // hold duration to skip
let _introActive = true;
let _introHoldStart = 0;
let _introHoldRAF = null;
let _introAutoTimeout = null;
let _creditsTimer = null;
let _creditsIndex = 0;

const introEl = document.getElementById("intro-screen");
const introFill = introEl ? introEl.querySelector('.intro-progress-fill') : null;
const menuEl = document.getElementById("menu");
const creditsEl = introEl ? introEl.querySelector('.intro-credits') : null;
const laughEl = introEl ? introEl.querySelector('.intro-laugh') : null;

function updateIntroFill(frac) {
  if (!introFill) return;
  introFill.style.width = (Math.max(0, Math.min(1, frac)) * 100) + '%';
}

function finishIntro() {
  if (!_introActive) return;
  _introActive = false;
  updateIntroFill(1);
  if (introEl) {
    introEl.classList.add('fadeout');
    setTimeout(() => introEl.classList.add('hidden'), 420);
  }
  if (menuEl) menuEl.classList.remove('hidden');
  if (_introHoldRAF) { cancelAnimationFrame(_introHoldRAF); _introHoldRAF = null; }
  if (_introAutoTimeout) { clearTimeout(_introAutoTimeout); _introAutoTimeout = null; }
  stopCredits();
}

function introHoldLoop(ts) {
  if (!_introHoldStart) {
    _introHoldStart = ts;
  }
  const elapsed = ts - _introHoldStart;
  updateIntroFill(elapsed / INTRO_HOLD_MS);
  if (elapsed >= INTRO_HOLD_MS) {
    finishIntro();
    return;
  }
  _introHoldRAF = requestAnimationFrame(introHoldLoop);
}

function startIntroHold() {
  if (!_introActive) return;
  if (_introHoldRAF) return; // already running
  _introHoldStart = 0;
  _introHoldRAF = requestAnimationFrame(introHoldLoop);
}

function cancelIntroHold() {
  if (_introHoldRAF) cancelAnimationFrame(_introHoldRAF);
  _introHoldRAF = null;
  _introHoldStart = 0;
  updateIntroFill(0);
}

// Show intro on first load: hide menu until intro finishes
if (menuEl) menuEl.classList.add('hidden');

document.addEventListener('keydown', (e) => {
  if (!_introActive) return;
  // Use e.code for consistent key detection
  if (_INTRO_HOLD_KEYS.has(e.code)) {
    e.preventDefault();
    e.stopPropagation();
    startIntroHold();
  }
});

document.addEventListener('keyup', (e) => {
  if (!_introActive) return;
  if (_INTRO_HOLD_KEYS.has(e.code)) {
    e.preventDefault();
    e.stopPropagation();
    cancelIntroHold();
  }
});

// Pointer / touch hold support on the intro overlay
if (introEl) {
  introEl.addEventListener('pointerdown', (ev) => {
    if (!_introActive) return;
    ev.preventDefault();
    startIntroHold();
  });
  introEl.addEventListener('pointerup', (ev) => {
    if (!_introActive) return;
    ev.preventDefault();
    cancelIntroHold();
  });
  introEl.addEventListener('pointercancel', () => { cancelIntroHold(); });
}

// Ensure touch / click hold also works reliably (prevent legacy touch scroll)
if (introEl) {
  introEl.addEventListener('touchstart', (ev) => { ev.preventDefault(); startIntroHold(); }, {passive:false});
  introEl.addEventListener('touchend', (ev) => { ev.preventDefault(); cancelIntroHold(); }, {passive:false});
}

// If user leaves the page or pointer is lost, cancel hold
window.addEventListener('blur', cancelIntroHold);
document.addEventListener('visibilitychange', () => { if (document.hidden) cancelIntroHold(); });

// Auto-finish intro after short load-time so users don't get stuck
_introAutoTimeout = setTimeout(() => { finishIntro(); }, Math.random() * 7500);

// clicking/tapping the intro will also finish it quickly
if (introEl) {
  introEl.addEventListener('click', () => finishIntro());
}

// --- credits sequence ---
const _CREDITS = [
  {text: 'MasterOfAWolf', cls: 'credit-big'},
  {text: 'The Potato Thanks You', cls: ''},
  {text: 'Special Thanks — The Community', cls: 'credit-small'},
];

function showCredit(index) {
  if (!creditsEl) return;
  // Clear existing lines
  creditsEl.innerHTML = '';
  const info = _CREDITS[index];
  const el = document.createElement('div');
  el.className = 'credit-line ' + (info.cls || '');
  el.textContent = info.text;
  creditsEl.appendChild(el);
  // force reveal
  requestAnimationFrame(() => el.classList.add('visible'));
  // the rotating joke loop runs independently of credits (handled elsewhere)
}

// --- rotating jokes loop (longer display, immediate next) ---
const _JOKES = [
  "That took longer than my last haircut.",
  "Powered by coffee and questionable code.",
  "Credits? More like ‘who stole my snacks'.",
  "If you see bugs, they're features in beta.",
  "Made with too much caffeine and not enough sleep.",

  "Loading... please pretend this is intentional.",
  "Optimizing… (we are not optimizing).",
  "Reticulating splines… whatever that means.",
  "Loading faster than my motivation on Mondays.",
  "This would be quicker if I knew what I was doing.",
  
  "Compiling confidence… failed successfully.",
  "Spawning world… hope it works this time.",
  "If this crashes, it’s your fault now.",
  "99% loaded… just kidding.",
  "Almost there… probably.",
  
  "Fixing bugs by staring at them intensely.",
  "Loading assets… and emotional baggage.",
  "This is definitely not stalling for time.",
  "Generating fun… please wait.",
  "If you're reading this, it's already too late.",
  
  "Debugging… step one: panic.",
  "Loading… powered by pure hope.",
  "One eternity later...",
  "Trust the process. There is no process.",
  "Running on vibes and stack overflow.",
  
  "Calibrating wolves… 🐺",
  "Adding legs… again.",
  "Rolling cube not included.",
  "Vote system loading… democracy takes time.",
  "Multiplayer? Don’t ask.",
  
  "Loading… do not blink.",
  "We tested this. Once.",
  "This seemed like a good idea at 2 AM.",
  "Please wait while we question our life choices.",
  "Everything is under control. Probably."
];

let _jokeLoopTimeout = null;
const JOKE_DISPLAY_MS = 2200; // how long each joke stays visible
const JOKE_GAP_MS = 60; // short gap while we swap text

function startJokeLoop() {
  if (!laughEl) return;
  stopJokeLoop();
  function cycle() {
    if (!laughEl) return;
    laughEl.textContent = _JOKES[Math.floor(Math.random() * _JOKES.length)];
    // show
    requestAnimationFrame(() => laughEl.classList.add('visible'));
    // hide after display time, then immediately start next
    _jokeLoopTimeout = setTimeout(() => {
      if (laughEl) laughEl.classList.remove('visible');
      _jokeLoopTimeout = setTimeout(cycle, JOKE_GAP_MS);
    }, JOKE_DISPLAY_MS);
  }
  cycle();
}

function stopJokeLoop() {
  if (_jokeLoopTimeout) { clearTimeout(_jokeLoopTimeout); _jokeLoopTimeout = null; }
  if (laughEl) { laughEl.classList.remove('visible'); }
}

function startCredits() {
  if (!creditsEl) return;
  _creditsIndex = 0;
  showCredit(_creditsIndex);
  _creditsTimer = setInterval(() => {
    _creditsIndex++;
    if (_creditsIndex >= _CREDITS.length) {
      clearInterval(_creditsTimer);
      _creditsTimer = null;
      return;
    }
    showCredit(_creditsIndex);
  }, 1500);
}

function stopCredits() {
  if (_creditsTimer) { clearInterval(_creditsTimer); _creditsTimer = null; }
}

// kick off credits when script loads
if (_introActive) startCredits();
// Start sprite animations in the intro for a more cinematic feel
function startIntroSprites() {
  const p = document.getElementById('intro-player');
  const s = document.getElementById('intro-snail');
  if (p) {
    // small delay to sync with credits — animate into center/visible state
    setTimeout(() => { p.classList.add('animate'); }, 400);
  }
  if (s) {
    setTimeout(() => { s.classList.add('animate'); }, 700);
  }
}

// Kick sprite animation when intro starts
if (_introActive) startIntroSprites();
if (_introActive) startJokeLoop();

// ------------------ Intro particle system (canvas) ------------------
let _introCanvas = null;
let _introCtx = null;
let _introParticles = [];
let _introParticleRAF = null;
// intro sprite animation state
let _introLastTS = 0;
let _introSnailFrame = 0;
let _introSnailTimer = 0;
const _introSnailInterval = 180; // ms per frame
let _introPlayerScale = 2.0;
let _introSnailScale = 2.2;

function createIntroCanvas() {
  if (!introEl) return;
  if (_introCanvas) return;
  const c = document.createElement('canvas');
  c.id = 'intro-canvas';
  c.style.width = '100%';
  c.style.height = '100%';
  // append just inside the intro so it sits above background but under UI
  introEl.insertBefore(c, introEl.querySelector('.intro-content'));
  _introCanvas = c;
  _introCtx = c.getContext('2d');
  resizeIntroCanvas();
  window.addEventListener('resize', resizeIntroCanvas);
}

function resizeIntroCanvas() {
  if (!_introCanvas) return;
  const rect = introEl.getBoundingClientRect();
  _introCanvas.width = Math.max(1, Math.floor(rect.width * devicePixelRatio));
  _introCanvas.height = Math.max(1, Math.floor(rect.height * devicePixelRatio));
  _introCanvas.style.width = rect.width + 'px';
  _introCanvas.style.height = rect.height + 'px';
  if (_introCtx) _introCtx.setTransform(devicePixelRatio, 0, 0, devicePixelRatio, 0, 0);
}

function spawnIntroParticle() {
  if (!_introCanvas) return;
  const w = _introCanvas.width / devicePixelRatio;
  const h = _introCanvas.height / devicePixelRatio;
  const x = Math.random() * (w * 0.6) + w * 0.2;
  const y = Math.random() * (h * 0.35) + h * 0.1;
  const vx = (Math.random() - 0.5) * 0.25;
  const vy = (Math.random() * 0.2 + 0.1);
  const life = Math.random() * 1800 + 900;
  const size = Math.random() * 3 + 2;
  const colors = ['#ffd86b', '#ff9a6b', '#9be3d8', '#8fc5ff'];
  const color = colors[Math.floor(Math.random() * colors.length)];
  _introParticles.push({ x, y, vx, vy, life, maxLife: life, size, color, alpha: 1 });
}

function introParticleTick(ts) {
  if (!_introCtx) return;
  // delta time
  const dt = _introLastTS ? (ts - _introLastTS) : 16;
  _introLastTS = ts;
  _introCtx.clearRect(0, 0, _introCanvas.width, _introCanvas.height);
  for (let i = _introParticles.length - 1; i >= 0; i--) {
    const p = _introParticles[i];
    p.x += p.vx * (dt / 16);
    p.y += p.vy * (dt / 16);
    p.life -= dt;
    p.alpha = Math.max(0, p.life / p.maxLife);
    // glow
    _introCtx.beginPath();
    _introCtx.fillStyle = p.color;
    _introCtx.globalAlpha = 0.08 * p.alpha;
    _introCtx.arc(p.x, p.y, p.size * 3.5, 0, Math.PI * 2);
    _introCtx.fill();
    _introCtx.beginPath();
    _introCtx.globalAlpha = 0.9 * p.alpha;
    _introCtx.arc(p.x, p.y, p.size, 0, Math.PI * 2);
    _introCtx.fill();
    _introCtx.globalAlpha = 1;
    if (p.life <= 0 || p.y > _introCanvas.height / devicePixelRatio + 30) {
      _introParticles.splice(i, 1);
    }
  }
  // occasionally spawn
  if (Math.random() < 0.18) spawnIntroParticle();

  // draw cinematic sprites (player left, snail right)
  try {
    const w = _introCanvas.width / devicePixelRatio;
    const h = _introCanvas.height / devicePixelRatio;

    // snail animation frame update
    _introSnailTimer += dt;
    if (_introSnailTimer >= _introSnailInterval) {
      _introSnailTimer = 0;
      _introSnailFrame = (_introSnailFrame + 1) % (snailFrames.length || 1);
    }

    // draw player
    if (playerImg && playerImg.complete && playerImg.naturalWidth) {
      const img = playerImg;
      const scale = _introPlayerScale;
      const sw = img.naturalWidth;
      const sh = img.naturalHeight;
      const dw = sw * scale;
      const dh = sh * scale;
      const px = Math.round(w * 0.28 - dw / 2);
      const py = Math.round(h * 0.56 - dh / 2);
      _introCtx.globalAlpha = 0.95;
      _introCtx.drawImage(img, px, py, dw, dh);
      _introCtx.globalAlpha = 1;
    }

    // draw snail (animated frames if available)
    let snailFrameImg = snailFrames && snailFrames.length ? snailFrames[_introSnailFrame % snailFrames.length] : snailImg;
    if (snailFrameImg && snailFrameImg.complete && snailFrameImg.naturalWidth) {
      const img = snailFrameImg;
      const scale = _introSnailScale;
      const sw = img.naturalWidth;
      const sh = img.naturalHeight;
      const dw = sw * scale;
      const dh = sh * scale;
      const sx = Math.round(w * 0.72 - dw / 2);
      const sy = Math.round(h * 0.60 - dh / 2);
      _introCtx.globalAlpha = 0.95;
      _introCtx.drawImage(img, sx, sy, dw, dh);
      _introCtx.globalAlpha = 1;
    }
  } catch (e) {}

  _introParticleRAF = requestAnimationFrame(introParticleTick);
}

function startIntroParticles() {
  if (_introParticleRAF) return;
  createIntroCanvas();
  _introParticles.length = 0;
  // seed a few
  for (let i = 0; i < 8; i++) spawnIntroParticle();
  _introParticleRAF = requestAnimationFrame(introParticleTick);
}

function stopIntroParticles() {
  if (_introParticleRAF) { cancelAnimationFrame(_introParticleRAF); _introParticleRAF = null; }
  _introParticles.length = 0;
  if (_introCanvas) {
    try { _introCanvas.remove(); } catch (e) {}
    _introCanvas = null; _introCtx = null;
  }
  window.removeEventListener('resize', resizeIntroCanvas);
}

// Hook particles into intro lifecycle
if (_introActive) startIntroParticles();

// Ensure finishIntro stops particle loop
const _origFinishIntro = finishIntro;
finishIntro = function() {
  stopIntroParticles();
  stopCredits();
  stopJokeLoop();
  _origFinishIntro();
};

// ============================================================
//  ATMOSPHERIC PARTICLE SYSTEM - DUNGEON AMBIANCE
// ============================================================

const atmosphericParticles = {
  dustMotes: [],
  embers: [],
  fireflies: [],
  debris: [],
  fogLayers: []
};

const ATMOSPHERIC_TARGETS = {
  dustMotes: 80,
  fireflies: 15,
  debris: 30,
  fogLayers: 3
};

let atmosphericStepMs = 1000 / 20; // throttle ambient particle sim to 20 FPS
let atmosphericAccumMs = 0;

// Particle class for dust motes floating in light rays
class DustMote {
  constructor() {
    this.x = Math.random() * MAP_WIDTH;
    this.y = Math.random() * MAP_HEIGHT;
    this.vx = (Math.random() - 0.5) * 0.3;
    this.vy = (Math.random() - 0.5) * 0.2;
    this.size = Math.random() * 1.5 + 0.5;
    this.opacity = Math.random() * 0.4 + 0.1;
    this.wobble = Math.random() * Math.PI * 2;
    this.wobbleSpeed = Math.random() * 0.02 + 0.01;
  }

  update() {
    this.wobble += this.wobbleSpeed;
    this.x += this.vx + Math.sin(this.wobble) * 0.2;
    this.y += this.vy + Math.cos(this.wobble * 0.7) * 0.15;
    
    // Wrap around world boundaries
    if (this.x < 0) this.x = MAP_WIDTH;
    if (this.x > MAP_WIDTH) this.x = 0;
    if (this.y < 0) this.y = MAP_HEIGHT;
    if (this.y > MAP_HEIGHT) this.y = 0;
  }

  draw(ctx) {
    ctx.fillStyle = `rgba(200, 180, 150, ${this.opacity})`;
    ctx.beginPath();
    ctx.arc(this.x, this.y, this.size, 0, Math.PI * 2);
    ctx.fill();
  }
}

// Ember particles - floating upward with glow
class Ember {
  constructor(x, y) {
    this.x = x || Math.random() * MAP_WIDTH;
    this.y = y || MAP_HEIGHT;
    this.vx = (Math.random() - 0.5) * 0.5;
    this.vy = -(Math.random() * 1.5 + 0.5);
    this.size = Math.random() * 2 + 1;
    this.life = Math.random() * 120 + 60;
    this.maxLife = this.life;
    this.brightness = Math.random() * 0.5 + 0.5;
    this.flicker = Math.random() * Math.PI * 2;
  }

  update() {
    this.x += this.vx;
    this.y += this.vy;
    this.vy -= 0.02; // gentle upward acceleration
    this.vx *= 0.99;
    this.life--;
    this.flicker += 0.1;
  }

  draw(ctx) {
    const alpha = (this.life / this.maxLife) * this.brightness;
    const flicker = Math.sin(this.flicker) * 0.3 + 0.7;

    // Cheap glow: use a larger translucent disc instead of canvas shadow blur.
    ctx.fillStyle = `rgba(255, 120, 50, ${alpha * 0.18})`;
    ctx.beginPath();
    ctx.arc(this.x, this.y, this.size * 2.6, 0, Math.PI * 2);
    ctx.fill();

    ctx.fillStyle = `rgba(255, 140, 60, ${alpha * flicker})`;
    ctx.beginPath();
    ctx.arc(this.x, this.y, this.size, 0, Math.PI * 2);
    ctx.fill();
    
    // Bright center
    ctx.fillStyle = `rgba(255, 220, 150, ${alpha * flicker})`;
    ctx.beginPath();
    ctx.arc(this.x, this.y, this.size * 0.5, 0, Math.PI * 2);
    ctx.fill();
  }
}

// Firefly particles - floating with soft pulsing glow
class Firefly {
  constructor() {
    this.x = Math.random() * MAP_WIDTH;
    this.y = Math.random() * MAP_HEIGHT;
    this.vx = (Math.random() - 0.5) * 0.4;
    this.vy = (Math.random() - 0.5) * 0.4;
    this.size = Math.random() * 1.5 + 1;
    this.pulsePhase = Math.random() * Math.PI * 2;
    this.pulseSpeed = Math.random() * 0.03 + 0.02;
    const warmOrange = [255, 165, 90];
    const currentPalette = Math.random() > 0.7 ? [100, 255, 150] : [150, 255, 200];
    const blend = Math.random(); // 0 = warm orange, 1 = current palette

    this.color = [
      Math.round(warmOrange[0] + (currentPalette[0] - warmOrange[0]) * blend),
      Math.round(warmOrange[1] + (currentPalette[1] - warmOrange[1]) * blend),
      Math.round(warmOrange[2] + (currentPalette[2] - warmOrange[2]) * blend)
    ];

    // Very rare color variant.
    if (Math.random() < 0.025) {
      this.color = [255, 120, 205];
    }
    this.changeDirection = Math.random() * 120 + 60;
    this.timer = 0;
  }

  update() {
    this.timer++;
    
    // Change direction periodically
    if (this.timer > this.changeDirection) {
      this.vx = (Math.random() - 0.5) * 0.6;
      this.vy = (Math.random() - 0.5) * 0.6;
      this.changeDirection = Math.random() * 120 + 60;
      this.timer = 0;
    }
    
    this.x += this.vx;
    this.y += this.vy;
    this.pulsePhase += this.pulseSpeed;
    
    // Wrap around
    if (this.x < 0) this.x = MAP_WIDTH;
    if (this.x > MAP_WIDTH) this.x = 0;
    if (this.y < 0) this.y = MAP_HEIGHT;
    if (this.y > MAP_HEIGHT) this.y = 0;
  }

  draw(ctx) {
    const pulse = Math.sin(this.pulsePhase) * 0.5 + 0.5;
    const alpha = pulse * 0.7 + 0.3;

    // Use a layered disc glow instead of per-particle shadow blur.
    ctx.fillStyle = `rgba(${this.color[0]}, ${this.color[1]}, ${this.color[2]}, ${alpha * 0.14})`;
    ctx.beginPath();
    ctx.arc(this.x, this.y, this.size * (2.8 + pulse), 0, Math.PI * 2);
    ctx.fill();

    ctx.fillStyle = `rgba(${this.color[0]}, ${this.color[1]}, ${this.color[2]}, ${alpha})`;
    ctx.beginPath();
    ctx.arc(this.x, this.y, this.size * (0.7 + pulse * 0.3), 0, Math.PI * 2);
    ctx.fill();
  }
}

// Floating debris - small rocks, dust clouds
class Debris {
  constructor() {
    this.x = Math.random() * MAP_WIDTH;
    this.y = Math.random() * MAP_HEIGHT;
    this.vx = (Math.random() - 0.5) * 0.2;
    this.vy = (Math.random() - 0.5) * 0.15;
    this.width = Math.random() * 3 + 2;
    this.height = Math.random() * 3 + 2;
    this.rotation = Math.random() * Math.PI * 2;
    this.rotationSpeed = (Math.random() - 0.5) * 0.02;
    this.opacity = Math.random() * 0.2 + 0.05;
  }

  update() {
    this.x += this.vx;
    this.y += this.vy;
    this.rotation += this.rotationSpeed;
    
    if (this.x < 0) this.x = MAP_WIDTH;
    if (this.x > MAP_WIDTH) this.x = 0;
    if (this.y < 0) this.y = MAP_HEIGHT;
    if (this.y > MAP_HEIGHT) this.y = 0;
  }

  draw(ctx) {
    ctx.save();
    ctx.translate(this.x, this.y);
    ctx.rotate(this.rotation);
    ctx.fillStyle = `rgba(80, 70, 60, ${this.opacity})`;
    ctx.fillRect(-this.width / 2, -this.height / 2, this.width, this.height);
    ctx.restore();
  }
}

// Fog layer for depth
class FogLayer {
  constructor(depth) {
    this.depth = depth; // 0-1, where 0 is foreground
    this.x = 0;
    this.y = 0;
    this.speed = depth * 0.3;
    this.opacity = (1 - depth) * 0.05;
    this.scale = 1 + depth * 0.5;
  }

  update() {
    this.x += this.speed * 0.2;
    if (this.x > MAP_WIDTH) this.x = 0;
  }

  draw(ctx) {
    ctx.save();
    ctx.globalAlpha = this.opacity;
    
    // Draw repeating fog pattern
    for (let x = -MAP_WIDTH; x < MAP_WIDTH * 2; x += MAP_WIDTH) {
      const gradient = ctx.createRadialGradient(
        x + this.x + MAP_WIDTH / 2, 
        MAP_HEIGHT / 2,
        0,
        x + this.x + MAP_WIDTH / 2,
        MAP_HEIGHT / 2,
        MAP_WIDTH
      );
      
      gradient.addColorStop(0, 'rgba(40, 35, 50, 0.3)');
      gradient.addColorStop(0.5, 'rgba(30, 25, 40, 0.1)');
      gradient.addColorStop(1, 'rgba(20, 15, 30, 0)');
      
      ctx.fillStyle = gradient;
      ctx.fillRect(x + this.x, 0, MAP_WIDTH, MAP_HEIGHT);
    }
    
    ctx.restore();
  }
}

// Initialize atmospheric particles
function initAtmosphericParticles() {
  if (!settings.particles) return;

  // Reset pools so restarts don't stack duplicate particles.
  atmosphericParticles.dustMotes.length = 0;
  atmosphericParticles.embers.length = 0;
  atmosphericParticles.fireflies.length = 0;
  atmosphericParticles.debris.length = 0;
  atmosphericParticles.fogLayers.length = 0;
  
  // Dust motes - lots of them for atmosphere
  for (let i = 0; i < ATMOSPHERIC_TARGETS.dustMotes; i++) {
    atmosphericParticles.dustMotes.push(new DustMote());
  }
  
  // Fireflies - fewer, more special
  for (let i = 0; i < ATMOSPHERIC_TARGETS.fireflies; i++) {
    atmosphericParticles.fireflies.push(new Firefly());
  }
  
  // Floating debris
  for (let i = 0; i < ATMOSPHERIC_TARGETS.debris; i++) {
    atmosphericParticles.debris.push(new Debris());
  }
  
  // Fog layers for depth
  for (let i = 0; i < ATMOSPHERIC_TARGETS.fogLayers; i++) {
    atmosphericParticles.fogLayers.push(new FogLayer(i / 3));
  }
}

// Update atmospheric particles
function updateAtmosphericParticles() {
  if (!settings.particles) return;

  // Keep ambient particles alive even if settings were toggled during gameplay.
  if (atmosphericParticles.dustMotes.length < ATMOSPHERIC_TARGETS.dustMotes && Math.random() < 0.35) {
    atmosphericParticles.dustMotes.push(new DustMote());
  }
  if (atmosphericParticles.fireflies.length < ATMOSPHERIC_TARGETS.fireflies && Math.random() < 0.2) {
    atmosphericParticles.fireflies.push(new Firefly());
  }
  if (atmosphericParticles.debris.length < ATMOSPHERIC_TARGETS.debris && Math.random() < 0.2) {
    atmosphericParticles.debris.push(new Debris());
  }
  while (atmosphericParticles.fogLayers.length < ATMOSPHERIC_TARGETS.fogLayers) {
    atmosphericParticles.fogLayers.push(new FogLayer(atmosphericParticles.fogLayers.length / 3));
  }
  
  for (let i = 0; i < atmosphericParticles.dustMotes.length; i++) atmosphericParticles.dustMotes[i].update();
  for (let i = 0; i < atmosphericParticles.fireflies.length; i++) atmosphericParticles.fireflies[i].update();
  for (let i = 0; i < atmosphericParticles.debris.length; i++) atmosphericParticles.debris[i].update();
  for (let i = 0; i < atmosphericParticles.fogLayers.length; i++) atmosphericParticles.fogLayers[i].update();
  
  // Update embers
  for (let i = atmosphericParticles.embers.length - 1; i >= 0; i--) {
    atmosphericParticles.embers[i].update();
    if (atmosphericParticles.embers[i].life <= 0) {
      atmosphericParticles.embers.splice(i, 1);
    }
  }
  
  // Spawn new embers near light sources (attach torch effects to lights)
  if (settings.particles && typeof lights !== 'undefined' && lights.length) {
    for (let i = 0; i < lights.length; i++) {
      const L = lights[i];
      if (!L) continue;

      // only emit if light has meaningful intensity
      if ((L.intensity || 0) < 0.08) continue;

      // small probability scaled by intensity and spawnRate
      const spawnChance = (L.particleSpawnRate || 0.02) * (L.intensity || 1);
      if (Math.random() < spawnChance && atmosphericParticles.embers.length < 120) {
        // spawn point jitter within a fraction of the light radius
        const jitter = Math.max(8, L.radius * 0.18);
        const ex = L.x + (Math.random() - 0.5) * jitter;
        const ey = L.y + (Math.random() - 0.8) * jitter; // bias upward a bit

        const e = new Ember(ex, ey);
        // make embers rise more from stronger lights
        e.vx += (Math.random() - 0.5) * 0.6;
        e.vy -= Math.random() * 0.6 * (L.intensity || 1);
        atmosphericParticles.embers.push(e);
      }
    }
  }
}

function updateAtmosphericParticlesThrottled(deltaMs) {
  if (!settings.particles) return;
  if (atmosphericStepMs <= 0) {
    updateAtmosphericParticles();
    return;
  }
  atmosphericAccumMs += deltaMs;
  const maxAccum = atmosphericStepMs * 3;
  if (atmosphericAccumMs > maxAccum) atmosphericAccumMs = maxAccum;
  if (atmosphericAccumMs < atmosphericStepMs) return;
  atmosphericAccumMs -= atmosphericStepMs;
  updateAtmosphericParticles();
}

// Draw atmospheric particles (call this in your draw function)
function drawAtmosphericParticles() {
  if (!settings.particles) return;

  // Background layers are drawn earlier in the frame; only render the
  // foreground glow particles here so they don't get duplicated.
  for (const ember of atmosphericParticles.embers) {
    if (isEffectVisibleInWorld(ember.x, ember.y, ember.size * 4, ember.size * 4)) {
      ember.draw(ctx);
    }
  }

  for (const firefly of atmosphericParticles.fireflies) {
    if (isEffectVisibleInWorld(firefly.x, firefly.y, firefly.size * 8, firefly.size * 8)) {
      firefly.draw(ctx);
    }
  }
}

const tableFrames = [];
for (let i = 0; i < 4; i++) {
  const img = new Image();
  img.src = `Assets/Sprites/table-frame-${i}.png`; // rename to match your actual filenames
  tableFrames.push(img);
}

const bgTile = new Image();
bgTile.src = "Assets/Tiles/Cobblestone BG.png";

const snailImg = new Image();
snailImg.src = "Assets/Sprites/snail-pixilart.png";

const babyMicrowaveImg = new Image();
babyMicrowaveImg.src = "Assets/Sprites/baby-microwave.svg";

const cannonImg = new Image();
cannonImg.src = "Assets/Sprites/potatocannon.png";

const clubImg = new Image();
clubImg.src = "Assets/Sprites/Club.png";

// --- SWORD ATTACK ANIMATION FRAMES ---
const swordAttackSheet = new Image();
swordAttackSheet.src = "Assets/Sprites/Sword Attack Sprite Sheet.png";

const SWORD_FRAME_WIDTH = 34;
const SWORD_FRAME_HEIGHT = 31;
const SWORD_FRAME_COUNT = 7;
const SWORD_ATTACK_EXTENSION_WIDTH = 42;
const SWORD_ATTACK_DRAW_SCALE = 1.5;
const SWORD_DOWN_BOUNCE_VELOCITY = -12;

const CLUB_ATTACK_SWING_SPAN = Math.PI * 1.25;
const CLUB_ATTACK_BASE_ANGLE = -Math.PI / 2;
const CLUB_ATTACK_RADIUS = 60;
const CLUB_ATTACK_BOX_WIDTH = 100;
const CLUB_ATTACK_BOX_HEIGHT = 30;
const CLUB_ATTACK_BOX_HALF_WIDTH = CLUB_ATTACK_BOX_WIDTH / 2;
const CLUB_ATTACK_BOX_HALF_HEIGHT = CLUB_ATTACK_BOX_HEIGHT / 2;
const CLUB_TURRET_STUN_DURATION = 50;
const CLUB_ENEMY_KNOCKBACK_MULTIPLIER = 8;
const CLUB_BOX_KNOCKBACK_MULTIPLIER = 3.5;
const CLUB_HIT_SHAKE_INTENSITY = 4;
const CLUB_PLAYER_KNOCKBACK = 4; // Player recoil when hitting enemies/boxes
const CLUB_DRAW_TIP_PADDING = 14;
const CLUB_SPRITE_ROTATION_OFFSET = Math.PI / 4;
const CLUB_FALLBACK_STROKE_BASE = 4;
const CLUB_FALLBACK_STROKE_VARIATION = 5;
const CLUB_DAMAGE = 0.5;

const DEBUG_HITBOX_LINE_WIDTH = 1;
const DEBUG_HITBOX_FILL_ALPHA = 0.14;
const DEBUG_HITBOX_ENTITY_COLOR = "rgba(255,0,0,0.7)";
const DEBUG_HITBOX_PLAYER_COLOR = "rgba(0,255,0,0.9)";
const DEBUG_HITBOX_SWORD_COLOR = "rgba(120,200,255,0.95)";
const DEBUG_HITBOX_CLUB_COLOR = "rgba(255,220,120,0.95)";
const SWORD_DRAW_ALPHA = 0.95;
const SWORD_DRAW_SHADOW_COLOR = "rgba(45, 121, 255, 0.5)";
const SWORD_DRAW_SHADOW_BLUR = 12;

// Sword attack animation canvases for rendering (right & left directions + extended reach)
let swordAnimFrames = {
  right: [],   // frames 0-6 (original right-facing sprites)
  left: [],    // frames 0-6 (flipped left-facing sprites)
  rightExtended: [], // frames 0-6 (right with extended reach pixels)
  leftExtended: []   // frames 0-6 (left with extended reach pixels)
};

// Initialize sword animation frames from the sprite sheet
function initSwordAnimFrames() {
  swordAnimFrames.right.length = 0;
  swordAnimFrames.left.length = 0;
  swordAnimFrames.rightExtended.length = 0;
  swordAnimFrames.leftExtended.length = 0;

  if (!swordAttackSheet.complete || !swordAttackSheet.naturalWidth) return;

  for (let frameIdx = 0; frameIdx < SWORD_FRAME_COUNT; frameIdx++) {
    // Extract frame from sprite sheet
    const sourceX = frameIdx * SWORD_FRAME_WIDTH;
    const sourceY = 0;

    // Create canvas for right-facing frame
    const rightCanvas = document.createElement('canvas');
    rightCanvas.width = SWORD_FRAME_WIDTH;
    rightCanvas.height = SWORD_FRAME_HEIGHT;
    const rightCtx = rightCanvas.getContext('2d');
    rightCtx.drawImage(swordAttackSheet, sourceX, sourceY, SWORD_FRAME_WIDTH, SWORD_FRAME_HEIGHT, 0, 0, SWORD_FRAME_WIDTH, SWORD_FRAME_HEIGHT);
    swordAnimFrames.right[frameIdx] = rightCanvas;

    // Create canvas for left-facing frame (horizontally flipped)
    const leftCanvas = document.createElement('canvas');
    leftCanvas.width = SWORD_FRAME_WIDTH;
    leftCanvas.height = SWORD_FRAME_HEIGHT;
    const leftCtx = leftCanvas.getContext('2d');
    leftCtx.scale(-1, 1);
    leftCtx.drawImage(swordAttackSheet, sourceX, sourceY, SWORD_FRAME_WIDTH, SWORD_FRAME_HEIGHT, -SWORD_FRAME_WIDTH, 0, SWORD_FRAME_WIDTH, SWORD_FRAME_HEIGHT);
    swordAnimFrames.left[frameIdx] = leftCanvas;

    // Create extended reach frames (stretch sprite for reach extension)
    
    // Right extended - stretched
    const rightExtCanvas = document.createElement('canvas');
    rightExtCanvas.width = SWORD_FRAME_WIDTH + SWORD_ATTACK_EXTENSION_WIDTH;
    rightExtCanvas.height = SWORD_FRAME_HEIGHT;
    const rightExtCtx = rightExtCanvas.getContext('2d');
    rightExtCtx.drawImage(swordAttackSheet, sourceX, sourceY, SWORD_FRAME_WIDTH, SWORD_FRAME_HEIGHT, 0, 0, SWORD_FRAME_WIDTH + SWORD_ATTACK_EXTENSION_WIDTH, SWORD_FRAME_HEIGHT);
    swordAnimFrames.rightExtended[frameIdx] = rightExtCanvas;

    // Left extended - stretched and mirrored
    const leftExtCanvas = document.createElement('canvas');
    leftExtCanvas.width = SWORD_FRAME_WIDTH + SWORD_ATTACK_EXTENSION_WIDTH;
    leftExtCanvas.height = SWORD_FRAME_HEIGHT;
    const leftExtCtx = leftExtCanvas.getContext('2d');
    leftExtCtx.scale(-1, 1);
    leftExtCtx.drawImage(swordAttackSheet, sourceX, sourceY, SWORD_FRAME_WIDTH, SWORD_FRAME_HEIGHT, -(SWORD_FRAME_WIDTH + SWORD_ATTACK_EXTENSION_WIDTH), 0, SWORD_FRAME_WIDTH + SWORD_ATTACK_EXTENSION_WIDTH, SWORD_FRAME_HEIGHT);
    swordAnimFrames.leftExtended[frameIdx] = leftExtCanvas;
  }
}

// Listen for sprite sheet load
swordAttackSheet.addEventListener('load', initSwordAnimFrames);
// Try to init if already loaded
setTimeout(initSwordAnimFrames, 100);

// --- PLAYER ANIMATION FRAMES ---
const playerWalkSheet = new Image();
playerWalkSheet.src = "Assets/Sprites/MACHO.png"; // your sheet

const WALK_FRAME_WIDTH  = 70;
const WALK_FRAME_HEIGHT = 90;
const WALK_FRAME_COUNT  = 8;
const PLAYER_SPRITE_H  = 64;
const PLAYER_SPRITE_W  = Math.round(PLAYER_SPRITE_H * (WALK_FRAME_WIDTH / WALK_FRAME_HEIGHT)); // ~50
const PLAYER_SPRITE_OX = Math.round((PLAYER_SPRITE_W - 32) / 2); // horizontal overflow offset (~9px)

const playerIdleImg = new Image();
playerIdleImg.src = "Assets/Sprites/Player_idle.png"; // or keep using Player.png

/*const playerJumpImg = new Image();
playerJumpImg.src = "Assets/Sprites/Player_jump.png"; // optional, for later*/

const playerImg = new Image();
playerImg.src = "Assets/Sprites/Player.png";

const snailFrames = [];

const snail1 = new Image();
snail1.src = "Assets/Sprites/Snail 1.png";

const snail2 = new Image();
snail2.src = "Assets/Sprites/Snail 2.png";

const snail3 = new Image();
snail3.src = "Assets/Sprites/Snail 3.png";

snailFrames.push(snail1, snail2, snail3, snail2);

const chairFrames = [];
for (let i = 0; i < 5; i++) {
  const img = new Image();
  img.src = `Assets/Sprites/pixil-frame-${i}.png`;
  chairFrames.push(img);
}

const settings = {
  // Graphics
  graphicsQuality: 50,
  lighting: true,
  particles: true,
  decor: true,
  enemyHealthBars: true,
  screenShake: true,
  offScreenIndicators: true,

  // Audio
  sfxEnabled: true,
  musicVolume: 0.5,
  sfxVolume: 0.5,

  // Gameplay
  invincible: false,
  infiniteLives: false,
  infiniteDash: false,
  showHitboxes: false,
  speedMultiplier: 1,

  // Controls
  swapJumpDash: false,
  vibration: true,
  joystickDeadzone: 0.2,

  // UI
  showFPS: false,
  showCoords: false,
  showMinimap: true,
  tutorialTooltips: true,

  // Accessibility
  reducedMotion: false,
  highContrast: false,
  largeHUD: false,

  // Dev / Commands
  commandsEnabled: false,
};

function applyGraphicsQuality() {
  const q = Math.max(0, Math.min(100, settings.graphicsQuality || 0));
  const t = q / 100;
  const particleFps = 20 + (60 - 20) * t;
  const lightingFps = 20 + (60 - 20) * t;
  atmosphericStepMs = 1000 / particleFps;
  lightingCacheMs = 1000 / lightingFps;
  lightingCacheDirty = true;
}

// ── MULTIPLAYER IDENTITY ──
// Unique session ID — will be assigned by server in multiplayer
const localPlayerId = "player_" + Math.random().toString(36).slice(2, 8);

// Display name — can be set from a future lobby screen
let localPlayerName = localStorage.getItem("playerName") || "Player";

// ── PLAYER NAME INPUT ──
const playerNameInput = document.getElementById("playerNameInput");
playerNameInput.value = localPlayerName;

playerNameInput.addEventListener("input", function() {
  const val = this.value.trim();
  if (val.length > 0) {
    localPlayerName = val;
    localStorage.setItem("playerName", val);
  }
});

// ── SECRET MULTIPLAYER UNLOCK ──
let _mpSequence = "";
const _MP_CODE = "wolfmp"; // change this to whatever you want

document.addEventListener("keydown", e => {
  // Only active on the main menu
  if (!document.getElementById("menu").classList.contains("hidden")) {
    _mpSequence += e.key.toLowerCase();
    if (_mpSequence.length > _MP_CODE.length) {
      _mpSequence = _mpSequence.slice(-_MP_CODE.length);
    }
    if (_mpSequence === _MP_CODE) {
      _mpSequence = "";
      openMultiplayer();
    }
  }
});

// Prevent game keys firing while typing name
playerNameInput.addEventListener("keydown", e => e.stopPropagation());

// --- INVENTORY / SHOP UI ---
function createInventoryUI() {
  if (inventoryUI) return;
  inventoryUI = document.createElement('div');
  inventoryUI.id = 'inventory-ui';
  inventoryUI.className = 'hidden inventory-overlay';

  const inner = document.createElement('div');
  inner.className = 'inventory-inner';

  const header = document.createElement('div');
  header.className = 'inventory-header';
  header.innerHTML = '<h2>Inventory</h2><div class="gold">Gold: <span id="invGold">' + playerInventory.gold + '</span></div>';
  inner.appendChild(header);

  const grid = document.createElement('div');
  grid.className = 'inventory-grid';
  grid.id = 'invGrid';
  inner.appendChild(grid);

  const closeBtn = document.createElement('button');
  closeBtn.textContent = 'Close';
  closeBtn.addEventListener('click', () => toggleInventory());
  inner.appendChild(closeBtn);

  inventoryUI.appendChild(inner);
  document.body.appendChild(inventoryUI);
  renderInventory();
}

function createShopUI() {
  if (shopUI) return;
  shopUI = document.createElement('div');
  shopUI.id = 'shop-ui';
  shopUI.className = 'hidden inventory-overlay';

  const inner = document.createElement('div');
  inner.className = 'inventory-inner shop-inner';

  const header = document.createElement('div');
  header.className = 'inventory-header';
  header.innerHTML = '<h2>Shop</h2><div class="gold">Gold: <span id="shopGold">' + playerInventory.gold + '</span></div>';
  inner.appendChild(header);

  const tip = document.createElement('p');
  tip.className = 'shop-tip';
  tip.textContent = 'Buy here. Use bought items from inventory with I.';
  inner.appendChild(tip);

  const shopList = document.createElement('div');
  shopList.className = 'shop-list';
  shopList.id = 'shopList';
  inner.appendChild(shopList);

  const actions = document.createElement('div');
  actions.className = 'shop-actions';

  const startWaveBtn = document.createElement('button');
  startWaveBtn.className = 'shop-start-wave-btn';
  startWaveBtn.textContent = 'Start Next Wave';
  startWaveBtn.addEventListener('click', () => {
    startNextWaveFromIntermission();
  });
  actions.appendChild(startWaveBtn);

  const closeBtn = document.createElement('button');
  closeBtn.textContent = 'Close';
  closeBtn.addEventListener('click', () => closeShopUI());
  actions.appendChild(closeBtn);

  inner.appendChild(actions);
  shopUI.appendChild(inner);
  document.body.appendChild(shopUI);
  renderShop();
}

function toggleInventory() {
  if (!gameRunning || gamePaused || gameOver) {
    if (inventoryOpen && inventoryUI) {
      inventoryOpen = false;
      inventoryUI.classList.add('hidden');
    }
    return;
  }
  createInventoryUI();
  inventoryOpen = !inventoryOpen;
  inventoryUI.classList.toggle('hidden', !inventoryOpen);
  if (inventoryOpen) renderInventory();
}

function openInventory() { if (!inventoryOpen) toggleInventory(); }
function closeInventory() { if (inventoryOpen) toggleInventory(); }

function openShopUI() {
  createShopUI();
  shopOpen = true;
  shopUI.classList.remove('hidden');
  renderShop();
}

function closeShopUI() {
  if (!shopUI) return;
  shopOpen = false;
  shopUI.classList.add('hidden');
}

function renderInventory() {
  if (!inventoryUI) return;
  document.getElementById('invGold').textContent = playerInventory.gold;
  const grid = document.getElementById('invGrid');
  grid.innerHTML = '';
  for (let i = 0; i < INVENTORY_SIZE; i++) {
    const slot = document.createElement('div');
    const it = playerInventory.items[i];
    if (it) {
      slot.className = 'inv-slot';
      const label = document.createElement('span');
      label.className = 'inv-slot-label';
      label.textContent = it.label + (it.qty > 1 ? ' x' + it.qty : '');
      const useBtn = document.createElement('button');
      useBtn.className = 'inv-use-btn';
      useBtn.textContent = 'Use';
      useBtn.addEventListener('click', () => useInventoryItem(i));
      slot.appendChild(label);
      slot.appendChild(useBtn);
    } else {
      slot.className = 'inv-slot empty';
      slot.textContent = '';
    }
    grid.appendChild(slot);
  }
}

function renderShop() {
  if (!shopUI) return;
  const shopGold = document.getElementById('shopGold');
  if (shopGold) shopGold.textContent = playerInventory.gold;
  const shopList = document.getElementById('shopList');
  shopList.innerHTML = '';
  for (const it of SHOP_ITEMS) {
    const row = document.createElement('div');
    row.className = 'shop-row';
    row.innerHTML = `<span class="shop-item">${it.label}</span><span class="shop-price">💰${it.price}</span>`;
    const b = document.createElement('button'); b.textContent = 'Buy';
    b.disabled = playerInventory.gold < it.price;
    b.addEventListener('click', () => buyFromShop(it.id));
    row.appendChild(b);
    shopList.appendChild(row);
  }
}

function useInventoryItem(slotIndex) {
  const slot = playerInventory.items[slotIndex];
  if (!slot) return;

  let consumed = false;

  switch (slot.id) {
    case 'health_potion': {
      if (playerLives >= maxLives) {
        potatoMessage = 'You already have full lives';
        potatoMessageTimer = 90;
        return;
      }
      playerLives = Math.min(maxLives, playerLives + 1);
      consumed = true;
      potatoMessage = 'Health restored +1';
      potatoMessageTimer = 90;
      break;
    }
    case 'jump_boots': {
      player.jumpPower = Math.min(18, player.jumpPower + 1);
      player.wallJumpPower = Math.min(18, player.wallJumpPower + 1);
      consumed = true;
      potatoMessage = 'Jump power increased';
      potatoMessageTimer = 90;
      break;
    }
    case 'speed_chili': {
      activateSpeedChili();
      consumed = true;
      potatoMessage = 'Speed Chili: sprinting at max speed for 25 seconds';
      potatoMessageTimer = 90;
      break;
    }
    case 'mega_potion': {
      if (playerLives >= maxLives) {
        potatoMessage = 'You already have full lives';
        potatoMessageTimer = 90;
        return;
      }
      playerLives = Math.min(maxLives, playerLives + 2);
      consumed = true;
      potatoMessage = 'Health restored +2';
      potatoMessageTimer = 90;
      break;
    }
    case 'feather_boots': {
      activateFeatherBoots();
      consumed = true;
      potatoMessage = 'Feather Boots: falling slower for 45 seconds';
      potatoMessageTimer = 90;
      break;
    }
    case 'dash_battery': {
      activateDashBattery();
      consumed = true;
      potatoMessage = 'Dash Battery: quarter dash cooldown for 20 seconds';
      potatoMessageTimer = 90;
      break;
    }
    default:
      potatoMessage = 'This item is not usable yet';
      potatoMessageTimer = 90;
      return;
  }

  if (!consumed) return;
  slot.qty -= 1;
  if (slot.qty <= 0) {
    playerInventory.items[slotIndex] = null;
  }
  renderInventory();
  renderShop();
}

function buyFromShop(id) {
  const it = SHOP_ITEMS.find(x => x.id === id);
  if (!it) return;
  if (playerInventory.gold < it.price) { 
    potatoMessage = "Not enough gold"; 
    potatoMessageTimer = 90; 
    return; 
  }
  
  let stacked = false;
  for (let i = 0; i < playerInventory.items.length; i++) {
    const slot = playerInventory.items[i];
    if (slot && slot.id === id) { 
      slot.qty++; 
      stacked = true; 
      break; 
    }
  }
  
  if (!stacked) {
    if (playerInventory.items.length < INVENTORY_SIZE) {
      playerInventory.items.push({ id: it.id, label: it.label, qty: 1 });
    } else {
      potatoMessage = "Inventory full!";
      potatoMessageTimer = 90;
      return;
    }
  }
  
  playerInventory.gold -= it.price;
  potatoMessage = `Bought ${it.label}`;
  potatoMessageTimer = 90;
  renderInventory();
  renderShop();
}

function startNextWaveFromIntermission() {
  if (!G.wavesystem.enabled || G.wavesystem.waveActive || buildMode) {
    return false;
  }

  closeBuildMode();
  closeShopUI();
  G.shopkeepers.length = 0;
  G.wavesystem.waveTimer = 0;
  startNextWave();
  return true;
}

function finishBuildModeForShopping() {
  if (!G.wavesystem.enabled || G.wavesystem.waveActive || !buildMode) {
    return false;
  }

  closeBuildMode();

  const shouldOpenShopWindow = G.wavesystem.currentWave >= nextShopWindowWave;
  if (shouldOpenShopWindow) {
    maybeSpawnShopkeeperOnWaveComplete();
    G.wavesystem.waveTimer = POST_BUILD_SHOP_FRAMES;
    potatoMessage = `Build complete. ${POST_BUILD_SHOP_SECONDS}s to shop — press N for 3s countdown`;
    potatoMessageTimer = 180;
    showSpawnHUD(`Shop time: ${POST_BUILD_SHOP_SECONDS}s — press N to skip to 3s`, 220);
  } else {
    G.wavesystem.waveTimer = 180;
    potatoMessage = `Build complete. Next shop in ${Math.max(1, nextShopWindowWave - G.wavesystem.currentWave)} wave(s).`;
    potatoMessageTimer = 140;
  }

  return true;
}

function skipIntermissionToThreeSeconds() {
  if (!G.wavesystem.enabled || G.wavesystem.waveActive || buildMode) {
    return false;
  }
  if (G.wavesystem.waveTimer <= INTERMISSION_SKIP_TO_FRAMES) {
    return false;
  }

  G.wavesystem.waveTimer = INTERMISSION_SKIP_TO_FRAMES;
  closeShopUI();
  potatoMessage = 'Skipping to 3 second countdown';
  potatoMessageTimer = 90;
  return true;
}

function attemptShopInteract() {
  if (inventoryOpen || shopOpen) return;
  const interacted = tryInteractWithShop();
  if (!interacted) {
    const nearestDist = getNearestShopkeeperDistance();
    if (nearestDist > 0 && nearestDist < 200) {
      potatoMessage = "Move closer to the shopkeeper";
      potatoMessageTimer = 60;
    }
  }
}

// (Removed quick single-key handlers in favor of unified keybinding system)

// ── NETWORK ──
const Network = {
  socket: null,
  connected: false,
  remotePlayers: new Map(),
  isHost: false,
  serverUrl: "ws://localhost:8080", //Use this for local testing
  //serverUrl: "wss://youtube-game-production.up.railway.app/", // Use this to connect to the server

  connect(onOpen) {
    this.socket = new WebSocket(this.serverUrl);

    this.socket.onopen = () => {
      this.connected = true;
      if (onOpen) onOpen();
    };

    this.socket.onclose = () => {
      this.connected = false;
      chatLog("🌐 Disconnected from server", "#ff8888");
    };

    this.socket.onerror = () => {
      this.connected = false;
      document.getElementById("lobbyStatus").textContent = "Could not connect to server.";
    };

    this.socket.onmessage = (e) => {
      let msg;
      try { msg = JSON.parse(e.data); } catch { return; }
      this.handleMessage(msg);
    };
  },

  send(data) {
    if (this.connected && this.socket.readyState === WebSocket.OPEN) {
      this.socket.send(JSON.stringify(data));
    }
  },

  handleMessage(msg) {
    switch (msg.type) {
  
      case "created":
        Network.isHost = true;
        document.getElementById("lobbyRoomCode").textContent = msg.code;
        document.getElementById("lobbyRoom").classList.remove("hidden");
        document.getElementById("lobbyStatus").textContent = "Share this code with friends!";
        document.getElementById("lobbyStartBtn").classList.remove("hidden");
        lobbySetPlayerList(msg.players);
        break;
  
      case "joined":
        Network.isHost = false;
        document.getElementById("lobbyRoomCode").textContent = msg.code;
        document.getElementById("lobbyRoom").classList.remove("hidden");
        document.getElementById("lobbyStatus").textContent = "Connected!";
        lobbySetPlayerList(msg.players);
        break;
  
      case "gameState":
        if (!Network.isHost) {
          applyEnemySnapshot(msg.snap);
        }
        break;
  
      case "playerJoined":
        // Don't touch isHost here — this fires on everyone when someone joins
        chatLog("🎮 " + msg.name + " joined", "#80ff80");
        lobbySetPlayerList(msg.players);
        break;
  
      case "playerLeft":
        chatLog("👋 " + msg.name + " left", "#aaaaaa");
        this.remotePlayers.delete(msg.id);
        break;
  
      case "playerList":
        lobbySetPlayerList(msg.players);
        break;
  
      case "youAreHost":
        Network.isHost = true;
        document.getElementById("lobbyStartBtn").classList.remove("hidden");
        document.getElementById("lobbyStatus").textContent = "You are now the host.";
        break;
  
      case "playerUpdate":
        if (msg.id !== localPlayerId) {
          if (!this.remotePlayers.has(msg.id)) {
            this.remotePlayers.set(msg.id, {});
          }
          applyPlayerSnapshot(this.remotePlayers.get(msg.id), msg.snapshot);
        }
        break;
  
      case "gameStarted":
        hideAllMenus();
        startWaveModeLevel(msg.level || 1);
        break;
  
      case "chat":
        chatLog("[" + msg.name + "] " + msg.text, "#c8c0e8");
        break;
  
      case "error":
        document.getElementById("lobbyStatus").textContent = msg.message;
        break;
    }
  },

  tick() {
    if (!this.connected) return;
    this.send({
      type: "playerUpdate",
      id: localPlayerId,
      snapshot: getPlayerSnapshot()
    });
    if (this.isHost) {
    this._enemyTick = (this._enemyTick || 0) + 1;
    if (this._enemyTick >= 3) {
      this._enemyTick = 0;
      this.send({
        type: "gameState",
        snap: getEnemySnapshot(),
      });
    }
  }
},
};

function lobbySetPlayerList(players) {
  const list = document.getElementById("lobbyPlayerList");
  list.innerHTML = "";
  for (const p of players) {
    const entry = document.createElement("div");
    entry.className = "lobby-player-entry" + (p.isHost ? " is-host" : "");
    entry.textContent = "🎮 " + p.name;
    list.appendChild(entry);
  }
}
// ── MULTIPLAYER LOBBY ──
function openMultiplayer() {
  hideAllMenus();
  document.getElementById("multiplayerLobby").classList.remove("hidden");
  document.getElementById("lobbyRoom").classList.add("hidden");
}
function lobbyCreateRoom() {
  Network.connect(() => {
    Network.send({ type: "create", id: localPlayerId, name: localPlayerName });
    Network.isHost = true;
  });
}

function lobbyJoinRoom() {
  const code = document.getElementById("roomCodeInput").value.trim().toUpperCase();
  if (code.length !== 4) {
    document.getElementById("lobbyStatus").textContent = "Enter a 4-letter code.";
    return;
  }
  document.getElementById("lobbyStatus").textContent = "Connecting...";
  Network.connect(() => {
    Network.send({ type: "join", id: localPlayerId, name: localPlayerName, code });
  });
}

function lobbyStartGame() {
  Network.send({ type: "startGame", level: 1 });
}

document.getElementById("roomCodeInput").addEventListener("input", function() {
  this.value = this.value.toUpperCase();
});
// Prevent game keys while typing room code
document.getElementById("roomCodeInput").addEventListener("keydown", e => e.stopPropagation());

const tutorialState = {
  active: false,
  completedZones: new Set(),
  currentMessage: '',
  messageColor: '#ffd54f',
  messageTimer: 0,
  completionShown: false,
  pulseTimer: 0,
  arrowBob: 0,
  zoneSigns: [],
  groundPaintings: [],
  museumLabels: [],
  checkpointArrows: [],
  zoneDividers: [],
};

// === DEBUG TEST SYSTEM ===
let debugTests = [];
let debugTestMode = false;

const TEST_STATUS = {
  PENDING:  "pending",
  RUNNING:  "running",
  PASS:     "pass",
  FAIL:     "fail"
};

const TUTORIAL_TRIGGERS = [];

const G = {
SuperSnails: [],
snails: [],
bats: [],
yetis: [],
snowmen:     [],
babyMicrowaves: [],
turrets:     [],
chairs:      [],
tables:      [],
bullets:     [],
fireballs:   [],
snowballs:   [],
icicles:     [],
explosions:  [],
droppedCookies: [],
  cookie: {
  x: 400,
  y: 200,
  radius: 45,
  bobOffset: 0,
  bobSpeed: 0.08,
  clickCooldown: 0,
  clickCount: 0
},
wavesystem: {
  enabled: false,
  currentWave: 0,
  enemiesRemaining: 0,
  waveActive: false,
  timeBetweenWaves: 180 * 5,
  waveTimer: 0,
  totalEnemiesKilled: 0,
  
  spawnQueue: [],
  spawnTimer: 0,
  
  // Current map's wave configuration
  currentMapWaves: null
}
};

// Shopkeepers pool
G.shopkeepers = [];

let wasOff = true; 
let lightingEnabled = true;
let lights = [];
let lightingCacheMs = 1000 / 20; // throttle lighting redraw to 20 FPS
let lightingCacheCanvas = null;
let lightingCacheCtx = null;
let lightingCacheTime = 0;
let lightingCacheCamX = 0;
let lightingCacheCamY = 0;
let lightingCacheDirty = true;
let gameRunning = false;
let gamePaused = false;
let tutorialActive = false;
let currentMap = 1;
let currentLevel = 1;
let lastTimestamp = 0;
let generatedTiles = [];
let enemies = [];
let walls = [];
let cheeses = [];
let boxes = [];
let items = [];
let initialChairs = [];
let ladders = [];
let spikes = [];
let timeElapsed = 0;
let cheeseCooldown = 0;
const CHEESE_COOLDOWN = 3600; // 60 seconds
let gameLoopId = null;
let ovens = [];
let potato = [];
let snowParticles = [];
let speedChiliTrailParticles = [];
let initialTables = [];
let seesaws = [];
let potatoMessage = "";
let potatoMessageTimer = 0;
// Top-center HUD notification (for important spawns like shopkeeper)
let spawnHUDText = "";
let spawnHUDTimer = 0;
let spawnHUDMax = 0;

function showSpawnHUD(text, frames = 180) {
  spawnHUDText = text || "";
  spawnHUDTimer = Math.max(0, Math.floor(frames));
  spawnHUDMax = spawnHUDTimer;
}
let potatoHUDLine = "";
let ambientLight = .67;

// Level-defined spawn zones (populated from .lvl files)
let levelSpawnZones = [];

let vehicles = [];
let playerVehicle = null;    // vehicle the player is currently in
let playerInVehicle = false;

let cannonProjectiles = [];
let cannonAimAngle = 0;       // radians, updated every frame from mouse or joystick
let cannonCooldown = 0;       // prevents spray-firing
const CANNON_COOLDOWN_FRAMES = 18;

let droppedParts = [];    // world pickups
let placedStructures = []; // built objects in the world
let partInventory = {
  bouncy: 0, spike: 0, wall: 0,
  body: 0, wheel: 0, engine: 0, seat: 0
};

// --- PLAYER INVENTORY & SHOP ---
const INVENTORY_SIZE = 24; // slots
const POST_BUILD_SHOP_SECONDS = 60;
const POST_BUILD_SHOP_FRAMES = POST_BUILD_SHOP_SECONDS * 60;
const INTERMISSION_SKIP_TO_FRAMES = 180; // 3 seconds at 60fps
const SHOP_WAVE_GAP_MIN = 3;
const SHOP_WAVE_GAP_MAX = 5;

function randomShopGap() {
  return SHOP_WAVE_GAP_MIN + Math.floor(Math.random() * (SHOP_WAVE_GAP_MAX - SHOP_WAVE_GAP_MIN + 1));
}

let nextShopWindowWave = randomShopGap();

let playerInventory = {
  gold: 50,
  items: [] // { id, label, qty }
};

const SHOP_ITEMS = [
  { id: 'health_potion', label: 'Health Potion', price: 25 },
  { id: 'jump_boots',   label: 'Jump Boots',   price: 75 },
  { id: 'speed_chili',   label: 'Speed Chili',  price: 60 },
  { id: 'mega_potion',   label: 'Mega Potion',  price: 55 },
  { id: 'feather_boots', label: 'Feather Boots', price: 90 },
  { id: 'dash_battery',  label: 'Dash Battery', price: 70 }
];

const SPEED_CHILI_DURATION_FRAMES = 25 * 60;
const SPEED_CHILI_SPEED = 8;
const FEATHER_BOOTS_DURATION_FRAMES = 45 * 60;
const FEATHER_BOOTS_FALL_GRAVITY_MULTIPLIER = 0.45;
const FEATHER_BOOTS_MAX_FALL_SPEED = 7;
const DASH_BATTERY_DURATION_FRAMES = 20 * 60;
const DASH_BATTERY_COOLDOWN_MULTIPLIER = 0.25;

function activateSpeedChili() {
  player.speedChiliTimer = SPEED_CHILI_DURATION_FRAMES;
  player.speedChiliDirection = player.facing || 1;
  player.speedChiliTrailCooldown = 0;
}

function activateFeatherBoots() {
  player.featherBootsTimer = FEATHER_BOOTS_DURATION_FRAMES;
}

function activateDashBattery() {
  player.dashBatteryTimer = DASH_BATTERY_DURATION_FRAMES;
}

function updateSpeedChiliState() {
  if (player.speedChiliTimer <= 0) return;
  player.speedChiliTimer--;
  if (player.speedChiliTimer <= 0) {
    player.speedChiliTimer = 0;
    player.speedChiliDirection = 0;
    player.speedChiliTrailCooldown = 0;
  }
}

function updateDashBatteryState() {
  if (player.dashBatteryTimer > 0) {
    player.dashCooldownMultiplier = DASH_BATTERY_COOLDOWN_MULTIPLIER;
  } else {
    player.dashCooldownMultiplier = 1;
  }

  if (player.dashBatteryTimer <= 0) return;
  player.dashBatteryTimer--;
  if (player.dashBatteryTimer <= 0) {
    player.dashBatteryTimer = 0;
    player.dashCooldownMultiplier = 1;
  }
}

function updateSpeedChiliTrail() {
  if (!settings.particles) {
    speedChiliTrailParticles.length = 0;
    return;
  }

  if (player.speedChiliTimer > 0 && !playerInVehicle && !gameOver && !levelUpPending && !buildMode) {
    if (player.speedChiliTrailCooldown > 0) {
      player.speedChiliTrailCooldown--;
    }

    if (player.speedChiliTrailCooldown <= 0) {
      const facing = player.speedChiliDirection || player.facing || 1;
      const trailX = facing === 1 ? player.x + 6 : player.x + player.width - 6;
      const trailY = player.y + player.height - 12;

      speedChiliTrailParticles.push({
        x: trailX,
        y: trailY + (Math.random() * 6 - 3),
        vx: -facing * (0.25 + Math.random() * 0.25),
        vy: -0.35 - Math.random() * 0.3,
        life: 16,
        maxLife: 16,
        size: 4 + Math.random() * 3,
        hue: 18 + Math.random() * 18
      });

      if (speedChiliTrailParticles.length > 48) {
        speedChiliTrailParticles.shift();
      }

      player.speedChiliTrailCooldown = 2;
    }
  } else {
    player.speedChiliTrailCooldown = 0;
  }

  for (let i = speedChiliTrailParticles.length - 1; i >= 0; i--) {
    const p = speedChiliTrailParticles[i];
    p.x += p.vx;
    p.y += p.vy;
    p.vy += 0.03;
    p.life--;
    if (p.life <= 0) {
      speedChiliTrailParticles.splice(i, 1);
    }
  }
}

function drawSpeedChiliTrail() {
  if (!settings.particles || speedChiliTrailParticles.length === 0) return;

  ctx.save();
  ctx.globalCompositeOperation = 'lighter';

  for (const p of speedChiliTrailParticles) {
    const alpha = Math.max(0, p.life / p.maxLife);
    ctx.globalAlpha = alpha;
    ctx.fillStyle = `hsl(${p.hue}, 100%, ${55 + alpha * 18}%)`;
    ctx.beginPath();
    ctx.arc(p.x, p.y, p.size * (0.5 + alpha * 0.6), 0, Math.PI * 2);
    ctx.fill();
  }

  ctx.restore();
}

let inventoryUI = null; // DOM node for inventory UI
let shopUI = null; // DOM node for shop UI
let inventoryOpen = false;
let shopOpen = false;

let buildMode = false;
let buildSelectedPart = "bouncy";
let buildCursor = { wx: 0, wy: 0 }; // world-space grid cursor
let buildDeleteMode = false;

const BUILD_CELL = 40; // grid cell size in world pixels

const PART_TYPES = {
  bouncy:   { label: "🌀 Bouncy",    color: "#4caf50", key: "2" },
  spike:    { label: "🩸 Spike Trap",color: "#d33",    key: "3" },
  wall:     { label: "🧱 Wall",      color: "#888",    key: "4" },
  body:     { label: "🟫 Body",      color: "#7a5c3a", key: "5" },
  wheel:    { label: "⚙️ Wheel",     color: "#333",    key: "6" },
  engine:   { label: "🔧 Engine",    color: "#c07020", key: "7" },
  seat:     { label: "💺 Seat",      color: "#4466aa", key: "8" },
};

// === GAMEPAD MODULE ===
const virtualCursor = {
  x: 400, // screen space
  y: 300,
  radius: 80 // how far from player center it orbits
};

let gamepadIndex = null;

window.addEventListener("gamepadconnected", (e) => {
  gamepadIndex = e.gamepad.index;
  console.log("🎮 Controller connected:", e.gamepad.id);
});

window.addEventListener("gamepaddisconnected", () => {
  gamepadIndex = null;
  console.log("🎮 Controller disconnected");
});
  
const attackBtn = document.getElementById("btnAttack");
const inventoryBtn = document.getElementById("btnInventory");
const shopBtn = document.getElementById("btnShop");
// Joystick state (mobile aiming)
const joystick = {
  active: false,
  startX: 0,
  startY: 0,
  currentX: 0,
  currentY: 0,
  angle: 0,
  magnitude: 0
};

const potatoDeathLines = [
  "🥔 that was avoidable",
  "🥔 you dropped us",
  "🥔 again?",
  "🥔 gravity warned you",
  "🥔 I felt that",
  "🥔 unfortunate",
  "🥔 skill issue",
  "🥔 failure",
  "🥔 not lit",
  "🥔 do better",
  "🥔 death should not stop you",
  "🥔 ... ",
  "🥔 ?$@!%",
  "🥔 this is some rigidbody ahh gameplay",
  "🥔 we will pretend this did not happen"
];

const bakedPotatoDeathLines = [
  "🥔🔥 perfectly roasted… and dropped",
  "🥔🔥 crispy on the outside, dead inside",
  "🥔🔥 you burnt it",
  "🥔🔥 overcooked",
  "🥔🔥 we warned you",
  "🥔🔥 skill issue, but warmer",
  "🥔🔥 mashed by gravity",
  "🥔🔥 this is why we preheat"
];

let potatoState = "none";
// "none" | "raw" | "baked"

// === Level Initial State Storage ===
let initialBoxes = [];
let initialSnails = [];
let initialSuperSnails = [];
let initialBabyMicrowaves = [];
let initialWalls = [];
let initialSpikes = [];
let initialLadders = [];

const swordWidth = 70;  // new longer sword
const swordHeight = 10; // keep same height
const swordOffsetY = 8; // vertical offset from player

const MAP_WIDTH = 2800;
const MAP_HEIGHT = 2100;
const WALL_THICKNESS = 30;

// Screaming potato sprite sheet
const screamPotatoSheet = new Image();
screamPotatoSheet.src = "Assets/Sprites/screaming-potato-sheet.png";

const SCREAM_ANIM = {
  frameW: 16, frameH: 16,   // size of ONE frame in your sheet
  frameCount: 5,
  framesPerRow: 5,
  frameSpeed: 5,             // ticks per frame
  drawSize: 22, drawSizeBig: 32,
};

// Screams — add as many files as you want, one is picked randomly on fire + mid-flight
const potatoScreams = [
  new Audio("Assets/Sfx/scream1.mp3"),
  new Audio("Assets/Sfx/scream2.mp3"),
  new Audio("Assets/Sfx/scream3.mp3"),
];
const potatoImpactSFX    = new Audio("Assets/Sfx/splat.mp3");
const explosionImpactSFX = new Audio("Assets/Sfx/boom.mp3");

// Sword sounds — picked randomly and pitch-shifted
const swordSounds = [
  new Audio("Assets/Sfx/Sword 1.wav"),
  new Audio("Assets/Sfx/Sword 2.wav"),
  new Audio("Assets/Sfx/Sword 3.wav")
];

function playSwordSound() {
  if (!settings.sfxEnabled) return;
  const s = swordSounds[Math.floor(Math.random() * swordSounds.length)];
  s.currentTime = 0;
  s.volume = settings.sfxVolume;
  // Random pitch variation between 0.8 and 1.2 (±20%)
  s.playbackRate = 0.8 + Math.random() * 0.4;
  s.play().catch(() => {});
}

function playPotatoScream() {
  if (!settings.sfxEnabled) return;
  const s = potatoScreams[Math.floor(Math.random() * potatoScreams.length)];
  s.currentTime = 0;
  s.play().catch(() => {});
}
function playPotatoImpact(explosive = false) {
  if (!settings.sfxEnabled) return;
  const s = explosive ? explosionImpactSFX : potatoImpactSFX;
  s.currentTime = 0;
  s.play().catch(() => {});
}

// ============================================================
//  SETTINGS PERSISTENCE
// ============================================================

function saveSettings() {
  localStorage.setItem("gameSettings", JSON.stringify(settings));
  localStorage.setItem("keyBindings", JSON.stringify(keyBindings));
  // Also save the toggles that live outside the settings object
  localStorage.setItem("crtEnabled", document.getElementById("crtToggle").checked);
  localStorage.setItem("pixelEnabled", document.getElementById("pixelToggle").checked);
  localStorage.setItem("musicEnabled", document.getElementById("musicToggle").checked);
}

function loadSettings() {
  const saved = localStorage.getItem("gameSettings");
  if (saved) {
    try {
      const parsed = JSON.parse(saved);
      // Merge into settings (keeps any new keys added in future)
      Object.assign(settings, parsed);
    } catch(e) { /* corrupt data, ignore */ }
  }

  // Apply settings object to all checkboxes/sliders
  document.getElementById("settingLighting").checked     = settings.lighting;
  document.getElementById("settingParticles").checked    = settings.particles;
  document.getElementById("settingDecor").checked        = settings.decor;
  document.getElementById("settingHealthBars").checked   = settings.enemyHealthBars;
  document.getElementById("settingScreenShake").checked  = settings.screenShake;
  document.getElementById("settingIndicators").checked   = settings.offScreenIndicators;
  document.getElementById("settingGraphicsQuality").value = settings.graphicsQuality;
  document.getElementById("graphicsQualityLabel").textContent = Math.round(settings.graphicsQuality) + "%";
  document.getElementById("settingSFX").checked          = settings.sfxEnabled;
  document.getElementById("settingMusicVolume").value    = settings.musicVolume;
  document.getElementById("settingSFXVolume").value     = settings.sfxVolume;
  document.getElementById("musicVolumeLabel").textContent = Math.round(settings.musicVolume * 100) + "%";
  document.getElementById("settingHitboxes").checked     = settings.showHitboxes;
  document.getElementById("settingSwapJumpDash").checked = settings.swapJumpDash;
  document.getElementById("settingVibration").checked    = settings.vibration;
  document.getElementById("settingDeadzone").value       = settings.joystickDeadzone;
  document.getElementById("deadzoneLabel").textContent   = settings.joystickDeadzone.toFixed(2);
  document.getElementById("settingFPS").checked          = settings.showFPS;
  document.getElementById("settingCoords").checked       = settings.showCoords;
  document.getElementById("settingMinimap").checked      = settings.showMinimap;
  document.getElementById("settingTooltips").checked     = settings.tutorialTooltips;
  document.getElementById("settingReducedMotion").checked = settings.reducedMotion;
  document.getElementById("settingHighContrast").checked = settings.highContrast;
  document.getElementById("settingLargeHUD").checked     = settings.largeHUD;
  document.getElementById("settingCommands").checked     = settings.commandsEnabled;

  // Apply side effects that normally fire from listeners
  lightingEnabled = settings.lighting;
  applyGraphicsQuality();
  if (settings.highContrast) document.body.classList.add("high-contrast");

  // CRT / pixel / music toggles (stored separately)
  const crtOn   = localStorage.getItem("crtEnabled") === "true";
  const pixelOn = localStorage.getItem("pixelEnabled") === "true";
  const musicOn = localStorage.getItem("musicEnabled");

  document.getElementById("crtToggle").checked   = crtOn;
  document.getElementById("pixelToggle").checked = pixelOn;
  document.body.classList.toggle("crt", crtOn);
  document.body.classList.toggle("pixelated", pixelOn);

  if (musicOn !== null) {
    document.getElementById("musicToggle").checked = musicOn === "true";
  }
}

// Load on startup
loadSettings();


//Debugging amd testing Module

function initDebugTests() {
  debugTests = [
    // --- PLAYER ---
    {
      id: "player_spawn",
      name: "Player spawns at start position",
      status: TEST_STATUS.PENDING,
      timer: 0,
      check() {
        return player.x > 0 && player.y > 0 && playerLives === maxLives;
      }
    },
    {
      id: "player_gravity",
      name: "Gravity pulls player down",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _startY: null,
      setup() { this._startY = player.y; player.dy = 0; player.onGround = false; },
      check() { return player.y > this._startY + 10; }
    },
    {
      id: "player_wall_collision",
      name: "Player collides with walls",
      status: TEST_STATUS.PENDING,
      timer: 0,
      check() { return player.onGround === true; }
    },
    {
      id: "player_jump",
      name: "Player can jump",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _startY: null,
      setup() {
        this._startY = player.y;
        player.onGround = true;
        player.dy = -player.jumpPower;
      },
      check() { return player.y < this._startY - 20; }
    },
    {
      id: "player_dash",
      name: "Dash moves player horizontally",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _startX: null,
      setup() { this._startX = player.x; tryDash(); },
      check() { return Math.abs(player.x - this._startX) > 20; }
    },

    // --- PHYSICS ---
    {
      id: "box_gravity",
      name: "Boxes fall with gravity",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _box: null,
      setup() {
        this._box = createBox(500, 200, BOX_TYPE.NORMAL);
        this._box._testStartY = this._box.y;
        boxes.push(this._box);
      },
      check() { return this._box && this._box.y > this._box._testStartY + 10; },
      cleanup() {
        const i = boxes.indexOf(this._box);
        if (i > -1) boxes.splice(i, 1);
      }
    },
    {
      id: "bouncy_box",
      name: "Bouncy boxes rebound",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _box: null,
      setup() {
        this._box = createBox(600, 400, BOX_TYPE.BOUNCY);
        this._box.dy = 8;
        boxes.push(this._box);
      },
      check() {
        return this._box && this._box.dy < 0 && this._box.y < 420;
      },
      cleanup() {
        const i = boxes.indexOf(this._box);
        if (i > -1) boxes.splice(i, 1);
      }
    },
    {
      id: "seesaw_responds",
      name: "Seesaw tilts under weight",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _seesaw: null,
      setup() {
        this._seesaw = { x: 700, y: 400, width: 160, height: 12, angle: 0, angularVelocity: 0 };
        seesaws.push(this._seesaw);
      },
      check() { return this._seesaw && Math.abs(this._seesaw.angle) > 0.01; },
      cleanup() {
        const i = seesaws.indexOf(this._seesaw);
        if (i > -1) seesaws.splice(i, 1);
      }
    },

    // --- ENEMIES ---
    {
      id: "snail_spawns",
      name: "Snail spawns and has HP",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _snail: null,
      setup() {
        this._snail = {
          x: 900, y: 300, width: 28, height: 20,
          dx: 0, dy: 0, dir: 1, speed: 0.5, gravity: 0.6,
          chaseRange: 400, hp: 2, maxHp: 2, hitFlash: 0,
          frame: 0, frameTimer: 0,
          knockbackTimer: 0, knockbackDx: 0, knockbackDy: 0
        };
        G.snails.push(this._snail);
      },
      check() { return this._snail && this._snail.hp === 2; },
      cleanup() {
        const i = G.snails.indexOf(this._snail);
        if (i > -1) G.snails.splice(i, 1);
      }
    },
    {
      id: "enemy_takes_damage",
      name: "damageEnemy reduces HP",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _snail: null,
      setup() {
        this._snail = {
          x: 1000, y: 300, width: 28, height: 20,
          dx: 0, dy: 0, dir: 1, speed: 0, gravity: 0.6,
          chaseRange: 0, hp: 3, maxHp: 3, hitFlash: 0,
          frame: 0, frameTimer: 0,
          knockbackTimer: 0, knockbackDx: 0, knockbackDy: 0
        };
        G.snails.push(this._snail);
        damageEnemy(this._snail, 1, { x: 0, y: 0 });
      },
      check() { return this._snail && this._snail.hp === 2; },
      cleanup() {
        const i = G.snails.indexOf(this._snail);
        if (i > -1) G.snails.splice(i, 1);
      }
    },
    {
      id: "bat_patrols",
      name: "Bat moves from spawn point",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _bat: null,
      setup() {
        this._bat = createBat(1100, 300, 2);
        this._bat._startX = this._bat.x;
        G.bats.push(this._bat);
      },
      check() { return this._bat && Math.abs(this._bat.x - this._bat._startX) > 2; },
      cleanup() {
        const i = G.bats.indexOf(this._bat);
        if (i > -1) G.bats.splice(i, 1);
      }
    },
    {
      id: "turret_fires",
      name: "Turret fires fireball at player",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _turret: null,
      _prevFireballs: 0,
      setup() {
        this._prevFireballs = G.fireballs.length;
        this._turret = {
          x: player.x + 100, y: player.y,
          width: 40, height: 40,
          cooldown: 0, fireRate: 1,
          hp: 5, maxHp: 5, hitFlash: 0, armed: true
        };
        G.turrets.push(this._turret);
      },
      check() { return G.fireballs.length > this._prevFireballs; },
      cleanup() {
        const i = G.turrets.indexOf(this._turret);
        if (i > -1) G.turrets.splice(i, 1);
      }
    },

    // --- WEAPONS ---
    {
      id: "sword_swing",
      name: "Sword attack timer runs",
      status: TEST_STATUS.PENDING,
      timer: 0,
      setup() {
        player.attackCharging = false;
        player.attackTimer = player.attackDuration;
        player.attackHitObjects.clear();
      },
      check() { return player.attackTimer > 0 && player.attackTimer < player.attackDuration; }
    },
    {
      id: "cannon_fires",
      name: "Potato cannon creates projectile",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _prevCount: 0,
      setup() {
        hasPotato = true;
        potatoState = "raw";
        this._prevCount = cannonProjectiles.length;
        cannonAimAngle = 0;
        cannonCooldown = 0;
        firePotatoCannon();
      },
      check() { return cannonProjectiles.length > this._prevCount; },
      cleanup() { hasPotato = false; potatoState = "none"; }
    },
    {
      id: "explosion_creates",
      name: "createExplosion adds to array",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _prevCount: 0,
      setup() {
        this._prevCount = G.explosions.length;
        createExplosion(500, 500);
      },
      check() { return G.explosions.length > this._prevCount; }
    },

    // --- WAVE SYSTEM ---
    {
      id: "wave_xp",
      name: "grantXP increases xp",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _prevXP: 0,
      setup() { this._prevXP = xp; G.wavesystem.enabled = true; grantXP(10); },
      check() { return xp > this._prevXP; },
      cleanup() { G.wavesystem.enabled = false; }
    },
    {
      id: "enemy_killed_counts",
      name: "onEnemyKilled increments kills",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _prevKills: 0,
      setup() {
        G.wavesystem.enabled = true;
        G.wavesystem.totalEnemiesKilled = 0;
        this._prevKills = G.wavesystem.totalEnemiesKilled;
        onEnemyKilled('snail');
      },
      check() { return G.wavesystem.totalEnemiesKilled > this._prevKills; },
      cleanup() { G.wavesystem.enabled = false; }
    },
    {
      id: "level_up_triggers",
      name: "triggerLevelUp sets levelUpPending",
      status: TEST_STATUS.PENDING,
      timer: 0,
      setup() { triggerLevelUp(); },
      check() { return levelUpPending === true; },
      cleanup() {
        levelUpPending = false;
        levelUpCards = [];
        gamePaused = false;
      }
    },

    // --- BUILD SYSTEM ---
    {
      id: "part_drops",
      name: "tryDropPart adds to droppedParts",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _prevCount: 0,
      setup() {
        this._prevCount = droppedParts.length;
        // Force a drop by calling multiple times
        for (let i = 0; i < 20; i++) tryDropPart(400, 300);
      },
      check() { return droppedParts.length > this._prevCount; },
      cleanup() { droppedParts = []; }
    },
    {
      id: "place_wall",
      name: "placeBuildPart adds wall to world",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _prevWalls: 0,
      setup() {
        partInventory.wall = 5;
        buildSelectedPart = "wall";
        this._prevWalls = walls.length;
        placeBuildPart(800, 400);
      },
      check() { return walls.length > this._prevWalls; },
      cleanup() {
        deleteBuildPart(800, 400);
      }
    },
    {
      id: "delete_restores_inventory",
      name: "deleteBuildPart refunds inventory",
      status: TEST_STATUS.PENDING,
      timer: 0,
      setup() {
        partInventory.wall = 1;
        buildSelectedPart = "wall";
        placeBuildPart(840, 400);
        this._countAfterPlace = partInventory.wall;
        deleteBuildPart(840, 400);
      },
      check() { return partInventory.wall > this._countAfterPlace; }
    },

    // --- CHEESE ---
    {
      id: "cheese_creates",
      name: "createCheese returns valid object",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _cheese: null,
      setup() { this._cheese = createCheese(500, 300, 0); },
      check() {
        return this._cheese &&
               this._cheese.width > 0 &&
               this._cheese.despawnTimer === 1800 &&
               this._cheese.pristine === true;
      }
    },
    {
      id: "cheese_despawns",
      name: "Cheese despawn timer counts down",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _cheese: null,
      setup() {
        this._cheese = createCheese(550, 300, 0);
        this._cheese._startTimer = this._cheese.despawnTimer;
        cheeses.push(this._cheese);
      },
      check() {
        return this._cheese &&
               this._cheese.despawnTimer < this._cheese._startTimer;
      },
      cleanup() {
        const i = cheeses.indexOf(this._cheese);
        if (i > -1) cheeses.splice(i, 1);
      }
    },

    // --- CAMERA ---
    {
      id: "camera_follows_player",
      name: "Camera follows player position",
      status: TEST_STATUS.PENDING,
      timer: 0,
      _startCamX: 0,
      setup() {
        this._startCamX = camera.x;
        player.x += 200;
        updateCamera();
      },
      check() { return camera.x !== this._startCamX; },
      cleanup() { player.x -= 200; }
    },

    // --- COLLISION ---
    {
      id: "isColliding_works",
      name: "isColliding detects overlap",
      status: TEST_STATUS.PENDING,
      timer: 0,
      check() {
        const a = { x: 0, y: 0, width: 10, height: 10 };
        const b = { x: 5, y: 5, width: 10, height: 10 };
        const c = { x: 20, y: 20, width: 10, height: 10 };
        return isColliding(a, b) === true && isColliding(a, c) === false;
      }
    },
    {
      id: "rectsOverlap_works",
      name: "rectsOverlap detects overlap",
      status: TEST_STATUS.PENDING,
      timer: 0,
      check() {
        const a = { x: 0,  y: 0,  width: 10, height: 10 };
        const b = { x: 5,  y: 5,  width: 10, height: 10 };
        const c = { x: 50, y: 50, width: 10, height: 10 };
        return rectsOverlap(a, b) === true && rectsOverlap(a, c) === false;
      }
    },
  ];
}

// How long each test has to pass before it fails (frames)
const TEST_TIMEOUT = 120;

function runDebugTests() {
  if (!debugTestMode) return;

  for (const test of debugTests) {
    if (test.status === TEST_STATUS.PASS || test.status === TEST_STATUS.FAIL) continue;

    if (test.status === TEST_STATUS.PENDING) {
      // Run setup if defined
      if (test.setup) {
        try { test.setup(); }
        catch (e) { test.status = TEST_STATUS.FAIL; test.error = e.message; continue; }
      }
      test.status = TEST_STATUS.RUNNING;
      test.timer = 0;
    }

    if (test.status === TEST_STATUS.RUNNING) {
      test.timer++;
      let passed = false;
      try { passed = test.check(); }
      catch (e) { test.status = TEST_STATUS.FAIL; test.error = e.message; continue; }

      if (passed) {
        test.status = TEST_STATUS.PASS;
        if (test.cleanup) {
          try { test.cleanup(); } catch (e) {}
        }
      } else if (test.timer >= TEST_TIMEOUT) {
        test.status = TEST_STATUS.FAIL;
        test.error = "Timed out";
        if (test.cleanup) {
          try { test.cleanup(); } catch (e) {}
        }
      }
    }
  }
}

function startDebugMode() {
  hideAllMenus();
  document.getElementById("game").style.display = "block";
  stopGameLoop();
  resetGameState();
  debugTestMode = true;
  currentLevel = 99; // won't match any real level
  loadMap_Debug();
  saveInitialState();
  startMusic();
  gameRunning = true;
  gamePaused = false;
  lastFrameTime = performance.now();
  lastTimestamp  = performance.now();
  initDebugTests();
  gameLoopId = requestAnimationFrame(gameLoop);
}

function startBuildTest() {
  hideAllMenus();
  document.getElementById("game").style.display = "block";
  stopGameLoop();
  resetGameState();
  currentLevel = 99;
  loadMap_Debug();
  saveInitialState();
  startMusic();
  gameRunning = true;
  gamePaused = false;
  lastFrameTime = performance.now();
  lastTimestamp = performance.now();

  // Max out vehicle inventory
  partInventory.body   = 20;
  partInventory.wheel  = 20;
  partInventory.engine = 10;
  partInventory.seat   = 10;
  partInventory.wall   = 10;
  partInventory.bouncy = 10;
  partInventory.spike  = 10;


  G.wavesystem.enabled = true;
  G.wavesystem.currentMapWaves = waveConfigurations.level1;
  G.wavesystem.currentWave = 0;
  G.wavesystem.waveActive = false;
  G.wavesystem.waveTimer = 900; // 15 second build window

  // Drop straight into build mode
  openBuildMode();

  gameLoopId = requestAnimationFrame(gameLoop);
}

function drawDebugTests() {
  if (!debugTestMode) return;

  const panelW = 340;
  const panelX = canvas.width - panelW - 8;
  const lineH  = 18;
  const panelH = debugTests.length * lineH + 50;
  const panelY = 8;

  // Panel background
  ctx.fillStyle = "rgba(0,0,0,0.85)";
  ctx.strokeStyle = "#555";
  ctx.lineWidth = 1;
  ctx.fillRect(panelX, panelY, panelW, panelH);
  ctx.strokeRect(panelX, panelY, panelW, panelH);

  // Title
  ctx.fillStyle = "#ffd54f";
  ctx.font = "bold 12px monospace";
  ctx.textAlign = "left";
  ctx.fillText("🧪 GAME TEST", panelX + 10, panelY + 16);

  // Pass/fail summary
  const passed = debugTests.filter(t => t.status === TEST_STATUS.PASS).length;
  const failed = debugTests.filter(t => t.status === TEST_STATUS.FAIL).length;
  const total  = debugTests.length;
  ctx.fillStyle = failed > 0 ? "#f44" : passed === total ? "#0f0" : "#aaa";
  ctx.font = "10px monospace";
  ctx.textAlign = "right";
  ctx.fillText(`${passed}/${total} passed`, panelX + panelW - 8, panelY + 16);
  ctx.textAlign = "left";

  // Individual test rows
  for (let i = 0; i < debugTests.length; i++) {
    const test = debugTests[i];
    const ty   = panelY + 28 + i * lineH;

    // Status light
    let lightColor;
    switch (test.status) {
      case TEST_STATUS.PASS:    lightColor = "#00ff44"; break;
      case TEST_STATUS.FAIL:    lightColor = "#ff3333"; break;
      case TEST_STATUS.RUNNING: lightColor = "#ffaa00"; break;
      default:                  lightColor = "#555555";
    }

    // Pulsing effect for running tests
    if (test.status === TEST_STATUS.RUNNING) {
      const pulse = 0.5 + 0.5 * Math.sin(performance.now() * 0.01);
      ctx.globalAlpha = 0.4 + pulse * 0.6;
    }

    ctx.fillStyle = lightColor;
    ctx.beginPath();
    ctx.arc(panelX + 14, ty + 6, 5, 0, Math.PI * 2);
    ctx.fill();

    // Glow for pass/fail
    if (test.status === TEST_STATUS.PASS || test.status === TEST_STATUS.FAIL) {
      ctx.shadowColor = lightColor;
      ctx.shadowBlur = 6;
      ctx.beginPath();
      ctx.arc(panelX + 14, ty + 6, 5, 0, Math.PI * 2);
      ctx.fill();
      ctx.shadowBlur = 0;
    }

    ctx.globalAlpha = 1;

    // Test name
    ctx.fillStyle = test.status === TEST_STATUS.FAIL ? "#ff8888" :
                    test.status === TEST_STATUS.PASS ? "#aaffaa" : "#ccc";
    ctx.font = "9px monospace";
    ctx.fillText(test.name, panelX + 24, ty + 9);

    // Error message for failures
    if (test.status === TEST_STATUS.FAIL && test.error) {
      ctx.fillStyle = "#ff4444";
      ctx.font = "8px monospace";
      ctx.fillText(`  ↳ ${test.error}`, panelX + 24, ty + 17);
    }

    // Timer bar for running tests
    if (test.status === TEST_STATUS.RUNNING) {
      const pct = test.timer / TEST_TIMEOUT;
      ctx.fillStyle = "#333";
      ctx.fillRect(panelX + 24, ty + 11, panelW - 32, 3);
      ctx.fillStyle = "#ffaa00";
      ctx.fillRect(panelX + 24, ty + 11, (panelW - 32) * (1 - pct), 3);
    }
  }

  // Reset button
  const resetBtnY = panelY + panelH - 22;
  ctx.fillStyle = "#333";
  ctx.strokeStyle = "#777";
  ctx.lineWidth = 1;
  ctx.fillRect(panelX + 8, resetBtnY, 80, 16);
  ctx.strokeRect(panelX + 8, resetBtnY, 80, 16);
  ctx.fillStyle = "#fff";
  ctx.font = "9px monospace";
  ctx.fillText("↺ Re-run", panelX + 14, resetBtnY + 11);
}
// === MUSIC MODULE ===
const bgMusic = new Audio("Assets/Music/Dungeon%20Synth.mp3");
bgMusic.loop = true;
bgMusic.volume = 0.5;

function startMusic() {
  const toggle = document.getElementById("musicToggle");
  if (toggle && !toggle.checked) return;
  bgMusic.play().catch(() => {});
}

document.getElementById("musicToggle").addEventListener("change", function () {
  if (this.checked) {
    bgMusic.play().catch(() => {});
  } else {
    bgMusic.pause();
  }
});

// === SETTINGS LISTENERS ===
document.getElementById("settingLighting").addEventListener("change", function() {
  settings.lighting = this.checked;
  lightingEnabled = this.checked;
  lightingCacheDirty = true;
  saveSettings();
});
document.getElementById("settingGraphicsQuality").addEventListener("input", function() {
  settings.graphicsQuality = parseInt(this.value, 10);
  document.getElementById("graphicsQualityLabel").textContent = Math.round(settings.graphicsQuality) + "%";
  applyGraphicsQuality();
  saveSettings();
});
document.getElementById("settingParticles").addEventListener("change", function() {
  settings.particles = this.checked;
  saveSettings();
});
document.getElementById("settingDecor").addEventListener("change", function() {
  settings.decor = this.checked;
  saveSettings();
});
document.getElementById("settingHealthBars").addEventListener("change", function() {
  settings.enemyHealthBars = this.checked;
  saveSettings();
});
document.getElementById("settingScreenShake").addEventListener("change", function() {
  settings.screenShake = this.checked;
  saveSettings();
});
document.getElementById("settingIndicators").addEventListener("change", function() {
  settings.offScreenIndicators = this.checked;
  saveSettings();
});
document.getElementById("settingSFX").addEventListener("change", function() {
  settings.sfxEnabled = this.checked;
  saveSettings();
});
document.getElementById("settingMusicVolume").addEventListener("input", function() {
  settings.musicVolume = parseFloat(this.value);
  bgMusic.volume = settings.musicVolume;
  document.getElementById("musicVolumeLabel").textContent = Math.round(this.value * 100) + "%";
  saveSettings();
});
document.getElementById("settingSFXVolume").addEventListener("input", function() {
  settings.sfxVolume = parseFloat(this.value);
  // Apply volume to all sword sounds
  for (const sound of swordSounds) {
    sound.volume = settings.sfxVolume;
  }
  // Apply volume to other SFX sounds
  potatoImpactSFX.volume = settings.sfxVolume;
  explosionImpactSFX.volume = settings.sfxVolume;
  for (const scream of potatoScreams) {
    scream.volume = settings.sfxVolume;
  }
  document.getElementById("sfxVolumeLabel").textContent = Math.round(this.value * 100) + "%";
  saveSettings();
});
/*document.getElementById("settingInvincible").addEventListener("change", function() {
  settings.invincible = this.checked;
});
document.getElementById("settingInfiniteLives").addEventListener("change", function() {
  settings.infiniteLives = this.checked;
});
document.getElementById("settingInfiniteDash").addEventListener("change", function() {
  settings.infiniteDash = this.checked;
});  */
document.getElementById("settingHitboxes").addEventListener("change", function() {
  settings.showHitboxes = this.checked;
  saveSettings();
});
/*document.getElementById("settingSpeed").addEventListener("input", function() {
  settings.speedMultiplier = parseFloat(this.value);
});  */
document.getElementById("settingSwapJumpDash").addEventListener("change", function() {
  settings.swapJumpDash = this.checked;
  saveSettings();
});
document.getElementById("settingVibration").addEventListener("change", function() {
  settings.vibration = this.checked;
  saveSettings();
});
document.getElementById("settingDeadzone").addEventListener("input", function() {
  settings.joystickDeadzone = parseFloat(this.value);
  document.getElementById("deadzoneLabel").textContent = parseFloat(this.value).toFixed(2);
  saveSettings();
});
document.getElementById("settingFPS").addEventListener("change", function() {
  settings.showFPS = this.checked;
  saveSettings();
});
document.getElementById("settingCoords").addEventListener("change", function() {
  settings.showCoords = this.checked;
  saveSettings();
});
document.getElementById("settingMinimap").addEventListener("change", function() {
  settings.showMinimap = this.checked;
  saveSettings();
});
document.getElementById("settingTooltips").addEventListener("change", function() {
  settings.tutorialTooltips = this.checked;
  saveSettings();
});
document.getElementById("settingReducedMotion").addEventListener("change", function() {
  settings.reducedMotion = this.checked;
  saveSettings();
});
document.getElementById("settingHighContrast").addEventListener("change", function() {
  settings.highContrast = this.checked;
  document.body.classList.toggle("high-contrast", this.checked);
  saveSettings();
});
document.getElementById("settingLargeHUD").addEventListener("change", function() {
  settings.largeHUD = this.checked;
  saveSettings();
});
document.getElementById("settingCommands").addEventListener("change", function() {
  settings.commandsEnabled = this.checked;
  saveSettings();
});

document.addEventListener("keydown", e => {
  const normalizedKey = normalizeInputKey(e.key);

  if (keybindCaptureAction) {
    e.preventDefault();
    e.stopPropagation();
    if (normalizedKey === "backspace" || normalizedKey === "delete") {
      bindActionToKey(keybindCaptureAction, "");
    } else {
      bindActionToKey(keybindCaptureAction, normalizedKey);
    }
    clearKeybindCapture();
    return;
  }

  const keybindMenu = document.getElementById("keybindsMenu");
  if (keybindMenu && !keybindMenu.classList.contains("hidden")) {
    return;
  }

  // --- CHAT INPUT INTERCEPT ---
  if (chat.open) {
    e.preventDefault();
    if (e.key === "Escape") {
      chat.open = false;
      chat.input = "";
    } else if (e.key === "Enter") {
      const raw = chat.input.trim();
      chat.input = "";
      chat.open = false;
      if (raw !== "") {
        if (raw.startsWith("/") && settings.commandsEnabled) {
          runCommand(raw);
        } else {
          chatLog("[You] " + raw, "#e8e0f8");
        }
      }
    } else if (e.key === "Backspace") {
      chat.input = chat.input.slice(0, -1);
    } else if (e.key.length === 1) {
      if (chat.input.length < 80) chat.input += e.key;
    }
    return; // don't pass keypresses to the game while typing
  }

  // Open chat with Enter or / (only while game is running and not paused)
  if ((e.key === "Enter" || (e.key === "/" && settings.commandsEnabled)) && gameRunning && !gamePaused && !levelUpPending) {
    chat.open = true;
    chat.input = e.key === "/" ? "/" : "";
    for (const k in keys) keys[k] = false;
    e.preventDefault();
    return;
  }

  const action = getActionForKey(normalizedKey);
  if (action === "inventory") {
    e.preventDefault();
    toggleInventory();
    return;
  }
  if (action === "interact") {
    e.preventDefault();
    attemptShopInteract();
    return;
  }
  if (action === "skipCountdown" && skipIntermissionToThreeSeconds()) {
    e.preventDefault();
    return;
  }

  setKeyState(normalizedKey, true);
  const btnId = action ? ACTION_BUTTON_IDS[action] : null;
  if (btnId) {
    const btn = document.getElementById(btnId);
    btn.classList.add("pressed");
  }
});

document.addEventListener("keyup", e => {
  if (keybindCaptureAction) return;
  const keybindMenu = document.getElementById("keybindsMenu");
  if (keybindMenu && !keybindMenu.classList.contains("hidden")) return;

  if (chat.open) return;

  const normalizedKey = normalizeInputKey(e.key);
  setKeyState(normalizedKey, false);
  const action = getActionForKey(normalizedKey);
  const btnId = action ? ACTION_BUTTON_IDS[action] : null;
  if (btnId) {
    const btn = document.getElementById(btnId);
    btn.classList.remove("pressed");
  }
});

// Get the toggle checkbox and touch controls container
const hideButtonsToggle = document.getElementById("hideButtonsToggle");
const touchControls = document.getElementById("touchControls");

// Listen for changes on the toggle
hideButtonsToggle.addEventListener("change", function() {
  if (this.checked) {
    // Hide buttons
    touchControls.style.display = "none";
  } else {
    // Show buttons
    touchControls.style.display = "flex"; // or "block" depending on your CSS
  }
});

// Optional: preserve setting across sessions using localStorage
if (localStorage.getItem("hideButtons") === "true") {
  hideButtonsToggle.checked = true;
  touchControls.style.display = "none";
}

hideButtonsToggle.addEventListener("change", function() {
  localStorage.setItem("hideButtons", this.checked);
});

let pixelScale = 1;

function applyPixelScale() {
  const wrapper = document.getElementById("game-wrapper");
  wrapper.style.transform = `scale(${pixelScale})`;
}

pixelToggle.addEventListener("change", () => {
  document.body.classList.toggle("pixelated", pixelToggle.checked);
  ctx.imageSmoothingEnabled = !pixelToggle.checked;
    pixelScale = enabled ? 3 : 1; // 👈 MAKE PIXELS BIGGER HERE
  applyPixelScale();
});

// === DEV MODE ===
let devMapView = false;
let mouse = {
  x: 0,
  y: 0,
  worldX: 0,
  worldY: 0
};

let devShowGrid = false;

let devScale = 1; // updated every draw

function rectsOverlap(a, b) {
  return (
    a.x < b.x + b.width &&
    a.x + a.width > b.x &&
    a.y < b.y + b.height &&
    a.y + a.height > b.y
  );
}

function bindTouch(buttonId, action) {
  const btn = document.getElementById(buttonId);
  const TAP_WINDOW = 300; // ms between taps to count as double-tap
  let lastTap = 0;

  btn.addEventListener("touchstart", e => {
    e.preventDefault();
    setKeyState(getBindingForAction(action), true);

    // Double-tap dash for left/right buttons
    if (action === "left" || action === "right") {
      const now = performance.now();
      if (now - lastTap < TAP_WINDOW) {
        player.facing = action === "right" ? 1 : -1;
        tryDash();
      }
      lastTap = now;
    }
  });
  btn.addEventListener("touchend", e => { e.preventDefault(); setKeyState(getBindingForAction(action), false); });
  btn.addEventListener("mousedown", () => {
    setKeyState(getBindingForAction(action), true);
    if (action === "left" || action === "right") {
      const now = performance.now();
      if (now - (btn._lastMouse || 0) < 300) {
        player.facing = action === "right" ? 1 : -1;
        tryDash();
      }
      btn._lastMouse = now;
    }
  });
  btn.addEventListener("mouseup", () => setKeyState(getBindingForAction(action), false));
  btn.addEventListener("mouseleave", () => setKeyState(getBindingForAction(action), false));
}

function pressAttack() {
  localInput.attack = true;
}

function releaseAttack() {
  localInput.attack = false;
}

attackBtn.addEventListener("touchstart", e => {
  e.preventDefault();
  pressAttack();
});

attackBtn.addEventListener("touchend", e => {
  e.preventDefault();
  releaseAttack();
});

if (inventoryBtn) {
  inventoryBtn.addEventListener("touchstart", e => {
    e.preventDefault();
    toggleInventory();
  });
  inventoryBtn.addEventListener("mousedown", () => {
    toggleInventory();
  });
  inventoryBtn.addEventListener("click", () => {
    toggleInventory();
  });
  inventoryBtn.addEventListener("pointerdown", (e) => {
    if (e.pointerType !== 'touch') toggleInventory();
  });
}

if (shopBtn) {
  shopBtn.addEventListener("touchstart", e => {
    e.preventDefault();
    attemptShopInteract();
  });
  shopBtn.addEventListener("mousedown", () => {
    attemptShopInteract();
  });
}

canvas.addEventListener("touchstart", (e) => {
  const rect   = canvas.getBoundingClientRect();
  const scaleX = canvas.width  / rect.width;
  const scaleY = canvas.height / rect.height;
  const touch  = e.changedTouches[0];
  const mx = (touch.clientX - rect.left) * scaleX;
  const my = (touch.clientY - rect.top)  * scaleY;

  // ── BUILD MODE ─────────────────────────────────────────
  if (buildMode) {
    e.preventDefault();

    // Skip / start wave button
    const skipBtnW = 140;
    const skipBtnX = canvas.width - skipBtnW - 12;
    const skipBtnY = canvas.height - 116;
    if (mx >= skipBtnX && mx <= skipBtnX + skipBtnW &&
        my >= skipBtnY && my <= skipBtnY + 50) {
      finishBuildModeForShopping();
      return;
    }

    // HUD part buttons
    const partKeys  = Object.keys(PART_TYPES);
    const btnW      = 90;
    const totalW    = btnW * partKeys.length + 8 * (partKeys.length - 1);
    const startBtnX = (canvas.width - totalW) / 2;
    const by        = canvas.height - 58;

    if (my >= by && my <= canvas.height) {
      for (let i = 0; i < partKeys.length; i++) {
        const bx = startBtnX + i * (btnW + 8);
        if (mx >= bx && mx <= bx + btnW) {
          buildSelectedPart = partKeys[i];
          return;
        }
      }
    }

    // World placement — convert touch canvas coords to world space
    const wx = Math.floor((mx + camera.x) / BUILD_CELL) * BUILD_CELL;
    const wy = Math.floor((my + camera.y) / BUILD_CELL) * BUILD_CELL;
    const existing = placedStructures.find(s => s.wx === wx && s.wy === wy);
    if (existing) {
      deleteBuildPart(wx, wy);
    } else {
      placeBuildPart(wx, wy);
    }
    return;
  }

  // ── LEVEL UP CARDS ─────────────────────────────────────
  if (levelUpPending) {
    e.preventDefault();
    const cardW  = 170;
    const cardH  = 200;
    const gap    = 24;
    const totalW = levelUpCards.length * cardW + (levelUpCards.length - 1) * gap;
    const startX = (canvas.width - totalW) / 2;
    const cardY  = (canvas.height - cardH) / 2 - 10;

    for (let i = 0; i < levelUpCards.length; i++) {
      const cx = startX + i * (cardW + gap);
      if (mx >= cx && mx <= cx + cardW && my >= cardY && my <= cardY + cardH) {
        levelUpSelectedIndex = i;
        chooseLevelUpCard(i);
        return;
      }
    }
  }
}, { passive: false });

attackBtn.addEventListener("touchcancel", releaseAttack);

// Mouse support (CodePen desktop testing)
attackBtn.addEventListener("mousedown", pressAttack);
attackBtn.addEventListener("mouseup", releaseAttack);
attackBtn.addEventListener("mouseleave", releaseAttack);

document.getElementById("btnRestart").addEventListener("touchstart", e => {
  e.preventDefault();
  pulseAction("restart");
  hideCanvas();
  hideAllMenus();
  triggerGameOver();
});

document.getElementById("btnRestart").addEventListener("mousedown", () => {
  pulseAction("restart");
});


bindTouch("btnLeft", "left");
bindTouch("btnRight", "right");
bindTouch("btnJump", "jump");
bindTouch("btnAttack", "attack");
bindTouch("btnDown", "down");

document.getElementById("btnPause").addEventListener("click", () => {
  togglePause();
});

canvas.addEventListener("mousemove", (e) => {
  if (!levelUpPending) return;
  const cardW = 170, cardH = 200, gap = 24;
  const totalW = levelUpCards.length * cardW + (levelUpCards.length - 1) * gap;
  const startX = (canvas.width - totalW) / 2;
  const cardY = (canvas.height - cardH) / 2 - 10;
const rect   = canvas.getBoundingClientRect();
const scaleX = canvas.width  / rect.width;
const scaleY = canvas.height / rect.height;
const mx = (e.clientX - rect.left) * scaleX;
const my = (e.clientY - rect.top)  * scaleY;
  for (let i = 0; i < levelUpCards.length; i++) {
    const cx = startX + i * (cardW + gap);
    if (mx >= cx && mx <= cx + cardW && my >= cardY && my <= cardY + cardH) {
      levelUpSelectedIndex = i;
      return;
    }
  }
});

canvas.addEventListener("mousedown", (e) => {
  if (buildMode) {
const rect   = canvas.getBoundingClientRect();
const scaleX = canvas.width  / rect.width;
const scaleY = canvas.height / rect.height;
const mx = (e.clientX - rect.left) * scaleX;
const my = (e.clientY - rect.top)  * scaleY;

    // ✅ Skip button — check FIRST since it overlaps the HUD y-range
    const skipBtnW = 140;
    const skipBtnX = canvas.width - skipBtnW - 12;
    const skipBtnY = canvas.height - 116;
    if (mx >= skipBtnX && mx <= skipBtnX + skipBtnW &&
      my >= skipBtnY && my <= skipBtnY + 50) {
      finishBuildModeForShopping();
      return;
    }

    // HUD part buttons
    const partKeys = Object.keys(PART_TYPES);
    const btnW = 90;
    const totalW = btnW * partKeys.length + 8 * (partKeys.length - 1);
    const startBtnX = (canvas.width - totalW) / 2;
    const by = canvas.height - 58;

    if (my >= by && my <= canvas.height) {
      for (let i = 0; i < partKeys.length; i++) {
        const bx = startBtnX + i * (btnW + 8);
        if (mx >= bx && mx <= bx + btnW) {
          buildSelectedPart = partKeys[i];
          return;
        }
      }
    }

    // World placement
    const wx = Math.floor((mx + camera.x) / BUILD_CELL) * BUILD_CELL;
    const wy = Math.floor((my + camera.y) / BUILD_CELL) * BUILD_CELL;
    if (e.button === 0) placeBuildPart(wx, wy);
    if (e.button === 2) deleteBuildPart(wx, wy);
    return;
  }
    if (levelUpPending) {
  const cardW = 170;
  const cardH = 200;
  const gap = 24;
  const totalW = levelUpCards.length * cardW + (levelUpCards.length - 1) * gap;
  const startX = (canvas.width - totalW) / 2;
  const cardY = (canvas.height - cardH) / 2 - 10;
const rect   = canvas.getBoundingClientRect();
const scaleX = canvas.width  / rect.width;
const scaleY = canvas.height / rect.height;
const mx = (e.clientX - rect.left) * scaleX;
const my = (e.clientY - rect.top)  * scaleY;

  for (let i = 0; i < levelUpCards.length; i++) {
    const cx = startX + i * (cardW + gap);
    if (mx >= cx && mx <= cx + cardW && my >= cardY && my <= cardY + cardH) {
      chooseLevelUpCard(i);
      return;
    }
  }
  return; // don't fire cannon while card is up
}
// Inside mousedown, before cannon fire:
if (debugTestMode) {
  const panelW  = 340;
  const panelX  = canvas.width - panelW - 8;
  const panelH  = debugTests.length * 18 + 50;
  const resetBtnY = 8 + panelH - 22;
const rect   = canvas.getBoundingClientRect();
const scaleX = canvas.width  / rect.width;
const scaleY = canvas.height / rect.height;
const mx = (e.clientX - rect.left) * scaleX;
const my = (e.clientY - rect.top)  * scaleY;
  if (mx >= panelX + 8 && mx <= panelX + 88 &&
      my >= resetBtnY  && my <= resetBtnY + 16) {
    initDebugTests();
    return;
  }
}

// Check for cookie click always available (before hasPotato check)
if (gameRunning && !gamePaused && !gameOver) {
  const rect   = canvas.getBoundingClientRect();
  const scaleX = canvas.width  / rect.width;
  const scaleY = canvas.height / rect.height;
  const mx = (e.clientX - rect.left) * scaleX;
  const my = (e.clientY - rect.top)  * scaleY;
  
  // Convert screen coords to world coords
  const worldX = mx + camera.x;
  const worldY = my + camera.y;
  
  if (clickCookie(worldX, worldY)) {
    return; // Clicked on cookie, don't fire cannon
  }
}

if (!hasPotato || !gameRunning || gamePaused || gameOver) return;
if (e.button === 0) firePotatoCannon();
});

// --- Inject mobile joystick into touchControls div ---
(function injectJoystick() {
  const joystickHTML = `
    <div id="potatoJoystickArea" style="
      display:none; 
      position:relative; 
      width:80px; 
      height:80px; 
      border-radius:50%; 
      background:rgba(255,255,255,0.15); 
      border:2px solid #ffd966; 
      touch-action:none; 
      flex-shrink:0;
    ">
      <div id="potatoJoystickKnob" style="
        position:absolute; 
        width:32px; 
        height:32px; 
        border-radius:50%; 
        background:#b58b4a; 
        border:2px solid #ffd966; 
        top:50%; 
        left:50%; 
        transform:translate(-50%,-50%); 
        pointer-events:none;
      "></div>
      <div style="position:absolute; bottom:-22px; left:50%; transform:translateX(-50%); font-size:10px; color:#ffd966; font-weight:bold; white-space:nowrap; pointer-events:none;">🥔 AIM</div>
    </div>`;

  const rightControls = document.querySelector(".right-controls");
  if (rightControls) {
    // Append it to the right-controls container
    rightControls.insertAdjacentHTML("beforeend", joystickHTML);
  }
  const zone = document.getElementById("potatoJoystickArea");
  const knob = document.getElementById("potatoJoystickKnob");
  if (!zone || !knob) return;

  let activeTouchId = null; // ← track which finger owns the joystick

  zone.addEventListener("touchstart", (e) => {
    e.preventDefault();
    if (activeTouchId !== null) return; // already tracking a finger
    const t = e.changedTouches[0];
    activeTouchId = t.identifier;
    joystick.active   = true;
    joystick.startX   = t.clientX;
    joystick.startY   = t.clientY;
    joystick.currentX = t.clientX;
    joystick.currentY = t.clientY;
  }, { passive: false });

  zone.addEventListener("touchmove", (e) => {
    e.preventDefault();
    // Only respond to the finger that started on this joystick
    let t = null;
    for (let i = 0; i < e.changedTouches.length; i++) {
      if (e.changedTouches[i].identifier === activeTouchId) {
        t = e.changedTouches[i];
        break;
      }
    }
    if (!t) return;

    joystick.currentX = t.clientX;
    joystick.currentY = t.clientY;

    const rect   = zone.getBoundingClientRect();
    const center = { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
    const dx     = t.clientX - center.x;
    const dy     = t.clientY - center.y;
    const maxR   = 30;
    const dist   = Math.min(Math.hypot(dx, dy), maxR);
    const angle  = Math.atan2(dy, dx);

    joystick.angle     = angle;
    joystick.magnitude = dist / maxR;

    knob.style.left      = `calc(50% + ${Math.cos(angle) * dist}px)`;
    knob.style.top       = `calc(50% + ${Math.sin(angle) * dist}px)`;
    knob.style.transform = "none";
  }, { passive: false });

  function onJoystickRelease(e) {
    // Check if the released finger is the one we're tracking
    let found = false;
    for (let i = 0; i < e.changedTouches.length; i++) {
      if (e.changedTouches[i].identifier === activeTouchId) {
        found = true;
        break;
      }
    }
    if (!found) return; // a different finger lifted, ignore

    if (joystick.active && joystick.magnitude > 0.15) {
      cannonAimAngle = joystick.angle;
      firePotatoCannon();
    }
    activeTouchId      = null;
    joystick.active    = false;
    joystick.magnitude = 0;
    knob.style.left      = "50%";
    knob.style.top       = "50%";
    knob.style.transform = "translate(-50%, -50%)";
  }

  zone.addEventListener("touchend",    onJoystickRelease);
  zone.addEventListener("touchcancel", onJoystickRelease);
})();

// Show/hide joystick based on potato state (call this wherever state changes)
function syncJoystickVisibility() {
  const zone = document.getElementById("potatoJoystickArea");
  if (!zone) return;
  zone.style.display = hasPotato ? "flex" : "none";
}

function syncShopButtonVisibility() {
  if (!shopBtn) return;
  if (!gameRunning || gamePaused || buildMode) {
    shopBtn.style.display = "none";
    return;
  }
  if (shopOpen) {
    shopBtn.style.display = "none";
    return;
  }
  const nearestDist = getNearestShopkeeperDistance();
  shopBtn.style.display = nearestDist > 0 && nearestDist <= 160 ? "block" : "none";
}

function updateGamepad() {
  if (gamepadIndex === null) return;
  const gp = navigator.getGamepads()[gamepadIndex];
  if (!gp) return;
  if (buildMode) return;
  const STICK_DEAD = settings.joystickDeadzone; // deadzone

  // Left stick / D-pad — movement
  // Left stick / D-pad
  const axisX = gp.axes[0];
  localInput._gpLeft  = axisX < -STICK_DEAD || gp.buttons[14]?.pressed;
  localInput._gpRight = axisX >  STICK_DEAD || gp.buttons[15]?.pressed;
  
  const axisY = gp.axes[1];
  localInput._gpDown  = axisY > STICK_DEAD || gp.buttons[13]?.pressed;
  
  const jumpBtn = settings.swapJumpDash ? 5 : 0;
  const dashBtn = settings.swapJumpDash ? 0 : 5;
  localInput._gpJump = gp.buttons[jumpBtn]?.pressed;
  localInput._gpDash = gp.buttons[dashBtn]?.pressed;

  
  if (gameOver && gp.buttons[1]?.pressed && !gp._menuBackHeld) {
  pulseAction("restart");
  gp._menuBackHeld = true;
}
  // X = club hold/release, Y = directional sword
  localInput._gpAttack = gp.buttons[2]?.pressed;
  localInput._gpSword = gp.buttons[3]?.pressed;

  // Potato cannon — right stick aim + right trigger (index 7) to fire
if (hasPotato) {
  const rx = gp.axes[2];
  const ry = gp.axes[3];
  if (Math.hypot(rx, ry) > STICK_DEAD) {
    cannonAimAngle = Math.atan2(ry, rx);
    player.facing = rx > 0 ? 1 : -1;

    // move virtual cursor around player in screen space
    const cx = player.x + player.width / 2 - camera.x;
    const cy = player.y + player.height / 2 - camera.y;
    virtualCursor.x = cx + Math.cos(cannonAimAngle) * virtualCursor.radius;
    virtualCursor.y = cy + Math.sin(cannonAimAngle) * virtualCursor.radius;

    // keep mouse in sync so drawCannonCrosshair works
    mouse.x = virtualCursor.x;
    mouse.y = virtualCursor.y;
  }
  if (gp.buttons[7]?.pressed && cannonCooldown <= 0) {
    firePotatoCannon();
  }
}

  // Pause — Start button (index 9)
  if (gp.buttons[9]?.pressed && !gp._pauseHeld) {
    togglePause();
    gp._pauseHeld = true;
  }
  if (!gp.buttons[9]?.pressed) gp._pauseHeld = false;

  // Restart on game over — Select (index 8)
  if (gameOver && gp.buttons[8]?.pressed) {
    pulseAction("restart");
  }
}

// === GAMEPAD MENU NAVIGATION ===
let menuNavCooldown = 0;
let focusedButtonIndex = 0;

function updateGamepadMenu() {
  if (gamepadIndex === null) return;
  const gp = navigator.getGamepads()[gamepadIndex];
  if (!gp) return;

  if (menuNavCooldown > 0) { menuNavCooldown--; return; }

  // Level up card navigation
if (levelUpPending) {
  const axisX = gp.axes[0];
  
  const moveRight = axisX > 0.3 || gp.buttons[15]?.pressed;
  const moveLeft  = axisX < -0.3 || gp.buttons[14]?.pressed;

  if (moveRight && !gp._cardRightHeld) {
    levelUpSelectedIndex = (levelUpSelectedIndex + 1) % levelUpCards.length;
    gp._cardRightHeld = true;
    menuNavCooldown = 18;
  }
  if (!moveRight) gp._cardRightHeld = false;

  if (moveLeft && !gp._cardLeftHeld) {
    levelUpSelectedIndex = (levelUpSelectedIndex - 1 + levelUpCards.length) % levelUpCards.length;
    gp._cardLeftHeld = true;
    menuNavCooldown = 18;
  }
  if (!moveLeft) gp._cardLeftHeld = false;

  if (gp.buttons[0]?.pressed && !gp._menuConfirmHeld) {
    chooseLevelUpCard(levelUpSelectedIndex);
    gp._menuConfirmHeld = true;
  }
  if (!gp.buttons[0]?.pressed) gp._menuConfirmHeld = false;

  return;
}
  
  // Settings navigation
if (!document.getElementById("settings").classList.contains("hidden")) {
  const inputs = Array.from(document.querySelectorAll(
    "#settings input[type='checkbox'], #settings input[type='range']"
  ));

  focusedButtonIndex = Math.max(0, Math.min(focusedButtonIndex, inputs.length - 1));
  const current = inputs[focusedButtonIndex];

  // ✅ ADD THIS — scroll the focused element into view
if (current) {
  current.closest("label")?.scrollIntoView({ block: "nearest", behavior: "smooth" });
}

  const axisY = gp.axes[1];
  if (axisY > 0.3 && !gp._settingsDownHeld) {
    focusedButtonIndex = (focusedButtonIndex + 1) % inputs.length;
    menuNavCooldown = 18;
    gp._settingsDownHeld = true;
  }
  if (axisY < -0.3 && !gp._settingsUpHeld) {
    focusedButtonIndex = (focusedButtonIndex - 1 + inputs.length) % inputs.length;
    menuNavCooldown = 18;
    gp._settingsUpHeld = true;
  }
  if (Math.abs(axisY) < 0.3) { gp._settingsDownHeld = false; gp._settingsUpHeld = false; }

  // highlight
  inputs.forEach((t, i) => {
    const label = t.closest("label") || t.parentElement;
    label.style.outline   = i === focusedButtonIndex ? '2px solid #ffd54f' : '';
    label.style.boxShadow = i === focusedButtonIndex ? '0 0 10px #ffd54f' : '';
  });

  // A = toggle checkbox
  if (current?.type === "checkbox" && gp.buttons[0]?.pressed && !gp._menuConfirmHeld) {
    current.checked = !current.checked;
    current.dispatchEvent(new Event("change"));
    gp._menuConfirmHeld = true;
  }
  if (!gp.buttons[0]?.pressed) gp._menuConfirmHeld = false;

  // left/right stick = adjust slider
 if (current?.type === "range") {
  const axisX = gp.axes[0];
  const DEAD = settings.joystickDeadzone;

  // Right
  if (axisX > DEAD && !gp._sliderRightHeld) {
    const step = parseFloat(current.step) || 0.1;
    current.value = Math.min(
      parseFloat(current.max),
      parseFloat(current.value) + step
    );
    current.dispatchEvent(new Event("input"));
    gp._sliderRightHeld = true;
  }
  if (axisX <= DEAD) gp._sliderRightHeld = false;

  // Left — separate held state so it never gets blocked by nav cooldown
  if (axisX < -DEAD && !gp._sliderLeftHeld) {
    const step = parseFloat(current.step) || 0.1;
    current.value = Math.max(
      parseFloat(current.min),
      parseFloat(current.value) - step
    );
    current.dispatchEvent(new Event("input"));
    gp._sliderLeftHeld = true;
  }
  if (axisX >= -DEAD) gp._sliderLeftHeld = false;
}

  if (gp.buttons[1]?.pressed && !gp._menuBackHeld) {
    document.querySelector("#settings .back-btn")?.click();
    gp._menuBackHeld = true;
  }
  if (!gp.buttons[1]?.pressed) gp._menuBackHeld = false;

  return;
}
  // get all visible, focusable buttons in current visible menu
const buttons = Array.from(document.querySelectorAll(
  '#menu:not(.hidden) button, #levelSelect:not(.hidden) button, ' +
  '#waveSelect:not(.hidden) button, #freeSelect:not(.hidden) button, ' +
  '#settings:not(.hidden) button, #keybindsMenu:not(.hidden) button, #credits:not(.hidden) button, ' +
  '#controls:not(.hidden) button, #pauseMenu:not(.hidden) button'
));
  if (!buttons.length) return;

  focusedButtonIndex = Math.max(0, Math.min(focusedButtonIndex, buttons.length - 1));

  const axisY = gp.axes[1];
  const DEAD  = 0.3;

  // navigate down
  if (axisY > DEAD || gp.buttons[13]?.pressed) {
    focusedButtonIndex = (focusedButtonIndex + 1) % buttons.length;
    menuNavCooldown = 18;
  }
  // navigate up
  if (axisY < -DEAD || gp.buttons[12]?.pressed) {
    focusedButtonIndex = (focusedButtonIndex - 1 + buttons.length) % buttons.length;
    menuNavCooldown = 18;
  }

  // focus the button visually
  buttons.forEach((b, i) => {
    b.style.outline = i === focusedButtonIndex ? '3px solid #ffd54f' : '';
    b.style.boxShadow = i === focusedButtonIndex ? '0 0 12px #ffd54f' : '';
  });

  // A to confirm
  if (gp.buttons[0]?.pressed && !gp._menuConfirmHeld) {
    buttons[focusedButtonIndex]?.click();
    gp._menuConfirmHeld = true;
    focusedButtonIndex = 0;
  }
  if (!gp.buttons[0]?.pressed) gp._menuConfirmHeld = false;

  // B to go back
  if (gp.buttons[1]?.pressed && !gp._menuBackHeld) {
    const backBtn = document.querySelector(
      '.menu:not(.hidden) .back-btn, #levelSelect:not(.hidden) .back-btn, ' +
      '#waveSelect:not(.hidden) .back-btn, #freeSelect:not(.hidden) .back-btn, ' +
      '#settings:not(.hidden) .back-btn, #pauseMenu:not(.hidden) .back-btn'
    );
    backBtn?.click();
    gp._menuBackHeld = true;
  }
  if (!gp.buttons[1]?.pressed) gp._menuBackHeld = false;
}
const crtToggle = document.getElementById("crtToggle");

crtToggle.addEventListener("change", () => {
  document.body.classList.toggle("crt", crtToggle.checked);
});

function triggerVHSGlitch() {
  if (!document.body.classList.contains("crt")) return;

  document.body.classList.add("vhs");

  setTimeout(() => {
    document.body.classList.remove("vhs");
  }, 120 + Math.random() * 120);
}

// random VHS glitch every 6–14 seconds
setInterval(() => {
  if (Math.random() < 0.5) triggerVHSGlitch();
}, 6000 + Math.random() * 8000);

// Keep track of state outside the function


/*function updateLights() {
  const now = performance.now();
  const cycleTime = now % 10000;
  const isOn = cycleTime < 5000;

  if (isOn) {
    ambientLight = 0.68;
    
    // Only initialize once when the cycle first starts
    if (wasOff) {
      initializeLevelLights();
      wasOff = false;
      lightingCacheDirty = true;
    }

    for (let light of lights) {
      if (light.flickerSpeed > 0) {
        const flicker = Math.sin(now * light.flickerSpeed * 0.01) * light.flickerAmount;
        light.radius = light.baseRadius;
        
        const newIntensity = light.baseIntensity + (flicker * light.baseIntensity);
        light.intensity = Math.max(0.3, newIntensity);
      }
    }
  } else {
    // "Off" state
    wasOff = true; 
    ambientLight = 1;
    
    for (let light of lights) {
      light.intensity = 0;
      light.radius = 0;
    }
  }
}
*/

function updateLights() {
  const now = performance.now();
  const cycleDuration = 60000; // 10 seconds total
  const cycleTime = now % cycleDuration;
  
  // Define transition windows (e.g., 2 seconds for sunrise, 2 seconds for sunset)
  const sunriseDuration = 3000; 
  const sunsetDuration = 5000;
  const dayDuration = 35000; // Total time lights are "active" (including transitions)

  let transitionFactor = 0; // 0 = Midnight (Off), 1 = Noon (Full Intensity)

  if (cycleTime < dayDuration) {
    // We are in the "Daylight" half of the cycle
    if (cycleTime < sunriseDuration) {
      // Sunrise: Ramp up from 0 to 1
      transitionFactor = cycleTime / sunriseDuration;
    } else if (cycleTime > dayDuration - sunsetDuration) {
      // Sunset: Ramp down from 1 to 0
      transitionFactor = (dayDuration - cycleTime) / sunsetDuration;
    } else {
      // Full Day
      transitionFactor = 1;
    }
  }

  const isOn = transitionFactor > 0;

  if (isOn) {
    // Smoothly transition ambientLight between 1.0 (dark/off) and 0.67 (active)
    ambientLight = 1.0 - (0.33 * transitionFactor);
    
    if (wasOff) {
      initializeLevelLights();
      wasOff = false;
      lightingCacheDirty = true;
    }

    for (let light of lights) {
      // Scale flickering by the transition factor so lights fade in/out smoothly
      if (light.flickerSpeed > 0) {
        const flicker = Math.sin(now * light.flickerSpeed * 0.01) * light.flickerAmount;
        
        // Base values scaled by the "sun" position
        light.radius = light.baseRadius * transitionFactor;
        const targetIntensity = light.baseIntensity + (flicker * light.baseIntensity);
        light.intensity = targetIntensity * transitionFactor;
        
        // Ensure they don't drop below your minimum threshold while active
        light.intensity = Math.max(0.1 * transitionFactor, light.intensity);
      }
    }
  } else {
    // "Deep Night" state
    if (!wasOff) {
      wasOff = true; 
      ambientLight = 1.0;
      for (let light of lights) {
        light.intensity = 0;
        light.radius = 0;
      }
      lightingCacheDirty = true;
    }
  }
}



function initializeLevelLights() {
  lights = [];
  
  if (currentLevel === 1) {
    // Level 1: Warm scattered lighting
    lights.push(
      createLight(400, 500, 400, "#ffcc66", 0.5),
      createLight(1200, 500, 450, "#ffaa44", 0.4),
      createLight(1600, 500, 400, "#ffcc66", 0.5),
      createLight(1000, 1950, 450, "#ffaa44", 0.4),
      createLight(2200, 500, 400, "#ffcc66", 0.4),
      createLight(2700, 2000, 400, "#aaddff", 0.6),
      createLight(1000, 1400, 350, "#ff8844", 0.4)
      
    );
  } else if (currentLevel === 2) {
    // Level 2: Tower with lights at key floors
    lights.push(
      createLight(400, 1900, 350, "#ffcc66", 0.7),   // Ground floor
      createLight(750, 1350, 300, "#ffaa44", 0.6),   // Mid section
      createLight(650, 900, 350, "#ffcc66", 0.7),    // Upper section
      createLight(1300, 600, 300, "#ff8844", 0.6),   // Trap corridor
      createLight(1350, 300, 400, "#ffcc88", 0.8)    // Summit
    );
  } else if (currentLevel === 3) {
    // Level 3: Cold blue Christmas lights
    lights.push(
      createLight(500, 1300, 400, "#aaddff", 0.6),
      createLight(1200, 1000, 450, "#88ccff", 0.7),
      createLight(1800, 1300, 400, "#aaddff", 0.6)
    );
  } else if (currentLevel === 4) {
    // Level 4: Chaos - flickering emergency lights
    lights.push(
      createLight(700, 100, 600, "#ff4444", 0.5),
      createLight(2100, 100, 600, "#ff4444", 0.5)
    );
    lights[0].flickerSpeed = 0.1;
    lights[0].flickerAmount = 0.3;
    lights[1].flickerSpeed = 0.15;
    lights[1].flickerAmount = 0.3;
  }

  lightingCacheDirty = true;
}

function createLight(x, y, radius, color, intensity = 1.0) {
  return {
    x: x,
    y: y,
    radius: radius,
    color: color,
    intensity: intensity,
    flickerSpeed: 0,
    flickerAmount: 0,
    baseRadius: radius,
    // particle emitter state for torch/ember effects
    particleTimer: 0,
    // per-update spawn chance multiplier (higher = more embers)
    particleSpawnRate: 0.1,
    // type of particles to emit (currently only 'ember' is used)
    particleType: 'ember'
  };
}

// Line segment intersection test
function lineSegmentsIntersect(x1, y1, x2, y2, x3, y3, x4, y4) {
  const denom = ((y4 - y3) * (x2 - x1)) - ((x4 - x3) * (y2 - y1));
  if (denom === 0) return false;
  
  const ua = (((x4 - x3) * (y1 - y3)) - ((y4 - y3) * (x1 - x3))) / denom;
  const ub = (((x2 - x1) * (y1 - y3)) - ((y2 - y1) * (x1 - x3))) / denom;
  
  return (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1);
}

function drawMinimap() {
  const MW = 160, MH = 90;
  const MX = canvas.width - MW - 10, MY = 95;
  const scaleX = MW / world.width, scaleY = MH / world.height;

  ctx.save();
  ctx.fillStyle = "rgba(0,0,0,0.6)";
  ctx.strokeStyle = "#555";
  ctx.lineWidth = 1;
  ctx.fillRect(MX, MY, MW, MH);
  ctx.strokeRect(MX, MY, MW, MH);

  // Walls
  ctx.fillStyle = "#666";
  for (const w of walls) {
    ctx.fillRect(MX + w.x * scaleX, MY + w.y * scaleY, w.width * scaleX, w.height * scaleY);
  }

  // Enemies
  ctx.fillStyle = "#f44";
  for (const e of [...G.snails, ...G.SuperSnails, ...G.bats, ...G.turrets, ...G.snowmen, ...G.tables, ...G.yetis, ...G.chairs, ...G.babyMicrowaves]) {
    ctx.fillRect(MX + e.x * scaleX - 1, MY + e.y * scaleY - 1, 3, 3);
  }

  // Player
  ctx.fillStyle = "#0f0";
  ctx.fillRect(MX + player.x * scaleX - 2, MY + player.y * scaleY - 2, 4, 4);

  // Camera viewport box
  ctx.strokeStyle = "#fff";
  ctx.lineWidth = 0.5;
  ctx.strokeRect(
    MX + camera.x * scaleX, MY + camera.y * scaleY,
    camera.width * scaleX, camera.height * scaleY
  );

  ctx.restore();
}

// Cast shadows from a light source
function drawShadows(renderCtx, light) {
  // Iterate shadow casters without creating temporary objects
  
  renderCtx.fillStyle = `rgba(0, 0, 0, ${0.7 - ambientLight})`;
  
  // Shadow walls
  for (let wall of walls) {
    const dx = wall.x + wall.width / 2 - light.x;
    const dy = wall.y + wall.height / 2 - light.y;
    const dist = Math.sqrt(dx * dx + dy * dy);
    
    if (dist > light.radius * 1.5) continue;
    
    const corners = [
      { x: wall.x, y: wall.y },
      { x: wall.x + wall.width, y: wall.y },
      { x: wall.x + wall.width, y: wall.y + wall.height },
      { x: wall.x, y: wall.y + wall.height }
    ];
    
    for (let i = 0; i < corners.length; i++) {
      const corner1 = corners[i];
      const corner2 = corners[(i + 1) % corners.length];
      
      const edgeDx = corner2.x - corner1.x;
      const edgeDy = corner2.y - corner1.y;
      const lightDx = light.x - corner1.x;
      const lightDy = light.y - corner1.y;
      
      const cross = edgeDx * lightDy - edgeDy * lightDx;
      
      if (cross > 0) continue;
      
      const projectionDist = 2770;
      
      const dir1x = corner1.x - light.x;
      const dir1y = corner1.y - light.y;
      const len1 = Math.sqrt(dir1x * dir1x + dir1y * dir1y) || 1;
      
      const dir2x = corner2.x - light.x;
      const dir2y = corner2.y - light.y;
      const len2 = Math.sqrt(dir2x * dir2x + dir2y * dir2y) || 1;
      
      const proj1x = corner1.x + (dir1x / len1) * projectionDist;
      const proj1y = corner1.y + (dir1y / len1) * projectionDist;
      
      const proj2x = corner2.x + (dir2x / len2) * projectionDist;
      const proj2y = corner2.y + (dir2y / len2) * projectionDist;
      
      renderCtx.beginPath();
      renderCtx.moveTo(corner1.x, corner1.y);
      renderCtx.lineTo(corner2.x, corner2.y);
      renderCtx.lineTo(proj2x, proj2y);
      renderCtx.lineTo(proj1x, proj1y);
      renderCtx.fill();
    }
  }
  
  // Shadow boxes
  for (let box of boxes) {
    const dx = box.x + box.width / 2 - light.x;
    const dy = box.y + box.height / 2 - light.y;
    const dist = Math.sqrt(dx * dx + dy * dy);
    
    if (dist > light.radius * 1.5) continue;
    
    const corners = [
      { x: box.x, y: box.y },
      { x: box.x + box.width, y: box.y },
      { x: box.x + box.width, y: box.y + box.height },
      { x: box.x, y: box.y + box.height }
    ];
    
    for (let i = 0; i < corners.length; i++) {
      const corner1 = corners[i];
      const corner2 = corners[(i + 1) % corners.length];
      
      const edgeDx = corner2.x - corner1.x;
      const edgeDy = corner2.y - corner1.y;
      const lightDx = light.x - corner1.x;
      const lightDy = light.y - corner1.y;
      
      const cross = edgeDx * lightDy - edgeDy * lightDx;
      
      if (cross > 0) continue;
      
      const projectionDist = 2770;
      
      const dir1x = corner1.x - light.x;
      const dir1y = corner1.y - light.y;
      const len1 = Math.sqrt(dir1x * dir1x + dir1y * dir1y) || 1;
      
      const dir2x = corner2.x - light.x;
      const dir2y = corner2.y - light.y;
      const len2 = Math.sqrt(dir2x * dir2x + dir2y * dir2y) || 1;
      
      const proj1x = corner1.x + (dir1x / len1) * projectionDist;
      const proj1y = corner1.y + (dir1y / len1) * projectionDist;
      
      const proj2x = corner2.x + (dir2x / len2) * projectionDist;
      const proj2y = corner2.y + (dir2y / len2) * projectionDist;
      
      renderCtx.beginPath();
      renderCtx.moveTo(corner1.x, corner1.y);
      renderCtx.lineTo(corner2.x, corner2.y);
      renderCtx.lineTo(proj2x, proj2y);
      renderCtx.lineTo(proj1x, proj1y);
      renderCtx.fill();
    }
  }
}

function drawBackground() {
  if (!bgTile.complete) return; // wait until image is loaded

  const tileW = bgTile.width;   // 100
  const tileH = bgTile.height;  // 100

  const cols = Math.ceil(MAP_WIDTH / tileW);
  const rows = Math.ceil(MAP_HEIGHT / tileH);
  for (let y = 0; y < rows; y++) {
    for (let x = 0; x < cols; x++) {
      ctx.drawImage(bgTile, x * tileW, y * tileH, tileW, tileH);
    }
  }
}

const dungeonAesthetics = {
  key: "",
  floorDetails: [],
  props: []
};

function createAestheticRng(seed) {
  let s = (seed >>> 0) || 1;
  return function rand() {
    s = (s * 1664525 + 1013904223) >>> 0;
    return s / 4294967296;
  };
}

function hashAestheticKey(str) {
  let h = 2166136261 >>> 0;
  for (let i = 0; i < str.length; i++) {
    h ^= str.charCodeAt(i);
    h = Math.imul(h, 16777619);
  }
  return h >>> 0;
}

function rectOverlapsRect(ax, ay, aw, ah, bx, by, bw, bh) {
  return ax < bx + bw && ax + aw > bx && ay < by + bh && ay + ah > by;
}

function overlapsSolidAt(x, y, w, h) {
  for (let i = 0; i < walls.length; i++) {
    const wall = walls[i];
    if (rectOverlapsRect(x, y, w, h, wall.x, wall.y, wall.width, wall.height)) return true;
  }
  for (let i = 0; i < boxes.length; i++) {
    const b = boxes[i];
    if (rectOverlapsRect(x, y, w, h, b.x, b.y, b.width, b.height)) return true;
  }
  return false;
}

function pickPlatformSpot(rng, platforms, w, h) {
  const pad = 6;
  for (let i = 0; i < 40; i++) {
    const wall = platforms[(rng() * platforms.length) | 0];
    if (!wall || wall.width < w + pad * 2) continue;
    const x = wall.x + pad + rng() * (wall.width - w - pad * 2);
    const y = wall.y - h;
    if (y < 10) continue;
    if (overlapsSolidAt(x, y, w, h)) continue;
    return { x, y };
  }
  return null;
}

function pickPlatformSpotNear(rng, platforms, w, h, ax, ay) {
  const pad = 6;
  for (let i = 0; i < 40; i++) {
    const wall = platforms[(rng() * platforms.length) | 0];
    if (!wall || wall.width < w + pad * 2) continue;
    const cx = wall.x + wall.width / 2;
    const cy = wall.y;
    const dx = cx - ax;
    const dy = cy - ay;
    if (dx * dx + dy * dy > 520 * 520) continue;
    const x = wall.x + pad + rng() * (wall.width - w - pad * 2);
    const y = wall.y - h;
    if (y < 10) continue;
    if (overlapsSolidAt(x, y, w, h)) continue;
    return { x, y };
  }
  return null;
}

function initDungeonAesthetics() {
  const key = `${currentMap}|${currentLevel}|${MAP_WIDTH}|${MAP_HEIGHT}|${walls.length}|${boxes.length}`;
  if (dungeonAesthetics.key === key) return;

  dungeonAesthetics.key = key;
  dungeonAesthetics.floorDetails.length = 0;
  dungeonAesthetics.props.length = 0;

  const rng = createAestheticRng(hashAestheticKey(key));
  const platforms = walls.filter(w => !w.moving && w.width >= 24 && w.height >= 6);

  // Floor texture details: cracks, stains and worn tile seams.
  for (let i = 0; i < 260; i++) {
    const x = 30 + rng() * (MAP_WIDTH - 60);
    const y = 30 + rng() * (MAP_HEIGHT - 60);
    if (rng() < 0.58) {
      dungeonAesthetics.floorDetails.push({
        kind: "crack",
        x,
        y,
        len: 16 + rng() * 34,
        angle: rng() * Math.PI * 2,
        alpha: 0.09 + rng() * 0.14
      });
    } else {
      dungeonAesthetics.floorDetails.push({
        kind: "stain",
        x,
        y,
        rx: 8 + rng() * 18,
        ry: 6 + rng() * 14,
        alpha: 0.08 + rng() * 0.12
      });
    }
  }

  const propTypes = ["crate", "urn", "bones", "candle", "rubble"];
  let attempts = 0;
  while (dungeonAesthetics.props.length < 90 && attempts < 900) {
    attempts++;
    const t = propTypes[(rng() * propTypes.length) | 0];
    const scale = 1.15 + rng() * 1.1;
    const w = (t === "crate" ? 26 : t === "urn" ? 20 : t === "rubble" ? 22 : 14) * scale;
    const h = (t === "crate" ? 22 : t === "urn" ? 24 : t === "rubble" ? 14 : 12) * scale;
    const spot = pickPlatformSpot(rng, platforms, w, h);
    if (!spot) continue;

    dungeonAesthetics.props.push({
      type: t,
      x: spot.x,
      y: spot.y,
      w,
      h,
      rotation: (rng() - 0.5) * 0.35,
      alpha: 0.9 + rng() * 0.1
    });
  }

  // Ensure some visible dressing near the level's starting area.
  const anchorX = Math.max(80, Math.min(MAP_WIDTH - 80, (player.x || 120) + player.width / 2));
  const anchorY = Math.max(80, Math.min(MAP_HEIGHT - 80, (player.y || 120) + player.height / 2));
  for (let i = 0; i < 8; i++) {
    const t = propTypes[(rng() * propTypes.length) | 0];
    const scale = 1.2 + rng() * 0.8;
    const w = (t === "crate" ? 26 : t === "urn" ? 20 : t === "rubble" ? 22 : 14) * scale;
    const h = (t === "crate" ? 22 : t === "urn" ? 24 : t === "rubble" ? 14 : 12) * scale;
    let spot = pickPlatformSpotNear(rng, platforms, w, h, anchorX, anchorY);
    if (!spot) spot = pickPlatformSpot(rng, platforms, w, h);
    if (!spot) continue;
    dungeonAesthetics.props.push({
      type: t,
      x: spot.x,
      y: spot.y,
      w,
      h,
      rotation: (rng() - 0.5) * 0.25,
      alpha: 0.92 + rng() * 0.08
    });
  }
}

function drawDungeonFloorTexture() {
  if (!settings.decor) return;
  if (!dungeonAesthetics.floorDetails.length) return;

  ctx.save();

  const tileStep = 80;
  ctx.strokeStyle = "rgba(20, 18, 24, 0.17)";
  ctx.lineWidth = 1;
  for (let x = tileStep; x < MAP_WIDTH; x += tileStep) {
    ctx.beginPath();
    ctx.moveTo(x, 0);
    ctx.lineTo(x, MAP_HEIGHT);
    ctx.stroke();
  }
  for (let y = tileStep; y < MAP_HEIGHT; y += tileStep) {
    ctx.beginPath();
    ctx.moveTo(0, y);
    ctx.lineTo(MAP_WIDTH, y);
    ctx.stroke();
  }

  for (let i = 0; i < dungeonAesthetics.floorDetails.length; i++) {
    const d = dungeonAesthetics.floorDetails[i];
    if (d.kind === "crack") {
      ctx.strokeStyle = `rgba(10, 9, 14, ${d.alpha})`;
      ctx.lineWidth = 1.4;
      ctx.beginPath();
      ctx.moveTo(d.x, d.y);
      ctx.lineTo(d.x + Math.cos(d.angle) * d.len, d.y + Math.sin(d.angle) * d.len);
      ctx.stroke();
    } else {
      ctx.fillStyle = `rgba(16, 14, 20, ${d.alpha})`;
      ctx.beginPath();
      ctx.ellipse(d.x, d.y, d.rx, d.ry, 0, 0, Math.PI * 2);
      ctx.fill();
    }
  }

  ctx.restore();
}

function drawDungeonProps() {
  if (!settings.decor) return;
  if (!dungeonAesthetics.props.length) return;

  for (let i = 0; i < dungeonAesthetics.props.length; i++) {
    const p = dungeonAesthetics.props[i];
    if (!isEffectVisibleInWorld(p.x, p.y, p.w, p.h, 80)) continue;

    ctx.save();
    ctx.translate(p.x + p.w / 2, p.y + p.h / 2);
    ctx.rotate(p.rotation);
    ctx.globalAlpha = p.alpha;
    ctx.shadowBlur = 0;
    ctx.shadowOffsetY = 0;

    if (p.type === "crate") {
      ctx.fillStyle = "#7a5330";
      ctx.fillRect(-p.w / 2, -p.h / 2, p.w, p.h);
      ctx.strokeStyle = "#3d2815";
      ctx.lineWidth = 2;
      ctx.strokeRect(-p.w / 2, -p.h / 2, p.w, p.h);
      ctx.beginPath();
      ctx.moveTo(-p.w / 2, -p.h / 2);
      ctx.lineTo(p.w / 2, p.h / 2);
      ctx.moveTo(p.w / 2, -p.h / 2);
      ctx.lineTo(-p.w / 2, p.h / 2);
      ctx.stroke();
    } else if (p.type === "urn") {
      ctx.fillStyle = "#8c7f70";
      ctx.beginPath();
      ctx.ellipse(0, 2, p.w * 0.45, p.h * 0.5, 0, 0, Math.PI * 2);
      ctx.fill();
      ctx.fillStyle = "#b4a484";
      ctx.fillRect(-p.w * 0.2, -p.h * 0.45, p.w * 0.4, p.h * 0.14);
    } else if (p.type === "bones") {
      ctx.strokeStyle = "#f3ecd4";
      ctx.lineWidth = 3.5;
      ctx.beginPath();
      ctx.moveTo(-p.w * 0.45, -p.h * 0.35);
      ctx.lineTo(p.w * 0.45, p.h * 0.35);
      ctx.moveTo(-p.w * 0.45, p.h * 0.35);
      ctx.lineTo(p.w * 0.45, -p.h * 0.35);
      ctx.stroke();
    } else if (p.type === "candle") {
      ctx.fillStyle = "#d5c8a2";
      ctx.fillRect(-p.w * 0.16, -p.h * 0.48, p.w * 0.32, p.h * 0.82);
      ctx.fillStyle = "rgba(255, 164, 75, 0.18)";
      ctx.beginPath();
      ctx.ellipse(0, -p.h * 0.55, p.w * 0.5, p.h * 0.45, 0, 0, Math.PI * 2);
      ctx.fill();
      ctx.fillStyle = "rgba(255, 164, 75, 0.9)";
      ctx.beginPath();
      ctx.ellipse(0, -p.h * 0.56, p.w * 0.13, p.h * 0.2, 0, 0, Math.PI * 2);
      ctx.fill();
      ctx.fillStyle = "rgba(255, 194, 120, 0.45)";
      ctx.beginPath();
      ctx.ellipse(0, -p.h * 0.54, p.w * 0.35, p.h * 0.35, 0, 0, Math.PI * 2);
      ctx.fill();
    } else {
      ctx.fillStyle = "#6a6158";
      for (let n = 0; n < 4; n++) {
        const rx = -p.w * 0.45 + (n * p.w) / 4;
        const ry = (n % 2 === 0 ? -1 : 1) * p.h * 0.15;
        ctx.fillRect(rx, ry, p.w * 0.28, p.h * 0.3);
      }
    }

    // Slight outline pass to improve readability over cobblestone.
    ctx.strokeStyle = "rgba(20, 16, 12, 0.45)";
    ctx.lineWidth = 1;
    ctx.strokeRect(-p.w / 2, -p.h / 2, p.w, p.h);

    ctx.restore();
  }
}

function drawOrbiters() {
  for (const orb of playerUpgrades.orbiters) {
    if (orb.screenX === undefined) continue;

    ctx.save();
    ctx.fillStyle = "rgba(170, 221, 255, 0.18)";
    ctx.beginPath();
    ctx.arc(orb.screenX, orb.screenY, orb.size * 2.7, 0, Math.PI * 2);
    ctx.fill();

    ctx.fillStyle = "#8fc";
    ctx.beginPath();
    ctx.arc(orb.screenX, orb.screenY, orb.size, 0, Math.PI * 2);
    ctx.fill();

    // inner highlight
    ctx.fillStyle = "rgba(255,255,255,0.5)";
    ctx.beginPath();
    ctx.arc(orb.screenX - orb.size * 0.3, orb.screenY - orb.size * 0.3, orb.size * 0.35, 0, Math.PI * 2);
    ctx.fill();
    ctx.restore();
  }
}

function drawXPBar() {
  const barW = 200;
  const barH = 10;
  const bx = Math.floor((canvas.width - barW) / 2);
  const by = canvas.height - 18;

  // Background
  ctx.fillStyle = "#222";
  ctx.fillRect(bx, by, barW, barH);

  // Fill
  const pct = Math.min(xp / xpToNext, 1);
  const fillW = Math.floor(pct * barW);
  
  // Use cached gradient or create once
  if (!window._xpBarGradient) {
    window._xpBarGradient = ctx.createLinearGradient(0, 0, barW, 0);
    window._xpBarGradient.addColorStop(0, "#7b2fd4");
    window._xpBarGradient.addColorStop(1, "#d46de8");
  }
  ctx.fillStyle = window._xpBarGradient;
  ctx.fillRect(bx, by, fillW, barH);

  // Border
  ctx.strokeStyle = "#555";
  ctx.lineWidth = 1;
  ctx.strokeRect(bx, by, barW, barH);

  // Level label
  ctx.fillStyle = "#fff";
  ctx.font = "bold 12px Arial";
  ctx.textAlign = "center";
  ctx.fillText(`LV ${xpLevel}`, canvas.width / 2, by - 3);
  ctx.textAlign = "left";
}

function drawLevelUpScreen() {
  if (!levelUpPending) return;

  // Dim background
  ctx.fillStyle = "rgba(0,0,0,0.72)";
  ctx.fillRect(0, 0, canvas.width, canvas.height);

  // Title
  ctx.fillStyle = "#f0d060";
  ctx.font = "bold 32px Arial";
  ctx.textAlign = "center";
  ctx.fillText(`LEVEL ${xpLevel}!`, canvas.width / 2, 80);

  ctx.fillStyle = "#ccc";
  ctx.font = "16px Arial";
  ctx.fillText("Choose an upgrade", canvas.width / 2, 112);

  // Cards
  const cardW = 170;
  const cardH = 200;
  const gap = 24;
  const totalW = levelUpCards.length * cardW + (levelUpCards.length - 1) * gap;
  const startX = (canvas.width - totalW) / 2;
  const cardY = (canvas.height - cardH) / 2 - 10;

  for (let i = 0; i < levelUpCards.length; i++) {
    const card = levelUpCards[i];
    const cx = startX + i * (cardW + gap);
    const isSelected = (i === levelUpSelectedIndex);

    // Card shadow / glow when selected
    ctx.save();
    if (isSelected) {
      ctx.shadowColor = "#f0d060";
      ctx.shadowBlur = 22;
    }

    // Card background
    ctx.fillStyle = isSelected ? "#2a1e4a" : "#1a1428";
    ctx.beginPath();
    ctx.roundRect(cx, cardY, cardW, cardH, 12);
    ctx.fill();

    // Card border
    ctx.strokeStyle = isSelected ? "#f0d060" : "#5a4878";
    ctx.lineWidth = isSelected ? 3 : 1.5;
    ctx.stroke();

    ctx.restore();

    // Icon
    ctx.font = "44px Arial";
    ctx.textAlign = "center";
    ctx.fillText(card.icon, cx + cardW / 2, cardY + 60);

    // Name
    ctx.fillStyle = isSelected ? "#f0d060" : "#e8e0f8";
    ctx.font = `bold 16px Arial`;
    ctx.fillText(card.name, cx + cardW / 2, cardY + 92);

    // Description (word-wrap at ~22 chars)
    ctx.fillStyle = "#a090c0";
    ctx.font = "13px Arial";
    const words = card.desc.split(" ");
    let line = "";
    let lineY = cardY + 116;
    for (const word of words) {
      const test = line + (line ? " " : "") + word;
      if (ctx.measureText(test).width > cardW - 16) {
        ctx.fillText(line, cx + cardW / 2, lineY);
        line = word;
        lineY += 18;
      } else {
        line = test;
      }
    }
    if (line) ctx.fillText(line, cx + cardW / 2, lineY);

    // "Click to choose" hint on selected
    if (isSelected) {
      ctx.fillStyle = "#f0d060";
      ctx.font = "12px Arial";
      ctx.fillText("[ Click or Enter ]", cx + cardW / 2, cardY + cardH - 14);
    }
  }

  ctx.textAlign = "left";

  // Keyboard nav hint
  ctx.fillStyle = "#666";
  ctx.font = "12px Arial";
  ctx.textAlign = "center";
  ctx.fillText("← → to browse   1 / 2 / 3 to pick instantly", canvas.width / 2, cardY + cardH + 28);
  ctx.textAlign = "left";
}

// ============================================================
//  ENHANCED DUNGEON LIGHTING SYSTEM
// ============================================================

const dungeonLighting = {
  torches: [],
  ambientPulse: 0,
  flickerNoise: []
};

// Torch light source with flicker
class TorchLight {
  constructor(x, y, radius = 150) {
    this.x = x;
    this.y = y;
    this.baseRadius = radius;
    this.radius = radius;
    this.flicker = Math.random() * Math.PI * 2;
    this.flickerSpeed = Math.random() * 0.05 + 0.03;
    this.color = { r: 255, g: 180, b: 80 };
    this.intensity = 0.8;
  }

  update() {
    this.flicker += this.flickerSpeed;
    // Organic flicker pattern
    const flicker1 = Math.sin(this.flicker) * 0.15;
    const flicker2 = Math.sin(this.flicker * 2.3) * 0.08;
    const flicker3 = Math.sin(this.flicker * 4.7) * 0.05;
    this.radius = this.baseRadius * (1 + flicker1 + flicker2 + flicker3);
    this.intensity = 0.7 + (flicker1 + flicker2) * 0.3;
  }

  draw(ctx) {
    if (!settings.lighting) return;
    
    // Create radial gradient for torch glow
    const gradient = ctx.createRadialGradient(
      this.x, this.y, 0,
      this.x, this.y, this.radius
    );
    
    const alpha = this.intensity;
    gradient.addColorStop(0, `rgba(${this.color.r}, ${this.color.g}, ${this.color.b}, ${alpha * 0.4})`);
    gradient.addColorStop(0.3, `rgba(${this.color.r}, ${this.color.g}, ${this.color.b}, ${alpha * 0.2})`);
    gradient.addColorStop(0.6, `rgba(${this.color.r * 0.8}, ${this.color.g * 0.7}, ${this.color.b * 0.5}, ${alpha * 0.1})`);
    gradient.addColorStop(1, 'rgba(0, 0, 0, 0)');
    
    ctx.globalCompositeOperation = 'lighter';
    ctx.fillStyle = gradient;
    ctx.fillRect(this.x - this.radius, this.y - this.radius, this.radius * 2, this.radius * 2);
    ctx.globalCompositeOperation = 'source-over';
  }
}

// Add some torches to your level (call this when loading a level)
function initDungeonLighting() {
  dungeonLighting.torches = [];
  
  // Example: Add torches at regular intervals along walls
  // Adjust positions based on your level layout
  for (let x = 200; x < MAP_WIDTH; x += 400) {
    dungeonLighting.torches.push(new TorchLight(x, 150));
    dungeonLighting.torches.push(new TorchLight(x, MAP_HEIGHT - 150));
  }
  
  // Generate flicker noise for ambient lighting
  dungeonLighting.flickerNoise = [];
  for (let i = 0; i < 100; i++) {
    dungeonLighting.flickerNoise.push(Math.random());
  }
}

function updateDungeonLighting() {
  dungeonLighting.ambientPulse += 0.01;
  for (let i = 0; i < dungeonLighting.torches.length; i++) {
    dungeonLighting.torches[i].update();
  }
}

function drawDungeonLighting() {
  if (!settings.lighting) return;
  
  // Draw darkness overlay first
  ctx.save();
  ctx.globalCompositeOperation = 'source-over';
  ctx.fillStyle = 'rgba(15, 12, 20, 0.25)'; // Dark purple-ish dungeon darkness
  ctx.fillRect(0, 0, MAP_WIDTH, MAP_HEIGHT);
  
  // Draw torch lights
  for (let i = 0; i < dungeonLighting.torches.length; i++) {
    const t = dungeonLighting.torches[i];
    if (!isEffectVisibleInWorld(t.x, t.y, t.radius * 2, t.radius * 2, t.radius)) continue;
    t.draw(ctx);
  }
  
  ctx.restore();
}

// ============================================================
//  SCREEN EFFECTS - VIGNETTE & ATMOSPHERIC OVERLAY
// ============================================================

function drawVignette() {
  ctx.save();
  // Reset transform to draw in screen space
  ctx.setTransform(1, 0, 0, 1, 0, 0);
  
  // Radial gradient from center to edges
  const gradient = ctx.createRadialGradient(
    canvas.width / 2, canvas.height / 2, canvas.height * 0.2,
    canvas.width / 2, canvas.height / 2, canvas.height * 0.8
  );
  
  gradient.addColorStop(0, 'rgba(0, 0, 0, 0)');
gradient.addColorStop(0.7, 'rgba(5, 5, 10, 0.05)');
gradient.addColorStop(1, 'rgba(0, 0, 5, 0.15)');
  
  ctx.fillStyle = gradient;
  ctx.fillRect(0, 0, canvas.width, canvas.height);
  
  ctx.restore();
}

function drawAtmosphericOverlay() {
  ctx.save();
  ctx.setTransform(1, 0, 0, 1, 0, 0);
  
  // Subtle noise/grain effect
  if (Math.random() < 0.03) {
    ctx.fillStyle = `rgba(255, 255, 255, ${Math.random() * 0.02})`;
    for (let i = 0; i < 5; i++) {
      const x = Math.random() * canvas.width;
      const y = Math.random() * canvas.height;
      ctx.fillRect(x, y, 1, 1);
    }
  }
  
  ctx.restore();
}

// ============================================================
//  ENHANCED CAMERA WITH SMOOTH MOTION
// ============================================================

const enhancedCamera = {
  targetX: 0,
  targetY: 0,
  actualX: 0,
  actualY: 0,
  smoothing: 0.08, // Higher = snappier, lower = smoother
  shakeX: 0,
  shakeY: 0,
  shakeDecay: 0.9
};

function updateEnhancedCamera() {
  // Set target to player position (or wherever you want camera focused)
  enhancedCamera.targetX = player.x + player.width / 2 - canvas.width / 2;
  enhancedCamera.targetY = player.y + player.height / 2 - canvas.height / 2;
  
  // Smooth interpolation
  enhancedCamera.actualX += (enhancedCamera.targetX - enhancedCamera.actualX) * enhancedCamera.smoothing;
  enhancedCamera.actualY += (enhancedCamera.targetY - enhancedCamera.actualY) * enhancedCamera.smoothing;
  
  // Apply shake if enabled
  if (settings.screenShake) {
    enhancedCamera.shakeX *= enhancedCamera.shakeDecay;
    enhancedCamera.shakeY *= enhancedCamera.shakeDecay;
    
    // Kill tiny values
    if (Math.abs(enhancedCamera.shakeX) < 0.1) enhancedCamera.shakeX = 0;
    if (Math.abs(enhancedCamera.shakeY) < 0.1) enhancedCamera.shakeY = 0;
  }
  
  // Update your existing camera object
  camera.x = enhancedCamera.actualX + enhancedCamera.shakeX;
  camera.y = enhancedCamera.actualY + enhancedCamera.shakeY;
  
  // Clamp to world boundaries
  camera.x = Math.max(0, Math.min(camera.x, MAP_WIDTH - canvas.width));
  camera.y = Math.max(0, Math.min(camera.y, MAP_HEIGHT - canvas.height));
}

// Call this to trigger screen shake
function triggerScreenShake(intensity = 5) {
  if (!settings.screenShake) return;
  enhancedCamera.shakeX = (Math.random() - 0.5) * intensity * 2;
  enhancedCamera.shakeY = (Math.random() - 0.5) * intensity * 2;
}

// Draw lighting layer
function ensureLightingCache() {
  if (!lightingCacheCanvas) {
    lightingCacheCanvas = document.createElement("canvas");
    lightingCacheCtx = lightingCacheCanvas.getContext("2d");
    lightingCacheDirty = true;
  }
  if (lightingCacheCanvas.width !== canvas.width || lightingCacheCanvas.height !== canvas.height) {
    lightingCacheCanvas.width = canvas.width;
    lightingCacheCanvas.height = canvas.height;
    lightingCacheDirty = true;
  }
}

function drawLighting() {
  if (!lightingEnabled && ambientLight < 0.75) return;
  if (!settings.lighting) return;

  ensureLightingCache();

  const now = performance.now();
  const camMoved = Math.abs(camera.x - lightingCacheCamX) > 0.5 ||
                   Math.abs(camera.y - lightingCacheCamY) > 0.5;
  const timeSince = now - lightingCacheTime;
  const needsRedraw = camMoved || lightingCacheDirty || lightingCacheMs <= 0 || timeSince >= lightingCacheMs;

  if (needsRedraw) {
    lightingCacheTime = now;
    lightingCacheCamX = camera.x;
    lightingCacheCamY = camera.y;
    lightingCacheDirty = false;

    const renderCtx = lightingCacheCtx;
    renderCtx.setTransform(1, 0, 0, 1, 0, 0);
    renderCtx.clearRect(0, 0, lightingCacheCanvas.width, lightingCacheCanvas.height);

    renderCtx.save();
    renderCtx.translate(-camera.x, -camera.y);

    // Create darkness overlay
    renderCtx.fillStyle = `rgba(0, 0, 0, ${1 - ambientLight})`;
    renderCtx.fillRect(camera.x, camera.y, canvas.width, canvas.height);

    // Set blend mode for lights
    renderCtx.globalCompositeOperation = 'lighter';

    // Draw each light source
    for (let light of lights) {
      if (!isEffectVisibleInWorld(light.x, light.y, light.radius * 2, light.radius * 2, light.radius)) continue;

      renderCtx.save();

      // Torch head + flame (visual only; lighting math below stays unchanged)
      const torchFlicker = Math.sin(now * 0.02 + light.x * 0.05) * 0.5 + 0.5;
      const flameH = 10 + torchFlicker * 3;

      // Wooden torch handle
      renderCtx.fillStyle = '#5c3b1d';
      renderCtx.fillRect(light.x - 1.5, light.y - 2, 3, 14);

      // Metal collar near the flame
      renderCtx.fillStyle = '#8a8f98';
      renderCtx.fillRect(light.x - 4, light.y - 3, 8, 4);

      // Outer flame
      renderCtx.fillStyle = 'rgba(255, 150, 60, 0.18)';
      renderCtx.beginPath();
      renderCtx.arc(light.x, light.y - flameH * 0.55, 10, 0, Math.PI * 2);
      renderCtx.fill();
      renderCtx.fillStyle = `rgba(255, 140, 40, ${0.72 + torchFlicker * 0.22})`;
      renderCtx.beginPath();
      renderCtx.moveTo(light.x, light.y - flameH - 1);
      renderCtx.quadraticCurveTo(light.x + 6, light.y - 5, light.x, light.y + 1);
      renderCtx.quadraticCurveTo(light.x - 6, light.y - 5, light.x, light.y - flameH - 1);
      renderCtx.fill();

      // Inner hot core
      renderCtx.fillStyle = `rgba(255, 235, 170, ${0.7 + torchFlicker * 0.25})`;
      renderCtx.beginPath();
      renderCtx.moveTo(light.x, light.y - flameH + 2);
      renderCtx.quadraticCurveTo(light.x + 3, light.y - 6, light.x, light.y - 1);
      renderCtx.quadraticCurveTo(light.x - 3, light.y - 6, light.x, light.y - flameH + 2);
      renderCtx.fill();

      let beamStopY = -2099;

      const beamOccluders = [...walls, ...boxes];
      for (let obj of beamOccluders) {
        // Check if light is horizontally aligned with the object
        if (light.x >= obj.x && light.x <= obj.x + obj.width) {
          // Find the bottom edge of the object that is ABOVE the light
          let objBottom = obj.y + obj.height;
          if (objBottom < light.y && objBottom > beamStopY) {
            beamStopY = objBottom;
          }
        }
      }

      // Create radial gradient for light
      const gradient = renderCtx.createRadialGradient(
        light.x, light.y, 0,
        light.x, light.y, light.radius
      );

      const alpha = (light.intensity || 0) * 0.8;
      gradient.addColorStop(0, `${light.color}${Math.floor(alpha * 255).toString(16).padStart(2, '0')}`);
      gradient.addColorStop(0.4, `${light.color}${Math.floor(alpha * 0.5 * 255).toString(16).padStart(2, '0')}`);
      gradient.addColorStop(1, 'rgba(0, 0, 0, 0)');

      renderCtx.fillStyle = gradient;
      renderCtx.beginPath();
      renderCtx.arc(light.x, light.y, light.radius, 0, Math.PI * 2);
      renderCtx.fill();

      renderCtx.restore();
    }

    // Fireflies act as tiny, dim moving light sources.
    if (settings.particles && atmosphericParticles.fireflies.length) {
      for (let i = 0; i < atmosphericParticles.fireflies.length; i++) {
        const f = atmosphericParticles.fireflies[i];
        if (!isEffectVisibleInWorld(f.x, f.y, 64, 64, 32)) continue;

        const c = f.color || [170, 255, 190];
        const pulse = Math.sin(f.pulsePhase || 0) * 0.5 + 0.5;
        const r = 18 + pulse * 14;
        const a = 0.09 + pulse * 0.12;
        const g = renderCtx.createRadialGradient(f.x, f.y, 0, f.x, f.y, r);
        g.addColorStop(0, `rgba(${c[0]}, ${c[1]}, ${c[2]}, ${a})`);
        g.addColorStop(0.6, `rgba(${Math.round(c[0] * 0.75)}, ${Math.round(c[1] * 0.75)}, ${Math.round(c[2] * 0.75)}, ${a * 0.45})`);
        g.addColorStop(1, 'rgba(0, 0, 0, 0)');
        renderCtx.fillStyle = g;
        renderCtx.beginPath();
        renderCtx.arc(f.x, f.y, r, 0, Math.PI * 2);
        renderCtx.fill();
      }
    }

    // Reset blend mode
    renderCtx.globalCompositeOperation = 'source-over';

    // Draw shadows
    for (let light of lights) {
      drawShadows(renderCtx, light);
    }

    renderCtx.restore();
  }

  ctx.save();
  ctx.setTransform(1, 0, 0, 1, 0, 0);
  ctx.drawImage(lightingCacheCanvas, 0, 0);
  ctx.restore();
}
/*
// Toggle lighting (for testing)
document.addEventListener("keydown", (e) => {
  if (e.key.toLowerCase() === "l") {
    lightingEnabled = !lightingEnabled;
    lightingCacheDirty = true;
  }
});
*/
// --- Aim update (called every frame in gameLoop) ---
function updateCannonAim() {
  if (!hasPotato) return;

  if (!joystick.active) {
    // Desktop: aim toward world-space mouse
    const worldMouseX = mouse.x + camera.x;
    const worldMouseY = mouse.y + camera.y;
    const cx = player.x + player.width  / 2;
    const cy = player.y + player.height / 2;
    cannonAimAngle = Math.atan2(worldMouseY - cy, worldMouseX - cx);
  } else {
    cannonAimAngle = joystick.angle;
  }

  // Keep player facing the cannon direction
  player.facing = Math.abs(cannonAimAngle) < Math.PI / 2 ? 1 : -1;

  // Cooldown tick
  if (cannonCooldown > 0) cannonCooldown--;
}

// --- Fire a projectile ---
function firePotatoCannon() {
  if (cannonCooldown > 0) return;

  const speed = 14;
  const cx = player.x + player.width  / 2;
  const cy = player.y + player.height / 2;
  const baked = potatoState === "baked";

  cannonProjectiles.push({
    x:         cx + Math.cos(cannonAimAngle) * 20,  // spawn at barrel tip
    y:         cy + Math.sin(cannonAimAngle) * 20,
    vx:        Math.cos(cannonAimAngle) * speed,
    vy:        Math.sin(cannonAimAngle) * speed,
    size:      baked ? 13 : 8,
    explosive: baked,
    alive:     true,
    trail:     [],
    animFrame: 0,
    animTimer: 0,
    rotation: 0,
    screamTimer: 0,
    screamInterval: 22 + Math.floor(Math.random() * 18)
  });
  
  playPotatoScream();

  cannonCooldown = playerUpgrades.cannonRapidEnabled
  ? Math.floor(CANNON_COOLDOWN_FRAMES / 2)
  : CANNON_COOLDOWN_FRAMES;
  // Tiny recoil
  player.dx -= Math.cos(cannonAimAngle) * 1.5;
  player.dy -= Math.sin(cannonAimAngle) * 0.8;
}

// --- Update projectiles ---
function updateCannonProjectiles() {
  for (let i = cannonProjectiles.length - 1; i >= 0; i--) {
    const p = cannonProjectiles[i];

    if (!p.alive) { cannonProjectiles.splice(i, 1); continue; }

    // Trail
    p.trail.push({ x: p.x, y: p.y });
    if (p.trail.length > 9) p.trail.shift();

    // Animation
p.animTimer++;
if (p.animTimer >= SCREAM_ANIM.frameSpeed) {
  p.animTimer = 0;
  p.animFrame = (p.animFrame + 1) % SCREAM_ANIM.frameCount;
}
p.rotation += p.vx * 0.055;

// Mid-flight scream
p.screamTimer++;
if (p.screamTimer >= p.screamInterval) {
  p.screamTimer = 0;
  p.screamInterval = 20 + Math.floor(Math.random() * 20);
  playPotatoScream();
}
    // Physics
    p.x += p.vx;
    p.y += p.vy;

    if (p.homing && p.homingTarget) {
      const t = p.homingTarget;
      const alive = t.hp > 0 && (t.alive !== false);
      if (alive) {
        const tx = t.x + (t.width  || 0) / 2;
        const ty = t.y + (t.height || 0) / 2;
        const dx = tx - p.x, dy = ty - p.y;
        const dist = Math.hypot(dx, dy) || 1;
        p.vx += (dx / dist) * 0.35;
        p.vy += (dy / dist) * 0.35;
        const spd = Math.hypot(p.vx, p.vy);
        if (spd > 10) { p.vx = p.vx / spd * 10; p.vy = p.vy / spd * 10; }
      } else {
        p.vy += 0.25; // target gone, fall normally
      }
    } else {
      p.vy += 0.25; // normal gravity
    }

    // World bounds
    if (p.x < 0 || p.x > world.width || p.y > world.height + 300) {
      playPotatoImpact(p.explosive);
      p.alive = false; continue;
    }

   // Wall collision
if (collidesWithWall(p.x - p.size, p.y - p.size, p.size * 2, p.size * 2)) {

  if (p.explosive || (p.homing && playerUpgrades.homingExplosive)) {
    createExplosion(p.x, p.y);
  }
  
  if (playerUpgrades.cannonBounceEnabled && !p.bounced) {
    // Use the previous position to separate horizontal and vertical collisions.
    const prevX = p.x - p.vx;
    const prevY = p.y - p.vy;
    const hitH = collidesWithWall(prevX + p.vx - p.size, prevY - p.size, p.size * 2, p.size * 2);
    const hitV = collidesWithWall(prevX - p.size, prevY + p.vy - p.size, p.size * 2, p.size * 2);
    if (hitV) p.vy *= -1;
    if (hitH) p.vx *= -1;
    if (p.explosive) createExplosion(p.x, p.y);
    p.bounced = true;
  } else {
    if (p.explosive) createExplosion(p.x, p.y);
    playPotatoImpact(p.explosive);
    p.alive = false;
  }
  continue;
}

    // Enemy hit detection
    const hitBox = { x: p.x - p.size, y: p.y - p.size, width: p.size * 2, height: p.size * 2 };
    let hit = false;
    const dmg = p.explosive ? 2 : 1;
    const kb  = { x: p.vx * 0.4, y: -3 };

    const enemyChecks = [
      { list: G.snails,     key: 'snail' },
      { list: G.SuperSnails,key: 'superSnail' },
      { list: G.bats,       key: 'bat' },
      { list: G.snowmen,    key: 'snowman' },
      { list: G.babyMicrowaves, key: 'babyMicrowave' },
    ];

for (const { list, key } of enemyChecks) {
  if (hit) break;
  for (let j = list.length - 1; j >= 0; j--) {
    const e = list[j];
    if (isColliding(hitBox, e)) {
      if (key === 'babyMicrowave') {
        e.hp = Math.min(e.maxHp || 1, (e.hp || 0) + Math.max(1, dmg));
        e.maxHp = e.maxHp || e.hp;
        e.hitFlash = 6;
        e.openTimer = Math.max(e.openTimer || 0, 10);
        e.dingTimer = 14;
        potatoMessage = '🍼 baby microwave healed';
        potatoMessageTimer = 60;
      } else {
        damageEnemy(e, dmg, kb);
        if (e.hp <= 0) { list.splice(j, 1); onEnemyKilled(key); }
      }
      hit = true;
      break;
    }
  }
}
// Cheese — cannon
if (!hit) {
  hit = damageCheeseCheck(
    hitBox,
    dmg,
    { x: p.vx * 0.4, y: -3 }
  );
}

    // G.yetis
    if (!hit) for (const y of G.yetis) {
      if (!y.alive) continue;
      if (isColliding(hitBox, y)) {
        damageEnemy(y, p.explosive ? 4 : 1, kb);
        if (y.hp <= 0) { y.alive = false; onEnemyKilled('yeti'); }
        hit = true; break;
      }
    }

    // G.turrets
    if (!hit) for (let j = G.turrets.length - 1; j >= 0; j--) {
      if (isColliding(hitBox, G.turrets[j])) {
        damageEnemy(G.turrets[j], dmg, { x: 0, y: 0 });
        if (G.turrets[j].hp <= 0) { G.turrets.splice(j, 1); onEnemyKilled('turret'); }
        hit = true; break;
      }
    }

        // G.chairs — knock and damage
    if (!hit) for (let j = G.chairs.length - 1; j >= 0; j--) {
      const c = G.chairs[j];
      if (isColliding(hitBox, c)) {
        const kbDir = { x: p.vx * 0.5, y: -4 };
        damageEnemy(c, dmg, kbDir);
        // Extra physics shove on top of knockback
        c.dx += p.vx * 0.6;
        c.dy += p.vy * 0.3 - 3;
        if (c.hp <= 0) { G.chairs.splice(j, 1); onEnemyKilled('chair'); }
        if (p.explosive) createExplosion(p.x, p.y);
        hit = true; break;
      }
    }
    // G.tables — flip them when hit!
    if (!hit) for (let j = G.tables.length - 1; j >= 0; j--) {
      const t = G.tables[j];
      if (isColliding(hitBox, t)) {
        damageEnemy(t, dmg, { x: p.vx * 0.4, y: -5 });
        if (!t.flipping) triggerTableFlip(t, p.vx * 0.6);
        if (t.hp <= 0) { G.tables.splice(j, 1); onEnemyKilled('table'); }
        if (p.explosive) createExplosion(p.x, p.y);
        hit = true; break;
      }
    }
    // Boxes — knock them away
    if (!hit) for (const b of boxes) {
      if (isColliding(hitBox, b)) {
        damageBox(b, 1);
        b.dx += p.vx * 0.5;
        b.dy += p.vy * 0.3 - 2;
        hit = true; break;
      }
    }

  if (hit) {
  if (p.explosive || (p.homing && playerUpgrades.homingExplosive)) {
    createExplosion(p.x, p.y);
  }
  p.alive = false;
  playPotatoImpact(p.explosive);
      }
    }
  }

// --- Explosion effects ---
function createExplosion(x, y, options = {}) {
  const type = options.type || 'potato';
  const maxRadius = options.maxRadius || (type === 'microwave' ? 64 : 85);
  const timer = options.timer || (type === 'microwave' ? 24 : 28);
  const dmg = options.damage || (type === 'microwave' ? 2 : 3);

  G.explosions.push({
    x,
    y,
    radius: 0,
    maxRadius,
    timer,
    maxTimer: timer,
    type,
    damage: dmg,
    playerHit: false,
  });

  const R   = maxRadius;
  const kb  = (ex, ey) => ({ x: (ex - x) * 0.12, y: -5 });

  for (let j = G.snails.length - 1; j >= 0; j--) {
    const s = G.snails[j];
    if (Math.hypot((s.x + s.width/2) - x, (s.y + s.height/2) - y) < R) {
      damageEnemy(s, dmg, kb(s.x, s.y));
      if (s.hp <= 0) { G.snails.splice(j, 1); onEnemyKilled('snail'); }
    }
  }
  for (let j = G.SuperSnails.length - 1; j >= 0; j--) {
    const s = G.SuperSnails[j];
    if (Math.hypot((s.x + s.width/2) - x, (s.y + s.height/2) - y) < R) {
      damageEnemy(s, dmg, kb(s.x, s.y));
      if (s.hp <= 0) { G.SuperSnails.splice(j, 1); onEnemyKilled('superSnail'); }
    }
  }
  for (const yeti of G.yetis) {
    if (!yeti.alive) continue;
    if (Math.hypot((yeti.x + yeti.width/2) - x, (yeti.y + yeti.height/2) - y) < R) {
      damageEnemy(yeti, 4, kb(yeti.x, yeti.y));
      if (yeti.hp <= 0) { yeti.alive = false; onEnemyKilled('yeti'); }
    }
  }
  for (let j = G.snowmen.length - 1; j >= 0; j--) {
    const s = G.snowmen[j];
    if (Math.hypot((s.x + s.width/2) - x, (s.y + s.height/2) - y) < R) {
      damageEnemy(s, dmg, kb(s.x, s.y));
      if (s.hp <= 0) { G.snowmen.splice(j, 1); onEnemyKilled('snowman'); }
    }
  }
  for (let j = G.babyMicrowaves.length - 1; j >= 0; j--) {
    const m = G.babyMicrowaves[j];
    if (Math.hypot((m.x + m.width/2) - x, (m.y + m.height/2) - y) < R) {
      if (type === 'microwave') {
        damageEnemy(m, dmg, kb(m.x, m.y));
        if (m.hp <= 0) triggerBabyMicrowaveExplosion(m);
      } else {
        m.hp = Math.min(m.maxHp || 1, (m.hp || 0) + dmg);
        m.maxHp = m.maxHp || m.hp;
        m.hitFlash = 6;
        m.openTimer = Math.max(m.openTimer || 0, 10);
        m.dingTimer = 14;
        potatoMessage = '🍼 baby microwave healed';
        potatoMessageTimer = 60;
      }
    }
  }
  for (const b of boxes) {
    const dx   = (b.x + b.width/2)  - x;
    const dy   = (b.y + b.height/2) - y;
    const dist = Math.hypot(dx, dy);
    if (dist < R) {
      const force = (1 - dist / R) * 16;
      b.dx += (dx / dist) * force;
      b.dy -= (1 - dist / R) * 10;
    }
  }
  // G.chairs caught in explosion radius
  for (let j = G.chairs.length - 1; j >= 0; j--) {
    const c = G.chairs[j];
    const dx   = (c.x + c.width/2)  - x;
    const dy   = (c.y + c.height/2) - y;
    const dist = Math.hypot(dx, dy);
    if (dist < R) {
      const force = (1 - dist / R) * 14;
      damageEnemy(c, 3, { x: (dx / dist) * force * 0.4, y: -5 });
      c.dx += (dx / dist) * force;
      c.dy -= (1 - dist / R) * 9;
      if (c.hp <= 0) { G.chairs.splice(j, 1); onEnemyKilled('chair'); }
    }
  }
  // G.tables caught in explosion: flip them spectacularly
  for (let j = G.tables.length - 1; j >= 0; j--) {
    const t = G.tables[j];
    const dx   = (t.x + t.width/2)  - x;
    const dy   = (t.y + t.height/2) - y;
    const dist = Math.hypot(dx, dy);
    if (dist < R) {
      const force = (1 - dist / R) * 16;
      damageEnemy(t, 3, { x: (dx / dist) * force * 0.3, y: -6 });
      if (!t.flipping) triggerTableFlip(t, (dx / (dist||1)) * force * 0.5);
      if (t.hp <= 0) { G.tables.splice(j, 1); onEnemyKilled('table'); }
    }
  }
  // Screen shake + VHS glitch
  if (settings.screenShake && !settings.reducedMotion) {
  camera.x += (Math.random() - 0.5) * 22;
  camera.y += (Math.random() - 0.5) * 22;
}
  triggerVHSGlitch();

  if (hasPotato) {
    potatoMessage = "🥔🔥 BOOM";
    potatoMessageTimer = 60;
  }
}

// --- Update explosion animations ---
function updateExplosions() {
  for (let i = G.explosions.length - 1; i >= 0; i--) {
    const e = G.explosions[i];
    e.timer--;
    e.radius = e.maxRadius * (1 - e.timer / e.maxTimer);

    if (e.type === 'microwave' && !e.playerHit) {
      const playerDistance = Math.hypot(
        (player.x + player.width / 2) - e.x,
        (player.y + player.height / 2) - e.y
      );
      if (playerDistance <= e.radius * 0.86) {
        damagePlayer('Baby Microwave Explosion');
        e.playerHit = true;
      }
    }

    if (e.timer <= 0) G.explosions.splice(i, 1);
  }
}


function drawPotatoCannon() {

  // --- Draw projectiles ---
  for (const p of cannonProjectiles) {
    if (!p.alive) continue;

    // Always draw projectiles — homing shots fire even without the potato
    for (let j = 0; j < p.trail.length; j++) {
      const frac = j / p.trail.length;
      const alpha = frac * 0.55;
      const sz = p.size * frac * 0.65;
      ctx.fillStyle = p.homing
        ? `rgba(223,139,254,${alpha})`
        : p.explosive ? `rgba(255,110,0,${alpha})` : `rgba(160,100,40,${alpha})`;
      ctx.beginPath();
      ctx.arc(p.trail[j].x, p.trail[j].y, Math.max(sz, 1), 0, Math.PI * 2);
      ctx.fill();
    }
    ctx.save();
    if (p.homing) {ctx.shadowColor = "#8E44AD"; ctx.shadowBlur = 14; ctx.fillStyle = "#fa1593";}
    else if (p.explosive) { ctx.shadowColor = "#ff5500"; ctx.shadowBlur = 18; ctx.fillStyle = "#ff8800"; }
    else { ctx.fillStyle = "#b58b4a"; }
    const s = p.size;
    ctx.beginPath(); ctx.arc(p.x, p.y, s, 0, Math.PI * 2); ctx.fill();
    ctx.fillStyle = p.homing ? "#df8bfe" : p.explosive ? "#ffdd88" : "#d4aa6a";
    ctx.beginPath(); ctx.arc(p.x - s * 0.3, p.y - s * 0.3, s * 0.4, 0, Math.PI * 2); ctx.fill();
    ctx.restore();
    
    // Trail
    for (let j = 0; j < p.trail.length; j++) {
      const frac  = j / p.trail.length;
      const alpha = frac * 0.55;
      const sz    = p.size * frac * 0.65;
      ctx.fillStyle = p.explosive
        ? `rgba(255,110,0,${alpha})`
        : `rgba(160,100,40,${alpha})`;
      ctx.beginPath();
      ctx.arc(p.trail[j].x, p.trail[j].y, Math.max(sz, 1), 0, Math.PI * 2);
      ctx.fill();
    }
    drawScreamingPotato(p);  // ← pass p, not the whole array
  }

  if (!hasPotato) return;

  const cx = player.x + player.width  / 2;
  const cy = player.y + player.height / 2;
  const baked = potatoState === "baked";

  // --- Draw cannon barrel ---
  ctx.save();
  ctx.translate(cx, cy);
  ctx.rotate(cannonAimAngle);
  const cannonW = 59;
  const cannonH = 12;
  if (baked) { ctx.shadowColor = "#ff6600"; ctx.shadowBlur = 16; }
  if (Math.abs(cannonAimAngle) > Math.PI / 2) { ctx.scale(1, -1); }
  ctx.drawImage(cannonImg, -5, -cannonH / 2, cannonW, cannonH);
  ctx.restore();
}

  function drawScreamingPotato(p) {
    const drawSize = p.explosive ? SCREAM_ANIM.drawSizeBig : SCREAM_ANIM.drawSize;
    const half = drawSize / 2;
    const col = p.animFrame % SCREAM_ANIM.framesPerRow;
    const row = Math.floor(p.animFrame / SCREAM_ANIM.framesPerRow);
  
    ctx.save();
    ctx.translate(p.x, p.y);
    ctx.rotate(p.rotation);
    if (p.explosive) { ctx.shadowColor = "#ff5500"; ctx.shadowBlur = 18; }
    ctx.imageSmoothingEnabled = false;
  
    if (screamPotatoSheet.complete && screamPotatoSheet.naturalWidth > 0) {
      ctx.drawImage(
        screamPotatoSheet,
        col * SCREAM_ANIM.frameW, row * SCREAM_ANIM.frameH,
        SCREAM_ANIM.frameW, SCREAM_ANIM.frameH,
        -half, -half, drawSize, drawSize
      );
    } else {
      // Fallback while sheet loads
      ctx.fillStyle = p.explosive ? "#ff8800" : "#b58b4a";
      ctx.fillRect(-half, -half, drawSize, drawSize);
    }
    ctx.restore();
  }

function drawExplosions() {
  for (const e of G.explosions) {
    const frac = 1 - e.timer / e.maxTimer;
    const alpha = 1 - frac;
    if (e.type === 'microwave') {
      ctx.save();
      ctx.globalAlpha = alpha * 0.75;
      ctx.strokeStyle = '#ff9ec7';
      ctx.lineWidth = 3;
      ctx.beginPath();
      ctx.arc(e.x, e.y, e.radius, 0, Math.PI * 2);
      ctx.stroke();

      ctx.globalAlpha = alpha * 0.95;
      const grad = ctx.createRadialGradient(e.x, e.y, 0, e.x, e.y, e.radius * 0.7);
      grad.addColorStop(0, '#fff8fb');
      grad.addColorStop(0.35, '#ffd1e2');
      grad.addColorStop(0.7, '#ff8fb8');
      grad.addColorStop(1, 'rgba(255,143,184,0)');
      ctx.fillStyle = grad;
      ctx.beginPath();
      ctx.arc(e.x, e.y, e.radius * 0.7, 0, Math.PI * 2);
      ctx.fill();

      ctx.strokeStyle = 'rgba(255,255,255,0.9)';
      ctx.lineWidth = 2;
      for (let a = 0; a < Math.PI * 2; a += Math.PI / 3) {
        ctx.beginPath();
        ctx.moveTo(e.x + Math.cos(a) * (e.radius * 0.2), e.y + Math.sin(a) * (e.radius * 0.2));
        ctx.lineTo(e.x + Math.cos(a) * (e.radius * 0.92), e.y + Math.sin(a) * (e.radius * 0.92));
        ctx.stroke();
      }
      ctx.restore();
      continue;
    }

    // outer shockwave ring
    ctx.save();
    ctx.globalAlpha = alpha * 0.6;
    ctx.strokeStyle = '#ff8800';
    ctx.lineWidth = 4;
    ctx.beginPath();
    ctx.arc(e.x, e.y, e.radius, 0, Math.PI * 2);
    ctx.stroke();

    // inner fireball
    ctx.globalAlpha = alpha * 0.8;
    const grad = ctx.createRadialGradient(e.x, e.y, 0, e.x, e.y, e.radius * 0.6);
    grad.addColorStop(0,   '#fff');
    grad.addColorStop(0.3, '#ffdd00');
    grad.addColorStop(0.7, '#ff5500');
    grad.addColorStop(1,   'rgba(255,80,0,0)');
    ctx.fillStyle = grad;
    ctx.beginPath();
    ctx.arc(e.x, e.y, e.radius * 0.6, 0, Math.PI * 2);
    ctx.fill();

    ctx.restore();
  }
}

// HUD crosshair — draw in screen-space (after ctx.restore for camera)
function drawCannonCrosshair() {
  if (!hasPotato || gameOver) return;

  const screenMouseX = mouse.x;
  const screenMouseY = mouse.y;

  ctx.save();
  ctx.translate(screenMouseX, screenMouseY);

  const baked = potatoState === "baked";
  const col   = baked ? "#ff8800" : "#ffd966";
  const r     = 12;

  ctx.strokeStyle = col;
  ctx.lineWidth   = 2;

  // Crosshair circle
  ctx.beginPath();
  ctx.arc(0, 0, r, 0, Math.PI * 2);
  ctx.stroke();

  // Cross lines
  [[-r - 5, 0], [r + 5, 0], [0, -r - 5], [0, r + 5]].forEach(([tx, ty]) => {
    ctx.beginPath();
    ctx.moveTo(tx < 0 ? -r + 3 : r - 3, ty < 0 ? -r + 3 : r - 3);
    ctx.lineTo(tx || (ty < 0 ? 0 : 0), ty || 0);
    if (Math.abs(tx) > 0) { ctx.moveTo(tx < 0 ? -r : r, 0); ctx.lineTo(tx, 0); }
    if (Math.abs(ty) > 0) { ctx.moveTo(0, ty < 0 ? -r : r); ctx.lineTo(0, ty); }
    ctx.stroke();
  });

  // Simpler cross
  ctx.beginPath();
  ctx.moveTo(-r - 5, 0); ctx.lineTo(-r, 0);
  ctx.moveTo( r,     0); ctx.lineTo( r + 5, 0);
  ctx.moveTo(0, -r - 5); ctx.lineTo(0, -r);
  ctx.moveTo(0,  r);     ctx.lineTo(0,  r + 5);
  ctx.stroke();

  if (baked) {
    ctx.fillStyle = `rgba(255,140,0,0.25)`;
    ctx.beginPath();
    ctx.arc(0, 0, r, 0, Math.PI * 2);
    ctx.fill();
  }

  ctx.restore();
}

function drawSnowAura(s) {
  const cx = s.x + s.width / 2;
  const cy = s.y + s.height / 2;
  const R = s.slowRadius;

  // --- AURA RING ---
  ctx.beginPath();
  ctx.arc(cx, cy, R, 0, Math.PI * 2);
  ctx.strokeStyle = "rgba(220,240,255,0.45)";
  ctx.lineWidth = 3;
  ctx.stroke();

  // subtle glow
  ctx.beginPath();
  ctx.arc(cx, cy, R - 2, 0, Math.PI * 2);
  ctx.strokeStyle = "rgba(255,255,255,0.2)";
  ctx.lineWidth = 1;
  ctx.stroke();

  // --- SPAWN SNOW PARTICLES ---
  if (s.flurryParticles.length < 40) {
    const angle = Math.random() * Math.PI * 2;
    const r = Math.random() * R;

    s.flurryParticles.push({
      x: cx + Math.cos(angle) * r,
      y: cy + Math.sin(angle) * r,
      vx: 0.4 + Math.random() * 0.9,
      vy: 0.4 + Math.random() * 1,// sideways wind
      size: 1.5 + Math.random() * 1.5
    });
  }

  // --- UPDATE & DRAW PARTICLES ---
  ctx.fillStyle = "rgba(255,255,255,0.9)";

  for (let i = s.flurryParticles.length - 1; i >= 0; i--) {
    const p = s.flurryParticles[i];

    p.x += p.vx;

    // distance from center
    const dx = p.x - cx;
    const dy = p.y - cy;

    // remove if outside radius
    if (dx * dx + dy * dy > R * R) {
      s.flurryParticles.splice(i, 1);
      continue;
    }

    ctx.beginPath();
    ctx.arc(p.x, p.y, p.size, 0, Math.PI * 2);
    ctx.fill();
  }
}

function randomFrom(arr) {
  return arr[Math.floor(Math.random() * arr.length)];
}

function isChristmasMap() {
  return currentLevel === 3;
}

function shatterIcicle(i) {
  i.active = false;
  i.falling = false;
  i.respawnTimer = 120; // ~2 seconds at 60fps
}

function getGroundSurface(entity) {
  for (let wall of walls) {
    if (
      entity.x + entity.width > wall.x &&
      entity.x < wall.x + wall.width &&
      entity.y + entity.height <= wall.y + 6 &&
      entity.y + entity.height >= wall.y - 6
    ) {
      return wall;
    }
  }
  return null;
}


// Ensure an enemy stays within reasonable world bounds. If outside, teleport
// them to a random X inside the map and a semi-random Y, and zero their
// vertical velocity to avoid tunneling.
function ensureEntityInBounds(e) {
  const MARGIN = 200;
  if (e.x < -MARGIN || e.x > MAP_WIDTH + MARGIN || e.y < -MARGIN || e.y > MAP_HEIGHT + MARGIN) {
    // Random X well inside the map
    e.x = 100 + Math.random() * Math.max(0, MAP_WIDTH - 200);
    // Semi-random Y: prefer upper half to avoid immediate ground clipping
    e.y = 100 + Math.random() * Math.max(0, MAP_HEIGHT - 300);
    // Zero vertical velocity to avoid tunneling through floors
    if (typeof e.dy !== 'undefined') e.dy = 0;
    if (typeof e.vy !== 'undefined') e.vy = 0;
    // clear knockback so they don't immediately fly out again
    if (typeof e.knockbackTimer !== 'undefined') e.knockbackTimer = 0;
    if (typeof e.knockbackDx !== 'undefined') e.knockbackDx = 0;
    if (typeof e.knockbackDy !== 'undefined') e.knockbackDy = 0;
  }
}


function showCanvas() {
  canvas.style.display = "block";
}

function hideCanvas() {
  canvas.style.display = "none";
}

function startGame() {
  // Always stop any existing loop first
  stopGameLoop();
  // Reset everything
  resetGameState();
  hideAllMenus();
  document.getElementById("game").style.display = "block";

  
  gameRunning = true;
  gamePaused = false;
  lastFrameTime = performance.now();
  lastTimestamp = performance.now();

  // Start loop
  gameLoopId = requestAnimationFrame(gameLoop);
}

function stopGameLoop() {
  if (gameLoopId) {
    cancelAnimationFrame(gameLoopId);
    gameLoopId = null;
  }
  gameRunning = false;
}


function openSettings() {
  hideAllMenus();
  document.getElementById("settings").classList.remove("hidden");
}

function openKeybindsMenu() {
  keybindCaptureAction = null;
  hideAllMenus();
  renderKeybindMenu();
  document.getElementById("keybindsMenu").classList.remove("hidden");
}

function backToSettingsFromKeybinds() {
  keybindCaptureAction = null;
  hideAllMenus();
  document.getElementById("settings").classList.remove("hidden");
}

function openLevelSelect() {
  hideAllMenus();
  document.getElementById("levelSelect").classList.remove("hidden");
}

function openFreeSelect() {
  hideAllMenus();
  document.getElementById("freeSelect").classList.remove("hidden");
  
}
function openWaveSelect() {
  hideAllMenus();
  tutorialActive = false;
  document.getElementById("waveSelect").classList.remove("hidden");
}
function openFreeSelect() {
  hideAllMenus();
  document.getElementById("freeSelect").classList.remove("hidden");
}

function openCredits() {
  hideAllMenus();
  document.getElementById("credits").classList.remove("hidden");
  
}

function openControllerControls() {
  hideAllMenus();
  document.getElementById("controllerControls").classList.remove("hidden");
}

function openControls() {
    hideAllMenus();
    document.getElementById("controls").classList.remove("hidden");
}

// --- Custom levels integration ---
function openLevelEditorOverlay(){
  hideAllMenus();
  const ov = document.getElementById('levelEditorOverlay');
  if (ov) ov.classList.remove('hidden');
}
function closeLevelEditorOverlay(){
  const ov = document.getElementById('levelEditorOverlay');
  if (ov) ov.classList.add('hidden');
  document.getElementById('menu').classList.remove('hidden');
  try { populateCustomLevelsList(); } catch(e){}
}

function openCustomLevels(){
  hideAllMenus();
  const el = document.getElementById('customLevels');
  if (el) el.classList.remove('hidden');
  populateCustomLevelsList();
}

function populateCustomLevelsList(){
  const wrap = document.getElementById('custom-levels-list');
  if (!wrap) return;
  wrap.innerHTML = '';
  try{
    const raw = localStorage.getItem('yt_custom_levels') || '{}';
    const store = JSON.parse(raw || '{}');
    const names = Object.keys(store);
    if (!names.length) { wrap.innerHTML = '<div style="color:#bbb">No custom levels saved yet. Open the Level Editor to save one.</div>'; return; }
    names.forEach(n=>{
      const row = document.createElement('div');
      row.style.display='flex'; row.style.alignItems='center'; row.style.justifyContent='space-between'; row.style.marginBottom='8px';
      const title = document.createElement('div'); title.textContent = n; title.style.color='#e8e0f8';
      const actions = document.createElement('div');
      const loadBtn = document.createElement('button'); loadBtn.textContent='Play'; loadBtn.className='btn'; loadBtn.onclick = ()=>{ startCustomLevel(n); };
      const editBtn = document.createElement('button'); editBtn.textContent='Edit'; editBtn.className='btn'; editBtn.onclick = ()=>{ openLevelEditorOverlay(); setTimeout(()=>{ const f = document.getElementById('levelEditorFrame'); if(f && f.contentWindow){ f.contentWindow.postMessage({ type:'load-custom-level', name: n }, '*'); } }, 400); };
      const delBtn = document.createElement('button'); delBtn.textContent='Delete'; delBtn.className='btn bd'; delBtn.onclick = ()=>{ if(confirm('Delete custom level '+n+'?')){ deleteCustomLevel(n); populateCustomLevelsList(); } };
      actions.appendChild(loadBtn); actions.appendChild(editBtn); actions.appendChild(delBtn);
      row.appendChild(title); row.appendChild(actions); wrap.appendChild(row);
    });
  }catch(e){ wrap.innerHTML = '<div style="color:#f66">Error reading custom levels</div>'; }
}

function deleteCustomLevel(name){
  try{
    const raw = localStorage.getItem('yt_custom_levels') || '{}';
    const store = JSON.parse(raw || '{}');
    delete store[name];
    localStorage.setItem('yt_custom_levels', JSON.stringify(store));
  }catch(e){ console.warn('deleteCustomLevel failed', e); }
}

function startCustomLevel(name){
  try{
    const raw = localStorage.getItem('yt_custom_levels') || '{}';
    const store = JSON.parse(raw || '{}');
    const data = store[name];
    if (!data) { alert('Custom level not found'); return; }
    stopGameLoop();
    resetGameState();
    hideAllMenus();
    document.getElementById('game').style.display = 'block';
    resetWorld();
    try{ applyEditorObjects(data.objects || [], true); } catch(e){ console.warn('applyEditorObjects failed', e); }
    if (Array.isArray(data.waves)) { G.wavesystem.currentMapWaves = data.waves; G.wavesystem.enabled = true; G.wavesystem.currentWave = 0; G.wavesystem.waveActive = false; G.wavesystem.spawnQueue = []; }
    initializeLevelLights();
    saveInitialState();
    startMusic();
    gameRunning = true; gamePaused = false; lastFrameTime = performance.now(); lastTimestamp = performance.now();
    gameLoopId = requestAnimationFrame(gameLoop);
  }catch(e){ alert('Failed to load custom level: '+e.message); }
}

// Editor <-> page messaging (placeholder)
window.addEventListener('message', (ev)=>{});

function resetLevelGeometry() {
  walls = [];
  seesaws = [];
  boxes = [];
  spikes = [];
  ladders = [];
  ovens = [];
  G.turrets = [];
  G.snails = [];
  G.SuperSnails = [];
  G.chairs = [];
  G.tables = [];
  G.bats = [];
  G.yetis = [];
  G.snowmen = [];
  G.babyMicrowaves = [];
  G.icicles = [];
  // Clear level-defined lighting and spawn zones
  lights = [];
  levelSpawnZones = [];
}

function applyEditorObjects(objs, withBounds = true) {
  resetLevelGeometry();
  if (withBounds) addMapBounds();

  for (const o of objs) {
    if (o.type === 'wall') {
      walls.push({ x: o.x, y: o.y, width: o.width, height: o.height, ice: !!o.ice });
    } else if (o.type === 'wall-moving') {
      const axKey = o.axis === 'h' ? 'startX' : 'startY';
      const axVal = o.axis === 'h' ? o.x : o.y;
      walls.push({ x: o.x, y: o.y, width: o.width, height: o.height, moving: true, dir: 1, speed: o.speed || 1.5, ice: !!o.ice, [axKey]: axVal, range: o.range || 100 });
    } else if (o.type === 'spike') {
      spikes.push({ x: o.x, y: o.y, width: o.width || 40, height: o.height || 26 });
    } else if (o.type === 'ladder') {
      ladders.push({ x: o.x, y: o.y, width: o.width, height: o.height });
    } else if (o.type === 'seesaw') {
      seesaws.push({ x: o.x, y: o.y, width: o.width, height: o.height, angle: 0, angularVelocity: 0 });
    } else if (o.type === 'light') {
      // Light objects from editor: { x, y, radius, intensity, color, particleSpawnRate }
      lights.push({
        x: o.x + (o.width || 0) / 2,
        y: o.y + (o.height || 0) / 2,
        radius: o.radius || Math.max(o.width, o.height) || 200,
        intensity: typeof o.intensity === 'number' ? o.intensity : 1,
        color: o.color || '#ffdbaa',
        particleSpawnRate: o.particleSpawnRate || 0.02
      });
    } else if (o.type === 'spawn') {
      // Spawn zone: store rectangles for getSpawnPosition to use
      levelSpawnZones.push({ x: o.x, y: o.y, width: o.width || 40, height: o.height || 40 });
    } else if (o.type === 'oven') {
      ovens.push({ x: o.x, y: o.y, width: o.width || 40, height: o.height || 50, active: !!o.active, baked: !!o.baked, glow: o.glow || 0 });
    }
  }
}

async function loadMap_LevelFile(level) {
  const url = `levels/level${level}.lvl`;
  try {
    const res = await fetch(url, { cache: 'no-store' });
    if (!res.ok) return false;
    const raw = await res.text();
    const data = JSON.parse(raw);
    const objs = Array.isArray(data.objects) ? data.objects : (Array.isArray(data) ? data : []);
    if (!objs.length) return false;
    applyEditorObjects(objs, data.includeBounds !== false);

    // If the level file includes a waves array, use it for this map
    if (Array.isArray(data.waves)) {
      G.wavesystem.currentMapWaves = data.waves;
      G.wavesystem.enabled = true;
      G.wavesystem.currentWave = 0;
      G.wavesystem.waveActive = false;
      G.wavesystem.spawnQueue = [];
    }

    // Backward compatibility: older .lvl files did not include oven objects.
    if (level === 1 && ovens.length === 0) {
      ovens.push({ x: 200, y: 840, width: 40, height: 50, active: false, baked: false, glow: 0 });
    }

    return true;
  } catch (err) {
    return false;
  }
}

async function loadLevel(level) {
  resetWorld(); // clear previous map junk
  currentLevel = level;
  if (editorPreviewMode) {
    loadMap_EditorPreview();
  } else {
    if (level === 0) {
      loadMap_Tutorial();
    } else {
      const loaded = await loadMap_LevelFile(level);
      if (!loaded) {
        if (level === 1) loadMap_Level1();
        if (level === 2) loadMap_Level2();
        if (level === 3) loadMap_Level3();
        //if (level === 4) loadMap_Level4();
      }
    }
  }

  initializeLevelLights();
  saveInitialState(); // allow reset after death
}

function loadMap_EditorPreview() {
  const raw = localStorage.getItem('yt_editor_preview');
  if (!raw) return;
  let data = null;
  try {
    data = JSON.parse(raw);
  } catch (err) {
    console.error('Preview load failed:', err);
    return;
  }

  const objs = Array.isArray(data.objects) ? data.objects : [];
  applyEditorObjects(objs, true);
  // If preview payload contains waves, apply them
  if (Array.isArray(data.waves)) {
    G.wavesystem.currentMapWaves = data.waves;
    G.wavesystem.enabled = true;
    G.wavesystem.currentWave = 0;
    G.wavesystem.waveActive = false;
    G.wavesystem.spawnQueue = [];
    // populate waves editor UI if present (editor only)
    try { if (window.parent && window.parent.document) { /* noop */ } } catch(e){}
  }
}

function startTutorial() {
  hideAllMenus();
  document.getElementById('game').style.display = 'block';
  stopGameLoop();
  resetGameState();
  tutorialState.active = true;
  tutorialActive = true;
  tutorialState.completedZones.clear();
  tutorialState.completionShown = false;
  tutorialState.currentMessage = '';
  tutorialState.messageTimer = 0;
  startLevel(0);
  
}

function addMapBounds() {
  // Floor
  walls.push({ x: 0, y: MAP_HEIGHT - WALL_THICKNESS, width: MAP_WIDTH, height: 50, hidden: true });

  // Ceiling
  walls.push({ x: 0, y: -20, width: MAP_WIDTH, height: 50, hidden: true });

  // Left wall
  walls.push({ x: -20, y: 0, width: 50, height: MAP_HEIGHT, hidden: true });

  // Right wall
  walls.push({ x: MAP_WIDTH - WALL_THICKNESS, y: 0, width: 50, height: MAP_HEIGHT, hidden: true });
}

function loadMap_Tutorial() {
  TUTORIAL_TRIGGERS.length = 0;
  tutorialState.zoneSigns       = [];
  tutorialState.groundPaintings = [];
  tutorialState.zoneDividers    = [];
  tutorialState.checkpointArrows= [];
  tutorialState.museumLabels    = [];

  const WT = 20;
  const floorPlan = [
    { y: 1900, segments: [[40, MAP_WIDTH - 80]], ladderX: 2200, zone: 'move' },
    { y: 1650, segments: [[40, MAP_WIDTH - 80]], ladderX: 300,  zone: 'jump' },
    { y: 1400, segments: [[40, MAP_WIDTH - 80]], ladderX: 2200, zone: 'walljump' },
    { y: 1150, segments: [[40, 1160], [1380, MAP_WIDTH - 80 - 1380]], ladderX: 300, zone: 'dash' },
    { y: 900,  segments: [[40, MAP_WIDTH - 80]], ladderX: 2200, zone: 'sword' },
    { y: 650,  segments: [[40, MAP_WIDTH - 80]], ladderX: 300,  zone: 'museum' },
    { y: 400,  segments: [[40, MAP_WIDTH - 80]], ladderX: 2200, zone: 'hazards' },
    { y: 180,  segments: [[40, MAP_WIDTH - 80]], ladderX: null, zone: 'potato' },
  ];

  addMapBounds();

  for (const floor of floorPlan) {
    for (const [x, w] of floor.segments) {
      walls.push({ x, y: floor.y, width: w, height: WT });
    }
  }

  for (let i = 0; i < floorPlan.length - 1; i++) {
    const lower = floorPlan[i];
    const upper = floorPlan[i + 1];
    if (!lower.ladderX) continue;
    ladders.push({
      x: lower.ladderX,
      y: upper.y - 8,
      width: 30,
      height: (lower.y - upper.y) + 16
    });
  }

  const floorFillers = [
    { y: floorPlan[0].y - 120, segments: [[260, 160], [640, 140], [980, 160], [1400, 180], [1820, 160]] },
    { y: floorPlan[1].y - 110, segments: [[220, 140], [520, 160], [860, 140], [1200, 160], [1600, 160]] },
    { y: floorPlan[2].y - 120, segments: [[320, 120], [640, 140], [980, 140], [1360, 120], [1720, 140]] },
    { y: floorPlan[3].y - 120, segments: [[220, 140], [520, 160], [980, 120], [1560, 160], [2000, 140]] },
    { y: floorPlan[4].y - 120, segments: [[260, 160], [620, 140], [980, 160], [1380, 140], [1760, 160]] },
    { y: floorPlan[5].y - 120, segments: [[260, 140], [620, 140], [980, 140], [1340, 140], [1700, 140]] },
    { y: floorPlan[6].y - 110, segments: [[320, 160], [720, 140], [1100, 160], [1480, 140], [1880, 160]] },
    { y: floorPlan[7].y - 110, segments: [[260, 160], [620, 160], [980, 160], [1340, 160], [1760, 160]] },
  ];

  for (const filler of floorFillers) {
    for (const [x, w] of filler.segments) {
      walls.push({ x, y: filler.y, width: w, height: WT });
    }
  }

  // ── ZONE 1: MOVEMENT ──────────────────────────
  tutorialState.groundPaintings.push(
    { wx: 120, wy: floorPlan[0].y - 8, text: '← A / D / ARROWS →', font: 'bold 14px monospace', color: '#4fc3f7' }
  );
  tutorialState.zoneSigns.push({
    wx: 120, wy: floorPlan[0].y - 140, title: '[ ZONE 1 ]  MOVEMENT',
    lines: ['Press A / D or ← → to MOVE', 'Head for the ladder!'],
    color: '#4fc3f7', width: 240
  });
  tutorialState.checkpointArrows.push({ wx: floorPlan[0].ladderX - 40, wy: floorPlan[0].y - 60, dir: 'right', color: '#4fc3f7' });
  tutorialState.zoneDividers.push({ wx: floorPlan[0].ladderX - 20, wy: floorPlan[0].y - 260, height: 260, color: '#4fc3f7' });
  TUTORIAL_TRIGGERS.push({ x: 160, y: floorPlan[0].y - 200, w: 160, h: 200,
    zoneId: 'move', message: '✅ Zone 1 — You can MOVE!', color: '#4fc3f7' });

  // ── ZONE 2: JUMPING ───────────────────────────
  walls.push(
    { x: 320, y: floorPlan[1].y - 90, width: 120, height: WT },
    { x: 560, y: floorPlan[1].y - 170, width: 120, height: WT },
    { x: 820, y: floorPlan[1].y - 250, width: 120, height: WT }
  );
  tutorialState.groundPaintings.push(
    { wx: 120, wy: floorPlan[1].y - 8, text: 'JUMP →', font: 'bold 13px monospace', color: '#81c784' }
  );
  tutorialState.zoneSigns.push({
    wx: 120, wy: floorPlan[1].y - 130, title: '[ ZONE 2 ]  JUMPING',
    lines: ['Press W / ↑ to JUMP', 'Hop the steps upward.'],
    color: '#81c784', width: 230
  });
  tutorialState.checkpointArrows.push({ wx: floorPlan[1].ladderX + 20, wy: floorPlan[1].y - 60, dir: 'left', color: '#81c784' });
  tutorialState.zoneDividers.push({ wx: floorPlan[1].ladderX + 30, wy: floorPlan[1].y - 260, height: 260, color: '#81c784' });
  TUTORIAL_TRIGGERS.push({ x: 200, y: floorPlan[1].y - 200, w: 200, h: 200,
    zoneId: 'jump', message: '✅ Zone 2 — You can JUMP!', color: '#81c784' });

  // ── ZONE 3: WALL JUMP ─────────────────────────
  walls.push(
    { x: 1280, y: floorPlan[2].y - 300, width: 20, height: 300 },
    { x: 1460, y: floorPlan[2].y - 300, width: 20, height: 300 },
    { x: 1240, y: floorPlan[2].y - 320, width: 260, height: WT }
  );
  ladders.push({ x: 200, y: floorPlan[2].y - 320, width: 30, height: 320 });
  tutorialState.zoneSigns.push({
    wx: 1080, wy: floorPlan[2].y - 420, title: '[ ZONE 3 ]  WALL JUMP',
    lines: ['Hold INTO a wall to SLIDE.', 'Press W to WALL JUMP!', 'Climb the shaft.'],
    color: '#ffb74d', width: 245
  });
  tutorialState.checkpointArrows.push({ wx: 1360, wy: floorPlan[2].y - 60, dir: 'up', color: '#ffb74d' });
  tutorialState.zoneDividers.push({ wx: 1510, wy: floorPlan[2].y - 260, height: 260, color: '#ffb74d' });
  TUTORIAL_TRIGGERS.push({ x: 1320, y: floorPlan[2].y - 300, w: 120, h: 300,
    zoneId: 'walljump', message: '✅ Zone 3 — WALL JUMP mastered!', color: '#ffb74d' });

  // ── ZONE 4: DASH ──────────────────────────────
  tutorialState.groundPaintings.push(
    { wx: 120, wy: floorPlan[3].y - 8, text: '→ DASH!', font: 'bold 13px monospace', color: '#00e5ff' }
  );
  tutorialState.zoneSigns.push({
    wx: 120, wy: floorPlan[3].y - 130, title: '[ ZONE 4 ]  DASH',
    lines: ['Press SHIFT to DASH!', 'Cross the gap to the right.'],
    color: '#00e5ff', width: 230
  });
  tutorialState.checkpointArrows.push({ wx: 1220, wy: floorPlan[3].y - 60, dir: 'right', color: '#00e5ff' });
  tutorialState.zoneDividers.push({ wx: 1340, wy: floorPlan[3].y - 260, height: 260, color: '#00e5ff' });
  TUTORIAL_TRIGGERS.push({ x: 1120, y: floorPlan[3].y - 200, w: 160, h: 200,
    zoneId: 'dash', message: '✅ Zone 4 — You can DASH!', color: '#00e5ff' });

  // ── ZONE 5: SWORD ─────────────────────────────
  G.snails.push({ x: 520, y: floorPlan[4].y - 28, width: 28, height: 20,
    dx: 0, dy: 0, dir: 1, speed: 0.2, gravity: 0.6, chaseRange: 80,
    knockbackTimer: 0, knockbackDx: 0, knockbackDy: 0,
    hp: 2, maxHp: 2, hitFlash: 0, frame: 0, frameTimer: 0 });
  G.snails.push({ x: 720, y: floorPlan[4].y - 28, width: 28, height: 20,
    dx: 0, dy: 0, dir: -1, speed: 0.2, gravity: 0.6, chaseRange: 80,
    knockbackTimer: 0, knockbackDx: 0, knockbackDy: 0,
    hp: 2, maxHp: 2, hitFlash: 0, frame: 0, frameTimer: 0 });
  tutorialState.zoneSigns.push({
    wx: 120, wy: floorPlan[4].y - 150, title: '[ ZONE 5 ]  SWORD',
    lines: ['Press G to attack!', 'Practice on snails.'],
    color: '#f06292', width: 255
  });
  tutorialState.zoneDividers.push({ wx: 320, wy: floorPlan[4].y - 260, height: 260, color: '#f06292' });
  TUTORIAL_TRIGGERS.push({ x: 160, y: floorPlan[4].y - 200, w: 200, h: 200,
    zoneId: 'sword', message: '✅ Zone 5 — SWORD ATTACKS learned!', color: '#f06292' });

  // ── ZONE 6: ENEMY MUSEUM ──────────────────────
  const museumY = floorPlan[5].y;
  const museum = [
    { x: 360, label: '🐌 SNAIL',       desc: 'Ground patroller.\nChases, bounces off walls.',  color: '#69f0ae' },
    { x: 520, label: '💚 SUPER SNAIL', desc: 'Wall-climber! Jumps\nand crawls ceilings.',       color: '#00e676' },
    { x: 680, label: '🦇 BAT',         desc: 'Flies at you.\nSword it from any angle.',         color: '#b39ddb' },
    { x: 840, label: '🔴 TURRET',      desc: 'Fires G.fireballs in range.\nDestroy it with sword!', color: '#ef5350' },
    { x: 1000, label: '⛄ SNOWMAN',    desc: 'Emits a SLOW FIELD.\nStay back or use potato!',  color: '#e0f7fa' },
    { x: 1160, label: '🦣 YETI',       desc: 'Boss-tier. Throws\nsnowballs. Very tanky.',       color: '#e0e0e0' },
    { x: 1320, label: '🪑 CHAIR',      desc: 'Bouncy furniture enemy.\nKnockback sends it flying.', color: '#ffcc80' },
    { x: 1480, label: '🪵 TABLE',      desc: 'Heavy patroller. Hit it\nto trigger a dramatic FLIP!', color: '#c8922a' },
  ];
  for (const me of museum) {
    walls.push({ x: me.x, y: museumY - 45, width: 50, height: 45 });
    tutorialState.museumLabels.push({ wx: me.x, wy: museumY - 45, label: me.label, desc: me.desc, color: me.color, width: 50 });
  }
  G.chairs.push({ ...createChair(1325, museumY - 93), hp: 999, maxHp: 999, dx: 0, dy: 0, tutorialDisplay: true });
  G.tables.push({ ...createTable(1485, museumY - 101), hp: 999, maxHp: 999, dx: 0, dy: 0, tutorialDisplay: true });
  G.snails.push({ x: 365, y: museumY - 73, width: 28, height: 20, dx: 0, dy: 0, dir: 1,
    speed: 0, gravity: 0, chaseRange: 0, knockbackTimer: 0, knockbackDx: 0, knockbackDy: 0,
    hp: 999, maxHp: 999, hitFlash: 0, frame: 0, frameTimer: 0, tutorialDisplay: true});
  G.SuperSnails.push({ x: 525, y: museumY - 73, width: 28, height: 20, dx: 0, dy: 0,
    speed: 0, gravity: 0, dir: 1, jumpPower: 0, mode: 'ground',
    knockbackTimer: 0, knockbackDx: 0, knockbackDy: 0,
    jumpTimer: 99999, lastWallSide: null, prevMode: 'ground', hp: 999, maxHp: 999, hitFlash: 0, tutorialDisplay: true });
  G.bats.push({ x: 685, y: museumY - 115, width: 28, height: 20, dx: 0, dy: 0,
    hp: 999, maxHp: 999, hitFlash: 0, tutorialDisplay: true });
  G.turrets.push({ x: 848, y: museumY - 77, cooldown: 999999, fireRate: 999999,
    hp: 999, maxHp: 999, armed: false, tutorialDisplay: true });
  G.snowmen.push({ x: 1005, y: museumY - 83, width: 26, height: 38, speed: 0,
    slowRadius: 140, slowAmount: 1, dx: 0, facing: 1, flurryParticles: [],
    hp: 999, maxHp: 999, hitFlash: 0, tutorialDisplay: true });
  G.yetis.push({ x: 1165, y: museumY - 114, width: 48, height: 64, dx: 0, dy: 0,
    dead: false, speed: 0, chaseRange: 0, hp: 999, alive: true,
    throwCooldown: 999999, facing: 1, knockbackTimer: 0, knockbackDx: 0, knockbackDy: 0,
    maxHp: 999, hitFlash: 0, tutorialDisplay: true });
  tutorialState.zoneSigns.push({
    wx: 1680, wy: museumY - 230, title: '[ ZONE 6 ]  ENEMY MUSEUM',
    lines: ['These are your foes.', 'Read the labels!'],
    color: '#ce93d8', width: 260
  });
  tutorialState.zoneDividers.push({ wx: 1960, wy: museumY - 260, height: 260, color: '#ce93d8' });
  TUTORIAL_TRIGGERS.push({ x: 1700, y: museumY - 200, w: 200, h: 200,
    zoneId: 'museum', message: '✅ Zone 6 — ENEMIES identified!', color: '#ce93d8' });

  // ── ZONE 7: HAZARDS ───────────────────────────
  const hazardY = floorPlan[6].y;
  spikes.push(
    { x: 1180, y: hazardY - 26, width: 40, height: 26 },
    { x: 1220, y: hazardY - 26, width: 40, height: 26 },
    { x: 1260, y: hazardY - 26, width: 40, height: 26 },
    { x: 1300, y: hazardY - 26, width: 40, height: 26 },
    { x: 1340, y: hazardY - 26, width: 40, height: 26 }
  );
  walls.push({ x: 1180, y: hazardY - 120, width: 220, height: 14, moving: true, dir: 1, speed: 1.5, startX: 1180, range: 120 });
  G.turrets.push({ x: 2000, y: hazardY - 32, cooldown: 0, fireRate: 140,
    hp: 3, maxHp: 3, armed: true });
  tutorialState.zoneSigns.push({
    wx: 160, wy: hazardY - 200, title: '[ ZONE 7 ]  HAZARDS',
    lines: ['RED SPIKES = instant death!', 'Ride the moving platform.', 'Destroy the turret!'],
    color: '#ef9a9a', width: 252
  });
  tutorialState.zoneDividers.push({ wx: 420, wy: hazardY - 260, height: 260, color: '#ef9a9a' });
  TUTORIAL_TRIGGERS.push({ x: 200, y: hazardY - 200, w: 200, h: 200,
    zoneId: 'hazards', message: '✅ Zone 7 — HAZARDS survived!', color: '#ef9a9a' });

  // ── ZONE 8: POTATO CANNON ─────────────────────
  const potatoY = floorPlan[7].y;
  potato.x = 2600; potato.y = potatoY - 30;
  potato.collected = false;
  hasPotato = false;
  ovens.push({ x: 2700, y: potatoY - 60, width: 40, height: 50, active: true, baked: false, glow: 0 });
  G.snails.push({ x: 2480, y: potatoY - 28, width: 28, height: 20,
    dx: 0, dy: 0, dir: -1, speed: 0.4, gravity: 0.6, chaseRange: 200,
    knockbackTimer: 0, knockbackDx: 0, knockbackDy: 0,
    hp: 3, maxHp: 3, hitFlash: 0, frame: 0, frameTimer: 0 });
  tutorialState.zoneSigns.push({
    wx: 2200, wy: potatoY - 210, title: '[ ZONE 8 ]  POTATO CANNON 🥔',
    lines: ['Pick up the POTATO.', 'AIM with MOUSE, CLICK to fire.', 'Walk into the OVEN to BAKE', 'for EXPLOSIVE shots!'],
    color: '#ffd54f', width: 265
  });
  TUTORIAL_TRIGGERS.push({ x: 2400, y: potatoY - 200, w: 200, h: 200,
    zoneId: 'potato', message: '🥔 Zone 8 — Tutorial COMPLETE!', color: '#ffd54f' });

  // Zone lighting
  const zColors  = ['#4fc3f7','#81c784','#ffb74d','#00e5ff','#f06292','#ce93d8','#ef9a9a','#ffd54f'];
  const zXs      = [220, 260, 1200, 220, 220, 1800, 220, 2400];
  for (let i = 0; i < floorPlan.length; i++) {
    lights.push({ x: zXs[i], y: floorPlan[i].y - 20, radius: 280, intensity: 0.75,
      color: zColors[i], baseRadius: 280, baseIntensity: 0.75,
      flickerSpeed: 0.3 + i * 0.08, flickerAmount: 0.08 });
  }

  player.x = 80;
  player.y = floorPlan[7].y - 50;
}
    
//Debugging Map

function loadMap_Debug() {
  resetWorld();
  addMapBounds();

  const FLOOR = 500;

  // Main floor
  walls.push({ x: 0, y: FLOOR, width: 2800, height: 20 });

  // Platforms for testing specific mechanics
  walls.push({ x: 200, y: FLOOR - 120, width: 160, height: 20 }); // jump test
  walls.push({ x: 500, y: FLOOR - 300,  width: 200, height: 20 }); // seesaw platform
  walls.push({ x: 800, y: FLOOR,       width: 200, height: 20 }); // enemy test area
  walls.push(
    { x: 1100, y: FLOOR - 200, width: 120, height: 20, moving: true, dir: 1, speed: 2, startX: 1100, range: 150 }
  ); // moving platform test

  // Boxes for box physics tests
  boxes.push(createBox(400, FLOOR - 100, BOX_TYPE.BOUNCY));
  boxes.push(createBox(560, FLOOR - 100, BOX_TYPE.BREAKABLE));
  boxes.push(createBox(620, FLOOR - 100, BOX_TYPE.HEAVY));

  // Seesaw
  seesaws.push({ x: 500, y: FLOOR - 40, width: 200, height: 12, angle: 0, angularVelocity: 0 });

  // Spikes
  spikes.push({ x: 1400, y: FLOOR - 26, width: 40, height: 26 });
  spikes.push({ x: 1460, y: FLOOR - 26, width: 40, height: 26 });

  // Ladder
  ladders.push({ x: 1600, y: FLOOR - 200, width: 30, height: 200 });

  // Oven for potato test
  ovens.push({ x: 1800, y: FLOOR - 60, width: 40, height: 50, active: true, baked: false, glow: 0 });

  // Potato pickup
  potato.x = 1700;
  potato.y = FLOOR - 30;
  potato.collected = false;

  // Part inventory for build test
  partInventory.wall = 10;
  partInventory.bouncy = 5;
  partInventory.spike = 5;
  partInventory.body = 5;
  partInventory.wheel = 5;
  partInventory.engine = 3;
  partInventory.seat = 2;

  // Lights for the test area
  lights.push(
    { x: 400,  y: FLOOR - 100, radius: 300, color: "#aaddff", intensity: 0.6, baseRadius: 300, baseIntensity: 0.6, flickerSpeed: 0, flickerAmount: 0 },
    { x: 900,  y: FLOOR - 100, radius: 300, color: "#aaddff", intensity: 0.6, baseRadius: 300, baseIntensity: 0.6, flickerSpeed: 0, flickerAmount: 0 },
    { x: 1400, y: FLOOR - 100, radius: 300, color: "#aaddff", intensity: 0.6, baseRadius: 300, baseIntensity: 0.6, flickerSpeed: 0, flickerAmount: 0 },
    { x: 1900, y: FLOOR - 100, radius: 300, color: "#aaddff", intensity: 0.6, baseRadius: 300, baseIntensity: 0.6, flickerSpeed: 0, flickerAmount: 0 }
  );

  player.x = 100;
  player.y = FLOOR - 50;
}

function loadMap_Level1() {

  /* ------------------ WORLD BOUNDS ------------------ */
 addMapBounds();

  /* ------------------ MAIN GROUND PATH ------------------ */
    walls.push(
    { x: 30, y: 570, width: 580, height: 20 },
    { x: 700, y: 570, width: 500, height: 20 },
    { x: 1300, y: 570, width: 600, height: 20 },
    { x: 2000, y: 570, width: 700, height: 20 },
    { x: 2690, y: 570, width: 20, height: 1380 },

  );

    G.chairs.push(createChair(500, 540));
  G.chairs.push(createChair(1200, 540));
  /* ------------------ LOWER PLATFORMS ------------------ */
  walls.push(
    { x: 200, y: 450, width: 160, height: 20 },
    { x: 450, y: 380, width: 160, height: 20 },
    { x: 700, y: 310, width: 160, height: 20 },

    { x: 1100, y: 450, width: 180, height: 20 },
    { x: 1400, y: 380, width: 180, height: 20 },

    { x: 1800, y: 450, width: 200, height: 20 }
  );

  /* ------------------ VERTICAL CLIMB (CENTER) ------------------ */
  walls.push(
    { x: 950, y: 1500, width: 200, height: 20 },
    { x: 900, y: 1365, width: 200, height: 20 },
    { x: 1000, y: 1230, width: 200, height: 20 },
    { x: 900, y: 1000, width: 100, height: 20 },
    { x: 950, y: 1090, width: 200, height: 20 },
    { x: 1000, y: 900, width: 200, height: 20 }
  );
  
  boxes.push(createBox(300, 200, BOX_TYPE.BOUNCY));
boxes.push(createBox(350, 200, BOX_TYPE.BREAKABLE));
  boxes.push(createBox(350, 200, BOX_TYPE.HEAVY));
boxes.push(createBox(400, 200, BOX_TYPE.ICE));

  /* ------------------ MOVING PLATFORMS (LATE AREA) ------------------ */
  walls.push(
    { x: 1500, y: 1100, width: 120, height: 20, moving: true, dir: 1, speed: 2, startX: 1500, range: 200},
    { x: 1800, y: 970, width: 120, height: 20 }
  );

  /* ------------------ SEESAWS (INTENTIONAL) ------------------ */
  seesaws.push(
    {
      x: 500,
      y: 260,
      width: 160,
      height: 12,
      angle: 0,
      angularVelocity: 0
    },
      {
      x: 580,
      y: 500,
      width: 160,
      height: 12,
      angle: 0,
      angularVelocity: 0
    },
    { x: 950,
     y: 1665,
     width: 100,
     height: 12,
     angle: 0,
     angularVelocity: 0 },
    { x: 1150,
     y: 1720,
     width: 120,
     height: 12,
     angle: 0,
     angularVelocity: 0 },
    { x: 920,
     y: 1595,
     width: 120,
     height: 12,
     angle: 0,
     angularVelocity: 0 },
    {
      x: 1500,
      y: 320,
      width: 200,
      height: 12,
      angle: 0,
      angularVelocity: 0
    }
  );

  ovens.push(
  { x: 200, y: 840, width: 40, height: 50,  active: false, baked: false,  glow: 0 }
);

   G.turrets.push(
    { x: 100, y: 650, cooldown: 0, fireRate: 200 },
  );
  
  walls.push(
    { x: 500, y: 680, width: 120, height: 20, moving: true, dir: 1, speed: 2, startX: 500, range: 100},
    );
// === POTATO MODULE ===
let potato = {
  x: 2700,
  y: 1800,
  width: 20,
  height: 10,
  wobble: 0,
  collected: false,
  active: true
};

let hasPotato = false;

  /* ------------------ BOXES (PUZZLE / CHAOS) ------------------ */
boxes.push(
  createBox(220, 418, BOX_TYPE.NORMAL),
  createBox(260, 418, BOX_TYPE.NORMAL),
  createBox(520, 228, BOX_TYPE.NORMAL),
  createBox(960, 1468, BOX_TYPE.NORMAL),
  createBox(1000, 1468, BOX_TYPE.NORMAL),
  createBox(1820, 918, BOX_TYPE.NORMAL)
);

/* ------------------ LOW-THREAT FILL ------------------ */
boxes.push(
  createBox(950, 748, BOX_TYPE.NORMAL),
  createBox(1780, 788, BOX_TYPE.NORMAL)
);
  /* ------------------ G.snails (GROUND PRESSURE) ------------------ */
  G.snails.push(
    { x: 350, y: 540, width: 28, height: 20, dx: 0, dy: 0, dir: 1, speed: 0.7, gravity: 0.6, chaseRange: 400, knockbackTimer: 0, knockbackDx: 0, knockbackDy: 0, frame: 0,
  frameTimer: 0},
    { x: 850, y: 540, width: 28, height: 20, dx: 0, dy: 0, dir: -1, speed: 0.65, gravity: 0.6, chaseRange: 400, knockbackTimer: 0, knockbackDx: 0, knockbackDy: 0, frame: 0,
  frameTimer: 0 },
    { x: 1450, y: 540, width: 28, height: 20, dx: 0, dy: 0, dir: 1, speed: 0.55, gravity: 0.6, chaseRange: 400, knockbackTimer: 0, knockbackDx: 0, knockbackDy: 0, frame: 0,
  frameTimer: 0 }
  );
   

  /* ------------------ SUPER SNAIL (MID-LATE THREAT) ------------------ */
  G.SuperSnails.push({
    x: 1000,
    y: 870,
    width: 28,
    height: 20,
    dx: 0,
    dy: 0,
    speed: 1.8,
    gravity: 0.5,
    dir: 1,
    jumpPower: -14,
    mode: "ground",
    knockbackTimer: 0,
    knockbackDx: 0,
    knockbackDy: 0,
    jumpTimer: 0,
    lastWallSide: null,
    prevMode: "ground"
  });

  /* ------------------ G.turrets (CLEAR TELEGRAPHING) ------------------ */
  G.turrets.push(
    { x: 1200, y: 420, cooldown: 0, fireRate: 120 },
    { x: 1900, y: 880, cooldown: 0, fireRate: 150 }
  );

  /* ------------------ SPIKES (FAIR, AVOIDABLE) ------------------ */
  spikes.push(
    { x: 570, y: 544, width: 40, height: 26 },
    { x: 700, y: 544, width: 40, height: 26 },

    { x: 1550, y: 544, width: 40, height: 26 }
  );
  /* ------------------ RECOVERY LADDERS ------------------ */
ladders.push(
  // Left recovery
  { x: 110, y: 590, width: 39, height: 2050 },

  // Center recovery
  { x: 1100, y: 1750, width: 40, height: 350 }
);

  /* ------------------ MID-SPACE FILL PLATFORMS ------------------ */
walls.push(
  // Left air-fill
  { x: 150, y: 900, width: 140, height: 20 },
  { x: 350, y: 820, width: 140, height: 20 },

  // Center air-fill
  { x: 900, y: 780, width: 160, height: 20 },
  { x: 1150, y: 700, width: 160, height: 20 },

  // Right air-fill
  { x: 1750, y: 820, width: 180, height: 20 },
  { x: 2100, y: 740, width: 180, height: 20 }
);

  /* ------------------ FLOOR ROUTE STRUCTURE ------------------ */
walls.push(
  { x: 300, y: 1850, width: 300, height: 20 },
  { x: 800, y: 1750, width: 300, height: 20 },
  { x: 1300, y: 1680, width: 300, height: 20 },
  { x: 1700, y: 1580, width: 300, height: 20 },
  { x: 1300, y: 1520, width: 300, height: 20 }
);
/* ------------------ LOW-THREAT FILL ------------------ */
boxes.push(
  { x: 950, y: 748, width: 32, height: 32, dx: 0, dy: 0 },
  { x: 1780, y: 788, width: 32, height: 32, dx: 0, dy: 0 }
);

G.snails.push(
  {
    x: 2100,
    y: 1720,
    width: 28,
    height: 20,
    dx: 0,
    dy: 0,
    dir: -1,
    speed: 0.75,
    gravity: 0.6,
    chaseRange: 400,
    knockbackTimer: 0,
    knockbackDx: 0,
    knockbackDy: 0,
    frame: 0,
    frameTimer: 0
  }
);

// === G.tables — placed on wide platforms in Level 1 ===
G.tables.push(
  createTable(420, 540),   // on the main floor — early encounter
  createTable(1100, 660),  // on a mid-air ledge
  createTable(1780, 790),  // right side
  createTable(700, 1740),  // lower route
);

}

function loadMap_Level2() {
  walls = [];
  G.turrets = [];
  seesaws = [];
  boxes = [];
  G.snails = [];
  G.SuperSnails = [];
  spikes = [];
  ladders = [];
  G.chairs = [];
  G.tables = [];
  G.babyMicrowaves = [];
  addMapBounds();

  // ── Level: Spikes and Moving ── (generated by Level Editor)
// Paste inside your startLevel / wave function after clearing arrays

walls.push(
  { x: 1740, y: 1388, width: 150, height: 20 },
  { x: 1824, y: 976, width: 100, height: 20 },
  { x: 1736, y: 976, width: 52, height: 20 }
);

walls.push(
  { x: 420, y: 460, width: 500, height: 20, moving: true, dir: 1, speed: 3, startX: 420, range: 100 },
  { x: 30, y: 420, width: 200, height: 20, moving: true, dir: 1, speed: 1.1, startY: 420, range: 300 },
  { x: 1824, y: 1168, width: 24, height: 80, moving: true, dir: -1, speed: 1.5, startX: 1824, range: 50 },
  { x: 1760, y: 1088, width: 24, height: 80, moving: true, dir: 1, speed: 1.5, startX: 1760, range: 50 },
  { x: 1824, y: 1008, width: 24, height: 80, moving: true, dir: -1, speed: 1.5, startX: 1824, range: 50 },
  { x: 1760, y: 1252, width: 24, height: 80, moving: true, dir: 1, speed: 1.5, startX: 1760, range: 50 },
  { x: 408, y: 580, width: 24, height: 328, moving: true, dir: 1, speed: 1.5, startX: 408, range: 100 },
  { x: 1284, y: 748, width: 16, height: 368, moving: true, dir: 1, speed: 2.5, startY: 748, range: 100 },
  { x: 576, y: 1108, width: 472, height: 20, moving: true, dir: 1, speed: 1, startX: 576, range: 100 },
  { x: 1648, y: 520, width: 140, height: 20, moving: true, dir: 1, speed: 1.5, startX: 1648, range: 100 },
  { x: 1350, y: 2024, width: 152, height: 20, moving: true, dir: 1, speed: 3.5, startX: 1350, range: 1350 },
  { x: 516, y: 1788, width: 356, height: 20, moving: true, dir: 1, speed: 1.5, startX: 516, range: 100 },
  { x: 2520, y: 1604, width: 20, height: 400, moving: true, dir: 1, speed: 1.5, startX: 2520, range: 100 },
  { x: 2442, y: 1604, width: 20, height: 400, moving: true, dir: 1, speed: 1.5, startX: 2442, range: 100 },
  { x: 2196, y: 1604, width: 168, height: 20, moving: true, dir: 1, speed: 1.7, startX: 2196, range: 200 }
);

spikes.push(
  { x: 0, y: 2044, width: 40, height: 26 },
  { x: 40, y: 2044, width: 40, height: 26 },
  { x: 80, y: 2044, width: 40, height: 26 },
  { x: 200, y: 2044, width: 40, height: 26 },
  { x: 160, y: 2044, width: 40, height: 26 },
  { x: 120, y: 2044, width: 40, height: 26 },
  { x: 240, y: 2044, width: 40, height: 26 },
  { x: 360, y: 2044, width: 40, height: 26 },
  { x: 320, y: 2044, width: 40, height: 26 },
  { x: 280, y: 2044, width: 40, height: 26 },
  { x: 400, y: 2044, width: 40, height: 26 },
  { x: 600, y: 2044, width: 40, height: 26 },
  { x: 480, y: 2044, width: 40, height: 26 },
  { x: 680, y: 2044, width: 40, height: 26 },
  { x: 520, y: 2044, width: 40, height: 26 },
  { x: 560, y: 2044, width: 40, height: 26 },
  { x: 640, y: 2044, width: 40, height: 26 },
  { x: 440, y: 2044, width: 40, height: 26 },
  { x: 1120, y: 2044, width: 40, height: 26 },
  { x: 1240, y: 2044, width: 40, height: 26 },
  { x: 1160, y: 2044, width: 40, height: 26 },
  { x: 1280, y: 2044, width: 40, height: 26 },
  { x: 1320, y: 2044, width: 40, height: 26 },
  { x: 840, y: 2044, width: 40, height: 26 },
  { x: 800, y: 2044, width: 40, height: 26 },
  { x: 760, y: 2044, width: 40, height: 26 },
  { x: 720, y: 2044, width: 40, height: 26 },
  { x: 880, y: 2044, width: 40, height: 26 },
  { x: 960, y: 2044, width: 40, height: 26 },
  { x: 920, y: 2044, width: 40, height: 26 },
  { x: 1000, y: 2044, width: 40, height: 26 },
  { x: 1200, y: 2044, width: 40, height: 26 },
  { x: 1080, y: 2044, width: 40, height: 26 },
  { x: 1040, y: 2044, width: 40, height: 26 },
  { x: 1400, y: 2044, width: 40, height: 26 },
  { x: 1560, y: 2044, width: 40, height: 26 },
  { x: 1520, y: 2044, width: 40, height: 26 },
  { x: 1480, y: 2044, width: 40, height: 26 },
  { x: 1720, y: 2044, width: 40, height: 26 },
  { x: 1680, y: 2044, width: 40, height: 26 },
  { x: 1640, y: 2044, width: 40, height: 26 },
  { x: 1600, y: 2044, width: 40, height: 26 },
  { x: 1440, y: 2044, width: 40, height: 26 },
  { x: 1360, y: 2044, width: 40, height: 26 },
  { x: 1760, y: 2044, width: 40, height: 26 },
  { x: 1800, y: 2044, width: 40, height: 26 },
  { x: 1840, y: 2044, width: 40, height: 26 },
  { x: 1880, y: 2044, width: 40, height: 26 },
  { x: 1920, y: 2044, width: 40, height: 26 },
  { x: 1960, y: 2044, width: 40, height: 26 },
  { x: 2000, y: 2044, width: 40, height: 26 },
  { x: 2040, y: 2044, width: 40, height: 26 },
  { x: 2080, y: 2044, width: 40, height: 26 },
  { x: 2120, y: 2044, width: 40, height: 26 },
  { x: 2160, y: 2044, width: 40, height: 26 },
  { x: 2200, y: 2044, width: 40, height: 26 },
  { x: 2240, y: 2044, width: 40, height: 26 },
  { x: 2280, y: 2044, width: 40, height: 26 },
  { x: 2320, y: 2044, width: 40, height: 26 },
  { x: 2360, y: 2044, width: 40, height: 26 },
  { x: 2400, y: 2044, width: 40, height: 26 },
  { x: 2440, y: 2044, width: 40, height: 26 },
  { x: 2480, y: 2044, width: 40, height: 26 },
  { x: 2520, y: 2044, width: 40, height: 26 },
  { x: 2560, y: 2044, width: 40, height: 26 },
  { x: 2600, y: 2044, width: 40, height: 26 },
  { x: 2640, y: 2044, width: 40, height: 26 },
  { x: 2680, y: 2044, width: 40, height: 26 },
  { x: 2720, y: 2044, width: 40, height: 26 },
  { x: 2760, y: 2044, width: 40, height: 26 }
);

ladders.push(
  { x: 1788, y: 976, width: 36, height: 412 }
);

seesaws.push(
  { x: 336, y: 376, width: 150, height: 8, angle: 0, angularVelocity: 0 },
  { x: 1240, y: 576, width: 120, height: 8, angle: 0, angularVelocity: 0 },
  { x: 2092, y: 1108, width: 152, height: 12, angle: 0, angularVelocity: 0 }

  );
}

function loadMap_Level3() {
  walls = [];
  G.turrets = [];
  seesaws = [];
  boxes = [];
  G.snails = [];
  G.SuperSnails = [];
  spikes = [];
  G.icicles = [];
  G.tables = [];
  G.babyMicrowaves = [];

walls.push({ x: 0, y: 0, width: 2800, height: 30, ice: true },
{ x: 0, y: 0, width: 30, height: 2100, ice: true },
{ x: 0, y: 2070, width: 2800, height: 30, ice: true },{ x: 2770, y: 0, width: 30, height:2100, ice: true },
);
  // --- VERTICAL CLIMB ---
// Long icy floor
walls.push({ x: 200, y: 1350, width: 1800, height: 30, ice: true });

// Raised icy ledges
walls.push({ x: 300, y: 1200, width: 200, height: 25, ice: true });
walls.push({ x: 600, y: 1150, width: 200, height: 25, ice: true });
walls.push({ x: 900, y: 1100, width: 200, height: 25, ice: true });
walls.push({ x: 1200, y: 1050, width: 200, height: 25, ice: true });
walls.push({ x: 1500, y: 1000, width: 200, height: 25, ice: true });

walls.push({ x: 80, y: 1300, width: 120, height: 20, ice: true });
walls.push({ x: 80, y: 1220, width: 120, height: 20, ice: true });
walls.push({ x: 80, y: 1140, width: 120, height: 20, ice: true });
walls.push({ x: 80, y: 1060, width: 120, height: 20, ice: true });
walls.push({ x: 80, y: 980, width: 120, height: 20, ice: true });

  // --- SEESAW GAUNTLET ---
  seesaws.push(
    { x: 450, y: 1550, width: 200, height: 12, angle: 0, angularVelocity: 0 },
    { x: 800, y: 1400, width: 200, height: 12, angle: 0, angularVelocity: 0 },
    { x: 1150, y: 1250, width: 200, height: 12, angle: 0, angularVelocity: 0 }
  );

  // --- ENEMIES ---
  G.yetis.push({
  x: 1200,
  y: 1250,
  width: 48,
  height: 64,

  dx: 0,
  dy: 0,

  dead: false,
  speed: 1.2,
  chaseRange: 500,

  hp: 5,
  alive: true,

  throwCooldown: 0,
  facing: 1, // 1 = right, -1 = left
   
  knockbackTimer: 0,
  knockbackDx: 0,
  knockbackDy: 0
});

  G.snails.push(
    {
      x: 750, y: 1430, width: 32, height: 24,
      dx: 0, dy: 0, dir: 1, speed: 0.9,
      chaseRange: 500, gravity: 0.6,
      knockbackTimer: 0, knockbackDx: 0, knockbackDy: 0, frame: 0,
  frameTimer: 0
    }
  );

  G.SuperSnails.push(
    {
      x: 1450, y: 980, width: 28, height: 20,
      dx: 0, dy: 0, speed: 2.1, gravity: 0.6,
      dir: -1, jumpPower: -15, mode: "ground",
      knockbackTimer: 0, knockbackDx: 0, knockbackDy: 0,
      jumpTimer: 0, lastWallSide: null, prevMode: "ground"
    }
  );

  // --- TURRET PRESSURE ---
  G.turrets.push(
    { x: 1650, y: 870, cooldown: 0, fireRate: 90 },
    { x: 150, y: 1600, cooldown: 0, fireRate: 90 },
    { x: 1050, y: 2000, cooldown: 0, fireRate: 90 }
  );
 
  G.snowmen.push(
   { x: 1000,
    y: 1000,
    width: 26,
    height: 38,
    speed: 0.6,
    slowRadius: 140,
    slowAmount: 0.45, // 45% speed
    dx: 0,
    facing: 1,
    flurryParticles: []
   }
);

  G.icicles.push (
{
  x: 900,
  y: 30,          // ceiling position
  startY: 30,     // respawn anchor
  width: 12,
  height: 24,
  dy: 0,
  falling: false,
  active: true,
  respawnTimer: 0
},
  {
  x: 600,
  y: 30,          // ceiling position
  startY: 30,     // respawn anchor
  width: 12,
  height: 24,
  dy: 0,
  falling: false,
  active: true,
  respawnTimer: 0
},
{
  x: 1000,
  y: 1383,          // ceiling position
  startY: 1383,     // respawn anchor
  width: 12,
  height: 24,
  dy: 0,
  falling: false,
  active: true,
  respawnTimer: 0
});
}

/*function loadMap_Level4() {
 addMapBounds();

        }*/
async function startLevel(level) {
  hideAllMenus();
  document.getElementById("game").style.display = "block";
  
  // Show loading screen before any async operations
  showLoadingScreen();
  
  stopGameLoop();   // stop old loop
  resetGameState(); // reset player & flags
  
  updateLoadingProgress(0.1);
  
  initAtmosphericParticles();
  initDungeonLighting();
  
  updateLoadingProgress(0.3);
  
  await loadLevel(level); // THIS is now the only loader
  
  updateLoadingProgress(0.6);
  
  initDungeonAesthetics();
  if (level === 0) tutorialActive = true;
  startMusic();
  
  updateLoadingProgress(0.9);
  
  // All async operations complete — NOW we start the game
  gameRunning = true;
  gamePaused = false;
  lastFrameTime = performance.now();
  lastTimestamp = performance.now();
  
  updateLoadingProgress(1);
  
  // Hide loading screen and start game loop
  hideLoadingScreen();
  gameLoopId = requestAnimationFrame(gameLoop);
}

function startEditorPreview() {
  hideAllMenus();
  document.getElementById("game").style.display = "block";
  stopGameLoop();
  resetGameState();
  tutorialActive = false;
  startLevel(1);
}

if (editorPreviewMode) {
  window.addEventListener('load', () => {
    finishIntro();
    startEditorPreview();
  });
}

canvas.width = 800;
canvas.height = 600;

const gravity = 0.6;


const BOX_TYPE = {
  NORMAL: "normal",
  BOUNCY: "bouncy",
  BREAKABLE: "breakable",
  HEAVY: "heavy",
  ICE: "ice"
};

// === OFF-SCREEN ENEMY INDICATORS ===

const ENEMY_COLORS = {
  snail: "#5b3",      // green
  superSnail: "#4dff68", // bright green
  bat: "#6b4c8a",     // purple
  yeti: "#eef",       // white
  snowman: "#fff",    // white
  babyMicrowave: "#ff9ec7",
  turret: "#f44",     // red
  table: "#c8922a"    // oak brown
};

function drawOffScreenIndicators() {
  if (!G.wavesystem.enabled || !G.wavesystem.waveActive) return;
  if (!settings.offScreenIndicators) return;
  ctx.save();
  
  // Get all alive enemies
const allEnemies = [
    ...G.snails.map(e => ({ e, list: G.snails, key: 'snail' })),
    ...G.SuperSnails.map(e => ({ e, list: G.SuperSnails, key: 'superSnail' })),
    ...G.yetis.filter(y => y.alive).map(e => ({ e, list: null, key: 'yeti' })),
    ...G.snowmen.map(e => ({ e, list: G.snowmen, key: 'snowman' })),
    ...G.turrets.map(e => ({ e, list: G.turrets, key: 'turret' })),
    ...G.chairs.map(e => ({ e, list: G.chairs, key: 'chair' })),
    ...G.tables.map(e => ({ e, list: G.tables, key: 'table' })),
    ...G.bats.map(e => ({ e, list: G.bats, key: 'bat' })),
  ];
  
  for (let enemy of allEnemies) {
    const enemyScreenX = enemy.e.x - camera.x;
    const enemyScreenY = enemy.e.y - camera.y;
    
    // Check if enemy is off-screen
    const offScreen = 
      enemyScreenX < -50 || 
      enemyScreenX > canvas.width + 50 ||
      enemyScreenY < -50 ||
      enemyScreenY > canvas.height + 50;
    
    if (!offScreen) continue;
    
    // Calculate arrow position at screen edge
    const margin = 30;
    
    // Clamp to screen edges
    const arrowX = Math.max(margin, Math.min(canvas.width - margin, enemyScreenX));
    const arrowY = Math.max(margin, Math.min(canvas.height - margin, enemyScreenY));
    
    // Calculate angle from arrow position toward the enemy
    const dx = enemyScreenX - arrowX;
    const dy = enemyScreenY - arrowY;
    const angle = Math.atan2(dy, dx);
    
    // Draw arrow
    const color = ENEMY_COLORS[enemy.key] || "#fff";
    
    ctx.save();
    ctx.translate(arrowX, arrowY);
    ctx.rotate(angle);
    
    // Arrow body (triangle)
    ctx.fillStyle = color;
    ctx.beginPath();
    ctx.moveTo(15, 0);      // tip
    ctx.lineTo(-10, -8);    // top back
    ctx.lineTo(-10, 8);     // bottom back
    ctx.closePath();
    ctx.fill();
    
    // Arrow outline
    ctx.strokeStyle = "#000";
    ctx.lineWidth = 2;
    ctx.stroke();
    
    // Glow effect
    ctx.shadowColor = color;
    ctx.shadowBlur = 10;
    ctx.fill();
    
    ctx.restore();
    
    // Distance text
    const distance = Math.sqrt(
      Math.pow(enemy.e.x - player.x, 2) + 
      Math.pow(enemy.e.y - player.y, 2)
    );
    
    ctx.fillStyle = color;
    ctx.strokeStyle = "#000";
    ctx.lineWidth = 3;
    ctx.font = "bold 12px Arial";
    ctx.textAlign = "center";
    
    const distText = Math.floor(distance);
    ctx.strokeText(distText, arrowX, arrowY - 20);
    ctx.fillText(distText, arrowX, arrowY - 20);
  }
  
  ctx.restore();
}

// Enhanced box creation
function createBox(x, y, type = BOX_TYPE.NORMAL, width = 32, height = 32) {
  let box = {
    x: x,
    y: y,
    width: width,
    height: height,
    dx: 0,
    dy: 0,
    type: type,
    
    // Type-specific properties
    hp: type === BOX_TYPE.BREAKABLE ? 3 : Infinity,
    maxHp: type === BOX_TYPE.BREAKABLE ? 3 : Infinity,
    hitFlash: 0,
    
    bounciness: type === BOX_TYPE.BOUNCY ? 1 : 0.1,
    friction: type === BOX_TYPE.ICE ? 0.99 : 
              type === BOX_TYPE.HEAVY ? 0.7 : 0.9,
    gravityMultiplier: type === BOX_TYPE.HEAVY ? 1.5 : 1.0,
    
    broken: false
  };
  
  return box;
}

function tryDropPart(x, y) {
  // Building parts from boxes
  const buildTypes = ["bouncy", "spike", "wall"];
  // Vehicle parts from enemies and boxes
  const vehicleTypes = ["body", "wheel", "engine", "seat"];

  const allTypes = [...buildTypes, ...buildTypes, ...buildTypes, ...vehicleTypes];
  // Build parts are 3x more common than vehicle parts

  const dropCount = Math.random() < 0.3 ? 2 : Math.random() < 0.6 ? 1 : 0;
  for (let i = 0; i < dropCount; i++) {
    const type = allTypes[Math.floor(Math.random() * allTypes.length)];
    droppedParts.push({
      x: x + (Math.random() - 0.5) * 30,
      y: y - 10,
      dy: -3 - Math.random() * 2,
      width: 20,
      height: 20,
      type,
      landed: false
    });
  }
}

function updateDroppedParts() {
  for (let i = droppedParts.length - 1; i >= 0; i--) {
    const p = droppedParts[i];

    if (!p.landed) {
      p.dy += 0.4;
      p.y += p.dy;
      if (collidesWithWall(p.x, p.y, p.width, p.height)) {
        p.dy = 0;
        p.landed = true;
      }
    }

    // Player picks it up
    if (isColliding(p, player)) {
      partInventory[p.type]++;
      potatoMessage = `+1 ${PART_TYPES[p.type].label}`;
      potatoMessageTimer = 60;
      droppedParts.splice(i, 1);
    }
  }
}

function drawDroppedParts() {
  for (const p of droppedParts) {
    const pt = PART_TYPES[p.type];
    ctx.save();
    ctx.fillStyle = pt.color;
    ctx.strokeStyle = "#fff";
    ctx.lineWidth = 1.5;
    ctx.fillRect(p.x, p.y, p.width, p.height);
    ctx.strokeRect(p.x, p.y, p.width, p.height);
    // icon
    ctx.font = "12px Arial";
    ctx.textAlign = "center";
    ctx.fillStyle = "#fff";
    ctx.fillText(pt.label.split(" ")[0], p.x + p.width / 2, p.y + p.height / 2 + 4);
    ctx.textAlign = "left";
    ctx.restore();

    // Bobbing label
    const bob = Math.sin(performance.now() * 0.004 + p.x) * 4;
    ctx.fillStyle = "#fff";
    ctx.font = "10px monospace";
    ctx.textAlign = "center";
    ctx.fillText(pt.label, p.x + p.width / 2, p.y - 6 + bob);
    ctx.textAlign = "left";
  }
}


function updateBuildMode() {
  if (!buildMode) return;

  // Keyboard part selection
  for (const [type, data] of Object.entries(PART_TYPES)) {
    if (keys[data.key]) buildSelectedPart = type;
  }
  buildDeleteMode = isActionPressed("buildDelete");

 // Mouse cursor — only when no controller is connected
  if (gamepadIndex === null) {
    buildCursor.wx = Math.floor((mouse.x + camera.x) / BUILD_CELL) * BUILD_CELL;
    buildCursor.wy = Math.floor((mouse.y + camera.y) / BUILD_CELL) * BUILD_CELL;
  }
  
  // Controller cursor movement
  // Controller cursor movement
  if (gamepadIndex !== null) {
    const gp = navigator.getGamepads()[gamepadIndex];
    if (gp) {
      const DEAD = settings.joystickDeadzone;

      if (!gp._buildCursorCooldown) gp._buildCursorCooldown = 0;
      if (gp._buildCursorCooldown > 0) {
        gp._buildCursorCooldown--;
      } else {
        const axisX = gp.axes[0];
        const axisY = gp.axes[1];
        if (axisX > DEAD || gp.buttons[15]?.pressed) {
          buildCursor.wx += BUILD_CELL;
          gp._buildCursorCooldown = 8;
        } else if (axisX < -DEAD || gp.buttons[14]?.pressed) {
          buildCursor.wx -= BUILD_CELL;
          gp._buildCursorCooldown = 8;
        }
        if (axisY > DEAD || gp.buttons[13]?.pressed) {
          buildCursor.wy += BUILD_CELL;
          gp._buildCursorCooldown = 8;
        } else if (axisY < -DEAD || gp.buttons[12]?.pressed) {
          buildCursor.wy -= BUILD_CELL;
          gp._buildCursorCooldown = 8;
        }
      }

      // Clamp to world
      buildCursor.wx = Math.max(0, Math.min(world.width  - BUILD_CELL, buildCursor.wx));
      buildCursor.wy = Math.max(0, Math.min(world.height - BUILD_CELL, buildCursor.wy));

      // A = place, B = delete, bumpers = cycle parts
      const partKeys = Object.keys(PART_TYPES);
      if (gp.buttons[4]?.pressed && !gp._buildLBHeld) {
        const idx = partKeys.indexOf(buildSelectedPart);
        buildSelectedPart = partKeys[(idx - 1 + partKeys.length) % partKeys.length];
        gp._buildLBHeld = true;
      }
      if (!gp.buttons[4]?.pressed) gp._buildLBHeld = false;

      if (gp.buttons[5]?.pressed && !gp._buildRBHeld) {
        const idx = partKeys.indexOf(buildSelectedPart);
        buildSelectedPart = partKeys[(idx + 1) % partKeys.length];
        gp._buildRBHeld = true;
      }
      if (!gp.buttons[5]?.pressed) gp._buildRBHeld = false;

      if (gp.buttons[0]?.pressed && !gp._buildPlaceHeld) {
        placeBuildPart(buildCursor.wx, buildCursor.wy);
        gp._buildPlaceHeld = true;
      }
      if (!gp.buttons[0]?.pressed) gp._buildPlaceHeld = false;

      if (gp.buttons[1]?.pressed && !gp._buildDeleteHeld) {
        deleteBuildPart(buildCursor.wx, buildCursor.wy);
        gp._buildDeleteHeld = true;
      }
      if (!gp.buttons[1]?.pressed) gp._buildDeleteHeld = false;

      // Y = skip wave
      if (gp.buttons[3]?.pressed && !gp._buildCloseHeld) {
        finishBuildModeForShopping();
        gp._buildCloseHeld = true;
      }
      if (!gp.buttons[3]?.pressed) gp._buildCloseHeld = false;
    }
  }
}

function drawBuildMode() {
  if (!buildMode) return;

  // Dim overlay
  ctx.fillStyle = "rgba(0,0,20,0.55)";
  ctx.fillRect(0, 0, canvas.width, canvas.height);

  // Grid lines (visible portion only)
  ctx.strokeStyle = "rgba(255,255,255,0.07)";
  ctx.lineWidth = 1;
  const startX = Math.floor(camera.x / BUILD_CELL) * BUILD_CELL;
  const startY = Math.floor(camera.y / BUILD_CELL) * BUILD_CELL;
  for (let x = startX; x < camera.x + canvas.width; x += BUILD_CELL) {
    ctx.beginPath();
    ctx.moveTo(x - camera.x, 0);
    ctx.lineTo(x - camera.x, canvas.height);
    ctx.stroke();
  }
  for (let y = startY; y < camera.y + canvas.height; y += BUILD_CELL) {
    ctx.beginPath();
    ctx.moveTo(0, y - camera.y);
    ctx.lineTo(canvas.width, y - camera.y);
    ctx.stroke();
  }

  // Draw placed structures
  for (const s of placedStructures) {
    const pt = PART_TYPES[s.type];
    const sx = s.wx - camera.x;
    const sy = s.wy - camera.y;
    ctx.fillStyle = pt.color + "cc";
    ctx.strokeStyle = pt.color;
    ctx.lineWidth = 2;
    ctx.fillRect(sx, sy, BUILD_CELL, BUILD_CELL);
    ctx.strokeRect(sx, sy, BUILD_CELL, BUILD_CELL);
    ctx.font = "18px Arial";
    ctx.textAlign = "center";
    ctx.fillStyle = "#fff";
    ctx.fillText(pt.label.split(" ")[0], sx + BUILD_CELL / 2, sy + BUILD_CELL / 2 + 6);
    ctx.textAlign = "left";
  }

  // Ghost cursor
  const pt = PART_TYPES[buildSelectedPart];
  const gx = buildCursor.wx - camera.x;
  const gy = buildCursor.wy - camera.y;
  const hasStock = partInventory[buildSelectedPart] > 0;
  ctx.globalAlpha = 0.5;
  ctx.fillStyle = hasStock ? pt.color : "#f00";
  ctx.fillRect(gx, gy, BUILD_CELL, BUILD_CELL);
  ctx.globalAlpha = 1;
  ctx.strokeStyle = hasStock ? "#fff" : "#f00";
  ctx.lineWidth = 2;
  ctx.strokeRect(gx, gy, BUILD_CELL, BUILD_CELL);

  // HUD panel — bottom of screen
  ctx.fillStyle = "rgba(0,0,0,0.85)";
  ctx.fillRect(0, canvas.height - 64, canvas.width, 64);

  // Part buttons
  const partKeys = Object.keys(PART_TYPES);
  const btnW = 90;
  const totalW = btnW * partKeys.length + 8 * (partKeys.length - 1);
  const startBtnX = (canvas.width - totalW) / 2;

  for (let i = 0; i < partKeys.length; i++) {
    const key = partKeys[i];
    const pdata = PART_TYPES[key];
    const bx = startBtnX + i * (btnW + 8);
    const by = canvas.height - 58;
    const selected = key === buildSelectedPart;

    ctx.fillStyle = selected ? pdata.color : "#222";
    ctx.strokeStyle = selected ? "#fff" : "#555";
    ctx.lineWidth = selected ? 2 : 1;
    ctx.fillRect(bx, by, btnW, 50);
    ctx.strokeRect(bx, by, btnW, 50);

    ctx.fillStyle = "#fff";
    ctx.font = "bold 11px monospace";
    ctx.textAlign = "center";
    ctx.fillText(pdata.label, bx + btnW / 2, by + 18);
    ctx.fillStyle = partInventory[key] > 0 ? "#0f0" : "#f44";
    ctx.fillText(`x${partInventory[key]}`, bx + btnW / 2, by + 36);
    ctx.fillStyle = "#888";
    ctx.font = "10px monospace";
    ctx.fillText(`[${pdata.key}]`, bx + btnW / 2, by + 48);
    ctx.textAlign = "left";
  }

// Build mode instructions
ctx.fillStyle = "#ffd54f";
ctx.font = "bold 13px monospace";
ctx.textAlign = "center";
ctx.fillText("🧱 Build mode: finish build to start 60s shop time", canvas.width / 2, canvas.height - 122);

// ✅ SKIP BUTTON
const skipBtnW = 140;
const skipBtnX = canvas.width - skipBtnW - 12;
const skipBtnY = canvas.height - 116;
ctx.fillStyle = "#c03030";
ctx.strokeStyle = "#ff4444";
ctx.lineWidth = 2;
ctx.fillRect(skipBtnX, skipBtnY, skipBtnW, 50);
ctx.strokeRect(skipBtnX, skipBtnY, skipBtnW, 50);
ctx.fillStyle = "#fff";
ctx.font = "bold 12px monospace";
ctx.fillText("✓ FINISH BUILD", skipBtnX + skipBtnW / 2, skipBtnY + 30);
ctx.textAlign = "left";
}

// Mobile part selector buttons — drawn in screen space outside camera transform
function drawBuildMobileButtons() {
  if (!buildMode) return;
  // These are handled in the HUD panel drawn in drawBuildMode above
  // Mobile users tap the bottom panel to select, then tap canvas to place
  const partKeys = Object.keys(PART_TYPES);
  const btnW = 90;
  const startBtnX = (canvas.width - (btnW * partKeys.length + 8 * (partKeys.length - 1))) / 2;

  for (let i = 0; i < partKeys.length; i++) {
    const bx = startBtnX + i * (btnW + 8);
    const by = canvas.height - 116;
    // Touch detection for part selection buttons
    // (handled via touchstart listener below)
  }
}

function placeBuildPart(wx, wy) {
  if (partInventory[buildSelectedPart] <= 0) {
    potatoMessage = `🧱 no ${PART_TYPES[buildSelectedPart].label} left`;
    potatoMessageTimer = 60;
    return;
  }

  // Don't stack on existing structure
  const existing = placedStructures.find(s => s.wx === wx && s.wy === wy);
  if (existing) return;

  partInventory[buildSelectedPart]--;
  placedStructures.push({
    wx, wy,
    type: buildSelectedPart,
    x: wx, y: wy,
    width: BUILD_CELL, height: BUILD_CELL
  });

  // Register as a wall or spike immediately
  applyStructureToWorld(placedStructures[placedStructures.length - 1]);
}

function deleteBuildPart(wx, wy) {
  const idx = placedStructures.findIndex(s => s.wx === wx && s.wy === wy);
  if (idx === -1) return;

  const s = placedStructures[idx];
  partInventory[s.type]++;            // refund the part
  removeStructureFromWorld(s);
  placedStructures.splice(idx, 1);
}

function applyStructureToWorld(s) {
  if (s.type === "wall") {
    // Tag it so we can find and remove it later
    const wall = { x: s.wx, y: s.wy, width: BUILD_CELL, height: BUILD_CELL, isBuilt: true, structureRef: s };
    walls.push(wall);
    s._wallRef = wall;
  }
  if (s.type === "spike") {
    const spike = { x: s.wx, y: s.wy + BUILD_CELL - 26, width: BUILD_CELL, height: 26, isBuilt: true, structureRef: s };
    spikes.push(spike);
    s._spikeRef = spike;
  }
  if (s.type === "bouncy") {
    // Handled in updatePlacedStructures
  }
}

function drawPlacedStructures() {
  for (const s of placedStructures) {
    if (s.type === "wall" || s.type === "spike") continue;
    // walls/spikes/platforms already draw via the walls/spikes arrays
    // only bouncy needs a manual draw here
    const pt = PART_TYPES[s.type];
    ctx.fillStyle = pt.color + "cc";
    ctx.strokeStyle = pt.color;
    ctx.lineWidth = 2;
    ctx.fillRect(s.wx, s.wy, BUILD_CELL, BUILD_CELL);
    ctx.strokeRect(s.wx, s.wy, BUILD_CELL, BUILD_CELL);
    ctx.font = "18px Arial";
    ctx.textAlign = "center";
    ctx.fillStyle = "#fff";
    ctx.fillText(pt.label.split(" ")[0], s.wx + BUILD_CELL / 2, s.wy + BUILD_CELL / 2 + 6);
    ctx.textAlign = "left";
  }
}

function removeStructureFromWorld(s) {
  if (s._wallRef) {
    const idx = walls.indexOf(s._wallRef);
    if (idx > -1) walls.splice(idx, 1);
  }
  if (s._spikeRef) {
    const idx = spikes.indexOf(s._spikeRef);
    if (idx > -1) spikes.splice(idx, 1);
  }
}

function updatePlacedStructures() {
  for (const s of placedStructures) {
    if (s.type !== "bouncy") continue;

    // Launch anything that lands on it
    const rect = { x: s.wx, y: s.wy, width: BUILD_CELL, height: BUILD_CELL };

    const targets = [player, ...G.snails, ...G.SuperSnails, ...G.chairs, ...G.tables];
    for (const t of targets) {
      if (!isColliding(rect, t)) continue;
      const feet = t.y + (t.height || 32);
      const top = s.wy + 4;
      if (feet >= top && feet <= top + 12 && t.dy >= 0) {
        t.dy = -18;
        t.y = s.wy - (t.height || 32);
      }
    }
  }
}

// === VEHICLE MODULE ===

const VEHICLE_TILE = BUILD_CELL; // same grid size as build tiles

// After build mode closes, scan all placed structures for connected
// groups that contain a seat — turn them into vehicle objects
function buildVehiclesFromStructures() {
  // Remove old vehicles first, return their tiles to placedStructures
  // (vehicles persist so we skip this — only build on first assembly)

  const vehicleTileTypes = new Set(["body", "wheel", "engine", "seat"]);
  const candidates = placedStructures.filter(s => vehicleTileTypes.has(s.type));

  // Find connected groups via flood fill
  const visited = new Set();
  const groups = [];

  for (const start of candidates) {
    const key = `${start.wx},${start.wy}`;
    if (visited.has(key)) continue;

    // BFS
    const group = [];
    const queue = [start];
    visited.add(key);

    while (queue.length > 0) {
      const tile = queue.shift();
      group.push(tile);

      // Check 4 neighbours
      const neighbours = [
        { wx: tile.wx + VEHICLE_TILE, wy: tile.wy },
        { wx: tile.wx - VEHICLE_TILE, wy: tile.wy },
        { wx: tile.wx, wy: tile.wy + VEHICLE_TILE },
        { wx: tile.wx, wy: tile.wy - VEHICLE_TILE },
      ];

      for (const n of neighbours) {
        const nKey = `${n.wx},${n.wy}`;
        if (visited.has(nKey)) continue;
        const found = candidates.find(s => s.wx === n.wx && s.wy === n.wy);
        if (found) {
          visited.add(nKey);
          queue.push(found);
        }
      }
    }

    // Only a vehicle if it has a seat
    if (group.some(t => t.type === "seat")) {
      groups.push(group);
    }
  }

  // Turn each group into a vehicle — only create if not already one
  for (const group of groups) {
    const alreadyVehicle = vehicles.some(v =>
      v.tiles.some(t => group.includes(t))
    );
    if (alreadyVehicle) continue;

    // Replace the vehicle = { ... } block:
const minX = Math.min(...group.map(t => t.wx));
const minY = Math.min(...group.map(t => t.wy));

// Compute center of mass in local space BEFORE creating vehicle
let initSX = 0, initSY = 0;
for (const t of group) {
  initSX += (t.wx - minX) + VEHICLE_TILE / 2;
  initSY += (t.wy - minY) + VEHICLE_TILE / 2;
}
const initLcx = initSX / group.length;
const initLcy = initSY / group.length;

const vehicle = {
  x: minX, y: minY,
  cx: minX + initLcx,   // ← world position of center of mass
  cy: minY + initLcy,
  vx: 0, vy: 0,
  angle: 0,
  angularVel: 0,
  tiles: group.map(t => ({
    relX: t.wx - minX,
    relY: t.wy - minY,
    type: t.type,
    hp:    t.type === "wheel" ? 2 : t.type === "engine" ? 3 : 1,
    maxHp: t.type === "wheel" ? 2 : t.type === "engine" ? 3 : 1,
    hitFlash: 0,
    structureRef: t
  })),
  hasEngine: group.some(t => t.type === "engine"),
  hasWheels: group.some(t => t.type === "wheel"),
  hasSeat:   group.some(t => t.type === "seat"),
};

    vehicles.push(vehicle);

    // Remove these tiles from placedStructures and world walls
    // so they don't double-collide
    for (const t of group) {
      removeStructureFromWorld(t);
      const idx = placedStructures.indexOf(t);
      if (idx > -1) placedStructures.splice(idx, 1);
    }
  }
}

function updateVehicles() {
  for (let vi = vehicles.length - 1; vi >= 0; vi--) {
    const v = vehicles[vi];

    // --- Tile management ---
    for (let ti = v.tiles.length - 1; ti >= 0; ti--) {
      const t = v.tiles[ti];
      if (t.hitFlash > 0) t.hitFlash--;
      if (t.hp <= 0) {
        if (t.type === "seat" && playerInVehicle && playerVehicle === v) exitVehicle();
        v.tiles.splice(ti, 1);
      }
    }
    v.hasEngine = v.tiles.some(t => t.type === "engine");
    v.hasWheels = v.tiles.some(t => t.type === "wheel");
    v.hasSeat   = v.tiles.some(t => t.type === "seat");
    if (v.tiles.length === 0 || !v.hasSeat) {
      if (playerInVehicle && playerVehicle === v) exitVehicle();
      vehicles.splice(vi, 1);
      continue;
    }

    // --- Local center of mass ---
    let sx = 0, sy = 0;
    for (const t of v.tiles) { sx += t.relX + VEHICLE_TILE/2; sy += t.relY + VEHICLE_TILE/2; }
    const lcx = sx / v.tiles.length;
    const lcy = sy / v.tiles.length;

    // --- Init physics if missing ---
    if (v.cx === undefined) {
      v.cx = v.x + lcx; v.cy = v.y + lcy;
      v.vx = 0; v.vy = 0;
      v.angle = 0; v.angularVel = 0;
    }

    const isOccupied = playerInVehicle && playerVehicle === v;

    // --- Mass and moment of inertia ---
    const MASS = Math.max(v.tiles.length * 4, 8);
    let inertia = 0;
    for (const t of v.tiles) {
      const dx = t.relX + VEHICLE_TILE/2 - lcx;
      const dy = t.relY + VEHICLE_TILE/2 - lcy;
      inertia += (dx*dx + dy*dy + VEHICLE_TILE*VEHICLE_TILE/6) * MASS / v.tiles.length;
    }
    inertia = Math.max(inertia, 4000);

    const cosA = Math.cos(v.angle);
    const sinA = Math.sin(v.angle);

    // --- Force / torque accumulators ---
    let Fx = 0;
    let Fy = MASS * 0.45;  // gravity
    let torque = 0;

    // ── WHEEL / DRIVE / COLLISION ──────────────────────────────
    const WHEEL_R = VEHICLE_TILE * 0.45;
    const DRIVE_ACCEL = 0.55;  // velocity added per frame when throttle held
    const MAX_SPEED   = 9;
    const GROUND_SNAP = WHEEL_R + 8; // distance within which wheel counts as grounded
    
    const wheelTiles = v.tiles.filter(t => t.type === "wheel");
    let groundedWheels = 0;
    
    const throttle = (isOccupied && v.hasEngine) ?
      ((localInput.right) ?  1 :
       (localInput.left)  ? -1 : 0) : 0;
    
    // ── 1. GRAVITY ─────────────────────────────────────────────
    v.vy += 0.55;
    if (v.vy >  20) v.vy = 20;
    if (v.vy < -20) v.vy = -20;
    
    // ── 2. MOVE ────────────────────────────────────────────────
    v.cx += v.vx;
    v.cy += v.vy;
    v.angle += v.angularVel;
    
    // ── 3. CORNER COLLISION (position only, clamped velocity) ──
    // Recompute corners after move
    const corners = [];
    for (const t of v.tiles) {
      for (const [clx, cly] of [
        [t.relX,               t.relY              ],
        [t.relX + VEHICLE_TILE, t.relY              ],
        [t.relX,               t.relY + VEHICLE_TILE],
        [t.relX + VEHICLE_TILE, t.relY + VEHICLE_TILE],
      ]) {
        const dlx = clx - lcx, dly = cly - lcy;
        corners.push({
          wx: v.cx + cosA*dlx - sinA*dly,
          wy: v.cy + sinA*dlx + cosA*dly,
          rx: cosA*dlx - sinA*dly,
          ry: sinA*dlx + cosA*dly
        });
      }
    }
    
    for (const c of corners) {
      for (const wall of walls) {
        if (c.wx < wall.x || c.wx > wall.x + wall.width)   continue;
        if (c.wy < wall.y || c.wy > wall.y + wall.height)  continue;
    
        const dTop    = c.wy - wall.y;
        const dBottom = wall.y + wall.height - c.wy;
        const dLeft   = c.wx - wall.x;
        const dRight  = wall.x + wall.width - c.wx;
        const minD    = Math.min(dTop, dBottom, dLeft, dRight);
    
        if (dTop === minD) {
          v.cy -= dTop;
          if (v.vy > 0) v.vy = 0; // absorb landing, no bounce explosion
          v.angularVel -= c.rx * 0.0003 * dTop;
        } else if (dBottom === minD) {
          v.cy += dBottom;
          if (v.vy < 0) v.vy *= -0.1;
        } else if (dLeft === minD) {
          v.cx -= dLeft;
          if (v.vx > 0) v.vx *= -0.2;
          v.angularVel += c.ry * 0.0003 * dLeft;
        } else {
          v.cx += dRight;
          if (v.vx < 0) v.vx *= -0.2;
          v.angularVel -= c.ry * 0.0003 * dRight;
        }
      }
    }
    
    // ── 4. WHEEL GROUND DETECTION ──────────────────────────────
    for (const wt of wheelTiles) {
      const wlx = wt.relX + VEHICLE_TILE/2 - lcx;
      const wly = wt.relY + VEHICLE_TILE/2 - lcy;
      const wwx = v.cx + cosA*wlx - sinA*wly;
      const wwy = v.cy + sinA*wlx + cosA*wly;
    
      // Check all 4 sides of each wheel for contact
      const probes = [
        { px: wwx,          py: wwy + WHEEL_R, side: "bottom" },
        { px: wwx - WHEEL_R, py: wwy,          side: "left"   },
        { px: wwx + WHEEL_R, py: wwy,          side: "right"  },
        { px: wwx,          py: wwy - WHEEL_R, side: "top"    },
      ];
    
      for (const probe of probes) {
        for (const wall of walls) {
          const inside =
            probe.px >= wall.x - GROUND_SNAP &&
            probe.px <= wall.x + wall.width  + GROUND_SNAP &&
            probe.py >= wall.y - GROUND_SNAP &&
            probe.py <= wall.y + wall.height + GROUND_SNAP;
    
          if (!inside) continue;
    
          groundedWheels++;
    
          // Lever arm from CoM to wheel center
          const rx = wwx - v.cx;
          const ry = wwy - v.cy;
    
          // ── Drive: flat accel, capped, in correct direction ──
          if (throttle !== 0) {
            // Apply as velocity delta, capped so landing can't amplify it
            const currentSpeed = v.vx;
            const newSpeed = currentSpeed + throttle * DRIVE_ACCEL;
            v.vx = Math.max(-MAX_SPEED, Math.min(MAX_SPEED, newSpeed));
    
            // Torque from drive — creates tilt effect
          }
          v.angularVel -= throttle * 0.0085; // direct, no inertia division
          // ── Ground friction ──
          v.vx *= 0.86;
    
          break; // one contact per wheel
        }
        if (groundedWheels > 0) break; // one side per wheel
      }
    }
    
    // ── 5. JUMP ────────────────────────────────────────────────
    if (isOccupied && groundedWheels > 0 && (localInput.jump)) {
      v.vy = -15;
    }
    
    // ── 6. ANGULAR VELOCITY ────────────────────────────────────
    v.angularVel += torque / inertia;
    v.angularVel *= groundedWheels > 0 ? 0.92 : 0.985;
    
    // Air resistance
    if (groundedWheels === 0) v.vx *= 0.995;

    // World bounds
    if (v.cx < 100) { v.cx = 100; if (v.vx < 0) v.vx *= -0.3; }
    if (v.cx > world.width - 100) { v.cx = world.width - 100; if (v.vx > 0) v.vx *= -0.3; }
    if (v.cy > world.height + 200) {
      if (playerInVehicle && playerVehicle === v) exitVehicle();
      vehicles.splice(vi, 1);
      continue;
    }

    // Re-derive v.x/y from cx/cy (for bounds and legacy draw code)
    v.x = v.cx - (cosA*lcx - sinA*lcy);
    v.y = v.cy - (sinA*lcx + cosA*lcy);

    // --- Sync player to seat ---
    if (isOccupied) {
      const seat = v.tiles.find(t => t.type === "seat");
      if (seat) {
        const slx = seat.relX + VEHICLE_TILE/2 - lcx;
        const sly = seat.relY + VEHICLE_TILE/2 - lcy;
        player.x = v.cx + cosA*slx - sinA*sly - player.width  / 2;
        player.y = v.cy + sinA*slx + cosA*sly - player.height / 2;
        player.dx = v.vx;
        player.dy = v.vy;
      }
    }

    // --- Ram enemies ---
    if (Math.abs(v.vx) > 2) {
      const bounds = getVehicleBounds(v);
      const lists = [
        { list: G.snails,      key: 'snail'      },
        { list: G.SuperSnails, key: 'superSnail' },
        { list: G.chairs,      key: 'chair'      },
        { list: G.tables,      key: 'table'      },
      ];
      for (const { list, key } of lists) {
        for (let i = list.length - 1; i >= 0; i--) {
          if (!rectsOverlap(bounds, list[i])) continue;
          damageEnemy(list[i], 1, { x: v.vx * 0.6, y: -4 });
          if (list[i].hp <= 0) { list.splice(i, 1); onEnemyKilled(key); }
        }
      }
    }
  }
}

// Get the bounding box of the entire vehicle in world space
function getVehicleBounds(v) {
  const cosA = Math.cos(v.angle ?? 0);
  const sinA = Math.sin(v.angle ?? 0);
  let sx = 0, sy = 0;
  for (const t of v.tiles) { sx += t.relX + VEHICLE_TILE/2; sy += t.relY + VEHICLE_TILE/2; }
  const lcx = sx / v.tiles.length;
  const lcy = sy / v.tiles.length;
  const cx = v.cx ?? (v.x + lcx);
  const cy = v.cy ?? (v.y + lcy);

  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
  for (const t of v.tiles) {
    for (const [clx, cly] of [
      [t.relX, t.relY],
      [t.relX + VEHICLE_TILE, t.relY],
      [t.relX, t.relY + VEHICLE_TILE],
      [t.relX + VEHICLE_TILE, t.relY + VEHICLE_TILE],
    ]) {
      const dlx = clx - lcx, dly = cly - lcy;
      const wx = cx + cosA*dlx - sinA*dly;
      const wy = cy + sinA*dlx + cosA*dly;
      if (wx < minX) minX = wx;
      if (wx > maxX) maxX = wx;
      if (wy < minY) minY = wy;
      if (wy > maxY) maxY = wy;
    }
  }
  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
}

function enterVehicle(v) {
  playerInVehicle = true;
  playerVehicle = v;
  player.dx = 0;
  player.dy = 0;
  potatoMessage = "💺 entered vehicle — W=jump  A/D=drive  S=exit";
  potatoMessageTimer = 180;
}

function exitVehicle() {
  if (!playerInVehicle) return;
  playerInVehicle = false;
  player.dy = playerVehicle?.dy ?? 0;
  player.dx = playerVehicle?.dx ?? 0;
  playerVehicle = null;
  potatoMessage = "💺 exited vehicle";
  potatoMessageTimer = 90;
}

function checkVehicleEntry() {
  if (playerInVehicle) {
    if (localInput.down) exitVehicle();
    return;
  }

  for (const v of vehicles) {
    if (!v.hasSeat) continue;
    const seat = v.tiles.find(t => t.type === "seat");
    if (!seat) continue;

    const cosA = Math.cos(v.angle ?? 0);
    const sinA = Math.sin(v.angle ?? 0);
    let sx = 0, sy = 0;
    for (const t of v.tiles) { sx += t.relX + VEHICLE_TILE/2; sy += t.relY + VEHICLE_TILE/2; }
    const lcx = sx / v.tiles.length;
    const lcy = sy / v.tiles.length;
    const cx = v.cx ?? (v.x + lcx);
    const cy = v.cy ?? (v.y + lcy);

    const slx = seat.relX + VEHICLE_TILE/2 - lcx;
    const sly = seat.relY + VEHICLE_TILE/2 - lcy;
    const seatWX = cx + cosA*slx - sinA*sly;
    const seatWY = cy + sinA*slx + cosA*sly;

    const dist = Math.hypot(player.x + player.width/2 - seatWX, player.y + player.height/2 - seatWY);
    if (dist < VEHICLE_TILE && (localInput.jump)) {
      enterVehicle(v);
      return;
    }
  }
}

function drawVehicles() {
  for (const v of vehicles) {
    const bounds = getVehicleBounds(v);
    if (!isEffectVisibleInWorld(bounds.x, bounds.y, bounds.width, bounds.height, 160)) continue;
    const angle = v.angle ?? 0;
    const cosA  = Math.cos(angle);
    const sinA  = Math.sin(angle);

    let sx = 0, sy = 0;
    for (const t of v.tiles) { sx += t.relX + VEHICLE_TILE/2; sy += t.relY + VEHICLE_TILE/2; }
    const lcx = sx / v.tiles.length;
    const lcy = sy / v.tiles.length;
    const cx = v.cx ?? (v.x + lcx);
    const cy = v.cy ?? (v.y + lcy);

    for (const t of v.tiles) {
      const lx = t.relX + VEHICLE_TILE/2 - lcx;
      const ly = t.relY + VEHICLE_TILE/2 - lcy;

      // World position — ctx.translate already handles camera offset
      const wx = cx + cosA*lx - sinA*ly;
      const wy = cy + sinA*lx + cosA*ly;

      ctx.save();
      ctx.translate(wx, wy);
      ctx.rotate(angle);
      if (t.hitFlash > 0) ctx.filter = "brightness(5)";

      const hw = VEHICLE_TILE / 2;

      switch (t.type) {
        case "body":
          ctx.fillStyle = "#7a5c3a";
          ctx.fillRect(-hw, -hw, VEHICLE_TILE, VEHICLE_TILE);
          ctx.strokeStyle = "#5a3c1a"; ctx.lineWidth = 2;
          ctx.strokeRect(-hw, -hw, VEHICLE_TILE, VEHICLE_TILE);
          ctx.strokeStyle = "rgba(0,0,0,0.2)"; ctx.lineWidth = 1;
          for (let i = -hw + 8; i < hw; i += 8) {
            ctx.beginPath(); ctx.moveTo(-hw, i); ctx.lineTo(hw, i); ctx.stroke();
          }
          break;

        case "wheel": {
          const r    = hw - 3;
          const spin = (v.cx ?? 0) / 8 % (Math.PI * 2);
          ctx.fillStyle = "#1a1a1a";
          ctx.beginPath(); ctx.arc(0, 0, r, 0, Math.PI*2); ctx.fill();
          ctx.fillStyle = "#888";
          ctx.beginPath(); ctx.arc(0, 0, r*0.55, 0, Math.PI*2); ctx.fill();
          ctx.strokeStyle = "#aaa"; ctx.lineWidth = 2;
          for (let a = 0; a < Math.PI*2; a += Math.PI/3) {
            ctx.beginPath();
            ctx.moveTo(Math.cos(a+spin)*r*0.55, Math.sin(a+spin)*r*0.55);
            ctx.lineTo(Math.cos(a+spin)*r,      Math.sin(a+spin)*r);
            ctx.stroke();
          }
          ctx.fillStyle = "#ccc";
          ctx.beginPath(); ctx.arc(0, 0, 4, 0, Math.PI*2); ctx.fill();
          break;
        }

        case "engine":
          ctx.fillStyle = "#c07020";
          ctx.fillRect(-hw, -hw, VEHICLE_TILE, VEHICLE_TILE);
          ctx.strokeStyle = "#804000"; ctx.lineWidth = 2;
          ctx.strokeRect(-hw, -hw, VEHICLE_TILE, VEHICLE_TILE);
          ctx.fillStyle = "#888";
          ctx.fillRect(-hw+6, -hw+6,  10, 6);
          ctx.fillRect(-hw+6, -hw+28, 10, 6);
          ctx.fillRect(hw-16, -hw+6,  10, 6);
          ctx.fillRect(hw-16, -hw+28, 10, 6);
          ctx.fillStyle = "#ff8800";
          ctx.beginPath(); ctx.arc(0, 0, 8, 0, Math.PI*2); ctx.fill();
          if (playerInVehicle && playerVehicle === v &&
              (localInput.right || localInput.left)) {
            ctx.fillStyle = `rgba(140,100,40,${0.3 + Math.random()*0.4})`;
            ctx.beginPath();
            ctx.arc(-hw - 6, 0, 4 + Math.random()*5, 0, Math.PI*2);
            ctx.fill();
          }
          break;

        case "seat":
          ctx.fillStyle = "#4466aa";
          ctx.fillRect(-hw, -hw, VEHICLE_TILE, VEHICLE_TILE);
          ctx.strokeStyle = "#224488"; ctx.lineWidth = 2;
          ctx.strokeRect(-hw, -hw, VEHICLE_TILE, VEHICLE_TILE);
          ctx.fillStyle = "#2244aa";
          ctx.fillRect(-hw+6, -hw+4, VEHICLE_TILE-12, VEHICLE_TILE*0.4);
          ctx.fillStyle = "#3355bb";
          ctx.fillRect(-hw+4, 0, VEHICLE_TILE-8, VEHICLE_TILE*0.35);
          if (!playerInVehicle) {
            const dist = Math.hypot(player.x + player.width/2 - wx,
                                    player.y + player.height/2 - wy);
            if (dist < 80) {
              ctx.rotate(-angle);
              ctx.fillStyle = "#fff";
              ctx.font = "bold 11px monospace";
              ctx.textAlign = "center";
              ctx.fillText("W to enter", 0, -hw - 6);
              ctx.textAlign = "left";
            }
          }
          break;
      }

      if (t.hp < t.maxHp && settings.enemyHealthBars) {
        ctx.rotate(-angle);
        const pct = t.hp / t.maxHp;
        ctx.fillStyle = "#300";
        ctx.fillRect(-hw, -hw-7, VEHICLE_TILE, 3);
        ctx.fillStyle = pct > 0.5 ? "#0f0" : "#f00";
        ctx.fillRect(-hw, -hw-7, VEHICLE_TILE*pct, 3);
      }

      ctx.restore();
    }
  }
}

function checkEnemyVehicleDamage() {
  for (const v of vehicles) {
    const bounds = getVehicleBounds(v);
    const allEnemies = [...G.snails, ...G.SuperSnails, ...G.bats, ...G.babyMicrowaves];

    for (const e of allEnemies) {
      if (!rectsOverlap(bounds, e)) continue;
      // Find which tile was hit
      for (const t of v.tiles) {
        const tRect = {
          x: v.x + t.relX, y: v.y + t.relY,
          width: VEHICLE_TILE, height: VEHICLE_TILE
        };
        if (!rectsOverlap(tRect, e)) continue;
        if (Math.random() < 0.02) { // low chance per frame so it doesn't melt instantly
          t.hp--;
          t.hitFlash = 4;
        }
      }
    }
  }
}

function updateSpecialBoxes() {
  for (let i = boxes.length - 1; i >= 0; i--) {
    let box = boxes[i];
    
    // Initialize type if missing
    if (!box.type) box.type = BOX_TYPE.NORMAL;
    
    // Remove broken boxes
    if (box.type === BOX_TYPE.BREAKABLE && box.hp <= 0) {
      createBreakEffect(box.x + box.width / 2, box.y + box.height / 2);
    
      // ← ADD THIS: chance to drop parts
      tryDropPart(box.x + box.width / 2, box.y);
    
      boxes.splice(i, 1);
      continue;
    }

    // Hit flash
    if (box.hitFlash > 0) box.hitFlash--;
    
    // Apply special gravity
    if (box.gravityMultiplier) {
      box.dy += gravity * box.gravityMultiplier;
    } else {
      box.dy += gravity;
    }
    
    // Move box
    box.x += box.dx;
    box.y += box.dy;
    
        for (let j = 0; j < boxes.length; j++) {
      if (i === j) continue;
      const other = boxes[j];
      if (isColliding(box, other)) resolveBoxCollision(box, other);
    }
    
    // Wall collisions
    for (let wall of walls) {
      if (isColliding(box, wall)) {
        const overlapX = Math.min(
          box.x + box.width - wall.x,
          wall.x + wall.width - box.x
        );
        const overlapY = Math.min(
          box.y + box.height - wall.y,
          wall.y + wall.height - box.y
        );
        
        if (overlapX < overlapY) {
          // Horizontal
          if (box.x < wall.x) box.x -= overlapX;
          else box.x += overlapX;
          box.dx = 0;
        } else {
          // Vertical
          if (box.y < wall.y) {
            box.y -= overlapY;
            
            // Bouncy box bounce
            if (box.type === BOX_TYPE.BOUNCY && Math.abs(box.dy) > 2) {
              box.dy = -box.dy * box.bounciness;
            } else {
              box.dy = 0;
            }
          } else {
            box.y += overlapY;
            box.dy = 0;
          }
        }
      }
    }
    for (let j = 0; j < boxes.length; j++) {
      if (i === j) continue;
      const other = boxes[j];
      if (isColliding(box, other)) resolveBoxCollision(box, other);
    }

// --- BOX COLLISIONS WITH PLAYER ---
if (
  player.x + player.width > box.x &&
  player.x < box.x + box.width &&
  player.y + player.height > box.y &&
  player.y < box.y + box.height
) {
  const overlapX = Math.min(
    player.x + player.width - box.x,
    box.x + box.width - player.x
  );
  const overlapY = Math.min(
    player.y + player.height - box.y,
    box.y + box.height - player.y
  );

  if (overlapX < overlapY) {
    // Horizontal collision → stop player and box if blocked
    if (player.x < box.x) {
      // Player is left of box
      const blocked = walls.some(w =>
        box.x + overlapX > w.x &&
        box.x + overlapX < w.x + w.width &&
        box.y + box.height > w.y &&
        box.y < w.y + w.height
      );

      if (!blocked) {
        // Free to push
        box.x += overlapX;
        box.dx = player.dx;
        player.x -= 0; // player already moving normally
      } else {
        // Blocked → stop
        player.x -= overlapX;
        player.dx = 0;
        box.dx = 0;
      }
    } else {
      // Player is right of box
      const blocked = walls.some(w =>
        box.x - overlapX < w.x + w.width &&
        box.x - overlapX + box.width > w.x &&
        box.y + box.height > w.y &&
        box.y < w.y + w.height
      );

      if (!blocked) {
        // Free to push
        box.x -= overlapX;
        box.dx = player.dx;
        player.x += 0;
      } else {
        // Blocked → stop
        player.x += overlapX;
        player.dx = 0;
        box.dx = 0;
      }
    }
  } else {
    // Vertical collision → same as working vertical logic
    if (player.y + player.height - overlapY <= box.y) {
      // Player is above box → stand on it
      player.dashUsedInAir = false;
      player.y = box.y - player.height;
      player.dy = 0;
      player.onGround = true;
      player.x += box.dx * 0.8;
    } else if (box.y + box.height - overlapY <= player.y) {
      // Box is landing on player
      box.y = player.y - box.height;
      box.dy = 0;
      box.x += player.dx * 0.7;
    } else {
      // Sideways overlap (player inside box) → push player out
      if (player.y < box.y) player.y -= overlapY;
      else player.y += overlapY;
      player.dy = 0;
    }
  }
}

    // --- BOX COLLISIONS WITH G.snails ---
    for (let s of [...G.snails, ...G.SuperSnails, ...G.babyMicrowaves]) {
      if (isColliding(box, s)) resolveBoxCollision(box, s);
    }

    // Apply wall/ground friction
    const ground = getGroundSurface(box);
if (ground && ground.ice) {
  box.dx *= 0.99;
} else {
  box.dx *= box.friction; 
}
  }
}

// --- Helper to resolve box vs solid collisions ---
function resolveBoxCollision(box, solid) {
  const overlapX = Math.min(box.x + box.width - solid.x, solid.x + solid.width - box.x);
  const overlapY = Math.min(box.y + box.height - solid.y, solid.y + solid.height - box.y);

  if (overlapX < overlapY) {
    // Horizontal separation
    if (box.x < solid.x) box.x -= overlapX / 2;
    else box.x += overlapX / 2;

    if (solid.dx !== undefined) { // Moving object like player/snail
      box.dx = solid.dx * 0.8;
    } else {
      box.dx = 0;
    }
  } else {
    // Vertical separation
    if (box.y < solid.y) {
      box.y -= overlapY;
      box.dy = 0;
    } else {
      box.y += overlapY;
      box.dy = 0;
    }

    // If box is on top of a moving object, move with it slightly
    if (solid.dx !== undefined && box.y + box.height <= solid.y + solid.height + 1) {
      box.x += solid.dx * 0.8; 
    }
  }
    // Apply friction
    const ground = getGroundSurface(box);
    if (ground && ground.ice) {
      box.dx *= 0.99;
    } else {
      box.dx *= box.friction || 0.9;
    }
  }


function drawSpecialBoxes() {
  for (let box of boxes) {
    if (!box.type) box.type = BOX_TYPE.NORMAL;
    
    ctx.save();
    
    if (box.hitFlash > 0) {
      ctx.fillStyle = "#fff";
      ctx.fillRect(box.x, box.y, box.width, box.height);
    }
    
    switch (box.type) {
      case BOX_TYPE.BOUNCY:
        drawBouncyBox(box);
        break;
      case BOX_TYPE.BREAKABLE:
        drawBreakableBox(box);
        break;
      case BOX_TYPE.HEAVY:
        drawHeavyBox(box);
        break;
      case BOX_TYPE.ICE:
        drawIceBox(box);
        break;
      default:
        drawNormalBox(box);
    }
    
    ctx.restore();
  }
}

function drawBouncyBox(b) {
  // Squishy spring box
  const squish = Math.sin(performance.now() * 0.01) * 2;
  
  // Main body - bright green
  ctx.fillStyle = "#4caf50";
  ctx.fillRect(b.x, b.y + squish, b.width, b.height - squish * 2);
  
  // Spring coils
  ctx.strokeStyle = "#81c784";
  ctx.lineWidth = 2;
  for (let i = 0; i < 4; i++) {
    ctx.beginPath();
    ctx.arc(b.x + 8 + i * 7, b.y + b.height / 2, 3, 0, Math.PI * 2);
    ctx.stroke();
  }
  
  // Bounce indicator
  ctx.fillStyle = "#fff";
  ctx.font = "12px Arial";
  ctx.fillText("↑", b.x + b.width / 2 - 4, b.y + b.height / 2 + 4);
}

function drawBreakableBox(b) {
  // Cracked crate
  const healthPercent = b.hp / b.maxHp;
  
  // Base color gets darker as damaged
  const darkness = Math.floor((1 - healthPercent) * 100);
  ctx.fillStyle = `rgb(${139 - darkness}, ${90 - darkness}, ${43 - darkness})`;
  ctx.fillRect(b.x, b.y, b.width, b.height);
  
  // Cracks
  ctx.strokeStyle = "#000";
  ctx.lineWidth = 2;
  
  if (healthPercent < 0.66) {
    ctx.beginPath();
    ctx.moveTo(b.x + 5, b.y);
    ctx.lineTo(b.x + 8, b.y + b.height);
    ctx.stroke();
  }
  
  if (healthPercent < 0.33) {
    ctx.beginPath();
    ctx.moveTo(b.x + b.width - 5, b.y + 5);
    ctx.lineTo(b.x + b.width - 8, b.y + b.height - 5);
    ctx.stroke();
  }

}

function drawHeavyBox(b) {
  // Dense metal box
  ctx.fillStyle = "#546e7a";
  ctx.fillRect(b.x, b.y, b.width, b.height);
  
  // Metal borders
  ctx.strokeStyle = "#37474f";
  ctx.lineWidth = 3;
  ctx.strokeRect(b.x, b.y, b.width, b.height);
  
  // Rivets
  ctx.fillStyle = "#263238";
  for (let corner of [[4,4], [b.width-4, 4], [4, b.height-4], [b.width-4, b.height-4]]) {
    ctx.beginPath();
    ctx.arc(b.x + corner[0], b.y + corner[1], 2, 0, Math.PI * 2);
    ctx.fill();
  }
  
  // Weight indicator
  ctx.fillStyle = "#fff";
  ctx.font = "bold 12px Arial";
  ctx.fillText("H", b.x + b.width / 2 - 4, b.y + b.height / 2 + 4);
}

function drawIceBox(b) {
  // Frozen ice block
  ctx.fillStyle = "#b3e5fc";
  ctx.fillRect(b.x, b.y, b.width, b.height);
  
  // Ice shine
  ctx.fillStyle = "rgba(255,255,255,0.5)";
  ctx.fillRect(b.x + 4, b.y + 4, b.width - 8, 6);
  
  // Frost crystals
  ctx.strokeStyle = "rgba(255,255,255,0.7)";
  ctx.lineWidth = 1;
  for (let i = 0; i < 3; i++) {
    const cx = b.x + 8 + i * 10;
    const cy = b.y + b.height / 2;
    
    ctx.beginPath();
    ctx.moveTo(cx, cy - 4);
    ctx.lineTo(cx, cy + 4);
    ctx.moveTo(cx - 3, cy);
    ctx.lineTo(cx + 3, cy);
    ctx.stroke();
  }
}

function drawNormalBox(b) {
  if (isChristmasMap()) {
    // Present box (existing code)
    ctx.fillStyle = "#c33";
    ctx.fillRect(b.x, b.y, b.width, b.height);
    ctx.fillStyle = "#fff";
    ctx.fillRect(b.x + b.width / 2 - 3, b.y, 6, b.height);
    ctx.fillRect(b.x, b.y + b.height / 2 - 3, b.width, 6);
    ctx.beginPath();
    ctx.arc(b.x + b.width / 2 - 6, b.y + 6, 4, 0, Math.PI * 2);
    ctx.arc(b.x + b.width / 2 + 6, b.y + 6, 4, 0, Math.PI * 2);
    ctx.fill();
  } else {
    // Wood crate (existing code)
    ctx.fillStyle = "#a36a2f";
    ctx.fillRect(b.x, b.y, b.width, b.height);
    ctx.strokeStyle = "rgba(0,0,0,0.25)";
    for (let y = b.y; y < b.y + b.height; y += 10) {
      ctx.beginPath();
      ctx.moveTo(b.x, y);
      ctx.lineTo(b.x + b.width, y);
      ctx.stroke();
    }
    ctx.fillStyle = "#555";
    ctx.fillRect(b.x, b.y, 4, 4);
    ctx.fillRect(b.x + b.width - 4, b.y, 4, 4);
    ctx.fillRect(b.x, b.y + b.height - 4, 4, 4);
    ctx.fillRect(b.x + b.width - 4, b.y + b.height - 4, 4, 4);
  }
}

function createBreakEffect(x, y) {
  // Create particle debris
  for (let i = 0; i < 8; i++) {
    const angle = (Math.PI * 2 * i) / 8;
    const speed = 2 + Math.random() * 3;
    
    // You can add to a particles array if you have one
    // For now, just visual feedback
  }
}

// Damage box when hit by sword
function damageBox(box, damage) {
  if (box.type !== BOX_TYPE.BREAKABLE) return false;
  
  box.hp -= damage;
  box.hitFlash = 5;
  
  if (box.hp <= 0) {
    box.broken = true;
    return true;
  }
  
  return false;
}

const BAT_STATE = {
  PATROL: "patrol",
  CHASE: "chase",
  LUNGE: "lunge",
  RETREAT: "retreat"
};

function createBat(x, y, hp = 2) {
  return {
    x: x,
    y: y,
    width: 24,
    height: 20,
    
    // Movement
    dx: 0,
    dy: 0,
    speed: 2.5,
    lungeSpeed: 6,
    
    // AI
    state: BAT_STATE.PATROL,
    patrolCenterX: x,
    patrolCenterY: y,
    patrolRadius: 150,
    detectionRange: 300,
    lungeRange: 200,
    
    // Lunge mechanics
    lungeTimer: 0,
    lungeCooldown: 0,
    lungeTargetX: 0,
    lungeTargetY: 0,
    
    // Animation
    wingFlap: 0,
    facing: 1, // 1 = right, -1 = left
    
    // Health
    hp: hp,
    maxHp: hp,
    hitFlash: 0,
    
    // Knockback
    knockbackTimer: 0,
    knockbackDx: 0,
    knockbackDy: 0
  };
}

function updateTutorial() {
  tutorialState.pulseTimer += 0.04;
  tutorialState.arrowBob = Math.sin(tutorialState.pulseTimer * 2) * 6;

  // Potato pickup notification
  if (hasPotato && !tutorialState.completedZones.has('potato_pickup')) {
    tutorialState.completedZones.add('potato_pickup');
    tutorialState.currentMessage = '🥔 POTATO acquired! Click to fire!';
    tutorialState.messageColor = '#ffd54f';
    tutorialState.messageTimer = 150;
  }

  // Zone triggers
  const pr = { x: player.x, y: player.y, width: player.width, height: player.height };
  for (const t of TUTORIAL_TRIGGERS) {
    if (tutorialState.completedZones.has(t.zoneId)) continue;
    if (
      pr.x < t.x + t.w && pr.x + pr.width  > t.x &&
      pr.y < t.y + t.h && pr.y + pr.height > t.y
    ) {
      tutorialState.completedZones.add(t.zoneId);
      tutorialState.currentMessage = t.message;
      tutorialState.messageColor   = t.color;
      tutorialState.messageTimer   = 180;

      const required = ['move','jump','walljump','dash','sword','museum','hazards','potato'];
      if (!tutorialState.completionShown && required.every(z => tutorialState.completedZones.has(z))) {
        tutorialState.completionShown = true;
        setTimeout(() => {
          tutorialState.currentMessage = '🎉 TUTORIAL COMPLETE! You are ready!';
          tutorialState.messageColor   = '#ffd54f';
          tutorialState.messageTimer   = 360;
        }, 3000);
      }
    }
  }
}

// === CHEESE MODULE ===
// Rare bouncing enemy. Splits on death. Despawns for a free upgrade.

function createCheese(x, y, generation = 0, despawnTimer = 1800, pristine = true) {
  const scale = Math.pow(0.75, generation);
  const w = Math.max(8, Math.floor(36 * scale));
  const h = Math.max(6, Math.floor(28 * scale));
  const speed = 4 + generation * 0.8;

  return {
    x, y,
    width: w,
    height: h,
    dx: (Math.random() - 0.5) * speed * 2,
    dy: -(2 + Math.random() * 3 + generation * 0.5),
    hp: 1,
    maxHp: 1,
    hitFlash: 0,
    knockbackTimer: 0,
    knockbackDx: 0,
    knockbackDy: 0,
    generation,
    despawnTimer,
    pristine,   // ← now actually defined
    bobTimer: Math.random() * Math.PI * 2,
    alive: true
  };
}

function updateCheeses() {
  for (let i = cheeses.length - 1; i >= 0; i--) {
    const c = cheeses[i];
    if (!c.alive) { cheeses.splice(i, 1); continue; }

    // Despawn timer
    c.despawnTimer--;
    if (c.despawnTimer <= 0) {
      if (c.pristine) {
        // Was never hit at all — give the upgrade
        potatoMessage = "🧀 it got away... but left something behind";
        potatoMessageTimer = 180;
        cheeseCooldown = CHEESE_COOLDOWN;
        cheeses.splice(i, 1);
        triggerLevelUp(); // ← call directly, no setTimeout needed
        continue;
      } else {
        potatoMessage = "🧀 the fragment escaped";
        potatoMessageTimer = 80;
        cheeseCooldown = CHEESE_COOLDOWN;
        cheeses.splice(i, 1);
        continue;
      }
    }

    // Knockback
    if (c.knockbackTimer > 0) {
      c.x += c.knockbackDx;
      c.y += c.knockbackDy;
      c.knockbackDx *= 0.85;
      c.knockbackDy *= 0.85;
      c.knockbackTimer--;
    }

    if (c.hitFlash > 0) c.hitFlash--;

    // Random direction nudges — makes it feel erratic
    c.bobTimer += 0.08;
    if (Math.random() < 0.03) c.dx += (Math.random() - 0.5) * 3;
    if (Math.random() < 0.015) c.dy -= 2 + Math.random() * 2; // random hop

    // Gravity
    c.dy += 0.25;
    if (c.dy > 14) c.dy = 14;

    // Speed cap (loose — cheese is chaotic)
    c.dx = Math.max(-5, Math.min(5, c.dx));

    c.x += c.dx;
    c.y += c.dy;

    // Wall bounce
    for (const w of walls) {
      if (!isColliding(c, w)) continue;
      const ox = Math.min(c.x + c.width - w.x, w.x + w.width - c.x);
      const oy = Math.min(c.y + c.height - w.y, w.y + w.height - c.y);

      if (ox < oy) {
        c.x += c.x < w.x ? -ox : ox;
        c.dx *= -0.85; // bounce off walls
        c.dx += (Math.random() - 0.5) * 2; // chaotic bounce angle
      } else {
        if (c.y < w.y) {
          c.y -= oy;
          c.dy *= -0.7; // bounce off floor
          c.dx += (Math.random() - 0.5) * 3;
        } else {
          c.y += oy;
          c.dy = Math.abs(c.dy) * 0.5;
        }
      }
    }

    // World bounds bounce
    if (c.x < 0) { c.x = 0; c.dx = Math.abs(c.dx); }
    if (c.x + c.width > world.width) { c.x = world.width - c.width; c.dx = -Math.abs(c.dx); }
    if (c.y > world.height + 100) { c.alive = false; continue; }

    // Player contact
    if (isColliding(c, player)) damagePlayer("cheese");
  }
}

function drawCheeses() {
  for (const c of cheeses) {
    if (!isEffectVisibleInWorld(c.x, c.y, c.width, c.height, 120)) continue;
    ctx.save();

    // Warning flash in last 5 seconds
    const flashing = c.despawnTimer < 300 && Math.floor(c.despawnTimer / 15) % 2 === 0;
    if (flashing) ctx.globalAlpha = 0.4;

    if (c.hitFlash > 0) ctx.filter = "brightness(8)";

    const cx = c.x + c.width / 2;
    const cy = c.y + c.height / 2;

    // Body
    ctx.fillStyle = c.generation > 0 ? "#e8c94a" : "#f5d842";    ctx.beginPath();
    ctx.ellipse(cx, cy, c.width / 2, c.height / 2, 0, 0, Math.PI * 2);
    ctx.fill();

    // Holes
    ctx.fillStyle = "#c9a800";
    const holeCount = c.generation > 0 ? Math.max(1, 4 - c.generation) : 4;
    for (let h = 0; h < holeCount; h++) {
      const hx = c.x + 6 + (h % 2) * (c.width * 0.45);
      const hy = c.y + 6 + Math.floor(h / 2) * (c.height * 0.45);
      ctx.beginPath();
      const holeSize = Math.max(1, 4 - c.generation);
      ctx.ellipse(hx, hy, holeSize, holeSize - 1, 0, 0, Math.PI * 2);
      ctx.fill();
    }

    // Outline
    ctx.strokeStyle = "#a07800";
    ctx.lineWidth = 1.5;
    ctx.beginPath();
    ctx.ellipse(cx, cy, c.width / 2, c.height / 2, 0, 0, Math.PI * 2);
    ctx.stroke();

    ctx.restore();

    // Despawn timer bar (shows only when under 10 seconds)
    if (c.despawnTimer < 600) {
      const pct = c.despawnTimer / 600;
      const barW = c.width;
      ctx.fillStyle = "#300";
      ctx.fillRect(c.x, c.y - 7, barW, 4);
      ctx.fillStyle = pct > 0.5 ? "#ff0" : "#f80";
      ctx.fillRect(c.x, c.y - 7, barW * pct, 4);
      ctx.strokeStyle = "#000";
      ctx.lineWidth = 1;
      ctx.strokeRect(c.x, c.y - 7, barW, 4);
    }

    // Health bar
    if (settings.enemyHealthBars && c.hp > 0) {
      const barW = c.width;
      ctx.fillStyle = "#300";
      ctx.fillRect(c.x, c.y - 14, barW, 4);
      const hpPct = c.hp / c.maxHp;
      ctx.fillStyle = hpPct > 0.5 ? "#0f0" : "#f00";
      ctx.fillRect(c.x, c.y - 14, barW * hpPct, 4);
      ctx.strokeStyle = "#000";
      ctx.lineWidth = 1;
      ctx.strokeRect(c.x, c.y - 14, barW, 4);
    }
  }
}

function damageCheeseCheck(hitBox, dmg, kb) {
  for (let i = cheeses.length - 1; i >= 0; i--) {
    const c = cheeses[i];
    if (!isColliding(hitBox, c)) continue;

    c.hp -= dmg;
    c.hitFlash = 5;
    c.knockbackTimer = 8;
    c.knockbackDx = kb.x;
    c.knockbackDy = kb.y;

    if (c.hp <= 0) {
      const MIN_GENERATION = 6; // stops splitting at this point — too tiny to see
    
      if (c.generation < MIN_GENERATION) {
        // Always split — infinite splitting
        cheeses.push(createCheese(c.x - 8, c.y - 4, c.generation + 1, c.despawnTimer, false));
        cheeses.push(createCheese(c.x + 8, c.y - 4, c.generation + 1, c.despawnTimer, false));
    
        if (c.generation === 0) {
          potatoMessage = "🧀 it split!";
        } else if (c.generation === 1) {
          potatoMessage = "🧀 it split again??";
        } else if (c.generation === 2) {
          potatoMessage = "🧀 stop splitting";
        } else {
          potatoMessage = `🧀 generation ${c.generation + 1}... please`;
        }
        potatoMessageTimer = 90;
      } else {
        // Finally dead — too small to split further
        potatoMessage = "🧀 +0 XP   (seriously)";
        potatoMessageTimer = 90;
      }
    
      cheeses.splice(i, 1);
      return true;
    }
    return false;
  }
  return false;
}

// Try to spawn a cheese this wave tick
// Call this from updateWaveSystem
function trySpawnCheese() {
  if (!G.wavesystem.enabled || !G.wavesystem.waveActive) return;

  // Base chance 0.0001% per frame, scales with wave number
  const wave = G.wavesystem.currentWave;
  const chance = 0.000001 + wave * 0.0000015; // caps around 1.8% at wave 10

  if (Math.random() > chance) return;
  // Max 1 cheese at a time (including splits)
  if (cheeses.length > 0) return;

  const pos = getSpawnPosition('snail'); // reuse any spawn zone
  cheeses.push(createCheese(pos.x, pos.y, false));
  potatoMessage = "🧀 a cheese has appeared";
  potatoMessageTimer = 120;
}

function updateBats() {
  for (let i = G.bats.length - 1; i >= 0; i--) {
    let bat = G.bats[i];
    
    // Remove dead G.bats
    if (bat.hp <= 0) {
      G.bats.splice(i, 1);
      onEnemyKilled('bat');
      continue;
    }
    ensureEntityInBounds(bat);
    
    // Knockback
    if (bat.knockbackTimer > 0) {
      bat.x += bat.knockbackDx;
      bat.y += bat.knockbackDy;
      bat.knockbackTimer--;
      bat.knockbackDx *= 0.9;
      bat.knockbackDy *= 0.9;
      continue;
    }
    
    // Hit flash
    if (bat.hitFlash > 0) bat.hitFlash--;
    
    // Wing flap animation
    bat.wingFlap += 0.15;
    
    // Distance to player
    const dx = player.x + player.width / 2 - (bat.x + bat.width / 2);
    const dy = player.y + player.height / 2 - (bat.y + bat.height / 2);
    const distToPlayer = Math.sqrt(dx * dx + dy * dy);
    
    // Update facing
    if (dx > 0) bat.facing = 1;
    else if (dx < 0) bat.facing = -1;
    
    // Cooldown
    if (bat.lungeCooldown > 0) bat.lungeCooldown--;
    
    // === STATE MACHINE ===
    
    if (bat.state === BAT_STATE.PATROL) {
      // Circular patrol around spawn point
      const patrolAngle = performance.now() * 0.001 + i; // unique per bat
      const targetX = bat.patrolCenterX + Math.cos(patrolAngle) * bat.patrolRadius;
      const targetY = bat.patrolCenterY + Math.sin(patrolAngle) * bat.patrolRadius;
      
      const pdx = targetX - bat.x;
      const pdy = targetY - bat.y;
      const patrolDist = Math.sqrt(pdx * pdx + pdy * pdy);
      
      if (patrolDist > 5) {
        bat.dx = (pdx / patrolDist) * bat.speed * 0.6;
        bat.dy = (pdy / patrolDist) * bat.speed * 0.6;
      }
      
      // Detect player
      if (distToPlayer < bat.detectionRange) {
        bat.state = BAT_STATE.CHASE;
      }
    }
    
    else if (bat.state === BAT_STATE.CHASE) {
      // Move toward player
      bat.dx = (dx / distToPlayer) * bat.speed;
      bat.dy = (dy / distToPlayer) * bat.speed;
      
      // Lunge when close enough
      if (distToPlayer < bat.lungeRange && bat.lungeCooldown <= 0) {
        bat.state = BAT_STATE.LUNGE;
        bat.lungeTimer = 30; // frames
        bat.lungeTargetX = player.x + player.width / 2;
        bat.lungeTargetY = player.y + player.height / 2;
        bat.lungeCooldown = 90; // 1.5 seconds
      }
      
      // Return to patrol if player too far
      if (distToPlayer > bat.detectionRange + 100) {
        bat.state = BAT_STATE.PATROL;
      }
    }
    
    else if (bat.state === BAT_STATE.LUNGE) {
      bat.lungeTimer--;
      
      // Fast dive toward target
      const ldx = bat.lungeTargetX - bat.x;
      const ldy = bat.lungeTargetY - bat.y;
      const lungeDist = Math.sqrt(ldx * ldx + ldy * ldy);
      
      if (lungeDist > 5) {
        bat.dx = (ldx / lungeDist) * bat.lungeSpeed;
        bat.dy = (ldy / lungeDist) * bat.lungeSpeed;
      }
      
      // End lunge
      if (bat.lungeTimer <= 0 || lungeDist < 10) {
        bat.state = BAT_STATE.RETREAT;
        bat.lungeTimer = 20;
      }
    }
    
    else if (bat.state === BAT_STATE.RETREAT) {
      bat.lungeTimer--;
      
      // Move away from player
      bat.dx = -(dx / distToPlayer) * bat.speed * 1.2;
      bat.dy = -(dy / distToPlayer) * bat.speed * 1.2;
      
      if (bat.lungeTimer <= 0) {
        bat.state = BAT_STATE.CHASE;
      }
    }
    
    // Apply movement
    bat.x += bat.dx;
    bat.y += bat.dy;
    
    // Damping
    bat.dx *= 0.95;
    bat.dy *= 0.95;
    
    // Keep in bounds
    if (bat.x < 30) bat.x = 30;
    if (bat.x > MAP_WIDTH - 30) bat.x = MAP_WIDTH - 30;
    if (bat.y < 30) bat.y = 30;
    if (bat.y > MAP_HEIGHT - 30) bat.y = MAP_HEIGHT - 30;
    
    // Damage player on contact
    if (isColliding(bat, player)  && !bat.tutorialDisplay) {
      damagePlayer("Bat");
    }
  }
}

function drawTutorialWorld() {
  // Zone dividers
  for (const d of tutorialState.zoneDividers) {
    const sx = d.wx - camera.x, sy = d.wy - camera.y;
    if (sx < -20 || sx > canvas.width + 20) continue;
    ctx.save();
    ctx.globalAlpha = 0.4 + 0.1 * Math.sin(tutorialState.pulseTimer);
    ctx.strokeStyle = d.color;
    ctx.lineWidth = 3;
    ctx.setLineDash([8, 6]);
    ctx.beginPath();
    ctx.moveTo(sx, sy);
    ctx.lineTo(sx, sy + d.height);
    ctx.stroke();
    ctx.setLineDash([]);
    ctx.globalAlpha = 1;
    ctx.restore();
  }

  // Floating arrows
  for (const arr of tutorialState.checkpointArrows) {
    const sx = arr.wx - camera.x;
    const sy = arr.wy - camera.y + tutorialState.arrowBob;
    if (sx < -40 || sx > canvas.width + 40) continue;
    ctx.save();
    ctx.fillStyle = arr.color;
    ctx.strokeStyle = '#000';
    ctx.lineWidth = 1.5;
    ctx.beginPath();
    if (arr.dir === 'right') {
      ctx.moveTo(sx + 20, sy);     ctx.lineTo(sx, sy - 10);
      ctx.lineTo(sx + 8, sy - 10); ctx.lineTo(sx + 8, sy - 18);
      ctx.lineTo(sx + 14, sy - 18);ctx.lineTo(sx + 14, sy - 10);
      ctx.lineTo(sx + 20, sy - 10);
    } else if (arr.dir === 'up') {
      ctx.moveTo(sx, sy - 20);     ctx.lineTo(sx - 10, sy);
      ctx.lineTo(sx - 10, sy - 8); ctx.lineTo(sx - 18, sy - 8);
      ctx.lineTo(sx - 18, sy - 14);ctx.lineTo(sx - 10, sy - 14);
      ctx.lineTo(sx - 10, sy - 20);
    }
    ctx.closePath();
    ctx.fill(); ctx.stroke();
    ctx.restore();
  }

  // Ground text
  for (const p of tutorialState.groundPaintings) {
    const sx = p.wx - camera.x, sy = p.wy - camera.y;
    if (sx < -300 || sx > canvas.width + 300) continue;
    ctx.save();
    ctx.globalAlpha = 0.7;
    ctx.fillStyle = p.color;
    ctx.font = p.font;
    ctx.fillText(p.text, sx, sy);
    ctx.globalAlpha = 1;
    ctx.restore();
  }

  // Signs
  for (const sign of tutorialState.zoneSigns) {
    const pad = 10, lineH = 15;
    const totalH = 28 + sign.lines.length * lineH + pad;
    const sx = sign.wx - camera.x;
    const sy = sign.wy - camera.y - totalH - 30;
    if (sx < -(sign.width + 20) || sx > canvas.width + 20) continue;
    ctx.save();
    ctx.fillStyle = 'rgba(5,5,15,0.92)';
    ctx.strokeStyle = sign.color;
    ctx.lineWidth = 2;
    ctx.shadowColor = sign.color; ctx.shadowBlur = 8;
    ctx.fillRect(sx, sy, sign.width, totalH);
    ctx.strokeRect(sx, sy, sign.width, totalH);
    ctx.shadowBlur = 0;
    // Pole
    ctx.fillStyle = '#7a5c1e';
    ctx.fillRect(sx + sign.width / 2 - 3, sy + totalH, 6, 35);
    // Title bar
    ctx.fillStyle = sign.color;
    ctx.fillRect(sx, sy, sign.width, 20);
    ctx.fillStyle = '#0a0a14';
    ctx.font = 'bold 10px monospace';
    ctx.textAlign = 'center';
    ctx.fillText(sign.title, sx + sign.width / 2, sy + 14);
    // Body
    ctx.fillStyle = '#ddd'; ctx.font = '10px monospace';
    for (let i = 0; i < sign.lines.length; i++) {
      ctx.fillText(sign.lines[i], sx + sign.width / 2, sy + 32 + i * lineH);
    }
    ctx.textAlign = 'left';
    ctx.restore();
  }

  // Museum labels
  for (const ml of tutorialState.museumLabels) {
    const sx = ml.wx - camera.x, sy = ml.wy - camera.y;
    if (sx < -100 || sx > canvas.width + 80) continue;
    ctx.save();
    ctx.fillStyle = 'rgba(5,5,20,0.9)';
    ctx.strokeStyle = ml.color; ctx.lineWidth = 1.5;
    ctx.fillRect(sx, sy, ml.width, 45);
    ctx.strokeRect(sx, sy, ml.width, 45);
    ctx.fillStyle = ml.color;
    ctx.font = 'bold 8px monospace'; ctx.textAlign = 'center';
    ctx.fillText(ml.label, sx + ml.width / 2, sy + 12);
    ctx.fillStyle = '#aaa'; ctx.font = '7px monospace';
    const lines = ml.desc.split('\n');
    for (let i = 0; i < lines.length; i++) {
      ctx.fillText(lines[i], sx + ml.width / 2, sy + 24 + i * 10);
    }
    ctx.textAlign = 'left';
    ctx.restore();
  }
}

function drawTutorialHUD() {
  const ZONES = ['move','jump','walljump','dash','sword','museum','hazards','potato'];
  const done  = ZONES.filter(z => tutorialState.completedZones.has(z)).length;
  const frac  = done / ZONES.length;
  const BAR_W = 320, BAR_X = (canvas.width - BAR_W) / 2, BAR_Y = 8;

  ctx.save();

  // Track BG
  ctx.fillStyle = 'rgba(0,0,0,0.7)';
  ctx.fillRect(BAR_X - 2, BAR_Y - 2, BAR_W + 4, 24);

  // Gradient fill
  const grad = ctx.createLinearGradient(BAR_X, 0, BAR_X + BAR_W, 0);
  grad.addColorStop(0,    '#4fc3f7');
  grad.addColorStop(0.28, '#81c784');
  grad.addColorStop(0.42, '#ffb74d');
  grad.addColorStop(0.56, '#00e5ff');
  grad.addColorStop(0.70, '#f06292');
  grad.addColorStop(0.84, '#ce93d8');
  grad.addColorStop(1,    '#ffd54f');
  ctx.fillStyle = grad;
  ctx.fillRect(BAR_X, BAR_Y, BAR_W * frac, 20);

  // Dividers
  ctx.strokeStyle = 'rgba(0,0,0,0.5)'; ctx.lineWidth = 1;
  for (let i = 1; i < ZONES.length; i++) {
    const sx = BAR_X + (BAR_W / ZONES.length) * i;
    ctx.beginPath(); ctx.moveTo(sx, BAR_Y); ctx.lineTo(sx, BAR_Y + 20); ctx.stroke();
  }
  ctx.strokeStyle = 'rgba(255,255,255,0.6)';
  ctx.strokeRect(BAR_X, BAR_Y, BAR_W, 20);

  // Label
  ctx.fillStyle = frac === 1 ? '#ffd54f' : '#fff';
  ctx.font = 'bold 10px monospace'; ctx.textAlign = 'center';
  ctx.fillText(
    frac === 1 ? '🎉 TRAINING DOJO COMPLETE!' : `TRAINING DOJO — ${done} / ${ZONES.length} Zones`,
    canvas.width / 2, BAR_Y + 14
  );

  // Zone completion banner
  if (tutorialState.messageTimer > 0) {
    const alpha = Math.min(1, tutorialState.messageTimer / 40);
    const MSG_W = 500, MSG_X = (canvas.width - MSG_W) / 2, MSG_Y = canvas.height / 2 - 55;
    ctx.globalAlpha = alpha;
    ctx.fillStyle = 'rgba(0,0,0,0.88)';
    ctx.strokeStyle = tutorialState.messageColor;
    ctx.lineWidth = 2;
    ctx.shadowColor = tutorialState.messageColor; ctx.shadowBlur = 14;
    ctx.fillRect(MSG_X, MSG_Y, MSG_W, 44);
    ctx.strokeRect(MSG_X, MSG_Y, MSG_W, 44);
    ctx.shadowBlur = 0;
    ctx.fillStyle = tutorialState.messageColor;
    ctx.font = 'bold 17px monospace'; ctx.textAlign = 'center';
    ctx.fillText(tutorialState.currentMessage, canvas.width / 2, MSG_Y + 28);
    ctx.globalAlpha = 1;
    tutorialState.messageTimer--;
  }

  // Bottom hint bar
  ctx.globalAlpha = 1;
  ctx.fillStyle = 'rgba(0,0,0,0.65)';
  ctx.fillRect(0, canvas.height - 22, canvas.width, 22);
  ctx.fillStyle = '#aaa'; ctx.font = '9px monospace'; ctx.textAlign = 'center';
  ctx.fillText(
    'MOVE: A/D   JUMP: W   DASH: Shift   CLUB: F   SWORD: G + Direction   CANNON: Mouse + Click',
    canvas.width / 2, canvas.height - 7
  );
  ctx.textAlign = 'left';
  ctx.restore();
}

// ──────────────────────────────────────── GIANT COOKIE SYSTEM ────────────────────────────────────────

function updateCookie() {
  const cookie = G.cookie;
  
  // Update bobbing animation
  cookie.bobOffset += cookie.bobSpeed;
  
  // Update click cooldown
  if (cookie.clickCooldown > 0) {
    cookie.clickCooldown--;
  }
  
  // Update dropped cookies
  for (let i = G.droppedCookies.length - 1; i >= 0; i--) {
    const c = G.droppedCookies[i];
    c.vy += 0.3; // gravity
    c.y += c.vy;
    c.x += c.vx;
    c.rotation += c.rotationSpeed;
    c.life--;
    
    // Remove if off screen or expired
    if (c.life <= 0 || c.y > MAP_HEIGHT + 100) {
      G.droppedCookies.splice(i, 1);
    }
  }
}

function drawCookie() {
  const cookie = G.cookie;
  
  // Calculate bobbing position
  const bobY = cookie.y + Math.sin(cookie.bobOffset) * 8;
  
  // Main cookie circle (HUGE!)
  ctx.fillStyle = "#d4a574"; // golden brown
  ctx.beginPath();
  ctx.arc(cookie.x, bobY, cookie.radius, 0, Math.PI * 2);
  ctx.fill();
  
  // Cookie shine/highlight
  ctx.fillStyle = "rgba(255, 255, 255, 0.3)";
  ctx.beginPath();
  ctx.arc(cookie.x - 15, bobY - 20, cookie.radius * 0.35, 0, Math.PI * 2);
  ctx.fill();
  
  // Cookie chocolate chips
  const chipPositions = [
    {x: -15, y: -10}, {x: 10, y: -15}, {x: -8, y: 8},
    {x: 20, y: 5}, {x: -20, y: 15}, {x: 12, y: 18},
    {x: 0, y: 0}, {x: 15, y: -8}
  ];
  
  ctx.fillStyle = "#6b4423"; // dark brown chips
  for (const chip of chipPositions) {
    ctx.beginPath();
    ctx.arc(cookie.x + chip.x, bobY + chip.y, 6, 0, Math.PI * 2);
    ctx.fill();
  }
  
  // Shadow/outline
  ctx.strokeStyle = "rgba(0, 0, 0, 0.2)";
  ctx.lineWidth = 2;
  ctx.beginPath();
  ctx.arc(cookie.x, bobY, cookie.radius, 0, Math.PI * 2);
  ctx.stroke();
  
  // Draw dropped cookies falling
  for (const c of G.droppedCookies) {
    if (!isEffectVisibleInWorld(c.x, c.y, 16, 16, 50)) continue;
    
    ctx.save();
    ctx.translate(c.x, c.y);
    ctx.rotate(c.rotation);
    
    // Main cookie
    ctx.fillStyle = "#d4a574";
    ctx.beginPath();
    ctx.arc(0, 0, c.size, 0, Math.PI * 2);
    ctx.fill();
    
    // Chip
    ctx.fillStyle = "#6b4423";
    ctx.beginPath();
    ctx.arc(-4, -2, 2, 0, Math.PI * 2);
    ctx.fill();
    
    ctx.restore();
  }

  // Click counter label near cookie
  ctx.save();
  ctx.fillStyle = "#ffffff";
  ctx.font = "14px monospace";
  ctx.textAlign = "left";
  const clicks = cookie.clickCount || 0;
  ctx.fillText("Cookies: " + clicks, cookie.x + cookie.radius + 8, bobY - cookie.radius + 18);
  ctx.restore();
}

function clickCookie(worldX, worldY) {
  const cookie = G.cookie;
  const bobY = cookie.y + Math.sin(cookie.bobOffset) * 8;
  
  // Check if click is on cookie
  const dx = worldX - cookie.x;
  const dy = worldY - bobY;
  const dist = Math.sqrt(dx * dx + dy * dy);
  
  if (dist < cookie.radius && cookie.clickCooldown <= 0) {
    // increment click counter
    cookie.clickCount = (cookie.clickCount || 0) + 1;
    // Create 5-8 dropped cookies
    const numCookies = Math.floor(Math.random() * 4) + 5;
    for (let i = 0; i < numCookies; i++) {
      const angle = (Math.PI * 2 * i) / numCookies + (Math.random() - 0.5) * 0.5;
      const speed = Math.random() * 4 + 3;
      
      G.droppedCookies.push({
        x: cookie.x,
        y: bobY,
        vx: Math.cos(angle) * speed,
        vy: Math.sin(angle) * speed - 6,
        size: Math.random() * 3 + 5,
        rotation: Math.random() * Math.PI * 2,
        rotationSpeed: (Math.random() - 0.5) * 0.15,
        life: 120
      });
    }
    
    cookie.clickCooldown = 20; // Prevent spam clicking
    return true;
  }
  return false;
}

function drawBats() {
  for (let bat of G.bats) {
    if (!isEffectVisibleInWorld(bat.x, bat.y, bat.width, bat.height, 120)) continue;
    ctx.save();
    
    // Hit flash
    if (bat.hitFlash > 0) {
      ctx.fillStyle = "#f00";
    } else if (bat.state === BAT_STATE.LUNGE) {
      ctx.fillStyle = "#c44"; // red when lunging
    } else {
      ctx.fillStyle = "#6b4c8a"; // purple
    }
    
    // Body
    ctx.beginPath();
    ctx.ellipse(
      bat.x + bat.width / 2,
      bat.y + bat.height / 2,
      bat.width / 2,
      bat.height / 2,
      0, 0, Math.PI * 2
    );
    ctx.fill();
    
    // Wings (animated)
    const wingSpread = Math.sin(bat.wingFlap) * 8;
    
    ctx.fillStyle = bat.hitFlash > 0 ? "#f00" : "#4a3a5a";
    
    // Left wing
    ctx.beginPath();
    ctx.moveTo(bat.x + bat.width / 2, bat.y + bat.height / 2);
    ctx.lineTo(bat.x - wingSpread, bat.y + bat.height / 2 - 6);
    ctx.lineTo(bat.x - wingSpread - 6, bat.y + bat.height / 2 + 4);
    ctx.closePath();
    ctx.fill();
    
    // Right wing
    ctx.beginPath();
    ctx.moveTo(bat.x + bat.width / 2, bat.y + bat.height / 2);
    ctx.lineTo(bat.x + bat.width + wingSpread, bat.y + bat.height / 2 - 6);
    ctx.lineTo(bat.x + bat.width + wingSpread + 6, bat.y + bat.height / 2 + 4);
    ctx.closePath();
    ctx.fill();
    
    // Eyes
    ctx.fillStyle = "#ff0";
    if (bat.state === BAT_STATE.LUNGE) {
      ctx.fillStyle = "#f00"; // red eyes when attacking
    }
    
    const eyeX = bat.facing > 0 ? bat.x + 14 : bat.x + 6;
    ctx.fillRect(eyeX, bat.y + 8, 3, 3);
    ctx.fillRect(eyeX + 4, bat.y + 8, 3, 3);
    
    ctx.restore();
  }
}

// Add bat to wave spawn
function spawnBat(x, y, hp) {
  G.bats.push(createBat(x, y, hp));
  createSpawnEffect(x, y);
}

const player = {
  x: 50,
  y: 50,
  dx: 0,
  dy: 0,
  width: 32,
  height: 64,
  speed: 3,
  jumpPower: 11,
  wallJumpPower: 11,
  onGround: false,
  onWall: false,
  wallDir: 0,
  wallJumpBoost: 0,
  prevOnGround: false,
  // Crouch
  crouching: false,
  crouchHeight: 40,
  slowMultiplier: 1,
  
  attacking: false,
  attackDuration: 10, // frames
  attackTimer: 0,
  attackCooldown: 30, // frames
  attackDir: 1, // 1 = right, -1 = left
  featherBootsTimer: 0,
  dashBatteryTimer: 0,
  dashCooldownMultiplier: 1
};

player.facing = 1; // 1 = right, -1 = left, default right

player.attackCharging = false;
player.attackChargeTime = 0;
player.maxChargeTime = 30;       // frames to fully charge
player.attackTimer = 0;          // counts down swing duration
player.attackCooldown = 0;       // prevents spamming
player.attackDuration = 20;      // frames the swing lasts
player.attackKnockback = 2;      // scales with charge
player.attackHitObjects = new Set(); // track hits per swing
player.swordTimer = 0;
player.swordDuration = 10;
player.swordCooldown = 0;
player.swordBaseCooldown = 12;
player.swordDir = "right";
player.swordHitObjects = new Set();
player.featherBootsTimer = 0;
player.dashBatteryTimer = 0;
player.dashCooldownMultiplier = 1;

// --- PLAYER ANIM STATE ---
player.walkFrame    = 0;
player.walkTimer    = 0;
player.animState    = "idle"; // "idle" | "walk" | "jump" | "fall" | "attack" | "dash" | "crouch"
// --- DASH ---
player.dashSpeed = 14;
player.dashDuration = 0;       // frames remaining in dash
player.dashMaxDuration = 12;   // how long the dash lasts
player.dashCooldown = 0;
player.dashMaxCooldown = 50;   // ~0.8s at 60fps
player.dashUsedInAir = false;  // one air dash per jump
player.dashActive = false;
// --- ROLL (ground-only dash alternative)
player.rollSpeed = 10;
player.rollDuration = 0;
player.rollMaxDuration = 30; // frames
player.rollCooldown = 0;
player.rollMaxCooldown = 40;
player.rollActive = false;
player.speedChiliTimer = 0;
player.speedChiliDirection = 0;
player.speedChiliTrailCooldown = 0;

function addEnemyHealth() {
  // G.snails get 1-2 HP
  for (let s of G.snails) {
    if (!s.hp) s.hp = 1;
    if (!s.maxHp) s.maxHp = s.hp;
  }
  
  // Super G.snails get 3-4 HP
  for (let s of G.SuperSnails) {
    if (!s.hp) s.hp = 3;
    if (!s.maxHp) s.maxHp = s.hp;
  }

  for (let m of G.babyMicrowaves) {
    if (!m.hp) m.hp = 2;
    if (!m.maxHp) m.maxHp = m.hp;
  }
  
  // G.yetis already have HP in your code (5)
  for (let y of G.yetis) {
    if (!y.hp) y.hp = 5;
    if (!y.maxHp) y.maxHp = y.hp;
  }
  
  // G.snowmen get 4 HP
  for (let s of G.snowmen) {
    if (!s.hp) s.hp = 4;
    if (!s.maxHp) s.maxHp = s.hp;
  }
  
  // G.turrets get 2 HP (can be destroyed!)
  for (let t of G.turrets) {
    if (!t.hp) t.hp = 2;
    if (!t.maxHp) t.maxHp = t.hp;
  }
}

// Handle damage to enemies
function damageEnemy(enemy, damage, knockbackDir) {
  if (enemy.tutorialDisplay) return false;
  if (!enemy.hp) enemy.hp = 1; // safety
  
  enemy.hp -= damage;
  
  // Apply knockback
  enemy.knockbackTimer = 10;
  enemy.knockbackDx = knockbackDir.x;
  enemy.knockbackDy = knockbackDir.y;
  
  // Visual hit flash
  enemy.hitFlash = 5; // frames to show red
  
  // Death
  if (enemy.hp <= 0) {
    enemy.dead = true;
    return true; // enemy died
  }
  
  return false; // enemy survived
}

// Draw health bars for all enemies
function drawEnemyHealthBars() {
  if (!settings.enemyHealthBars) return;
  ctx.save();
  
  // G.snails
  for (let s of G.snails) {
    if (!s.hp || s.hp <= 0) continue;
    
    const barWidth = 24;
    const barHeight = 4;
    const x = s.x + (s.width - barWidth) / 2;
    const y = s.y - 8;
    
    // Background
    ctx.fillStyle = "#300";
    ctx.fillRect(x, y, barWidth, barHeight);
    
    // Health
    const healthPercent = s.hp / s.maxHp;
    ctx.fillStyle = healthPercent > 0.5 ? "#0f0" : healthPercent > 0.25 ? "#ff0" : "#f00";
    ctx.fillRect(x, y, barWidth * healthPercent, barHeight);
    
    // Border
    ctx.strokeStyle = "#000";
    ctx.lineWidth = 1;
    ctx.strokeRect(x, y, barWidth, barHeight);
  }
  for (let c of G.chairs) {
    if (!c.hp || c.hp <= 0) continue;
    const barWidth = 32;
    const barHeight = 4;
    const x = c.x + (c.width - barWidth) / 2;
    const y = c.y - 8;
    ctx.fillStyle = "#300";
    ctx.fillRect(x, y, barWidth, barHeight);
    const hp = c.hp / c.maxHp;
    ctx.fillStyle = hp > 0.5 ? "#0f0" : hp > 0.25 ? "#ff0" : "#f00";
    ctx.fillRect(x, y, barWidth * hp, barHeight);
    ctx.strokeStyle = "#000";
    ctx.lineWidth = 1;
    ctx.strokeRect(x, y, barWidth, barHeight);
  }
  for (let b of G.bats) {
    if (!b.hp || b.hp <= 0) continue;
    
    const barWidth = 24;
    const barHeight = 4;
    const x = b.x + (b.width - barWidth) / 2;
    const y = b.y - 8;
    
    // Background
    ctx.fillStyle = "#300";
    ctx.fillRect(x, y, barWidth, barHeight);
    
    // Health
    const healthPercent = b.hp / b.maxHp;
    ctx.fillStyle = healthPercent > 0.5 ? "#0f0" : healthPercent > 0.25 ? "#ff0" : "#f00";
    ctx.fillRect(x, y, barWidth * healthPercent, barHeight);
    
    // Border
    ctx.strokeStyle = "#000";
    ctx.lineWidth = 1;
    ctx.strokeRect(x, y, barWidth, barHeight);
  }
  // Super G.snails
  for (let s of G.SuperSnails) {
    if (!s.hp || s.hp <= 0) continue;
    
    const barWidth = 28;
    const barHeight = 4;
    const x = s.x + (s.width - barWidth) / 2;
    const y = s.y - 8;
    
    ctx.fillStyle = "#300";
    ctx.fillRect(x, y, barWidth, barHeight);
    
    const healthPercent = s.hp / s.maxHp;
    ctx.fillStyle = healthPercent > 0.5 ? "#0f0" : healthPercent > 0.25 ? "#ff0" : "#f00";
    ctx.fillRect(x, y, barWidth * healthPercent, barHeight);
    
    ctx.strokeStyle = "#000";
    ctx.lineWidth = 1;
    ctx.strokeRect(x, y, barWidth, barHeight);
  }

  for (let m of G.babyMicrowaves) {
    if (!m.hp || m.hp <= 0) continue;

    const barWidth = 24;
    const barHeight = 4;
    const x = m.x + (m.width - barWidth) / 2;
    const y = m.y - 8;

    ctx.fillStyle = "#300";
    ctx.fillRect(x, y, barWidth, barHeight);

    const healthPercent = m.hp / m.maxHp;
    ctx.fillStyle = healthPercent > 0.5 ? "#0f0" : healthPercent > 0.25 ? "#ff0" : "#f00";
    ctx.fillRect(x, y, barWidth * healthPercent, barHeight);

    ctx.strokeStyle = "#000";
    ctx.lineWidth = 1;
    ctx.strokeRect(x, y, barWidth, barHeight);
  }
  
  // G.yetis
  for (let y of G.yetis) {
    if (!y.alive || !y.hp || y.hp <= 0) continue;
    
    const barWidth = 40;
    const barHeight = 5;
    const x = y.x + (y.width - barWidth) / 2;
    const yPos = y.y - 10;
    
    ctx.fillStyle = "#300";
    ctx.fillRect(x, yPos, barWidth, barHeight);
    
    const healthPercent = y.hp / y.maxHp;
    ctx.fillStyle = healthPercent > 0.5 ? "#0f0" : healthPercent > 0.25 ? "#ff0" : "#f00";
    ctx.fillRect(x, yPos, barWidth * healthPercent, barHeight);
    
    ctx.strokeStyle = "#000";
    ctx.lineWidth = 1;
    ctx.strokeRect(x, yPos, barWidth, barHeight);
  }
  
  // G.snowmen
  for (let s of G.snowmen) {
    if (!s.hp || s.hp <= 0) continue;
    
    const barWidth = 30;
    const barHeight = 4;
    const x = s.x + (s.width - barWidth) / 2;
    const y = s.y - 8;
    
    ctx.fillStyle = "#300";
    ctx.fillRect(x, y, barWidth, barHeight);
    
    const healthPercent = s.hp / s.maxHp;
    ctx.fillStyle = healthPercent > 0.5 ? "#0f0" : healthPercent > 0.25 ? "#ff0" : "#f00";
    ctx.fillRect(x, y, barWidth * healthPercent, barHeight);
    
    ctx.strokeStyle = "#000";
    ctx.lineWidth = 1;
    ctx.strokeRect(x, y, barWidth, barHeight);
  }
  
  // G.turrets
  for (let t of G.turrets) {
    if (!t.hp || t.hp <= 0) continue;
    
    const barWidth = 32;
    const barHeight = 4;
    const x = t.x;
    const y = t.y - 6;
    
    ctx.fillStyle = "#300";
    ctx.fillRect(x, y, barWidth, barHeight);
    
    const healthPercent = t.hp / t.maxHp;
    ctx.fillStyle = healthPercent > 0.5 ? "#0f0" : healthPercent > 0.25 ? "#ff0" : "#f00";
    ctx.fillRect(x, y, barWidth * healthPercent, barHeight);
    
    ctx.strokeStyle = "#000";
    ctx.lineWidth = 1;
    ctx.strokeRect(x, y, barWidth, barHeight);
  }
  
  ctx.restore();
}

// Update hit flash effect
function updateEnemyHitFlashes() {
  for (let s of [...G.snails, ...G.SuperSnails, ...G.snowmen, ...G.tables, ...G.babyMicrowaves]) {
    if (s.hitFlash > 0) s.hitFlash--;
  }
  
  for (let y of G.yetis) {
    if (y.hitFlash > 0) y.hitFlash--;
  }
  
  for (let t of G.turrets) {
    if (t.hitFlash > 0) t.hitFlash--;
  }
}

// === ADVANCED WAVE SYSTEM ===

let xp = 0;
let xpLevel = 1;
let xpToNext = 60; // XP needed for first level-up

// Active passive upgrades the player has collected
const playerUpgrades = {
  orbiters: [],         // orbiting projectiles
  homingEnabled: false, // periodic homing shot
  homingTimer: 0,
  // Wolf companion
  wolf: null,  // null = not unlocked
  dashDamageEnabled: false,
  homingRate: 1,          // ← new: multiplier for fire rate
  homingExplosive: false, // ← new
  dashInvulEnabled: false,      // ← new: Ghost Dash upgrade
  dashHitEnemies: new Set(),    // ← new: tracks who was hit this dash
  extraJumpsMax: 0,     // double-jump charges
  extraJumpsLeft: 0,
  swordVampEnabled: false,  // ← new
  cannonBounceEnabled: false, // ← new
  cannonRapidEnabled: false,  // ← new
  rollEnabled: false,         // ground roll upgrade
};

// Level-up UI state
let levelUpInputDelay = 0; // frames before input is accepted
let levelUpPending = false;
let levelUpCards = [];       // 3 cards offered this level-up
let levelUpSelectedIndex = 0;

// XP rewards per enemy type
const XP_TABLE = {
  snail:      8,
  superSnail: 20,
  bat:        12,
  yeti:       25,
  snowman:    18,
  babyMicrowave: 14,
  turret:     15,
  chair:      10,
  table:      18,
};

// Gold rewards per enemy type
const GOLD_TABLE = {
  snail:      2,
  superSnail: 6,
  bat:        3,
  yeti:       10,
  snowman:    5,
  babyMicrowave: 4,
  turret:     4,
  chair:      2,
  table:      5,
};

// Full upgrade pool — each entry is one possible card
const UPGRADE_POOL = [
  {
    id: "wolf",
    name: "Master of the Wolf",
    desc: "A loyal wolf companion follows you and attacks nearby enemies",
    icon: "🐺",
    apply() {
      playerUpgrades.wolf = {
        x: player.x - 40, y: player.y,
        width: 32, height: 24,
        hp: 8, maxHp: 8,
        speed: 3.2,
        damage: 1,
        attackRate: 40,
        attackCooldown: 0,
        range: 180,
        facing: 1,
        frame: 0, frameTimer: 0,
        moving: false, lunging: false,
        biteFlash: 0, hitFlash: 0,
        iframes: 0,
        dy: 0,
        dead: false,
        elite: false,
      };
      potatoMessage = "🐺 a wolf emerges from the shadows";
      potatoMessageTimer = 200;
    }
  },
  {
    id: "wolfElite",
    name: "Alpha Wolf",
    desc: "Wolf becomes elite — more HP, faster attacks, bigger range",
    icon: "🐺⚡",
    apply() {
      const w = playerUpgrades.wolf;
      if (!w) return;
      w.elite = true;
      w.hp = w.maxHp = 20;
      w.damage = 2;
      w.attackRate = 22;
      w.range = 280;
      w.speed = 4.5;
      w.dead = false; // revive if dead
      potatoMessage = "🐺 the wolf awakens";
      potatoMessageTimer = 200;
    }
  },
  {
    id: "wolfRevive",
    name: "Pack Bond",
    desc: "Wolf automatically revives 10 seconds after dying",
    icon: "🐺❤️",
    apply() { playerUpgrades.wolfAutoRevive = true; }
  },
  {
  id: "dashInvul",
  name: "Ghost Dash",
  desc: "Become invulnerable while dashing",
  icon: "👻",
  apply() { playerUpgrades.dashInvulEnabled = true; }
},
  {
  id: "potato",
  name: "Potato Cannon",
  desc: "Gain the 🥔 — aim and fire with mouse/joystick",
  icon: "🥔",
  apply() {
    hasPotato = true;
    potatoState = "raw";
    potato.collected = true;
    potatoMessage = "The potato accepts you.";
    potatoMessageTimer = 180;
    potatoHUDLine = "🥔 something feels different";
    camera.x += (Math.random() - 0.5) * 13;
    camera.y += (Math.random() - 0.5) * 15;
    syncJoystickVisibility();
  }
},
  {
    id: "speed1",
    name: "Swift Boots",
    desc: "+25% move speed",
    icon: "👟",
    apply() { player.speed *= 1.25; }
  },
  {
    id: "jump1",
    name: "Spring Legs",
    desc: "+20% jump height",
    icon: "🦵",
    apply() { player.jumpPower *= 1.20; player.wallJumpPower *= 1.20; }
  },
  {
    id: "dashCooldown",
    name: "Slipstream",
    desc: "Dash cooldown halved",
    icon: "💨",
    apply() { player.dashMaxCooldown = Math.max(10, Math.floor(player.dashMaxCooldown * 0.5)); }
  },
  {
    id: "extraJump",
    name: "Double Jump",
    desc: "Gain an extra mid-air jump",
    icon: "🌀",
    apply() { playerUpgrades.extraJumpsMax++; playerUpgrades.extraJumpsLeft = playerUpgrades.extraJumpsMax; }
  },
  {
    id: "swordSpeed",
    name: "Blade Fury",
    desc: "Sword swings 40% faster",
    icon: "⚔️",
    apply() { player.attackDuration = Math.max(4, Math.floor(player.attackDuration * 0.6)); }
  },
  {
    id: "swordKnockback",
    name: "Heavy Blade",
    desc: "Double sword knockback",
    icon: "🗡️",
    apply() { player.attackKnockback *= 2; }
  },
  {
    id: "orbiter",
    name: "Stone Orbit",
    desc: "A rock orbits you, damaging enemies",
    icon: "🪨",
    apply() {
      playerUpgrades.orbiters.push({
        angle: Math.random() * Math.PI * 2,
        speed: 0.07,
        radius: 52,
        size: 10,
        damage: 1,
        hitCooldowns: new Map() // enemy → timer so it doesn't spam
      });
    }
  },
  {
    id: "orbiter2",
    name: "Twin Orbit",
    desc: "A second orbiting rock joins you",
    icon: "🌑",
    apply() {
      playerUpgrades.orbiters.push({
        angle: Math.PI, // offset from first
        speed: 0.07,
        radius: 52,
        size: 10,
        damage: 1,
        hitCooldowns: new Map()
      });
    }
  },
  {
    id: "homing",
    name: "Seeker Shot",
    desc: "Auto-fires homing bolts at enemies",
    icon: "🎯",
    apply() { playerUpgrades.homingEnabled = true; playerUpgrades.homingTimer = 0; }
  },
  {
    id: "dashDamage",
    name: "Warp Strike",
    desc: "Dashing through enemies damages them",
    icon: "⚡",
    apply() { playerUpgrades.dashDamageEnabled = true; }
  },
    {
      id: "roll",
      name: "Ground Roll",
      desc: "Perform a low, fast roll along the ground to evade and move quickly.",
      icon: "🛞",
      apply() { playerUpgrades.rollEnabled = true; }
    },
  {
    id: "maxSpeed",
    name: "Turbo",
    desc: "+40% move speed",
    icon: "🏃",
    apply() { player.speed *= 1.40; }
  },
  {
    id: "dashDistance",
    name: "Hyperdash",
    desc: "Dash distance +50%",
    icon: "🔥",
    apply() { player.dashSpeed *= 1.25; player.dashMaxDuration = Math.floor(player.dashMaxDuration * 1.25); }
  },
  // === SWORD BRANCH ===
  {
    id: "swordRange",
    name: "Long Reach",
    desc: "Sword radius +50%",
    icon: "🔱",
    apply() { /* radius is calculated from a const — store a multiplier */
      playerUpgrades.swordRangeMulti = (playerUpgrades.swordRangeMulti || 1) * 1.5;
    }
  },
  {
    id: "swordVamp",
    name: "Soul Blade",
    desc: "Killing with the sword restores 1 life (once per wave)",
    icon: "🩸",
    apply() { playerUpgrades.swordVampEnabled = true; playerUpgrades.swordVampUsed = false; }
  },

  // === ORBIT BRANCH ===
  {
    id: "orbiter3",
    name: "Triple Orbit",
    desc: "A third orbiting rock joins you",
    icon: "🌕",
    apply() {
      playerUpgrades.orbiters.push({
        angle: Math.PI * 4 / 3,
        speed: 0.07,
        radius: 52,
        size: 10,
        damage: 1,
        hitCooldowns: new Map()
      });
    }
  },
  {
    id: "orbiterFast",
    name: "Rapid Orbit",
    desc: "All orbiting rocks spin twice as fast",
    icon: "💫",
    apply() { for (const o of playerUpgrades.orbiters) o.speed *= 2; playerUpgrades.orbitSpeedBonus = 2; }
  },

  // === HOMING BRANCH ===
  {
    id: "homingRate",
    name: "Missile Barrage",
    desc: "Seeker Shot fires twice as often",
    icon: "🚀",
    apply() { playerUpgrades.homingRate = (playerUpgrades.homingRate || 1) * 2; }
  },
  {
    id: "homingExplosive",
    name: "Seeker Bomb",
    desc: "Homing bolts explode on impact",
    icon: "💥",
    apply() { playerUpgrades.homingExplosive = true; }
  },

  // === CANNON BRANCH ===
  {
    id: "cannonRapid",
    name: "Rapid Fire",
    desc: "Cannon fires twice as fast",
    icon: "🔫",
    apply() { playerUpgrades.cannonRapidEnabled = true; }
  },
  {
    id: "cannonBounce",
    name: "Ricochet",
    desc: "Cannon shots bounce off walls once",
    icon: "↩️",
    apply() { playerUpgrades.cannonBounceEnabled = true; }
  },
];

// Track which upgrades the player already has (for de-duplication where needed)
const ownedUpgradeIds = new Set();

// === WAVE DEFINITIONS PER MAP ===

const waveConfigurations = {
  // Level 1 Waves - Tutorial-style progression
  level1:
  [
    {
      name: "First Contact",
      enemies: [
        { type: "snail", count: { min: 2, max: 3 }, hp: 1 }
      ],
      spawnDelay: 60,
      message: "🌊 Wave 1: First Contact"
    },
    {
      name: "Air Assault",
      enemies: [
        { type: "bat", count: { min: 2, max: 4 }, hp: 2 },
        { type: "snail", count: 3, hp: 1 }
      ],
      spawnDelay: 50,
      message: "Wave 2: 🦇 From Above!"
    },
    {
      name: "Double Trouble",
      enemies: [
        { type: "snail", count: { min: 3, max: 4 }, hp: 1 },
        { type: "turret", count: 1, hp: 2 }
      ],
      spawnDelay: 50,
      message: "🌊 Wave 3: Double Trouble"
    },
    {
      name: "Speed Demons",
      enemies: [
        { type: "snail", count: 2, hp: 1 },
        { type: "bat", count: 2, hp: 2 },
        { type: "table", count: 1, hp: 4 }
      ],
      spawnDelay: 45,
      message: "🌊 Wave 4: Speed Demons"
    },
    {
      name: "Mixed Assault",
      enemies: [
        { type: "snail", count: { min: 3, max: 5 }, hp: 1 },
        { type: "superSnail", count: 2, hp: 3 },
        { type: "turret", count: { min: 1, max: 2 }, hp: 2 },
        { type: "table", count: 1, hp: 5 }
      ],
      spawnDelay: 40,
      message: "🌊 Wave 5: Mixed Assault"
    },
    {
      name: "Boss Wave",
      enemies: [
        { type: "snail", count: 4, hp: 2 }, // tougher G.snails
        { type: "superSnail", count: 3, hp: 4 },
        { type: "turret", count: 2, hp: 3 },
        { type: "bat", count: 2, hp: 2 },
        { type: "babyMicrowave", count: { min: 2, max: 3 }, hp: 3 },
        { type: "table", count: 2, hp: 5 }
      ],
      spawnDelay: 35,
      message: "⚔️ BOSS WAVE!"
    },
    // Wave 6+ uses random generation
    {
      name: "Random Wave",
      random: true,
      randomConfig: {
        enemyPool: ["snail", "superSnail", "turret","babyMicrowave", "bat", "table"],
        totalEnemies: { min: 10, max: 20},
        hpMultiplier: 1.2
      },
      spawnDelay: 35,
      message: "🎲 Random Wave"
    }
  ],
  
  // Level 2 Waves - More complex
  level2: [
    {
      name: "Warm Up",
      enemies: [
        { type: "snail", count: { min: 4, max: 5 }, hp: 1 },
        { type: "turret", count: 1, hp: 2 }
      ],
      spawnDelay: 50
    },
    {
      name: "Swarm",
      enemies: [
        { type: "snail", count: { min: 6, max: 8 }, hp: 1 }
      ],
      spawnDelay: 30,
      message: "🐌 SNAIL SWARM!"
    },
    {
      name: "Elite Squad",
      enemies: [
        { type: "superSnail", count: { min: 3, max: 5 }, hp: 4 },
        { type: "turret", count: 2, hp: 3 }
      ],
      spawnDelay: 40
    },
    {
      name: "Random Chaos",
      random: true,
      randomConfig: {
        enemyPool: ["snail", "superSnail", "turret", "babyMicrowave"],
        totalEnemies: { min: 10, max: 15 },
        hpMultiplier: 1.3
      },
      spawnDelay: 35
    }
  ],
  
  // Level 3 Waves - Christmas themed
  level3: [
    {
      name: "Winter Greeting",
      enemies: [
        { type: "snail", count: { min: 2, max: 3 }, hp: 1 },
        { type: "snowman", count: 1, hp: 4 }
      ],
      spawnDelay: 60,
      message: "❄️ Winter is Coming"
    },
    {
      name: "Frosty Friends",
      enemies: [
        { type: "snowman", count: { min: 2, max: 3 }, hp: 4 },
        { type: "turret", count: 1, hp: 2 }
      ],
      spawnDelay: 50
    },
    {
      name: "Ice & Fire",
      enemies: [
        { type: "snail", count: 3, hp: 1 },
        { type: "snowman", count: 2, hp: 5 },
        { type: "turret", count: { min: 2, max: 3 }, hp: 2 }
      ],
      spawnDelay: 45
    },
    {
      name: "Yeti Attack",
      enemies: [
        { type: "yeti", count: { min: 1, max: 2 }, hp: 6 },
        { type: "snowman", count: { min: 1, max: 2 }, hp: 4 }
      ],
      spawnDelay: 50,
      message: "🦣 YETI ATTACK!"
    },
    {
      name: "Winter Boss",
      enemies: [
        { type: "yeti", count: 2, hp: 8 },
        { type: "snowman", count: 3, hp: 6 },
        { type: "superSnail", count: 2, hp: 4 }
      ],
      spawnDelay: 40,
      message: "❄️⚔️ WINTER BOSS WAVE!"
    },
    {
      name: "Endless Winter",
      random: true,
      randomConfig: {
        enemyPool: ["snail", "superSnail", "yeti", "snowman", "turret"],
        totalEnemies: { min: 10, max: 15 },
        hpMultiplier: 1.4
      },
      spawnDelay: 35
    }
  ],
  
  // Level 4 Waves - Chaos
  level4: [
    {
      name: "Box Chaos Start",
      enemies: [
        { type: "snail", count: { min: 10, max: 15 }, hp: 1 }
      ],
      spawnDelay: 20,
      message: "📦 CHAOS BEGINS"
    },
    {
      name: "Snack Time",
      enemies: [
        { type: "snail", count: 4, hp: 1 },
        { type: "babyMicrowave", count: { min: 2, max: 3 }, hp: 3 },
        { type: "turret", count: 1, hp: 2 }
      ],
      spawnDelay: 30,
      message: "🍼 BABY MICROWAVE PARADE"
    },
    {
      name: "Everything",
      random: true,
      randomConfig: {
        enemyPool: ["snail", "superSnail", "turret", "babyMicrowave"],
        totalEnemies: { min: 20, max: 30},
        hpMultiplier: 1.5
      },
      spawnDelay: 25
    }
  ]
};

// Generate a random wave based on config
function generateRandomWave(config, waveNumber = 1) {
  const totalEnemies = typeof config.totalEnemies === 'number' 
    ? config.totalEnemies 
    : randomBetween(config.totalEnemies.min, config.totalEnemies.max);
  
  // Scale total enemies with wave number (1.1x per wave)
  const scaledTotalEnemies = Math.ceil(totalEnemies * Math.pow(1.1, waveNumber - 1));
  
  const enemies = [];
  
  // Wave scaling multiplier: grows progressively, 1.1x per wave
  const waveScaling = Math.pow(1.1, waveNumber - 1);
  
  for (let i = 0; i < scaledTotalEnemies; i++) {
    const enemyType = config.enemyPool[Math.floor(Math.random() * config.enemyPool.length)];
    
    // Base HP per enemy type
    const baseHP = {
      snail: 1,
      superSnail: 3,
      turret: 2,
      yeti: 5,
      snowman: 4,
      table: 4,
      babyMicrowave: 2
    };
    
    // Apply both config multiplier and wave scaling
    const totalMultiplier = (config.hpMultiplier - 0.2 || 1) * waveScaling;
    
    enemies.push({
      type: enemyType,
      count: 1,
      hp: Math.ceil(baseHP[enemyType] * totalMultiplier)
    });
  }
  
  return { enemies };
}

// Random number between min and max (inclusive)
function randomBetween(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

// Initialize wave mode for a level
function startWaveMode(levelNumber) {
  cheeses = [];
  G.wavesystem.enabled = true;
  G.wavesystem.currentWave = 0;
  G.wavesystem.enemiesRemaining = 0;
  G.wavesystem.waveActive = false;
  G.wavesystem.waveTimer = 180; // 3 second delay before first wave
  G.wavesystem.totalEnemiesKilled = 0;
  G.wavesystem.spawnQueue = [];
  
  // Load wave config for this level
  const levelKey = `level${levelNumber}`;
  G.wavesystem.currentMapWaves = waveConfigurations[levelKey] || waveConfigurations.level1;
  
  // Clear existing enemies
  G.snails = [];
  G.SuperSnails = [];
  G.yetis = [];
  G.snowmen = [];
  G.babyMicrowaves = [];
  G.turrets = [];
  G.bats = [];
  G.tables = [];
  
  potatoMessage = "🌊 WAVE MODE STARTING...";
  potatoMessageTimer = 120;
}

// Start the next wave
function startNextWave() {
  if (!G.wavesystem.currentMapWaves) {
    potatoMessage = "🌊 no wave config for this map";
    potatoMessageTimer = 120;
    buildMode = false;
    return;
  }

  // Shopkeepers are intermission-only and should not persist into active waves.
  G.shopkeepers.length = 0;
  closeInventory();
  closeShopUI();

  G.wavesystem.currentWave++;
  G.wavesystem.waveActive = true;
  G.wavesystem.waveTimer = 0;

  playerUpgrades.swordVampUsed = false;
  // Get wave config
  let waveIndex = Math.min (G.wavesystem.currentWave - 1, G.wavesystem.currentMapWaves.length - 1);
  let waveConfig = G.wavesystem.currentMapWaves[waveIndex];
  
  // If this is a random wave, generate it
  if (waveConfig.random) {
    const generated = generateRandomWave(waveConfig.randomConfig, G.wavesystem.currentWave);
    waveConfig = { ...waveConfig, ...generated };
  }
  
  // Show wave message
  if (waveConfig.message) {
    potatoMessage = waveConfig.message;
  } else {
    potatoMessage = `🌊 Wave ${G.wavesystem.currentWave}`;
  }
  potatoMessageTimer = 120;
  
  // Build spawn queue
  G.wavesystem.spawnQueue = [];
  let delayCounter = 0;
  
  for (let enemyDef of waveConfig.enemies) {
    // Determine count (can be fixed number or range)
    let count;
    if (typeof enemyDef.count === 'number') {
      count = enemyDef.count;
    } else {
      count = randomBetween(enemyDef.count.min, enemyDef.count.max);
    }
    
    // Add to spawn queue
    for (let i = 0; i < count; i++) {
      G.wavesystem.spawnQueue.push({
        type: enemyDef.type,
        hp: enemyDef.hp,
        delay: delayCounter
      });
      delayCounter += waveConfig.spawnDelay;
    }
  }
  
  // Shuffle spawn queue for variety
  G.wavesystem.spawnQueue.sort(() => Math.random() - 0.5);
  
  G.wavesystem.enemiesRemaining = G.wavesystem.spawnQueue.length;
  G.wavesystem.spawnTimer = 0;
  const boxCount = 2 + Math.floor (G.wavesystem.currentWave * 0.5);
  for (let i = 0; i < boxCount; i++) {
    const pos = getSpawnPosition('snail'); // reuse spawn zones
    boxes.push(createBox(
      pos.x + (Math.random() - 0.5) * 200,
      pos.y - 40,
      BOX_TYPE.BREAKABLE
    ));
  }
}

// Spawn positions for different enemy types
function getSpawnPosition(type) {
  // Get valid spawn zones based on current level
  // Prefer level-defined spawn zones if present
  let spawnZones = [];
  if (levelSpawnZones && levelSpawnZones.length) {
    // Convert rectangular zones into candidate points
    for (const z of levelSpawnZones) {
      spawnZones.push({ x: z.x + (z.width||0)/2, y: z.y + (z.height||0)/2 });
    }
  }

  if (!spawnZones.length) {
    if (currentLevel === 1) {
    spawnZones = [
      { x: 100, y: 650 },
      { x: 800, y: 400 },
      { x: 1500, y: 1000 },
      { x: 2200, y: 400 }
    ];
  } else if (currentLevel === 2) {
    spawnZones = [
      { x: 200, y: 1000 },
      { x: 1000, y: 875 },
      { x: 2000, y: 900 }
    ];
  } else if (currentLevel === 3) {
    spawnZones = [
      { x: 300, y: 100 },
      { x: 900, y: 100 },
      { x: 1500, y: 100 },
      { x: 2100, y: 100 }
    ];
  } else {
    spawnZones = [
      { x: 200, y: 100 },
      { x: 1400, y: 100 },
      { x: 2400, y: 100 }
    ];
  }
  
  // Pick random spawn zone
  let zone = spawnZones[Math.floor(Math.random() * spawnZones.length)];
  
  return {
    x: zone.x + (Math.random() - 0.5) * 100,
    y: zone.y
  };
}
}
// Spawn an enemy with custom HP
function spawnEnemy(type, hp) {
  let pos = getSpawnPosition(type);
  
  switch(type) {
    case 'snail':
      G.snails.push({
        x: pos.x + Math.random() * 100,
        y: pos.y,
        width: 28,
        height: 20,
        dx: 0,
        dy: 0,
        dir: Math.random() > 0.5 ? 1 : -1,
        speed: 0.6 + Math.random() * 0.3,
        gravity: 0.6,
        chaseRange: 400 + Math.random() * 200,
        knockbackTimer: 0,
        knockbackDx: 0,
        knockbackDy: 0,
        hp: hp || 1,
        maxHp: hp || 1,
        hitFlash: 0,
        frame: 0, 
        frameTimer: 0
      });
      break;
      
    case 'superSnail':
      G.SuperSnails.push({
        x: pos.x + Math.random() * 100,
        y: pos.y,
        width: 28,
        height: 20,
        dx: 0,
        dy: 0,
        speed: 1.2 + Math.random() * 1,
        gravity: 0.5,
        dir: Math.random() > 0.5 ? 1 : -1,
        jumpPower: -14,
        mode: "ground",
        knockbackTimer: 0,
        knockbackDx: 0,
        knockbackDy: 0,
        jumpTimer: 0,
        lastWallSide: null,
        prevMode: "ground",
        hp: hp || 3,
        maxHp: hp || 3,
        hitFlash: 0
      });
      break;
      
    case 'turret':
      G.turrets.push({
        x: pos.x,
        y: pos.y,
        width: 40,  // REQUIRED for collision
        height: 40, // REQUIRED for collision
        cooldown: 0,
        fireRate: 120 + Math.random() * 100,
        hp: hp || 2,
        maxHp: hp || 2,
        hitFlash: 0
      });
      break;
      
    case 'yeti':
      if (isChristmasMap()) {
        G.yetis.push({
          x: pos.x,
          y: pos.y + 1100,
          width: 48,
          height: 64,
          dx: 0,
          dy: 0,
          dead: false,
          speed: 1.2,
          chaseRange: 500,
          hp: hp || 5,
          maxHp: hp || 5,
          alive: true,
          throwCooldown: 0,
          facing: 1,
          knockbackTimer: 0,
          knockbackDx: 0,
          knockbackDy: 0,
          hitFlash: 0
        });
      }
      break;
      
    case 'bat':
    spawnBat(pos.x, pos.y, hp || 2);
    break;

case 'table': {
  const newTable = createTable(pos.x, pos.y);
  newTable.frame = 0;
  newTable.frameTimer = 0;
  newTable.frameSpeed = 8;
  newTable.hp    = hp || 4;
  newTable.maxHp = hp || 4;
  G.tables.push(newTable);
  break;
}
      
    case 'snowman':
      if (isChristmasMap()) {
        G.snowmen.push({
          x: pos.x,
          y: pos.y + 1100,
          width: 26,
          height: 38,
          speed: 0.6 + Math.random() * 1,
          slowRadius: 140,
          slowAmount: 0.45,
          dx: 0,
          facing: 1,
          flurryParticles: [],
          hp: hp || 4,
          maxHp: hp || 4,
          hitFlash: 0
        });
      }
      break;

    case 'babyMicrowave':
      G.babyMicrowaves.push(createBabyMicrowave(pos.x, pos.y, hp || 2));
      break;
      
  }
  
  // Spawn particle effect
  createSpawnEffect(pos.x, pos.y);
}

function createSpawnEffect(x, y) {
  for (let i = 0; i < 12; i++) {
    if (isChristmasMap()) {
      snowParticles.push({
        x: x + (Math.random() - 0.5) * 40,
        y: y - 20,
        speed: 2 + Math.random() * 2,
        size: 2 + Math.random() * 2,
        drift: (Math.random() - 0.5) * 2,
        life: 30
      });
    }
  }
}

// Update wave system
function updateWaveSystem() {
  if (tutorialActive) return;
  if (!G.wavesystem.enabled) return;
  
  trySpawnCheese();

  // Process spawn queue
  if  (G.wavesystem.spawnQueue.length > 0) {
    G.wavesystem.spawnTimer++;
    
    for (let i = G.wavesystem.spawnQueue.length - 1; i >= 0; i--) {
      let spawn = G.wavesystem.spawnQueue[i];
      
      if  (G.wavesystem.spawnTimer >= spawn.delay) {
        spawnEnemy(spawn.type, spawn.hp);
        G.wavesystem.spawnQueue.splice(i, 1);
      }
    }
  }
  
  // Check if wave is complete
  if  (G.wavesystem.waveActive && G.wavesystem.spawnQueue.length === 0) {
    let aliveCount = 0;
    
    aliveCount += G.snails.filter(s => s.hp > 0).length;
    aliveCount += G.SuperSnails.filter(s => s.hp > 0).length;
    aliveCount += G.yetis.filter(y => y.alive && y.hp > 0).length;
    aliveCount += G.snowmen.filter(s => s.hp > 0).length;
    aliveCount += G.turrets.filter(t => t.hp > 0).length;
    aliveCount += G.bats.filter(b => b.hp > 0).length;
    aliveCount += G.tables.filter(t => t.hp > 0).length;
    if (aliveCount === 0) {
      G.wavesystem.waveActive = false;
      G.wavesystem.waveTimer = 0;
      
      giveWaveReward();
      openBuildMode();
      potatoMessage = `✅ Wave ${G.wavesystem.currentWave} Complete! Build, then finish build to shop.`;
      potatoMessageTimer = 180;
    }
  }
  
  // Start next wave after delay
  if (!G.wavesystem.waveActive && G.wavesystem.waveTimer > 0) {
    // Build mode fully pauses intermission countdown.
    if (buildMode) {
      return;
    }

    G.wavesystem.waveTimer--;
    
    if  (G.wavesystem.waveTimer === 0) {
      closeBuildMode();
      startNextWave();
    }
  }
}

// --- Shopkeeper logic ---
function spawnShopkeeper(x, y) {
  const sk = {
    x: x, y: y,
    width: 40, height: 64,
    active: true,
    interactRadius: 60,
    id: 'shop_' + Math.random().toString(36).slice(2,6)
  };
  G.shopkeepers.push(sk);
  return sk;
}

function updateShopkeepers() {
  // remove inactive
  for (let i = G.shopkeepers.length - 1; i >= 0; i--) {
    const s = G.shopkeepers[i];
    if (!s.active) G.shopkeepers.splice(i,1);
  }

  // Safety cleanup for edge-cases where a wave starts before cleanup runs.
  if (G.wavesystem.waveActive && G.shopkeepers.length > 0) {
    G.shopkeepers.length = 0;
    closeInventory();
    closeShopUI();
  }
}

// spawn shopkeepers every few waves (host only / singleplayer)
function maybeSpawnShopkeeperOnWaveComplete() {
  if (G.wavesystem.waveActive) return;
  if (G.shopkeepers.some(s => s.active)) return;

  const w = G.wavesystem.currentWave;
  if (w > 0 && w >= nextShopWindowWave) {
    // pick a spawn position near center
    const pos = { x: Math.min(Math.max(player.x + 300, 200), MAP_WIDTH-200), y: player.y };
    spawnShopkeeper(pos.x, pos.y);
    nextShopWindowWave = w + randomShopGap();
    potatoMessage = 'A shopkeeper has appeared nearby!'; potatoMessageTimer = 240;
    showSpawnHUD('Shopkeeper nearby — E: shop, N: skip to 3s', 260);
  }
}

// Call this when wave completes
const _origGiveWaveReward = giveWaveReward;
giveWaveReward = function() {
  _origGiveWaveReward();
};
function tryInteractWithShop() {
  if (G.wavesystem.enabled && G.wavesystem.waveActive) return false;

  for (const s of G.shopkeepers) {
    if (!s.active) continue;
    const dx = s.x - player.x;
    const dy = s.y - player.y;
    const dist = Math.hypot(dx, dy);
    if (dist <= s.interactRadius) {
      openShopUI();
      potatoMessage = "Welcome to the shop!";
      potatoMessageTimer = 90;
      return true;
    }
  }
  return false;
}

function getNearestShopkeeperDistance() {
  const activeShops = G.shopkeepers.filter(s => s.active);
  if (activeShops.length === 0) return -1;
  let minDist = Infinity;
  for (const s of activeShops) {
    const dx = s.x - player.x;
    const dy = s.y - player.y;
    const dist = Math.hypot(dx, dy);
    if (dist < minDist) minDist = dist;
  }
  return minDist;
}

const _origDraw = draw;
draw = function() {
  _origDraw();
};

// Give player a reward
function giveWaveReward() {
  if (playerLives < maxLives) {
    playerLives++;
    potatoHUDLine = "❤️ Life restored!";
  }
  
  if  (G.wavesystem.currentWave % 3 === 0) {
    player.jumpPower *= 1.03;
    player.speed *= 1.03;
    potatoHUDLine = "⚡ Power increased!";
  }
   setTimeout(() => { potatoHUDLine = ""; }, 3000); 
}

// Track enemy death
function onEnemyKilled(enemyType) {
  if (!G.wavesystem.enabled) return;
  G.wavesystem.totalEnemiesKilled++;
  const gained = XP_TABLE[enemyType] ?? 10;
  const goldGained = GOLD_TABLE[enemyType] ?? 1;
  grantXP(gained);
  playerInventory.gold += goldGained;

  if (inventoryOpen) renderInventory();
  if (shopOpen) renderShop();

  // Small chance to drop a part
  if (Math.random() < 0.12) {
    const pos = getSpawnPosition('snail');
    // Use the last killed enemy position if we can find it
    tryDropPart(pos.x, pos.y);
  }
}

function grantXP(amount) {
  xp += amount;

  // Floating XP text — reuse the potato message system
  potatoMessage = `+${amount} XP`;
  potatoMessageTimer = 40;

  if (xp >= xpToNext) {
    xp -= xpToNext;
    xpLevel++;
    xpToNext = Math.floor(xpToNext * 1.20); // scale requirement up each level
    triggerLevelUp();
  }
}

function openBuildMode() {
  buildMode = true;
  //gamePaused = true; // freeze enemies
}

function closeBuildMode() {
  buildMode = false;
  gamePaused = false;
  buildVehiclesFromStructures();
}

function triggerLevelUp() {
  levelUpPending = true;
  gamePaused = true; // freeze game while choosing
  levelUpInputDelay = 45; // 0.75 seconds before you can pick

  // Pick 3 unique upgrades at random
  // Infinitely-stackable ones (orbiters, speed, etc.) are always available;
  // one-shot ones are excluded if already owned.
const oneShot = new Set([
  "homing", "dashDamage", "extraJump", "potato", "orbiter", "orbiter2", "orbiter3",
  "dashInvul", "swordVamp", "homingExplosive", "wolf", "wolfElite", "wolfRevive",
  "cannonRapid", "cannonBounce", "orbiterFast", "roll"
]);

const available = UPGRADE_POOL.filter(u => {
  if (oneShot.has(u.id) && ownedUpgradeIds.has(u.id)) return false;
  // Branching requirements
  if (u.id === "wolfElite"  && !ownedUpgradeIds.has("wolf")) return false;
  if (u.id === "wolfRevive" && !ownedUpgradeIds.has("wolf")) return false;
  if (u.id === "orbiter2"       && !ownedUpgradeIds.has("orbiter"))    return false;
  if (u.id === "orbiter3"       && !ownedUpgradeIds.has("orbiter2"))   return false;
  if (u.id === "orbiterFast"    && !ownedUpgradeIds.has("orbiter"))    return false;
  if (u.id === "dashDamage"     && !ownedUpgradeIds.has("dashInvul"))  return false;
  if (u.id === "swordRange"     && !ownedUpgradeIds.has("swordSpeed") && !ownedUpgradeIds.has("swordKnockback")) return false;
  if (u.id === "swordVamp"      && !ownedUpgradeIds.has("swordKnockback")) return false;
  if (u.id === "homingRate"     && !ownedUpgradeIds.has("homing"))     return false;
  if (u.id === "homingExplosive"&& !ownedUpgradeIds.has("homing"))     return false;
  if (u.id === "cannonRapid"    && !ownedUpgradeIds.has("potato"))     return false;
  if (u.id === "cannonBounce"   && !ownedUpgradeIds.has("potato"))     return false;
  return true;
});

  // Shuffle and take 3
  const shuffled = available.sort(() => Math.random() - 0.5);
  levelUpCards = shuffled.slice(0, Math.min(3, shuffled.length));
  levelUpSelectedIndex = 0;
}

function chooseLevelUpCard(index) {
  if (levelUpInputDelay > 0) return;
  const card = levelUpCards[index];
  if (!card) return;

  card.apply();
  ownedUpgradeIds.add(card.id);

  levelUpPending = false;
  levelUpCards = [];
  gamePaused = false;
}
// Draw wave UI
function drawWaveUI() {
  if (!G.wavesystem.enabled || gameOver) return;
  
  ctx.save();
  
  ctx.fillStyle = "#fff";
  ctx.font = "bold 24px Arial";
  ctx.textAlign = "right";
  ctx.fillText(`Wave ${G.wavesystem.currentWave}`, canvas.width - 20, 30);
  
  if  (G.wavesystem.waveActive) {
    let aliveCount = 0;
    aliveCount += G.snails.filter(s => s.hp > 0).length;
    aliveCount += G.SuperSnails.filter(s => s.hp > 0).length;
    aliveCount += G.yetis.filter(y => y.alive && y.hp > 0).length;
    aliveCount += G.snowmen.filter(s => s.hp > 0).length;
    aliveCount += G.babyMicrowaves.filter(s => s.hp > 0).length;
    aliveCount += G.turrets.filter(t => t.hp > 0).length;
    aliveCount += G.bats.filter(b => b.hp > 0).length;
    aliveCount += G.tables.filter(t => t.hp > 0).length;
    
    ctx.font = "18px Arial";
    ctx.fillText(`Enemies: ${aliveCount}`, canvas.width - 20, 55);
  }
  
  if (!G.wavesystem.waveActive && G.wavesystem.waveTimer > 0) {
    let seconds = Math.ceil (G.wavesystem.waveTimer / 60);
    ctx.font = "20px Arial";
    ctx.fillStyle = "#ffcc00";
    ctx.fillText(`Next wave: ${seconds}s`, canvas.width - 20, 55);
  }
  
  ctx.font = "16px Arial";
  ctx.fillStyle = "#aaa";
  ctx.fillText(`Kills: ${G.wavesystem.totalEnemiesKilled}`, canvas.width - 20, 80);
  
  ctx.textAlign = "left";
  ctx.restore();
}

// Start wave mode for a level
async function startWaveModeLevel(level) {
  hideAllMenus();
  document.getElementById("game").style.display = "block";
  
  // Show loading screen before any async operations
  showLoadingScreen();
  
  stopGameLoop();
  resetGameState();
  
  updateLoadingProgress(0.1);
  
  initAtmosphericParticles();
  initDungeonLighting();
  
  updateLoadingProgress(0.3);
  
  await loadLevel(level); // Make this properly awaited
  
  updateLoadingProgress(0.6);
  
  initDungeonAesthetics();
  startMusic();
  startWaveMode(level);
  
  updateLoadingProgress(0.9);
  
  // All async operations complete — NOW we start the game
  gameRunning = true;
  gamePaused = false;
  lastFrameTime = performance.now();
  lastTimestamp = performance.now();
  
  updateLoadingProgress(1);
  
  // Hide loading screen and start game loop
  hideLoadingScreen();
  gameLoopId = requestAnimationFrame(gameLoop);
}


const keys = {};

const DEFAULT_KEY_BINDINGS = {
  left: "arrowleft",
  right: "arrowright",
  jump: "arrowup",
  down: "arrowdown",
  dash: "shift",
  attack: "f",
  sword: "g",
  pause: "escape",
  restart: "r",
  inventory: "i",
  interact: "e",
  skipCountdown: "n",
  buildDelete: "x"
};

const ACTION_BUTTON_IDS = {
  left: "btnLeft",
  right: "btnRight",
  jump: "btnJump",
  down: "btnDown",
  attack: "btnAttack"
};

const KEYBIND_ACTIONS = [
  { action: "left", label: "Move Left" },
  { action: "right", label: "Move Right" },
  { action: "jump", label: "Jump" },
  { action: "down", label: "Down / Crouch" },
  { action: "dash", label: "Dash" },
  { action: "attack", label: "Club Attack" },
  { action: "sword", label: "Sword Attack" },
  { action: "pause", label: "Pause" },
  { action: "restart", label: "Restart" },
  { action: "inventory", label: "Inventory" },
  { action: "interact", label: "Interact / Shop" },
  { action: "skipCountdown", label: "Skip Countdown" },
  { action: "buildDelete", label: "Build Delete" }
];

let keyBindings = loadKeyBindings();
let keybindCaptureAction = null;

function normalizeInputKey(key) {
  if (!key) return "";
  if (key === " ") return "space";
  return key.toLowerCase();
}

function getBindingForAction(action) {
  return keyBindings[action] || "";
}

function isActionPressed(action) {
  const binding = getBindingForAction(action);
  return binding ? !!keys[binding] : false;
}

function getActionForKey(key) {
  const normalizedKey = normalizeInputKey(key);
  for (const [action, binding] of Object.entries(keyBindings)) {
    if (binding === normalizedKey) return action;
  }
  return null;
}

function setKeyState(key, isPressed) {
  const normalizedKey = normalizeInputKey(key);
  if (!normalizedKey) return;
  keys[normalizedKey] = isPressed;
}

function pulseAction(action, duration = 60) {
  const binding = getBindingForAction(action);
  if (!binding) return;
  setKeyState(binding, true);
  setTimeout(() => {
    if (keys[binding]) {
      setKeyState(binding, false);
    }
  }, duration);
}

function formatBindingLabel(binding) {
  if (!binding) return "Unbound";
  if (binding === "space") return "Space";
  if (binding.length === 1) return binding.toUpperCase();
  if (binding.startsWith("arrow")) {
    return "Arrow " + binding.slice(5, 6).toUpperCase() + binding.slice(6);
  }
  return binding.charAt(0).toUpperCase() + binding.slice(1);
}

function loadKeyBindings() {
  const saved = localStorage.getItem("keyBindings");
  if (!saved) return { ...DEFAULT_KEY_BINDINGS };

  try {
    const parsed = JSON.parse(saved);
    return { ...DEFAULT_KEY_BINDINGS, ...parsed };
  } catch (error) {
    return { ...DEFAULT_KEY_BINDINGS };
  }
}

function saveKeyBindings() {
  localStorage.setItem("keyBindings", JSON.stringify(keyBindings));
}

function resetKeyBindings() {
  keyBindings = { ...DEFAULT_KEY_BINDINGS };
  saveKeyBindings();
  renderKeybindMenu();
}

function bindActionToKey(action, key) {
  const normalizedKey = normalizeInputKey(key);
  for (const otherAction of Object.keys(keyBindings)) {
    if (otherAction !== action && keyBindings[otherAction] === normalizedKey) {
      keyBindings[otherAction] = "";
    }
  }
  keyBindings[action] = normalizedKey;
  saveKeyBindings();
  renderKeybindMenu();
}

function captureKeybind(action) {
  keybindCaptureAction = action;
  renderKeybindMenu();
}

function clearKeybindCapture() {
  keybindCaptureAction = null;
  renderKeybindMenu();
}

function renderKeybindMenu() {
  const list = document.getElementById("keybindList");
  if (!list) return;

  list.innerHTML = "";
  for (const entry of KEYBIND_ACTIONS) {
    const row = document.createElement("div");
    row.className = "keybind-row";

    const info = document.createElement("div");
    info.className = "keybind-info";

    const label = document.createElement("span");
    label.className = "keybind-label";
    label.textContent = entry.label;

    const hint = document.createElement("span");
    hint.className = "keybind-hint";
    hint.textContent = entry.action === keybindCaptureAction ? "Press a key..." : "Click to change";

    info.appendChild(label);
    info.appendChild(hint);

    const button = document.createElement("button");
    button.type = "button";
    button.className = "keybind-button" + (entry.action === keybindCaptureAction ? " capturing" : "");
    button.dataset.keybindAction = entry.action;
    button.textContent = formatBindingLabel(getBindingForAction(entry.action));
    button.addEventListener("click", () => captureKeybind(entry.action));

    row.appendChild(info);
    row.appendChild(button);
    list.appendChild(row);
  }
}

// --- LOADING SCREEN SYSTEM ---
let isLoadingScreenVisible = false;

function showLoadingScreen() {
  isLoadingScreenVisible = true;
  const loadingEl = document.getElementById("intro-screen");
  if (loadingEl) {
    loadingEl.classList.remove('hidden');
    loadingEl.classList.remove('fadeout');
    updateLoadingProgress(0);
  }
}

function hideLoadingScreen() {
  isLoadingScreenVisible = false;
  const loadingEl = document.getElementById("intro-screen");
  if (loadingEl) {
    loadingEl.classList.add('fadeout');
    setTimeout(() => loadingEl.classList.add('hidden'), 420);
  }
}

function updateLoadingProgress(fraction) {
  const fill = document.querySelector('.intro-progress-fill');
  if (fill) {
    fill.style.width = (Math.max(0, Math.min(1, fraction)) * 100) + '%';
  }
}

const camera = {
  x: 0,
  y: 0,
  width: canvas.width,
  height: canvas.height,
  smoothFactor: 0.1
};

// --- WORLD SETTINGS ---
const world = {
  width: 2800,  // how wide your level is
  height: 2100  // how tall your level is
};

function hideAllMenus() {
  document.getElementById("multiplayerLobby").classList.add("hidden");
  document.getElementById("menu").classList.add("hidden");
  document.getElementById("levelSelect").classList.add("hidden");
  document.getElementById("waveSelect").classList.add("hidden");
  document.getElementById("credits").classList.add("hidden");
  document.getElementById("freeSelect").classList.add("hidden");
  document.getElementById("settings").classList.add("hidden");
  document.getElementById("keybindsMenu").classList.add("hidden");
  document.getElementById("pauseMenu").classList.add("hidden");
  document.getElementById("controls").classList.add("hidden");
  document.getElementById("controllerControls").classList.add("hidden");
  document.getElementById("customLevels").classList.add("hidden");
}

// AABB collision
function isColliding(a, b) {
    const aWidth = a.width ?? a.size;   // use size if width not defined
    const aHeight = a.height ?? a.size; // use size if height not defined
    const bWidth = b.width ?? b.size;
    const bHeight = b.height ?? b.size;

    return (
        a.x < b.x + bWidth &&
        a.x + aWidth > b.x &&
        a.y < b.y + bHeight &&
        a.y + aHeight > b.y
    );
}

// Check if a rectangle collides with any wall
function collidesWithWall(x, y, w, h) {
  for (let wall of walls) {
    if (
      x < wall.x + wall.width &&
      x + w > wall.x &&
      y < wall.y + wall.height &&
      y + h > wall.y
    ) return true;
  }
  return false;
}

function getEnemySnapshot() {
  function minEnemy(e) {
    return {
      x: Math.round(e.x), y: Math.round(e.y),
      dx: e.dx, dy: e.dy,
      hp: e.hp, maxHp: e.maxHp,
      dir: e.dir ?? e.facing ?? 1,
      alive: e.alive ?? true,
      hitFlash: e.hitFlash ?? 0,
      frame: e.frame ?? 0,
      openTimer: e.openTimer ?? 0,
      dingTimer: e.dingTimer ?? 0,
      wobblePhase: e.wobblePhase ?? 0,
    };
  }
  return {
    snails:      G.snails.map(minEnemy),
    SuperSnails: G.SuperSnails.map(minEnemy),
    bats:        G.bats.map(minEnemy),
    yetis:       G.yetis.map(minEnemy),
    snowmen:     G.snowmen.map(minEnemy),
    babyMicrowaves: G.babyMicrowaves.map(minEnemy),
    turrets:     G.turrets.map(minEnemy),
    chairs:      G.chairs.map(minEnemy),
    tables:      G.tables.map(minEnemy),
    boxes: boxes.map(b => ({
      x: Math.round(b.x), y: Math.round(b.y),
      dx: b.dx, dy: b.dy,
      hp: b.hp, maxHp: b.maxHp,
      type: b.type,
      broken: b.broken ?? false,
    })),
    wave: {
      currentWave:    G.wavesystem.currentWave,
      waveActive:     G.wavesystem.waveActive,
      waveTimer:      G.wavesystem.waveTimer,
      enabled:        G.wavesystem.enabled,
    }
  };
}

function applyEnemySnapshot(snap) {
  if (!snap) return;
  function applyList(target, source) {
    // Resize target array to match
    target.length = source.length;
    for (let i = 0; i < source.length; i++) {
      if (!target[i]) target[i] = {};
      Object.assign(target[i], source[i]);
    }
  }
  applyList(G.snails,      snap.snails);
  applyList(G.SuperSnails, snap.SuperSnails);
  applyList(G.bats,        snap.bats);
  applyList(G.yetis,       snap.yetis);
  applyList(G.snowmen,     snap.snowmen);
  applyList(G.babyMicrowaves, snap.babyMicrowaves || []);
  applyList(G.turrets,     snap.turrets);
  applyList(G.chairs,      snap.chairs);
  applyList(G.tables,      snap.tables);
  applyList(boxes, snap.boxes);
  if (snap.wave) {
    G.wavesystem.currentWave = snap.wave.currentWave;
    G.wavesystem.waveActive  = snap.wave.waveActive;
    G.wavesystem.waveTimer   = snap.wave.waveTimer;
    G.wavesystem.enabled     = snap.wave.enabled;
  }
}


// Serialize local player state — call this to get what to broadcast over the network
function getPlayerSnapshot() {
  return {
    id:         localPlayerId,
    name:       localPlayerName,
    x:          player.x,
    y:          player.y,
    dx:         player.dx,
    dy:         player.dy,
    facing:     player.facing,
    lives:      playerLives,
    attacking:  player.attacking,
    charging:   false,
    dashActive: player.dashActive,
    rollActive: player.rollActive,
    onGround:   player.onGround,
    hasPotato:  hasPotato,
    upgrades: {
      wolf:               !!playerUpgrades.wolf,
      homingEnabled:      playerUpgrades.homingEnabled,
      dashDamageEnabled:  playerUpgrades.dashDamageEnabled,
      rollEnabled:        playerUpgrades.rollEnabled,
      extraJumpsMax:      playerUpgrades.extraJumpsMax,
      cannonRapidEnabled: playerUpgrades.cannonRapidEnabled,
      cannonBounceEnabled:playerUpgrades.cannonBounceEnabled,
    }
  };
}

// Apply a received snapshot onto a remote player object (for rendering other players)
function applyPlayerSnapshot(target, snapshot) {
  target.x          = snapshot.x;
  target.y          = snapshot.y;
  target.dx         = snapshot.dx;
  target.dy         = snapshot.dy;
  target.facing     = snapshot.facing;
  target.lives      = snapshot.lives;
  target.attacking  = snapshot.attacking;
  target.charging   = snapshot.charging;
  target.dashActive = snapshot.dashActive;
  target.rollActive = snapshot.rollActive || false;
  target.onGround   = snapshot.onGround;
  target.hasPotato  = snapshot.hasPotato;
  target.name       = snapshot.name;
}

function resetGameState() {
  
    if (gameLoopId) {
    cancelAnimationFrame(gameLoopId);
    gameLoopId = null;
  }
  // Reset player
  player.x = 100;
  player.y = 100;
  player.dx = 0;
  player.dy = 0;
  player.dashMaxCooldown = 50;
  player.jumpPower = 11;
player.wallJumpPower = 11;
player.speed = 3;
player.dashSpeed = 14;
player.dashMaxDuration = 12;
player.attackDuration = 20;
player.attackKnockback = 2;
player.speedChiliTimer = 0;
player.speedChiliDirection = 0;
player.speedChiliTrailCooldown = 0;
player.featherBootsTimer = 0;
player.dashBatteryTimer = 0;
player.dashCooldownMultiplier = 1;
  // reset roll state
  player.rollSpeed = 10;
  player.rollDuration = 0;
  player.rollMaxDuration = 30;
  player.rollCooldown = 0;
  player.rollMaxCooldown = 40;
  player.rollActive = false;
  
  // Reset lives & flags
  playerLives = maxLives;
  gameOver = false;
  gamePaused = false;
  gameRunning = false;
  player.attacking = false;
  playerUpgrades.wolf = null;
  playerUpgrades.wolfAutoRevive = false;
tutorialActive = false;
playerUpgrades.rollEnabled = false;

 xp = 0;
xpLevel = 1;
xpToNext = 60;
levelUpPending = false;
levelUpCards = [];
levelUpSelectedIndex = 0;
playerUpgrades.orbiters = [];
playerUpgrades.homingEnabled = false;
playerUpgrades.homingTimer = 0;
playerUpgrades.dashDamageEnabled = false;
playerUpgrades.extraJumpsMax = 0;
playerUpgrades.extraJumpsLeft = 0;
ownedUpgradeIds.clear();
playerUpgrades.dashInvulEnabled = false;

droppedParts = [];
placedStructures = [];
partInventory = {bouncy: 0, spike: 0, wall: 0, body: 0, wheel: 0, engine: 0, seat: 0 };
buildMode = false;
vehicles = [];
playerVehicle = null;
playerInVehicle = false;
cheeseCooldown = 0;
  
debugTestMode = false;
debugTests = [];

  generatedTiles = [];
  enemies = [];
  G.fireballs = [];
  G.shopkeepers = []
  timeElapsed = 0;
 hasPotato = false;
  G.babyMicrowaves = [];
  potato.collected = true;
  cheeses = [];
  cannonProjectiles = [];
  G.explosions = [];
  cannonCooldown = 0;
  syncJoystickVisibility();
  potatoMessage = "";
  potatoMessageTimer = 0;
  potatoHUDLine = "";
  potatoState = "none";
  // "none" | "raw" | "baked"
  if (initialChairs && initialChairs.length) G.chairs = initialChairs.map(c => ({ ...c }));
  if (initialTables && initialTables.length) G.tables = initialTables.map(t => ({ ...t }));
  if (initialBoxes && initialBoxes.length) boxes = initialBoxes.map(b => ({ ...b }));
  if (initialSnails && initialSnails.length) G.snails = initialSnails.map(s => ({ ...s }));
  if (initialSuperSnails && initialSuperSnails.length) G.SuperSnails = initialSuperSnails.map(s => ({ ...s }));
  if (initialBabyMicrowaves && initialBabyMicrowaves.length) G.babyMicrowaves = initialBabyMicrowaves.map(m => ({ ...m }));
  if (initialWalls && initialWalls.length) walls = initialWalls.map(w => ({ ...w }));
  if (initialSpikes && initialSpikes.length) spikes = initialSpikes.map(s => ({ ...s }));
  if (initialLadders && initialLadders.length) ladders = initialLadders.map(l => ({ ...l }));

  // Cancel the animation frame if scheduled
  if (gameLoopId) {
    cancelAnimationFrame(gameLoopId);
    gameLoopId = null;
  }
}


function triggerGameOver() {
  stopGameLoop();          // stop loop immediately
  resetGameState();        // reset everything
  hideAllMenus();
  document.getElementById("menu").classList.remove("hidden");
}

function stopGameLoop() {
  if (gameLoopId) {
    cancelAnimationFrame(gameLoopId);
    gameLoopId = null;
  }
  gameRunning = false;
}


// === LEVEL BUILDER MODULE ===
// Utility functions to easily build platforms, ladders, spikes, and boxes.

function addPlatform(x, y, width, height, moving = false, dir = 1) {
  walls.push({ x, y, width, height, moving, dir });
}

function addLadder(x, y, width, height) {
  ladders.push({ x, y, width, height });
}

function addSpike(x, y, width = 40, height = 26) {
  spikes.push({ x, y, width, height });
}

function addBox(x, y, width = 32, height = 32) {
  boxes.push({ x, y, width, height, dx: 0, dy: 0 });
}

// Example: helper pattern for a staircase of platforms
function addStaircase(startX, startY, stepWidth, stepHeight, steps, rise) {
  for (let i = 0; i < steps; i++) {
    addPlatform(startX + i * stepWidth, startY - i * rise, stepWidth, stepHeight);
  }
}

function seesawSurfaceY(s, x) {
  const centerX = s.x + s.width / 2;
  const dx = x - centerX;
  return s.y + Math.sin(s.angle) * dx;
}

/*function handleSwordHit() {
  if (!player.attacking) return;

  const attackBox = {
    x: player.attackDir > 0 ? player.x + player.width : player.x - 20,
    y: player.y,
    width: 20,
    height: player.height
  };

  for (let s of G.snails.concat(SuperSnails)) {
    if (
      attackBox.x < s.x + s.width &&
      attackBox.x + attackBox.width > s.x &&
      attackBox.y < s.y + s.height &&
      attackBox.y + attackBox.height > s.y
    ) {
      // Apply knockback
      s.knockbackDx = 5 * player.attackDir; // push left/right
      s.knockbackDy = -5;                   // lift slightly
      s.knockbackTimer = 10;                // lasts 10 frames
    }
  }
}
*/

function saveInitialState() {
  initialBoxes = boxes.map(b => ({ ...b }));
  initialSnails = G.snails.map(s => ({ ...s }));
  initialSuperSnails = G.SuperSnails.map(s => ({ ...s }));
  initialBabyMicrowaves = G.babyMicrowaves.map(m => ({ ...m }));
  initialWalls = walls.map(w => ({ ...w }));
  initialSpikes = spikes.map(s => ({ ...s }));
  initialLadders = ladders.map(l => ({ ...l }));
  initialChairs = G.chairs.map(c => ({ ...c }));
  initialTables = G.tables.map(t => ({ ...t }));
  
  
}

function bakePotato(oven) {
  oven.used = true;
  potatoState = "baked";

  potatoMessage = "🥔🔥 we are cooked.";
  potatoMessageTimer = 180;

  activatePotatoChaosLevel2();
}

function updateFireballs() {
    for (let i = G.fireballs.length - 1; i >= 0; i--) {
        const f = G.fireballs[i];

        // Apply velocity
        f.x += f.vx;
        f.y += f.vy;

      
        // Gravity optional (comment out if you want straight shots)
        f.vy += -0.01;

          // 🔥 IGNITE OVEN
    for (let i = ovens.length - 1; i >= 0; i--) {
  const oven = ovens[i];

  if (oven.baked || oven.active) continue;

  if (
    f.x > oven.x &&
    f.x < oven.x + oven.width &&
    f.y > oven.y &&
    f.y < oven.y + oven.height
  ) {
    oven.active = true;
    oven.glow = 0;

      potatoMessage = "🥔 the oven awakens";
      potatoMessageTimer = 120;

      G.fireballs.splice(i, 1); // consume fireball
      continue;
    }
    }     
 if (player.sword && player.sword.active) {
            const s = player.sword;

            if (
                f.x < s.x + s.width &&
                f.x + f.size > s.x &&
                f.y < s.y + s.height &&
                f.y + f.size > s.y
            ) {
                // Reflect fireball horizontally away from player center
                const centerX = player.x + player.width / 2;

                if (f.x < centerX) f.vx = -Math.abs(f.vx); // bounce left
                else f.vx = Math.abs(f.vx); // bounce right

                // Slight upward kick so it feels like a ricochet
                f.vy -= 0.5;

                continue; // DO NOT allow box/player checks this frame
            }
        }


        // Collision with walls
        if (collidesWithWall(f.x, f.y, f.size, f.size)) {
            G.fireballs.splice(i, 1);
            continue;
        }

         // Collision with boxes
        for (let j = 0; j < boxes.length; j++) {
            const box = boxes[j];
            if (isColliding(f, box)) {
                // Knockback: push the box slightly away
                const dx = box.x + box.width/2 - f.x;
                const dy = box.y + box.height/2 - f.y;
                const mag = Math.sqrt(dx*dx + dy*dy) || 2;
                const knockback = 20; // tweak this value for stronger push

              box.x += (dx / mag) * (knockback * 2);
              box.y += (dy / mag) * -knockback;

                G.fireballs.splice(i, 1); // destroy fireball
                break; // stop checking boxes
            }
        }
        // Collision with player
        if (
            player.x < f.x + f.size &&
            player.x + player.width > f.x &&
            player.y < f.y + f.size &&
            player.y + player.height > f.y
        ) {
            damagePlayer("Fireball");
            G.fireballs.splice(i, 1);
          
        }
    }
}

function updateYetis() {
  for (let y of G.yetis) {
    ensureEntityInBounds(y);
    if (!y.alive) continue;

    if (y.stunTimer > 0) {
      y.stunTimer--;
      y.dx = 0;
      if (y.throwCooldown > 0) y.throwCooldown--;
      continue;
    }

    const dx = player.x - y.x;
    const dy = player.y - y.y;
    const dist = Math.hypot(dx, dy);

    // Face player
    y.facing = dx >= 0 ? 1 : -1;

    // Chase player
    if (dist < y.chaseRange) {
      y.dx = Math.sign(dx) * y.speed;
    } else {
      y.dx = 0;
    }

    y.x += y.dx;

    // Throw G.snowballs
    if (dist < 450 && y.throwCooldown <= 0) {
      throwSnowball(y);
      y.throwCooldown = 90; // cooldown frames
    }

    if (y.throwCooldown > 0) y.throwCooldown--;
  }
}

function throwSnowball(y) {
  const speed = 6;
  const dx = player.x - y.x;
  const dy = player.y - y.y;
  const dist = Math.hypot(dx, dy) || 1;

  G.snowballs.push({
  x: y.x + y.width / 2 - 6,
  y: y.y + 20 - 6,
  width: 12,
  height: 12,
  dx: (dx / dist) * speed,
  dy: (dy / dist) * speed - 2,
  alive: true
});
}

function updateSnowballs() {
  for (let s of G.snowballs) {
    if (!s.alive) continue;

    s.x += s.dx;
    s.y += s.dy;
    s.dy += 0.25; // gravity

    // Kill player
    if (rectsOverlap(s, player)) {
      damagePlayer("Snowball");
      s.alive = false;
    }

    // Remove if off world
    if (s.y > world.height + 200) {
      s.alive = false;
    }
  }
}

function updateTurrets() {
  for (let turret of G.turrets) {
    ensureEntityInBounds(turret);
        if (turret.stunTimer > 0) {
            turret.stunTimer--;
            if (turret.cooldown > 0) turret.cooldown--;
            turret.armed = false;
            continue;
        }
        if (turret.cooldown > 0) {
            turret.cooldown--;
            continue;
        }

        // Distance to player
        const dx = player.x + player.width / 2 - (turret.x + 16);
        const dy = player.y + player.height / 2 - (turret.y + 16);
        const dist = Math.sqrt(dx * dx + dy * dy);

      turret.armed = dist <= 450;
        // 🚫 OUT OF RANGE → DO NOTHING
        if (dist > 450) continue;

        // Shoot fireball
        const speed = 11;
        G.fireballs.push({
            x: turret.x + 16,
            y: turret.y + 16,
            vx: (dx / dist) * speed,
            vy: (dy / dist) * speed,
            size: 20
        });

        turret.cooldown = turret.fireRate;
    }
}

// === SPIKES MODULE ===
function updateSpikes() {
  for (let spike of spikes) {
    if (
      player.x < spike.x + spike.width &&
      player.x + player.width > spike.x &&
      player.y < spike.y + spike.height &&
      player.y + player.height > spike.y
    ) {
      damagePlayer("Spike");
      break;
    }
  }
}

function drawSpikes() {
  ctx.fillStyle = "#d33";
  for (let s of spikes) {
    ctx.beginPath();
    ctx.moveTo(s.x, s.y + s.height);
    ctx.lineTo(s.x + s.width / 2, s.y);
    ctx.lineTo(s.x + s.width, s.y + s.height);
    ctx.closePath();
    ctx.fill();
  }
}

function updateIcicles() {
  if (!isChristmasMap()) return;

  for (let i of G.icicles) {

    // --- RESPAWN LOGIC ---
    if (!i.active) {
      i.respawnTimer--;
      if (i.respawnTimer <= 0) {
        i.y = i.startY;
        i.dy = 0;
        i.falling = false;
        i.active = true;
      }
      continue;
    }

    // --- RANDOM DROP ---
    if (!i.falling && Math.random() < 0.003) {
      i.falling = true;
      i.dy = 0;
    }

    if (!i.falling) continue;

    // --- FALL PHYSICS ---
    i.dy += 0.35;               // gravity
    i.dy = Math.min(i.dy, 7);   // terminal velocity
    i.y += i.dy;

    // --- PLAYER HIT ---
    if (rectsOverlap(i, player)) {
      damagePlayer("Icicle");
      shatterIcicle(i);
      continue;
    }

    // --- PLATFORM HIT ---
    for (let w of walls) {
      if (rectsOverlap(i, w)) {
        shatterIcicle(i);
        break;
      }
    }
  }
}

// === SMART SNAIL MODULE (Enhanced AI) ===
function updateSnails() {
  for (let s of G.snails) {
    ensureEntityInBounds(s);
    
    if (s.knockbackTimer > 0) {
  s.x += s.knockbackDx;
  s.y += s.knockbackDy;
  s.knockbackTimer--;
  continue; // skip normal AI/movement for this frame
}

    if (s.dy > 12) s.dy = 12; 
    if (s.dy < -16) s.dy = -16; 
    
    // Gravity
    s.dy += s.gravity;
    s.y += s.dy;

    // --- AI BEHAVIOR ---
    const dx = player.x - s.x;
    const dy = player.y - s.y;
    const distance = Math.sqrt(dx * dx + dy * dy);

    if (distance < s.chaseRange) {
      // Move toward player horizontally only
      s.dir = dx > 0 ? 1 : -1;
      s.dx = s.speed * s.dir;
    } else {
      // Idle crawl
      s.dx = 0;
    }

    // Apply horizontal movement
    s.x += s.dx;

    // Collision + gravity correction
    let onGround = false;

    for (let wall of walls) {
      if (
        s.x < wall.x + wall.width &&
        s.x + s.width > wall.x &&
        s.y < wall.y + wall.height &&
        s.y + s.height > wall.y
      ) {
        const overlapX = Math.min(
          s.x + s.width - wall.x,
          wall.x + wall.width - s.x
        );
        const overlapY = Math.min(
          s.y + s.height - wall.y,
          wall.y + wall.height - s.y
        );

        if (overlapX < overlapY) {
          // Horizontal wall bounce
          s.dir *= -1;
          s.x += s.dir * overlapX;
          s.dx = 0;
        } else {
          // Vertical correction
          if (s.y < wall.y) {
            s.y -= overlapY;
            s.dy = 0;
            onGround = true;
          } else {
            s.y += overlapY;
            s.dy = 0;
          }
        }
      }
      for (let snail of G.snails) {

  snail.frameTimer++;

  if (snail.frameTimer > 40) { // speed control
    snail.frameTimer = 0;
    snail.frame++;

    if (snail.frame >= snailFrames.length) {
      snail.frame = 0;
    }
  }
}
    }

    // --- Edge detection: turn around before falling ---
    if (onGround) {
      const frontX = s.dir > 0 ? s.x + s.width + 2 : s.x - 2;
      const frontY = s.y + s.height + 4;
      let groundAhead = false;

      for (let wall of walls) {
        if (
          frontX > wall.x &&
          frontX < wall.x + wall.width &&
          frontY > wall.y &&
          frontY < wall.y + wall.height
        ) {
          groundAhead = true;
          break;
        }
      }

      if (!groundAhead) s.dir *= -1; // turn before falling
    }

    // --- Player collision kills player ---
    if (!s.tutorialDisplay &&
      player.x < s.x + s.width &&
      player.x + player.width > s.x &&
      player.y < s.y + s.height &&
      player.y + player.height > s.y
    ) {
      damagePlayer("Snail");
    }
  }
}
// === ENEMY MODULE (Smart Snail) ===
Gsnails = [
  { 
    x: 700, 
    y: 538, 
    width: 32, 
    height: 24, 
    dx: 0, 
    dy: 0, 
    dir: 1, 
    speed: 0.6, 
    chaseRange: 400, 
    gravity: 0.6,
    
    // Inside each snail object
knockbackTimer: 0,
knockbackDx: 0,
knockbackDy: 0

  }
];

// === POTATO MODULE ===
// === POTATO MODULE ===
potato = {
  x: 2700,
  y: 2000,
  width: 28,
  height: 22,
  wobble: 0,
  collected: true,
  active: true
};


let hasPotato = false;


// === SUPER G.snails ===
G.SuperSnails = [
  {
    x: 600,
    y: 500,
    width: 28,
    height: 20,
    dx: 0,
    dy: 0,
    speed: 1.8,
    gravity: 0.5,
    dir: 1,
    jumpPower: -14,
    mode: "ground",

    knockbackTimer: 0,
    knockbackDx: 0,
    knockbackDy: 0,

    jumpTimer: 0,
    lastWallSide: null,
    prevMode: "ground"
  }
];

// Cooldown timer
const SUPER_JUMP_COOLDOWN= 150;
const SUPER_JUMP_COOLDOWN_MIN = 45;  // ~.75 sec at 60fps
const SUPER_JUMP_COOLDOWN_MAX = 180; // ~3 sec at 60fps


function updateSuperSnails() {
  for (let s of G.SuperSnails) {
    ensureEntityInBounds(s);

    if (s.prevMode    === undefined) s.prevMode    = s.mode;
    if (s.lastWallSide === undefined) s.lastWallSide = null;
    if (s.jumpTimer   === undefined) s.jumpTimer   = 0;
    // ✅ REMOVED: s.wallJumpBoost = 0 (was wiping boost every frame)

    if (s.knockbackTimer > 0) {
      s.x += s.knockbackDx;
      s.y += s.knockbackDy;
      s.knockbackTimer--;
      continue;
    }

    if (s.jumpTimer > 0) s.jumpTimer--;

    // Gravity
    if (s.mode === "ground" || s.mode === "falling") {
      s.dy += s.gravity;
    } else {
      s.dy = 0;
    }

    if (s.dy  >  12) s.dy =  12;
    if (s.dy  < -15) s.dy = -15;

    const dx = player.x - s.x;
    const dy = player.y - s.y;
    s.dir = dx > 0 ? 1 : -1;

    s.x += s.dx;
    s.y += s.dy;

    // ✅ FIXED: s.hp instead of s.health
    if (s.y > 2200) {
      s.hp = 0;
      s.y = 200;
      s.x = Math.random() * world.width;
    }

    let touching = { left: false, right: false, top: false, bottom: false };

    // Box collisions
    for (let b of boxes) {
      if (!isColliding(s, b)) continue;
      const ox = Math.min(s.x + s.width - b.x, b.x + b.width - s.x);
      const oy = Math.min(s.y + s.height - b.y, b.y + b.height - s.y);

      if (oy < ox) {
        if (s.dy > 0) {
          s.y = b.y - s.height;
          s.dy = 0;
          touching.bottom = true;
          s.jumpTimer = Math.max(s.jumpTimer, 10);
          if (s.mode === "falling" || s.mode === "ground") s.mode = "ground";
        } else {
          s.y = b.y + b.height;
          s.dy = 0;
        }
      } else {
        if (s.dx > 0) { s.x = b.x - s.width;  touching.right = true; }
        else           { s.x = b.x + b.width;  touching.left  = true; }
        s.dx = 0;
        if (s.mode === "wall") { s.mode = "falling"; s.wallJumpActive = false; }
      }
    }

    // Wall collisions
    for (let w of walls) {
      if (!isColliding(s, w)) continue;
      const ox = Math.min(s.x + s.width - w.x, w.x + w.width - s.x);
      const oy = Math.min(s.y + s.height - w.y, w.y + w.height - s.y);

      if (ox < oy) {
        if (s.x < w.x) { s.x -= ox; touching.right = true; s.lastWallSide = "right"; }
        else            { s.x += ox; touching.left  = true; s.lastWallSide = "left";  }
        s.dx = 0;
      } else {
        if (s.y < w.y) { s.y -= oy; touching.bottom = true; }
        else            { s.y += oy; touching.top    = true; }
        if (s.mode !== "wall") s.dy = 0;
      }
    }

    if (touching.bottom) {
  s.mode = "ground";
} else if (touching.left && touching.right) {
  // Squeezed between two walls — just fall
  s.mode = "falling";
  s.dy = 2;
} else if (touching.left || touching.right) {
  s.mode = "wall";
} else if (touching.top && s.dy <= 0) {
  s.mode = "ceiling";
} else {
  s.mode = "falling";
}

    // ✅ FIXED: refresh timer while actively on wall (not just on transition)
    if (s.mode === "wall") {
      s.jumpTimer = 45;
    }

    // Wall → not-wall: trigger wall jump
    if (s.prevMode === "wall" && s.mode !== "wall" && !s.wallJumpActive) {
      s.wallJumpActive  = true;
      // ✅ FIXED: sane velocity values (was 60/-60)
      if      (s.lastWallSide === "left")  s.wallJumpTargetDx =  7;
      else if (s.lastWallSide === "right") s.wallJumpTargetDx = -7;
      else                                  s.wallJumpTargetDx = s.dir * 6;
      s.dy          = s.jumpPower * 0.7;
      s.mode        = "falling";
      s.wallJumpBoost = 10;
    }

    if (s.wallJumpActive) {
      const smoothing = 0.2;
      s.dx += (s.wallJumpTargetDx - s.dx) * smoothing;
      s.wallJumpBoost--;
      if (s.wallJumpBoost <= 0) s.wallJumpActive = false;
    }

    // Edge detection
    let frontX = s.dir > 0 ? s.x + s.width + 2 : s.x - 2;
    let frontY = s.y + s.height + 1;
    let groundAhead = false;
    for (let w of [...walls, ...boxes]) {
      if (frontX > w.x && frontX < w.x + w.width &&
          frontY >= w.y && frontY <= w.y + w.height) {
        groundAhead = true; break;
      }
    }

    // Mode behaviors
    if (s.mode === "ground") {
      s.dx = s.speed * s.dir;
      const distX = Math.abs(player.x - s.x);
      const distY = Math.abs(player.y - s.y);
      if ((distX < 170 && distY < 750 && s.jumpTimer <= 0) ||
          !groundAhead ||
          collidesWithWall(s.x + s.dir * (s.width + 2), s.y, 2, s.height) ||
          touching.left || touching.right) {
        s.dy = s.jumpPower;
        s.jumpTimer = SUPER_JUMP_COOLDOWN + Math.floor(Math.random() * 60);
      }
    }

    if (s.mode === "wall") {
      s.dx = 0;
      s.dy = player.y > s.y ? s.speed * 1.4 : -s.speed * 1.4;
    }

    if (s.mode === "ceiling") {
      let ceilingAbove = false;
      for (let w of walls) {
        if (s.x + s.width > w.x && s.x < w.x + w.width &&
            s.y >= w.y && s.y <= w.y + w.height) {
          ceilingAbove = true; break;
        }
      }
      if (!ceilingAbove) s.mode = "falling";
      if (player.y > s.y + s.height && Math.abs(player.x - s.x) < 75) s.mode = "falling";
      if (s.mode === "ceiling") { s.dy = 0; s.dx = s.speed * s.dir; }
    }

    if (s.mode === "falling") {
      s.dx = s.wallJumpBoost > 0 ? s.dx : s.speed * s.dir;
    }

    if ((touching.left || touching.right) && s.mode !== "wall") {
      s.dir *= -1;
    }

    if (isColliding(player, s) && !s.tutorialDisplay) damagePlayer("Super Snail");

    s.prevMode = s.mode;
  }
}

function drawSuperSnails() {
      if (G.SuperSnails.hitFlash > 0) {
      ctx.fillStyle = "#f00"; // red
    } else {
      ctx.fillStyle = "#4dff68"; // normal green
    }
  for (let s of G.SuperSnails) {
    ctx.fillRect(s.x, s.y, s.width, s.height);
  }
}

// === LADDER MODULE (V2 — fixed ground & speed) ===

function updateLadders() {
  const climbSpeed = 12.5// slower climb rate
  let onLadder = false;

  for (let ladder of ladders) {
    const insideLadder =
      player.x + player.width > ladder.x &&
      player.x < ladder.x + ladder.width &&
      player.y + player.height > ladder.y &&
      player.y < ladder.y + ladder.height;

    if (insideLadder) {
      onLadder = true;

      // Disable gravity while on ladder
      player.dy = 0;

      // Handle climb inputs
      if (localInput.jump) {
        player.y -= climbSpeed;
      } else if (localInput.down) {
        player.y += climbSpeed;
      }

      // Prevent jump abuse
      player.onGround = false;
      player.onWall = false;
      player.wallSliding = false;
    }
  }

  // If not on ladder, re-enable normal gravity
  if (!onLadder) {
    player.isOnLadder = false;
  } else {
    player.isOnLadder = true;
  }
}

function drawLadders() {
  ctx.fillStyle = "#b5651d";
  for (let ladder of ladders) {
    ctx.fillRect(ladder.x, ladder.y, ladder.width, ladder.height);
  }
}

function drawYetis() {
  for (let y of G.yetis) {
    if (!y.alive) continue;
    if (!isEffectVisibleInWorld(y.x, y.y, y.width, y.height, 120)) continue;

        if (G.yetis.hitFlash > 0) {
      ctx.fillStyle = "#f00"; // red
    } else {
      ctx.fillStyle = "#eef"; // normal green
    }
    // body
    ctx.fillRect(y.x, y.y, y.width, y.height);

    // face
    ctx.fillStyle = "#222";
    const eyeX = y.facing === 1 ? y.x + 30 : y.x + 10;
    ctx.fillRect(eyeX, y.y + 16, 6, 6);
  }
}

function drawOven() {
  for (let oven of ovens) {
    // init glow if missing (safety)
    if (oven.glow === undefined) oven.glow = 0;

    oven.glow += 0.05;
    const heat = Math.sin(oven.glow) * 10;

    ctx.save();
    ctx.translate(oven.x, oven.y);

    // === BODY ===
    ctx.fillStyle = "#3a3a3a";
    ctx.fillRect(0, 0, oven.width, oven.height);

    // Metal border
    ctx.strokeStyle = "#111";
    ctx.lineWidth = 3;
    ctx.strokeRect(0, 0, oven.width, oven.height);

    // === INNER CAVITY ===
    ctx.fillStyle = "#1a0d05";
    ctx.fillRect(10, 20, oven.width - 20, oven.height - 30);

    // === FIRE GLOW ===
    const fireGradient = ctx.createRadialGradient(
      oven.width / 2,
      oven.height - 20,
      5,
      oven.width / 2,
      oven.height - 20,
      35
    );

    fireGradient.addColorStop(0, "rgba(255,180,60,0.8)");
    fireGradient.addColorStop(1, "rgba(255,80,0,0.1)");

   if (oven.active && !oven.baked) {
  ctx.fillStyle = fireGradient;
  ctx.fillRect(12, 22, oven.width - 24, oven.height - 34);
}

    if (oven.baked) {
  ctx.fillStyle = "rgba(0,0,0,0.35)";
  ctx.fillRect(12, 22, oven.width - 24, oven.height - 34);
}

    // === HEAT WAVES ===
    ctx.strokeStyle = "rgba(255,140,50,0.3)";
    for (let i = 0; i < 3; i++) {
      ctx.beginPath();
      ctx.moveTo(20 + i * 15, 20);
      ctx.quadraticCurveTo(
        30 + i * 15,
        10 - heat,
        40 + i * 15,
        20
      );
      ctx.stroke();
    }

    // === KNOBS ===
    ctx.fillStyle = "#555";
    ctx.beginPath();
    ctx.arc(20, 10, 4, 0, Math.PI * 2);
    ctx.arc(oven.width - 20, 10, 4, 0, Math.PI * 2);
    ctx.fill();

    // === FEET ===
    ctx.fillStyle = "#222";
    ctx.fillRect(10, oven.height, 15, 6);
    ctx.fillRect(oven.width - 25, oven.height, 15, 6);

    ctx.restore();
  }
}


function drawSnowballs() {
  ctx.fillStyle = "#fff";
  for (let s of G.snowballs) {
    if (!s.alive) continue;
    ctx.beginPath();
    ctx.arc(
      s.x + s.width / 2,
      s.y + s.height / 2,
      s.width / 2,
      0,
      Math.PI * 2
    );
    ctx.fill();
  }
}


// --- PLAYER LIVES MODULE ---
const maxLives = 3;
let playerLives = maxLives;

// Single authoritative entry point for all player damage.
// In multiplayer, only the host calls this and broadcasts the result.
function damagePlayer(source = "unknown") {
  if (player.iframes > 0) return;   // already recently hit
  player.iframes = 60;              // ~1 second grace period
  chatLog("💥 " + source, "#ff6060");
  loseLife();
}

// Function to handle losing a life
function loseLife() {
  if (settings.invincible) return;
  if (settings.infiniteLives) { playerLives = maxLives; return; }
 if (playerUpgrades.dashInvulEnabled && player.dashActive) return;
  
 if (playerInVehicle) exitVehicle();
  playerLives--;

  if (hasPotato) {
    potatoMessage =
      potatoDeathLines[Math.floor(Math.random() * potatoDeathLines.length)];
    potatoMessageTimer = 180;

    potatoHUDLine = "🥔 disappointed but present";
  }

  if (playerLives <= 0) {
    playerLives = 0;
    endGame();
  } else {
    resetPlayer();
  }
}


// Reset player position
function resetPlayer() {
  player.x = 50;
  player.y = 50;
  player.dx = 0;
  player.dy = 0;
  player.iframes = 0;
  player.speedChiliTimer = 0;
  player.speedChiliDirection = 0;
  player.speedChiliTrailCooldown = 0;
  player.featherBootsTimer = 0;
  player.dashBatteryTimer = 0;
  player.dashCooldownMultiplier = 1;
  speedChiliTrailParticles.length = 0;
}

// --- GAME OVER MODULE ---
  let gameOver = false;

function endGame() {
  gameOver = true;
}

function resetGame() {
  playerLives = maxLives;
  gameOver = false;
  resetPlayer();

  cannonProjectiles = [];
  G.explosions = [];
  cannonCooldown = 0;
  syncJoystickVisibility();
  // --- POTATO RESET ---
  hasPotato = false;
  potato.collected = true;

  potatoMessage = "";
  potatoMessageTimer = 0;
  potatoHUDLine = "";
  potatoState = "none";
// "none" | "raw" | "baked"

  // Optional: reset potato wobble
  potato.wobble = 0;
}


// --- AIR FLOAT MODULE ---
const floatFactor = 0.1; // fraction of gravity applied while holding up

function applyAirFloat() {
  if ((localInput.jump) && !player.onGround) {
    // Reduce downward speed while in the air
    if (player.dy > 0) {
      player.dy *= (1 - floatFactor); 
    }
  }
}

// --- BOX-TO-BOX FRICTION MODULE ---
const boxFrictionStrength = 1; // 0 = no friction, 1 = locked together

function applyBoxFriction() {
  for (let i = 0; i < boxes.length; i++) {
    for (let j = 0; j < boxes.length; j++) {
      if (i === j) continue;

      const boxA = boxes[i];
      const boxB = boxes[j];

      // Only apply friction when boxA is directly on top of boxB
      const touchingVertically =
        boxA.y + boxA.height >= boxB.y &&
        boxA.y < boxB.y + boxB.height;

      const overlappingHorizontally =
        boxA.x < boxB.x + boxB.width && boxA.x + boxA.width > boxB.x;

      if (touchingVertically && overlappingHorizontally) {
        // Reduce relative horizontal movement between stacked boxes
        const relativeDx = boxA.dx - boxB.dx;
        const frictionForce = relativeDx * boxFrictionStrength;
        boxA.dx -= frictionForce / 2;
        boxB.dx += frictionForce / 2;

        // Optional: also reduce vertical "bouncing" slightly
        const relativeDy = boxA.dy - boxB.dy;
        const verticalFriction = relativeDy * (boxFrictionStrength / 2);
        boxA.dy -= verticalFriction / 2;
        boxB.dy += verticalFriction / 2;
      }
    }
  }
}

// --- STACKABLE BOX MODULE ---
const boxFriction = 0.9; // slows boxes when touching other boxes
const wallFriction = 0.9; // slows boxes when on wall/ground

// --- Helper to resolve box vs solid collisions ---
function resolveBoxCollision(box, solid) {
  const overlapX = Math.min(box.x + box.width - solid.x, solid.x + solid.width - box.x);
  const overlapY = Math.min(box.y + box.height - solid.y, solid.y + solid.height - box.y);

  if (overlapX < overlapY) {
    // Horizontal separation
    if (box.x < solid.x) box.x -= overlapX / 2;
    else box.x += overlapX / 2;

    if (solid.dx !== undefined) { // Moving object like player/snail
      box.dx = solid.dx * 0.8;
    } else {
      box.dx = 0;
    }
  } else {
    // Vertical separation
    if (box.y < solid.y) {
      box.y -= overlapY;
      box.dy = 0;
    } else {
      box.y += overlapY;
      box.dy = 0;
    }

    // If box is on top of a moving object, move with it slightly
    if (solid.dx !== undefined && box.y + box.height <= solid.y + solid.height + 1) {
      box.x += solid.dx * 0.8; 
    }
  }
}

function drawBox(b) {
      if (isChristmasMap()) {
      // PRESENT BOX
      ctx.fillStyle = "#c33";
      ctx.fillRect(b.x, b.y, b.width, b.height);

      ctx.fillStyle = "#fff";
      ctx.fillRect(b.x + b.width / 2 - 3, b.y, 6, b.height);
      ctx.fillRect(b.x, b.y + b.height / 2 - 3, b.width, 6);

      ctx.beginPath();
      ctx.arc(b.x + b.width / 2 - 6, b.y + 6, 4, 0, Math.PI * 2);
      ctx.arc(b.x + b.width / 2 + 6, b.y + 6, 4, 0, Math.PI * 2);
      ctx.fill();

    } else {
  // wood base
  ctx.fillStyle = "#a36a2f";
  ctx.fillRect(b.x, b.y, b.width, b.height);

  // planks
  ctx.strokeStyle = "rgba(0,0,0,0.25)";
  for (let y = b.y; y < b.y + b.height; y += 10) {
    ctx.beginPath();
    ctx.moveTo(b.x, y);
    ctx.lineTo(b.x + b.width, y);
    ctx.stroke();
  }

  // metal corners
  ctx.fillStyle = "#555";
  ctx.fillRect(b.x, b.y, 4, 4);
  ctx.fillRect(b.x + b.width - 4, b.y, 4, 4);
  ctx.fillRect(b.x, b.y + b.height - 4, 4, 4);
  ctx.fillRect(b.x + b.width - 4, b.y + b.height - 4, 4, 4);
}
}

function spawnSnow() {
  if (!isChristmasMap()) return;
 if (!settings.particles) return;
  if (snowParticles.length < 150) {
    snowParticles.push({
      x: Math.random() * world.width,
      y: -20,
      speed: 0.5 + Math.random() * 1.2,
      size: 1 + Math.random() * 2,
      drift: (Math.random() - 0.5) * 0.3
    });
  }
}

function updateSnow() {
  if (!isChristmasMap()) return;

  for (let s of snowParticles) {
    s.y += s.speed;

    // Respawn at top once off-screen
    if (s.y > 2200) {
      s.y = -10;
      s.x = Math.random() * world.width;
    }
  }
}

/*function spawnSimpleYetiDeath(y) {
  for (let i = 0; i < 12; i++) {
    snowParticles.push({
      x: y.x + y.width / 2,
      y: y.y + y.height / 2,
      dx: (Math.random() - 0.5) * 4,
      dy: -Math.random() * 3,
      size: 3,
      life: 20
    });
  }
}*/

function drawPotato() {
  if (potato.collected) return;

  potato.wobble += 0.05;

  ctx.save();
  ctx.translate(
    potato.x + potato.width / 2,
    potato.y + potato.height / 2
  );
  ctx.rotate(Math.sin(potato.wobble) * 0.15);

  ctx.fillStyle = "#b58b4a";
  ctx.beginPath();
  ctx.ellipse(0, 0, potato.width / 2, potato.height / 2, 0, 0, Math.PI * 2);
  ctx.fill();

  // little "eyes" (optional but recommended)
  ctx.fillStyle = "#5a3d1e";
  ctx.fillRect(-6, -2, 4, 3);
  ctx.fillRect(3, 1, 3, 3);
  ctx.fillRect(-2, 5, 2, 2);

  ctx.restore();
}


// INPUT

canvas.addEventListener("mousemove", (e) => {
  const rect   = canvas.getBoundingClientRect();
  const scaleX = canvas.width  / rect.width;   // accounts for CSS scaling
  const scaleY = canvas.height / rect.height;

  mouse.x = (e.clientX - rect.left) * scaleX;
  mouse.y = (e.clientY - rect.top)  * scaleY;

  if (devMapView) {
    mouse.worldX = Math.floor(mouse.x / devScale);
    mouse.worldY = Math.floor(mouse.y / devScale);
  } else {
    mouse.worldX = Math.floor(mouse.x + camera.x);
    mouse.worldY = Math.floor(mouse.y + camera.y);
  }
});

document.addEventListener("keydown", (e) => {
  if (!devMapView) return;

  if (e.key.toLowerCase() === "g") {
    devShowGrid = !devShowGrid;
  }
});

document.addEventListener("keydown", (e) => {
  const normalizedKey = normalizeInputKey(e.key);
  const keybindMenu = document.getElementById("keybindsMenu");
  if (keybindCaptureAction || (keybindMenu && !keybindMenu.classList.contains("hidden"))) {
    return;
  }

  setKeyState(normalizedKey, true);
  const action = getActionForKey(normalizedKey);

  if (levelUpPending) {
  if (action === "left") {
    levelUpSelectedIndex = (levelUpSelectedIndex - 1 + levelUpCards.length) % levelUpCards.length;
  }
  if (action === "right") {
    levelUpSelectedIndex = (levelUpSelectedIndex + 1) % levelUpCards.length;
  }
  if (action === "jump" || normalizedKey === "enter") {
    chooseLevelUpCard(levelUpSelectedIndex);
  }
  if (normalizedKey === "1") chooseLevelUpCard(0);
  if (normalizedKey === "2") chooseLevelUpCard(1);
  if (normalizedKey === "3") chooseLevelUpCard(2);
  return;
}

  if (action === "restart" && gameOver) {
    resetGame();
    triggerGameOver();
    document.getElementById("game").style.display = "none";
    return;
  }

  if (action === "pause") togglePause();
});
document.addEventListener("keyup", (e) => {
  const normalizedKey = normalizeInputKey(e.key);
  const keybindMenu = document.getElementById("keybindsMenu");
  if (keybindCaptureAction || (keybindMenu && !keybindMenu.classList.contains("hidden"))) {
    return;
  }
  setKeyState(normalizedKey, false);
});

document.addEventListener("keydown", e => {
    const action = getActionForKey(normalizeInputKey(e.key));

    // Start charging if not attacking or on cooldown
    if (action === "dash") { e.preventDefault(); tryDash(); }
});

document.addEventListener("keydown", (e) => {
  if (e.key.toLowerCase() === "m") {
    devMapView = !devMapView;
  }
});

document.addEventListener("keyup", e => {
  setKeyState(normalizeInputKey(e.key), false);
});



function togglePause() {
  if (!gameRunning) return;
  gamePaused = !gamePaused;
  const menu = document.getElementById("pauseMenu");
  const settings = document.getElementById("settings");
  if (gamePaused) {
    menu.classList.remove("hidden");

    // Build upgrade list
    const listEl = document.getElementById("upgradeListItems");
    if (ownedUpgradeIds.size === 0) {
      listEl.innerHTML = "None yet";
    } else {
      const lines = [];
      for (const id of ownedUpgradeIds) {
        const upgrade = UPGRADE_POOL.find(u => u.id === id);
        if (upgrade) lines.push(`${upgrade.icon} <b>${upgrade.name}</b> — ${upgrade.desc}`);
      }
      listEl.innerHTML = lines.join("<br>");
    }
  } else {
    menu.classList.add("hidden");
    settings.classList.add("hidden");
  }
}

function backToControls() {

  stopGameLoop();  
  document.getElementById("pauseMenu").classList.add("hidden");
  document.getElementById("levelSelect").classList.add("hidden");
  document.getElementById("waveSelect").classList.add("hidden");
  document.getElementById("credits").classList.add("hidden");
  document.getElementById("freeSelect").classList.add("hidden");
  document.getElementById("settings").classList.add("hidden");
  document.getElementById("menu").classList.add("hidden");
  document.getElementById("controls").classList.remove("hidden");
  document.getElementById("controllerControls").classList.add("hidden");
  // Hide canvas to be safe
  document.getElementById("game").style.display = "none";
}

function backToMenu() {

  stopGameLoop();  
  document.getElementById("multiplayerLobby").classList.add("hidden");
  document.getElementById("pauseMenu").classList.add("hidden");
  document.getElementById("levelSelect").classList.add("hidden");
  document.getElementById("waveSelect").classList.add("hidden");
  document.getElementById("credits").classList.add("hidden");
  document.getElementById("freeSelect").classList.add("hidden");
  document.getElementById("settings").classList.add("hidden");
  document.getElementById("menu").classList.remove("hidden");
  document.getElementById("controls").classList.add("hidden");
  document.getElementById("controllerControls").classList.add("hidden");
  document.getElementById("customLevels").classList.add("hidden");
  // Hide canvas to be safe
  document.getElementById("game").style.display = "none";
}

function backToPause() {

  document.getElementById("pauseMenu").classList.remove("hidden");
  document.getElementById("levelSelect").classList.add("hidden");
  document.getElementById("waveSelect").classList.add("hidden");
  document.getElementById("credits").classList.add("hidden");
  document.getElementById("freeSelect").classList.add("hidden");
  document.getElementById("settings").classList.add("hidden");
  document.getElementById("menu").classList.add("hidden");
  document.getElementById("controls").classList.add("hidden");
  document.getElementById("controllerControls").classList.add("hidden");
}

function backToMenuOrPause() {
  if (gameRunning === true) {
    backToPause();
  } else {
    backToMenu();
  }
}


function checkPotatoPickup() {
  if (potato.collected) return;

  if (
    player.x < potato.x + potato.width &&
    player.x + player.width > potato.x &&
    player.y < potato.y + potato.height &&
    player.y + player.height > potato.y
  ) {
    potato.collected = true;
    hasPotato = true;
    potatoState = "raw";

    potatoMessage = "The potato accepts you.";
potatoMessageTimer = 180; // 3 seconds

potatoHUDLine = "🥔 something feels different";


    // Tiny screen shake
    if (settings.screenShake && !settings.reducedMotion) {
    camera.x += (Math.random() - 0.5) * 13;
    camera.y += (Math.random() - 0.5) * 15;
}
  }
}

function updateOvens(player) {
  for (const oven of ovens) {
    if (!oven.active || oven.baked || !hasPotato) continue;

    if (
      player.x + player.width > oven.x &&
      player.x < oven.x + oven.width &&
      player.y + player.height > oven.y &&
      player.y < oven.y + oven.height
    ) {
      bakePotato(oven);
      break;
    }
  }
}


function bakePotato(oven) {
  oven.baked = true;
  oven.active = false;

  potatoState = "baked";
  potatoChaosLevel = 2;

  potatoMessage = randomFrom([
    "🥔 baked to perfection",
    "🥔 I am crispy now",
    "🥔 warmth… I feel complete",
    "🥔 LET ME COOK",
    "🥔 the oven accepts me"
  ]);

  potatoMessageTimer = 180;

  player.wallJumpPower *= 1.15;
  player.speed *= 1.2;
  player.jumpPower *= 1.15;
}



function updateSnowmen() {
  for (let s of G.snowmen) {
    ensureEntityInBounds(s);
    if (s.stunTimer > 0) {
      s.stunTimer--;
      s.dx = 0;
      continue;
    }
    const dx = player.x - s.x;
    const dist = Math.abs(dx);

    s.facing = dx >= 0 ? 1 : -1;

    // Simple chase
    if (dist < 600) {
      s.dx = Math.sign(dx) * s.speed;
    } else {
      s.dx = 0;
    }

    s.x += s.dx;
  }
}

function createBabyMicrowave(x, y, hp = 2) {
  return {
    x,
    y,
    width: 34,
    height: 28,
    dx: 0,
    dy: 0,
    dir: Math.random() > 0.5 ? 1 : -1,
    speed: 0.85 + Math.random() * 0.35,
    gravity: 0.55,
    chaseRange: 420 + Math.random() * 120,
    hopTimer: 0,
    openTimer: 0,
    dingTimer: 0,
    wobblePhase: Math.random() * Math.PI * 2,
    hp,
    maxHp: hp,
    hitFlash: 0,
    knockbackTimer: 0,
    knockbackDx: 0,
    knockbackDy: 0
  };
}

function updateBabyMicrowaves() {
  for (let m of G.babyMicrowaves) {
    if (m.hp <= 0) {
      triggerBabyMicrowaveExplosion(m);
      continue;
    }

    ensureEntityInBounds(m);

    if (m.hitFlash > 0) m.hitFlash--;
    if (m.openTimer > 0) m.openTimer--;
    if (m.dingTimer > 0) m.dingTimer--;
    if (m.hopTimer > 0) m.hopTimer--;

    if (m.knockbackTimer > 0) {
      m.x += m.knockbackDx;
      m.y += m.knockbackDy;
      m.knockbackDx *= 0.84;
      m.knockbackDy *= 0.84;
      m.knockbackTimer--;
      continue;
    }

    m.dy += m.gravity;
    if (m.dy > 12) m.dy = 12;

    const centerX = m.x + m.width / 2;
    const centerY = m.y + m.height / 2;
    const playerDx = player.x + player.width / 2 - centerX;
    const playerDy = player.y + player.height / 2 - centerY;
    const dist = Math.hypot(playerDx, playerDy);

    m.dir = playerDx >= 0 ? 1 : -1;

    if (dist < m.chaseRange) {
      m.dx = m.dir * m.speed;
      m.openTimer = Math.max(m.openTimer, 10);
      if (dist < 160) {
        m.dingTimer = 12;
      }
    } else {
      m.dx = m.dir * (m.speed * 0.35);
      if (Math.random() < 0.01) {
        m.dir *= -1;
      }
    }

    m.x += m.dx;
    m.y += m.dy;

    let onGround = false;

    for (let wall of walls) {
      if (!isColliding(m, wall)) continue;
      const ox = Math.min(m.x + m.width - wall.x, wall.x + wall.width - m.x);
      const oy = Math.min(m.y + m.height - wall.y, wall.y + wall.height - m.y);

      if (ox < oy) {
        m.x += m.x < wall.x ? -ox : ox;
        m.dir *= -1;
        m.dx = 0;
      } else {
        if (m.y < wall.y) {
          m.y -= oy;
          m.dy = 0;
          onGround = true;
        } else {
          m.y += oy;
          m.dy = 0;
        }
      }
    }

    if (onGround) {
      const frontX = m.dir > 0 ? m.x + m.width + 2 : m.x - 2;
      const frontY = m.y + m.height + 4;
      let groundAhead = false;

      for (let wall of walls) {
        if (
          frontX > wall.x &&
          frontX < wall.x + wall.width &&
          frontY > wall.y &&
          frontY < wall.y + wall.height
        ) {
          groundAhead = true;
          break;
        }
      }

      if (!groundAhead) m.dir *= -1;
    }

    m.wobblePhase += 0.08;

    if (isColliding(m, player)) {
      damagePlayer("Baby Microwave");
      m.dir *= -1;
      m.dx = -m.dir * m.speed;
    }
  }
}

function drawBabyMicrowaves() {
  for (let m of G.babyMicrowaves) {
    if (!isEffectVisibleInWorld(m.x - 12, m.y - 12, m.width + 24, m.height + 24, 120)) continue;

    const bob = Math.sin(m.wobblePhase) * 1.5;
    const centerX = m.x + m.width / 2;
    const centerY = m.y + m.height / 2;

    ctx.save();
    ctx.translate(centerX, centerY + bob);

    if (m.dir < 0) {
      ctx.scale(-1, 1);
    }

    if (m.hitFlash > 0) {
      ctx.filter = "brightness(1.7) saturate(1.25)";
    }

    if (babyMicrowaveImg.complete && babyMicrowaveImg.naturalWidth) {
      ctx.drawImage(babyMicrowaveImg, -m.width / 2, -m.height / 2, m.width, m.height);
    } else {
      ctx.fillStyle = "#f2c1d4";
      ctx.fillRect(-m.width / 2, -m.height / 2, m.width, m.height);
      ctx.fillStyle = "#fff0f5";
      ctx.fillRect(-10, -8, 20, 14);
    }

    ctx.filter = "none";

    if (m.openTimer > 0) {
      ctx.fillStyle = "rgba(255,255,255,0.35)";
      ctx.fillRect(2, -5, 7, 10);
      ctx.fillStyle = "rgba(255,214,226,0.65)";
      ctx.beginPath();
      ctx.arc(9, 0, 3.5, 0, Math.PI * 2);
      ctx.fill();
    }

    if (m.dingTimer > 0) {
      ctx.fillStyle = "rgba(255,255,255,0.8)";
      ctx.beginPath();
      ctx.arc(0, -18, 2, 0, Math.PI * 2);
      ctx.arc(5, -15, 1.5, 0, Math.PI * 2);
      ctx.arc(-5, -15, 1.5, 0, Math.PI * 2);
      ctx.fill();
    }

    ctx.restore();
  }
}

function triggerBabyMicrowaveExplosion(microwave) {
  if (!microwave || microwave.exploding) return;

  microwave.exploding = true;
  const index = G.babyMicrowaves.indexOf(microwave);
  if (index > -1) G.babyMicrowaves.splice(index, 1);
  onEnemyKilled('babyMicrowave');

  createExplosion(
    microwave.x + microwave.width / 2,
    microwave.y + microwave.height / 2,
    { type: 'microwave', maxRadius: 64, timer: 24, damage: 2 }
  );
}

function drawOvens() {
  for (const oven of ovens) {
    drawOven(oven);
  }
}

// UPDATE LOOP
// UPDATE LOOP
 function potatoChaos() {
  if (!hasPotato) return;

  // Slight gravity corruption
player.dy += (Math.random() - 0.5) * 1.0;
player.dy *= 1 + (Math.random() - 0.5) * 0.02;

   if (Math.random() < 0.002) {
const whispers = [
  "🥔 it is too late",
  "🥔 gravity is lying",
  "🥔 the boxes remember",
  "🥔 keep going",
  "🥔 do not trust the ladder",
  "🥔 i have always been here",
  "🥔 the G.snails know",
  "🥔 you are not the first",
  "🥔 something is watching the cheese",
  "🥔 the wolf dreams in numbers",
  "🥔 i felt that",
  "🥔 don't look at the background",

  "🥔 the floor moved again",
  "🥔 it blinked first",
  "🥔 the walls are getting closer",
  "🥔 you missed one",
  "🥔 it remembers your steps",
  "🥔 the cheese is a lie",
  "🥔 something followed you in",
  "🥔 the air feels heavy",
  "🥔 count backwards now",
  "🥔 it heard you think",
  "🥔 the exit moved",
  "🥔 you're looping",

  "🥔 don't stop now",
  "🥔 it almost saw you",
  "🥔 the shadows are late",
  "🥔 you dropped something important",
  "🥔 it's behind the next tile",
  "🥔 you weren't supposed to see that",
  "🥔 the lights are wrong",
  "🥔 it knows your pattern",
  "🥔 something is off-grid",
  "🥔 you took too long",
  "🥔 it is closer now",
  "🥔 the code is breathing",

  "🥔 try again but faster",
  "🥔 you changed something",
  "🥔 it noticed",
  "🥔 the silence is loud",
  "🥔 one of these is not real",
  "🥔 the ladder is watching you",
  "🥔 your path is predictable",
  "🥔 something is desynced",
  "🥔 the map shifted",
  "🥔 you forgot to check",
  "🥔 it's still there",
  "🥔 are you sure?",

  "🥔 the potato sees all",
  "🥔 this was inevitable",
  "🥔 it learns every run",
  "🥔 you can't reset this",
  "🥔 the background moved again",
  "🥔 something is wrong with the cheese",
  "🥔 it waits patiently",
  "🥔 the end is not the end",
  "🥔 there is another layer",
  "🥔 keep digging",
  "🥔 you're getting closer",
  "🥔 it is getting louder"
];
  potatoHUDLine = whispers[Math.floor(Math.random() * whispers.length)];
}

  // Rare micro-freeze (players will feel it, not see it)
if (Math.random() < 0.0005) {
  player.chaosStall = 20; // frames
}
}

function applySnowmanSlow() {
  player.slowMultiplier = 1; // reset EVERY frame

  // 🥔 Potato = no snow slow
if (!hasPotato) {
  for (let s of G.snowmen) {
    const cx = s.x + s.width / 2;
    const cy = s.y + s.height / 2;

    const px = player.x + player.width / 2;
    const py = player.y + player.height / 2;

    const dist = Math.hypot(px - cx, py - cy);

    if (dist < s.slowRadius) {
      player.slowMultiplier = Math.min(
        player.slowMultiplier,
        s.slowAmount
      );
    }
    }
  }
}

function tryDash() {
  // If the roll upgrade is unlocked and we're on the ground, perform a ground roll
  if (playerUpgrades.rollEnabled && player.onGround) {
    if (!settings.infiniteDash) {
      if (player.rollCooldown > 0) return;
    }
    player.rollActive = true;
    player.rollDuration = player.rollMaxDuration;
    player.rollCooldown = player.rollMaxCooldown;
    player.dy = 0;
    player.dx = player.facing * player.rollSpeed;
    return;
  }

  if (!settings.infiniteDash) {
    if (player.dashCooldown > 0) return;
    if (!player.onGround && player.dashUsedInAir) return;
  }

  player.dashActive = true;
  player.dashDuration = player.dashMaxDuration;
  player.dashCooldown = Math.max(1, Math.floor(player.dashMaxCooldown * player.dashCooldownMultiplier));
  player.dy = player.wallSliding ? 0 : player.dy * 0.2;
  player.dx = player.facing * player.dashSpeed;
  playerUpgrades.dashHitEnemies.clear(); // ← clear per-dash hit registry

  if (!player.onGround) player.dashUsedInAir = true;
}

// === TABLE MODULE ===
// G.tables are heavy furniture enemies that patrol, can be stood on,
// and enter a dramatic FLIP STATE when damaged — spinning through the
// air and slamming down to deal area-of-effect damage.

function createTable(x, y) {
  return {
    x, y,
    width: 64,
    height: 36,          // tabletop height; legs hang below
    dx: 0,
    dy: 0,
    dir: Math.random() > 0.5 ? 1 : -1,
    speed: 0.7 + Math.random() * 0.4,
    onGround: false,
    hp: 4,
    maxHp: 4,
    hitFlash: 0,
    knockbackTimer: 0,
    knockbackDx: 0,
    knockbackDy: 0,

    // FLIP STATE
    flipping: false,
    flipAngle: 0,             // current rotation (radians)
    flipAngularVel: 0,        // spin speed
    flipVx: 0,                // horizontal velocity while airborne during flip
    flipVy: 0,                // vertical velocity while airborne during flip
    flipDamageCooldown: 0,    // prevents dealing damage every frame

    // SLAM STATE
    slamming: false,          // true when falling fast after a flip
    slamDamageDealt: false,   // so slam only fires once per landing

    // Visual detail
    woodGrain: Math.floor(Math.random() * 3),  // 0-2 grain style
    clothColor: null,         // some G.tables have tablecloths
  };
}

function triggerTableFlip(t, launchDx) {
  if (t.flipping) return;            // already mid-air
  t.flipping = true;
  t.slamDamageDealt = false;
  t.flipAngle = 0;
  t.flipAngularVel = (Math.random() > 0.5 ? 1 : -1) * (0.15 + Math.random() * 0.12);
  t.flipVx  = (launchDx || t.dir * t.speed) * 2.2;
  t.flipVy  = -(8 + Math.random() * 5);  // dramatic upward launch
  t.dy = t.flipVy;
  t.dx = t.flipVx;
}

function updateTables() {
  for (let t of G.tables) {
    ensureEntityInBounds(t);
    if (t.hitFlash  > 0) t.hitFlash--;
    if (t.flipDamageCooldown > 0) t.flipDamageCooldown--;

    // --- KNOCKBACK (not flipping) ---
    if (!t.flipping && t.knockbackTimer > 0) {
      t.x += t.knockbackDx;
      t.y += t.knockbackDy;
      t.knockbackDx *= 0.80;
      t.knockbackDy *= 0.80;
      t.knockbackTimer--;
      continue;
    }

    // =====================================================
    //  FLIP STATE — table is airborne & spinning
    // =====================================================
    if (t.flipping) {
      // Gravity
      t.flipVy += gravity * 1.1;
      t.flipVy = Math.min(t.flipVy, 18);
      t.x += t.flipVx;
      t.y += t.flipVy;
      t.flipAngle += t.flipAngularVel;

      // Slow horizontal spin drag
      t.flipVx *= 0.97;

      // Deal damage to enemies within the table's spinning hitbox
      if (t.flipDamageCooldown <= 0) {
        const spinR = (t.width * 0.6);
        const cx = t.x + t.width / 2;
        const cy = t.y + t.height / 2;
        const flipHit = { x: cx - spinR, y: cy - spinR, width: spinR*2, height: spinR*2 };

        // Hurt G.snails
        for (let i = G.snails.length - 1; i >= 0; i--) {
          const s = G.snails[i];
          if (isColliding(flipHit, s)) {
            damageEnemy(s, 1, { x: (s.x - cx)*0.15, y: -4 });
            if (s.hp <= 0) { G.snails.splice(i, 1); onEnemyKilled('snail'); }
          }
        }
        // Hurt G.SuperSnails
        for (let i = G.SuperSnails.length - 1; i >= 0; i--) {
          const s = G.SuperSnails[i];
          if (isColliding(flipHit, s)) {
            damageEnemy(s, 1, { x: (s.x - cx)*0.15, y: -4 });
            if (s.hp <= 0) { G.SuperSnails.splice(i, 1); onEnemyKilled('superSnail'); }
          }
        }
        // Hurt baby microwaves
        for (let i = G.babyMicrowaves.length - 1; i >= 0; i--) {
          const m = G.babyMicrowaves[i];
          if (isColliding(flipHit, m)) {
            damageEnemy(m, 1, { x: (m.x - cx)*0.15, y: -4 });
            if (m.hp <= 0) triggerBabyMicrowaveExplosion(m);
          }
        }
        // Hurt G.turrets
        for (let i = G.turrets.length - 1; i >= 0; i--) {
          if (isColliding(flipHit, G.turrets[i])) {
            damageEnemy(G.turrets[i], 1, {x:0,y:0});
            if (G.turrets[i].hp <= 0) { G.turrets.splice(i, 1); onEnemyKilled('turret'); }
          }
        }
        // Hurt G.chairs
        for (let i = G.chairs.length - 1; i >= 0; i--) {
          const c = G.chairs[i];
          if (isColliding(flipHit, c)) {
            damageEnemy(c, 1, { x:(c.x-cx)*0.2, y:-5 });
            c.dx += (c.x-cx)*0.12;
            c.dy -= 3;
            if (c.hp <= 0) { G.chairs.splice(i, 1); onEnemyKilled('chair'); }
          }
        }
        // Hurt player
        if (isColliding(flipHit, player)) {
          damagePlayer("Table Flip");
        }
        // Knock boxes
        for (const b of boxes) {
          if (isColliding(flipHit, b)) {
            b.dx += (b.x - cx) * 0.18;
            b.dy -= 5;
          }
        }
        t.flipDamageCooldown = 18;
      }

      // World bounds — bounce off side walls
      if (t.x < 0 || t.x + t.width > world.width) {
        t.flipVx *= -0.6;
        t.x = Math.max(0, Math.min(t.x, world.width - t.width));
      }

      // --- LANDING: check floor collision ---
      let landed = false;
      for (let wall of walls) {
        if (!isColliding(t, wall)) continue;
        const oy = Math.min(t.y + t.height - wall.y, wall.y + wall.height - t.y);
        const ox = Math.min(t.x + t.width  - wall.x, wall.x + wall.width  - t.x);
        if (oy <= ox) {
          if (t.y + t.height / 2 < wall.y + wall.height / 2) {
            // Landing on top of wall
            t.y -= oy;
            t.flipVy = 0;
            landed = true;
          } else {
            t.y += oy;
            t.flipVy = Math.abs(t.flipVy) * 0.4;
          }
        } else {
          t.x += t.x < wall.x ? -ox : ox;
          t.flipVx *= -0.5;
        }
      }

      if (landed) {
        // SLAM EFFECT — if landing hard enough
        if (!t.slamDamageDealt && Math.abs(t.flipVy) > 5) {
          const slamR = 100;
          const cx = t.x + t.width / 2;
          const cy = t.y + t.height;
          // Slam particle burst
          for (let i = 0; i < 8; i++) {
            snowParticles.push({
              x: cx + (Math.random()-0.5)*t.width,
              y: cy,
              speed: 1 + Math.random()*2,
              size: 2 + Math.random()*3,
              drift: (Math.random()-0.5)*2,
              life: 25,
              color: "#c8922a"
            });
          }
          // Slam shockwave damage
          for (let i = G.snails.length - 1; i >= 0; i--) {
            const s = G.snails[i];
            if (Math.hypot(s.x+s.width/2 - cx, s.y+s.height/2 - cy) < slamR) {
              damageEnemy(s, 2, { x:(s.x-cx)*0.1, y:-6 });
              if (s.hp <= 0) { G.snails.splice(i, 1); onEnemyKilled('snail'); }
            }
          }
          for (let i = G.SuperSnails.length - 1; i >= 0; i--) {
            const s = G.SuperSnails[i];
            if (Math.hypot(s.x+s.width/2 - cx, s.y+s.height/2 - cy) < slamR) {
              damageEnemy(s, 2, { x:(s.x-cx)*0.1, y:-6 });
              if (s.hp <= 0) { G.SuperSnails.splice(i, 1); onEnemyKilled('superSnail'); }
            }
          }
          for (let i = G.babyMicrowaves.length - 1; i >= 0; i--) {
            const m = G.babyMicrowaves[i];
            if (Math.hypot(m.x+m.width/2 - cx, m.y+m.height/2 - cy) < slamR) {
              damageEnemy(m, 2, { x:(m.x-cx)*0.1, y:-6 });
              if (m.hp <= 0) triggerBabyMicrowaveExplosion(m);
            }
          }
          for (let i = G.chairs.length - 1; i >= 0; i--) {
            const c = G.chairs[i];
            if (Math.hypot(c.x+c.width/2 - cx, c.y+c.height/2 - cy) < slamR) {
              damageEnemy(c, 2, { x:(c.x-cx)*0.15, y:-7 });
              c.dx += (c.x-cx)*0.15; c.dy -= 6;
              if (c.hp <= 0) { G.chairs.splice(i, 1); onEnemyKilled('chair'); }
            }
          }
          // Slam hurts player too if they're under it
          if (Math.hypot(player.x+player.width/2 - cx, player.y+player.height/2 - cy) < slamR * 0.6) {
            damagePlayer("Table Slam");
          }
          // Screen shake
          if (settings.screenShake && !settings.reducedMotion) {
          camera.x += (Math.random()-0.5)*12;
          camera.y += (Math.random()-0.5)*12;
           }
          triggerVHSGlitch();
          if (hasPotato) {
            potatoMessage = "🥔 the furniture demands respect";
            potatoMessageTimer = 100;
          }
          t.slamDamageDealt = true;
        }

        // Settle the table
        t.flipping = false;
        t.flipAngle = 0;
        t.flipAngularVel = 0;
        t.flipVx = 0;
        t.flipVy = 0;
        t.onGround = true;
        t.dx = 0;
        t.dy = 0;
        t.dir = Math.random() > 0.5 ? 1 : -1; // face a random direction after landing
      }
      continue; // skip normal AI while flipping
    }

    // =====================================================
    //  NORMAL STATE — patrol on the ground
    // =====================================================
    t.dy += gravity;
    if (t.dy > 12) t.dy = 12;

    t.dx = t.dir * t.speed;
    t.x += t.dx;
    t.y += t.dy;
    t.onGround = false;

    // Wall collisions
    for (let wall of walls) {
      if (!isColliding(t, wall)) continue;
      const ox = Math.min(t.x + t.width - wall.x, wall.x + wall.width - t.x);
      const oy = Math.min(t.y + t.height - wall.y, wall.y + wall.height - t.y);

      if (ox < oy) {
        t.x += t.x < wall.x ? -ox : ox;
        t.dir *= -1;
        t.dx = 0;
      } else {
        if (t.y < wall.y) {
          t.y -= oy;
          t.dy = 0;
          t.onGround = true;
        } else {
          t.y += oy;
          t.dy = 0;
        }
      }
    }

    // Edge detection — don't walk off ledges
    if (t.onGround) {
      const frontX = t.dir > 0 ? t.x + t.width + 2 : t.x - 2;
      const frontY = t.y + t.height + 4;
      let groundAhead = false;
      for (let wall of walls) {
        if (frontX > wall.x && frontX < wall.x + wall.width &&
            frontY > wall.y && frontY < wall.y + wall.height) {
          groundAhead = true; break;
        }
      }
      if (!groundAhead) t.dir *= -1;
    }


    // Animate walking frames
if (t.onGround) {
  t.frameTimer++;
  if (t.frameTimer >= t.frameSpeed) {
    t.frameTimer = 0;
    t.frame = (t.frame + 1) % tableFrames.length;
  }
}
    // --- TABLE vs PLAYER collision ---
    if (isColliding(t, player)) {
      const playerFeet = player.y + player.height;
      const tableTop   = t.y + 6;   // a little tolerance at the surface

      const landingFromAbove = playerFeet <= tableTop + 10 && player.dy >= 0;
      if (landingFromAbove) {
        // Ride the table — it's a platform!
        player.y = t.y - player.height;
        player.dy = 0;
        player.onGround = true;
        player.x += t.dx;
      } else {
        // Walked into the legs — FLIP the table and hurt player
        damagePlayer("Table Legs");
        triggerTableFlip(t, player.dx * 0.5);
      }
    }

    // --- TABLE shoves BOXES ---
    for (let box of boxes) {
      if (!isColliding(t, box)) continue;
      const ox = Math.min(t.x+t.width-box.x, box.x+box.width-t.x);
      const oy = Math.min(t.y+t.height-box.y, box.y+box.height-t.y);
      if (ox < oy) {
        box.x += t.x < box.x ? ox : -ox;
        box.dx = t.dx * 1.1;
      } else {
        if (t.y < box.y) { box.y += oy; box.dy = 0; }
      }
    }
  }
}

function drawTables() {
  for (let t of G.tables) {
    if (!isEffectVisibleInWorld(t.x - 10, t.y - 20, t.width + 20, t.height + 20, 120)) continue;
    ctx.save();

const cx = t.x + t.width / 2;
const cy = t.y + t.height / 2;

if (t.hitFlash > 0) ctx.filter = "brightness(8)";

if (t.flipping) {
  // Frozen on frame 0 while airborne
  const img = tableFrames[0];
  if (img && img.complete) {
    ctx.translate(cx, cy);
    ctx.rotate(t.flipAngle);
    ctx.drawImage(img, -t.width / 2 - 10, -t.height / 2 - 10, t.width + 20, t.height + 20);
  }
} else {
  // Walking animation — flip sprite based on direction
  const img = tableFrames[t.frame];
  if (img && img.complete) {
    if (t.dir > 0) {
      ctx.translate(t.x + t.width, t.y);
      ctx.scale(-1, 1);
      ctx.drawImage(img, -10, -20, t.width + 20, t.height + 20);
    } else {
      ctx.drawImage(img, t.x - 10, t.y - 20, t.width + 20, t.height + 20);
    }
  }
}

    ctx.restore();
    
  const barW = t.width;
  const barH = 4;
  const barX = t.flipping ? cx - t.width / 2 : t.x;
  const barY = t.flipping ? cy - t.height / 2 - 8 : t.y - 8;
  ctx.fillStyle = "#300";
  ctx.fillRect(barX, barY, barW, barH);
  const pct = t.hp / t.maxHp;
  ctx.fillStyle = pct > 0.5 ? "#0f0" : pct > 0.25 ? "#ff0" : "#f00";
  ctx.fillRect(barX, barY, barW * pct, barH);
  ctx.strokeStyle = "#000";
  ctx.lineWidth = 1;
  ctx.strokeRect(barX, barY, barW, barH);
  }
}
// === END TABLE MODULE ===
function createChair(x, y) {
  return {
    x, y,
    width: 40,
    height: 48,
    dx: 0,
    dy: 0,
    dir: Math.random() > 0.5 ? 1 : -1,
    speed: 1.2 + Math.random() * 0.6,
    frame: 0,
    frameTimer: 0,
    frameSpeed: 7,
    onGround: false,
    hp: 3,
    maxHp: 3,
    hitFlash: 0,
    knockbackTimer: 0,
    knockbackDx: 0,
    knockbackDy: 0
  };
}

// --- DRAW PLAYER ---
function drawPlayer() {
  let srcX = player.walkFrame * WALK_FRAME_WIDTH;
  let srcY = 0;
  let srcW = WALK_FRAME_WIDTH;
  let srcH = WALK_FRAME_HEIGHT;
  const sheet = playerWalkSheet;

  // Sprite is wider than hitbox — offset left so it's centered on the hitbox
  const drawX = player.x - PLAYER_SPRITE_OX;
  const drawY = player.y + player.height - PLAYER_SPRITE_H; // pin feet to hitbox bottom

  // If rolling, draw a single rotated full-size sprite centered on the top-half instead
  if (player.animState === "roll") {
    const ovCx = drawX + PLAYER_SPRITE_W / 2;
    const ovCy = drawY + PLAYER_SPRITE_H * 0.75; // top-half center (on floor)

    ctx.save();
    ctx.translate(ovCx, ovCy);
    ctx.rotate(player._rollSpin || 0);
    if (player.facing === 1) ctx.scale(-1, 1);
    ctx.imageSmoothingEnabled = false;
    ctx.drawImage(sheet, srcX, srcY, srcW, srcH, -PLAYER_SPRITE_W / 2, -PLAYER_SPRITE_H / 2, PLAYER_SPRITE_W, PLAYER_SPRITE_H);
    ctx.restore();
    return; // skip normal drawing
  }

  ctx.save();
  if (player.facing === 1) {
    ctx.translate(drawX + PLAYER_SPRITE_W, drawY);
    ctx.scale(-1, 1);
    if (player.animState === "crouch") {
      ctx.drawImage(sheet, srcX, srcY, srcW, srcH, 0, 3 + (PLAYER_SPRITE_H - 40), PLAYER_SPRITE_W, 40);
    } else {
      ctx.drawImage(sheet, srcX, srcY, srcW, srcH, 0, 3, PLAYER_SPRITE_W, PLAYER_SPRITE_H);
    }
  } else {
    if (player.animState === "crouch") {
      ctx.drawImage(sheet, srcX, srcY, srcW, srcH, drawX, drawY + 3 + (PLAYER_SPRITE_H - 40), PLAYER_SPRITE_W, 40);
    } else {
      ctx.drawImage(sheet, srcX, srcY, srcW, srcH, drawX, drawY + 3, PLAYER_SPRITE_W, PLAYER_SPRITE_H);
    }
  }
  ctx.restore();
};

function updateChairs() {
  for (let c of G.chairs) {
    ensureEntityInBounds(c);

    if (c.hitFlash > 0) c.hitFlash--;

    // Knockback
    if (c.knockbackTimer > 0) {
      c.x += c.knockbackDx;
      c.y += c.knockbackDy;
      c.knockbackDx *= 0.85;
      c.knockbackDy *= 0.85;
      c.knockbackTimer--;
      continue;
    }

    // Gravity
    c.dy += gravity;
    if (c.dy > 12) c.dy = 12;

    c.dx = c.dir * c.speed;
    c.x += c.dx;
    c.y += c.dy;
    c.onGround = false;

    // Wall collisions
    for (let wall of walls) {
      if (!isColliding(c, wall)) continue;
      const ox = Math.min(c.x + c.width - wall.x, wall.x + wall.width - c.x);
      const oy = Math.min(c.y + c.height - wall.y, wall.y + wall.height - c.y);

      if (ox < oy) {
        c.x += c.x < wall.x ? -ox : ox;
        c.dir *= -1;
        c.dx = 0;
      } else {
        if (c.y < wall.y) {
          c.y -= oy;
          c.dy = 0;
          c.onGround = true;
        } else {
          c.y += oy;
          c.dy = 0;
        }
      }
    }

    // Edge detection — turn before falling off ledge
    if (c.onGround) {
      const frontX = c.dir > 0 ? c.x + c.width + 2 : c.x - 2;
      const frontY = c.y + c.height + 4;
      let groundAhead = false;
      for (let wall of walls) {
        if (frontX > wall.x && frontX < wall.x + wall.width &&
            frontY > wall.y && frontY < wall.y + wall.height) {
          groundAhead = true;
          break;
        }
      }
      if (!groundAhead) c.dir *= -1;
    }

    // Animation
    c.frameTimer++;
    if (c.frameTimer >= c.frameSpeed) {
      c.frameTimer = 0;
      c.frame = (c.frame + 1) % chairFrames.length;
    }

    // --- CHAIR COLLISIONS WITH BOXES ---
    for (let box of boxes) {
      if (!isColliding(c, box)) continue;

      const ox = Math.min(c.x + c.width - box.x, box.x + box.width - c.x);
      const oy = Math.min(c.y + c.height - box.y, box.y + box.height - c.y);

      if (ox < oy) {
        // Horizontal — chair shoves box sideways
        if (c.x < box.x) {
          // Check if box is blocked by a wall before pushing
          const blocked = walls.some(w =>
            box.x + ox > w.x &&
            box.x + ox < w.x + w.width &&
            box.y + box.height > w.y &&
            box.y < w.y + w.height
          );
          if (!blocked) {
            box.x += ox;
            box.dx = c.dx * 0.85;
          } else {
            // Chair is blocked by box+wall — bounce chair
            c.dir *= -1;
            c.dx = 0;
          }
        } else {
          const blocked = walls.some(w =>
            box.x - ox + box.width > w.x &&
            box.x - ox < w.x + w.width &&
            box.y + box.height > w.y &&
            box.y < w.y + w.height
          );
          if (!blocked) {
            box.x -= ox;
            box.dx = c.dx * 0.85;
          } else {
            c.dir *= -1;
            c.dx = 0;
          }
        }
      } else {
        if (c.y < box.y) {
          // Chair lands on top of box
          c.y -= oy;
          c.dy = 0;
          c.onGround = true;
          // Box gets pressed down slightly by chair weight
          box.dy += 0.5;
          // Carry box along if chair is moving
          box.dx += c.dx * 0.4;
        } else {
          // Box lands on top of chair — ride it
          box.y = c.y - box.height;
          box.dy = 0;
          box.x += c.dx * 0.85; // box rides the chair
        }
      }
    }
    
    // --- PLAYER COLLISION ---
    if (!isColliding(c, player)) continue;

    const playerFeet = player.y + player.height;
    const chairMid = c.y + c.height * 0.5; // halfway down sprite

    const landingFromAbove = playerFeet <= chairMid + 8 && player.dy >= 0;

    if (landingFromAbove) {
      // Safe zone — ride it
      player.y = c.y - player.height;
      player.dy = 0;
      player.onGround = true;
      player.x += c.dx; // carry player along
    } else {
      // Leg zone — ouch
      damagePlayer("Chair");
    }
  }
}

function drawChairs() {
  for (let c of G.chairs) {
    if (!isEffectVisibleInWorld(c.x - 10, c.y - 10, c.width + 20, c.height + 20, 120)) continue;
    const img = chairFrames[c.frame];
    if (!img || !img.complete) continue;

    ctx.save();
    if (c.hitFlash > 0) ctx.filter = "brightness(8)";

    if (c.dir < 0) {
      ctx.translate(c.x + c.width, c.y);
      ctx.scale(-1, 1);
      ctx.drawImage(img, -10, -10, c.width + 20, c.height + 20);
    } else {
      ctx.drawImage(img, c.x -10, c.y -10, c.width + 20, c.height + 20);
    }
    ctx.restore();
  }
}

// LOCAL player input snapshot — in multiplayer, remote players get this
// filled from the network instead of from keys[]
function getLocalInput() {
  return {
    left:   !!(isActionPressed("left") || localInput._gpLeft),
    right:  !!(isActionPressed("right") || localInput._gpRight),
    down:   !!(isActionPressed("down") || localInput._gpDown),
    jump:   !!(isActionPressed("jump") || localInput._gpJump),
    dash:   !!(isActionPressed("dash") || localInput._gpDash),
    attack: !!(isActionPressed("attack") || localInput._gpAttack),
    sword:  !!(isActionPressed("sword") || localInput._gpSword),
  };
}

// The active input for the local player — swap this out for network input later
let localInput = {};
let prevInput  = {};
// --- UPDATE PLAYER ---

function updatePlayerAnimation() {
  const isMoving   = Math.abs(player.dx) > 0.5;
  const isOnGround = player.onGround;
  const isDashing  = player.dashActive;
  const isRolling  = player.rollActive;
  const isAttacking = player.attackTimer > 0 || player.swordTimer > 0;
  // Determine state
  // Crouch animation has priority when on ground
  if (player.crouching) {
    player.animState = "crouch";
  } else if (isRolling) {
    player.animState = "roll";
  } else if (isDashing) {
    player.animState = "dash";
  } else if (isAttacking) {
    player.animState = "attack";
  } else if (!isOnGround && player.dy < 0) {
    player.animState = "jump";
  } else if (!isOnGround && player.dy > 0) {
    player.animState = "fall";
  } else if (isMoving) {
    player.animState = "walk";
  } else {
    player.animState = "idle";
  }

  // Advance walk frame — speed scales the animation rate
  if (player.animState === "walk"|| player.animState === "crouch"|| player.animState === "fall"|| player.animState === "jump") {
    // Higher speed = faster animation. Base speed ~2, so normalize around that.
    const speedRatio   = Math.abs(player.dx) / player.speed;  // 0..1+
    const frameDuration = Math.max(2, Math.round(6 / speedRatio)); // frames per anim frame

    player.walkTimer++;
    if (player.walkTimer >= frameDuration) {
      player.walkTimer = 0;
      player.walkFrame += 1;
      if (player.walkFrame >= 8) {
        player.walkFrame = 0;
      }
    }
  }
  }


function updatePlayer() {
  if (gameOver || levelUpPending) return;
  if (playerInVehicle) return;

  const speedChiliActive = player.speedChiliTimer > 0;

  prevInput  = { ...localInput };
localInput = getLocalInput();

  // Ladder presence detection: treat the player as on a ladder before physics.
  let isOnLadder = false;
  for (let ladder of ladders) {
    if (
      player.x + player.width > ladder.x &&
      player.x < ladder.x + ladder.width &&
      player.y + player.height > ladder.y &&
      player.y < ladder.y + ladder.height
    ) {
      isOnLadder = true;
      break;
    }
  }
  player.isOnLadder = isOnLadder;

// Attack pressed this frame (keyboard/gamepad edge)
if (localInput.attack && !prevInput.attack) {
  if (player.attackTimer <= 0 && player.attackCooldown <= 0) {
    player.attackTimer = player.attackDuration;
    player.attackCooldown = 20;
    player.attackHitObjects.clear();
  }
}

// Directional sword swings immediately on press
if (localInput.sword && !prevInput.sword) {
  if (player.swordTimer <= 0 && player.swordCooldown <= 0) {
    const inAir = !player.onGround;
    if (localInput.down && inAir) {
      player.swordDir = "down";
    } else if (localInput.jump) {
      player.swordDir = "up";
    } else {
      player.swordDir = player.facing >= 0 ? "right" : "left";
    }
    player.swordTimer = player.swordDuration;
    player.swordCooldown = player.swordBaseCooldown;
    player.swordHitObjects.clear();
    playSwordSound();
  }
}
// Attack released this frame (keyboard/gamepad edge)
if (!localInput.attack && prevInput.attack) {
  // no-op: club is instant now
}

// Crouch handling: hold Down while on ground to crouch
if (localInput.down && player.onGround) {
  if (!player.crouching) {
    player.crouching = true;
    player._standHeight = player.height;
    player.height = player.crouchHeight;
    // keep feet in same position
    player.y += (player._standHeight - player.height);
  }
  // slow movement while crouched
  player.slowMultiplier = Math.min(player.slowMultiplier || 1, 0.5);
} else if (!localInput.down && player.crouching) {
  // try to stand up: ensure no ceiling collision
  const desiredHeight = player._standHeight || 64;
  const newY = player.y - (desiredHeight - player.height);
  const testRect = { x: player.x, y: newY, width: player.width, height: desiredHeight };
  let blocked = false;
  for (const w of walls) {
    if (rectsOverlap(testRect, w)) { blocked = true; break; }
  }
  if (!blocked) {
    player.crouching = false;
    player.y = newY;
    player.height = desiredHeight;
    delete player._standHeight;
  } else {
    // remain crouched
    player.slowMultiplier = Math.min(player.slowMultiplier || 1, 0.5);
  }
}

if (speedChiliActive) {
  player.slowMultiplier = 1;
}

if (player.attackTimer > 0) {
    player.attackTimer--;
  }
  
  if (player.iframes > 0) player.iframes--;

  // Decrease cooldown
  if (player.attackCooldown > 0) {
    player.attackCooldown--;
  }

  // Horizontal movement
const ground = getGroundSurface(player);
const onIce = ground && ground.ice;

let accel = onIce ? 0.6 : player.speed;
let friction = onIce ? 0.99 : 0.0;

const playerGravity = gravity - 0.05;
const moveSpeed = speedChiliActive ? SPEED_CHILI_SPEED : player.speed * player.slowMultiplier;


if (speedChiliActive) {
  if (localInput.left && !localInput.right) {
    player.speedChiliDirection = -1;
  } else if (localInput.right && !localInput.left) {
    player.speedChiliDirection = 1;
  } else if (!player.speedChiliDirection) {
    player.speedChiliDirection = player.facing || 1;
  }

  player.facing = player.speedChiliDirection;
  player.dx = player.speedChiliDirection * moveSpeed;
} else {
  // input
  if (localInput.left) {
    player.dx -= accel;
    player.facing = -1;
  }
  if (localInput.right) {
    player.dx += accel;
    player.facing = 1;
  }

  // friction when no input
  if (
    !localInput.left &&
    !localInput.right
  ) {
    player.dx *= friction;
  }

  // hard clamp speed (THIS is the important part)
  if (!player.dashActive) {
    player.dx = Math.max(
      -moveSpeed,
      Math.min(player.dx, moveSpeed)
    );
  }
}

if (localInput.dash) {
  tryDash();
}
  // Jumping
if ((localInput.jump) && player.onGround) {
  player.dy = -player.jumpPower;
  player.onGround = false;
  player._jumpHeld = true;
} else if ((localInput.jump) && player.onWall) {
  player.dy = -player.wallJumpPower;
  player.wallJumpBoost = 60 * -player.wallDir;
  player.onWall = false;
  player._jumpHeld = true;
} else if ((localInput.jump) && !player._jumpHeld &&
           !player.onGround && !player.onWall && playerUpgrades.extraJumpsLeft > 0) {
  // Double / extra jump
  player.dy = -player.jumpPower * 0.9;
  playerUpgrades.extraJumpsLeft--;
  player._jumpHeld = true;
} else if (!(localInput.jump)) {
  player._jumpHeld = false;
}

//Sword
// Charging
// Decrease cooldown
if (player.attackCooldown > 0) player.attackCooldown--;
if (player.swordCooldown > 0) player.swordCooldown--;

  // Ladder physics: stick to ladder while climbing and avoid horizontal drift.
  if (player.isOnLadder) {
    player.onGround = false;
    player.onWall = false;
    player.wallSliding = false;
    player.dy = 0;
    if (!localInput.left && !localInput.right) {
      player.dx = 0;
    } else {
      player.dx *= 1;
    }
  } else {
    // Gravity
    if (player.featherBootsTimer > 0 && player.dy > 0) {
      player.dy += gravity * FEATHER_BOOTS_FALL_GRAVITY_MULTIPLIER;
      if (player.dy > FEATHER_BOOTS_MAX_FALL_SPEED) {
        player.dy = FEATHER_BOOTS_MAX_FALL_SPEED;
      }
    } else {
      player.dy += playerGravity;
    }
  }

  if (speedChiliActive) {
    player.dx = player.speedChiliDirection * moveSpeed;
  }

  // Wall jump horizontal boost
  if (player.wallJumpBoost !== 0) {
    player.dx += player.wallJumpBoost * 0.2;
    player.wallJumpBoost *= 0.7;
    if (Math.abs(player.wallJumpBoost) < 0.5) player.wallJumpBoost = 0;
  }

  const fastfall = (isActionPressed("down"));
  // Apply velocity
  if (!fastfall && player.dy > 12) player.dy = 12;  // cap BEFORE moving
  if (player.dy > 16) player.dy = 16;

  // Dash override
  if (player.dashDuration > 0) {
    player.dx = player.facing * player.dashSpeed;
    player.dy *= 0.15;
    player.dashDuration--;
    if (player.dashDuration === 0) player.dashActive = false;
  }
  if (player.dashCooldown > 0) player.dashCooldown--;
  // Roll override (ground-only rapid movement)
  if (player.rollDuration > 0) {
    player.dx = player.facing * player.rollSpeed;
    // keep player grounded while rolling
    if (player.onGround) player.dy = 0;
    player.rollDuration--;
    if (player.rollDuration === 0) player.rollActive = false;
  }
  if (player.rollCooldown > 0) player.rollCooldown--;

  // --- Handle shrinking hitbox when roll starts / restore when ends ---
  if (player.rollActive && !player._rollSaved) {
    // save original
    player._rollSaved = true;
    player._origWidth = player.width;
    player._origHeight = player.height;
    player._origY = player.y;
    // shrink to 32x32 and keep feet in place
    const newH = 32;
    const newW = 32;
    player.height = newH;
    player.width = newW;
    player.y = player._origY + (player._origHeight - newH);
  }

  if (!player.rollActive && player._rollSaved) {
    // restore
    player.width = player._origWidth || player.width;
    player.height = player._origHeight || player.height;
    player.y = player._origY || player.y;
    delete player._origWidth; delete player._origHeight; delete player._origY;
    player._rollSaved = false;
  }

  // roll spin timer for visual
  if (player.rollActive) {
    // spin faster and in facing direction
    const spinSpeed = 0.5; // radians per frame base
    player._rollSpin = (player._rollSpin || 0) + spinSpeed * (player.facing || 1);
  } else {
    player._rollSpin = 0;
  }

  // Reset ground/wall flags
  player.onGround = false;
  player.onWall = false;

  // ── X pass ──
  player.x += player.dx;
  for (let wall of walls) {
    if (!rectsOverlap(player, wall)) continue;
    const overlapX = Math.min(
      player.x + player.width - wall.x,
      wall.x + wall.width - player.x
    );
    if (player.x < wall.x) player.x -= overlapX;
    else                    player.x += overlapX;
    player.dx = 0;
    player.onWall = true;
    player.wallDir = player.x < wall.x ? 1 : -1;
  }

  // ── Y pass (substepped so fast falls don't tunnel) ──
  const steps = Math.ceil(Math.abs(player.dy) / 8);
  const stepDY = player.dy / steps;
  for (let s = 0; s < steps; s++) {
    player.y += stepDY;
    for (let wall of walls) {
      if (!rectsOverlap(player, wall)) continue;
      const overlapY = Math.min(
        player.y + player.height - wall.y,
        wall.y + wall.height - player.y
      );
      if (player.y < wall.y) {
        player.y -= overlapY;
        player.dy = 0;
        player.onGround = true;
      } else {
        player.y += overlapY;
        player.dy = 0;
      }
    }
  }
  if (player.chaosStall > 0) {
  player.dy = 0;
  player.chaosStall--;
  return;
}

// Reset air dash when grounded
  if (player.onGround) player.dashUsedInAir = false;
  if (player.onGround) {
  playerUpgrades.extraJumpsLeft = playerUpgrades.extraJumpsMax;
}
  
  // --- Lose life if player falls off-screen ---
  if (player.y > world.height + 200) { // extra margin below screen
    damagePlayer("Off-Screen (how?)");
  }
}


function drawPlayerClub() {
  if (player.attackTimer <= 0) return;
  
  const t = 1 - player.attackTimer / player.attackDuration;
  
  const startAngle = CLUB_ATTACK_BASE_ANGLE - CLUB_ATTACK_SWING_SPAN / 2;
  const angle = startAngle + t * CLUB_ATTACK_SWING_SPAN;
  
  const pivotX = player.x + player.width / 2;
  const pivotY = player.y + player.height / 2;
  const radius = CLUB_ATTACK_RADIUS * (playerUpgrades.swordRangeMulti || 1);
  
  const tipX = pivotX + Math.cos(angle) * radius;
  const tipY = pivotY + Math.sin(angle) * radius;

  if (clubImg.complete && clubImg.naturalWidth > 0) {
    const sourceW = clubImg.naturalWidth;
    const sourceH = clubImg.naturalHeight;
    const sourceLen = Math.hypot(sourceW, sourceH) || 1;
    const desiredLen = radius + CLUB_DRAW_TIP_PADDING;
    const scale = desiredLen / sourceLen;
    const drawW = sourceW * scale;
    const drawH = sourceH * scale;

    // Sprite points from bottom-left (handle) to top-right (head), so rotate by +45deg.
    const spriteAngle = angle + CLUB_SPRITE_ROTATION_OFFSET;

    ctx.save();
    ctx.globalAlpha = 0.7;
    ctx.translate(pivotX, pivotY);
    ctx.rotate(spriteAngle - 0.2);
    ctx.drawImage(clubImg, 0, -drawH, drawW, drawH);
    ctx.restore();

    ctx.save();
    ctx.globalAlpha = 0.45;
    ctx.translate(pivotX, pivotY);
    ctx.rotate(spriteAngle - 0.38);
    ctx.drawImage(clubImg, 0, -drawH, drawW, drawH);
    ctx.restore();

    ctx.save();
    ctx.translate(pivotX, pivotY);
    ctx.rotate(spriteAngle);
    ctx.drawImage(clubImg, 0, -drawH, drawW, drawH);
    ctx.restore();
  } else {
    // Fallback while the club image is loading.
    const dynamicWidth = CLUB_FALLBACK_STROKE_BASE + Math.sin(t * Math.PI) * CLUB_FALLBACK_STROKE_VARIATION;
    const grad = ctx.createLinearGradient(pivotX, pivotY, tipX, tipY);
    grad.addColorStop(0, "#8d6e63");
    grad.addColorStop(0.7, "#a1887f");
    grad.addColorStop(1, "#5d4037");
    ctx.strokeStyle = grad;
    ctx.lineWidth = dynamicWidth;
    ctx.beginPath();
    ctx.moveTo(pivotX, pivotY);
    ctx.lineTo(tipX, tipY);
    ctx.stroke();
  }
}

function drawSword() {
  if (player.swordTimer <= 0) return;

  // Calculate animation progress (0 = start, 1 = end)
  const animProgress = 1 - player.swordTimer / player.swordDuration;
  
  // Map animation progress to frame index (0-6)
  const frameIndex = Math.floor(animProgress * SWORD_FRAME_COUNT);
  const clampedFrame = Math.min(frameIndex, SWORD_FRAME_COUNT - 1);

  const SWORD_SCALE = SWORD_ATTACK_DRAW_SCALE;

  // Determine which frame set to use based on direction
  let frameSet = swordAnimFrames.right;
  let drawOffsetX = 0;
  let drawOffsetY = 0;

  if (player.swordDir === "right") {
    frameSet = swordAnimFrames.rightExtended;
    drawOffsetX = player.x + player.width / 2;
    drawOffsetY = player.y + player.height / 2 - (SWORD_FRAME_HEIGHT * SWORD_SCALE) / 2;
  } else if (player.swordDir === "left") {
    frameSet = swordAnimFrames.leftExtended;
    // Offset to center the extended frame
    drawOffsetX = player.x + player.width / 2 - ((SWORD_FRAME_WIDTH + SWORD_ATTACK_EXTENSION_WIDTH) * SWORD_SCALE);
    drawOffsetY = player.y + player.height / 2 - (SWORD_FRAME_HEIGHT * SWORD_SCALE) / 2;
  } else if (player.swordDir === "up") {
    // Up swing - use right frame rotated, starts at top of player
    frameSet = swordAnimFrames.right;
    drawOffsetX = player.x + player.width / 2 - (SWORD_FRAME_WIDTH * SWORD_SCALE) / 2;
    drawOffsetY = player.y - (SWORD_FRAME_HEIGHT * SWORD_SCALE);
  } else if (player.swordDir === "down") {
    // Down swing - use right frame rotated, starts at bottom of player
    frameSet = swordAnimFrames.right;
    drawOffsetX = player.x + player.width / 2 - (SWORD_FRAME_WIDTH * SWORD_SCALE) / 2;
    drawOffsetY = player.y + player.height;
  }

  // Draw the sprite frame
  const frame = frameSet[clampedFrame];
  if (frame) {
    ctx.save();
    ctx.globalAlpha = SWORD_DRAW_ALPHA;
    ctx.shadowColor = SWORD_DRAW_SHADOW_COLOR;
    ctx.shadowBlur = SWORD_DRAW_SHADOW_BLUR;
    
    if (player.swordDir === "up") {
      ctx.translate(drawOffsetX + (SWORD_FRAME_WIDTH * SWORD_SCALE) / 2, drawOffsetY + (SWORD_FRAME_HEIGHT * SWORD_SCALE) / 2);
      ctx.rotate(-Math.PI / 2);
      ctx.drawImage(frame, -(SWORD_FRAME_HEIGHT * SWORD_SCALE) / 2, -(SWORD_FRAME_WIDTH * SWORD_SCALE) / 2, SWORD_FRAME_HEIGHT * SWORD_SCALE, SWORD_FRAME_WIDTH * SWORD_SCALE);
    } else if (player.swordDir === "down") {
      ctx.translate(drawOffsetX + (SWORD_FRAME_WIDTH * SWORD_SCALE) / 2, drawOffsetY + (SWORD_FRAME_HEIGHT * SWORD_SCALE) / 2);
      ctx.rotate(Math.PI / 2);
      ctx.drawImage(frame, -(SWORD_FRAME_HEIGHT * SWORD_SCALE) / 2, -(SWORD_FRAME_WIDTH * SWORD_SCALE) / 2, SWORD_FRAME_HEIGHT * SWORD_SCALE, SWORD_FRAME_WIDTH * SWORD_SCALE);
    } else {
      ctx.drawImage(frame, drawOffsetX, drawOffsetY, (SWORD_FRAME_WIDTH + (player.swordDir === "right" ? SWORD_ATTACK_EXTENSION_WIDTH : player.swordDir === "left" ? SWORD_ATTACK_EXTENSION_WIDTH : 0)) * SWORD_SCALE, SWORD_FRAME_HEIGHT * SWORD_SCALE);
    }
    
    ctx.restore();
  }
}

function applyClubStun(enemy, duration = 36) {
  if (!enemy) return;
  enemy.stunTimer = Math.max(enemy.stunTimer || 0, duration);
  enemy.hitFlash = Math.max(enemy.hitFlash || 0, 4);
  enemy.knockbackTimer = Math.max(enemy.knockbackTimer || 0, duration);
  enemy.knockbackDx = 0;
  enemy.knockbackDy = 0;
}

function getDirectionalSwordHitbox() {
  const baseX = player.x + player.width / 2;
  const baseY = player.y + player.height / 2;
  const range = (SWORD_FRAME_WIDTH + SWORD_ATTACK_EXTENSION_WIDTH) * (playerUpgrades.swordRangeMulti || 1);
  const width = SWORD_FRAME_HEIGHT;

  if (player.swordDir === "up") {
    return { x: baseX - width / 2, y: baseY - range, width, height: range };
  }
  if (player.swordDir === "down") {
    return { x: baseX - width / 2, y: baseY, width, height: range };
  }
  if (player.swordDir === "left") {
    return { x: baseX - range, y: baseY - width / 2, width: range, height: width };
  }
  // Right
  return { x: baseX, y: baseY - width / 2, width: range, height: width };
}

function getClubAttackHitbox() {
  if (player.attackTimer <= 0 || player.attackDuration <= 0) return null;

  const progress = 1 - player.attackTimer / player.attackDuration;
  const swingStartAngle = CLUB_ATTACK_BASE_ANGLE - CLUB_ATTACK_SWING_SPAN / 2;
  const angle = swingStartAngle + progress * CLUB_ATTACK_SWING_SPAN;
  const pivotX = player.x + player.width / 2;
  const pivotY = player.y + player.height / 2;
  const radius = CLUB_ATTACK_RADIUS * (playerUpgrades.swordRangeMulti || 1);
  const tipX = pivotX + Math.cos(angle) * radius;
  const tipY = pivotY + Math.sin(angle) * radius;

  return {
    x: tipX - CLUB_ATTACK_BOX_HALF_WIDTH,
    y: tipY - CLUB_ATTACK_BOX_HALF_HEIGHT,
    width: CLUB_ATTACK_BOX_WIDTH,
    height: CLUB_ATTACK_BOX_HEIGHT
  };
}

function getClubKnockback(targetX, targetY, multiplier = CLUB_ENEMY_KNOCKBACK_MULTIPLIER) {
  const pivotX = player.x + player.width / 2;
  const pivotY = player.y + player.height / 2;
  const dx = targetX - pivotX;
  const dy = targetY - pivotY;
  const length = Math.hypot(dx, dy) || 1;
  return {
    x: (dx / length) * multiplier,
    y: (dy / length) * multiplier - 2
  };
}

function drawDebugHitbox(hitbox, color) {
  if (!hitbox) return;
  ctx.save();
  ctx.lineWidth = DEBUG_HITBOX_LINE_WIDTH;
  ctx.strokeStyle = color;
  ctx.fillStyle = color;
  ctx.globalAlpha = DEBUG_HITBOX_FILL_ALPHA;
  ctx.fillRect(hitbox.x, hitbox.y, hitbox.width, hitbox.height);
  ctx.globalAlpha = 1;
  ctx.strokeRect(hitbox.x, hitbox.y, hitbox.width, hitbox.height);
  ctx.restore();
}

function getSwordKnockback(ex, ey) {
  const px = player.x + player.width / 2;
  const py = player.y + player.height / 2;
  const dx = ex - px;
  const dy = ey - py;
  const len = Math.hypot(dx, dy) || 1;
  return { x: (dx / len) * 11, y: (dy / len) * 11 - 4 };
}

function hitSwordTargets(attackBox) {
  const damage = 1;
  let shouldBounce = player.swordDir === "down";

  for (let i = G.snails.length - 1; i >= 0; i--) {
    const s = G.snails[i];
    if (!isColliding(attackBox, s) || player.swordHitObjects.has(s)) continue;
    const died = damageEnemy(s, damage, getSwordKnockback(s.x, s.y));
    if (died) { G.snails.splice(i, 1); onEnemyKilled("snail"); }
    if (shouldBounce) player.dy = SWORD_DOWN_BOUNCE_VELOCITY;
    player.swordHitObjects.add(s);
    triggerScreenShake(3);
  }

  for (let i = G.SuperSnails.length - 1; i >= 0; i--) {
    const s = G.SuperSnails[i];
    if (!isColliding(attackBox, s) || player.swordHitObjects.has(s)) continue;
    const died = damageEnemy(s, damage, getSwordKnockback(s.x, s.y));
    if (died) { G.SuperSnails.splice(i, 1); onEnemyKilled("superSnail"); }
    if (shouldBounce) player.dy = SWORD_DOWN_BOUNCE_VELOCITY;
    player.swordHitObjects.add(s);
    triggerScreenShake(5);
  }

  for (let i = G.babyMicrowaves.length - 1; i >= 0; i--) {
    const m = G.babyMicrowaves[i];
    if (!isColliding(attackBox, m) || player.swordHitObjects.has(m)) continue;
    const died = damageEnemy(m, damage, getSwordKnockback(m.x, m.y));
    if (died) triggerBabyMicrowaveExplosion(m);
    if (shouldBounce) player.dy = SWORD_DOWN_BOUNCE_VELOCITY;
    player.swordHitObjects.add(m);
    triggerScreenShake(2);
  }

  for (let i = G.bats.length - 1; i >= 0; i--) {
    const b = G.bats[i];
    if (!isColliding(attackBox, b) || player.swordHitObjects.has(b)) continue;
    const died = damageEnemy(b, damage, getSwordKnockback(b.x, b.y));
    if (died) { G.bats.splice(i, 1); onEnemyKilled("bat"); }
    if (shouldBounce) player.dy = SWORD_DOWN_BOUNCE_VELOCITY;
    player.swordHitObjects.add(b);
    triggerScreenShake(2);
  }

  for (let i = G.snowmen.length - 1; i >= 0; i--) {
    const s = G.snowmen[i];
    if (!isColliding(attackBox, s) || player.swordHitObjects.has(s)) continue;
    const died = damageEnemy(s, damage, getSwordKnockback(s.x, s.y));
    if (died) { G.snowmen.splice(i, 1); onEnemyKilled("snowman"); }
    if (shouldBounce) player.dy = SWORD_DOWN_BOUNCE_VELOCITY;
    player.swordHitObjects.add(s);
    triggerScreenShake(2);
  }

  for (const y of G.yetis) {
    if (!y.alive || !isColliding(attackBox, y) || player.swordHitObjects.has(y)) continue;
    const died = damageEnemy(y, damage, getSwordKnockback(y.x, y.y));
    if (died) { y.alive = false; onEnemyKilled("yeti"); }
    if (shouldBounce) player.dy = SWORD_DOWN_BOUNCE_VELOCITY;
    player.swordHitObjects.add(y);
    triggerScreenShake(5);
  }

  for (let i = G.turrets.length - 1; i >= 0; i--) {
    const t = G.turrets[i];
    if (!isColliding(attackBox, t) || player.swordHitObjects.has(t)) continue;
    const died = damageEnemy(t, damage, { x: 0, y: 0 });
    if (died) { G.turrets.splice(i, 1); onEnemyKilled("turret"); }
    if (shouldBounce) player.dy = SWORD_DOWN_BOUNCE_VELOCITY;
    player.swordHitObjects.add(t);
    triggerScreenShake(4);
  }

  for (let i = G.chairs.length - 1; i >= 0; i--) {
    const c = G.chairs[i];
    if (!isColliding(attackBox, c) || player.swordHitObjects.has(c)) continue;
    const died = damageEnemy(c, damage, getSwordKnockback(c.x, c.y));
    if (died) { G.chairs.splice(i, 1); onEnemyKilled("chair"); }
    if (shouldBounce) player.dy = SWORD_DOWN_BOUNCE_VELOCITY;
    player.swordHitObjects.add(c);
    triggerScreenShake(3);
  }

  for (let i = G.tables.length - 1; i >= 0; i--) {
    const t = G.tables[i];
    if (!isColliding(attackBox, t) || player.swordHitObjects.has(t)) continue;
    const died = damageEnemy(t, damage, getSwordKnockback(t.x, t.y));
    if (!t.flipping) triggerTableFlip(t, player.facing * 5);
    if (shouldBounce) player.dy = SWORD_DOWN_BOUNCE_VELOCITY;
    if (died) { G.tables.splice(i, 1); onEnemyKilled("table"); }
    player.swordHitObjects.add(t);
    triggerScreenShake(4);
  }

  for (const box of boxes) {
    if (!isColliding(attackBox, box) || player.swordHitObjects.has(box)) continue;
    damageBox(box, 1);
    const kb = getSwordKnockback(box.x, box.y);
    box.dx += kb.x * 3.5;
    box.dy += kb.y * 3.5;
    if (shouldBounce) player.dy = SWORD_DOWN_BOUNCE_VELOCITY;
    player.swordHitObjects.add(box);
    triggerScreenShake(1);
  }

  // Hit spikes with down attack
  if (shouldBounce) {
    for (const spike of spikes) {
      if (!isColliding(attackBox, spike)) continue;
      player.dy = SWORD_DOWN_BOUNCE_VELOCITY;
      triggerScreenShake(1);
      break; // Only bounce once per frame even if hitting multiple spikes
    }
  }

  damageCheeseCheck(attackBox, damage, { x: player.facing * 7, y: -4 });
}

function updateDirectionalSwordAttack() {
  if (player.swordTimer <= 0) return;
  const attackBox = getDirectionalSwordHitbox();
  hitSwordTargets(attackBox);
  player.swordTimer--;
}

function updatePlayerClubAttack() {
  if (player.attackTimer <= 0) return;
  const attackBox = getClubAttackHitbox();
  if (!attackBox) return;

  let hitEnemyThisFrame = false;
  
  // Hit G.snails
  for (let i = G.snails.length - 1; i >= 0; i--) {
    let s = G.snails[i];
    
    if (isColliding(attackBox, s) && !player.attackHitObjects.has(s)) {
      applyClubStun(s);
      damageEnemy(s, CLUB_DAMAGE, { x: 0, y: 0 });
      const knockback = getClubKnockback(s.x + (s.width || 0) / 2, s.y + (s.height || 0) / 2);
      s.knockbackDx = knockback.x;
      s.knockbackDy = knockback.y;
      player.dx -= knockback.x * 0.4; // Player recoil in opposite direction
      player.dy -= knockback.y * 0.4; // Upwards force from knockback
      hitEnemyThisFrame = true;
      player.attackHitObjects.add(s);
    }
  }
  
  // Hit super G.snails
  for (let i = G.SuperSnails.length - 1; i >= 0; i--) {
    let s = G.SuperSnails[i];
    
    if (isColliding(attackBox, s) && !player.attackHitObjects.has(s)) {
      applyClubStun(s);
      damageEnemy(s, CLUB_DAMAGE, { x: 0, y: 0 });
      const knockback = getClubKnockback(s.x + (s.width || 0) / 2, s.y + (s.height || 0) / 2);
      s.knockbackDx = knockback.x;
      s.knockbackDy = knockback.y;
      player.dx -= knockback.x * 0.4; // Player recoil in opposite direction
      player.dy -= knockback.y * 0.4; // Upwards force from knockback
      hitEnemyThisFrame = true;
      player.attackHitObjects.add(s);
    }
  }
  
  // Hit G.bats
  for (let i = G.bats.length - 1; i >= 0; i--) {
    let bat = G.bats[i];
    
    if (isColliding(attackBox, bat) && !player.attackHitObjects.has(bat)) {
      applyClubStun(bat);
      damageEnemy(bat, CLUB_DAMAGE, { x: 0, y: 0 });
      const knockback = getClubKnockback(bat.x + (bat.width || 0) / 2, bat.y + (bat.height || 0) / 2);
      bat.knockbackDx = knockback.x;
      bat.knockbackDy = knockback.y;
      player.dx -= knockback.x * 0.4; // Player recoil in opposite direction
      player.dy -= knockback.y * 0.4; // Upwards force from knockback
      hitEnemyThisFrame = true;
      player.attackHitObjects.add(bat);
    }
  }
  
  // Hit G.yetis
  for (let y of G.yetis) {
    if (!y.alive) continue;
    
    if (isColliding(attackBox, y) && !player.attackHitObjects.has(y)) {
      applyClubStun(y);
      damageEnemy(y, CLUB_DAMAGE, { x: 0, y: 0 });
      const knockback = getClubKnockback(y.x + (y.width || 0) / 2, y.y + (y.height || 0) / 2);
      y.knockbackDx = knockback.x;
      y.knockbackDy = knockback.y;
      player.dx -= knockback.x * 0.4; // Player recoil in opposite direction
      player.dy -= knockback.y * 0.4; // Upwards force from knockback
      hitEnemyThisFrame = true;
      player.attackHitObjects.add(y);
    }
  }
  
  // Hit G.snowmen
  for (let i = G.snowmen.length - 1; i >= 0; i--) {
    let s = G.snowmen[i];
    
    if (isColliding(attackBox, s) && !player.attackHitObjects.has(s)) {
      applyClubStun(s);
      damageEnemy(s, CLUB_DAMAGE, { x: 0, y: 0 });
      const knockback = getClubKnockback(s.x + (s.width || 0) / 2, s.y + (s.height || 0) / 2);
      s.knockbackDx = knockback.x;
      s.knockbackDy = knockback.y;
      player.dx -= knockback.x * 0.4; // Player recoil in opposite direction
      player.dy -= knockback.y * 0.4; // Upwards force from knockback
      hitEnemyThisFrame = true;
      player.attackHitObjects.add(s);
    }
  }
  // Hit G.turrets
  for (let i = G.turrets.length - 1; i >= 0; i--) {
    let t = G.turrets[i];
    
    if (isColliding(attackBox, t) && !player.attackHitObjects.has(t)) {
      applyClubStun(t, CLUB_TURRET_STUN_DURATION);
      damageEnemy(t, CLUB_DAMAGE, { x: 0, y: 0 });
      const knockback = getClubKnockback(t.x + (t.width || 0) / 2, t.y + (t.height || 0) / 2);
      t.knockbackDx = knockback.x;
      t.knockbackDy = knockback.y;
      player.dx -= knockback.x * 0.4; // Player recoil in opposite direction
      player.dy -= knockback.y * 0.4; // Upwards force from knockback
      hitEnemyThisFrame = true;
      player.attackHitObjects.add(t);
    }
  }

    // Hit G.chairs
  for (let i = G.chairs.length - 1; i >= 0; i--) {
    let c = G.chairs[i];
    if (isColliding(attackBox, c) && !player.attackHitObjects.has(c)) {
      applyClubStun(c);
      damageEnemy(c, CLUB_DAMAGE, { x: 0, y: 0 });
      const knockback = getClubKnockback(c.x + (c.width || 0) / 2, c.y + (c.height || 0) / 2);
      c.knockbackDx = knockback.x;
      c.knockbackDy = knockback.y;
      player.dx -= knockback.x * 0.4; // Player recoil in opposite direction
      player.dy -= knockback.y * 0.4; // Upwards force from knockback
      hitEnemyThisFrame = true;
      player.attackHitObjects.add(c);
    }
  }
  // Hit G.tables — club now deals half damage while still applying stun
  for (let i = G.tables.length - 1; i >= 0; i--) {
    let t = G.tables[i];
    if (isColliding(attackBox, t) && !player.attackHitObjects.has(t)) {
      applyClubStun(t);
      damageEnemy(t, CLUB_DAMAGE, { x: 0, y: 0 });
      const knockback = getClubKnockback(t.x + (t.width || 0) / 2, t.y + (t.height || 0) / 2, CLUB_BOX_KNOCKBACK_MULTIPLIER);
      t.knockbackDx = knockback.x;
      t.knockbackDy = knockback.y;
      player.dx -= knockback.x * 0.4; // Player recoil in opposite direction
      player.dy -= knockback.y * 0.4; // Upwards force from knockback
      hitEnemyThisFrame = true;
      player.attackHitObjects.add(t);
    }
  }

  for (const box of boxes) {
    if (!isColliding(attackBox, box) || player.attackHitObjects.has(box)) continue;
    const knockback = getClubKnockback(box.x + box.width / 2, box.y + box.height / 2, CLUB_BOX_KNOCKBACK_MULTIPLIER);
    box.dx += knockback.x;
    box.dy += knockback.y;
    player.dx -= knockback.x * 0.4; // Player recoil in opposite direction
    player.dy -= knockback.y * 0.4; // Upwards force from knockback
    hitEnemyThisFrame = true;
    player.attackHitObjects.add(box);
  }


  for (let i = G.babyMicrowaves.length - 1; i >= 0; i--) {
    const m = G.babyMicrowaves[i];
    if (!isColliding(attackBox, m) || player.attackHitObjects.has(m)) continue;
    applyClubStun(m, 24);
    const knockback = getClubKnockback(m.x + (m.width || 0) / 2, m.y + (m.height || 0) / 2, CLUB_ENEMY_KNOCKBACK_MULTIPLIER * 0.75);
    m.knockbackDx = knockback.x;
    m.knockbackDy = knockback.y;
    damageEnemy(m, CLUB_DAMAGE, knockback);
    if (m.hp <= 0) triggerBabyMicrowaveExplosion(m);
    player.dx -= knockback.x * 0.4;
    player.dy -= knockback.y * 0.4;
    hitEnemyThisFrame = true;
    player.attackHitObjects.add(m);
  }
  if (hitEnemyThisFrame) {
    triggerScreenShake(CLUB_HIT_SHAKE_INTENSITY);
  }
}

function resetWorld() {
  walls = [];
  G.turrets = [];
  seesaws = [];
  boxes = [];
  G.shopkeepers = []
  G.snails = [];
  cheeses = [];
  G.bats = [];
  G.chairs = [];
  G.tables = [];
  G.SuperSnails = [];
  G.babyMicrowaves = [];
  ladders = [];
  spikes = [];
  G.bats = [];
  hasPotato = false;
  G.yetis =[];
  swordRangeMulti = 1
  G.snowmen =[];

  vehicles = [];
  playerVehicle = null;
  playerInVehicle = false;

  ovens = [];
  droppedParts = [];
  placedStructures = [];
  partInventory = {bouncy: 0, spike: 0, wall: 0, body: 0, wheel: 0, engine: 0, seat: 0 };  buildMode = false;
  lights = [];        // ← ADD THIS LINE
  playerLight = null; // ← ADD THIS LINE
  let potato
  tutorialActive = false;
  let potatoMessage = "";
  let potatoMessageTimer = 0;
  let potatoHUDLine = "";
  let potatoState = "none";
  G.fireballs = [];

  player.speed *= 1;
  player.jumpPower *= 1;
player.dashMaxCooldown = 50;
  xp = 0;
xpLevel = 1;
xpToNext = 60;
levelUpPending = false;
levelUpCards = [];
levelUpSelectedIndex = 0;
playerUpgrades.orbiters = [];
playerUpgrades.homingEnabled = false;
playerUpgrades.homingTimer = 0;
playerUpgrades.dashDamageEnabled = false;
playerUpgrades.extraJumpsMax = 0;
playerUpgrades.dashInvulEnabled = false;
playerUpgrades.extraJumpsLeft = 0;
playerUpgrades.wolf = null;
playerUpgrades.wolfAutoRevive = false;
playerUpgrades.homingExplosive = false;
ownedUpgradeIds.clear();
  cannonProjectiles = [];
  G.explosions = [];
  cannonCooldown = 0;
  syncJoystickVisibility();
  G.wavesystem.enabled = false;
G.wavesystem.currentWave = 0;
G.wavesystem.enemiesRemaining = 0;
G.wavesystem.waveActive = false;
G.wavesystem.timeBetweenWaves = 180 * 5;
G.wavesystem.waveTimer = 0;
G.wavesystem.totalEnemiesKilled = 0;
G.wavesystem.spawnQueue = [];
G.wavesystem.spawnTimer = 0;
G.wavesystem.currentMapWaves = null;
}

function updateWolf() {
  const w = playerUpgrades.wolf;
  if (!w || w.dead) return;

  // Rare idle wolf sounds
if (Math.random() < 0.0008) {
  const idles = ["🐺 *howls at nothing*", "🐺 *sniffs the air*", "🐺 *whines softly*", "🐺 *stares intensely*", "🐺 awoooo"];
  chatLog(idles[Math.floor(Math.random() * idles.length)], "#c0a0ff");
}

  // Auto-revive
if (w.dead && playerUpgrades.wolfAutoRevive) {
  w.reviveTimer = (w.reviveTimer || 0) + 1;
  if (w.reviveTimer >= 600) { // 10 seconds
    w.dead = false; w.hp = w.maxHp;
    w.x = player.x; w.y = player.y;
    w.reviveTimer = 0;
    potatoMessage = "🐺 the wolf returns";
    potatoMessageTimer = 140;
  }
  return;
}

  // ── Regen invincibility frames ──
  if (w.iframes > 0) w.iframes--;

  // ── Follow player ──
  const tx = player.x + player.width / 2 + (player.facing * -55);
  const ty = player.y + player.height - w.height;
  const dx = tx - w.x, dy = ty - w.y;
  const dist = Math.hypot(dx, dy);

  if (dist > 12) {
    const spd = Math.min(w.speed, dist);
    w.x += (dx / dist) * spd;
    w.y += (dy / dist) * spd;
    w.facing = dx > 0 ? 1 : -1;
    w.moving = true;
  } else {
    w.moving = false;
  }

  // ── Teleport if too far away ──
  const wdist = Math.hypot(tx - w.x, ty - w.y);
  if (wdist > 600) {
    w.x = player.x + (player.facing * -40);
    w.y = player.y;
    w.dy = 0;
  }
  
  // ── Simple gravity + ground snap ──
  w.dy = (w.dy || 0) + 0.5;
  w.y += w.dy;
  if (collidesWithWall(w.x, w.y, w.width, w.height)) {
    while (collidesWithWall(w.x, w.y, w.width, w.height)) w.y--;
    w.dy = 0;
  }

  // ── Animate ──
  w.frameTimer = (w.frameTimer || 0) + 1;
  if (w.frameTimer >= 6) { w.frameTimer = 0; w.frame = (w.frame + 1) % 4; }

  // ── Attack cooldown ──
  if (w.attackCooldown > 0) w.attackCooldown--;

  // ── Hunt nearest enemy ──
  const allEnemies = [
    ...G.snails, ...G.SuperSnails, ...G.bats,
    ...G.snowmen, ...G.chairs, ...G.tables,
    ...G.yetis.filter(y => y.alive),
  ];

  let nearest = null, nearestDist = w.range;
  for (const e of allEnemies) {
    const d = Math.hypot((e.x + (e.width||0)/2) - w.x, (e.y + (e.height||0)/2) - w.y);
    if (d < nearestDist) { nearest = e; nearestDist = d; }
  }

  if (nearest) {
    // Lunge toward target
    const ex = nearest.x + (nearest.width||0)/2;
    const ey = nearest.y + (nearest.height||0)/2;
    const ddx = ex - w.x, ddy = ey - w.y;
    const dd  = Math.hypot(ddx, ddy) || 1;
    w.x += (ddx/dd) * w.speed * 1.6;
    w.y += (ddy/dd) * w.speed * 0.4;
    w.facing = ddx > 0 ? 1 : -1;
    w.lunging = true;

    // Bite
    if (w.attackCooldown <= 0) {
      const biteBox = {
        x: w.x + (w.facing > 0 ? w.width - 4 : -18),
        y: w.y, width: 22, height: w.height
      };
      if (isColliding(biteBox, nearest)) {
        damageEnemy(nearest, w.damage, { x: w.facing * 3, y: -2 });
        w.attackCooldown = w.attackRate;
        w.biteFlash = 8;
        // Wolf bark on bite (occasional)
      if (Math.random() < 0.15) {
        const barks = ["🐺 *grr*", "🐺 *snap*", "🐺 *growl*", "🐺 *bark*", "🐺 *snarl*"];
        chatLog(barks[Math.floor(Math.random() * barks.length)], "#c0a0ff");
        }
        // Check death for each list
        const lists = [
          { list: G.snails,      key: 'snail'      },
          { list: G.SuperSnails, key: 'superSnail'  },
          { list: G.bats,        key: 'bat'         },
          { list: G.snowmen,     key: 'snowman'     },
          { list: G.chairs,      key: 'chair'       },
          { list: G.tables,      key: 'table'       },
        ];
        for (const { list, key } of lists) {
          const idx = list.indexOf(nearest);
          if (idx > -1 && nearest.hp <= 0) { list.splice(idx, 1); onEnemyKilled(key); break; }
        }
        if (nearest.alive === false) onEnemyKilled('yeti');
      }
    }
  } else {
    w.lunging = false;
  }

  if (w.biteFlash > 0) w.biteFlash--;

  // ── Take damage from enemies touching wolf ──
  if (w.iframes <= 0) {
    for (const e of allEnemies) {
      if (isColliding(w, e)) {
        w.hp--;
        w.iframes = 45;
        w.hitFlash = 12;
        if (w.hp <= 0) {
          w.dead = true;
          potatoMessage = "🐺 the wolf has fallen";
          potatoMessageTimer = 180;
        }
        break;
      }
    }
  }
  if (w.hitFlash > 0) w.hitFlash--;
}

function drawWolf() {
  const w = playerUpgrades.wolf;
  if (!w || w.dead) return;

  ctx.save();

  // Flash white when hit
  if (w.hitFlash > 0 && Math.floor(w.hitFlash / 3) % 2 === 0) {
    ctx.globalAlpha = 0.35;
  }

  const fx = w.facing; // 1 = right, -1 = left
  const cx = w.x + w.width / 2;
  const cy = w.y + w.height / 2;

  ctx.translate(cx, cy);
  if (fx < 0) ctx.scale(-1, 1);

  // Body bob while moving
  const bob = w.moving ? Math.sin(Date.now() / 120) * 1.5 : 0;

  // ── Body ──
  ctx.fillStyle = w.elite ? "#5a4fcf" : "#7a6a5a";
  ctx.beginPath();
  ctx.ellipse(0, bob, w.width/2 - 2, w.height/2 - 3, 0, 0, Math.PI*2);
  ctx.fill();

  // ── Head ──
  ctx.fillStyle = w.elite ? "#6a5fdf" : "#8a7a6a";
  ctx.beginPath();
  ctx.ellipse(w.width/2 - 4, -w.height/4 + bob, 9, 8, 0.3, 0, Math.PI*2);
  ctx.fill();

  // ── Snout ──
  ctx.fillStyle = w.elite ? "#8a7aef" : "#a09080";
  ctx.fillRect(w.width/2 + 1, -w.height/4 + bob - 2, 8, 5);

  // ── Nose ──
  ctx.fillStyle = "#1a1a1a";
  ctx.beginPath();
  ctx.arc(w.width/2 + 8, -w.height/4 + bob, 2, 0, Math.PI*2);
  ctx.fill();

  // ── Eye ──
  ctx.fillStyle = w.elite ? "#ffee00" : "#ffdd00";
  ctx.beginPath();
  ctx.arc(w.width/2 + 1, -w.height/4 + bob - 3, 2.5, 0, Math.PI*2);
  ctx.fill();
  ctx.fillStyle = "#000";
  ctx.beginPath();
  ctx.arc(w.width/2 + 1.5, -w.height/4 + bob - 3, 1.2, 0, Math.PI*2);
  ctx.fill();

  // ── Ear ──
  ctx.fillStyle = w.elite ? "#4a3fbf" : "#6a5a4a";
  ctx.beginPath();
  ctx.moveTo(w.width/2 - 3, -w.height/4 + bob - 5);
  ctx.lineTo(w.width/2 + 3, -w.height/4 + bob - 13);
  ctx.lineTo(w.width/2 + 8, -w.height/4 + bob - 5);
  ctx.closePath(); ctx.fill();

  // ── Tail ──
  const tailWag = Math.sin(Date.now() / 150) * 0.5;
  ctx.strokeStyle = w.elite ? "#5a4fcf" : "#7a6a5a";
  ctx.lineWidth = 4;
  ctx.lineCap = "round";
  ctx.beginPath();
  ctx.moveTo(-w.width/2 + 2, bob);
  ctx.quadraticCurveTo(-w.width/2 - 8, bob - 10 + tailWag * 8, -w.width/2 - 4, bob - 18 + tailWag * 6);
  ctx.stroke();

  // ── Legs (walking animation) ──
  ctx.strokeStyle = w.elite ? "#4a3fbf" : "#6a5a4a";
  ctx.lineWidth = 3;
  const legSwing = w.moving ? Math.sin(Date.now() / 90) * 6 : 0;
  // front legs
  ctx.beginPath();
  ctx.moveTo(w.width/4, bob + w.height/4);
  ctx.lineTo(w.width/4 + legSwing, bob + w.height/2 + 4);
  ctx.stroke();
  ctx.beginPath();
  ctx.moveTo(w.width/4 + 4, bob + w.height/4);
  ctx.lineTo(w.width/4 + 4 - legSwing, bob + w.height/2 + 4);
  ctx.stroke();
  // back legs
  ctx.beginPath();
  ctx.moveTo(-w.width/4, bob + w.height/4);
  ctx.lineTo(-w.width/4 - legSwing, bob + w.height/2 + 4);
  ctx.stroke();

  // ── Bite flash ──
  if (w.biteFlash > 0) {
    ctx.strokeStyle = "#fff";
    ctx.lineWidth = 2;
    ctx.beginPath();
    ctx.moveTo(w.width/2 + 5, -w.height/4 + bob);
    ctx.lineTo(w.width/2 + 14, -w.height/4 + bob + 4);
    ctx.stroke();
  }

  // ── Elite glow ──
  if (w.elite) {
    ctx.shadowColor = "#8888ff";
    ctx.shadowBlur = 18;
    ctx.globalAlpha = 0.18;
    ctx.fillStyle = "#8888ff";
    ctx.beginPath();
    ctx.ellipse(0, bob, w.width/2 + 4, w.height/2 + 2, 0, 0, Math.PI*2);
    ctx.fill();
    ctx.globalAlpha = 1; ctx.shadowBlur = 0;
  }

  ctx.restore();

  // ── HP bar ──
  if (settings.enemyHealthBars && w.hp < w.maxHp) {
    const bw = w.width + 8, bh = 4;
    const bx = w.x - 4, by = w.y - 8;
    ctx.fillStyle = "#300"; ctx.fillRect(bx, by, bw, bh);
    ctx.fillStyle = w.elite ? "#88f" : "#4f4";
    ctx.fillRect(bx, by, bw * (w.hp / w.maxHp), bh);
  }
}

function updateOrbiters() {
  if (!playerUpgrades.orbiters.length) return;

  const cx = player.x + player.width / 2;
  const cy = player.y + player.height / 2;
  const count = playerUpgrades.orbiters.length;

  // Increment only the first orbiter's angle — others derive from it
  playerUpgrades.orbiters[0].angle += playerUpgrades.orbiters[0].speed;
  const baseAngle = playerUpgrades.orbiters[0].angle;

  const allEnemies = [
    ...G.snails.map(e => ({ e, list: G.snails, key: 'snail' })),
    ...G.SuperSnails.map(e => ({ e, list: G.SuperSnails, key: 'superSnail' })),
    ...G.yetis.filter(y => y.alive).map(e => ({ e, list: null, key: 'yeti' })),
    ...G.snowmen.map(e => ({ e, list: G.snowmen, key: 'snowman' })),
    ...G.babyMicrowaves.map(e => ({ e, list: G.babyMicrowaves, key: 'babyMicrowave' })),
    ...G.turrets.map(e => ({ e, list: G.turrets, key: 'turret' })),
    ...G.chairs.map(e => ({ e, list: G.chairs, key: 'chair' })),
    ...G.tables.map(e => ({ e, list: G.tables, key: 'table' })),
    ...G.bats.map(e => ({ e, list: G.bats, key: 'bat' })),
  ];

  for (let i = 0; i < count; i++) {
    const orb = playerUpgrades.orbiters[i];

    // Evenly space: 1 orb = 0°, 2 orbs = 180° apart, 3 = 120° apart, etc.
    const angleOffset = (Math.PI * 2 / count) * i;
    const angle = baseAngle + angleOffset;

    const ox = cx + Math.cos(angle) * orb.radius;
    const oy = cy + Math.sin(angle) * orb.radius;
    orb.screenX = ox;
    orb.screenY = oy;

    const hitBox = { x: ox - orb.size, y: oy - orb.size, width: orb.size * 2, height: orb.size * 2 };

    // Tick cooldowns
    for (const [enemy, timer] of orb.hitCooldowns) {
      if (timer <= 1) orb.hitCooldowns.delete(enemy);
      else orb.hitCooldowns.set(enemy, timer - 1);
    }

    for (const { e, list, key } of allEnemies) {
      if (orb.hitCooldowns.has(e)) continue;
      if (!isColliding(hitBox, e)) continue;

      // Orbiter hits cheese
for (let i = cheeses.length - 1; i >= 0; i--) {
  const c = cheeses[i];
  if (orb.hitCooldowns.has(c)) continue;
  if (!isColliding(hitBox, c)) continue;
  damageCheeseCheck(
    { x: ox - orb.size, y: oy - orb.size, width: orb.size*2, height: orb.size*2 },
    orb.damage,
    { x: (c.x - cx) * 0.1, y: -3 }
  );
  orb.hitCooldowns.set(c, 40);
}

      damageEnemy(e, orb.damage, { x: (e.x - cx) * 0.1, y: -3 });
      orb.hitCooldowns.set(e, 40);

      if (e.hp <= 0) {
        if (list) {
          const idx = list.indexOf(e);
          if (idx > -1) { list.splice(idx, 1); onEnemyKilled(key); }
        } else if (key === 'yeti') {
          e.alive = false; onEnemyKilled('yeti');
        }
      }
    }
  }
}

function updateHomingShot() {
  if (!playerUpgrades.homingEnabled) return;

  playerUpgrades.homingTimer--;
  if (playerUpgrades.homingTimer > 0) return;
  playerUpgrades.homingTimer = Math.floor(120 / (playerUpgrades.homingRate || 1));

  // Find closest enemy
  let closest = null;
  let closestDist = Infinity;

  const cx = player.x + player.width / 2;
  const cy = player.y + player.height / 2;

  const candidates = [
    ...G.snails, ...G.SuperSnails,
    ...G.yetis.filter(y => y.alive),
    ...G.snowmen, ...G.turrets, ...G.chairs, ...G.tables, ...G.bats
  ];

  for (const e of candidates) {
    const ex = (e.x || 0) + (e.width || 0) / 2;
    const ey = (e.y || 0) + (e.height || 0) / 2;
    const d = Math.hypot(ex - cx, ey - cy);
    if (d < closestDist) { closestDist = d; closest = e; }
  }

  if (!closest || closestDist > 700) return;

  const tx = closest.x + (closest.width || 0) / 2;
  const ty = closest.y + (closest.height || 0) / 2;
  const speed = 9;
  const dx = tx - cx;
  const dy = ty - cy;
  const dist = Math.hypot(dx, dy) || 1;

  cannonProjectiles.push({
    x: cx,
    y: cy,
    vx: (dx / dist) * speed,
    vy: (dy / dist) * speed,
    size: 7,
    explosive: false,
    alive: true,
    trail: [],
    homing: true,
    homingTarget: closest
  });
}

function updateDashDamage() {
  // Allow dash-damage to also apply during the ground roll so both upgrades can coexist
  if (!playerUpgrades.dashDamageEnabled || !(player.dashActive || player.rollActive)) return;

  const hitBox = { x: player.x, y: player.y, width: player.width, height: player.height };
  const hitSet = playerUpgrades.dashHitEnemies;
  const knockback = { x: player.facing * 9, y: -5 };

  const groups = [
    { list: G.snails,      key: 'snail' },
    { list: G.SuperSnails, key: 'superSnail' },
    { list: G.snowmen,     key: 'snowman' },
    { list: G.babyMicrowaves, key: 'babyMicrowave' },
    { list: G.chairs,      key: 'chair' },
    { list: G.turrets,     key: 'turret' },
    { list: G.tables,      key: 'table' },
    { list: G.bats,        key: 'bat' },
  ];

  for (const { list, key } of groups) {
    for (let i = list.length - 1; i >= 0; i--) {
      const e = list[i];
      if (hitSet.has(e)) continue;          // already hit this dash
      if (!isColliding(hitBox, e)) continue;
      damageEnemy(e, 2, knockback);
      hitSet.add(e);                        // mark so it won't be hit again
      if (e.hp <= 0) { list.splice(i, 1); onEnemyKilled(key); }
    }
  }

  for (const y of G.yetis) {
    if (!y.alive || hitSet.has(y)) continue;
    if (!isColliding(hitBox, y)) continue;
    damageEnemy(y, 2, knockback);
    hitSet.add(y);
    if (y.hp <= 0) { y.alive = false; onEnemyKilled('yeti'); }
  }
}

// --- CAMERA MODULE ---
function updateCamera() {
  const targetX =
    player.x + player.width / 2 - camera.width / 2;
  const targetY =
    player.y + player.height / 2 - camera.height / 2;

  camera.x += (targetX - camera.x) * camera.smoothFactor;
  camera.y += (targetY - camera.y) * camera.smoothFactor;

  // ✅ HARD CLAMP — ALWAYS
  camera.x = Math.max(
    0,
    Math.min(camera.x, world.width - camera.width)
  );
  camera.y = Math.max(
    0,
    Math.min(camera.y, world.height - camera.height)
  );
}

function updateSeesaws() {
  for (let s of seesaws) {

    // gravity pull toward flat
    s.angularVelocity += -s.angle * 0.01;

    // player influence
    const playerOn =
      player.y + player.height <= s.y + 8 &&
      player.y + player.height >= s.y - 8 &&
      player.x + player.width > s.x &&
      player.x < s.x + s.width;

    if (playerOn) {
      const center = s.x + s.width / 2;
      const offset = (player.x + player.width / 2) - center;
      s.angularVelocity += offset * 0.0005;
      player.x += s.angularVelocity * 6; // instability
      player.dashUsedInAir = false;
    }

    // box influence
    for (let box of boxes) {
      const boxOn =
        box.y + box.height <= s.y + 8 &&
        box.y + box.height >= s.y - 8 &&
        box.x + box.width > s.x &&
        box.x < s.x + s.width;

      if (boxOn) {
        const center = s.x + s.width / 2;
        const offset = (box.x + box.width / 2) - center;
        s.angularVelocity += offset * 0.0003;
        box.x += s.angularVelocity * 4;
      }
    }

    // damping
    s.angularVelocity *= 0.92; // friction in the hinge

    const SPRING_STRENGTH = 0.0015;
s.angularVelocity += -s.angle * SPRING_STRENGTH;

    s.angle += s.angularVelocity;
    const MAX_ANGLE = Math.PI / 10; // ~18 degrees

s.angle = Math.max(-MAX_ANGLE, Math.min(MAX_ANGLE, s.angle));

// --- PLAYER SUPPORT ON SEESAW (edge-safe) ---
const playerFeet = player.y + player.height;

for (let s of seesaws) {
  const playerCenterX = player.x + player.width / 2;

  // must be horizontally over the seesaw
  if (
    playerCenterX < s.x ||
    playerCenterX > s.x + s.width
  ) continue;

  const surfaceY = seesawSurfaceY(s, playerCenterX);

  const onSeesaw =
    playerFeet >= surfaceY - 6 &&
    playerFeet <= surfaceY + 10 &&
    player.dy >= 0;

  if (onSeesaw) {
    player.y = surfaceY - player.height;
    player.dy = 0;
    player.onGround = true;

    // slide toward lower side
    player.x += Math.sin(s.angle) * 1.4;
  }
}

// --- BOX VISUAL HEIGHT ON SEESAW ---
// --- BOX SUPPORT ON SEESAW ---
for (let box of boxes) {
  const boxFeet = box.y + box.height;
  const boxCenterX = box.x + box.width / 2;

  for (let s of seesaws) {
    if (boxCenterX < s.x || boxCenterX > s.x + s.width) continue;

    const surfaceY = seesawSurfaceY(s, boxCenterX);

    const boxOn =
      boxFeet >= surfaceY - 6 &&
      boxFeet <= surfaceY + 10 &&
      box.dy >= 0;

    if (boxOn) {
      box.y = surfaceY - box.height;
      box.dy = 0;
      box.x += Math.sin(s.angle) * 1.2;
    }
  }
}

  }
}

// === MOVING PLATFORM MODULE (with friction) ===
function updateMovingPlatforms() {
  for (let wall of walls) {
    if (!wall.moving) continue;

    const prevX = wall.x;
    const prevY = wall.y;
    const useVertical = typeof wall.startY === "number";
    const startX = typeof wall.startX === "number" ? wall.startX : wall.x;
    const startY = typeof wall.startY === "number" ? wall.startY : wall.y;
    const range = typeof wall.range === "number" ? wall.range : 0;

    if (useVertical) {
      wall.y += wall.dir * wall.speed;
      if (wall.y > startY + range || wall.y < startY - range) {
        wall.dir *= -1;
      }
    } else {
      wall.x += wall.dir * wall.speed;
      if (wall.x > startX + range || wall.x < startX - range) {
        wall.dir *= -1;
      }
    }

    const deltaX = wall.x - prevX;
    const deltaY = wall.y - prevY;

    // --- PLAYER RIDING PLATFORM ---
    const standingOn =
      player.y + player.height <= wall.y + 5 &&
      player.y + player.height >= wall.y - 10 &&
      player.x + player.width > wall.x &&
      player.x < wall.x + wall.width;

    if (standingOn && player.onGround) {
      player.x += deltaX;
      player.y += deltaY;
    }

    // --- BOX RIDING PLATFORM ---
    for (let box of boxes) {
      const boxOn =
        box.y + box.height <= wall.y + 5 &&
        box.y + box.height >= wall.y - 10 &&
        box.x + box.width > wall.x &&
        box.x < wall.x + wall.width;

      if (boxOn) {
        box.x += deltaX;
        box.y += deltaY;
      }
    }

    // --- SPIKE RIDING PLATFORM ---
    for (let spike of spikes) {
      const spikeOn =
        spike.y + spike.height <= wall.y + 5 &&
        spike.y + spike.height >= wall.y - 10 &&
        spike.x + spike.width > wall.x &&
        spike.x < wall.x + wall.width;

      if (spikeOn) {
        spike.x += deltaX;
        spike.y += deltaY;
      }
    }
  }
}

// --- WALL SLIDING MODULE ---
function updateWallSliding() {
  if (!player.onGround && player.onWall) {
    player.wallSliding = true;
    player.dy *= 0.3; // slower fall
  } else {
    player.wallSliding = false;
  }
}

function drawMouseCoords() {
  ctx.save();
  ctx.fillStyle = "#0ff";
  ctx.font = "10 px monospace";

  ctx.fillText(
    `Mouse: ${Math.round(mouse.worldX * 3.5)}, ${Math.round(mouse.worldY * 3.5)}`,
    10,
    canvas.height - 10
  );

  ctx.restore();
}

 function drawDevGrid(scale) {
  const STEP = 100;

  ctx.save();
  ctx.strokeStyle = "rgba(0, 255, 255, 0.25)";
  ctx.lineWidth = 1;

  // vertical lines
  for (let x = 0; x <= world.width; x += STEP) {
    const sx = x * scale;
    ctx.beginPath();
    ctx.moveTo(sx, 0);
    ctx.lineTo(sx, canvas.height);
    ctx.stroke();
  }

  // horizontal lines
  for (let y = 0; y <= world.height; y += STEP) {
    const sy = y * scale;
    ctx.beginPath();
    ctx.moveTo(0, sy);
    ctx.lineTo(canvas.width, sy);
    ctx.stroke();
  }

  ctx.restore();
}

function drawDevRulers(scale) {
  const STEP = 100;

  ctx.save();
  ctx.font = "6px monospace";
  ctx.fillStyle = "#0ff";
  ctx.strokeStyle = "#0ff";
  ctx.lineWidth = 1;

  // --- X AXIS (TOP) ---
  for (let x = 0; x <= world.width; x += STEP) {
    const sx = x * scale;

    // tick
    ctx.beginPath();
    ctx.moveTo(sx, 0);
    ctx.lineTo(sx, 12);
    ctx.stroke();

    // label
    ctx.fillText(x, sx + 2, 24);
  }

  // --- Y AXIS (LEFT) ---
  for (let y = 0; y <= world.height; y += STEP) {
    const sy = y * scale;

    // tick
    ctx.beginPath();
    ctx.moveTo(0, sy);
    ctx.lineTo(12, sy);
    ctx.stroke();

    // label
    ctx.fillText(y, 16, sy - 2);
  }

  ctx.restore();
}

function drawSnow() {
  if (!isChristmasMap()) return;

  ctx.fillStyle = "rgba(255,255,255,0.8)";
  for (let s of snowParticles) {
    ctx.beginPath();
    ctx.arc(s.x, s.y, s.size, 0, Math.PI * 2);
    ctx.fill();
  }
}

function drawIcicles() {
  if (!isChristmasMap()) return;

  ctx.fillStyle = "#ccf2ff";

  for (let i of G.icicles) {
    if (!i.active) continue;

    ctx.beginPath();
    ctx.moveTo(i.x, i.y);                         // top-left (ceiling)
    ctx.lineTo(i.x + i.width, i.y);               // top-right
    ctx.lineTo(i.x + i.width / 2, i.y + i.height); // sharp tip DOWN
    ctx.closePath();
    ctx.fill();
  }
}

function drawSnowmen() {
  for (let s of G.snowmen) {
    if (!isEffectVisibleInWorld(s.x, s.y, s.width, s.height, 120)) continue;
        if (s.hitFlash > 0) {
      ctx.fillStyle = "#f00"; // red
    } else {
      ctx.fillStyle = "#fff"; // normal green
    }
     drawSnowAura(s);

    const cx = s.x + s.width / 2;
    const baseY = s.y + s.height;

    // === BODY ===
    ctx.fillStyle = "#fff";

    // bottom
    ctx.beginPath();
    ctx.arc(cx, baseY - 10, 14, 0, Math.PI * 2);
    ctx.fill();

    // middle
    ctx.beginPath();
    ctx.arc(cx, baseY - 26, 11, 0, Math.PI * 2);
    ctx.fill();

    // head
    ctx.beginPath();
    ctx.arc(cx, baseY - 40, 9, 0, Math.PI * 2);
    ctx.fill();

    // 🎩 TOP HAT
const hatY = baseY - 56;

// brim
ctx.fillStyle = "#111";
ctx.fillRect(cx - 12, hatY + 10, 24, 4);

// hat body
ctx.fillRect(cx - 9, hatY - 8, 18, 18);

// band
ctx.fillStyle = "#c22"; // red band to match scarf
ctx.fillRect(cx - 9, hatY + 2, 18, 3);

// subtle highlight
ctx.fillStyle = "rgba(255,255,255,0.15)";
ctx.fillRect(cx - 7, hatY - 6, 3, 14);

    // === COAL EYES ===
    ctx.fillStyle = "#222";
    ctx.beginPath();
    ctx.arc(cx - 3, baseY - 42, 1.5, 0, Math.PI * 2);
    ctx.arc(cx + 3, baseY - 42, 1.5, 0, Math.PI * 2);
    ctx.fill();

    // === CARROT NOSE ===
    ctx.fillStyle = "#ff9933";
    ctx.beginPath();
    ctx.moveTo(cx, baseY - 39);
    ctx.lineTo(cx + s.facing * 8, baseY - 37);
    ctx.lineTo(cx, baseY - 35);
    ctx.closePath();
    ctx.fill();

    // === COAL BUTTONS ===
    ctx.fillStyle = "#222";
    for (let i = 0; i < 3; i++) {
      ctx.beginPath();
      ctx.arc(cx, baseY - 26 + i * 6, 1.6, 0, Math.PI * 2);
      ctx.fill();
    }

    // === SCARF ===
    ctx.fillStyle = "#c22";
    ctx.fillRect(cx - 10, baseY - 32, 20, 4);
    ctx.fillRect(cx + 4, baseY - 28, 4, 10);

    // === TWIG ARMS ===
    ctx.strokeStyle = "#6b4a2d";
    ctx.lineWidth = 2;

    function twigArm(dir) {
      ctx.beginPath();
      ctx.moveTo(cx, baseY - 28);
      ctx.lineTo(cx + dir * 16, baseY - 36);
      ctx.stroke();

      // fingers
      for (let i = -1; i <= 1; i++) {
        ctx.beginPath();
        ctx.moveTo(cx + dir * 14, baseY - 34);
        ctx.lineTo(cx + dir * (18 + i * 3), baseY - (40 + i * 2));
        ctx.stroke();
      }
    }

    twigArm(1);
    twigArm(-1);
  }
}

// ============================================================
//  CHAT + COMMAND SYSTEM
// ============================================================

const chat = {
  open: false,
  input: "",
  cursorBlink: 0,
  messages: [],
  MAX_MESSAGES: 14,
  FADE_START: 300,   // frames before a message starts fading (~5s at 60fps)
  FADE_SPEED: 0.018,
};

function chatLog(text, color = "#e8e0f8") {
  const MAX_CHARS = 44; // approx chars that fit the box width

  // Split into word-wrapped lines
  const words = text.split(" ");
  const lines = [];
  let current = "";
  for (const word of words) {
    const test = current ? current + " " + word : word;
    if (test.length > MAX_CHARS) {
      if (current) lines.push(current);
      current = word;
    } else {
      current = test;
    }
  }
  if (current) lines.push(current);

  for (const line of lines) {
    chat.messages.push({ text: line, color, alpha: 1, life: 0 });
  }
  // Trim oldest if over limit
  while (chat.messages.length > chat.MAX_MESSAGES) chat.messages.shift();
}

// ---- COMMANDS ----
const COMMANDS = {
  reset: {
    run() {
      // Toggle-based command effects
      settings.invincible = false;
      settings.showHitboxes = false;
      settings.showFPS = false;
      settings.particles = true;
      settings.lighting = true;
      lightingEnabled = true;
      settings.speedMultiplier = 1;
  
      // Restore player gravity to default
      if (gameRunning) player.gravity = 0.6;
  
      chatLog("🔄 Reset: invincible off, hitboxes off, FPS off,", "#f0d060");
      chatLog("   particles on, lighting on, speed x1, gravity default.", "#f0d060");
    }
  },

  help: {
    run() {
      chatLog("Commands: /help /give /spawn /set /heal /god /kill", "#a0d0ff");
chatLog("  /reset /clear /tp /wave /echo", "#a0d0ff");
}
  },

  give: {
    run(args) {
      const id = args[0]?.toLowerCase();
      if (!id) { chatLog("Usage: /give <upgradeName>", "#ff8888"); return; }
      const upgrade = UPGRADE_POOL.find(u => u.id.toLowerCase() === id);
      if (!upgrade) {
        chatLog("Unknown upgrade. Valid: " + UPGRADE_POOL.map(u => u.id).join(", "), "#ff8888");
        return;
      }
      upgrade.apply();
      chatLog(upgrade.icon + " Gave: " + upgrade.name, "#80ff80");
    }
  },

  spawn: {
    run(args) {
      const type = args[0];
      const hp   = parseInt(args[1]) || undefined;
      const valid = ["snail","superSnail","bat","yeti","snowman","turret","chair","table"];
      if (!type || !valid.includes(type)) {
        chatLog("Usage: /spawn <" + valid.join("|") + "> [hp]", "#ff8888");
        return;
      }
      if (!gameRunning) { chatLog("Start a level first.", "#ff8888"); return; }
      spawnEnemy(type, hp);
      chatLog("Spawned " + type + (hp ? " (hp:" + hp + ")" : ""), "#80ff80");
    }
  },

  spawnshop: {
    run(args) {
      if (!gameRunning) { chatLog("Start a level first.", "#ff8888"); return; }
      // spawn at a short offset from player so it's easy to find
      const sx = Math.min(Math.max(player.x + 160, 200), MAP_WIDTH - 200);
      const sy = player.y;
      const sk = spawnShopkeeper(sx, sy);
      if (sk) {
        chatLog("Spawned shopkeeper at (" + Math.round(sx) + "," + Math.round(sy) + ")", "#80ff80");
        potatoMessage = 'A shopkeeper has appeared nearby!'; potatoMessageTimer = 240;
        showSpawnHUD('Shopkeeper spawned — press E to interact', 240);
      } else {
        chatLog('Failed to spawn shopkeeper.', '#ff8888');
      }
    }
  },

  set: {
    run(args) {
      const key = args[0];
      const val = args[1];
      if (!key || val === undefined) { chatLog("Usage: /set <var> <value>", "#ff8888"); return; }
      const bool = val !== "false" && val !== "0";
      const num  = parseFloat(val);
      const vars = {
        lighting:   () => { settings.lighting = bool; lightingEnabled = bool; },
        particles:  () => { settings.particles = bool; },
        hitboxes:   () => { settings.showHitboxes = bool; },
        fps:        () => { settings.showFPS = bool; },
        invincible: () => { settings.invincible = bool; },
        speed:      () => { if (!isNaN(num)) settings.speedMultiplier = num; },
        gravity:    () => { if (!isNaN(num)) player.gravity = num; },
        hp:         () => { if (!isNaN(num)) player.hp = Math.max(0, Math.min(num, player.maxHp)); },
        maxhp:      () => { if (!isNaN(num)) { player.maxHp = num; player.hp = Math.min(player.hp, player.maxHp); } },
        ambient:    () => { if (!isNaN(num)) ambientLight = Math.max(0, Math.min(1, num)); },
        musicvol:   () => { if (!isNaN(num)) { settings.musicVolume = Math.max(0,Math.min(1,num)); if(typeof bgMusic!=="undefined") bgMusic.volume = settings.musicVolume; } },
      };
      const fn = vars[key.toLowerCase()];
      if (fn) { fn(); chatLog("Set " + key + " = " + val, "#80ff80"); }
      else { chatLog('Unknown var "' + key + '". Try: ' + Object.keys(vars).join(", "), "#ff8888"); }
    }
  },

  heal: {
    run(args) {
      if (!gameRunning) { chatLog("Start a level first.", "#ff8888"); return; }
      const amount = parseInt(args[0]) || player.maxHp;
      player.hp = Math.min(player.maxHp, player.hp + amount);
      chatLog("❤️ Healed " + amount + " HP (now " + player.hp + "/" + player.maxHp + ")", "#ff6080");
    }
  },

  god: {
    run() {
      settings.invincible = !settings.invincible;
      chatLog("God mode " + (settings.invincible ? "ON 🛡️" : "OFF"), "#f0d060");
    }
  },

  kill: {
    run() {
      if (!gameRunning) { chatLog("Start a level first.", "#ff8888"); return; }
      let count = 0;
      const lists = [G.snails, G.SuperSnails, G.bats, G.yetis, G.snowmen, G.turrets, G.chairs, G.tables];
      for (const list of lists) { count += list.length; list.length = 0; }
      chatLog("💀 Killed " + count + " enemies", "#ff8888");
    }
  },

  clear: {
    run() { chat.messages = []; }
  },

  tp: {
    run(args) {
      if (!gameRunning) { chatLog("Start a level first.", "#ff8888"); return; }
      const x = parseFloat(args[0]);
      const y = parseFloat(args[1]);
      if (isNaN(x) || isNaN(y)) { chatLog("Usage: /tp <x> <y>", "#ff8888"); return; }
      player.x = x; player.y = y; player.dx = 0; player.dy = 0;
      chatLog("Teleported to (" + x + ", " + y + ")", "#80ff80");
    }
  },

  wave: {
    run(args) {
      if (typeof G.wavesystem.currentWave === "undefined") { chatLog("Not in wave mode.", "#ff8888"); return; }
      const n = parseInt(args[0]);
      if (!isNaN(n)) G.wavesystem.currentWave = n;
      let count = 0;
      const lists = [G.snails, G.SuperSnails, G.bats, G.yetis, G.snowmen, G.turrets, G.chairs, G.tables];
      for (const list of lists) { count += list.length; list.length = 0; }
      chatLog("⏭ Skipped to wave " + (G.wavesystem.currentWave), "#f0d060");
    }
  },

  echo: {
    run(args) { chatLog(args.join(" "), "#f0d060"); }
  },
};

function runCommand(raw) {
  const parts = raw.slice(1).trim().split(/\s+/);
  const name  = parts[0].toLowerCase();
  const args  = parts.slice(1);
  const cmd   = COMMANDS[name];
  if (!cmd) {
    chatLog('Unknown command "/' + name + '". Type /help for a list.', "#ff8888");
    return;
  }
  try { cmd.run(args); }
  catch(err) { chatLog("Error: " + err.message, "#ff8888"); }
}

// ---- DRAW CHAT ----
function drawChat() {
  chat.cursorBlink = (chat.cursorBlink + 1) % 60;

  for (const msg of chat.messages) {
    msg.life++;
    if (msg.life > chat.FADE_START) {
      msg.alpha = Math.max(0, msg.alpha - chat.FADE_SPEED);
    }
  }
  if (!chat.open) {
    chat.messages = chat.messages.filter(m => m.alpha > 0.01);
  }

  const MSG_H   = 17;
  const PADDING = 7;
  const BOX_W   = 320;
  const BASE_X  = 10;

  const visible = chat.messages.filter(m => m.alpha > 0.01);
  const totalRows = visible.length + (chat.open ? 1 : 0);
  if (totalRows === 0) return;

  const BOX_H  = totalRows * MSG_H + PADDING * 2;
  const BASE_Y = canvas.height - 12 - BOX_H;
  const maxAlpha = Math.max(...visible.map(m => m.alpha), chat.open ? 1 : 0);

  ctx.save();

  // Background
  ctx.globalAlpha = maxAlpha * 0.55;
  ctx.fillStyle = "#050510";
  ctx.beginPath();
  ctx.roundRect(BASE_X, BASE_Y, BOX_W, BOX_H, 5);
  ctx.fill();

  // Messages
  ctx.font = "bold 11px monospace";
  ctx.textBaseline = "top";
  let row = 0;
  for (const msg of visible) {
    ctx.globalAlpha = msg.alpha;
    ctx.fillStyle = msg.color;
    ctx.fillText(msg.text, BASE_X + PADDING, BASE_Y + PADDING + row * MSG_H);
    row++;
  }

  // Input box
  if (chat.open) {
    const iy = BASE_Y + PADDING + row * MSG_H;
    ctx.globalAlpha = 1;
    ctx.fillStyle = "#1a1428";
    ctx.fillRect(BASE_X + 3, iy - 1, BOX_W - 6, MSG_H + 1);
    ctx.fillStyle = "#a080d0";
    ctx.fillText(">", BASE_X + PADDING, iy);
    const cursor = chat.cursorBlink < 30 ? "|" : "";
    ctx.fillStyle = "#ffffff";
    const maxChars = Math.floor((BOX_W - PADDING * 2 - 14) / 6.6);
    const shown = chat.input.length > maxChars ? "…" + chat.input.slice(-maxChars + 1) : chat.input;
    ctx.fillText(shown + cursor, BASE_X + PADDING + 14, iy);
    ctx.strokeStyle = "#5a4878";
    ctx.lineWidth = 1;
    ctx.strokeRect(BASE_X + 3, iy - 1, BOX_W - 6, MSG_H + 1);
  }

  ctx.globalAlpha = 1;
  ctx.restore();
}

// ---- COMMAND MODE HUD ICON ----
function drawCommandHUD() {
  if (!settings.commandsEnabled) return;
  const w = 44, h = 18;
  const x = canvas.width - w - 8;
  const y = 8;

  ctx.save();
  ctx.fillStyle = "rgba(10,5,20,0.75)";
  ctx.beginPath();
  ctx.roundRect(x, y, w, h, 4);
  ctx.fill();
  ctx.strokeStyle = "#5a4878";
  ctx.lineWidth = 1;
  ctx.stroke();
  ctx.fillStyle = "#a080d0";
  ctx.font = "bold 10px monospace";
  ctx.textBaseline = "middle";
  ctx.textAlign = "center";
  ctx.fillText(">_", x + w / 2, y + h / 2 + 1);
  ctx.textAlign = "left";
  ctx.restore();
}

function drawRemotePlayer(p) {
  if (!p || p.x === undefined) return;

  ctx.save();

  // Dash trail
  if (p.dashActive) {
    ctx.globalAlpha = 0.3;
    if (p.facing === -1) {
      ctx.translate(p.x + 32, p.y);
      ctx.scale(-1, 1);
      ctx.drawImage(playerImg, 8, 0, 32, 32);
      ctx.setTransform(1, 0, 0, 1, 0, 0);
    } else {
      ctx.drawImage(playerImg, p.x - 8, p.y, 32, 32);
    }
    ctx.globalAlpha = 1;
  }

  // Name tag above head
  const name = p.name || "Player";
  ctx.save();
  ctx.font = "bold 10px monospace";
  ctx.textAlign = "center";
  ctx.textBaseline = "bottom";

  // Background pill
  const nameW = ctx.measureText(name).width + 10;
  const nameX = p.x + 16 - nameW / 2;
  const nameY = p.y - 6;
  ctx.fillStyle = "rgba(0,0,0,0.55)";
  ctx.beginPath();
  ctx.roundRect(nameX, nameY - 13, nameW, 14, 4);
  ctx.fill();

  // Name text
  ctx.fillStyle = "#f0d060";
  ctx.fillText(name, p.x + 16, p.y - 6);

  // Lives dots
  const lives = p.lives ?? 0;
  for (let i = 0; i < 3; i++) {
    ctx.beginPath();
    ctx.arc(p.x + 8 + i * 9, p.y - 20, 3, 0, Math.PI * 2);
    ctx.fillStyle = i < lives ? "#ff4455" : "#333";
    ctx.fill();
  }

  ctx.restore();
}

//Draw Everything
function draw() {
  const hudFontSize = settings.largeHUD ? 22 : 16;
 ctx.clearRect(0, 0, canvas.width, canvas.height);
ctx.save();

let devScale = 1;

if (devMapView) {
  const scaleX = canvas.width / world.width;
  const scaleY = canvas.height / world.height;
  devScale = Math.min(scaleX, scaleY);
drawMouseCoords();
  // DEV MODE: full world, no camera offset
  ctx.scale(devScale, devScale);
} else {
  // NORMAL MODE: camera-follow
  ctx.translate(-camera.x, -camera.y);
}

drawBackground();
drawDungeonFloorTexture();

for (let i = 0; i < atmosphericParticles.fogLayers.length; i++) {
  atmosphericParticles.fogLayers[i].draw(ctx);
}

  for (let s of seesaws) {
  if (!isEffectVisibleInWorld(s.x, s.y, s.width, s.height, 120)) continue;
  ctx.save();
    // --- DRAW PIVOT ---
const pivotX = s.x + s.width / 2;
const pivotY = s.y;

ctx.fillStyle = "#222";
ctx.beginPath();
ctx.arc(pivotX, pivotY, 5, 0, Math.PI * 2);
ctx.fill();

// optional highlight
ctx.fillStyle = "#888";
ctx.beginPath();
ctx.arc(pivotX - 1, pivotY - 1, 2, 0, Math.PI * 2);
ctx.fill();

  ctx.translate(s.x + s.width / 2, s.y + s.height / 2);
  ctx.rotate(s.angle);
  ctx.fillStyle = "#950";
  ctx.fillRect(-s.width / 2, -s.height / 2, s.width, s.height);
  ctx.restore();
    
}
  
  drawLadders();
  drawSnowmen();
   drawPotato();
  drawCookie();
  drawOven();
  for (let i = 0; i < atmosphericParticles.debris.length; i++) {
    const d = atmosphericParticles.debris[i];
    if (!isEffectVisibleInWorld(d.x, d.y, d.width, d.height, 120)) continue;
    d.draw(ctx);
  }
  for (let i = 0; i < atmosphericParticles.dustMotes.length; i++) {
    const m = atmosphericParticles.dustMotes[i];
    if (!isEffectVisibleInWorld(m.x, m.y, m.size * 2, m.size * 2, 120)) continue;
    m.draw(ctx);
  }
  drawDroppedParts();
  // Draw walls
  for (let wall of walls) {
  if (!isEffectVisibleInWorld(wall.x, wall.y, wall.width, wall.height, 96)) continue;

  if (isChristmasMap() && wall.ice) {
    // ICE BODY
    ctx.fillStyle = "#5cc6ff";
    ctx.fillRect(wall.x, wall.y, wall.width, wall.height);

    // ICE SHINE
    ctx.fillStyle = "rgba(255,255,255,0.25)";
    ctx.fillRect(wall.x + 4, wall.y + 4, wall.width - 8, 6);

    // SNOW CAP
    ctx.fillStyle = "#fff";
    ctx.fillRect(wall.x, wall.y - 6, wall.width, 6);

    // uneven snow bumps
    for (let i = 0; i < wall.width; i += 12) {
      ctx.beginPath();
      ctx.arc(wall.x + i + 6, wall.y - 6, 4, 0, Math.PI * 2);
      ctx.fill();
    }
ctx.strokeStyle = "rgba(255,255,255,0.35)";
ctx.lineWidth = 1;

for (let i = 0; i < wall.width / 60; i++) {
  ctx.beginPath();
  ctx.moveTo(
    wall.x + Math.random() * wall.width,
    wall.y + Math.random() * wall.height
  );
  ctx.lineTo(
    wall.x + Math.random() * wall.width,
    wall.y + Math.random() * wall.height
  );
  ctx.stroke();
}

  } else {
    // NORMAL WALL
    ctx.fillStyle = "#444";
    ctx.fillRect(wall.x, wall.y, wall.width, wall.height);
  }
}

  //Draw Spikes
drawDungeonProps();
drawSpikes();

  //draw snow
  drawSnow();

  
function drawSnails() {
    for (let snail of G.snails) {
    if (!isEffectVisibleInWorld(snail.x, snail.y, snail.width, snail.height, 96)) continue;
        ctx.save();
        const img = snailFrames[snail.frame];
        
        // Ensure image is loaded before drawing
        if (!img || !img.complete) continue;

        if (snail.dir < 0) {
            // 1. Move origin to the right edge of the snail
            ctx.translate(snail.x + snail.width, snail.y);
            // 2. Flip horizontal axis
            ctx.scale(-1, 1);
            // 3. Draw image at 0,0 (which is now top-left, but flipped)
            ctx.drawImage(img, 0, 0, snail.width, snail.height);
        } else {
            // Draw normally
            ctx.drawImage(img, snail.x, snail.y, snail.width, snail.height);
        }
        
        ctx.restore();
    }
}

function drawShopkeepers() {
  for (const s of G.shopkeepers) {
    if (!s.active) continue;
    if (!isEffectVisibleInWorld(s.x, s.y, s.width || 32, s.height || 64, 120)) continue;
    // interaction check (world-space)
    const dx = (s.x + (s.width||32)/2) - (player.x + player.width/2);
    const dy = (s.y + (s.height||64)/2) - (player.y + player.height/2);
    const dist = Math.hypot(dx, dy);
    const inRange = dist <= s.interactRadius;

    // interaction arc (world coords)
    if (inRange) {
      ctx.strokeStyle = 'rgba(255, 215, 0, 0.28)';
      ctx.lineWidth = 2;
      ctx.beginPath();
      ctx.arc(s.x + (s.width||32)/2, s.y + (s.height||64)/2, s.interactRadius, 0, Math.PI * 2);
      ctx.stroke();
    }

    // body (world coords)
    ctx.fillStyle = '#8b5a2b';
    ctx.fillRect(s.x, s.y, s.width || 32, s.height || 64);

    // face
    ctx.fillStyle = '#f5deb3';
    ctx.fillRect(s.x + 4, s.y + 8, Math.min(24, (s.width || 32) - 8), 20);
    ctx.fillStyle = '#000';
    ctx.fillRect(s.x + 8, s.y + 14, 4, 4);
    ctx.fillRect(s.x + 16, s.y + 14, 4, 4);

    // label
    ctx.fillStyle = inRange ? '#ffd700' : '#000';
    ctx.font = 'bold 12px sans-serif';
    ctx.textAlign = 'center';
    ctx.fillText('SHOP', s.x + (s.width||32)/2, s.y - 6);

    if (inRange) {
      ctx.fillStyle = '#ffd700';
      ctx.font = '10px sans-serif';
      ctx.fillText('[E] Interact', s.x + (s.width||32)/2, s.y + (s.height||64) + 14);
    }
  }
}


  // Draw boxes
  for (let b of boxes) {
  if (!isEffectVisibleInWorld(b.x, b.y, b.width, b.height, 96)) continue;
  drawBox(b);
}

drawWolf();
  drawChairs();
  drawTables();
  drawVehicles();
  drawShopkeepers();
  drawSnails();
  drawBabyMicrowaves();
  drawSuperSnails();
  drawYetis();
  drawSnowballs();
  drawSpeedChiliTrail();

  drawPlayer();

  
// Draw remote players
for (const [id, p] of Network.remotePlayers) {
  drawRemotePlayer(p);
}

drawAtmosphericParticles()

  // --- POTATO FLOATING MESSAGE ---
// Top-center spawn HUD (drawn in screen space)
if (spawnHUDTimer > 0) {
  const alpha = Math.max(0, Math.min(1, spawnHUDTimer / Math.max(1, spawnHUDMax)));
  const pad = 12;
  // Reset transform so we draw in screen coordinates (not world)
  ctx.save();
  ctx.setTransform(1, 0, 0, 1, 0, 0);
  ctx.globalAlpha = 0.95 * alpha;
  ctx.fillStyle = 'rgba(20,20,30,0.85)';
  ctx.font = `bold ${Math.round(hudFontSize * 1.1)}px sans-serif`;
  ctx.textAlign = 'center';
  const txt = spawnHUDText || '';
  const tw = ctx.measureText(txt).width;
  const boxW = Math.max(160, tw + pad * 2);
  const cx = canvas.width / 2;
  const cy = 48;
  // background
  ctx.fillRect(cx - boxW/2, cy - 18, boxW, 36);
  // text
  ctx.fillStyle = '#ffd966';
  ctx.fillText(txt, cx, cy + 4);
  ctx.restore();
  spawnHUDTimer--;
}

if (potatoMessageTimer > 0) {
  ctx.fillStyle = "#ffd966";
  ctx.font = `${hudFontSize}px monospace`;
  ctx.textAlign = "center";
  
  ctx.fillText(
    potatoMessage,
    player.x + 9,
    player.y - 23.67
  );

  potatoMessageTimer--;
}

// Draw G.turrets
for (let t of G.turrets) {
  if (!isEffectVisibleInWorld(t.x, t.y, 32, 32, 120)) continue;

  // --- POTATO CHAOS TREMBLE ---
  let shakeX = 0;
  let shakeY = 0;

  if (hasPotato && t.armed) {
    shakeX = (Math.random() - 0.5) * 2; // -1 to +1 px
    shakeY = (Math.random() - 0.5) * 2;
  }
if (isChristmasMap()) {
  // ORNAMENT
  const cx = t.x + 16 + shakeX;
  const cy = t.y + 16 + shakeY;

  ctx.fillStyle = t.armed ? "#ff4444" : "#cc2222";
  ctx.beginPath();
  ctx.arc(cx, cy, 14, 0, Math.PI * 2);
  ctx.fill();

  ctx.fillStyle = "rgba(255,255,255,0.25)";
  ctx.beginPath();
  ctx.arc(cx - 5, cy - 5, 4, 0, Math.PI * 2);
  ctx.fill();

  ctx.fillStyle = "#777";
  ctx.fillRect(cx - 4, cy - 18, 8, 6);

} else {
  // NORMAL TURRET
ctx.fillStyle = "#777";
ctx.fillRect(t.x, t.y, 32, 32);

// top plate
ctx.fillStyle = "#999";
ctx.fillRect(t.x + 4, t.y + 4, 24, 8);

// barrel
ctx.fillStyle = "#333";
ctx.fillRect(t.x + 14, t.y - 6, 4, 6);
}

  // --- TURRET EYE ---
  const cx = t.x + 16 + shakeX;
  const cy = t.y + 16 + shakeY;

  ctx.fillStyle = t.armed ? "#ff3b3b" : "#444";
  ctx.beginPath();
  ctx.arc(cx, cy, t.armed ? 4 : 3, 0, Math.PI * 2);
  ctx.fill();
  if (hasPotato && t.armed && Math.random() < 0.05) {
  ctx.fillStyle = "#9c7a2f"; // potato-brown flash    
  }
}

// Draw G.fireballs
ctx.fillStyle = "#f33";
for (let f of G.fireballs) {
  if (!isEffectVisibleInWorld(f.x, f.y, f.size, f.size, 120)) continue;
    ctx.beginPath();
    ctx.arc(f.x + f.size/2, f.y + f.size/2, f.size/2, 0, Math.PI*2);
    ctx.fill();
}

  drawBats();
  drawCheeses();
  drawSpecialBoxes();
  drawPlacedStructures()
  drawExplosions();
  drawPlayerClub();
  drawSword();
  drawOrbiters();
  // Dash afterimage trail
if (player.dashActive || player.dashDuration > 0) {
  const alpha = (player.dashDuration / player.dashMaxDuration) * 0.5;
  ctx.save();
  ctx.globalAlpha = alpha;
  if (player.facing === -1) {
    ctx.translate(player.x + player.width, player.y);
    ctx.scale(-1, 1);
    ctx.drawImage(playerImg, 8, 0, player.width, player.height);
  } else {
    ctx.drawImage(playerImg, player.x - 8, player.y, player.width, player.height);
  }
  ctx.globalAlpha = alpha * 0.4;
  if (player.facing === -1) {
    ctx.translate(-8, 0);
    ctx.drawImage(playerImg, 8, 0, player.width, player.height);
  } else {
    ctx.drawImage(playerImg, player.x - 16, player.y, player.width, player.height);
  }
  ctx.restore();
}
  // Hitboxes
if (settings.showHitboxes) {
  ctx.save();
  ctx.strokeStyle = DEBUG_HITBOX_ENTITY_COLOR;
  ctx.lineWidth = DEBUG_HITBOX_LINE_WIDTH;
  const allObjs = [...G.snails, ...G.SuperSnails, ...G.bats, ...G.turrets,
                   ...G.snowmen, ...G.yetis, ...G.chairs, ...G.tables, ...boxes, ...spikes];
  for (const o of allObjs) ctx.strokeRect(o.x, o.y, o.width || 32, o.height || 32);
  // player
  ctx.strokeStyle = DEBUG_HITBOX_PLAYER_COLOR;
  ctx.strokeRect(player.x, player.y, player.width, player.height);

  drawDebugHitbox(getDirectionalSwordHitbox(), DEBUG_HITBOX_SWORD_COLOR);
  drawDebugHitbox(getClubAttackHitbox(), DEBUG_HITBOX_CLUB_COLOR);
  ctx.restore();
}

  drawPotatoCannon();
  drawLighting();
  drawEnemyHealthBars();
  drawDungeonLighting();
  
// ADD: Screen effects (in screen space, after restore)

  ctx.restore(); // Restore camera transform for HUD
  drawVignette();
  drawAtmosphericOverlay();
  
  drawOffScreenIndicators();
  drawBuildMode();
  if (tutorialActive) drawTutorialWorld();
  // HUD / DEV OVERLAYS
if (devMapView) {
  if (devShowGrid) {
    drawDevGrid(devScale);
  }

  drawDevRulers(devScale);
}
  // HUD — fixed to screen
  ctx.fillStyle = "#fff";
  ctx.font = `${hudFontSize - 2}px monospace`;
  ctx.fillText("Lives: " + playerLives, 10, 20);

  // Dash cooldown indicator
if (player.dashCooldown > 0) {
  ctx.fillStyle = "#aaa";
  ctx.font = `${hudFontSize - 3}px monospace`;
  ctx.fillText("DASH cooling...", 10, 40);
} else if (player.onGround || !player.dashUsedInAir) {
  ctx.fillStyle = "#00eeff";
  ctx.font = `${hudFontSize - 3}px monospace`;
  ctx.fillText(`DASH ready [${formatBindingLabel(getBindingForAction("dash"))}]`, 10, 40);
} else {
  ctx.fillStyle = "#555";
  ctx.font = `${hudFontSize - 3}px monospace`;
  ctx.fillText("DASH used", 10, 40);
}

  // --- POTATO HUD WHISPER ---
  ctx.fillStyle = "#ffcc66";
  ctx.font = `${hudFontSize - 2}px monospace`;
  ctx.fillText(potatoHUDLine, 10, 80);

  // --- GAME OVER OVERLAY ---
  if (gameOver) {
    ctx.fillStyle = "rgba(0, 0, 0, 1)";
    ctx.fillRect(0, 0, canvas.width, canvas.height);

    ctx.fillStyle = "#fff";
    ctx.font = "48px Arial";
    ctx.textAlign = "center";
    ctx.fillText("GAME OVER", canvas.width / 2, canvas.height / 2 - 20);

    ctx.font = "20px Arial";
    ctx.fillText(`Press ${formatBindingLabel(getBindingForAction("restart"))} to Restart`, canvas.width / 2, canvas.height / 2 + 30);
    ctx.textAlign = "left";
  }

  drawWaveUI();  
  if (debugTestMode) drawDebugTests();

      ctx.restore();

  drawCannonCrosshair();

  if  (G.wavesystem.enabled) drawXPBar();
  if  (G.wavesystem.enabled || levelUpPending) drawLevelUpScreen();
  
  if (devMapView) {
  drawDevRulers(devScale);
}
  // --- DEV MODE LABEL ---
  if (devMapView) {
    ctx.fillStyle = "rgba(0,0,0,0.7)";
    ctx.fillRect(10, 10, 220, 30);
    ctx.fillStyle = "#0f0";
    ctx.font = `${hudFontSize}px monospace`;
    ctx.fillText("DEV MAP VIEW (M)", 20, 30);
  }

  if (tutorialActive) drawTutorialHUD();

  // FPS
if (settings.showFPS) {
  const hudFont = settings.largeHUD ? "16px monospace" : "12px monospace";
  ctx.fillStyle = "#0f0";
  ctx.font = hudFont;
  ctx.fillText("FPS: " + fpsDisplay, canvas.width - 450, 10);
}

// Coords
if (settings.showCoords) {
  ctx.fillStyle = "#0ff";
  ctx.font = `${hudFontSize - 4}px monospace`;
  ctx.fillText(`x:${Math.round(player.x)} y:${Math.round(player.y)}`, canvas.width - 450, 25);
}
// Minimap
if (settings.showMinimap) {
  drawMinimap();
}

drawCommandHUD();
  drawChat();
}

saveInitialState();

// --- MAIN LOOP ---
function gameLoop(currentTime) {
  if (!gameRunning) return;

  if (!fpsSampleTime) fpsSampleTime = currentTime;
  fpsFrameCount++;
  const fpsElapsed = currentTime - fpsSampleTime;
  if (fpsElapsed >= 500) {
    fpsDisplay = Math.round((fpsFrameCount * 1000) / fpsElapsed);
    fpsSampleTime = currentTime;
    fpsFrameCount = 0;
  }

  // Calculate time since last frame
  deltaTime = currentTime - lastFrameTime;

  // Only update if enough time has passed (60 FPS cap)
  if (deltaTime >= FRAME_DURATION) {
    // Track how much extra time we have
    const excess = deltaTime % FRAME_DURATION;
    lastFrameTime = currentTime - excess;
    
    if (!gamePaused) {
      Network.tick();
      updateGamepad();
    
      const isSim = !Network.connected || Network.isHost;
    
      if (isSim) {
        updateWaveSystem();
        updateShopkeepers();
        updateEnemyHitFlashes();
        applySnowmanSlow();
      }

      updateSpeedChiliState();
      //updateFeatherBootsState();
      updateDashBatteryState();
    
      if (!buildMode) {
        if (isSim) {
          updateBats();
          updateSnowmen();
          updateTurrets();
          updateFireballs();
          updateYetis();
          updateSnowballs();
          updateSnails();
          updateBabyMicrowaves();
          updateChairs();
          updateTables();
          updateSuperSnails();
          updateIcicles();
        }
        updatePlayer();
        updateCookie();
        updatePlayerClubAttack();
        updateDirectionalSwordAttack();
        updateCannonAim();
        updateCannonProjectiles();
        updateExplosions();
        updatePlacedStructures();
        syncJoystickVisibility();
        syncShopButtonVisibility();
        updateSpecialBoxes();
        updateWallSliding();
        applyAirFloat();
        applyBoxFriction();
        updatePlayerAnimation(); // add this line before the draw calls
        updateMovingPlatforms();
        updateSeesaws();
        updateLadders();
        updateWolf();
        updateSpikes();
        checkPotatoPickup();
        potatoChaos();
        updateOvens(player);
        if (isSim) updateCheeses();
        updateVehicles();
        checkEnemyVehicleDamage();
        checkVehicleEntry();
        if (tutorialActive) updateTutorial();
        updateOrbiters();
        updateHomingShot();
        updateDashDamage();
        if (debugTestMode) runDebugTests();
      }
      updateSpeedChiliTrail();
      updateLights();
      spawnSnow();
      updateAtmosphericParticlesThrottled(deltaTime);
    updateDungeonLighting();
    updateEnhancedCamera();
      updateSnow();
      updateDroppedParts();
    }    // In gameLoop, outside the if (!gamePaused) block:
if (levelUpInputDelay > 0) levelUpInputDelay--;
drawIcicles();
drawOven();
draw();
  }
  if (buildMode) updateBuildMode();
  requestAnimationFrame(gameLoop);
}
gameLoop();


function menuLoop() {
  updateGamepadMenu();
  requestAnimationFrame(menuLoop);
}
menuLoop(); // start it immediately at the bottom of your script