wtclaude
4035c523cb
Found on the walk: the game spells one label "jungle swamp" on both rigs' maps, and the fleet list printed it that way beside the minor list's "Jungle Swamp". Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01E14m6SuuY6i1vASFeGDBeY
92 lines
3.8 KiB
JavaScript
92 lines
3.8 KiB
JavaScript
// ── Which monument labels a map draws (PLAN_REDESIGNS §4, D196) ───────────
|
|
//
|
|
// The admin card's half of the rule `model/map/map.model.js` applies on the
|
|
// server: a switch per monument LABEL, the minor labels off unless somebody
|
|
// turns them on, every other label on. A server's switch wins over the fleet's,
|
|
// the fleet's over the built-in list.
|
|
//
|
|
// The form holds only the EXPLICIT switches, as the server does — `{ key: bool }`
|
|
// — so a label nobody touched keeps following the default above it. Setting the
|
|
// fleet back to what the built-in list says clears the row rather than storing a
|
|
// copy of the default: the next change to the list then reaches that label.
|
|
//
|
|
// Pure, and free of React, so it is tested in Node.
|
|
|
|
/** A label as its switch's key: trimmed, single-spaced, lower case. The server's rule exactly. */
|
|
export function markerKey(label) {
|
|
return String(label == null ? '' : label).trim().replace(/\s+/g, ' ').toLowerCase()
|
|
}
|
|
|
|
/** The built-in answer for one key: hidden for the minor labels, drawn for everything else. */
|
|
export function builtIn(minorLabels, key) {
|
|
return !(minorLabels || []).some((l) => markerKey(l) === key)
|
|
}
|
|
|
|
const has = (o, k) => Boolean(o) && Object.prototype.hasOwnProperty.call(o, k)
|
|
|
|
/** Whether the fleet draws one key: its own switch, or the built-in list. */
|
|
export function fleetShows(minorLabels, fleetMarkers, key) {
|
|
return has(fleetMarkers, key) ? fleetMarkers[key] : builtIn(minorLabels, key)
|
|
}
|
|
|
|
/** Whether one server draws one key: its switch, or the fleet's answer. */
|
|
export function serverShows(minorLabels, fleetMarkers, serverMarkers, key) {
|
|
return has(serverMarkers, key) ? serverMarkers[key] : fleetShows(minorLabels, fleetMarkers, key)
|
|
}
|
|
|
|
/**
|
|
* Every label the fleet list offers, sorted by name: each server's current
|
|
* labels and the minor list, each once. A minor label no map has yet is still
|
|
* listed, so it can be decided before a wipe brings it.
|
|
*/
|
|
export function fleetLabels(minorLabels, servers) {
|
|
const byKey = new Map()
|
|
// A capitalised spelling wins over the game's lower-case one ("jungle swamp").
|
|
const add = (key, label, count) => {
|
|
const seen = byKey.get(key)
|
|
if (!seen) byKey.set(key, { key, label, count })
|
|
else {
|
|
seen.count += count
|
|
if (seen.label === seen.label.toLowerCase() && label !== label.toLowerCase()) seen.label = label
|
|
}
|
|
}
|
|
for (const s of servers || []) {
|
|
for (const l of s.markerLabels || []) add(l.key, l.label, l.count || 0)
|
|
}
|
|
for (const label of minorLabels || []) add(markerKey(label), label, 0)
|
|
return [...byKey.values()].sort((a, b) => a.label.localeCompare(b.label))
|
|
}
|
|
|
|
/** The fleet form after ticking one key: an explicit switch, or none where it matches the built-in list. */
|
|
export function setFleet(minorLabels, fleetMarkers, key, shown) {
|
|
const next = { ...(fleetMarkers || {}) }
|
|
if (shown === builtIn(minorLabels, key)) delete next[key]
|
|
else next[key] = shown
|
|
return next
|
|
}
|
|
|
|
/** A server form after choosing one key: `null` follows the fleet, otherwise an explicit switch. */
|
|
export function setServer(serverMarkers, key, shown) {
|
|
const next = { ...(serverMarkers || {}) }
|
|
if (shown === null) delete next[key]
|
|
else next[key] = shown
|
|
return next
|
|
}
|
|
|
|
/**
|
|
* What changed between two explicit maps, as the PUT takes it: `{ key: bool }`
|
|
* for a switch set or changed, `{ key: null }` for one cleared. Null when
|
|
* nothing changed.
|
|
*/
|
|
export function markerDiff(before, now) {
|
|
const out = {}
|
|
const keys = new Set([...Object.keys(before || {}), ...Object.keys(now || {})])
|
|
for (const key of keys) {
|
|
const was = has(before, key) ? before[key] : undefined
|
|
const is = has(now, key) ? now[key] : undefined
|
|
if (was === is) continue
|
|
out[key] = is === undefined ? null : is
|
|
}
|
|
return Object.keys(out).length ? out : null
|
|
}
|