619 lines
23 KiB
JavaScript
619 lines
23 KiB
JavaScript
import { spawn } from 'node:child_process';
|
|
import { chromium } from 'playwright';
|
|
|
|
const targetUrl = process.env.QA_URL ?? 'http://localhost:5173/';
|
|
const headless = process.env.QA_HEADLESS !== '0';
|
|
const maxRounds = Number(process.env.QA_MAX_ROUNDS ?? 80);
|
|
const pnpmCommand = process.env.PNPM_CMD ?? 'pnpm';
|
|
|
|
const allRepresentativeBattles = [
|
|
{ no: 1, id: 'first-battle-zhuo-commandery', selected: [], targets: ['rebel-leader'], protected: ['liu-bei'] },
|
|
{
|
|
no: 7,
|
|
id: 'seventh-battle-xuzhou-rescue',
|
|
selected: ['liu-bei', 'guan-yu', 'zhang-fei'],
|
|
targets: ['xuzhou-leader-xiahou-dun'],
|
|
protected: ['liu-bei']
|
|
},
|
|
{
|
|
no: 18,
|
|
id: 'eighteenth-battle-bowang-ambush',
|
|
selected: ['liu-bei', 'zhuge-liang', 'zhao-yun', 'guan-yu', 'zhang-fei', 'sun-qian'],
|
|
targets: ['bowang-leader-xiahou-dun'],
|
|
protected: ['liu-bei']
|
|
},
|
|
{
|
|
no: 27,
|
|
id: 'twenty-seventh-battle-yizhou-relief-road',
|
|
selected: ['liu-bei', 'zhuge-liang', 'huang-zhong', 'wei-yan', 'zhao-yun', 'mi-zhu'],
|
|
targets: ['yizhou-leader-yang-huai'],
|
|
protected: ['liu-bei', 'zhuge-liang']
|
|
},
|
|
{
|
|
no: 37,
|
|
id: 'thirty-seventh-battle-hanzhong-decisive',
|
|
selected: ['liu-bei', 'huang-zhong', 'fa-zheng', 'wang-ping', 'ma-chao', 'ma-dai', 'zhuge-liang'],
|
|
targets: ['hanzhong-leader-cao-cao'],
|
|
protected: ['liu-bei', 'wang-ping']
|
|
},
|
|
{
|
|
no: 45,
|
|
id: 'forty-fifth-battle-yiling-vanguard',
|
|
selected: ['liu-bei', 'zhang-fei', 'zhao-yun', 'ma-chao', 'zhuge-liang', 'huang-quan', 'ma-liang'],
|
|
targets: ['yiling-leader-lu-xun'],
|
|
protected: ['liu-bei']
|
|
},
|
|
{
|
|
no: 55,
|
|
id: 'fifty-fifth-battle-northern-qishan-road',
|
|
selected: ['zhuge-liang', 'zhao-yun', 'huang-quan', 'ma-liang', 'wang-ping', 'ma-dai', 'wei-yan'],
|
|
targets: ['northern-first-leader-cao-zhen'],
|
|
protected: ['zhuge-liang']
|
|
},
|
|
{
|
|
no: 58,
|
|
id: 'fifty-eighth-battle-qishan-retreat',
|
|
selected: ['zhuge-liang', 'jiang-wei', 'wang-ping', 'zhao-yun', 'ma-dai', 'huang-quan', 'ma-liang'],
|
|
targets: ['northern-fourth-leader-sima-yi', 'northern-fourth-officer-zhang-he'],
|
|
protected: ['zhuge-liang']
|
|
},
|
|
{
|
|
no: 66,
|
|
id: 'sixty-sixth-battle-wuzhang-final',
|
|
selected: ['zhuge-liang', 'jiang-wei', 'wang-ping', 'ma-dai', 'huang-quan', 'li-yan', 'wei-yan'],
|
|
targets: ['northern-twelfth-leader-sima-yi', 'northern-twelfth-officer-zhang-he', 'northern-twelfth-officer-guo-huai'],
|
|
protected: ['zhuge-liang']
|
|
}
|
|
];
|
|
|
|
const requestedBattles = new Set(
|
|
(process.env.QA_BATTLES ?? '')
|
|
.split(',')
|
|
.map((entry) => entry.trim())
|
|
.filter(Boolean)
|
|
);
|
|
const representativeBattles =
|
|
requestedBattles.size > 0
|
|
? allRepresentativeBattles.filter((battle) => requestedBattles.has(String(battle.no)) || requestedBattles.has(battle.id))
|
|
: allRepresentativeBattles;
|
|
|
|
let serverProcess;
|
|
|
|
try {
|
|
serverProcess = await ensureLocalServer(targetUrl);
|
|
const browser = await chromium.launch({ headless });
|
|
|
|
try {
|
|
const page = await browser.newPage({ viewport: { width: 1280, height: 720 } });
|
|
const results = [];
|
|
|
|
for (const battle of representativeBattles) {
|
|
await setupBattle(page, battle);
|
|
results.push(await playBattleWithoutDebugVictory(page, battle));
|
|
}
|
|
|
|
const failed = results.filter((result) => result.outcome !== 'victory');
|
|
console.table(
|
|
results.map((result) => ({
|
|
no: result.no,
|
|
outcome: result.outcome,
|
|
turn: result.finalTurn,
|
|
alliesAlive: result.alliesAlive,
|
|
enemiesAlive: result.enemiesAlive,
|
|
itemsUsed: result.itemsUsed,
|
|
supports: result.supports,
|
|
objectives: `${result.objectivesAchieved}/${result.objectiveCount}`
|
|
}))
|
|
);
|
|
|
|
if (failed.length > 0) {
|
|
console.dir(
|
|
failed.map((result) => ({
|
|
no: result.no,
|
|
id: result.id,
|
|
outcome: result.outcome,
|
|
protected: result.protectedStatus,
|
|
targets: result.targetStatus,
|
|
allies: result.allyStatus,
|
|
enemies: result.enemyStatus,
|
|
log: result.battleLogTail
|
|
})),
|
|
{ depth: null }
|
|
);
|
|
throw new Error(`Representative battle QA failed: ${failed.map((result) => `${result.no}:${result.id}`).join(', ')}`);
|
|
}
|
|
|
|
console.log(`Representative battle QA passed without debug victory for ${results.length} battles at ${targetUrl}`);
|
|
} finally {
|
|
await browser.close();
|
|
}
|
|
} finally {
|
|
if (serverProcess) {
|
|
serverProcess.kill();
|
|
}
|
|
}
|
|
|
|
async function setupBattle(page, battle) {
|
|
await page.goto(targetUrl, { waitUntil: 'domcontentloaded' });
|
|
await page.waitForFunction(() => window.__HEROS_GAME__ !== undefined && window.__HEROS_DEBUG__ !== undefined, undefined, { timeout: 90000 });
|
|
await page.evaluate((selected) => {
|
|
const now = new Date().toISOString();
|
|
const state = {
|
|
version: 1,
|
|
updatedAt: now,
|
|
step: 'first-battle',
|
|
activeSaveSlot: 1,
|
|
gold: 999999,
|
|
roster: [],
|
|
bonds: [],
|
|
inventory: {},
|
|
selectedSortieUnitIds: selected,
|
|
reserveTrainingFocus: 'balanced',
|
|
completedCampDialogues: [],
|
|
completedCampVisits: [],
|
|
battleHistory: {}
|
|
};
|
|
window.localStorage.clear();
|
|
window.localStorage.setItem('heros-web:campaign-state', JSON.stringify(state));
|
|
window.localStorage.setItem('heros-web:campaign-state:slot-1', JSON.stringify(state));
|
|
}, battle.selected);
|
|
await page.reload({ waitUntil: 'domcontentloaded' });
|
|
await page.waitForFunction(() => window.__HEROS_GAME__ !== undefined && window.__HEROS_DEBUG__ !== undefined, undefined, { timeout: 90000 });
|
|
await page.evaluate((battleId) => window.__HEROS_DEBUG__.goToBattle(battleId), battle.id);
|
|
await page.waitForFunction(
|
|
(battleId) => {
|
|
const state = window.__HEROS_DEBUG__?.battle();
|
|
return state?.scene === 'BattleScene' && state?.battleId === battleId && state?.phase === 'idle' && state?.mapBackgroundReady === true;
|
|
},
|
|
battle.id,
|
|
{ timeout: 90000 }
|
|
);
|
|
}
|
|
|
|
async function playBattleWithoutDebugVictory(page, battle) {
|
|
return page.evaluate(
|
|
async ({ no, id, maxRounds, targets, protected: protectedUnitIds }) => {
|
|
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
|
const scene = window.__HEROS_GAME__.scene.getScene('BattleScene');
|
|
const primaryTargetId = targets[0];
|
|
const targetIds = new Set(targets);
|
|
const protectedIds = new Set(protectedUnitIds);
|
|
const metrics = {
|
|
no,
|
|
id,
|
|
outcome: null,
|
|
finalTurn: 0,
|
|
alliesAlive: 0,
|
|
enemiesAlive: 0,
|
|
itemsUsed: 0,
|
|
supports: 0,
|
|
allyAttacks: 0,
|
|
enemyAttacks: 0,
|
|
objectivesAchieved: 0,
|
|
objectiveCount: 0,
|
|
protectedStatus: [],
|
|
targetStatus: [],
|
|
allyStatus: [],
|
|
enemyStatus: [],
|
|
battleLogTail: []
|
|
};
|
|
|
|
const state = () => window.__HEROS_DEBUG__.battle();
|
|
const distance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
|
|
const unitRef = (unitId) => scene.debugUnitById(unitId);
|
|
const liveUnits = (faction) =>
|
|
state()
|
|
.units.filter((unit) => unit.faction === faction && unit.hp > 0)
|
|
.map((unit) => unitRef(unit.id))
|
|
.filter(Boolean);
|
|
const actedUnitIds = () => new Set(state().actedUnitIds ?? []);
|
|
const syncUnit = (unit) => {
|
|
scene.positionUnitView?.(unit);
|
|
scene.updateMiniMap?.();
|
|
};
|
|
const resolveOutcome = () => scene.resolveBattleOutcomeIfNeeded?.();
|
|
|
|
function withUnitAt(unit, tile, callback) {
|
|
const original = { x: unit.x, y: unit.y };
|
|
unit.x = tile.x;
|
|
unit.y = tile.y;
|
|
try {
|
|
return callback();
|
|
} finally {
|
|
unit.x = original.x;
|
|
unit.y = original.y;
|
|
}
|
|
}
|
|
|
|
function priorityForTarget(enemy) {
|
|
if (enemy.id === primaryTargetId) {
|
|
return 5200;
|
|
}
|
|
if (targetIds.has(enemy.id)) {
|
|
return 3400;
|
|
}
|
|
if (enemy.id.includes('leader')) {
|
|
return 1200;
|
|
}
|
|
if (enemy.id.includes('officer')) {
|
|
return 720;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
function focusTarget(unit) {
|
|
const aliveTargets = targets.map((targetId) => unitRef(targetId)).filter((target) => target && target.hp > 0);
|
|
if (aliveTargets.length > 0) {
|
|
return aliveTargets.sort((a, b) => distance(unit, a) - distance(unit, b))[0];
|
|
}
|
|
return liveUnits('enemy').sort((a, b) => priorityForTarget(b) - priorityForTarget(a) || distance(unit, a) - distance(unit, b))[0];
|
|
}
|
|
|
|
function attackChoice(unit) {
|
|
return liveUnits('enemy')
|
|
.filter((enemy) => scene.canAttack(unit, enemy))
|
|
.map((enemy) => {
|
|
const preview = scene.combatPreview(unit, enemy, 'attack');
|
|
const kill = preview.damage >= enemy.hp;
|
|
const priority = priorityForTarget(enemy);
|
|
return {
|
|
target: enemy,
|
|
preview,
|
|
score: priority + preview.damage * 10 + (kill ? 760 : 0) - enemy.hp - distance(unit, enemy) * 4
|
|
};
|
|
})
|
|
.sort((a, b) => b.score - a.score)[0];
|
|
}
|
|
|
|
function incomingThreat(unit, tile) {
|
|
return withUnitAt(unit, tile, () => {
|
|
const threats = [];
|
|
const nearbyEnemies = liveUnits('enemy')
|
|
.sort((a, b) => distance(a, tile) - distance(b, tile))
|
|
.slice(0, 10);
|
|
for (const enemy of nearbyEnemies) {
|
|
const original = { x: enemy.x, y: enemy.y };
|
|
const behavior = scene.enemyBehavior(enemy);
|
|
const target = scene.chooseEnemyTarget(enemy, behavior);
|
|
if (target) {
|
|
if (!scene.canAttack(enemy, target) && behavior !== 'hold') {
|
|
const destination = scene.chooseApproachTile(enemy, target);
|
|
if (destination) {
|
|
enemy.x = destination.x;
|
|
enemy.y = destination.y;
|
|
}
|
|
}
|
|
if (scene.canAttack(enemy, unit)) {
|
|
threats.push(scene.combatPreview(enemy, unit, 'attack').damage);
|
|
}
|
|
}
|
|
enemy.x = original.x;
|
|
enemy.y = original.y;
|
|
}
|
|
return threats.sort((a, b) => b - a).slice(0, 3).reduce((total, damage) => total + damage, 0);
|
|
});
|
|
}
|
|
|
|
function shouldPressProtected(unit) {
|
|
if (!protectedIds.has(unit.id)) {
|
|
return false;
|
|
}
|
|
const focus = focusTarget(unit);
|
|
const enemies = liveUnits('enemy');
|
|
const vanguardInPosition = liveUnits('ally').some(
|
|
(ally) => ally.id !== unit.id && !protectedIds.has(ally.id) && (!focus || distance(ally, focus) <= 10)
|
|
);
|
|
return (
|
|
!vanguardInPosition ||
|
|
(focus && targetIds.has(focus.id) && focus.hp <= Math.ceil(focus.maxHp * 0.3))
|
|
);
|
|
}
|
|
|
|
function canTakeAttack(unit, attack, threat = protectedIds.has(unit.id) ? incomingThreat(unit, unit) : 0) {
|
|
if (!protectedIds.has(unit.id)) {
|
|
return true;
|
|
}
|
|
const pressProtected = shouldPressProtected(unit);
|
|
const isTarget = targetIds.has(attack.target.id);
|
|
const kill = attack.preview.damage >= attack.target.hp;
|
|
if (isTarget && (threat <= Math.floor(unit.hp * (pressProtected ? 0.7 : 0.42)) || unit.hp >= Math.ceil(unit.maxHp * 0.8))) {
|
|
return true;
|
|
}
|
|
if (kill && threat <= Math.floor(unit.hp * (pressProtected ? 0.5 : 0.32))) {
|
|
return true;
|
|
}
|
|
return threat <= Math.floor(unit.hp * (pressProtected ? 0.28 : 0.18));
|
|
}
|
|
|
|
function canPressProtectedTile(unit, tile, focus, currentDistance) {
|
|
const threat = incomingThreat(unit, tile);
|
|
if (threat <= Math.floor(unit.hp * 0.55)) {
|
|
return true;
|
|
}
|
|
const enemies = liveUnits('enemy');
|
|
return (
|
|
unit.hp >= Math.ceil(unit.maxHp * 0.95) &&
|
|
distance(tile, focus) < currentDistance &&
|
|
(enemies.length <= 8 || currentDistance <= 8 || (targetIds.has(focus.id) && focus.hp <= Math.ceil(focus.maxHp * 0.5)))
|
|
);
|
|
}
|
|
|
|
function chooseMove(unit) {
|
|
const tiles = [{ x: unit.x, y: unit.y, cost: 0 }, ...scene.reachableTiles(unit)];
|
|
const pressProtected = shouldPressProtected(unit);
|
|
const attackingTiles = tiles
|
|
.map((tile) =>
|
|
withUnitAt(unit, tile, () => {
|
|
const attack = attackChoice(unit);
|
|
return attack ? { tile, attack, threat: protectedIds.has(unit.id) ? incomingThreat(unit, tile) : 0 } : undefined;
|
|
})
|
|
)
|
|
.filter(Boolean);
|
|
|
|
const preferredAttackingTiles = protectedIds.has(unit.id)
|
|
? attackingTiles.filter((entry) => canTakeAttack(unit, entry.attack, entry.threat))
|
|
: attackingTiles;
|
|
|
|
if (preferredAttackingTiles.length > 0 && (!protectedIds.has(unit.id) || unit.hp >= Math.ceil(unit.maxHp * 0.45))) {
|
|
return preferredAttackingTiles.sort((a, b) => {
|
|
const threatWeight = protectedIds.has(unit.id) ? (pressProtected ? 4 : 8) : 2;
|
|
const aScore = a.attack.score + (targetIds.has(a.attack.target.id) ? 2400 : 1350) - a.threat * threatWeight;
|
|
const bScore = b.attack.score + (targetIds.has(b.attack.target.id) ? 2400 : 1350) - b.threat * threatWeight;
|
|
return bScore - aScore;
|
|
})[0].tile;
|
|
}
|
|
|
|
if (!protectedIds.has(unit.id) || pressProtected) {
|
|
const focus = focusTarget(unit);
|
|
if (focus) {
|
|
const currentDistance = distance(unit, focus);
|
|
const pressureTile = tiles
|
|
.filter((tile) => distance(tile, focus) < currentDistance)
|
|
.filter((tile) => !pressProtected || canPressProtectedTile(unit, tile, focus, currentDistance))
|
|
.sort((a, b) => distance(a, focus) - distance(b, focus) || (a.cost ?? 0) - (b.cost ?? 0))[0];
|
|
if (pressureTile) {
|
|
return pressureTile;
|
|
}
|
|
}
|
|
}
|
|
|
|
let best = { tile: tiles[0], score: Number.NEGATIVE_INFINITY };
|
|
|
|
for (const tile of tiles) {
|
|
const score = withUnitAt(unit, tile, () => {
|
|
const attack = attackChoice(unit);
|
|
const focus = attack?.target ?? focusTarget(unit);
|
|
const isProtected = protectedIds.has(unit.id);
|
|
const shouldPress = isProtected && shouldPressProtected(unit);
|
|
const approach = focus ? -distance(unit, focus) * (isProtected ? (shouldPress ? 42 : 5) : 36) : 0;
|
|
const attackScore = attack ? attack.score + (targetIds.has(attack.target.id) ? 2400 : 1350) : approach;
|
|
const allySupport = liveUnits('ally').filter((ally) => ally.id !== unit.id && distance(unit, ally) <= 2).length * 16;
|
|
const threat = incomingThreat(unit, tile);
|
|
const nearestEnemyDistance = liveUnits('enemy')
|
|
.map((enemy) => distance(unit, enemy))
|
|
.sort((a, b) => a - b)[0] ?? 99;
|
|
const protectedFrontlinePenalty = isProtected && !shouldPress && nearestEnemyDistance <= 5 ? (6 - nearestEnemyDistance) * 1800 : 0;
|
|
const fragilePenalty = unit.hp - threat <= Math.max(5, Math.floor(unit.maxHp * 0.18)) ? (isProtected ? (shouldPress ? 420 : 900) : 260) : 0;
|
|
const threatWeight = isProtected ? (shouldPress ? 5 : 12) : 4;
|
|
return attackScore + allySupport - threat * threatWeight - fragilePenalty - protectedFrontlinePenalty - (tile.cost ?? 0) * 2;
|
|
});
|
|
|
|
if (score > best.score) {
|
|
best = { tile, score };
|
|
}
|
|
}
|
|
|
|
return best.tile;
|
|
}
|
|
|
|
function bestSupportAction(user) {
|
|
const injured = liveUnits('ally')
|
|
.filter((ally) => ally.hp < ally.maxHp)
|
|
.sort((a, b) => b.maxHp - b.hp - (a.maxHp - a.hp));
|
|
const options = [];
|
|
|
|
for (const command of ['item', 'strategy']) {
|
|
for (const usable of scene.availableUsables(user, command)) {
|
|
if (usable.effect !== 'heal') {
|
|
continue;
|
|
}
|
|
for (const target of injured) {
|
|
if (!scene.canUseSupportCommand(user, target, usable)) {
|
|
continue;
|
|
}
|
|
const missing = target.maxHp - target.hp;
|
|
const amount = scene.supportHealAmount(user, target, usable);
|
|
const urgent = target.hp <= Math.ceil(target.maxHp * 0.45);
|
|
if (!urgent && amount < 8 && missing < 10) {
|
|
continue;
|
|
}
|
|
options.push({ usable, target, score: amount * 12 + missing * 4 + (urgent ? 180 : 0) + (usable.command === 'item' ? 15 : 0) });
|
|
}
|
|
}
|
|
}
|
|
|
|
return options.sort((a, b) => b.score - a.score)[0];
|
|
}
|
|
|
|
function performSupport(user, support) {
|
|
if (support.usable.command === 'item' && !scene.consumeItem(user.id, support.usable.id)) {
|
|
return false;
|
|
}
|
|
scene.resolveSupportAction(user, support.target, support.usable);
|
|
scene.finishUnitAction(user, `QA support ${user.id} -> ${support.target.id}`);
|
|
metrics.supports += 1;
|
|
if (support.usable.command === 'item') {
|
|
metrics.itemsUsed += 1;
|
|
}
|
|
resolveOutcome();
|
|
return true;
|
|
}
|
|
|
|
function performAttack(attacker, target, side) {
|
|
const result = scene.resolveAttack(attacker, target);
|
|
result.counter = scene.resolveCounterAttack(result);
|
|
if (side === 'ally') {
|
|
scene.finishUnitAction(attacker, `QA attack ${attacker.id} -> ${target.id}`);
|
|
metrics.allyAttacks += 1;
|
|
} else {
|
|
metrics.enemyAttacks += 1;
|
|
}
|
|
resolveOutcome();
|
|
}
|
|
|
|
for (let round = 0; round < maxRounds; round += 1) {
|
|
let snapshot = state();
|
|
if (snapshot.battleOutcome) {
|
|
break;
|
|
}
|
|
|
|
const acted = actedUnitIds();
|
|
const allies = snapshot.units
|
|
.filter((unit) => unit.faction === 'ally' && unit.hp > 0 && !acted.has(unit.id))
|
|
.sort((a, b) => a.hp / a.maxHp - b.hp / b.maxHp);
|
|
|
|
for (const allyState of allies) {
|
|
snapshot = state();
|
|
if (snapshot.battleOutcome) {
|
|
break;
|
|
}
|
|
const unit = unitRef(allyState.id);
|
|
if (!unit || unit.hp <= 0 || actedUnitIds().has(unit.id)) {
|
|
continue;
|
|
}
|
|
|
|
const urgentSupport = bestSupportAction(unit);
|
|
if (urgentSupport && (unit.hp <= Math.ceil(unit.maxHp * 0.48) || urgentSupport.target.hp <= Math.ceil(urgentSupport.target.maxHp * 0.4))) {
|
|
if (performSupport(unit, urgentSupport)) {
|
|
await sleep(1);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
scene.selectedUnit = unit;
|
|
scene.phase = 'moving';
|
|
const tile = chooseMove(unit);
|
|
scene.moveSelectedUnit(tile.x, tile.y);
|
|
syncUnit(unit);
|
|
|
|
const attack = attackChoice(unit);
|
|
if (attack && canTakeAttack(unit, attack)) {
|
|
performAttack(unit, attack.target, 'ally');
|
|
} else {
|
|
const support = bestSupportAction(unit);
|
|
if (!support || !performSupport(unit, support)) {
|
|
scene.completeUnitAction(unit, `QA wait ${unit.id}`);
|
|
}
|
|
}
|
|
|
|
await sleep(1);
|
|
}
|
|
|
|
snapshot = state();
|
|
if (snapshot.battleOutcome) {
|
|
break;
|
|
}
|
|
|
|
scene.activeFaction = 'enemy';
|
|
for (const enemyState of snapshot.units.filter((unit) => unit.faction === 'enemy' && unit.hp > 0)) {
|
|
if (state().battleOutcome) {
|
|
break;
|
|
}
|
|
const enemy = unitRef(enemyState.id);
|
|
if (!enemy || enemy.hp <= 0) {
|
|
continue;
|
|
}
|
|
|
|
const behavior = scene.enemyBehavior(enemy);
|
|
let target = scene.chooseEnemyTarget(enemy, behavior);
|
|
if (!target) {
|
|
continue;
|
|
}
|
|
|
|
if (!scene.canAttack(enemy, target) && behavior !== 'hold') {
|
|
const destination = scene.chooseApproachTile(enemy, target);
|
|
if (destination) {
|
|
enemy.x = destination.x;
|
|
enemy.y = destination.y;
|
|
syncUnit(enemy);
|
|
}
|
|
}
|
|
|
|
target = scene.chooseTargetInRange(enemy) ?? target;
|
|
if (target && scene.canAttack(enemy, target)) {
|
|
performAttack(enemy, target, 'enemy');
|
|
}
|
|
}
|
|
|
|
if (state().battleOutcome) {
|
|
break;
|
|
}
|
|
|
|
scene.beginNextAllyTurn();
|
|
await sleep(1);
|
|
}
|
|
|
|
const finalState = state();
|
|
metrics.outcome = finalState.battleOutcome;
|
|
metrics.finalTurn = finalState.turnNumber;
|
|
metrics.alliesAlive = finalState.units.filter((unit) => unit.faction === 'ally' && unit.hp > 0).length;
|
|
metrics.enemiesAlive = finalState.units.filter((unit) => unit.faction === 'enemy' && unit.hp > 0).length;
|
|
metrics.objectiveCount = finalState.objectives.length;
|
|
metrics.objectivesAchieved = finalState.objectives.filter((objective) => objective.achieved).length;
|
|
metrics.protectedStatus = protectedUnitIds.map((unitId) => {
|
|
const unit = finalState.units.find((candidate) => candidate.id === unitId);
|
|
return unit ? `${unit.id}:${unit.hp}/${unit.maxHp}@${unit.x},${unit.y}` : `${unitId}:missing`;
|
|
});
|
|
metrics.targetStatus = targets.map((unitId) => {
|
|
const unit = finalState.units.find((candidate) => candidate.id === unitId);
|
|
return unit ? `${unit.id}:${unit.hp}/${unit.maxHp}@${unit.x},${unit.y}` : `${unitId}:missing`;
|
|
});
|
|
metrics.allyStatus = finalState.units
|
|
.filter((unit) => unit.faction === 'ally')
|
|
.map((unit) => `${unit.id}:${unit.hp}/${unit.maxHp}@${unit.x},${unit.y}`);
|
|
metrics.enemyStatus = finalState.units
|
|
.filter((unit) => unit.faction === 'enemy' && unit.hp > 0)
|
|
.map((unit) => `${unit.id}:${unit.hp}/${unit.maxHp}@${unit.x},${unit.y}`);
|
|
metrics.battleLogTail = finalState.battleLog.slice(-8);
|
|
return metrics;
|
|
},
|
|
{ no: battle.no, id: battle.id, maxRounds, targets: battle.targets, protected: battle.protected }
|
|
);
|
|
}
|
|
|
|
async function ensureLocalServer(url) {
|
|
if (await isServerReachable(url)) {
|
|
return undefined;
|
|
}
|
|
|
|
const child = spawn(pnpmCommand, ['dev'], {
|
|
cwd: process.cwd(),
|
|
shell: true,
|
|
stdio: 'ignore',
|
|
windowsHide: true
|
|
});
|
|
|
|
for (let attempt = 0; attempt < 120; attempt += 1) {
|
|
if (await isServerReachable(url)) {
|
|
return child;
|
|
}
|
|
await sleep(500);
|
|
}
|
|
|
|
child.kill();
|
|
throw new Error(`Could not start dev server at ${url}`);
|
|
}
|
|
|
|
async function isServerReachable(url) {
|
|
try {
|
|
const response = await fetch(url);
|
|
return response.ok;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function sleep(ms) {
|
|
return new Promise((resolve) => setTimeout(resolve, ms));
|
|
}
|