Function bodies 653 total

export function clearEffectGhosts() {
  const scene = getScene();
  for (const g of effectGhosts) {
    g.mesh.children.forEach(child => { child.material.dispose(); });
    scene.remove(g.mesh);
  }
  effectGhosts.length = 0;
}

function circleVsAABB(cx, cz, radius, box) {
  // Find closest point on AABB to circle center
  const closestX = Math.max(box.minX, Math.min(cx, box.maxX));
  const closestZ = Math.max(box.minZ, Math.min(cz, box.maxZ));

  const dx = cx - closestX;
  const dz = cz - closestZ;
  const distSq = dx * dx + dz * dz;

  if (distSq < radius * radius) {
    const dist = Math.sqrt(distSq);
    if (dist === 0) {
      // Center is inside the box — push out on shortest axis
      const overlapLeft = cx - box.minX;
      const overlapRight = box.maxX - cx;
      const overlapTop = cz - box.minZ;
      const overlapBottom = box.maxZ - cz;
      const minOverlap = Math.min(overlapLeft, overlapRight, overlapTop, overlapBottom);
      if (minOverlap === overlapLeft) return { x: -(overlapLeft + radius), z: 0 };
      if (minOverlap === overlapRight) return { x: overlapRight + radius, z: 0 };
      if (minOverlap === overlapTop) return { x: 0, z: -(overlapTop + radius) };
      return { x: 0, z: overlap

export function resolveTerrainCollision(x, z, radius) {
  const bounds = getBounds();
  let rx = x, rz = z;
  for (const box of bounds) {
    const push = circleVsAABB(rx, rz, radius, box);
    if (push) {
      rx += push.x;
      rz += push.z;
    }
  }
  return { x: rx, z: rz };
}

export function pointHitsTerrain(px, pz) {
  const bounds = getBounds();
  for (const box of bounds) {
    if (pointVsAABB(px, pz, box)) return true;
  }
  return false;
}

export function resolveMovementCollision(x, z, radius) {
  const bounds = getMoveBounds();
  let rx = x, rz = z;
  let wasDeflected = false;
  for (const box of bounds) {
    const push = circleVsAABB(rx, rz, radius, box);
    if (push) {
      rx += push.x;
      rz += push.z;
      wasDeflected = true;
    }
  }
  return { x: rx, z: rz, wasDeflected };
}

export function pointInPit(px, pz) {
  const pits = getPits();
  for (const pit of pits) {
    if (px >= pit.minX && px <= pit.maxX && pz >= pit.minZ && pz <= pit.maxZ) {
      return true;
    }
  }
  return false;
}

export function checkPitFalls(gameState) {
  const playerPos = getPlayerPos();

  // Player pit check (skip during dash — dash phases through pits)
  if (!isPlayerDashing() && !isPlayerInvincible()) {
    if (pointInPit(playerPos.x, playerPos.z)) {
      gameState.playerHealth = 0;
      gameState.phase = 'gameOver';
      screenShake(5, 200);
      spawnDamageNumber(playerPos.x, playerPos.z, 'FELL!', '#ff4466');
    }
  }

  // Enemy pit check
  for (const enemy of gameState.enemies) {
    if (enemy.health <= 0) continue; // already dead
    if (enemy.isLeaping) continue;   // airborne — leaping over pit
    if (pointInPit(enemy.pos.x, enemy.pos.z)) {
      // Spawn sinking ghost + expanding purple ring before killing
      spawnPitFallGhost(enemy);
      createAoeRing(enemy.pos.x, enemy.pos.z, 2.5, 500, 0x8844ff);

      enemy.health = 0;
      enemy.fellInPit = true;
      enemy.stunTimer = 9999; // freeze during cleanup frame
      spawnDamageNumber(enemy.pos.x, enemy.pos.z, 'FELL!

function applyDamageToEnemy(enemy, damage, gameState) {
  if (enemy.shieldActive && enemy.shieldHealth > 0) {
    enemy.shieldHealth -= damage;
    if (enemy.shieldHealth <= 0) {
      // Shield break — overkill passes to HP
      const overkill = -enemy.shieldHealth;
      enemy.shieldHealth = 0;
      enemy.shieldActive = false;
      onShieldBreak(enemy, gameState);
      if (overkill > 0) {
        enemy.health -= overkill;
      }
    }
  } else {
    enemy.health -= damage;
  }
}

function onShieldBreak(enemy, gameState) {
  const shieldCfg = enemy.config.shield;

  // Remove shield mesh
  if (enemy.shieldMesh) {
    enemy.shieldMesh.visible = false;
    enemy.mesh.remove(enemy.shieldMesh);
    enemy.shieldMesh.material.dispose();
    enemy.shieldMesh = null;
  }

  // Stun the golem immediately
  stunEnemy(enemy, shieldCfg.stunDuration);

  // "BREAK" damage number in cyan
  spawnDamageNumber(enemy.pos.x, enemy.pos.z, 'BREAK', '#88eeff');

  // Generic AoE: expanding ring + cascade stun on nearby enemies
  applyAoeEffect({
    x: enemy.pos.x,
    z: enemy.pos.z,
    radius: shieldCfg.stunRadius,
    durationMs: shieldCfg.breakRingDuration || 400,
    color: 0x88eeff,
    label: 'STUNNED',
    effectFn: (e) => stunEnemy(e, shieldCfg.stunDuration),
    gameState,
    excludeEnemy: enemy,
  });

  // Weaken post-break: drop knockback resist to 0 (same as goblin)
  enemy.knockbackResist = 0;

  // Visual: make golem semi-transparent (exposed without shield)
  if (e

export function checkCollisions(gameState) {
  const playerPos = getPlayerPos();
  const playerR = PLAYER.size.radius;

  // === Player vs terrain + pits (skip during dash — dash phases through) ===
  if (!isPlayerDashing()) {
    const resolved = resolveMovementCollision(playerPos.x, playerPos.z, playerR);
    playerPos.x = resolved.x;
    playerPos.z = resolved.z;
  }

  // === Enemies vs terrain + pits (voluntary movement — edge-slide around pits) ===
  // Must happen BEFORE knockback so enemies slide around pits during normal movement
  for (const enemy of gameState.enemies) {
    if (enemy.isLeaping) continue; // airborne — skip ground collision entirely
    const resolved = resolveMovementCollision(enemy.pos.x, enemy.pos.z, enemy.config.size.radius);
    enemy.pos.x = resolved.x;
    enemy.pos.z = resolved.z;
    enemy.wasDeflected = resolved.wasDeflected;
    enemy.mesh.position.copy(enemy.pos);
  }

  // === Player projectiles vs enemies ===
  const playerProj = getPlayerProjec

  constructor(createFn, initialSize) {
    if (initialSize === undefined) initialSize = 50;
    this.pool = [];
    this.active = [];
    this.createFn = createFn;
    for (let i = 0; i < initialSize; i++) {
      const obj = createFn();
      obj.mesh.visible = false;
      this.pool.push(obj);
    }
  }

  acquire() {
    let obj = this.pool.pop();
    if (!obj) {
      obj = this.createFn();
    }
    obj.mesh.visible = true;
    this.active.push(obj);
    return obj;
  }

  release(obj) {
    obj.mesh.visible = false;
    const idx = this.active.indexOf(obj);
    if (idx !== -1) {
      // Swap-remove: O(1) instead of O(n) splice
      const last = this.active.length - 1;
      if (idx !== last) this.active[idx] = this.active[last];
      this.active.length = last;
    }
    this.pool.push(obj);
  }

  releaseAll() {
    for (let i = this.active.length - 1; i >= 0; i--) {
      const obj = this.active[i];
      obj.mesh.visible = false;
      this.pool.push(obj);
    }
    this.active.length = 0;
  }

export function initRenderer() {
  scene = new THREE.Scene();
  scene.background = new THREE.Color(0x0a0a1a);
  scene.fog = new THREE.Fog(0x0a0a1a, 30, 60);

  const { w, h } = getViewportSize();
  const aspect = w / h;
  camera = new THREE.OrthographicCamera(
    -baseFrustum * aspect, baseFrustum * aspect,
    baseFrustum, -baseFrustum, 0.1, 100
  );
  camera.position.copy(cameraOffset);
  camera.lookAt(0, 0, 0);

  // Zoom camera in on mobile for tighter view
  const hasTouch = 'ontouchstart' in window || navigator.maxTouchPoints > 0;
  if (hasTouch) applyFrustum(8);

  renderer = new THREE.WebGLRenderer({ antialias: true });
  renderer.setSize(w, h);
  renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
  document.body.prepend(renderer.domElement);

  // Lighting
  const ambient = new THREE.AmbientLight(0x6666aa, 0.4);
  scene.add(ambient);

  const dirLight = new THREE.DirectionalLight(0xffeedd, 0.8);
  dirLight.position.set(10, 15, 10);
  scene.add(dirLight);

  const r

function clearObstacleMeshes() {
  for (const m of obstacleMeshes) {
    scene.remove(m);
    if (m.geometry) m.geometry.dispose();
  }
  obstacleMeshes = [];
  for (const m of wallMeshes) {
    scene.remove(m);
    if (m.geometry) m.geometry.dispose();
  }
  wallMeshes = [];
}

function createObstacles() {
  clearObstacleMeshes();

  const mat = new THREE.MeshStandardMaterial({
    color: 0x2a2a4a,
    emissive: 0x223355,
    emissiveIntensity: 0.3,
    roughness: 0.7,
    metalness: 0.2
  });

  for (const o of OBSTACLES) {
    const mesh = new THREE.Mesh(new THREE.BoxGeometry(o.w, o.h, o.d), mat);
    mesh.position.set(o.x, o.h / 2, o.z);
    scene.add(mesh);
    obstacleMeshes.push(mesh);
  }

  // Arena perimeter walls
  const wallMat = new THREE.MeshStandardMaterial({
    color: 0x1a1a2e,
    emissive: 0x334466,
    emissiveIntensity: 0.4,
    roughness: 0.8
  });

  // North/South walls
  for (const zSign of [-1, 1]) {
    const wall = new THREE.Mesh(
      new THREE.BoxGeometry(ARENA_HALF * 2 + WALL_THICKNESS, WALL_HEIGHT, WALL_THICKNESS),
      wallMat
    );
    wall.position.set(0, WALL_HEIGHT / 2, zSign * ARENA_HALF);
    scene.add(wall);
    wallMeshes.push(wall);
  }
  // East/West walls
  for (const xSign of [-1, 1]) {
    const wall = new THREE

function clearPitMeshes() {
  for (const m of pitMeshes) {
    scene.remove(m);
    if (m.geometry) m.geometry.dispose();
  }
  pitMeshes = [];
}

function createPits() {
  clearPitMeshes();

  const edgeThickness = 0.08;
  const edgeHeight = 0.02;

  const edgeMat = new THREE.MeshBasicMaterial({
    color: 0xff2244,
    transparent: true,
    opacity: 0.8,
  });

  for (const p of PITS) {
    // Dark void floor (slightly below ground)
    const voidMesh = new THREE.Mesh(
      new THREE.PlaneGeometry(p.w, p.d),
      new THREE.MeshBasicMaterial({ color: 0x000000 })
    );
    voidMesh.rotation.x = -Math.PI / 2;
    voidMesh.position.set(p.x, -0.05, p.z);
    scene.add(voidMesh);
    pitMeshes.push(voidMesh);

    // North edge
    const nEdge = new THREE.Mesh(
      new THREE.BoxGeometry(p.w + edgeThickness * 2, edgeHeight, edgeThickness),
      edgeMat
    );
    nEdge.position.set(p.x, 0.01, p.z + p.d / 2);
    scene.add(nEdge);
    pitMeshes.push(nEdge);

    // South edge
    const sEdge = new THREE.Mesh(
      new THREE.BoxGeometry(p.w + edgeThickness * 2, edgeHeight, edgeThickness),
      edgeMat
    );
    sEdge.position.

function getViewportSize() {
  // visualViewport gives accurate size on mobile (accounts for browser chrome)
  if (window.visualViewport) {
    return { w: window.visualViewport.width, h: window.visualViewport.height };
  }
  return { w: window.innerWidth, h: window.innerHeight };
}

function applyFrustum(f) {
  const { w, h } = getViewportSize();
  const aspect = w / h;
  camera.left = -f * aspect;
  camera.right = f * aspect;
  camera.top = f;
  camera.bottom = -f;
  camera.updateProjectionMatrix();
  currentFrustum = f;
}

export function updateCamera(playerPos, dt) {
  // Snap camera to player — no lerp. Ortho camera + lerp causes a sliding/swimming feel
  // because the lookAt target and position desync subtly each frame.
  camera.position.copy(playerPos).add(cameraOffset);

  // Screen shake (offset from snapped position)
  if (shakeRemaining > 0) {
    shakeRemaining -= dt * 1000;
    const decay = Math.max(0, shakeRemaining / 150);
    const amt = shakeIntensity * decay;
    camera.position.x += (Math.random() - 0.5) * amt * 0.1;
    camera.position.z += (Math.random() - 0.5) * amt * 0.1;
  }

  camera.lookAt(playerPos);
}

export function screenToWorld(ndcX, ndcY) {
  _unprojectVec.set(ndcX, ndcY, 0);
  _unprojectVec.unproject(camera);

  // Camera direction
  _camDir.set(0, 0, -1).applyQuaternion(camera.quaternion);

  // Intersect ray with y=0 plane
  const t = -_unprojectVec.y / _camDir.y;
  return new THREE.Vector3(
    _unprojectVec.x + _camDir.x * t,
    0,
    _unprojectVec.z + _camDir.z * t
  );
}

export function initTelegraph(scene) {
  sceneRef = scene;

  // Ring: inner 0.6, outer 0.8, flat on ground
  ringGeo = new THREE.RingGeometry(0.6, 0.8, 24);
  ringGeo.rotateX(-Math.PI / 2);

  // Fill circle: radius 0.6
  fillGeo = new THREE.CircleGeometry(0.6, 24);
  fillGeo.rotateX(-Math.PI / 2);

  // Type indicators — small shapes
  // Goblin: triangle (cone 3 sides)
  typeGeos.goblin = new THREE.ConeGeometry(0.2, 0.4, 3);
  // Archer: diamond (box rotated)
  typeGeos.skeletonArcher = new THREE.BoxGeometry(0.25, 0.25, 0.25);
  // Golem: hexagon (cylinder 6 sides, flat)
  typeGeos.crystalGolem = new THREE.CylinderGeometry(0.25, 0.25, 0.1, 6);
}

export function createTelegraph(x, z, typeName) {
  const color = ENEMY_TYPES[typeName] ? ENEMY_TYPES[typeName].color : 0xffffff;
  const group = new THREE.Group();
  group.position.set(x, 0, z);

  // Ground ring
  const ringMat = new THREE.MeshBasicMaterial({
    color: color,
    transparent: true,
    opacity: 0.6,
    side: THREE.DoubleSide,
    depthWrite: false,
  });
  const ring = new THREE.Mesh(ringGeo, ringMat);
  ring.position.y = 0.03;
  group.add(ring);

  // Fill circle
  const fillMat = new THREE.MeshBasicMaterial({
    color: color,
    transparent: true,
    opacity: 0,
    side: THREE.DoubleSide,
    depthWrite: false,
  });
  const fill = new THREE.Mesh(fillGeo, fillMat);
  fill.position.y = 0.02;
  group.add(fill);

  // Type indicator — floating shape
  const typeGeo = typeGeos[typeName] || typeGeos.goblin;
  const typeMat = new THREE.MeshStandardMaterial({
    color: color,
    emissive: color,
    emissiveIntensity: 0.6,
    transparent: true,
    opacity: 0.8,

export function updateTelegraph(telegraph, progress, dt) {
  telegraph.time += dt;

  // Fill circle: opacity ramps up with progress
  telegraph.fillMat.opacity = progress * 0.4;

  // Ring: pulse frequency increases with progress (2Hz → 10Hz)
  const freq = 2 + progress * 8;
  const pulse = 0.5 + 0.5 * Math.sin(telegraph.time * freq * Math.PI * 2);

  // Ring opacity: base 0.3 + pulse
  telegraph.ringMat.opacity = 0.3 + pulse * 0.5;

  // Ring scale: gentle breathing
  const scale = 1.0 + 0.1 * Math.sin(telegraph.time * freq * Math.PI * 2);
  telegraph.ring.scale.set(scale, 1, scale);

  // Flash white when close to spawning (>80%)
  if (progress > 0.8) {
    const flash = Math.sin(telegraph.time * 20) > 0.5;
    telegraph.ringMat.color.setHex(flash ? 0xffffff : telegraph.baseColor);
    telegraph.fillMat.color.setHex(flash ? 0xffffff : telegraph.baseColor);
  }

  // Type indicator: gentle bob
  telegraph.typeIndicator.position.y = 1.2 + 0.15 * Math.sin(telegraph.time * 2);
  telegra

export function removeTelegraph(telegraph) {
  if (telegraph.group.parent) {
    sceneRef.remove(telegraph.group);
  }
  // Dispose cloned materials
  telegraph.ringMat.dispose();
  telegraph.fillMat.dispose();
  telegraph.typeMat.dispose();
}

function getNestedValue(obj, path) {
  const parts = path.split('.');
  let cur = obj;
  for (const p of parts) {
    if (cur == null) return undefined;
    cur = cur[p];
  }
  return cur;
}

function setNestedValue(obj, path, value) {
  const parts = path.split('.');
  let cur = obj;
  for (let i = 0; i < parts.length - 1; i++) {
    if (cur[parts[i]] == null) cur[parts[i]] = {};
    cur = cur[parts[i]];
  }
  cur[parts[parts.length - 1]] = value;
}

function parseValue(raw) {
  if (raw === 'true') return true;
  if (raw === 'false') return false;
  if (raw.startsWith('0x') || raw.startsWith('0X')) {
    const hex = parseInt(raw, 16);
    if (!isNaN(hex)) return hex;
  }
  const num = Number(raw);
  return isNaN(num) ? raw : num;
}

export function applyUrlParams() {
  const params = new URLSearchParams(window.location.search);
  let applied = 0;

  for (const [key, rawValue] of params) {
    const dotIdx = key.indexOf('.');
    if (dotIdx === -1) continue; // no prefix, skip

    const prefix = key.slice(0, dotIdx);
    const path = key.slice(dotIdx + 1);
    if (!path) continue;

    const root = CONFIG_ROOTS[prefix];
    if (!root) {
      console.warn(`[urlParams] Unknown prefix: "${prefix}" (from "${key}")`);
      continue;
    }

    // Validate property exists (prevent typos from creating junk keys)
    const existing = getNestedValue(root, path);
    if (existing === undefined) {
      console.warn(`[urlParams] Unknown path: "${key}" — no such property`);
      continue;
    }

    const value = parseValue(rawValue);
    setNestedValue(root, path, value);
    applied++;
    console.log(`[urlParams] ${key} = ${value}`);
  }

  if (applied > 0) {
    console.log(`[urlParams] Applied ${applied} override(s) f

export function snapshotDefaults() {
  const snap = {};
  for (const [prefix, root] of Object.entries(CONFIG_ROOTS)) {
    snap[prefix] = JSON.parse(JSON.stringify(root));
  }
  return snap;
}

export function buildShareUrl(defaults) {
  const params = new URLSearchParams();

  for (const [prefix, root] of Object.entries(CONFIG_ROOTS)) {
    const defRoot = defaults[prefix];
    if (!defRoot) continue;
    collectDiffs(params, prefix, defRoot, root, '');
  }

  const base = window.location.origin + window.location.pathname;
  const qs = params.toString();
  return qs ? base + '?' + qs : base;
}

function collectDiffs(params, prefix, defObj, curObj, pathPrefix) {
  for (const key of Object.keys(curObj)) {
    const fullPath = pathPrefix ? pathPrefix + '.' + key : key;
    const curVal = curObj[key];
    const defVal = getNestedValue(defObj, fullPath);

    if (curVal != null && typeof curVal === 'object' && !Array.isArray(curVal)) {
      collectDiffs(params, prefix, defObj, curVal, fullPath);
    } else if (curVal !== defVal) {
      params.set(prefix + '.' + fullPath, String(curVal));
    }
  }
}

export function initWaveRunner(scene) {
  sceneRef = scene;
  initTelegraph(scene);

  // Get or create announce element
  announceEl = document.getElementById('wave-announce');
}

export function startWave(index, gameState) {
  if (index >= WAVES.length) {
    waveState.status = 'victory';
    showAnnounce('VICTORY');
    return;
  }

  waveState.waveIndex = index;
  waveState.status = 'announce';
  waveState.announceTimer = 2000;
  waveState.elapsedMs = 0;
  waveState.groups = [];

  gameState.currentWave = WAVES[index].wave;

  // Show wave announcement
  showAnnounce(WAVES[index].message);
}

export function updateWaveRunner(dt, gameState) {
  const dtMs = dt * 1000;

  switch (waveState.status) {
    case 'idle':
    case 'victory':
      return;

    case 'announce':
      waveState.announceTimer -= dtMs;
      if (waveState.announceTimer <= 0) {
        hideAnnounce();
        waveState.status = 'running';
        initGroupRuntimes();
      }
      break;

    case 'running':
      waveState.elapsedMs += dtMs;
      let allGroupsDone = true;

      for (const g of waveState.groups) {
        updateGroup(g, dt, dtMs, gameState);
        if (g.phase !== 'done') allGroupsDone = false;
      }

      // Wave cleared: all groups spawned AND no enemies alive
      if (allGroupsDone && gameState.enemies.length === 0) {
        waveState.status = 'cleared';
        waveState.clearPauseTimer = 2000;
        showAnnounce('Wave cleared!');
      }
      break;

    case 'cleared':
      waveState.clearPauseTimer -= dtMs;
      if (waveState.clearPauseTimer <= 0) {
        hideAnnou

function initGroupRuntimes() {
  const waveCfg = WAVES[waveState.waveIndex];
  waveState.groups = waveCfg.groups.map(groupCfg => ({
    config: groupCfg,
    phase: 'waiting',    // 'waiting' | 'telegraphing' | 'spawning' | 'done'
    timer: 0,
    spawnIndex: 0,
    staggerTimer: 0,
    telegraphs: [],
  }));
}

function updateGroup(g, dt, dtMs, gameState) {
  switch (g.phase) {
    case 'waiting':
      if (waveState.elapsedMs >= g.config.triggerDelay) {
        g.phase = 'telegraphing';
        g.timer = g.config.telegraphDuration;

        // Create telegraph markers for each spawn in this group
        for (const s of g.config.spawns) {
          const t = createTelegraph(s.x, s.z, s.type);
          g.telegraphs.push(t);
        }
      }
      break;

    case 'telegraphing':
      g.timer -= dtMs;
      const progress = 1.0 - Math.max(0, g.timer / g.config.telegraphDuration);

      // Update all telegraph animations
      for (const t of g.telegraphs) {
        updateTelegraph(t, progress, dt);
      }

      if (g.timer <= 0) {
        // Remove telegraphs
        for (const t of g.telegraphs) {
          removeTelegraph(t);
        }
        g.telegraphs = [];

        // Transition to spawning
        g.phase = 'spawning';
        g.spawnIndex = 0;
        g.staggerTimer = 0;
      

export function resetWaveRunner() {
  // Clean up any active telegraphs
  for (const g of waveState.groups) {
    for (const t of g.telegraphs) {
      removeTelegraph(t);
    }
  }
  waveState.status = 'idle';
  waveState.waveIndex = 0;
  waveState.elapsedMs = 0;
  waveState.groups = [];
  hideAnnounce();
}

function createShieldMesh(cfg) {
  const shieldCfg = cfg.shield;
  const radius = cfg.size.radius * 1.8;
  if (!shieldGeo) shieldGeo = new THREE.SphereGeometry(1, 16, 12); // unit sphere, scaled per enemy
  const mat = new THREE.MeshStandardMaterial({
    color: shieldCfg.color || 0x88eeff,
    emissive: shieldCfg.emissive || 0x44ccff,
    emissiveIntensity: 0.4,
    transparent: true,
    opacity: shieldCfg.opacity || 0.35,
    side: THREE.DoubleSide,
    depthWrite: false,
  });
  const mesh = new THREE.Mesh(shieldGeo, mat);
  mesh.scale.set(radius, radius, radius);
  return mesh;
}

export function spawnEnemy(typeName, position, gameState) {
  const cfg = ENEMY_TYPES[typeName];
  if (!cfg) return null;

  const group = new THREE.Group();

  // Body (shared geometry per type)
  if (!_bodyGeoCache[typeName]) {
    _bodyGeoCache[typeName] = new THREE.CylinderGeometry(cfg.size.radius, cfg.size.radius, cfg.size.height * 0.6, 6);
  }
  const bodyMesh = new THREE.Mesh(
    _bodyGeoCache[typeName],
    new THREE.MeshStandardMaterial({
      color: cfg.color,
      emissive: cfg.emissive,
      emissiveIntensity: 0.5
    })
  );
  bodyMesh.position.y = cfg.size.height * 0.3;
  group.add(bodyMesh);

  // Head (shared geometry per type)
  if (!_headGeoCache[typeName]) {
    _headGeoCache[typeName] = new THREE.SphereGeometry(cfg.size.radius * 0.7, 6, 4);
  }
  const headMesh = new THREE.Mesh(
    _headGeoCache[typeName],
    new THREE.MeshStandardMaterial({
      color: cfg.color,
      emissive: cfg.emissive,
      emissiveIntensity: 0.6
    })
  );
  headMesh.position.y = c

export function spawnTestGroup(gameState) {
  // Larger group for longer sessions
  const spawns = [
    // Goblins — scattered around arena
    { type: 'goblin', x: 10, z: 5 },
    { type: 'goblin', x: -8, z: 7 },
    { type: 'goblin', x: 5, z: -10 },
    { type: 'goblin', x: -12, z: -3 },
    { type: 'goblin', x: 15, z: 0 },
    { type: 'goblin', x: -5, z: 12 },
    { type: 'goblin', x: -15, z: 8 },
    { type: 'goblin', x: 8, z: -15 },
    { type: 'goblin', x: -3, z: -14 },
    { type: 'goblin', x: 14, z: 10 },
    { type: 'goblin', x: -10, z: -10 },
    { type: 'goblin', x: 16, z: -8 },
    // Archers — positioned at range
    { type: 'skeletonArcher', x: 12, z: 12 },
    { type: 'skeletonArcher', x: -12, z: -12 },
    { type: 'skeletonArcher', x: -14, z: 10 },
    { type: 'skeletonArcher', x: 14, z: -10 },
    { type: 'skeletonArcher', x: 0, z: -16 },
    // Mortar Imps — lobbed AoE
    { type: 'mortarImp', x: 10, z: -14 },
    { type: 'mortarImp', x: -10, z: 14 },
    { type: 'mo

function pitAt(x, z, margin) {
  if (!_pitBoundsCache) _pitBoundsCache = getPitBounds();
  for (const pit of _pitBoundsCache) {
    if (x > pit.minX - margin && x < pit.maxX + margin &&
        z > pit.minZ - margin && z < pit.maxZ + margin) {
      return pit;
    }
  }
  return null;
}

function pitAwareDir(x, z, dx, dz, lookahead) {
  const ahead = pitAt(x + dx * lookahead, z + dz * lookahead, 0.5);
  if (!ahead) return { dx, dz }; // no pit ahead — go straight

  // Pit center
  const pcx = (ahead.minX + ahead.maxX) / 2;
  const pcz = (ahead.minZ + ahead.maxZ) / 2;

  // Two perpendicular options: rotate ±90°
  // Option A: (dz, -dx)   Option B: (-dz, dx)
  // Pick the one whose lookahead is further from pit center
  const ax = x + dz * lookahead, az = z + (-dx) * lookahead;
  const bx = x + (-dz) * lookahead, bz = z + dx * lookahead;
  const distA = (ax - pcx) * (ax - pcx) + (az - pcz) * (az - pcz);
  const distB = (bx - pcx) * (bx - pcx) + (bz - pcz) * (bz - pcz);

  // Also verify the chosen strafe doesn't land in another pit
  if (distA >= distB) {
    if (!pitAt(ax, az, 0.5)) return { dx: dz, dz: -dx };
    if (!pitAt(bx, bz, 0.5)) return { dx: -dz, dz: dx };
  } else {
    if (!pitAt(bx, bz, 0.5)) return { dx: -dz, dz: dx };
    if (!pitAt(ax, az, 0.5)) return

function raycastTerrainDist(ox, oz, dx, dz, maxDist) {
  if (!_collisionBounds) _collisionBounds = getCollisionBounds();

  let closest = maxDist;

  for (const box of _collisionBounds) {
    // Slab method on X axis
    let tmin, tmax;
    if (Math.abs(dx) < 1e-8) {
      // Ray parallel to X — check if origin is within X slab
      if (ox < box.minX || ox > box.maxX) continue;
      tmin = -Infinity;
      tmax = Infinity;
    } else {
      const invDx = 1 / dx;
      let t1 = (box.minX - ox) * invDx;
      let t2 = (box.maxX - ox) * invDx;
      if (t1 > t2) { const tmp = t1; t1 = t2; t2 = tmp; }
      tmin = t1;
      tmax = t2;
    }

    // Slab method on Z axis
    if (Math.abs(dz) < 1e-8) {
      if (oz < box.minZ || oz > box.maxZ) continue;
      // tmin/tmax unchanged
    } else {
      const invDz = 1 / dz;
      let t1 = (box.minZ - oz) * invDz;
      let t2 = (box.maxZ - oz) * invDz;
      if (t1 > t2) { const tmp = t1; t1 = t2; t2 = tmp; }
      tmin = Math.max(tmin, t1)

export function updateEnemies(dt, playerPos, gameState) {
  for (let i = gameState.enemies.length - 1; i >= 0; i--) {
    const enemy = gameState.enemies[i];

    // Pit leap update — runs independently of stun (can't stun mid-air)
    if (enemy.isLeaping) {
      updateLeap(enemy, dt);
      // Skip normal behavior/movement but still check death below
    } else if (enemy.stunTimer > 0) {
      // Stun check — stunned enemies cannot move or attack
      enemy.stunTimer -= dt * 1000;
    } else {
      // Behavior dispatch (only when not stunned)
      switch (enemy.behavior) {
        case 'rush': behaviorRush(enemy, playerPos, dt); break;
        case 'kite': behaviorKite(enemy, playerPos, dt, gameState); break;
        case 'tank': behaviorTank(enemy, playerPos, dt); break;
        case 'mortar': behaviorMortar(enemy, playerPos, dt, gameState); break;
      }
    }

    // Arena clamp
    enemy.pos.x = Math.max(-19, Math.min(19, enemy.pos.x));
    enemy.pos.z = Math.max(-19, Math.mi

function behaviorRush(enemy, playerPos, dt) {
  // Skip normal movement during leap (handled by updateLeap)
  if (enemy.isLeaping) return;

  _toPlayer.subVectors(playerPos, enemy.pos);
  _toPlayer.y = 0;
  const dist = _toPlayer.length();

  const stopDist = (enemy.config.rush && enemy.config.rush.stopDistance) || 0.5;
  if (dist > stopDist) {
    _toPlayer.normalize();
    const slideBoost = enemy.wasDeflected ? 1.175 : 1.0;
    const iceEffects = getIceEffects(enemy.pos.x, enemy.pos.z, false);
    const speed = enemy.config.speed * (enemy.slowTimer > 0 ? enemy.slowMult : 1) * slideBoost * iceEffects.speedMult;
    enemy.pos.x += _toPlayer.x * speed * dt;
    enemy.pos.z += _toPlayer.z * speed * dt;
  }

  // Face player
  if (dist > 0.1) {
    enemy.mesh.rotation.y = Math.atan2(-_toPlayer.x, -_toPlayer.z);
  }

  // --- Pit leap detection ---
  const leapCfg = enemy.config.pitLeap;
  if (!leapCfg) return;

  // Tick cooldown
  if (enemy.leapCooldown > 0) {
    enemy.leapCooldown -= 

function startPitLeap(enemy, playerPos, leapCfg) {
  // Direction toward player
  const dx = playerPos.x - enemy.pos.x;
  const dz = playerPos.z - enemy.pos.z;
  const dist = Math.sqrt(dx * dx + dz * dz);
  if (dist < 0.1) return; // too close, skip

  const dirX = dx / dist;
  const dirZ = dz / dist;

  // Find how far we need to leap to clear the pit ahead
  // Scan forward in small steps to find where the pit ends
  let leapDist = 3; // minimum leap distance
  for (let probe = 1; probe <= 15; probe += 0.5) {
    const px = enemy.pos.x + dirX * probe;
    const pz = enemy.pos.z + dirZ * probe;
    if (!pitAt(px, pz, 0.3)) {
      leapDist = probe + 1; // overshoot by 1 unit to land clear
      break;
    }
    leapDist = probe + 1;
  }

  // Cap the leap distance
  leapDist = Math.min(leapDist, 12);

  enemy.isLeaping = true;
  enemy.leapStartX = enemy.pos.x;
  enemy.leapStartZ = enemy.pos.z;
  enemy.leapTargetX = enemy.pos.x + dirX * leapDist;
  enemy.leapTargetZ = enemy.pos.z + dir

function updateLeap(enemy, dt) {
  enemy.leapElapsed += dt;
  const t = Math.min(enemy.leapElapsed / enemy.leapDuration, 1);

  // Interpolate XZ position linearly
  enemy.pos.x = enemy.leapStartX + (enemy.leapTargetX - enemy.leapStartX) * t;
  enemy.pos.z = enemy.leapStartZ + (enemy.leapTargetZ - enemy.leapStartZ) * t;

  // Parabolic arc for Y (visual only)
  const arcY = 4 * enemy.leapArcHeight * t * (1 - t);
  enemy.mesh.position.set(enemy.pos.x, arcY, enemy.pos.z);

  // Face direction of travel
  const dx = enemy.leapTargetX - enemy.leapStartX;
  const dz = enemy.leapTargetZ - enemy.leapStartZ;
  if (dx * dx + dz * dz > 0.01) {
    enemy.mesh.rotation.y = Math.atan2(-dx, -dz);
  }

  // Landing
  if (t >= 1) {
    enemy.isLeaping = false;
    enemy.leapCooldown = (enemy.config.pitLeap && enemy.config.pitLeap.cooldown) || 4000;
    // Snap mesh back to ground
    enemy.mesh.position.set(enemy.pos.x, 0, enemy.pos.z);
  }
}