646 lines
23 KiB
JavaScript
646 lines
23 KiB
JavaScript
/**
|
|
* QuestTrackerHud — the quest tracker that slides in right below the
|
|
* system dossier (top-left), the moment the dossier has folded:
|
|
*
|
|
* ┌ SYSTEM NAME ▸ (the dossier — folded to its title)
|
|
* │
|
|
* │ QUESTS ▁▁▁▁▁ (green section title — always visible)
|
|
* │ ◆ START YOUR JOURNEY 75% (the ONE priority quest — its
|
|
* │ ✓ RESEARCH TETHER LEVEL 2 checklist renders UNDER its
|
|
* │ · MINE 200 MINERALS… — 120/200 title and tracks LIVE)
|
|
* │ · MINE THE BELT 33% (the rest: plain titles, main story
|
|
* │ …up to maxVisible … first, then side quests)
|
|
* │ [ SHOW MORE ] (only when MORE than maxVisible are active
|
|
* └ — opens the QUESTS console on the first
|
|
* hidden quest)
|
|
*
|
|
* Or, with nothing tracked: QUESTS / "NONE TRACKED" (grayed out).
|
|
*
|
|
* Lifecycle (driven by GameScene — see GameScene.updateHud /
|
|
* startExpand): the tracker is VISIBLE ⇔ the dossier is FOLDED, armed by
|
|
* the dossier's FIRST fold (the one-shot auto-fold, or the player's
|
|
* manual fold — either is the first fold). When the dossier re-opens the
|
|
* tracker SLIDES OFF (offscreen left) first, then the dossier expands;
|
|
* when the dossier folds again the tracker slides back in. The slide is
|
|
* a ~320 ms ease-out translate (data/quests.json → tracker.slideMs).
|
|
*
|
|
* The tracker is a VIEW — the same live split as the QUESTS console:
|
|
* the scene computes the snapshot (GameScene.questSnapshot — progress is
|
|
* LIVE: research, mined, tether, discovery) and owns the effects
|
|
* (set/clear the priority on the quest ledger, open the console). It
|
|
* polls every frame and repaints only when the fingerprint changes, so
|
|
* the checklist ticks over as tasks complete.
|
|
*
|
|
* The ONE priority quest (js/quests/QuestState.js): the player sets it
|
|
* (a row's popup → SET PRIORITY, or the console's SET PRIORITY) and
|
|
* clears it (row popup → CLEAR PRIORITY); otherwise the first active
|
|
* story quest is the priority (ledger auto-assignment), and claiming it
|
|
* auto-advances to the next story/side quest.
|
|
*
|
|
* A row click opens the row's POPUP (a small cut-corner panel, the
|
|
* mining menu's contract): a click on a button is the button's (Menu-
|
|
* Button's own pointerdown); any click elsewhere closes the popup and
|
|
* that click is consumed — the scene's pointerdown enforces the
|
|
* contract (GameScene: contains() / popupContains() below).
|
|
*/
|
|
import Phaser from '../vendor/phaser.js';
|
|
import { config } from '../config/Config.js';
|
|
import { toCss } from '../utils/Color.js';
|
|
import { fontStack, themeColor } from '../utils/Theme.js';
|
|
import { CyberShape } from './CyberShape.js';
|
|
import { MenuButton } from './MenuButton.js';
|
|
|
|
const FONT_FALLBACK = "'Segoe UI', 'Helvetica Neue', Arial, sans-serif";
|
|
const HEADER = fontStack('header', FONT_FALLBACK);
|
|
const BODY = fontStack('body', FONT_FALLBACK);
|
|
|
|
/** The tracker's palette — green is the tracker's accent (data/quests.json). */
|
|
const C = {
|
|
green: themeColor('green', 0x67e863),
|
|
ink: themeColor('ink', 0xeaf6ff),
|
|
dim: themeColor('dim', 0x7d92c4),
|
|
faint: themeColor('faint', 0x3d4c74),
|
|
panel: themeColor('panel', 0x0a1120),
|
|
};
|
|
|
|
/** Display order: main story first, then side quests, then anything else. */
|
|
function catRank(q) {
|
|
return q?.category === 'main' ? 0 : q?.category === 'side' ? 1 : 2;
|
|
}
|
|
|
|
/**
|
|
* The tracker's visible rows: the first `max` in display order — except
|
|
* the priority quest, which is ALWAYS in the list (its checklist is the
|
|
* point of the tracker): when it would sit past the cap it takes the
|
|
* last slot (original order is preserved).
|
|
*/
|
|
function pickVisible(active, priorityId, max) {
|
|
let vis = active.slice(0, max);
|
|
if (priorityId && !vis.some((q) => q.id === priorityId)) {
|
|
const p = active.find((q) => q.id === priorityId);
|
|
if (p) {
|
|
vis = active.slice(0, Math.max(0, max - 1));
|
|
vis.push(p);
|
|
vis.sort((a, b) => active.indexOf(a) - active.indexOf(b));
|
|
}
|
|
}
|
|
return vis;
|
|
}
|
|
|
|
export class QuestTrackerHud {
|
|
/**
|
|
* @param {Phaser.Scene} scene the owning scene (GameScene — the tracker
|
|
* does not exist on the surface)
|
|
* @param {object} o
|
|
* @param {number} o.anchorX — the left edge (the dossier's X)
|
|
* @param {number} o.anchorY — the top edge (just below the dossier title)
|
|
* @param {() => object|null} o.getSnapshot — the live dossier snapshot
|
|
* (GameScene.questSnapshot; polled every frame)
|
|
* @param {(activeIds: string[]) => string|null} o.resolvePriority —
|
|
* the ledger's priority resolution (GameScene.questState.resolvePriority)
|
|
* @param {(id: string) => void} [o.onSetPriority] — SET PRIORITY pressed
|
|
* @param {() => void} [o.onClearPriority] — CLEAR PRIORITY pressed
|
|
* @param {(id: string) => void} [o.onViewQuest] — VIEW QUEST pressed
|
|
* @param {(id: string) => void} [o.onShowMore] — SHOW MORE pressed (the
|
|
* first hidden quest)
|
|
*/
|
|
constructor(scene, o = {}) {
|
|
this.scene = scene;
|
|
this.getSnapshot = typeof o.getSnapshot === 'function' ? o.getSnapshot : null;
|
|
this.resolvePriority = typeof o.resolvePriority === 'function' ? o.resolvePriority : null;
|
|
this.onSetPriority = typeof o.onSetPriority === 'function' ? o.onSetPriority : null;
|
|
this.onClearPriority = typeof o.onClearPriority === 'function' ? o.onClearPriority : null;
|
|
this.onViewQuest = typeof o.onViewQuest === 'function' ? o.onViewQuest : null;
|
|
this.onShowMore = typeof o.onShowMore === 'function' ? o.onShowMore : null;
|
|
|
|
const cfg = config.section('quests.tracker', {});
|
|
this.maxVisible = Math.max(1, Math.floor(cfg.maxVisible ?? 5));
|
|
this.slideMs = Math.max(80, Math.floor(cfg.slideMs ?? 320));
|
|
this.X = Math.max(8, Math.floor(o.anchorX ?? 16));
|
|
this.Y0 = Math.max(30, Math.floor(o.anchorY ?? 40));
|
|
this.rowW = 250; // the row plates' width (the percent sits at their right edge)
|
|
this._offX = -(this.rowW + 60); // offscreen-left (the slide's start/end)
|
|
|
|
// Everything lives in ONE container — the slide is a single x
|
|
// translate of the container (at (0,0) at rest, so local == screen).
|
|
this.root = new Phaser.GameObjects.Container(scene, 0, 0);
|
|
scene.add.existing(this.root); // v4: a directly-constructed GameObject must register
|
|
this.root.setScrollFactor(0); // UI — pinned to the screen
|
|
this.root.setDepth(30); // with the dossier and the other corner readouts
|
|
this.root.setVisible(false);
|
|
|
|
// --- The section title: green, ALWAYS there while the HUD exists ---
|
|
this.title = scene
|
|
.add.text(this.X, this.Y0, String(cfg.title ?? 'QUESTS').toUpperCase(), {
|
|
fontFamily: HEADER,
|
|
fontSize: '12px',
|
|
color: toCss(C.green),
|
|
fontStyle: 'bold',
|
|
letterSpacing: 3,
|
|
})
|
|
.setOrigin(0, 0)
|
|
.setScrollFactor(0);
|
|
this.root.add(this.title);
|
|
this.rule = scene.add.graphics().setScrollFactor(0);
|
|
this.rule.clear();
|
|
this.rule.lineStyle(1, C.green, 0.45);
|
|
this.rule.lineBetween(this.X, this.Y0 + 18, this.X + 54, this.Y0 + 18);
|
|
this.root.add(this.rule);
|
|
|
|
// The dynamic content (rows / checklist / none / show-more) + the
|
|
// row popup — repainted on fingerprint change.
|
|
this._kids = []; // the current paint's scene objects (torn down on repaint)
|
|
this._rowRects = []; // { id, x, y, w, h } — the clickable rows
|
|
this._rowRectById = new Map();
|
|
this._moreRect = null; // the SHOW MORE button's rect
|
|
this._popup = null; // { questId, rect, sourceRect, openedAt, btns, obj }
|
|
this._lastPopup = null; // { rect, at } — the just-closed popup (the same-frame guard)
|
|
this._fp = null; // the last painted fingerprint
|
|
this._priorityId = null; // the last resolved priority (for the popup)
|
|
this.state = 'hidden'; // hidden | showing | shown | hiding
|
|
this._destroyed = false;
|
|
|
|
this.root.setPosition(this._offX, 0); // start offscreen-left
|
|
this.update(scene.time.now); // first paint (hidden — it slides in when the dossier folds)
|
|
}
|
|
|
|
// ------------------------------------------------------------ lifecycle
|
|
/** Is a slide in flight? (the scene guards the dossier toggle on this) */
|
|
isBusy() {
|
|
return this.state === 'showing' || this.state === 'hiding';
|
|
}
|
|
|
|
/** Occupies the screen (fully in, or still sliding in). */
|
|
get shown() {
|
|
return this.state === 'shown' || this.state === 'showing';
|
|
}
|
|
|
|
/** Slide IN from offscreen-left (the dossier just folded). */
|
|
show(now) {
|
|
if (this.state === 'shown' || this.state === 'showing') return;
|
|
this.closePopup();
|
|
this.state = 'showing';
|
|
this.root.setVisible(true);
|
|
this.root.setX(this._offX);
|
|
this._slide(0, () => {
|
|
this.state = 'shown';
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Slide OFF to offscreen-left (the dossier is about to re-open — make
|
|
* room BEFORE it unfolds). `onDone` fires when the slide lands (or
|
|
* immediately when already hidden) — the scene starts the dossier
|
|
* expand from there.
|
|
*/
|
|
hide(now, onDone) {
|
|
if (this.state === 'hidden') {
|
|
if (typeof onDone === 'function') onDone();
|
|
return;
|
|
}
|
|
if (this.state === 'hiding') return; // the in-flight hide fires ITS onDone
|
|
this.closePopup();
|
|
this.state = 'hiding';
|
|
this._slide(this._offX, () => {
|
|
this.root.setVisible(false);
|
|
this.state = 'hidden';
|
|
if (typeof onDone === 'function') onDone();
|
|
});
|
|
}
|
|
|
|
/** One slide (a single x tween of the root container). */
|
|
_slide(toX, after) {
|
|
// Kill any in-flight slide first (a show→hide race leaves two tweens
|
|
// fighting over the same x — killTweensOf is the codebase's pattern).
|
|
this.scene.tweens.killTweensOf(this.root);
|
|
this.scene.tweens.add({
|
|
targets: this.root,
|
|
x: toX,
|
|
duration: this.slideMs,
|
|
ease: 'Sine.easeOut',
|
|
onComplete: () => {
|
|
if (typeof after === 'function') after();
|
|
},
|
|
});
|
|
}
|
|
|
|
// ------------------------------------------------------------ painting
|
|
/**
|
|
* Per-frame (GameScene.update): poll the live snapshot, resolve the
|
|
* priority, and repaint only when the fingerprint changes (a check
|
|
* completing, a percent ticking, the priority moving, a quest
|
|
* claimed/granted). The slide state is tween-driven, not polled.
|
|
*/
|
|
update(_time) {
|
|
let snap = null;
|
|
try {
|
|
snap = this.getSnapshot ? this.getSnapshot() : null;
|
|
} catch {
|
|
snap = null;
|
|
}
|
|
const quests = Array.isArray(snap?.quests) ? snap.quests : [];
|
|
// ACTIVE = held + not claimed, display order: main story first, then
|
|
// side quests (stable within a category — the data file's order).
|
|
const active = quests
|
|
.filter((q) => q && !q.claimed)
|
|
.sort((a, b) => catRank(a) - catRank(b));
|
|
const ids = active.map((q) => q.id);
|
|
let priorityId = null;
|
|
if (this.resolvePriority) {
|
|
try {
|
|
priorityId = this.resolvePriority(ids) ?? null;
|
|
} catch {
|
|
priorityId = null;
|
|
}
|
|
}
|
|
const visible = pickVisible(active, priorityId, this.maxVisible);
|
|
const overflowFirst = active.length > visible.length ? active[visible.length] : null;
|
|
const fp = JSON.stringify({
|
|
p: priorityId,
|
|
a: ids,
|
|
c: active.map((q) => {
|
|
const checks = q.checks ?? [];
|
|
return (
|
|
checks.map((c) => (c?.done ? 1 : 0)).join('') +
|
|
'|' +
|
|
checks.map((c) => String(c?.detail ?? '')).join(',').slice(0, 40)
|
|
);
|
|
}),
|
|
o: overflowFirst ? overflowFirst.id : null,
|
|
});
|
|
if (fp === this._fp) return;
|
|
this._fp = fp;
|
|
this._priorityId = priorityId;
|
|
this._paint(active, visible, priorityId, overflowFirst);
|
|
}
|
|
|
|
/** Tear down the dynamic content (the title + rule are permanent). */
|
|
_teardown() {
|
|
for (const k of this._kids) {
|
|
try {
|
|
k.destroy();
|
|
} catch {
|
|
/* already gone */
|
|
}
|
|
}
|
|
this._kids = [];
|
|
this._rowRects = [];
|
|
this._rowRectById = new Map();
|
|
this._moreRect = null;
|
|
this.closePopup();
|
|
}
|
|
|
|
_paint(active, visible, priorityId, overflowFirst) {
|
|
this._teardown();
|
|
const s = this.scene;
|
|
const add = (obj) => {
|
|
this._kids.push(obj);
|
|
this.root.add(obj);
|
|
return obj;
|
|
};
|
|
const cfg = config.section('quests.tracker', {});
|
|
let y = this.Y0 + 32;
|
|
|
|
if (active.length === 0) {
|
|
add(
|
|
s.add
|
|
.text(this.X, y, String(cfg.noneTracked ?? 'NONE TRACKED'), {
|
|
fontFamily: BODY,
|
|
fontSize: '11px',
|
|
color: toCss(C.faint),
|
|
letterSpacing: 2,
|
|
})
|
|
.setOrigin(0, 0)
|
|
.setScrollFactor(0),
|
|
);
|
|
return;
|
|
}
|
|
|
|
for (const q of visible) {
|
|
const isPrio = q.id === priorityId;
|
|
const doneN = (q.checks ?? []).filter((c) => c?.done).length;
|
|
const total = (q.checks ?? []).length;
|
|
const pct = total > 0 ? Math.round((100 * doneN) / total) : 0;
|
|
const rx = this.X - 2;
|
|
const ry = y;
|
|
const rw = this.rowW;
|
|
const rh = 20;
|
|
|
|
// The row plate (a VISIBLE object — the v4 hit-test rule) + the
|
|
// left tick (green = the priority quest, faint = the rest).
|
|
const plate = add(s.add.graphics().setScrollFactor(0));
|
|
plate.clear();
|
|
plate.fillStyle(C.panel, 0.35);
|
|
plate.fillRect(rx, ry, rw, rh);
|
|
plate.fillStyle(isPrio ? C.green : C.faint, isPrio ? 0.95 : 0.7);
|
|
plate.fillRect(rx, ry + 3, isPrio ? 2 : 1, rh - 6);
|
|
plate.setInteractive({
|
|
useHandCursor: true,
|
|
hitArea: new Phaser.Geom.Rectangle(rx, ry, rw, rh),
|
|
hitAreaCallback: (area, px, py) => area.contains(px, py),
|
|
});
|
|
plate.on('pointerover', () => {
|
|
if (this.shown) this.scene.playSfx?.('ui_hover');
|
|
});
|
|
plate.on('pointerdown', () => {
|
|
if (!this.shown || this.isBusy()) return;
|
|
this.scene.playSfx?.('ui_click');
|
|
this.openPopup(q, { x: rx, y: ry, w: rw, h: rh });
|
|
});
|
|
|
|
add(
|
|
s.add
|
|
.text(this.X + 8, ry + 3, String(q.title ?? '').toUpperCase(), {
|
|
fontFamily: BODY,
|
|
fontSize: '12px',
|
|
color: toCss(isPrio ? C.ink : C.dim),
|
|
letterSpacing: 1,
|
|
})
|
|
.setOrigin(0, 0)
|
|
.setScrollFactor(0),
|
|
);
|
|
add(
|
|
s.add
|
|
.text(this.X + rw, ry + rh / 2, `${pct}%`, {
|
|
fontFamily: BODY,
|
|
fontSize: '11px',
|
|
color: toCss(isPrio ? C.green : C.dim),
|
|
letterSpacing: 1,
|
|
})
|
|
.setOrigin(1, 0.5)
|
|
.setScrollFactor(0),
|
|
);
|
|
const rect = { id: q.id, x: rx, y: ry, w: rw, h: rh };
|
|
this._rowRects.push(rect);
|
|
this._rowRectById.set(q.id, rect);
|
|
y += rh + 6;
|
|
|
|
// The priority quest's CHECKLIST — under its title, LIVE (the
|
|
// fingerprint repaints as checks complete): done = a green check +
|
|
// the dim label; open = a gray bullet, the label, and the detail.
|
|
if (isPrio) {
|
|
for (const c of q.checks ?? []) {
|
|
const label = String(c?.label ?? '');
|
|
const detail = String(c?.detail ?? '');
|
|
const line = c?.done
|
|
? `✓ ${label}`
|
|
: detail && detail !== '??'
|
|
? `· ${label} — ${detail}`
|
|
: `· ${label}`;
|
|
add(
|
|
s.add
|
|
.text(this.X + 14, y, line, {
|
|
fontFamily: BODY,
|
|
fontSize: '11px',
|
|
color: toCss(c?.done ? C.dim : C.faint),
|
|
letterSpacing: 0.5,
|
|
})
|
|
.setOrigin(0, 0)
|
|
.setScrollFactor(0),
|
|
);
|
|
y += 16;
|
|
}
|
|
y += 4; // a breath before the next quest
|
|
}
|
|
}
|
|
|
|
// SHOW MORE — only when there is more beyond the cap (opens the
|
|
// QUESTS console on the first hidden quest — its tab is switched
|
|
// there, GameScene.openQuestAt → QuestWindow.openAt).
|
|
if (overflowFirst) {
|
|
const bw = 150;
|
|
const bh = 30;
|
|
const bx = this.X + bw / 2;
|
|
const by = y + bh / 2 + 4;
|
|
const btn = new MenuButton(s, bx, by, String(cfg.showMore ?? 'SHOW MORE'), () => {
|
|
this.onShowMore?.(overflowFirst.id);
|
|
}, {
|
|
width: bw,
|
|
fontSize: 11,
|
|
paddingX: 8,
|
|
paddingY: 6,
|
|
letterSpacing: 2,
|
|
upper: true,
|
|
screenFixed: true,
|
|
bgColor: C.panel,
|
|
hoverColor: C.panel,
|
|
textColor: toCss(C.ink),
|
|
});
|
|
btn.style.stroke = C.dim;
|
|
btn.style.neon = C.green;
|
|
btn.paint('base');
|
|
add(btn);
|
|
this._moreRect = { x: bx - bw / 2, y: by - bh / 2, w: bw, h: bh };
|
|
y += bh + 8;
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------ the row popup
|
|
/**
|
|
* The row's context popup (a click on a quest row): a small cut-corner
|
|
* panel to the right of the row with the quest's name and two buttons —
|
|
* SET PRIORITY (CLEAR PRIORITY, when this quest IS the priority) and
|
|
* VIEW QUEST (the QUESTS console on this quest). A click on a button
|
|
* is the button's (MenuButton's own pointerdown); any click ELSEWHERE
|
|
* closes the popup and is consumed (GameScene's pointerdown, via
|
|
* popupContains() below).
|
|
* @param {object} quest the snapshot quest (GameScene.questSnapshot shape)
|
|
* @param {{x:number,y:number,w:number,h:number}} rowRect the row clicked
|
|
*/
|
|
openPopup(quest, rowRect) {
|
|
if (!quest) return;
|
|
this.closePopup();
|
|
const s = this.scene;
|
|
const isPrio = this._priorityId === quest.id;
|
|
const W = 212;
|
|
const mk = (label, onClick) =>
|
|
new MenuButton(s, 0, 0, label, onClick, {
|
|
width: W - 24,
|
|
fontSize: 11,
|
|
paddingX: 8,
|
|
paddingY: 6,
|
|
letterSpacing: 1.5,
|
|
upper: true,
|
|
screenFixed: true,
|
|
bgColor: C.panel,
|
|
hoverColor: C.panel,
|
|
textColor: toCss(C.ink),
|
|
});
|
|
const bPrio = mk(isPrio ? 'CLEAR PRIORITY' : 'SET PRIORITY', () => {
|
|
if (isPrio) this.onClearPriority?.();
|
|
else this.onSetPriority?.(quest.id);
|
|
this.closePopup();
|
|
});
|
|
bPrio.style.stroke = isPrio ? C.faint : C.green;
|
|
bPrio.style.neon = isPrio ? C.dim : C.green;
|
|
bPrio.paint('base');
|
|
const bView = mk('VIEW QUEST', () => {
|
|
this.onViewQuest?.(quest.id);
|
|
this.closePopup();
|
|
});
|
|
bView.style.stroke = C.dim;
|
|
bView.style.neon = C.green;
|
|
bView.paint('base');
|
|
|
|
const h1 = bPrio.style.height;
|
|
const h2 = bView.style.height;
|
|
const H = 26 + 6 + h1 + 6 + h2 + 8;
|
|
// The panel plate (a cut-corner plate — CyberShape at its centre).
|
|
const g = s.add.graphics().setScrollFactor(0);
|
|
g.clear();
|
|
CyberShape.draw(g, W, H, {
|
|
notch: Math.min(12, H * 0.18),
|
|
fill: C.panel,
|
|
fillAlpha: 0.96,
|
|
stroke: isPrio ? C.faint : C.green,
|
|
strokeAlpha: 0.85,
|
|
lineWidth: 1.5,
|
|
glow: isPrio ? C.dim : C.green,
|
|
glowAlpha: 0.18,
|
|
});
|
|
g.setPosition(W / 2, H / 2);
|
|
const header = s.add
|
|
.text(10, 8, String(quest.title ?? '').toUpperCase(), {
|
|
fontFamily: BODY,
|
|
fontSize: '10px',
|
|
color: toCss(C.dim),
|
|
letterSpacing: 1.5,
|
|
})
|
|
.setOrigin(0, 0)
|
|
.setScrollFactor(0);
|
|
bPrio.setPosition(W / 2, 26 + h1 / 2);
|
|
bView.setPosition(W / 2, 26 + h1 + 6 + h2 / 2);
|
|
|
|
// Placement: right of the row (falling back to its left when the
|
|
// right side runs off the screen edge).
|
|
const sw = s.scale.width;
|
|
let px = rowRect.x + rowRect.w + 14;
|
|
if (px + W > sw - 8) px = Math.max(8, rowRect.x - W - 14);
|
|
const py = Math.max(8, rowRect.y - 4);
|
|
|
|
// ONE container — the popup slides/fades as a unit and is hit-tested
|
|
// as a whole (the scene's contract: inside = the popup's, outside =
|
|
// the close).
|
|
const cont = new Phaser.GameObjects.Container(s, px, py);
|
|
s.add.existing(cont);
|
|
cont.setScrollFactor(0);
|
|
cont.setDepth(31); // just above the tracker's own plate (30)
|
|
cont.add(g);
|
|
cont.add(header);
|
|
cont.add(bPrio);
|
|
cont.add(bView);
|
|
this._popup = {
|
|
questId: quest.id,
|
|
rect: { x: px, y: py, w: W, h: H },
|
|
sourceRect: { ...rowRect }, // the row that opened it (the scene's same-click test)
|
|
openedAt: this.scene.time.now,
|
|
btns: [bPrio, bView],
|
|
obj: cont,
|
|
};
|
|
this.scene.playSfx?.('ui_window');
|
|
}
|
|
|
|
/** Close the row popup (a no-op when it isn't up). */
|
|
closePopup() {
|
|
const p = this._popup;
|
|
this._popup = null;
|
|
if (!p) return;
|
|
this._lastPopup = { rect: p.rect, at: this.scene.time.now }; // the same-frame guard
|
|
for (const b of p.btns) {
|
|
try {
|
|
b.destroy();
|
|
} catch {
|
|
/* already gone */
|
|
}
|
|
}
|
|
try {
|
|
p.obj.destroy(true);
|
|
} catch {
|
|
/* already gone */
|
|
}
|
|
this.scene.playSfx?.('ui_close');
|
|
}
|
|
|
|
get popupOpen() {
|
|
return this._popup !== null;
|
|
}
|
|
|
|
/** Is (px,py) on the open popup's plate? (the scene's pointerdown contract) */
|
|
popupContains(px, py) {
|
|
const r = this._popup?.rect;
|
|
return !!r && px >= r.x && px <= r.x + r.w && py >= r.y && py <= r.y + r.h;
|
|
}
|
|
|
|
/**
|
|
* Is (px,py) on the row that OPENED the popup? (The scene's contract:
|
|
* the opening click — same frame as openPopup — is swallowed; a later
|
|
* deliberate re-click on that row folds the popup.)
|
|
*/
|
|
sourceContains(px, py) {
|
|
const r = this._popup?.sourceRect;
|
|
return !!r && px >= r.x && px <= r.x + r.w && py >= r.y && py <= r.y + r.h;
|
|
}
|
|
|
|
/** The popup was opened within `ms` of the scene's clock (same-frame test). */
|
|
popupOpenedWithin(ms) {
|
|
const at = this._popup?.openedAt;
|
|
return typeof at === 'number' && (this.scene.time.now - at) < ms;
|
|
}
|
|
|
|
/**
|
|
* Was the popup just closed (within one frame) and is (px,py) inside
|
|
* its former plate? (The scene's contract: a click the popup's OWN
|
|
* buttons just handled — they close it from their side first — is the
|
|
* popup's click, never a world click. The mining menu's guard.)
|
|
*/
|
|
closedPopupAt(px, py) {
|
|
const lp = this._lastPopup;
|
|
if (!lp || typeof lp.at !== 'number') return false;
|
|
if (this.scene.time.now - lp.at >= 40) return false;
|
|
const r = lp.rect;
|
|
return px >= r.x && px <= r.x + r.w && py >= r.y && py <= r.y + r.h;
|
|
}
|
|
|
|
/**
|
|
* Is (px,py) inside the tracker's footprint — a row, the SHOW MORE
|
|
* button, or the open popup? (The scene's pointerdown: inside = the
|
|
* tracker's own click, never a fly-here; the mining menu's contract.)
|
|
*/
|
|
contains(px, py) {
|
|
if (this.popupContains(px, py)) return true;
|
|
for (const r of this._rowRects) {
|
|
if (px >= r.x && px <= r.x + r.w && py >= r.y && py <= r.y + r.h) return true;
|
|
}
|
|
const m = this._moreRect;
|
|
if (m && px >= m.x && px <= m.x + m.w && py >= m.y && py <= m.y + m.h) return true;
|
|
return false;
|
|
}
|
|
|
|
/** The current resolved priority (the popup's SET/CLEAR choice). */
|
|
get priorityId() {
|
|
return this._priorityId;
|
|
}
|
|
|
|
destroy() {
|
|
if (this._destroyed) return;
|
|
this._destroyed = true;
|
|
this.closePopup();
|
|
this._teardown();
|
|
try {
|
|
this.title.destroy();
|
|
} catch {
|
|
/* already gone */
|
|
}
|
|
try {
|
|
this.rule.destroy();
|
|
} catch {
|
|
/* already gone */
|
|
}
|
|
try {
|
|
this.root.destroy(true);
|
|
} catch {
|
|
/* already gone */
|
|
}
|
|
}
|
|
}
|