Phase 3: AR hunt /hunt + launch page /play - shared-visual ghosts, colour lure, hauntometer

public/hunt.js

@@ -0,0 +1,155 @@
+/**
+ * hunt.js — Newbury Nights hunt loop (Phase 3, standalone demo)
+ *
+ * Core v1 mechanics:
+ *   - Spawn: rarity-weighted draw from the roster, placed in a forward arc.
+ *   - Colour lure: the wheel sets the "lured" colour; matching ghosts spawn more
+ *     often and are worth more, mirroring the original's GhostColor mechanic.
+ *   - Capture: aim the reticle, hold to charge, release to fire. Charge time
+ *     scales with the ghost's chargePips; misses let it flee (escape timing).
+ *   - Hauntometer: every active/escaped ghost raises the meter; captures lower
+ *     it. As the meter climbs, spawn rate and rarity bias escalate — the session
+ *     gets harder the longer the haunt goes unchecked.
+ *
+ * Engine-agnostic: takes a THREE instance + a scene + the createGhostVisual
+ * factory. No AR/session code here — the page wires camera/anchor.
+ */
+
+import { createGhostVisual } from './ghost-visual.js';
+
+const RARITY_BASE_WEIGHT = { Common: 50, Rare: 30, Epic: 15, Legendary: 5 };
+const RARITY_SCORE       = { Common: 10, Rare: 25, Epic: 60, Legendary: 150 };
+const COLORS = ['Red', 'Blue', 'Yellow'];
+
+export function createHunt(THREE, scene, opts = {}) {
+  const roster = opts.roster || [];
+  const maxActive = opts.maxActive ?? 4;
+  const spawnArcDeg = opts.spawnArcDeg ?? 120; // ±60°
+  const onEvent = opts.onEvent || (() => {});
+
+  let luredColor = null;           // set by the colour wheel
+  let haunt = 0;                   // 0..100 hauntometer
+  let captured = [];               // captured ghost ids this session
+  const active = new Map();        // id -> { ghost, visual, hp, state, fleeAt }
+  let nextId = 1;
+  let spawnTimer = 0;
+
+  // --- weighted roster draw, biased by lure + haunt escalation ---
+  function pickGhost() {
+    // haunt escalation: higher haunt tilts the draw toward rarer ghosts
+    const escal = 1 + (haunt / 100) * 1.5; // up to 2.5x rare bias
+    const pool = [];
+    for (const g of roster) {
+      let w = RARITY_BASE_WEIGHT[g.rarity] || 1;
+      // rarer ghosts get heavier as haunt climbs
+      if (g.rarity !== 'Common') w *= escal;
+      // lure: matching colour spawns ~2x more often
+      if (luredColor && g.color === luredColor) w *= 2;
+      pool.push([g, w]);
+    }
+    const total = pool.reduce((s, [, w]) => s + w, 0);
+    let r = Math.random() * total;
+    for (const [g, w] of pool) { r -= w; if (r <= 0) return g; }
+    return pool[pool.length - 1][0];
+  }
+
+  function placeInArc(obj) {
+    const half = (spawnArcDeg * Math.PI / 180) / 2;
+    const yaw = (Math.random() * 2 - 1) * half;        // forward-facing arc
+    const pitch = (Math.random() * 0.5 - 0.15);        // slightly varied height
+    const dist = 2.2 + Math.random() * 1.8;            // 2.2-4m out
+    obj.position.set(
+      Math.sin(yaw) * dist,
+      0.2 + Math.sin(pitch) * 1.2,
+      -Math.cos(yaw) * dist
+    );
+  }
+
+  function spawn() {
+    if (active.size >= maxActive) return;
+    const g = pickGhost();
+    const visual = createGhostVisual(THREE, { color: g.color, fx: opts.fx !== false });
+    placeInArc(visual.object3d);
+    scene.add(visual.object3d);
+    const id = nextId++;
+    // hp derived from health pips/stat; charge to capture scales with chargePips
+    const hp = (g.healthMax || 300) / 100;             // ~2.6-4.5
+    active.set(id, {
+      ghost: g, visual, hp, maxHp: hp,
+      state: 'idle',
+      fleeAt: performance.now() + (6000 + Math.random() * 4000), // escapes if ignored
+    });
+    haunt = Math.min(100, haunt + 4);                  // presence raises the meter
+    onEvent({ type: 'spawn', id, ghost: g, haunt });
+  }
+
+  // --- capture attempt: called by the page with a charge level 0..1 ---
+  function fireAt(id, charge) {
+    const a = active.get(id);
+    if (!a) return { hit: false };
+    // damage = charge, but the ghost needs enough charge relative to chargePips
+    const needed = 0.4 + (a.ghost.chargePips || 2) * 0.12; // 0.5-1.0
+    const dmg = charge >= needed ? charge * 1.6 : charge * 0.4;
+    a.hp -= dmg;
+    if (a.hp <= 0) return capture(id);
+    a.state = 'hit';
+    onEvent({ type: 'hit', id, ghost: a.ghost, hpFrac: Math.max(0, a.hp / a.maxHp) });
+    return { hit: true, captured: false };
+  }
+
+  function capture(id) {
+    const a = active.get(id);
+    if (!a) return { hit: false };
+    a.visual.setState('capture');
+    const colorBonus = luredColor && a.ghost.color === luredColor ? 1.5 : 1;
+    const score = Math.round((RARITY_SCORE[a.ghost.rarity] || 10) * colorBonus);
+    captured.push(a.ghost.id);
+    haunt = Math.max(0, haunt - 10);                   // captures calm the haunt
+    setTimeout(() => { scene.remove(a.visual.object3d); a.visual.dispose(); }, 500);
+    active.delete(id);
+    onEvent({ type: 'capture', id, ghost: a.ghost, score, captured: captured.length, haunt });
+    return { hit: true, captured: true, score };
+  }
+
+  function flee(id) {
+    const a = active.get(id);
+    if (!a) return;
+    a.visual.setState('capture'); // reuse shrink-out
+    setTimeout(() => { scene.remove(a.visual.object3d); a.visual.dispose(); }, 400);
+    active.delete(id);
+    haunt = Math.min(100, haunt + 8);                  // an escape feeds the haunt
+    onEvent({ type: 'flee', id, ghost: a.ghost, haunt });
+  }
+
+  function setLure(color) {
+    luredColor = COLORS.includes(color) ? color : null;
+    onEvent({ type: 'lure', color: luredColor });
+  }
+
+  function update(dt, elapsed) {
+    // spawn cadence accelerates with haunt
+    const interval = Math.max(1.2, 4.5 - (haunt / 100) * 3.0);
+    spawnTimer += dt;
+    if (spawnTimer >= interval) { spawnTimer = 0; spawn(); }
+
+    const now = performance.now();
+    for (const [id, a] of active) {
+      a.visual.update(dt, elapsed);
+      if (now >= a.fleeAt) flee(id);
+    }
+  }
+
+  function listActive() {
+    return [...active.entries()].map(([id, a]) => ({
+      id, ghost: a.ghost, object3d: a.visual.object3d,
+      hpFrac: Math.max(0, a.hp / a.maxHp),
+    }));
+  }
+
+  return {
+    update, spawn, fireAt, capture, flee, setLure, listActive,
+    get haunt() { return haunt; },
+    get captured() { return captured.slice(); },
+    get luredColor() { return luredColor; },
+  };
+}