3361 lines
155 KiB
JavaScript
3361 lines
155 KiB
JavaScript
// DungeonBossGame.js — Phaser scene for Dungeon Boss (presentation only; all
|
||
// rules live in DungeonBossLogic). The scene pumps the engine's decision queue:
|
||
// human decisions enable click UI, AI decisions run on a think delay, and each
|
||
// action's event stream drives a sequential animation queue before re-render.
|
||
|
||
import * as Phaser from 'phaser';
|
||
import { GAME_WIDTH, GAME_HEIGHT, COLORS } from '../../config.js';
|
||
import { Button } from '../../ui/Button.js';
|
||
import { playSound, SFX } from '../../ui/Sounds.js';
|
||
import { MusicPlayer } from '../../ui/MusicPlayer.js';
|
||
import { api } from '../../services/api.js';
|
||
import { createPlayerPortrait, createOpponentPortrait } from '../../ui/Portrait.js';
|
||
import {
|
||
BOSSES, ROOMS, SPELLS, HEROES, CLASS_INFO,
|
||
heroSouls, roomDef, spellDef, heroDef,
|
||
} from './DungeonBossData.js';
|
||
import {
|
||
newGame, pendingDecision, takeEvents, publicView,
|
||
actSetupDiscard, actBuild, actWindow, actReact, actChooseTarget, actDiscard, actRoomDraw,
|
||
legalBuilds, windowActions, treasureCount, dungeonDamage,
|
||
SOULS_TO_WIN, WOUNDS_TO_DIE, MAX_ROOMS,
|
||
} from './DungeonBossLogic.js';
|
||
import { decide, nextThinkDelay } from './DungeonBossAI.js';
|
||
|
||
// ── palette: retro dungeon (dark stone, parchment, class colors) ─────────────
|
||
const C = {
|
||
bg: 0x120e16, bgTop: 0x221a2a,
|
||
parchment: 0xe8dcbf, ink: '#2a2118', inkLight: '#f2ead8', muted: '#9e9080',
|
||
gold: 0xd9a520, goldHex: '#d9a520',
|
||
monsterEdge: 0x8a5a2a, monsterPlate: 0x7a1f1f,
|
||
trapEdge: 0xc9962a, trapPlate: 0x8a6a14,
|
||
spellEdge: 0x8f6fd8, spellPlate: 0x453569,
|
||
bossEdge: 0x8c1f28,
|
||
heroWindow: 0x274060, artWindow: 0x1b2436,
|
||
soul: 0xf5d76e, wound: 0xc0392b, frozen: 0x9fd8f0,
|
||
goldDarkHex: '#8a6a14', spellPhaseDarkHex: '#5b3f96', xpDarkHex: '#57506a',
|
||
};
|
||
// Card face background — same parchment tone as the rules-text box; the name
|
||
// plates and art windows stay dark (own contrast), so only the few bits of
|
||
// text drawn directly on the bare face need the darker ink variants above.
|
||
C.cardBg = C.parchment;
|
||
const DEPTH = { board: 10, town: 20, hand: 40, fx: 60, ui: 80, overlay: 90, hover: 100 };
|
||
// Canonical card shapes (w/h) — every rendered instance of a card type keeps
|
||
// this aspect ratio, whatever box a call site hands it (see fitCardBox).
|
||
const CARD_ASPECT = { room: 280 / 390, spell: 260 / 360, hero: 280 / 390, boss: 300 / 430 };
|
||
// Mini hero-card sizes for entrance/gate queues (see miniHeroCard) and the
|
||
// full town-card width heroes shrink from when they walk to a gate (see the
|
||
// 'heroWalks' case in eventFx).
|
||
const TOWN_HERO_W = 106;
|
||
const OPP_ENTRANCE_W = 46, OPP_ENTRANCE_PITCH = 30;
|
||
const HUMAN_ENTRANCE_W = 64, HUMAN_ENTRANCE_PITCH = 38;
|
||
// Width a drawn card grows to while paused, face down then flipped, in the
|
||
// center of the screen mid-draw-animation, before shrinking into the hand.
|
||
const DRAW_FULL_W = { room: 340, spell: 300 };
|
||
// Deck-pile screen positions the draw animation flies cards out of — must
|
||
// match renderDeckPiles()'s room/spell rows.
|
||
const DECK_PILE_POS = { room: { x: 60, y: 520, w: 46, h: 64 }, spell: { x: 60, y: 600, w: 46, h: 64 } };
|
||
|
||
// ── adventure battle modal: layout constants ────────────────────────────────
|
||
// Event types the modal owns end-to-end once a walk starts (see
|
||
// splitAdventureWalk). NOT exclusively adventure-walk events elsewhere in the
|
||
// engine (endRound()'s own trap collapse also emits roomDestroyed; spells
|
||
// also emit heroHurt) — membership here is necessary but not sufficient, see
|
||
// splitAdventureWalk's midHero guard.
|
||
const ADV_WALK_TYPES = new Set([
|
||
'heroEnters', 'heroTeleported', 'heroHurt', 'roomHits', 'heroDies', 'bossWounded', 'roomDestroyed', 'eliminated',
|
||
]);
|
||
const ADV_HERO_ROW = { x0: 40, x1: 860, y: 200, maxW: 120 };
|
||
const ADV_ROOM_ROW = { x0: 900, x1: 1880, y: 200, maxW: 150 };
|
||
const ADV_STAGE_HERO = { x: 380, y: 680 };
|
||
const ADV_STAGE_ROOM = { x: 760, y: 680 };
|
||
// Card widths in the battle stage match the hover-zoom preview size those
|
||
// same card renderers use elsewhere (makeHeroCard/makeRoomCard's own
|
||
// `previewW`) — keep these two pairs in sync if either one ever changes.
|
||
const ADV_STAGE_HERO_W = 314;
|
||
const ADV_STAGE_ROOM_W = 344;
|
||
const ADV_LOG_PANEL = { x0: 1180, y0: 420, w: 700, h: 480, lineH: 50 };
|
||
const ADV_CONTINUE_POS = { x: 1530, y: 990 };
|
||
const ADV_FRAME_MARGIN = 18;
|
||
// Labeled section boxes drawn around the hero row, dungeon+boss row, and
|
||
// battle stage — comfortably outside the content each area actually lays
|
||
// out (see the ADV_HERO_ROW/ADV_ROOM_ROW/ADV_STAGE_* constants above).
|
||
const ADV_HERO_SECTION = { x0: 24, y0: 92, x1: 876, y1: 306 };
|
||
const ADV_ROOM_SECTION = { x0: 892, y0: 92, x1: 1896, y1: 306 };
|
||
const ADV_STAGE_SECTION = { x0: 24, y0: 396, x1: 1140, y1: 1024 };
|
||
|
||
// Deep-dive card inspector: per-card-type table of gameplay-relevant "zones"
|
||
// to annotate with a box + leader line + tooltip once a hovered card has
|
||
// been centered on screen (see openDeepDive/revealZones/showZoneCallout).
|
||
// All rect/anchor coordinates are in the card's own local space (origin at
|
||
// its center), evaluated against the fixed preview w/h the card was built
|
||
// at — the card is only ever translated (never rescaled) once centered, so
|
||
// these stay valid throughout. Reveal order is the array order.
|
||
const ROOM_DEEPDIVE_ZONES = [
|
||
{
|
||
id: 'type', side: 'left', title: 'Room Type',
|
||
text: (def) => (def.type === 'trap'
|
||
? 'Trap Room (gold border) — an environmental hazard triggers instead of a creature fight.'
|
||
: 'Monster Room (red border) — a creature blocks would-be heroes and fights anyone who reaches this room.'),
|
||
rect: (w, h) => ({ x: -w / 2 + 10, y: -h / 2 + 10, w: w - 20, h: h - 20 }),
|
||
anchor: (w, h) => ({ x: -w / 2 - 130, y: -h / 2 + 40 }),
|
||
},
|
||
{
|
||
id: 'advanced', side: 'right', title: 'Advanced Room',
|
||
text: 'Advanced rooms can only be built directly on top of another room that shares at least one treasure class.',
|
||
condition: (def) => !!def.advanced,
|
||
rect: (w, h) => {
|
||
const R = Math.max(2.5, w / 60) + 10;
|
||
return { x: w / 2 - 9 - R, y: -h / 2 + 9 - R, w: R * 2, h: R * 2 };
|
||
},
|
||
anchor: (w, h) => ({ x: w / 2 + 130, y: -h / 2 + 100 }),
|
||
},
|
||
{
|
||
id: 'treasure', side: 'right', title: 'Treasure Class',
|
||
text: 'Each icon is one Soul-point of this class, scored at game end for every matching class among your built rooms.',
|
||
condition: (def) => Object.values(def.treasure || {}).some((n) => n > 0),
|
||
rect: (w, h, def) => {
|
||
const icons = [];
|
||
for (const [cls, n] of Object.entries(def.treasure || {})) for (let i = 0; i < n; i++) icons.push(cls);
|
||
const isz = Math.max(6, w / 22);
|
||
// Deep-dive only ever runs on the large card (w > 200), where
|
||
// makeRoomCard nudges the icon row up-and-left by one icon's worth —
|
||
// mirror that same offset here so the callout box tracks it.
|
||
const pad = w > 200 ? isz : 0;
|
||
const cy = h / 2 - isz - 6 - pad;
|
||
const xRight = (w / 2 - 12 - pad) + isz + 2;
|
||
const xLeft = (w / 2 - 12 - pad - (icons.length - 1) * (isz * 2 + 4)) - isz - 2;
|
||
return { x: xLeft, y: cy - isz - 2, w: xRight - xLeft, h: (isz + 2) * 2 };
|
||
},
|
||
anchor: (w, h) => ({ x: w / 2 + 130, y: h / 2 - 10 }),
|
||
},
|
||
{
|
||
id: 'damage', side: 'left', title: 'Damage',
|
||
text: 'Damage this room deals to invading heroes when they reach it.',
|
||
rect: (w, h) => {
|
||
const br = Math.max(9, w / 13), cx = -w / 2 + br + 5, cy = h / 2 - br - 5, R = br + 6;
|
||
return { x: cx - R, y: cy - R, w: R * 2, h: R * 2 };
|
||
},
|
||
anchor: (w, h) => ({ x: -w / 2 - 130, y: h / 2 - 60 }),
|
||
},
|
||
];
|
||
// Boss cards use def = BOSSES[bossId] directly (see makeBossCard) — art
|
||
// window height/iy formulas below mirror that function's own math exactly
|
||
// (with opts.showText always true for a deep-dive build).
|
||
const BOSS_DEEPDIVE_ZONES = [
|
||
{
|
||
id: 'xp', side: 'left', title: 'XP',
|
||
text: 'Turn order — highest XP goes first each round; on a tie in souls at game end, lowest XP wins.',
|
||
rect: (w, h) => {
|
||
const artH = h * 0.44;
|
||
const iy = -h / 2 + 30 + artH + 14;
|
||
return { x: -w / 2 + 2, y: iy - 18, w: 100, h: 36 };
|
||
},
|
||
anchor: (w, h) => ({ x: -w / 2 - 130, y: -h / 2 + 30 + h * 0.44 + 14 }),
|
||
},
|
||
{
|
||
id: 'treasure', side: 'right', title: 'Treasure Class',
|
||
text: 'The Soul-class this boss counts toward at scoring.',
|
||
rect: (w, h) => {
|
||
const artH = h * 0.44;
|
||
const cx = w / 2 - 18, cy = -h / 2 + 30 + artH + 14;
|
||
return { x: cx - 11, y: cy - 11, w: 22, h: 22 };
|
||
},
|
||
anchor: (w, h) => ({ x: w / 2 + 130, y: -h / 2 + 30 + h * 0.44 + 14 }),
|
||
},
|
||
{
|
||
id: 'levelUp', side: 'right', title: 'Level-Up Ability',
|
||
text: 'A one-time power that triggers when this boss builds their 5th room.',
|
||
rect: (w, h) => {
|
||
const artH = h * 0.44;
|
||
const iy = -h / 2 + 30 + artH + 14;
|
||
const boxTop = iy + 12;
|
||
return { x: -w / 2 + 7, y: boxTop, w: w - 14, h: h / 2 - boxTop - 8 };
|
||
},
|
||
anchor: (w, h) => ({ x: w / 2 + 130, y: h / 2 - 60 }),
|
||
},
|
||
];
|
||
// Spell cards use def = spellDef(inst) (see makeSpellCard) — plateH/artH/
|
||
// boxTop formulas below mirror that function's own math exactly. Unlike
|
||
// Room/Boss, the rules box has no opts.showText gate (always rendered).
|
||
const SPELL_DEEPDIVE_ZONES = [
|
||
{
|
||
id: 'phase', side: 'left', title: 'When You Can Cast It',
|
||
text: (def) => (def.phase === 'both'
|
||
? 'This spell can be cast during either the Build phase or the Adventure phase.'
|
||
: `This spell can only be cast during the ${def.phase === 'build' ? 'Build' : 'Adventure'} phase.`),
|
||
rect: (w, h) => {
|
||
const plateH = Math.max(15, h * 0.15), artH = h * 0.36;
|
||
const cy = -h / 2 + plateH + artH + 16;
|
||
return { x: -60, y: cy - 14, w: 120, h: 28 };
|
||
},
|
||
anchor: (w, h) => {
|
||
const plateH = Math.max(15, h * 0.15), artH = h * 0.36;
|
||
return { x: -w / 2 - 130, y: -h / 2 + plateH + artH + 16 };
|
||
},
|
||
},
|
||
{
|
||
id: 'effect', side: 'right', title: 'Effect',
|
||
text: 'The parchment box spells out exactly what happens when this spell is cast.',
|
||
rect: (w, h) => {
|
||
const plateH = Math.max(15, h * 0.15), artH = h * 0.36;
|
||
const boxTop = -h / 2 + plateH + artH + 26;
|
||
return { x: -w / 2 + 7, y: boxTop, w: w - 14, h: h / 2 - boxTop - 8 };
|
||
},
|
||
anchor: (w, h) => ({ x: w / 2 + 130, y: h / 2 - 60 }),
|
||
},
|
||
];
|
||
// Hero cards use def = heroDef(hero) (see makeHeroCard). "class" doubles as
|
||
// the Epic Hero card's class zone too — the same zone table covers both,
|
||
// since an Epic Hero is just a HEROES entry with epic:true, rendered by the
|
||
// same function; the 'epic' zone below is what only appears on Epic Heroes.
|
||
const HERO_DEEPDIVE_ZONES = [
|
||
{
|
||
id: 'class', side: 'left', title: 'Class',
|
||
text: (def) => (def.fool
|
||
? 'The Fool has no class — it is drawn toward whichever player currently has the fewest souls, not treasure.'
|
||
: 'This hero is drawn toward whichever player has the most matching-class treasure built in their dungeon.'),
|
||
rect: (w, h) => {
|
||
const artH = h * 0.52;
|
||
return { x: -w / 2 + 6, y: -h / 2 + artH + 10, w: w - 12, h: 16 };
|
||
},
|
||
anchor: (w, h) => ({ x: -w / 2 - 130, y: -h / 2 + h * 0.52 + 18 }),
|
||
},
|
||
{
|
||
id: 'epic', side: 'right', title: 'Epic Hero',
|
||
text: 'Epic heroes are worth more souls (and deal more wounds to your boss) than ordinary heroes.',
|
||
condition: (def) => !!def.epic,
|
||
rect: (w, h) => ({ x: -40, y: -h / 2 + 2, w: 80, h: 24 }),
|
||
anchor: (w, h) => ({ x: w / 2 + 130, y: -h / 2 + 40 }),
|
||
},
|
||
{
|
||
id: 'hp', side: 'left', title: 'Hit Points',
|
||
text: 'How much damage this hero can take from your rooms before it dies.',
|
||
rect: (w, h) => { const hy = h / 2 - 16; return { x: -w / 2 + 5, y: hy - 13, w: 32, h: 28 }; },
|
||
anchor: (w, h) => ({ x: -w / 2 - 130, y: h / 2 - 16 }),
|
||
},
|
||
{
|
||
id: 'souls', side: 'right', title: 'Souls',
|
||
text: 'Souls you score when this hero dies in your dungeon.',
|
||
rect: (w, h) => { const hy = h / 2 - 16; return { x: w / 2 - 31, y: hy - 13, w: 26, h: 26 }; },
|
||
anchor: (w, h) => ({ x: w / 2 + 130, y: h / 2 - 16 }),
|
||
},
|
||
];
|
||
const DEEPDIVE_ZONES = {
|
||
room: ROOM_DEEPDIVE_ZONES, boss: BOSS_DEEPDIVE_ZONES, spell: SPELL_DEEPDIVE_ZONES, hero: HERO_DEEPDIVE_ZONES,
|
||
};
|
||
|
||
export default class DungeonBossGame extends Phaser.Scene {
|
||
constructor() { super('DungeonBossGame'); }
|
||
|
||
init(data) {
|
||
this._initData = data;
|
||
this.gameDef = data?.game ?? { slug: 'dungeonboss', name: 'Dungeon Boss' };
|
||
this.opponents = data?.opponents ?? [];
|
||
this.playfield = data?.playfield ?? null;
|
||
this.nPlayers = 1 + this.opponents.length;
|
||
this.humanSeat = 0;
|
||
this.gs = null;
|
||
this.mode = { type: 'idle' }; // current human input mode
|
||
this.busy = false; // animation lock
|
||
this._heroTokens = new Map(); // uid → world position of last render
|
||
this._slotRects = new Map(); // `${seat}:${idx}` → {x,y,w,h}
|
||
this._handSprites = new Map(); // uid → container
|
||
this._soulsPos = new Map(); // seat → {x,y}
|
||
this._recorded = false;
|
||
this.hoverTimer = null;
|
||
this.hoverVisible = false;
|
||
this._dealing = false; // true while the initial-deal animation plays
|
||
this.deepDiveTimer = null; // second "keep hovering" timer, mirrors hoverTimer
|
||
this._deepDive = null; // { modal, cardHolder, zoneTimers, zoneNodes, returnX, returnY, w, h, deepDiveInfo } while open
|
||
this._hoverSuppressCont = null; // card container currently mid-drag — its own hover popup stays disabled until dropped
|
||
this._advBattle = null; // adventure battle modal session state (see openAdventureModal) while open
|
||
this._advDungeonSnapshot = null; // per-seat pre-mutation dungeon snapshot, refreshed every applyDecision (see there)
|
||
}
|
||
|
||
create() {
|
||
try { const m = this.cache.json.get('music'); if (m?.tracks) new MusicPlayer(this, m.tracks); } catch (_) { /* optional */ }
|
||
this.art = this.cache.json.get('dungeonboss-artwork') || {};
|
||
|
||
const pf = this.playfield;
|
||
if (pf?.key && this.textures.exists(pf.key)) {
|
||
this.add.image(GAME_WIDTH / 2, GAME_HEIGHT / 2, pf.key)
|
||
.setDisplaySize(GAME_WIDTH, GAME_HEIGHT).setDepth(0);
|
||
} else {
|
||
const bg = this.add.graphics().setDepth(0);
|
||
bg.fillGradientStyle(C.bgTop, C.bgTop, C.bg, C.bg, 1);
|
||
bg.fillRect(0, 0, GAME_WIDTH, GAME_HEIGHT);
|
||
// faint stonework
|
||
bg.lineStyle(1, 0xffffff, 0.025);
|
||
for (let y = 0; y < GAME_HEIGHT; y += 64) { bg.lineBetween(0, y, GAME_WIDTH, y); }
|
||
for (let x = 0; x < GAME_WIDTH; x += 96) { bg.lineBetween(x, 0, x, GAME_HEIGHT); }
|
||
}
|
||
|
||
this.boardLayer = this.add.container(0, 0).setDepth(DEPTH.board);
|
||
this.townLayer = this.add.container(0, 0).setDepth(DEPTH.town);
|
||
this.discardZoneLayer = this.add.container(0, 0).setDepth(DEPTH.hand - 1);
|
||
this.handLayer = this.add.container(0, 0).setDepth(DEPTH.hand);
|
||
this.fxLayer = this.add.container(0, 0).setDepth(DEPTH.fx);
|
||
this.uiLayer = this.add.container(0, 0).setDepth(DEPTH.ui);
|
||
this.buildHoverPopup();
|
||
this.input.on('pointermove', (p) => {
|
||
this.lastPointer = { x: p.x, y: p.y };
|
||
if (this.hoverVisible) this.positionHover(p.x, p.y);
|
||
});
|
||
|
||
this.buildStaticUi();
|
||
this.gs = newGame(this.nPlayers, (Math.random() * 1e9) | 0);
|
||
takeEvents(this.gs); // swallow gameStart
|
||
this._dealing = true;
|
||
this.renderAll();
|
||
this.animateInitialDeal(() => {
|
||
this.showBanner('Discard 2 cards, then build your first room');
|
||
this.pump();
|
||
});
|
||
}
|
||
|
||
// ── static chrome ──────────────────────────────────────────────────────────
|
||
buildStaticUi() {
|
||
new Button(this, 90, GAME_HEIGHT - 36, 'Leave', () => this.scene.start('GameMenu'),
|
||
{ width: 130, fontSize: 18, variant: 'ghost' }).setDepth(DEPTH.ui);
|
||
this.deckText = this.add.text(20, 360, '', {
|
||
fontFamily: '"Julius Sans One"', fontSize: '16px', color: '#9e9080', lineSpacing: 6,
|
||
}).setDepth(DEPTH.ui);
|
||
// y=865 sits below the human dungeon room slots (humanSlotRect bottom
|
||
// edge ≈836.5, w=196/CARD_ASPECT.room) and above the hand row (room/
|
||
// spell card top edges ≈897 at hand y=985) — see also addActionButton,
|
||
// which now sits under the boss card instead of near this text.
|
||
this.promptText = this.add.text(GAME_WIDTH / 2, 865, '', {
|
||
fontFamily: 'Righteous', fontSize: '24px', color: C.goldHex,
|
||
backgroundColor: '#120e16dd', padding: { x: 16, y: 6 },
|
||
}).setOrigin(0.5).setDepth(DEPTH.ui);
|
||
|
||
// portraits (static; boards re-render around them)
|
||
const panels = this.oppPanelCenters();
|
||
this._oppPortraits = this.opponents.map((opp, i) =>
|
||
createOpponentPortrait(this, opp, panels[i].x - 265, panels[i].y - 88, 36, DEPTH.ui));
|
||
this._playerPortrait = createPlayerPortrait(this, 180, 870, 40, DEPTH.ui, 'DungeonBossGame');
|
||
|
||
// Round-phase wheel — above the boss card, in the gap under the opponent
|
||
// panels (whose bottom edge sits at y=330 for all player counts; the boss
|
||
// card's top edge is at y=582).
|
||
this.phaseWheel = this.makePhaseWheel(1740, 456, 76);
|
||
}
|
||
|
||
// A 5-wedge ring (Round Start/Build/Bait/Adventure/Round End) that spins so
|
||
// the active wedge locks under a fixed top pointer — same mechanic as
|
||
// Dominion's phase dial (src/games/dominion/DominionGame.js:makePhaseDial),
|
||
// minus the per-seat active/pulse logic: Dungeon Boss phases apply to the
|
||
// whole table each round, so the wheel is always fully visible.
|
||
makePhaseWheel(x, y, outerR) {
|
||
const scene = this;
|
||
const PHASE = { roundStart: 0, build: 1, bait: 2, adventure: 3, roundEnd: 4 };
|
||
const colors = [0xf2ead8, C.gold, 0x8c5a2b, 0x6b8c3a, C.bossEdge];
|
||
const TWO_PI_5 = (Math.PI * 2) / 5;
|
||
const HALF = Math.PI / 5;
|
||
const TOP = -Math.PI / 2;
|
||
|
||
const container = this.add.container(x, y).setDepth(DEPTH.ui);
|
||
const ring = this.add.container(0, 0);
|
||
container.add(ring);
|
||
|
||
const a0 = [], a1 = [], mid = [];
|
||
for (let i = 0; i < 5; i++) {
|
||
const c = TOP + i * TWO_PI_5;
|
||
a0[i] = c - HALF; a1[i] = c + HALF; mid[i] = c;
|
||
}
|
||
|
||
const wedges = [];
|
||
for (let i = 0; i < 5; i++) {
|
||
const w = this.add.graphics();
|
||
ring.add(w);
|
||
wedges.push(w);
|
||
}
|
||
const paintWedges = (activeIdx) => {
|
||
for (let i = 0; i < 5; i++) {
|
||
const w = wedges[i];
|
||
const on = i === activeIdx;
|
||
w.clear();
|
||
w.fillStyle(colors[i], on ? 0.95 : 0.26);
|
||
w.beginPath(); w.moveTo(0, 0); w.arc(0, 0, outerR, a0[i], a1[i], false); w.closePath(); w.fillPath();
|
||
w.lineStyle(on ? Math.max(2, outerR * 0.05) : 1.5, on ? colors[i] : 0x9e9080, on ? 1 : 0.55);
|
||
w.beginPath(); w.moveTo(0, 0); w.arc(0, 0, outerR, a0[i], a1[i], false); w.closePath(); w.strokePath();
|
||
}
|
||
};
|
||
|
||
const ic = outerR * 0.2;
|
||
const midR = outerR * 0.66;
|
||
const drawHourglass = (g) => {
|
||
g.fillStyle(0x2a2118, 1);
|
||
g.fillTriangle(-ic, -ic, ic, -ic, 0, 0);
|
||
g.fillTriangle(-ic, ic, ic, ic, 0, 0);
|
||
g.lineStyle(Math.max(1, 0.16 * ic), 0xf2ead8, 1);
|
||
g.strokeTriangle(-ic, -ic, ic, -ic, 0, 0);
|
||
g.strokeTriangle(-ic, ic, ic, ic, 0, 0);
|
||
};
|
||
const drawHammer = (g) => {
|
||
g.fillStyle(0x2a2118, 1);
|
||
g.fillRect(-0.16 * ic, -0.2 * ic, 0.32 * ic, 1.2 * ic);
|
||
g.fillStyle(0x2a2118, 1);
|
||
g.fillRoundedRect(-ic, -1.15 * ic, 2 * ic, 0.7 * ic, 2);
|
||
};
|
||
const drawFootprint = (g) => {
|
||
g.fillStyle(0x2a2118, 1);
|
||
g.fillEllipse(0, 0.25 * ic, 0.7 * ic, 1 * ic);
|
||
g.fillCircle(-0.35 * ic, -0.75 * ic, 0.18 * ic);
|
||
g.fillCircle(0, -0.85 * ic, 0.2 * ic);
|
||
g.fillCircle(0.4 * ic, -0.75 * ic, 0.18 * ic);
|
||
};
|
||
const drawBoot = (g) => {
|
||
g.fillStyle(0x2a2118, 1);
|
||
g.fillRoundedRect(-0.5 * ic, -1.1 * ic, ic, 1.3 * ic, 3);
|
||
g.fillTriangle(-0.5 * ic, 0.2 * ic, 0.9 * ic, 0.2 * ic, 0.9 * ic, 0.7 * ic);
|
||
g.fillRect(-0.5 * ic, 0.2 * ic, 1.4 * ic, 0.5 * ic);
|
||
};
|
||
const drawMoon = (g) => {
|
||
g.fillStyle(0xf2ead8, 1);
|
||
g.fillCircle(0, 0, ic);
|
||
g.fillStyle(0x8c1f28, 1);
|
||
g.fillCircle(0.45 * ic, -0.15 * ic, 0.85 * ic);
|
||
};
|
||
const drawers = [drawHourglass, drawHammer, drawFootprint, drawBoot, drawMoon];
|
||
const icons = [];
|
||
for (let i = 0; i < 5; i++) {
|
||
const g = this.add.graphics();
|
||
drawers[i](g);
|
||
g.setPosition(Math.cos(mid[i]) * midR, Math.sin(mid[i]) * midR);
|
||
ring.add(g);
|
||
icons.push(g);
|
||
}
|
||
|
||
const hub = this.add.graphics();
|
||
hub.fillStyle(0x141008, 0.88); hub.fillCircle(0, 0, outerR * 0.4);
|
||
hub.lineStyle(Math.max(1.5, outerR * 0.03), 0x9e9080, 0.7); hub.strokeCircle(0, 0, outerR * 0.4);
|
||
container.add(hub);
|
||
|
||
const pointer = this.add.graphics();
|
||
const pw = outerR * 0.16, ph = outerR * 0.3, ty = -outerR;
|
||
pointer.fillStyle(C.gold, 1);
|
||
pointer.fillTriangle(-pw, ty - ph, pw, ty - ph, 0, ty + ph * 0.5);
|
||
pointer.lineStyle(1.5, 0x2a2118, 0.6);
|
||
pointer.strokeTriangle(-pw, ty - ph, pw, ty - ph, 0, ty + ph * 0.5);
|
||
container.add(pointer);
|
||
|
||
const names = ['Round Start', 'Build', 'Bait', 'Adventure', 'Round End'];
|
||
const nameHex = ['#f2ead8', C.goldHex, '#c98a52', '#9fce6a', '#e0656e'];
|
||
const labelSize = Math.max(12, Math.round(outerR * 0.3));
|
||
const label = this.add.text(0, -(outerR + labelSize), '', {
|
||
fontFamily: 'Righteous', fontSize: `${labelSize}px`, color: nameHex[0],
|
||
}).setOrigin(0.5);
|
||
label.setShadow(0, 2, '#000000', 4, false, true);
|
||
container.add(label);
|
||
const applyLabel = (idx) => { label.setText(names[idx]); label.setColor(nameHex[idx]); };
|
||
|
||
let phaseIdx = 0;
|
||
let rotTween = null;
|
||
paintWedges(phaseIdx);
|
||
applyLabel(phaseIdx);
|
||
|
||
return {
|
||
container,
|
||
setPhase(name) {
|
||
const idx = PHASE[name] ?? 0;
|
||
if (idx === phaseIdx) return;
|
||
phaseIdx = idx;
|
||
paintWedges(idx);
|
||
applyLabel(idx);
|
||
rotTween?.remove();
|
||
rotTween = scene.tweens.add({
|
||
targets: ring, rotation: -idx * TWO_PI_5, duration: 500, ease: 'Cubic.Out',
|
||
onUpdate: () => { icons.forEach((g) => { g.rotation = -ring.rotation; }); },
|
||
onComplete: () => { icons.forEach((g) => { g.rotation = -ring.rotation; }); },
|
||
});
|
||
},
|
||
destroy() { rotTween?.remove(); container.destroy(true); },
|
||
};
|
||
}
|
||
|
||
oppPanelCenters() {
|
||
const y = 218;
|
||
// panels are 560 wide; the 3-up layout previously spaced centers exactly
|
||
// 560 apart, leaving zero gap edge-to-edge — add a little breathing room.
|
||
const xs = this.opponents.length === 1 ? [960]
|
||
: this.opponents.length === 2 ? [630, 1290] : [376, 960, 1544];
|
||
return xs.map((x) => ({ x, y }));
|
||
}
|
||
|
||
// Keep a card render's width (the dimension every layout — hand row, dungeon
|
||
// slots, draft grid — actually spaces cards by) and derive height from the
|
||
// canonical aspect ratio, so every card of a type is truly the same shape
|
||
// instead of whatever height a call site guessed. Every card in this game is
|
||
// portrait, so the aspect is also clamped to guarantee height > width even
|
||
// if a caller (or a future CARD_ASPECT entry) passes a landscape ratio.
|
||
fitCardBox(boxW, boxH, aspect) {
|
||
const a = Math.min(aspect, 1 / aspect);
|
||
return { w: boxW, h: boxW / a };
|
||
}
|
||
|
||
// ── art lookup ─────────────────────────────────────────────────────────────
|
||
artFor(kind, id) {
|
||
const sheet = this.art[`${kind}Sheet`];
|
||
const plural = kind === 'boss' ? 'bosses' : kind === 'hero' ? 'heroes' : `${kind}s`;
|
||
const frame = this.art[plural]?.[id];
|
||
if (sheet && sheet.key && frame != null && this.textures.exists(sheet.key)) {
|
||
return { key: sheet.key, frame };
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// ── treasure / soul / heart icons ────────────────────────────────────────────
|
||
// All three fall back to procedural vector art (used throughout for the
|
||
// room/boss treasure-class badge, every soul-count display, hero HP, and
|
||
// the boss wound tracker) until dungeonboss-icons.png is wired in via
|
||
// dungeonboss-artwork.json's iconSheet + icons map.
|
||
drawTreasureIcon(cont, x, y, cls, s = 10) {
|
||
const info = CLASS_INFO[cls];
|
||
if (!info) return;
|
||
const g = this.add.graphics();
|
||
g.fillStyle(0x000000, 0.35);
|
||
g.fillRoundedRect(x - s - 2, y - s - 2, s * 2 + 4, s * 2 + 4, 3);
|
||
const art = this.artFor('icon', cls);
|
||
if (art) {
|
||
cont.add(g);
|
||
const img = this.add.image(x, y, art.key, art.frame);
|
||
img.setScale((s * 2) / Math.max(img.width, img.height));
|
||
cont.add(img);
|
||
return;
|
||
}
|
||
g.fillStyle(info.color, 1);
|
||
g.lineStyle(Math.max(1.5, s / 5), info.color, 1);
|
||
switch (info.glyph) {
|
||
case 'sword':
|
||
g.fillTriangle(x, y - s, x - s * 0.28, y + s * 0.35, x + s * 0.28, y + s * 0.35);
|
||
g.fillRect(x - s * 0.55, y + s * 0.35, s * 1.1, s * 0.18);
|
||
g.fillRect(x - s * 0.12, y + s * 0.5, s * 0.24, s * 0.5);
|
||
break;
|
||
case 'tome':
|
||
g.fillRoundedRect(x - s * 0.75, y - s * 0.65, s * 1.5, s * 1.3, 2);
|
||
g.lineStyle(Math.max(1, s / 7), 0x120e16, 1);
|
||
g.lineBetween(x, y - s * 0.6, x, y + s * 0.6);
|
||
g.lineBetween(x - s * 0.5, y - s * 0.2, x - s * 0.15, y - s * 0.2);
|
||
g.lineBetween(x + s * 0.15, y - s * 0.2, x + s * 0.5, y - s * 0.2);
|
||
break;
|
||
case 'coins':
|
||
g.fillCircle(x - s * 0.3, y + s * 0.2, s * 0.45);
|
||
g.fillCircle(x + s * 0.35, y + s * 0.15, s * 0.45);
|
||
g.fillCircle(x + 0, y - s * 0.35, s * 0.45);
|
||
break;
|
||
case 'ankh':
|
||
g.fillCircle(x, y - s * 0.45, s * 0.34);
|
||
g.fillStyle(0x000000, 0.001); // punch look via inner stroke instead
|
||
g.lineStyle(Math.max(2, s / 3.2), info.color, 1);
|
||
g.lineBetween(x, y - s * 0.15, x, y + s);
|
||
g.lineBetween(x - s * 0.5, y + s * 0.15, x + s * 0.5, y + s * 0.15);
|
||
break;
|
||
default: break;
|
||
}
|
||
cont.add(g);
|
||
}
|
||
|
||
// r is the icon's radius (matches the diameter callers used to draw by hand).
|
||
drawSoulIcon(cont, x, y, r = 10) {
|
||
const art = this.artFor('icon', 'soul');
|
||
if (art) {
|
||
const img = this.add.image(x, y, art.key, art.frame);
|
||
img.setScale((r * 2) / Math.max(img.width, img.height));
|
||
cont.add(img);
|
||
return;
|
||
}
|
||
const g = this.add.graphics();
|
||
g.fillStyle(C.soul, 1); g.fillCircle(x, y, r);
|
||
cont.add(g);
|
||
}
|
||
|
||
// d is the icon's full width; filled=true draws the "remaining" heart,
|
||
// false draws the "lost" (heartEmpty) variant.
|
||
drawHeartIcon(cont, x, y, d = 24, filled = true) {
|
||
const art = this.artFor('icon', filled ? 'heart' : 'heartEmpty');
|
||
if (art) {
|
||
const img = this.add.image(x, y, art.key, art.frame);
|
||
img.setScale(d / Math.max(img.width, img.height));
|
||
cont.add(img);
|
||
return;
|
||
}
|
||
const r = d / 4;
|
||
const g = this.add.graphics();
|
||
g.fillStyle(filled ? C.wound : 0x54505c, 1);
|
||
g.fillCircle(x - r, y - r * 0.5, r); g.fillCircle(x + r, y - r * 0.5, r);
|
||
g.fillTriangle(x - r * 2, y - r * 0.17, x + r * 2, y - r * 0.17, x, y + r * 2);
|
||
cont.add(g);
|
||
}
|
||
|
||
// ── card renderers (Boss-Monster-style procedural frames) ──────────────────
|
||
makeRoomCard(x, y, inst, w, h, opts = {}) {
|
||
({ w, h } = this.fitCardBox(w, h, CARD_ASPECT.room));
|
||
const fb = opts.isHoverPreview ? 1.6 : 1; // bump fixed-size text in the hover-zoom popup
|
||
const def = roomDef(inst);
|
||
const cont = this.add.container(x, y);
|
||
const trap = def.type === 'trap';
|
||
const edge = opts.selected ? C.gold : (trap ? C.trapEdge : C.monsterEdge);
|
||
const plate = trap ? C.trapPlate : C.monsterPlate;
|
||
const g = this.add.graphics();
|
||
g.fillStyle(C.cardBg, 1); g.fillRoundedRect(-w / 2, -h / 2, w, h, 6);
|
||
g.lineStyle(Math.max(2, w / 55), edge, 1); g.strokeRoundedRect(-w / 2, -h / 2, w, h, 6);
|
||
if (def.advanced) {
|
||
g.lineStyle(1.5, C.gold, 0.9);
|
||
g.strokeRoundedRect(-w / 2 + 4, -h / 2 + 4, w - 8, h - 8, 4);
|
||
for (const [gx, gy] of [[-w / 2 + 9, -h / 2 + 9], [w / 2 - 9, -h / 2 + 9], [-w / 2 + 9, h / 2 - 9], [w / 2 - 9, h / 2 - 9]]) {
|
||
g.fillStyle(C.gold, 1); g.fillCircle(gx, gy, Math.max(2.5, w / 60));
|
||
}
|
||
}
|
||
// name plate — advanced rooms get a gilded left-to-right fade into the
|
||
// same gold used by the inner border/corner rivets, tying the whole
|
||
// advanced treatment together.
|
||
const plateH = Math.max(16, h * 0.17);
|
||
if (def.advanced) g.fillGradientStyle(plate, C.gold, plate, C.gold, 1);
|
||
else g.fillStyle(plate, 1);
|
||
g.fillRoundedRect(-w / 2 + 5, -h / 2 + 5, w - 10, plateH, 3);
|
||
// art window
|
||
const artH = h * (opts.showText ? 0.42 : 0.58);
|
||
g.fillStyle(C.artWindow, 1);
|
||
g.fillRect(-w / 2 + 7, -h / 2 + plateH + 8, w - 14, artH);
|
||
cont.add(g);
|
||
|
||
const art = this.artFor('room', inst.id);
|
||
const artCY = -h / 2 + plateH + 8 + artH / 2;
|
||
if (art) {
|
||
const img = this.add.image(0, artCY, art.key, art.frame);
|
||
img.setScale(Math.min((w - 14) / Math.max(img.width, 1), artH / Math.max(img.height, 1)));
|
||
cont.add(img);
|
||
} else {
|
||
cont.add(this.add.text(0, artCY, trap ? '⚙' : '👹', { fontSize: `${Math.round(artH * 0.5)}px` }).setOrigin(0.5).setAlpha(0.75));
|
||
}
|
||
cont.add(this.add.text(0, -h / 2 + 5 + plateH / 2, def.name, {
|
||
fontFamily: 'Righteous', fontSize: `${Math.max(9, Math.round(w / 12))}px`,
|
||
color: '#f2ead8', wordWrap: { width: w - 14 },
|
||
}).setOrigin(0.5).setScale(Math.min(1, (w - 16) / Math.max(1, def.name.length * (w / 20)))));
|
||
|
||
// damage badge (bottom-left)
|
||
const bd = this.add.graphics();
|
||
const br = Math.max(9, w / 13);
|
||
bd.fillStyle(0x1a1420, 1); bd.fillCircle(-w / 2 + br + 5, h / 2 - br - 5, br + 2);
|
||
bd.fillStyle(C.wound, 1); bd.fillCircle(-w / 2 + br + 5, h / 2 - br - 5, br);
|
||
cont.add(bd);
|
||
const dmgLabel = def.passive === 'ballroomDamage' ? '✷' : `${def.dmg}`;
|
||
cont.add(this.add.text(-w / 2 + br + 5, h / 2 - br - 5, dmgLabel, {
|
||
fontFamily: 'Righteous', fontSize: `${Math.round(br * 1.1)}px`, color: '#f2ead8',
|
||
}).setOrigin(0.5));
|
||
|
||
// treasure icons (bottom-right) — the fixed 12/6px corner margins read
|
||
// fine at board/hand scale, but on the large hover-zoom/inspect card
|
||
// (w > 200) they're a tiny sliver of the card and the row looks jammed
|
||
// into the corner, so nudge it up-and-left by one icon's worth there.
|
||
const icons = [];
|
||
for (const [cls, n] of Object.entries(def.treasure || {})) for (let i = 0; i < n; i++) icons.push(cls);
|
||
const isz = Math.max(6, w / 22);
|
||
const pad = w > 200 ? isz : 0;
|
||
icons.forEach((cls, i) => {
|
||
this.drawTreasureIcon(cont, w / 2 - 12 - pad - i * (isz * 2 + 4), h / 2 - isz - 6 - pad, cls, isz);
|
||
});
|
||
|
||
if (opts.showText && def.text) {
|
||
const boxTop = -h / 2 + plateH + 12 + artH;
|
||
// Leave room below the box for the damage badge / treasure icons row
|
||
// (the badge is the taller of the two), so the text never covers them.
|
||
const bottomReserve = br * 2 + 12;
|
||
const boxH = h / 2 - boxTop - bottomReserve;
|
||
const tg = this.add.graphics();
|
||
tg.fillStyle(C.parchment, 1); tg.fillRoundedRect(-w / 2 + 7, boxTop, w - 14, boxH, 3);
|
||
cont.add(tg);
|
||
cont.add(this.add.text(0, boxTop + boxH / 2, def.text, {
|
||
fontFamily: '"Julius Sans One"', fontSize: `${Math.round(12 * fb)}px`, color: C.ink, align: 'center',
|
||
wordWrap: { width: w - 22 },
|
||
}).setOrigin(0.5));
|
||
}
|
||
if (!opts.isHoverPreview) {
|
||
// Wide enough that the art window (300x200 native) renders at ~1:1
|
||
// instead of being downscaled — the rules text also gets more room
|
||
// to clear the damage badge / treasure icons row without overlapping.
|
||
const previewW = 344;
|
||
opts._deepDiveInfo = { kind: 'room', inst, previewW };
|
||
opts._hoverBuild = (parent) => {
|
||
this.makeRoomCard(0, 0, inst, previewW, previewW / CARD_ASPECT.room, { showText: true, isHoverPreview: true, parent });
|
||
return { w: previewW, h: previewW / CARD_ASPECT.room };
|
||
};
|
||
}
|
||
this.finishCard(cont, w, h, opts);
|
||
return cont;
|
||
}
|
||
|
||
makeSpellCard(x, y, inst, w, h, opts = {}) {
|
||
({ w, h } = this.fitCardBox(w, h, CARD_ASPECT.spell));
|
||
const fb = opts.isHoverPreview ? 1.6 : 1; // bump fixed-size text in the hover-zoom popup
|
||
const def = spellDef(inst);
|
||
const cont = this.add.container(x, y);
|
||
const g = this.add.graphics();
|
||
g.fillStyle(C.cardBg, 1); g.fillRoundedRect(-w / 2, -h / 2, w, h, 6);
|
||
g.lineStyle(Math.max(2, w / 45), opts.selected ? C.gold : C.spellEdge, 1);
|
||
g.strokeRoundedRect(-w / 2, -h / 2, w, h, 6);
|
||
const plateH = Math.max(15, h * 0.15);
|
||
g.fillStyle(C.spellPlate, 1); g.fillRoundedRect(-w / 2 + 5, -h / 2 + 5, w - 10, plateH, 3);
|
||
const artH = h * 0.36;
|
||
g.fillStyle(0x201640, 1); g.fillRect(-w / 2 + 7, -h / 2 + plateH + 8, w - 14, artH);
|
||
cont.add(g);
|
||
const art = this.artFor('spell', inst.id);
|
||
const artCY = -h / 2 + plateH + 8 + artH / 2;
|
||
if (art) {
|
||
const img = this.add.image(0, artCY, art.key, art.frame);
|
||
img.setScale(Math.min((w - 14) / Math.max(img.width, 1), artH / Math.max(img.height, 1)));
|
||
cont.add(img);
|
||
} else {
|
||
cont.add(this.add.text(0, artCY, '✦', { fontSize: `${Math.round(artH * 0.55)}px`, color: '#8f6fd8' }).setOrigin(0.5));
|
||
}
|
||
cont.add(this.add.text(0, -h / 2 + 5 + plateH / 2, def.name, {
|
||
fontFamily: 'Righteous', fontSize: `${Math.max(9, Math.round(w / 8.5))}px`, color: '#f2ead8',
|
||
}).setOrigin(0.5).setScale(Math.min(1, (w - 14) / Math.max(1, def.name.length * (w / 14)))));
|
||
const phase = def.phase === 'both' ? 'BUILD · ADV' : def.phase.toUpperCase();
|
||
cont.add(this.add.text(0, -h / 2 + plateH + artH + 16, phase, {
|
||
fontFamily: '"Julius Sans One"', fontSize: `${Math.round(10 * fb)}px`, color: C.spellPhaseDarkHex,
|
||
}).setOrigin(0.5));
|
||
const boxTop = -h / 2 + plateH + artH + 26;
|
||
const tg = this.add.graphics();
|
||
tg.fillStyle(C.parchment, 1); tg.fillRoundedRect(-w / 2 + 7, boxTop, w - 14, h / 2 - boxTop - 8, 3);
|
||
cont.add(tg);
|
||
cont.add(this.add.text(0, boxTop + (h / 2 - boxTop - 8) / 2, def.text, {
|
||
fontFamily: '"Julius Sans One"', fontSize: `${Math.round(11 * fb)}px`, color: C.ink, align: 'center',
|
||
wordWrap: { width: w - 20 },
|
||
}).setOrigin(0.5));
|
||
if (!opts.isHoverPreview) {
|
||
// Wide enough that the art window (300x160 native) renders at ~1:1.
|
||
const previewW = 322;
|
||
opts._deepDiveInfo = { kind: 'spell', inst, previewW };
|
||
opts._hoverBuild = (parent) => {
|
||
this.makeSpellCard(0, 0, inst, previewW, previewW / CARD_ASPECT.spell, { isHoverPreview: true, parent });
|
||
return { w: previewW, h: previewW / CARD_ASPECT.spell };
|
||
};
|
||
}
|
||
this.finishCard(cont, w, h, opts);
|
||
return cont;
|
||
}
|
||
|
||
makeHeroCard(x, y, hero, w, h, opts = {}) {
|
||
({ w, h } = this.fitCardBox(w, h, CARD_ASPECT.hero));
|
||
const fb = opts.isHoverPreview ? 1.6 : 1; // bump fixed-size text in the hover-zoom popup
|
||
const def = heroDef(hero);
|
||
const info = CLASS_INFO[def.cls] || { color: 0x888888, label: 'Wanderer' };
|
||
const cont = this.add.container(x, y);
|
||
const g = this.add.graphics();
|
||
g.fillStyle(C.cardBg, 1); g.fillRoundedRect(-w / 2, -h / 2, w, h, 6);
|
||
g.lineStyle(Math.max(2, w / 40), opts.selected ? C.gold : info.color, 1);
|
||
g.strokeRoundedRect(-w / 2, -h / 2, w, h, 6);
|
||
if (def.epic) { g.lineStyle(2, C.gold, 1); g.strokeRoundedRect(-w / 2 + 4, -h / 2 + 4, w - 8, h - 8, 4); }
|
||
const artH = h * 0.52;
|
||
g.fillStyle(C.heroWindow, 1); g.fillRect(-w / 2 + 6, -h / 2 + 6, w - 12, artH);
|
||
// class banner
|
||
g.fillStyle(info.color, 1); g.fillRoundedRect(-w / 2 + 6, -h / 2 + artH + 10, w - 12, 16, 3);
|
||
cont.add(g);
|
||
const art = this.artFor('hero', hero.id);
|
||
if (art) {
|
||
const img = this.add.image(0, -h / 2 + 6 + artH / 2, art.key, art.frame);
|
||
img.setScale(Math.min((w - 12) / Math.max(img.width, 1), artH / Math.max(img.height, 1)));
|
||
cont.add(img);
|
||
} else {
|
||
const glyph = def.fool ? '🃏' : def.cls === 'fighter' ? '🛡' : def.cls === 'mage' ? '🔮' : def.cls === 'thief' ? '🗝' : '📿';
|
||
cont.add(this.add.text(0, -h / 2 + 6 + artH / 2, glyph, { fontSize: `${Math.round(artH * 0.42)}px` }).setOrigin(0.5).setAlpha(0.85));
|
||
}
|
||
if (def.epic) {
|
||
cont.add(this.add.text(0, -h / 2 + 14, '★ EPIC', { fontFamily: 'Righteous', fontSize: `${Math.round(11 * fb)}px`, color: C.goldHex }).setOrigin(0.5));
|
||
}
|
||
cont.add(this.add.text(0, -h / 2 + artH + 18, (def.fool ? 'THE FOOL' : info.label.toUpperCase()), {
|
||
fontFamily: 'Righteous', fontSize: `${Math.round(11 * fb)}px`, color: '#f2ead8',
|
||
}).setOrigin(0.5));
|
||
cont.add(this.add.text(0, -h / 2 + artH + 38, def.name, {
|
||
fontFamily: '"Julius Sans One"', fontSize: `${Math.round(11 * fb)}px`, color: C.ink, align: 'center',
|
||
wordWrap: { width: w - 12 },
|
||
}).setOrigin(0.5));
|
||
// hp heart + soul value
|
||
const hy = h / 2 - 16;
|
||
this.drawHeartIcon(cont, -w / 2 + 21, hy + 1, 24);
|
||
// Stashed on the container so the adventure battle modal can drive a
|
||
// live numeric tween on it during an HP-drain animation.
|
||
cont.hpText = this.add.text(-w / 2 + 21, hy + 1, `${hero.hp}`, {
|
||
fontFamily: 'Righteous', fontSize: '13px', color: '#fff',
|
||
}).setOrigin(0.5);
|
||
cont.add(cont.hpText);
|
||
const souls = heroSouls(def);
|
||
this.drawSoulIcon(cont, w / 2 - 18, hy + 2, 9);
|
||
cont.add(this.add.text(w / 2 - 18, hy + 2, `${souls}`, {
|
||
fontFamily: 'Righteous', fontSize: '12px', color: '#2a2118',
|
||
}).setOrigin(0.5));
|
||
if (!opts.isHoverPreview) {
|
||
// Wide enough that the art window (300x225 native) renders at ~1:1.
|
||
const previewW = 314;
|
||
opts._deepDiveInfo = { kind: 'hero', hero, previewW };
|
||
opts._hoverBuild = (parent) => {
|
||
this.makeHeroCard(0, 0, hero, previewW, previewW / CARD_ASPECT.hero, { isHoverPreview: true, parent });
|
||
return { w: previewW, h: previewW / CARD_ASPECT.hero };
|
||
};
|
||
}
|
||
this.finishCard(cont, w, h, opts);
|
||
return cont;
|
||
}
|
||
|
||
makeBossCard(x, y, bossId, w, h, opts = {}) {
|
||
({ w, h } = this.fitCardBox(w, h, CARD_ASPECT.boss));
|
||
const fb = opts.isHoverPreview ? 1.6 : 1; // bump fixed-size text in the hover-zoom popup
|
||
const def = BOSSES[bossId];
|
||
const cont = this.add.container(x, y);
|
||
const g = this.add.graphics();
|
||
g.fillStyle(C.cardBg, 1); g.fillRoundedRect(-w / 2, -h / 2, w, h, 7);
|
||
g.lineStyle(Math.max(2.5, w / 40), C.bossEdge, 1); g.strokeRoundedRect(-w / 2, -h / 2, w, h, 7);
|
||
g.lineStyle(1.5, C.gold, 0.7); g.strokeRoundedRect(-w / 2 + 4, -h / 2 + 4, w - 8, h - 8, 5);
|
||
const artH = h * (opts.showText ? 0.44 : 0.6);
|
||
g.fillStyle(0x0d0a12, 1); g.fillRect(-w / 2 + 7, -h / 2 + 30, w - 14, artH);
|
||
cont.add(g);
|
||
const art = this.artFor('boss', bossId);
|
||
if (art) {
|
||
const img = this.add.image(0, -h / 2 + 30 + artH / 2, art.key, art.frame);
|
||
img.setScale(Math.min((w - 14) / Math.max(img.width, 1), artH / Math.max(img.height, 1)));
|
||
cont.add(img);
|
||
} else {
|
||
cont.add(this.add.text(0, -h / 2 + 30 + artH / 2, '☠', { fontSize: `${Math.round(artH * 0.5)}px`, color: '#8c1f28' }).setOrigin(0.5));
|
||
}
|
||
cont.add(this.add.text(0, -h / 2 + 16, def.name, {
|
||
fontFamily: 'Righteous', fontSize: `${Math.max(11, Math.round(w / 10))}px`, color: C.goldDarkHex,
|
||
}).setOrigin(0.5).setScale(Math.min(1, (w - 12) / Math.max(1, def.name.length * (w / 16)))));
|
||
const iy = -h / 2 + 30 + artH + 14;
|
||
cont.add(this.add.text(-w / 2 + 10, iy, `${def.xp} XP`, {
|
||
fontFamily: 'Righteous', fontSize: `${Math.round(13 * fb)}px`, color: C.xpDarkHex,
|
||
}).setOrigin(0, 0.5));
|
||
this.drawTreasureIcon(cont, w / 2 - 18, iy, def.treasure, 9);
|
||
if (opts.showText) {
|
||
const boxTop = iy + 12;
|
||
const tg = this.add.graphics();
|
||
tg.fillStyle(C.parchment, 1); tg.fillRoundedRect(-w / 2 + 7, boxTop, w - 14, h / 2 - boxTop - 8, 3);
|
||
cont.add(tg);
|
||
cont.add(this.add.text(0, boxTop + (h / 2 - boxTop - 8) / 2, def.text, {
|
||
fontFamily: '"Julius Sans One"', fontSize: `${Math.round(11 * fb)}px`, color: C.ink, align: 'center',
|
||
wordWrap: { width: w - 20 },
|
||
}).setOrigin(0.5));
|
||
}
|
||
if (!opts.isHoverPreview) {
|
||
// Wide enough that the art window (300x275 native, per sprites.md)
|
||
// renders at ~1:1 once dungeonboss-bosses.png is dropped in.
|
||
const previewW = 440;
|
||
opts._deepDiveInfo = { kind: 'boss', bossId, previewW };
|
||
opts._hoverBuild = (parent) => {
|
||
this.makeBossCard(0, 0, bossId, previewW, previewW / CARD_ASPECT.boss, { showText: true, isHoverPreview: true, parent });
|
||
return { w: previewW, h: previewW / CARD_ASPECT.boss };
|
||
};
|
||
}
|
||
this.finishCard(cont, w, h, opts);
|
||
return cont;
|
||
}
|
||
|
||
makeCardBack(x, y, w, h, parent) {
|
||
const cont = this.add.container(x, y);
|
||
const g = this.add.graphics();
|
||
g.fillStyle(0x241a2e, 1); g.fillRoundedRect(-w / 2, -h / 2, w, h, 6);
|
||
g.lineStyle(2, 0x4a3a5c, 1); g.strokeRoundedRect(-w / 2, -h / 2, w, h, 6);
|
||
g.lineStyle(1, 0x4a3a5c, 0.6); g.strokeRoundedRect(-w / 2 + 5, -h / 2 + 5, w - 10, h - 10, 4);
|
||
cont.add(g);
|
||
cont.add(this.add.text(0, 0, '✦', { fontSize: `${Math.round(h * 0.3)}px`, color: '#5c4a70' }).setOrigin(0.5));
|
||
(parent || this.boardLayer).add(cont);
|
||
return cont;
|
||
}
|
||
|
||
// Small "how many are left in this deck" pile — two offset shadow cards
|
||
// behind a top card, whose face uses deckBackSheet art if supplied
|
||
// (see dungeonboss-artwork.json) or a procedural glyph-per-deck fallback.
|
||
drawDeckPile(x, y, w, h, kind, count, parent) {
|
||
const cont = this.add.container(x, y);
|
||
for (let i = 2; i >= 1; i--) {
|
||
const g = this.add.graphics();
|
||
g.fillStyle(0x1a1420, 1); g.fillRoundedRect(-w / 2 + i * 3, -h / 2 + i * 3, w, h, 5);
|
||
g.lineStyle(1.5, 0x4a3a5c, 0.7); g.strokeRoundedRect(-w / 2 + i * 3, -h / 2 + i * 3, w, h, 5);
|
||
cont.add(g);
|
||
}
|
||
this.makeDeckBackFace(0, 0, w, h, kind, cont);
|
||
if (count <= 0) {
|
||
cont.add(this.add.text(0, 0, '✕', { fontSize: `${Math.round(h * 0.5)}px`, color: '#c0392b' }).setOrigin(0.5));
|
||
cont.setAlpha(0.45);
|
||
}
|
||
(parent || this.boardLayer).add(cont);
|
||
return cont;
|
||
}
|
||
|
||
// The single card-back face (art if supplied, else a procedural
|
||
// plate+glyph), shared by the deck-pile display and the draw-flight
|
||
// animation so both show the same back design.
|
||
makeDeckBackFace(x, y, w, h, kind, parent) {
|
||
const cont = this.add.container(x, y);
|
||
const art = this.artFor('deckBack', kind);
|
||
if (art) {
|
||
cont.add(this.add.image(0, 0, art.key, art.frame).setDisplaySize(w, h));
|
||
const b = this.add.graphics();
|
||
b.lineStyle(2, 0x4a3a5c, 1); b.strokeRoundedRect(-w / 2, -h / 2, w, h, 5);
|
||
cont.add(b);
|
||
} else {
|
||
const g = this.add.graphics();
|
||
g.fillStyle(0x241a2e, 1); g.fillRoundedRect(-w / 2, -h / 2, w, h, 5);
|
||
g.lineStyle(2, 0x4a3a5c, 1); g.strokeRoundedRect(-w / 2, -h / 2, w, h, 5);
|
||
g.lineStyle(1, 0x4a3a5c, 0.6); g.strokeRoundedRect(-w / 2 + 4, -h / 2 + 4, w - 8, h - 8, 3);
|
||
cont.add(g);
|
||
const glyph = { room: '⌂', spell: '✦', hero: '⚔', epic: '♛' }[kind] || '✦';
|
||
cont.add(this.add.text(0, 0, glyph, { fontSize: `${Math.round(h * 0.34)}px`, color: '#5c4a70' }).setOrigin(0.5));
|
||
}
|
||
(parent || this.boardLayer).add(cont);
|
||
return cont;
|
||
}
|
||
|
||
// Flies one card from its deck pile to the center of the screen at full
|
||
// size, flips it face-up there, then shrinks it into its resting spot in
|
||
// the hand. Used both for the initial deal and for any later draw. The
|
||
// container is built once at full size and only ever scaled (never
|
||
// redrawn), so the back/front art stays crisp through every phase.
|
||
// onComplete receives the landed container — it is NOT auto-destroyed,
|
||
// since during the initial deal it needs to keep showing (as the real
|
||
// hand render is suppressed until every card has landed); callers that
|
||
// don't need that (e.g. a single mid-game draw, where the real card is
|
||
// already rendered underneath) should destroy it themselves.
|
||
flyCardFromDeck(kind, inst, targetX, targetY, targetW, onComplete) {
|
||
const pile = DECK_PILE_POS[kind];
|
||
const { w: fw, h: fh } = this.fitCardBox(DRAW_FULL_W[kind], 0, CARD_ASPECT[kind]);
|
||
const cont = this.add.container(pile.x, pile.y).setScale(pile.w / fw);
|
||
this.fxLayer.add(cont);
|
||
const back = this.makeDeckBackFace(0, 0, fw, fh, kind, cont);
|
||
this.sfx(SFX.CARD_DEAL);
|
||
this.tweens.add({
|
||
targets: cont, x: GAME_WIDTH / 2, y: GAME_HEIGHT / 2 - 60, scale: 1,
|
||
duration: 300, ease: 'Cubic.easeOut',
|
||
onComplete: () => {
|
||
this.tweens.add({
|
||
targets: cont, scaleX: 0, duration: 110, ease: 'Sine.easeIn',
|
||
onComplete: () => {
|
||
back.destroy();
|
||
this.sfx(SFX.CARD_SHOW);
|
||
if (kind === 'room') this.makeRoomCard(0, 0, inst, fw, fh, { parent: cont, showText: true, hover: false, noHoverPreview: true });
|
||
else this.makeSpellCard(0, 0, inst, fw, fh, { parent: cont, hover: false, noHoverPreview: true });
|
||
this.tweens.add({
|
||
targets: cont, scaleX: 1, duration: 110, ease: 'Sine.easeOut',
|
||
onComplete: () => {
|
||
this.time.delayedCall(1200, () => {
|
||
const handScale = targetW / fw;
|
||
this.tweens.add({
|
||
targets: cont, x: targetX, y: targetY, scale: handScale,
|
||
duration: 280, ease: 'Cubic.easeIn',
|
||
onComplete: () => onComplete?.(cont),
|
||
});
|
||
});
|
||
},
|
||
});
|
||
},
|
||
});
|
||
},
|
||
});
|
||
}
|
||
|
||
// Left-side "deck piles" area: small representations of the four draw
|
||
// decks with remaining counts, sitting in the gap between the deck-count
|
||
// text (above) and the player portrait cluster (below).
|
||
renderDeckPiles() {
|
||
const gs = this.gs;
|
||
const piles = [
|
||
{ kind: 'room', label: 'Room Deck', count: gs.decks.rooms.length },
|
||
{ kind: 'spell', label: 'Spell Deck', count: gs.decks.spells.length },
|
||
{ kind: 'hero', label: 'Hero', count: gs.decks.heroes.length },
|
||
{ kind: 'epic', label: 'Epic Hero', count: gs.decks.epics.length },
|
||
];
|
||
const x = 60, startY = 520, rowH = 80, w = 46, h = 64;
|
||
piles.forEach((pile, i) => {
|
||
const y = startY + i * rowH;
|
||
this.drawDeckPile(x, y, w, h, pile.kind, pile.count, this.boardLayer);
|
||
this.boardLayer.add(this.add.text(x + w / 2 + 14, y - 9, pile.label, {
|
||
fontFamily: '"Julius Sans One"', fontSize: '14px', color: '#c9bfae',
|
||
}).setOrigin(0, 0.5));
|
||
this.boardLayer.add(this.add.text(x + w / 2 + 14, y + 11, `${pile.count} left`, {
|
||
fontFamily: '"Julius Sans One"', fontSize: '12px', color: '#9e9080',
|
||
}).setOrigin(0, 0.5));
|
||
});
|
||
}
|
||
|
||
finishCard(cont, w, h, opts) {
|
||
if (opts.deactivated) {
|
||
const ov = this.add.graphics();
|
||
ov.fillStyle(C.frozen, 0.28); ov.fillRoundedRect(-w / 2, -h / 2, w, h, 6);
|
||
cont.add(ov);
|
||
cont.add(this.add.text(0, 0, '❄', { fontSize: `${Math.round(h * 0.3)}px`, color: '#d8f0fa' }).setOrigin(0.5).setAlpha(0.9));
|
||
}
|
||
if (opts.highlight) {
|
||
const hl = this.add.graphics();
|
||
hl.lineStyle(3, C.gold, 1); hl.strokeRoundedRect(-w / 2 - 4, -h / 2 - 4, w + 8, h + 8, 8);
|
||
cont.add(hl);
|
||
this.tweens.add({ targets: hl, alpha: 0.35, duration: 480, yoyo: true, repeat: -1 });
|
||
}
|
||
const wantHoverPreview = opts._hoverBuild && !opts.noHoverPreview;
|
||
if (opts.onClick || wantHoverPreview || opts.draggable) {
|
||
cont.setSize(w, h);
|
||
cont.setInteractive({ useHandCursor: !!(opts.onClick || opts.draggable) });
|
||
if (opts.draggable) {
|
||
// Click vs. drag is disambiguated on release: if the pointer never
|
||
// moved the card, treat it as a click (onClick); otherwise resolve
|
||
// the drop (onDrop), which snaps back via a full renderAll() when
|
||
// the caller decides nothing actually changed.
|
||
this.input.setDraggable(cont);
|
||
let moved = false;
|
||
cont.on('dragstart', () => {
|
||
if (this.busy) return;
|
||
moved = false;
|
||
(opts.parent || this.boardLayer).bringToTop(cont);
|
||
if (opts.onDragStart) opts.onDragStart();
|
||
});
|
||
cont.on('drag', (pointer, dragX, dragY) => {
|
||
if (this.busy) return;
|
||
if (!moved) {
|
||
// Actual dragging just began — drop the hover-zoom preview (or
|
||
// its pending timer) so it doesn't sit over the drop zone, and
|
||
// keep it from reopening on this card while it's under the
|
||
// pointer for the rest of the drag (see attachHover).
|
||
if (this.hoverTimer) { this.hoverTimer.remove(); this.hoverTimer = null; }
|
||
if (this.deepDiveTimer) { this.deepDiveTimer.remove(); this.deepDiveTimer = null; }
|
||
this.hideHover();
|
||
this._hoverSuppressCont = cont;
|
||
}
|
||
moved = true;
|
||
cont.x = dragX; cont.y = dragY;
|
||
});
|
||
cont.on('dragend', () => {
|
||
if (this.busy) return;
|
||
if (this._hoverSuppressCont === cont) this._hoverSuppressCont = null;
|
||
if (!moved) { opts.onClick && opts.onClick(); return; }
|
||
if (opts.onDrop) opts.onDrop(cont.x, cont.y);
|
||
});
|
||
} else if (opts.onClick) {
|
||
if (opts.hover !== false) {
|
||
const baseY = cont.y;
|
||
cont.on('pointerover', () => { if (!this.busy) this.tweens.add({ targets: cont, y: baseY - 14, duration: 100 }); });
|
||
cont.on('pointerout', () => this.tweens.add({ targets: cont, y: baseY, duration: 100 }));
|
||
}
|
||
cont.on('pointerdown', () => { if (!this.busy) opts.onClick(); });
|
||
}
|
||
if (wantHoverPreview) this.attachHover(cont, opts._hoverBuild, opts._deepDiveInfo, opts);
|
||
}
|
||
(opts.parent || this.boardLayer).add(cont);
|
||
}
|
||
|
||
// ── Hover-to-zoom card preview ───────────────────────────────────────────────
|
||
buildHoverPopup() {
|
||
this.hoverPopup = this.add.container(-9999, -9999).setDepth(DEPTH.hover).setVisible(false);
|
||
this._hoverDragCtx = null; // { cont, opts } of the real card, set only while it's draggable
|
||
// A draggable source card's popup can be grabbed directly — pressing and
|
||
// holding it hands off into the same manual drag path a native card drag
|
||
// uses (see beginProxyDrag).
|
||
this.hoverPopup.on('pointerdown', () => {
|
||
if (this.busy || !this._hoverDragCtx) return;
|
||
this.beginProxyDrag(this._hoverDragCtx);
|
||
});
|
||
}
|
||
|
||
attachHover(hitObj, buildFn, deepDiveInfo, opts) {
|
||
hitObj.on('pointerover', () => {
|
||
// A card being dragged (natively, or handed off from its own popup/
|
||
// deep-dive) gets repositioned under the pointer, which otherwise
|
||
// reads as a fresh "pointer entered this object" and would reopen the
|
||
// popup mid-drag — suppressed until it's dropped (see beginProxyDrag
|
||
// and finishCard's draggable branch).
|
||
if (this._hoverSuppressCont === hitObj) return;
|
||
if (this.hoverTimer) this.hoverTimer.remove();
|
||
if (this.deepDiveTimer) { this.deepDiveTimer.remove(); this.deepDiveTimer = null; }
|
||
this.hoverTimer = this.time.delayedCall(500, () => {
|
||
this.showHover(buildFn, hitObj, opts);
|
||
if (deepDiveInfo && DEEPDIVE_ZONES[deepDiveInfo.kind]) {
|
||
this.deepDiveTimer = this.time.delayedCall(1000, () => this.openDeepDive(deepDiveInfo, hitObj, opts));
|
||
}
|
||
});
|
||
});
|
||
hitObj.on('pointerout', () => {
|
||
if (this.hoverTimer) { this.hoverTimer.remove(); this.hoverTimer = null; }
|
||
if (this.deepDiveTimer) { this.deepDiveTimer.remove(); this.deepDiveTimer = null; }
|
||
this.hideHover();
|
||
});
|
||
}
|
||
|
||
showHover(buildFn, sourceCont, opts) {
|
||
this.hoverPopup.removeAll(true);
|
||
const { w, h } = buildFn(this.hoverPopup);
|
||
const shadow = this.add.graphics();
|
||
shadow.fillStyle(0x000000, 0.45);
|
||
shadow.fillRoundedRect(-w / 2 - 8, -h / 2 - 8, w + 16, h + 16, 14);
|
||
this.hoverPopup.addAt(shadow, 0);
|
||
this.hoverPopup.setData('w', w);
|
||
this.hoverPopup.setData('h', h);
|
||
this.hoverVisible = true;
|
||
this.hoverPopup.setVisible(true);
|
||
// If the card being previewed is a draggable source card, the popup
|
||
// itself becomes grabbable — refresh its hit area to match this card's
|
||
// size (it's a reused container, so a stale hit area from a previous,
|
||
// differently-sized card would otherwise linger). Ordinary previews stay
|
||
// non-interactive, same as before, so clicks still pass through to
|
||
// whatever's underneath rather than being swallowed for no reason.
|
||
this._hoverDragCtx = (opts && opts.draggable) ? { cont: sourceCont, opts } : null;
|
||
if (this._hoverDragCtx) {
|
||
this.hoverPopup.setInteractive({
|
||
hitArea: new Phaser.Geom.Rectangle(-w / 2, -h / 2, w, h),
|
||
hitAreaCallback: Phaser.Geom.Rectangle.Contains,
|
||
useHandCursor: true,
|
||
});
|
||
} else if (this.hoverPopup.input) {
|
||
this.hoverPopup.disableInteractive();
|
||
}
|
||
// Opponent portraits use a real DOM <video>, which always renders above
|
||
// canvas content no matter its Phaser depth — hide/pause them so they
|
||
// can't sit on top of the popup.
|
||
this._oppPortraits?.forEach((p) => p.setVideoVisible(false));
|
||
const p = this.lastPointer ?? { x: GAME_WIDTH / 2, y: GAME_HEIGHT / 2 };
|
||
this.positionHover(p.x, p.y);
|
||
}
|
||
|
||
positionHover(px, py) {
|
||
const w = this.hoverPopup.getData('w') ?? 300;
|
||
const h = this.hoverPopup.getData('h') ?? 430;
|
||
const x = Phaser.Math.Clamp(px + w / 2 + 24, w / 2 + 8, GAME_WIDTH - w / 2 - 8);
|
||
const y = Phaser.Math.Clamp(py, h / 2 + 8, GAME_HEIGHT - h / 2 - 8);
|
||
this.hoverPopup.setPosition(x, y);
|
||
}
|
||
|
||
hideHover() {
|
||
this.hoverVisible = false;
|
||
this._hoverDragCtx = null;
|
||
this.hoverPopup.setVisible(false).setPosition(-9999, -9999);
|
||
this._oppPortraits?.forEach((p) => p.setVideoVisible(true));
|
||
}
|
||
|
||
// Manually drives a drag for the REAL card (`ctx.cont`) starting from a
|
||
// pointerdown that landed on a stand-in (the hover popup or the deep-dive
|
||
// zone) instead of the card itself — Phaser's native drag plugin only
|
||
// tracks objects pressed directly, so this reimplements the same
|
||
// press-hold-move-release lifecycle finishCard's draggable branch uses,
|
||
// by hand, via scene-level pointer events.
|
||
beginProxyDrag(ctx) {
|
||
const { cont, opts } = ctx;
|
||
let moved = false;
|
||
let active = true;
|
||
const onMove = (p) => {
|
||
if (!active || !cont.scene) return;
|
||
if (!moved) {
|
||
moved = true;
|
||
// Hand off from whichever stand-in is showing to the real card.
|
||
this.hideHover();
|
||
this.forceCloseDeepDive();
|
||
this._hoverSuppressCont = cont;
|
||
if (opts.onDragStart) opts.onDragStart();
|
||
(opts.parent || this.boardLayer).bringToTop(cont);
|
||
}
|
||
cont.x = p.x; cont.y = p.y;
|
||
};
|
||
const onUp = () => {
|
||
active = false;
|
||
this.input.off('pointermove', onMove);
|
||
this.input.off('pointerup', onUp);
|
||
if (this._hoverSuppressCont === cont) this._hoverSuppressCont = null;
|
||
if (moved && cont.scene && opts.onDrop) opts.onDrop(cont.x, cont.y);
|
||
};
|
||
this.input.on('pointermove', onMove);
|
||
this.input.on('pointerup', onUp);
|
||
}
|
||
|
||
// ── layout helpers ──────────────────────────────────────────────────────────
|
||
humanSlotRect(idx) {
|
||
// Boss at the right; slot 0 sits beside it, entrance grows leftward.
|
||
// Height is derived from the room card's own portrait aspect so badges/
|
||
// labels positioned off this rect (below) line up with the actual card.
|
||
const w = 196;
|
||
return { x: 1500 - idx * 212, y: 700, w, h: w / CARD_ASPECT.room };
|
||
}
|
||
townPos(i, n) {
|
||
const pitch = Math.min(124, 1100 / Math.max(1, n));
|
||
return { x: GAME_WIDTH / 2 - ((n - 1) * pitch) / 2 + i * pitch, y: 458 };
|
||
}
|
||
|
||
// ── full re-render ──────────────────────────────────────────────────────────
|
||
renderAll() {
|
||
if (this.hoverTimer) { this.hoverTimer.remove(); this.hoverTimer = null; }
|
||
this.hideHover();
|
||
this.boardLayer.removeAll(true);
|
||
this.townLayer.removeAll(true);
|
||
this.handLayer.removeAll(true);
|
||
this.discardZoneLayer.removeAll(true);
|
||
this._heroTokens.clear();
|
||
this._slotRects.clear();
|
||
this._handSprites.clear();
|
||
this._soulsPos.clear();
|
||
this._discardZoneRect = null;
|
||
const gs = this.gs;
|
||
if (!gs) return;
|
||
|
||
this.renderOpponents();
|
||
this.renderTown();
|
||
this.renderHumanBoard();
|
||
this.renderHand();
|
||
this.renderDiscardZone();
|
||
this.renderDeckPiles();
|
||
this.deckText.setText([
|
||
`Rooms ${gs.decks.rooms.length}`,
|
||
`Spells ${gs.decks.spells.length}`,
|
||
`Heroes ${gs.decks.heroes.length}`,
|
||
`Epics ${gs.decks.epics.length}${gs.epicsActive ? ' ⚡' : ''}`,
|
||
`Round ${gs.round}`,
|
||
].join('\n'));
|
||
}
|
||
|
||
// Re-renders just the board (opponents/town/human board) — used while
|
||
// dragging a room card so the legal-slot pulse can update immediately
|
||
// without touching handLayer (see onBuildCardDragStart).
|
||
renderBoardOnly() {
|
||
if (!this.gs) return;
|
||
this.boardLayer.removeAll(true);
|
||
this.townLayer.removeAll(true);
|
||
this._heroTokens.clear();
|
||
this._slotRects.clear();
|
||
this._soulsPos.clear();
|
||
this.renderOpponents();
|
||
this.renderTown();
|
||
this.renderHumanBoard();
|
||
}
|
||
|
||
renderOpponents() {
|
||
const centers = this.oppPanelCenters();
|
||
for (let i = 0; i < this.opponents.length; i++) {
|
||
const seat = i + 1;
|
||
const p = this.gs.players[seat];
|
||
const { x, y } = centers[i];
|
||
const pw = 560, ph = 224;
|
||
const g = this.add.graphics();
|
||
g.fillStyle(0xe4ded2, p.alive ? 0.92 : 0.5);
|
||
g.fillRoundedRect(x - pw / 2, y - ph / 2, pw, ph, 10);
|
||
g.lineStyle(2, p.alive ? 0xb8b0a0 : 0xcac4b8, 1);
|
||
g.strokeRoundedRect(x - pw / 2, y - ph / 2, pw, ph, 10);
|
||
this.boardLayer.add(g);
|
||
const nameCol = p.alive ? '#2c2620' : '#8f887a';
|
||
this.boardLayer.add(this.add.text(x - 195, y - 62, this.opponents[i].name || `Boss ${seat}`, {
|
||
fontFamily: 'Righteous', fontSize: '18px', color: nameCol,
|
||
}).setOrigin(0.5));
|
||
if (!p.alive) {
|
||
this.boardLayer.add(this.add.text(x, y, 'DEFEATED', {
|
||
fontFamily: 'Righteous', fontSize: '34px', color: '#8c1f28',
|
||
}).setOrigin(0.5).setAngle(-8));
|
||
continue;
|
||
}
|
||
// boss mini-card at panel right (a hair bigger than the reference 88x124
|
||
// so the treasure-icon badge — sized off fixed pixel offsets, not h —
|
||
// stays inside the card's bottom edge at this small scale)
|
||
this.makeBossCard(x + 222, y - 20, p.boss.id, 102, 146, {
|
||
parent: this.boardLayer, hover: false,
|
||
onClick: () => this.showInspect('boss', p.boss.id),
|
||
});
|
||
// souls & wounds under the name
|
||
const sy = y - 20;
|
||
this.drawSoulIcon(this.boardLayer, x - 245, sy, 11);
|
||
this._soulsPos.set(seat, { x: x - 245, y: sy });
|
||
this.boardLayer.add(this.add.text(x - 228, sy, `${p.souls}/${SOULS_TO_WIN}`, {
|
||
fontFamily: 'Righteous', fontSize: '17px', color: '#7a5a10',
|
||
}).setOrigin(0, 0.5));
|
||
for (let wI = 0; wI < WOUNDS_TO_DIE; wI++) {
|
||
this.drawHeartIcon(this.boardLayer, x - 250 + wI * 22, sy + 30, 18, wI >= p.wounds);
|
||
}
|
||
this.boardLayer.add(this.add.text(x - 245, sy + 56, `✋ ${p.hand.rooms.length + p.hand.spells.length}`, {
|
||
fontFamily: '"Julius Sans One"', fontSize: '15px', color: '#6b6459',
|
||
}).setOrigin(0, 0.5));
|
||
// mini dungeon: boss-adjacent on the right, entrance leftward
|
||
// (mh derived from the room card's portrait aspect so it stays inside
|
||
// the opponent panel and badge positions below stay correctly anchored)
|
||
const mw = 68, mh = mw / CARD_ASPECT.room, pitch = 88;
|
||
for (let idx = 0; idx < p.dungeon.length; idx++) {
|
||
const sx = x + 128 - idx * pitch;
|
||
const slot = p.dungeon[idx];
|
||
this._slotRects.set(`${seat}:${idx}`, { x: sx, y: y + 62, w: mw, h: mh });
|
||
this.makeRoomCard(sx, y + 62, slot.room, mw, mh, {
|
||
parent: this.boardLayer, hover: false,
|
||
deactivated: slot.deactivated,
|
||
highlight: this.isRoomTarget(seat, idx),
|
||
onClick: () => this.onRoomClicked(seat, idx),
|
||
});
|
||
if (slot.tempDmg) this.miniBadge(sx + mw / 2 - 8, y + 62 - mh / 2 + 8, `+${slot.tempDmg}`);
|
||
}
|
||
// pending secret build
|
||
if (p.pendingBuild) this.makeCardBack(x + 128 - p.dungeon.length * pitch, y + 62, mw * 0.8, mh * 0.9, this.boardLayer);
|
||
// entrance heroes — mini cards, fanned with a slight overlap
|
||
p.entrance.forEach((hero, hi) => {
|
||
const hx = x - pw / 2 + 30 + hi * OPP_ENTRANCE_PITCH;
|
||
const hy = y + 62;
|
||
this.miniHeroCard(hx, hy, hero, OPP_ENTRANCE_W, {
|
||
parent: this.boardLayer, hover: false,
|
||
highlight: this.isHeroTarget(hero.uid),
|
||
onClick: () => this.onHeroClicked(hero.uid),
|
||
});
|
||
this._heroTokens.set(hero.uid, { x: hx, y: hy });
|
||
});
|
||
}
|
||
}
|
||
|
||
renderTown() {
|
||
const gs = this.gs;
|
||
const n = gs.town.length;
|
||
const label = this.add.text(GAME_WIDTH / 2, 368, `— TOWN ${n ? '' : '(empty)'} —`, {
|
||
fontFamily: 'Righteous', fontSize: '18px', color: '#9e9080',
|
||
}).setOrigin(0.5);
|
||
this.townLayer.add(label);
|
||
gs.town.forEach((hero, i) => {
|
||
const { x, y } = this.townPos(i, n);
|
||
this._heroTokens.set(hero.uid, { x, y });
|
||
this.makeHeroCard(x, y, hero, TOWN_HERO_W, TOWN_HERO_W / CARD_ASPECT.hero, {
|
||
parent: this.townLayer,
|
||
highlight: this.isHeroTarget(hero.uid),
|
||
onClick: () => this.onHeroClicked(hero.uid),
|
||
});
|
||
});
|
||
}
|
||
|
||
renderHumanBoard() {
|
||
const gs = this.gs;
|
||
const p = gs.players[this.humanSeat];
|
||
const seat = this.humanSeat;
|
||
// boss card
|
||
this.makeBossCard(1740, 700, p.boss.id, 168, 236, {
|
||
parent: this.boardLayer, showText: true, hover: false,
|
||
onClick: () => this.showInspect('boss', p.boss.id),
|
||
});
|
||
// souls & wounds beside the player portrait
|
||
this.drawSoulIcon(this.boardLayer, 160, 950, 13);
|
||
this._soulsPos.set(seat, { x: 160, y: 950 });
|
||
this.boardLayer.add(this.add.text(182, 950, `${p.souls}/${SOULS_TO_WIN} souls`, {
|
||
fontFamily: 'Righteous', fontSize: '20px', color: C.goldHex,
|
||
}).setOrigin(0, 0.5));
|
||
for (let wI = 0; wI < WOUNDS_TO_DIE; wI++) {
|
||
this.drawHeartIcon(this.boardLayer, 152 + wI * 26, 988, 22, wI >= p.wounds);
|
||
}
|
||
if (!p.alive) {
|
||
this.boardLayer.add(this.add.text(1060, 700, 'YOUR BOSS HAS FALLEN', {
|
||
fontFamily: 'Righteous', fontSize: '42px', color: '#8c1f28',
|
||
}).setOrigin(0.5).setAngle(-4));
|
||
return;
|
||
}
|
||
// slots: existing rooms + (in build mode) legal placement outlines
|
||
for (let idx = 0; idx < MAX_ROOMS; idx++) {
|
||
const r = this.humanSlotRect(idx);
|
||
const slot = p.dungeon[idx];
|
||
if (slot) {
|
||
this._slotRects.set(`${seat}:${idx}`, r);
|
||
this.makeRoomCard(r.x, r.y, slot.room, r.w, r.h, {
|
||
parent: this.boardLayer, hover: false,
|
||
deactivated: slot.deactivated,
|
||
highlight: this.isRoomTarget(seat, idx) || this.isBuildSlot(idx),
|
||
onClick: () => this.onRoomClicked(seat, idx),
|
||
});
|
||
if (slot.under.length) {
|
||
this.boardLayer.add(this.add.text(r.x - r.w / 2 + 10, r.y - r.h / 2 - 10, `▤ ${slot.under.length + 1}`, {
|
||
fontFamily: '"Julius Sans One"', fontSize: '13px', color: '#9e9080',
|
||
}).setOrigin(0, 0.5));
|
||
}
|
||
if (slot.tempDmg) this.miniBadge(r.x + r.w / 2 - 10, r.y - r.h / 2 + 10, `+${slot.tempDmg}`);
|
||
if (slot.armed) this.miniBadge(r.x, r.y - r.h / 2 + 10, slot.armed.type === 'ramp' ? '⚠+5' : '⚠', 0xc9962a);
|
||
// activatable badge during windows
|
||
const act = this.activatableFor(idx);
|
||
if (act) {
|
||
const b = this.add.container(r.x, r.y + r.h / 2 + 16);
|
||
const bg = this.add.graphics();
|
||
bg.fillStyle(C.gold, 1); bg.fillRoundedRect(-42, -12, 84, 24, 12);
|
||
b.add(bg);
|
||
b.add(this.add.text(0, 0, 'USE', { fontFamily: 'Righteous', fontSize: '14px', color: '#2a2118' }).setOrigin(0.5));
|
||
b.setSize(84, 24);
|
||
b.setInteractive({ useHandCursor: true });
|
||
b.on('pointerdown', () => { if (!this.busy) this.beginActivate(idx, act); });
|
||
this.boardLayer.add(b);
|
||
this.tweens.add({ targets: b, alpha: 0.6, duration: 500, yoyo: true, repeat: -1 });
|
||
}
|
||
} else if (this.isBuildSlot(idx)) {
|
||
const g = this.add.graphics();
|
||
g.lineStyle(3, C.gold, 0.9);
|
||
g.strokeRoundedRect(r.x - r.w / 2, r.y - r.h / 2, r.w, r.h, 8);
|
||
this.boardLayer.add(g);
|
||
this.tweens.add({ targets: g, alpha: 0.35, duration: 480, yoyo: true, repeat: -1 });
|
||
const z = this.add.zone(r.x, r.y, r.w, r.h).setInteractive({ useHandCursor: true });
|
||
z.on('pointerdown', () => this.onBuildSlotClicked(idx));
|
||
this.boardLayer.add(z);
|
||
} else if (idx === p.dungeon.length) {
|
||
const g = this.add.graphics();
|
||
g.lineStyle(2, 0x3a2f4d, 0.8);
|
||
g.strokeRoundedRect(r.x - r.w / 2, r.y - r.h / 2, r.w, r.h, 8);
|
||
this.boardLayer.add(g);
|
||
}
|
||
}
|
||
// queued heroes at entrance
|
||
const entR = this.humanSlotRect(Math.max(p.dungeon.length, 1) - 0.35);
|
||
p.entrance.forEach((hero, hi) => {
|
||
const hx = entR.x - 130 - hi * HUMAN_ENTRANCE_PITCH;
|
||
this.miniHeroCard(hx, 640, hero, HUMAN_ENTRANCE_W, {
|
||
parent: this.boardLayer, hover: false,
|
||
highlight: this.isHeroTarget(hero.uid),
|
||
onClick: () => this.onHeroClicked(hero.uid),
|
||
});
|
||
this._heroTokens.set(hero.uid, { x: hx, y: 640 });
|
||
});
|
||
// pending build indicator
|
||
if (p.pendingBuild) {
|
||
const r = this.humanSlotRect(p.pendingBuild.slotIdx);
|
||
this.makeCardBack(r.x, r.y - 20, r.w * 0.85, r.h * 0.9, this.boardLayer).setAlpha(0.9);
|
||
}
|
||
}
|
||
|
||
// Small "hero at the gate" card: just the portrait framed in the hero's
|
||
// class colour (gold if epic) with HP as a number underneath — used for
|
||
// every entrance/gate hero queue. Replaces the old plain numbered circle
|
||
// so a glance at a gate still shows which hero it is. Still gets the
|
||
// standard hover-to-zoom preview (see attachHover) unless suppressed.
|
||
miniHeroCard(x, y, hero, w, opts = {}) {
|
||
const h = w / CARD_ASPECT.hero;
|
||
const def = heroDef(hero);
|
||
const info = CLASS_INFO[def.cls] || { color: 0x888888 };
|
||
const cont = this.add.container(x, y);
|
||
const g = this.add.graphics();
|
||
g.fillStyle(C.cardBg, 1); g.fillRoundedRect(-w / 2, -h / 2, w, h, 4);
|
||
g.lineStyle(def.epic ? 3 : 2, def.epic ? C.gold : info.color, 1);
|
||
g.strokeRoundedRect(-w / 2, -h / 2, w, h, 4);
|
||
cont.add(g);
|
||
const art = this.artFor('hero', hero.id);
|
||
if (art) {
|
||
const img = this.add.image(0, -2, art.key, art.frame);
|
||
img.setScale(Math.min((w - 6) / Math.max(img.width, 1), (h - 6) / Math.max(img.height, 1)));
|
||
cont.add(img);
|
||
} else {
|
||
const glyph = def.fool ? '🃏' : def.cls === 'fighter' ? '🛡' : def.cls === 'mage' ? '🔮' : def.cls === 'thief' ? '🗝' : '📿';
|
||
cont.add(this.add.text(0, -2, glyph, { fontSize: `${Math.round(h * 0.5)}px` }).setOrigin(0.5).setAlpha(0.85));
|
||
}
|
||
const by = h / 2 + 12;
|
||
const bb = this.add.graphics();
|
||
bb.fillStyle(0x10141c, 1); bb.fillCircle(0, by, 11);
|
||
bb.lineStyle(1.5, def.epic ? C.gold : info.color, 1); bb.strokeCircle(0, by, 11);
|
||
cont.add(bb);
|
||
cont.add(this.add.text(0, by, `${hero.hp}`, {
|
||
fontFamily: 'Righteous', fontSize: '13px', color: '#f2ead8',
|
||
}).setOrigin(0.5));
|
||
if (!opts.noHoverPreview) {
|
||
const previewW = 314;
|
||
opts._deepDiveInfo = { kind: 'hero', hero, previewW };
|
||
opts._hoverBuild = (parent) => {
|
||
this.makeHeroCard(0, 0, hero, previewW, previewW / CARD_ASPECT.hero, { isHoverPreview: true, parent });
|
||
return { w: previewW, h: previewW / CARD_ASPECT.hero };
|
||
};
|
||
}
|
||
this.finishCard(cont, w, h + 26, opts);
|
||
return cont;
|
||
}
|
||
|
||
miniBadge(x, y, txt, color = 0x8f6fd8) {
|
||
const g = this.add.graphics();
|
||
g.fillStyle(color, 1); g.fillRoundedRect(x - 17, y - 9, 34, 18, 9);
|
||
this.boardLayer.add(g);
|
||
this.boardLayer.add(this.add.text(x, y, txt, {
|
||
fontFamily: 'Righteous', fontSize: '12px', color: '#f2ead8',
|
||
}).setOrigin(0.5));
|
||
}
|
||
|
||
// Deals the human player's starting hand (5 rooms + 2 spells, per
|
||
// newGame()) one card at a time, flying each from its deck pile to its
|
||
// real final hand slot. renderHand() is suppressed via this._dealing
|
||
// until every card has landed, so the reflow always matches where the
|
||
// flying copies land. Each landed card is kept on screen (not destroyed)
|
||
// so the hand visibly builds up card by card; once the last one lands,
|
||
// the real hand is rendered underneath and only then are the landed
|
||
// stand-ins destroyed, in the same tick, so there's no flicker.
|
||
animateInitialDeal(onDone) {
|
||
const p = this.gs.players[this.humanSeat];
|
||
const rooms = p.hand.rooms, spells = p.hand.spells;
|
||
const total = rooms.length + spells.length;
|
||
if (!total) { this._dealing = false; onDone(); return; }
|
||
const roomW = 125, spellW = 104;
|
||
const pitch = Math.min(160, 1500 / total);
|
||
const width = (total - 1) * pitch;
|
||
const baseX = GAME_WIDTH / 2 - width / 2, y = 985;
|
||
const plan = [
|
||
...rooms.map((inst, i) => ({ inst, kind: 'room', x: baseX + i * pitch, y, w: roomW })),
|
||
...spells.map((inst, i) => ({ inst, kind: 'spell', x: baseX + (rooms.length + i) * pitch, y: y - 16, w: spellW })),
|
||
];
|
||
const landed = [];
|
||
const dealNext = (i) => {
|
||
if (i >= plan.length) {
|
||
this._dealing = false;
|
||
this.renderAll();
|
||
landed.forEach((c) => c.destroy());
|
||
onDone();
|
||
return;
|
||
}
|
||
const step = plan[i];
|
||
this.flyCardFromDeck(step.kind, step.inst, step.x, step.y, step.w, (cont) => {
|
||
landed.push(cont);
|
||
dealNext(i + 1);
|
||
});
|
||
};
|
||
dealNext(0);
|
||
}
|
||
|
||
renderHand() {
|
||
if (this._dealing) return;
|
||
const p = this.gs.players[this.humanSeat];
|
||
if (!p.alive) return;
|
||
const mode = this.mode;
|
||
// While a discard is pending, cards the player has queued up move out of
|
||
// the hand row into the discard zone (see renderDiscardZone) so the zone
|
||
// visibly fills as they're picked — the hand row reflows around them.
|
||
const zoneActive = mode.type === 'discard' || mode.type === 'setupDiscard';
|
||
const buildActive = mode.type === 'build';
|
||
const inZone = (uid) => zoneActive && (mode.selected || []).includes(uid);
|
||
const rooms = p.hand.rooms.filter((c) => !inZone(c.uid));
|
||
const spells = p.hand.spells.filter((c) => !inZone(c.uid));
|
||
const total = rooms.length + spells.length;
|
||
if (!total) return;
|
||
const roomW = 125, roomH = 102, spellW = 104, spellH = 146;
|
||
const pitch = Math.min(160, 1500 / Math.max(1, total));
|
||
const width = (total - 1) * pitch;
|
||
let x = GAME_WIDTH / 2 - width / 2;
|
||
const y = 985;
|
||
for (const inst of rooms) {
|
||
const selectable = this.isHandSelectable(inst);
|
||
const draggable = (zoneActive || buildActive) && selectable;
|
||
const sp = this.makeRoomCard(x, y, inst, roomW, roomH, {
|
||
parent: this.handLayer, showText: false,
|
||
selected: this.isHandSelected(inst.uid),
|
||
highlight: selectable && zoneActive,
|
||
onClick: () => this.onHandClicked(inst),
|
||
draggable,
|
||
onDragStart: buildActive ? () => this.onBuildCardDragStart(inst) : undefined,
|
||
onDrop: zoneActive
|
||
? (dx, dy) => this.onDiscardCardDropped(inst, dx, dy)
|
||
: buildActive ? (dx, dy) => this.onBuildCardDropped(inst, dx, dy) : undefined,
|
||
});
|
||
if (!selectable && (mode.type === 'build' || zoneActive || mode.type === 'window')) sp.setAlpha(0.85);
|
||
this._handSprites.set(inst.uid, sp);
|
||
x += pitch;
|
||
}
|
||
for (const inst of spells) {
|
||
const castable = this.castableUids?.has(inst.uid);
|
||
const selectable = this.isHandSelectable(inst);
|
||
const draggable = zoneActive && selectable;
|
||
const sp = this.makeSpellCard(x, y - 16, inst, spellW, spellH, {
|
||
parent: this.handLayer,
|
||
selected: this.isHandSelected(inst.uid),
|
||
highlight: !!castable || (selectable && zoneActive),
|
||
onClick: () => this.onHandClicked(inst),
|
||
draggable,
|
||
onDrop: (dx, dy) => this.onDiscardCardDropped(inst, dx, dy),
|
||
});
|
||
this._handSprites.set(inst.uid, sp);
|
||
x += pitch;
|
||
}
|
||
}
|
||
|
||
// ── discard drop zone ────────────────────────────────────────────────────────
|
||
// Draws a slot for each card still owed during a discard/setupDiscard
|
||
// decision, centered on screen. Slots already claimed (mode.selected) show
|
||
// the actual card (draggable back out, or click to un-discard); the rest
|
||
// show an empty placeholder so the player can see how many are left.
|
||
renderDiscardZone() {
|
||
const m = this.mode;
|
||
if (m.type !== 'discard' && m.type !== 'setupDiscard') return;
|
||
const p = this.gs.players[this.humanSeat];
|
||
const n = m.n;
|
||
const availW = 1600;
|
||
let slotW = 120;
|
||
let pitch = slotW + 20;
|
||
if ((n - 1) * pitch + slotW > availW) {
|
||
slotW = Math.max(70, (availW - (n - 1) * 20) / n);
|
||
pitch = slotW + 20;
|
||
}
|
||
const slotH = slotW / CARD_ASPECT.room;
|
||
const width = (n - 1) * pitch;
|
||
const cx = GAME_WIDTH / 2, cy = GAME_HEIGHT / 2;
|
||
const padX = 36, padTop = 52, padBottom = 26;
|
||
const panelW = width + slotW + padX * 2;
|
||
const panelH = slotH + padTop + padBottom;
|
||
const px = cx - panelW / 2, py = cy - panelH / 2;
|
||
this._discardZoneRect = { x: px, y: py, w: panelW, h: panelH };
|
||
|
||
const g = this.add.graphics();
|
||
g.fillStyle(0x1a1422, 0.93); g.fillRoundedRect(px, py, panelW, panelH, 14);
|
||
g.lineStyle(3, C.gold, 0.85); g.strokeRoundedRect(px, py, panelW, panelH, 14);
|
||
this.discardZoneLayer.add(g);
|
||
|
||
const label = m.type === 'setupDiscard' ? 'Discard' : `Discard ${m.cardType}`;
|
||
this.discardZoneLayer.add(this.add.text(cx, py + 24, `${label} — ${m.selected.length}/${n}`, {
|
||
fontFamily: 'Righteous', fontSize: '20px', color: '#f2ead8',
|
||
}).setOrigin(0.5));
|
||
|
||
const x0 = cx - width / 2, sy = py + padTop + slotH / 2;
|
||
for (let i = 0; i < n; i++) {
|
||
const sx = x0 + i * pitch;
|
||
const uid = m.selected[i];
|
||
const inst = uid != null ? [...p.hand.rooms, ...p.hand.spells].find((c) => c.uid === uid) : null;
|
||
if (inst) {
|
||
const opts = {
|
||
parent: this.discardZoneLayer, showText: false, selected: true,
|
||
onClick: () => this.onHandClicked(inst),
|
||
draggable: true,
|
||
onDrop: (dx, dy) => this.onDiscardCardDropped(inst, dx, dy),
|
||
};
|
||
if (ROOMS[inst.id]) this.makeRoomCard(sx, sy, inst, slotW, slotH, opts);
|
||
else this.makeSpellCard(sx, sy, inst, slotW, slotH, opts);
|
||
} else {
|
||
const pg = this.add.graphics();
|
||
pg.lineStyle(2, C.gold, 0.4);
|
||
pg.strokeRoundedRect(sx - slotW / 2, sy - slotH / 2, slotW, slotH, 8);
|
||
this.discardZoneLayer.add(pg);
|
||
this.discardZoneLayer.add(this.add.text(sx, sy, '＋', {
|
||
fontSize: '26px', color: C.goldHex,
|
||
}).setOrigin(0.5).setAlpha(0.55));
|
||
}
|
||
}
|
||
}
|
||
|
||
pointInDiscardZone(x, y) {
|
||
const r = this._discardZoneRect;
|
||
return !!r && x >= r.x && x <= r.x + r.w && y >= r.y && y <= r.y + r.h;
|
||
}
|
||
|
||
// Dragend handler for both hand cards (dragged in to select) and zone cards
|
||
// (dragged out to un-select). If the drop actually changes which side of
|
||
// the zone boundary the card is on, toggle it via the normal click-select
|
||
// path (which selects/deselects and re-renders); otherwise just re-render
|
||
// to snap the card back to where it came from.
|
||
onDiscardCardDropped(inst, x, y) {
|
||
const wasSelected = this.isHandSelected(inst.uid);
|
||
const droppedInZone = this.pointInDiscardZone(x, y);
|
||
if (wasSelected !== droppedInZone) this.onHandClicked(inst);
|
||
else this.renderAll();
|
||
}
|
||
|
||
// ── mode / highlight queries ────────────────────────────────────────────────
|
||
isBuildSlot(idx) {
|
||
return this.mode.type === 'build' && this.mode.selectedRoom
|
||
&& this.mode.legal.some((b) => b.roomUid === this.mode.selectedRoom && b.slotIdx === idx);
|
||
}
|
||
isRoomTarget(seat, idx) {
|
||
return (this.mode.type === 'target' || this.mode.type === 'castTarget' || this.mode.type === 'activateTarget')
|
||
&& (this.mode.candidates || []).some((c) => (c.kind === 'room' && c.seat === seat && c.slotIdx === idx)
|
||
|| (c.kind === 'swap' && c.seat === seat && (c.a === idx || c.b === idx)));
|
||
}
|
||
isHeroTarget(uid) {
|
||
return (this.mode.type === 'target' || this.mode.type === 'castTarget' || this.mode.type === 'activateTarget')
|
||
&& (this.mode.candidates || []).some((c) => c.kind === 'hero' && c.uid === uid);
|
||
}
|
||
isHandSelected(uid) { return (this.mode.selected || []).includes(uid) || this.mode.selectedRoom === uid; }
|
||
isHandSelectable(inst) {
|
||
const m = this.mode;
|
||
if (m.type === 'setupDiscard' || m.type === 'discard') {
|
||
if (m.cardType === 'spell') return !!SPELLS[inst.id];
|
||
if (m.cardType === 'room') return !!ROOMS[inst.id];
|
||
return true;
|
||
}
|
||
if (m.type === 'build') return !!ROOMS[inst.id] && m.legal.some((b) => b.roomUid === inst.uid);
|
||
if (m.type === 'window') return this.castableUids?.has(inst.uid);
|
||
return false;
|
||
}
|
||
|
||
// ── pump: run engine until human input is required ─────────────────────────
|
||
pump() {
|
||
if (!this.gs || this.busy) return;
|
||
if (this.gs.gameOver) { this.onGameOver(); return; }
|
||
const d = pendingDecision(this.gs);
|
||
if (!d) return;
|
||
if (d.seat !== this.humanSeat) {
|
||
this.setPrompt(this.aiPromptFor(d));
|
||
const skill = this.opponents[d.seat - 1]?.skill ?? 3;
|
||
this.busy = true;
|
||
this.time.delayedCall(nextThinkDelay(skill), () => {
|
||
this.busy = false;
|
||
if (this.gs.gameOver) { this.onGameOver(); return; }
|
||
const nd = pendingDecision(this.gs);
|
||
if (!nd || nd.seat === this.humanSeat) { this.pump(); return; }
|
||
const choice = decide(publicView(this.gs, nd.seat), nd, skill);
|
||
this.applyDecision(nd, choice);
|
||
});
|
||
return;
|
||
}
|
||
this.enterHumanMode(d);
|
||
}
|
||
|
||
aiPromptFor(d) {
|
||
const name = this.opponents[d.seat - 1]?.name || `Boss ${d.seat}`;
|
||
switch (d.kind) {
|
||
case 'build': return `${name} is scheming a room…`;
|
||
case 'window': return `${name} is considering spells…`;
|
||
case 'react': return `${name} eyes the spell…`;
|
||
default: return `${name} is thinking…`;
|
||
}
|
||
}
|
||
|
||
applyDecision(d, choice) {
|
||
// Snapshot every seat's dungeon BEFORE the mutator runs. The adventure
|
||
// battle modal needs to know what a seat's dungeon looked like at the
|
||
// start of a walk, but by the time playEvents() sees the resulting
|
||
// events, the mutator (and any AI/engine cascade it triggers) has
|
||
// already run to completion — a trap kill may have already spliced a
|
||
// room out of gs.players[seat].dungeon, shifting every later index.
|
||
// Reading live state at that point would silently show the wrong (or a
|
||
// missing) room. This is cheap (≤MAX_ROOMS rooms × player count).
|
||
this._advDungeonSnapshot = this.gs.players.map((p) => p.dungeon.map((s) => ({
|
||
room: { id: s.room.id, uid: s.room.uid }, deactivated: s.deactivated, armed: s.armed,
|
||
})));
|
||
// Same problem, different spot: runBait() removes every baited hero from
|
||
// gs.town before emitting heroWalks, all within this SAME mutator call —
|
||
// so by the time playEvents()'s own renderAll() runs and heroWalks' fx
|
||
// reads this._heroTokens for a "from" (town) position, that hero is
|
||
// already gone from gs.town and renderTown() never gave it an entry.
|
||
// Snapshot the current (pre-mutation, still-accurate) town positions now.
|
||
this._preBaitHeroTokens = new Map(this._heroTokens);
|
||
try {
|
||
switch (d.kind) {
|
||
case 'setupDiscard': actSetupDiscard(this.gs, d.seat, choice); break;
|
||
case 'build': actBuild(this.gs, d.seat, choice); break;
|
||
case 'window': actWindow(this.gs, d.seat, choice); break;
|
||
case 'react': actReact(this.gs, d.seat, choice); break;
|
||
case 'target': actChooseTarget(this.gs, d.seat, choice); break;
|
||
case 'discard': actDiscard(this.gs, d.seat, choice); break;
|
||
case 'roomDraw': actRoomDraw(this.gs, d.seat, choice); break;
|
||
default: break;
|
||
}
|
||
} catch (err) {
|
||
// A decision the engine rejects should never soft-lock the table.
|
||
console.error('dungeonboss action rejected:', err);
|
||
this.renderAll();
|
||
this.pump();
|
||
return;
|
||
}
|
||
this.mode = { type: 'idle' };
|
||
this.castableUids = null;
|
||
this.clearActionButtons();
|
||
this.playEvents(takeEvents(this.gs));
|
||
}
|
||
|
||
// ── human decision modes ────────────────────────────────────────────────────
|
||
enterHumanMode(d) {
|
||
this.clearActionButtons();
|
||
switch (d.kind) {
|
||
case 'setupDiscard':
|
||
this.mode = { type: 'setupDiscard', selected: [], n: 2 };
|
||
this.setPrompt('Discard 2 cards — click cards, then Confirm');
|
||
this.addActionButton('Confirm', () => {
|
||
if (this.mode.selected.length === 2) this.applyDecision(d, this.mode.selected);
|
||
});
|
||
break;
|
||
case 'discard':
|
||
this.mode = { type: 'discard', selected: [], n: d.n, cardType: d.cardType };
|
||
this.setPrompt(`Discard ${d.n} ${d.cardType} card${d.n > 1 ? 's' : ''}`);
|
||
this.addActionButton('Confirm', () => {
|
||
if (this.mode.selected.length === d.n) this.applyDecision(d, this.mode.selected);
|
||
});
|
||
break;
|
||
case 'build': {
|
||
const legal = legalBuilds(this.gs, this.humanSeat);
|
||
this.mode = { type: 'build', legal, selectedRoom: null, decision: d };
|
||
if (d.setup) this.setPrompt('Build your first room — click a room card, then a slot');
|
||
else if (d.extra) this.setPrompt('Extra build! Click a room card, then a slot');
|
||
else this.setPrompt('Build a room (click card, then slot) — or Pass');
|
||
if (!d.setup || !legal.length) this.addActionButton('Pass', () => this.applyDecision(d, null));
|
||
break;
|
||
}
|
||
case 'window': {
|
||
const acts = windowActions(this.gs, this.humanSeat);
|
||
this.mode = { type: 'window', decision: d, acts };
|
||
this.castableUids = new Set(acts.spells.map((s) => s.uid));
|
||
const label = d.window === 'advStart'
|
||
? (d.advSeat === this.humanSeat ? 'Heroes charge your gate! Cast spells or Pass'
|
||
: `Heroes storm ${this.seatName(d.advSeat)} — interfere or Pass`)
|
||
: 'Spell window — cast, use a room, or Pass';
|
||
this.setPrompt(label);
|
||
this.addActionButton('Pass', () => this.applyDecision(d, { pass: true }));
|
||
break;
|
||
}
|
||
case 'react': {
|
||
this.mode = { type: 'react', decision: d };
|
||
this.showReactModal(d);
|
||
break;
|
||
}
|
||
case 'target': {
|
||
this.mode = { type: 'target', decision: d, candidates: d.candidates };
|
||
this.setPrompt(this.targetPrompt(d));
|
||
if (d.optional) this.addActionButton('Skip', () => this.applyDecision(d, null));
|
||
if (this.needsModalTargets(d)) this.showPickModal(d.candidates, (ref) => this.applyDecision(d, ref));
|
||
break;
|
||
}
|
||
case 'roomDraw': {
|
||
this.mode = { type: 'roomDraw', decision: d };
|
||
this.setPrompt('Haunted Library: choose your draw');
|
||
this.addActionButton('Draw Room', () => this.applyDecision(d, 'room'));
|
||
this.addActionButton('Draw Spell', () => this.applyDecision(d, 'spell'));
|
||
break;
|
||
}
|
||
default: break;
|
||
}
|
||
this.renderAll();
|
||
}
|
||
|
||
seatName(seat) {
|
||
return seat === this.humanSeat ? 'you' : (this.opponents[seat - 1]?.name || `Boss ${seat}`);
|
||
}
|
||
|
||
targetPrompt(d) {
|
||
switch (d.op) {
|
||
case 'destroyOwnRoom': return 'Robobo strikes! Choose one of your rooms to demolish';
|
||
case 'killHeroTown': return 'Choose a hero in town to petrify';
|
||
case 'lureHero': return 'Choose a hero to lure to your entrance';
|
||
case 'swapRooms': return 'Choose a room pair to swap';
|
||
case 'tutorAdvanced': return 'Choose an advanced room to build';
|
||
case 'recoverDiscard': return 'Reclaim a card from the discard pile';
|
||
case 'revealTake': return 'Take a card from a rival\'s hand';
|
||
case 'stealRandom': case 'opponentDiscardRandom': return 'Choose a rival';
|
||
default: return 'Choose a target';
|
||
}
|
||
}
|
||
|
||
// Ops whose candidates aren't on the board (cards in discards/hands/decks).
|
||
needsModalTargets(d) {
|
||
return ['recoverDiscard', 'revealTake', 'tutorAdvanced'].includes(d.op)
|
||
|| (d.op === 'lureHero' && (d.candidates || []).some((c) => c.kind === 'deckHero'))
|
||
|| ['stealRandom', 'opponentDiscardRandom'].includes(d.op)
|
||
|| (d.candidates || []).every((c) => c.kind === 'soul' || c.kind === 'player');
|
||
}
|
||
|
||
// ── click handlers ──────────────────────────────────────────────────────────
|
||
onHandClicked(inst) {
|
||
const m = this.mode;
|
||
if (m.type === 'setupDiscard' || m.type === 'discard') {
|
||
if (!this.isHandSelectable(inst)) return;
|
||
const i = m.selected.indexOf(inst.uid);
|
||
if (i >= 0) m.selected.splice(i, 1);
|
||
else if (m.selected.length < m.n) m.selected.push(inst.uid);
|
||
this.sfx(SFX.CARD_SHOW);
|
||
this.renderAll();
|
||
return;
|
||
}
|
||
if (m.type === 'build') {
|
||
if (!ROOMS[inst.id] || !m.legal.some((b) => b.roomUid === inst.uid)) return;
|
||
m.selectedRoom = m.selectedRoom === inst.uid ? null : inst.uid;
|
||
this.sfx(SFX.CARD_SHOW);
|
||
this.renderAll();
|
||
return;
|
||
}
|
||
if (m.type === 'window' && this.castableUids?.has(inst.uid)) {
|
||
const act = m.acts.spells.find((s) => s.uid === inst.uid);
|
||
if (act.targets === null) {
|
||
this.applyDecision(m.decision, { spellUid: inst.uid });
|
||
} else {
|
||
this.mode = { type: 'castTarget', decision: m.decision, spellUid: inst.uid, candidates: act.targets };
|
||
this.setPrompt(`${SPELLS[inst.id].name}: choose a target`);
|
||
this.clearActionButtons();
|
||
this.addActionButton('Cancel', () => this.enterHumanMode(m.decision));
|
||
if (act.targets.every((c) => ['card', 'soul', 'player', 'deckHero', 'build', 'swap'].includes(c.kind))) {
|
||
this.showPickModal(act.targets, (t) => this.applyDecision(this.mode.decision, { spellUid: inst.uid, target: t }));
|
||
}
|
||
this.renderAll();
|
||
}
|
||
}
|
||
}
|
||
|
||
onBuildSlotClicked(idx) {
|
||
const m = this.mode;
|
||
if (m.type !== 'build' || !m.selectedRoom) return;
|
||
this.sfx(SFX.CARD_PLACE);
|
||
this.applyDecision(m.decision, { roomUid: m.selectedRoom, slotIdx: idx });
|
||
}
|
||
|
||
// Picking a room card up (dragstart) arms it exactly like clicking it does,
|
||
// so the legal-slot pulse (isBuildSlot, drawn in renderHumanBoard) appears
|
||
// right away. Re-renders only the board, not the hand — the dragged card
|
||
// lives in handLayer, and a full renderAll() would destroy the very
|
||
// container the pointer is still holding.
|
||
onBuildCardDragStart(inst) {
|
||
const m = this.mode;
|
||
if (m.type !== 'build' || !this.isHandSelectable(inst)) return;
|
||
if (m.selectedRoom !== inst.uid) {
|
||
m.selectedRoom = inst.uid;
|
||
this.renderBoardOnly();
|
||
}
|
||
}
|
||
|
||
onBuildCardDropped(inst, x, y) {
|
||
const m = this.mode;
|
||
if (m.type !== 'build' || m.selectedRoom !== inst.uid) { this.renderAll(); return; }
|
||
const idx = m.legal
|
||
.filter((b) => b.roomUid === inst.uid)
|
||
.map((b) => b.slotIdx)
|
||
.find((slotIdx) => this.pointInRect(x, y, this.humanSlotRect(slotIdx)));
|
||
if (idx != null) { this.onBuildSlotClicked(idx); return; }
|
||
// dropped somewhere invalid — disarm and snap the hand/board back
|
||
m.selectedRoom = null;
|
||
this.renderAll();
|
||
}
|
||
|
||
pointInRect(x, y, r) {
|
||
return x >= r.x - r.w / 2 && x <= r.x + r.w / 2 && y >= r.y - r.h / 2 && y <= r.y + r.h / 2;
|
||
}
|
||
|
||
onRoomClicked(seat, idx) {
|
||
const m = this.mode;
|
||
const ref = this.matchCandidate((c) => (c.kind === 'room' && c.seat === seat && c.slotIdx === idx)
|
||
|| (c.kind === 'swap' && c.seat === seat && (c.a === idx || c.b === idx)));
|
||
if (ref && ref.kind === 'swap') {
|
||
// two-click swap: first click picks `a`, second picks the pair
|
||
if (m.swapFirst == null) { m.swapFirst = idx; this.setPrompt('Now choose the room to swap with'); return; }
|
||
const pair = (m.candidates || []).find((c) => c.kind === 'swap' && c.seat === seat
|
||
&& ((c.a === m.swapFirst && c.b === idx) || (c.a === idx && c.b === m.swapFirst)));
|
||
if (pair) this.resolveTargetClick(pair);
|
||
return;
|
||
}
|
||
if (ref) { this.resolveTargetClick(ref); return; }
|
||
// build-over: clicking an occupied slot while a room is armed
|
||
if (m.type === 'build' && m.selectedRoom && seat === this.humanSeat
|
||
&& m.legal.some((b) => b.roomUid === m.selectedRoom && b.slotIdx === idx)) {
|
||
this.onBuildSlotClicked(idx);
|
||
return;
|
||
}
|
||
// otherwise: inspect
|
||
const slot = this.gs.players[seat].dungeon[idx];
|
||
if (slot) this.showInspect('room', slot.room.id);
|
||
}
|
||
|
||
onHeroClicked(uid) {
|
||
const ref = this.matchCandidate((c) => c.kind === 'hero' && c.uid === uid);
|
||
if (ref) { this.resolveTargetClick(ref); return; }
|
||
const hero = this.findHero(uid);
|
||
if (hero) this.showInspect('hero', hero.id);
|
||
}
|
||
|
||
matchCandidate(fn) {
|
||
const m = this.mode;
|
||
if (!['target', 'castTarget', 'activateTarget'].includes(m.type)) return null;
|
||
return (m.candidates || []).find(fn) || null;
|
||
}
|
||
|
||
resolveTargetClick(ref) {
|
||
const m = this.mode;
|
||
if (m.type === 'target') this.applyDecision(m.decision, ref);
|
||
else if (m.type === 'castTarget') this.applyDecision(m.decision, { spellUid: m.spellUid, target: ref });
|
||
else if (m.type === 'activateTarget') this.applyDecision(m.decision, { slotIdx: m.slotIdx, effIdx: m.effIdx, target: ref, costUids: m.costUids });
|
||
}
|
||
|
||
findHero(uid) {
|
||
for (const h of this.gs.town) if (h.uid === uid) return h;
|
||
for (const p of this.gs.players) for (const h of p.entrance) if (h.uid === uid) return h;
|
||
return null;
|
||
}
|
||
|
||
activatableFor(idx) {
|
||
if (this.mode.type !== 'window') return null;
|
||
return (this.mode.acts?.rooms || []).find((r) => r.slotIdx === idx) || null;
|
||
}
|
||
|
||
beginActivate(idx, act) {
|
||
const d = this.mode.decision;
|
||
const slot = this.gs.players[this.humanSeat].dungeon[idx];
|
||
const eff = roomDef(slot.room).effects[act.effIdx];
|
||
const costUids = this.autoCostUids(eff.cost);
|
||
if (act.targets === null) {
|
||
this.applyDecision(d, { slotIdx: idx, effIdx: act.effIdx, costUids });
|
||
return;
|
||
}
|
||
this.mode = { type: 'activateTarget', decision: d, slotIdx: idx, effIdx: act.effIdx, costUids, candidates: act.targets };
|
||
this.setPrompt(`${roomDef(slot.room).name}: choose a target`);
|
||
this.clearActionButtons();
|
||
this.addActionButton('Cancel', () => this.enterHumanMode(d));
|
||
if (act.targets.every((c) => ['card', 'soul', 'player', 'deckHero', 'build'].includes(c.kind))) {
|
||
this.showPickModal(act.targets, (t) => this.applyDecision(d, { slotIdx: idx, effIdx: act.effIdx, target: t, costUids }));
|
||
}
|
||
this.renderAll();
|
||
}
|
||
|
||
// Cheapest valid cards to pay a cost (humans aren't prompted for cost picks).
|
||
autoCostUids(cost) {
|
||
if (!cost) return undefined;
|
||
const p = this.gs.players[this.humanSeat];
|
||
if (cost.discardRooms) {
|
||
return p.hand.rooms.slice().sort((a, b) => roomDef(a).dmg - roomDef(b).dmg)
|
||
.slice(0, cost.discardRooms).map((c) => c.uid);
|
||
}
|
||
if (cost.discardMonsterRoom) {
|
||
const m = p.hand.rooms.filter((c) => roomDef(c).type === 'monster')
|
||
.sort((a, b) => roomDef(a).dmg - roomDef(b).dmg)[0];
|
||
return m ? [m.uid] : undefined;
|
||
}
|
||
if (cost.discardSpell) return p.hand.spells.length ? [p.hand.spells[0].uid] : undefined;
|
||
return undefined;
|
||
}
|
||
|
||
// ── modals ──────────────────────────────────────────────────────────────────
|
||
modalRoot() {
|
||
const root = this.add.container(0, 0).setDepth(DEPTH.overlay);
|
||
const dim = this.add.rectangle(GAME_WIDTH / 2, GAME_HEIGHT / 2, GAME_WIDTH, GAME_HEIGHT, 0x000000, 0.6);
|
||
dim.setInteractive(); // swallow clicks
|
||
root.add(dim);
|
||
this._modal = root;
|
||
return root;
|
||
}
|
||
closeModal() { if (this._modal) { this._modal.destroy(); this._modal = null; } }
|
||
|
||
// Generic candidate picker for off-board targets.
|
||
showPickModal(cands, onPick) {
|
||
const root = this.modalRoot();
|
||
const cols = Math.min(6, Math.max(3, Math.ceil(Math.sqrt(cands.length))));
|
||
// ch sets the row pitch; it must clear the tallest candidate card, which is
|
||
// a room at full cw width (portrait aspect makes it ~209 tall).
|
||
const cw = 150, ch = 220;
|
||
const rows = Math.ceil(cands.length / cols);
|
||
const x0 = GAME_WIDTH / 2 - ((cols - 1) * (cw + 14)) / 2;
|
||
const y0 = GAME_HEIGHT / 2 - ((rows - 1) * (ch + 16)) / 2;
|
||
cands.forEach((ref, i) => {
|
||
const x = x0 + (i % cols) * (cw + 14);
|
||
const y = y0 + Math.floor(i / cols) * (ch + 16);
|
||
const pick = () => { this.closeModal(); onPick(ref); };
|
||
const card = this.renderCandidate(ref, x, y, cw, ch, root, pick);
|
||
if (!card) {
|
||
// Button self-registers on the scene root rather than becoming a
|
||
// child of `root` (see openDeepDive's identical root.add(closeBtn)
|
||
// for the established fix) — reparent it so closeModal()'s
|
||
// root.destroy() actually removes it instead of leaving a stray,
|
||
// still-clickable button behind once a pick is made.
|
||
const b = new Button(this, x, y, this.candidateLabel(ref), pick, { width: cw, fontSize: 16 });
|
||
b.setDepth(DEPTH.overlay + 1);
|
||
root.add(b);
|
||
}
|
||
});
|
||
const cancel = this.mode.decision?.optional;
|
||
const cancelBtn = new Button(this, GAME_WIDTH / 2, GAME_HEIGHT / 2 + (rows / 2) * (ch + 16) + 60,
|
||
cancel ? 'Skip' : 'Cancel', () => {
|
||
this.closeModal();
|
||
if (cancel) this.applyDecision(this.mode.decision, null);
|
||
else this.enterHumanMode(this.mode.decision);
|
||
}, { width: 150, fontSize: 18, variant: 'ghost' }).setDepth(DEPTH.overlay + 1);
|
||
root.add(cancelBtn);
|
||
}
|
||
|
||
renderCandidate(ref, x, y, cw, ch, root, onPick) {
|
||
const gs = this.gs;
|
||
if (ref.kind === 'card') {
|
||
const inst = [...gs.decks.roomDiscard, ...gs.decks.spellDiscard,
|
||
...gs.players.flatMap((p) => [...p.hand.rooms, ...p.hand.spells])]
|
||
.find((c) => c.uid === ref.uid);
|
||
if (!inst) return null;
|
||
if (ROOMS[inst.id]) return this.makeRoomCard(x, y, inst, cw, ch * 0.72, { parent: root, showText: false, onClick: onPick, hover: false });
|
||
return this.makeSpellCard(x, y, inst, cw * 0.72, ch, { parent: root, onClick: onPick, hover: false });
|
||
}
|
||
if (ref.kind === 'soul') {
|
||
const hero = gs.players[ref.seat].soulCards.find((h) => h.uid === ref.uid);
|
||
if (!hero) return null;
|
||
return this.makeHeroCard(x, y, hero, cw * 0.72, ch, { parent: root, onClick: onPick, hover: false });
|
||
}
|
||
if (ref.kind === 'deckHero') {
|
||
const hero = [...gs.decks.heroes, ...gs.decks.epics].find((h) => h.uid === ref.uid);
|
||
if (!hero) return null;
|
||
return this.makeHeroCard(x, y, hero, cw * 0.72, ch, { parent: root, onClick: onPick, hover: false });
|
||
}
|
||
if (ref.kind === 'build') {
|
||
const inst = [...gs.decks.rooms, ...gs.decks.roomDiscard].find((c) => c.uid === ref.roomUid);
|
||
if (!inst) return null;
|
||
const card = this.makeRoomCard(x, y - 12, inst, cw, ch * 0.66, { parent: root, showText: false, onClick: onPick, hover: false });
|
||
root.add(this.add.text(x, y + ch / 2 - 14, `→ slot ${ref.slotIdx + 1}`, {
|
||
fontFamily: '"Julius Sans One"', fontSize: '14px', color: C.goldHex,
|
||
}).setOrigin(0.5));
|
||
return card;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
candidateLabel(ref) {
|
||
if (ref.kind === 'player') return this.seatName(ref.seat);
|
||
if (ref.kind === 'swap') return `Swap ${ref.a + 1} ↔ ${ref.b + 1} (${this.seatName(ref.seat)})`;
|
||
return 'Choose';
|
||
}
|
||
|
||
showReactModal(d) {
|
||
const root = this.modalRoot();
|
||
const cx = GAME_WIDTH / 2, cy = GAME_HEIGHT / 2;
|
||
const g = this.add.graphics();
|
||
g.fillStyle(0x1a1422, 0.97); g.fillRoundedRect(cx - 330, cy - 150, 660, 300, 12);
|
||
g.lineStyle(3, C.spellEdge, 1); g.strokeRoundedRect(cx - 330, cy - 150, 660, 300, 12);
|
||
root.add(g);
|
||
root.add(this.add.text(cx, cy - 110, `${this.seatName(d.casterSeat)} casts ${SPELLS[d.spellId].name}!`, {
|
||
fontFamily: 'Righteous', fontSize: '26px', color: '#f2ead8',
|
||
}).setOrigin(0.5));
|
||
root.add(this.add.text(cx, cy - 66, SPELLS[d.spellId].text, {
|
||
fontFamily: '"Julius Sans One"', fontSize: '17px', color: '#b7a6e8', align: 'center',
|
||
wordWrap: { width: 560 },
|
||
}).setOrigin(0.5));
|
||
const p = this.gs.players[this.humanSeat];
|
||
const buttons = [];
|
||
const cs = p.hand.spells.find((c) => spellDef(c).op.op === 'counterSpell');
|
||
if (cs) buttons.push({ label: 'Counterspell!', resp: { type: 'counterspell', spellUid: cs.uid } });
|
||
p.dungeon.forEach((slot, slotIdx) => {
|
||
if (slot.deactivated) return;
|
||
const effIdx = (roomDef(slot.room).effects || []).findIndex((e) => e.trigger === 'reaction');
|
||
if (effIdx >= 0 && !slot.usedOnce[effIdx] && p.hand.spells.length) {
|
||
const spare = p.hand.spells.find((c) => c.uid !== cs?.uid) || p.hand.spells[0];
|
||
buttons.push({ label: 'All-Seeing Eye (toss a spell)', resp: { type: 'allseeingeye', slotIdx, discardSpellUid: spare.uid } });
|
||
}
|
||
});
|
||
buttons.push({ label: 'Let it resolve', resp: null });
|
||
buttons.forEach((b, i) => {
|
||
// Button self-registers on the scene root rather than becoming a
|
||
// child of `root` (see openDeepDive's root.add(closeBtn) for the
|
||
// established fix) — reparent it so closeModal()'s root.destroy()
|
||
// actually removes it instead of leaving a stray, still-clickable
|
||
// button behind once a choice is made.
|
||
const btn = new Button(this, cx, cy + 4 + i * 54, b.label, () => { this.closeModal(); this.applyDecision(d, b.resp); },
|
||
{ width: 380, fontSize: 19, variant: b.resp ? undefined : 'ghost' }).setDepth(DEPTH.overlay + 1);
|
||
root.add(btn);
|
||
});
|
||
}
|
||
|
||
showInspect(kind, id) {
|
||
if (this._modal) return;
|
||
const root = this.modalRoot();
|
||
const cx = GAME_WIDTH / 2, cy = GAME_HEIGHT / 2;
|
||
const inst = { uid: -1, id, hp: kind === 'hero' ? HEROES[id]?.hp : 0, hpMax: 0 };
|
||
if (kind === 'room') this.makeRoomCard(cx, cy, inst, 340, 430, { parent: root, showText: true, hover: false, noHoverPreview: true });
|
||
else if (kind === 'hero') this.makeHeroCard(cx, cy, inst, 280, 390, { parent: root, hover: false, noHoverPreview: true });
|
||
else if (kind === 'boss') this.makeBossCard(cx, cy, id, 300, 430, { parent: root, showText: true, hover: false, noHoverPreview: true });
|
||
const zone = this.add.zone(cx, cy, GAME_WIDTH, GAME_HEIGHT).setInteractive();
|
||
zone.on('pointerdown', () => this.closeModal());
|
||
root.add(zone);
|
||
root.bringToTop(zone);
|
||
// let the card render above the dim but below the close zone… close on any click
|
||
}
|
||
|
||
// ── deep-dive card inspector ─────────────────────────────────────────────────
|
||
// Triggered from attachHover once the ordinary hover preview has stayed up
|
||
// for another second (see attachHover/DEEPDIVE_ZONES). Flies the currently
|
||
// previewed card to screen center, then reveals its gameplay-zone callouts
|
||
// one at a time; "Close" reverses everything back to the hover-preview spot.
|
||
// Deliberately doesn't reuse modalRoot()/this._modal/closeModal() — this
|
||
// modal needs a bespoke close *animation* and must never close on an
|
||
// incidental click, only via the Close button.
|
||
openDeepDive(deepDiveInfo, hitObj, opts) {
|
||
if (this._modal || this._deepDive || this.busy) return;
|
||
const returnX = this.hoverPopup.x, returnY = this.hoverPopup.y;
|
||
this.hideHover();
|
||
|
||
const root = this.add.container(0, 0).setDepth(DEPTH.overlay);
|
||
// Clicking anywhere on this counts as Close — except the card itself,
|
||
// which gets its own interactive zone (added below) that sits on top
|
||
// and swallows the click first (Phaser's default topOnly input mode
|
||
// means only the topmost interactive object under the pointer fires).
|
||
const dim = this.add.rectangle(GAME_WIDTH / 2, GAME_HEIGHT / 2, GAME_WIDTH, GAME_HEIGHT, 0x000000, 0.6);
|
||
dim.setInteractive();
|
||
dim.on('pointerdown', () => this.closeDeepDive());
|
||
root.add(dim);
|
||
const cardHolder = this.add.container(returnX, returnY);
|
||
root.add(cardHolder);
|
||
|
||
const { kind, inst, bossId, hero, previewW } = deepDiveInfo;
|
||
const previewH = previewW / CARD_ASPECT[kind];
|
||
if (kind === 'room') {
|
||
this.makeRoomCard(0, 0, inst, previewW, previewH, { showText: true, isHoverPreview: true, parent: cardHolder });
|
||
} else if (kind === 'boss') {
|
||
this.makeBossCard(0, 0, bossId, previewW, previewH, { showText: true, isHoverPreview: true, parent: cardHolder });
|
||
} else if (kind === 'spell') {
|
||
this.makeSpellCard(0, 0, inst, previewW, previewH, { isHoverPreview: true, parent: cardHolder });
|
||
} else if (kind === 'hero') {
|
||
this.makeHeroCard(0, 0, hero, previewW, previewH, { isHoverPreview: true, parent: cardHolder });
|
||
}
|
||
// Sits on top of the card (added after it), same size — wins topOnly
|
||
// hit-testing over `dim` so clicks on the card don't close the modal.
|
||
// If the card being viewed is a draggable source card, pressing and
|
||
// holding it here hands off into the same manual drag path the hover
|
||
// popup uses (see beginProxyDrag): the modal closes immediately and the
|
||
// real card appears under the pointer.
|
||
const dragCtx = opts && opts.draggable ? { cont: hitObj, opts } : null;
|
||
const zone = this.add.zone(0, 0, previewW, previewH).setInteractive({ useHandCursor: !!dragCtx });
|
||
if (dragCtx) zone.on('pointerdown', () => this.beginProxyDrag(dragCtx));
|
||
cardHolder.add(zone);
|
||
|
||
const closeBtn = new Button(this, GAME_WIDTH / 2, GAME_HEIGHT / 2 + previewH / 2 + 70, 'Close',
|
||
() => this.closeDeepDive(), { width: 160, fontSize: 20 });
|
||
closeBtn.setDepth(DEPTH.overlay + 1);
|
||
root.add(closeBtn);
|
||
|
||
this._deepDive = {
|
||
modal: root, cardHolder, zoneTimers: [], zoneNodes: [],
|
||
returnX, returnY, w: previewW, h: previewH, deepDiveInfo,
|
||
};
|
||
|
||
this.tweens.add({
|
||
targets: cardHolder, x: GAME_WIDTH / 2, y: GAME_HEIGHT / 2,
|
||
duration: 300, ease: 'Cubic.easeOut',
|
||
onComplete: () => this.revealZones(deepDiveInfo, cardHolder),
|
||
});
|
||
}
|
||
|
||
revealZones(deepDiveInfo, cardHolder) {
|
||
if (!this._deepDive) return; // closed mid zoom-in
|
||
const { kind, inst, bossId, hero } = deepDiveInfo;
|
||
const def = kind === 'room' ? roomDef(inst)
|
||
: kind === 'boss' ? BOSSES[bossId]
|
||
: kind === 'spell' ? spellDef(inst)
|
||
: kind === 'hero' ? heroDef(hero) : null;
|
||
const zones = (DEEPDIVE_ZONES[kind] || []).filter((z) => !z.condition || z.condition(def));
|
||
const { w, h } = this._deepDive;
|
||
zones.forEach((zone, i) => {
|
||
const t = this.time.delayedCall(i * 200, () => this.showZoneCallout(zone, def, w, h, cardHolder));
|
||
this._deepDive.zoneTimers.push(t);
|
||
});
|
||
}
|
||
|
||
// Draws one zone's callout box + leader line + tooltip pill, all as
|
||
// children of `cardHolder` so they translate for free with the card and
|
||
// get destroyed for free when the modal tears down.
|
||
showZoneCallout(zone, def, w, h, cardHolder) {
|
||
const r = zone.rect(w, h, def);
|
||
const rcx = r.x + r.w / 2, rcy = r.y + r.h / 2;
|
||
const edgeX = zone.side === 'left' ? rcx - r.w / 2 : rcx + r.w / 2;
|
||
const anchor = zone.anchor(w, h, def);
|
||
|
||
const box = this.add.container(rcx, rcy).setScale(0).setAlpha(0);
|
||
const bg = this.add.graphics();
|
||
bg.lineStyle(3, C.gold, 1);
|
||
bg.strokeRoundedRect(-r.w / 2, -r.h / 2, r.w, r.h, 4);
|
||
box.add(bg);
|
||
cardHolder.add(box);
|
||
this.tweens.add({ targets: box, scale: 1, alpha: 1, duration: 220, ease: 'Back.easeOut' });
|
||
|
||
const line = this.add.graphics().setAlpha(0);
|
||
line.lineStyle(2, C.gold, 0.9);
|
||
line.lineBetween(edgeX, rcy, anchor.x, anchor.y);
|
||
cardHolder.add(line);
|
||
this.tweens.add({ targets: line, alpha: 1, duration: 150, delay: 80 });
|
||
|
||
const pillW = 460;
|
||
const text = typeof zone.text === 'function' ? zone.text(def) : zone.text;
|
||
const titleTxt = this.add.text(0, 0, zone.title, {
|
||
fontFamily: 'Righteous', fontSize: '28px', color: C.goldHex, align: 'center',
|
||
}).setOrigin(0.5);
|
||
const bodyTxt = this.add.text(0, 0, text, {
|
||
fontFamily: '"Julius Sans One"', fontSize: '24px', color: '#f2ead8', align: 'center',
|
||
wordWrap: { width: pillW - 40 },
|
||
}).setOrigin(0.5);
|
||
const totalH = titleTxt.height + bodyTxt.height + 28;
|
||
titleTxt.setY(-totalH / 2 + titleTxt.height / 2 + 10);
|
||
bodyTxt.setY(totalH / 2 - bodyTxt.height / 2 - 10);
|
||
const pillBg = this.add.graphics();
|
||
pillBg.fillStyle(0x120e16, 0.94);
|
||
pillBg.fillRoundedRect(-pillW / 2, -totalH / 2 - 10, pillW, totalH + 20, 12);
|
||
pillBg.lineStyle(1.5, C.gold, 0.8);
|
||
pillBg.strokeRoundedRect(-pillW / 2, -totalH / 2 - 10, pillW, totalH + 20, 12);
|
||
const pillX = zone.side === 'left' ? anchor.x - pillW / 2 : anchor.x + pillW / 2;
|
||
const pill = this.add.container(pillX, anchor.y, [pillBg, titleTxt, bodyTxt]).setScale(0.85).setAlpha(0);
|
||
cardHolder.add(pill);
|
||
this.tweens.add({ targets: pill, scale: 1, alpha: 1, duration: 200, ease: 'Back.easeOut', delay: 160 });
|
||
|
||
this._deepDive.zoneNodes.push(box, line, pill);
|
||
}
|
||
|
||
closeDeepDive() {
|
||
if (!this._deepDive) return;
|
||
const { modal, cardHolder, zoneTimers, zoneNodes, returnX, returnY } = this._deepDive;
|
||
zoneTimers.forEach((t) => t.remove());
|
||
this.tweens.killTweensOf(cardHolder);
|
||
if (zoneNodes.length) this.tweens.add({ targets: zoneNodes, alpha: 0, duration: 150, ease: 'Sine.easeIn' });
|
||
this.tweens.add({
|
||
targets: cardHolder, x: returnX, y: returnY,
|
||
duration: 280, ease: 'Cubic.easeIn',
|
||
onComplete: () => { modal.destroy(); this._deepDive = null; },
|
||
});
|
||
}
|
||
|
||
// Instant teardown (no fly-back animation) — used when a drag is handed
|
||
// off out of the deep-dive card, since the player is already mid-gesture
|
||
// and shouldn't have to wait on a competing tween.
|
||
forceCloseDeepDive() {
|
||
if (!this._deepDive) return;
|
||
const { modal, cardHolder, zoneTimers } = this._deepDive;
|
||
zoneTimers.forEach((t) => t.remove());
|
||
this.tweens.killTweensOf(cardHolder);
|
||
modal.destroy();
|
||
this._deepDive = null;
|
||
}
|
||
|
||
// ── adventure battle modal ───────────────────────────────────────────────────
|
||
// A full-screen, step-by-step replacement for the old fixed-delay adventure
|
||
// fx: when a seat's queued heroes start walking, this pops a modal (self-
|
||
// contained state on this._advBattle, modeled on _deepDive rather than the
|
||
// generic modalRoot()/_modal — it must survive many Continue clicks and a
|
||
// possible mid-session hide/show without the "any click closes it" default)
|
||
// showing that seat's whole hero queue up top-left and its dungeon (rooms
|
||
// -> boss) up top-right, then steps hero-by-hero, room-by-room through the
|
||
// walk: each room's card + the active hero's card animate down to a battle
|
||
// stage, the hit resolves with an animation + a play-by-play log line, and
|
||
// a Continue button (shown only once the animation finishes) advances.
|
||
//
|
||
// CRITICAL CORRECTNESS NOTE: by the time playEvents() sees these events,
|
||
// the engine has already fully mutated gs to completion (or the next
|
||
// decision-pause) — gs is never an in-progress snapshot. So this code never
|
||
// reads the live hero queue (p.entrance — already drained) or the live room
|
||
// list (p.dungeon — may have had a room spliced out by a trap kill, shifting
|
||
// every later index) to build its initial layout. Instead: the hero roster
|
||
// comes purely from heroEnters events (each carries {seat,uid,id}; starting
|
||
// HP is always heroDef(id).hp since only stepAdventure ever mutates hp, and
|
||
// only after heroEnters fires), and the room track comes from
|
||
// this._advDungeonSnapshot[seat], captured pre-mutation in applyDecision().
|
||
// A parallel `liveOrder` array (stable "display key" per snapshotted room,
|
||
// in current live order) plus a self-tracked `currentLiveIdx` pointer
|
||
// (mirroring the engine's own w.roomIdx countdown) resolve every
|
||
// roomHits/roomDestroyed/ramp-heroHurt event to the correct card even after
|
||
// an earlier trap kill this same session shifted every subsequent index —
|
||
// and surface rooms the engine's event stream is silent about entirely
|
||
// (0-net-damage or deactivated rooms never emit anything) as a quick 'pass'
|
||
// beat, so the hero never appears to silently teleport past one.
|
||
|
||
// Splits `events` into `{ before, walk, rest }`: `before` is whatever
|
||
// precedes the walk (e.g. the windowPass event(s) that close the pre-
|
||
// adventure advStart window — confirmed via a direct engine trace that the
|
||
// seat closing that window's own windowPass shares the SAME event batch as
|
||
// the heroEnters it unblocks, so the walk is NOT reliably the first event
|
||
// in the array), `walk` is the contiguous adventure-walk run this modal
|
||
// owns end-to-end, and `rest` is whatever follows (typically the next
|
||
// seat's adventureStart, or the round/game tail). Pure scan, no side
|
||
// effects. roomDestroyed/heroHurt/eliminated are NOT exclusively
|
||
// adventure-walk events elsewhere (endRound()'s own trap collapse also
|
||
// emits roomDestroyed; spells also emit heroHurt) — the midHero guard
|
||
// (true strictly between a heroEnters and that hero's terminal event) is
|
||
// what keeps this correct once inside the walk.
|
||
splitAdventureWalk(events) {
|
||
const before = [];
|
||
const walk = [];
|
||
let seat = this._advBattle ? this._advBattle.seat : null;
|
||
let inWalk = false;
|
||
let midHero = false;
|
||
let i = 0;
|
||
for (; i < events.length; i++) {
|
||
const e = events[i];
|
||
if (!inWalk) {
|
||
if (e.type === 'heroEnters' && (seat == null || e.seat === seat)) {
|
||
seat = e.seat;
|
||
inWalk = true;
|
||
walk.push(e); midHero = true;
|
||
} else {
|
||
before.push(e);
|
||
}
|
||
continue;
|
||
}
|
||
if (e.type === 'heroEnters') {
|
||
if (e.seat !== seat) break;
|
||
walk.push(e); midHero = true; continue;
|
||
}
|
||
if (e.seat !== seat || !ADV_WALK_TYPES.has(e.type)) break;
|
||
if (!midHero && e.type !== 'bossWounded' && e.type !== 'eliminated') break;
|
||
walk.push(e);
|
||
if (e.type === 'heroDies' || e.type === 'bossWounded') midHero = false;
|
||
}
|
||
return { before, walk, rest: events.slice(i) };
|
||
}
|
||
|
||
// Hands a walk sub-run off to the modal, opening it on the first call for
|
||
// this seat and just re-showing + feeding it more events on later calls
|
||
// (the only way a session spans more than one call: a mid-walk decision
|
||
// like an onHeroDieHere room effect needing a real target choice — see
|
||
// onAdventureQueueDrained). `rest` is whatever follows this seat's walk in
|
||
// the original batch (typically the next seat's adventureStart, or the
|
||
// round/game tail) and is handed back to the normal pipeline once this
|
||
// session closes.
|
||
runAdventureWalk(events, rest) {
|
||
// On a brand-new session, let the player see the full hero/dungeon
|
||
// layout at rest first — the very first battle only starts once they
|
||
// click Continue, rather than immediately marching into the first room.
|
||
const freshlyOpened = !this._advBattle;
|
||
if (freshlyOpened) {
|
||
this.openAdventureModal(events[0].seat, events);
|
||
} else {
|
||
this._advBattle.root.setVisible(true);
|
||
this._advBattle.attackedPortrait.forEach((o) => o.setVisible?.(true));
|
||
this.setAdventureVideosVisible(false);
|
||
this.syncHeroRow(events);
|
||
}
|
||
const ab = this._advBattle;
|
||
ab.events.push(...events);
|
||
ab.onSessionDrained = () => this.closeAdventureModal(() => { this.busy = false; this.playEvents(rest); });
|
||
if (freshlyOpened) ab.continueBtn.setVisible(true);
|
||
else this.advanceAdventureStep();
|
||
}
|
||
|
||
openAdventureModal(seat, firstBatch) {
|
||
this.setAdventureVideosVisible(false);
|
||
const root = this.add.container(0, 0).setDepth(DEPTH.overlay);
|
||
// Dark plum backdrop (matches the game's own scene background, C.bgTop)
|
||
// rather than plain black, framed by an inset gold border so the modal
|
||
// reads as its own "window" over the darkened board.
|
||
const dim = this.add.rectangle(GAME_WIDTH / 2, GAME_HEIGHT / 2, GAME_WIDTH, GAME_HEIGHT, C.bgTop, 0.93).setInteractive();
|
||
root.add(dim);
|
||
const frame = this.add.graphics();
|
||
const m = ADV_FRAME_MARGIN;
|
||
frame.lineStyle(4, C.gold, 0.9);
|
||
frame.strokeRoundedRect(m, m, GAME_WIDTH - m * 2, GAME_HEIGHT - m * 2, 14);
|
||
frame.lineStyle(1.5, C.gold, 0.45);
|
||
frame.strokeRoundedRect(m + 8, m + 8, GAME_WIDTH - (m + 8) * 2, GAME_HEIGHT - (m + 8) * 2, 10);
|
||
root.add(frame);
|
||
this._advBattle = {
|
||
root, dim, seat,
|
||
heroCards: new Map(), heroOrder: [], heroMeta: new Map(), heroHp: new Map(),
|
||
roomCards: new Map(), bossCard: null, liveOrder: [], attackedPortrait: [],
|
||
stage: null, logLines: [], continueBtn: null,
|
||
events: [], cursor: 0, currentLiveIdx: null, activeHeroUid: null,
|
||
lastStep: null, onSessionDrained: null,
|
||
};
|
||
this.buildAdventureRoomRow(seat);
|
||
this.syncHeroRow(firstBatch);
|
||
const ab = this._advBattle;
|
||
this.buildAdventureAttackedPortrait(seat);
|
||
this.drawAdventureSectionFrame(ADV_HERO_SECTION, 'Heroes');
|
||
this.drawAdventureSectionFrame(ADV_ROOM_SECTION, this.advDungeonLabel(seat));
|
||
this.drawAdventureSectionFrame(ADV_STAGE_SECTION, 'Battle Zone');
|
||
ab.stage = this.add.container(0, 0);
|
||
root.add(ab.stage);
|
||
// "Prepare for Dungeon Crawl!" — only ever shown here, at the very start
|
||
// of a fresh session, before the first Continue click. It's a child of
|
||
// ab.stage, so playAdventureStep's own stage.removeAll(true) (its first
|
||
// action once the first real step plays) clears it away for free.
|
||
const prepText = this.add.text(
|
||
(ADV_STAGE_SECTION.x0 + ADV_STAGE_SECTION.x1) / 2, (ADV_STAGE_SECTION.y0 + ADV_STAGE_SECTION.y1) / 2,
|
||
'Prepare for Dungeon Crawl!', {
|
||
fontFamily: 'Righteous', fontSize: '52px', color: '#f5d76e', align: 'center',
|
||
stroke: '#120e16', strokeThickness: 6,
|
||
wordWrap: { width: ADV_STAGE_SECTION.x1 - ADV_STAGE_SECTION.x0 - 60 },
|
||
},
|
||
).setOrigin(0.5).setAlpha(0);
|
||
ab.stage.add(prepText);
|
||
this.tweens.add({ targets: prepText, alpha: 1, duration: 320, ease: 'Cubic.easeOut' });
|
||
this.buildLogPanel();
|
||
ab.continueBtn = new Button(this, ADV_CONTINUE_POS.x, ADV_CONTINUE_POS.y, 'Continue',
|
||
() => this.onAdventureContinue(), { width: 220, fontSize: 22 }).setDepth(DEPTH.overlay + 1);
|
||
ab.continueBtn.setVisible(false);
|
||
root.setAlpha(0);
|
||
this.tweens.add({ targets: root, alpha: 1, duration: 220 });
|
||
}
|
||
|
||
// Adds any hero from `events` not already in the row (every heroEnters the
|
||
// first time; only genuinely new ones on a later, resumed batch), sized by
|
||
// the pitch formula for the CURRENT total queue length — mirrors the
|
||
// existing townPos pitch pattern. Existing cards are left at their original
|
||
// slot/size on a later batch rather than reflowed, a deliberate simplification
|
||
// since that only matters for the rare mid-session-decision resume case.
|
||
syncHeroRow(events) {
|
||
const ab = this._advBattle;
|
||
const newUids = [];
|
||
for (const e of events) {
|
||
if (e.type === 'heroEnters' && !ab.heroMeta.has(e.uid)) {
|
||
const def = heroDef({ id: e.id });
|
||
ab.heroMeta.set(e.uid, { id: e.id, def });
|
||
ab.heroHp.set(e.uid, def.hp);
|
||
ab.heroOrder.push(e.uid);
|
||
newUids.push(e.uid);
|
||
}
|
||
}
|
||
if (!newUids.length) return;
|
||
const n = Math.max(1, ab.heroOrder.length);
|
||
const { x0, x1, y, maxW } = ADV_HERO_ROW;
|
||
const pitch = Math.min(maxW + 14, (x1 - x0) / n);
|
||
const w = Math.max(46, Math.min(maxW, pitch - 14));
|
||
const h = w / CARD_ASPECT.hero;
|
||
newUids.forEach((uid) => {
|
||
const i = ab.heroOrder.indexOf(uid);
|
||
const x = x0 + pitch / 2 + i * pitch;
|
||
const meta = ab.heroMeta.get(uid);
|
||
const cont = this.makeHeroCard(x, y, { uid, id: meta.id, hp: meta.def.hp }, w, h,
|
||
{ parent: ab.root, hover: false, noHoverPreview: true });
|
||
ab.heroCards.set(uid, { cont, x, y, w, h, id: meta.id, def: meta.def });
|
||
});
|
||
}
|
||
|
||
// Room track, gate -> boss (left -> right): dungeon slot index length-1 is
|
||
// gate-side (walked first), index 0 is boss-adjacent (see the engine
|
||
// comment "entrance = dungeon.length-1" on roomDamage). Keyed by a stable
|
||
// displayKey = the room's ORIGINAL snapshot index, paired with a `liveOrder`
|
||
// array (displayKeys in current live-index order) that a trap kill splices
|
||
// from during play, exactly mirroring the engine's own p.dungeon.splice —
|
||
// this is what keeps later roomHits/heroHurt events resolving to the right
|
||
// card even after an earlier trap kill shifted every subsequent live index.
|
||
buildAdventureRoomRow(seat) {
|
||
const ab = this._advBattle;
|
||
const snap = (this._advDungeonSnapshot && this._advDungeonSnapshot[seat]) || [];
|
||
const { x0, x1, y, maxW } = ADV_ROOM_ROW;
|
||
const n = snap.length + 1; // rooms + boss
|
||
const pitch = Math.min(maxW + 14, (x1 - x0) / n);
|
||
const w = Math.max(50, Math.min(maxW, pitch - 14));
|
||
const h = w / CARD_ASPECT.room;
|
||
ab.liveOrder = snap.map((_, i) => i);
|
||
const ordered = snap.map((s, i) => ({ s, displayKey: i })).reverse();
|
||
ordered.forEach(({ s, displayKey }, pos) => {
|
||
const x = x0 + pitch / 2 + pos * pitch;
|
||
const cont = this.makeRoomCard(x, y, s.room, w, h, {
|
||
parent: ab.root, showText: false, hover: false, noHoverPreview: true,
|
||
});
|
||
if (s.armed) this.tagArmedBadge(cont, w, h);
|
||
ab.roomCards.set(displayKey, { cont, x, y, w, h, defId: s.room.id, destroyed: false });
|
||
});
|
||
const bx = x0 + pitch / 2 + snap.length * pitch;
|
||
const bh = w / CARD_ASPECT.boss;
|
||
const bossCont = this.makeBossCard(bx, y, this.gs.players[seat].boss.id, w, bh, {
|
||
parent: ab.root, showText: false, hover: false, noHoverPreview: true,
|
||
});
|
||
ab.bossCard = { cont: bossCont, x: bx, y, w, h: bh };
|
||
}
|
||
|
||
// A static profile picture — never the animated <video> the board
|
||
// portraits use, per request — for whichever seat's dungeon this session
|
||
// is attacking, sitting just to the right of their boss card. Reuses the
|
||
// same board-portrait picture (avatar/initial for the human, sprite-sheet
|
||
// frame for an opponent) via Portrait.js's renderInto(); these are plain
|
||
// scene-root objects (not children of ab.root), so closeAdventureModal
|
||
// destroys them explicitly alongside it.
|
||
buildAdventureAttackedPortrait(seat) {
|
||
const ab = this._advBattle;
|
||
const boss = ab.bossCard;
|
||
if (!boss) { ab.attackedPortrait = []; return; }
|
||
const portrait = seat === this.humanSeat ? this._playerPortrait : this._oppPortraits?.[seat - 1];
|
||
const radius = 34;
|
||
const x = boss.x + boss.w / 2 + radius + 14;
|
||
const y = boss.y;
|
||
ab.attackedPortrait = portrait ? portrait.renderInto(x, y, radius, DEPTH.overlay + 1) : [];
|
||
}
|
||
|
||
tagArmedBadge(cont, w, h) {
|
||
cont.add(this.add.text(w / 2 - 14, -h / 2 + 14, '⚠', { fontSize: '18px', color: '#c9962a' }).setOrigin(0.5));
|
||
}
|
||
|
||
advDungeonLabel(seat) {
|
||
return seat === this.humanSeat ? 'Your Dungeon' : `${this.seatName(seat)}'s Dungeon`;
|
||
}
|
||
|
||
// A subtle labeled box (gold-on-dark, tab-style title straddling the top
|
||
// edge) grouping one region of the modal — purely visual organization, no
|
||
// interactivity.
|
||
drawAdventureSectionFrame(box, label) {
|
||
const ab = this._advBattle;
|
||
const g = this.add.graphics();
|
||
g.lineStyle(2, C.gold, 0.55);
|
||
g.strokeRoundedRect(box.x0, box.y0, box.x1 - box.x0, box.y1 - box.y0, 8);
|
||
ab.root.add(g);
|
||
ab.root.add(this.add.text(box.x0 + 18, box.y0, label, {
|
||
fontFamily: 'Righteous', fontSize: '17px', color: C.goldHex,
|
||
backgroundColor: '#120e16', padding: { x: 10, y: 3 },
|
||
}).setOrigin(0, 0.5));
|
||
}
|
||
|
||
buildLogPanel() {
|
||
const ab = this._advBattle;
|
||
const { x0, y0, w, h } = ADV_LOG_PANEL;
|
||
const bg = this.add.graphics();
|
||
bg.fillStyle(C.parchment, 0.96); bg.fillRoundedRect(x0, y0, w, h, 8);
|
||
bg.lineStyle(2, 0x4a3a5c, 0.6); bg.strokeRoundedRect(x0, y0, w, h, 8);
|
||
ab.root.add(bg);
|
||
}
|
||
|
||
appendLogLine(text, color = C.ink) {
|
||
const ab = this._advBattle;
|
||
const { x0, y0, w, h, lineH } = ADV_LOG_PANEL;
|
||
const maxLines = Math.floor(h / lineH) - 1;
|
||
if (ab.logLines.length >= maxLines) ab.logLines.shift().destroy();
|
||
const t = this.add.text(x0 + 16, 0, text, {
|
||
fontFamily: '"Julius Sans One"', fontSize: '28px', color, wordWrap: { width: w - 32 },
|
||
});
|
||
ab.logLines.push(t);
|
||
ab.root.add(t);
|
||
let y = y0 + h - 20;
|
||
for (let i = ab.logLines.length - 1; i >= 0; i--) {
|
||
ab.logLines[i].setY(y - ab.logLines[i].height);
|
||
y -= ab.logLines[i].height + 6;
|
||
}
|
||
t.setAlpha(0);
|
||
this.tweens.add({ targets: t, alpha: 1, duration: 180 });
|
||
}
|
||
|
||
// ── step sequencing ─────────────────────────────────────────────────────────
|
||
// Pulls raw events from ab.events/ab.cursor and groups them into one
|
||
// Continue-gated "step." The modal walks its OWN currentLiveIdx pointer
|
||
// from liveOrder.length-1 down to -1 per hero, mirroring the engine's
|
||
// w.roomIdx, and matches it against the next unconsumed event — this is
|
||
// what surfaces a silent 0-damage/deactivated room (no event at all) as a
|
||
// 'pass' step that a pure event-type scan would miss entirely.
|
||
nextAdventureStep() {
|
||
const ab = this._advBattle;
|
||
let bounceAmount = null;
|
||
for (;;) {
|
||
if (ab.cursor >= ab.events.length) return null;
|
||
const e = ab.events[ab.cursor];
|
||
|
||
if (e.type === 'heroEnters') {
|
||
ab.cursor++;
|
||
ab.activeHeroUid = e.uid;
|
||
ab.currentLiveIdx = ab.liveOrder.length - 1;
|
||
const step = { kind: 'enter', uid: e.uid };
|
||
if (ab.events[ab.cursor]?.type === 'heroTeleported') {
|
||
ab.cursor++;
|
||
step.teleported = true;
|
||
ab.currentLiveIdx = ab.liveOrder.length - 1;
|
||
}
|
||
return step;
|
||
}
|
||
|
||
if (e.type === 'bossWounded') {
|
||
ab.cursor++;
|
||
const step = { kind: 'bossWound', uid: e.uid, seat: e.seat, wounds: e.wounds, total: e.total };
|
||
if (ab.events[ab.cursor]?.type === 'eliminated') { ab.cursor++; step.eliminated = true; }
|
||
ab.activeHeroUid = null; ab.currentLiveIdx = null;
|
||
return step;
|
||
}
|
||
|
||
if (ab.currentLiveIdx == null || ab.currentLiveIdx < 0) { ab.cursor++; continue; } // defensive
|
||
|
||
const roomIdx = ab.currentLiveIdx;
|
||
const uid = ab.activeHeroUid;
|
||
|
||
// Minotaur's Maze: a one-off re-hit of the room just left, folded as a
|
||
// narrative prefix onto whatever happens in the current room next.
|
||
if (e.type === 'roomHits' && e.bounce && e.slotIdx === roomIdx + 1) {
|
||
ab.cursor++;
|
||
bounceAmount = e.amount;
|
||
continue;
|
||
}
|
||
if (e.type === 'roomDestroyed' && e.slotIdx === roomIdx) {
|
||
ab.cursor++;
|
||
const displayKey = ab.liveOrder.splice(roomIdx, 1)[0];
|
||
const step = { kind: 'trapKill', uid, displayKey, bounceAmount };
|
||
if (ab.events[ab.cursor]?.type === 'heroDies') { step.heroDies = ab.events[ab.cursor]; ab.cursor++; }
|
||
ab.activeHeroUid = null; ab.currentLiveIdx = null;
|
||
return step;
|
||
}
|
||
if (e.type === 'heroHurt') {
|
||
ab.cursor++;
|
||
const displayKey = ab.liveOrder[roomIdx];
|
||
const step = { kind: 'roomHit', uid, displayKey, rampAmount: e.amount, amount: 0, bounceAmount };
|
||
if (ab.events[ab.cursor]?.type === 'roomHits' && ab.events[ab.cursor].slotIdx === roomIdx) {
|
||
step.amount = ab.events[ab.cursor].amount; step.bounce = !!ab.events[ab.cursor].bounce; ab.cursor++;
|
||
}
|
||
if (ab.events[ab.cursor]?.type === 'heroDies') { step.heroDies = ab.events[ab.cursor]; ab.cursor++; }
|
||
if (step.heroDies) { ab.activeHeroUid = null; ab.currentLiveIdx = null; } else ab.currentLiveIdx--;
|
||
return step;
|
||
}
|
||
if (e.type === 'roomHits' && e.slotIdx === roomIdx) {
|
||
ab.cursor++;
|
||
const displayKey = ab.liveOrder[roomIdx];
|
||
const step = { kind: 'roomHit', uid, displayKey, amount: e.amount, bounceAmount };
|
||
if (ab.events[ab.cursor]?.type === 'heroDies') { step.heroDies = ab.events[ab.cursor]; ab.cursor++; }
|
||
if (step.heroDies) { ab.activeHeroUid = null; ab.currentLiveIdx = null; } else ab.currentLiveIdx--;
|
||
return step;
|
||
}
|
||
// No event matches this room index — a silent 0-dmg or deactivated pass.
|
||
const displayKey = ab.liveOrder[roomIdx];
|
||
ab.currentLiveIdx--;
|
||
return { kind: 'pass', uid, displayKey, bounceAmount };
|
||
}
|
||
}
|
||
|
||
advanceAdventureStep() {
|
||
const ab = this._advBattle;
|
||
ab.continueBtn.setVisible(false);
|
||
const step = this.nextAdventureStep();
|
||
if (!step) { this.onAdventureQueueDrained(); return; }
|
||
ab.lastStep = step;
|
||
this.playAdventureStep(step, () => {
|
||
if (step.kind === 'enter' || step.kind === 'pass') { this.advanceAdventureStep(); return; }
|
||
ab.continueBtn.setVisible(true);
|
||
});
|
||
}
|
||
|
||
onAdventureContinue() {
|
||
const ab = this._advBattle;
|
||
ab.continueBtn.setVisible(false);
|
||
this.settleAdventureStepIntoTopRows(ab.lastStep, () => this.advanceAdventureStep());
|
||
}
|
||
|
||
// Return-to-top / dim / advance, per the spec: a survived room hit sends
|
||
// both cards back up then dims the room just passed; a trap kill sends
|
||
// just the room back up as a destroyed placeholder (the hero already faded
|
||
// away in playTrapKillStep); bossWound and pass need no further settling
|
||
// (already fully resolved inline in their own play functions).
|
||
settleAdventureStepIntoTopRows(step, onDone) {
|
||
if (!step) { onDone(); return; } // the opening Continue click — nothing has played yet to settle
|
||
switch (step.kind) {
|
||
case 'roomHit': {
|
||
// The hero (if it died here) is already gone from the stage by now
|
||
// (removeHeroCard ran inside playRoomHitStep) — only the room needs
|
||
// to travel back, either way.
|
||
const uid = step.heroDies ? null : step.uid;
|
||
this.returnHome(uid, step.displayKey, () => { this.dimRoomCard(step.displayKey); onDone(); });
|
||
break;
|
||
}
|
||
case 'trapKill':
|
||
this.returnHome(null, step.displayKey, () => { this.markRoomDestroyed(step.displayKey); onDone(); });
|
||
break;
|
||
default:
|
||
onDone();
|
||
break;
|
||
}
|
||
}
|
||
|
||
// When the step queue empties: if the engine is now waiting on a real
|
||
// decision for THIS seat (e.g. an onHeroDieHere room effect's target
|
||
// choice), hide (not destroy) the modal and let the existing decision UI
|
||
// (showPickModal etc.) run its course via the normal pump()/applyDecision
|
||
// cycle — the next batch of events resumes this same session (see
|
||
// runAdventureWalk). Otherwise the seat's whole queue is done.
|
||
onAdventureQueueDrained() {
|
||
const ab = this._advBattle;
|
||
const d = pendingDecision(this.gs);
|
||
if (d && d.seat === ab.seat && ['target', 'discard', 'roomDraw'].includes(d.kind)) {
|
||
ab.root.setVisible(false);
|
||
ab.continueBtn.setVisible(false);
|
||
ab.attackedPortrait.forEach((o) => o.setVisible?.(false)); // scene-root objects, not children of ab.root
|
||
this.setAdventureVideosVisible(true); // the decision UI (showPickModal etc.) is a normal board overlay, fine to show these under
|
||
this.busy = false;
|
||
this.pump();
|
||
return;
|
||
}
|
||
ab.onSessionDrained();
|
||
}
|
||
|
||
closeAdventureModal(onDone) {
|
||
const ab = this._advBattle;
|
||
ab.continueBtn.setVisible(false);
|
||
this.tweens.add({
|
||
// ab.continueBtn and ab.attackedPortrait are scene-root objects (see
|
||
// their own comments), not children of ab.root, so they need to fade
|
||
// and be destroyed alongside it explicitly rather than for free.
|
||
targets: [ab.root, ...ab.attackedPortrait], alpha: 0, duration: 240, ease: 'Cubic.easeIn',
|
||
onComplete: () => {
|
||
ab.continueBtn.destroy();
|
||
ab.attackedPortrait.forEach((o) => o.destroy());
|
||
ab.root.destroy();
|
||
this._advBattle = null;
|
||
this.setAdventureVideosVisible(true);
|
||
this.renderAll();
|
||
onDone?.();
|
||
},
|
||
});
|
||
}
|
||
|
||
// Opponent portraits use a real DOM <video>, which always renders above
|
||
// canvas content regardless of Phaser depth (see hoverPopup's identical
|
||
// treatment) — hide/pause them whenever the adventure modal is the topmost
|
||
// thing on screen so they can't float over it.
|
||
setAdventureVideosVisible(visible) {
|
||
this._oppPortraits?.forEach((p) => p.setVideoVisible(visible));
|
||
}
|
||
|
||
// ── shared move helpers ──────────────────────────────────────────────────────
|
||
moveToStage(uid, displayKey, opts, onDone) {
|
||
const ab = this._advBattle;
|
||
const heroRec = uid != null ? ab.heroCards.get(uid) : null;
|
||
const roomRec = displayKey != null ? ab.roomCards.get(displayKey) : null;
|
||
const duration = opts.duration || 300;
|
||
let pending = 0;
|
||
const done = () => { if (--pending <= 0) onDone(); };
|
||
if (heroRec) {
|
||
pending++;
|
||
// Scale relative to this card's OWN built width (varies with hero-row
|
||
// pitch/count) so it lands at the exact hover-preview width, not just
|
||
// a fixed multiplier of whatever size it happened to be built at.
|
||
const scale = ADV_STAGE_HERO_W / heroRec.w;
|
||
this.tweens.add({ targets: heroRec.cont, x: ADV_STAGE_HERO.x, y: ADV_STAGE_HERO.y, scale, duration, ease: 'Cubic.easeOut', onComplete: done });
|
||
}
|
||
if (roomRec && !roomRec.destroyed) {
|
||
pending++;
|
||
const scale = ADV_STAGE_ROOM_W / roomRec.w;
|
||
this.tweens.add({ targets: roomRec.cont, x: ADV_STAGE_ROOM.x, y: ADV_STAGE_ROOM.y, scale, duration, ease: 'Cubic.easeOut', onComplete: done });
|
||
}
|
||
if (!pending) onDone();
|
||
}
|
||
|
||
returnHome(uid, displayKey, onDone) {
|
||
const ab = this._advBattle;
|
||
const heroRec = uid != null ? ab.heroCards.get(uid) : null;
|
||
const roomRec = displayKey != null ? ab.roomCards.get(displayKey) : null;
|
||
let pending = 0;
|
||
const done = () => { if (--pending <= 0) onDone(); };
|
||
if (heroRec) {
|
||
pending++;
|
||
this.tweens.add({ targets: heroRec.cont, x: heroRec.x, y: heroRec.y, scale: 1, duration: 260, ease: 'Cubic.easeIn', onComplete: done });
|
||
}
|
||
if (roomRec && !roomRec.destroyed) {
|
||
pending++;
|
||
this.tweens.add({ targets: roomRec.cont, x: roomRec.x, y: roomRec.y, scale: 1, duration: 260, ease: 'Cubic.easeIn', onComplete: done });
|
||
}
|
||
if (!pending) onDone();
|
||
}
|
||
|
||
// Large "-{amount}" overlaid on the hero's card in the stage, rising and
|
||
// fading over 1.5s — placed in absolute stage coordinates (not as a child
|
||
// of the hero card's own container) so its size stays fixed/predictable
|
||
// regardless of how much that container is currently scaled up (which
|
||
// varies with hero-row crowding, from ~2.6x up to ~6.8x).
|
||
popHeroDamageNumber(amount) {
|
||
const ab = this._advBattle;
|
||
const t = this.add.text(ADV_STAGE_HERO.x, ADV_STAGE_HERO.y, `-${amount}`, {
|
||
fontFamily: 'Righteous', fontSize: '72px', color: '#ff2222', stroke: '#000000', strokeThickness: 8,
|
||
}).setOrigin(0.5);
|
||
ab.stage.add(t);
|
||
this.tweens.add({ targets: t, y: t.y - 140, alpha: 0, duration: 1500, ease: 'Cubic.easeOut', onComplete: () => t.destroy() });
|
||
}
|
||
|
||
dimRoomCard(displayKey) {
|
||
const rc = this._advBattle.roomCards.get(displayKey);
|
||
if (rc && !rc.destroyed) rc.cont.setAlpha(0.35);
|
||
}
|
||
|
||
markRoomDestroyed(displayKey) {
|
||
const rc = this._advBattle.roomCards.get(displayKey);
|
||
if (!rc || rc.destroyed) return;
|
||
rc.destroyed = true;
|
||
rc.cont.setAlpha(1);
|
||
rc.cont.removeAll(true);
|
||
const g = this.add.graphics();
|
||
g.fillStyle(0x241a2e, 0.9); g.fillRoundedRect(-rc.w / 2, -rc.h / 2, rc.w, rc.h, 6);
|
||
g.lineStyle(2, 0x6b5a4a, 0.8); g.strokeRoundedRect(-rc.w / 2, -rc.h / 2, rc.w, rc.h, 6);
|
||
rc.cont.add(g);
|
||
rc.cont.add(this.add.text(0, 0, '💥', { fontSize: `${Math.round(rc.h * 0.4)}px` }).setOrigin(0.5).setAlpha(0.7));
|
||
}
|
||
|
||
// Soul-rises removal beat for a hero that died this session (trap kill or
|
||
// cumulative room damage) — echoes the live board's heroDies soul-flight fx.
|
||
removeHeroCard(uid, onDone) {
|
||
const ab = this._advBattle;
|
||
const rec = ab.heroCards.get(uid);
|
||
if (!rec) { onDone(); return; }
|
||
const soul = this.add.circle(rec.cont.x, rec.cont.y, 10, 0xf5d76e, 0.9);
|
||
ab.stage.add(soul);
|
||
this.tweens.add({ targets: soul, y: soul.y - 90, alpha: 0, duration: 500, ease: 'Cubic.easeOut', onComplete: () => soul.destroy() });
|
||
this.tweens.add({
|
||
targets: rec.cont, alpha: 0, scale: 0.7, duration: 380, ease: 'Cubic.easeIn',
|
||
onComplete: () => {
|
||
rec.cont.destroy();
|
||
ab.heroCards.delete(uid);
|
||
const idx = ab.heroOrder.indexOf(uid);
|
||
if (idx >= 0) ab.heroOrder.splice(idx, 1);
|
||
onDone();
|
||
},
|
||
});
|
||
}
|
||
|
||
advHeroCurrentHp(uid) { return this._advBattle.heroHp.get(uid) ?? 0; }
|
||
advSetHeroCurrentHp(uid, v) { this._advBattle.heroHp.set(uid, v); }
|
||
advHeroName(uid) {
|
||
const meta = this._advBattle.heroMeta.get(uid);
|
||
return meta ? meta.def.name : 'The hero';
|
||
}
|
||
advRoomName(displayKey) {
|
||
const rc = this._advBattle.roomCards.get(displayKey);
|
||
return rc ? (ROOMS[rc.defId]?.name || 'the room') : 'the room';
|
||
}
|
||
|
||
// ── battle-step animations ──────────────────────────────────────────────────
|
||
playAdventureStep(step, onDone) {
|
||
const ab = this._advBattle;
|
||
ab.stage.removeAll(true);
|
||
const ctx = this.adventureStepCtx(step);
|
||
this.appendLogLine(this.adventureLogLine(step, ctx), this.adventureLogColor(step));
|
||
switch (step.kind) {
|
||
case 'enter': this.playEnterStep(step, onDone); return;
|
||
case 'pass': this.playPassStep(step, onDone); return;
|
||
case 'roomHit': this.playRoomHitStep(step, onDone); return;
|
||
case 'trapKill': this.playTrapKillStep(step, onDone); return;
|
||
case 'bossWound': this.playBossWoundStep(step, onDone); return;
|
||
default: onDone(); return;
|
||
}
|
||
}
|
||
|
||
adventureStepCtx(step) {
|
||
const ab = this._advBattle;
|
||
const heroName = step.uid != null ? this.advHeroName(step.uid) : 'The hero';
|
||
const roomName = step.displayKey != null ? this.advRoomName(step.displayKey) : '';
|
||
const seatName = this.seatName(ab.seat);
|
||
let boosted = false;
|
||
if (step.kind === 'roomHit' && step.displayKey != null) {
|
||
const rc = ab.roomCards.get(step.displayKey);
|
||
const def = rc && ROOMS[rc.defId];
|
||
boosted = !!(def && step.amount > def.dmg);
|
||
}
|
||
return { heroName, roomName, seatName, boosted };
|
||
}
|
||
|
||
adventureLogLine(step, ctx) {
|
||
switch (step.kind) {
|
||
case 'enter':
|
||
return `${ctx.heroName} enters the dungeon${step.teleported ? ' again (teleported!)' : ''}...`;
|
||
case 'pass':
|
||
return `${ctx.heroName} slips past ${ctx.roomName} unscathed.`;
|
||
case 'roomHit': {
|
||
const total = (step.rampAmount || 0) + (step.amount || 0) + (step.bounceAmount || 0);
|
||
const boosted = ctx.boosted ? ' (boosted!)' : '';
|
||
const bounce = step.bounceAmount ? ' — bounced back into the previous room!' : '';
|
||
let line = `${ctx.roomName} hits ${ctx.heroName} for ${total}${boosted}${bounce}`;
|
||
if (step.heroDies) line += ` — ${ctx.heroName} falls! (+${step.heroDies.souls} soul${step.heroDies.souls > 1 ? 's' : ''})`;
|
||
return line;
|
||
}
|
||
case 'trapKill': {
|
||
const souls = step.heroDies?.souls ?? 1;
|
||
return `${ctx.roomName} triggers — it collapses, destroying itself and killing ${ctx.heroName} instantly! (+${souls} soul${souls > 1 ? 's' : ''})`;
|
||
}
|
||
case 'bossWound':
|
||
return `${ctx.heroName} reaches the boss chamber! ${ctx.seatName}'s boss takes ${step.wounds} wound${step.wounds > 1 ? 's' : ''} (${step.total}/5)`
|
||
+ (step.eliminated ? ` — ${ctx.seatName} is slain!` : '');
|
||
default:
|
||
return '';
|
||
}
|
||
}
|
||
|
||
adventureLogColor(step) {
|
||
if (step.kind === 'roomHit' || step.kind === 'trapKill') return '#8c1f28';
|
||
if (step.kind === 'bossWound' && step.eliminated) return '#8c1f28';
|
||
return C.ink;
|
||
}
|
||
|
||
playEnterStep(step, onDone) {
|
||
const ab = this._advBattle;
|
||
const rec = ab.heroCards.get(step.uid);
|
||
this.resetRoomDimming(); // fresh hero, fresh run — every room but a truly destroyed one is fair game again
|
||
if (!rec) { onDone(); return; }
|
||
const hl = this.add.graphics();
|
||
hl.lineStyle(3, C.gold, 1);
|
||
hl.strokeRoundedRect(rec.x - rec.w / 2 - 5, rec.y - rec.h / 2 - 5, rec.w + 10, rec.h + 10, 8);
|
||
ab.root.add(hl);
|
||
this.tweens.add({ targets: hl, alpha: 0, duration: 500, ease: 'Cubic.easeOut', onComplete: () => { hl.destroy(); onDone(); } });
|
||
}
|
||
|
||
// Rooms only get dimmed to mark "already passed through THIS hero's run" —
|
||
// a room a prior hero cleared is fully live again for the next one, so
|
||
// undo that dimming whenever a fresh hero starts (a room actually
|
||
// destroyed by a trap stays a rubble placeholder for the whole session).
|
||
resetRoomDimming() {
|
||
const ab = this._advBattle;
|
||
ab.roomCards.forEach((rc) => {
|
||
if (!rc.destroyed && rc.cont.alpha < 1) {
|
||
this.tweens.add({ targets: rc.cont, alpha: 1, duration: 260, ease: 'Cubic.easeOut' });
|
||
}
|
||
});
|
||
}
|
||
|
||
playPassStep(step, onDone) {
|
||
this.moveToStage(step.uid, step.displayKey, { duration: 200 }, () => {
|
||
this.time.delayedCall(140, () => {
|
||
this.returnHome(step.uid, step.displayKey, () => { this.dimRoomCard(step.displayKey); onDone(); });
|
||
});
|
||
});
|
||
}
|
||
|
||
playRoomHitStep(step, onDone) {
|
||
const ab = this._advBattle;
|
||
const uid = step.uid;
|
||
const heroRec = ab.heroCards.get(uid);
|
||
const roomRec = ab.roomCards.get(step.displayKey);
|
||
const def = roomRec && ROOMS[roomRec.defId];
|
||
const trap = def && def.type === 'trap';
|
||
|
||
this.moveToStage(uid, step.displayKey, {}, () => {
|
||
const midX = (ADV_STAGE_HERO.x + ADV_STAGE_ROOM.x) / 2, midY = (ADV_STAGE_HERO.y + ADV_STAGE_ROOM.y) / 2;
|
||
if (roomRec) this.tweens.add({ targets: roomRec.cont, x: roomRec.cont.x - 30, duration: 130, ease: 'Back.easeOut', yoyo: true });
|
||
this.popText(midX, midY, '⚔', trap ? '#c9962a' : '#ff6b5e', 34);
|
||
this.time.delayedCall(260, () => {
|
||
this.shakeAt(ADV_STAGE_HERO.x, ADV_STAGE_HERO.y);
|
||
const totalAmount = (step.rampAmount || 0) + (step.amount || 0) + (step.bounceAmount || 0);
|
||
this.popHeroDamageNumber(totalAmount);
|
||
if (def && step.amount > def.dmg) this.popText(ADV_STAGE_HERO.x + 46, ADV_STAGE_HERO.y - 74, '⚡ boosted!', '#f5d76e', 16);
|
||
const startHp = this.advHeroCurrentHp(uid);
|
||
const newHp = Math.max(0, startHp - totalAmount);
|
||
this.advSetHeroCurrentHp(uid, newHp);
|
||
if (heroRec?.cont.hpText) {
|
||
const hpObj = { v: startHp };
|
||
this.tweens.add({
|
||
targets: hpObj, v: newHp, duration: 440, ease: 'Cubic.easeIn',
|
||
onUpdate: () => heroRec.cont.hpText.setText(`${Math.round(hpObj.v)}`),
|
||
});
|
||
}
|
||
if (step.heroDies) this.time.delayedCall(480, () => this.removeHeroCard(uid, onDone));
|
||
else this.time.delayedCall(480, onDone);
|
||
});
|
||
});
|
||
}
|
||
|
||
playTrapKillStep(step, onDone) {
|
||
const ab = this._advBattle;
|
||
const uid = step.uid;
|
||
const roomRec = ab.roomCards.get(step.displayKey);
|
||
this.moveToStage(uid, step.displayKey, {}, () => {
|
||
if (roomRec) this.tweens.add({ targets: roomRec.cont, scaleY: 0.1, duration: 180, ease: 'Cubic.easeIn' });
|
||
this.popText(ADV_STAGE_ROOM.x, ADV_STAGE_ROOM.y, '💥', '#ffffff', 40);
|
||
this.shakeAt(ADV_STAGE_ROOM.x, ADV_STAGE_ROOM.y);
|
||
this.time.delayedCall(60, () => this.shakeAt(ADV_STAGE_HERO.x, ADV_STAGE_HERO.y));
|
||
const heroRec = ab.heroCards.get(uid);
|
||
if (heroRec) {
|
||
// Size to the card's CURRENT on-stage scale, not its small built
|
||
// dimensions, so the flash actually covers the (now much bigger,
|
||
// hover-preview-sized) card.
|
||
const s = heroRec.cont.scaleX || 1;
|
||
const flash = this.add.rectangle(heroRec.cont.x, heroRec.cont.y, heroRec.w * s, heroRec.h * s, 0xff0000, 0.5);
|
||
ab.stage.add(flash);
|
||
this.tweens.add({ targets: flash, alpha: 0, duration: 260, onComplete: () => flash.destroy() });
|
||
}
|
||
this.time.delayedCall(300, () => this.removeHeroCard(uid, onDone));
|
||
});
|
||
}
|
||
|
||
playBossWoundStep(step, onDone) {
|
||
const ab = this._advBattle;
|
||
const uid = step.uid;
|
||
const heroRec = ab.heroCards.get(uid);
|
||
const boss = ab.bossCard;
|
||
if (!heroRec || !boss) { onDone(); return; }
|
||
this.tweens.add({
|
||
targets: heroRec.cont, x: boss.x - boss.w / 2 - 10, y: boss.y, scale: 1.1,
|
||
duration: 260, ease: 'Back.easeIn',
|
||
onComplete: () => {
|
||
this.shakeAt(boss.x, boss.y);
|
||
this.popText(boss.x, boss.y - boss.h / 2 - 10, `☠ wound${step.wounds > 1 ? ' ×2' : ''}`, '#ff5348', 26);
|
||
const flash = this.add.rectangle(boss.x, boss.y, boss.w, boss.h, 0xc0392b, 0.4);
|
||
ab.root.add(flash);
|
||
this.tweens.add({ targets: flash, alpha: 0, duration: 380, onComplete: () => flash.destroy() });
|
||
this.tweens.add({
|
||
targets: heroRec.cont, alpha: 0, duration: 300, delay: 150, ease: 'Cubic.easeIn',
|
||
onComplete: () => {
|
||
heroRec.cont.destroy();
|
||
ab.heroCards.delete(uid);
|
||
const idx = ab.heroOrder.indexOf(uid);
|
||
if (idx >= 0) ab.heroOrder.splice(idx, 1);
|
||
if (step.eliminated) this.showAdventureEliminatedBanner(this.seatName(ab.seat), onDone);
|
||
else onDone();
|
||
},
|
||
});
|
||
},
|
||
});
|
||
}
|
||
|
||
showAdventureEliminatedBanner(name, onDone) {
|
||
const ab = this._advBattle;
|
||
const dark = this.add.rectangle(GAME_WIDTH / 2, GAME_HEIGHT / 2, GAME_WIDTH, GAME_HEIGHT, 0x000000, 0.35);
|
||
ab.root.add(dark);
|
||
const banner = this.add.text(GAME_WIDTH / 2, 120, `${name} has been slain!`, {
|
||
fontFamily: 'Righteous', fontSize: '34px', color: '#f2ead8',
|
||
backgroundColor: '#120e16ee', padding: { x: 28, y: 14 },
|
||
}).setOrigin(0.5).setAlpha(0);
|
||
ab.root.add(banner);
|
||
this.tweens.add({ targets: banner, alpha: 1, duration: 240, ease: 'Back.easeOut', onComplete: () => this.time.delayedCall(900, onDone) });
|
||
}
|
||
|
||
// ── prompt + action buttons ─────────────────────────────────────────────────
|
||
setPrompt(txt) { this.promptText.setText(txt || ''); }
|
||
addActionButton(label, cb) {
|
||
this._actionButtons = this._actionButtons || [];
|
||
const i = this._actionButtons.length;
|
||
// Stacked in a single column under the human boss card (center x=1740,
|
||
// bottom edge ≈820.4 — see makeBossCard(1740, 700, ..., 168, 236) — plus
|
||
// a little padding), rather than beside the prompt text.
|
||
const b = new Button(this, 1740, 890 + i * 52, label, cb, { width: 160, fontSize: 18 });
|
||
b.setDepth(DEPTH.ui);
|
||
this._actionButtons.push(b);
|
||
}
|
||
clearActionButtons() {
|
||
for (const b of this._actionButtons || []) b.destroy();
|
||
this._actionButtons = [];
|
||
}
|
||
|
||
// ── event playback ──────────────────────────────────────────────────────────
|
||
playEvents(events) {
|
||
this.busy = true;
|
||
this.setPrompt('');
|
||
// A single action can emit several same-kind 'draw' events for the human
|
||
// (e.g. draw 2 rooms); the event carries no card uid, so figure out up
|
||
// front how many of each kind are coming, and consume them in order from
|
||
// the end of the (already fully mutated) hand array as each is played.
|
||
this._humanDrawBatch = { room: 0, spell: 0 };
|
||
this._humanDrawSeen = { room: 0, spell: 0 };
|
||
for (const e of events) if (e.type === 'draw' && e.seat === this.humanSeat) this._humanDrawBatch[e.card]++;
|
||
// `before` (e.g. the windowPass event(s) that close the pre-adventure
|
||
// advStart window — confirmed via engine trace to share the SAME batch
|
||
// as the heroEnters it unblocks) plays through the normal fixed-delay
|
||
// pipeline first; once it drains, `walk` (if any) hands off to the
|
||
// adventure battle modal instead of falling through to pump().
|
||
const { before, walk, rest } = this.splitAdventureWalk(events);
|
||
const queue = before.filter((e) => this.eventDelay(e) > 0 || this.eventFx(e, true));
|
||
const step = () => {
|
||
const e = queue.shift();
|
||
if (!e) {
|
||
if (walk.length) { this.renderAll(); this.runAdventureWalk(walk, rest); return; }
|
||
this.busy = false;
|
||
this.renderAll();
|
||
this.pump();
|
||
return;
|
||
}
|
||
this.eventFx(e, false);
|
||
this.time.delayedCall(this.eventDelay(e), step);
|
||
};
|
||
// render intermediate state once so effects anchor to fresh positions
|
||
this.renderAll();
|
||
step();
|
||
}
|
||
|
||
eventDelay(e) {
|
||
switch (e.type) {
|
||
case 'flip': return 260;
|
||
case 'roomBuilt': return 240;
|
||
case 'heroRevealed': return 140;
|
||
case 'heroWalks': return 1500;
|
||
case 'heroEnters': return 200;
|
||
case 'roomHits': return 340;
|
||
case 'heroDies': return 480;
|
||
case 'bossWounded': return 420;
|
||
case 'levelUp': return 800;
|
||
case 'eliminated': return 800;
|
||
case 'spellCast': return 820;
|
||
case 'spellCountered': return 700;
|
||
case 'roundStart': return 600;
|
||
case 'roundEnd': return 400;
|
||
case 'phaseBuild': return 10;
|
||
case 'phaseBait': return 10;
|
||
case 'phaseAdventure': return 10;
|
||
case 'heroResurrected': return 400;
|
||
case 'roomDestroyed': return 320;
|
||
case 'roomFrozen': return 300;
|
||
case 'trapArmed': return 260;
|
||
case 'draw': return 260;
|
||
default: return 0;
|
||
}
|
||
}
|
||
|
||
// When probe=true just report whether the event produces fx.
|
||
eventFx(e, probe) {
|
||
if (probe) return this.eventDelay(e) > 0;
|
||
const gs = this.gs;
|
||
switch (e.type) {
|
||
case 'flip':
|
||
this.sfx(SFX.CARD_SHOW);
|
||
break;
|
||
case 'roomBuilt': {
|
||
this.sfx(SFX.CARD_PLACE);
|
||
const r = this.slotRect(e.seat, e.slotIdx);
|
||
if (r) this.popText(r.x, r.y, ROOMS[e.id]?.name || '', '#f2ead8');
|
||
break;
|
||
}
|
||
case 'heroRevealed':
|
||
this.sfx(SFX.CARD_DEAL);
|
||
break;
|
||
case 'draw': {
|
||
if (e.seat !== this.humanSeat) { this.sfx(SFX.CARD_DEAL); break; }
|
||
const p = gs.players[e.seat];
|
||
const list = e.card === 'room' ? p.hand.rooms : p.hand.spells;
|
||
const total = this._humanDrawBatch[e.card] || 1;
|
||
const seen = this._humanDrawSeen[e.card]++;
|
||
const inst = list[list.length - total + seen];
|
||
const sprite = inst && this._handSprites.get(inst.uid);
|
||
if (inst && sprite) {
|
||
this.flyCardFromDeck(e.card, inst, sprite.x, sprite.y, e.card === 'room' ? 125 : 104, (cont) => cont.destroy());
|
||
} else this.sfx(SFX.CARD_DEAL);
|
||
break;
|
||
}
|
||
case 'heroWalks': {
|
||
// Use the pre-mutation snapshot (see applyDecision) — by now
|
||
// renderAll() has already redrawn the town without this hero (bait
|
||
// already moved it into an entrance), so the live _heroTokens has no
|
||
// entry for it any more.
|
||
const from = this._preBaitHeroTokens?.get(e.uid) || this._heroTokens.get(e.uid);
|
||
const hero = this.findHero(e.uid) || { uid: e.uid, id: e.id, hp: 0 };
|
||
if (from) {
|
||
// Built at full town-card width, then tweened down (via scale) to
|
||
// the destination gate's mini-card width as it flies, so the hero
|
||
// visibly shrinks into its resting entrance size.
|
||
const entW = e.seat === this.humanSeat ? HUMAN_ENTRANCE_W : OPP_ENTRANCE_W;
|
||
const tok = this.miniHeroCard(from.x, from.y, hero, TOWN_HERO_W, {
|
||
parent: this.fxLayer, noHoverPreview: true,
|
||
});
|
||
const to = this.entranceApprox(e.seat);
|
||
const scale = entW / TOWN_HERO_W;
|
||
this.tweens.add({
|
||
targets: tok, x: to.x, y: to.y, scaleX: scale, scaleY: scale,
|
||
duration: 1500, ease: 'Cubic.easeInOut', onComplete: () => tok.destroy(),
|
||
});
|
||
}
|
||
break;
|
||
}
|
||
case 'roomHits': {
|
||
const r = this.slotRect(e.seat, e.slotIdx);
|
||
if (r) {
|
||
this.popText(r.x, r.y - 20, `-${e.amount}`, '#ff6b5e', 26);
|
||
this.shakeAt(r.x, r.y);
|
||
}
|
||
break;
|
||
}
|
||
case 'heroDies': {
|
||
const from = this._heroTokens.get(e.uid) || this.entranceApprox(e.seat);
|
||
const to = this._soulsPos.get(e.seat) || { x: 60, y: 780 };
|
||
const cont = this.add.container(from.x, from.y);
|
||
this.drawSoulIcon(cont, 0, 0, 10);
|
||
this.fxLayer.add(cont);
|
||
this.tweens.add({ targets: cont, x: to.x, y: to.y, duration: 440, ease: 'Cubic.easeInOut', onComplete: () => cont.destroy() });
|
||
this.popText(from.x, from.y - 26, `+${e.souls} soul${e.souls > 1 ? 's' : ''}`, '#f5d76e');
|
||
this.sfx(SFX.COINS);
|
||
break;
|
||
}
|
||
case 'bossWounded': {
|
||
const pos = e.seat === this.humanSeat ? { x: 1740, y: 700 } : this.oppBossPos(e.seat);
|
||
this.popText(pos.x, pos.y - 40, `☠ wound${e.wounds > 1 ? ' ×2' : ''}`, '#ff5348', 26);
|
||
const flash = this.add.rectangle(pos.x, pos.y, 180, 250, 0xc0392b, 0.4).setDepth(DEPTH.fx);
|
||
this.tweens.add({ targets: flash, alpha: 0, duration: 380, onComplete: () => flash.destroy() });
|
||
break;
|
||
}
|
||
case 'levelUp':
|
||
this.showBanner(`⚡ ${BOSSES[e.boss].name} LEVELS UP — ${this.seatName(e.seat)}`);
|
||
break;
|
||
case 'eliminated':
|
||
this.showBanner(`${this.seatName(e.seat)} has been slain!`);
|
||
break;
|
||
case 'spellCast': {
|
||
this.sfx(SFX.CARD_SHOW);
|
||
const cx = GAME_WIDTH / 2, cy = 560;
|
||
const card = this.makeSpellCard(cx, cy, { uid: -1, id: e.id }, 168, 236, { parent: this.fxLayer, hover: false, noHoverPreview: true });
|
||
card.setScale(0.4).setAlpha(0);
|
||
this.tweens.add({ targets: card, scale: 1, alpha: 1, duration: 180, ease: 'Back.easeOut' });
|
||
this.fxLayer.add(this.add.text(cx, cy - 150, `${this.seatName(e.seat)} casts`, {
|
||
fontFamily: 'Righteous', fontSize: '20px', color: '#b7a6e8',
|
||
}).setOrigin(0.5));
|
||
this.time.delayedCall(680, () => this.fxLayer.removeAll(true));
|
||
break;
|
||
}
|
||
case 'spellCountered':
|
||
this.showBanner(`✕ ${SPELLS[e.spellId]?.name || 'The spell'} is countered by ${this.seatName(e.seat)}!`);
|
||
break;
|
||
case 'roundStart':
|
||
this.showBanner(`— Round ${e.round} —`);
|
||
this.sfx(SFX.CARD_DEAL);
|
||
this.phaseWheel.setPhase('roundStart');
|
||
break;
|
||
case 'roundEnd':
|
||
this.phaseWheel.setPhase('roundEnd');
|
||
break;
|
||
case 'phaseBuild':
|
||
this.phaseWheel.setPhase('build');
|
||
break;
|
||
case 'phaseBait':
|
||
this.phaseWheel.setPhase('bait');
|
||
break;
|
||
case 'phaseAdventure':
|
||
this.phaseWheel.setPhase('adventure');
|
||
break;
|
||
case 'heroResurrected':
|
||
this.popText(GAME_WIDTH / 2, 500, 'A hero rises from the grave!', '#9be89b');
|
||
break;
|
||
case 'roomDestroyed': {
|
||
const r = this.slotRect(e.seat, e.slotIdx);
|
||
if (r) { this.popText(r.x, r.y, '💥', '#ffffff', 34); this.shakeAt(r.x, r.y); }
|
||
break;
|
||
}
|
||
case 'roomFrozen': {
|
||
const r = this.slotRect(e.seat, e.slotIdx);
|
||
if (r) this.popText(r.x, r.y, '❄', '#d8f0fa', 34);
|
||
break;
|
||
}
|
||
case 'trapArmed':
|
||
this.popText(GAME_WIDTH / 2, 700, '⚠ trap armed', '#c9962a');
|
||
break;
|
||
default: break;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
slotRect(seat, idx) {
|
||
return this._slotRects.get(`${seat}:${idx}`)
|
||
|| (seat === this.humanSeat ? this.humanSlotRect(idx) : null);
|
||
}
|
||
entranceApprox(seat) {
|
||
if (seat === this.humanSeat) {
|
||
const len = this.gs.players[seat].dungeon.length;
|
||
const r = this.humanSlotRect(Math.max(0, len - 1));
|
||
return { x: r.x - 130, y: 640 };
|
||
}
|
||
const centers = this.oppPanelCenters();
|
||
const c = centers[seat - 1];
|
||
return { x: c.x - 250, y: c.y + 62 };
|
||
}
|
||
oppBossPos(seat) {
|
||
const c = this.oppPanelCenters()[seat - 1];
|
||
return { x: c.x + 228, y: c.y - 20 };
|
||
}
|
||
|
||
popText(x, y, txt, color, size = 20) {
|
||
const t = this.add.text(x, y, txt, {
|
||
fontFamily: 'Righteous', fontSize: `${size}px`, color, stroke: '#120e16', strokeThickness: 4,
|
||
}).setOrigin(0.5).setDepth(DEPTH.fx);
|
||
this.tweens.add({ targets: t, y: y - 46, alpha: 0, duration: 900, ease: 'Cubic.easeOut', onComplete: () => t.destroy() });
|
||
}
|
||
|
||
shakeAt(x, y) {
|
||
const g = this.add.graphics().setDepth(DEPTH.fx);
|
||
g.lineStyle(3, 0xffffff, 0.5);
|
||
g.strokeCircle(x, y, 26);
|
||
this.tweens.add({ targets: g, scale: 1.6, alpha: 0, duration: 300, onComplete: () => g.destroy() });
|
||
}
|
||
|
||
showBanner(text) {
|
||
const banner = this.add.text(GAME_WIDTH / 2, 330, text, {
|
||
fontFamily: 'Righteous', fontSize: '30px', color: '#f2ead8',
|
||
backgroundColor: '#120e16ee', padding: { x: 26, y: 12 },
|
||
}).setOrigin(0.5).setDepth(DEPTH.overlay);
|
||
this.tweens.add({
|
||
targets: banner, y: 356, duration: 240, ease: 'Back.easeOut',
|
||
onComplete: () => this.time.delayedCall(900, () =>
|
||
this.tweens.add({ targets: banner, alpha: 0, y: 330, duration: 220, onComplete: () => banner.destroy() })),
|
||
});
|
||
}
|
||
|
||
sfx(key) { try { playSound(this, key); } catch (_) { /* optional */ } }
|
||
|
||
// ── game over ───────────────────────────────────────────────────────────────
|
||
onGameOver() {
|
||
if (this._gameOverShown) return;
|
||
this._gameOverShown = true;
|
||
this.clearActionButtons();
|
||
this.setPrompt('');
|
||
const gs = this.gs;
|
||
const won = gs.winner === this.humanSeat;
|
||
const human = gs.players[this.humanSeat];
|
||
const oppScores = gs.players.filter((p) => p.seat !== this.humanSeat).map((p) => p.souls);
|
||
this.recordResult(won ? 'win' : 'loss', human.souls, oppScores);
|
||
|
||
const order = gs.players.slice().sort((a, b) => (b.seat === gs.winner) - (a.seat === gs.winner) || b.souls - a.souls);
|
||
const cx = GAME_WIDTH / 2, cy = GAME_HEIGHT / 2;
|
||
const h = 170 + order.length * 44;
|
||
const root = this.add.container(0, 0).setDepth(DEPTH.overlay);
|
||
root.add(this.add.rectangle(cx, cy, GAME_WIDTH, GAME_HEIGHT, 0x000000, 0.55).setInteractive());
|
||
const g = this.add.graphics();
|
||
g.fillStyle(0x14101c, 0.97); g.fillRoundedRect(cx - 340, cy - h / 2, 680, h, 14);
|
||
g.lineStyle(3, won ? C.gold : C.bossEdge, 1); g.strokeRoundedRect(cx - 340, cy - h / 2, 680, h, 14);
|
||
root.add(g);
|
||
root.add(this.add.text(cx, cy - h / 2 + 40, won ? '👑 Your dungeon reigns!' : 'Your reign is over', {
|
||
fontFamily: 'Righteous', fontSize: '36px', color: won ? C.goldHex : '#f2ead8',
|
||
}).setOrigin(0.5));
|
||
order.forEach((p, i) => {
|
||
const tag = p.seat === gs.winner ? '👑 ' : p.alive ? '' : '☠ ';
|
||
root.add(this.add.text(cx, cy - h / 2 + 96 + i * 42,
|
||
`${tag}${this.seatName(p.seat)} — ${p.souls} souls, ${p.wounds} wounds`, {
|
||
fontFamily: '"Julius Sans One"', fontSize: '21px',
|
||
color: p.seat === gs.winner ? C.goldHex : '#e6ddc8',
|
||
}).setOrigin(0.5));
|
||
});
|
||
new Button(this, cx - 115, cy + h / 2 - 42, 'Play Again', () => this.scene.restart(this._initData),
|
||
{ width: 195, fontSize: 21 }).setDepth(DEPTH.overlay + 1);
|
||
new Button(this, cx + 115, cy + h / 2 - 42, 'Leave', () => this.scene.start('GameMenu'),
|
||
{ width: 195, fontSize: 21, variant: 'ghost' }).setDepth(DEPTH.overlay + 1);
|
||
}
|
||
|
||
async recordResult(result, score, opponentScores) {
|
||
if (this._recorded) return;
|
||
this._recorded = true;
|
||
try {
|
||
await api.post('/history/single-player', { slug: 'dungeonboss', score, opponentScores, result });
|
||
} catch { /* best effort */ }
|
||
}
|
||
}
|