PROCITY/tools/qa/interior_scale_check.py

#!/usr/bin/env python3
"""PROCITY Lane D — interior figure-scale gate (Round 10 regression guard).

Guards the R9 blocker: interior rig figures came out ~2x too tall (keeper head at 3.83 m in a
3.4 m room) because rigs.js `buildFigure` normalised by the head bone's world Y in BIND POSE —
which is head-above-hips (the skeleton origin), ~half the standing height — instead of the
feet->crown span. Fixed in R10 (normalise by `headY - minY`).

This gate boots the real game, enters a sample of open shops, spawns browser rigs at every browse
point (occupancy is 0 right after boot, so we inject it to exercise the browse spawn path
deterministically), and asserts for EVERY spawned interior figure:
    1.4 m <= crown(head-bone world Y) <= 2.0 m      (human-sized)
    crown < room dims.H                              (never clips the ceiling)
    |feet(min-bone world Y)| < 0.05 m                (planted on the floor)
Exits non-zero if any figure fails, so tools/qa.sh --strict fails a giant before it can ship.

Run:  tools/.venv/bin/python tools/qa/interior_scale_check.py [--seed N]
Setup: the same Playwright venv as tools/soak.py / tools/flags_check.py.
Needs Lane B's window.DBG hook (?dbg=1) + window.PROCITY.interiorMode (Lane C/F).
"""
import sys, time, socket, subprocess, pathlib

ROOT = pathlib.Path(__file__).resolve().parent.parent.parent
PORT = 8130
HOST = f'http://127.0.0.1:{PORT}'
SEED = 20261990
if '--seed' in sys.argv:
    SEED = int(sys.argv[sys.argv.index('--seed') + 1])

LO, HI = 1.4, 2.0          # human crown band (Round-10 gate)
FOOT_EPS = 0.05            # feet must plant at floor y=0
SAMPLE_TYPES = ['opshop', 'toy', 'video', 'record', 'book', 'milkbar', 'clothes', 'hardware']

fails = []
def FAIL(m): fails.append(m); print(f"  \033[31m✗ FAIL\033[0m {m}")
def OK(m):   print(f"  \033[32m✓\033[0m {m}")

def port_up(port):
    with socket.socket() as s:
        s.settimeout(0.4)
        return s.connect_ex(('127.0.0.1', port)) == 0

