heros_web/scripts/verify-save-retry-flow.mjs

import { spawn } from 'node:child_process';
import { chromium } from 'playwright';

const targetUrl = withCanvasRenderer(process.env.VERIFY_URL ?? 'http://localhost:5173/');
const baselineViewport = { width: 1920, height: 1080 };
const legacyUiScale = 1.5;

function withCanvasRenderer(url) {
  const parsed = new URL(url);
  parsed.searchParams.set('renderer', 'canvas');
  return parsed.toString();
}

let serverProcess;
let browser;

try {
  serverProcess = await ensureLocalServer(targetUrl);

  browser = await chromium.launch({ headless: true });
  const page = await browser.newPage({ viewport: baselineViewport });

  await page.goto(targetUrl, { waitUntil: 'domcontentloaded' });
  await page.evaluate(() => window.localStorage.clear());
  await page.reload({ waitUntil: 'domcontentloaded' });
  await waitForTitle(page);
  await page.screenshot({ path: 'dist/verification-save-title-empty.png', fullPage: true });

  await startTitleDefaultAction(page);
  await advanceUntilBattle(page, 'first-battle-zhuo-commandery');
  await page.screenshot({ path: 'dist/verification-save-new-battle.png', fullPage: true });

  const autoSave = await readCampaignSave(page);
  if (autoSave.current?.step !== 'first-battle' || autoSave.slot1?.step !== 'first-battle') {
    throw new Error(`Expected first battle auto-save in current and slot 1 saves: ${JSON.stringify(autoSave)}`);
  }

  await page.reload({ waitUntil: 'domcontentloaded' });
  await waitForTitle(page);
  await page.screenshot({ path: 'dist/verification-save-title-continue.png', fullPage: true });

  await startTitleDefaultAction(page);
  await waitForBattleReady(page, 'first-battle-zhuo-commandery');
  const continuedBattle = await page.evaluate(() => window.__HEROS_DEBUG__?.battle());
  if (continuedBattle?.battleOutcome !== null || continuedBattle?.resultVisible !== false || continuedBattle?.turnNumber !== 1) {
    throw new Error(`Expected continue to reopen a clean first battle: ${JSON.stringify(continuedBattle)}`);
  }
  await page.screenshot({ path: 'dist/verification-save-continued-battle.png', fullPage: true });

  await page.evaluate(() => window.__HEROS_DEBUG__?.forceBattleOutcome('defeat'));
  await waitForBattleOutcome(page, 'defeat');
  await page.screenshot({ path: 'dist/verification-save-defeat-result.png', fullPage: true });

  const defeatSave = await readCampaignSave(page);
  if (defeatSave.current?.step !== 'first-battle' || defeatSave.current?.firstBattleReport?.outcome !== 'defeat') {
    throw new Error(`Expected defeat to save retry-ready first battle state: ${JSON.stringify(defeatSave.current)}`);
  }

  await clickLegacyUi(page, 884, 642);
  await waitForBattleReady(page, 'first-battle-zhuo-commandery');
  const retriedBattle = await page.evaluate(() => window.__HEROS_DEBUG__?.battle());
  const retriedLiuBei = retriedBattle?.units?.find((unit) => unit.id === 'liu-bei');
  const retriedEnemies = retriedBattle?.units?.filter((unit) => unit.faction === 'enemy' && unit.hp > 0) ?? [];
  const damagedAlliesAfterRetry = retriedBattle?.units?.filter((unit) => unit.faction === 'ally' && unit.hp !== unit.maxHp) ?? [];
  if (
    retriedBattle?.battleOutcome !== null ||
    retriedBattle?.resultVisible !== false ||
    retriedBattle?.turnNumber !== 1 ||
    !retriedLiuBei ||
    retriedLiuBei.hp !== retriedLiuBei.maxHp ||
    damagedAlliesAfterRetry.length > 0 ||
    retriedEnemies.length <= 0
  ) {
    throw new Error(`Expected retry to restart battle without stale result or damage state: ${JSON.stringify(retriedBattle)}`);
  }
  await page.screenshot({ path: 'dist/verification-save-retry-battle.png', fullPage: true });

  await page.evaluate(() => window.__HEROS_DEBUG__?.forceBattleOutcome('victory'));
  await waitForBattleOutcome(page, 'victory');
  await page.screenshot({ path: 'dist/verification-save-victory-result.png', fullPage: true });

  await clickLegacyUi(page, 738, 642);
  await advanceUntilCamp(page);
  await page.screenshot({ path: 'dist/verification-save-victory-camp.png', fullPage: true });

  const campState = await page.evaluate(() => window.__HEROS_DEBUG__?.camp());
  const victorySave = await readCampaignSave(page);
  if (
    campState?.scene !== 'CampScene' ||
    campState?.report?.rewardGold <= 0 ||
    victorySave.current?.step !== 'first-camp' ||
    victorySave.current?.firstBattleReport?.outcome !== 'victory' ||
    victorySave.current?.gold <= 0
  ) {
    throw new Error(`Expected victory to return to camp with persisted rewards: ${JSON.stringify({ campState, victorySave })}`);
  }

  console.log(`Verified new-game auto-save, browser reload continue, defeat retry, and victory camp return at ${targetUrl}`);
} finally {
  await browser?.close();
  if (serverProcess && !serverProcess.killed) {
    serverProcess.kill();
  }
}

