Function bodies 69 total

function dominantBody(worldPos) {
  let best = TERRA;
  let bestDist = worldPos.distanceTo(TERRA.center);
  for (const body of BODIES) {
    if (body === TERRA) continue;
    const dist = worldPos.distanceTo(body.center);
    if (dist < body.soiRadius && dist < bestDist) {
      best = body;
      bestDist = dist;
    }
  }
  return best;
}

function gravityVecAt(worldPos) {
  const body = dominantBody(worldPos);
  _grav.copy(body.center).sub(worldPos);
  const r = _grav.length();
  if (r < body.radius * 0.5) return _gravZero.set(0, 0, 0);
  const gMag = PHYS.gravity * (body.radius * body.radius) / (r * r);
  return _grav.normalize().multiplyScalar(gMag);
}

function planetGravityVec(worldPos) {
  return gravityVecAt(worldPos);
}

function flatToSphere(x, z, h) {
  const R = PLANET.radius;
  _ftsDir.set(x, R, z).normalize();
  _ftsResult.copy(PLANET.center).addScaledVector(_ftsDir, R + h);
  return _ftsResult;
}

function sphereToFlat(worldPos) {
  _stfFrom.copy(worldPos).sub(PLANET.center);
  _stfDir.copy(_stfFrom).normalize();
  if (_stfDir.y <= 0.01) { _stfResult.x = 0; _stfResult.z = 0; return _stfResult; }
  const scale = PLANET.radius / _stfDir.y;
  _stfResult.x = _stfDir.x * scale;
  _stfResult.z = _stfDir.z * scale;
  return _stfResult;
}

function planetUp(worldPos) {
  return _puResult.copy(worldPos).sub(PLANET.center).normalize();
}

function planetRadius(worldPos) {
  return worldPos.distanceTo(PLANET.center);
}

function altitudeAboveSphere(worldPos) {
  return planetRadius(worldPos) - PLANET.radius;
}

function altitudeAGL(worldPos) {
  const r = planetRadius(worldPos);
  const flat = sphereToFlat(worldPos);
  const surfaceR = PLANET.radius + terrainHeight(flat.x, flat.z);
  return r - surfaceR;
}

function airDensityAtPos(worldPos) {
  const body = dominantBody(worldPos);
  if (!body.hasAtmosphere) return 0;
  const alt = worldPos.distanceTo(body.center) - body.radius;
  if (alt > body.atmosphereHeight) return 0;
  const T = 288.15 - 0.0065 * Math.min(Math.max(alt, 0), 11000);
  let rho = 1.225 * Math.pow(T / 288.15, 4.256);
  // Smooth fade in the top 20% of atmosphere (no hard cutoff)
  const fadeStart = body.atmosphereHeight * 0.8;
  if (alt > fadeStart) {
    const fade = 1 - (alt - fadeStart) / (body.atmosphereHeight - fadeStart);
    rho *= fade * fade;  // quadratic ease-out
  }
  return rho;
}

function sphereRotation(worldPos) {
  const radial = planetUp(worldPos);
  return new THREE.Quaternion().setFromUnitVectors(_flatUp, radial);
}

function fireWeapon() {
  const now = performance.now();
  const w = STATE.weapons.types[STATE.weapons.current];
  if (now - STATE.lastFire < w.fireRate) return;
  if (w.ammo <= 0) return;

  STATE.lastFire = now;
  w.ammo--;
  playWeaponSound(w.name);

  const dir = new THREE.Vector3(0, 0, -1);
  dir.applyQuaternion(playerObj.quaternion);

  const pos = playerObj.position.clone();

  if (w.name === 'BOMB') {
    projectiles.push({
      pos: pos.clone(),
      vel: dir.clone().multiplyScalar(PROJ_SPEED * 0.3).add(STATE.velocity),
      type: w,
      life: 5,
      gravity: true
    });
  } else {
    projectiles.push({
      pos: pos.clone(),
      vel: dir.clone().multiplyScalar(PROJ_SPEED),
      type: w,
      life: 3,
      gravity: false
    });
  }

  // Muzzle flash
  spawnExplosion(
    pos.x + dir.x * 8, pos.y + dir.y * 8, pos.z + dir.z * 8,
    3, new THREE.Color(1, 0.8, 0.2), new THREE.Color(1, 0.4, 0.1), 5
  );
}