def ensure_server():
    if port_up(PORT):
        return None
    proc = subprocess.Popen(['python3', '-m', 'http.server', str(PORT)],
                            cwd=str(ROOT / 'web'), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    for _ in range(50):
        if port_up(PORT): return proc
        time.sleep(0.1)
    proc.terminate(); sys.exit(f"could not start http.server on :{PORT}")

# JS: enter is done via DBG; this measures every interior fig after injecting browsers at browse points.
MEASURE_JS = r"""
(shopId) => {
  const P = window.PROCITY, THREE = P.THREE, im = P.interiorMode, v = new THREE.Vector3();
  const cur = im.current;
  if (!cur || P.mode !== 'interior') return { err: 'not in interior' };
  // occupancy is 0 right after boot; inject a browser rig at each browse point to exercise the
  // browse spawn path (same spawnRig->buildFigure the shell uses when patronage fills a shop).
  const bps = cur.browsePoints || [];
  bps.slice(0, 3).forEach((pt, i) => {
    try { im.keepers.spawn(cur.group, { x: pt.x, z: pt.z, ry: pt.ry, shopId: shopId, browse: true,
                                        seedKey: 'qa#' + i, pedIndex: (i * 7) % 19 }); } catch (e) {}
  });
  const H = +cur.dims.H;
  const figs = im.keepers.keepers.map(k => {
    const a = k.actor; let crown = 0, foot = Infinity;
    a.fig.updateWorldMatrix(true, true);
    (a.inner || a.fig).traverse(o => { if (o.isBone) { o.getWorldPosition(v);
      if (/head/i.test(o.name)) crown = Math.max(crown, v.y); foot = Math.min(foot, v.y); } });
    return { kind: k.kind, browse: !!k.browse, crown: +crown.toFixed(3), foot: +foot.toFixed(3) };
  });
  return { H: +H.toFixed(2), figs };
}
"""

def main():
    try:
        from playwright.sync_api import sync_playwright
    except ImportError:
        sys.exit("playwright not installed — python3 -m venv tools/.venv && tools/.venv/bin/pip install playwright && tools/.venv/bin/playwright install chromium")

    print(f"\033[1mINTERIOR FIGURE-SCALE GATE\033[0m  (seed {SEED}, band [{LO},{HI}] m, no giants)")
    srv = ensure_server()
    total_figs = 0
    shops_checked = 0
    try:
        with sync_playwright() as p:
            b = p.chromium.launch()
            pg = b.new_page(viewport={'width': 1280, 'height': 720})
            pg.goto(f'{HOST}/index.html?seed={SEED}&dbg=1')
            pg.wait_for_function("window.DBG && window.DBG.ready === true", timeout=25000)
            pg.evaluate("() => { const o=document.getElementById('pc-start'); if(o) o.style.display='none'; }")
            try:
                pg.wait_for_function("() => window.PROCITY && window.PROCITY.fleet && window.PROCITY.fleet.ready", timeout=15000)
            except Exception:
                sys.exit("fleet never became ready — cannot test rig scale")
            pg.evaluate("() => window.DBG.setSegment(2)")   # midday: shops open

            for t in SAMPLE_TYPES:
                sid = pg.evaluate("""(t) => {
                    const P=window.PROCITY;
                    const s=(P.plan.shops||[]).find(x=>x.type===t && P.isOpen(x));
                    if(!s) return null; window.DBG.enterShop(s.id); return {id:s.id, name:s.name};
                }""", t)
                if not sid:
                    continue
                pg.wait_for_timeout(400)   # interior build + keeper/browser rigs settle
                res = pg.evaluate(MEASURE_JS, sid['id'])
                if isinstance(res, dict) and res.get('err'):
                    FAIL(f"{sid['name']} ({t}): {res['err']}")
                    pg.evaluate("() => window.DBG.exitShop && window.DBG.exitShop()"); pg.wait_for_timeout(150)
                    continue
                H, figs = res['H'], res['figs']
                shops_checked += 1
                bad = []
                for f in figs:
                    total_figs += 1
                    if not (LO <= f['crown'] <= HI):        bad.append(f"crown {f['crown']}m out of [{LO},{HI}]")
                    elif not (f['crown'] < H):              bad.append(f"crown {f['crown']}m >= ceiling {H}m")
                    elif abs(f['foot']) >= FOOT_EPS:        bad.append(f"feet at {f['foot']}m (not planted)")
                if bad:
                    FAIL(f"{sid['name']} ({t}, H={H}m): " + "; ".join(bad))
                else:
                    crowns = ", ".join(f"{f['crown']:.2f}" for f in figs)
                    OK(f"{sid['name']} ({t}, H={H}m): {len(figs)} figs crowns=[{crowns}] all human-sized")
                pg.evaluate("() => window.DBG.exitShop && window.DBG.exitShop()")
                pg.wait_for_timeout(150)
            b.close()
    finally:
        if srv: srv.terminate()

    print()
    if shops_checked == 0:
        sys.exit("\033[31m✗ no shops could be entered — gate inconclusive\033[0m")
    if fails:
        print(f"\033[31m● {len(fails)} FAIL\033[0m — interior giant(s) detected across {shops_checked} shop(s), {total_figs} figs.")
        sys.exit(1)
    print(f"\033[32m● PASS\033[0m — {total_figs} interior figs across {shops_checked} shops all human-sized [{LO},{HI}] m and under-ceiling.")
    sys.exit(0)

if __name__ == '__main__':
    main()