`nx_wasm_craft.nx` source

↩ module page · 3087 lines · 149620 B
1// nx_wasm_craft.nx -- NISHI CRAFT: a GENERATED 3D VOXEL WORLD, playable first-person. The operator's
2// 2026-05-19 vision ("build minecraft equivalent on the lowest possible hardware") finally EMITTING:
3// procedural terrain (integer value-noise heightmap, biome banding, water, trees) in a 64x32x64 block
4// grid, rendered by a per-pixel integer DDA raycast (true 3D: block faces, face shading, distance fog,
5// sky), walked in first person (collision, auto-step-up, water float), and EDITED live (break/place at
6// the crosshair). Every pixel and every world byte is NishiLang; base-relative so the identical code
7// runs natively (gate, PNG proof) and as wasm (browser page); input arrives through nx_input_abstract
8// (keyboard/gamepad/touch all work on day one).
9//
10// Controls (via the input layer's semantic actions): W/S or Up/Down = walk, A/D or Left/Right = turn,
11// R/F = look up/down (bound to the MENU/PAUSE bits -- the 8-action mask is fully spent; widening it
12// to 16 actions is the filed follow-up), E = break block, B = place stone. Touch d-pad works: center
13// tap = break.
14//
15// license_tier: ORIGINAL
16import "nx_syscalls.nx"
17import "nx_itrig.nx"
18import "nx_input_abstract.nx"
19import "nx_softbind.nx"
20import "_hdl_build/nx_entity_store.nx"
21import "_hdl_build/nx_gamesave_core.nx"
22const WATER_MAGIC_16777216: i64 = 16777216
23const WATER_MAGIC_40503: i64 = 40503
24const WATER_MAGIC_33554431: i64 = 33554431
25const WATER_MAGIC_374761393: i64 = 374761393
26const WATER_MAGIC_668265263: i64 = 668265263
27const WATER_MAGIC_1442695041: i64 = 1442695041
28const WATER_MAGIC_4611686018427387903: i64 = 4611686018427387903
29const WATER_MAGIC_1274126177: i64 = 1274126177
30const WATER_MAGIC_1099511627776: i64 = 1099511627776
31const WATER_MAGIC_65536: i64 = 65536
32const WATER_MAGIC_4096: i64 = 4096
33const WATER_MAGIC_1048576: i64 = 1048576
34const WATER_MAGIC_1536: i64 = 1536
35const WATER_MAGIC_6144: i64 = 6144
36const WATER_MAGIC_57344: i64 = 57344
37const WATER_MAGIC_1469598103: i64 = 1469598103
38const WATER_MAGIC_1099511: i64 = 1099511
39const WATER_MAGIC_2400: i64 = 2400
40const WATER_MAGIC_2500: i64 = 2500
41const WATER_MAGIC_1400: i64 = 1400
42const WATER_MAGIC_20260728: i64 = 20260728
43
44const W: i64 = 480
45const H: i64 = 300
46const RES: i64 = 2                   // ray per RESxRES pixel block (240x150 rays)
47const RW: i64 = 240
48const RH: i64 = 150
49const FOC: i64 = 120                 // ~90 degree fov at RW=240
50
51const WX: i64 = 128                  // world blocks (v2: 4x the area, taller)
52const WY: i64 = 48
53const WZ: i64 = 128
54const WATER_H: i64 = 9
55
56// FARMING-LIFE blocks (roadmap B1/B2): wetness lives IN the id and crops are separate stage ids,
57// so the v6 save format is UNTOUCHED -- voxels + the edit journal already persist every farm cell.
58const B_FARM: i64 = 12               // tilled farmland, dry
59const B_CROP0: i64 = 13              // crop sprout (placed by SEEDS onto farmland)
60const B_CROP1: i64 = 14              // crop growing
61const B_CROP2: i64 = 15              // crop MATURE -- breaking it is the HARVEST
62const B_FARMW: i64 = 16              // farmland, wet (rain or water within the 5x5 ring)
63
64const O_FB: i64 = 0                  // W*H i64 packed R|G<<8|B<<16
65const O_ST: i64 = 1152000            // 64 state slots
66const O_INPUT: i64 = 1152512         // nx_input_abstract arena (64 words)
67const O_VOX: i64 = 1153024           // WX*WY*WZ u8 blocks
68const O_MOBS: i64 = 1939456          // nx_entity_store arena (certified part): en_bytes(16,7)=1632
69const MOB_CAP: i64 = 16
70const MOB_NCOMP: i64 = 7
71const MOB_BYTES: i64 = 1632
72const O_SPEC: i64 = 1941120          // GAME SPEC block (64 words) -- AFTER the arena's 1632B end
73const O_EJRN: i64 = 1941760          // EDIT JOURNAL: 8192 packed i64 hash slots at ABSOLUTE world
                                   // coords (v6 streaming). Reuses the pre-v6 save staging spot.
75const EJRN_SLOTS: i64 = 8192
76const EJRN_BYTES: i64 = 65536
77const O_SAVE: i64 = 2730336          // v6 save image (relocated past MOBAUX): 128B header + voxels
                                   // + mob arena + edit journal. The page reads save_off() so the
                                   // relocation is invisible to every surface.
80const SAVE_HDR: i64 = 128
81const SAVE_BODY: i64 = 853600        // WX*WY*WZ + MOB_BYTES + EJRN_BYTES
82const SAVE_BODY_V5: i64 = 788064     // pre-streaming body (load-compat: v5 saves still open)
83const SAVE_LEN: i64 = 853728         // SAVE_HDR + SAVE_BODY
84const CRAFT_BYTES: i64 = 3584064     // O_SAVE + SAVE_LEN
85const O_MOBAUX: i64 = 2729952        // 16 mobs x (dx,dz,dy) last-applied step, i64 triples
                                   // (384B, fits the 544B rounding slack past the save image;
                                   // save format untouched). NON-PERSISTED display truth.
                                   // The page's heading/speed used to be a JS derivative of
                                   // positions -- a workaround; the ORGAN owns motion, so it
                                   // exports the applied step incl the vertical component
                                   // (climb cadence needs dy).
92const O_SOFT: i64 = 3584064          // A4 soft-body springs: 16 mobs x SB_PTS x SD_STRIDE words.
                                   // NON-PERSISTED display truth (pure function of root motion;
                                   // re-seated on init/load/shift/summon -- the MOBAUX pattern).
95const O_NEED: i64 = 3586368          // C1 needs: 16 mobs x 4 words (hunger, energy, social, spare).
                                   // NON-PERSISTED; re-seeded deterministically on init/load.
97const O_MIND: i64 = 3586880          // C3/C5 THE INNER LIFE: 16 girls x 24 words -- 8 THOUGHT
                                   // slots (id<<8 | mag+128, expiry-tick) then 4 GOSSIP slots
                                   // (subj<<16 | pred<<8 | conf, born-tick). NON-PERSISTED;
                                   // every write derives from deterministic state, so the
                                   // T4/T17 two-arena checksums hold by construction.
102const O_PASS: i64 = 3589952          // THE TRAVELER'S PASSPORT (the isekai carry): the
                                   // CHARACTER crosses worlds while each world keeps its own
                                   // v6 save. Wire = 12 words (magic ver charseed broken
                                   // placed harv plant found lost ticks worldmask ck);
                                   // words 16-24 = the in-arena delta SNAPSHOT so a world
                                   // reload never double-counts a deed into the ledger.
108const PASS_MAGIC: i64 = 20260802001
109const PASS_LEN: i64 = 192            // 24 wire words: [0]magic [1]ver [2]charseed [3]broken
                                   // [4]placed [5]harv [6]plant [7]found [8]lost [9]ticks
                                   // [10]worldmask [11]party-count [12..20]=3x(kind,disg,
                                   // gene) -- COMPANIONS CROSS WORLDS with their bond and
                                   // bred genome intact -- [21]ck. Snapshot at words 32+.
114const CRAFT_TOTAL: i64 = 3590336     // O_PASS + 384 -- the full arena an allocator must map
115
116// C3 thought ids (RimWorld's inspectable-mood law: a mood is a LEDGER, never a scalar mystery)
117const TH_RAIN: i64 = 1
118const TH_FEAR: i64 = 2
119const TH_MET: i64 = 3
120const TH_SLEPT: i64 = 4
121const TH_HUNGRY: i64 = 5
122const TH_SAWTAKEN: i64 = 6
123const TH_HEARD_TAKEN: i64 = 7
124const TH_HEARD_FRIEND: i64 = 8
125const TH_COMPANY: i64 = 9
126// C5 gossip predicates (Talk of the Town's law -- the differentiator no shipped game has)
127const GO_FRIEND: i64 = 1
128const GO_TAKEN: i64 = 2
129const SAVE_MAGIC: i64 = 20260728001
130const SAVE_VER: i64 = 6              // v6 = STREAMING WORLD (origin + edit journal in the image);
                                   // v5 still LOADS (origin 0, empty journal); others REFUSED
132const SAVE_VER5: i64 = 5
133// mob components (nx_entity_store comp slots)
134const MC_X: i64 = 0
135const MC_Y: i64 = 1
136const MC_Z: i64 = 2
137const MC_KIND: i64 = 3
138const MC_PH: i64 = 4
139const MC_DISG: i64 = 5               // 1 = a HUMAN girl disguised as a monster girl (the lore:
                                   // monster girls took the world; humans hide among them --
                                   // her features are a worn costume, not grown)
142const MC_GENE: i64 = 6               // 20-bit APPEARANCE GENOME rolled at spawn -- every girl is
                                   // GENERATED, not hand-built: bits 0-2 hair hue, 3-4 hair
                                   // length, 5-6 height, 7-8 outfit tint, 9-10 skin tone,
                                   // 11-12 feature size. The slot bred inheritance plugs into.
146
147// state slots
148const S_SEED: i64 = 0
149const S_CX: i64 = 1                  // camera pos Q8 (256 = one block)
150const S_CY: i64 = 2
151const S_CZ: i64 = 3
152const S_YAW: i64 = 4                 // it-units (IT_PI = half turn)
153const S_PITCH: i64 = 5
154const S_T: i64 = 6
155const S_BROKEN: i64 = 7
156const S_PLACED: i64 = 8
157const S_HX: i64 = 9                  // crosshair DDA hit cache
158const S_HY: i64 = 10
159const S_HZ: i64 = 11
160const S_HFACE: i64 = 12              // 0 none, 1 +x, 2 -x, 3 +y, 4 -y, 5 +z, 6 -z
161const S_HOK: i64 = 13                // 1 = in reach
162const S_VY: i64 = 14                 // vertical velocity Q8/tick (jump + gravity)
163const S_GROUNDED: i64 = 15           // 1 = standing on a surface (jump allowed)
164const S_SEL: i64 = 16                // hotbar slot 0..4 (Q cycles; sel_block maps to a block type)
165const S_LBX: i64 = 17                // last-broken cell (probes/particles; the hit cache retargets
166const S_LBY: i64 = 18                // every frame, so "what did I just break" needs its own slots)
167const S_LBZ: i64 = 19
168const S_Q: i64 = 20                  // ray pixel size 2..5 -- ADAPTIVE: the organ tunes itself from
169const S_FMA: i64 = 21                // the surface's reported frame ms (EMA x16); shim only reports
170const S_WMAX: i64 = 22               // highest solid y in the world -- rays above it heading up/flat
                                   // are SKY immediately (kills the 110-step horizon marches)
172const S_SPX: i64 = 23                // spawn point (H key + void-fall auto-respawn return here)
173const S_SPY: i64 = 24
174const S_SPZ: i64 = 25
175const S_NPCT: i64 = 26               // crosshair NPC target: dense index of the girl under the
                                   // gaze (occlusion-aware, walls block), -1 = none
177const S_FOUND: i64 = 27              // disguised humans FOUND (met + identified = under protection)
178const S_LOST: i64 = 28               // found humans TAKEN by wardens (the cost of not protecting)
179const S_BCD: i64 = 29                // birth cooldown ticks (community pacing)
180const S_WOX: i64 = 30                // WORLD ORIGIN of the window, in blocks (v6 streaming): the
181const S_WOZ: i64 = 31                // arena is a 128x48x128 CACHE over unbounded absolute terrain
182const S_EJDROP: i64 = 32             // edits REFUSED because the journal was full (loud, never silent)
183const S_HARV: i64 = 33               // MATURE crops harvested (the farming loop's payoff counter)
184const S_PLANT: i64 = 34              // seeds planted
185const S_GROWN: i64 = 35              // crops that reached maturity (world truth, gate-readable)
186const S_VAR: i64 = 36                // which world identity this arena runs (the passport's
                                   // visited-mask bit; set once at init)
188const SHIFT_STRIDE: i64 = 16         // one window slide, in blocks
189const SHIFT_MARGIN: i64 = 32         // player this close to a window edge -> the world slides under them
190
191// spec slots (the game-identity DATA the engine reads -- nx_voxel_world's style-is-a-spec doctrine)
192const P_TBASE: i64 = 0               // terrain base height
193const P_TAMP1: i64 = 1               // large-noise amplitude
194const P_TAMP2: i64 = 2               // detail-noise amplitude
195const P_WATER: i64 = 3               // flood level
196const P_SNOW: i64 = 4                // snow line (99 = never)
197const P_TREE: i64 = 5                // tree sparsity modulus (0 = no trees)
198const P_CAVETH: i64 = 6              // cave carve threshold (lower = more cavern)
199const P_SKYTOP: i64 = 7              // packed zenith colour
200const P_SKYHOR: i64 = 8              // packed horizon colour
201const P_SUN: i64 = 9                 // 1 = sun disc
202const P_CLOUD: i64 = 10              // 1 = cloud deck
203const P_PAL: i64 = 16                // +blocktype = packed base colour (0..11)
204const P_MOBC: i64 = 28               // +kind*2+half = packed mob colours (3 kinds x 2 tones)
205const P_PAL2: i64 = 34               // +b-12 = packed colour for farm blocks 12..16 (5 rows, 34-38)
206const P_DAYLEN: i64 = 40             // A1 calendar: ticks per day (ALL timing is spec DATA)
207const P_SEASD: i64 = 41              // days per season (4 seasons cycle)
208const P_GROWE: i64 = 42              // farm-tick cadence: one grow/hydrate pass every N ticks
209const P_GROWW: i64 = 43              // crop speed on WET farmland (Minecraft stencil speed)
210const P_GROWD: i64 = 44              // crop speed on DRY farmland
211const P_RAINS: i64 = 45              // +season = rain permil per day-eighth (4 rows, 45-48)
212const P_ADV: i64 = 50                // +i = smart-object ADVERTISEMENTS (C1): packed
                                   // block<<16 | need<<8 | strength; 6 rows 50-55, 0 = end.
                                   // NPC minds read OBJECTS as data -- adding a row changes
                                   // village life with zero new NPC code (The Sims' law).
216const P_HISTAGE: i64 = 60            // DECLARED geomorphic stage (Strahler bands): 0 = mature/
                                   // equilibrium (HI 300-600 permil), 1 = youthful (HI >= 600).
                                   // A world DECLARES its stage and gate T53 checks the
                                   // MEASUREMENT matches -- widening one band until everything
                                   // fits would hide a young landscape. (Ported 2026-08-02:
                                   // existed only on the laptop line; the NAS gate ran 52 teeth
                                   // while local ran 53 -- the LOCAL-IS-NOT-A-SUPERSET fork.)
223const P_TREEMAX: i64 = 59            // tree altitude ceiling (0 = the historic hardcoded 19)
224const P_WARD: i64 = 58               // warden daytime hunt radius in BLOCKS (0 = the 12-block
                                   // default). A world declares its own danger; the arriving
                                   // traveler's LEVEL scales it further (isekai: new world,
                                   // new challenge, and the challenge KNOWS who showed up).
228const P_OUTFIT: i64 = 57             // outfit mode: 0 = identity keeps everyone clothed;
                                   // 1 = MIXED (beach): genome bits 18-19 pick each girl's
                                   // beachwear -- clothed / topless / nude -- stable per
                                   // girl, bred like every trait. Identity DATA decides
                                   // whether the dimension is active at all.
233const P_CURI: i64 = 56               // curiosity threshold: a girl approaches the player only
                                   // while her loneliness exceeds this (HABITUATION -- the
                                   // operator's "they just follow me around": company
                                   // satisfies, satisfied girls walk on with their lives.
                                   // Fear never habituates; shy girls always keep distance).
238
239// GAME-FEEL TUNABLES -- every one carries a row in knowledge/gamefeel_oracle.conf (banked
240// reference bands: biomechanics, shipped-sim constants, modding-community defaults) and
241// nx_gamefeel_oracle_gate REFUSES any value outside its cited band. Feel is derived, not tasted.
242const WC_GAIT_BOB_Q8: i64 = 7        // thorax oscillation AMPLITUDE (~2.7cm, 5.5cm p2p --
                                   // the band is peak-to-peak/2; 14 was a p2p-vs-amplitude
                                   // conflation the recorder exposed as 11.3cm of chest)