async function waitForTitle(page) {
  await page.waitForFunction(() => document.querySelector('canvas') !== null, undefined, { timeout: 90000 });
  await page.waitForFunction(() => window.__HEROS_GAME__ !== undefined, undefined, { timeout: 90000 });
  await page.waitForFunction(() => window.__HEROS_DEBUG__ !== undefined, undefined, { timeout: 90000 });
  await page.waitForFunction(() => {
    const activeScenes = window.__HEROS_DEBUG__?.activeScenes() ?? [];
    return activeScenes.includes('TitleScene');
  }, undefined, { timeout: 90000 });
}

async function startTitleDefaultAction(page) {
  await waitForTitle(page);
  await page.keyboard.press('Enter');
  await page.waitForTimeout(300);
}

async function advanceUntilBattle(page, battleId) {
  for (let i = 0; i < 180; i += 1) {
    const battleReady = await page.evaluate((expectedBattleId) => {
      let state;
      try {
        state = window.__HEROS_DEBUG__?.battle();
      } catch {
        state = undefined;
      }
      return (
        state?.scene === 'BattleScene' &&
        state?.battleId === expectedBattleId &&
        state?.battleOutcome === null &&
        ['deployment', 'idle'].includes(state?.phase) &&
        state?.mapBackgroundReady === true &&
        state?.resultVisible === false
      );
    }, battleId);

    if (battleReady) {
      return;
    }

    const activeScenes = await page.evaluate(() => window.__HEROS_DEBUG__?.activeScenes() ?? []);
    await page.keyboard.press(activeScenes.includes('TitleScene') ? 'Enter' : 'Space');
    await page.waitForTimeout(240);
  }

  const state = await page.evaluate(() => ({
    activeScenes: window.__HEROS_DEBUG__?.activeScenes() ?? [],
    battle: window.__HEROS_DEBUG__?.battle(),
    camp: window.__HEROS_DEBUG__?.camp()
  }));
  throw new Error(`Expected to advance into ${battleId}: ${JSON.stringify(state)}`);
}

async function waitForBattleReady(page, battleId) {
  await page.waitForFunction((expectedBattleId) => {
    let state;
    try {
      state = window.__HEROS_DEBUG__?.battle();
    } catch {
      state = undefined;
    }
    return (
      state?.scene === 'BattleScene' &&
      state?.battleId === expectedBattleId &&
      state?.battleOutcome === null &&
      ['deployment', 'idle'].includes(state?.phase) &&
      state?.mapBackgroundReady === true &&
      state?.resultVisible === false
    );
  }, battleId, { timeout: 90000 });
}

async function waitForBattleOutcome(page, outcome) {
  await page.waitForFunction((expectedOutcome) => {
    let state;
    try {
      state = window.__HEROS_DEBUG__?.battle();
    } catch {
      state = undefined;
    }
    return state?.battleOutcome === expectedOutcome && state?.phase === 'resolved' && state?.resultVisible === true;
  }, outcome, { timeout: 90000 });
}

async function advanceUntilCamp(page) {
  for (let i = 0; i < 240; i += 1) {
    const state = await page.evaluate(() => ({
      activeScenes: window.__HEROS_DEBUG__?.activeScenes() ?? [],
      battle: window.__HEROS_DEBUG__?.battle(),
      camp: window.__HEROS_DEBUG__?.camp()
    }));

    if (state.activeScenes.includes('CampScene')) {
      return;
    }

    if (state.activeScenes.includes('BattleScene') && state.battle?.battleOutcome === 'victory' && state.battle?.resultVisible) {
      await clickLegacyUi(page, 738, 642);
    } else {
      await page.keyboard.press('Space');
    }
    await page.waitForTimeout(250);
  }

  const state = await page.evaluate(() => ({
    activeScenes: window.__HEROS_DEBUG__?.activeScenes() ?? [],
    battle: window.__HEROS_DEBUG__?.battle(),
    camp: window.__HEROS_DEBUG__?.camp()
  }));
  throw new Error(`Expected victory flow to reach CampScene: ${JSON.stringify(state)}`);
}

async function readCampaignSave(page) {
  return page.evaluate(() => {
    const read = (key) => {
      const raw = window.localStorage.getItem(key);
      return raw ? JSON.parse(raw) : undefined;
    };
    return {
      current: read('heros-web:campaign-state'),
      slot1: read('heros-web:campaign-state:slot-1')
    };
  });
}

async function ensureLocalServer(url) {
  if (await canReach(url)) {
    return undefined;
  }

  const parsed = new URL(url);
  const isLocal = ['localhost', '127.0.0.1', '0.0.0.0'].includes(parsed.hostname);
  if (!isLocal) {
    throw new Error(`No server responded at ${url}`);
  }

  const stderr = [];
  const child = spawn(process.execPath, ['node_modules/vite/bin/vite.js', '--host', '127.0.0.1', '--port', parsed.port || '5173'], {
    cwd: process.cwd(),
    env: process.env,
    stdio: ['ignore', 'pipe', 'pipe']
  });

  child.stderr.on('data', (chunk) => stderr.push(chunk.toString()));
  child.stdout.on('data', () => {});

  for (let i = 0; i < 80; i += 1) {
    if (await canReach(url)) {
      return child;
    }
    await delay(250);
  }

  child.kill();
  throw new Error(`Vite server did not start at ${url}\n${stderr.join('')}`);
}

async function canReach(url) {
  try {
    const response = await fetch(url, { signal: AbortSignal.timeout(1000) });
    return response.ok;
  } catch {
    return false;
  }
}

function delay(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

async function clickLegacyUi(page, x, y, options) {
  await page.mouse.click(x * legacyUiScale, y * legacyUiScale, options);
}