Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 kamilkrzywda
|
fdf6eb236a |
@@ -28,19 +28,12 @@ renders territorial ownership; the whole thing persists to SQLite and streams ov
|
||||
- Backend: Node 22 + Express — one process serving the built client, `/api` (REST), and `/sse`
|
||||
- Persistence: `better-sqlite3` (one row per game, full `GameState` as JSON)
|
||||
- Map: MapLibre GL (`maplibre-gl`) — remote OpenFreeMap `dark` basemap + a **sub-national**
|
||||
choropleth from `public/regions.geo.json` (1,796 sub-regions; feature `id` = `<ISO_A3>-<nn>`,
|
||||
`properties.parent` = the country's ISO_A3). Ownership is at **region-key** granularity
|
||||
(v0.19, #16 P1): every sub-region is addressed by a stable key from
|
||||
`public/region-keys.json`, `Nation.territory` holds those keys, and each sub-region is
|
||||
colored by its own owner. Since v0.21 (#16 P2) the LLM moves *individual* sub-regions
|
||||
across shared land borders (frontier-biased transfers, verified with the `getNeighbours`
|
||||
function-calling tool) instead of whole countries.
|
||||
choropleth from `public/regions.geo.json` (2,597 sub-regions; feature `id` = `<ISO_A3>-<nn>`,
|
||||
`properties.parent` = the country's ISO_A3). Ownership and the LLM stay at **country**
|
||||
granularity, so a sub-region inherits its parent country's owner color (see #16).
|
||||
- The LLM client is a thin OpenAI chat-completions wrapper over native `fetch` with an
|
||||
**injectable transport** (mirrors `mesh-bot/src/llm`), with two entry points: plain
|
||||
`chat()` and `chatWithTools()` — a bounded OpenAI function-calling loop (max 6 tool
|
||||
rounds, then one forced no-tools request) sharing the same retry/backoff/
|
||||
`reasoning_effort` machinery (see the LLM config note below). A deterministic **stub**
|
||||
transport (`LLM_STUB=1`) is used by all tests/e2e.
|
||||
**injectable transport** (mirrors `mesh-bot/src/llm`). A deterministic **stub** transport
|
||||
(`LLM_STUB=1`) is used by all tests/e2e.
|
||||
|
||||
## Layout
|
||||
|
||||
@@ -52,33 +45,22 @@ history/
|
||||
├── eslint.config.js # flat config (ESLint 9)
|
||||
├── tsconfig.json # strict; aliases @/ → src/, @shared/ → shared/
|
||||
├── vite.config.ts # dev server + proxy /api,/sse → :4321; @ / @shared aliases
|
||||
├── vitest.config.ts # unit tests (server/**/*.test.ts + scripts/**/*.test.ts; 151 tests)
|
||||
├── vitest.config.ts # unit tests (server/**/*.test.ts)
|
||||
├── playwright.config.ts # deterministic e2e (webServer runs npm run dev, LLM_STUB=1)
|
||||
├── index.html
|
||||
├── presets/ # 5 scenario JSON files + index.json (manifest)
|
||||
├── public/
|
||||
│ ├── countries.geo.json # 177 countries, id=ISO_A3 (input to the region generator)
|
||||
│ ├── regions.geo.json # 1,796 sub-regions, id=<ISO_A3>-<nn>, parent=ISO_A3 (the choropleth)
|
||||
│ ├── region-keys.json # feature id -> region key, 1,796 entries (the ownership/LLM address space, #16 P1)
|
||||
│ └── region-adjacency.json # region key -> bordering region keys, 1,796 entries (the getNeighbours data, #16 P2)
|
||||
├── scripts/ # the geo/manifest data pipeline — .mjs (turf allowed HERE only;
|
||||
│ │ # never imported by .ts): generate → coarsen → cleanup → smooth →
|
||||
│ │ # fill-gaps → build-region-keys → build-region-adjacency
|
||||
│ └── *.test.ts # turf-free vitest tests pinning the dataset + both manifests
|
||||
│ └── regions.geo.json # 2,597 sub-regions, id=<ISO_A3>-<nn>, parent=ISO_A3 (the choropleth)
|
||||
├── shared/ # NO runtime deps — the single source of truth
|
||||
│ ├── types.ts # domain types (Nation, GameState, RoundItem, Preset, …)
|
||||
│ └── protocol.ts # LLM TurnResult schema (incl. `unowned`, v0.22 #16 P3, and
|
||||
│ # `nationOps`, v0.23 #16 P4a; v0.24 #16 P4b) + AddAction/AddDiplomacy/RemoveQueueItem/
|
||||
│ # Jump + NationOp confirm/reject request types + pure helpers
|
||||
│ └── protocol.ts # LLM TurnResult schema + AddAction/AddDiplomacy/RemoveQueueItem/Jump request types + pure helpers
|
||||
├── server/
|
||||
│ ├── index.ts # Express: /api/* (health|action|diplomacy|queue/remove|jump|advisor|
|
||||
│ │ # nation-op/confirm|nation-op/reject|games|map|presets), /sse/:id; reads
|
||||
│ │ # PORT/LLM_*/DATA_DIR
|
||||
│ ├── engine.ts # pure: prompts / parse+validate / applyTurnResult (sole-ownership + no-man's-land releases, v0.22 #16 P3) / runTurn (tool path + plain fallback) / getNeighbours tool + executor / playerFrontier / queue ops / advisor / nation-op ops (resolveNationRef / freshNationId / NEW_NATION_STATS / applyNationOp rename+split+merge / confirmNationOp / rejectNationOp, v0.23 #16 P4a; v0.24 #16 P4b)
|
||||
│ ├── llm.ts # LlmClient: chat() + chatWithTools() (bounded function-calling loop), injectable transport, retry+backoff, logging + env config
|
||||
│ ├── regions.ts # turf-free region-key data access: load manifest/geo/adjacency (public/ then dist/), country→keys expansion, reference table, neighboursOf/hasAdjacency
|
||||
│ ├── stub.ts # deterministic LLM transport (tests/e2e): one frontier conquest per turn + ADVISOR_MARKER
|
||||
│ ├── map.ts # GameState → RegionMap (region key → owner + stable color)
|
||||
│ ├── index.ts # Express: /api/* (action|diplomacy|queue/remove|jump|advisor|games|presets), /sse/:id; reads PORT/LLM_*/DATA_DIR
|
||||
│ ├── engine.ts # pure: buildPrompt / parse+validate / applyTurnResult / runTurn / queueRoundItem / removeRoundItem / advisor
|
||||
│ ├── llm.ts # LlmClient (injectable transport, retry+backoff, logging) + env config
|
||||
│ ├── stub.ts # deterministic LLM transport (tests/e2e) + ADVISOR_MARKER
|
||||
│ ├── map.ts # GameState → RegionMap (ISO_A3 → owner + stable color)
|
||||
│ ├── presets.ts # load preset JSON files from disk
|
||||
│ ├── db.ts # SQLite open/save/load
|
||||
│ └── *.test.ts # unit tests (vitest)
|
||||
@@ -95,8 +77,7 @@ history/
|
||||
├── PresetPicker.tsx / NationSelect.tsx # home + nation pick screens
|
||||
├── WorldMap.tsx # MapLibre basemap + choropleth + click→dossier + hover tooltip + player highlight
|
||||
├── NationPanel.tsx # a nation's stats/territory/diplomacy dossier
|
||||
├── ActionPanel.tsx # tabs: Action / Diplomacy / Advisor + pending-queue list (per-item trash button + confirm dialog) + "Jump forward" + "Nation proposals" trigger (v0.23 #16 P4a)
|
||||
├── NationOpDialog.tsx # review LLM-proposed nation ops (rename/split/merge) — confirm (editable rename/merge name, split successor radio) or reject (v0.24 #16 P4b)
|
||||
├── ActionPanel.tsx # tabs: Action / Diplomacy / Advisor + pending-queue list (per-item trash button + confirm dialog) + "Jump forward"
|
||||
├── EventFeed.tsx # scrolling event log (newest first)
|
||||
├── FloatingWindow.tsx # the HUD window primitive — free-floating (draggable, position persisted), or `pinned` (fixed top-center bar), or `dock`ed (full-height left/right column); renders dock controls when `onDockChange` is set
|
||||
├── StatBar.tsx
|
||||
@@ -110,11 +91,10 @@ history/
|
||||
| `npm run dev` | Express on :4321 (tsx watch) + Vite on :5173 (proxies `/api`,`/sse`) concurrently |
|
||||
| `npm run build` | `vite build` (client → `dist/`) then `tsup server/index.ts` → `server/dist/index.js` |
|
||||
| `npm start` | run the compiled server (`node server/dist/index.js`) on :4321 |
|
||||
| `npm test` | vitest unit tests (`server/` + `scripts/`; 151 tests) |
|
||||
| `npm test` | vitest unit tests in `server/` (39 tests) |
|
||||
| `npm run typecheck` | `tsc --noEmit` (strict) across src/server/shared/e2e/configs |
|
||||
| `npm run lint` | ESLint flat config |
|
||||
| `npm run e2e` | Playwright, fully deterministic (`LLM_STUB=1`); **runs in CI on every PR** (see below) |
|
||||
| `npm run build:region-keys` / `build:region-adjacency` | (re)generate the `public/region-keys.json` / `region-adjacency.json` manifests — deterministic + idempotent (byte-identical re-run) |
|
||||
| `docker compose up -d --build` | prod image on :4321, routed via Traefik at `history.dev.kkhost.pl` |
|
||||
|
||||
**Local verification (before every PR):** `npm run typecheck` + `npm run lint` + `npm test` (unit) + `npm run build`. The full **e2e** suite (`npm run e2e`) is verified by **CI on every PR** (the Playwright config boots its own dev webServer with `LLM_STUB=1`) — locally you only need the four checks above; e2e is the CI source of truth.
|
||||
@@ -163,101 +143,29 @@ history/
|
||||
(model down) surfaces as an HTTP 502 to the client (shown as a toast).
|
||||
- **Stable per-nation colors.** `shared.nationColor(id)` hashes a nation id → hue, shared by the
|
||||
server's `RegionMap` and any client coloring so the choropleth always agrees.
|
||||
- **Region-level territory (v0.19/v0.21, #16 P1+P2).** Since v0.19 ownership lives at sub-region
|
||||
granularity: `Nation.territory` holds **region keys** (`<name-slug>-<4char>`, e.g. `moselle-rygy`;
|
||||
the manifest is `public/region-keys.json`), `server/regions.ts` expands each preset's country list
|
||||
to all its sub-regions' keys at game creation, and `buildRegionMap` keys the choropleth `RegionMap`
|
||||
by region key. Since v0.21 transfers are **frontier-biased**: `applyTurnResult` is snapshot-first
|
||||
and enforces **sole ownership** (a key transfers only when exactly one nation claims it to gain,
|
||||
it has exactly one current owner, and the owner is not the gainer — a double claim is rejected and
|
||||
a lone `lose` is a no-op, so a key can never be orphaned or duplicated), and the LLM can call the
|
||||
`getNeighbours` tool (`GET_NEIGHBOURS_TOOL` + `makeNeighboursExecutor` in `engine.ts`, data from
|
||||
`public/region-adjacency.json` via `neighboursOf`) to verify land borders before proposing a
|
||||
transfer; the user payload carries the player's `frontier` (the sorted other-nation keys bordering
|
||||
the player's territory, via `playerFrontier`). The tool path degrades gracefully: without the
|
||||
adjacency manifest (or with a client lacking `chatWithTools`), a turn runs the legacy plain
|
||||
`chat()` path and the tool/frontier simply switch off. Since v0.22 (#16 P3) a key may also end
|
||||
a turn **unowned** — "no man's land": `TurnResult.unowned` lists keys released this turn;
|
||||
`applyTurnResult` applies releases FIRST (a key leaves its sole owner — only a key with exactly
|
||||
one current owner can be released; a never-assigned or corrupt key is a no-op), then claims
|
||||
against the post-release snapshot, so a `gain` on an ownerless key is a **re-claim** (granted to
|
||||
the sole gainer and removed from the cumulative `GameState.unowned` list). The user payload
|
||||
carries the current `GameState.unowned` as `unowned`, and the jump route's `regions` reference
|
||||
table includes those keys so the model can name them when re-claiming. The map renders a
|
||||
released key in the distinct visible grey (`NO_MANS_LAND_FILL` in `shared/protocol.ts`, with a
|
||||
"No man's land" tooltip sub-line) while a preset-unassigned key keeps the faint look ("No owner")
|
||||
— the distinction is decided by the client from `GameState.unowned` (via `regionFillStyle` /
|
||||
`unownedTooltipLabel`), never by the `RegionMap`, which only knows "owned" vs "absent". A fresh
|
||||
game always starts with `unowned: []` (legacy SQLite rows load with it defaulted).
|
||||
- **Nation ops — “LLM proposes, player confirms” (v0.23, #16 P4a; v0.24, #16 P4b).**
|
||||
`TurnResult.nationOps` (required in the schema) carries the LLM’s proposed **`NationOp`s** — a
|
||||
discriminated union of `rename` / `split` / `merge`, all three of which are now applied on confirm
|
||||
(P4b implemented split/merge). Each op names its target via `nationRef` — the LLM may use a
|
||||
nation’s **id or name**; `resolveNationRef` resolves id-first, then a case-insensitive
|
||||
unique-name match, and returns `null` for an unknown or ambiguous ref (such ops are dropped
|
||||
defensively in `validateNationOps`, never thrown). A turn’s ops are appended to
|
||||
`GameState.pendingNationOps`, which is **never cleared on a turn commit** — pending proposals
|
||||
persist across turns until resolved (like the action queue). The player then decides per op via
|
||||
`POST /api/games/:id/nation-op/confirm` (`{index, edits?{name?, playerPart?}}`) or
|
||||
`.../nation-op/reject` (`{index}`): `confirmNationOp` applies the op to a clone — **rename** sets
|
||||
`Nation.name` to the edited value or, failing that, the proposed `to` (id / territory / relations /
|
||||
`playerNationId` stay valid, so a renamed player is re-named in place); **split** (the parent
|
||||
must resolve and have ≥2 named parts, else a no-op) partitions the parent’s region-key territory
|
||||
into new nations in parts order — each new nation gets a fresh id (`freshNationId`: first free of
|
||||
`n1`, `n2`, …) and the baseline `NEW_NATION_STATS` (not a copy of the parent’s), plus a copy of
|
||||
the parent’s relations; a key named by several parts goes to the first, and the parent’s
|
||||
unclaimed keys go to part 0 (in territory order), so sole ownership holds and nothing is
|
||||
orphaned; if the parent was the player’s nation, `playerNationId` moves to the part chosen by
|
||||
`edits.playerPart` (clamped into range, default 0), which also receives `edits.name`; **merge**
|
||||
(every ref must resolve, ≥2 DISTINCT inputs, and the survivor must be one of them, else a
|
||||
no-op) folds the inputs into the survivor, which keeps its id and its own stats, gains the
|
||||
union of the inputs’ territories (the survivor’s keys first) and a union of their relations
|
||||
(the survivor’s own view of a third party wins, else the first input’s), is renamed
|
||||
`edits.name` → `into` → its own name, while the other inputs are removed and their ids dropped
|
||||
from every remaining nation’s relations maps; if the player led a removed input,
|
||||
`playerNationId` moves to the survivor. An op that is invalid at confirm time (an ambiguous ref,
|
||||
…) is a no-op on the world but is still removed — and `rejectNationOp` just drops it; both
|
||||
splice by index and bump `version` once (an invalid index → `null` → HTTP 400). The response is
|
||||
`{ game }` and the server broadcasts a version-bumped SSE `state`, so every tab’s
|
||||
version-guarded `applyState` stays in sync. The client lists the pending ops in a “Nation
|
||||
proposals” dialog (in the “Your move” panel): a rename and a merge show an editable name field
|
||||
(the merge also highlights the survivor among the input chips); a split lists each part (name +
|
||||
proposed region count) with a successor radio that appears only when the parent is the player’s
|
||||
own nation (preselected part 0 — the choice is always valid). The system prompt documents all
|
||||
three op shapes as a proposal queue (at most 1–2 per turn, each narrated in events). The stub
|
||||
never proposes a nation op (`nationOps: []`), so this path is covered by unit tests only
|
||||
(`server/engine.test.ts`).
|
||||
- **Map click → dossier target (owner resolved from the RegionMap, by region key).**
|
||||
- **Map click → dossier target (owner resolved from the RegionMap, via the parent country).**
|
||||
Clicking a sub-region does NOT open a popup — it switches the dossier to that sub-region's
|
||||
owning nation (`focusNation(ownerId, {name})` in `App.tsx`, which also records which region was
|
||||
clicked for a small dossier label); the manual "Inspect" selector and a map click both set the
|
||||
same target and stay in sync (a manual pick clears the label). Ownership is resolved from the
|
||||
authoritative `RegionMap` (keyed by **region key**) via the feature's stamped
|
||||
`properties.regionKey`, using the shared `mapFeatureOwner()` helper (`shared/protocol.ts`) —
|
||||
`WorldMap` stamps each rendered feature with its key from `region-keys.json` when it builds the
|
||||
choropleth source. It must **never** be resolved from the feature's top-level `id` (MapLibre
|
||||
repacks it into a numeric index — the "no owner" bug, #6) nor from the raw sub-region `id` (not a
|
||||
`RegionMap` key). A sub-region whose key has no owner leaves the current dossier target
|
||||
unchanged — never a broken dossier. The hover path (a non-closeable tooltip showing the region
|
||||
name + owner chip + key stats) uses the same resolution. `properties.parent` is static
|
||||
geographic-origin data — never use it for ownership or display.
|
||||
**parent country's** owning nation (`focusNation(ownerId)` in `GameScreen`, which also records
|
||||
which region was clicked for a small dossier label); the manual "Inspect" selector and a map click
|
||||
both set the same target and stay in sync (a manual pick clears the label). Ownership is resolved
|
||||
from the authoritative `RegionMap` (keyed by the **parent country's** ISO_A3) via the feature's
|
||||
`properties.parent`, using the shared `mapFeatureOwner()` helper (`regionId` still holds the
|
||||
sub-region's own id, e.g. `FRA-03`). It must **never** be resolved from the feature's top-level
|
||||
`id` (MapLibre repacks it into a numeric index — the "no owner" bug, #6) nor from the sub-region
|
||||
`id` (not a `RegionMap` key). Sub-regions of a country with no `RegionMap` entry (unowned) leave
|
||||
the current dossier target unchanged — never a broken dossier. The hover path (a non-closeable
|
||||
tooltip showing the sub-region name + parent country + owner + key stats) uses the same resolution.
|
||||
**PR 2 of #16:** the map renders `regions.geo.json` (sub-national) but ownership/territory and the
|
||||
LLM stay at country level — a nation owns whole countries, so all its sub-regions share the country's
|
||||
color, and a whole-country transfer flips all its sub-regions at once (PR 3 will make sub-regions
|
||||
individually ownable).
|
||||
- **Deterministic stub.** `server/stub.ts` answers the model contract deterministically per
|
||||
queued round item: each `action` item → one military/success event, each `diplomacy` item → one
|
||||
diplomatic/partial event, an empty round → one political "The world moves on" event. The player
|
||||
nation's `military` is set to `(current + 5)` (clamped) once per committed turn (not per item),
|
||||
the player is allied with the first other nation (by key order in the `nations` record), and the
|
||||
date advances 2 days. Since v0.21 the stub also makes **one contiguous conquest per turn**: the
|
||||
player gains `frontier[0]` (the first of the sorted `frontier` list from the prompt payload —
|
||||
stable) and that region's owner loses it; an empty frontier (no controllable border, e.g. the UK
|
||||
in `wwii-1939`) transfers nothing. Since v0.22 (#16 P3) the stub **never releases** a region to
|
||||
no man's land (it always returns `unowned: []` and ignores the payload's `unowned` field) — its
|
||||
one-conquest behavior is what the e2e assertions rely on, so the release/re-claim path is
|
||||
covered by unit tests only (`server/engine.test.ts`, `server/map.test.ts`). Since v0.23 (#16 P4a)
|
||||
the stub also returns `nationOps: []` — it **never proposes** a nation op (rename/split/merge;
|
||||
still true since P4b implemented split/merge), so the confirm/reject path is covered by unit
|
||||
tests only, mirroring the P3 approach; all e2e assertions are unaffected. The stub answers plain `content` (never tool calls), so it naturally
|
||||
bypasses the tool loop in a single round. Unit + e2e assertions rely on these exact values, so
|
||||
keep the stub deterministic.
|
||||
date advances 2 days. Unit + e2e assertions rely on these exact values, so keep the stub
|
||||
deterministic.
|
||||
- **HUD layout.** The game screen is a full-viewport map (z-0) with `FloatingWindow` overlays. The
|
||||
top bar is **pinned** — a fixed, non-movable bar centered at the top a few px down (it re-centers
|
||||
on resize and always floats above the other windows). The **dossier / event-feed / action**
|
||||
@@ -300,12 +208,6 @@ history/
|
||||
> ignoring `reasoning`. `chat()` retries transient failures (timeout/abort, 5xx, network
|
||||
> errors, null/empty `content`) up to 3 attempts with 2s→3s backoff and logs every call
|
||||
> (`[llm] chat ok` / `[llm] chat failed`). No auth header is sent — the endpoint requires no key.
|
||||
> The same machinery backs `chatWithTools()` (the function-calling loop used by turns when the
|
||||
> region-adjacency manifest is loaded): a `finish_reason: "tool_calls"` response is a *successful*
|
||||
> round (never a truncation error), each requested tool call is run through the injected executor,
|
||||
> the assistant tool-call message plus one `tool` result message per call are appended to the
|
||||
> history, and the loop re-sends until a final `content` — max `DEFAULT_MAX_TOOL_ROUNDS = 6`
|
||||
> tool rounds, after which one last *no-tools* request forces the answer.
|
||||
| `PORT` | `4321` | single server port |
|
||||
| `DATA_DIR` | `./data` | where `history.db` lives |
|
||||
| `CLIENT_DIST` | `./dist` | built client to serve (auto-found) |
|
||||
@@ -345,10 +247,6 @@ history/
|
||||
caught.
|
||||
- **`better-sqlite3`** is the only native module; the Docker build relies on its prebuilt binary
|
||||
(works on `node:22-slim`/glibc). It's the sole `--external` in the tsup server bundle.
|
||||
- The `dist/` client is committed to the build output only; the `public/` data files
|
||||
(`regions.geo.json` — the choropleth — `region-keys.json` + `region-adjacency.json` — the
|
||||
ownership/adjacency manifests — and `countries.geo.json`) are copied into `dist/` by Vite at
|
||||
build time, so the prod image serves them from `dist/` (no separate copy). The server's region
|
||||
loader (`server/regions.ts`) probes `public/` then `dist/` for the manifest pair, because the
|
||||
Docker image keeps only `dist/` (the v0.20 fix — before it, region-level ownership silently
|
||||
never activated in prod).
|
||||
- The `dist/` client is committed to the build output only; the `public/` geo files
|
||||
(`regions.geo.json` — the choropleth — and `countries.geo.json`) are copied into `dist/` by Vite
|
||||
at build time, so the prod image serves them from `dist/` (no separate copy).
|
||||
|
||||
+9
-58
@@ -2,64 +2,15 @@
|
||||
|
||||
All notable changes to **History** are listed here, newest first.
|
||||
|
||||
## v0.24.0 — 2026-10-14 13:41
|
||||
- **Part 4b of #16: nation splits and merges — "LLM proposes, player confirms" is now complete.** P4a let the LLM propose a *rename* (a safe, single-field change). Now the same confirm/reject flow actually applies the two destructive ops: a **split** (one nation dissolves into several) and a **merge** (several nations fold into one). This is the last piece of #16 — all three `NationOp` kinds are now applied on player confirm.
|
||||
- **Split (`server/engine.ts`).** `applyNationOp` now handles `kind: "split"`: it resolves the parent `nationRef` and requires **≥2** named parts (fewer → a safe no-op, the op is still resolved and removed). It partitions the parent's **region-key** territory across the parts **in order** — each part gets the keys of its `territory` that the parent actually owns and that no earlier part claimed (the **first part to name a key wins**, so a key is never held twice); any of the parent's keys no part claimed go to **part 0** (in the parent's territory order), so nothing is orphaned. Each new nation gets a **fresh id** (`freshNationId`: first free of `n1`, `n2`, …, tracked in a running `taken` set so ids never collide within the op), the baseline `NEW_NATION_STATS` (a neutral 50/50/50/50 profile — *not* a copy of the parent's, since a small rump state is not the parent's power), a copy of the parent's relations, and the parent's `type`; the parent is then removed and its id dropped from every other nation's relations map (`dropRelationsTo`). If the **parent was the player's nation**, `playerNationId` moves to the chosen part (`edits.playerPart`, clamped into range, default 0) — that same part also receives an `edits.name` override.
|
||||
- **Merge (`server/engine.ts`).** `kind: "merge"`: every input ref and the survivor ref must resolve, at least **two distinct** inputs are required, and the **survivor must be one of the inputs** — any failure is a safe no-op. The survivor keeps its **id** and its **own stats**; it gains the **union of all inputs' territories** (the survivor's keys first, then each other input's unclaimed keys in its own order) and a **union of the inputs' relations** (the survivor's own view of a third party wins, else the first input's); it is renamed to `edits.name` → `into` → its own name (in that precedence). The other inputs are removed and their ids dropped from every remaining nation's relations maps; if the **player led a removed input**, `playerNationId` moves to the survivor.
|
||||
- **Confirm contract extended (`shared/protocol.ts`).** `ConfirmNationOpRequest.edits` is now `{ name?: string; playerPart?: number }` — `name` overrides a rename's target or a merge's merged name; `playerPart` picks which new part the player's nation becomes in a split (default 0). The `SplitOp` / `MergeOp` / `NationOp` doc comments and the `TurnResult.nationOps` doc now describe the *applied* semantics (no longer "a no-op until P4b").
|
||||
- **Prompt (`server/engine.ts`).** The system prompt's JSON contract now shows all three `nationOps` shapes (rename / split / merge), and the HARD CONSTRAINTS gain one line per op explaining when to use it and the "≥2 parts" / "survivor must be an input" rules — so the model knows what it may propose and that each is a player-confirmed PROPOSAL.
|
||||
- **Client (`src/components/NationOpDialog.tsx`).** The dialog now renders all three kinds with a Confirm button (no more "dismiss-only" split/merge rows): a **split** lists each part (name + the number of regions it was assigned) and, when the split's parent is the **player's own nation**, shows a **radio group** to pick which new part the player leads (preselected 0, so the choice is always valid); a **merge** shows the input nations as chips (the **survivor** highlighted) and an **editable name** for the merged state (defaulting to `into`). Rename keeps its editable-name behavior. The new `onConfirm(index, edits?)` signature threads `playerPart` through `ActionPanel` and `App.tsx` (`runConfirmNationOp`) to the API helper.
|
||||
- **Defensive invariants.** All ops are **pure and never throw**: an unresolvable or ambiguous ref, too few parts, or a survivor that isn't an input makes the op a no-op on the world (the proposal is still resolved and removed on confirm, mirroring P4a's ambiguous-ref behavior). **Sole ownership** is preserved by construction (a key lands in at most one new part / one survivor), and `playerNationId` is always re-pointed to a still-existing nation. The **stub is unchanged** — it still never proposes a nation op (`nationOps: []`) — so, like P4a/P4b before it, the new paths are covered by **unit tests only** and the e2e suite (CI, `LLM_STUB=1`) is unaffected.
|
||||
- **Tests (`server/engine.test.ts`).** New `freshNationId`, `applyNationOp (split)`, and `applyNationOp (merge)` suites: the partition (first-wins, leftovers-to-part-0, sole ownership, fresh ids/stats/relations, parent removed, relations cleanup, player-pointer move, clamped `playerPart`, `edits.name` on the chosen part), the merge (union territory, survivor stats, relations union with survivor-wins, removed ids dropped from everyone else, into-name, player-pointer move, and the four no-op guards), plus an updated prompt-contract test asserting all three op shapes. The old "split/merge is a no-op" P4a test is retargeted to a 1-part split. The unit suite grows **151 → 164**.
|
||||
- **Verification.** Typecheck, lint, **164 unit tests**, and the production build all pass. The e2e suite (CI, `LLM_STUB=1`) carries no nation-op assertions, so it stays green with the unchanged stub.
|
||||
- **Deploy:** manual `docker compose up -d --build` on the host (no `down -v`).
|
||||
- Part of #16 — major nation changes (P4b, the final part of the epic). #16 was already closed (2026-10-12, after P3 shipped); the PR references it for traceability the same way P4a's PR #38 did ("Part of #16" / "Related: #16") — no auto-close.
|
||||
|
||||
## v0.23.0 — 2026-10-14 12:58
|
||||
- **Part 4a of #16: nation renames — "LLM proposes, player confirms."** The LLM can now propose that a nation be renamed during a turn. Unlike stat/relation/territory changes (applied automatically), a rename is stored as a **pending proposal** (`GameState.pendingNationOps`) and only takes effect when the player **confirms** it (optionally editing the new name) or is dropped on **reject**. This is the first of the "major nation changes" the LLM may propose — the `NationOp` contract is stable now; **split** and **merge** are declared in the same union but are *accepted-and-stored, not applied* until P4b.
|
||||
- **New `NationOp` union (`shared/protocol.ts`).** `rename` / `split` / `merge`, discriminated by `kind`. Each names its target via a `nationRef` the LLM may give as either a nation **id** or **name**. `TurnResult.nationOps` is a **required** `NationOp[]` (the model's proposals this turn); the confirm/reject request types (`NationOpConfirmRequest` `{index, edits?{name?}}`, `NationOpRejectRequest` `{index}`, response `{game}`) live here too.
|
||||
- **`GameState.pendingNationOps` (`shared/types.ts`, type-only import of `NationOp`)** — the proposals awaiting the player's decision. A turn **appends** to it (never clears it on commit), so a proposal persists across turns until confirmed or rejected. Legacy SQLite rows and new games default it to `[]` (`server/db.ts`).
|
||||
- **Engine (`server/engine.ts`), all pure.** `resolveNationRef` resolves a `nationRef` id-first, then a case-insensitive unique-name match (returns `null` for unknown/ambiguous — never throws). `validateNationOps` drops invalid ops defensively. `applyTurnResult` keeps existing pending ops and appends the turn's valid ones (a rename-only turn is `isMeaningful`, so it survives the retry/nudge path). `applyNationOp` mutates a clone (rename → `Nation.name` = edited value or the proposed `to`; split/merge are no-ops for now). `confirmNationOp`/`rejectNationOp` splice by index and bump `version` once (invalid index → `null`). The system prompt (both tool-mode and plain-mode) gains the `nationOps` JSON field and the rename-proposal rule.
|
||||
- **Routes + client.** `POST /api/games/:id/nation-op/confirm` and `.../reject` (404 unknown game, 400 bad index), each returning `{ game }` and broadcasting a version-bumped SSE `state` — mirroring the existing queue add/remove routes. The "Your move" panel shows a "Nation proposals (N)" trigger that opens a dialog listing each pending op; a rename has an editable name field plus **Confirm**/**Reject**, and split/merge offer **Dismiss** (they aren't applied yet).
|
||||
- **Stub + tests.** The deterministic stub **never** proposes a nation op (`nationOps: []`), so this path is covered by **unit tests only** (mirroring the P3 no-man's-land approach) — `server/engine.test.ts` gains suites for `resolveNationRef`, `validateNationOps`, `applyNationOp`/confirm/reject (incl. an invalid-index 400 and the version-bump), and the prompt contract. The unit suite grows **127 → 151**; the e2e suite is unaffected.
|
||||
- **Verification.** Typecheck, lint, **151 unit tests**, and the production build all pass. The e2e suite (CI, `LLM_STUB=1`) has no nation-op assertions, so it stays green with the unchanged stub.
|
||||
- **Deploy:** manual `docker compose up -d --build` on the host (no `down -v`).
|
||||
- Part of #16 — major nation changes (P4a); #16 stays open (P4b: split/merge).
|
||||
|
||||
## v0.22.0 — 2026-10-14 12:02
|
||||
- **Part 3 of #16: no man's land — a region can be left unowned mid-game and re-claimed later.** After a war or cataclysm the LLM can leave a region without an owner: it lists the key in the new `TurnResult.unowned` field (and narrates the cause in `events`); the engine removes the key from its sole owner, and the region ends the turn ownerless. A later ordinary `gain` on that key is a **re-claim** — the key is granted to the (sole) gainer and removed from the no-man's-land list. A fresh game always starts fully owned (no man's land can only arise mid-game).
|
||||
- **Engine (`server/engine.ts`).** `applyTurnResult` applies **releases first**: a key is released only when it has exactly one current owner (0 owners — a preset never assigned it — is a no-op, so no man's land can never be fabricated from an ordinary unowned region; 2+ owners — corruption — is a no-op; already-unowned is a no-op). Claims are then resolved against the post-release ownership snapshot: sole gainer + sole owner ≠ gainer = a transfer (the v0.21 rules, unchanged); sole gainer + no owner = a re-claim; a double claim is still rejected. Invariants after every turn: no key sits in two or more territories, a released key sits in none, and `GameState.unowned` holds exactly the keys released mid-game. A lone release counts as `isMeaningful` (it survives the retry/nudge path instead of being replaced by the generic "unclear" result). The system prompt gains the JSON field, the no-man's-land rule (in both tool-mode and plain-mode), and the hard constraint that `unowned` may contain only region keys a nation currently owns. The user payload always carries the current `GameState.unowned` as `unowned` (even when empty), and the jump route's `regions` reference table now includes the released keys so the model can name them when re-claiming.
|
||||
- **New required `GameState.unowned` field** (`shared/types.ts`): the cumulative list of keys released mid-game. A no-man's-land region is **distinct from a preset-unassigned region** — the presets assign only ~25–30% of the 1,796 sub-regions (e.g. `wwii-1939` starts with 411 owned / 1,385 unowned), so ~1,300 ownerless regions exist at init; those keep the existing faint look, and only `GameState.unowned` keys get the distinct one. Legacy SQLite rows saved before v0.22 load with the field defaulted to `[]` (`server/db.ts`), and game creation sets it to `[]`.
|
||||
- **Map presentation (a new contract in `shared/protocol.ts`).** `regionFillStyle(owner, isNoMansLand)` + `unownedTooltipLabel` decide the look: an owned region is unchanged (nation color + `OWNED_STROKE`); a released region gets the distinct visible grey `NO_MANS_LAND_FILL = '#3f3f46'` (hue-less by construction, so it can never collide with a nation's `hsl(h 58% 46%)` color) with a brighter border (`NO_MANS_LAND_STROKE`) and the tooltip sub-line "No man's land"; every other ownerless region keeps the faint `rgba(148,163,184,0.05)` fill and "No owner". The client (`WorldMap`, via a new `unowned` prop from `App.tsx`) is the sole consumer of the distinction — the `RegionMap` simply has no entry for an unowned key (`buildRegionMap` is unchanged). Clicking a no-man's-land region does not change the dossier (there is no owner to focus), and a release/re-claim flashes like any other ownership change.
|
||||
- **Stub + tests.** The deterministic stub is deliberately **unchanged** — it never releases a region (it always returns `unowned: []` and ignores the payload's `unowned` field), because its one-conquest behavior is what the e2e assertions rely on; the release/re-claim path is therefore covered by **unit tests only** (a new `applyTurnResult (no man's land)` suite: release, re-claim, release+claim of the same key, a double claim on a released key, the four no-op release cases, a legacy state without the field, and a `runTurn` end-to-end test with a narrated release; new `buildUserPrompt`/`buildSystemPrompt` contract tests; a presentation-contract suite in `server/map.test.ts`; a legacy-row normalization test in `server/db.test.ts`). The unit suite grows **105 → 127**.
|
||||
- **No data-format wipe.** The `GameState` shape only gains a field that legacy rows load with, so existing saves remain compatible: the deploy is a plain `up -d --build` (no `down -v`).
|
||||
- **Verification.** Typecheck, lint, **127 unit tests**, and the production build all pass. The e2e suite (CI, `LLM_STUB=1`) carries no map-color/no-man's-land assertions, so it stays green with the unchanged stub.
|
||||
- **Deploy:** manual `docker compose up -d --build` on the host (no `down -v`).
|
||||
- Part of #16 — no man's land (P3); #16 stays open.
|
||||
|
||||
## v0.21.0 — 2026-10-14 10:37
|
||||
- **Part 2 of #16: territory now moves region-by-region along real land borders, and the LLM can verify borders with a live tool.** v0.19 made ownership region-keyed, but the model's `territoryChanges` were still applied wholesale — any key could jump to any nation, effectively moving whole countries. Now:
|
||||
- **Region-adjacency manifest (Stage 1).** `scripts/build-region-adjacency.mjs` (`npm run build:region-adjacency`) computes which of the 1,796 sub-regions share a land border: per candidate pair, a cheap bbox-proximity prefilter (0.05° gap reject) then a `@turf/boolean-intersects` arbiter. The output `public/region-adjacency.json` is symmetric and deduped — **1,796 entries, 4,470 border pairs (8,940 directed), max degree 19; 1,727 regions have ≥1 neighbour, 69 don't** — and is deterministic/idempotent (sha256 `e9f1d475…`; re-running is byte-identical). Vite copies it into `dist/` for prod; `server/regions.ts` loads it (turf-free — plain `JSON.parse`, no `@turf` import in any `.ts`) and degrades gracefully when it is missing.
|
||||
- **`getNeighbours` LLM tool (Stage 2).** `server/llm.ts` gains `LlmClient.chatWithTools` — a bounded OpenAI function-calling loop: on a `finish_reason: "tool_calls"` response the client runs the injected executor for every call, appends the assistant tool-call message plus one `tool` result message per call, and re-sends until a final `content` (max **6** tool rounds, then one last *no-tools* request forces the answer). It shares the retry/backoff/`reasoning_effort: "low"` machinery with `chat()`; a tool-call round is a success (never treated as truncation); malformed tool arguments become an `{"error":"invalid tool arguments…"}` tool message, so a bad model reply can never throw. `tools` is included in the request body only when non-empty, so plain `chat()` bodies (and their tests) are unchanged.
|
||||
- **Engine wiring.** `runTurn` takes an optional `getNeighbours` resolver — the server's jump route passes one only when the manifest loaded (`hasAdjacency()`). With both the resolver and a `chatWithTools`-capable client, the turn runs the tool path: the system prompt gains the contiguity rules (a nation may only GAIN a key that borders its own territory; every key has exactly one owner) and advertises the tool; the user payload gains a `frontier` field — the player's `playerFrontier`, the sorted/deduped set of *other-nation* keys bordering the player's territory (the natural targets of a player-led conquest). Without the manifest, or with a minimal chat-only client, the turn falls back to the legacy plain `chat()` path — everything keeps working, the tool/frontier simply switch off.
|
||||
- **Sole-ownership enforcement.** `applyTurnResult` now applies territory snapshot-first: before mutating anything it computes each key's current owner, and a key transfers only when (a) exactly one nation claims to gain it (a double claim is rejected — the key stays), (b) it has exactly one current owner (pre-existing double ownership is never touched), and (c) the owner is not the gainer (self-gain is a no-op). A transfer removes the key from all nations first, then grants it to the gainer; lone `lose` entries are no-ops. Every key therefore ends the turn with exactly one owner — it can never be orphaned or duplicated, and a bad model answer degrades to "no transfer", never to a corrupt map.
|
||||
- **Deterministic stub.** The stub now makes one contiguous conquest per turn: the player gains `frontier[0]` (sorted → stable) and its owner loses it. It answers plain content (no tool calls), so it naturally bypasses the tool loop in a single round; with an empty frontier (no controllable border — e.g. the UK in `wwii-1939`, whose only external neighbour is Ireland) nothing transfers and every existing e2e assertion stays stable.
|
||||
- **No data-format change — no save wipe.** The `TerritoryChange` wire shape is unchanged and saved games load as-is, so the deploy is a plain rebuild (no `down -v`).
|
||||
- **Verification.** Typecheck, lint, **105 unit tests** (79 baseline + 26 new: tool-loop protocol — echo, parsed executor args, bounded rounds, malformed args, retry; engine tool-path wiring + fallback; `playerFrontier`; executor degradation; sole-ownership invariants; `neighboursOf`/`hasAdjacency`), the production build, and all **14 e2e** tests pass.
|
||||
- **Deploy:** manual `docker compose up -d --build` on the host (no `down -v`).
|
||||
- Part of #16 — P3 (region rename/split/merge) and P4 follow; #16 stays open.
|
||||
|
||||
## v0.20.0 — 2026-10-14 09:30
|
||||
- **Fixed: v0.19.0's region-level ownership did not activate in the production image.** The server-side region loader (`server/regions.ts`) only looked for the manifest + geo in `public/`, but in the Docker image Vite copies `public/*` → `dist/` and no `public/` directory is kept — so `loadRegions` found nothing, `expandCountriesToKeys` degraded to a no-op, and freshly-created games kept raw ISO_A3 codes (`DEU`, `GBR,IRL,IND`, …) instead of expanding to region keys. The choropleth therefore still rendered whole-country ownership and the model's region-key contract was inactive in prod (the client's own `/region-keys.json` fetch still worked, because the client is served from `dist/`). `loadRegions` now probes `public/` (dev) then `dist/` (prod, == `clientDir`) and uses the first directory holding both files, so one build works in both environments. A new test covers the prod-only (`dist/`), dev (`public/`), and empty-root (no data) layouts.
|
||||
- **Deploy:** `docker compose down -v` (drops the `history-data` volume — pre-v0.19 saves were already dropped by v0.19.0 and are dropped again here) then `up -d --build`.
|
||||
|
||||
## v0.19.0 — 2026-10-14 09:14
|
||||
- **Region-level ownership foundation (Part 1 of #16): internal territory ownership flips from whole countries to individual sub-regions.** Previously a nation owned *whole countries* (a `territory` list of ISO_A3 codes) and every sub-region of a country shared the parent's color, so a single region could never change owner independently. Now each owned sub-region is addressed by a stable **region key** — `<name-slug>-<4char>`, e.g. `moselle-rygy`, `ain-lqtt`, `western-alun` — generated deterministically by `scripts/build-region-keys.mjs` into `public/region-keys.json` (**1,796 unique keys** over the 1,796 sub-regions). A key is a slug of the region's name (NFKD, diacritics stripped, lowercased, non-alphanumerics → `-`) plus a 4-character hash of the feature's stable id, salted on within-country name collisions, so it is stable, human-readable, and globally unique (a "western" collision group yields `western-alun` / `western-qwvr` / `western-adsp` / …; an accented name like Shkodër becomes `shkoder-gmnr`).
|
||||
- **The map, the model, and the LLM all now reason in region keys.** `Nation.territory` and the `RegionMap` are keyed by region key; the choropleth resolves each sub-region's owner by its stamped `properties.regionKey` (never the repacked numeric feature `id`, never the raw sub-region id — the #6 guard, now region-keyed). A new `server/regions.ts` (turf-free) loads the manifest + geo once at boot and **expands each nation's country list to all its sub-regions' keys at game creation**, so a fresh game shows every sub-region in its owner's color — visually identical to the old whole-country choropleth, but each sub-region is now individually addressable. The LLM prompt gains a `regions` reference table (region key → "<name> (parent ISO_A3)"), and `applyTurnResult` ignores any territory key not in the valid set, so a hallucinated key can't corrupt ownership.
|
||||
- **The dossier shows region names.** NationPanel's territory chips display each sub-region's human name (e.g. "Ain", "Wales", "Moselle") with the raw key in the tooltip / data attribute, instead of bare codes.
|
||||
- **⚠ Breaking — pre-v0.19 saved games are dropped.** The `territory` field's meaning changed from ISO_A3 country codes to region keys, so a game saved before this version can't be read by it. Deploy runs `docker compose down -v` (dropping the `history-data` volume) then `up -d --build`; there is no migration — start fresh after deploying.
|
||||
- **Supersedes the abandoned `feat/sub-region-territory` branch**, which prototyped raw feature-id keys (`DEU-03`); this version uses the slugged, human-readable key scheme instead.
|
||||
- **Verification.** Typecheck, lint, and the unit suite (now **71 tests across 7 files**: +`server/regions.test.ts`, a rewritten `server/map.test.ts`, +2 in `engine.test.ts`) all pass; the production build is clean. The deterministic `LLM_STUB` and the format-agnostic e2e suite (legend/stats/dates) are unchanged. **#16 stays open** — P2 (LLM tools / function-calling for reliable region ops) and the no-man's-land rename/split/merge phases follow.
|
||||
## v0.19.0 — 2026-10-13 22:02
|
||||
- **Sub-region-level territory (PR 3 of #16): ownership, the LLM, and the map all operate at individual sub-region granularity instead of whole-country.**
|
||||
- `Nation.territory` is now a list of **sub-region ids** (`FR-57`, `DE-BB`, `US-AK`, … — the feature ids of `regions.geo.json`) rather than ISO_A3 country codes. At game creation (`POST /api/games`) each preset nation's ISO_A3 list is expanded to all its sub-region ids by the new `server/regions.ts` (a turf-free module that loads `public/`/`dist/regions.geo.json` once at boot into a region-id index + a country→regions map). Games saved before v0.19 are transparently migrated to region-level territory on read (`db.load` → `migrateTerritoryToRegions` — idempotent, and a no-op when the geo is not loaded).
|
||||
- **The LLM contract follows the map:** a `TurnResult`'s `territoryChanges` now gain/lose sub-region ids, so a border can shift **one region at a time** — a gained region is moved out of whichever nation currently holds it, and a lost region with no matching gainer becomes unowned no-man's-land (the `applyTurnResult` splice logic was already format-agnostic and is unchanged). The user prompt carries a new top-level `regions` reference table — `{ id: "name (parent)" }` for every region id present in the world state — so the model can map an id it is considering to a real place; the system prompt's hard constraints now name sub-region ids (e.g. `FR-57`). **Prompt-size measurement (full `wwii-1939`: 7 nations, 411 regions): the complete user prompt is ≈ 24.7k chars / ≈ 6.2k tokens at start (≈ 26.4k / ≈ 6.6k with 8 recent events + a 2-item round) — far under the ~80k frontier limit, so the full `regions` table is always sent (no frontier-limited mode was needed).**
|
||||
- **The choropleth is now truly per-region:** a nation's color fills exactly the sub-regions it owns, so a single country can be visibly split between nations, and unowned sub-regions render grey. Click/hover ownership resolves via the feature's `properties.regionId` (now the RegionMap key) through the shared `mapFeatureOwner` in `shared/protocol`, and the territory-change flash lights up exactly the regions whose owner changed (`featuresByRegionIds`, replacing the country-expanding `featuresByParents`).
|
||||
- **Graceful degradation:** when the geo file is missing or unreadable the region maps stay empty and `hasRegionData()` is false, so expansion, migration, the prompt's `regions` table, and ownership resolution all fall back to the pre-v0.19 whole-country ISO_A3 behavior — the server still boots and the app still works (with a one-time console warning).
|
||||
- **The deterministic stub stays deterministic** and now also makes exactly one region-level move per non-empty round: the player annexes the lexicographically-first sub-region of the first other nation (by key order) — empty rounds make no move — so unit tests and e2e assert the exact region that changes hands.
|
||||
- **Tests:** new `server/regions.test.ts` (real-geo expansion/migration, the not-loaded fallback path, and the fixture seams); `server/map.test.ts` and `server/engine.test.ts` re-pinned to region-id fixtures, including the #6 regression guard (owner from `properties.regionId`, never the repacked numeric `feature.id`) and new `applyTurnResult` tests for prior-owner transfer, no-owner gain, and no-gainer lose.
|
||||
- Part of #16
|
||||
|
||||
## v0.18.0 — 2026-10-13 18:54
|
||||
- **Fixed a stale-owner display bug: the region hover tooltip and the dossier "Selected" label no longer print the static parent-country code (e.g. "FRA").** The GeoJSON `properties.parent` is a *static geographic-origin* field that never updates when a country is taken, yet it was rendered in the hover tooltip (as a sub-line and as a title fallback) and in the dossier's `Selected:` label (as a `(FRA)` suffix) — so a sub-region of a transferred country still displayed the old country's code next to the (correct) new owner. The tooltip now shows only the region name + the live owner chip (from the RegionMap) + key stats, and the dossier label shows only the region name. Ownership resolution still keys on `properties.parent` (unchanged) — only the display of it was removed.
|
||||
|
||||
+1
-3
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "history",
|
||||
"version": "0.24.0",
|
||||
"version": "0.19.0",
|
||||
"private": true,
|
||||
"type": "module",
|
||||
"description": "AI-driven alternate-history simulator — the LLM is the world engine (Pax Historia style).",
|
||||
@@ -14,8 +14,6 @@
|
||||
"cleanup:regions": "node scripts/cleanup-regions.mjs",
|
||||
"smooth:regions": "node scripts/smooth-regions.mjs",
|
||||
"fill:regions": "node scripts/fill-gaps.mjs",
|
||||
"build:region-keys": "node scripts/build-region-keys.mjs",
|
||||
"build:region-adjacency": "node scripts/build-region-adjacency.mjs",
|
||||
"typecheck": "tsc --noEmit",
|
||||
"lint": "eslint .",
|
||||
"e2e": "playwright test"
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,133 +0,0 @@
|
||||
/**
|
||||
* scripts/build-region-adjacency.mjs — build the precomputed region-adjacency
|
||||
* manifest: `public/region-adjacency.json` = `{ "<regionKey>": ["<neighbourKey>", ...], ... }`.
|
||||
*
|
||||
* For every sub-region (region key, see `public/region-keys.json`) this records
|
||||
* which *other* sub-regions it **borders** — i.e. shares an edge or a point with.
|
||||
* The result is the data behind the model's `getNeighbours` tool (P2 of #16):
|
||||
* given a set of region keys, the engine returns the union of their adjacency
|
||||
* entries (excluding the queried keys), so the LLM can plan *frontier-biased,
|
||||
* contiguous* territory transfers (a nation realistically gains/loses a region
|
||||
* it already abuts) instead of whole countries.
|
||||
*
|
||||
* Method — bounding-box-pruned polygon intersection (turf is allowed in .mjs
|
||||
* scripts; it is deliberately kept OUT of the TS typecheck program, see the
|
||||
* v0.17 note). For each unordered pair of regions (i < j) we first do a cheap
|
||||
* bbox-proximity reject with a small gap tolerance (adjacent regions' bboxes
|
||||
* touch, so their gap is ≈0), and only for the survivors do we run
|
||||
* `@turf/boolean-intersects`, which returns true exactly when the two
|
||||
* (Multi)Polygons share at least one point (edge or corner touch, or overlap).
|
||||
* A hit adds each key to the other's set — adjacency is recorded **symmetrically**
|
||||
* and **deduplicated** (a neighbour appears once even if the pair shares several
|
||||
* disjoint border segments).
|
||||
*
|
||||
* Output contract (asserted by scripts/region-adjacency.test.ts):
|
||||
* - one entry for **every** region key (including regions with no bordering
|
||||
* neighbours, e.g. isolated islands — their list is simply empty);
|
||||
* - adjacency is symmetric (A ∈ B's list ⟺ B ∈ A's list);
|
||||
* - no key lists itself.
|
||||
*
|
||||
* Deterministic + idempotent: the input files are fixed, the intersection test
|
||||
* is a pure geometric computation, and the output is written with keys and
|
||||
* neighbour lists both sorted — so a re-run rewrites a byte-identical file.
|
||||
*
|
||||
* Usage: `node scripts/build-region-adjacency.mjs` (or `npm run build:region-adjacency`).
|
||||
*/
|
||||
import { readFileSync, writeFileSync } from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import bbox from '@turf/bbox';
|
||||
import booleanIntersects from '@turf/boolean-intersects';
|
||||
import { feature } from '@turf/helpers';
|
||||
|
||||
const here = path.dirname(fileURLToPath(import.meta.url));
|
||||
const root = path.resolve(here, '..');
|
||||
|
||||
// "Close enough" bbox gap (degrees) for the cheap reject. Adjacent regions'
|
||||
// bboxes touch (gap ≈ 0); a small tolerance absorbs 4-dp coordinate rounding
|
||||
// and digitization fuzz. It only prunes work — it never affects correctness,
|
||||
// because `booleanIntersects` is the final arbiter (a pair is a neighbour only
|
||||
// if the polygons actually share a point).
|
||||
const GAP_DEG = 0.05; // ≈ 5.5 km
|
||||
|
||||
// --- load the geo + region-key manifest (plain parse; keys join feature->key) --
|
||||
const geo = JSON.parse(readFileSync(path.join(root, 'public', 'regions.geo.json'), 'utf8'));
|
||||
const idToKey = JSON.parse(readFileSync(path.join(root, 'public', 'region-keys.json'), 'utf8'));
|
||||
|
||||
// Region records in stable file order, keyed by their region key.
|
||||
const regions = [];
|
||||
for (const f of geo.features ?? []) {
|
||||
const id = f.id == null ? '' : String(f.id);
|
||||
const key = idToKey[id];
|
||||
if (!key) continue; // a geo feature with no manifest entry is skipped
|
||||
regions.push({ key, feature: feature(f.geometry), bbox: bbox(f.geometry) });
|
||||
}
|
||||
|
||||
if (regions.length === 0) {
|
||||
throw new Error('no regions with valid region keys — check regions.geo.json / region-keys.json');
|
||||
}
|
||||
|
||||
// bboxes are flat [minX, minY, maxX, maxY] (turf's BBox type).
|
||||
function bboxesClose(a, b) {
|
||||
return (
|
||||
a[0] <= b[2] + GAP_DEG && // a.w <= b.e + gap
|
||||
b[0] <= a[2] + GAP_DEG && // b.w <= a.e + gap
|
||||
a[1] <= b[3] + GAP_DEG && // a.s <= b.n + gap
|
||||
b[1] <= a[3] + GAP_DEG // b.s <= a.n + gap
|
||||
);
|
||||
}
|
||||
|
||||
// key -> set of neighbouring keys (deduped; a pair sharing several segments is
|
||||
// recorded once).
|
||||
const adj = new Map();
|
||||
for (const r of regions) adj.set(r.key, new Set());
|
||||
|
||||
let pairChecks = 0;
|
||||
let intersections = 0;
|
||||
for (let i = 0; i < regions.length; i++) {
|
||||
for (let j = i + 1; j < regions.length; j++) {
|
||||
if (!bboxesClose(regions[i].bbox, regions[j].bbox)) continue; // cheap reject
|
||||
pairChecks++;
|
||||
let touches = false;
|
||||
try {
|
||||
touches = booleanIntersects(regions[i].feature, regions[j].feature);
|
||||
} catch {
|
||||
touches = false; // a degenerate geometry pair is treated as non-adjacent
|
||||
}
|
||||
if (touches) {
|
||||
intersections++;
|
||||
adj.get(regions[i].key).add(regions[j].key);
|
||||
adj.get(regions[j].key).add(regions[i].key);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// --- write idempotently: keys sorted, neighbour lists sorted ------------------
|
||||
// Every region key gets an entry (an isolated island's list is simply empty).
|
||||
const manifest = {};
|
||||
for (const key of [...adj.keys()].sort()) {
|
||||
manifest[key] = [...adj.get(key)].sort();
|
||||
}
|
||||
|
||||
// Self-reference guard (can't happen — we only ever add the *other* region — but
|
||||
// assert it so a future regression is loud rather than silent).
|
||||
for (const [k, list] of Object.entries(manifest)) {
|
||||
if (list.includes(k)) throw new Error(`region ${k} lists itself as a neighbour`);
|
||||
}
|
||||
|
||||
writeFileSync(path.join(root, 'public', 'region-adjacency.json'), JSON.stringify(manifest, null, 2) + '\n');
|
||||
|
||||
// --- summary ------------------------------------------------------------------
|
||||
const totalEntries = Object.values(manifest).reduce((n, l) => n + l.length, 0);
|
||||
const withNeighbours = Object.values(manifest).filter((l) => l.length > 0).length;
|
||||
const maxDegree = Math.max(0, ...Object.values(manifest).map((l) => l.length));
|
||||
console.log(
|
||||
`[build-region-adjacency] wrote public/region-adjacency.json — ${Object.keys(manifest).length} region keys, ` +
|
||||
`${totalEntries / 2} border pairs (${totalEntries} directed entries), max degree ${maxDegree}, ` +
|
||||
`${withNeighbours} with ≥1 neighbour (${pairChecks} bbox-close pairs tested, ${intersections} intersect)`,
|
||||
);
|
||||
// A couple of human-checkable examples (highest-degree regions, stable order).
|
||||
const byDegree = Object.entries(manifest).sort((a, b) => b[1].length - a[1].length || a[0].localeCompare(b[0]));
|
||||
for (const [k, list] of byDegree.slice(0, 3)) {
|
||||
console.log(` e.g. ${k} (deg ${list.length}) → ${list.slice(0, 4).join(', ')}${list.length > 4 ? ', …' : ''}`);
|
||||
}
|
||||
@@ -1,158 +0,0 @@
|
||||
/**
|
||||
* scripts/build-region-keys.mjs — build the deterministic region-key manifest.
|
||||
*
|
||||
* Region ownership flips from whole-country (ISO_A3) to individual sub-region
|
||||
* granularity, but the LLM and the persisted `Nation.territory` list need a
|
||||
* *stable, human-readable, globally unique* identifier per sub-region. Raw
|
||||
* feature ids (`FR-57`) are opaque to the model, so we mint a readable key of
|
||||
* the form:
|
||||
*
|
||||
* <name-slug>-<4char> e.g. brittany-xk2a, western-alun
|
||||
*
|
||||
* where:
|
||||
* - <name-slug> = properties.name → NFKD → strip combining marks → lowercase
|
||||
* → a tiny fold table for the handful of letters NFKD does NOT decompose
|
||||
* (ə ø ð đ œ ł, the only non-folding letters present in this dataset)
|
||||
* → every non-alphanumeric run collapsed to a single '-' → leading/trailing
|
||||
* '-' trimmed.
|
||||
* - <4char> = a deterministic 4-letter lowercase code derived from the
|
||||
* feature's stable id (FNV-1a 32-bit → 4 base-26 chars). It is stable
|
||||
* (same id → same code on every run) because the key is persisted in
|
||||
* SQLite and shown to the LLM. Within any name-slug group (e.g. the six
|
||||
* regions all named "Western") the 4-char codes are made distinct by
|
||||
* re-deriving with a deterministic salt on collision, which guarantees the
|
||||
* full key is unique across all 1,796 regions.
|
||||
*
|
||||
* Output: `public/region-keys.json` — a `{ [stableFeatureId]: regionKey }`
|
||||
* object, e.g. `{ "FR-57": "brittany-xk2a" }`, in file (stable) order. The map
|
||||
* is looked up by the client (`WorldMap`) and the server (`map`/`presets`/
|
||||
* `engine`) to join a sub-region's stable id to its readable key.
|
||||
*
|
||||
* Builtins only — deliberately NO `@turf`/geojson import (importing one pulls
|
||||
* `@types/geojson` into the tsc program and breaks `WorldMap.tsx`; see the
|
||||
* v0.17 changelog note). Reads the geo file with plain `JSON.parse`.
|
||||
*
|
||||
* Idempotent: a re-run rewrites a byte-identical file (no timestamps, no
|
||||
* randomness, stable feature order, deterministic hash).
|
||||
*
|
||||
* Usage: `node scripts/build-region-keys.mjs` (or `npm run build:region-keys`).
|
||||
*/
|
||||
import { readFileSync, writeFileSync } from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
|
||||
const here = path.dirname(fileURLToPath(import.meta.url));
|
||||
const root = path.resolve(here, '..');
|
||||
|
||||
/**
|
||||
* Letters present in the dataset that NFKD does NOT decompose, and their
|
||||
* single/multi-letter ASCII equivalents, so their slugs aren't hyphen-soup.
|
||||
* Kept deliberately tiny + deterministic (only the six that actually occur).
|
||||
*/
|
||||
const FOLD = {
|
||||
'ə': 'a', // schwa
|
||||
'ø': 'o', // o-stroke
|
||||
'ð': 'd', // eth
|
||||
'đ': 'dj', // d-stroke
|
||||
'œ': 'oe', // oe ligature
|
||||
'ł': 'l', // l-stroke
|
||||
};
|
||||
|
||||
/**
|
||||
* Readable slug from a region name. NFKD decomposes + we strip the combining
|
||||
* marks, lowercase, fold the non-decomposing letters, collapse every other
|
||||
* non-alphanumeric run to one hyphen, and trim leading/trailing hyphens.
|
||||
*/
|
||||
function slug(name) {
|
||||
let s = name.normalize('NFKD').replace(/[\u0300-\u036f]/g, '');
|
||||
s = s.toLowerCase();
|
||||
s = [...s].map((ch) => FOLD[ch] ?? ch).join('');
|
||||
s = s.replace(/[^a-z0-9]+/g, '-');
|
||||
s = s.replace(/^-+|-+$/g, '');
|
||||
return s;
|
||||
}
|
||||
|
||||
/** FNV-1a 32-bit — a tiny, stable, pure string hash. */
|
||||
function fnv1a32(str) {
|
||||
let h = 0x811c9dc5;
|
||||
for (let i = 0; i < str.length; i++) {
|
||||
h ^= str.charCodeAt(i);
|
||||
h = (h * 0x01000193) >>> 0;
|
||||
}
|
||||
return h >>> 0;
|
||||
}
|
||||
|
||||
/** Spread a 32-bit hash across four lowercase letters (base 26 per byte). */
|
||||
function code4(h) {
|
||||
let out = '';
|
||||
for (let i = 0; i < 4; i++) {
|
||||
out += String.fromCharCode(97 + ((((h >>> (i * 8)) & 0xff) % 26)));
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/** The 4-char code for an id, deterministically salted on within-group collision. */
|
||||
function codeFor(id, used) {
|
||||
let code = code4(fnv1a32(id));
|
||||
let attempt = 0;
|
||||
while (used.has(code)) {
|
||||
attempt += 1;
|
||||
code = code4(fnv1a32(`${id}#${attempt}`));
|
||||
}
|
||||
return code;
|
||||
}
|
||||
|
||||
// --- load the region geo (plain parse; no geojson types) ---
|
||||
const geoFile = path.join(root, 'public', 'regions.geo.json');
|
||||
const geo = JSON.parse(readFileSync(geoFile, 'utf8'));
|
||||
const features = Array.isArray(geo?.features) ? geo.features : [];
|
||||
|
||||
if (features.length !== 1796) {
|
||||
throw new Error(`expected 1,796 regions, got ${features.length} — regions.geo.json changed; re-verify the region-key contract`);
|
||||
}
|
||||
|
||||
// Group features by their (computed) name-slug, preserving file order, so the
|
||||
// within-slug 4-char uniqueness resolution below is deterministic.
|
||||
const groups = new Map(); // slug -> array of { id }
|
||||
for (const f of features) {
|
||||
const id = f.id == null ? '' : String(f.id);
|
||||
const name = f.properties?.name;
|
||||
if (!id || typeof name !== 'string') {
|
||||
throw new Error(`region with id ${JSON.stringify(id)} has no usable name`);
|
||||
}
|
||||
const s = slug(name);
|
||||
if (!groups.has(s)) groups.set(s, []);
|
||||
groups.get(s).push({ id });
|
||||
}
|
||||
|
||||
// Assign keys, resolving 4-char collisions within each slug group.
|
||||
const manifest = {};
|
||||
for (const [s, ids] of groups) {
|
||||
const used = new Set();
|
||||
for (const { id } of ids) {
|
||||
manifest[id] = `${s}-${codeFor(id, used)}`;
|
||||
used.add(manifest[id].slice(-4));
|
||||
}
|
||||
}
|
||||
|
||||
// --- hard assertions (the test re-checks these against the committed file) ---
|
||||
const keys = Object.values(manifest);
|
||||
if (new Set(keys).size !== keys.length) {
|
||||
throw new Error(`region-key collision: ${keys.length} keys but only ${new Set(keys).size} unique`);
|
||||
}
|
||||
const KEY_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*-[a-z]{4}$/;
|
||||
for (const k of keys) {
|
||||
if (!KEY_RE.test(k) || !k.includes('-')) {
|
||||
throw new Error(`malformed region key: ${JSON.stringify(k)}`);
|
||||
}
|
||||
}
|
||||
|
||||
// --- write idempotently (stable order = insertion order = file order) ---
|
||||
const out = JSON.stringify(manifest, null, 2) + '\n';
|
||||
writeFileSync(path.join(root, 'public', 'region-keys.json'), out);
|
||||
|
||||
const western = Object.entries(manifest)
|
||||
.filter(([, k]) => k.startsWith('western-'))
|
||||
.sort((a, b) => a[0] < b[0] ? -1 : 1);
|
||||
console.log(`[build-region-keys] wrote public/region-keys.json — ${keys.length} unique region keys (1,796 expected)`);
|
||||
console.log(` western group: ${western.map(([id, k]) => `${id}=${k}`).join(', ')}`);
|
||||
@@ -1,87 +0,0 @@
|
||||
/**
|
||||
* scripts/region-adjacency.test.ts — validation for the committed
|
||||
* `public/region-adjacency.json` (built by `scripts/build-region-adjacency.mjs`).
|
||||
*
|
||||
* The manifest maps each region key to the list of region keys it **borders**
|
||||
* (shares an edge/point with). It is the data behind the model's `getNeighbours`
|
||||
* tool (v0.21, #16 P2), so it is a load-bearing data artifact — this test pins
|
||||
* its contract.
|
||||
*
|
||||
* Deliberately dependency-free: it reads the JSON with plain `fs`/`JSON.parse`
|
||||
* and never imports `@turf`/geojson types (importing one pulls `@types/geojson`
|
||||
* into the tsc program and breaks `WorldMap.tsx`; see the v0.17 changelog note).
|
||||
* Mirrors the style of `scripts/region-keys.test.ts`.
|
||||
*/
|
||||
import { readFileSync } from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { describe, expect, it } from 'vitest';
|
||||
|
||||
const here = path.dirname(fileURLToPath(import.meta.url));
|
||||
const root = path.resolve(here, '..');
|
||||
|
||||
function readJson(rel: string): Record<string, unknown> {
|
||||
return JSON.parse(readFileSync(path.join(root, rel), 'utf8'));
|
||||
}
|
||||
|
||||
describe('region-adjacency.json', () => {
|
||||
const adjacency = readJson('public/region-adjacency.json') as Record<string, string[]>;
|
||||
const manifest = readJson('public/region-keys.json') as Record<string, string>;
|
||||
const keys = new Set(Object.values(manifest));
|
||||
|
||||
it('has exactly one entry per region key (same key set as region-keys.json)', () => {
|
||||
const manifestKeys = new Set(Object.values(manifest));
|
||||
const adjacencyKeys = new Set(Object.keys(adjacency));
|
||||
expect(adjacencyKeys).toEqual(manifestKeys);
|
||||
expect(Object.keys(adjacency)).toHaveLength(keys.size);
|
||||
expect(adjacencyKeys.size).toBe(1796);
|
||||
});
|
||||
|
||||
it('every neighbour is itself a valid region key (referential integrity)', () => {
|
||||
for (const [key, neighbours] of Object.entries(adjacency)) {
|
||||
for (const n of neighbours) {
|
||||
expect(keys.has(n), `neighbour ${n} of ${key} is not a valid region key`).toBe(true);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('no region lists itself as a neighbour', () => {
|
||||
for (const [key, neighbours] of Object.entries(adjacency)) {
|
||||
expect(neighbours.includes(key), `${key} lists itself`).toBe(false);
|
||||
}
|
||||
});
|
||||
|
||||
it('adjacency is symmetric (A ∈ B ⟺ B ∈ A)', () => {
|
||||
let checked = 0;
|
||||
for (const [a, aList] of Object.entries(adjacency)) {
|
||||
const aSet = new Set(aList);
|
||||
for (const b of aList) {
|
||||
const bList = adjacency[b];
|
||||
expect(Array.isArray(bList), `${b} has no adjacency entry`).toBe(true);
|
||||
// A lists B, so B must list A.
|
||||
expect(bList!.includes(a), `${a} → ${b} but ${b} does not list ${a}`).toBe(true);
|
||||
checked++;
|
||||
}
|
||||
// And the converse: every neighbour B of A must be a key (implied above) —
|
||||
// also assert no *missing* reverse entry by checking the full set equality.
|
||||
const bSet = new Set(aSet);
|
||||
for (const b of aList) bSet.add(b);
|
||||
// Symmetry means a's set equals the set of {b : a ∈ b}.
|
||||
const reverse = Object.entries(adjacency)
|
||||
.filter(([, list]) => list.includes(a))
|
||||
.map(([k]) => k);
|
||||
expect(new Set(reverse).size, `asymmetric degree for ${a}`).toBe(aList.length);
|
||||
expect(new Set(aList).size).toBe(aSet.size); // no duplicate neighbours
|
||||
}
|
||||
expect(checked).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it('spot-checks known real bordering pairs', () => {
|
||||
// Brazil ↔ Peru (Acre borders Loreto) — a real, unambiguous land border.
|
||||
expect(adjacency['acre-ekzw']?.includes('loreto-ipkx')).toBe(true);
|
||||
expect(adjacency['loreto-ipkx']?.includes('acre-ekzw')).toBe(true);
|
||||
// France ↔ Germany (Moselle borders Baden-Württemberg) — another real border.
|
||||
expect(adjacency['moselle-rygy']?.includes('baden-wurttemberg-oyje')).toBe(true);
|
||||
expect(adjacency['baden-wurttemberg-oyje']?.includes('moselle-rygy')).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,61 +0,0 @@
|
||||
/**
|
||||
* scripts/region-keys.test.ts — validation for the committed `public/region-keys.json`.
|
||||
*
|
||||
* The manifest maps each sub-region's **stable feature id** (from
|
||||
* `public/regions.geo.json`) to a deterministic, human-readable, globally
|
||||
* unique region key of the form `<name-slug>-<4char>` (built by
|
||||
* `scripts/build-region-keys.mjs`). Region-level ownership (v0.19) keys both
|
||||
* `Nation.territory` and the `RegionMap` on these keys, so the manifest is a
|
||||
* load-bearing data artifact — this test pins its contract.
|
||||
*
|
||||
* Deliberately dependency-free: it reads both JSON files with plain
|
||||
* `fs`/`JSON.parse` and never imports `@turf`/geojson types (importing one
|
||||
* pulls `@types/geojson` into the tsc program and breaks `WorldMap.tsx`; see
|
||||
* the v0.17 changelog note). Mirrors the style of `scripts/regions.test.ts`.
|
||||
*/
|
||||
import { readFileSync } from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { describe, expect, it } from 'vitest';
|
||||
|
||||
const here = path.dirname(fileURLToPath(import.meta.url));
|
||||
const root = path.resolve(here, '..');
|
||||
|
||||
function readJson(rel: string): Record<string, unknown> {
|
||||
return JSON.parse(readFileSync(path.join(root, rel), 'utf8'));
|
||||
}
|
||||
|
||||
describe('region-keys.json', () => {
|
||||
const manifest = readJson('public/region-keys.json') as Record<string, string>;
|
||||
const geo = readJson('public/regions.geo.json') as {
|
||||
features?: Array<{ id?: string | number }>;
|
||||
};
|
||||
const keys = Object.values(manifest);
|
||||
const featureIds = (geo.features ?? []).map((f) => String(f.id));
|
||||
|
||||
it('has exactly 1,796 entries (one per region)', () => {
|
||||
expect(Object.keys(manifest)).toHaveLength(1796);
|
||||
});
|
||||
|
||||
it('has 1,796 unique keys (no collisions)', () => {
|
||||
expect(new Set(keys).size).toBe(keys.length);
|
||||
expect(new Set(keys).size).toBe(1796);
|
||||
});
|
||||
|
||||
it('keys each end in -[a-z]{4} and contain at least one hyphen', () => {
|
||||
const ending = /-[a-z]{4}$/;
|
||||
for (const k of keys) {
|
||||
expect(k, `key does not end in -[a-z]{4}: ${k}`).toMatch(ending);
|
||||
expect(k, `key has no hyphen: ${k}`).toContain('-');
|
||||
}
|
||||
});
|
||||
|
||||
it('is a stable join: its keys are exactly the regions.geo.json feature ids', () => {
|
||||
// The manifest is looked up by feature id, so its key set must line up
|
||||
// 1:1 with the geo file (catches drift if the geo is regenerated without
|
||||
// rebuilding the keys).
|
||||
expect(featureIds).toHaveLength(1796);
|
||||
const manifestIds = Object.keys(manifest);
|
||||
expect(new Set(manifestIds)).toEqual(new Set(featureIds));
|
||||
});
|
||||
});
|
||||
@@ -23,8 +23,6 @@ function makeState(id: string): GameState {
|
||||
events: [],
|
||||
pending: [],
|
||||
version: 1,
|
||||
unowned: [],
|
||||
pendingNationOps: [],
|
||||
};
|
||||
}
|
||||
|
||||
@@ -75,28 +73,6 @@ describe('openDb', () => {
|
||||
db.close();
|
||||
});
|
||||
|
||||
it('(v0.22 #16 P3) a legacy row saved before the unowned field existed loads with it defaulted to []', () => {
|
||||
const db = openDb(':memory:');
|
||||
const legacy = makeState('legacy');
|
||||
delete (legacy as { unowned?: string[] }).unowned; // a pre-v0.22 save (field absent)
|
||||
db.save(legacy);
|
||||
const loaded = db.load('legacy');
|
||||
expect(loaded).not.toBeNull();
|
||||
expect(loaded!.unowned).toEqual([]);
|
||||
db.close();
|
||||
});
|
||||
|
||||
it('(v0.23 #16 P4a) a legacy row saved before the pendingNationOps field existed loads with it defaulted to []', () => {
|
||||
const db = openDb(':memory:');
|
||||
const legacy = makeState('legacy');
|
||||
delete (legacy as { pendingNationOps?: unknown[] }).pendingNationOps; // a pre-v0.23 save (field absent)
|
||||
db.save(legacy);
|
||||
const loaded = db.load('legacy');
|
||||
expect(loaded).not.toBeNull();
|
||||
expect(loaded!.pendingNationOps).toEqual([]);
|
||||
db.close();
|
||||
});
|
||||
|
||||
it('delete removes a game by id and reports absence otherwise', () => {
|
||||
const db = openDb(':memory:');
|
||||
db.save(makeState('a'));
|
||||
|
||||
+6
-8
@@ -3,6 +3,7 @@ import { mkdirSync } from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import Database from 'better-sqlite3';
|
||||
import type { GameState } from '../shared/types';
|
||||
import { migrateTerritoryToRegions } from './regions';
|
||||
|
||||
export interface Db {
|
||||
save(state: GameState): void;
|
||||
@@ -39,14 +40,11 @@ export function openDb(filePath: string): Db {
|
||||
const row = byId.get(id) as { data: string } | undefined;
|
||||
if (!row) return null;
|
||||
try {
|
||||
const state = JSON.parse(row.data) as GameState;
|
||||
// (v0.22, #16 P3) Rows saved before `GameState.unowned` existed load
|
||||
// with it defaulted: a legacy game has no no-man's-land regions.
|
||||
if (state.unowned === undefined) state.unowned = [];
|
||||
// (v0.23, #16 P4a) Same for pending nation-op proposals: a legacy game
|
||||
// has none awaiting confirm/reject.
|
||||
if (state.pendingNationOps === undefined) state.pendingNationOps = [];
|
||||
return state;
|
||||
// v0.19: migrate any pre-v0.19 (whole-country ISO_A3) territory to
|
||||
// sub-region ids on read. A no-op when the region geo is not loaded,
|
||||
// and idempotent once a state has been migrated (the next save then
|
||||
// persists the region-level territory).
|
||||
return migrateTerritoryToRegions(JSON.parse(row.data) as GameState);
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
|
||||
+84
-1169
File diff suppressed because it is too large
Load Diff
+47
-659
@@ -7,8 +7,6 @@ import type {
|
||||
EventOutcome,
|
||||
EventType,
|
||||
GameState,
|
||||
Nation,
|
||||
NationStats,
|
||||
Preset,
|
||||
RelationStatus,
|
||||
RoundItem,
|
||||
@@ -21,149 +19,25 @@ import {
|
||||
isDateLike,
|
||||
makeEvent,
|
||||
nationForPrompt,
|
||||
type NationOp,
|
||||
type TurnEventSpec,
|
||||
type TurnResult,
|
||||
} from '../shared/protocol';
|
||||
import {
|
||||
DEFAULT_MAX_TOKENS,
|
||||
type ChatMessage,
|
||||
type LlmClient,
|
||||
type ToolDefinition,
|
||||
type ToolExecutor,
|
||||
type WireMessage,
|
||||
} from './llm';
|
||||
import { DEFAULT_MAX_TOKENS, type LlmClient } from './llm';
|
||||
import { ADVISOR_MARKER } from './stub';
|
||||
import { regionNamesFor } from './regions';
|
||||
|
||||
const VALID_EVENT_TYPES = new Set<string>(EVENT_TYPES);
|
||||
const VALID_RELATIONS = new Set<string>(RELATION_STATUSES);
|
||||
const VALID_OUTCOMES = new Set<string>(['success', 'failure', 'partial', 'neutral']);
|
||||
const VALID_STATS = new Set<string>(['military', 'economy', 'stability', 'population']);
|
||||
|
||||
// --- The LLM's getNeighbours tool (v0.21, #16 P2: contiguous region transfers) ---
|
||||
|
||||
/**
|
||||
* The single tool the turn loop exposes to the model: the precomputed region
|
||||
* adjacency manifest (public/region-adjacency.json, via the resolver injected
|
||||
* into runTurn). Given a set of region keys it returns the union of their
|
||||
* bordering keys (the queried keys themselves excluded, sorted for
|
||||
* determinism) — so the model can verify that a territory transfer is
|
||||
* *contiguous* (a nation gains a region it already abuts) before committing
|
||||
* it, instead of moving whole countries at a whim.
|
||||
*/
|
||||
export const GET_NEIGHBOURS_TOOL: ToolDefinition = {
|
||||
type: 'function',
|
||||
function: {
|
||||
name: 'getNeighbours',
|
||||
description:
|
||||
'List the region keys that share a land border with any of the given region keys. ' +
|
||||
'Pass a nation\'s territory keys (or a single region key) to see which regions are ' +
|
||||
'contiguous to it. Use it before transferring territory: a nation can realistically ' +
|
||||
'only gain regions that border its existing territory.',
|
||||
parameters: {
|
||||
type: 'object',
|
||||
properties: {
|
||||
regionKeys: {
|
||||
type: 'array',
|
||||
items: { type: 'string' },
|
||||
description: 'One or more region keys to query (e.g. a gaining nation\'s territory).',
|
||||
},
|
||||
},
|
||||
required: ['regionKeys'],
|
||||
additionalProperties: false,
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
/**
|
||||
* Build the tool executor for the turn loop. Never throws: unknown tool
|
||||
* names, malformed arguments, and unknown region keys all degrade to a safe
|
||||
* response (an error object or an empty list) that the model can recover from.
|
||||
*/
|
||||
export function makeNeighboursExecutor(
|
||||
getNeighbours: (keys: string[]) => string[],
|
||||
validRegionKeys?: ReadonlySet<string>,
|
||||
): ToolExecutor {
|
||||
return (name, args) => {
|
||||
if (name !== GET_NEIGHBOURS_TOOL.function.name) {
|
||||
return JSON.stringify({ error: `unknown tool: ${name}` });
|
||||
}
|
||||
const raw = Array.isArray(args.regionKeys) ? args.regionKeys : [];
|
||||
const keys = raw.filter((k): k is string => typeof k === 'string' && k.length > 0);
|
||||
const valid = validRegionKeys ? keys.filter((k) => validRegionKeys.has(k)) : keys;
|
||||
if (valid.length === 0) return JSON.stringify({ neighbours: [] });
|
||||
return JSON.stringify({ neighbours: getNeighbours(valid) });
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* The player's frontier: region keys owned by *other* nations that share a
|
||||
* land border with the player's territory (deduped, sorted — stable order for
|
||||
* the deterministic stub). Computed server-side from the adjacency manifest so
|
||||
* both the LLM (the `frontier` field of the user prompt) and the stub (which
|
||||
* cannot call tools) see the same candidates. Empty when there is no
|
||||
* adjacency data or no controllable border (e.g. the UK in 1939).
|
||||
*/
|
||||
export function playerFrontier(
|
||||
state: GameState,
|
||||
getNeighbours: (keys: string[]) => string[],
|
||||
): string[] {
|
||||
const player = state.nations[state.playerNationId];
|
||||
if (!player || player.territory.length === 0) return [];
|
||||
const playerKeys = new Set(player.territory);
|
||||
const candidates = new Set<string>();
|
||||
for (const key of getNeighbours(player.territory)) {
|
||||
if (!playerKeys.has(key)) candidates.add(key);
|
||||
}
|
||||
if (candidates.size === 0) return [];
|
||||
const frontier: string[] = [];
|
||||
for (const n of Object.values(state.nations)) {
|
||||
if (n.id === state.playerNationId) continue;
|
||||
for (const key of n.territory) {
|
||||
if (candidates.has(key)) {
|
||||
candidates.delete(key);
|
||||
frontier.push(key);
|
||||
}
|
||||
}
|
||||
}
|
||||
return frontier.sort();
|
||||
}
|
||||
|
||||
// --- Prompt building ----------------------------------------------------------
|
||||
|
||||
/**
|
||||
* The LLM system prompt: world context + rules + a strict JSON contract.
|
||||
* When `withNeighboursTool` is set (the turn runs with the getNeighbours tool
|
||||
* available) the contract gains the contiguity rules for territory transfers
|
||||
* (v0.21, #16 P2): the model may only move regions across a shared border, and
|
||||
* may verify borders with the tool before answering. The contract also
|
||||
* documents the `nationOps` proposal queue (v0.23, #16 P4a) — rename plus the
|
||||
* split/merge shapes applied on player confirm (v0.24, #16 P4b).
|
||||
*/
|
||||
export function buildSystemPrompt(preset: Preset, withNeighboursTool = false): string {
|
||||
/** The LLM system prompt: world context + rules + a strict JSON contract. */
|
||||
export function buildSystemPrompt(preset: Preset): string {
|
||||
const rules = preset.simulationRules
|
||||
.map((r) => `- ${r}`)
|
||||
.join('\n');
|
||||
const respondLine = withNeighboursTool
|
||||
? 'You have a getNeighbours tool: given region keys it returns the region keys that border them. You may call it (a few times) to verify land borders before deciding territory transfers. Once done, respond with ONLY a valid JSON object of exactly this shape. No prose, no commentary, no markdown fences, no trailing commas:'
|
||||
: 'Respond with ONLY a valid JSON object of exactly this shape. No prose, no commentary, no markdown fences, no trailing commas:';
|
||||
// (v0.22, #16 P3) No man's land: a region can be left unowned after a war or
|
||||
// cataclysm (the model narrates the cause in "events" and lists the key in
|
||||
// "unowned"); unowned regions can later be re-claimed with an ordinary gain.
|
||||
// The model sees the current no-man's-land keys in the user payload's
|
||||
// "unowned" field and in the "regions" reference table.
|
||||
const noMansLandRule =
|
||||
'- A region key has at most one owner at all times — never assign a key to two nations. After a war or cataclysm a region may be left unowned ("no man\'s land"): list its key in "unowned" and narrate the cause in "events"; it stays unowned (grey on the map) until a nation re-claims it with a "gain". The "unowned" field of the user message lists the regions currently in no man\'s land.';
|
||||
const territoryRules = withNeighboursTool
|
||||
? [
|
||||
'- Territory changes must be contiguous: a nation may only GAIN region keys that share a land border with a region it already owns (verify with getNeighbours) and may only LOSE region keys it currently owns.',
|
||||
'- The "frontier" field of the user message lists region keys owned by other nations that border the player\'s territory — the natural targets of a player-led conquest this turn.',
|
||||
noMansLandRule,
|
||||
]
|
||||
: [
|
||||
'- Only change borders when war or a decisive political shift justifies it.',
|
||||
noMansLandRule,
|
||||
];
|
||||
return [
|
||||
`WORLD: ${preset.title} — ${preset.startDate}`,
|
||||
preset.worldBackground,
|
||||
@@ -172,7 +46,7 @@ export function buildSystemPrompt(preset: Preset, withNeighboursTool = false): s
|
||||
rules,
|
||||
'',
|
||||
'You are the world simulator. You advance the shared world state for ALL nations given the current state and the player\'s move.',
|
||||
respondLine,
|
||||
'Respond with ONLY a valid JSON object of exactly this shape. No prose, no commentary, no markdown fences, no trailing commas:',
|
||||
'{',
|
||||
' "date": "YYYY-MM-DD (a few days after the current date)",',
|
||||
' "events": [',
|
||||
@@ -180,27 +54,16 @@ export function buildSystemPrompt(preset: Preset, withNeighboursTool = false): s
|
||||
' ],',
|
||||
' "stateChanges": [{"nation":"<nationId>","stat":"<military|economy|stability|population>","op":"<set|add>","value":<0-100>}],',
|
||||
' "relations": [{"a":"<nationId>","b":"<nationId>","set":"<ally|neutral|rival|hostile|war>"}],',
|
||||
' "territoryChanges": [{"nation":"<nationId>","gain":["<region key>"],"lose":["<region key>"]}],',
|
||||
' "unowned": ["<region key>"],',
|
||||
' "nationOps": [',
|
||||
' {"kind":"rename","nationRef":"<nation id or name>","to":"<new name>"},',
|
||||
' {"kind":"split","nationRef":"<nation id or name>","parts":[{"name":"<new name>","territory":["<region key>"]}]}',
|
||||
' {"kind":"merge","nationRefs":["<id>","<id>"],"survivingRef":"<id of the surviving nation>","into":"<new name>"}',
|
||||
' ],',
|
||||
' "territoryChanges": [{"nation":"<nationId>","gain":["<regionId>"],"lose":["<regionId>"]}]',
|
||||
'}',
|
||||
'',
|
||||
'HARD CONSTRAINTS',
|
||||
'- Use only nation ids and region keys that exist in the provided state.',
|
||||
'- A region key identifies one sub-region; the "regions" table in the user message maps each key to "<region name> (<parent country ISO_A3>)". Use those keys in territoryChanges and unowned.',
|
||||
'- List in "unowned" only region keys that a nation currently owns, and narrate each release in "events".',
|
||||
'- Nation-management ops ("nationOps") are PROPOSALS: they only take effect if the player confirms them afterwards. Propose at most 1-2 per turn, only when the narrative justifies it, and narrate each one in "events".',
|
||||
'- Rename: add {"kind":"rename","nationRef":"<nation id or name>","to":"<new name>"} for a revolution, regime change or reunification that changes a nation\'s name.',
|
||||
'- Split: add {"kind":"split","nationRef":"<nation id or name>","parts":[{"name":"<new name>","territory":["<region key>"]}, ...]} when a state breaks up (dissolution, secession). Use at least 2 parts and assign each of the nation\'s region keys to at most one part — any key you leave unassigned goes to the first part.',
|
||||
'- Merge: add {"kind":"merge","nationRefs":["<id or name>","<id or name>"],"survivingRef":"<id or name of the surviving nation>","into":"<new name>"} when states reunify or one is absorbed. Use at least 2 input nations and "survivingRef" must name one of them — the survivor keeps its id and its stats.',
|
||||
'- Use only nation ids and sub-region ids (e.g. `FR-57`) that exist in the provided state.',
|
||||
'- A region id (e.g. `FR-57`) identifies a single sub-region — the `regions` table below lists each id with its name and country; a nation\'s border can change one region at a time.',
|
||||
'- Prefer 1-4 events per turn; keep each text 1-3 sentences.',
|
||||
'- Keep your internal reasoning brief (a few sentences) and go straight to the JSON result; do not over-deliberate or re-derive facts already present in the state.',
|
||||
'- Keep every stat value between 0 and 100.',
|
||||
...territoryRules,
|
||||
'- Only change borders when war or a decisive political shift justifies it.',
|
||||
'- If a field is not relevant this turn, set it to an empty array.',
|
||||
].join('\n');
|
||||
}
|
||||
@@ -214,25 +77,7 @@ export function buildSystemPrompt(preset: Preset, withNeighboursTool = false): s
|
||||
* model to simulate the combined consequences of the whole batch (or to let the
|
||||
* world advance on its own when the batch is empty) and return one TurnResult.
|
||||
*/
|
||||
export function buildUserPrompt(
|
||||
state: GameState,
|
||||
items: RoundItem[],
|
||||
regionReference?: Record<string, string>,
|
||||
/**
|
||||
* The player's frontier: region keys owned by other nations that border the
|
||||
* player's territory (v0.21, #16 P2). Emitted verbatim (even when empty) so
|
||||
* the model — and the deterministic stub, which reads it — see the same
|
||||
* contiguous targets. Omitted entirely when undefined (no adjacency data).
|
||||
*/
|
||||
frontier?: string[],
|
||||
/**
|
||||
* (v0.22, #16 P3) Region keys that are currently "no man's land" (released
|
||||
* mid-game — `state.unowned`). Emitted verbatim (even when empty) so the
|
||||
* model knows which unowned regions exist and can be re-claimed this turn.
|
||||
* Omitted entirely when undefined.
|
||||
*/
|
||||
noMansLand?: string[],
|
||||
): string {
|
||||
export function buildUserPrompt(state: GameState, items: RoundItem[]): string {
|
||||
const player = state.nations[state.playerNationId];
|
||||
const playerName = player?.name ?? state.playerNationId;
|
||||
const playerActions = items.map((i) =>
|
||||
@@ -245,7 +90,7 @@ export function buildUserPrompt(
|
||||
)}. Simulate the combined consequences across all nations and advance the world by one period. Return a single TurnResult.`
|
||||
: 'The player takes no action this period; let the world advance on its own momentum. Return a single TurnResult.';
|
||||
|
||||
const payload: Record<string, unknown> = {
|
||||
const payload = {
|
||||
state: {
|
||||
turn: state.turn,
|
||||
date: state.date,
|
||||
@@ -263,13 +108,19 @@ export function buildUserPrompt(
|
||||
outcome: e.outcome,
|
||||
})),
|
||||
},
|
||||
// A name lookup for every region id referenced anywhere in the state, so the
|
||||
// model can map an id it is considering (e.g. `FR-57`) to a place it
|
||||
// recognizes. This is a top-level reference table keyed by sub-region id;
|
||||
// each nation's own `territory` still carries raw ids (via nationForPrompt,
|
||||
// unchanged) so the deterministic stub can parse them. When the region geo
|
||||
// is not loaded the table is empty and the model falls back to the raw ids.
|
||||
regions: regionNamesFor(
|
||||
Object.values(state.nations).flatMap((n) => n.territory),
|
||||
),
|
||||
playerActions,
|
||||
pending: items,
|
||||
roundInstruction,
|
||||
};
|
||||
if (regionReference) payload.regions = regionReference;
|
||||
if (frontier !== undefined) payload.frontier = frontier;
|
||||
if (noMansLand !== undefined) payload.unowned = noMansLand;
|
||||
return JSON.stringify(payload, null, 2);
|
||||
}
|
||||
|
||||
@@ -330,53 +181,6 @@ function str(s: unknown, max = 0): string | null {
|
||||
return max ? t.slice(0, max) : t;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate a raw (LLM) `nationOps` array into safe {@link NationOp} values
|
||||
* (v0.23, #16 P4a). Defensive like the rest of the parser: entries with an
|
||||
* unknown `kind` or missing/empty required fields are dropped, never throw.
|
||||
* Rename: non-empty `nationRef` + `to` (each capped at 200 chars — resolution
|
||||
* of `nationRef` to a concrete nation happens later, at confirm time). Split:
|
||||
* non-empty `nationRef` + at least one part with a name. Merge: non-empty
|
||||
* `nationRefs` (capped at 20) + `survivingRef` + `into`.
|
||||
*/
|
||||
export function validateNationOps(raw: unknown): NationOp[] {
|
||||
if (!Array.isArray(raw)) return [];
|
||||
const out: NationOp[] = [];
|
||||
for (const e of raw) {
|
||||
if (!e || typeof e !== 'object') continue;
|
||||
const o = e as Record<string, unknown>;
|
||||
if (o.kind === 'rename') {
|
||||
const nationRef = str(o.nationRef, 200);
|
||||
const to = str(o.to, 200);
|
||||
if (nationRef && to) out.push({ kind: 'rename', nationRef, to });
|
||||
} else if (o.kind === 'split') {
|
||||
const nationRef = str(o.nationRef, 200);
|
||||
const parts = (Array.isArray(o.parts) ? o.parts : [])
|
||||
.filter((p): p is Record<string, unknown> => !!p && typeof p === 'object')
|
||||
.map((p) => {
|
||||
const name = str(p.name, 200);
|
||||
const territory = Array.isArray(p.territory)
|
||||
? p.territory.filter((k): k is string => typeof k === 'string' && k.trim() !== '')
|
||||
: [];
|
||||
return { name, territory };
|
||||
})
|
||||
.filter((p): p is { name: string; territory: string[] } => p.name !== null);
|
||||
if (nationRef && parts.length > 0) out.push({ kind: 'split', nationRef, parts });
|
||||
} else if (o.kind === 'merge') {
|
||||
const nationRefs = (Array.isArray(o.nationRefs) ? o.nationRefs : [])
|
||||
.map((x) => (typeof x === 'string' ? x.trim().slice(0, 200) : ''))
|
||||
.filter((x) => x !== '')
|
||||
.slice(0, 20);
|
||||
const survivingRef = str(o.survivingRef, 200);
|
||||
const into = str(o.into, 200);
|
||||
if (nationRefs.length > 0 && survivingRef && into) {
|
||||
out.push({ kind: 'merge', nationRefs, survivingRef, into });
|
||||
}
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate and normalize an arbitrary parsed object into a safe TurnResult.
|
||||
* Ignores unknown/invalid entries; clamps numeric stats to 0-100. Returns null
|
||||
@@ -391,8 +195,6 @@ export function validateTurnResult(input: unknown): TurnResult | null {
|
||||
stateChanges: [],
|
||||
relations: [],
|
||||
territoryChanges: [],
|
||||
unowned: [],
|
||||
nationOps: [],
|
||||
};
|
||||
|
||||
if (Array.isArray(o.events)) {
|
||||
@@ -468,38 +270,12 @@ export function validateTurnResult(input: unknown): TurnResult | null {
|
||||
}
|
||||
}
|
||||
|
||||
// (v0.22, #16 P3) Keys released to "no man's land": deduped, non-empty
|
||||
// strings only (applied later by applyTurnResult against validKeys).
|
||||
if (Array.isArray(o.unowned)) {
|
||||
for (const k of o.unowned) {
|
||||
const s = typeof k === 'string' ? k.trim() : '';
|
||||
if (s && !result.unowned.includes(s)) result.unowned.push(s);
|
||||
}
|
||||
}
|
||||
|
||||
// (v0.23, #16 P4a) Nation-management ops the LLM proposes this turn. These
|
||||
// are NOT applied by the turn — applyTurnResult appends them to the pending
|
||||
// list for the player to confirm/reject.
|
||||
result.nationOps = validateNationOps(o.nationOps);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* A turn is "meaningful" if it produced at least an event, a stat change, a
|
||||
* no-man's-land release (v0.22 #16 P3: a release is a real world change even
|
||||
* when the model under-narrates it), or a nation-op proposal (v0.23 #16 P4a:
|
||||
* a proposal is a real pending-world change the player will resolve, so it
|
||||
* must survive the retry/nudge path instead of being replaced by the generic
|
||||
* "unclear" result).
|
||||
*/
|
||||
/** A turn is "meaningful" if it produced at least an event or a stat change. */
|
||||
export function isMeaningful(result: TurnResult): boolean {
|
||||
return (
|
||||
result.events.length > 0 ||
|
||||
result.stateChanges.length > 0 ||
|
||||
result.unowned.length > 0 ||
|
||||
result.nationOps.length > 0
|
||||
);
|
||||
return result.events.length > 0 || result.stateChanges.length > 0;
|
||||
}
|
||||
|
||||
// --- Applying the delta -------------------------------------------------------
|
||||
@@ -516,13 +292,9 @@ function genericUnclearEvent(state: GameState): TurnEventSpec {
|
||||
|
||||
/**
|
||||
* Apply a TurnResult to a GameState immutably: advance the date/turn, append
|
||||
* events, apply stat changes (clamped), symmetric relations, and territory
|
||||
* moves (including no-man's-land releases, v0.22 #16 P3). It also appends any
|
||||
* proposed nation-ops to the pending list (v0.23 #16 P4a) without applying
|
||||
* them — see the doc comment on `pendingNationOps` for why that list
|
||||
* deliberately survives across turns.
|
||||
* events, apply stat changes (clamped), symmetric relations, and territory moves.
|
||||
*/
|
||||
export function applyTurnResult(state: GameState, result: TurnResult, validKeys?: ReadonlySet<string>): GameState {
|
||||
export function applyTurnResult(state: GameState, result: TurnResult): GameState {
|
||||
const next: GameState = JSON.parse(JSON.stringify(state));
|
||||
next.version = (state.version ?? 0) + 1; // every mutation is a new revision
|
||||
const actingTurn = state.turn; // this action resolves the current turn
|
||||
@@ -545,104 +317,21 @@ export function applyTurnResult(state: GameState, result: TurnResult, validKeys?
|
||||
a.relations[r.b] = r.set;
|
||||
b.relations[r.a] = r.set;
|
||||
}
|
||||
// --- Territory (v0.21, #16 P2: at most one owner per key;
|
||||
// v0.22, #16 P3: a key may also be released to "no man's land") ---
|
||||
//
|
||||
// Two kinds of change, applied in this order:
|
||||
//
|
||||
// (1) RELEASES (`result.unowned`, v0.22 #16 P3): each key that a nation
|
||||
// CURRENTLY owns (exactly one owner) is removed from that owner, left
|
||||
// ownerless, and added to `GameState.unowned` — the client renders it
|
||||
// as the distinct no-man's-land grey. A key with zero owners (a preset
|
||||
// never assigned it) is never released: doing so would fabricate a
|
||||
// visible no-man's-land out of an ordinary unowned region. A key with
|
||||
// two or more owners (pre-existing corruption) is never touched, and
|
||||
// a key already in `unowned` is a no-op (it is already unowned).
|
||||
//
|
||||
// (2) CLAIMS (`gain` entries), resolved against the ownership AFTER the
|
||||
// releases (snapshot-first):
|
||||
// - a key with exactly one owner that is not the gainer → a TRANSFER:
|
||||
// removed from the old owner, granted to the gainer (v0.21 rules);
|
||||
// - a key with NO owner → a RE-CLAIM: granted to the (sole) gainer and
|
||||
// removed from `GameState.unowned` (it leaves no man's land);
|
||||
// - a double claim (two or more distinct gainers) is rejected — the
|
||||
// key stays as it is; a self-gain is a no-op; a pre-existing double
|
||||
// ownership is never touched.
|
||||
//
|
||||
// Invariants after the turn: no key sits in two or more territories; a
|
||||
// released key sits in none; `GameState.unowned` holds exactly the
|
||||
// zero-owner keys that were released mid-game (not the preset-unassigned
|
||||
// ones). "lose" entries remain deliberate no-ops: releasing is the
|
||||
// `unowned` list's job, and a lone loss without a release would just
|
||||
// orphan a key silently.
|
||||
const valid = (k: string) => !validKeys || validKeys.has(k);
|
||||
const unowned = new Set(state.unowned ?? []);
|
||||
|
||||
// (1) Releases: establish the new no-man's-land set before any claim.
|
||||
for (const key of new Set(result.unowned)) {
|
||||
if (!valid(key) || unowned.has(key)) continue;
|
||||
const owners = Object.values(next.nations)
|
||||
.filter((n) => n.territory.includes(key))
|
||||
.map((n) => n.id);
|
||||
if (owners.length !== 1) continue; // 0 owners (never assigned) or 2+ (corrupt): no-op
|
||||
unowned.add(key);
|
||||
next.nations[owners[0]].territory = next.nations[owners[0]].territory.filter((k) => k !== key);
|
||||
}
|
||||
|
||||
// (2) Claims against the post-release ownership snapshot.
|
||||
const ownerOf = new Map<string, string>(); // key -> sole owner id, or '' (2+ owners; 0 = absent)
|
||||
for (const n of Object.values(next.nations)) {
|
||||
for (const key of n.territory) {
|
||||
if (!valid(key)) continue;
|
||||
const cur = ownerOf.get(key);
|
||||
if (cur === undefined) ownerOf.set(key, n.id);
|
||||
else if (cur !== '') ownerOf.set(key, '');
|
||||
}
|
||||
}
|
||||
// Claim pairs, deduped: one (key, gainer) per pair even if the model emits
|
||||
// duplicate entries; two DIFFERENT gainers for one key is a double claim.
|
||||
const claimPairs = new Set<string>();
|
||||
for (const t of result.territoryChanges) {
|
||||
if (!next.nations[t.nation]) continue;
|
||||
for (const key of new Set(t.gain)) {
|
||||
if (!valid(key)) continue;
|
||||
claimPairs.add(`${key}\u0000${t.nation}`);
|
||||
const n = next.nations[t.nation];
|
||||
if (!n) continue;
|
||||
for (const code of t.gain) {
|
||||
for (const other of Object.values(next.nations)) {
|
||||
const i = other.territory.indexOf(code);
|
||||
if (i !== -1) other.territory.splice(i, 1);
|
||||
}
|
||||
if (!n.territory.includes(code)) n.territory.push(code);
|
||||
}
|
||||
}
|
||||
const claimants = new Map<string, Set<string>>(); // key -> distinct gainers
|
||||
for (const pair of claimPairs) {
|
||||
const idx = pair.indexOf('\u0000');
|
||||
const key = pair.slice(0, idx);
|
||||
const gainer = pair.slice(idx + 1);
|
||||
let set = claimants.get(key);
|
||||
if (set === undefined) {
|
||||
set = new Set();
|
||||
claimants.set(key, set);
|
||||
}
|
||||
set.add(gainer);
|
||||
}
|
||||
for (const [key, claiming] of claimants) {
|
||||
if (claiming.size !== 1) continue; // double claim: the key stays as it was
|
||||
const gainer = [...claiming][0];
|
||||
const owner = ownerOf.get(key); // undefined: no owner; '': 2+ owners (corrupt)
|
||||
if (owner === '') continue; // pre-existing double ownership: never touched
|
||||
if (owner !== undefined && owner === gainer) continue; // self-gain: no-op
|
||||
for (const n of Object.values(next.nations)) {
|
||||
const i = n.territory.indexOf(key);
|
||||
for (const code of t.lose) {
|
||||
const i = n.territory.indexOf(code);
|
||||
if (i !== -1) n.territory.splice(i, 1);
|
||||
}
|
||||
next.nations[gainer].territory.push(key);
|
||||
unowned.delete(key); // re-claimed: the key leaves no man's land
|
||||
}
|
||||
|
||||
next.unowned = [...unowned];
|
||||
// (v0.23, #16 P4a) Nation-op proposals are NOT applied by the turn — they
|
||||
// are appended to the pending list, which (unlike `pending`) SURVIVES
|
||||
// across turns until the player confirms or rejects each one. `next` is a
|
||||
// deep clone of `state`, so `next.pendingNationOps` is a copy of whatever
|
||||
// the state already held (or undefined for a legacy row) — start from that
|
||||
// and append the new proposals, defaulting a missing field to `[]`.
|
||||
next.pendingNationOps = [...(next.pendingNationOps ?? []), ...result.nationOps];
|
||||
return next;
|
||||
}
|
||||
|
||||
@@ -677,336 +366,37 @@ export function removeRoundItem(state: GameState, index: number | undefined): Ga
|
||||
return next;
|
||||
}
|
||||
|
||||
// --- Nation-management ops (v0.23, #16 P4a: the hybrid "LLM proposes,
|
||||
// player confirms" model) ----------------------------------------------------
|
||||
//
|
||||
// A NationOp proposed by a turn lands in `GameState.pendingNationOps` (see
|
||||
// applyTurnResult) and waits there across turns. These functions resolve the
|
||||
// player's decision on one pending proposal, by index. Like removeRoundItem
|
||||
// they are pure: clone the state, mutate the clone, bump `version` once,
|
||||
// return the new state — and return `null` for a bad index so the route can
|
||||
// answer 400 without mutating anything.
|
||||
|
||||
/** True when `index` is a valid, in-bounds integer position in the pending list. */
|
||||
function validPendingOpIndex(state: GameState, index: number): boolean {
|
||||
const len = state.pendingNationOps?.length ?? 0;
|
||||
return Number.isInteger(index) && index >= 0 && index < len;
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve a nation reference (the `nationRef` of a NationOp — the LLM may
|
||||
* write either the nation's stable `id` or its human-readable `name`) to a
|
||||
* concrete nation id: an exact id match wins, then a unique case-insensitive
|
||||
* name match. Returns `null` when the reference is empty, unknown, or
|
||||
* ambiguous (two or more nations share that name) — every caller treats
|
||||
* `null` as "no-op" and nothing here ever throws.
|
||||
*/
|
||||
export function resolveNationRef(state: GameState, ref: string): string | null {
|
||||
const r = (ref ?? '').trim();
|
||||
if (!r) return null;
|
||||
if (state.nations[r]) return r; // exact id first
|
||||
const matches = Object.values(state.nations).filter(
|
||||
(n) => n.name.trim().toLowerCase() === r.toLowerCase(),
|
||||
);
|
||||
return matches.length === 1 ? matches[0].id : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a fresh, unused nation id for a newly created nation (split
|
||||
* parts, v0.24 #16 P4b): the first free of `n1`, `n2`, ... The caller adds
|
||||
* each id it creates to `taken` as it goes, so ids stay unique within an
|
||||
* op and are never reused from a removed nation.
|
||||
*/
|
||||
export function freshNationId(taken: ReadonlySet<string>): string {
|
||||
for (let i = 1; ; i++) {
|
||||
const id = `n${i}`;
|
||||
if (!taken.has(id)) return id;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The baseline stats a freshly created nation starts with (split parts,
|
||||
* v0.24 #16 P4b) — a neutral middle-of-the-scale profile, deliberately NOT
|
||||
* a copy of the parent's stats (a small rump state is not the parent's
|
||||
* military power).
|
||||
*/
|
||||
export const NEW_NATION_STATS: NationStats = {
|
||||
military: 50,
|
||||
economy: 50,
|
||||
stability: 50,
|
||||
population: 50,
|
||||
};
|
||||
|
||||
/**
|
||||
* Defensive cleanup after nations are removed (merge, v0.24 #16 P4b): drop
|
||||
* the removed nations' ids from every remaining nation's `relations` map so
|
||||
* no key dangles. (The client already degrades gracefully on a missing
|
||||
* target, but consistent data is cleaner.)
|
||||
*/
|
||||
function dropRelationsTo(state: GameState, removedIds: ReadonlySet<string>): void {
|
||||
for (const n of Object.values(state.nations)) {
|
||||
for (const id of removedIds) {
|
||||
if (id in n.relations) delete n.relations[id];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply one NationOp to a state, MUTATING the passed object in place (the
|
||||
* caller passes a clone — confirmNationOp does) and NOT bumping `version`
|
||||
* (the route-level functions do that once per decision). It never throws:
|
||||
* any unresolvable reference or malformed op is a silent no-op (the op is
|
||||
* still removed by confirmNationOp — the world simply doesn't change).
|
||||
*
|
||||
* - **rename** (v0.23, #16 P4a): changes only `Nation.name` — the id, its
|
||||
* territory, its relations (keyed by id), and the player pointer all stay
|
||||
* valid, so nothing downstream breaks; a player-supplied `edits.name`
|
||||
* overrides the proposed `to` (an empty edit falls back to the proposal's
|
||||
* own name).
|
||||
*
|
||||
* - **split** (v0.24, #16 P4b): the `nationRef` must resolve and there must
|
||||
* be at least two named parts, else no-op. Parts are processed in order;
|
||||
* each receives the region keys of its `territory` that (a) the parent
|
||||
* owns and (b) no earlier part claimed — the first part to name a key
|
||||
* wins. Keys of the parent's territory that no part claimed go to part 0
|
||||
* (in the parent's `territory` order), so the parent's territory is fully
|
||||
* partitioned — no key is lost or ever held twice. Each part gets a
|
||||
* FRESH id (`freshNationId`) and the baseline `NEW_NATION_STATS` (not a
|
||||
* copy of the parent's), plus a copy of the parent's relations; the
|
||||
* parent is then removed. If the parent was the player's nation,
|
||||
* `playerNationId` moves to the chosen part (`edits.playerPart`, clamped
|
||||
* into range, default 0); `edits.name` renames that same chosen part.
|
||||
*
|
||||
* - **merge** (v0.24, #16 P4b): every input ref plus the survivor ref must
|
||||
* resolve, at least two inputs must resolve to DISTINCT nations, and the
|
||||
* survivor must be one of them — else no-op. The survivor keeps its id,
|
||||
* keeps its own stats, gains the union of all inputs' territories
|
||||
* (survivor's keys first, then each other input's unclaimed keys in its
|
||||
* own order), and gains a union of the inputs' relations (on a third
|
||||
* party the survivor's own view wins, else the first input's). The other
|
||||
* inputs are removed (their ids dropped from everyone else's relations
|
||||
* maps), and if the player led a removed input, `playerNationId` moves to
|
||||
* the survivor. The merged name is `edits.name` (if non-empty), else
|
||||
* `op.into`, else the survivor's current name.
|
||||
*/
|
||||
export function applyNationOp(
|
||||
state: GameState,
|
||||
op: NationOp,
|
||||
edits?: { name?: string; playerPart?: number },
|
||||
): void {
|
||||
if (op.kind === 'rename') {
|
||||
const id = resolveNationRef(state, op.nationRef);
|
||||
if (id === null) return; // invalid/ambiguous ref: no-op
|
||||
const n = state.nations[id];
|
||||
if (!n) return;
|
||||
const name = (edits?.name ?? '').trim() || op.to.trim();
|
||||
if (name) n.name = name;
|
||||
return;
|
||||
}
|
||||
|
||||
if (op.kind === 'split') {
|
||||
const id = resolveNationRef(state, op.nationRef);
|
||||
if (id === null || op.parts.length < 2) return; // invalid ref / not enough parts: no-op
|
||||
const parent = state.nations[id];
|
||||
if (!parent) return;
|
||||
const taken = new Set(Object.keys(state.nations));
|
||||
const created: string[] = [];
|
||||
const claimed = new Set<string>();
|
||||
for (const part of op.parts) {
|
||||
const newId = freshNationId(taken);
|
||||
taken.add(newId);
|
||||
const keys = (part.territory ?? [])
|
||||
.filter((k) => parent.territory.includes(k) && !claimed.has(k));
|
||||
for (const k of keys) claimed.add(k);
|
||||
const partNation: Nation = {
|
||||
id: newId,
|
||||
type: parent.type, // a part keeps the parent's form of state
|
||||
name: part.name,
|
||||
stats: { ...NEW_NATION_STATS },
|
||||
territory: keys,
|
||||
relations: { ...parent.relations },
|
||||
};
|
||||
state.nations[newId] = partNation;
|
||||
created.push(newId);
|
||||
}
|
||||
// Keys the parent owned but no part claimed go to part 0 (in the
|
||||
// parent's territory order) — nothing is lost or duplicated.
|
||||
for (const k of parent.territory) {
|
||||
if (!claimed.has(k)) state.nations[created[0]].territory.push(k);
|
||||
}
|
||||
// The player chooses which part is its successor (edits.playerPart,
|
||||
// clamped into range; default 0) — only relevant when the parent was
|
||||
// the player's nation; the same part also gets a player-edited name.
|
||||
const partIdx =
|
||||
Math.min(Math.max(edits?.playerPart ?? 0, 0), created.length - 1);
|
||||
if (state.playerNationId === id) state.playerNationId = created[partIdx];
|
||||
const editedName = (edits?.name ?? '').trim();
|
||||
if (editedName) state.nations[created[partIdx]].name = editedName;
|
||||
delete state.nations[id];
|
||||
dropRelationsTo(state, new Set([id]));
|
||||
return;
|
||||
}
|
||||
|
||||
// merge
|
||||
const resolved: string[] = [];
|
||||
for (const ref of op.nationRefs) {
|
||||
const rid = resolveNationRef(state, ref);
|
||||
if (rid === null) return; // any unresolvable input: no-op
|
||||
resolved.push(rid);
|
||||
}
|
||||
const inputIds = new Set(resolved);
|
||||
const survivorId = resolveNationRef(state, op.survivingRef);
|
||||
if (survivorId === null || !inputIds.has(survivorId) || inputIds.size < 2) return;
|
||||
const survivor = state.nations[survivorId];
|
||||
if (!survivor) return;
|
||||
// Territory: the union of all inputs — the survivor's keys first (stable
|
||||
// order), then each other input's unclaimed keys in its own order.
|
||||
const territory = [...survivor.territory];
|
||||
const seen = new Set(territory);
|
||||
for (const rid of resolved) {
|
||||
for (const k of state.nations[rid].territory) {
|
||||
if (!seen.has(k)) {
|
||||
seen.add(k);
|
||||
territory.push(k);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Relations: the union of all inputs' relations; the first input to name a
|
||||
// third party sets it, then the survivor's own view overwrites per key.
|
||||
const relations: Record<string, RelationStatus> = {};
|
||||
for (const rid of resolved) {
|
||||
for (const [other, status] of Object.entries(state.nations[rid].relations)) {
|
||||
if (other === survivorId) continue; // never relate to oneself
|
||||
if (!(other in relations)) relations[other] = status;
|
||||
}
|
||||
}
|
||||
for (const [other, status] of Object.entries(survivor.relations)) {
|
||||
if (other !== survivorId) relations[other] = status;
|
||||
}
|
||||
const removed = new Set<string>();
|
||||
for (const rid of inputIds) {
|
||||
if (rid === survivorId) continue;
|
||||
delete state.nations[rid];
|
||||
removed.add(rid);
|
||||
}
|
||||
if (state.playerNationId !== survivorId && removed.has(state.playerNationId)) {
|
||||
state.playerNationId = survivorId;
|
||||
}
|
||||
const name = (edits?.name ?? '').trim() || op.into.trim() || survivor.name;
|
||||
if (name) survivor.name = name;
|
||||
survivor.territory = territory;
|
||||
survivor.relations = relations;
|
||||
dropRelationsTo(state, removed);
|
||||
}
|
||||
|
||||
/**
|
||||
* Confirm a pending nation-op proposal by index: apply it (a rename takes
|
||||
* effect, optionally with a player-edited name; a split partitions the
|
||||
* nation's territory into the new parts, the player picking which part is
|
||||
* its successor via `edits.playerPart`; a merge folds the inputs into the
|
||||
* survivor, optionally renamed via `edits.name`) and remove it from
|
||||
* `pendingNationOps`, bumping `version`. Returns `null` for an invalid
|
||||
* index, so the route answers 400 without mutating. Reused by the
|
||||
* /nation-op/confirm route.
|
||||
*/
|
||||
export function confirmNationOp(
|
||||
state: GameState,
|
||||
index: number,
|
||||
edits?: { name?: string; playerPart?: number },
|
||||
): GameState | null {
|
||||
if (!validPendingOpIndex(state, index)) return null;
|
||||
const next: GameState = JSON.parse(JSON.stringify(state));
|
||||
next.version = (state.version ?? 0) + 1;
|
||||
const op = next.pendingNationOps[index];
|
||||
applyNationOp(next, op, edits);
|
||||
next.pendingNationOps.splice(index, 1);
|
||||
return next;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reject (drop) a pending nation-op proposal by index without applying it,
|
||||
* bumping `version`. Returns `null` for an invalid index, so the route
|
||||
* answers 400 without mutating. Reused by the /nation-op/reject route.
|
||||
*/
|
||||
export function rejectNationOp(state: GameState, index: number): GameState | null {
|
||||
if (!validPendingOpIndex(state, index)) return null;
|
||||
const next: GameState = JSON.parse(JSON.stringify(state));
|
||||
next.version = (state.version ?? 0) + 1;
|
||||
next.pendingNationOps.splice(index, 1);
|
||||
return next;
|
||||
}
|
||||
|
||||
/**
|
||||
* Run one turn end-to-end against the (injectable) LLM: build prompts, parse/
|
||||
* validate, retry once with a nudge if the result is empty/invalid, and — if
|
||||
* it is still invalid — emit a generic "unclear" event and advance. The
|
||||
* committed state has `pending` cleared. Never throws on bad model output;
|
||||
* only the underlying transport/network can throw.
|
||||
*
|
||||
* When `getNeighbours` is provided AND the LLM client implements
|
||||
* `chatWithTools` (v0.21, #16 P2), the turn runs the bounded function-
|
||||
* calling loop with the getNeighbours tool (the model may verify land
|
||||
* borders before committing a territory transfer) and the user prompt gains
|
||||
* the player's `frontier` field. Otherwise it falls back to a plain chat()
|
||||
* call — same as before the tool existed.
|
||||
* Run one turn end-to-end against the (injectable) LLM: build prompts, call the
|
||||
* model ONCE over the whole pending batch, parse/validate, retry once with a
|
||||
* nudge if the result is empty/invalid, and — if it is still invalid — emit a
|
||||
* generic "unclear" event and advance. The committed state has `pending` cleared.
|
||||
* Never throws on bad model output; only the underlying transport/network can throw.
|
||||
*/
|
||||
export async function runTurn(opts: {
|
||||
llm: LlmClient;
|
||||
preset: Preset;
|
||||
state: GameState;
|
||||
items: RoundItem[];
|
||||
/** Region reference table (key -> "name (parent)") to include in the user prompt. */
|
||||
regionReference?: Record<string, string>;
|
||||
/** Set of valid region keys; territory changes with other keys are ignored. */
|
||||
validRegionKeys?: ReadonlySet<string>;
|
||||
/**
|
||||
* Region adjacency resolver (keys -> bordering keys, from the precomputed
|
||||
* manifest). Its presence (together with the client's chatWithTools)
|
||||
* switches the turn onto the getNeighbours tool path.
|
||||
*/
|
||||
getNeighbours?: (keys: string[]) => string[];
|
||||
}): Promise<{ state: GameState; result: TurnResult }> {
|
||||
const { llm, preset, state, items, regionReference, validRegionKeys, getNeighbours } = opts;
|
||||
const chatWithTools = llm.chatWithTools;
|
||||
const useTools = getNeighbours !== undefined && chatWithTools !== undefined;
|
||||
const system = buildSystemPrompt(preset, useTools);
|
||||
const frontier = getNeighbours ? playerFrontier(state, getNeighbours) : undefined;
|
||||
// (v0.22, #16 P3) the model always sees the current no-man's-land keys (empty
|
||||
// list on a fresh game) so it knows which unowned regions can be re-claimed.
|
||||
const user = buildUserPrompt(state, items, regionReference, frontier, state.unowned ?? []);
|
||||
const { llm, preset, state, items } = opts;
|
||||
const system = buildSystemPrompt(preset);
|
||||
const user = buildUserPrompt(state, items);
|
||||
const nudge =
|
||||
'Your previous output was invalid. Respond with ONLY the JSON object described above for this batch — no prose, no fences.';
|
||||
|
||||
/**
|
||||
* One model call with the standard turn sampling: the bounded
|
||||
* function-calling loop when available, else a plain chat(). The nudge
|
||||
* re-send below always starts a FRESH history (no tool context carried
|
||||
* over).
|
||||
*/
|
||||
const call = async (history: WireMessage[]): Promise<string> => {
|
||||
if (useTools) {
|
||||
return await chatWithTools(
|
||||
history,
|
||||
[GET_NEIGHBOURS_TOOL],
|
||||
makeNeighboursExecutor(getNeighbours, validRegionKeys),
|
||||
{ temperature: 0.4, maxTokens: DEFAULT_MAX_TOKENS },
|
||||
);
|
||||
}
|
||||
return llm.chat(history as ChatMessage[], { temperature: 0.4, maxTokens: DEFAULT_MAX_TOKENS });
|
||||
};
|
||||
|
||||
let result = parseTurnResult(await call([
|
||||
let result = parseTurnResult(await llm.chat([
|
||||
{ role: 'system', content: system },
|
||||
{ role: 'user', content: user },
|
||||
]));
|
||||
], { temperature: 0.4, maxTokens: DEFAULT_MAX_TOKENS }));
|
||||
|
||||
if (result === null || !isMeaningful(result)) {
|
||||
result = parseTurnResult(await call([
|
||||
result = parseTurnResult(await llm.chat([
|
||||
{ role: 'system', content: system },
|
||||
{ role: 'user', content: user },
|
||||
{ role: 'assistant', content: '' },
|
||||
{ role: 'user', content: nudge },
|
||||
]));
|
||||
], { temperature: 0.4, maxTokens: DEFAULT_MAX_TOKENS }));
|
||||
}
|
||||
|
||||
if (result === null || !isMeaningful(result)) {
|
||||
@@ -1016,12 +406,10 @@ export async function runTurn(opts: {
|
||||
stateChanges: [],
|
||||
relations: [],
|
||||
territoryChanges: [],
|
||||
unowned: [],
|
||||
nationOps: [],
|
||||
};
|
||||
}
|
||||
|
||||
return { state: applyTurnResult(state, result, validRegionKeys), result };
|
||||
return { state: applyTurnResult(state, result), result };
|
||||
}
|
||||
|
||||
// --- Advisor (brainstorm) -----------------------------------------------------
|
||||
|
||||
+16
-63
@@ -12,17 +12,15 @@ import { deepClone } from '../shared/protocol';
|
||||
import type {
|
||||
AddActionRequest,
|
||||
AddDiplomacyRequest,
|
||||
ConfirmNationOpRequest,
|
||||
CreateGameRequest,
|
||||
RejectNationOpRequest,
|
||||
RemoveQueueItemRequest,
|
||||
} from '../shared/protocol';
|
||||
import type { GameState } from '../shared/types';
|
||||
import { createLlmClient } from './llm';
|
||||
import { makeStubLlmClient } from './stub';
|
||||
import { askAdvisor, confirmNationOp, queueRoundItem, rejectNationOp, removeRoundItem, runTurn } from './engine';
|
||||
import { askAdvisor, queueRoundItem, removeRoundItem, runTurn } from './engine';
|
||||
import { expandTerritory, loadRegions } from './regions';
|
||||
import { buildRegionMap } from './map';
|
||||
import { allTerritoryKeys, expandCountriesToKeys, hasAdjacency, loadRegions, neighboursOf, referenceForKeys, validKeys } from './regions';
|
||||
import { createPresetStore } from './presets';
|
||||
import { openDb, type Db } from './db';
|
||||
|
||||
@@ -44,6 +42,10 @@ function findRoot(): string {
|
||||
}
|
||||
|
||||
const root = findRoot();
|
||||
// Load the sub-region geo once at boot (a graceful no-op, with a warning, when
|
||||
// the file is missing — the territory model then degrades to whole-country
|
||||
// ISO_A3 codes). Must run before the first game creation/load.
|
||||
loadRegions(root);
|
||||
const presetsDir = path.join(root, 'presets');
|
||||
const clientDir = process.env.CLIENT_DIST ?? path.join(root, 'dist');
|
||||
const dataDir = process.env.DATA_DIR ?? path.join(root, 'data');
|
||||
@@ -52,9 +54,6 @@ const dataDir = process.env.DATA_DIR ?? path.join(root, 'data');
|
||||
// the e2e config, so honor it as a fallback to keep all three in agreement.
|
||||
const PORT = parseInt(process.env.PORT ?? process.env.HISTORY_API_PORT ?? '4321', 10);
|
||||
const presetStore = createPresetStore(presetsDir);
|
||||
// Load the region-key manifest + geo once at boot (v0.19 #16 P1). A missing file
|
||||
// just means region expansion/reference degrade to the raw keys (server still boots).
|
||||
loadRegions(root);
|
||||
const db: Db = openDb(path.join(dataDir, 'history.db'));
|
||||
// LLM_STUB=1 → deterministic stub (tests/e2e/dev without a live model).
|
||||
const useStub = process.env.LLM_STUB === '1';
|
||||
@@ -122,23 +121,20 @@ app.post('/api/games', (req: Request, res) => {
|
||||
playerNationId: nation.id,
|
||||
turn: 1,
|
||||
date: preset.startDate,
|
||||
nations: Object.fromEntries(preset.nations.map((n) => [n.id, deepClone(n)])),
|
||||
// v0.19: territory is at sub-region granularity — expand each preset
|
||||
// nation's ISO_A3 country codes into all their sub-region ids (a no-op that
|
||||
// keeps the country codes when the region geo is not loaded).
|
||||
nations: Object.fromEntries(
|
||||
preset.nations.map((n) => {
|
||||
const nation = deepClone(n);
|
||||
nation.territory = expandTerritory(nation.territory);
|
||||
return [n.id, nation];
|
||||
}),
|
||||
),
|
||||
events: [],
|
||||
pending: [],
|
||||
version: 1, // the first saved revision; every later mutation bumps it
|
||||
// (v0.22, #16 P3) No man's land can only arise mid-game — a fresh game
|
||||
// starts with nothing released; this list grows as the LLM releases
|
||||
// regions and shrinks as they get re-claimed.
|
||||
unowned: [],
|
||||
// (v0.23, #16 P4a) No pending nation-op proposals on a fresh game; the
|
||||
// list grows as the LLM proposes renames (and, later, splits/merges) and
|
||||
// shrinks as the player confirms or rejects them.
|
||||
pendingNationOps: [],
|
||||
};
|
||||
// v0.19 (#16 P1): expand each nation's ISO_A3 country list to the region keys
|
||||
// of all its sub-regions, so ownership (and the choropleth) is at region
|
||||
// granularity from the very first turn. Preset JSONs stay country-level.
|
||||
for (const n of Object.values(state.nations)) n.territory = expandCountriesToKeys(n.territory);
|
||||
db.save(state);
|
||||
res.json({ game: state });
|
||||
});
|
||||
@@ -230,38 +226,6 @@ app.post('/api/games/:id/queue/remove', (req, res) => {
|
||||
res.json({ game: next });
|
||||
});
|
||||
|
||||
// (v0.23, #16 P4a; v0.24, #16 P4b) Resolve a pending nation-op proposal
|
||||
// waiting in game.pendingNationOps: a rename takes effect (body.edits.name
|
||||
// may override the proposed name), a split partitions the nation's territory
|
||||
// into the proposed parts (body.edits.playerPart picks which part the player
|
||||
// leads, default 0), and a merge folds its inputs into the survivor
|
||||
// (body.edits.name may override the merged name). No LLM call, no turn
|
||||
// advance — same fast save → broadcast → respond order as /queue/remove.
|
||||
// The version bump lets "never go backwards" clients reconcile.
|
||||
app.post('/api/games/:id/nation-op/confirm', (req, res) => {
|
||||
const id = req.params.id;
|
||||
const game = db.load(id);
|
||||
if (!game) return res.status(404).json({ error: 'game not found' });
|
||||
const body = (req.body ?? {}) as ConfirmNationOpRequest;
|
||||
const next = confirmNationOp(game, body.index, body.edits);
|
||||
if (!next) return res.status(400).json({ error: 'invalid proposal index' });
|
||||
db.save(next);
|
||||
broadcast(id, 'state', { state: next });
|
||||
res.json({ game: next });
|
||||
});
|
||||
|
||||
app.post('/api/games/:id/nation-op/reject', (req, res) => {
|
||||
const id = req.params.id;
|
||||
const game = db.load(id);
|
||||
if (!game) return res.status(404).json({ error: 'game not found' });
|
||||
const body = (req.body ?? {}) as RejectNationOpRequest;
|
||||
const next = rejectNationOp(game, body.index);
|
||||
if (!next) return res.status(400).json({ error: 'invalid proposal index' });
|
||||
db.save(next);
|
||||
broadcast(id, 'state', { state: next });
|
||||
res.json({ game: next });
|
||||
});
|
||||
|
||||
// Jump forward: commit the whole pending round (or an empty one) to the model
|
||||
// in a single turn. applyTurnResult clears the pending queue on the returned
|
||||
// state. 404 for not-found/preset-missing; 502 for LLM/model (transport) errors.
|
||||
@@ -277,17 +241,6 @@ app.post('/api/games/:id/jump', async (req, res) => {
|
||||
preset,
|
||||
state: game,
|
||||
items: game.pending,
|
||||
// (v0.22, #16 P3) the region reference table must also cover released
|
||||
// (no-man's-land) keys — they belong to no nation's territory, but the
|
||||
// model needs their names to re-claim them.
|
||||
regionReference: referenceForKeys(
|
||||
new Set([...allTerritoryKeys(game), ...(game.unowned ?? [])]),
|
||||
),
|
||||
validRegionKeys: validKeys(),
|
||||
// v0.21 (#16 P2): when the region-adjacency manifest loaded, hand the
|
||||
// engine the resolver — the turn then runs with the LLM's getNeighbours
|
||||
// tool and the player-frontier prompt field (both switch off without it).
|
||||
getNeighbours: hasAdjacency() ? (keys) => neighboursOf(keys) : undefined,
|
||||
});
|
||||
db.save(state);
|
||||
broadcast(id, 'turn', { state, result });
|
||||
|
||||
@@ -208,182 +208,3 @@ describe('createLlmClient (injectable transport)', () => {
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('createLlmClient.chatWithTools (function-calling loop, v0.21 #16 P2)', () => {
|
||||
const tool = {
|
||||
type: 'function' as const,
|
||||
function: {
|
||||
name: 'getNeighbours',
|
||||
description: 'list bordering region keys',
|
||||
parameters: { type: 'object' },
|
||||
},
|
||||
};
|
||||
|
||||
function toolCallResponse(id: string, name: string, args: string) {
|
||||
return json({
|
||||
choices: [
|
||||
{
|
||||
finish_reason: 'tool_calls',
|
||||
message: {
|
||||
content: null,
|
||||
tool_calls: [{ id, type: 'function', function: { name, arguments: args } }],
|
||||
},
|
||||
},
|
||||
],
|
||||
});
|
||||
}
|
||||
|
||||
function contentResponse(content: string) {
|
||||
return json({ choices: [{ finish_reason: 'stop', message: { content } }] });
|
||||
}
|
||||
|
||||
it('sends tools in the first request; echoes the assistant tool_calls + tool result; the executor gets parsed args', async () => {
|
||||
const sent: string[] = [];
|
||||
const transport = async (_url: string, init?: RequestInit) => {
|
||||
sent.push(String(init?.body ?? ''));
|
||||
if (sent.length === 1) return toolCallResponse('call_1', 'getNeighbours', '{"regionKeys":["a"]}');
|
||||
return contentResponse('final answer');
|
||||
};
|
||||
const executorCalls: Array<{ name: string; args: Record<string, unknown> }> = [];
|
||||
const llm = createLlmClient({ transport, apiBase: 'http://x/v1', model: 'm' });
|
||||
const out = await llm.chatWithTools!(
|
||||
[{ role: 'user', content: 'hi' }],
|
||||
[tool],
|
||||
(name, args) => {
|
||||
executorCalls.push({ name, args });
|
||||
return JSON.stringify({ neighbours: ['b'] });
|
||||
},
|
||||
);
|
||||
expect(out).toBe('final answer');
|
||||
expect(sent).toHaveLength(2);
|
||||
// request 1: the tools array is present, history is just the initial message
|
||||
const body1 = JSON.parse(sent[0]);
|
||||
expect(body1.tools).toEqual([tool]);
|
||||
expect(body1.messages).toEqual([{ role: 'user', content: 'hi' }]);
|
||||
// request 2: the assistant tool-call and the tool result are echoed back
|
||||
const body2 = JSON.parse(sent[1]);
|
||||
expect(body2.tools).toEqual([tool]);
|
||||
expect(body2.messages).toEqual([
|
||||
{ role: 'user', content: 'hi' },
|
||||
{
|
||||
role: 'assistant',
|
||||
content: null,
|
||||
tool_calls: [
|
||||
{
|
||||
id: 'call_1',
|
||||
type: 'function',
|
||||
function: { name: 'getNeighbours', arguments: '{"regionKeys":["a"]}' },
|
||||
},
|
||||
],
|
||||
},
|
||||
{ role: 'tool', tool_call_id: 'call_1', content: JSON.stringify({ neighbours: ['b'] }) },
|
||||
]);
|
||||
// the executor received the parsed (object) arguments, not the raw string
|
||||
expect(executorCalls).toEqual([{ name: 'getNeighbours', args: { regionKeys: ['a'] } }]);
|
||||
});
|
||||
|
||||
it('a content-only response ends in one round (the executor is never called)', async () => {
|
||||
const sent: string[] = [];
|
||||
const transport = async (_url: string, init?: RequestInit) => {
|
||||
sent.push(String(init?.body ?? ''));
|
||||
return contentResponse('done');
|
||||
};
|
||||
const llm = createLlmClient({ transport, apiBase: 'http://x/v1', model: 'm' });
|
||||
const out = await llm.chatWithTools!(
|
||||
[{ role: 'user', content: 'hi' }],
|
||||
[tool],
|
||||
() => {
|
||||
throw new Error('the executor must not be called');
|
||||
},
|
||||
);
|
||||
expect(out).toBe('done');
|
||||
expect(sent).toHaveLength(1);
|
||||
});
|
||||
|
||||
it('bounds the tool rounds: maxRounds tool-call rounds, then one final no-tools request', async () => {
|
||||
const sent: string[] = [];
|
||||
let n = 0;
|
||||
const transport = async (_url: string, init?: RequestInit) => {
|
||||
sent.push(String(init?.body ?? ''));
|
||||
n += 1;
|
||||
if (n <= 2) return toolCallResponse(`call_${n}`, 'getNeighbours', '{}');
|
||||
return contentResponse('committed');
|
||||
};
|
||||
const llm = createLlmClient({ transport, apiBase: 'http://x/v1', model: 'm' });
|
||||
const out = await llm.chatWithTools!(
|
||||
[{ role: 'user', content: 'hi' }],
|
||||
[tool],
|
||||
() => JSON.stringify({ neighbours: [] }),
|
||||
{ maxRounds: 2 },
|
||||
);
|
||||
expect(out).toBe('committed');
|
||||
expect(sent).toHaveLength(3); // 2 tool rounds + the forced final request
|
||||
expect(JSON.parse(sent[2]).tools).toBeUndefined(); // the final request has no tools
|
||||
});
|
||||
|
||||
it('malformed tool arguments produce an "invalid tool arguments" tool message (no throw)', async () => {
|
||||
const sent: string[] = [];
|
||||
let n = 0;
|
||||
const transport = async (_url: string, init?: RequestInit) => {
|
||||
sent.push(String(init?.body ?? ''));
|
||||
n += 1;
|
||||
if (n === 1) return toolCallResponse('call_1', 'getNeighbours', '{not valid json');
|
||||
return contentResponse('recovered');
|
||||
};
|
||||
const llm = createLlmClient({ transport, apiBase: 'http://x/v1', model: 'm' });
|
||||
const out = await llm.chatWithTools!(
|
||||
[{ role: 'user', content: 'hi' }],
|
||||
[tool],
|
||||
() => {
|
||||
throw new Error('the executor must not be called on malformed args');
|
||||
},
|
||||
);
|
||||
expect(out).toBe('recovered');
|
||||
const body2 = JSON.parse(sent[1]);
|
||||
const toolMsg = body2.messages.find((m: { role?: string }) => m.role === 'tool');
|
||||
expect(toolMsg).toBeDefined();
|
||||
expect(toolMsg.content).toMatch(/invalid tool arguments/);
|
||||
});
|
||||
|
||||
it('retries a tool-call round on transient failure and still resolves the tool (500 → tool_calls → content)', async () => {
|
||||
const sent: string[] = [];
|
||||
let n = 0;
|
||||
const transport = async (_url: string, init?: RequestInit) => {
|
||||
sent.push(String(init?.body ?? ''));
|
||||
n += 1;
|
||||
if (n === 1) return httpError(500);
|
||||
if (n === 2) return toolCallResponse('call_1', 'getNeighbours', '{"regionKeys":["a"]}');
|
||||
return contentResponse('ok');
|
||||
};
|
||||
const llm = createLlmClient({
|
||||
transport,
|
||||
apiBase: 'http://x/v1',
|
||||
model: 'm',
|
||||
retryBaseDelayMs: 1,
|
||||
});
|
||||
const out = await llm.chatWithTools!(
|
||||
[{ role: 'user', content: 'hi' }],
|
||||
[tool],
|
||||
() => JSON.stringify({ neighbours: [] }),
|
||||
);
|
||||
expect(out).toBe('ok');
|
||||
expect(sent).toHaveLength(3);
|
||||
});
|
||||
|
||||
it('a tool-call response is never treated as a truncation failure (content null is fine)', async () => {
|
||||
const sent: string[] = [];
|
||||
const transport = async (_url: string, init?: RequestInit) => {
|
||||
sent.push(String(init?.body ?? ''));
|
||||
if (sent.length === 1) return toolCallResponse('call_1', 'getNeighbours', '{}');
|
||||
return contentResponse('ok');
|
||||
};
|
||||
const llm = createLlmClient({ transport, apiBase: 'http://x/v1', model: 'm' });
|
||||
const out = await llm.chatWithTools!(
|
||||
[{ role: 'user', content: 'hi' }],
|
||||
[tool],
|
||||
() => JSON.stringify({ neighbours: [] }),
|
||||
);
|
||||
expect(out).toBe('ok');
|
||||
expect(sent).toHaveLength(2); // no retry of the first (successful) round
|
||||
});
|
||||
});
|
||||
|
||||
+9
-189
@@ -23,55 +23,12 @@
|
||||
// to 3 total attempts and 2s→3s backoff (±20% jitter). HTTP 4xx is a
|
||||
// deterministic client error and throws immediately, with no retry. Every
|
||||
// call is logged: one line on success, one on final failure.
|
||||
//
|
||||
// Function calling: `chatWithTools()` extends `chat()` with the OpenAI tool
|
||||
// loop. When the model answers with `finish_reason: "tool_calls"`, the client
|
||||
// runs the provided executor for every requested call, appends the assistant
|
||||
// tool-call message plus one `tool` result message per call, and re-sends the
|
||||
// growing history until the model produces a final `content`. The loop is
|
||||
// bounded to DEFAULT_MAX_TOOL_ROUNDS (6) tool rounds; if the budget is spent
|
||||
// without a final answer, one last *no-tools* request forces the model to
|
||||
// commit. The same retry/backoff/reasoning-effort machinery applies per
|
||||
// request, so an injectable transport only has to forward `tools` in the body
|
||||
// and accept `assistant`/`tool` messages in the history. The deterministic
|
||||
// stub answers plain `content` (no tool calls) and therefore bypasses the
|
||||
// loop in a single round.
|
||||
|
||||
export interface ChatMessage {
|
||||
role: 'system' | 'user' | 'assistant';
|
||||
content: string;
|
||||
}
|
||||
|
||||
/** One OpenAI-style function call the model requests (`finish_reason: "tool_calls"`). */
|
||||
export interface ToolCallSpec {
|
||||
id: string;
|
||||
type: 'function';
|
||||
function: { name: string; arguments: string };
|
||||
}
|
||||
|
||||
/** A function the model may call (one OpenAI `tools` entry). */
|
||||
export interface ToolDefinition {
|
||||
type: 'function';
|
||||
function: {
|
||||
name: string;
|
||||
description?: string;
|
||||
parameters?: Record<string, unknown>;
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* The full message vocabulary a request can carry: plain chat messages, plus
|
||||
* assistant messages that request tool calls and the `tool` results that
|
||||
* answer them (the OpenAI function-calling wire shape).
|
||||
*/
|
||||
export type WireMessage =
|
||||
| ChatMessage
|
||||
| { role: 'assistant'; content: string | null; tool_calls: ToolCallSpec[] }
|
||||
| { role: 'tool'; tool_call_id: string; content: string };
|
||||
|
||||
/** Executes one tool call; the returned string is fed back to the model as the `tool` result. */
|
||||
export type ToolExecutor = (name: string, args: Record<string, unknown>) => string;
|
||||
|
||||
/** A network call. The default implementation is native fetch. */
|
||||
export type Transport = (url: string, init?: RequestInit) => Promise<Response>;
|
||||
|
||||
@@ -82,18 +39,6 @@ export interface ChatOptions {
|
||||
|
||||
export interface LlmClient {
|
||||
chat(messages: ChatMessage[], opts?: ChatOptions): Promise<string>;
|
||||
/**
|
||||
* The function-calling variant of chat() — see the file header for the loop
|
||||
* semantics (bounded tool rounds, then a forced final answer). Optional on
|
||||
* the interface: minimal test doubles may omit it, and callers (the
|
||||
* engine's runTurn) fall back to chat() when it is absent.
|
||||
*/
|
||||
chatWithTools?(
|
||||
messages: WireMessage[],
|
||||
tools: ToolDefinition[],
|
||||
executeTool: ToolExecutor,
|
||||
opts?: ChatOptions & { maxRounds?: number },
|
||||
): Promise<string>;
|
||||
listModels(): Promise<string[]>;
|
||||
}
|
||||
|
||||
@@ -118,17 +63,9 @@ export const DEFAULT_MAX_TOKENS = 4000;
|
||||
*/
|
||||
export const DEFAULT_REASONING_EFFORT = 'low';
|
||||
|
||||
/** Total attempts per request (chat / chatWithTools) before giving up (1 initial + 2 retries). */
|
||||
/** Total attempts `chat()` makes before giving up (1 initial + 2 retries). */
|
||||
export const MAX_ATTEMPTS = 3;
|
||||
|
||||
/**
|
||||
* Max tool-call rounds (assistant tool_calls → tool results) a chatWithTools
|
||||
* loop may make before a final no-tools request forces the answer. Keeps a
|
||||
* turn bounded even if the model keeps asking for data; a realistic turn uses
|
||||
* 0–2 rounds.
|
||||
*/
|
||||
export const DEFAULT_MAX_TOOL_ROUNDS = 6;
|
||||
|
||||
/** Base retry backoff: retry 1 waits 2000ms, retry 2 waits 3000ms, each ±20% jitter. */
|
||||
const RETRY_BASE_DELAY_MS = 2000;
|
||||
|
||||
@@ -217,30 +154,6 @@ function isNetworkError(err: unknown): boolean {
|
||||
);
|
||||
}
|
||||
|
||||
/** Parse the wire `tool_calls` array into validated ToolCallSpecs (malformed entries are dropped). */
|
||||
function parseToolCalls(raw: unknown): ToolCallSpec[] {
|
||||
if (!Array.isArray(raw)) return [];
|
||||
const out: ToolCallSpec[] = [];
|
||||
for (const tc of raw) {
|
||||
if (!tc || typeof tc !== 'object') continue;
|
||||
const t = tc as Record<string, unknown>;
|
||||
const fn = t.function as Record<string, unknown> | undefined;
|
||||
if (!fn || typeof fn.name !== 'string' || fn.name === '') continue;
|
||||
const argumentsText =
|
||||
typeof fn.arguments === 'string'
|
||||
? fn.arguments
|
||||
: fn.arguments != null
|
||||
? JSON.stringify(fn.arguments)
|
||||
: '{}';
|
||||
out.push({
|
||||
id: typeof t.id === 'string' && t.id !== '' ? t.id : `call_${out.length}`,
|
||||
type: 'function',
|
||||
function: { name: fn.name, arguments: argumentsText },
|
||||
});
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/** One transport attempt, classified as success / retryable / fatal. */
|
||||
interface Attempt {
|
||||
status?: number;
|
||||
@@ -248,7 +161,6 @@ interface Attempt {
|
||||
retryable: boolean;
|
||||
content?: string;
|
||||
finishReason?: string | null;
|
||||
toolCalls?: ToolCallSpec[];
|
||||
}
|
||||
|
||||
export function createLlmClient(deps: LlmClientDeps = {}): LlmClient {
|
||||
@@ -267,7 +179,7 @@ export function createLlmClient(deps: LlmClientDeps = {}): LlmClient {
|
||||
|
||||
/**
|
||||
* One POST to /chat/completions. Classifies the outcome:
|
||||
* - success → content and/or tool_calls
|
||||
* - success → content + finish_reason
|
||||
* - retryable → timeout/abort, HTTP 5xx, network error, null/empty content
|
||||
* - fatal → HTTP 4xx (deterministic client error) or an unexpected throw
|
||||
*/
|
||||
@@ -301,27 +213,12 @@ export function createLlmClient(deps: LlmClientDeps = {}): LlmClient {
|
||||
const body = (await res.json()) as {
|
||||
choices?: {
|
||||
finish_reason?: string | null;
|
||||
message?: { content?: string; reasoning?: string | null; tool_calls?: unknown };
|
||||
message?: { content?: string; reasoning?: string | null };
|
||||
}[];
|
||||
};
|
||||
const choice = body.choices?.[0];
|
||||
const message = choice?.message;
|
||||
// A tool-call round is a SUCCESS even though `content` is null there: the
|
||||
// model is asking for data, not failing (never treat it as truncation).
|
||||
const toolCalls = parseToolCalls(message?.tool_calls);
|
||||
if (toolCalls.length > 0) {
|
||||
return {
|
||||
status: res.status,
|
||||
retryable: false,
|
||||
content:
|
||||
typeof message?.content === 'string' && message.content !== '' ? message.content : undefined,
|
||||
finishReason: choice?.finish_reason ?? null,
|
||||
toolCalls,
|
||||
};
|
||||
}
|
||||
// The reasoning model can exhaust its output budget on the CoT and return
|
||||
// a null `content` — treat that as a retryable truncation, not a success.
|
||||
const content = message?.content;
|
||||
const content = body.choices?.[0]?.message?.content;
|
||||
if (typeof content !== 'string' || content === '') {
|
||||
return {
|
||||
status: res.status,
|
||||
@@ -333,16 +230,11 @@ export function createLlmClient(deps: LlmClientDeps = {}): LlmClient {
|
||||
status: res.status,
|
||||
retryable: false,
|
||||
content,
|
||||
finishReason: choice?.finish_reason ?? null,
|
||||
finishReason: body.choices?.[0]?.finish_reason ?? null,
|
||||
};
|
||||
}
|
||||
|
||||
/** Build one /chat/completions request body. `tools` is only included when non-empty, so plain chat() keeps its exact legacy shape. */
|
||||
function buildPayload(
|
||||
messages: WireMessage[],
|
||||
tools: ToolDefinition[] | undefined,
|
||||
opts: ChatOptions,
|
||||
): Record<string, unknown> {
|
||||
async function chat(messages: ChatMessage[], opts: ChatOptions = {}): Promise<string> {
|
||||
const payload: Record<string, unknown> = {
|
||||
model,
|
||||
messages,
|
||||
@@ -353,16 +245,7 @@ export function createLlmClient(deps: LlmClientDeps = {}): LlmClient {
|
||||
};
|
||||
if (opts.temperature != null) payload.temperature = opts.temperature;
|
||||
if (sendEffort) payload.reasoning_effort = effort;
|
||||
if (tools && tools.length > 0) payload.tools = tools;
|
||||
return payload;
|
||||
}
|
||||
|
||||
/**
|
||||
* One request with the standard retry/backoff: up to MAX_ATTEMPTS per
|
||||
* request; resolves with a successful Attempt (content and/or toolCalls) or
|
||||
* throws the last error once the attempts are spent.
|
||||
*/
|
||||
async function requestWithRetry(payload: Record<string, unknown>): Promise<Attempt> {
|
||||
const totalStart = Date.now();
|
||||
let lastStatus: number | undefined;
|
||||
let lastError: Error = new Error('chat failed: no attempt completed');
|
||||
@@ -372,13 +255,12 @@ export function createLlmClient(deps: LlmClientDeps = {}): LlmClient {
|
||||
if (out.status !== undefined) lastStatus = out.status;
|
||||
if (out.error) lastError = out.error;
|
||||
|
||||
if (out.content !== undefined || out.toolCalls !== undefined) {
|
||||
if (out.content !== undefined) {
|
||||
console.log('[llm] chat ok', {
|
||||
ms: Date.now() - totalStart,
|
||||
finishReason: out.finishReason ?? null,
|
||||
toolCalls: out.toolCalls?.length ?? 0,
|
||||
});
|
||||
return out;
|
||||
return out.content;
|
||||
}
|
||||
// Give up on a non-retryable failure, or when the last attempt is spent.
|
||||
if (!out.retryable || attempt === MAX_ATTEMPTS) {
|
||||
@@ -396,68 +278,6 @@ export function createLlmClient(deps: LlmClientDeps = {}): LlmClient {
|
||||
throw lastError;
|
||||
}
|
||||
|
||||
async function chat(messages: ChatMessage[], opts: ChatOptions = {}): Promise<string> {
|
||||
const out = await requestWithRetry(buildPayload(messages, undefined, opts));
|
||||
return out.content ?? '';
|
||||
}
|
||||
|
||||
/**
|
||||
* The function-calling loop — see the file header. Bounded: at most
|
||||
* `maxRounds` tool rounds, then one final no-tools request forces an answer.
|
||||
* Throws like chat() only on transport-level exhaustion (the engine maps that
|
||||
* to a 502; bad *content* never throws, it is parsed defensively downstream).
|
||||
*/
|
||||
async function chatWithTools(
|
||||
initial: WireMessage[],
|
||||
tools: ToolDefinition[],
|
||||
executeTool: ToolExecutor,
|
||||
opts: ChatOptions & { maxRounds?: number } = {},
|
||||
): Promise<string> {
|
||||
const maxRounds = Math.max(1, opts.maxRounds ?? DEFAULT_MAX_TOOL_ROUNDS);
|
||||
const messages: WireMessage[] = [...initial];
|
||||
for (let round = 0; round < maxRounds; round++) {
|
||||
const out = await requestWithRetry(buildPayload(messages, tools, opts));
|
||||
// Tool calls win over any partial content: the model asked for data
|
||||
// before it finished.
|
||||
if (out.toolCalls && out.toolCalls.length > 0) {
|
||||
messages.push({
|
||||
role: 'assistant',
|
||||
content: out.content ?? null,
|
||||
tool_calls: out.toolCalls,
|
||||
});
|
||||
for (const tc of out.toolCalls) {
|
||||
let result: string;
|
||||
try {
|
||||
const parsed: unknown =
|
||||
tc.function.arguments !== '' ? JSON.parse(tc.function.arguments) : {};
|
||||
const args =
|
||||
parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
|
||||
? (parsed as Record<string, unknown>)
|
||||
: {};
|
||||
result = executeTool(tc.function.name, args);
|
||||
} catch (err) {
|
||||
// Malformed arguments are not fatal: hand the model an error
|
||||
// result so it can re-call with valid arguments or move on.
|
||||
result = JSON.stringify({
|
||||
error: `invalid tool arguments: ${err instanceof Error ? err.message : String(err)}`,
|
||||
});
|
||||
}
|
||||
messages.push({ role: 'tool', tool_call_id: tc.id, content: result });
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (out.content !== undefined) return out.content;
|
||||
}
|
||||
// The tool budget is spent without a final answer: one last no-tools
|
||||
// request forces the model to commit.
|
||||
messages.push({
|
||||
role: 'user',
|
||||
content: 'You have reached your tool budget. Answer now with the final result only.',
|
||||
});
|
||||
const out = await requestWithRetry(buildPayload(messages, undefined, opts));
|
||||
return out.content ?? '';
|
||||
}
|
||||
|
||||
async function listModels(): Promise<string[]> {
|
||||
const res = await transport(`${apiBase}/models`, {
|
||||
signal: AbortSignal.timeout(timeoutMs),
|
||||
@@ -467,5 +287,5 @@ export function createLlmClient(deps: LlmClientDeps = {}): LlmClient {
|
||||
return (body.data ?? []).map((m) => m.id);
|
||||
}
|
||||
|
||||
return { chat, chatWithTools, listModels };
|
||||
return { chat, listModels };
|
||||
}
|
||||
|
||||
+46
-117
@@ -1,24 +1,10 @@
|
||||
import { describe, expect, it } from 'vitest';
|
||||
import { buildRegionMap } from './map';
|
||||
import {
|
||||
mapFeatureOwner,
|
||||
nationColor,
|
||||
NO_MANS_LAND_FILL,
|
||||
NO_MANS_LAND_STROKE,
|
||||
OWNED_STROKE,
|
||||
regionFillStyle,
|
||||
regionOwner,
|
||||
UNOWNED_FILL,
|
||||
UNOWNED_STROKE,
|
||||
unownedTooltipLabel,
|
||||
type RegionMap,
|
||||
} from '../shared/protocol';
|
||||
import { mapFeatureOwner, nationColor, regionOwner, type RegionMap } from '../shared/protocol';
|
||||
import type { GameState } from '../shared/types';
|
||||
|
||||
// Region-key fixtures (v0.19, #16 P1): ownership and the RegionMap are now keyed
|
||||
// by region key (one per owned sub-region), not by a parent-country ISO_A3. The
|
||||
// keys below are deliberately fake (obviously not real manifest entries) so this
|
||||
// test stays self-contained and format-agnostic.
|
||||
// As of v0.19 territory is a list of **sub-region ids** (the RegionMap keys),
|
||||
// not whole-country ISO_A3 codes.
|
||||
const state: GameState = {
|
||||
id: 'g',
|
||||
presetId: 'p',
|
||||
@@ -32,7 +18,7 @@ const state: GameState = {
|
||||
name: 'UK',
|
||||
type: 'major',
|
||||
stats: { military: 80, economy: 70, stability: 60, population: 50 },
|
||||
territory: ['albania-aaaa', 'wales-bbbb'],
|
||||
territory: ['GB-01', 'GB-02'],
|
||||
relations: {},
|
||||
},
|
||||
de: {
|
||||
@@ -40,49 +26,38 @@ const state: GameState = {
|
||||
name: 'DE',
|
||||
type: 'major',
|
||||
stats: { military: 90, economy: 70, stability: 70, population: 90 },
|
||||
territory: ['brandenburg-cccc'],
|
||||
territory: ['DE-01'],
|
||||
relations: {},
|
||||
},
|
||||
},
|
||||
events: [],
|
||||
pending: [],
|
||||
version: 1,
|
||||
unowned: [],
|
||||
pendingNationOps: [],
|
||||
};
|
||||
|
||||
// The RegionMap built from the fixture: the authoritative region key → owner source.
|
||||
// The RegionMap built from the fixture: the authoritative sub-region id → owner
|
||||
// source.
|
||||
const regions: RegionMap = buildRegionMap(state);
|
||||
|
||||
describe('buildRegionMap', () => {
|
||||
it('maps each owned region key to its owner + that nation\'s stable color', () => {
|
||||
it('maps each sub-region id to its owner + that nation\'s stable color', () => {
|
||||
const m = buildRegionMap(state);
|
||||
expect(m['albania-aaaa']).toEqual({ color: nationColor('uk'), owner: 'UK', ownerId: 'uk' });
|
||||
expect(m['wales-bbbb']).toEqual({ color: nationColor('uk'), owner: 'UK', ownerId: 'uk' });
|
||||
expect(m['brandenburg-cccc']).toEqual({ color: nationColor('de'), owner: 'DE', ownerId: 'de' });
|
||||
// a region nobody owns is simply absent
|
||||
expect(m['normandie-dddd']).toBeUndefined();
|
||||
});
|
||||
|
||||
it('(v0.22 #16 P3) a released (no-man\'s-land) key — in GameState.unowned, owned by no nation — is absent: absence IS unowned', () => {
|
||||
const s: GameState = JSON.parse(JSON.stringify(state));
|
||||
// simulate a mid-game release: the key left every territory and entered unowned
|
||||
s.nations.uk.territory = s.nations.uk.territory.filter((k) => k !== 'albania-aaaa');
|
||||
s.unowned = ['albania-aaaa'];
|
||||
const m = buildRegionMap(s);
|
||||
expect(m['albania-aaaa']).toBeUndefined(); // the map cannot tell which kind of unowned
|
||||
expect(s.unowned).toEqual(['albania-aaaa']); // ...the client's GameState.unowned decides that
|
||||
expect(m['GB-01']).toEqual({ color: nationColor('uk'), owner: 'UK', ownerId: 'uk' });
|
||||
expect(m['GB-02']).toEqual({ color: nationColor('uk'), owner: 'UK', ownerId: 'uk' });
|
||||
expect(m['DE-01']).toEqual({ color: nationColor('de'), owner: 'DE', ownerId: 'de' });
|
||||
// a sub-region nobody owns is simply absent
|
||||
expect(m['FR-57']).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('regionOwner', () => {
|
||||
it('resolves an owned region key to its owner record', () => {
|
||||
expect(regionOwner(regions, 'albania-aaaa')).toEqual({
|
||||
it('resolves an owned sub-region id to its owner record', () => {
|
||||
expect(regionOwner(regions, 'GB-01')).toEqual({
|
||||
color: nationColor('uk'),
|
||||
owner: 'UK',
|
||||
ownerId: 'uk',
|
||||
});
|
||||
expect(regionOwner(regions, 'brandenburg-cccc')).toEqual({
|
||||
expect(regionOwner(regions, 'DE-01')).toEqual({
|
||||
color: nationColor('de'),
|
||||
owner: 'DE',
|
||||
ownerId: 'de',
|
||||
@@ -90,11 +65,11 @@ describe('regionOwner', () => {
|
||||
});
|
||||
|
||||
it('returns undefined for an unowned region (no RegionMap entry)', () => {
|
||||
expect(regionOwner(regions, 'normandie-dddd')).toBeUndefined();
|
||||
expect(regionOwner(regions, 'yorkshire-eeee')).toBeUndefined();
|
||||
expect(regionOwner(regions, 'FR-57')).toBeUndefined();
|
||||
expect(regionOwner(regions, 'US-01')).toBeUndefined();
|
||||
});
|
||||
|
||||
it('returns undefined for an empty or missing key', () => {
|
||||
it('returns undefined for an empty or missing id', () => {
|
||||
expect(regionOwner(regions, '')).toBeUndefined();
|
||||
expect(regionOwner(regions, null)).toBeUndefined();
|
||||
expect(regionOwner(regions, undefined)).toBeUndefined();
|
||||
@@ -102,29 +77,28 @@ describe('regionOwner', () => {
|
||||
});
|
||||
|
||||
/**
|
||||
* #6 regression guard (sub-national map, region-keyed). The click/hover handlers
|
||||
* resolve the owning nation from a rendered map feature. MapLibre repacks a
|
||||
* GeoJSON source's top-level `id` into a *numeric index* when it stores the
|
||||
* source, so a feature the map hands back at interaction time has a number for
|
||||
* `id`. The choropleth is sub-national: a feature's own sub-region id is a code
|
||||
* (`DEU-03`), and its owner now lives at its **region key** (`brandenburg-cccc`),
|
||||
* which the client stamps into `properties.regionKey` from `region-keys.json`
|
||||
* (the RegionMap is keyed by that key, never the sub-region id nor the repacked
|
||||
* id). This pins the exact data shape and proves the resolution:
|
||||
* `mapFeatureOwner` works via `properties.regionKey`, while the two wrong paths
|
||||
* (the repacked numeric `feature.id`, and the sub-region `regionId`, which is
|
||||
* not a RegionMap key) do not.
|
||||
* #6 regression guard (sub-national map, v0.19 region-level ownership). The
|
||||
* click/hover handlers resolve the owning nation from a rendered map feature.
|
||||
* MapLibre repacks a GeoJSON source's top-level `id` into a *numeric index*
|
||||
* when it stores the source, so a feature the map hands back at interaction
|
||||
* time has a number for `id`. Since v0.19 ownership is at **sub-region**
|
||||
* granularity: a feature's owner lives at its **own sub-region id** (e.g.
|
||||
* `DE-01`), which the client stamps into `properties.regionId` (the RegionMap
|
||||
* is keyed by that id). This pins the exact data shape and proves the
|
||||
* resolution: `mapFeatureOwner` works via `properties.regionId`, while the
|
||||
* repacked numeric `feature.id` path does not.
|
||||
*/
|
||||
describe('#6 — sub-region owner must be resolved from properties.regionKey, not the sub-region id / repacked feature.id', () => {
|
||||
describe('#6 — region owner must be resolved from properties.regionId, never the repacked feature.id', () => {
|
||||
// The shape MapLibre returns for a sub-region feature after setData(): `id`
|
||||
// is a number (repacked), and the stable identifiers live only in properties —
|
||||
// `regionId` (the sub-region code) and `regionKey` (the region key).
|
||||
// is a number (repacked), and the stable identifiers live only in properties
|
||||
// — `regionId` (the sub-region id, the RegionMap key) and `parent` (the
|
||||
// static parent country's ISO_A3).
|
||||
const repackedFeature = {
|
||||
id: 0,
|
||||
properties: { name: 'Brandenburg R03', regionId: 'DEU-03', regionKey: 'brandenburg-cccc' },
|
||||
properties: { name: 'Rhineland', regionId: 'DE-01', parent: 'DEU' },
|
||||
};
|
||||
|
||||
it('resolves the owner from properties.regionKey (the fix)', () => {
|
||||
it('resolves the owner from properties.regionId (the fix)', () => {
|
||||
expect(mapFeatureOwner(regions, repackedFeature)).toEqual({
|
||||
color: nationColor('de'),
|
||||
owner: 'DE',
|
||||
@@ -132,30 +106,30 @@ describe('#6 — sub-region owner must be resolved from properties.regionKey, no
|
||||
});
|
||||
});
|
||||
|
||||
it('the sub-region regionId is NOT a RegionMap key — resolving from it fails', () => {
|
||||
// 'DEU-03' is a sub-region id; the RegionMap is keyed by region key.
|
||||
expect(regionOwner(regions, repackedFeature.properties.regionId)).toBeUndefined();
|
||||
});
|
||||
|
||||
it('the repacked numeric feature.id does NOT resolve — the bug', () => {
|
||||
it('the repacked numeric feature.id does NOT resolve — the original bug', () => {
|
||||
// String(0) === '0' is not a valid key, so the pre-fix lookup failed and
|
||||
// reported "No owner" even for owned regions.
|
||||
expect(regionOwner(regions, String(repackedFeature.id))).toBeUndefined();
|
||||
});
|
||||
|
||||
it('a sub-region id nobody owns does NOT resolve', () => {
|
||||
expect(regionOwner(regions, 'FR-57')).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('mapFeatureOwner', () => {
|
||||
it('returns undefined for a missing feature, missing regionKey, or non-string regionKey', () => {
|
||||
it('returns undefined for a missing feature, missing regionId, or non-string regionId', () => {
|
||||
expect(mapFeatureOwner(regions, null)).toBeUndefined();
|
||||
expect(mapFeatureOwner(regions, undefined)).toBeUndefined();
|
||||
expect(mapFeatureOwner(regions, {})).toBeUndefined();
|
||||
expect(mapFeatureOwner(regions, { properties: {} })).toBeUndefined();
|
||||
expect(mapFeatureOwner(regions, { properties: { regionKey: 42 } })).toBeUndefined();
|
||||
expect(mapFeatureOwner(regions, { properties: { regionId: 42 } })).toBeUndefined();
|
||||
expect(mapFeatureOwner(regions, { properties: { regionId: '' } })).toBeUndefined();
|
||||
});
|
||||
|
||||
it('returns undefined for a region key nobody owns', () => {
|
||||
expect(mapFeatureOwner(regions, { properties: { regionKey: 'normandie-dddd' } })).toBeUndefined();
|
||||
expect(mapFeatureOwner(regions, { properties: { regionKey: 'yorkshire-eeee' } })).toBeUndefined();
|
||||
it('returns undefined for a sub-region nobody owns', () => {
|
||||
expect(mapFeatureOwner(regions, { properties: { regionId: 'FR-57' } })).toBeUndefined();
|
||||
expect(mapFeatureOwner(regions, { properties: { regionId: 'US-01' } })).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
@@ -167,48 +141,3 @@ describe('nationColor', () => {
|
||||
expect(nationColor('uk')).toMatch(/^hsl\(\d+ 58% 46%\)$/);
|
||||
});
|
||||
});
|
||||
|
||||
// (v0.22, #16 P3) The no-man's-land presentation contract lives in
|
||||
// shared/protocol (shared/*.test.ts is not in the vitest glob, so these
|
||||
// tests live here): the distinct visible grey, the faint preset-unassigned
|
||||
// look, the per-kind borders, and the tooltip sub-line.
|
||||
describe('no man\'s land presentation contract (v0.22 #16 P3)', () => {
|
||||
it('regionFillStyle: an owned region uses its nation color + the owned border', () => {
|
||||
expect(regionFillStyle(regions['albania-aaaa'], false)).toEqual({
|
||||
fill: nationColor('uk'),
|
||||
stroke: OWNED_STROKE,
|
||||
});
|
||||
expect(regionFillStyle(regions['brandenburg-cccc'], true)).toEqual({
|
||||
fill: nationColor('de'),
|
||||
stroke: OWNED_STROKE,
|
||||
}); // the no-man's-land flag never affects an owned region
|
||||
});
|
||||
|
||||
it('regionFillStyle: an unowned region that IS no man\'s land gets the distinct visible grey', () => {
|
||||
expect(regionFillStyle(undefined, true)).toEqual({
|
||||
fill: NO_MANS_LAND_FILL,
|
||||
stroke: NO_MANS_LAND_STROKE,
|
||||
});
|
||||
});
|
||||
|
||||
it('regionFillStyle: an unowned region that was never released keeps the faint look', () => {
|
||||
expect(regionFillStyle(undefined, false)).toEqual({
|
||||
fill: UNOWNED_FILL,
|
||||
stroke: UNOWNED_STROKE,
|
||||
});
|
||||
});
|
||||
|
||||
it('the no-man\'s-land grey can never collide with a nation color (hue-less vs HSL)', () => {
|
||||
expect(NO_MANS_LAND_FILL).not.toMatch(/^hsl\(/);
|
||||
expect(NO_MANS_LAND_FILL).not.toBe(nationColor('uk'));
|
||||
expect(NO_MANS_LAND_FILL).not.toBe(nationColor('de'));
|
||||
// and it must be visibly different from the faint preset-unassigned fill
|
||||
expect(NO_MANS_LAND_FILL).not.toBe(UNOWNED_FILL);
|
||||
expect(NO_MANS_LAND_STROKE).not.toBe(UNOWNED_STROKE);
|
||||
});
|
||||
|
||||
it('unownedTooltipLabel: the tooltip sub-line names the two kinds of unowned', () => {
|
||||
expect(unownedTooltipLabel(true)).toBe("No man's land");
|
||||
expect(unownedTooltipLabel(false)).toBe('No owner');
|
||||
});
|
||||
});
|
||||
|
||||
+9
-14
@@ -1,15 +1,10 @@
|
||||
// Build the choropleth payload from a GameState: every region key (see
|
||||
// public/region-keys.json) maps to its owning nation plus that nation's stable
|
||||
// color (see shared.nationColor). The client merges this onto the sub-national
|
||||
// regions.geo.json (resolving each feature by its own region key) and calls
|
||||
// source.setData(). Format-agnostic: it maps whatever keys sit in territory.
|
||||
//
|
||||
// A key ABSENT from the returned map is unowned (no nation's territory holds
|
||||
// it) — this covers both regions a preset never assigned and regions released
|
||||
// to no man's land mid-game (v0.22, #16 P3). The map deliberately does NOT
|
||||
// distinguish the two: the visible no-man's-land grey vs the faint
|
||||
// preset-unassigned look is decided by the client from `GameState.unowned`
|
||||
// (see shared/protocol.ts's regionFillStyle).
|
||||
// Build the choropleth payload from a GameState: every **sub-region id** in a
|
||||
// nation's territory maps to its owning nation plus that nation's stable color
|
||||
// (see shared.nationColor). The client merges this onto public/regions.geo.json
|
||||
// and calls source.setData(). The map is keyed by whatever ids sit in
|
||||
// `nation.territory` — sub-region ids (e.g. `FR-57`) as of v0.19 — so it needs
|
||||
// no change to move from country to sub-region granularity; a sub-region in no
|
||||
// nation's territory is simply absent (unowned, rendered grey by the map).
|
||||
import { nationColor, type RegionMap } from '../shared/protocol';
|
||||
import type { GameState } from '../shared/types';
|
||||
|
||||
@@ -17,8 +12,8 @@ export function buildRegionMap(state: GameState): RegionMap {
|
||||
const map: RegionMap = {};
|
||||
for (const [id, nation] of Object.entries(state.nations)) {
|
||||
const color = nationColor(id);
|
||||
for (const key of nation.territory) {
|
||||
map[key] = { color, owner: nation.name, ownerId: id };
|
||||
for (const regionId of nation.territory) {
|
||||
map[regionId] = { color, owner: nation.name, ownerId: id };
|
||||
}
|
||||
}
|
||||
return map;
|
||||
|
||||
+156
-174
@@ -1,194 +1,176 @@
|
||||
import { afterAll, afterEach, beforeEach, describe, expect, it } from 'vitest';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { copyFileSync, mkdirSync, mkdtempSync, rmSync } from 'node:fs';
|
||||
import { tmpdir } from 'node:os';
|
||||
/**
|
||||
* server/regions.test.ts — the sub-region data module (v0.19).
|
||||
*
|
||||
* The first suite loads the REAL `public/regions.geo.json` (the same file the
|
||||
* production server loads at boot), so expansion/migration runs against the
|
||||
* actual 1,796-region dataset. The second suite exercises the graceful
|
||||
* "geo missing" path (module not loaded) via the `_resetRegionsForTests` seam,
|
||||
* and pins the `_setRegionsForTests` fixture seam used by the other unit tests.
|
||||
* Module state is per vitest file, so these suites never collide with other
|
||||
* test files.
|
||||
*/
|
||||
import path from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
||||
import type { GameState } from '../shared/types';
|
||||
import {
|
||||
allTerritoryKeys,
|
||||
expandCountriesToKeys,
|
||||
hasAdjacency,
|
||||
_resetRegionsForTests,
|
||||
_setRegionsForTests,
|
||||
expandTerritory,
|
||||
hasRegionData,
|
||||
loadRegions,
|
||||
neighboursOf,
|
||||
referenceForKeys,
|
||||
regionName,
|
||||
resetRegions,
|
||||
validKeys,
|
||||
migrateTerritoryToRegions,
|
||||
regionLabel,
|
||||
regionNamesFor,
|
||||
} from './regions';
|
||||
import type { GameState } from '../shared/types';
|
||||
|
||||
// The repo root: this file lives in server/, so '..' is the directory holding
|
||||
// public/region-keys.json and public/regions.geo.json. cwd-independent (mirrors
|
||||
// how server/index.ts locates its root via import.meta.url).
|
||||
const root = fileURLToPath(new URL('..', import.meta.url));
|
||||
const here = path.dirname(fileURLToPath(import.meta.url));
|
||||
const root = path.resolve(here, '..');
|
||||
|
||||
describe('regions (region-key loader, v0.19 #16 P1)', () => {
|
||||
beforeEach(() => {
|
||||
expect(loadRegions(root)).toBe(true);
|
||||
});
|
||||
|
||||
it('loads the full manifest: 1,796 unique valid region keys', () => {
|
||||
expect(hasRegionData()).toBe(true);
|
||||
expect(validKeys().size).toBe(1796);
|
||||
});
|
||||
|
||||
it('expands an ISO_A3 country to the region keys of all its sub-regions', () => {
|
||||
const fra = expandCountriesToKeys(['FRA']);
|
||||
// FRA has 42 sub-regions in the committed dataset.
|
||||
expect(fra).toHaveLength(42);
|
||||
// every expanded key is a real region key
|
||||
for (const k of fra) expect(validKeys().has(k)).toBe(true);
|
||||
// and the reference table labels each one with its parent country
|
||||
const ref = referenceForKeys(fra);
|
||||
expect(Object.keys(ref)).toHaveLength(42);
|
||||
for (const [k, label] of Object.entries(ref)) {
|
||||
expect(label.endsWith('(FRA)')).toBe(true);
|
||||
expect(regionName(k)).toBeTruthy();
|
||||
}
|
||||
// sample known FRA keys, and their exact reference strings
|
||||
expect(fra).toContain('ain-lqtt');
|
||||
expect(ref['ain-lqtt']).toBe('Ain (FRA)');
|
||||
expect(ref['aisne-gstu']).toBe('Aisne (FRA)');
|
||||
});
|
||||
|
||||
it('referenceForKeys labels only known keys and omits unknown ones', () => {
|
||||
const ref = referenceForKeys(['ain-lqtt', 'not-a-real-key-xyz']);
|
||||
expect(ref['ain-lqtt']).toBe('Ain (FRA)');
|
||||
expect(ref['not-a-real-key-xyz']).toBeUndefined();
|
||||
});
|
||||
|
||||
it('allTerritoryKeys unions every nation\'s territory keys (no overlap)', () => {
|
||||
const state: GameState = {
|
||||
id: 'g',
|
||||
presetId: 'p',
|
||||
presetTitle: 'P',
|
||||
playerNationId: 'uk',
|
||||
turn: 1,
|
||||
date: '1939-09-01',
|
||||
nations: {
|
||||
uk: {
|
||||
id: 'uk',
|
||||
name: 'UK',
|
||||
type: 'major',
|
||||
stats: { military: 80, economy: 70, stability: 60, population: 50 },
|
||||
territory: expandCountriesToKeys(['GBR']),
|
||||
relations: {},
|
||||
},
|
||||
fr: {
|
||||
id: 'fr',
|
||||
name: 'FR',
|
||||
type: 'major',
|
||||
stats: { military: 80, economy: 70, stability: 60, population: 50 },
|
||||
territory: expandCountriesToKeys(['FRA']),
|
||||
relations: {},
|
||||
},
|
||||
function makeState(territory: string[]): GameState {
|
||||
return {
|
||||
id: 'g',
|
||||
presetId: 'p',
|
||||
presetTitle: 'P',
|
||||
playerNationId: 'uk',
|
||||
turn: 1,
|
||||
date: '1939-09-01',
|
||||
nations: {
|
||||
uk: {
|
||||
id: 'uk',
|
||||
name: 'UK',
|
||||
type: 'major',
|
||||
stats: { military: 80, economy: 70, stability: 60, population: 50 },
|
||||
territory,
|
||||
relations: {},
|
||||
},
|
||||
events: [],
|
||||
pending: [],
|
||||
version: 1,
|
||||
unowned: [],
|
||||
pendingNationOps: [],
|
||||
};
|
||||
// 16 GBR sub-regions + 42 FRA sub-regions, no overlap between the two.
|
||||
expect(allTerritoryKeys(state).size).toBe(58);
|
||||
},
|
||||
events: [],
|
||||
pending: [],
|
||||
version: 1,
|
||||
};
|
||||
}
|
||||
|
||||
describe('server/regions (real geo)', () => {
|
||||
beforeAll(() => {
|
||||
_resetRegionsForTests();
|
||||
loadRegions(root);
|
||||
});
|
||||
|
||||
it('hasAdjacency() is true: the region-adjacency manifest loaded (v0.21 #16 P2)', () => {
|
||||
expect(hasAdjacency()).toBe(true);
|
||||
});
|
||||
|
||||
it('neighboursOf returns the union of bordering keys (deduped, sorted, queried excluded)', () => {
|
||||
// known mutual pairs from the manifest (verified in the Stage 1 spot checks)
|
||||
const moselle = neighboursOf(['moselle-rygy']);
|
||||
expect(moselle).toContain('baden-wurttemberg-oyje'); // FRA/DEU border
|
||||
expect(neighboursOf(['baden-wurttemberg-oyje'])).toContain('moselle-rygy'); // mutual
|
||||
expect(neighboursOf(['acre-ekzw'])).toContain('loreto-ipkx'); // BRA/PER border
|
||||
expect(neighboursOf(['loreto-ipkx'])).toContain('acre-ekzw'); // mutual
|
||||
|
||||
// union + dedupe + sorted + the queried keys themselves excluded
|
||||
const union = neighboursOf(['moselle-rygy', 'baden-wurttemberg-oyje']);
|
||||
expect(union).toEqual([...union].sort());
|
||||
expect(new Set(union).size).toBe(union.length); // no duplicates
|
||||
expect(union).not.toContain('moselle-rygy');
|
||||
expect(union).not.toContain('baden-wurttemberg-oyje');
|
||||
});
|
||||
|
||||
it('neighboursOf returns [] for unknown keys or an empty set', () => {
|
||||
expect(neighboursOf(['not-a-real-key-xyz'])).toEqual([]);
|
||||
expect(neighboursOf([])).toEqual([]);
|
||||
});
|
||||
|
||||
describe('graceful degradation with no region data', () => {
|
||||
beforeEach(() => resetRegions());
|
||||
|
||||
it('expands to the raw input, omits references, and reports no data', () => {
|
||||
expect(hasRegionData()).toBe(false);
|
||||
// no manifest -> the country list passes through unchanged (old model)
|
||||
expect(expandCountriesToKeys(['FRA', 'GBR'])).toEqual(['FRA', 'GBR']);
|
||||
expect(referenceForKeys(['FRA'])).toEqual({});
|
||||
expect(validKeys().size).toBe(0);
|
||||
expect(regionName('FRA')).toBeUndefined();
|
||||
// and no adjacency: the LLM tool / frontier field switch off
|
||||
expect(hasAdjacency()).toBe(false);
|
||||
expect(neighboursOf(['moselle-rygy'])).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
afterAll(() => resetRegions());
|
||||
});
|
||||
|
||||
describe('loadRegions resolves the manifest per environment (dev public/ vs prod dist/)', () => {
|
||||
const realRoot = root;
|
||||
// A root that mimics the prod Docker image: no public/, the region files live
|
||||
// in dist/ (where Vite copies public/* at build). This is the exact layout that
|
||||
// broke v0.19.0 in prod (the loader only looked in public/).
|
||||
const base = mkdtempSync(path.join(tmpdir(), 'history-regions-'));
|
||||
const prodRoot = path.join(base, 'prod');
|
||||
|
||||
beforeEach(() => {
|
||||
mkdirSync(path.join(prodRoot, 'dist'), { recursive: true });
|
||||
copyFileSync(
|
||||
path.join(realRoot, 'public', 'region-keys.json'),
|
||||
path.join(prodRoot, 'dist', 'region-keys.json'),
|
||||
);
|
||||
copyFileSync(
|
||||
path.join(realRoot, 'public', 'regions.geo.json'),
|
||||
path.join(prodRoot, 'dist', 'regions.geo.json'),
|
||||
);
|
||||
});
|
||||
|
||||
afterEach(() => resetRegions());
|
||||
|
||||
afterAll(() => {
|
||||
rmSync(base, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
it('loads from dist/ when public/ is absent (the prod container layout)', () => {
|
||||
expect(loadRegions(prodRoot)).toBe(true);
|
||||
it('loads public/regions.geo.json (hasRegionData becomes true)', () => {
|
||||
expect(hasRegionData()).toBe(true);
|
||||
expect(validKeys().size).toBe(1796);
|
||||
expect(expandCountriesToKeys(['FRA'])).toHaveLength(42);
|
||||
});
|
||||
|
||||
it('still loads from public/ (the dev layout, the first candidate)', () => {
|
||||
expect(loadRegions(realRoot)).toBe(true);
|
||||
expect(validKeys().size).toBe(1796);
|
||||
it('loadRegions is idempotent: a second call keeps the loaded data', () => {
|
||||
loadRegions(root);
|
||||
expect(hasRegionData()).toBe(true);
|
||||
});
|
||||
|
||||
it('a dist/ WITHOUT the adjacency manifest degrades: hasAdjacency() false, neighboursOf []', () => {
|
||||
// this fixture copies only region-keys.json + regions.geo.json (no
|
||||
// region-adjacency.json) — the server must boot and serve turns with the
|
||||
// tool/frontier simply switched off.
|
||||
expect(loadRegions(prodRoot)).toBe(true);
|
||||
expect(hasAdjacency()).toBe(false);
|
||||
expect(neighboursOf(['moselle-rygy'])).toEqual([]);
|
||||
it('expandTerritory expands an ISO_A3 into its sub-region ids (unique, all with that parent)', () => {
|
||||
const ids = expandTerritory(['FRA']);
|
||||
expect(ids.length).toBeGreaterThan(1); // France is subdivided, not one region
|
||||
expect(new Set(ids).size).toBe(ids.length); // deduped
|
||||
// every expanded id resolves back to the same parent country
|
||||
const names = regionNamesFor(ids);
|
||||
for (const id of ids) expect(names[id]).toMatch(/\(FRA\)$/);
|
||||
});
|
||||
|
||||
it('returns false and no data when neither public/ nor dist/ holds the files', () => {
|
||||
const emptyRoot = path.join(base, 'empty');
|
||||
mkdirSync(emptyRoot, { recursive: true });
|
||||
expect(loadRegions(emptyRoot)).toBe(false);
|
||||
it('expandTerritory is order-preserving and dedupes repeated country codes', () => {
|
||||
expect(expandTerritory(['FRA', 'FRA'])).toEqual(expandTerritory(['FRA']));
|
||||
// two countries: the union, in first-seen order (the ids are disjoint)
|
||||
expect(expandTerritory(['FRA', 'DEU'])).toEqual([
|
||||
...expandTerritory(['FRA']),
|
||||
...expandTerritory(['DEU']),
|
||||
]);
|
||||
});
|
||||
|
||||
it('expandTerritory of an empty or unknown list yields no regions', () => {
|
||||
expect(expandTerritory([])).toEqual([]);
|
||||
expect(expandTerritory(['XXX'])).toEqual([]); // no country with that code
|
||||
});
|
||||
|
||||
it('regionNamesFor maps every known id to "name (parent)"', () => {
|
||||
const ids = expandTerritory(['DEU']);
|
||||
const names = regionNamesFor(ids);
|
||||
expect(Object.keys(names).sort()).toEqual([...ids].sort());
|
||||
for (const id of ids) expect(names[id]).toMatch(/\(DEU\)$/);
|
||||
});
|
||||
|
||||
it('regionNamesFor skips ids that are not in the loaded index', () => {
|
||||
expect(regionNamesFor(['NO-SUCH-01'])).toEqual({});
|
||||
});
|
||||
|
||||
it('regionLabel is "id — name (parent)" for known ids and the bare id for unknown', () => {
|
||||
const [id] = expandTerritory(['FRA']);
|
||||
expect(regionLabel(id)).toMatch(new RegExp(`^${id} — .+ \\(FRA\\)$`));
|
||||
expect(regionLabel('NO-SUCH-01')).toBe('NO-SUCH-01');
|
||||
});
|
||||
|
||||
it('migrateTerritoryToRegions rewrites ISO_A3 entries to region ids, keeps existing region ids, and is idempotent', () => {
|
||||
const [deId] = expandTerritory(['DEU']); // a real region id of another country
|
||||
const state = makeState(['FRA', deId]); // mixed: legacy ISO_A3 + already migrated
|
||||
const originalArray = state.nations.uk.territory;
|
||||
// it mutates and returns the (fresh) state it is given — callers pass a
|
||||
// just-parsed object (db.load), so the in-place mutation is safe
|
||||
const out = migrateTerritoryToRegions(state);
|
||||
expect(out).toBe(state);
|
||||
// the original array object is never mutated in place — a new one is
|
||||
// installed on the nation, and the original stays as it was
|
||||
expect(out.nations.uk.territory).not.toBe(originalArray);
|
||||
expect(originalArray).toEqual(['FRA', deId]);
|
||||
// the ISO_A3 entry is gone, replaced by its sub-region ids…
|
||||
expect(out.nations.uk.territory).not.toContain('FRA');
|
||||
for (const id of expandTerritory(['FRA'])) expect(out.nations.uk.territory).toContain(id);
|
||||
// …and the existing region id survives, exactly once
|
||||
expect(out.nations.uk.territory.filter((t) => t === deId)).toEqual([deId]);
|
||||
// idempotent: a second migration changes nothing
|
||||
expect(migrateTerritoryToRegions(out).nations.uk.territory).toEqual(out.nations.uk.territory);
|
||||
});
|
||||
});
|
||||
|
||||
describe('server/regions (fallback: geo not loaded)', () => {
|
||||
beforeAll(() => {
|
||||
_resetRegionsForTests();
|
||||
});
|
||||
afterAll(() => {
|
||||
// restore the real geo for anything in this file that runs later
|
||||
_resetRegionsForTests();
|
||||
loadRegions(root);
|
||||
});
|
||||
|
||||
it('hasRegionData is false after a reset', () => {
|
||||
expect(hasRegionData()).toBe(false);
|
||||
expect(validKeys().size).toBe(0);
|
||||
});
|
||||
|
||||
it('expandTerritory returns its input unchanged (whole-country fallback)', () => {
|
||||
expect(expandTerritory(['FRA'])).toEqual(['FRA']);
|
||||
expect(expandTerritory([])).toEqual([]);
|
||||
});
|
||||
|
||||
it('regionNamesFor is empty and regionLabel falls back to the bare id', () => {
|
||||
expect(regionNamesFor(['FRA'])).toEqual({});
|
||||
expect(regionLabel('FRA')).toBe('FRA');
|
||||
});
|
||||
|
||||
it('migrateTerritoryToRegions is a no-op (returns the state untouched)', () => {
|
||||
const state = makeState(['FRA']);
|
||||
const out = migrateTerritoryToRegions(state);
|
||||
expect(out).toBe(state);
|
||||
expect(out.nations.uk.territory).toEqual(['FRA']);
|
||||
});
|
||||
|
||||
it('_setRegionsForTests loads a fixture and drives the pure helpers', () => {
|
||||
_setRegionsForTests(
|
||||
{
|
||||
'GB-01': { name: 'Greater London', parent: 'GBR' },
|
||||
'GB-02': { name: 'Scotland', parent: 'GBR' },
|
||||
},
|
||||
{ GBR: ['GB-01', 'GB-02'] },
|
||||
);
|
||||
expect(hasRegionData()).toBe(true);
|
||||
expect(expandTerritory(['GBR'])).toEqual(['GB-01', 'GB-02']);
|
||||
expect(regionNamesFor(['GB-01'])).toEqual({ 'GB-01': 'Greater London (GBR)' });
|
||||
const state = makeState(['GBR']);
|
||||
expect(migrateTerritoryToRegions(state).nations.uk.territory).toEqual(['GB-01', 'GB-02']);
|
||||
});
|
||||
});
|
||||
|
||||
+136
-156
@@ -1,144 +1,102 @@
|
||||
// Region-key data access (server). Loads the deterministic region-key manifest
|
||||
// (region-keys.json: stable feature id -> region key), the sub-national geo
|
||||
// (regions.geo.json: feature id -> { name, parent }), and — optionally — the
|
||||
// precomputed region-adjacency manifest (region-adjacency.json: region key ->
|
||||
// bordering region keys, built by scripts/build-region-adjacency.mjs) — all
|
||||
// from public/ in dev (Vite serves it) or dist/ in prod (Vite copies
|
||||
// public/* -> dist/ at build, and the Docker image keeps only dist/) — and
|
||||
// joins them into the lookups the region-level ownership model needs:
|
||||
// Sub-national region data: loaded ONCE at server boot from
|
||||
// `public/regions.geo.json` (dev) or `dist/regions.geo.json` (prod — Vite copies
|
||||
// `public/` → `dist/`). It builds two in-memory maps that power the
|
||||
// sub-region-level territory model (v0.19):
|
||||
//
|
||||
// - expand a nation's ISO_A3 country list -> the region keys of all its sub-regions (v0.19, #16 P1)
|
||||
// - build the LLM "regions" reference table (key -> "name (parent ISO_A3)")
|
||||
// - the set of all valid region keys (to ignore hallucinated keys in applyTurnResult)
|
||||
// - neighboursOf(): the union of the bordering keys for a set of keys — the
|
||||
// data behind the LLM's getNeighbours tool and the player-frontier prompt
|
||||
// field (v0.21, #16 P2)
|
||||
// - `regionIndex` : region id → { name, parent } (parent = ISO_A3 country)
|
||||
// - `regionsByCountry`: ISO_A3 country → array of its region ids
|
||||
//
|
||||
// Deliberately turf-free: it reads the JSON files with plain JSON.parse and
|
||||
// never imports @turf/@types/geojson (importing one pulls @types/geojson into
|
||||
// the tsc program and breaks WorldMap.tsx; see the v0.17 changelog note).
|
||||
// Loaded once at boot; the accessors below are pure data reads thereafter.
|
||||
// These are used to (a) expand a nation's ISO_A3 territory into its sub-region
|
||||
// ids at game creation / load-time migration, and (b) hand the LLM a human
|
||||
// name for each region id it may reference in a TurnResult.
|
||||
//
|
||||
// This is deliberately turf-free (plain `JSON.parse`): importing `@turf/*`
|
||||
// would pull `@types/geojson` into the tsc program and break `WorldMap.tsx`
|
||||
// (see AGENTS.md / the v0.17 changelog note on the geojson type gotcha).
|
||||
//
|
||||
// The server must still boot and the app still work when the geo file is
|
||||
// missing or unreadable: the maps stay empty, `hasRegionData()` stays false,
|
||||
// and the territory model gracefully degrades to whole-country ISO_A3 codes
|
||||
// (the pre-v0.19 behavior). Nothing here ever throws.
|
||||
import { existsSync, readFileSync } from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import type { GameState } from '../shared/types';
|
||||
|
||||
/** { name, parent } for one sub-region, where parent is the ISO_A3 country. */
|
||||
interface RegionInfo {
|
||||
/** A region's stable identity: display name + the parent country's ISO_A3. */
|
||||
export interface RegionInfo {
|
||||
name: string;
|
||||
parent: string;
|
||||
}
|
||||
|
||||
interface RegionData {
|
||||
/** stable feature id -> region key (from public/region-keys.json). */
|
||||
idToKey: Record<string, string>;
|
||||
/** region key -> { name, parent }. */
|
||||
keyToInfo: Record<string, RegionInfo>;
|
||||
/** ISO_A3 parent -> region keys of its sub-regions (file order, stable). */
|
||||
keysByCountry: Record<string, string[]>;
|
||||
/** the set of all region keys. */
|
||||
validKeys: Set<string>;
|
||||
/** region key -> bordering region keys (from public/region-adjacency.json). */
|
||||
adjacency: Record<string, string[]>;
|
||||
let regionIndex: Record<string, RegionInfo> = {};
|
||||
let regionsByCountry: Record<string, string[]> = {};
|
||||
let loaded = false;
|
||||
|
||||
/** True once the region geo has been loaded successfully. */
|
||||
export function hasRegionData(): boolean {
|
||||
return loaded;
|
||||
}
|
||||
|
||||
let data: RegionData | null = null;
|
||||
|
||||
/**
|
||||
* Load (or reload) the region-key manifest, geo, and adjacency. Idempotent.
|
||||
* The files are served to the client from `public/` in dev (Vite serves it
|
||||
* directly) and from `dist/` in prod (Vite copies `public/*` → `dist/` at build
|
||||
* and the Docker image keeps only `dist/`), so probe `public/` then `dist/`
|
||||
* (plus the root as a last resort) and use the first directory that holds the
|
||||
* key manifest + geo. The adjacency manifest is OPTIONAL: when it is missing
|
||||
* or broken, `adjacency` stays empty and `neighboursOf`/`hasAdjacency` simply
|
||||
* report "no adjacency" (the LLM tool and the frontier prompt field switch
|
||||
* off; everything else keeps working). Returns true when the core pair loaded
|
||||
* cleanly; a missing/broken pair clears the data and returns false so the
|
||||
* server still boots and degrades gracefully (expansion becomes a no-op,
|
||||
* ownership falls back to the raw input keys).
|
||||
* (Re)build the in-memory region maps from the region geo. Idempotent: a second
|
||||
* call is a no-op. Tries `<root>/public/regions.geo.json` first (dev), then
|
||||
* `<root>/dist/regions.geo.json` (prod, where Vite copies `public/` → `dist/`).
|
||||
* If no candidate file is found, or it fails to parse, the maps stay empty and
|
||||
* `hasRegionData()` stays false (graceful fallback to ISO_A3) — never throws.
|
||||
*/
|
||||
export function loadRegions(root: string): boolean {
|
||||
const keyFile = 'region-keys.json';
|
||||
const geoFile = 'regions.geo.json';
|
||||
const adjacencyFile = 'region-adjacency.json';
|
||||
const base = [
|
||||
path.join(root, 'public'), // dev: Vite serves public/ at /
|
||||
path.join(root, 'dist'), // prod: Vite copies public/* -> dist/ (== clientDir)
|
||||
root, // last resort
|
||||
].find((d) => existsSync(path.join(d, keyFile)) && existsSync(path.join(d, geoFile)));
|
||||
if (!base) {
|
||||
data = null;
|
||||
return false;
|
||||
export function loadRegions(root: string): void {
|
||||
if (loaded) return;
|
||||
const candidates = [
|
||||
path.join(root, 'public', 'regions.geo.json'),
|
||||
path.join(root, 'dist', 'regions.geo.json'),
|
||||
];
|
||||
const file = candidates.find((c) => existsSync(c));
|
||||
if (!file) {
|
||||
console.warn(
|
||||
'[history] regions.geo.json not found (tried: ' + candidates.join(', ') +
|
||||
') — falling back to whole-country (ISO_A3) territory',
|
||||
);
|
||||
return;
|
||||
}
|
||||
const keyPath = path.join(base, keyFile);
|
||||
const geoPath = path.join(base, geoFile);
|
||||
try {
|
||||
const idToKey = JSON.parse(readFileSync(keyPath, 'utf8')) as Record<string, string>;
|
||||
const geo = JSON.parse(readFileSync(geoPath, 'utf8')) as {
|
||||
features?: Array<{ id?: string | number; properties?: { name?: string; parent?: string } }>;
|
||||
const geo = JSON.parse(readFileSync(file, 'utf8')) as {
|
||||
features?: Array<{
|
||||
id?: string | number;
|
||||
properties?: { name?: string; parent?: string };
|
||||
}>;
|
||||
};
|
||||
const keyToInfo: Record<string, RegionInfo> = {};
|
||||
const keysByCountry: Record<string, string[]> = {};
|
||||
const validKeys = new Set<string>();
|
||||
const index: Record<string, RegionInfo> = {};
|
||||
const byCountry: Record<string, string[]> = {};
|
||||
for (const f of geo.features ?? []) {
|
||||
const id = f.id == null ? '' : String(f.id);
|
||||
const key = idToKey[id];
|
||||
if (!key) continue; // a geo feature with no manifest entry is skipped
|
||||
const name = typeof f.properties?.name === 'string' ? f.properties.name : '';
|
||||
const parent = typeof f.properties?.parent === 'string' ? f.properties.parent : '';
|
||||
keyToInfo[key] = { name, parent };
|
||||
validKeys.add(key);
|
||||
if (parent) (keysByCountry[parent] ??= []).push(key);
|
||||
const name = typeof f.properties?.name === 'string' ? f.properties.name : '';
|
||||
if (!id || !parent) continue;
|
||||
index[id] = { name, parent };
|
||||
(byCountry[parent] ??= []).push(id);
|
||||
}
|
||||
|
||||
// Adjacency is optional: a missing file means "no adjacency data".
|
||||
let adjacency: Record<string, string[]> = {};
|
||||
const adjacencyPath = path.join(base, adjacencyFile);
|
||||
if (existsSync(adjacencyPath)) {
|
||||
try {
|
||||
adjacency = JSON.parse(readFileSync(adjacencyPath, 'utf8')) as Record<string, string[]>;
|
||||
} catch (err) {
|
||||
// A corrupt manifest must not kill the core region data: degrade to
|
||||
// "no adjacency" (the LLM tool / frontier guidance simply switch off).
|
||||
console.error('[regions] failed to load region-adjacency.json, continuing without it', err);
|
||||
adjacency = {};
|
||||
}
|
||||
}
|
||||
|
||||
data = { idToKey, keyToInfo, keysByCountry, validKeys, adjacency };
|
||||
return validKeys.size > 0;
|
||||
} catch (err) {
|
||||
console.error('[regions] failed to load region data', err);
|
||||
data = null;
|
||||
return false;
|
||||
regionIndex = index;
|
||||
regionsByCountry = byCountry;
|
||||
loaded = Object.keys(index).length > 0;
|
||||
} catch (e) {
|
||||
console.warn('[history] failed to load regions.geo.json (' + file + '):', e);
|
||||
}
|
||||
}
|
||||
|
||||
/** Test/dev seam: drop the loaded data (the next accessors behave as "no data"). */
|
||||
export function resetRegions(): void {
|
||||
data = null;
|
||||
}
|
||||
|
||||
/** True when the manifest + geo loaded cleanly. */
|
||||
export function hasRegionData(): boolean {
|
||||
return data !== null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Expand a nation's ISO_A3 country list to the region keys of all its sub-regions
|
||||
* (file order, deduped). This is what turns a preset's country-level territory
|
||||
* into region-level ownership at game creation. Returns the input unchanged when
|
||||
* no region data is loaded (graceful degradation — behaves like the old model).
|
||||
* Expand a list of ISO_A3 country codes into the union of all their sub-region
|
||||
* ids (deduped, preserving first-seen order). When the region data is not
|
||||
* loaded, returns the input unchanged (graceful fallback to ISO_A3 territory).
|
||||
*/
|
||||
export function expandCountriesToKeys(countries: string[]): string[] {
|
||||
if (!data) return countries;
|
||||
const out: string[] = [];
|
||||
export function expandTerritory(countryCodes: string[]): string[] {
|
||||
if (!loaded) return countryCodes;
|
||||
const seen = new Set<string>();
|
||||
for (const c of countries) {
|
||||
for (const key of data.keysByCountry[c] ?? []) {
|
||||
if (!seen.has(key)) {
|
||||
seen.add(key);
|
||||
out.push(key);
|
||||
const out: string[] = [];
|
||||
for (const code of countryCodes) {
|
||||
for (const id of regionsByCountry[code] ?? []) {
|
||||
if (!seen.has(id)) {
|
||||
seen.add(id);
|
||||
out.push(id);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -146,62 +104,84 @@ export function expandCountriesToKeys(countries: string[]): string[] {
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the LLM reference table: region key -> "<name> (<parent ISO_A3>)", e.g.
|
||||
* `moselle-rygy -> "Moselle (FRA)"`. Only the given keys are included (the caller
|
||||
* passes the game's owned-region universe) so the prompt stays bounded.
|
||||
* A `{ [regionId]: "name (parent)" }` object for the given region ids, for the
|
||||
* LLM prompt. Unknown ids (not in the loaded index) are skipped. Empty when the
|
||||
* region data is not loaded.
|
||||
*/
|
||||
export function referenceForKeys(keys: Iterable<string>): Record<string, string> {
|
||||
export function regionNamesFor(ids: Iterable<string>): Record<string, string> {
|
||||
const out: Record<string, string> = {};
|
||||
if (!data) return out;
|
||||
for (const key of keys) {
|
||||
const info = data.keyToInfo[key];
|
||||
if (info) out[key] = info.parent ? `${info.name} (${info.parent})` : info.name;
|
||||
for (const id of ids) {
|
||||
const info = regionIndex[id];
|
||||
if (info) out[id] = `${info.name} (${info.parent})`;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/** The region key's human name (for the dossier), or undefined if unknown. */
|
||||
export function regionName(key: string): string | undefined {
|
||||
return data?.keyToInfo[key]?.name;
|
||||
/**
|
||||
* Human-readable label for a single region id: `id — name (parent)`, or just
|
||||
* the id when it is unknown (e.g. a region that predates the geo or a
|
||||
* synthetic id).
|
||||
*/
|
||||
export function regionLabel(id: string): string {
|
||||
const info = regionIndex[id];
|
||||
return info ? `${id} — ${info.name} (${info.parent})` : id;
|
||||
}
|
||||
|
||||
/** The union of every nation's territory region keys (the game's region universe). */
|
||||
export function allTerritoryKeys(state: GameState): Set<string> {
|
||||
const out = new Set<string>();
|
||||
/** A bare ISO_A3 country code: exactly three uppercase letters (no hyphen). */
|
||||
const ISO_A3_RE = /^[A-Z]{3}$/;
|
||||
|
||||
/**
|
||||
* Migrate a loaded game's territory from whole-country ISO_A3 codes to
|
||||
* sub-region ids, for nations that still carry ISO_A3 entries (i.e. games
|
||||
* saved before v0.19). Each such nation's ISO_A3 codes are expanded to all
|
||||
* their sub-region ids; any entries that are already region ids (they contain
|
||||
* a hyphen, so they never match `ISO_A3_RE`) are kept. Idempotent and
|
||||
* no-op when the region data is not loaded or a nation has no ISO_A3 codes.
|
||||
* Mutates and returns the (fresh) state it is given.
|
||||
*/
|
||||
export function migrateTerritoryToRegions(state: GameState): GameState {
|
||||
if (!loaded) return state;
|
||||
for (const n of Object.values(state.nations)) {
|
||||
for (const key of n.territory) out.add(key);
|
||||
if (!n.territory.some((t) => ISO_A3_RE.test(t))) continue;
|
||||
const isoCodes = n.territory.filter((t) => ISO_A3_RE.test(t));
|
||||
const existingRegions = n.territory.filter((t) => !ISO_A3_RE.test(t));
|
||||
const merged = expandTerritory(isoCodes).concat(existingRegions);
|
||||
const seen = new Set<string>();
|
||||
const out: string[] = [];
|
||||
for (const id of merged) {
|
||||
if (!seen.has(id)) {
|
||||
seen.add(id);
|
||||
out.push(id);
|
||||
}
|
||||
}
|
||||
n.territory = out;
|
||||
}
|
||||
return out;
|
||||
return state;
|
||||
}
|
||||
|
||||
/** The set of all valid region keys (to ignore hallucinated keys in applyTurnResult). */
|
||||
export function validKeys(): ReadonlySet<string> {
|
||||
return data ? data.validKeys : new Set<string>();
|
||||
// --- Test-only seams ---------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Test-only: reset the module state to "not loaded" (empty maps,
|
||||
* `hasRegionData()` false). Lets a test exercise the graceful-fallback path.
|
||||
*/
|
||||
export function _resetRegionsForTests(): void {
|
||||
regionIndex = {};
|
||||
regionsByCountry = {};
|
||||
loaded = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* True when the region-adjacency manifest loaded with at least one entry.
|
||||
* Callers (the server's jump route) use this to decide whether to hand the
|
||||
* engine an adjacency resolver (which turns on the LLM's getNeighbours tool
|
||||
* and the frontier prompt field) or fall back to the plain chat() path.
|
||||
* Test-only: inject region maps directly (bypassing the file load) so a unit
|
||||
* test can drive `expandTerritory` / `regionNamesFor` / `regionLabel` /
|
||||
* `migrateTerritoryToRegions` against a small, deterministic fixture without
|
||||
* reading the 3.4 MB geo file. `loaded` becomes true iff `index` is non-empty.
|
||||
*/
|
||||
export function hasAdjacency(): boolean {
|
||||
return data !== null && Object.keys(data.adjacency).length > 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* The union of the region keys that share a land border with any of the given
|
||||
* keys — deduplicated, the queried keys themselves excluded, and sorted for
|
||||
* determinism. This is the data behind the LLM's getNeighbours tool and the
|
||||
* player-frontier computation in the turn prompt (v0.21, #16 P2). Returns
|
||||
* `[]` when no region data (or no adjacency manifest) is loaded.
|
||||
*/
|
||||
export function neighboursOf(keys: Iterable<string>): string[] {
|
||||
if (!data) return [];
|
||||
const out = new Set<string>();
|
||||
for (const key of keys) {
|
||||
for (const n of data.adjacency[key] ?? []) out.add(n);
|
||||
}
|
||||
for (const key of keys) out.delete(key); // never report a key as its own neighbour
|
||||
return [...out].sort();
|
||||
export function _setRegionsForTests(
|
||||
index: Record<string, RegionInfo>,
|
||||
byCountry: Record<string, string[]>,
|
||||
): void {
|
||||
regionIndex = index;
|
||||
regionsByCountry = byCountry;
|
||||
loaded = Object.keys(index).length > 0;
|
||||
}
|
||||
|
||||
+12
-52
@@ -2,7 +2,7 @@
|
||||
// sets LLM_STUB=1) so the whole loop is reproducible with no live model. It
|
||||
// speaks the OpenAI chat-completions wire shape, so it plugs in as a Transport.
|
||||
import { createLlmClient, type ChatMessage, type Transport } from './llm';
|
||||
import { addDays, clampStat, type TerritoryChange, type TurnEventSpec, type TurnResult } from '../shared/protocol';
|
||||
import { addDays, clampStat, type TurnEventSpec, type TurnResult } from '../shared/protocol';
|
||||
import type { RoundItem } from '../shared/types';
|
||||
|
||||
export const ADVISOR_MARKER = '<<ADVISOR>>';
|
||||
@@ -13,24 +13,11 @@ export interface StubPayload {
|
||||
turn: number;
|
||||
date: string;
|
||||
playerNationId: string;
|
||||
/** As of v0.19 territory is a list of sub-region ids (not ISO_A3 codes). */
|
||||
nations: Record<string, { stats: Record<string, number>; territory?: string[] }>;
|
||||
};
|
||||
/** The raw pending round the engine emitted (one entry per queued item). */
|
||||
pending?: RoundItem[];
|
||||
/**
|
||||
* Region keys owned by other nations that share a land border with the
|
||||
* player's territory — the engine's `frontier` field, computed from the
|
||||
* adjacency manifest (v0.21, #16 P2). The stub cannot call tools, so it
|
||||
* reads the frontier from the prompt instead.
|
||||
*/
|
||||
frontier?: string[];
|
||||
/**
|
||||
* (v0.22, #16 P3) Region keys currently in no man's land (`state.unowned`),
|
||||
* emitted by the engine's user prompt. The stub ignores this field — it
|
||||
* never releases a region (see deterministicTurn), so no-man's-land behavior
|
||||
* is covered by unit tests against applyTurnResult, not by the stub.
|
||||
*/
|
||||
unowned?: string[];
|
||||
}
|
||||
|
||||
function truncate(s: string, n: number): string {
|
||||
@@ -44,23 +31,12 @@ function truncate(s: string, n: number): string {
|
||||
* single political "The world moves on" event when the round is empty — so a
|
||||
* caller can predict the exact next state for assertions. It always sets the
|
||||
* player's military to (current + 5) and allies the player with the first other
|
||||
* nation, advancing the date by 2 days.
|
||||
*
|
||||
* (v0.21, #16 P2) It also makes ONE contiguous conquest per turn: the player
|
||||
* gains the first frontier region (sorted order) from its current owner, and
|
||||
* that owner loses it. The stub bypasses the tool loop (it answers with plain
|
||||
* content in one round), so the frontier comes from the prompt payload, not
|
||||
* from a getNeighbours call. With an empty frontier (no controllable border)
|
||||
* no territory change is emitted, keeping every existing assertion stable.
|
||||
*
|
||||
* (v0.22, #16 P3) The stub NEVER releases a region to no man's land (it
|
||||
* always returns `unowned: []`) — e2e assertions rely on its fully-deterministic
|
||||
* one-conquest behavior, so the release/re-claim path is exercised by unit
|
||||
* tests only (see server/engine.test.ts).
|
||||
*
|
||||
* (v0.23, #16 P4a) The stub likewise NEVER proposes nation-management ops (it
|
||||
* always returns `nationOps: []`) — the propose→confirm/reject flow is
|
||||
* covered by unit tests only, keeping the e2e assertions untouched.
|
||||
* nation (by key order), advancing the date by 2 days. As of v0.19, when the
|
||||
* round is non-empty it also makes exactly **one** territory move: the player
|
||||
* annexes the lexicographically-first sub-region id of that first other
|
||||
* nation's territory (an empty round makes no move, and a player with nothing
|
||||
* to annex from that nation also makes no move) — so unit tests and e2e can
|
||||
* assert the exact region that changes hands.
|
||||
*/
|
||||
export function deterministicTurn(p: StubPayload): TurnResult {
|
||||
const state = p.state;
|
||||
@@ -71,23 +47,9 @@ export function deterministicTurn(p: StubPayload): TurnResult {
|
||||
? (Object.keys(state.nations).find((id) => id !== pid) ?? '')
|
||||
: 'us';
|
||||
const items = p.pending ?? [];
|
||||
|
||||
// The one deterministic region transfer: the player takes the first
|
||||
// frontier region (sorted → stable) from whichever other nation owns it.
|
||||
let territoryChanges: TerritoryChange[] = [];
|
||||
const frontier = p.frontier ?? [];
|
||||
if (state && frontier.length > 0) {
|
||||
const key = frontier[0];
|
||||
const loserId = Object.keys(state.nations).find(
|
||||
(id) => id !== pid && (state.nations[id].territory ?? []).includes(key),
|
||||
);
|
||||
if (loserId) {
|
||||
territoryChanges = [
|
||||
{ nation: pid, gain: [key], lose: [] },
|
||||
{ nation: loserId, gain: [], lose: [key] },
|
||||
];
|
||||
}
|
||||
}
|
||||
// The one deterministic per-turn territory move (see the doc above).
|
||||
const otherTerritory = [...(state?.nations?.[otherId]?.territory ?? [])].sort();
|
||||
const gain = items.length > 0 && otherTerritory.length > 0 ? [otherTerritory[0]] : [];
|
||||
|
||||
const events: TurnEventSpec[] =
|
||||
items.length === 0
|
||||
@@ -123,9 +85,7 @@ export function deterministicTurn(p: StubPayload): TurnResult {
|
||||
events,
|
||||
stateChanges: [{ nation: pid, stat: 'military', op: 'set', value: mil }],
|
||||
relations: otherId ? [{ a: pid, b: otherId, set: 'ally' }] : [],
|
||||
territoryChanges,
|
||||
unowned: [], // the stub never creates no man's land (see doc comment)
|
||||
nationOps: [], // the stub never proposes nation ops (see doc comment)
|
||||
territoryChanges: gain.length > 0 ? [{ nation: pid, gain, lose: [] }] : [],
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
+30
-195
@@ -23,88 +23,19 @@ export interface RelationChange {
|
||||
set: RelationStatus;
|
||||
}
|
||||
|
||||
/** A nation gains/loses region keys (see `public/region-keys.json`) this turn. */
|
||||
/**
|
||||
* A nation gains/loses **sub-region ids** this turn (e.g. `FR-57`), not
|
||||
* whole-country ISO_A3 codes. Each id identifies a single sub-region, so a
|
||||
* border can shift one region at a time; a gained region is moved out of
|
||||
* whichever nation currently owns it, and a lost region with no matching
|
||||
* gainer simply becomes unowned (no-man's-land).
|
||||
*/
|
||||
export interface TerritoryChange {
|
||||
nation: string;
|
||||
gain: string[];
|
||||
lose: string[];
|
||||
}
|
||||
|
||||
// --- Nation-management ops (v0.23 P4a / v0.24 P4b, #16: the hybrid "LLM
|
||||
// proposes, player confirms" model) ------------------------------------------
|
||||
//
|
||||
// Unlike stat / relation / territory deltas, a NationOp proposed in a turn is
|
||||
// NOT applied by that turn. It is stored as a *pending proposal* in
|
||||
// `GameState.pendingNationOps` and only takes effect when the player confirms
|
||||
// it (optionally editing it) or is dropped when the player rejects it. All
|
||||
// three kinds are implemented: rename (v0.23 P4a), split and merge (v0.24 P4b).
|
||||
|
||||
/**
|
||||
* The identity reference a nation is addressed by inside a {@link NationOp}.
|
||||
* The LLM may use either the nation's stable `id` (the `nations` record key,
|
||||
* e.g. `f`) or its human-readable `name` (e.g. `France`); the engine resolves
|
||||
* it to a concrete `nationId` (id first, then a unique name match — see the
|
||||
* engine's `resolveNationRef`).
|
||||
*/
|
||||
|
||||
/**
|
||||
* A **rename** proposal: change a nation's human-readable `name`. Only the
|
||||
* `name` changes — the stable `id`, its territory keys, its relations (keyed
|
||||
* by id), and the player pointer are all left untouched, so nothing downstream
|
||||
* breaks. `to` is the new display name.
|
||||
*/
|
||||
export interface RenameOp {
|
||||
kind: 'rename';
|
||||
/** The target nation's id or current name (see the note above). */
|
||||
nationRef: string;
|
||||
/** The new display name to apply when the player confirms. */
|
||||
to: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* A **split** proposal (v0.24, #16 P4b). Describes the new nations a source
|
||||
* nation is divided into. On confirm the source is dissolved: each part gets a
|
||||
* fresh id, the region keys it was given (restricted to keys the source
|
||||
* actually owns — first claim wins), fresh baseline stats, and a copy of the
|
||||
* source's relations; any of the source's unclaimed keys go to `parts[0]`.
|
||||
* When the source is the player's own nation the player chooses which part
|
||||
* they lead (the confirm request's `edits.playerPart`, default `parts[0]`).
|
||||
*/
|
||||
export interface SplitOp {
|
||||
kind: 'split';
|
||||
/** The id/name of the nation being split. */
|
||||
nationRef: string;
|
||||
/** The new nations created from the split. */
|
||||
parts: Array<{ name: string; territory?: string[] }>;
|
||||
}
|
||||
|
||||
/**
|
||||
* A **merge** proposal (v0.24, #16 P4b). Folds several nations into a single
|
||||
* surviving nation. On confirm the survivor keeps its id (renamed to `into`,
|
||||
* or to the confirm request's `edits.name`), its territory becomes the union
|
||||
* of all inputs' territories, it keeps its own stats, and it inherits the
|
||||
* union of all inputs' relations (its own winning per third party, else the
|
||||
* first input's); every non-survivor input is removed. If the player's nation
|
||||
* was a non-survivor input the player pointer is re-pointed to the survivor.
|
||||
*/
|
||||
export interface MergeOp {
|
||||
kind: 'merge';
|
||||
/** The id/name of every nation folded into the result. */
|
||||
nationRefs: string[];
|
||||
/** The id/name of the nation that survives and keeps its identity. */
|
||||
survivingRef: string;
|
||||
/** The name to give the merged nation. */
|
||||
into: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* A structural operation on the set of nations that the LLM may propose in a
|
||||
* turn (`TurnResult.nationOps`). See the section comment above for the hybrid
|
||||
* propose→confirm semantics. All three kinds are implemented: rename (P4a),
|
||||
* and split / merge (P4b, v0.24).
|
||||
*/
|
||||
export type NationOp = RenameOp | SplitOp | MergeOp;
|
||||
|
||||
/** One narrative event the LLM proposes for this turn. */
|
||||
export interface TurnEventSpec {
|
||||
nation: string;
|
||||
@@ -121,54 +52,33 @@ export interface TurnResult {
|
||||
stateChanges: StateChange[];
|
||||
relations: RelationChange[];
|
||||
territoryChanges: TerritoryChange[];
|
||||
/**
|
||||
* (v0.22, #16 P3) Region keys that become **unowned** — "no man's land" —
|
||||
* this turn. The engine removes each key from its current (sole) owner so it
|
||||
* ends the turn ownerless and marks it in `GameState.unowned`; the LLM
|
||||
* narrates the cause (war, cataclysm, collapse) in `events`. Re-claiming is
|
||||
* NOT expressed here: a nation re-claims an unowned region with an ordinary
|
||||
* `gain` on that key. Only keys a nation currently owns can be released;
|
||||
* empty on normal turns.
|
||||
*/
|
||||
unowned: string[];
|
||||
/**
|
||||
* (v0.23 P4a / v0.24 P4b, #16) Nation-management ops the LLM proposes this
|
||||
* turn. These are NOT applied by the turn: each is appended to
|
||||
* `GameState.pendingNationOps` as a proposal awaiting the player's
|
||||
* confirm/reject. All three kinds (rename, split, merge) are implemented —
|
||||
* a confirmed rename changes `Nation.name`; a confirmed split dissolves the
|
||||
* source into its parts; a confirmed merge folds its inputs into the
|
||||
* survivor. Empty on turns where the model proposes none.
|
||||
*/
|
||||
nationOps: NationOp[];
|
||||
}
|
||||
|
||||
/** Per-region map payload: region key -> owning nation + its stable color. */
|
||||
/** Per-region map payload: **sub-region id** -> owning nation + its stable color. */
|
||||
export interface RegionOwner {
|
||||
color: string;
|
||||
owner: string;
|
||||
ownerId: string;
|
||||
}
|
||||
/**
|
||||
* The authoritative ownership map: a **region key** (see `public/region-keys.json`)
|
||||
* -> the owning nation + its stable color. Owned at sub-region granularity (v0.19,
|
||||
* #16 P1); a key absent from this map is unowned (rendered grey).
|
||||
* The authoritative region→owner map, **keyed by sub-region id** (e.g. `FR-57`).
|
||||
* Every sub-region any nation owns appears here; a sub-region in no nation's
|
||||
* territory is absent (unowned / no-man's-land) and rendered grey by the map.
|
||||
*/
|
||||
export type RegionMap = Record<string, RegionOwner>;
|
||||
|
||||
/**
|
||||
* Look up the owner record from the authoritative RegionMap by a RegionMap key.
|
||||
* The RegionMap is keyed by **region key** (see `public/region-keys.json`) — one
|
||||
* per owned sub-region (v0.19, #16 P1) — so `key` is a region key such as
|
||||
* `moselle-rygy`, never a raw feature id such as `FR-57` and never a
|
||||
* parent-country ISO_A3. Returns `undefined` for an empty/missing key or an
|
||||
* unowned region.
|
||||
* The RegionMap is keyed by the **sub-region's own id** (e.g. `FR-57` — never a
|
||||
* bare ISO_A3 like `FRA`, and never the repacked numeric `feature.id`), so `key`
|
||||
* is a sub-region id such as `FR-57`. Returns `undefined` for an empty/missing
|
||||
* key or an unowned region (one in no nation's territory).
|
||||
*
|
||||
* Pure + shared: the primitive "key → owner" lookup. The *map feature → owner*
|
||||
* resolution (deciding which key to pass) lives in {@link mapFeatureOwner} below,
|
||||
* which reads the feature's stamped `properties.regionKey` — never the repacked
|
||||
* top-level `id` (MapLibre turns it into a numeric index, the "no owner" bug #6)
|
||||
* and never the sub-region id.
|
||||
* resolution (deciding which key to pass) lives in {@link mapFeatureOwner}
|
||||
* below, which reads the feature's `properties.regionId` — never the repacked
|
||||
* top-level `id` (MapLibre turns it into a numeric index, the "no owner" bug
|
||||
* #6).
|
||||
*/
|
||||
export function regionOwner(regions: RegionMap, key: string | null | undefined): RegionOwner | undefined {
|
||||
if (!key) return undefined;
|
||||
@@ -177,23 +87,22 @@ export function regionOwner(regions: RegionMap, key: string | null | undefined):
|
||||
|
||||
/**
|
||||
* Resolve the owning-nation record for a **rendered map feature** from the
|
||||
* authoritative RegionMap. The choropleth renders sub-national regions, and the
|
||||
* RegionMap is now keyed by **region key** (one per sub-region, v0.19 #16 P1),
|
||||
* so a feature's owner is found via its `properties.regionKey` — the region key
|
||||
* the client stamps from `public/region-keys.json` by the feature's stable id
|
||||
* (see WorldMap) — and then `regionOwner`. This is the single shared source of
|
||||
* truth for that resolution, so the "use `regionKey`, never the sub-region `id`
|
||||
* / repacked `feature.id`" rule lives in one tested place rather than in the
|
||||
* React component.
|
||||
* authoritative RegionMap. Ownership is now at **sub-region** granularity, so a
|
||||
* feature's owner is found via its **own sub-region id** — the client stamps
|
||||
* the feature's id into `properties.regionId` (see WorldMap `applyRegions`), and
|
||||
* we look that up with `regionOwner`. This is the single shared source of truth
|
||||
* for that resolution, so the "use `properties.regionId`, never the repacked
|
||||
* top-level `feature.id` (a MapLibre numeric index, the "no owner" bug #6)" rule
|
||||
* lives in one tested place rather than in the React component.
|
||||
*
|
||||
* Returns `undefined` for a missing feature/regionKey or an unowned region.
|
||||
* Returns `undefined` for a missing feature/regionId or an unowned region.
|
||||
*/
|
||||
export function mapFeatureOwner(
|
||||
regions: RegionMap,
|
||||
feature: { properties?: { regionKey?: unknown } } | null | undefined,
|
||||
feature: { properties?: { regionId?: unknown } } | null | undefined,
|
||||
): RegionOwner | undefined {
|
||||
const regionKey = feature?.properties?.regionKey;
|
||||
return regionOwner(regions, typeof regionKey === 'string' ? regionKey : '');
|
||||
const regionId = feature?.properties?.regionId;
|
||||
return regionOwner(regions, typeof regionId === 'string' ? regionId : '');
|
||||
}
|
||||
|
||||
/** Server -> client Server-Sent Events payload (see server/index.ts /sse). */
|
||||
@@ -247,39 +156,6 @@ export interface RemoveQueueItemResponse {
|
||||
game: GameState;
|
||||
}
|
||||
|
||||
/**
|
||||
* (v0.23 P4a / v0.24 P4b, #16) Confirm a pending nation-op proposal by its
|
||||
* index in `game.pendingNationOps`. A rename takes effect (the player may
|
||||
* override the proposed name via `edits.name`); a split and a merge are fully
|
||||
* applied (v0.24 P4b). No LLM call, no turn advance.
|
||||
*/
|
||||
export interface ConfirmNationOpRequest {
|
||||
index: number;
|
||||
/**
|
||||
* Optional player edits applied on confirm.
|
||||
* - `name`: the final display name — overrides a rename's `to`, a merge's
|
||||
* `into`, or (for a split) the name of the part the player leads.
|
||||
* - `playerPart`: for a split of the player's own nation, which part (index
|
||||
* into the op's `parts`) the player will lead (default `0` when missing or
|
||||
* out of range, so the player is never orphaned).
|
||||
*/
|
||||
edits?: { name?: string; playerPart?: number };
|
||||
}
|
||||
export interface ConfirmNationOpResponse {
|
||||
game: GameState;
|
||||
}
|
||||
|
||||
/**
|
||||
* (v0.23, #16 P4a) Reject (drop) a pending nation-op proposal by its index
|
||||
* in `game.pendingNationOps` without applying it. No LLM call, no turn advance.
|
||||
*/
|
||||
export interface RejectNationOpRequest {
|
||||
index: number;
|
||||
}
|
||||
export interface RejectNationOpResponse {
|
||||
game: GameState;
|
||||
}
|
||||
|
||||
export interface AdvisorRequest {
|
||||
/** Optional prompt to steer the brainstorm. */
|
||||
prompt?: string;
|
||||
@@ -316,47 +192,6 @@ export function nationColor(id: string): string {
|
||||
return `hsl(${hue} 58% 46%)`;
|
||||
}
|
||||
|
||||
// --- No man's land (v0.22, #16 P3) — the map presentation contract ---
|
||||
//
|
||||
// An unowned region has two distinct looks, and the difference is NOT in the
|
||||
// RegionMap (a key absent there is simply unowned): it is decided by the
|
||||
// client from `GameState.unowned` (the keys released mid-game). The constants
|
||||
// and the one decision function live here — shared and pure — so the
|
||||
// client's choropleth is the only consumer and the color contract is testable
|
||||
// from the server-side tests (shared/*.test.ts is not in the vitest glob).
|
||||
|
||||
/** The distinct, visible neutral grey for a **no man's land** region (released mid-game). Hue-less by construction, so it can never collide with a nation's `nationColor` (`hsl(h 58% 46%)`, always chromatic). */
|
||||
export const NO_MANS_LAND_FILL = '#3f3f46';
|
||||
/** The border of a no-man's-land region (brighter than a plain unowned one). */
|
||||
export const NO_MANS_LAND_STROKE = 'rgba(255,255,255,0.25)';
|
||||
/** The faint neutral fill for a region no nation owns that was never released mid-game (a preset never assigned it). */
|
||||
export const UNOWNED_FILL = 'rgba(148,163,184,0.05)';
|
||||
/** The border of a plain unowned region. */
|
||||
export const UNOWNED_STROKE = 'rgba(255,255,255,0.14)';
|
||||
/** The border of an owned region (brighter than unowned). */
|
||||
export const OWNED_STROKE = 'rgba(255,255,255,0.30)';
|
||||
|
||||
/** The hover-tooltip sub-line for a region with no owning nation. */
|
||||
export function unownedTooltipLabel(isNoMansLand: boolean): string {
|
||||
return isNoMansLand ? "No man's land" : 'No owner';
|
||||
}
|
||||
|
||||
/**
|
||||
* The fill + border for one sub-region, given its RegionMap entry
|
||||
* (`undefined` = unowned) and whether its key is no man's land (released
|
||||
* mid-game, i.e. in `GameState.unowned`). Pure + shared; see the section
|
||||
* comment above for why the distinction is not encoded in the RegionMap.
|
||||
*/
|
||||
export function regionFillStyle(
|
||||
owner: RegionOwner | undefined,
|
||||
isNoMansLand: boolean,
|
||||
): { fill: string; stroke: string } {
|
||||
if (owner) return { fill: owner.color, stroke: OWNED_STROKE };
|
||||
return isNoMansLand
|
||||
? { fill: NO_MANS_LAND_FILL, stroke: NO_MANS_LAND_STROKE }
|
||||
: { fill: UNOWNED_FILL, stroke: UNOWNED_STROKE };
|
||||
}
|
||||
|
||||
/** Rebuild the full event list entry shape from a TurnEventSpec + turn/date. */
|
||||
export function makeEvent(
|
||||
spec: TurnEventSpec,
|
||||
|
||||
+9
-37
@@ -1,9 +1,5 @@
|
||||
// Domain types — the single source of truth shared by the frontend (src/), the
|
||||
// backend (server/), and the LLM prompt contract. No runtime dependencies here.
|
||||
// (The single `import type` below erases at compile time, so no runtime
|
||||
// dependency on protocol.ts is introduced — see the GameState.pendingNationOps
|
||||
// doc comment.)
|
||||
import type { NationOp } from './protocol';
|
||||
|
||||
/** A nation's 0–100 status indices. Every value is clamped to 0–100 by the engine. */
|
||||
export interface NationStats {
|
||||
@@ -30,10 +26,15 @@ export const RELATION_STATUSES: RelationStatus[] = [
|
||||
];
|
||||
|
||||
/**
|
||||
* A single nation in the world. `territory` holds **region keys** (see
|
||||
* `public/region-keys.json`) — one per owned sub-region, so the choropleth can
|
||||
* color individual sub-regions, not whole countries (v0.19, #16 P1). The map
|
||||
* resolves each sub-region's owner by its region key (see protocol.mapFeatureOwner).
|
||||
* A single nation in the world. `territory` holds **sub-region ids** (e.g.
|
||||
* `FR-57`) — one entry per individually-ownable sub-region, at sub-region
|
||||
* granularity rather than whole-country ISO_A3. The map colors each sub-region
|
||||
* with this nation's stable color (see protocol.nationColor). At scenario start
|
||||
* a nation owns **all** sub-regions of the countries it holds (the server
|
||||
* expands each ISO_A3 to its sub-regions; see server/regions.expandTerritory),
|
||||
* so no region starts unowned. A sub-region that is in **no** nation's list is
|
||||
* unowned (no-man's-land) — the map renders it grey and it can be gained or
|
||||
* lost region-by-region by the LLM.
|
||||
*/
|
||||
export interface Nation {
|
||||
id: string;
|
||||
@@ -124,35 +125,6 @@ export interface GameState {
|
||||
* in src/App.tsx. Starts at 1 on game creation.
|
||||
*/
|
||||
version: GameVersion;
|
||||
/**
|
||||
* (v0.22, #16 P3) Region keys that became **unowned** — "no man's land" —
|
||||
* during play: a region that was owned and was released to no owner by a
|
||||
* committed turn (the LLM narrates the cause in that turn's events). This is
|
||||
* deliberately distinct from the many regions a preset never assigns, which
|
||||
* are also unowned but were never *released* mid-game; only the keys in this
|
||||
* list render as the distinct visible no-man's-land grey (see
|
||||
* protocol.regionFillStyle). A region leaves the list when any nation
|
||||
* re-claims it (an ordinary `gain`). Always `[]` on a fresh game — no
|
||||
* man's land can only arise mid-game. Rows saved before v0.22 load with
|
||||
* this defaulted to `[]` (see server/db.ts).
|
||||
*/
|
||||
unowned: string[];
|
||||
/**
|
||||
* (v0.23, #16 P4a; v0.24, #16 P4b) Nation-management ops the LLM has
|
||||
* proposed but the player has not yet resolved: a *pending proposal* list,
|
||||
* as opposed to `pending` (the current round's queued player actions). A
|
||||
* turn NEVER applies one — `applyTurnResult` appends the turn's
|
||||
* `nationOps` to this list, and each proposal survives across turns until
|
||||
* the player resolves it: confirming applies it (a rename changes
|
||||
* `Nation.name` only; a split partitions the nation's region-key territory
|
||||
* into the new nations' territories; a merge folds the inputs' territory
|
||||
* into the survivor) and removes it; rejecting removes it without
|
||||
* applying. Always `[]` on a fresh game; rows saved before v0.23 load with
|
||||
* this defaulted to `[]` (see server/db.ts). (The `NationOp` type lives in
|
||||
* protocol.ts; the import there is type-only, so this file still has no
|
||||
* runtime dependencies.)
|
||||
*/
|
||||
pendingNationOps: NationOp[];
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
+5
-60
@@ -177,10 +177,6 @@ export default function App() {
|
||||
// gate the turn flow ("Jump forward" stays enabled while the advisor thinks) —
|
||||
// it only gates the advisor UI (the "Ask advisor" button + its hint).
|
||||
const [advisorBusy, setAdvisorBusy] = useState(false);
|
||||
// Separate again: a pending nation-op confirm/reject is its own (fast,
|
||||
// non-LLM) request. It gates only the nation-op dialog controls, never the
|
||||
// turn flow — "Jump forward" stays usable while it is in flight.
|
||||
const [opBusy, setOpBusy] = useState(false);
|
||||
// The id of the game the user is/was last in (mirrors localStorage) and the
|
||||
// list of saved games (newest first) shown on the home screen.
|
||||
const [activeGameId, setActiveGameId] = useState<string | null>(() => readActiveGameId());
|
||||
@@ -405,44 +401,6 @@ export default function App() {
|
||||
[game, applyState],
|
||||
);
|
||||
|
||||
// Apply a pending nation op the model proposed (confirm; `edits.name`
|
||||
// overrides a rename/merge name, `edits.playerPart` picks the player's
|
||||
// successor part in a split). Fast, non-LLM — gated by `opBusy`, not `busy`.
|
||||
// The version-bumped state comes back in the response and the SSE `state` event.
|
||||
const runConfirmNationOp = useCallback(
|
||||
async (index: number, edits?: { name?: string; playerPart?: number }) => {
|
||||
if (!game) return;
|
||||
setOpBusy(true);
|
||||
try {
|
||||
const { game: g } = await api.confirmNationOp(game.id, index, edits);
|
||||
applyState(g);
|
||||
toast.success('Nation change applied');
|
||||
} catch (e) {
|
||||
toastError(e);
|
||||
} finally {
|
||||
setOpBusy(false);
|
||||
}
|
||||
},
|
||||
[game, applyState],
|
||||
);
|
||||
|
||||
// Drop a pending nation op (reject / dismiss). Fast, non-LLM — `opBusy`.
|
||||
const runRejectNationOp = useCallback(
|
||||
async (index: number) => {
|
||||
if (!game) return;
|
||||
setOpBusy(true);
|
||||
try {
|
||||
const { game: g } = await api.rejectNationOp(game.id, index);
|
||||
applyState(g);
|
||||
} catch (e) {
|
||||
toastError(e);
|
||||
} finally {
|
||||
setOpBusy(false);
|
||||
}
|
||||
},
|
||||
[game, applyState],
|
||||
);
|
||||
|
||||
// Jump forward: the single LLM call that commits the pending round. Only this
|
||||
// sets `busy` (the adds above are fast and non-LLM).
|
||||
const runJump = useCallback(async () => {
|
||||
@@ -549,15 +507,12 @@ export default function App() {
|
||||
regions={regions}
|
||||
busy={busy}
|
||||
advisorBusy={advisorBusy}
|
||||
opBusy={opBusy}
|
||||
advisors={advisors}
|
||||
onAddAction={runAddAction}
|
||||
onAddDiplomacy={runAddDiplomacy}
|
||||
onRemoveQueueItem={runRemoveQueueItem}
|
||||
onAdvisor={askAdvisor}
|
||||
onJump={runJump}
|
||||
onConfirmNationOp={runConfirmNationOp}
|
||||
onRejectNationOp={runRejectNationOp}
|
||||
onHome={goHome}
|
||||
/>
|
||||
</>
|
||||
@@ -596,16 +551,12 @@ interface GameScreenProps {
|
||||
busy: boolean;
|
||||
/** An advisor fetch is in flight — drives the advisor UI only (never the turn). */
|
||||
advisorBusy: boolean;
|
||||
/** A nation-op confirm/reject is in flight — drives the dialog controls only. */
|
||||
opBusy: boolean;
|
||||
advisors: string[];
|
||||
onAddAction: (a: string) => void;
|
||||
onAddDiplomacy: (to: string, m: string) => void;
|
||||
onRemoveQueueItem: (index: number) => void;
|
||||
onAdvisor: (p?: string) => void;
|
||||
onJump: () => void;
|
||||
onConfirmNationOp: (index: number, edits?: { name?: string; playerPart?: number }) => void;
|
||||
onRejectNationOp: (index: number) => void;
|
||||
onHome: () => void;
|
||||
}
|
||||
|
||||
@@ -628,26 +579,24 @@ function GameScreen({
|
||||
regions,
|
||||
busy,
|
||||
advisorBusy,
|
||||
opBusy,
|
||||
advisors,
|
||||
onAddAction,
|
||||
onAddDiplomacy,
|
||||
onRemoveQueueItem,
|
||||
onAdvisor,
|
||||
onJump,
|
||||
onConfirmNationOp,
|
||||
onRejectNationOp,
|
||||
onHome,
|
||||
}: GameScreenProps) {
|
||||
// Which nation's dossier to show. Defaults to the player; remounts per game.
|
||||
const [viewingId, setViewingId] = useState(game.playerNationId);
|
||||
// When the dossier target was set by a map click, remember which sub-region
|
||||
// was clicked, for a small label in the dossier. The label shows only the
|
||||
// region's name. Cleared when the user picks a nation via the manual Inspect
|
||||
// select.
|
||||
const [selectedRegion, setSelectedRegion] = useState<{ name?: string } | null>(null);
|
||||
// region's name — the static parent-country code (which never updates on a
|
||||
// transfer) is no longer displayed, though the info object still carries it.
|
||||
// Cleared when the user picks a nation via the manual Inspect select.
|
||||
const [selectedRegion, setSelectedRegion] = useState<{ parent?: string; name?: string } | null>(null);
|
||||
const focusNation = useCallback(
|
||||
(id: string, info?: { name?: string }) => {
|
||||
(id: string, info?: { parent?: string; name?: string }) => {
|
||||
setViewingId(id);
|
||||
setSelectedRegion(info ?? null);
|
||||
},
|
||||
@@ -705,7 +654,6 @@ function GameScreen({
|
||||
playerNationId={game.playerNationId}
|
||||
nations={game.nations}
|
||||
presetId={game.presetId}
|
||||
unowned={game.unowned ?? []}
|
||||
onFocusNation={focusNation}
|
||||
/>
|
||||
|
||||
@@ -887,15 +835,12 @@ function GameScreen({
|
||||
game={game}
|
||||
busy={busy}
|
||||
advisorBusy={advisorBusy}
|
||||
opBusy={opBusy}
|
||||
advisors={advisors}
|
||||
onAddAction={onAddAction}
|
||||
onAddDiplomacy={onAddDiplomacy}
|
||||
onRemoveQueueItem={onRemoveQueueItem}
|
||||
onAdvisor={onAdvisor}
|
||||
onJump={onJump}
|
||||
onConfirmNationOp={onConfirmNationOp}
|
||||
onRejectNationOp={onRejectNationOp}
|
||||
inWindow
|
||||
/>
|
||||
</FloatingWindow>
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import { useState } from 'react';
|
||||
import { Loader2, MessageSquare, PenLine, Radar, Trash2, Zap } from 'lucide-react';
|
||||
import { Loader2, MessageSquare, Radar, Trash2, Zap } from 'lucide-react';
|
||||
import { Badge } from './ui/badge';
|
||||
import { Button } from './ui/button';
|
||||
import { Card, CardContent, CardHeader, CardTitle } from './ui/card';
|
||||
@@ -15,7 +15,6 @@ import { Input } from './ui/input';
|
||||
import { Textarea } from './ui/textarea';
|
||||
import { Tabs, TabsContent, TabsList, TabsTrigger } from './ui/tabs';
|
||||
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from './ui/select';
|
||||
import NationOpDialog from './NationOpDialog';
|
||||
import type { GameState, RoundItem } from '@shared/types';
|
||||
|
||||
interface Props {
|
||||
@@ -28,11 +27,6 @@ interface Props {
|
||||
* never disable "Jump forward" or the rest of the turn flow.
|
||||
*/
|
||||
advisorBusy: boolean;
|
||||
/**
|
||||
* A pending nation-op confirm/reject request is in flight. Distinct from
|
||||
* `busy`: it gates only the nation-op dialog controls, never the turn flow.
|
||||
*/
|
||||
opBusy: boolean;
|
||||
/** Advisor brainstorm suggestions from the last request. */
|
||||
advisors: string[];
|
||||
/** Queue a free-text action onto the pending round (no turn advance). */
|
||||
@@ -44,14 +38,6 @@ interface Props {
|
||||
onAdvisor: (prompt?: string) => void;
|
||||
/** Commit the whole pending round in a single LLM turn. */
|
||||
onJump: () => void;
|
||||
/**
|
||||
* Apply a pending nation op: `edits.name` overrides a rename's target name
|
||||
* (or a merge's name); `edits.playerPart` picks the player's successor part
|
||||
* in a split (default 0).
|
||||
*/
|
||||
onConfirmNationOp: (index: number, edits?: { name?: string; playerPart?: number }) => void;
|
||||
/** Drop (reject) a pending nation op by its index. */
|
||||
onRejectNationOp: (index: number) => void;
|
||||
/**
|
||||
* Render without the outer card chrome (the surrounding floating window
|
||||
* provides the border and the "Your move" title). Same content, same testids.
|
||||
@@ -80,15 +66,12 @@ export default function ActionPanel({
|
||||
game,
|
||||
busy,
|
||||
advisorBusy,
|
||||
opBusy,
|
||||
advisors,
|
||||
onAddAction,
|
||||
onAddDiplomacy,
|
||||
onRemoveQueueItem,
|
||||
onAdvisor,
|
||||
onJump,
|
||||
onConfirmNationOp,
|
||||
onRejectNationOp,
|
||||
inWindow = false,
|
||||
}: Props) {
|
||||
const [tab, setTab] = useState('action');
|
||||
@@ -98,8 +81,6 @@ export default function ActionPanel({
|
||||
const [prompt, setPrompt] = useState('');
|
||||
// Index of the queued item the user is about to remove, or null (dialog closed).
|
||||
const [confirmRemoveIndex, setConfirmRemoveIndex] = useState<number | null>(null);
|
||||
// Whether the nation-op review dialog is open.
|
||||
const [opDialogOpen, setOpDialogOpen] = useState(false);
|
||||
|
||||
const others = Object.entries(game.nations)
|
||||
.filter(([id]) => id !== game.playerNationId)
|
||||
@@ -127,7 +108,6 @@ export default function ActionPanel({
|
||||
};
|
||||
|
||||
const pending = game.pending;
|
||||
const ops = game.pendingNationOps;
|
||||
// The item the confirmation dialog is about (re-derived from the live list,
|
||||
// so if the queue changes while the dialog is open it tracks the current
|
||||
// item at that index — or the dialog closes if the index went out of range).
|
||||
@@ -345,31 +325,6 @@ export default function ActionPanel({
|
||||
</DialogContent>
|
||||
</Dialog>
|
||||
|
||||
{/* Pending nation ops proposed by the model — open to confirm or reject. */}
|
||||
{ops.length > 0 && (
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => setOpDialogOpen(true)}
|
||||
disabled={busy}
|
||||
data-testid="nation-op-trigger"
|
||||
className="flex w-full items-center justify-between gap-2 rounded-lg border border-amber-500/30 bg-amber-500/10 p-2.5 text-sm hover:bg-amber-500/15"
|
||||
>
|
||||
<span className="flex items-center gap-2 font-medium text-amber-300">
|
||||
<PenLine className="size-4" />
|
||||
{ops.length} nation {ops.length === 1 ? 'proposal' : 'proposals'} — review
|
||||
</span>
|
||||
<span className="text-xs text-amber-300/70">confirm or reject</span>
|
||||
</button>
|
||||
)}
|
||||
<NationOpDialog
|
||||
game={game}
|
||||
open={opDialogOpen}
|
||||
onOpenChange={setOpDialogOpen}
|
||||
opBusy={opBusy}
|
||||
onConfirm={onConfirmNationOp}
|
||||
onReject={onRejectNationOp}
|
||||
/>
|
||||
|
||||
<Button className="h-11 w-full" onClick={onJump} disabled={busy} data-testid="jump-forward">
|
||||
{busy ? <Loader2 className="size-4 animate-spin" /> : <Radar className="size-4" />}
|
||||
{queuedLabel}
|
||||
|
||||
@@ -1,307 +0,0 @@
|
||||
import { useState } from 'react';
|
||||
import { Check, Loader2, PenLine, X } from 'lucide-react';
|
||||
import { Button } from './ui/button';
|
||||
import {
|
||||
Dialog,
|
||||
DialogContent,
|
||||
DialogDescription,
|
||||
DialogHeader,
|
||||
DialogTitle,
|
||||
} from './ui/dialog';
|
||||
import { Input } from './ui/input';
|
||||
import { Badge } from './ui/badge';
|
||||
import type { GameState } from '@shared/types';
|
||||
import type { NationOp, RenameOp } from '@shared/protocol';
|
||||
|
||||
interface Props {
|
||||
game: GameState;
|
||||
open: boolean;
|
||||
onOpenChange: (open: boolean) => void;
|
||||
/** A confirm/reject request is in flight — disable the per-op controls. */
|
||||
opBusy: boolean;
|
||||
/**
|
||||
* Apply a pending op: `edits.name` overrides a rename's target name (or the
|
||||
* merged name for a merge); `edits.playerPart` picks which new part the
|
||||
* player's nation becomes in a split (default 0).
|
||||
*/
|
||||
onConfirm: (index: number, edits?: { name?: string; playerPart?: number }) => void;
|
||||
/** Drop a pending op (reject / dismiss). */
|
||||
onReject: (index: number) => void;
|
||||
}
|
||||
|
||||
/** A short, display-safe description of a pending nation op. */
|
||||
function describeOp(op: NationOp, name: (ref: string) => string): string {
|
||||
if (op.kind === 'rename') return `Rename ${name(op.nationRef)} to “${op.to}”`;
|
||||
if (op.kind === 'split')
|
||||
return `Split ${name(op.nationRef)} into ${op.parts.length} nations (${op.parts
|
||||
.map((p) => p.name)
|
||||
.join(', ')})`;
|
||||
return `Merge ${op.nationRefs.map(name).join(' + ')} into “${op.into}”`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reviews the nation ops the LLM has proposed (stored in `pendingNationOps`)
|
||||
* and lets the player apply ("LLM proposes, player confirms") or drop each one:
|
||||
* a rename shows the proposed name in an editable field; a split lists the
|
||||
* proposed parts (with the number of regions each is assigned) and, when the
|
||||
* split parent is the player's own nation, radio buttons to pick which new
|
||||
* part the player leads; a merge shows the input nations (the survivor
|
||||
* highlighted) and an editable name for the merged state (default `into`).
|
||||
*/
|
||||
export default function NationOpDialog({
|
||||
game,
|
||||
open,
|
||||
onOpenChange,
|
||||
opBusy,
|
||||
onConfirm,
|
||||
onReject,
|
||||
}: Props) {
|
||||
const ops = game.pendingNationOps;
|
||||
const name = (ref: string) => game.nations[ref]?.name ?? ref;
|
||||
// Resolve a nation ref the way the server does (id first, then a unique
|
||||
// case-insensitive name; null when unknown/ambiguous) — UI hints only, the
|
||||
// server stays authoritative.
|
||||
const resolveRef = (ref: string): string | null => {
|
||||
const r = (ref ?? '').trim();
|
||||
if (!r) return null;
|
||||
if (game.nations[r]) return r;
|
||||
const matches = Object.values(game.nations).filter(
|
||||
(n) => n.name.trim().toLowerCase() === r.toLowerCase(),
|
||||
);
|
||||
return matches.length === 1 ? matches[0].id : null;
|
||||
};
|
||||
// The player's edits, keyed by pending-op index: the rename/merge target
|
||||
// name (an unset entry means "use the model's proposed name"), and which
|
||||
// split part the player succeeds to (preselected 0 — the radio is
|
||||
// "required" and always has a valid answer).
|
||||
const [edits, setEdits] = useState<Record<number, string>>({});
|
||||
const [playerParts, setPlayerParts] = useState<Record<number, number>>({});
|
||||
|
||||
return (
|
||||
<Dialog open={open} onOpenChange={onOpenChange}>
|
||||
<DialogContent className="max-w-lg" data-testid="nation-op-dialog">
|
||||
<DialogHeader>
|
||||
<DialogTitle>
|
||||
<span className="flex items-center gap-2">
|
||||
<PenLine className="size-4 text-primary" />
|
||||
Nation proposals
|
||||
</span>
|
||||
</DialogTitle>
|
||||
<DialogDescription>
|
||||
The model proposed changes to nations. Confirm to apply them (you can edit a
|
||||
name and choose your successor state in a split) or reject to leave the world
|
||||
as it is.
|
||||
</DialogDescription>
|
||||
</DialogHeader>
|
||||
|
||||
{ops.length === 0 ? (
|
||||
<p className="py-2 text-sm text-muted-foreground" data-testid="nation-op-empty">
|
||||
Nothing pending — the model hasn’t proposed any nation changes.
|
||||
</p>
|
||||
) : (
|
||||
<ul className="max-h-[50vh] space-y-2.5 overflow-y-auto pr-1" data-testid="nation-op-list">
|
||||
{ops.map((op, i) => {
|
||||
const isRename = op.kind === 'rename';
|
||||
const isSplit = op.kind === 'split';
|
||||
const isMerge = op.kind === 'merge';
|
||||
const finalName = isRename ? (edits[i] ?? (op as RenameOp).to).trim() : '';
|
||||
// Split: is the parent the player's own nation? (the successor radio
|
||||
// is offered only in that case — the engine ignores playerPart otherwise)
|
||||
const splitParentIsPlayer =
|
||||
isSplit && resolveRef((op as { nationRef: string }).nationRef) === game.playerNationId;
|
||||
const playerPart = playerParts[i] ?? 0;
|
||||
// Merge: the survivor (highlighted) and whether the proposal is
|
||||
// even valid (2+ distinct inputs; the survivor among them).
|
||||
const survivorId = isMerge ? resolveRef((op as { survivingRef: string }).survivingRef) : null;
|
||||
const inputIds = isMerge
|
||||
? new Set(
|
||||
(op as { nationRefs: string[] }).nationRefs
|
||||
.map(resolveRef)
|
||||
.filter((x): x is string => x !== null),
|
||||
)
|
||||
: new Set<string>();
|
||||
const mergeValid =
|
||||
!isMerge || (inputIds.size >= 2 && (survivorId !== null && inputIds.has(survivorId)));
|
||||
const mergeName = isMerge ? (edits[i] ?? (op as { into: string }).into).trim() : '';
|
||||
|
||||
const confirm = () => {
|
||||
if (isRename) onConfirm(i, finalName ? { name: finalName } : undefined);
|
||||
else if (isMerge) onConfirm(i, mergeName ? { name: mergeName } : undefined);
|
||||
else onConfirm(i, splitParentIsPlayer ? { playerPart } : undefined);
|
||||
};
|
||||
|
||||
return (
|
||||
<li
|
||||
key={`${i}-${op.kind}`}
|
||||
className="rounded-lg border border-border/70 bg-card/50 p-3"
|
||||
data-testid="nation-op-item"
|
||||
data-kind={op.kind}
|
||||
>
|
||||
<div className="mb-2 flex items-start gap-2">
|
||||
<Badge variant="secondary" className="shrink-0 text-[11px] capitalize">
|
||||
{op.kind}
|
||||
</Badge>
|
||||
<span className="min-w-0 flex-1 text-sm leading-snug">
|
||||
{describeOp(op, name)}
|
||||
</span>
|
||||
</div>
|
||||
|
||||
{isRename ? (
|
||||
<div className="space-y-2.5">
|
||||
<Input
|
||||
value={edits[i] ?? (op as RenameOp).to}
|
||||
onChange={(e) => setEdits((p) => ({ ...p, [i]: e.target.value }))}
|
||||
placeholder="New name…"
|
||||
data-testid="nation-op-name-input"
|
||||
/>
|
||||
<div className="flex justify-end gap-2">
|
||||
<Button
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
onClick={() => onReject(i)}
|
||||
disabled={opBusy}
|
||||
className="text-muted-foreground hover:text-destructive"
|
||||
data-testid="nation-op-reject"
|
||||
>
|
||||
<X className="size-3.5" />
|
||||
Reject
|
||||
</Button>
|
||||
<Button
|
||||
size="sm"
|
||||
onClick={confirm}
|
||||
disabled={opBusy}
|
||||
data-testid="nation-op-confirm"
|
||||
>
|
||||
{opBusy ? <Loader2 className="size-3.5 animate-spin" /> : <Check className="size-3.5" />}
|
||||
Confirm
|
||||
</Button>
|
||||
</div>
|
||||
</div>
|
||||
) : isSplit ? (
|
||||
<div className="space-y-2.5">
|
||||
<div className="space-y-1">
|
||||
{(op as { parts: { name: string; territory?: string[] }[] }).parts.map((p, pi) => (
|
||||
<div
|
||||
key={pi}
|
||||
className="flex items-center gap-2 text-sm"
|
||||
data-testid="nation-op-part"
|
||||
data-part={pi}
|
||||
>
|
||||
{splitParentIsPlayer ? (
|
||||
<input
|
||||
type="radio"
|
||||
name={`player-part-${i}`}
|
||||
checked={playerPart === pi}
|
||||
onChange={() => setPlayerParts((prev) => ({ ...prev, [i]: pi }))}
|
||||
disabled={opBusy}
|
||||
className="size-3.5 shrink-0 accent-amber-400"
|
||||
aria-label={`Make ${p.name} the player's successor state`}
|
||||
data-testid="nation-op-player-part"
|
||||
/>
|
||||
) : (
|
||||
<span className="size-3.5 shrink-0" aria-hidden />
|
||||
)}
|
||||
<span className="min-w-0 flex-1 truncate">{p.name}</span>
|
||||
<span className="shrink-0 text-[11px] tabular-nums text-muted-foreground">
|
||||
{p.territory?.length ?? 0} region{(p.territory?.length ?? 0) === 1 ? '' : 's'}
|
||||
</span>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
{splitParentIsPlayer && (
|
||||
<p className="text-[11px] text-muted-foreground" data-testid="nation-op-split-hint">
|
||||
Choose which new state you will lead after the split.
|
||||
</p>
|
||||
)}
|
||||
{(op as { parts: unknown[] }).parts.length < 2 && (
|
||||
<p className="text-[11px] text-muted-foreground">
|
||||
This split names fewer than two parts — confirming will dismiss it
|
||||
without changing the world.
|
||||
</p>
|
||||
)}
|
||||
<div className="flex justify-end gap-2">
|
||||
<Button
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
onClick={() => onReject(i)}
|
||||
disabled={opBusy}
|
||||
className="text-muted-foreground hover:text-destructive"
|
||||
data-testid="nation-op-reject"
|
||||
>
|
||||
<X className="size-3.5" />
|
||||
Reject
|
||||
</Button>
|
||||
<Button
|
||||
size="sm"
|
||||
onClick={confirm}
|
||||
disabled={opBusy}
|
||||
data-testid="nation-op-confirm"
|
||||
>
|
||||
{opBusy ? <Loader2 className="size-3.5 animate-spin" /> : <Check className="size-3.5" />}
|
||||
Confirm
|
||||
</Button>
|
||||
</div>
|
||||
</div>
|
||||
) : (
|
||||
<div className="space-y-2.5">
|
||||
<div className="flex flex-wrap gap-1.5">
|
||||
{(op as { nationRefs: string[] }).nationRefs.map((ref, ri) => {
|
||||
const isSurvivor = resolveRef(ref) === survivorId;
|
||||
return (
|
||||
<Badge
|
||||
key={ri}
|
||||
variant={isSurvivor ? 'default' : 'secondary'}
|
||||
className="text-[11px]"
|
||||
data-testid="nation-op-input"
|
||||
>
|
||||
{name(ref)}
|
||||
{isSurvivor ? ' (survivor)' : ''}
|
||||
</Badge>
|
||||
);
|
||||
})}
|
||||
</div>
|
||||
<Input
|
||||
value={edits[i] ?? (op as { into: string }).into}
|
||||
onChange={(e) => setEdits((p) => ({ ...p, [i]: e.target.value }))}
|
||||
placeholder="New name…"
|
||||
data-testid="nation-op-name-input"
|
||||
/>
|
||||
{!mergeValid && (
|
||||
<p className="text-[11px] text-muted-foreground">
|
||||
This merge is not valid as proposed — confirming will dismiss it
|
||||
without changing the world.
|
||||
</p>
|
||||
)}
|
||||
<div className="flex justify-end gap-2">
|
||||
<Button
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
onClick={() => onReject(i)}
|
||||
disabled={opBusy}
|
||||
className="text-muted-foreground hover:text-destructive"
|
||||
data-testid="nation-op-reject"
|
||||
>
|
||||
<X className="size-3.5" />
|
||||
Reject
|
||||
</Button>
|
||||
<Button
|
||||
size="sm"
|
||||
onClick={confirm}
|
||||
disabled={opBusy}
|
||||
data-testid="nation-op-confirm"
|
||||
>
|
||||
{opBusy ? <Loader2 className="size-3.5 animate-spin" /> : <Check className="size-3.5" />}
|
||||
Confirm
|
||||
</Button>
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
</li>
|
||||
);
|
||||
})}
|
||||
</ul>
|
||||
)}
|
||||
</DialogContent>
|
||||
</Dialog>
|
||||
);
|
||||
}
|
||||
@@ -1,10 +1,8 @@
|
||||
import { useEffect, useState } from 'react';
|
||||
import { Badge } from './ui/badge';
|
||||
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from './ui/card';
|
||||
import StatBar from './StatBar';
|
||||
import { nationColor } from '@shared/protocol';
|
||||
import { RELATION_COLORS } from '@/lib/colors';
|
||||
import { keyToName } from '@/lib/regions';
|
||||
import type { Nation, RelationStatus } from '@shared/types';
|
||||
|
||||
/** Human labels for a diplomatic status (the raw value is kept in data-attrs). */
|
||||
@@ -40,23 +38,6 @@ export default function NationPanel({ nation, nations, isPlayer, inWindow = fals
|
||||
const relations = Object.entries(nation.relations).sort(([a], [b]) => a.localeCompare(b));
|
||||
const regions = nation.territory;
|
||||
|
||||
// Human region names for the territory chips (region key -> name), loaded once
|
||||
// (cached in @/lib/regions). A key with no known name falls back to the raw key.
|
||||
const [keyNames, setKeyNames] = useState<Record<string, string>>({});
|
||||
useEffect(() => {
|
||||
let cancelled = false;
|
||||
keyToName()
|
||||
.then((m) => {
|
||||
if (!cancelled) setKeyNames(m);
|
||||
})
|
||||
.catch(() => {
|
||||
/* names are cosmetic — a failed fetch just leaves the raw keys */
|
||||
});
|
||||
return () => {
|
||||
cancelled = true;
|
||||
};
|
||||
}, []);
|
||||
|
||||
const identity = (
|
||||
<div className="flex items-center gap-3">
|
||||
<span
|
||||
@@ -114,20 +95,15 @@ export default function NationPanel({ nation, nations, isPlayer, inWindow = fals
|
||||
</h3>
|
||||
{regions.length > 0 ? (
|
||||
<div className="flex flex-wrap gap-1.5">
|
||||
{regions.map((key) => {
|
||||
const label = keyNames[key] ?? key;
|
||||
return (
|
||||
<span
|
||||
key={key}
|
||||
className="rounded border px-1.5 py-0.5 text-xs"
|
||||
style={{ borderColor: `${color}66`, color, background: `${color}12` }}
|
||||
title={key}
|
||||
data-region-key={key}
|
||||
>
|
||||
{label}
|
||||
</span>
|
||||
);
|
||||
})}
|
||||
{regions.map((code) => (
|
||||
<span
|
||||
key={code}
|
||||
className="rounded border px-1.5 py-0.5 text-xs tabular-nums"
|
||||
style={{ borderColor: `${color}66`, color, background: `${color}12` }}
|
||||
>
|
||||
{code}
|
||||
</span>
|
||||
))}
|
||||
</div>
|
||||
) : (
|
||||
<p className="text-sm text-muted-foreground">No territory.</p>
|
||||
|
||||
+112
-189
@@ -8,21 +8,16 @@ import 'maplibre-gl/dist/maplibre-gl.css';
|
||||
// Point it at a Vite-emitted copy of the worker module so it loads in prod.
|
||||
import workerUrl from 'maplibre-gl/dist/maplibre-gl-worker.mjs?url';
|
||||
maplibregl.setWorkerUrl(workerUrl);
|
||||
import {
|
||||
mapFeatureOwner,
|
||||
regionFillStyle,
|
||||
unownedTooltipLabel,
|
||||
type RegionMap,
|
||||
type RegionOwner,
|
||||
} from '@shared/protocol';
|
||||
import { mapFeatureOwner, type RegionMap, type RegionOwner } from '@shared/protocol';
|
||||
import type { Nation } from '@shared/types';
|
||||
import { cn } from '@/lib/utils';
|
||||
import { idToKey } from '@/lib/regions';
|
||||
|
||||
// Minimal GeoJSON types (avoids a hard @types/geojson dependency). The choropleth
|
||||
// source is the sub-national `regions.geo.json`: each feature is a sub-region with
|
||||
// a top-level `id` of the form `<ISO_A3>-<nn>` (e.g. `FRA-03`) and
|
||||
// a stable top-level `id` (ISO 3166-2 style, e.g. `FR-57`, `US-AK`) and
|
||||
// `properties = { name, parent }` where `parent` is the parent country's ISO_A3.
|
||||
// As of v0.19 the top-level `id` is also the RegionMap key: ownership (and the
|
||||
// LLM) live at sub-region granularity, so a nation owns individual sub-regions.
|
||||
interface GeoFeature {
|
||||
type: 'Feature';
|
||||
id?: string | number;
|
||||
@@ -108,65 +103,51 @@ function cameraForPreset(presetId: string): { center: [number, number]; zoom: nu
|
||||
|
||||
/**
|
||||
* Stamp the current ownership + colors onto a clone of the sub-national base geo.
|
||||
* Ownership is at **region-key** granularity (v0.19, #16 P1): each sub-region has
|
||||
* its own region key (from `public/region-keys.json`, looked up by the feature's
|
||||
* stable id) and the RegionMap is keyed by that region key, so a single
|
||||
* sub-region can change owner while its neighbours keep theirs. Each feature
|
||||
* therefore carries:
|
||||
* Since v0.19 ownership and the LLM live at **sub-region** granularity: a nation
|
||||
* owns individual sub-region ids, so each sub-region carries the color of the
|
||||
* nation that owns that exact sub-region (a country can now be split between
|
||||
* nations, and a sub-region in no nation's territory renders grey). Each
|
||||
* sub-region therefore carries:
|
||||
*
|
||||
* - `regionId` – its own sub-region id (e.g. `FRA-03`), kept in a property that
|
||||
* - `regionId` – its own sub-region id (e.g. `FR-57`), kept in a property that
|
||||
* survives into the features MapLibre hands back on click/hover
|
||||
* (the top-level `id` is repacked into a numeric index, #6);
|
||||
* - `regionKey` – the region key (e.g. `moselle-rygy`), the RegionMap key;
|
||||
* - `fill` – the owning nation's stable color (from `RegionMap[regionKey]`);
|
||||
* - `owner`/`ownerId` – that nation's name/id (empty for an unowned region);
|
||||
* - `stroke` – a per-border alpha (owned brightest, no man's land next,
|
||||
* plain-unowned faintest);
|
||||
* (the top-level `id` is repacked into a numeric index, #6) —
|
||||
* and the **RegionMap key** the owner is resolved through;
|
||||
* - `parent` – the parent country's ISO_A3 (e.g. `FRA`); a static geographic
|
||||
* fact shown in the dossier label, **not** used for ownership;
|
||||
* - `fill` – the owning nation's stable color (from `RegionMap[regionId]`);
|
||||
* - `owner`/`ownerId` – that nation's name/id (empty for an unowned sub-region);
|
||||
* - `stroke` – a per-border alpha (owned brighter than unowned);
|
||||
* - `isPlayer` – 1 when the owning nation is the player (drives the amber
|
||||
* player-highlight border).
|
||||
*
|
||||
* Crucially, the owner lookup keys the RegionMap by the stamped
|
||||
* `properties.regionKey`, **never** by the sub-region id or the repacked
|
||||
* top-level `id` — the RegionMap has no `FRA-03` entries, only region keys.
|
||||
*
|
||||
* (v0.22, #16 P3) Unowned regions have two looks, decided here (the
|
||||
* RegionMap simply has no entry for them): a key in `unownedSet` — released to
|
||||
* no man's land mid-game (`GameState.unowned`) — gets the distinct visible grey
|
||||
* (`NO_MANS_LAND_FILL`); every other ownerless region keeps the faint
|
||||
* preset-unassigned look. Both come from the shared `regionFillStyle` contract.
|
||||
* Crucially, the owner lookup keys the RegionMap by the feature's **own
|
||||
* sub-region id** (as `properties.regionId` at interaction time, via
|
||||
* `mapFeatureOwner` in @shared/protocol) — **never** by the repacked top-level
|
||||
* `id` (a MapLibre numeric index, #6) and **never** by the parent country code.
|
||||
*/
|
||||
function applyRegions(
|
||||
geo: FeatureCollection,
|
||||
regions: RegionMap,
|
||||
playerNationId: string,
|
||||
idKey: Record<string, string>,
|
||||
unownedSet: ReadonlySet<string>,
|
||||
): FeatureCollection {
|
||||
function applyRegions(geo: FeatureCollection, regions: RegionMap, playerNationId: string): FeatureCollection {
|
||||
const out: FeatureCollection = JSON.parse(JSON.stringify(geo));
|
||||
for (const f of out.features) {
|
||||
f.properties = f.properties ?? {};
|
||||
// The sub-region's own id (e.g. `FRA-03`) — stamped into a property that
|
||||
// The sub-region's own id (e.g. `FR-57`) — stamped into a property that
|
||||
// survives into the rendered features (the top-level `id` gets repacked).
|
||||
const subId = f.id == null ? '' : String(f.id);
|
||||
f.properties.regionId = subId;
|
||||
// Resolve this feature's **region key** from the manifest (id -> key) and
|
||||
// key the RegionMap by it — never the sub-region id or the repacked id.
|
||||
const key = idKey[subId] ?? '';
|
||||
f.properties.regionKey = key;
|
||||
const r = key ? regions[key] : undefined;
|
||||
const regionId = f.id == null ? '' : String(f.id);
|
||||
f.properties.regionId = regionId;
|
||||
// The parent country's ISO_A3 (e.g. `FRA`) — a static geographic fact used
|
||||
// for the dossier label only; ownership is resolved by `regionId`.
|
||||
const parent = typeof f.properties.parent === 'string' ? f.properties.parent : '';
|
||||
f.properties.parent = parent;
|
||||
const r = regionId ? regions[regionId] : undefined;
|
||||
if (r) {
|
||||
const style = regionFillStyle(r, false);
|
||||
f.properties.fill = style.fill;
|
||||
f.properties.stroke = style.stroke;
|
||||
f.properties.fill = r.color;
|
||||
f.properties.owner = r.owner;
|
||||
f.properties.ownerId = r.ownerId;
|
||||
f.properties.stroke = 'rgba(255,255,255,0.30)';
|
||||
f.properties.isPlayer = r.ownerId === playerNationId ? 1 : 0;
|
||||
} else {
|
||||
// Ownerless: visible grey only for keys released mid-game (no man's
|
||||
// land); a preset that never assigned this sub-region stays faint.
|
||||
const style = regionFillStyle(undefined, key !== '' && unownedSet.has(key));
|
||||
f.properties.fill = style.fill;
|
||||
f.properties.stroke = style.stroke;
|
||||
f.properties.fill = 'rgba(148,163,184,0.05)';
|
||||
f.properties.stroke = 'rgba(255,255,255,0.14)';
|
||||
f.properties.owner = '';
|
||||
f.properties.ownerId = '';
|
||||
f.properties.isPlayer = 0;
|
||||
@@ -176,22 +157,15 @@ function applyRegions(
|
||||
}
|
||||
|
||||
/**
|
||||
* Build a FeatureCollection of just the sub-regions whose **region key** is in
|
||||
* `keys` (cloned). Used by the territory-change flash: a turn can change
|
||||
* individual sub-regions (the RegionMap is region-keyed, v0.19 #16 P1), so each
|
||||
* changed region key lights up exactly the sub-region that owns it.
|
||||
* Build a FeatureCollection of just the sub-regions whose **own sub-region id**
|
||||
* is in `regionIds` (cloned). Used by the territory-change flash: since v0.19
|
||||
* a turn changes individual sub-regions (the RegionMap is keyed by sub-region
|
||||
* id), so each changed id lights up exactly its feature — no expansion to a
|
||||
* whole country needed.
|
||||
*/
|
||||
function featuresByRegionKeys(
|
||||
geo: FeatureCollection,
|
||||
keys: Iterable<string>,
|
||||
idKey: Record<string, string>,
|
||||
): FeatureCollection {
|
||||
const set = new Set(keys);
|
||||
const features = geo.features.filter((f) => {
|
||||
const id = f.id == null ? '' : String(f.id);
|
||||
const key = idKey[id] ?? '';
|
||||
return key !== '' && set.has(key);
|
||||
});
|
||||
function featuresByRegionIds(geo: FeatureCollection, regionIds: Iterable<string>): FeatureCollection {
|
||||
const set = new Set(regionIds);
|
||||
const features = geo.features.filter((f) => f.id != null && set.has(String(f.id)));
|
||||
return { type: 'FeatureCollection', features: JSON.parse(JSON.stringify(features)) };
|
||||
}
|
||||
|
||||
@@ -205,22 +179,15 @@ function statRow(label: string, value?: number): string {
|
||||
|
||||
/**
|
||||
* Compact hover tooltip: the sub-region's name, its **current owner**
|
||||
* (color-chipped), and 1–2 key stats. When the region's country has no owning
|
||||
* nation, a minimal card is shown instead; its sub-line says "No man's land"
|
||||
* for a region released mid-game (v0.22, #16 P3) and "No owner" for a region
|
||||
* no preset ever assigned. The static parent-country code
|
||||
* (`properties.parent`) is deliberately NOT printed here — it never updates
|
||||
* when ownership is transferred, so only the live owner chip (resolved from
|
||||
* the RegionMap) is shown.
|
||||
* (color-chipped), and 1–2 key stats. When the region has no owning nation, a
|
||||
* minimal "No owner" card is shown instead. The static parent-country code
|
||||
* (`properties.parent`) is deliberately NOT printed here — it is a geographic
|
||||
* fact that never updates when ownership is transferred, so only the live
|
||||
* owner chip (resolved from the RegionMap by sub-region id) is shown.
|
||||
*/
|
||||
function hoverHtml(
|
||||
subRegionName: string,
|
||||
region?: RegionOwner,
|
||||
nation?: Nation,
|
||||
noMansLand = false,
|
||||
): string {
|
||||
function hoverHtml(subRegionName: string, region?: RegionOwner, nation?: Nation): string {
|
||||
if (!region || !nation) {
|
||||
return `<div class="hm-popup"><div class="hm-popup-title">${esc(subRegionName || 'Unclaimed')}</div><div class="hm-popup-sub">${unownedTooltipLabel(noMansLand)}</div></div>`;
|
||||
return `<div class="hm-popup"><div class="hm-popup-title">${esc(subRegionName || 'Unclaimed')}</div><div class="hm-popup-sub">No owner</div></div>`;
|
||||
}
|
||||
const stats = [statRow('Mil', nation.stats.military), statRow('Eco', nation.stats.economy)].join('');
|
||||
return `<div class="hm-popup">
|
||||
@@ -238,53 +205,41 @@ interface Props {
|
||||
/** The active scenario id, for a sensible initial camera. */
|
||||
presetId: string;
|
||||
className?: string;
|
||||
/**
|
||||
* (v0.22, #16 P3) Region keys currently in no man's land (released
|
||||
* mid-game — `GameState.unowned`). Such regions render the distinct visible
|
||||
* grey (vs the faint preset-unassigned look of every other ownerless
|
||||
* region) and their hover tooltip says "No man's land" instead of "No
|
||||
* owner".
|
||||
*/
|
||||
unowned?: string[];
|
||||
/**
|
||||
* Called with a region's owning-nation id when a sub-region is clicked, so the
|
||||
* dossier switches to that nation. The optional `info` carries the clicked
|
||||
* sub-region's name, for a small "which region" label in the dossier. Not
|
||||
* dossier switches to that nation. Since v0.19 the owner is the nation that
|
||||
* owns that very sub-region (resolved from the RegionMap by sub-region id).
|
||||
* The optional `info` carries the clicked sub-region's own name and its parent
|
||||
* country's ISO_A3, for a small "which region" label in the dossier. Not
|
||||
* called for unowned regions (the dossier keeps its current target). See the
|
||||
* component doc for the full behavior.
|
||||
*/
|
||||
onFocusNation?: (id: string, info?: { name?: string }) => void;
|
||||
onFocusNation?: (id: string, info?: { parent?: string; name?: string }) => void;
|
||||
}
|
||||
|
||||
/**
|
||||
* World basemap (MapLibre GL) + a **sub-national** choropleth. The map renders
|
||||
* the finer `regions.geo.json` dataset: each country is subdivided into
|
||||
* ~100–200 km sub-regions, drawn as a finer choropleth with thin internal border
|
||||
* lines. Ownership is at **region-key** granularity (v0.19, #16 P1): each
|
||||
* sub-region has its own region key (from `public/region-keys.json`, looked up
|
||||
* by the feature's stable id) and the RegionMap is keyed by that key, so a
|
||||
* single sub-region can change owner independently of its neighbours. Rendered
|
||||
* as a fixed, full-viewport background layer (z-0) behind the floating HUD
|
||||
* windows: a dark-navy basemap with subtle terrain, per-nation stable fills,
|
||||
* thin sub-region borders, a brighter/thicker amber border for the player's
|
||||
* regions, a hover tooltip (sub-region name + current owner + key stats), a
|
||||
* **click that switches the dossier to the sub-region's owning nation** (no
|
||||
* popup — see #7), a transient flash when a sub-region's owner changes, and a
|
||||
* per-scenario initial camera.
|
||||
* lines. Since v0.19 ownership and the LLM live at **sub-region** granularity:
|
||||
* a nation owns individual sub-region ids, so each feature is filled with the
|
||||
* color of the nation owning that exact sub-region (a country can be split
|
||||
* between nations; unowned sub-regions render grey). Rendered as a fixed,
|
||||
* full-viewport background layer (z-0) behind the floating HUD windows: a
|
||||
* dark-navy basemap with subtle terrain, per-region stable fills (the
|
||||
* choropleth is the star), thin sub-region borders, a brighter/thicker amber
|
||||
* border for the player's regions, a hover tooltip (sub-region name + current
|
||||
* owner + key stats), a **click that switches the dossier to the sub-region's
|
||||
* owning nation** (no popup — see #7), a transient flash when a region's owner
|
||||
* changes (lighting up exactly the changed features), and a per-scenario
|
||||
* initial camera.
|
||||
*
|
||||
* Ownership for a hovered/clicked sub-region is resolved from the authoritative
|
||||
* RegionMap by its stamped **region key** (`properties.regionKey`, via
|
||||
* RegionMap by the feature's **own sub-region id** (`properties.regionId`, via
|
||||
* `mapFeatureOwner` in @shared/protocol) — never from the feature's top-level
|
||||
* `id` (MapLibre repacks it into a numeric index at interaction time, #6) and
|
||||
* never from the raw sub-region id (not a RegionMap key). Unowned sub-regions
|
||||
* (no RegionMap entry for their key) simply do not change the dossier.
|
||||
*
|
||||
* (v0.22, #16 P3) An unowned region renders two distinct ways: a key in the
|
||||
* `unowned` prop (released to no man's land mid-game — `GameState.unowned`)
|
||||
* gets the distinct visible grey with a "No man's land" tooltip sub-line; every
|
||||
* other ownerless region (a preset never assigned it) keeps the faint look and
|
||||
* a plain "No owner" sub-line. The colors/labels come from the shared
|
||||
* `regionFillStyle` / `unownedTooltipLabel` contract in @shared/protocol.
|
||||
* `id` (MapLibre repacks it into a numeric index at interaction time, #6).
|
||||
* Unowned sub-regions (no RegionMap entry for the id) simply do not change the
|
||||
* dossier.
|
||||
*
|
||||
* Zoom and pan are driven directly by the user (MapLibre wheel/trackpad + drag)
|
||||
* — no floating control and no external API.
|
||||
@@ -295,27 +250,21 @@ export default function WorldMap({
|
||||
nations,
|
||||
presetId,
|
||||
className,
|
||||
unowned,
|
||||
onFocusNation,
|
||||
}: Props) {
|
||||
const containerRef = useRef<HTMLDivElement>(null);
|
||||
const mapRef = useRef<maplibregl.Map | null>(null);
|
||||
const baseGeoRef = useRef<FeatureCollection | null>(null);
|
||||
// The region-key manifest (feature id -> region key), loaded once; used to
|
||||
// stamp each feature's region key and to expand the flash to its sub-region.
|
||||
const idKeyRef = useRef<Record<string, string> | null>(null);
|
||||
// Latest props, so the mount effect's (re)establish closure always sees them.
|
||||
const regionsRef = useRef(regions);
|
||||
const nationsRef = useRef(nations);
|
||||
const playerRef = useRef(playerNationId);
|
||||
const presetRef = useRef(presetId);
|
||||
const unownedRef = useRef<Set<string>>(new Set(unowned ?? []));
|
||||
const onFocusNationRef = useRef(onFocusNation);
|
||||
regionsRef.current = regions;
|
||||
nationsRef.current = nations;
|
||||
playerRef.current = playerNationId;
|
||||
presetRef.current = presetId;
|
||||
unownedRef.current = new Set(unowned ?? []);
|
||||
onFocusNationRef.current = onFocusNation;
|
||||
|
||||
// Diffing state for the transient territory-change flash (owned by this component
|
||||
@@ -361,28 +310,17 @@ export default function WorldMap({
|
||||
return g;
|
||||
});
|
||||
|
||||
// The region-key manifest (feature id -> region key), fetched once and
|
||||
// cached in a ref so both the paint path and the flash can resolve keys.
|
||||
const loadIdKey = (): Promise<Record<string, string>> =>
|
||||
idKeyRef.current
|
||||
? Promise.resolve(idKeyRef.current)
|
||||
: idToKey().then((k) => {
|
||||
idKeyRef.current = k;
|
||||
return k;
|
||||
});
|
||||
|
||||
const emptyFC = (): FeatureCollection => ({ type: 'FeatureCollection', features: [] });
|
||||
|
||||
// Transient flash: pulse a bright outline over the changed regions, then fade
|
||||
// to zero over a few seconds and self-clean. Idempotent per call. `codes` are
|
||||
// region keys (a turn can change individual sub-regions, v0.19 #16 P1); each
|
||||
// lights up exactly the sub-region that owns that key.
|
||||
// to zero over a few seconds and self-clean. Idempotent per call. `codes`
|
||||
// are sub-region ids (the RegionMap keys that changed owner since the last
|
||||
// update); each lights up exactly its feature.
|
||||
function animateFlash(codes: string[]) {
|
||||
const geo = baseGeoRef.current;
|
||||
const idKey = idKeyRef.current;
|
||||
const src = map.getSource(FLASH_SOURCE) as GeoSource | undefined;
|
||||
if (!geo || !idKey || !src || cancelled) return;
|
||||
src.setData(featuresByRegionKeys(geo, codes, idKey));
|
||||
if (!geo || !src || cancelled) return;
|
||||
src.setData(featuresByRegionIds(geo, codes));
|
||||
if (!map.getLayer(FLASH_LINE)) {
|
||||
// Defensive re-add (normally created by ensureLayers). Keep it beneath the
|
||||
// hover highlight when that layer exists; otherwise just append.
|
||||
@@ -417,10 +355,10 @@ export default function WorldMap({
|
||||
|
||||
// The sub-region a hovered/clicked feature belongs to is identified by its
|
||||
// stable sub-region id in `properties.regionId` (stamped by `applyRegions`),
|
||||
// and its **owner** is resolved from the authoritative RegionMap via the
|
||||
// feature's stamped `properties.regionKey` through
|
||||
// `mapFeatureOwner` — never from the repacked top-level `id` (a numeric
|
||||
// index, #6) and never from the raw sub-region id (not a RegionMap key).
|
||||
// and its **owner** is resolved from the authoritative RegionMap via that
|
||||
// same `properties.regionId` through `mapFeatureOwner` — since v0.19 the
|
||||
// RegionMap is keyed by the sub-region's own id. Never the repacked
|
||||
// top-level `id` (a numeric index, #6).
|
||||
const onHover = (e: maplibregl.MapLayerMouseEvent) => {
|
||||
const f = e.features?.[0];
|
||||
if (!f) return;
|
||||
@@ -439,14 +377,9 @@ export default function WorldMap({
|
||||
}
|
||||
const region = mapFeatureOwner(regionsRef.current, f);
|
||||
const nation = region ? nationsRef.current[region.ownerId] : undefined;
|
||||
// (v0.22, #16 P3) whether this region is no man's land (released
|
||||
// mid-game), so the ownerless tooltip can say so.
|
||||
const pKey = f.properties?.regionKey;
|
||||
const noMansLand =
|
||||
!region && typeof pKey === 'string' && pKey !== '' && unownedRef.current.has(pKey);
|
||||
hoverPopup
|
||||
.setLngLat(e.lngLat)
|
||||
.setHTML(hoverHtml(p?.name ?? subId, region, nation, noMansLand))
|
||||
.setHTML(hoverHtml(p?.name ?? subId, region, nation))
|
||||
.addTo(map);
|
||||
map.getCanvas().style.cursor = 'pointer';
|
||||
};
|
||||
@@ -459,19 +392,22 @@ export default function WorldMap({
|
||||
};
|
||||
|
||||
// #7: a click does NOT open a popup — it switches the dossier to the region's
|
||||
// owning nation, resolved from the feature's stamped `properties.regionKey`
|
||||
// via the RegionMap (never the repacked top-level `f.id`, #6, and never the
|
||||
// raw sub-region id). A sub-region whose key has no owner leaves the current
|
||||
// dossier target unchanged — never a broken dossier.
|
||||
// owning nation. Since v0.19 the owner is the nation that owns **this**
|
||||
// sub-region, resolved from `properties.regionId` via the RegionMap (never
|
||||
// the repacked top-level `f.id`, #6). A sub-region with no owner leaves the
|
||||
// current dossier target unchanged — never a broken dossier.
|
||||
const onClick = (e: maplibregl.MapLayerMouseEvent) => {
|
||||
const f = e.features?.[0];
|
||||
if (!f) return;
|
||||
const region = mapFeatureOwner(regionsRef.current, f);
|
||||
if (!region?.ownerId) return;
|
||||
// Carry the clicked sub-region's name so the dossier can show which region
|
||||
// was selected.
|
||||
const p = f.properties as { name?: string };
|
||||
const info = { name: typeof p?.name === 'string' ? p.name : undefined };
|
||||
// Carry the clicked sub-region's identity (own id/name + parent ISO_A3) so
|
||||
// the dossier can show which region was selected.
|
||||
const p = f.properties as { regionId?: string; parent?: string; name?: string };
|
||||
const info = {
|
||||
parent: typeof p?.parent === 'string' ? p.parent : undefined,
|
||||
name: typeof p?.name === 'string' ? p.name : undefined,
|
||||
};
|
||||
onFocusNationRef.current?.(region.ownerId, info);
|
||||
};
|
||||
|
||||
@@ -499,40 +435,34 @@ export default function WorldMap({
|
||||
}
|
||||
};
|
||||
|
||||
// Stamp ownership + colors onto the regions source (no-op until both the
|
||||
// base geo and the region-key manifest are loaded).
|
||||
// Stamp ownership + colors onto the regions source (no-op until geo loads).
|
||||
const paintRegions = () => {
|
||||
const geo = baseGeoRef.current;
|
||||
const idKey = idKeyRef.current;
|
||||
const src = map.getSource(REGIONS_SOURCE) as GeoSource | undefined;
|
||||
if (!geo || !idKey || !src) return;
|
||||
src.setData(applyRegions(geo, regionsRef.current, playerRef.current, idKey, unownedRef.current));
|
||||
if (!geo || !src) return;
|
||||
src.setData(applyRegions(geo, regionsRef.current, playerRef.current));
|
||||
};
|
||||
|
||||
const ensureLayers = async () => {
|
||||
if (cancelled) return;
|
||||
ensureSources();
|
||||
if (!baseGeoRef.current) {
|
||||
if (baseGeoRef.current) {
|
||||
paintRegions();
|
||||
} else {
|
||||
try {
|
||||
await loadGeo();
|
||||
} catch (err) {
|
||||
console.error('failed to load regions geojson', err);
|
||||
}
|
||||
if (cancelled) return;
|
||||
paintRegions();
|
||||
}
|
||||
if (!idKeyRef.current) {
|
||||
try {
|
||||
await loadIdKey();
|
||||
} catch (err) {
|
||||
console.error('failed to load region keys', err);
|
||||
}
|
||||
}
|
||||
if (cancelled) return;
|
||||
paintRegions();
|
||||
if (!map.getLayer(FILL_LAYER)) {
|
||||
// The choropleth is the star: a high opacity so the vivid per-nation
|
||||
// colors read clearly even on the dark background / over the terrain.
|
||||
// Each sub-region carries its own owning nation's color (v0.19 #16 P1),
|
||||
// so the fill traces region-key ownership, not country borders.
|
||||
// Since v0.19 each sub-region carries the color of the nation owning
|
||||
// that exact sub-region, so a country taken at region level shows the
|
||||
// split directly in the fill.
|
||||
map.addLayer({
|
||||
id: FILL_LAYER,
|
||||
type: 'fill',
|
||||
@@ -612,39 +542,32 @@ export default function WorldMap({
|
||||
};
|
||||
}, []);
|
||||
|
||||
// Re-color the choropleth whenever ownership changes, and flash each
|
||||
// sub-region whose owner changed since the last update (a transient,
|
||||
// self-cleaning pulse). The diff is over the region-keyed RegionMap (v0.19
|
||||
// #16 P1); `animateFlash` lights up exactly the sub-region for each changed
|
||||
// key. Re-runs when the no-man's-land set changes too (v0.22 #16 P3) so a
|
||||
// release/re-claim repaints the grey even if the RegionMap diff alone
|
||||
// wouldn't catch it.
|
||||
// Re-color the choropleth whenever ownership changes, and flash any sub-region
|
||||
// whose owner changed since the last update (a transient, self-cleaning pulse).
|
||||
// The diff is over the sub-region-id-keyed RegionMap; `animateFlash` lights up
|
||||
// exactly the features whose own id changed owner.
|
||||
useEffect(() => {
|
||||
const map = mapRef.current;
|
||||
const geo = baseGeoRef.current;
|
||||
const idKey = idKeyRef.current;
|
||||
const cur = regions;
|
||||
const prev = prevRegionsRef.current;
|
||||
prevRegionsRef.current = cur;
|
||||
const wasPrimed = primedRef.current;
|
||||
if (Object.keys(cur).length > 0) primedRef.current = true;
|
||||
const unownedSet = new Set(unowned ?? []);
|
||||
|
||||
if (map && geo && idKey) {
|
||||
if (map && geo) {
|
||||
const src = map.getSource(REGIONS_SOURCE) as GeoSource | undefined;
|
||||
if (src) void src.setData(applyRegions(geo, cur, playerNationId, idKey, unownedSet));
|
||||
if (src) void src.setData(applyRegions(geo, cur, playerNationId));
|
||||
}
|
||||
|
||||
if (wasPrimed && prev && idKey) {
|
||||
if (wasPrimed && prev) {
|
||||
const changed = new Set<string>();
|
||||
for (const key of new Set([...Object.keys(prev), ...Object.keys(cur)])) {
|
||||
if ((prev[key]?.ownerId ?? '') !== (cur[key]?.ownerId ?? '')) changed.add(key);
|
||||
for (const regionId of new Set([...Object.keys(prev), ...Object.keys(cur)])) {
|
||||
if ((prev[regionId]?.ownerId ?? '') !== (cur[regionId]?.ownerId ?? '')) changed.add(regionId);
|
||||
}
|
||||
// A release (owned → unowned) and a re-claim (unowned → owned) both show
|
||||
// up as ownerId changes above, so they flash like any other transfer.
|
||||
if (changed.size > 0) flashApiRef.current?.([...changed]);
|
||||
}
|
||||
}, [regions, playerNationId, unowned]);
|
||||
}, [regions, playerNationId]);
|
||||
|
||||
// Full-viewport, edge-to-edge background layer. `position: fixed` is set
|
||||
// inline because MapLibre's own stylesheet sets `.maplibregl-map` to
|
||||
|
||||
@@ -6,11 +6,9 @@ import type {
|
||||
AddActionResponse,
|
||||
AddDiplomacyResponse,
|
||||
AdvisorResponse,
|
||||
ConfirmNationOpResponse,
|
||||
CreateGameResponse,
|
||||
DeleteGameResponse,
|
||||
GameSummary,
|
||||
RejectNationOpResponse,
|
||||
RemoveQueueItemResponse,
|
||||
TurnResponse,
|
||||
} from '@shared/protocol';
|
||||
@@ -62,24 +60,6 @@ export const api = {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ index }),
|
||||
}),
|
||||
// (v0.23, #16 P4a; v0.24, #16 P4b) Confirm a pending nation-op proposal by
|
||||
// its index in `game.pendingNationOps`: a rename takes effect (`edits.name`
|
||||
// overrides the proposed name), a split partitions the nation's territory
|
||||
// (`edits.playerPart` picks which part the player leads, default 0), and a
|
||||
// merge folds its inputs into the survivor (`edits.name` overrides the
|
||||
// merged name). Fast, non-LLM — no turn advance. Returns the updated game.
|
||||
confirmNationOp: (id: string, index: number, edits?: { name?: string; playerPart?: number }) =>
|
||||
req<ConfirmNationOpResponse>(`/api/games/${id}/nation-op/confirm`, {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ index, ...(edits ? { edits } : {}) }),
|
||||
}),
|
||||
// (v0.23, #16 P4a) Reject (drop) a pending nation-op proposal by index,
|
||||
// without applying it. Fast, non-LLM — no turn advance. Returns the updated game.
|
||||
rejectNationOp: (id: string, index: number) =>
|
||||
req<RejectNationOpResponse>(`/api/games/${id}/nation-op/reject`, {
|
||||
method: 'POST',
|
||||
body: JSON.stringify({ index }),
|
||||
}),
|
||||
// Commit the whole pending round (or an empty one) in a single LLM turn.
|
||||
jump: (id: string) =>
|
||||
req<TurnResponse>(`/api/games/${id}/jump`, {
|
||||
|
||||
@@ -1,46 +0,0 @@
|
||||
// Client-side region-key data access. Fetches the two static JSON files served
|
||||
// from public/ and builds the lookups the region-level UI needs:
|
||||
// - idToKey(): feature id -> region key (to stamp each map feature + resolve owner)
|
||||
// - keyToName(): region key -> human name (to show region names in the dossier)
|
||||
// Each is fetched once and cached (Promise singleton) so WorldMap and NationPanel
|
||||
// share a single fetch. Same-origin relative URLs (proxy/Traefik safe) — never a
|
||||
// hardcoded origin.
|
||||
type GeoLike = {
|
||||
features?: Array<{ id?: string | number; properties?: { name?: string } }>;
|
||||
};
|
||||
|
||||
let idKeyPromise: Promise<Record<string, string>> | null = null;
|
||||
let keyNamePromise: Promise<Record<string, string>> | null = null;
|
||||
|
||||
async function fetchJson<T>(url: string): Promise<T> {
|
||||
const r = await fetch(url);
|
||||
if (!r.ok) throw new Error(`${url} → HTTP ${r.status}`);
|
||||
return (await r.json()) as T;
|
||||
}
|
||||
|
||||
/** feature id (from regions.geo.json) -> region key (from region-keys.json). */
|
||||
export function idToKey(): Promise<Record<string, string>> {
|
||||
idKeyPromise ??= fetchJson<Record<string, string>>('/region-keys.json');
|
||||
return idKeyPromise;
|
||||
}
|
||||
|
||||
/**
|
||||
* region key -> human region name. Built by joining region-keys.json (id -> key)
|
||||
* with regions.geo.json (id -> properties.name). A key with no known name is
|
||||
* simply absent (callers fall back to the raw key).
|
||||
*/
|
||||
export function keyToName(): Promise<Record<string, string>> {
|
||||
keyNamePromise ??= Promise.all([idToKey(), fetchJson<GeoLike>('/regions.geo.json')]).then(
|
||||
([keys, geo]) => {
|
||||
const out: Record<string, string> = {};
|
||||
for (const f of geo.features ?? []) {
|
||||
const id = f.id == null ? '' : String(f.id);
|
||||
const key = keys[id];
|
||||
const name = f.properties?.name;
|
||||
if (key && typeof name === 'string') out[key] = name;
|
||||
}
|
||||
return out;
|
||||
},
|
||||
);
|
||||
return keyNamePromise;
|
||||
}
|
||||
Reference in New Issue
Block a user