245// RESPIRATION -- the idle drive. Derived, not tasted: resting adult breathing is 12-16/min;
246// at 14/min on the fixed 60Hz tick that is 60*60/14 = 257 ticks per cycle (0.233 Hz, inside the
247// 0.20-0.30 Hz band this rung is gated on). Amplitude is scaled off the GAIT constant above so
248// the two drives share one ruler: 7 q8 ~ 2.7cm => 1 q8 ~ 0.386cm, so 2 q8 ~ 0.77cm, inside the
249// declared 0.4-0.8cm resting-excursion band. A third value would have been a guess; this is an
250// arithmetic consequence of a constant already cited.
251const WC_BREATH_TICKS: i64 = 257
252// ★ AMPLITUDE, NOT PEAK-TO-PEAK -- and I got this wrong ONCE ALREADY on the gait constant.
253// Conversion, derived from the cited gait row: 7 q8 amplitude is documented as ~2.7cm, and
254// 7/256*100cm-per-block = 2.73cm, so the unit is q8 world units and p2p = 2*amp/256*100 cm.
255// At 2 q8 that is 1.56cm p2p -- OUTSIDE the 0.4-0.8cm resting band this rung is gated on, i.e.
256// 2x too large, the SAME p2p-vs-amplitude conflation the recorder caught in WC_GAIT_BOB_Q8 (14
257// -> 7). At 1 q8: 2/256*100 = 0.78cm p2p, inside the band. Caught by doing the arithmetic in the
258// unit the CRITERION is written in, before it shipped visibly.
259// ⚠KNOWN LIMIT, to be measured not assumed: 1 q8 is near the world-q8 resolution floor, so the
260// anchor steps coarsely; the spring integrates and should low-pass it, but ?breath=1 reports the
261// actual excursion so this is decided by measurement rather than by my expectation.
262const WC_BREATH_Q8: i64 = 1
263// speed at which GAIT fully owns the anchor. PROVISIONAL and deliberately marked so: the units
264// of the per-tick mob delta were never measured, so this is the one number here without a
265// derivation. The mobspd door added below exists to REPLACE it with a measurement rather than
266// leave a guess sitting in the engine pretending to be a constant.
267const WC_BREATH_CUT_Q8: i64 = 24
268const WC_STEP_EASE_UP: i64 = 48      // mob Y climb rate Q8/tick (a 1-block rise ~ 5 ticks)
269const WC_STEP_EASE_DN: i64 = 64      // mob Y descend rate Q8/tick
270const WC_NIGHT_X8: i64 = 5           // night begins at this eighth of the day (5/8)
271
272const EYE: i64 = 435                 // eye height Q8 (~1.7 blocks)
273const SPEED: i64 = 40                // walk Q8 per tick
274const TURN: i64 = 140                // yaw it-units per tick (keyboard turn / legacy dir path)
275const PITCHV: i64 = 90               // pitch it-units per tick (R/F keyboard look)
276const PITCH_MAX: i64 = 5000
277const LOOKS: i64 = 6                 // mouselook: it-units per accumulated look count
278const JUMPV: i64 = 66                // jump takeoff velocity Q8/tick
279const GRAV: i64 = 9                  // gravity Q8/tick^2
280const MAXSTEPS: i64 = 110            // DDA cells per ray (view distance)
281const REACH_STEPS: i64 = 20          // crosshair edit reach in DDA cells
282
283func wst(base: i64) -> *i64 { return (base + O_ST) as *i64 }
284func wsp(base: i64) -> *i64 { return (base + O_SPEC) as *i64 }
285func mobp(base: i64) -> *i64 { return (base + O_MOBS) as *i64 }
286func wfb(base: i64) -> *i64 { return (base + O_FB) as *i64 }
287func wvx(base: i64) -> *u8 { return (base + O_VOX) as *u8 }
288func winp(base: i64) -> *i64 { return (base + O_INPUT) as *i64 }
289func wpack(r: i64, g: i64, b: i64) -> i64 { return r | (g << 8) | (b << 16) }
290func wclamp(v: i64, lo: i64, hi: i64) -> i64 { if v < lo { return lo } if v > hi { return hi } return v }
291
292func vin(x: i64, y: i64, z: i64) -> i64 {
  if x < 0 { return 0 } if x >= WX { return 0 }
  if y < 0 { return 0 } if y >= WY { return 0 }
  if z < 0 { return 0 } if z >= WZ { return 0 }
  return 1
297}
298func vget(base: i64, x: i64, y: i64, z: i64) -> i64 {
  if vin(x, y, z) == 0 { return 0 }
  let v: *u8 = wvx(base)
  return (v[(y*WZ + z)*WX + x] & 0xff) as i64
302}
303func vset(base: i64, x: i64, y: i64, z: i64, b: i64) -> i64 {
  if vin(x, y, z) == 0 { return 0 }
  let v: *u8 = wvx(base)
  v[(y*WZ + z)*WX + x] = b as u8
  return 1
308}
309
310// ---------- edit journal (v6 streaming): every PLAYER edit recorded at ABSOLUTE world coords ----------
311// One packed i64 hash slot per touched cell: (key+1)<<8 | block, key = ax+2^24 (25b) : az+2^24 (25b)
312// : ay (6b). The journal is the persistent truth for touched land; the window is a cache over
313// (seed + journal) -- the voxchunk law (virgin land from the seed, touched land from history) wired
314// into the live game. Bounded EJRN_SLOTS edits; a FULL journal REFUSES the whole edit LOUDLY
315// (S_EJDROP counts refusals) so world and history can never disagree.
316func ejp(base: i64) -> *i64 { return (base + O_EJRN) as *i64 }
317func ej_key(ax: i64, ay: i64, az: i64) -> i64 {
  return ((ax + WATER_MAGIC_16777216) << 31) | ((az + WATER_MAGIC_16777216) << 6) | ay
319}
320func ej_put(base: i64, ax: i64, ay: i64, az: i64, b: i64) -> i64 {
  let e: *i64 = ejp(base)
  let k: i64 = ej_key(ax, ay, az)
  let kv: i64 = ((k + 1) << 8) | (b & 255)
  var i: i64 = (k * WATER_MAGIC_40503) & (EJRN_SLOTS - 1)
  var n: i64 = 0
  while n < EJRN_SLOTS {
      let cur: i64 = e[i]
      if cur == 0 { e[i] = kv; return 1 }
      if (cur >> 8) == k + 1 { e[i] = kv; return 1 }
      i = (i + 1) & (EJRN_SLOTS - 1)
      n = n + 1
  }
  return 0 - 1
334}
335func ej_get(base: i64, ax: i64, ay: i64, az: i64) -> i64 {
  let e: *i64 = ejp(base)
  let k: i64 = ej_key(ax, ay, az)
  var i: i64 = (k * WATER_MAGIC_40503) & (EJRN_SLOTS - 1)
  var n: i64 = 0
  while n < EJRN_SLOTS {
      let cur: i64 = e[i]
      if cur == 0 { return 0 - 1 }
      if (cur >> 8) == k + 1 { return cur & 255 }
      i = (i + 1) & (EJRN_SLOTS - 1)
      n = n + 1
  }
  return 0 - 1
348}
349// overlay journal entries falling inside the local box [lx0..lx1) x [lz0..lz1) -- edits WIN over regen
350func ej_overlay(base: i64, lx0: i64, lx1: i64, lz0: i64, lz1: i64) -> i64 {
  let s: *i64 = wst(base)
  let e: *i64 = ejp(base)
  var i: i64 = 0
  while i < EJRN_SLOTS {
      let cur: i64 = e[i]
      if cur != 0 {
          let k: i64 = (cur >> 8) - 1
          let ay: i64 = k & 63
          let az: i64 = ((k >> 6) & WATER_MAGIC_33554431) - WATER_MAGIC_16777216
          let ax: i64 = ((k >> 31) & WATER_MAGIC_33554431) - WATER_MAGIC_16777216
          let lx: i64 = ax - s[S_WOX]
          let lz: i64 = az - s[S_WOZ]
          if lx >= lx0 { if lx < lx1 { if lz >= lz0 { if lz < lz1 {
              vset(base, lx, ay, lz, cur & 255)
          } } } }
      }
      i = i + 1
  }
  return 0
370}
371// the PLAYER-EDIT write path: journal at absolute coords FIRST (a full journal refuses the whole
372// edit -- world and history stay consistent), then the window write. Gen/save paths keep raw vset.
373func wc_edit(base: i64, x: i64, y: i64, z: i64, b: i64) -> i64 {
  let s: *i64 = wst(base)
  if ej_put(base, x + s[S_WOX], y, z + s[S_WOZ], b) < 0 {
      s[S_EJDROP] = s[S_EJDROP] + 1
      return 0
  }
  return vset(base, x, y, z, b)
380}
381// solid for collision: everything but air, water and CROPS (plants are walked through, not on)
382func vsolid(base: i64, x: i64, y: i64, z: i64) -> i64 {
  let b: i64 = vget(base, x, y, z)
  if b == 0 { return 0 }
  if b == 4 { return 0 }
  if b >= B_CROP0 { if b <= B_CROP2 { return 0 } }
  return 1
388}
389
390// ---------- worldgen: integer value noise -> heightmap -> columns -> trees ----------
391func whash(x: i64, z: i64, sd: i64) -> i64 {
  var n: i64 = x*WATER_MAGIC_374761393 + z*WATER_MAGIC_668265263 + sd*WATER_MAGIC_1442695041
  n = n & WATER_MAGIC_4611686018427387903
  n = (n ^ (n >> 13)) * WATER_MAGIC_1274126177
  n = n & WATER_MAGIC_4611686018427387903
  return (n ^ (n >> 16)) % 256
397}
398// bilinear value noise, lattice spacing `sc`, result 0..255
399func wnoise(x: i64, z: i64, sc: i64, sd: i64) -> i64 {
  let cx: i64 = x / sc
  let cz: i64 = z / sc
  let fx: i64 = x % sc
  let fz: i64 = z % sc
  let c00: i64 = whash(cx, cz, sd)
  let c10: i64 = whash(cx+1, cz, sd)
  let c01: i64 = whash(cx, cz+1, sd)
  let c11: i64 = whash(cx+1, cz+1, sd)
  let v0: i64 = c00 + (c10 - c00)*fx/sc
  let v1: i64 = c01 + (c11 - c01)*fx/sc
  return v0 + (v1 - v0)*fz/sc
411}
412func wheight(base: i64, x: i64, z: i64, sd: i64) -> i64 {
  let sp: *i64 = wsp(base)
  let n1: i64 = wnoise(x, z, 16, sd)
  let n2: i64 = wnoise(x, z, 5, sd + 7)
  var h: i64 = sp[P_TBASE] + n1*sp[P_TAMP1]/256 + n2*sp[P_TAMP2]/256
  return wclamp(h, 1, WY - 8)
418}
419// trilinear 3D value noise 0..255 (cave carver)
420func wnoise3(x: i64, y: i64, z: i64, sc: i64, sd: i64) -> i64 {
  let cx: i64 = x / sc
  let cy3: i64 = y / sc
  let cz: i64 = z / sc
  let fx: i64 = x % sc
  let fy: i64 = y % sc
  let fz: i64 = z % sc
  let a00: i64 = whash(cx + cy3*97, cz, sd)
  let a10: i64 = whash(cx + 1 + cy3*97, cz, sd)
  let a01: i64 = whash(cx + cy3*97, cz + 1, sd)
  let a11: i64 = whash(cx + 1 + cy3*97, cz + 1, sd)
  let b00: i64 = whash(cx + (cy3+1)*97, cz, sd)
  let b10: i64 = whash(cx + 1 + (cy3+1)*97, cz, sd)
  let b01: i64 = whash(cx + (cy3+1)*97, cz + 1, sd)
  let b11: i64 = whash(cx + 1 + (cy3+1)*97, cz + 1, sd)
  let a0: i64 = a00 + (a10 - a00)*fx/sc
  let a1: i64 = a01 + (a11 - a01)*fx/sc
  let av: i64 = a0 + (a1 - a0)*fz/sc
  let b0: i64 = b00 + (b10 - b00)*fx/sc
  let b1: i64 = b01 + (b11 - b01)*fx/sc
  let bv: i64 = b0 + (b1 - b0)*fz/sc
  return av + (bv - av)*fy/sc
442}
443// recompute the world's highest solid layer (init + save-load; place maintains it incrementally)
444func wc_wmax(base: i64) -> i64 {
  let s: *i64 = wst(base)
  let vxp: *u8 = (base + O_VOX) as *u8
  var y: i64 = WY - 1
  while y >= 0 {
      var i: i64 = y*WZ*WX
      let end: i64 = (y + 1)*WZ*WX
      while i < end {
          if (vxp[i] & 0xff) != 0 { s[S_WMAX] = y; return y }
          i = i + 1
      }
      y = y - 1
  }
  s[S_WMAX] = 0
  return 0
459}
460
461// generate ONE local column from ABSOLUTE world coords: the terrain is a pure function of
462// (absolute position, seed) -> unbounded land, deterministic everywhere, no stored world needed
463// for virgin ground (the voxchunk regen law wired into the live game).
464func gencol(base: i64, x: i64, z: i64, ax: i64, az: i64, sd: i64) -> i64 {
  let sp: *i64 = wsp(base)
  let wl: i64 = sp[P_WATER]
  let h: i64 = wheight(base, ax, az, sd)
  var y: i64 = 0
  while y < WY {
      var b: i64 = 0
      if y <= h {
          b = 3                                       // stone
          if y > h - 3 { b = 2 }                      // dirt cap
          if y == h {
              b = 1                                   // grass
              if h <= wl { b = 5 }                    // sand at/below waterline
              if h >= sp[P_SNOW] { b = 8 }            // snow high up
          }
          // caves: carve inside the crust (never the floor, never the top 2 = no surface holes,
          // and never under water columns so lakes stay sealed)
          if b == 3 { if y >= 2 { if y <= h - 2 { if h > wl {
              if wnoise3(ax, y, az, 7, sd + 55) > sp[P_CAVETH] { b = 0 }
          } } } }
          // ores seed the remaining stone: coal common, iron deeper, gold deepest
          if b == 3 {
              let orr: i64 = whash(ax*7 + y*131, az*11 + y*17, sd + 31) % 997
              if orr < 22 { b = 9 }
              if y < 14 { if orr >= 22 { if orr < 32 { b = 10 } } }
              if y < 9 { if orr >= 32 { if orr < 38 { b = 11 } } }
          }
      }
      if y > h { if y <= wl { b = 4 } }               // flood low ground
      vset(base, x, y, z, b)
      y = y + 1
  }
  return 0
497}
498// paint a voxel ONLY inside the regen box -- a tree may never overwrite terrain (and its journal
499// overlay) outside the strip being regenerated
500func vset_box(base: i64, x: i64, y: i64, z: i64, b: i64, lx0: i64, lx1: i64, lz0: i64, lz1: i64) -> i64 {
  if x < lx0 { return 0 }
  if x >= lx1 { return 0 }
  if z < lz0 { return 0 }
  if z >= lz1 { return 0 }
  return vset(base, x, y, z, b)
506}
507// trees whose TRUNK falls in the +-2-expanded ABSOLUTE range paint their blocks CLIPPED to the
508// local box, so a tree crossing a strip seam is completed by whichever strip regenerates later.
509// The trunk condition is PURE (grass by the gen rules: above water, below snow) -- no window peeking.
510func gentrees(base: i64, lx0: i64, lx1: i64, lz0: i64, lz1: i64, sd: i64) -> i64 {
  let sp: *i64 = wsp(base)
  if sp[P_TREE] == 0 { return 0 }
  let s: *i64 = wst(base)
  let wl: i64 = sp[P_WATER]
  var az: i64 = s[S_WOZ] + lz0 - 2
  while az <= s[S_WOZ] + lz1 + 1 {
      var ax: i64 = s[S_WOX] + lx0 - 2
      while ax <= s[S_WOX] + lx1 + 1 {
          let h2: i64 = wheight(base, ax, az, sd)
          var trunk: i64 = 0
          // the tree altitude ceiling is a SPEC ROW, not an engine constant: hardcoded 19
          // silently capped forests for any identity whose land sits higher (gate T52 found
          // it -- vale's P_TREE 43->19 barely moved the trunk count because the CEILING, not
          // the density row, was binding). 0 = the historic 19, so craft/depths are unchanged.
          var tmax: i64 = sp[P_TREEMAX]
          if tmax <= 0 { tmax = 19 }
          if h2 < tmax { if h2 > wl { if h2 < sp[P_SNOW] {
              if whash(ax*3 + 7, az*5 + 11, sd + 99) % sp[P_TREE] == 0 { trunk = 1 }
          } } }
          if trunk == 1 {
              let tx: i64 = ax - s[S_WOX]
              let tz: i64 = az - s[S_WOZ]
              var ty: i64 = h2 + 1
              while ty <= h2 + 4 { vset_box(base, tx, ty, tz, 6, lx0, lx1, lz0, lz1); ty = ty + 1 }
              var lz: i64 = tz - 2
              while lz <= tz + 2 {
                  var lx: i64 = tx - 2
                  while lx <= tx + 2 {
                      var keep: i64 = 1
                      if lx == tx { if lz == tz { keep = 0 } }
                      if keep == 1 {
                          vset_box(base, lx, h2 + 4, lz, 7, lx0, lx1, lz0, lz1)
                          if lx >= tx - 1 { if lx <= tx + 1 { if lz >= tz - 1 { if lz <= tz + 1 {
                              vset_box(base, lx, h2 + 5, lz, 7, lx0, lx1, lz0, lz1)
                          } } } }
                      }
                      lx = lx + 1
                  }
                  lz = lz + 1
              }
              vset_box(base, tx, h2 + 6, tz, 7, lx0, lx1, lz0, lz1)
          }
          ax = ax + 1
      }
      az = az + 1
  }
  return 0
558}
559
560func genworld(base: i64, sd: i64) -> i64 {
  let s: *i64 = wst(base)
  var z: i64 = 0
  while z < WZ {
      var x: i64 = 0
      while x < WX {
          gencol(base, x, z, x + s[S_WOX], z + s[S_WOZ], sd)
          x = x + 1
      }
      z = z + 1
  }
  gentrees(base, 0, WX, 0, WZ, sd)
  return 0
573}
574
575// ---------- v6 STREAMING: slide the window one stride along x or z ----------
576// The world is unbounded; the arena is the cache. Order matters: move kept voxels -> bump the
577// origin -> regen the incoming strip from absolute coords -> repaint its trees -> overlay the
578// journal (edits WIN) -> translate every arena-space coordinate (player, spawn, mobs) -> rebuild
579// wmax -> invalidate the crosshair cache. One call = 16 blocks; ticks trigger it at the margins.
580func wc_shift(base: i64, dx: i64, dz: i64) -> i64 {
  let s: *i64 = wst(base)
  let v: *u8 = wvx(base)
  let sd: i64 = s[S_SEED]
  if dx != 0 {
      var y: i64 = 0
      while y < WY {
          var z: i64 = 0
          while z < WZ {
              let row: i64 = (y*WZ + z)*WX
              if dx > 0 {
                  var x: i64 = 0
                  while x < WX - dx { v[row + x] = v[row + x + dx]; x = x + 1 }
              } else {
                  var x2: i64 = WX - 1
                  while x2 >= 0 - dx { v[row + x2] = v[row + x2 + dx]; x2 = x2 - 1 }
              }
              z = z + 1
          }
          y = y + 1
      }
      s[S_WOX] = s[S_WOX] + dx
      var sx0: i64 = 0
      var sx1: i64 = 0 - dx
      if dx > 0 { sx0 = WX - dx; sx1 = WX }
      var rz: i64 = 0
      while rz < WZ {
          var rx: i64 = sx0
          while rx < sx1 { gencol(base, rx, rz, rx + s[S_WOX], rz + s[S_WOZ], sd); rx = rx + 1 }
          rz = rz + 1
      }
      gentrees(base, sx0, sx1, 0, WZ, sd)
      ej_overlay(base, sx0, sx1, 0, WZ)
  }
  if dz != 0 {
      var y2: i64 = 0
      while y2 < WY {
          let plane: i64 = y2*WZ*WX
          if dz > 0 {
              var z2: i64 = 0
              while z2 < WZ - dz {
                  let dstr: i64 = plane + z2*WX
                  let srcr: i64 = plane + (z2 + dz)*WX
                  var x3: i64 = 0
                  while x3 < WX { v[dstr + x3] = v[srcr + x3]; x3 = x3 + 1 }
                  z2 = z2 + 1
              }
          } else {
              var z3: i64 = WZ - 1
              while z3 >= 0 - dz {
                  let dstr2: i64 = plane + z3*WX
                  let srcr2: i64 = plane + (z3 + dz)*WX
                  var x4: i64 = 0
                  while x4 < WX { v[dstr2 + x4] = v[srcr2 + x4]; x4 = x4 + 1 }
                  z3 = z3 - 1
              }
          }
          y2 = y2 + 1
      }
      s[S_WOZ] = s[S_WOZ] + dz
      var sz0: i64 = 0
      var sz1: i64 = 0 - dz
      if dz > 0 { sz0 = WZ - dz; sz1 = WZ }
      var rz2: i64 = sz0
      while rz2 < sz1 {
          var rx2: i64 = 0
          while rx2 < WX { gencol(base, rx2, rz2, rx2 + s[S_WOX], rz2 + s[S_WOZ], sd); rx2 = rx2 + 1 }
          rz2 = rz2 + 1
      }
      gentrees(base, 0, WX, sz0, sz1, sd)
      ej_overlay(base, 0, WX, sz0, sz1)
  }
  // translate every arena-space coordinate by the slide
  s[S_CX] = s[S_CX] - dx*256
  s[S_CZ] = s[S_CZ] - dz*256
  s[S_SPX] = wclamp(s[S_SPX] - dx*256, 2*256, (WX - 2)*256)
  s[S_SPZ] = wclamp(s[S_SPZ] - dz*256, 2*256, (WZ - 2)*256)
  s[S_LBX] = s[S_LBX] - dx
  s[S_LBZ] = s[S_LBZ] - dz
  let m: *i64 = mobp(base)
  var k: i64 = 0
  while k < en_count(m) {
      let h: i64 = en_nth(m, k)
      en_set(m, h, MC_X, wclamp(en_get(m, h, MC_X) - dx*256, 2*256, (WX - 2)*256))
      en_set(m, h, MC_Z, wclamp(en_get(m, h, MC_Z) - dz*256, 2*256, (WZ - 2)*256))
      k = k + 1
  }
  wc_wmax(base)
  wc_soft_seat_all(base)                           // the world slid under every girl: re-seat springs
  s[S_HOK] = 0
  return 0
671}
672
673// ---------- DDA raycast ----------
674// marches from (S_CX,S_CY,S_CZ) along (dx,dy,dz) (any scale). On hit writes out[0..4] =
675// cellx,celly,cellz,face,tcross and returns the step count; returns -1 on miss (sky).
676// skipw=1 treats water as air (the transparency continuation ray). The voxel read is INLINED --
677// this loop runs ~2-8M times a second and a per-step call was the measured overhead.
678func wray2(base: i64, dx: i64, dy: i64, dz: i64, maxsteps: i64, out: *i64, skipw: i64) -> i64 {
  let s: *i64 = wst(base)
  var cxq: i64 = s[S_CX]
  var cyq: i64 = s[S_CY]
  var czq: i64 = s[S_CZ]
  var cellx: i64 = cxq >> 8
  var celly: i64 = cyq >> 8
  var cellz: i64 = czq >> 8
  let HUGE: i64 = WATER_MAGIC_1099511627776
  var stpx: i64 = 1
  if dx < 0 { stpx = 0-1 }
  var stpy: i64 = 1
  if dy < 0 { stpy = 0-1 }
  var stpz: i64 = 1
  if dz < 0 { stpz = 0-1 }
  // t units: pos_q8(t) = pos + d*t/65536; crossing one cell on axis c costs 256*65536/|dc|
  var tdx: i64 = HUGE
  if dx != 0 { tdx = 256*WATER_MAGIC_65536 / dx; if tdx < 0 { tdx = 0 - tdx } }
  var tdy: i64 = HUGE
  if dy != 0 { tdy = 256*WATER_MAGIC_65536 / dy; if tdy < 0 { tdy = 0 - tdy } }
  var tdz: i64 = HUGE
  if dz != 0 { tdz = 256*WATER_MAGIC_65536 / dz; if tdz < 0 { tdz = 0 - tdz } }
  var bx: i64 = (cellx << 8) - cxq                 // distance to boundary, Q8 (negative side)
  if stpx == 1 { bx = bx + 256 }
  var tmx: i64 = HUGE
  if dx != 0 { tmx = bx*WATER_MAGIC_65536 / dx; if tmx < 0 { tmx = 0 - tmx } }
  var by: i64 = (celly << 8) - cyq
  if stpy == 1 { by = by + 256 }
  var tmy: i64 = HUGE
  if dy != 0 { tmy = by*WATER_MAGIC_65536 / dy; if tmy < 0 { tmy = 0 - tmy } }
  var bz: i64 = (cellz << 8) - czq
  if stpz == 1 { bz = bz + 256 }
  var tmz: i64 = HUGE
  if dz != 0 { tmz = bz*WATER_MAGIC_65536 / dz; if tmz < 0 { tmz = 0 - tmz } }
  let vxp: *u8 = (base + O_VOX) as *u8
  var step: i64 = 0
  while step < maxsteps {
      var face: i64 = 0
      var tcross: i64 = 0
      if tmx <= tmy { if tmx <= tmz {
          cellx = cellx + stpx
          tcross = tmx
          tmx = tmx + tdx
          face = 1
          if stpx == 1 { face = 2 }                // stepped +x => hit the -x... face 2 = west-lit
      } }
      if face == 0 { if tmy <= tmz {
          celly = celly + stpy
          tcross = tmy
          tmy = tmy + tdy
          face = 3
          if stpy == 1 { face = 4 }                // stepped up => hit the block's bottom
      } }
      if face == 0 {
          cellz = cellz + stpz
          tcross = tmz
          tmz = tmz + tdz
          face = 5
          if stpz == 1 { face = 6 }
      }
      if celly >= WY { if stpy >= 0 { return 0 - 1 } }   // heading skyward above the world
      if celly > s[S_WMAX] { if stpy >= 0 { return 0 - 1 } }   // above every solid block, not diving
      if cellx < 0-8 { return 0 - 1 }
      if cellx > WX+8 { return 0 - 1 }
      if cellz < 0-8 { return 0 - 1 }
      if cellz > WZ+8 { return 0 - 1 }
      if celly < 0 { return 0 - 1 }
      var b: i64 = 0
      if cellx >= 0 { if cellx < WX { if celly < WY { if cellz >= 0 { if cellz < WZ {
          b = (vxp[(celly*WZ + cellz)*WX + cellx] & 0xff) as i64
      } } } } }
      if skipw == 1 { if b == 4 { b = 0 } }
      if b != 0 {
          out[0] = cellx
          out[1] = celly
          out[2] = cellz
          out[3] = face
          out[4] = tcross                          // crossing t: hit point = pos + d*t/WATER_MAGIC_65536 (Q8)
          return step + 1
      }
      step = step + 1
  }
  return 0 - 1
761}
762
763func wray(base: i64, dx: i64, dy: i64, dz: i64, maxsteps: i64, out: *i64) -> i64 {
  return wray2(base, dx, dy, dz, maxsteps, out, 0)
765}
766
767// block base colour -- from the SPEC PALETTE (the game's look is data, not code)
768func wcol(base: i64, b: i64) -> i64 {
  if b < 0 { return wpack(255, 0, 255) }
  if b >= 12 { if b <= 16 { return wsp(base)[P_PAL2 + b - 12] } }
  if b > 16 { return wpack(255, 0, 255) }
  if b > 11 { return wpack(255, 0, 255) }
  return wsp(base)[P_PAL + b]
774}
775// hotbar slot -> placeable block type
776func sel_block(sel: i64) -> i64 {
  if sel == 1 { return 2 }                         // dirt
  if sel == 2 { return 6 }                         // wood
  if sel == 3 { return 7 }                         // leaves
  if sel == 4 { return 5 }                         // sand
  if sel == 5 { return B_FARM }                    // the HOE: tills the targeted grass/dirt top
  if sel == 6 { return B_CROP0 }                   // SEEDS: plant onto farmland
  return 3                                         // stone
784}
785// face brightness permil: top lit, bottom dark, x/z sides distinct so edges READ as 3d
786func wface_l(face: i64) -> i64 {
  if face == 3 { return 1000 }
  if face == 4 { return 420 }
  if face == 1 { return 760 }
  if face == 2 { return 700 }
  if face == 5 { return 620 }
  return 560
793}
794func wsky(base: i64, syy: i64) -> i64 {
  let sp: *i64 = wsp(base)
  let hor: i64 = sp[P_SKYHOR]
  let top: i64 = sp[P_SKYTOP]
  let t: i64 = wclamp(syy + RH/2, 0, RH)           // 0 bottom .. RH top
  let r: i64 = (hor & 255) + ((top & 255) - (hor & 255))*t/RH
  let g: i64 = ((hor >> 8) & 255) + (((top >> 8) & 255) - ((hor >> 8) & 255))*t/RH
  let b: i64 = ((hor >> 16) & 255) + (((top >> 16) & 255) - ((hor >> 16) & 255))*t/RH
  return wpack(r, g, b)
803}
804// clouds: a flat noise plane above the world, sampled where an upward ray crosses it, slowly
805// drifting with time. Returns 0..255 coverage for blending into the sky.
806func wcloud(camx: i64, camy: i64, camz: i64, dx: i64, dy: i64, dz: i64, t: i64) -> i64 {
  if dy < 40 { return 0 }
  let plane: i64 = 56*256                          // cloud deck above the 48-high world
  let tq: i64 = (plane - camy)*WATER_MAGIC_65536/dy
  if tq <= 0 { return 0 }
  let cx: i64 = (camx + dx*tq/WATER_MAGIC_65536) >> 9          // 2-block cloud texels
  let cz: i64 = (camz + dz*tq/WATER_MAGIC_65536) >> 9
  let n: i64 = wnoise(cx + t/40, cz + t/90, 6, 777)
  if n < 148 { return 0 }
  var cov: i64 = (n - 148)*255/60
  if cov > 235 { cov = 235 }
  return cov
818}
819// sky with a SUN: disc + glow around the sun's projected ray-pixel position (sunon=0 -> plain sky)
820func wsky2(base: i64, syy: i64, px: i64, py: i64, sunx: i64, suny: i64, sunon: i64) -> i64 {
  let base2: i64 = wsky(base, syy)
  if sunon == 0 { return base2 }
  let ddx: i64 = px - sunx
  let ddy: i64 = py - suny
  let d2: i64 = ddx*ddx + ddy*ddy
  if d2 < 36 { return wpack(255, 250, 224) }        // the disc
  if d2 < 900 {                                     // the glow
      let w2: i64 = 255 - d2*255/900
      var r: i64 = (base2 & 255) + (255 - (base2 & 255))*w2/300
      var g: i64 = ((base2 >> 8) & 255) + (250 - ((base2 >> 8) & 255))*w2/340
      var b: i64 = ((base2 >> 16) & 255) + (224 - ((base2 >> 16) & 255))*w2/460
      return wpack(wclamp(r,0,255), wclamp(g,0,255), wclamp(b,0,255))
  }
  // ordered 2x2 dither breaks the gradient banding lines
  if ((px ^ py) & 1) == 1 {
      return wpack(wclamp((base2 & 255) + 2, 0, 255), wclamp(((base2 >> 8) & 255) + 2, 0, 255), wclamp(((base2 >> 16) & 255) + 2, 0, 255))
  }
  return base2
839}
840// textured face shading: per-texel hash variation from the HIT POINT's in-face UV (Q8 fractions),
841// per-type character (wood grain, leaf speckle, water shimmer, ore mottle), edge BEVEL so the
842// block grid reads crisply, then face light and step fog. All integer, all deterministic.
843// corner AO: darken a face edge when a solid block sits beside it in the face's outward layer --
844// the classic soft-corner cue that makes voxel scenes read as lit geometry instead of flat tiles
845func wao(base: i64, cx2: i64, cy2b: i64, cz2: i64, face: i64, u: i64, v: i64) -> i64 {
  var ox2: i64 = cx2
  var oy2: i64 = cy2b
  var oz2: i64 = cz2
  if face == 1 { ox2 = ox2 + 1 }
  if face == 2 { ox2 = ox2 - 1 }
  if face == 3 { oy2 = oy2 + 1 }
  if face == 4 { oy2 = oy2 - 1 }
  if face == 5 { oz2 = oz2 + 1 }
  if face == 6 { oz2 = oz2 - 1 }
  var ao: i64 = 0
  // u-axis neighbours (u maps to x on y/z faces, to z on x faces)
  if u < 44 {
      var hit1: i64 = 0
      if face == 1 { hit1 = vsolid(base, ox2, oy2, oz2 - 1) }
      if face == 2 { hit1 = vsolid(base, ox2, oy2, oz2 - 1) }
      if face == 3 { hit1 = vsolid(base, ox2 - 1, oy2, oz2) }
      if face == 4 { hit1 = vsolid(base, ox2 - 1, oy2, oz2) }
      if face == 5 { hit1 = vsolid(base, ox2 - 1, oy2, oz2) }
      if face == 6 { hit1 = vsolid(base, ox2 - 1, oy2, oz2) }
      if hit1 == 1 { ao = ao + (44 - u)*30/44 }
  }
  if u > 211 {
      var hit2: i64 = 0
      if face == 1 { hit2 = vsolid(base, ox2, oy2, oz2 + 1) }
      if face == 2 { hit2 = vsolid(base, ox2, oy2, oz2 + 1) }
      if face == 3 { hit2 = vsolid(base, ox2 + 1, oy2, oz2) }
      if face == 4 { hit2 = vsolid(base, ox2 + 1, oy2, oz2) }
      if face == 5 { hit2 = vsolid(base, ox2 + 1, oy2, oz2) }
      if face == 6 { hit2 = vsolid(base, ox2 + 1, oy2, oz2) }
      if hit2 == 1 { ao = ao + (u - 211)*30/44 }
  }
  // v-axis neighbours (v maps to z on top/bottom faces, to y on side faces)
  if v < 44 {
      var hit3: i64 = 0
      if face == 3 { hit3 = vsolid(base, ox2, oy2, oz2 - 1) }
      if face == 4 { hit3 = vsolid(base, ox2, oy2, oz2 - 1) }
      if face == 1 { hit3 = vsolid(base, ox2, oy2 - 1, oz2) }
      if face == 2 { hit3 = vsolid(base, ox2, oy2 - 1, oz2) }
      if face == 5 { hit3 = vsolid(base, ox2, oy2 - 1, oz2) }
      if face == 6 { hit3 = vsolid(base, ox2, oy2 - 1, oz2) }
      if hit3 == 1 { ao = ao + (44 - v)*30/44 }
  }
  if v > 211 {
      var hit4: i64 = 0
      if face == 3 { hit4 = vsolid(base, ox2, oy2, oz2 + 1) }
      if face == 4 { hit4 = vsolid(base, ox2, oy2, oz2 + 1) }
      if face == 1 { hit4 = vsolid(base, ox2, oy2 + 1, oz2) }
      if face == 2 { hit4 = vsolid(base, ox2, oy2 + 1, oz2) }
      if face == 5 { hit4 = vsolid(base, ox2, oy2 + 1, oz2) }
      if face == 6 { hit4 = vsolid(base, ox2, oy2 + 1, oz2) }
      if hit4 == 1 { ao = ao + (v - 211)*30/44 }
  }
  if ao > 45 { ao = 45 }
  return ao
900}
901func wshade2(base: i64, b0: i64, face: i64, steps: i64, syy: i64, hpx: i64, hpy: i64, hpz: i64, t2: i64, clx: i64, cly: i64, clz: i64) -> i64 {
  var u: i64 = hpx & 255
  var v: i64 = hpz & 255
  if face == 1 { u = hpz & 255; v = hpy & 255 }
  if face == 2 { u = hpz & 255; v = hpy & 255 }
  if face == 5 { u = hpx & 255; v = hpy & 255 }
  if face == 6 { u = hpx & 255; v = hpy & 255 }
  // grass block SIDES are dirt with a grass strip at the top edge (the classic block identity)
  var b: i64 = b0
  if b0 == 1 { if face != 3 { if face != 4 {
      b = 2
      if v > 206 { b = 1 }
  } } }
  var tex: i64 = 0
  if b == 6 {                                       // wood: vertical grain stripes
      tex = whash(u/12 + (hpx >> 8)*7 + (hpz >> 8)*13, 3, 99) % 256
  }
  if b != 6 {
      var amp: i64 = 70
      if b == 1 { amp = 95 }
      if b == 2 { amp = 85 }
      if b == 7 { amp = 130 }
      if b == 5 { amp = 55 }
      var us: i64 = u/16
      var vs: i64 = v/16
      if b == 4 {                                   // water: time-drifted shimmer
          us = us + t2/3
          vs = vs - t2/5
          amp = 110
      }
      tex = whash(us + (hpx >> 8)*31, vs + (hpy >> 8)*17 + (hpz >> 8)*7, b*131) % 256
      tex = 128 + (tex - 128)*amp/130
  }
  var light: i64 = wface_l(face)
  // sun-directional face light (sun worlds only): east faces catch it, west faces shadow
  if wsp(base)[P_SUN] == 1 {
      if face == 1 { light = light*112/100 }
      if face == 2 { light = light*92/100 }
      if face == 5 { light = light*104/100 }
  }
  light = light*(870 + tex*260/256)/1000
  if u < 14 { light = light*82/100 }                // edge bevel: the block grid
  if u > 241 { light = light*82/100 }
  if v < 14 { light = light*82/100 }
  if v > 241 { light = light*82/100 }
  let ao2: i64 = wao(base, clx, cly, clz, face, u, v)
  if ao2 > 0 { light = light*(100 - ao2)/100 }      // soft corners where geometry meets
  let c: i64 = wcol(base, b)
  var r: i64 = (c & 255) * light / 1000
  var g: i64 = ((c >> 8) & 255) * light / 1000
  var bl: i64 = ((c >> 16) & 255) * light / 1000
  let sk: i64 = wsky(base, syy)
  var fog: i64 = steps*280/MAXSTEPS
  if fog > 236 { fog = 236 }
  r = r + ((sk & 255) - r)*fog/256
  g = g + (((sk >> 8) & 255) - g)*fog/256
  bl = bl + (((sk >> 16) & 255) - bl)*fog/256
  return wpack(wclamp(r,0,255), wclamp(g,0,255), wclamp(bl,0,255))
959}
960
961// THE GAME SPEC WRITER -- two complete game identities as DATA over one engine.
962// v0 = NISHI CRAFT (sunlit overworld). v1 = NISHI DEPTHS (twilight cavern plateau: no sun/clouds/
963// trees, ember horizon, vast cave nets, mossy basalt, glowing ores and glow-mobs).
964func wc_spec(base: i64, v: i64) -> i64 {
  let sp: *i64 = wsp(base)
  var k: i64 = 0
  while k < 64 { sp[k] = 0; k = k + 1 }
  if v == 3 {
      // v3 = NISHI VALE, the MEDIEVAL VILLAGE: rolling green highland, deep woods, cold
      // snowline, cave-riddled stone. THIRD WORLD, ZERO ENGINE CODE -- the recombination
      // claim at n=3. Wardens run wide here (P_WARD), so a traveler arrives to REAL stakes.
      sp[P_TBASE] = 8
      sp[P_TAMP1] = 22
      sp[P_TAMP2] = 7
      sp[P_WATER] = 7
      sp[P_SNOW] = 26
      sp[P_TREE] = 11                              // deep woods, tuned to the PUBLISHED
                                                   // 500-800 trees/ha band -- 19 measured 372/ha,
                                                   // barely half a real forest (T53; ported from
                                                   // the laptop line 2026-08-02, same fork as
                                                   // P_HISTAGE -- the fix existed and never landed)
      sp[P_TREEMAX] = 25                           // woods climb to the snowline here
      sp[P_HISTAGE] = 0                            // MEASURED, not assumed: symmetric value-
                                                   // noise yields HI ~594 permil = mature
      sp[P_CAVETH] = 168                           // more cavern than craft's 182
      sp[P_SKYTOP] = wpack(86, 122, 176)
      sp[P_SKYHOR] = wpack(196, 200, 206)
      sp[P_SUN] = 1
      sp[P_CLOUD] = 1
      sp[P_PAL + 1] = wpack(72, 124, 56)           // highland grass
      sp[P_PAL + 2] = wpack(94, 72, 50)            // loam
      sp[P_PAL + 3] = wpack(118, 116, 120)         // quarry stone
      sp[P_PAL + 4] = wpack(44, 82, 140)           // cold water
      sp[P_PAL + 5] = wpack(190, 178, 150)         // riverbank
      sp[P_PAL + 6] = wpack(88, 62, 36)            // timber
      sp[P_PAL + 7] = wpack(40, 96, 44)            // dark canopy
      sp[P_PAL + 8] = wpack(238, 240, 246)         // snow
      sp[P_PAL + 9] = wpack(66, 66, 72)
      sp[P_PAL + 10] = wpack(176, 142, 118)
      sp[P_PAL + 11] = wpack(224, 188, 92)
      sp[P_MOBC + 0] = wpack(206, 160, 96)
      sp[P_MOBC + 1] = wpack(160, 118, 62)
      sp[P_MOBC + 2] = wpack(120, 158, 190)
      sp[P_MOBC + 3] = wpack(78, 110, 146)
      sp[P_MOBC + 4] = wpack(178, 120, 160)
      sp[P_MOBC + 5] = wpack(134, 86, 122)
      sp[P_PAL2 + 0] = wpack(88, 60, 38)
      sp[P_PAL2 + 1] = wpack(120, 186, 90)
      sp[P_PAL2 + 2] = wpack(92, 168, 58)
      sp[P_PAL2 + 3] = wpack(230, 200, 82)
      sp[P_PAL2 + 4] = wpack(58, 42, 30)
      sp[P_DAYLEN] = 72000
      sp[P_SEASD] = 3
      sp[P_GROWE] = 2400
      sp[P_GROWW] = 5                              // a harder land: crops take longer
      sp[P_GROWD] = 1
      sp[P_RAINS + 0] = 420                        // wet spring
      sp[P_RAINS + 1] = 220
      sp[P_RAINS + 2] = 380
      sp[P_RAINS + 3] = 180
      sp[P_ADV + 0] = (B_CROP2 << 16) | 9
      sp[P_ADV + 1] = (1 << 16) | 3
      sp[P_ADV + 2] = (4 << 16) | (2 << 8) | 2
      sp[P_CURI] = 400
      sp[P_OUTFIT] = 0
      sp[P_WARD] = 20                              // wardens hunt from 20 blocks by DAY here
      return 0
  }
  if v == 2 {
      // v2 = NISHI SHORE, the REVIEW STAGE (operator 2026-08-02): near-flat warm sand, a
      // sea, no trees/caves/snow -- body and sprite rendering judged WITHOUT environment
      // distraction, with the outfit dimension ACTIVE (mixed beach). One engine, one more
      // identity: this whole world is 30 data rows, which IS the recombination claim.
      sp[P_TBASE] = 11
      sp[P_TAMP1] = 2
      sp[P_TAMP2] = 1
      sp[P_WATER] = 9
      sp[P_SNOW] = 99
      sp[P_TREE] = 0
      sp[P_CAVETH] = 255
      sp[P_SKYTOP] = wpack(110, 168, 230)
      sp[P_SKYHOR] = wpack(214, 226, 240)
      sp[P_SUN] = 1
      sp[P_CLOUD] = 1
      sp[P_PAL + 1] = wpack(226, 204, 148)         // shore sand (the "grass" slot)
      sp[P_PAL + 2] = wpack(206, 180, 128)         // packed sand
      sp[P_PAL + 3] = wpack(180, 170, 158)         // beach rock
      sp[P_PAL + 4] = wpack(56, 140, 196)          // warm sea
      sp[P_PAL + 5] = wpack(232, 214, 160)         // dry sand
      sp[P_PAL + 6] = wpack(150, 110, 70)          // driftwood
      sp[P_PAL + 7] = wpack(96, 150, 96)           // beach scrub
      sp[P_PAL + 8] = wpack(240, 240, 244)
      sp[P_PAL + 9] = wpack(120, 116, 110)
      sp[P_PAL + 10] = wpack(176, 142, 118)
      sp[P_PAL + 11] = wpack(224, 188, 92)
      sp[P_MOBC + 0] = wpack(240, 178, 84)
      sp[P_MOBC + 1] = wpack(196, 138, 56)
      sp[P_MOBC + 2] = wpack(96, 206, 196)
      sp[P_MOBC + 3] = wpack(64, 158, 150)
      sp[P_MOBC + 4] = wpack(238, 138, 186)
      sp[P_MOBC + 5] = wpack(190, 100, 144)
      sp[P_PAL2 + 0] = wpack(94, 64, 40)
      sp[P_PAL2 + 1] = wpack(120, 186, 90)
      sp[P_PAL2 + 2] = wpack(92, 168, 58)
      sp[P_PAL2 + 3] = wpack(230, 200, 82)
      sp[P_PAL2 + 4] = wpack(64, 46, 32)
      sp[P_DAYLEN] = 72000
      sp[P_SEASD] = 3
      sp[P_GROWE] = 2400
      sp[P_GROWW] = 6
      sp[P_GROWD] = 1
      sp[P_RAINS + 0] = 60                         // a review stage stays mostly sunny
      sp[P_RAINS + 1] = 40
      sp[P_RAINS + 2] = 60
      sp[P_RAINS + 3] = 40
      sp[P_ADV + 0] = (4 << 16) | (2 << 8) | 4     // the water's edge is the gathering place
      sp[P_ADV + 1] = (1 << 16) | 3
      sp[P_CURI] = 350
      sp[P_OUTFIT] = 1
      return 0
  }
  // FARMING-LIFE rows, shared by every identity (the loop itself is identity-independent DATA)
  sp[P_PAL2 + 0] = wpack(94, 64, 40)               // tilled farmland, dry
  sp[P_PAL2 + 1] = wpack(120, 186, 90)             // crop sprout
  sp[P_PAL2 + 2] = wpack(92, 168, 58)              // crop growing
  sp[P_PAL2 + 3] = wpack(230, 200, 82)             // crop MATURE (reads golden at a glance)
  sp[P_PAL2 + 4] = wpack(64, 46, 32)               // farmland wet (soaked dark soil)
  sp[P_DAYLEN] = 72000                             // 20 real minutes at the fixed 60Hz sim
                                                   // tick -- the shipped-sim benchmark band
                                                   // (Minecraft 20:00/day, Stardew 14:33,
                                                   // Vintage Story ~24:00): a day you can
                                                   // farm INSIDE, not a light show
  sp[P_SEASD] = 3
  sp[P_GROWE] = 2400                               // one growth/hydration roll per farm cell
                                                   // per ~40s -- Minecraft's random-tick
                                                   // cadence (~47s/block avg) on our grid;
                                                   // wet stencil den=5 => a watered crop
                                                   // matures in ~6.7 min =~ 1/3 day (the
                                                   // Minecraft wheat band)
  sp[P_GROWW] = 6
  sp[P_GROWD] = 1
  sp[P_RAINS + 0] = 340                            // spring
  sp[P_RAINS + 1] = 180                            // summer
  sp[P_RAINS + 2] = 300                            // autumn
  sp[P_RAINS + 3] = 120                            // winter
  sp[P_ADV + 0] = (B_CROP2 << 16) | 9              // a mature field draws foragers (need 0 = hunger)
  sp[P_ADV + 1] = (1 << 16) | 3                    // grass meadow: light grazing
  sp[P_ADV + 2] = (4 << 16) | (2 << 8) | 2         // water's edge: where girls gather to talk
  sp[P_CURI] = 350
  if v == 1 {
      sp[P_TBASE] = 22
      sp[P_TAMP1] = 8
      sp[P_TAMP2] = 4
      sp[P_WATER] = 5
      sp[P_SNOW] = 99
      sp[P_TREE] = 0
      sp[P_CAVETH] = 148
      sp[P_SKYTOP] = wpack(28, 22, 40)
      sp[P_SKYHOR] = wpack(96, 48, 40)
      sp[P_SUN] = 0
      sp[P_CLOUD] = 0
      sp[P_PAL + 1] = wpack(74, 122, 84)           // moss
      sp[P_PAL + 2] = wpack(88, 62, 48)            // packed earth
      sp[P_PAL + 3] = wpack(98, 90, 104)           // basalt
      sp[P_PAL + 4] = wpack(60, 190, 180)          // glow-water
      sp[P_PAL + 5] = wpack(120, 100, 80)
      sp[P_PAL + 6] = wpack(70, 50, 36)
      sp[P_PAL + 7] = wpack(60, 90, 60)
      sp[P_PAL + 8] = wpack(200, 200, 210)
      sp[P_PAL + 9] = wpack(58, 58, 66)
      sp[P_PAL + 10] = wpack(198, 150, 116)
      sp[P_PAL + 11] = wpack(255, 206, 96)         // gold veins GLOW down here
      sp[P_MOBC + 0] = wpack(255, 128, 64)         // ember
      sp[P_MOBC + 1] = wpack(200, 84, 40)
      sp[P_MOBC + 2] = wpack(124, 220, 255)        // ice-glow
      sp[P_MOBC + 3] = wpack(80, 160, 200)
      sp[P_MOBC + 4] = wpack(204, 124, 255)        // violet
      sp[P_MOBC + 5] = wpack(150, 84, 200)
      return 0
  }
  sp[P_TBASE] = 4
  sp[P_TAMP1] = 17
  sp[P_TAMP2] = 5
  sp[P_WATER] = 9
  sp[P_SNOW] = 20
  sp[P_TREE] = 43
  sp[P_CAVETH] = 182
  sp[P_SKYTOP] = wpack(98, 152, 223)
  sp[P_SKYHOR] = wpack(168, 206, 245)
  sp[P_SUN] = 1
  sp[P_CLOUD] = 1
  sp[P_PAL + 1] = wpack(84, 158, 62)               // grass
  sp[P_PAL + 2] = wpack(122, 86, 56)               // dirt
  sp[P_PAL + 3] = wpack(126, 126, 132)             // stone
  sp[P_PAL + 4] = wpack(52, 96, 190)               // water
  sp[P_PAL + 5] = wpack(206, 190, 132)             // sand
  sp[P_PAL + 6] = wpack(104, 74, 40)               // wood
  sp[P_PAL + 7] = wpack(52, 122, 44)               // leaves
  sp[P_PAL + 8] = wpack(232, 238, 244)             // snow
  sp[P_PAL + 9] = wpack(72, 74, 80)                // coal
  sp[P_PAL + 10] = wpack(176, 142, 118)            // iron
  sp[P_PAL + 11] = wpack(224, 188, 92)             // gold
  sp[P_MOBC + 0] = wpack(240, 178, 84)
  sp[P_MOBC + 1] = wpack(196, 138, 56)
  sp[P_MOBC + 2] = wpack(96, 206, 196)
  sp[P_MOBC + 3] = wpack(64, 158, 150)
  sp[P_MOBC + 4] = wpack(238, 138, 186)
  sp[P_MOBC + 5] = wpack(190, 100, 144)
  return 0
1170}
1171
1172// mobs: 12 creatures spawned on grass, deterministic, through the CERTIFIED entity store
1173// (handle = index+generation, stale-handle-proof by construction -- the part's gate owns that claim)
1174func genmobs(base: i64, sd: i64) -> i64 {
  let m: *i64 = mobp(base)
  en_init(m, MOB_CAP, MOB_NCOMP)
  var i: i64 = 0
  var placed: i64 = 0
  while i < 200 {
      if placed < 12 {
          let mx: i64 = 4 + whash(i*13 + 5, i*7 + 1, sd + 400) % (WX - 8)
          let mz: i64 = 4 + whash(i*17 + 3, i*29 + 9, sd + 500) % (WZ - 8)
          let h: i64 = wheight(base, mx, mz, sd)
          if h < wsp(base)[P_SNOW] - 1 { if vget(base, mx, h, mz) == 1 {
              let hd: i64 = en_spawn(m)
              if hd > 0 {
                  en_set(m, hd, MC_X, mx*256 + 128)
                  en_set(m, hd, MC_Y, (h + 1)*256)
                  en_set(m, hd, MC_Z, mz*256 + 128)
                  en_set(m, hd, MC_KIND, whash(mx, mz, sd + 600) % 3)
                  en_set(m, hd, MC_PH, whash(mz, mx, sd + 700) % WATER_MAGIC_4096)
                  var dg: i64 = 0
                  if whash(mx + 13, mz + 7, sd + 800) % 3 == 0 { dg = 1 }
                  en_set(m, hd, MC_DISG, dg)
                  let g1: i64 = whash(mx*3 + 1, mz*5 + 9, sd + 900)
                  let g2: i64 = whash(mz*7 + 3, mx*11 + 5, sd + 901)
                  en_set(m, hd, MC_GENE, (g1*WATER_MAGIC_4096 + g2*16) % WATER_MAGIC_1048576)
                  placed = placed + 1
              }
          } }
      }
      i = i + 1
  }
  return placed
1205}
1206
1207// ---------- init / tick / render ----------
1208func init_impl_v(base: i64, v: i64, seed: i64) -> i64 {
  wc_spec(base, v)
  let s: *i64 = wst(base)
  var k: i64 = 0
  while k < 64 { s[k] = 0; k = k + 1 }
  let ej0: *i64 = ejp(base)
  var kj: i64 = 0
  while kj < EJRN_SLOTS { ej0[kj] = 0; kj = kj + 1 }
  s[S_SEED] = seed
  s[S_VAR] = v                                     // after the zero loop -- an earlier set
                                                   // here was wiped (the zero-loop-order class)
  s[S_T] = wsp(base)[P_DAYLEN]/4                   // first frame = MID-MORNING light (the
                                                   // visitor's first impression; a dawn-dark
                                                   // spawn read as night, screenshot-caught)
  genworld(base, seed)
  wc_wmax(base)
  genmobs(base, seed)
  // A4/C1: zero the spring + need regions (init may reuse a dirty arena), then seat and seed
  let sb0i: *i64 = (base + O_SOFT) as *i64
  var kzi: i64 = 0
  while kzi < MOB_CAP*SB_PTS*SD_STRIDE { sb0i[kzi] = 0; kzi = kzi + 1 }
  let nd0i: *i64 = (base + O_NEED) as *i64
  var kni: i64 = 0
  while kni < MOB_CAP*4 { nd0i[kni] = 0; kni = kni + 1 }
  wc_soft_seat_all(base)
  wc_need_seed(base)
  wc_mind_zero(base)
  // spawn on the TALLEST central column: from a local peak every direction is a vista,
  // never a cliff wall filling the first frame (the eyeball found exactly that)
  var sx: i64 = WX/2
  var sz: i64 = WZ/2
  var sh: i64 = 0
  var qz: i64 = WZ/2 - 12
  while qz < WZ/2 + 12 {
      var qx: i64 = WX/2 - 12
      while qx < WX/2 + 12 {
          let qh: i64 = wheight(base, qx, qz, seed)
          if qh > sh { sh = qh; sx = qx; sz = qz }
          qx = qx + 1
      }
      qz = qz + 1
  }
  s[S_CX] = sx*256 + 128
  s[S_CZ] = sz*256 + 128
  s[S_CY] = (sh + 1)*256 + EYE
  s[S_SPX] = s[S_CX]
  s[S_SPY] = s[S_CY]
  s[S_SPZ] = s[S_CZ]
  s[S_YAW] = 0
  s[S_PITCH] = 0
  s[S_Q] = 2
  ia_init(winp(base))
  ia_bind(winp(base), 82, IA_LUP)                  // R = look up (real action bits since seq1136)
  ia_bind(winp(base), 70, IA_LDOWN)                // F = look down (G = party invite, below)
  ia_bind(winp(base), 32, IA_JUMP)                 // space = jump (touch center zone jumps too)
  ia_bind(winp(base), 81, IA_MOD)                  // Q = cycle the hotbar selection
  ia_bind(winp(base), 72, IA_HOME)                 // H = return to spawn (edge-fall rescue)
  return 0
1266}
1267func init_impl(base: i64, seed: i64) -> i64 { return init_impl_v(base, 0, seed) }
1268
1269// return to spawn: position + velocity reset, world untouched (the operator's reset button)
1270func wc_respawn(base: i64) -> i64 {
  let s: *i64 = wst(base)
  s[S_CX] = s[S_SPX]
  s[S_CY] = s[S_SPY]
  s[S_CZ] = s[S_SPZ]
  s[S_VY] = 0
  s[S_GROUNDED] = 1
  return 0
1278}
1279
1280// highest solid y at a column (collision floor), -1 if none
1281func wground(base: i64, x: i64, z: i64) -> i64 {
  var y: i64 = WY - 1
  while y >= 0 {
      if vsolid(base, x, y, z) == 1 { return y }
      y = y - 1
  }
  return 0 - 1
1288}
1289
1290// try to stand at (nxq, nzq): returns the required cam y (Q8) or -1 if the move is blocked
1291func wstand(base: i64, nxq: i64, nzq: i64, cyq: i64) -> i64 {
  let g: i64 = wground(base, nxq >> 8, nzq >> 8)
  var stand: i64 = (g + 1)*256 + EYE
  let wl2: i64 = wsp(base)[P_WATER]
  let wsurf: i64 = (wl2 + 1)*256 + EYE - 96        // float slightly sunk in water
  if stand < wsurf { if vget(base, nxq >> 8, wl2, nzq >> 8) == 4 { stand = wsurf } }
  // VOID COLUMN = WALL: no ground below means off the world's edge -- refuse the step (the
  // walk-off-and-vanish bug: wstand happily computed a hover height over nothing)
  if g < 0 { return 0 - 1 }
  if stand - cyq > 384 { return 0 - 1 }            // more than a 1.5-block rise = wall
  let heady: i64 = (stand + 128) >> 8
  if vsolid(base, nxq >> 8, heady, nzq >> 8) == 1 { return 0 - 1 }
  return stand
1304}
1305
1306// stand height for the CURRENT column (no wall refusal -- the vertical-physics target)
1307func wstand_here(base: i64, xq: i64, zq: i64) -> i64 {
  let g: i64 = wground(base, xq >> 8, zq >> 8)
  var stand: i64 = (g + 1)*256 + EYE
  let wl3: i64 = wsp(base)[P_WATER]
  let wsurf: i64 = (wl3 + 1)*256 + EYE - 96
  if stand < wsurf { if vget(base, xq >> 8, wl3, zq >> 8) == 4 { stand = wsurf } }
  return stand
1314}
1315
1316// mob floor: first solid scanning DOWN from just above the mob's feet -- wground scans from the
1317// SKY and reads an overhanging leaf canopy as "ground 5 blocks up", which froze every mob under a
1318// tree (measured: phase advanced 982/tick = the refusal branch, position never moved).
1319// body clearance: a girl is ~2 blocks tall -- the two cells above the ground must be AIR or
1320// she stands with her head/shoulders inside an overhang (invisible as SDF; as a MESH her
1321// buried parts discard and the poking limbs read as floating shards -- operator-reported).
1322func mob_fits(base: i64, x: i64, g: i64, z: i64) -> i64 {
  if vsolid(base, x, g + 1, z) == 1 { return 0 }
  if vsolid(base, x, g + 2, z) == 1 { return 0 }
  return 1
1326}
1327
1328func mob_ground(base: i64, x: i64, ytop: i64, z: i64) -> i64 {
  var y: i64 = ytop
  if y > WY - 1 { y = WY - 1 }
  while y >= 0 {
      if vsolid(base, x, y, z) == 1 { return y }
      y = y - 1
  }
  return 0 - 1
1336}
1337
1338// NPC HIT DETECTION: march the view ray in half-block samples up to 7 blocks; a solid voxel
1339// blocks it (walls occlude, real detection); a sample inside a girl's body cylinder (r=.35,
1340// h=1.7) targets her. Returns the dense index or -1. The same pass PUSHES the player out of
1341// bodies (they have PRESENCE now -- no more walking through people).
1342func npc_pick(base: i64, fx: i64, fy: i64, fz: i64) -> i64 {
  let s: *i64 = wst(base)
  let m: *i64 = mobp(base)
  var t: i64 = 1
  while t <= 14 {
      let px2: i64 = s[S_CX] + fx*t*128/WATER_MAGIC_4096
      let py2: i64 = s[S_CY] + fy*t*128/WATER_MAGIC_4096
      let pz2: i64 = s[S_CZ] + fz*t*128/WATER_MAGIC_4096
      if vsolid(base, px2 >> 8, py2 >> 8, pz2 >> 8) == 1 { return 0 - 1 }
      var k: i64 = 0
      while k < en_count(m) {
          let h: i64 = en_nth(m, k)
          var ddx: i64 = px2 - en_get(m, h, MC_X)
          if ddx < 0 { ddx = 0 - ddx }
          var ddz: i64 = pz2 - en_get(m, h, MC_Z)
          if ddz < 0 { ddz = 0 - ddz }
          let dy2: i64 = py2 - en_get(m, h, MC_Y)
          if ddx < 90 { if ddz < 90 { if dy2 >= 0 { if dy2 < 440 { return k } } } }
          k = k + 1
      }
      t = t + 1
  }
  return 0 - 1
1365}
1366
1367// ---------- A1: the integer tick calendar (day/night + 4 seasons) ----------
1368// Pure functions of (S_T, spec) -> bit-exact across arenas by construction. Every phase compare
1369// CROSS-MULTIPLIES (the banked integer-truncation law: never divide a value before comparing it).
1370// RECOMBINATION CONTRACT: a different game = a different spec; a recombined identity turns a
1371// subsystem OFF by zeroing its rows, so every consumer guards the zero (endless day, no rain,
1372// no farm clock) instead of trapping on a modulo-by-zero. Off is a state, never a crash.
1373func cal_dayt(base: i64) -> i64 {
  let dl: i64 = wsp(base)[P_DAYLEN]
  if dl <= 0 { return 0 }
  let s: *i64 = wst(base)
  return s[S_T] % dl
1378}
1379func cal_day(base: i64) -> i64 {
  let dl: i64 = wsp(base)[P_DAYLEN]
  if dl <= 0 { return 0 }
  let s: *i64 = wst(base)
  return s[S_T] / dl
1384}
1385func cal_season(base: i64) -> i64 {
  let sd: i64 = wsp(base)[P_SEASD]
  if sd <= 0 { return 0 }
  return (cal_day(base) / sd) % 4
1389}
1390// night = the last 3/8 of each day: dayt*8 >= DAYLEN*5, cross-multiplied
1391func cal_night(base: i64) -> i64 {
  if wsp(base)[P_DAYLEN] <= 0 { return 0 }
  if cal_dayt(base)*8 >= wsp(base)[P_DAYLEN]*WC_NIGHT_X8 { return 1 }
  return 0
1395}
1396// sun elevation as a Q12 sine: rises 0 at dawn, +4096 at noon, negative through the night
1397func cal_sunel(base: i64) -> i64 {
  let dl: i64 = wsp(base)[P_DAYLEN]
  if dl <= 0 { return 4096 }                       // calendar off = eternal noon
  let dt2: i64 = cal_dayt(base)
  if dt2*8 < dl*WC_NIGHT_X8 { return it_sin4096(dt2*8*IT_PI/(dl*WC_NIGHT_X8)) }
  return 0 - it_sin4096((dt2*8 - dl*WC_NIGHT_X8)*IT_PI/(dl*(8 - WC_NIGHT_X8)))
1403}
1404// deterministic weather: ONE roll per absolute day-eighth from (seed, segment, season table) --
1405// the same world replays the same storms forever
1406func cal_rain(base: i64) -> i64 {
  let dl: i64 = wsp(base)[P_DAYLEN]
  if dl <= 0 { return 0 }
  let s: *i64 = wst(base)
  let seg: i64 = s[S_T]*8/dl
  if whash(seg, 771, s[S_SEED] + 3300) % 1000 < wsp(base)[P_RAINS + cal_season(base)] { return 1 }
  return 0
1413}
1414// write bst into MC_DISG bits 3-5 WITHOUT touching the disguise/met bits (0-2) or the
1415// FRIENDSHIP byte (bits 6-13) -- the old (dg & 7) mask silently erased any upper state
1416func dg_bst(dg: i64, b: i64) -> i64 { return dg - ((dg >> 3) & 7)*8 + b*8 }
1417
1418// ---------- B1/B2: soil + crops. THE EDIT JOURNAL IS THE SPARSE ACTIVE LIST ----------
1419// Every farm cell was player-touched, so it is already journaled at absolute coords: no scan,
1420// no extra memory, and growth writes go through the same journal so world and history can
1421// never disagree. Growth is Minecraft's integer stencil: p = 1/(floor(25/speed)+1), speed
1422// from soil wetness; rolls are seed+coord+epoch hashes -> replay-safe by construction.
1423func wc_grow_set(base: i64, lx: i64, ly: i64, lz: i64, b: i64) -> i64 {
  let s: *i64 = wst(base)
  if ej_put(base, lx + s[S_WOX], ly, lz + s[S_WOZ], b) < 0 {
      s[S_EJDROP] = s[S_EJDROP] + 1
      return 0
  }
  return vset(base, lx, ly, lz, b)
1430}
1431// water within the 5x5 ring at soil level or one below (ponds sit lower than their fields)
1432func wc_wet_near(base: i64, lx: i64, ly: i64, lz: i64) -> i64 {
  var dz2: i64 = 0 - 2
  while dz2 <= 2 {
      var dx2: i64 = 0 - 2
      while dx2 <= 2 {
          if vget(base, lx + dx2, ly, lz + dz2) == 4 { return 1 }
          if vget(base, lx + dx2, ly - 1, lz + dz2) == 4 { return 1 }
          dx2 = dx2 + 1
      }
      dz2 = dz2 + 1
  }
  return 0
1444}
1445func wc_farm_tick(base: i64) -> i64 {
  let s: *i64 = wst(base)
  let e: *i64 = ejp(base)
  let sp: *i64 = wsp(base)
  let rain: i64 = cal_rain(base)
  var i: i64 = 0
  while i < EJRN_SLOTS {
      let cur: i64 = e[i]
      if cur != 0 {
          let b: i64 = cur & 255
          if b >= B_FARM { if b <= B_FARMW {
              let k: i64 = (cur >> 8) - 1
              let ay: i64 = k & 63
              let az: i64 = ((k >> 6) & WATER_MAGIC_33554431) - WATER_MAGIC_16777216
              let ax: i64 = ((k >> 31) & WATER_MAGIC_33554431) - WATER_MAGIC_16777216
              let lx: i64 = ax - s[S_WOX]
              let lz: i64 = az - s[S_WOZ]
              // only cells inside the window tick (offscreen farms pause -- chunk law, honest)
              if vin(lx, ay, lz) == 1 { if vget(base, lx, ay, lz) == b {
                  if b == B_FARM { if rain == 1 { wc_grow_set(base, lx, ay, lz, B_FARMW) } }
                  if b == B_FARM { if rain == 0 { if wc_wet_near(base, lx, ay, lz) == 1 {
                      wc_grow_set(base, lx, ay, lz, B_FARMW)
                  } } }
                  if b == B_FARMW { if rain == 0 { if wc_wet_near(base, lx, ay, lz) == 0 {
                      wc_grow_set(base, lx, ay, lz, B_FARM)
                  } } }
                  if b >= B_CROP0 { if b <= B_CROP1 {
                      var spd: i64 = sp[P_GROWD]
                      let un: i64 = vget(base, lx, ay - 1, lz)
                      if un == B_FARMW { spd = sp[P_GROWW] }
                      if rain == 1 { if un == B_FARM { spd = sp[P_GROWW] } }
                      if spd < 1 { spd = 1 }
                      let den: i64 = 25/spd + 1
                      if whash(ax*131 + ay, az*97, s[S_SEED] + s[S_T]/sp[P_GROWE]) % den == 0 {
                          wc_grow_set(base, lx, ay, lz, b + 1)
                          if b + 1 == B_CROP2 { s[S_GROWN] = s[S_GROWN] + 1 }
                      }
                  } }
              } }
          } }
      }
      i = i + 1
  }
  return 0
1489}
1490
1491// ---------- A4/C1 shared state maintenance (springs + needs) ----------
1492func wc_soft_seat_all(base: i64) -> i64 {
  let m: *i64 = mobp(base)
  let sb0: *i64 = (base + O_SOFT) as *i64
  var k: i64 = 0
  while k < en_count(m) {
      let h: i64 = en_nth(m, k)
      if h > 0 { sb_seat_mob(sb0, k, en_get(m, h, MC_X)/4, en_get(m, h, MC_Y)/4, en_get(m, h, MC_Z)/4) }
      k = k + 1
  }
  return 0
1502}
1503// ---------- THE TRAVELER'S PASSPORT (isekai): character + party cross worlds ----------
1504func passp(base: i64) -> *i64 { return (base + O_PASS) as *i64 }
1505func wc_pass_ck(p: *i64) -> i64 {
  return gsc_fold_words(WATER_MAGIC_1469598103, p, 0, 21, WATER_MAGIC_1099511, WATER_MAGIC_4611686018427387903)
1507}
1508func wc_party_count(base: i64) -> i64 {
  let m: *i64 = mobp(base)
  var n: i64 = 0
  var k: i64 = 0
  while k < en_count(m) {
      let h: i64 = en_nth(m, k)
      if h > 0 { if (en_get(m, h, MC_DISG) & 4) == 4 { n = n + 1 } }
      k = k + 1
  }
  return n
1518}
1519// fold the session's deltas into the lifetime ledger (snapshot words 32+ make this idempotent:
1520// a world reload or a second build never double-counts a deed)
1521func wc_pass_sync(base: i64) -> i64 {
  let p: *i64 = passp(base)
  let s: *i64 = wst(base)
  if p[0] != PASS_MAGIC {
      var z: i64 = 0
      while z < 48 { p[z] = 0; z = z + 1 }
      p[0] = PASS_MAGIC
      p[1] = 1
      p[2] = whash(s[S_SEED], s[S_T], 20260802)
      // snapshot stays ZERO on creation: a traveler born mid-world ABSORBS what he has
      // already done here as his first deeds. Baselining at current values silently
      // discarded them (gate T50 caught exactly that: 7 harvests -> ledger 0).
  }
  var d: i64 = s[S_BROKEN] - p[32]
  if d > 0 { p[3] = p[3] + d }
  p[32] = s[S_BROKEN]
  d = s[S_PLACED] - p[33]
  if d > 0 { p[4] = p[4] + d }
  p[33] = s[S_PLACED]
  d = s[S_HARV] - p[34]
  if d > 0 { p[5] = p[5] + d }
  p[34] = s[S_HARV]
  d = s[S_PLANT] - p[35]
  if d > 0 { p[6] = p[6] + d }
  p[35] = s[S_PLANT]
  d = s[S_FOUND] - p[36]
  if d > 0 { p[7] = p[7] + d }
  p[36] = s[S_FOUND]
  d = s[S_LOST] - p[37]
  if d > 0 { p[8] = p[8] + d }
  p[37] = s[S_LOST]
  d = s[S_T] - p[38]
  if d > 0 { p[9] = p[9] + d }
  p[38] = s[S_T]
  p[10] = p[10] | (1 << s[S_VAR])
  // the party rides along: up to 3 companions' (kind, bond-word, genome)
  let m: *i64 = mobp(base)
  var pc: i64 = 0
  var k: i64 = 0
  while k < en_count(m) {
      let h: i64 = en_nth(m, k)
      if h > 0 { if (en_get(m, h, MC_DISG) & 4) == 4 { if pc < 3 {
          p[12 + pc*3] = en_get(m, h, MC_KIND)
          p[13 + pc*3] = en_get(m, h, MC_DISG)
          p[14 + pc*3] = en_get(m, h, MC_GENE)
          pc = pc + 1
      } } }
      k = k + 1
  }
  p[11] = pc
  p[21] = wc_pass_ck(p)
  return PASS_LEN
1573}
1574// arriving traveler: validate, re-baseline the snapshot, and WALK THE PARTY OFF THE BOAT --
1575// each companion respawns beside the player with bond and genome intact. Refusal touches
1576// nothing: -1 magic, -2 version, -3 checksum (the save doors' law).
1577func wc_pass_apply(base: i64) -> i64 {
  let p: *i64 = passp(base)
  if p[0] != PASS_MAGIC { return 0 - 1 }
  if p[1] != 1 { return 0 - 2 }
  if wc_pass_ck(p) != p[21] { return 0 - 3 }
  let s: *i64 = wst(base)
  p[32] = s[S_BROKEN]
  p[33] = s[S_PLACED]
  p[34] = s[S_HARV]
  p[35] = s[S_PLANT]
  p[36] = s[S_FOUND]
  p[37] = s[S_LOST]
  p[38] = s[S_T]
  p[10] = p[10] | (1 << s[S_VAR])
  let m: *i64 = mobp(base)
  var pc: i64 = 0
  while pc < p[11] { if pc < 3 {
      let hn: i64 = en_spawn(m)
      if hn > 0 {
          let ang: i64 = pc*2*IT_PI/3 + IT_PI/6
          var ax: i64 = s[S_CX] + it_sin4096(ang)*3*256/WATER_MAGIC_4096
          var az: i64 = s[S_CZ] + it_cos4096(ang)*3*256/WATER_MAGIC_4096
          ax = wclamp(ax, 2*256, (WX - 2)*256)
          az = wclamp(az, 2*256, (WZ - 2)*256)
          let gy: i64 = mob_ground(base, ax >> 8, WY - 1, az >> 8)
          en_set(m, hn, MC_X, ax)
          en_set(m, hn, MC_Z, az)
          en_set(m, hn, MC_Y, (gy + 1)*256)
          en_set(m, hn, MC_KIND, p[12 + pc*3])
          en_set(m, hn, MC_DISG, p[13 + pc*3])
          en_set(m, hn, MC_GENE, p[14 + pc*3])
          en_set(m, hn, MC_PH, whash(p[14 + pc*3], pc, s[S_SEED]) % WATER_MAGIC_4096)
      }
      pc = pc + 1
  } }
  wc_soft_seat_all(base)
  wc_need_seed(base)
  p[21] = wc_pass_ck(p)
  return 0
1616}
1617
1618// level + party-invite as BASE-PARAMETERIZED cores (the doors below are thin wrappers, so the
1619// gate exercises the same code the game runs -- one definition, zero drift)
1620func pass_level_of(base: i64) -> i64 {
  let p: *i64 = passp(base)
  if p[0] != PASS_MAGIC { return 1 }
  var sc: i64 = p[5]*4 + p[6] + p[7]*20 + p[3]/8 + p[4]/8 + p[9]/72000*3
  var lv: i64 = 1
  while sc >= lv*10 { sc = sc - lv*10; lv = lv + 1 }
  return lv
1627}
1628func party_of(base: i64) -> i64 {
  let s: *i64 = wst(base)
  if s[S_NPCT] < 0 { return 0 - 1 }
  let m: *i64 = mobp(base)
  let h: i64 = en_nth(m, s[S_NPCT])
  if h <= 0 { return 0 - 1 }
  let dg: i64 = en_get(m, h, MC_DISG)
  if ((dg >> 6) & 255) < 40 { return 0 - 2 }       // a bond, not a kidnapping
  if (dg & 4) == 4 {
      en_set(m, h, MC_DISG, dg - 4)                // toggle: she may also LEAVE
      return 0
  }
  if wc_party_count(base) >= 3 { return 0 - 3 }
  en_set(m, h, MC_DISG, dg | 4)
  th_add(base, s[S_NPCT], TH_MET, 20, 14400)
  return 1
1644}
1645
1646// outfit for girl k: identity data gates the dimension; her genome picks within it.
1647// 0 clothed · 1 topless · 2 nude (all figures are the one adult mesh)
1648// THE POSE DOOR (operator 2026-08-02: "interact with me and the environment in various poses
1649// beyond the one" -- the pose PIPELINE's first rung). The engine ALREADY computes behavioral
1650// states (T44: sleep/flee via MC_DISG bits 3-5; movement via O_MOBAUX deltas) and the renderer
1651// ignores every one of them: sleeping girls play the walk clip, idle girls walk in place. Same
1652// class as the face: THE DATA EXISTS AND DRIVES NOTHING -- so the consumer contract comes first.
1653// Pose ids (the page consumes; the coming NXA pose BANK indexes by these):
1654//   0 idle-stand (breath only)  1 walk  2 sleep-lying  3 flee-run  4 sit  5 lie-awake
1655// 4/5 are RESERVED rows: behaviors from the towel/smart-object chain select them; publishing
1656// the id space now means new poses arrive as DATA against a stable contract, not an engine edit.
1657func mob_pose(base: i64, k: i64) -> i64 {
  let m: *i64 = mobp(base)
  let st: i64 = (en_get(m, en_nth(m, k), MC_DISG) >> 3) & 7
  if st == 2 { return 2 }
  if st == 4 { return 3 }
  if mob_spd_q8i(base, k) > 0 { return 1 }
  return 0
1664}
1665func mobpose(k: i64) -> i64 { return mob_pose(0, k) }
1666
1667func mob_outfit(base: i64, k: i64) -> i64 {
  if wsp(base)[P_OUTFIT] == 0 { return 0 }
  let m: *i64 = mobp(base)
  let g: i64 = (en_get(m, en_nth(m, k), MC_GENE) >> 18) & 3
  if g <= 1 { return 0 }
  if g == 2 { return 1 }
  return 2
1674}
1675
1676func wc_need_seed(base: i64) -> i64 {
  let m: *i64 = mobp(base)
  let s: *i64 = wst(base)
  let nd0: *i64 = (base + O_NEED) as *i64
  var k: i64 = 0
  while k < en_count(m) {
      nd0[k*4] = 300 + (whash(k, 11, s[S_SEED]) % 200)
      nd0[k*4 + 1] = 700
      nd0[k*4 + 2] = 300 + (whash(k, 23, s[S_SEED]) % 200)
      nd0[k*4 + 3] = 0
      k = k + 1
  }
  return 0
1689}
1690
1691// ---------- C3/C5: the inner life (thought ledger + gossip records) ----------
1692func mindp(base: i64) -> *i64 { return (base + O_MIND) as *i64 }
1693func wc_mind_zero(base: i64) -> i64 {
  let mp: *i64 = mindp(base)
  var i: i64 = 0
  while i < MOB_CAP*24 { mp[i] = 0; i = i + 1 }
  return 0
1698}
1699// add/refresh a thought: same id refreshes in place; else a dead slot; else rotate one out
1700func th_add(base: i64, k: i64, id: i64, mag: i64, ttl: i64) -> i64 {
  let mp: *i64 = mindp(base)
  let s: *i64 = wst(base)
  let b: i64 = k*24
  var slot: i64 = 0 - 1
  var i: i64 = 0
  while i < 8 {
      if (mp[b + i*2] >> 8) == id { slot = i }
      i = i + 1
  }
  if slot < 0 {
      i = 0
      while i < 8 {
          if slot < 0 { if mp[b + i*2 + 1] <= s[S_T] { slot = i } }
          i = i + 1
      }
  }
  if slot < 0 { slot = (s[S_T] + k) % 8 }
  mp[b + slot*2] = id*256 + (mag + 128)
  mp[b + slot*2 + 1] = s[S_T] + ttl
  return 0
1721}
1722// mood = the sum of LIVE thoughts, clamped -- always decomposable back into its reasons
1723func th_mood(base: i64, k: i64) -> i64 {
  let mp: *i64 = mindp(base)
  let s: *i64 = wst(base)
  let b: i64 = k*24
  var mo: i64 = 0
  var i: i64 = 0
  while i < 8 {
      if mp[b + i*2] != 0 { if mp[b + i*2 + 1] > s[S_T] { mo = mo + (mp[b + i*2] & 255) - 128 } }
      i = i + 1
  }
  if mo > 100 { mo = 100 }
  if mo < 0 - 100 { mo = 0 - 100 }
  return mo
1736}
1737// a gossip fact: (subject, predicate, confidence, born). A better-known copy never downgrades.
1738func go_add(base: i64, k: i64, subj: i64, pred: i64, conf: i64) -> i64 {
  let mp: *i64 = mindp(base)
  let s: *i64 = wst(base)
  let b: i64 = k*24 + 16
  var slot: i64 = 0 - 1
  var free: i64 = 0 - 1
  var oldest: i64 = 0
  var oldt: i64 = WATER_MAGIC_4611686018427387903
  var i: i64 = 0
  while i < 4 {
      let w: i64 = mp[b + i*2]
      if w == 0 { if free < 0 { free = i } }
      if w != 0 { if (w >> 16) == subj { if ((w >> 8) & 255) == pred { slot = i } } }
      if mp[b + i*2 + 1] < oldt { oldt = mp[b + i*2 + 1]; oldest = i }
      i = i + 1
  }
  if slot >= 0 { if (mp[b + slot*2] & 255) >= conf { return 0 } }
  if slot < 0 { slot = free }
  if slot < 0 { slot = oldest }
  mp[b + slot*2] = subj*WATER_MAGIC_65536 + pred*256 + conf
  mp[b + slot*2 + 1] = s[S_T]
  return 0
1760}
1761func go_newest(base: i64, k: i64) -> i64 {
  let mp: *i64 = mindp(base)
  let b: i64 = k*24 + 16
  var best: i64 = 0 - 1
  var bt: i64 = 0 - 1
  var i: i64 = 0
  while i < 4 {
      if mp[b + i*2] != 0 { if mp[b + i*2 + 1] > bt { bt = mp[b + i*2 + 1]; best = i } }
      i = i + 1
  }
  return best
1772}
1773
1774// mob wander: smooth deterministic drift (phase-driven sin/cos), terrain-following, player-curious
1775// within 6 blocks. Pure integer -- the T4 determinism checksum covers mobs by construction.
1776func mob_tick(base: i64) -> i64 {
  let m: *i64 = mobp(base)
  let s: *i64 = wst(base)
  let nd: *i64 = (base + O_NEED) as *i64
  let night: i64 = cal_night(base)
  var k: i64 = 0
  while k < en_count(m) {
      let h: i64 = en_nth(m, k)
      if h > 0 {
          var x: i64 = en_get(m, h, MC_X)
          var z: i64 = en_get(m, h, MC_Z)
          var ph: i64 = en_get(m, h, MC_PH) + 5
          // C1 NEEDS drift (integer, staggered by handle -- the village never moves in lockstep)
          let nb: i64 = k*4
          if (s[S_T] + h) % 8 == 0 {
              if nd[nb] < 1000 { nd[nb] = nd[nb] + 2 }               // hunger grows
              if nd[nb + 2] < 1000 { nd[nb + 2] = nd[nb + 2] + 3 }   // loneliness grows
              if nd[nb + 1] > 0 { nd[nb + 1] = nd[nb + 1] - 1 }      // energy drains
          }
          // C3: lived moments become LEDGER ENTRIES (staggered; each refreshes in place)
          if (s[S_T] + h) % 128 == 0 {
              let bst0: i64 = (en_get(m, h, MC_DISG) >> 3) & 7
              if cal_rain(base) == 1 { if bst0 != 2 { th_add(base, k, TH_RAIN, 0 - 8, 1200) } }
              if nd[nb] > 700 { th_add(base, k, TH_HUNGRY, 0 - 10, 900) }
              if night == 1 { if bst0 == 2 { th_add(base, k, TH_SLEPT, 6, 3600) } }
          }
          // BEHAVIOR LAYER (C1/C2 -- lives picked by NEEDS x the spec ADVERTISEMENT table,
          // not a dice roll): state in MC_DISG bits 3-5, repicked on the staggered 240-tick
          // clock. 0=WANDER 1=SOCIALIZE 2=REST 3=FORAGE 4=FLEE. At night the village SLEEPS
          // (the C2 schedule) -- while the wardens hunt wider. The old spec-weights TODO is
          // RESOLVED: behavior now reads needs + P_ADV rows, both data.
          let dg: i64 = en_get(m, h, MC_DISG)
          var bst: i64 = (dg >> 3) & 7
          if (s[S_T] + h*37) % 240 == 0 {
              var sc1: i64 = 220 + (whash(h*911, s[S_T]/240, s[S_SEED]) % 64)
              // C3 feedback: the ledger BENDS the life -- a glad girl seeks company, a sad
              // one withdraws to rest. Mood is data the argmax reads, not a scripted branch.
              let mo9: i64 = th_mood(base, k)
              var sc2: i64 = nd[nb + 2]
              if mo9 > 0 { sc2 = sc2 + mo9 }
              var sc3: i64 = 1000 - nd[nb + 1]
              if mo9 < 0 { sc3 = sc3 - mo9*2 }
              var sc4: i64 = 0
              var ai: i64 = 0
              while ai < 6 {
                  let ad: i64 = wsp(base)[P_ADV + ai]
                  if ad != 0 { if ((ad >> 8) & 255) == 0 {
                      let ab: i64 = (ad >> 16) & 255
                      var fnd: i64 = 0
                      var az2: i64 = (z >> 8) - 3
                      while az2 <= (z >> 8) + 3 {
                          var ax2: i64 = (x >> 8) - 3
                          while ax2 <= (x >> 8) + 3 {
                              let gy2: i64 = mob_ground(base, ax2, (en_get(m, h, MC_Y) >> 8) + 2, az2)
                              if gy2 >= 0 {
                                  if vget(base, ax2, gy2, az2) == ab { fnd = 1 }
                                  if vget(base, ax2, gy2 + 1, az2) == ab { fnd = 1 }
                              }
                              ax2 = ax2 + 1
                          }
                          az2 = az2 + 1
                      }
                      if fnd == 1 {
                          let cand: i64 = nd[nb]*(ad & 255)/8
                          if cand > sc4 { sc4 = cand }
                      }
                  } }
                  ai = ai + 1
              }
              bst = 0
              var top: i64 = sc1
              if sc2 > top { top = sc2; bst = 1 }
              if sc3 > top { top = sc3; bst = 2 }
              if sc4 > top { top = sc4; bst = 3 }
              if night == 1 { bst = 2 }
              en_set(m, h, MC_DISG, dg_bst(dg, bst))
          }
          if (dg & 3) == 3 {
              // a hidden human checks for hunters -- night widens the danger radius
              var wr: i64 = 8*256
              if night == 1 { wr = 12*256 }
              var wnd: i64 = wr
              var wnx: i64 = 0
              var wnz: i64 = 0
              var kf: i64 = 0
              while kf < en_count(m) {
                  let hf: i64 = en_nth(m, kf)
                  if en_get(m, hf, MC_KIND) == 2 { if (en_get(m, hf, MC_DISG) & 1) == 0 {
                      var fdx: i64 = en_get(m, hf, MC_X) - x
                      if fdx < 0 { fdx = 0 - fdx }
                      var fdz: i64 = en_get(m, hf, MC_Z) - z
                      if fdz < 0 { fdz = 0 - fdz }
                      if fdx + fdz < wnd { wnd = fdx + fdz; wnx = en_get(m, hf, MC_X); wnz = en_get(m, hf, MC_Z) }
                  } }
                  kf = kf + 1
              }
              if wnd < wr { bst = 4; en_set(m, h, MC_DISG, dg_bst(en_get(m, h, MC_DISG), 4)) }
          }
          var dx: i64 = it_sin4096(ph*3 % (2*IT_PI))*5/WATER_MAGIC_4096
          var dz: i64 = it_cos4096(ph*3 % (2*IT_PI))*5/WATER_MAGIC_4096
          if bst == 1 {
              // SOCIALIZE: walk to the nearest other girl; inside 1.2 blocks, stand together
              var snd: i64 = WATER_MAGIC_4611686018427387903
              var snx: i64 = x
              var snz: i64 = z
              var snk: i64 = 0 - 1
              var ks: i64 = 0
              while ks < en_count(m) {
                  let hs: i64 = en_nth(m, ks)
                  if hs != h {
                      var sdx: i64 = en_get(m, hs, MC_X) - x
                      if sdx < 0 { sdx = 0 - sdx }
                      var sdz: i64 = en_get(m, hs, MC_Z) - z
                      if sdz < 0 { sdz = 0 - sdz }
                      if sdx + sdz < snd { snd = sdx + sdz; snx = en_get(m, hs, MC_X); snz = en_get(m, hs, MC_Z); snk = ks }
                  }
                  ks = ks + 1
              }
              dx = 0
              dz = 0
              if snd > 300 {
                  if snx > x + 32 { dx = 4 }
                  if snx < x - 32 { dx = 0 - 4 }
                  if snz > z + 32 { dz = 4 }
                  if snz < z - 32 { dz = 0 - 4 }
              }
              if snd <= 300 {
                  ph = ph - 4                             // stilled gait: talking, not marching
                  if (s[S_T] + h) % 4 == 0 {              // company relieves loneliness
                      nd[nb + 2] = nd[nb + 2] - 10
                      if nd[nb + 2] < 0 { nd[nb + 2] = 0 }
                  }
                  // C5: CONVERSATION MOVES FACTS. One fact passes speaker->listener with
                  // confidence -15; below conf 30 the predicate may FLIP (1<->2) -- rumor
                  // decays into misinformation BY MECHANIC, and hearing it leaves a thought.
                  if (s[S_T] + h) % 128 == 0 {
                      th_add(base, k, TH_COMPANY, 5, 1200)
                      let gi: i64 = go_newest(base, k)
                      if gi >= 0 { if snk >= 0 {
                          let gw: i64 = mindp(base)[k*24 + 16 + gi*2]
                          let conf2: i64 = (gw & 255) - 15
                          if conf2 > 0 {
                              var pred2: i64 = (gw >> 8) & 255
                              if conf2 < 30 { if whash(s[S_T], k*31 + snk, s[S_SEED] + 777) % 3 == 0 {
                                  pred2 = 3 - pred2
                              } }
                              go_add(base, snk, gw >> 16, pred2, conf2)
                              if pred2 == GO_TAKEN { th_add(base, snk, TH_HEARD_TAKEN, 0 - 10, 7200) }
                              if pred2 == GO_FRIEND { th_add(base, snk, TH_HEARD_FRIEND, 6, 7200) }
                          }
                      } }
                  }
              }
          }
          if bst == 2 {
              dx = 0
              dz = 0
              ph = ph - 4                                 // REST: seated stillness
              if (s[S_T] + h) % 4 == 0 {                  // sleep restores; night sleep restores MORE
                  var rg: i64 = 2
                  if night == 1 { rg = 8 }
                  nd[nb + 1] = nd[nb + 1] + rg
                  if nd[nb + 1] > 1000 { nd[nb + 1] = 1000 }
              }
          }
          if bst == 3 {
              // FORAGE: graze rhythm -- steps then a pause, head-down cadence; grazing feeds her
              if (s[S_T] + h) % 16 >= 6 { dx = 0; dz = 0; ph = ph - 3 }
              if (s[S_T] + h) % 8 == 0 {
                  nd[nb] = nd[nb] - 12
                  if nd[nb] < 0 { nd[nb] = 0 }
              }
          }
          if bst == 4 {
              // FLEE: straight away from the nearest warden, fast
              var wnd2: i64 = WATER_MAGIC_4611686018427387903
              var wax: i64 = x
              var waz: i64 = z
              var kf2: i64 = 0
              while kf2 < en_count(m) {
                  let hf2: i64 = en_nth(m, kf2)
                  if en_get(m, hf2, MC_KIND) == 2 { if (en_get(m, hf2, MC_DISG) & 1) == 0 {
                      var fdx2: i64 = en_get(m, hf2, MC_X) - x
                      if fdx2 < 0 { fdx2 = 0 - fdx2 }
                      var fdz2: i64 = en_get(m, hf2, MC_Z) - z
                      if fdz2 < 0 { fdz2 = 0 - fdz2 }
                      if fdx2 + fdz2 < wnd2 { wnd2 = fdx2 + fdz2; wax = en_get(m, hf2, MC_X); waz = en_get(m, hf2, MC_Z) }
                  } }
                  kf2 = kf2 + 1
              }
              dx = 0
              dz = 0
              if wax > x { dx = 0 - 6 }
              if wax <= x { dx = 6 }
              if waz > z { dz = 0 - 6 }
              if waz <= z { dz = 6 }
          }
          // PERSONALITY (genome bits 13-15, INHERITED): the bold<->shy spectrum photographers
          // know -- engagement is a RANGE, not one script. Near the player: shy girls (0-1)
          // retreat and keep 5 blocks; watchful ones (2-3) freeze and observe, backing off
          // only if crowded; warm ones (4-5) approach to a polite arm's length; bold ones
          // (6-7) come right to your side. FORAGE also reads it: bold girls gather TOWARD
          // you (the obvious pick-up), shy girls drift their gathering away (the oblivious).
          let pdx: i64 = s[S_CX] - x
          let pdz: i64 = s[S_CZ] - z
          var pd: i64 = pdx
          if pd < 0 { pd = 0 - pd }
          var pdz2: i64 = pdz
          if pdz2 < 0 { pdz2 = 0 - pdz2 }
          let bold: i64 = (en_get(m, h, MC_GENE) >> 13) & 7
          // HABITUATION: the approach/watch drive runs only while she is lonely enough to
          // care (the player is a smart object too -- company below relieves the need, and a
          // satisfied girl walks on). Shy retreat is FEAR, not curiosity: never gated.
          var curi: i64 = 1
          if nd[nb + 2] < wsp(base)[P_CURI] { curi = 0 }
          if bold <= 1 { curi = 1 }
          if curi == 1 { if bst != 2 { if bst != 4 { if pd + pdz2 < 6*256 {
              var twd: i64 = 0                       // -1 retreat, 0 hold, +1 approach
              var stopd: i64 = 400
              var spd: i64 = 3
              if bold <= 1 { twd = 0 - 1; stopd = 5*256; spd = 5 }
              if bold >= 2 { if bold <= 3 {
                  twd = 0
                  if pd + pdz2 < 2*256 { twd = 0 - 1; stopd = 2*256; spd = 4 }
              } }
              if bold >= 4 { if bold <= 5 { twd = 1; stopd = 400; spd = 3 } }
              if bold >= 6 { twd = 1; stopd = 200; spd = 5 }
              if bst == 3 { if twd != 0 { spd = 2 } }   // gathering: the drift is subtle
              if twd == 1 { if pd + pdz2 > stopd {
                  // S1 F-FORMATION SLOT (the social-interaction brief, rung S1): her approach
                  // target is HER slot on the ring around the player, never the player center
                  // -- N approaching girls used to converge on one point and bunch into a
                  // queue ("they just follow me around"). Slot angle = a stable hash of her
                  // handle; radius = her OWN personality stop distance, so bold girls ring
                  // close and warm girls ring at arm's length (proxemics stays personal).
                  let sa9: i64 = (h*1741) % (2*IT_PI)
                  let tx9: i64 = s[S_CX] + it_cos4096(sa9)*stopd/WATER_MAGIC_4096
                  let tz9: i64 = s[S_CZ] + it_sin4096(sa9)*stopd/WATER_MAGIC_4096
                  let sdx9: i64 = tx9 - x
                  let sdz9: i64 = tz9 - z
                  dx = 0
                  if sdx9 > 128 { dx = spd }
                  if sdx9 < 0 - 128 { dx = 0 - spd }
                  dz = 0
                  if sdz9 > 128 { dz = spd }
                  if sdz9 < 0 - 128 { dz = 0 - spd }
              } }
              if twd == 1 { if pd + pdz2 <= stopd { if bst == 0 { dx = 0; dz = 0; ph = ph - 4 } } }
              if twd == 0 - 1 { if pd + pdz2 < stopd {
                  dx = spd
                  if pdx > 0 { dx = 0 - spd }
                  dz = spd
                  if pdz > 0 { dz = 0 - spd }
              } }
              if twd == 0 { if bst == 0 { dx = 0; dz = 0; ph = ph - 4 } }   // the watcher stands
          } } } }
          // RELATIONSHIP (the FLIAW arc): shared time within arm's reach becomes FRIENDSHIP,
          // stored in MC_DISG bits 6-13 (cap 250) -- persisted with the mob arena, so a bond
          // survives every save/load. Meeting her (E) adds a step-change on top.
          if pd + pdz2 < 3*256 { if (s[S_T] + h) % 64 == 0 {
              let dgf: i64 = en_get(m, h, MC_DISG)
              if ((dgf >> 6) & 255) < 250 { en_set(m, h, MC_DISG, dgf + 64) }
          } }
          let nx: i64 = x + dx
          let nz: i64 = z + dz
          let cy0: i64 = en_get(m, h, MC_Y)
          let g: i64 = mob_ground(base, nx >> 8, (cy0 >> 8) + 1, nz >> 8)
          var ok: i64 = 0
          if g >= 1 { if g < WY - 4 {
              let ng: i64 = (g + 1)*256
              var dyy: i64 = ng - cy0
              if dyy < 0 { dyy = 0 - dyy }
              if dyy <= 384 { if mob_fits(base, nx >> 8, g, nz >> 8) == 1 {
                  ok = 1
                  en_set(m, h, MC_X, nx)
                  en_set(m, h, MC_Z, nz)
                  // STEP, don't teleport: Y eases toward the stand height (<=48 Q8 up /
                  // 64 down per tick) so a 1-block rise reads as ~5 ticks of CLIMBING,
                  // not a vertical pop (screenshot-caught; deterministic either way)
                  var ny9: i64 = ng
                  if ng > cy0 + WC_STEP_EASE_UP { ny9 = cy0 + WC_STEP_EASE_UP }
                  if ng < cy0 - WC_STEP_EASE_DN { ny9 = cy0 - WC_STEP_EASE_DN }
                  en_set(m, h, MC_Y, ny9)
              } }
          } }
          let aux: *i64 = (base + O_MOBAUX) as *i64
          if ok == 1 { aux[k*3] = dx; aux[k*3 + 1] = dz; aux[k*3 + 2] = en_get(m, h, MC_Y) - cy0 }
          if ok == 0 { aux[k*3] = 0; aux[k*3 + 1] = 0; aux[k*3 + 2] = 0; ph = ph + 977 }   // wall/cliff: turn away
          en_set(m, h, MC_PH, ph)
          // A4: the soft-body springs tick from ROOT TRUTH + HER GAIT: the anchor carries a
          // cadence-coupled thorax bob (published gait biomechanics -- vertical thorax
          // oscillation is what drives chest motion; a flat anchor was why nothing moved),
          // and the chest band is BRED (genome bits 16-17: firm rides tight, soft swings).
          // ★THE SOLVER AND THE INSTRUMENT MUST SHARE ONE REFERENCE (fixed 2026-08-03).
          // This tick used to drive the spring toward a RAW gait sinusoid while sbyb and every
          // probe subtracted mob_anchor_q8 -- the gait<->breath crossfade. Their difference rode
          // the rendered offset as a spurious term, and because ph advances +5 EVERY TICK FOREVER
          // the raw bob never quiets, so a STANDING girl still bounced: the 2026-08-02 breath fix
          // landed in the INSTRUMENT path and never reached the PHYSICS path. (The comment that
          // stood here claimed the bob 'quiets when she stands'. It does not. A comment asserting
          // a behaviour the code does not have is a landmine, so it is deleted with the defect.)
          // Driving the solver from the SAME anchor the instrument reads makes rest-bouncing
          // impossible BY CONSTRUCTION rather than by tuning. At walking speed the crossfade
          // weight saturates and the anchor EQUALS the old raw bob exactly => no-op in motion,
          // fix at rest: the safest shape a drive change can have.
          // ⚠STILL OPEN (debt 1785770635): ph is a FREE-RUNNING clock, so the drive is a fixed
          // 2.50Hz regardless of her real cadence while the render clip is DISTANCE-synced. Until
          // ph advances from travel, foot plant and tissue drive remain uncorrelated -- which is
          // the operator's actual report and is NOT closed by this change.
          sb_tick_mob_firm((base + O_SOFT) as *i64, k,
                           en_get(m, h, MC_X)/4, (en_get(m, h, MC_Y) + mob_anchor_q8i(base, k))/4, en_get(m, h, MC_Z)/4,
                           (en_get(m, h, MC_GENE) >> 16) & 3)
      }
      k = k + 1
  }
  // THE STAKES (losability doctrine: a find that cannot be lost is hollow): WARDENS -- real
  // demonkin -- hunt FOUND humans. Reached = TAKEN (the certified store's destroy, live in
  // production). The player's BODY blocks a warden within 2 blocks. One take per tick, max.
  var kw: i64 = 0
  var took: i64 = 0
  while kw < en_count(m) {
      if took == 0 {
          let hw: i64 = en_nth(m, kw)
          if en_get(m, hw, MC_KIND) == 2 { if (en_get(m, hw, MC_DISG) & 1) == 0 {
              var bestj: i64 = 0 - 1
              // the world declares its danger (P_WARD), night widens it, and the ARRIVING
              // TRAVELER'S LEVEL widens it further: a veteran isekai's stakes rise with him
              var wbase: i64 = wsp(base)[P_WARD]
              if wbase <= 0 { wbase = 12 }
              var bestd: i64 = wbase*256 + pass_level_of(base)*128
              if night == 1 { bestd = bestd + 8*256 }      // the night belongs to the wardens
              var kj: i64 = 0
              while kj < en_count(m) {
                  let hj: i64 = en_nth(m, kj)
                  if (en_get(m, hj, MC_DISG) & 3) == 3 {
                      var ddx2: i64 = en_get(m, hj, MC_X) - en_get(m, hw, MC_X)
                      if ddx2 < 0 { ddx2 = 0 - ddx2 }
                      var ddz2: i64 = en_get(m, hj, MC_Z) - en_get(m, hw, MC_Z)
                      if ddz2 < 0 { ddz2 = 0 - ddz2 }
                      if ddx2 + ddz2 < bestd { bestd = ddx2 + ddz2; bestj = kj }
                  }
                  kj = kj + 1
              }
              if bestj >= 0 {
                  var pdx3: i64 = s[S_CX] - en_get(m, hw, MC_X)
                  if pdx3 < 0 { pdx3 = 0 - pdx3 }
                  var pdz3: i64 = s[S_CZ] - en_get(m, hw, MC_Z)
                  if pdz3 < 0 { pdz3 = 0 - pdz3 }
                  if pdx3 + pdz3 > 2*256 {                 // your presence stays her hand
                      let hj2: i64 = en_nth(m, bestj)
                      if bestd < 220 {
                          // C3/C5: a TAKING is WITNESSED -- every girl within 16 blocks
                          // carries the grief as a thought and the fact as gossip (source =
                          // her own eyes, conf 100). The village REMEMBERS its losses.
                          let tkx: i64 = en_get(m, hj2, MC_X)
                          let tkz: i64 = en_get(m, hj2, MC_Z)
                          var tkk: i64 = 0 - 1
                          var kwi: i64 = 0
                          while kwi < en_count(m) {
                              if en_nth(m, kwi) == hj2 { tkk = kwi }
                              kwi = kwi + 1
                          }
                          en_destroy(m, hj2)
                          s[S_LOST] = s[S_LOST] + 1
                          var kwj: i64 = 0
                          while kwj < en_count(m) {
                              let hwj: i64 = en_nth(m, kwj)
                              if hwj > 0 {
                                  var wdx: i64 = en_get(m, hwj, MC_X) - tkx
                                  if wdx < 0 { wdx = 0 - wdx }
                                  var wdz: i64 = en_get(m, hwj, MC_Z) - tkz
                                  if wdz < 0 { wdz = 0 - wdz }
                                  if wdx + wdz < 16*256 {
                                      th_add(base, kwj, TH_SAWTAKEN, 0 - 25, 14400)
                                      if tkk >= 0 { go_add(base, kwj, tkk, GO_TAKEN, 100) }
                                  }
                              }
                              kwj = kwj + 1
                          }
                          took = 1
                      }
                      if bestd >= 220 { if took == 0 {
                          let txq: i64 = en_get(m, hj2, MC_X)
                          let tzq: i64 = en_get(m, hj2, MC_Z)
                          var wv: i64 = 4
                          if night == 1 { wv = 7 }         // she closes faster in the dark
                          var mx3: i64 = 0
                          if txq > en_get(m, hw, MC_X) + 32 { mx3 = wv }
                          if txq < en_get(m, hw, MC_X) - 32 { mx3 = 0 - wv }
                          var mz3: i64 = 0
                          if tzq > en_get(m, hw, MC_Z) + 32 { mz3 = wv }
                          if tzq < en_get(m, hw, MC_Z) - 32 { mz3 = 0 - wv }
                          en_set(m, hw, MC_X, en_get(m, hw, MC_X) + mx3)
                          en_set(m, hw, MC_Z, en_get(m, hw, MC_Z) + mz3)
                      } }
                  }
              }
          } }
      }
      kw = kw + 1
  }
  // INHERITANCE (the past-DAZ lever, live): two MET girls keeping close company bear a
  // DAUGHTER -- her genome FIELD-CROSSED from both parents (the breeders gcross pattern),
  // spawned through the certified store (capacity-bounded), cooldown-paced. Display cap 12.
  if s[S_BCD] > 0 { s[S_BCD] = s[S_BCD] - 1 }
  if s[S_BCD] == 0 { if en_count(m) < MOB_CAP {
      var ka: i64 = 0
      var born: i64 = 0
      while ka < en_count(m) {
          if born == 0 {
              let ha: i64 = en_nth(m, ka)
              if (en_get(m, ha, MC_DISG) & 2) == 2 {
                  var kb2: i64 = ka + 1
                  while kb2 < en_count(m) {
                      if born == 0 {
                          let hb2: i64 = en_nth(m, kb2)
                          if (en_get(m, hb2, MC_DISG) & 2) == 2 {
                              var bdx4: i64 = en_get(m, ha, MC_X) - en_get(m, hb2, MC_X)
                              if bdx4 < 0 { bdx4 = 0 - bdx4 }
                              var bdz4: i64 = en_get(m, ha, MC_Z) - en_get(m, hb2, MC_Z)
                              if bdz4 < 0 { bdz4 = 0 - bdz4 }
                              if bdx4 + bdz4 < 400 {
                                  let hn: i64 = en_spawn(m)
                                  if hn > 0 {
                                      let ga: i64 = en_get(m, ha, MC_GENE)
                                      let gb: i64 = en_get(m, hb2, MC_GENE)
                                      let pick: i64 = whash(ga, gb, s[S_T])
                                      var gn: i64 = 0
                                      var fm: i64 = 0
                                      while fm < 8 {
                                          var msk: i64 = 7
                                          if fm == 1 { msk = 24 }
                                          if fm == 2 { msk = 96 }
                                          if fm == 3 { msk = 384 }
                                          if fm == 4 { msk = WATER_MAGIC_1536 }
                                          if fm == 5 { msk = WATER_MAGIC_6144 }
                                          if fm == 6 { msk = WATER_MAGIC_57344 }   // bits 13-15: TEMPERAMENT (bold<->shy) is bred too
                                          if fm == 7 { msk = 983040 }              // bits 16-19: BODY NATURE (firmness 16-17 +
                                                                                   // beachwear nature 18-19) bred as one field --
                                                                                   // un-crossed genome bits default every daughter
                                                                                   // to one body (the class this row eats); pick
                                                                                   // has only 8 hash bits, so 16-19 share fm 7
                                          if ((pick >> fm) & 1) == 1 { gn = gn | (ga & msk) }
                                          if ((pick >> fm) & 1) == 0 { gn = gn | (gb & msk) }
                                          fm = fm + 1
                                      }
                                      en_set(m, hn, MC_GENE, gn)
                                      en_set(m, hn, MC_X, (en_get(m, ha, MC_X) + en_get(m, hb2, MC_X))/2)
                                      en_set(m, hn, MC_Y, en_get(m, ha, MC_Y))
                                      en_set(m, hn, MC_Z, (en_get(m, ha, MC_Z) + en_get(m, hb2, MC_Z))/2)
                                      var kk: i64 = en_get(m, ha, MC_KIND)
                                      if ((pick >> 6) & 1) == 1 { kk = en_get(m, hb2, MC_KIND) }
                                      en_set(m, hn, MC_KIND, kk)
                                      let da: i64 = en_get(m, ha, MC_DISG) & 1
                                      let db: i64 = en_get(m, hb2, MC_DISG) & 1
                                      var dn: i64 = 0
                                      if da == 1 { if db == 1 { dn = 1 } }
                                      if da != db { dn = (pick >> 7) & 1 }
                                      en_set(m, hn, MC_DISG, dn)
                                      en_set(m, hn, MC_PH, whash(gn, pick, s[S_T]) % WATER_MAGIC_4096)
                                      // seat the newborn's springs + needs (dense tail slot)
                                      let nk9: i64 = en_count(m) - 1
                                      sb_seat_mob((base + O_SOFT) as *i64, nk9,
                                                  en_get(m, hn, MC_X)/4, en_get(m, hn, MC_Y)/4, en_get(m, hn, MC_Z)/4)
                                      let nd9: *i64 = (base + O_NEED) as *i64
                                      nd9[nk9*4] = 400
                                      nd9[nk9*4 + 1] = 800
                                      nd9[nk9*4 + 2] = 500
                                      nd9[nk9*4 + 3] = 0
                                      s[S_BCD] = 900
                                      born = 1
                                  }
                              }
                          }
                      }
                      kb2 = kb2 + 1
                  }
              }
          }
          ka = ka + 1
      }
  } }
  return 0
2259}
2260
2261// the full FPS control core: fwd/strafe movement, keyboard turn + analog mouselook, keyboard pitch,
2262// jump with real gravity (auto-step <=1.5 blocks stays; 2+ needs a jump), then targeting + edits.
2263func apply2_impl(base: i64, fwd: i64, strafe: i64, turn: i64,
               lookx: i64, looky: i64, pit: i64, jump: i64, brk: i64, plc: i64) -> i64 {
  let s: *i64 = wst(base)
  s[S_T] = s[S_T] + 1
  s[S_YAW] = s[S_YAW] + turn*TURN + lookx*LOOKS
  if s[S_YAW] < 0 { s[S_YAW] = s[S_YAW] + 2*IT_PI }
  if s[S_YAW] >= 2*IT_PI { s[S_YAW] = s[S_YAW] - 2*IT_PI }
  s[S_PITCH] = wclamp(s[S_PITCH] + pit*PITCHV - looky*LOOKS, 0 - PITCH_MAX, PITCH_MAX)
  let sy: i64 = it_sin4096(s[S_YAW])
  let cy2: i64 = it_cos4096(s[S_YAW])
  // horizontal: move vector = fwd*forward + strafe*right, axis-split against walls
  let mx: i64 = (sy*fwd + cy2*strafe)*SPEED/WATER_MAGIC_4096
  let mz: i64 = (cy2*fwd - sy*strafe)*SPEED/WATER_MAGIC_4096
  if mx != 0 {
      let nx: i64 = s[S_CX] + mx
      if wstand(base, nx, s[S_CZ], s[S_CY]) >= 0 { s[S_CX] = nx }
  }
  if mz != 0 {
      let nz: i64 = s[S_CZ] + mz
      if wstand(base, s[S_CX], nz, s[S_CY]) >= 0 { s[S_CZ] = nz }
  }
  // vertical: jump + gravity against the current column's stand height (replaces the glide)
  var vy: i64 = s[S_VY]
  if jump == 1 { if s[S_GROUNDED] == 1 { vy = JUMPV } }
  vy = vy - GRAV
  if vy < 0 - 120 { vy = 0 - 120 }                 // terminal velocity
  var ny: i64 = s[S_CY] + vy
  if vy > 0 {                                       // ceiling while rising
      let hc: i64 = (ny + 128) >> 8
      if vsolid(base, s[S_CX] >> 8, hc, s[S_CZ] >> 8) == 1 { ny = s[S_CY]; vy = 0 }
  }
  let stand: i64 = wstand_here(base, s[S_CX], s[S_CZ])
  s[S_GROUNDED] = 0
  if ny <= stand { ny = stand; vy = 0; s[S_GROUNDED] = 1 }
  s[S_VY] = vy
  s[S_CY] = ny
  // void-fall rescue: below the world floor (edge slip despite the wall) -> respawn, never vanish
  if ny < 0 - 512 { wc_respawn(base) }
  if wground(base, s[S_CX] >> 8, s[S_CZ] >> 8) < 0 { wc_respawn(base) }
  // crosshair target: one ray straight along the view
  let sp: i64 = it_sin4096(s[S_PITCH])
  let cp: i64 = it_cos4096(s[S_PITCH])
  let fx: i64 = sy*cp/WATER_MAGIC_4096
  let fy: i64 = sp
  let fz: i64 = cy2*cp/WATER_MAGIC_4096
  let hout: *i64 = (base + O_ST + 40*8) as *i64    // scratch slots 40-44 (wray writes FIVE outs;
  let hs: i64 = wray(base, fx*FOC, fy*FOC, fz*FOC, REACH_STEPS, hout)   // 56+ overflowed into O_INPUT once)
  s[S_NPCT] = npc_pick(base, fx, fy, fz)
  // BODY PRESENCE: push the player out of any girl's personal cylinder (no ghost-walking)
  let mB: *i64 = mobp(base)
  var kB: i64 = 0
  while kB < en_count(mB) {
      let hB: i64 = en_nth(mB, kB)
      let bdx: i64 = s[S_CX] - en_get(mB, hB, MC_X)
      let bdz: i64 = s[S_CZ] - en_get(mB, hB, MC_Z)
      var adx: i64 = bdx
      if adx < 0 { adx = 0 - adx }
      var adz: i64 = bdz
      if adz < 0 { adz = 0 - adz }
      // SAME-ALTITUDE ONLY: a girl in a cave below (or ledge above) must NOT wall you off up
      // here -- the "invisible walls" bug was cylinders with no vertical extent
      var ady: i64 = s[S_CY] - EYE - en_get(mB, hB, MC_Y)
      if ady < 0 { ady = 0 - ady }
      if ady < 460 { if adx < 100 { if adz < 100 {
          if adx > adz {
              if bdx > 0 { s[S_CX] = en_get(mB, hB, MC_X) + 100 }
              if bdx <= 0 { s[S_CX] = en_get(mB, hB, MC_X) - 100 }
          }
          if adx <= adz {
              if bdz > 0 { s[S_CZ] = en_get(mB, hB, MC_Z) + 100 }
              if bdz <= 0 { s[S_CZ] = en_get(mB, hB, MC_Z) - 100 }
          }
      } } }
      kB = kB + 1
  }
  s[S_HOK] = 0
  if hs > 0 {
      s[S_HX] = hout[0]
      s[S_HY] = hout[1]
      s[S_HZ] = hout[2]
      s[S_HFACE] = hout[3]
      s[S_HOK] = 1
  }
  // THE INTERACT VERB: E on a targeted girl MEETS her (block-breaking is suppressed -- you are
  // talking to a person, not mining through her). Meeting marks her met-bit; a disguised human,
  // once met, is FOUND and counted (the identify-and-protect loop of the lore).
  var dobrk: i64 = brk
  if brk == 1 { if s[S_NPCT] >= 0 {
      dobrk = 0
      let mV: *i64 = mobp(base)
      let hV: i64 = en_nth(mV, s[S_NPCT])
      let dv: i64 = en_get(mV, hV, MC_DISG)
      if (dv & 2) == 0 {
          var dvn: i64 = dv | 2
          if ((dvn >> 6) & 255) <= 240 { dvn = dvn + 640 }   // meeting her: +10 friendship
          en_set(mV, hV, MC_DISG, dvn)
          if (dv & 1) == 1 { s[S_FOUND] = s[S_FOUND] + 1 }
          // C3/C5: the meeting lands in HER ledger, and the fact of it enters the village's
          // gossip graph with herself as subject -- her story spreads without another line
          th_add(base, s[S_NPCT], TH_MET, 15, 14400)
          go_add(base, s[S_NPCT], s[S_NPCT], GO_FRIEND, 100)
      }
  } }
  if dobrk == 1 { if s[S_HOK] == 1 { if s[S_HY] > 0 {
      let bwas: i64 = vget(base, s[S_HX], s[S_HY], s[S_HZ])
      if wc_edit(base, s[S_HX], s[S_HY], s[S_HZ], 0) == 1 {
          if bwas == B_CROP2 { s[S_HARV] = s[S_HARV] + 1 }   // the HARVEST: the loop pays out
          s[S_LBX] = s[S_HX]
          s[S_LBY] = s[S_HY]
          s[S_LBZ] = s[S_HZ]
          s[S_BROKEN] = s[S_BROKEN] + 1
          s[S_HOK] = 0
      }
  } } }
  if plc == 1 { if s[S_HOK] == 1 {
      let want: i64 = sel_block(s[S_SEL])
      if want == B_FARM { if s[S_HFACE] == 3 {
          // the HOE: tilling converts the TARGETED grass/dirt block itself -- no new block
          let tb: i64 = vget(base, s[S_HX], s[S_HY], s[S_HZ])
          if tb == 1 { if wc_edit(base, s[S_HX], s[S_HY], s[S_HZ], B_FARM) == 1 { s[S_PLACED] = s[S_PLACED] + 1 } }
          if tb == 2 { if wc_edit(base, s[S_HX], s[S_HY], s[S_HZ], B_FARM) == 1 { s[S_PLACED] = s[S_PLACED] + 1 } }
      } }
      if want == B_CROP0 { if s[S_HFACE] == 3 { if s[S_HY] + 1 < WY {
          // SEEDS: only into the air directly above targeted farmland (wet or dry)
          let sb2: i64 = vget(base, s[S_HX], s[S_HY], s[S_HZ])
          var okf: i64 = 0
          if sb2 == B_FARM { okf = 1 }
          if sb2 == B_FARMW { okf = 1 }
          if okf == 1 { if vget(base, s[S_HX], s[S_HY] + 1, s[S_HZ]) == 0 {
              if wc_edit(base, s[S_HX], s[S_HY] + 1, s[S_HZ], B_CROP0) == 1 {
                  s[S_PLANT] = s[S_PLANT] + 1
                  s[S_PLACED] = s[S_PLACED] + 1
              }
          } }
      } } }
      if want != B_FARM { if want != B_CROP0 {
      var px: i64 = s[S_HX]
      var py: i64 = s[S_HY]
      var pz: i64 = s[S_HZ]
      let f: i64 = s[S_HFACE]
      if f == 1 { px = px + 1 }
      if f == 2 { px = px - 1 }
      if f == 3 { py = py + 1 }
      if f == 4 { py = py - 1 }
      if f == 5 { pz = pz + 1 }
      if f == 6 { pz = pz - 1 }
      var okp: i64 = 0
      if vin(px, py, pz) == 1 { if vget(base, px, py, pz) == 0 { okp = 1 } }
      // never inside the player's own two cells
      if px == s[S_CX] >> 8 { if pz == s[S_CZ] >> 8 {
          let feet: i64 = (s[S_CY] - EYE) >> 8
          if py >= feet { if py <= feet + 1 { okp = 0 } }
      } }
      if okp == 1 {
          if wc_edit(base, px, py, pz, want) == 1 {
              s[S_PLACED] = s[S_PLACED] + 1
              if py > s[S_WMAX] { s[S_WMAX] = py } // a tower can rise past the old ceiling
          }
      }
      } }
  } }
  mob_tick(base)
  // B1/B2: the farm breathes on its own clock (soil hydration + crop growth, journal-driven).
  // P_GROWE <= 0 = a recombined identity with no farming: the clock simply never fires.
  let ge9: i64 = wsp(base)[P_GROWE]
  if ge9 >= 1 { if s[S_T] % ge9 == 0 { wc_farm_tick(base) } }
  // v6 STREAMING: approach a window margin -> the world slides under you (unbounded land).
  // Runs after the whole frame so every in-frame coordinate was consistent; one stride per
  // axis per tick is plenty at player speeds.
  if (s[S_CX] >> 8) >= WX - SHIFT_MARGIN { wc_shift(base, SHIFT_STRIDE, 0) }
  if (s[S_CX] >> 8) < SHIFT_MARGIN { wc_shift(base, 0 - SHIFT_STRIDE, 0) }
  if (s[S_CZ] >> 8) >= WZ - SHIFT_MARGIN { wc_shift(base, 0, SHIFT_STRIDE) }
  if (s[S_CZ] >> 8) < SHIFT_MARGIN { wc_shift(base, 0, 0 - SHIFT_STRIDE) }
  return 0
2437}
2438
2439func wc_cycle(base: i64) -> i64 {
  let s: *i64 = wst(base)
  s[S_SEL] = (s[S_SEL] + 1) % 7
  return s[S_SEL]
2443}
2444
2445// adaptive quality: the SURFACE reports how long its last frame took (transport only); the ORGAN
2446// owns the response. EMA x16 with hysteresis bands so it never flaps: sustained >24ms coarsens,
2447// sustained <11ms refines. Returns the current ray pixel size.
2448func wc_framems(base: i64, ms: i64) -> i64 {
  let s: *i64 = wst(base)
  var m2: i64 = ms
  if m2 < 0 { m2 = 0 }
  if m2 > 100 { m2 = 100 }
  s[S_FMA] = (s[S_FMA]*3 + m2*16)/4
  if s[S_FMA] > 384 { if s[S_Q] < 5 {              // >24ms sustained
      s[S_Q] = s[S_Q] + 1
      s[S_FMA] = 256
  } }
  if s[S_FMA] < 176 { if s[S_Q] > 1 {              // <11ms sustained -> refine, down to NATIVE res
      s[S_Q] = s[S_Q] - 1
      s[S_FMA] = 256
  } }
  return s[S_Q]
2463}
2464
2465// ---------- persistence: a sovereign save image (the nx_gamesave laws, wasm-compatible) ----------
2466// [0]=magic [1]=version [2]=seed [3..7]=camx/y/z/yaw/pitch [8]=sel [9]=broken [10]=placed
2467// [11]=checksum (order-sensitive rolling fold, 63-bit masked) then the raw voxel bytes.
2468// The surface (file on native, localStorage in the browser) moves BYTES ONLY; meaning stays here.
2469// seq1151 (2026-07-30): the rolling-fold mechanism now composes nx_gamesave_core -- ONE definition
2470// shared with the gs_save file surface; this format's constants stay ITS OWN (image bytes unchanged,
2471// golden gate checksums are the acceptance).
2472func wc_save_ck(base: i64) -> i64 {
  let hd: *i64 = (base + O_SAVE) as *i64
  let vb: *u8 = (base + O_SAVE + SAVE_HDR) as *u8
  var ck: i64 = gsc_fold_words(WATER_MAGIC_1469598103, hd, 2, 11, WATER_MAGIC_1099511, WATER_MAGIC_4611686018427387903)
  ck = gsc_fold(ck, hd[12], WATER_MAGIC_1099511, WATER_MAGIC_4611686018427387903)
  ck = gsc_fold(ck, hd[13], WATER_MAGIC_1099511, WATER_MAGIC_4611686018427387903)
  ck = gsc_fold(ck, hd[14], WATER_MAGIC_1099511, WATER_MAGIC_4611686018427387903)
  ck = gsc_fold(ck, hd[15], WATER_MAGIC_1099511, WATER_MAGIC_4611686018427387903)
  ck = gsc_fold_bytes(ck, vb, SAVE_BODY, 131, WATER_MAGIC_4611686018427387903)
  return ck
2482}
2483// pre-streaming (v5) checksum geometry -- LOAD-COMPAT ONLY, so old saves keep opening
2484func wc_save_ck_v5(base: i64) -> i64 {
  let hd: *i64 = (base + O_SAVE) as *i64
  let vb: *u8 = (base + O_SAVE + SAVE_HDR) as *u8
  var ck: i64 = gsc_fold_words(WATER_MAGIC_1469598103, hd, 2, 11, WATER_MAGIC_1099511, WATER_MAGIC_4611686018427387903)
  ck = gsc_fold(ck, hd[12], WATER_MAGIC_1099511, WATER_MAGIC_4611686018427387903)
  ck = gsc_fold(ck, hd[13], WATER_MAGIC_1099511, WATER_MAGIC_4611686018427387903)
  ck = gsc_fold_bytes(ck, vb, SAVE_BODY_V5, 131, WATER_MAGIC_4611686018427387903)
  return ck
2492}
2493// build the image from live state; returns its byte length
2494func wc_save_build(base: i64) -> i64 {
  let s: *i64 = wst(base)
  let hd: *i64 = (base + O_SAVE) as *i64
  hd[0] = SAVE_MAGIC
  hd[1] = SAVE_VER
  hd[2] = s[S_SEED]
  hd[3] = s[S_CX]
  hd[4] = s[S_CY]
  hd[5] = s[S_CZ]
  hd[6] = s[S_YAW]
  hd[7] = s[S_PITCH]
  hd[8] = s[S_SEL]
  hd[9] = s[S_BROKEN]
  hd[10] = s[S_PLACED]
  hd[12] = s[S_FOUND]
  hd[13] = s[S_LOST]
  hd[14] = s[S_WOX]
  hd[15] = s[S_WOZ]
  let vb: *u8 = (base + O_SAVE + SAVE_HDR) as *u8
  let vx: *u8 = wvx(base)
  var p: i64 = 0
  while p < WX*WY*WZ { vb[p] = vx[p]; p = p + 1 }
  let mb: *u8 = (base + O_MOBS) as *u8
  var q: i64 = 0
  while q < MOB_BYTES { vb[WX*WY*WZ + q] = mb[q]; q = q + 1 }
  let eb: *u8 = (base + O_EJRN) as *u8
  var r: i64 = 0
  while r < EJRN_BYTES { vb[WX*WY*WZ + MOB_BYTES + r] = eb[r]; r = r + 1 }
  hd[11] = wc_save_ck(base)
  return SAVE_LEN
2524}
2525// validate the image in place, then restore world + camera from it. NOTHING is touched on refusal.
2526// returns 0, or negative: -1 magic, -2 version, -3 checksum
2527func wc_save_apply(base: i64) -> i64 {
  let hd: *i64 = (base + O_SAVE) as *i64
  if hd[0] != SAVE_MAGIC { return 0 - 1 }
  var v5: i64 = 0
  if hd[1] == SAVE_VER5 { v5 = 1 }
  if hd[1] != SAVE_VER { if v5 == 0 { return 0 - 2 } }
  let want: i64 = hd[11]
  if v5 == 0 { if wc_save_ck(base) != want { return 0 - 3 } }
  if v5 == 1 { if wc_save_ck_v5(base) != want { return 0 - 3 } }
  let s: *i64 = wst(base)
  s[S_SEED] = hd[2]
  s[S_CX] = hd[3]
  s[S_CY] = hd[4]
  s[S_CZ] = hd[5]
  s[S_YAW] = hd[6]
  s[S_PITCH] = hd[7]
  s[S_SEL] = hd[8]
  s[S_BROKEN] = hd[9]
  s[S_PLACED] = hd[10]
  s[S_FOUND] = hd[12]
  s[S_LOST] = hd[13]
  s[S_WOX] = 0
  s[S_WOZ] = 0
  if v5 == 0 { s[S_WOX] = hd[14]; s[S_WOZ] = hd[15] }
  s[S_VY] = 0
  let vb: *u8 = (base + O_SAVE + SAVE_HDR) as *u8
  let vx: *u8 = wvx(base)
  var p: i64 = 0
  while p < WX*WY*WZ { vx[p] = vb[p]; p = p + 1 }
  let mb: *u8 = (base + O_MOBS) as *u8
  var q: i64 = 0
  while q < MOB_BYTES { mb[q] = vb[WX*WY*WZ + q]; q = q + 1 }
  // journal: v6 restores it from the image; a v5 save simply has no touched-land history yet
  let eb: *u8 = (base + O_EJRN) as *u8
  var r: i64 = 0
  if v5 == 0 {
      while r < EJRN_BYTES { eb[r] = vb[WX*WY*WZ + MOB_BYTES + r]; r = r + 1 }
  } else {
      while r < EJRN_BYTES { eb[r] = 0 as u8; r = r + 1 }
  }
  wc_wmax(base)                                    // the restored world's ceiling, not the fresh one's
  wc_soft_seat_all(base)                           // springs + needs are NON-PERSISTED: re-derive
  wc_need_seed(base)
  wc_mind_zero(base)                               // a loaded world wakes with a clear head
  return 0
2572}
2573
2574// legacy 6-arg form: forwards into the full core (no strafe/look/jump). Gate callers use this.
2575func apply_impl(base: i64, fwd: i64, turn: i64, pit: i64, brk: i64, plc: i64) -> i64 {
  return apply2_impl(base, fwd, 0, turn, 0, 0, pit, 0, brk, plc)
2577}
2578
2579// legacy single-action tick (gate + old shim): 0 fwd 1 back 2 turnL 3 turnR 4 break 5 place
2580func tick_impl(base: i64, d: i64) -> i64 {
  var fwd: i64 = 0
  var turn: i64 = 0
  var brk: i64 = 0
  var plc: i64 = 0
  if d == 0 { fwd = 1 }
  if d == 1 { fwd = 0 - 1 }
  if d == 2 { turn = 0 - 1 }
  if d == 3 { turn = 1 }
  if d == 4 { brk = 1 }
  if d == 5 { plc = 1 }
  if d == 6 { wc_cycle(base) }
  return apply_impl(base, fwd, turn, 0, brk, plc)
2593}
2594
2595// multi-action input frame, FPS scheme: W/S forward/back + A/D (and arrows) STRAFE from HELD,
2596// yaw from the analog LOOK channel (mouse), pitch from mouse + R/F, jump held (auto-rehop on
2597// landing, Minecraft-style), break/place from PRESSED edges so they cannot repeat-fire.
2598func step_impl(base: i64) -> i64 {
  let q: *i64 = winp(base)
  let held: i64 = ia_held(q)
  let pressed: i64 = ia_frame(q)
  var fwd: i64 = 0
  if (held & IA_UP) != 0 { fwd = 1 }
  if (held & IA_DOWN) != 0 { fwd = fwd - 1 }
  var strafe: i64 = 0
  if (held & IA_RIGHT) != 0 { strafe = 1 }
  if (held & IA_LEFT) != 0 { strafe = strafe - 1 }
  var pit: i64 = 0
  if (held & IA_LUP) != 0 { pit = 1 }
  if (held & IA_LDOWN) != 0 { pit = pit - 1 }
  var jump: i64 = 0
  if (held & IA_JUMP) != 0 { jump = 1 }
  var brk: i64 = 0
  if (pressed & IA_A) != 0 { brk = 1 }
  var plc: i64 = 0
  if (pressed & IA_B) != 0 { plc = 1 }
  if (pressed & IA_MOD) != 0 { wc_cycle(base) }    // Q taps cycle the hotbar (edge, no auto-repeat)
  if (pressed & IA_HOME) != 0 { wc_respawn(base) } // H = the reset button
  let lk: *i64 = (base + O_INPUT + 62*8) as *i64   // scratch beyond the ia arena's live slots
  ia_look_take(q, lk)
  return apply2_impl(base, fwd, strafe, 0, lk[0], lk[1], pit, jump, brk, plc)
2622}
2623
2624// mob billboards: project into the camera basis, occlusion by ONE ray per mob (budgeted to stop
2625// just short of the mob's cell -- a solid hit before that means hidden). An approximation, stated
2626// as such: no per-pixel z against terrain; correct enough at 12 mobs and zero fps cost.
2627func mob_col(base: i64, kind: i64, half: i64) -> i64 {
  var k2: i64 = kind
  if k2 < 0 { k2 = 0 }
  if k2 > 2 { k2 = 2 }
  return wsp(base)[P_MOBC + k2*2 + half]
2632}
2633func mob_draw(base: i64, fxv: i64, fyv: i64, fzv: i64, rxv: i64, rzv: i64,
            uxv: i64, uyv: i64, uzv: i64) -> i64 {
  let m: *i64 = mobp(base)
  let s: *i64 = wst(base)
  let f: *i64 = wfb(base)
  let tmp: *i64 = (base + O_ST + 32*8) as *i64     // scratch slots 32-36 (5 wray outs)
  var k: i64 = 0
  while k < en_count(m) {
      let h: i64 = en_nth(m, k)
      if h > 0 {
          let bob: i64 = it_sin4096((en_get(m, h, MC_PH)*9) % (2*IT_PI))*22/WATER_MAGIC_4096
          let dxq: i64 = en_get(m, h, MC_X) - s[S_CX]
          let dyq: i64 = en_get(m, h, MC_Y) + 128 + bob - s[S_CY]
          let dzq: i64 = en_get(m, h, MC_Z) - s[S_CZ]
          let vz: i64 = (dxq*fxv + dyq*fyv + dzq*fzv)/WATER_MAGIC_4096
          var vis: i64 = 0
          if vz > 200 { if vz < 40*256 { vis = 1 } }
          if vis == 1 {
              var man: i64 = dxq
              if man < 0 { man = 0 - man }
              var t2: i64 = dyq
              if t2 < 0 { t2 = 0 - t2 }
              man = man + t2
              t2 = dzq
              if t2 < 0 { t2 = 0 - t2 }
              man = (man + t2) >> 8
              if man > 2 {
                  if wray(base, dxq, dyq, dzq, man - 1, tmp) > 0 { vis = 0 }
              }
          }
          if vis == 1 {
              let vx: i64 = (dxq*rxv + dzq*rzv)/WATER_MAGIC_4096
              let vy: i64 = (dxq*uxv + dyq*uyv + dzq*uzv)/WATER_MAGIC_4096
              let sx: i64 = W/2 + vx*FOC*RES/vz
              let sy: i64 = H/2 - vy*FOC*RES/vz
              var halfw: i64 = 96*FOC*RES/vz
              if halfw > 90 { halfw = 90 }
              if halfw >= 2 {
                  let kind: i64 = en_get(m, h, MC_KIND)
                  let hh2: i64 = halfw*5/4
                  var yy: i64 = 0 - hh2
                  while yy <= hh2 {
                      var xx: i64 = 0 - halfw
                      while xx <= halfw {
                          let px2: i64 = sx + xx
                          let py2: i64 = sy + yy
                          if px2 >= 0 { if px2 < W { if py2 >= 0 { if py2 < H {
                              var hf: i64 = 0
                              if yy > 0 { hf = 1 }
                              f[py2*W + px2] = mob_col(base, kind, hf)
                          } } } }
                          xx = xx + 1
                      }
                      yy = yy + 1
                  }
                  // eyes so it reads as a creature, not a box
                  if halfw >= 6 {
                      let ex2: i64 = halfw/2
                      var e3: i64 = 0
                      while e3 < 2 {
                          var ei: i64 = 0 - 1
                          while ei <= 0 {
                              let epx: i64 = sx - ex2 + e3*(ex2*2) + ei
                              let epy: i64 = sy - hh2/2
                              if epx >= 0 { if epx < W { if epy >= 0 { if epy < H {
                                  f[epy*W + epx] = wpack(24, 20, 34)
                                  f[(epy+1)*W + epx] = wpack(24, 20, 34)
                              } } } }
                              ei = ei + 1
                          }
                          e3 = e3 + 1
                      }
                  }
              }
          }
      }
      k = k + 1
  }
  return 0
2712}
2713
2714func render_impl(base: i64) -> i64 {
  let s: *i64 = wst(base)
  let f: *i64 = wfb(base)
  let sy: i64 = it_sin4096(s[S_YAW])
  let cy2: i64 = it_cos4096(s[S_YAW])
  let sp: i64 = it_sin4096(s[S_PITCH])
  let cp: i64 = it_cos4096(s[S_PITCH])
  // camera basis fx4096: forward (with pitch), right (flat), up (anti-pitch)
  let fxv: i64 = sy*cp/WATER_MAGIC_4096
  let fyv: i64 = sp
  let fzv: i64 = cy2*cp/WATER_MAGIC_4096
  let rxv: i64 = cy2
  let rzv: i64 = 0 - sy
  let uxv: i64 = 0 - sy*sp/WATER_MAGIC_4096
  let uyv: i64 = cp
  let uzv: i64 = 0 - cy2*sp/WATER_MAGIC_4096
  let hout: *i64 = (base + O_ST + 46*8) as *i64    // scratch slots 46-50: wray writes FIVE outs;
  // the old slot-60 scratch put out[4] at slot 64 = O_INPUT[0] = the KEYBOARD MASK -- every pixel
  // stomped a crossing-t into held keys (5 bits stuck, pitch pinned skyward, 15fps of sky rays)
  // adaptive quality: ray pixel size q (2..5); fov held constant by foc = W/(2q)
  var q: i64 = s[S_Q]
  if q < 1 { q = 1 }
  if q > 5 { q = 5 }
  let rw: i64 = W/q
  let rh: i64 = H/q
  let foc: i64 = W/(2*q)
  // project the sun direction through the camera basis (a billboard at infinity)
  let SUX: i64 = WATER_MAGIC_2400
  let SUY: i64 = WATER_MAGIC_2500
  let SUZ: i64 = WATER_MAGIC_1400
  let svz: i64 = (SUX*fxv + SUY*fyv + SUZ*fzv)/WATER_MAGIC_4096
  var sunon: i64 = 0
  var sunx: i64 = 0
  var suny: i64 = 0
  if wsp(base)[P_SUN] == 1 { if svz > 400 {         // spec decides whether this world HAS a sun
      sunon = 1
      sunx = rw/2 + (SUX*rxv + SUZ*rzv)/WATER_MAGIC_4096*foc/svz
      suny = rh/2 - (SUX*uxv + SUY*uyv + SUZ*uzv)/WATER_MAGIC_4096*foc/svz
  } }
  let cloudon: i64 = wsp(base)[P_CLOUD]
  var py: i64 = 0
  while py < rh {
      let syy: i64 = rh/2 - py
      var px: i64 = 0
      while px < rw {
          let sxx: i64 = px - rw/2
          let dx: i64 = fxv*foc + rxv*sxx + uxv*syy
          let dy: i64 = fyv*foc + uyv*syy
          let dz: i64 = fzv*foc + rzv*sxx + uzv*syy
          let hs: i64 = wray(base, dx, dy, dz, MAXSTEPS, hout)
          var col: i64 = 0
          if hs < 0 {
              col = wsky2(base, syy, px, py, sunx, suny, sunon)
              var cov: i64 = 0
              if cloudon == 1 { cov = wcloud(s[S_CX], s[S_CY], s[S_CZ], dx, dy, dz, s[S_T]) }
              if cov > 0 {
                  var cr: i64 = (col & 255) + (250 - (col & 255))*cov/255
                  var cg: i64 = ((col >> 8) & 255) + (252 - ((col >> 8) & 255))*cov/255
                  var cb: i64 = ((col >> 16) & 255) + (254 - ((col >> 16) & 255))*cov/255
                  col = wpack(cr, cg, cb)
              }
          }
          if hs >= 0 {
              let t2: i64 = hout[4]
              let hpx: i64 = s[S_CX] + dx*t2/WATER_MAGIC_65536
              let hpy: i64 = s[S_CY] + dy*t2/WATER_MAGIC_65536
              let hpz: i64 = s[S_CZ] + dz*t2/WATER_MAGIC_65536
              let hb: i64 = vget(base, hout[0], hout[1], hout[2])
              col = wshade2(base, hb, hout[3], hs, syy, hpx, hpy, hpz, s[S_T], hout[0], hout[1], hout[2])
              if hb == 4 {
                  // WATER IS TRANSPARENT: continue the ray past water, blend 42% of what lies under
                  let hs2: i64 = wray2(base, dx, dy, dz, MAXSTEPS, hout, 1)
                  if hs2 >= 0 {
                      let t3: i64 = hout[4]
                      let qx: i64 = s[S_CX] + dx*t3/WATER_MAGIC_65536
                      let qy: i64 = s[S_CY] + dy*t3/WATER_MAGIC_65536
                      let qz: i64 = s[S_CZ] + dz*t3/WATER_MAGIC_65536
                      let under: i64 = wshade2(base, vget(base, hout[0], hout[1], hout[2]), hout[3], hs2, syy, qx, qy, qz, s[S_T], hout[0], hout[1], hout[2])
                      var br2: i64 = (col & 255)*58/100 + (under & 255)*42/100
                      var bg2: i64 = ((col >> 8) & 255)*58/100 + ((under >> 8) & 255)*42/100
                      var bb2: i64 = ((col >> 16) & 255)*58/100 + ((under >> 16) & 255)*42/100
                      col = wpack(br2, bg2, bb2)
                  }
              }
          }
          // write the qxq block
          let ox: i64 = px*q
          let oy: i64 = py*q
          var yy: i64 = 0
          while yy < q {
              var xx: i64 = 0
              while xx < q {
                  f[(oy + yy)*W + ox + xx] = col
                  xx = xx + 1
              }
              yy = yy + 1
          }
          px = px + 1
      }
      py = py + 1
  }
  mob_draw(base, fxv, fyv, fzv, rxv, rzv, uxv, uyv, uzv)
  // crosshair: white, or gold when a block is in reach
  var cc: i64 = wpack(255, 255, 255)
  if s[S_HOK] == 1 { cc = wpack(255, 210, 90) }
  var ci: i64 = 0 - 6
  while ci <= 6 {
      f[(H/2)*W + W/2 + ci] = cc
      f[(H/2 + ci)*W + W/2] = cc
      ci = ci + 1
  }
  // HUD pips: broken (red) and placed (green) counters, capped at 24 each
  var bq: i64 = 0
  while bq < s[S_BROKEN] { if bq < 24 {
      f[8*W + 8 + bq*7] = wpack(235, 96, 96)
      f[8*W + 9 + bq*7] = wpack(235, 96, 96)
      f[9*W + 8 + bq*7] = wpack(235, 96, 96)
      f[9*W + 9 + bq*7] = wpack(235, 96, 96)
  } bq = bq + 1 }
  var pq: i64 = 0
  while pq < s[S_PLACED] { if pq < 24 {
      f[14*W + 8 + pq*7] = wpack(120, 235, 130)
      f[14*W + 9 + pq*7] = wpack(120, 235, 130)
      f[15*W + 8 + pq*7] = wpack(120, 235, 130)
      f[15*W + 9 + pq*7] = wpack(120, 235, 130)
  } pq = pq + 1 }
  // hotbar: 7 swatches bottom-left (5 blocks + hoe + seeds), the selected one framed white
  var hb: i64 = 0
  while hb < 7 {
      let bx0: i64 = 8 + hb*18
      let by0: i64 = H - 22
      let bc: i64 = wcol(base, sel_block(hb))
      var yy2: i64 = 0
      while yy2 < 14 {
          var xx2: i64 = 0
          while xx2 < 14 { f[(by0 + yy2)*W + bx0 + xx2] = bc; xx2 = xx2 + 1 }
          yy2 = yy2 + 1
      }
      if hb == s[S_SEL] {
          var e2: i64 = 0 - 2
          while e2 <= 15 {
              f[(by0 - 2)*W + bx0 + e2] = wpack(255,255,255)
              f[(by0 + 15)*W + bx0 + e2] = wpack(255,255,255)
              if e2 >= 0 { if e2 < 14 {
                  f[(by0 + e2)*W + bx0 - 2] = wpack(255,255,255)
                  f[(by0 + e2)*W + bx0 + 15] = wpack(255,255,255)
              } }
              e2 = e2 + 1
          }
      }
      hb = hb + 1
  }
  return 0
2867}
2868
2869// ---------- the exported wasm surface (base = 0 in linear memory) ----------
2870func init() -> i64 { return init_impl(0, WATER_MAGIC_20260728) }
2871func init_seed(sd: i64) -> i64 { return init_impl(0, sd) }
2872func init_v(v: i64, sd: i64) -> i64 { return init_impl_v(0, v, sd) }
2873func tick(d: i64) -> i64 { return tick_impl(0, d) }
2874func render() -> i64 { return render_impl(0) }
2875func fb_off() -> i64 { return O_FB }
2876func ww() -> i64 { return W }
2877func hh() -> i64 { return H }
2878func broken() -> i64 { let s: *i64 = wst(0); return s[S_BROKEN] }
2879func placed() -> i64 { let s: *i64 = wst(0); return s[S_PLACED] }
2880func camx() -> i64 { let s: *i64 = wst(0); return s[S_CX] }
2881func camy() -> i64 { let s: *i64 = wst(0); return s[S_CY] }
2882func camz() -> i64 { let s: *i64 = wst(0); return s[S_CZ] }
2883// device doors (nx_input_abstract): the shim forwards RAW events; meaning lives sovereign-side
2884func key(code: i64, down: i64) -> i64 { return ia_key(winp(0), code, down) }
2885func padb(btn: i64, down: i64) -> i64 { return ia_pad(winp(0), btn, down) }
2886func paxis(idx: i64, milli: i64) -> i64 { return ia_axis(winp(0), idx, milli) }
2887func touch(tx: i64, ty: i64, down: i64) -> i64 { return ia_touch(winp(0), tx, ty, W, H, down) }
2888func look(dx: i64, dy: i64) -> i64 { return ia_look(winp(0), dx, dy) }
2889func step() -> i64 { return step_impl(0) }
2890// persistence doors: the surface moves save-image BYTES; build/validate/apply stay sovereign
2891func save_off() -> i64 { return O_SAVE }
2892// v6 streaming doors (probe truth: where the window sits over the unbounded world, and whether
2893// any edit was ever refused by a full journal -- silence here would be a lie)
2894func wox() -> i64 { let s: *i64 = wst(0); return s[S_WOX] }
2895func woz() -> i64 { let s: *i64 = wst(0); return s[S_WOZ] }
2896func ejdrop() -> i64 { let s: *i64 = wst(0); return s[S_EJDROP] }
2897func save_build() -> i64 { return wc_save_build(0) }
2898func save_apply() -> i64 { return wc_save_apply(0) }
2899func sel() -> i64 { let s: *i64 = wst(0); return s[S_SEL] }
2900func hx() -> i64 { let s: *i64 = wst(0); return s[S_HX] }
2901func hy() -> i64 { let s: *i64 = wst(0); return s[S_HY] }
2902func hz() -> i64 { let s: *i64 = wst(0); return s[S_HZ] }
2903func lbx() -> i64 { let s: *i64 = wst(0); return s[S_LBX] }
2904func lby() -> i64 { let s: *i64 = wst(0); return s[S_LBY] }
2905func lbz() -> i64 { let s: *i64 = wst(0); return s[S_LBZ] }
2906func frame_ms(ms: i64) -> i64 { return wc_framems(0, ms) }
2907func quality() -> i64 { let s: *i64 = wst(0); return s[S_Q] }
2908func work_ms() -> i64 { let s: *i64 = wst(0); return s[S_FMA]/16 }
2909func mobs() -> i64 { return en_count(mobp(0)) }
2910func mobx(k: i64) -> i64 { let m: *i64 = mobp(0); return en_get(m, en_nth(m, k), MC_X) }
2911func mobz(k: i64) -> i64 { let m: *i64 = mobp(0); return en_get(m, en_nth(m, k), MC_Z) }
2912// GPU-display doors: the shader is only a RENDERER of this organ's state -- it reads the voxel
2913// bytes and spec palette straight from linear memory and gets camera/mob state per frame
2914func moby(k: i64) -> i64 { let m: *i64 = mobp(0); return en_get(m, en_nth(m, k), MC_Y) }
2915func mobk(k: i64) -> i64 { let m: *i64 = mobp(0); return en_get(m, en_nth(m, k), MC_KIND) }
2916func mobd(k: i64) -> i64 { let m: *i64 = mobp(0); return en_get(m, en_nth(m, k), MC_DISG) }
2917func mobg(k: i64) -> i64 { let m: *i64 = mobp(0); return en_get(m, en_nth(m, k), MC_GENE) }
2918func npc_t() -> i64 { let s: *i64 = wst(0); return s[S_NPCT] }
2919func found() -> i64 { let s: *i64 = wst(0); return s[S_FOUND] }
2920func lost() -> i64 { let s: *i64 = wst(0); return s[S_LOST] }
2921func mobph(k: i64) -> i64 { let m: *i64 = mobp(0); return en_get(m, en_nth(m, k), MC_PH) }
2922// motion doors (seq1258): the girl's LAST APPLIED step -- heading/speed as ORGAN TRUTH,
2923// retiring the page's position-delta derivative. Zero when blocked/still.
2924func mobdx(k: i64) -> i64 { let a: *i64 = (0 + O_MOBAUX) as *i64; return a[k*3] }
2925func mobdz(k: i64) -> i64 { let a: *i64 = (0 + O_MOBAUX) as *i64; return a[k*3 + 1] }
2926func mobdy(k: i64) -> i64 { let a: *i64 = (0 + O_MOBAUX) as *i64; return a[k*3 + 2] }
2927// SUMMON door (operator review + the many-NPC perf test): teleport every girl into a grounded
2928// ring 4-7 blocks around the player. A door like look/padb -- the page binds N to it; nothing
2929// in the tick calls it, so determinism (T4) and the save format are untouched. They resume
2930// their behavior states immediately after placement.
2931func summon() -> i64 {
  let m: *i64 = mobp(0)
  let s: *i64 = wst(0)
  let n: i64 = en_count(m)
  if n <= 0 { return 0 }
  var k: i64 = 0
  while k < n {
      let h: i64 = en_nth(m, k)
      if h > 0 {
          let ang: i64 = k * 2 * IT_PI / n
          let r: i64 = (4 + (k & 3)) * 256
          var nx: i64 = s[S_CX] + it_sin4096(ang) * r / WATER_MAGIC_4096
          var nz: i64 = s[S_CZ] + it_cos4096(ang) * r / WATER_MAGIC_4096
          if nx < 512 { nx = 512 }
          if nx > (WX - 2) * 256 { nx = (WX - 2) * 256 }
          if nz < 512 { nz = 512 }
          if nz > (WZ - 2) * 256 { nz = (WZ - 2) * 256 }
          let gy: i64 = mob_ground(0, nx / 256, WY - 1, nz / 256)
          if gy >= 0 { if mob_fits(0, nx / 256, gy, nz / 256) == 1 {
              en_set(m, h, MC_X, nx)
              en_set(m, h, MC_Z, nz)
              en_set(m, h, MC_Y, (gy + 1) * 256)
          } }
      }
      k = k + 1
  }
  wc_soft_seat_all(0)                              // summon teleports every girl: re-seat springs
  return n
2959}
2960func yaw() -> i64 { let s: *i64 = wst(0); return s[S_YAW] }
2961func pitch() -> i64 { let s: *i64 = wst(0); return s[S_PITCH] }
2962func wmax() -> i64 { let s: *i64 = wst(0); return s[S_WMAX] }
2963func tsel() -> i64 { let s: *i64 = wst(0); return sel_block(s[S_SEL]) }
2964func vox_off() -> i64 { return O_VOX }
2965func spec_off() -> i64 { return O_SPEC }
2966func tnow() -> i64 { let s: *i64 = wst(0); return s[S_T] }
2967func hok() -> i64 { let s: *i64 = wst(0); return s[S_HOK] }
2968// ---- A4 doors: signed Q8 soft-body offsets (model units = worldQ8/4) per girl per point-kind
2969// (0 hair, 1 chest, 2 skirt). The page ADDS these to its joint bands -- helper offsets over the
2970// animation, never replacing it. sbck = the replay/netsync checksum over every spring word.
2971func sbx(k: i64, kd: i64) -> i64 { let m: *i64 = mobp(0); return sb_off_x_q8((0 + O_SOFT) as *i64, k, kd, en_get(m, en_nth(m, k), MC_X)/4) }
2972func sby(k: i64, kd: i64) -> i64 { let m: *i64 = mobp(0); return sb_off_y_q8((0 + O_SOFT) as *i64, k, kd, en_get(m, en_nth(m, k), MC_Y)/4) }
2973func sbz(k: i64, kd: i64) -> i64 { let m: *i64 = mobp(0); return sb_off_z_q8((0 + O_SOFT) as *i64, k, kd, en_get(m, en_nth(m, k), MC_Z)/4) }
2974func sbck() -> i64 { return sb_ck((0 + O_SOFT) as *i64, MOB_CAP) }
2975// TISSUE-VS-BONE (the door renderers and the recorder must both use): offset from the TRUE
2976// anchor -- the one the solver ticked, INCLUDING the gait bob. Measured 2026-08-02: reading
2977// from the un-bobbed root handed the mesh bob + resonant lag = 20.1cm of chest travel on a
2978// torso that does not bob (drive 2.5Hz vs natural 2.75Hz => ~2.6x resonant gain). The bob's
2979// job is to DRIVE the spring; only the LAG belongs on the joint. Bob is a pure function of
2980// her stored phase, so this stays deterministic and needs no extra state.
2981func mob_bob_q8(k: i64) -> i64 {
  let m: *i64 = mobp(0)
  let ph: i64 = en_get(m, en_nth(m, k), MC_PH)
  return it_sin4096((ph*214) % (2*IT_PI))*WC_GAIT_BOB_Q8/WATER_MAGIC_4096
2985}
2986// RESPIRATION: one slow cycle, phase-offset per girl so a crowd never inhales in unison --
2987// synchronised breathing is the tell that betrays a canned idle. Pure function of world tick
2988// and index, so it stays deterministic and needs no per-mob state.
2989// BASE-PARAMETERIZED IMPLS (doors below stay thin arena-0 wrappers): the gate verifies engine
2990// behavior on ITS OWN world arenas, and an arena-0-only door is a capability the gate cannot
2991// measure -- which, per the standing law, is indistinguishable from an absent one.
2992func mob_breath_q8i(bb: i64, k: i64) -> i64 {
  let s: *i64 = wst(bb)
  let ph: i64 = ((s[S_T] % WC_BREATH_TICKS)*2*IT_PI/WC_BREATH_TICKS + k*811) % (2*IT_PI)
  return it_sin4096(ph)*WC_BREATH_Q8/WATER_MAGIC_4096
2996}
2997func mob_breath_q8(k: i64) -> i64 { return mob_breath_q8i(0, k) }
2998// per-tick speed, exposed so the blend threshold can be MEASURED instead of guessed
2999func mob_spd_q8i(bb: i64, k: i64) -> i64 {
  let a: *i64 = (bb + O_MOBAUX) as *i64
  var dx: i64 = a[k*3]
  if dx < 0 { dx = 0 - dx }
  var dz: i64 = a[k*3 + 1]
  if dz < 0 { dz = 0 - dz }
  return dx + dz
3006}
3007func mob_spd_q8(k: i64) -> i64 { return mob_spd_q8i(0, k) }
3008// THE ANCHOR THE SPRING ACTUALLY SEES. Before this, the anchor was driven by GAIT PHASE alone --
3009// and gait phase does not zero when she stops, so a standing girl was still being driven by a
3010// locomotion signal with no locomotion. That is exactly the operator's report: "she bounces
3011// while stopped instead of breathing". Two drives, cross-faded on speed: gait owns motion,
3012// respiration owns rest, and the anchor is never unforced. Cross-multiplied, never divided
3013// before compare, so the blend cannot silently truncate to zero.
3014func mob_anchor_q8i(bb: i64, k: i64) -> i64 {
  var w: i64 = mob_spd_q8i(bb, k)*WATER_MAGIC_4096/WC_BREATH_CUT_Q8
  if w > WATER_MAGIC_4096 { w = WATER_MAGIC_4096 }
  if w < 0 { w = 0 }
  let m: *i64 = mobp(bb)
  let ph: i64 = en_get(m, en_nth(m, k), MC_PH)
  let bob: i64 = it_sin4096((ph*214) % (2*IT_PI))*WC_GAIT_BOB_Q8/WATER_MAGIC_4096
  return (bob*w + mob_breath_q8i(bb, k)*(WATER_MAGIC_4096 - w))/WATER_MAGIC_4096
3022}
3023func mob_anchor_q8(k: i64) -> i64 { return mob_anchor_q8i(0, k) }
3024func sbyb(k: i64, kd: i64) -> i64 {
  let m: *i64 = mobp(0)
  return sb_off_y_q8((0 + O_SOFT) as *i64, k, kd, (en_get(m, en_nth(m, k), MC_Y) + mob_anchor_q8(k))/4)
3027}
3028// ---- A1 doors: the calendar as organ truth (the page only DRAWS day, night and weather)
3029func dayt() -> i64 { return cal_dayt(0) }
3030func dlen() -> i64 { return wsp(0)[P_DAYLEN] }
3031func dayn() -> i64 { return cal_day(0) }
3032func season() -> i64 { return cal_season(0) }
3033func nightf() -> i64 { return cal_night(0) }
3034func sunel() -> i64 { return cal_sunel(0) }
3035func rainf() -> i64 { return cal_rain(0) }
3036// ---- B doors: the farming loop's counters (till -> plant -> weather -> grow -> HARVEST)
3037func harv() -> i64 { let s: *i64 = wst(0); return s[S_HARV] }
3038func planted() -> i64 { let s: *i64 = wst(0); return s[S_PLANT] }
3039func grown() -> i64 { let s: *i64 = wst(0); return s[S_GROWN] }
3040// ---- C doors: relationships + needs + THE INNER LIFE (the emergent-story surface)
3041func mobfr(k: i64) -> i64 { let m: *i64 = mobp(0); return (en_get(m, en_nth(m, k), MC_DISG) >> 6) & 255 }
3042func mobmood(k: i64) -> i64 { return th_mood(0, k) }
3043func mobth(k: i64, i2: i64) -> i64 {
  var i3: i64 = i2
  if i3 < 0 { i3 = 0 }
  if i3 > 7 { i3 = 7 }
  let mp: *i64 = mindp(0)
  let s: *i64 = wst(0)
  if mp[k*24 + i3*2 + 1] <= s[S_T] { return 0 }
  return mp[k*24 + i3*2]
3051}
3052func mobgo(k: i64, i2: i64) -> i64 {
  var i3: i64 = i2
  if i3 < 0 { i3 = 0 }
  if i3 > 3 { i3 = 3 }
  return mindp(0)[k*24 + 16 + i3*2]
3057}
3058func mobout(k: i64) -> i64 { return mob_outfit(0, k) }
3059// ---- ISEKAI doors: the passport is BYTES the surface moves; meaning stays sovereign
3060func pass_off() -> i64 { return O_PASS }
3061func pass_len() -> i64 { return PASS_LEN }
3062func pass_build() -> i64 { return wc_pass_sync(0) }
3063func pass_apply() -> i64 { return wc_pass_apply(0) }
3064func pass_get(i2: i64) -> i64 {
  var i3: i64 = i2
  if i3 < 0 { i3 = 0 }
  if i3 > 23 { i3 = 23 }
  return passp(0)[i3]
3069}
3070// LEVEL: the lifetime ledger read as one number (deeds + lives touched + days), so a fresh
3071// world can scale its challenge to WHO ARRIVED (the isekai contract: nothing is wasted)
3072func pass_level() -> i64 { return pass_level_of(0) }
3073// PARTY: G invites the girl under the crosshair once her bond is real (>= 40); she carries
3074// bit 2 of MC_DISG from then on -- persisted in the world save AND written to the passport.
3075func party() -> i64 { return party_of(0) }
3076func partyn() -> i64 { return wc_party_count(0) }
3077func mobparty(k: i64) -> i64 {
  let m: *i64 = mobp(0)
  return (en_get(m, en_nth(m, k), MC_DISG) >> 2) & 1
3080}
3081func mobneed(k: i64, w: i64) -> i64 {
  var w2: i64 = w
  if w2 < 0 { w2 = 0 }
  if w2 > 3 { w2 = 3 }
  let nd0: *i64 = (0 + O_NEED) as *i64
  return nd0[k*4 + w2]
3087}
nx_wasm_craft.nx source

`nx_wasm_craft.nx` source
