OpenCode/History
2
0
Fork 0
Code Issues Pull Requests Actions Activity

No man's land: TurnResult.unowned + release/re-claim in applyTurnResult + distinct grey map rendering (#16 P3)

Browse Source 
- shared/protocol.ts: TurnResult.unowned (keys released this turn) + the map
  presentation contract (regionFillStyle / unownedTooltipLabel, hue-less grey)
- shared/types.ts: required GameState.unowned (cumulative mid-game releases;
  [] at init, distinct from preset-unassigned regions)
- server/engine.ts: applyTurnResult applies releases first (sole-owner only,
  never fabricating no man's land from unassigned keys), then claims against
  the post-release snapshot (gain on an ownerless key = re-claim); lone
  release is isMeaningful; prompts + user payload carry the unowned field
- server/stub.ts: unchanged behavior (never releases; e2e stays stable)
- server/db.ts: legacy rows load with unowned defaulted to []
- server/index.ts: create-game sets []; jump reference table includes
  released keys so the model can name them for re-claim
- WorldMap/App: unowned prop -> visible grey + 'No man's land' tooltip
- unit tests: 105 -> 127 (release/re-claim suites, presentation contract,
  legacy-row normalization)
This commit is contained in:
kamilkrzywda
2026-10-14 12:04:03 +00:00
parent cb426273a9
commit 764f24fc55
13 changed files with 567 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/engine.ts
+99 -26
View File
@@ -142,12 +142,23 @@ export function buildSystemPrompt(preset: Preset, withNeighboursTool = false): s
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. One region key has exactly one owner at all times — never assign a key to two nations or to none.',
'- 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.'];
: [
'- Only change borders when war or a decisive political shift justifies it.',
noMansLandRule,
];
return [
`WORLD: ${preset.title} — ${preset.startDate}`,
preset.worldBackground,
@@ -164,12 +175,14 @@ 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>"]}]',
' "territoryChanges": [{"nation":"<nationId>","gain":["<region key>"],"lose":["<region key>"]}],',
' "unowned": ["<region key>"]',
'}',
'',
'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.',
'- 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".',
'- 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.',
@@ -198,6 +211,13 @@ export function buildUserPrompt(
* 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 {
const player = state.nations[state.playerNationId];
const playerName = player?.name ?? state.playerNationId;
@@ -235,6 +255,7 @@ export function buildUserPrompt(
};
if (regionReference) payload.regions = regionReference;
if (frontier !== undefined) payload.frontier = frontier;
if (noMansLand !== undefined) payload.unowned = noMansLand;
return JSON.stringify(payload, null, 2);
}
@@ -309,6 +330,7 @@ export function validateTurnResult(input: unknown): TurnResult | null {
stateChanges: [],
relations: [],
territoryChanges: [],
unowned: [],
};
if (Array.isArray(o.events)) {
@@ -384,12 +406,26 @@ 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);
}
}
return result;
}
/** A turn is "meaningful" if it produced at least an event or a stat change. */
/**
* A turn is "meaningful" if it produced at least an event, a stat change, or
* a no-man's-land release (v0.22 #16 P3: a release is a real world change even
* when the model under-narrates it, so it must survive the retry/nudge path
* instead of being replaced by the generic "unclear" result).
*/
export function isMeaningful(result: TurnResult): boolean {
return result.events.length > 0 || result.stateChanges.length > 0;
return result.events.length > 0 || result.stateChanges.length > 0 || result.unowned.length > 0;
}
// --- Applying the delta -------------------------------------------------------
@@ -406,7 +442,8 @@ 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.
* events, apply stat changes (clamped), symmetric relations, and territory
* moves (including no-man's-land releases, v0.22 #16 P3).
*/
export function applyTurnResult(state: GameState, result: TurnResult, validKeys?: ReadonlySet<string>): GameState {
const next: GameState = JSON.parse(JSON.stringify(state));
@@ -431,22 +468,53 @@ 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: a region key has exactly one owner) ---
// --- 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") ---
//
// Snapshot-first: BEFORE any mutation, compute who currently owns each
// region key. A key transfers only when (a) exactly one nation claims to
// gain it — a double claim (two or more gainers) is rejected so the key
// stays where it is, (b) the key currently has exactly one owner — a
// pre-existing double ownership (or unownership) is never touched, and
// (c) that owner is not the gainer (a self-gain is a no-op). A transfer
// removes the key from every nation first (defensive) and then grants it
// to the gainer; "lose" entries are pure no-ops by design, because a lone
// loss would orphan the key and a valid gain already removes it from the
// old owner. Ownership is therefore conserved: a key can never end a turn
// unowned or multiply-owned.
// 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 ownerOf = new Map<string, string>(); // key -> sole owner id, or '' (0 or 2+ owners)
for (const n of Object.values(state.nations)) {
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);
@@ -479,16 +547,18 @@ export function applyTurnResult(state: GameState, result: TurnResult, validKeys?
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);
if (owner === undefined || owner === '' || owner === gainer) continue;
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);
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
}
// "lose" entries are deliberate no-ops (see above): a valid gain already
// removes the key from its old owner, and a lone loss would orphan it.
next.unowned = [...unowned];
return next;
}
@@ -558,7 +628,9 @@ export async function runTurn(opts: {
const useTools = getNeighbours !== undefined && chatWithTools !== undefined;
const system = buildSystemPrompt(preset, useTools);
const frontier = getNeighbours ? playerFrontier(state, getNeighbours) : undefined;
const user = buildUserPrompt(state, items, regionReference, frontier);
// (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 nudge =
'Your previous output was invalid. Respond with ONLY the JSON object described above for this batch — no prose, no fences.';
@@ -601,6 +673,7 @@ export async function runTurn(opts: {
stateChanges: [],
relations: [],
territoryChanges: [],
unowned: [],
};
}