Files
settled-reach/project.yaml
T
jpmschweitzerandClaude Opus 5 3ec35b87c8 fix(client): the deep rungs were flat because relief_q fell off the wire (T-1213)
`relief_q` is the one field with signal below District — elev_q's 80 m steps
quantise sub-district detail away, which is precisely why relief_q was invented.
The server has encoded it since 5eb394b36 and the terrain layer has asked for it
by name ever since. step_canvas_protocol.gd's decode dictionary never listed the
key, so `canvas.get("relief_q")` was always null and the plane arrived nowhere.
The server half of that change landed; the protocol half did not.

That is the whole reason Region and below rendered as a flat wash. Measured plane
variety at District before the fix:

    {morphology: 1, elev_q: 11, relief_q: 0, moisture_q: 25, vegetation: 3}

A 0 there means ABSENT, not constant — a distinction the capture could not make
until this commit adds it, and the reason two earlier sessions read the flatness
as a missing generator rather than a missing key.

Also spends the field properly. It drove a stipple PROBABILITY only, so a ridge
and a plain differed in dot density, which at one pixel per cell reads as noise;
and `_ruggedness()` took absf(relief_q - 50), discarding the sign the server
deliberately preserved ("a hollow and a rise are different ground... the reverse
is not recoverable"). Relief now shades continuously and signed — rises lighten,
hollows darken — UNDER the stipple rather than instead of it. Ruggedness
(unsigned) and elevation (signed) are different questions and both are worth
asking.

Ladder, before -> after (tooling/atlas-flatness, lum p1-p99):

    Global    145.69 -> 145.69   unchanged, correct: relief_q is flat 50 at
                                 orbital rungs by construction
    Region     33.59 ->  71.01   2.1x
    District   13.72 ->  77.01   5.6x
    Quarter    11.01 ->  42.56   3.9x

Structure retention Global->Quarter: 7.6% -> 29%.

NOT finished, and the ticket says so: Region now reads as heavy speckle, because
ruggedness is real data instead of an elev_q-gradient fallback and far more cells
earn a mark than the T-1194 tuning assumed; District reads as soft blobby relief,
form without directionality. Both are grammar/tuning follow-ups on a channel that
finally carries signal.

0.4.9 is a REQUIRED bump. The disk cache stores the DECODED canvas, so every
earlier entry physically lacks the field and would keep rendering flat against a
build that reads it — the first bump in this series where a warm cache is wrong
about CONTENT, not merely stale. tooling/canvas_sources.py gains
step_canvas_protocol.gd for the same reason: it decides which planes exist, the
cache stores its output, and the T-1242 gate would not have flagged this fix
while the registry stopped at ui/.../step_canvas/.

Regression cover: every protocol test passed throughout the weeks the plane was
missing, because each asserted a field it already knew about and none asserted
the SET. There is now a test walking all eight dense planes of EncodedStepCanvas,
verified by disabling the fix and watching it fail by name.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-16 15:22:50 +02:00

101 lines
5.8 KiB
YAML

name: The Settled Reach
# Version scheme: 0.{phase}.{n} — phase = active Development Cascade phase (D-166).
# Phase 4 (deterministic world generation) is active.
# 0.4.1-tagged step canvases carried lake_margin_q's flat absolute-ceiling
# semantics (pre-per-basin-normalization) and were written to real disk
# caches during T-1188 eyeball runs — 0.4.2 forces those entries to miss.
# 0.4.2-tagged Global/Region-rung step canvases sampled the coastline
# position raw (no coast_warp_px) — T-1160 applies the warp at orbital
# sampling, changing orbital-rung canvas bytes (elev_q/temperature_dc/
# moisture_q shift near coasts) — 0.4.3 forces those cached entries to miss.
# 0.4.3-tagged canvases predate the D-255 extent inversion (a rung now fixes
# the canvas EXTENT and the gridunit spacing falls out, rather than the
# reverse). District/Quarter/Block/Chunk kept the same 960x540 cell counts
# through that change, so their cache keys are byte-identical while a District
# canvas now covers 3.6 km of ground instead of 1,966 km — a warm cache would
# silently serve pre-inversion canvases. 0.4.4 forces those entries to miss.
# 0.4.4-tagged GLOBAL canvases are all 2x1 — `serve_step_canvas_request` was
# still zeroing Global's wire extent (a pre-extent-inversion sentinel), so
# every Global request resolved to a two-cell canvas regardless of viewport.
# Those entries were also cached under a key that ignored extent, so they
# answered every later request forever. 0.4.5 forces them to miss.
# 0.4.5-tagged canvases carry pre-T-1237 river courses: one course per D8 HOP
# rather than one per river (build_paths walks whole headwater->mouth rivers
# now). The hop-shaped entries survived that fix because it changed only server
# and client code, never this version — so Ferrath Global replayed 375 fragments
# with a 106 km longest run, all of them below D-261's read-as-a-line floor, and
# drew NOTHING, while a cold cache on the same build produced 73 whole rivers
# with a 1,644 km trunk and drew 18. Diagnosed as T-1239. 0.4.6 forces them to
# miss.
#
# THE PATTERN, now four bumps deep: a change to how a canvas is GENERATED is
# only half the change — the other half is this line. Nothing enforces the
# pairing, so a canvas-generation commit that leaves this version alone ships a
# silent regression that reproduces only on machines with a warm cache. The
# capture harness no longer hides it (tests/run-visual isolates user:// per run,
# T-1239), but a real player's cache is still governed by this number alone.
# 0.4.7 carries NO canvas-generation change — it is the gate that enforces the
# pairing described above, arriving (T-1242). tooling/canvas_sources.py lists the
# paths, tooling/check-canvas-version rejects a push that touches them without
# moving this line, and the registry includes ITSELF so that narrowing it and
# changing a canvas file in one push still demands a bump. That self-inclusion is
# why this bump exists: adding the registry trips its own rule. The version is
# spent rather than special-cased, because "this change is obviously harmless" is
# the reasoning that produced all five regressions above.
# 0.4.8 also carries NO canvas-generation change: a test-only edit to
# composition.rs (its conservation assertion was a tautology) tripped the T-1242
# gate, because that gate is path-based and cannot tell test code from generator
# code. Second no-op bump in two days — the false-positive rate is real, and is
# the price of the ruling that a false negative costs a week. Revisit if it
# becomes noise; do NOT add an override to dodge it.
# 0.4.9 is a REQUIRED bump, not a gate formality (T-1213). The disk cache stores
# the DECODED canvas, and the decode was silently dropping the `relief_q` plane —
# so every 0.4.8-and-earlier entry physically lacks the field, and would keep
# rendering the deep rungs as a flat wash even against a build that reads it.
# This is the first bump in the series where a warm cache is wrong about CONTENT
# rather than merely stale.
version: 0.4.9
repository: settled-reach
description: >
Top-down life-sim set in an original science fiction universe. Asymmetric
information and occlusion-based perception from a single-character
perspective, with a Rimworld-style storyteller. Systems interactions like
The Sims, combat and visuals like single-character Rimworld, world
generation inheriting from Dwarf Fortress and NMS, economy inspired by
X4/EVE. Every system is interactable but ignorable — the world is alive
for any given run.
setting: >
The Settled Reach — a network of star systems connected by Founder Gates.
Neural lattice technology enables soft immortality, forking, and
re-embodiment.
development: >
Built outside-in along the six-phase Development Cascade (D-166): wiki
content and star map, economics layer, planetary maps and atlas,
deterministic world generation (active), player control and in-world
rendering, room-level detail.
architecture:
client: Godot 4 (GDScript)
server: Rust with bevy_ecs (simulation server)
transport: subprocess/IPC via TCP with MessagePack serialization
protocol: length-prefixed MessagePack frames (4-byte big-endian)
determinism: ChaCha20 seeded RNG, deterministic tick processing
simulation:
tick_rate: 10 ticks per game-minute
time_model: 4 day phases (Morning, Afternoon, Evening, Night)
grid: dual-scale (0.5m simulation tiles, 1m visual tiles)
visibility: symmetric shadowcasting + forward/peripheral/blind vision cone
knowledge: per-entity knowledge graphs with confidence decay
content:
format: YAML with JSON Schema validation
structure: campaigns/systems/stations/districts hierarchy
npcs: 10-axis model (7 essential + 3 supporting) with CombatCapability
dialogue: tagged line pools with 4-layer relational filtering
population: 30% flat / 50% mundane triangles / 20% intrigue-entangled