function updateProjectiles(dt) {
  for (let i = projectiles.length - 1; i >= 0; i--) {
    const p = projectiles[i];
    p.life -= dt;
    if (p.life <= 0) { projectiles.splice(i, 1); continue; }

    // Gravity: apply toward planet center (not flat -Y)
    if (p.gravity) {
      const gravDir = planetGravityVec(p.pos);
      p.vel.add(gravDir.multiplyScalar(dt));
    }
    p.pos.add(p.vel.clone().multiplyScalar(dt));

    // Terrain collision (spherical)
    if (altitudeAGL(p.pos) < 0) {
      explodeAt(p.pos.x, p.pos.y, p.pos.z, p.type.radius, p.type.damage);
      projectiles.splice(i, 1);
    }
  }
}

function explodeAt(x, y, z, radius, damage) {
  // Destroy terrain splats
  for (const chunk of chunks.values()) {
    chunk.destroySplatsInRadius(x, y, z, radius);
  }

  // Visual explosion
  const intensity = damage / 5;
  spawnExplosion(x, y, z, radius,
    new THREE.Color(1, 0.6, 0.1),
    new THREE.Color(1, 0.15, 0.0),
    Math.min(30 * intensity, 200)
  );
  spawnExplosion(x, y + 5, z, radius * 0.6,
    new THREE.Color(1, 0.9, 0.7),
    new THREE.Color(0.8, 0.3, 0.05),
    Math.min(15 * intensity, 80)
  );

  // Explosion sound
  playExplosionSound(x, y, z, damage);

  // Screen shake
  shakeAmount += damage * 0.15;

  // Damage flash
  const flash = document.getElementById('damage-flash');
  flash.classList.add('active');
  setTimeout(() => flash.classList.remove('active'), 150);
}

class GameServer(SimpleHTTPRequestHandler):
    def do_POST(self):
        if self.path == '/api/fdr':
            try:
                length = int(self.headers.get('Content-Length', 0))
                body = self.rfile.read(length)
                data = json.loads(body)

                # Generate filename from session ID and timestamp
                session_id = data.get('metadata', {}).get('sessionId', 'unknown')
                ts = datetime.now().strftime('%Y%m%d-%H%M%S')
                frames = len(data.get('frames', []))
                filename = f"fdr-{ts}-{session_id[:8]}-{frames}f.json"
                filepath = os.path.join(FDR_DIR, filename)

                with open(filepath, 'w') as f:
                    json.dump(data, f)

                self.send_response(200)
                self.send_header('Content-Type', 'application/json')
                self.send_header('Access-Control-Allow-Origin', '*')
                self.end_headers()
                self.wfile.wri

    def do_POST(self):
        if self.path == '/api/fdr':
            try:
                length = int(self.headers.get('Content-Length', 0))
                body = self.rfile.read(length)
                data = json.loads(body)

                # Generate filename from session ID and timestamp
                session_id = data.get('metadata', {}).get('sessionId', 'unknown')
                ts = datetime.now().strftime('%Y%m%d-%H%M%S')
                frames = len(data.get('frames', []))
                filename = f"fdr-{ts}-{session_id[:8]}-{frames}f.json"
                filepath = os.path.join(FDR_DIR, filename)

                with open(filepath, 'w') as f:
                    json.dump(data, f)

                self.send_response(200)
                self.send_header('Content-Type', 'application/json')
                self.send_header('Access-Control-Allow-Origin', '*')
                self.end_headers()
                self.wfile.write(json.dumps({'ok': True, 'file': filename,

    def do_OPTIONS(self):
        # CORS preflight
        self.send_response(200)
        self.send_header('Access-Control-Allow-Origin', '*')
        self.send_header('Access-Control-Allow-Methods', 'POST, OPTIONS')
        self.send_header('Access-Control-Allow-Headers', 'Content-Type')
        self.end_headers()

    def end_headers(self):
        # Prevent browser caching so updates are always picked up
        self.send_header('Cache-Control', 'no-cache, no-store, must-revalidate')
        self.send_header('Pragma', 'no-cache')
        self.send_header('Expires', '0')
        super().end_headers()

    def log_message(self, format, *args):
        # Suppress per-request GET logs, keep FDR logs
        if 'POST' in str(args):
            super().log_message(format, *args)