Ilia Denisov
969c0480ba
Engine wire change: Report.battle switched from []uuid.UUID to
[]BattleSummary{id, planet, shots} so the map can place battle
markers without N extra fetches. FBS schema + generated Go/TS
regenerated; transcoder + report controller updated; openapi
adds the BattleSummary schema with a freeze test.
Backend gateway forwards engine GET /api/v1/battle/:turn/:uuid as
/api/v1/user/games/{game_id}/battles/{turn}/{battle_id} (handler
plus engineclient.FetchBattle, contract test stub, openapi spec).
UI:
- BattleViewer (lib/battle-player/) is a logically isolated SVG
radial scene that consumes a BattleReport prop. Planet at the
centre, races on the outer ring at equal angular spacing, race
clusters by (race, className) with <class>:<numLeft> labels;
observer groups (inBattle: false) are not drawn; eliminated
races drop out and survivors re-distribute on the next frame.
- Shot line per frame: red on destroyed, green otherwise; erased
on the next frame. Playback controls: play/pause + step ± +
rewind + 1x/2x/4x speed (400/200/100 ms per frame).
- Page wrapper (lib/active-view/battle.svelte) loads BattleReport
via api/battle-fetch.ts; synthetic-gameId prefix routes to a
fixture loader, otherwise REST through the gateway. Always-
visible <ol> text protocol satisfies the accessibility ask.
- section-battles.svelte links every battle UUID into the viewer.
- map/battle-markers.ts: yellow X cross of 2 LinePrim through the
corners of the planet's circumscribed square (stroke width
clamps from 1 px at 1 shot to 5 px at 100+ shots); bombing
marker is a stroke-only ring (yellow when damaged, red when
wiped). Wired into state-binding.ts; click handler dispatches
battle clicks to the viewer and bombing clicks to the matching
Reports row.
- i18n keys for the viewer in en + ru.
Docs: ui/docs/battle-viewer-ux.md, FUNCTIONAL.md §6.5 + ru
mirror, ui/PLAN.md Phase 27 decisions + deferred TODOs (push
event, richer class visuals, animated re-distribution).
Tests: Vitest unit (radial layout + timeline frame builder +
marker stroke formula + marker primitives), Playwright e2e for
the viewer (Reports link → viewer, playback step, not-found),
backend engineclient FetchBattle (200 / 404 / bad input), engine
openapi freezes (BattleReport, BattleReportGroup,
BattleActionReport, BattleSummary, Report.battle items).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
89 lines
2.6 KiB
TypeScript
89 lines
2.6 KiB
TypeScript
// Battle-report fetcher used by the Battle Viewer page.
|
|
//
|
|
// Phase 27 ships the BattleViewer as a logically isolated component
|
|
// that accepts a `BattleReport` matching `pkg/model/report/battle.go`.
|
|
// This module owns the type mirror and a single `fetchBattle` entry
|
|
// point. In synthetic mode (development & e2e fixtures), the loader
|
|
// falls back to a local fixture so the UI tests don't depend on a
|
|
// running engine; otherwise it issues a real `GET` against the
|
|
// backend gateway route added in Phase 27 step 3.
|
|
|
|
import { isSyntheticGameId } from "./synthetic-report";
|
|
import { lookupSyntheticBattle } from "./synthetic-battle";
|
|
|
|
/**
|
|
* BattleReport is the wire shape returned by the engine endpoint
|
|
* `GET /api/v1/battle/:turn/:uuid` and forwarded by the backend
|
|
* gateway as `GET /api/v1/user/games/{game_id}/battles/{turn}/{battle_id}`.
|
|
* Fields mirror `pkg/model/report/battle.go`.
|
|
*/
|
|
export interface BattleReport {
|
|
id: string;
|
|
planet: number;
|
|
planetName: string;
|
|
races: Record<string, string>;
|
|
ships: Record<string, BattleReportGroup>;
|
|
protocol: BattleActionReport[];
|
|
}
|
|
|
|
export interface BattleReportGroup {
|
|
race: string;
|
|
className: string;
|
|
tech: Record<string, number>;
|
|
num: number;
|
|
numLeft: number;
|
|
loadType: string;
|
|
loadQuantity: number;
|
|
inBattle: boolean;
|
|
}
|
|
|
|
export interface BattleActionReport {
|
|
a: number;
|
|
sa: number;
|
|
d: number;
|
|
sd: number;
|
|
x: boolean;
|
|
}
|
|
|
|
export class BattleFetchError extends Error {
|
|
constructor(public readonly status: number, message: string) {
|
|
super(message);
|
|
this.name = "BattleFetchError";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* fetchBattle returns the `BattleReport` for the supplied game, turn,
|
|
* and battle id. In synthetic-report mode (DEV / e2e) the lookup is
|
|
* served from `synthetic-battle.ts`; otherwise the function calls the
|
|
* backend gateway route. Throws `BattleFetchError` with the upstream
|
|
* status on validation or transport failure.
|
|
*/
|
|
export async function fetchBattle(
|
|
gameId: string,
|
|
turn: number,
|
|
battleId: string,
|
|
): Promise<BattleReport> {
|
|
if (isSyntheticGameId(gameId)) {
|
|
const fixture = lookupSyntheticBattle(battleId);
|
|
if (fixture === null) {
|
|
throw new BattleFetchError(404, "battle not found");
|
|
}
|
|
return fixture;
|
|
}
|
|
const path = `/api/v1/user/games/${encodeURIComponent(gameId)}/battles/${turn}/${encodeURIComponent(battleId)}`;
|
|
const response = await fetch(path, {
|
|
headers: { Accept: "application/json" },
|
|
});
|
|
if (response.status === 404) {
|
|
throw new BattleFetchError(404, "battle not found");
|
|
}
|
|
if (!response.ok) {
|
|
throw new BattleFetchError(
|
|
response.status,
|
|
`battle fetch failed: ${response.status}`,
|
|
);
|
|
}
|
|
return (await response.json()) as BattleReport;
|
|
}
|