code wiki / _hdl_build / nx_wire_nethack_gate.nx
`nx_wire_nethack_gate.nx` source

↩ module page · 1051 lines · 43733 B
1// nx_wire_nethack_gate.nx -- TITLE WIRING #1: NetHack (roguelike), the first nx_gamebench title wired
2// through the certified parts. Until now every gamebench readiness number was SELF-GRADED (titles_wired=0):
3// the parts exist, but nothing proved they COMPOSE into this title's genre loop. This gate is that proof --
4// an actual playable roguelike loop (procgen dungeon -> descend -> fight -> loot rations -> level up ->
5// save/resume) built ONLY from certified parts, with every exercised capability measured by a tooth.
6//
7// CAPS EXERCISED (bit = nx_gamebench capability index, set ONLY if its tooth passes; the mask is written
8// into the wiring artifact payload[0] so the board's declared mask can be cross-checked by nx_gamebench_gate):
9//   bit 3  procgen-world        (deterministic carved dungeon, seed-diverse, stairs reachable)
10//   bit 7  pathfinding-ai       (nx_pathfind pf_astar drives the player every move turn)
11//   bit 6  entity-component-sim (nx_entity_store holds monsters; stale handle of a killed monster refused)
12//   bit 9  rpg-stats-progression(nx_rpgstats XP curve/level inverse/derived HP drive combat + level-ups)
13//   bit 11 inventory-crafting   (rations picked up, 2 rations CRAFT a feast, ledger conserves exactly)
14//   bit 15 save-load-persistence(nx_gamesave mid-run save -> load into ZEROED state -> resume TRANSPARENT)
15//   bit 18 ui-menus-hud        (nx_gamehud: the eat decision goes THROUGH a modal menu -- open/wrap/select
16//                               CAUSES the eat, it is not painted after the fact; HUD slots bind live
17//                               hp/lvl/depth/kills/food per turn, render-chain deterministic across runs)
18// NOT exercised (title requires, this loop does not prove -> the board must down-score them for NetHack):
19//   bit 14 text-render-typography (the HUD blits glyphs, but typography = layout/wrap/paragraphs; honest no-claim).
20//
21// FLAGSHIP PROPERTY (mutation target): save/load TRANSPARENCY -- play N..M continuously vs play N, save,
22// load into a zeroed world, resume to M: EVERY per-turn checksum identical (the GX-9 test most engines
23// cannot run; it catches the whole "the save forgot a field" class). Non-vacuity guard: the resumed world
24// must be non-trivial (live monsters, xp earned, items picked) or the equality proves nothing.
25// license_tier: ORIGINAL  expect_exit: 0
26import "nx_syscalls.nx"
27import "nx_gamesave.nx"
28import "nx_rpgstats.nx"
29import "nx_entity_store.nx"
30import "nx_pathfind.nx"
31import "nx_gamehud.nx"
32import "nx_wire_harness.nx"
33import "nx_gate_verdict.nx"
34import "nx_trimesh.nx"
35import "nx_objload.nx"
36
37// ---- world shape (data at the top, per rule 11) ----
38const NH_W:      i64 = 24
39const NH_H:      i64 = 12
40const NH_DEPTH:  i64 = 3
41const NH_NMON:   i64 = 6
42const NH_NITEM:  i64 = 5
43const NH_CAP:    i64 = 16        // entity arena capacity
44const NH_NCOMP:  i64 = 4         // components: 0=x 1=y 2=hp 3=xp_reward
45const NH_CARVE:  i64 = 140       // carve steps per level
46const NH_AGGRO:  i64 = 8         // monster chase radius (manhattan)
47const NH_MAXT:   i64 = 600
48// rpg tuning (feeds the data-driven nx_rpgstats curves)
49const NH_XB:     i64 = 20        // xp curve base
50const NH_XQ:     i64 = 10        // xp curve quad
51const NH_HPB:    i64 = 10
52const NH_HPC:    i64 = 2
53const NH_HPL:    i64 = 3
54const NH_CON:    i64 = 14
55const NH_BITE:   i64 = 2
56const NH_MHPB:   i64 = 12        // monster base hp (tanky enough that the save point sees a LIVE world)
57const NH_HEAL_R: i64 = 10        // ration heal
58const NH_HEAL_F: i64 = 25        // feast heal (crafted from 2 rations -> crafting is worth it)
59// save shape
60const NH_HDRN:   i64 = 26        // game header fields serialized
61const NH_NSV:    i64 = 106       // 26 hdr + 1 nmon + 16*4 monsters + 5*3 items
62const NH_SCHEMA: i64 = 7307
63const NH_ART_SCHEMA: i64 = 7317  // the wiring-evidence artifact schema
64// transparency test window (the full run wins at ~turn 62; the window must sit fully before the win)
65const NH_T1W:    i64 = 20
66const NH_T2W:    i64 = 45
67// ---- game arena offsets (i64 words; grid 288, scratch blocks padded to 296) ----
68const NG_O_GRID:   i64 = 32
69const NG_O_ITEM:   i64 = 320
70const NG_O_ENT:    i64 = 336     // en_words(16,4) = 156, padded to 160
71const NG_O_PATH:   i64 = 496
72const NG_O_G:      i64 = 792
73const NG_O_F:      i64 = 1088
74const NG_O_CAME:   i64 = 1384
75const NG_O_OPENF:  i64 = 1680
76const NG_O_CLOSED: i64 = 1976
77const NG_O_CARVE:  i64 = 2272
78const NG_O_HUD:    i64 = 2576    // nx_gamehud arena (GH_WORDS=64) APPENDED -- UI state rides the game
                               // arena but stays OUT of the save (transient UI, re-init on restore;
                               // the PART's own gate proves hud state CAN persist -- the TITLE keeps
                               // it ephemeral, which is what real roguelikes do with menu state)
82const NG_WORDS:    i64 = 2640
83const NH_HUDINK:   i64 = 50      // min ink px for a non-vacuous HUD frame (T10 guard)
84// header field indices inside the game arena
85const F_WS: i64 = 0
86const F_DEPTH: i64 = 1
87const F_TURN: i64 = 2
88const F_PX: i64 = 3
89const F_PY: i64 = 4
90const F_XP: i64 = 5
91const F_LVL: i64 = 6
92const F_HP: i64 = 7
93const F_KILLS: i64 = 8
94const F_RATION: i64 = 9
95const F_FEAST: i64 = 10
96const F_PICKED: i64 = 11
97const F_USED: i64 = 12
98const F_WIN: i64 = 13
99const F_COMB: i64 = 14
100const F_EATR: i64 = 15
101const F_EATF: i64 = 16
102const F_PSTEPS: i64 = 17
103const F_ATT: i64 = 18
104const F_BITES: i64 = 19
105const F_SPAWNED: i64 = 20
106const F_SX: i64 = 21
107const F_SY: i64 = 22
108const F_NCARVE: i64 = 23
109const F_GENRNG: i64 = 24
110const F_ABAND: i64 = 25          // monsters left alive on a level when the player descended
111
112func ww(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
113func wn(v: i64) -> i64 {
  if v==0 { sys_write(1,"0" as *u8,1); return 0 }
  var m: i64=v; if m<0 { sys_write(1,"-" as *u8,1); m=0-m }
  let t: *u8=sys_mmap(32); var k: i64=0
  while m>0 { t[k]=(48+(m%10)) as u8; m=m/10; k=k+1 }
  let o: *u8=sys_mmap(32); var q: i64=k-1; var i: i64=0
  while q>=0 { o[i]=t[q]; i=i+1; q=q-1 }
  sys_write(1,o,i); return 0
121}
122func nbit(i: i64) -> i64 { var v: i64=1; var k: i64=0; while k<i { v=v*2; k=k+1 } return v }
123func nrng(g: *i64) -> i64 {
  var x: i64 = g[F_GENRNG]
  x = x ^ (x << 13)
  x = x ^ (x >> 7)
  x = x ^ (x << 17)
  g[F_GENRNG] = x
  if x < 0 { return 0 - x }
  return x
131}
132func nabs(v: i64) -> i64 { if v<0 { return 0-v } return v }
133
134// ---- level structure: PURE function of (worldseed, depth). Restore regenerates it exactly. ----
135func nh_genstruct(g: *i64) -> i64 {
  g[F_GENRNG] = g[F_WS]*1000 + g[F_DEPTH]*7919
  if g[F_GENRNG]==0 { g[F_GENRNG]=1 }
  let grid: *i64 = (g as i64 + NG_O_GRID*8) as *i64
  let carve: *i64 = (g as i64 + NG_O_CARVE*8) as *i64
  var i: i64=0
  while i<NH_W*NH_H { grid[i]=1; i=i+1 }
  var cx: i64=1
  var cy: i64=1
  grid[cy*NH_W+cx]=0
  carve[0]=cy*NH_W+cx
  var nc: i64=1
  var steps: i64=0
  while steps<NH_CARVE {
      let d: i64 = nrng(g)%4
      var tx: i64=cx
      var ty: i64=cy
      if d==0 { tx=cx+1 }
      if d==1 { tx=cx-1 }
      if d==2 { ty=cy+1 }
      if d==3 { ty=cy-1 }
      if tx>=1 { if tx<=NH_W-2 { if ty>=1 { if ty<=NH_H-2 {
          cx=tx; cy=ty
          if grid[cy*NH_W+cx]==1 { grid[cy*NH_W+cx]=0; carve[nc]=cy*NH_W+cx; nc=nc+1 }
      } } } }
      steps=steps+1
  }
  g[F_SX]=cx
  g[F_SY]=cy
  g[F_NCARVE]=nc
  return nc
166}
167// place monsters + items on carved floor, reset player to the entrance (level entry only, never on restore)
168func nh_populate(g: *i64) -> i64 {
  let carve: *i64 = (g as i64 + NG_O_CARVE*8) as *i64
  let item: *i64 = (g as i64 + NG_O_ITEM*8) as *i64
  let a: *i64 = (g as i64 + NG_O_ENT*8) as *i64
  en_init(a, NH_CAP, NH_NCOMP)
  let nc: i64 = g[F_NCARVE]
  let d: i64 = g[F_DEPTH]
  var m: i64=0
  while m<NH_NMON {
      var placed: i64=0
      var guard: i64=0
      while placed==0 {
          guard=guard+1
          if guard>200 { placed=1 }
          let pick: i64 = 1 + (nrng(g) % (nc-1))
          let cell: i64 = carve[pick]
          let mx: i64 = cell % NH_W
          let my: i64 = cell / NH_W
          // not on another monster
          var clash: i64=0
          var k: i64=0
          while k<en_count(a) {
              let h: i64 = en_nth(a,k)
              let ox: i64 = en_get(a,h,0)
              let oy: i64 = en_get(a,h,1)
              if ox==mx { if oy==my { clash=1 } }
              k=k+1
          }
          if clash==0 { if placed==0 {
              let h2: i64 = en_spawn(a)
              if h2!=EN_NULL {
                  en_set(a,h2,0,mx)
                  en_set(a,h2,1,my)
                  let mhp: i64 = NH_MHPB + d*2
                  en_set(a,h2,2,mhp)
                  let mxp: i64 = 15*d
                  en_set(a,h2,3,mxp)
                  g[F_SPAWNED]=g[F_SPAWNED]+1
                  placed=1
              }
          } }
      }
      m=m+1
  }
  var it: i64=0
  while it<NH_NITEM {
      var placed2: i64=0
      var guard2: i64=0
      while placed2==0 {
          guard2=guard2+1
          if guard2>200 { placed2=1 }
          let pick2: i64 = 1 + (nrng(g) % (nc-1))
          let cell2: i64 = carve[pick2]
          let ix: i64 = cell2 % NH_W
          let iy: i64 = cell2 / NH_W
          var clash2: i64=0
          var q: i64=0
          while q<it { if item[q*3]==ix { if item[q*3+1]==iy { clash2=1 } } q=q+1 }
          // not on the stairs (items on stairs would be fine, keep them distinct for clarity)
          if ix==g[F_SX] { if iy==g[F_SY] { clash2=1 } }
          if clash2==0 { if placed2==0 {
              item[it*3]=ix
              item[it*3+1]=iy
              item[it*3+2]=0
              placed2=1
          } }
      }
      it=it+1
  }
  g[F_PX]=1
  g[F_PY]=1
  return 0
240}
241func nh_new(g: *i64, ws: i64) -> i64 {
  var i: i64=0
  while i<32 { g[i]=0; i=i+1 }
  g[F_WS]=ws
  g[F_DEPTH]=1
  let l1: i64 = rs_level_for_xp(0, NH_XB, NH_XQ)
  g[F_LVL]=l1
  let hp0: i64 = rs_derived_hp(NH_CON, l1, NH_HPB, NH_HPC, NH_HPL)
  g[F_HP]=hp0
  nh_genstruct(g)
  nh_populate(g)
  let hud: *i64 = (g as i64 + NG_O_HUD*8) as *i64
  gh_init(hud, 5)
  return 0
255}
256// serialize game-visible state into S[NH_NSV] (monsters via DENSE order so restore preserves iteration order)
257func nh_serialize(g: *i64, S: *i64) -> i64 {
  var i: i64=0
  while i<NH_HDRN { S[i]=g[i]; i=i+1 }
  let a: *i64 = (g as i64 + NG_O_ENT*8) as *i64
  let n: i64 = en_count(a)
  S[NH_HDRN]=n
  var k: i64=0
  while k<NH_CAP*4 { S[NH_HDRN+1+k]=0; k=k+1 }
  k=0
  while k<n {
      let h: i64 = en_nth(a,k)
      let b: i64 = NH_HDRN+1+k*4
      let v0: i64 = en_get(a,h,0)
      let v1: i64 = en_get(a,h,1)
      let v2: i64 = en_get(a,h,2)
      let v3: i64 = en_get(a,h,3)
      S[b]=v0
      S[b+1]=v1
      S[b+2]=v2
      S[b+3]=v3
      k=k+1
  }
  let item: *i64 = (g as i64 + NG_O_ITEM*8) as *i64
  let ib: i64 = NH_HDRN+1+NH_CAP*4
  var q: i64=0
  while q<NH_NITEM*3 { S[ib+q]=item[q]; q=q+1 }
  return NH_NSV
284}
285// restore a game from S into a (possibly ZEROED) arena: header, regenerated structure, monsters, items
286func nh_restore(g: *i64, S: *i64) -> i64 {
  var i: i64=0
  while i<32 { g[i]=0; i=i+1 }
  g[F_WS]=S[F_WS]
  g[F_DEPTH]=S[F_DEPTH]
  nh_genstruct(g)               // grid + stairs: pure function of (ws,depth), matches by determinism
  // copy the FULL header AFTER genstruct: genstruct clobbers F_GENRNG (it re-runs the carve), and the
  // saved value is the post-populate stream -- restoring it after keeps the checksum bit-exact.
  i=0
  while i<NH_HDRN { g[i]=S[i]; i=i+1 }
  let a: *i64 = (g as i64 + NG_O_ENT*8) as *i64
  en_init(a, NH_CAP, NH_NCOMP)
  let n: i64 = S[NH_HDRN]
  var k: i64=0
  while k<n {
      let b: i64 = NH_HDRN+1+k*4
      let h: i64 = en_spawn(a)
      en_set(a,h,0,S[b])
      en_set(a,h,1,S[b+1])
      en_set(a,h,2,S[b+2])
      en_set(a,h,3,S[b+3])
      k=k+1
  }
  let item: *i64 = (g as i64 + NG_O_ITEM*8) as *i64
  let ib: i64 = NH_HDRN+1+NH_CAP*4
  var q: i64=0
  while q<NH_NITEM*3 { item[q]=S[ib+q]; q=q+1 }
  let hud: *i64 = (g as i64 + NG_O_HUD*8) as *i64
  gh_init(hud, 5)               // UI state is transient: fresh menu machine on restore, game state untouched
  return 0
316}
317func nh_ckv(ck: i64, v0: i64) -> i64 {
  var v: i64 = v0
  if v<0 { v = (0-v)*2+1 } else { v = v*2 }
  return (ck*131 + v) & 0x7FFFFFFFFFFFFFFF
321}
322// order-sensitive rolling checksum of the FULL game-visible state.
323// DELIBERATELY INDEPENDENT of nh_serialize: it walks the live arena directly, so a serializer that
324// "forgets a field" produces a restore whose checksum diverges -- the T6 transparency tooth catches it.
325// (A ck routed THROUGH the serializer would inherit the same amnesia and prove nothing.)
326func nh_ck(g: *i64) -> i64 {
  var ck: i64 = 1469598103
  var i: i64=0
  while i<NH_HDRN { ck = nh_ckv(ck, g[i]); i=i+1 }
  let a: *i64 = (g as i64 + NG_O_ENT*8) as *i64
  let n: i64 = en_count(a)
  ck = nh_ckv(ck, n)
  var k: i64=0
  while k<n {
      let h: i64 = en_nth(a,k)
      var c: i64=0
      while c<4 {
          let v: i64 = en_get(a,h,c)
          ck = nh_ckv(ck, v)
          c=c+1
      }
      k=k+1
  }
  let item: *i64 = (g as i64 + NG_O_ITEM*8) as *i64
  var q: i64=0
  while q<NH_NITEM*3 { ck = nh_ckv(ck, item[q]); q=q+1 }
  return ck
348}
349// is any OTHER monster on (x,y)?
350func nh_moncell(a: *i64, x: i64, y: i64, skip: i64) -> i64 {
  var k: i64=0
  while k<en_count(a) {
      let h: i64 = en_nth(a,k)
      if h!=skip {
          let ox: i64 = en_get(a,h,0)
          let oy: i64 = en_get(a,h,1)
          if ox==x { if oy==y { return 1 } }
      }
      k=k+1
  }
  return 0
362}
363// one game turn. returns the handle of a monster KILLED this turn (0 if none) -- the stale-handle witness.
364func nh_tick(g: *i64) -> i64 {
  if g[F_WIN]==1 { return 0 }
  let grid: *i64 = (g as i64 + NG_O_GRID*8) as *i64
  let a: *i64 = (g as i64 + NG_O_ENT*8) as *i64
  let item: *i64 = (g as i64 + NG_O_ITEM*8) as *i64
  var killed: i64 = 0
  let px: i64 = g[F_PX]
  let py: i64 = g[F_PY]
  // ---- player action: attack an adjacent monster, else descend on stairs, else A* step toward stairs ----
  var adj: i64 = 0
  var k: i64=0
  while k<en_count(a) {
      if adj==0 {
          let h: i64 = en_nth(a,k)
          let mx: i64 = en_get(a,h,0)
          let my: i64 = en_get(a,h,1)
          let dd: i64 = nabs(mx-px)+nabs(my-py)
          if dd==1 { adj=h }
      }
      k=k+1
  }
  // DIALECT NOTE: no `else if` / `||` / `else` in this file from here on -- multiline else-branches
  // DESYNC the nx_cc parser (found by THIS gate; minimal repro nx_wire_probe.nx aux2: the next func
  // fuses into this one as an empty stub and the binary runs silent exit-0). The certified parts are
  // mostly plain-if code; this file uses flag vars instead of else-chains.
  var acted: i64=0
  if adj!=0 {
      acted=1
      g[F_ATT]=g[F_ATT]+1
      let dmg: i64 = 4 + g[F_LVL]*2
      let mhp: i64 = en_get(a,adj,2) - dmg
      if mhp<=0 {
          let reward: i64 = en_get(a,adj,3)
          en_destroy(a,adj)
          killed=adj
          g[F_KILLS]=g[F_KILLS]+1
          g[F_XP]=g[F_XP]+reward
          let nl: i64 = rs_level_for_xp(g[F_XP], NH_XB, NH_XQ)
          if nl>g[F_LVL] {
              g[F_LVL]=nl
              let mh: i64 = rs_derived_hp(NH_CON, nl, NH_HPB, NH_HPC, NH_HPL)
              g[F_HP]=mh
          }
      }
      if mhp>0 { en_set(a,adj,2,mhp) }
  }
  if acted==0 { if px==g[F_SX] { if py==g[F_SY] {
      acted=1
      g[F_DEPTH]=g[F_DEPTH]+1
      if g[F_DEPTH]>NH_DEPTH { g[F_WIN]=1 }
      if g[F_DEPTH]<=NH_DEPTH {
          let leftover: i64 = en_count(a)
          g[F_ABAND]=g[F_ABAND]+leftover
          nh_genstruct(g)
          nh_populate(g)
      }
  } } }
  if acted==0 { if g[F_WIN]==0 {
      let pg: *i64 = (g as i64 + NG_O_G*8) as *i64
      let pf: *i64 = (g as i64 + NG_O_F*8) as *i64
      let pc: *i64 = (g as i64 + NG_O_CAME*8) as *i64
      let po: *i64 = (g as i64 + NG_O_OPENF*8) as *i64
      let pz: *i64 = (g as i64 + NG_O_CLOSED*8) as *i64
      let pp: *i64 = (g as i64 + NG_O_PATH*8) as *i64
      let plen: i64 = pf_astar(grid, NH_W, NH_H, px, py, g[F_SX], g[F_SY], pg, pf, pc, po, pz, pp)
      if plen>=1 {
          let nxt: i64 = pp[1]
          let nx: i64 = nxt % NH_W
          let ny: i64 = nxt / NH_W
          // never step ONTO a monster (an adjacent one would have been attacked; this is belt+braces)
          let occ: i64 = nh_moncell(a, nx, ny, 0)
          if occ==0 { g[F_PX]=nx; g[F_PY]=ny; g[F_PSTEPS]=g[F_PSTEPS]+1 }
      }
  } }
  // ---- pickup ----
  let qx: i64 = g[F_PX]
  let qy: i64 = g[F_PY]
  var q: i64=0
  while q<NH_NITEM {
      if item[q*3+2]==0 { if item[q*3]==qx { if item[q*3+1]==qy {
          item[q*3+2]=1
          g[F_RATION]=g[F_RATION]+1
          g[F_PICKED]=g[F_PICKED]+1
      } } }
      q=q+1
  }
  // ---- craft: 2 rations -> 1 feast (one combine per turn) ----
  if g[F_RATION]>=2 {
      g[F_RATION]=g[F_RATION]-2
      g[F_FEAST]=g[F_FEAST]+1
      g[F_COMB]=g[F_COMB]+1
  }
  // ---- eat when hurt, THROUGH THE MENU (bit 18): the selection CAUSES the eat. Feast-first policy
  // is encoded as menu ORDER (feast listed first, cursor selects item 0 after a FULL WRAP -- the wrap
  // exercises gh_menu_move's both-directions arithmetic on every single eat of every run). Same
  // decisions as the old inline chain => game-state evolution and every banked checksum unchanged. ----
  let maxhp: i64 = rs_derived_hp(NH_CON, g[F_LVL], NH_HPB, NH_HPC, NH_HPL)
  let hud: *i64 = (g as i64 + NG_O_HUD*8) as *i64
  if g[F_HP] < maxhp {
      var edible: i64=0
      if g[F_FEAST]>0 { edible=edible+1 }
      if g[F_RATION]>0 { edible=edible+1 }
      if edible>0 {
          gh_menu_open(hud, edible)
          var slot: i64=0
          if g[F_FEAST]>0 { gh_menu_item(hud, slot, 1, g[F_FEAST]); slot=slot+1 }
          if g[F_RATION]>0 { gh_menu_item(hud, slot, 2, g[F_RATION]); slot=slot+1 }
          let choice: i64 = wh_menu_wrapsel(hud, edible)   // MIGRATED: shared variable-menu wrap+select
          if choice==1 {
              g[F_FEAST]=g[F_FEAST]-1
              g[F_HP]=g[F_HP]+NH_HEAL_F
              g[F_USED]=g[F_USED]+1
              g[F_EATF]=g[F_EATF]+1
          }
          if choice==2 {
              g[F_RATION]=g[F_RATION]-1
              g[F_HP]=g[F_HP]+NH_HEAL_R
              g[F_USED]=g[F_USED]+1
              g[F_EATR]=g[F_EATR]+1
          }
      }
      if g[F_HP]>maxhp { g[F_HP]=maxhp }
  }
  // ---- monsters: bite when adjacent, chase when in aggro range ----
  // ⚠nx_cc PARSER TRAP (found by THIS gate, minimal repro nx_wire_probe.nx aux2): a var/let declared
  // DIRECTLY inside an `else if` branch DESYNCS the parser -- later funcs fuse into this one as empty
  // stubs and the binary exits 0 silently. Workaround: hoist ALL decls above the if/else-if.
  var mI: i64=0
  var msx: i64=0
  var msy: i64=0
  var mtx: i64=0
  var mty: i64=0
  var moved: i64=0
  var occ2: i64=0
  var occ3: i64=0
  let mtot: i64 = en_count(a)
  while mI<mtot {
      let h2: i64 = en_nth(a,mI)
      let mx2: i64 = en_get(a,h2,0)
      let my2: i64 = en_get(a,h2,1)
      let da: i64 = nabs(mx2-g[F_PX])
      let db: i64 = nabs(my2-g[F_PY])
      let d2: i64 = da+db
      if d2==1 {
          g[F_HP]=g[F_HP]-NH_BITE
          g[F_BITES]=g[F_BITES]+1
      }
      if d2>1 { if d2<=NH_AGGRO {
          msx=0
          if g[F_PX]>mx2 { msx=1 }
          if g[F_PX]<mx2 { msx=0-1 }
          moved=0
          if msx!=0 {
              mtx=mx2+msx
              if grid[my2*NH_W+mtx]==0 {
                  occ2 = nh_moncell(a,mtx,my2,h2)
                  var onp: i64=0
                  if mtx==g[F_PX] { if my2==g[F_PY] { onp=1 } }
                  if occ2==0 { if onp==0 { en_set(a,h2,0,mtx); moved=1 } }
              }
          }
          if moved==0 {
              msy=0
              if g[F_PY]>my2 { msy=1 }
              if g[F_PY]<my2 { msy=0-1 }
              if msy!=0 {
                  mty=my2+msy
                  if grid[mty*NH_W+mx2]==0 {
                      occ3 = nh_moncell(a,mx2,mty,h2)
                      var onp2: i64=0
                      if mx2==g[F_PX] { if mty==g[F_PY] { onp2=1 } }
                      if occ3==0 { if onp2==0 { en_set(a,h2,1,mty) } }
                  }
              }
          }
      } }
      mI=mI+1
  }
  g[F_TURN]=g[F_TURN]+1
  return killed
544}
545// T10 instrument: replay a real game for `turns`, binding the HUD to live state and rendering every
546// turn; returns the rolling chain of frame checksums. out[0]=frames that CHANGED vs the previous
547// (a state-blind renderer scores 0), out[1]=final-frame ink px, out[2]=menu selections made in-loop.
548func nh_hudchain(seed: i64, turns: i64, out: *i64) -> i64 {
  let g: *i64 = sys_mmap(NG_WORDS*8) as *i64
  nh_new(g, seed)
  let font: *u8 = font8x8_table()
  let labels: *i64 = sys_mmap(8*8) as *i64
  labels[0]="HP" as i64
  labels[1]="LVL" as i64
  labels[2]="DEPTH" as i64
  labels[3]="KILLS" as i64
  labels[4]="FOOD" as i64
  let mlabels: *i64 = sys_mmap(8*8) as *i64
  mlabels[0]="feast" as i64
  mlabels[1]="ration" as i64
  let fb: *u8 = sys_mmap(72000)
  let hud: *i64 = (g as i64 + NG_O_HUD*8) as *i64
  var chain: i64 = 1469598103
  var prev: i64 = 0
  var moved: i64 = 0
  var t: i64 = 0
  while t < turns {
      nh_tick(g)
      gh_slot_set(hud, 0, g[F_HP])
      gh_slot_set(hud, 1, g[F_LVL])
      gh_slot_set(hud, 2, g[F_DEPTH])
      gh_slot_set(hud, 3, g[F_KILLS])
      gh_slot_set(hud, 4, g[F_RATION]+g[F_FEAST])
      var z: i64=0
      while z<72000 { fb[z]=0 as u8; z=z+1 }
      gh_render(hud, fb, 200, 120, font, labels, mlabels)
      let fk: i64 = gh_frame_ck(fb, 200, 120)
      if t>0 { if fk!=prev { moved=moved+1 } }
      prev=fk
      chain = (chain*131 + (fk & 0xFFFFFFFF)) & 0x7FFFFFFFFFFFFFFF
      t=t+1
  }
  out[0]=moved
  out[1]=gh_ink(fb, 200, 120)
  out[2]=hud[GH_F_NSEL]
  return chain
587}
588// T11/T12 helpers. nh_decint writes v0 in decimal at b[at..], returns the new cursor.
589// nh_clearfb / nh_filled / nh_fbck operate on the i64 trimesh framebuffer (same shapes the
590// certified nx_bunny_gate uses on this exact part chain).
591func nh_decint(b: *u8, at: i64, v0: i64) -> i64 {
  var a: i64 = at
  var v: i64 = v0
  if v < 0 { b[a]=45 as u8; a=a+1; v=0-v }
  let t: *u8 = sys_mmap(24)
  var k: i64 = 0
  if v == 0 { t[0]=48 as u8; k=1 }
  while v > 0 { t[k]=(48+(v%10)) as u8; v=v/10; k=k+1 }
  var q: i64 = k-1
  while q >= 0 { b[a]=t[q]; a=a+1; q=q-1 }
  return a
602}
603func nh_clearfb(fb: *i64, n: i64, c: i64) -> i64 { var i: i64=0; while i<n { fb[i]=c; i=i+1 } return 0 }
604func nh_filled(fb: *i64, n: i64, bg: i64) -> i64 { var c: i64=0; var i: i64=0; while i<n { if fb[i]!=bg { c=c+1 } i=i+1 } return c }
605func nh_fbck(fb: *i64, n: i64) -> i64 { var ck: i64=1469598103; var i: i64=0; while i<n { ck = nh_ckv(ck, fb[i]); i=i+1 } return ck }
606// run until win or maxturns; returns first-killed handle (the stale witness)
607func nh_run_full(g: *i64) -> i64 {
  var firstkill: i64=0
  var go: i64=1
  while go==1 {
      if g[F_WIN]==1 { go=0 }
      if g[F_TURN]>=NH_MAXT { go=0 }
      if g[F_HP]<=0 { go=0 }
      if go==1 {
          let kh: i64 = nh_tick(g)
          if kh!=0 { if firstkill==0 { firstkill=kh } }
      }
  }
  return firstkill
620}
621
622func main() -> i64 {
  ww("=== nx_wire_nethack_gate: does NetHack's genre loop actually run on the certified parts? ===\n\n")
  var pass: i64 = 0
  var checks: i64 = 0
  var mask: i64 = 0
  let SEED: i64 = 4242
  let g1: *i64 = sys_mmap(NG_WORDS*8) as *i64
  let g2: *i64 = sys_mmap(NG_WORDS*8) as *i64
  let S: *i64 = sys_mmap(NH_NSV*8+64) as *i64
  let S2: *i64 = sys_mmap(NH_NSV*8+64) as *i64
632
  // ---------- T1 procgen-world (bit 3): deterministic, seed-diverse, stairs reachable ----------
  checks=checks+1
  nh_new(g1, SEED)
  nh_new(g2, SEED)
  let cka: i64 = nh_ck(g1)
  let ckb: i64 = nh_ck(g2)
  nh_new(g2, SEED+1)
  let grid1: *i64 = (g1 as i64 + NG_O_GRID*8) as *i64
  let grid2: *i64 = (g2 as i64 + NG_O_GRID*8) as *i64
  var diff: i64=0
  var i: i64=0
  while i<NH_W*NH_H { if grid1[i]!=grid2[i] { diff=diff+1 } i=i+1 }
  let pg1: *i64 = (g1 as i64 + NG_O_G*8) as *i64
  let pf1: *i64 = (g1 as i64 + NG_O_F*8) as *i64
  let pc1: *i64 = (g1 as i64 + NG_O_CAME*8) as *i64
  let po1: *i64 = (g1 as i64 + NG_O_OPENF*8) as *i64
  let pz1: *i64 = (g1 as i64 + NG_O_CLOSED*8) as *i64
  let pp1: *i64 = (g1 as i64 + NG_O_PATH*8) as *i64
  let plen0: i64 = pf_astar(grid1, NH_W, NH_H, 1, 1, g1[F_SX], g1[F_SY], pg1, pf1, pc1, po1, pz1, pp1)
  // every monster and item sits on a floor cell
  let a1: *i64 = (g1 as i64 + NG_O_ENT*8) as *i64
  let item1: *i64 = (g1 as i64 + NG_O_ITEM*8) as *i64
  var badcell: i64=0
  var k: i64=0
  while k<en_count(a1) {
      let h: i64 = en_nth(a1,k)
      let mx: i64 = en_get(a1,h,0)
      let my: i64 = en_get(a1,h,1)
      if grid1[my*NH_W+mx]!=0 { badcell=badcell+1 }
      k=k+1
  }
  k=0
  while k<NH_NITEM {
      let ix: i64=item1[k*3]
      let iy: i64=item1[k*3+1]
      if grid1[iy*NH_W+ix]!=0 { badcell=badcell+1 }
      k=k+1
  }
  var t1: i64=0
  if cka==ckb { if diff>=30 { if plen0>=1 { if badcell==0 {
      ww("T1 GREEN procgen: same seed identical (ck "); wn(cka)
      ww("), seed+1 differs in "); wn(diff); ww(" cells, stairs reachable (path "); wn(plen0)
      ww("), 0 off-floor placements\n")
      t1=1; pass=pass+1
      mask=mask+nbit(3)
  } } } }
  if t1==0 {
      ww("T1 RED   procgen: ckA="); wn(cka); ww(" ckB="); wn(ckb)
      ww(" diff="); wn(diff); ww(" plen="); wn(plen0); ww(" badcell="); wn(badcell); ww("\n")
  }
683
  // ---------- T2 pathfinding-ai (bit 7): the A* path is valid cell-by-cell ----------
  checks=checks+1
  var pathok: i64=1
  i=1
  while i<=plen0 {
      let c0: i64 = pp1[i-1]
      let c1: i64 = pp1[i]
      let x0: i64 = c0 % NH_W
      let y0: i64 = c0 / NH_W
      let x1: i64 = c1 % NH_W
      let y1: i64 = c1 / NH_W
      let ad: i64 = nabs(x1-x0)+nabs(y1-y0)
      if ad!=1 { pathok=0 }
      if grid1[c1]!=0 { pathok=0 }
      i=i+1
  }
  var t2: i64=0
  if plen0>=1 { if pathok==1 {
      ww("T2 GREEN pathfinding: pf_astar path of "); wn(plen0)
      ww(" steps is 4-adjacent floor cell-by-cell (the part drives every player move)\n")
      t2=1; pass=pass+1
      mask=mask+nbit(7)
  } }
  if t2==0 { ww("T2 RED   pathfinding: plen="); wn(plen0); ww(" pathok="); wn(pathok); ww("\n") }
708
  // ---------- full deterministic run (the actual game) ----------
  nh_new(g1, SEED)
  let fk: i64 = nh_run_full(g1)
  let a1b: *i64 = (g1 as i64 + NG_O_ENT*8) as *i64
  let fck: i64 = nh_ck(g1)
  let runwin: i64 = g1[F_WIN]
  let runturn: i64 = g1[F_TURN]
  let runkills: i64 = g1[F_KILLS]
  let runxp: i64 = g1[F_XP]
  let runlvl: i64 = g1[F_LVL]
  ww("  [run] turns="); wn(g1[F_TURN]); ww(" depth="); wn(g1[F_DEPTH]); ww(" win="); wn(g1[F_WIN])
  ww(" kills="); wn(g1[F_KILLS]); ww(" xp="); wn(g1[F_XP]); ww(" level="); wn(g1[F_LVL])
  ww(" hp="); wn(g1[F_HP]); ww(" picked="); wn(g1[F_PICKED]); ww(" used="); wn(g1[F_USED])
  ww(" combines="); wn(g1[F_COMB]); ww(" psteps="); wn(g1[F_PSTEPS]); ww(" bites="); wn(g1[F_BITES])
  ww(" ck="); wn(fck); ww("\n")
724
  // ---------- T3 entity-component-sim (bit 6): stale handle refused, census exact ----------
  checks=checks+1
  var t3: i64=0
  var stale: i64=0-1
  if fk!=0 { stale = en_valid(a1b, fk) }
  let alive: i64 = en_count(a1b)
  let census: i64 = g1[F_SPAWNED] - g1[F_KILLS] - g1[F_ABAND]
  if fk!=0 { if stale==0 { if alive==census {
      ww("T3 GREEN entity store: first-killed monster's handle "); wn(fk)
      ww(" is DETECTABLY STALE (en_valid=0); census exact: spawned "); wn(g1[F_SPAWNED])
      ww(" - kills "); wn(g1[F_KILLS]); ww(" - abandoned-on-descend "); wn(g1[F_ABAND])
      ww(" = alive "); wn(alive); ww("\n")
      t3=1; pass=pass+1
      mask=mask+nbit(6)
  } } }
  if t3==0 {
      ww("T3 RED   entity: firstkill="); wn(fk); ww(" stale-valid="); wn(stale)
      ww(" alive="); wn(alive); ww(" census="); wn(census); ww("\n")
  }
744
  // ---------- T4 rpg-stats-progression (bit 9): curve honored, level inverse exact, hp derived ----------
  checks=checks+1
  let wantlvl: i64 = rs_level_for_xp(g1[F_XP], NH_XB, NH_XQ)
  let maxhp: i64 = rs_derived_hp(NH_CON, g1[F_LVL], NH_HPB, NH_HPC, NH_HPL)
  let thresh: i64 = rs_xp_for_level(g1[F_LVL], NH_XB, NH_XQ)
  var t4: i64=0
  if g1[F_XP]>0 { if g1[F_LVL]>1 { if g1[F_LVL]==wantlvl { if g1[F_HP]<=maxhp { if g1[F_XP]>=thresh {
      ww("T4 GREEN rpgstats: xp "); wn(g1[F_XP]); ww(" -> level "); wn(g1[F_LVL])
      ww(" == rs_level_for_xp EXACT (threshold "); wn(thresh); ww(" <= xp), hp "); wn(g1[F_HP])
      ww(" <= derived max "); wn(maxhp); ww("\n")
      t4=1; pass=pass+1
      mask=mask+nbit(9)
  } } } } }
  if t4==0 {
      ww("T4 RED   rpgstats: xp="); wn(g1[F_XP]); ww(" lvl="); wn(g1[F_LVL])
      ww(" want="); wn(wantlvl); ww(" hp="); wn(g1[F_HP]); ww(" maxhp="); wn(maxhp); ww("\n")
  }
762
  // ---------- T5 inventory-crafting (bit 11): the ledger conserves exactly ----------
  checks=checks+1
  // picked rations = held + eaten + 2*crafted ; crafted feasts = held + eaten
  let led1: i64 = g1[F_RATION] + g1[F_EATR] + 2*g1[F_COMB]
  let led2: i64 = g1[F_FEAST] + g1[F_EATF]
  var t5: i64=0
  if g1[F_PICKED]>=3 { if g1[F_USED]>=1 { if g1[F_COMB]>=1 {
      if g1[F_PICKED]==led1 { if g1[F_COMB]==led2 {
          ww("T5 GREEN inventory-crafting: picked "); wn(g1[F_PICKED]); ww(" == held ")
          wn(g1[F_RATION]); ww(" + eaten "); wn(g1[F_EATR]); ww(" + 2*crafted "); wn(g1[F_COMB])
          ww("; feasts "); wn(g1[F_COMB]); ww(" == held "); wn(g1[F_FEAST]); ww(" + eaten "); wn(g1[F_EATF])
          ww(" (conserved, "); wn(g1[F_USED]); ww(" consumed)\n")
          t5=1; pass=pass+1
          mask=mask+nbit(11)
      } }
  } } }
  if t5==0 {
      ww("T5 RED   inventory: picked="); wn(g1[F_PICKED]); ww(" led1="); wn(led1)
      ww(" comb="); wn(g1[F_COMB]); ww(" led2="); wn(led2); ww(" used="); wn(g1[F_USED]); ww("\n")
  }
783
  // ---------- T6 save-load TRANSPARENCY (bit 15, FLAGSHIP) ----------
  checks=checks+1
  // run A: continuous 0..T2W, banking a checksum EVERY turn in the window T1W..T2W
  let bank: *i64 = sys_mmap((NH_T2W-NH_T1W+2)*8) as *i64
  nh_new(g1, SEED)
  var t: i64=0
  while t<NH_T1W { nh_tick(g1); t=t+1 }
  // non-vacuity guard: the world at the save point must be NON-TRIVIAL
  let g1a: *i64 = (g1 as i64 + NG_O_ENT*8) as *i64
  let nv_alive: i64 = en_count(g1a)
  let nv_xp: i64 = g1[F_XP]
  let nv_picked: i64 = g1[F_PICKED]
  let ckt1: i64 = nh_ck(g1)
  bank[0]=ckt1
  t=NH_T1W
  while t<NH_T2W { nh_tick(g1); t=t+1; let c: i64 = nh_ck(g1); bank[t-NH_T1W]=c }
  let contwin: i64 = g1[F_WIN]
  // run B: fresh game to T1W, SAVE, load into a ZEROED arena, resume to T2W comparing every turn
  nh_new(g2, SEED)
  t=0
  while t<NH_T1W { nh_tick(g2); t=t+1 }
  nh_serialize(g2,S2)
  let sr: i64 = gs_save("knowledge/nx_wire_nethack_mid.sav" as *u8, NH_SCHEMA, S2, NH_NSV, 20260720)
  var zi: i64=0
  while zi<NG_WORDS { g2[zi]=0; zi=zi+1 }          // ZERO the whole arena: nothing survives but the file
  let Sl: *i64 = sys_mmap(NH_NSV*8+64) as *i64
  let lr: i64 = gs_load("knowledge/nx_wire_nethack_mid.sav" as *u8, Sl, NH_NSV, 0 as *i64)
  nh_restore(g2, Sl)
  let ckr: i64 = nh_ck(g2)
  var mismatch: i64=0
  if ckr!=bank[0] { mismatch=mismatch+1 }
  t=NH_T1W
  while t<NH_T2W {
      nh_tick(g2)
      t=t+1
      let c2: i64 = nh_ck(g2)
      if c2!=bank[t-NH_T1W] { mismatch=mismatch+1 }
  }
  // field-by-field final compare
  nh_serialize(g1,S)
  nh_serialize(g2,S2)
  var fdiff: i64=0
  i=0
  while i<NH_NSV { if S[i]!=S2[i] { fdiff=fdiff+1 } i=i+1 }
  var t6: i64=0
  if sr>0 { if lr==NH_NSV { if mismatch==0 { if fdiff==0 { if nv_alive>=1 { if nv_xp>0 { if nv_picked>=1 { if contwin==0 {
      ww("T6 GREEN save/load TRANSPARENT: save at turn "); wn(NH_T1W)
      ww(" -> load into ZEROED arena -> resume to "); wn(NH_T2W)
      ww(": all "); wn(NH_T2W-NH_T1W+1); ww(" per-turn checksums identical, 0/"); wn(NH_NSV)
      ww(" state fields differ (non-trivial world: alive="); wn(nv_alive)
      ww(" xp="); wn(nv_xp); ww(" picked="); wn(nv_picked); ww(")\n")
      t6=1; pass=pass+1
      mask=mask+nbit(15)
  } } } } } } } }
  if t6==0 {
      ww("T6 RED   transparency: save="); wn(sr); ww(" load="); wn(lr)
      ww(" ck-mismatches="); wn(mismatch); ww(" field-diffs="); wn(fdiff)
      ww(" alive="); wn(nv_alive); ww(" xp="); wn(nv_xp); ww(" picked="); wn(nv_picked)
      ww(" contwin="); wn(contwin); ww("\n")
  }
844
  // ---------- T7 corruption refused, state untouched ----------
  checks=checks+1
  let lenp: *i64 = sys_mmap(8) as *i64
  lenp[0]=0
  let raw: *u8 = sys_read_file("knowledge/nx_wire_nethack_mid.sav" as *u8, lenp)
  var t7: i64=0
  if (raw as i64)!=0 {
      let rl: i64 = lenp[0]
      let flip: i64 = 48+24                      // a payload byte (past the 48B header)
      raw[flip] = (raw[flip] as i64 ^ 255) as u8
      let cfd: i64 = sys_openat_wr("knowledge/nx_wire_nethack_corrupt.sav" as *u8, 0x1a4)
      if cfd>=0 {
          sys_write(cfd, raw, rl)
          sys_close(cfd)
          let Sc: *i64 = sys_mmap(NH_NSV*8+64) as *i64
          Sc[0]=777777
          let cr: i64 = gs_load("knowledge/nx_wire_nethack_corrupt.sav" as *u8, Sc, NH_NSV, 0 as *i64)
          if cr==(0-6) { if Sc[0]==777777 { t7=1 } }
          if t7==1 {
              ww("T7 GREEN corruption refused LOUD (rc=-6 CHECKSUM-CORRUPT) and caller state untouched\n")
              pass=pass+1
          } else {
              ww("T7 RED   corrupt load rc="); wn(cr); ww(" sentinel="); wn(Sc[0]); ww("\n")
          }
      } else { ww("T7 RED   cannot write corrupt copy\n") }
  } else { ww("T7 RED   cannot read the mid-save back\n") }
871
  // ---------- T8 determinism: two independent full runs, bit-identical ----------
  checks=checks+1
  nh_new(g2, SEED)
  nh_run_full(g2)
  let fck2: i64 = nh_ck(g2)
  var t8: i64=0
  if fck==fck2 { if runwin==g2[F_WIN] {
      ww("T8 GREEN deterministic: two independent full runs -> identical final checksum "); wn(fck)
      ww(" at turn "); wn(g2[F_TURN]); ww("\n")
      t8=1; pass=pass+1
  } }
  if t8==0 { ww("T8 RED   run1 ck="); wn(fck); ww(" run2 ck="); wn(fck2); ww("\n") }
884
  // ---------- T9 anti-vacuity: the LOOP is a real game that was actually played and WON ----------
  checks=checks+1
  var t9: i64=0
  if g2[F_WIN]==1 { if g2[F_TURN]>20 { if g2[F_TURN]<NH_MAXT { if g2[F_KILLS]>=4 { if g2[F_DEPTH]==NH_DEPTH+1 { if g2[F_HP]>0 {
      ww("T9 GREEN the game was PLAYED and WON: "); wn(NH_DEPTH); ww(" dungeon levels cleared in ")
      wn(g2[F_TURN]); ww(" turns, "); wn(g2[F_KILLS]); ww(" kills, survived at hp "); wn(g2[F_HP]); ww("\n")
      t9=1; pass=pass+1
  } } } } } }
  if t9==0 {
      ww("T9 RED   loop hollow: win="); wn(g2[F_WIN]); ww(" turns="); wn(g2[F_TURN])
      ww(" kills="); wn(g2[F_KILLS]); ww(" depth="); wn(g2[F_DEPTH]); ww(" hp="); wn(g2[F_HP]); ww("\n")
  }
897
  // ---------- T10 ui-menus-hud (bit 18): menu CAUSES the eats; HUD binds live state per turn ----------
  checks=checks+1
  let hud2: *i64 = (g2 as i64 + NG_O_HUD*8) as *i64
  let menusel: i64 = hud2[GH_F_NSEL]
  let o10a: *i64 = sys_mmap(4*8) as *i64
  let o10b: *i64 = sys_mmap(4*8) as *i64
  let ch10a: i64 = nh_hudchain(SEED, NH_T2W, o10a)
  let ch10b: i64 = nh_hudchain(SEED, NH_T2W, o10b)
  var t10: i64=0
  if ch10a==ch10b { if o10a[0]>=2 { if o10a[1]>=NH_HUDINK { if menusel>=1 { if menusel==g2[F_USED] {
      ww("T10 GREEN ui-menus-hud: "); wn(menusel); ww(" eats ALL caused by menu selections (nsel==used), HUD ")
      ww("render chain deterministic over "); wn(NH_T2W); ww(" turns ("); wn(o10a[0])
      ww(" frame changes, "); wn(o10a[1]); ww(" ink px)\n")
      t10=1; pass=pass+1
      mask=mask+nbit(18)
  } } } } }
  if t10==0 {
      ww("T10 RED   ui-menus-hud: chA="); wn(ch10a); ww(" chB="); wn(ch10b)
      ww(" changes="); wn(o10a[0]); ww(" ink="); wn(o10a[1])
      ww(" nsel="); wn(menusel); ww(" used="); wn(g2[F_USED]); ww("\n")
  }
919
  // ---------- T11 text-render-typography (bit 14): the status line is GLYPH TEXT bound to LIVE
  // run state, with EXACT ink accounting DERIVED FROM THE FONT TABLE ITSELF (zero picked numbers:
  // expected ink = sum of set bits over the exact glyphs drawn; cells disjoint at 9px pitch = 8px
  // glyph + 1px gap, drawn inside 200x120 with no clipping, so equality is exact by construction).
  // A stub that blits a cached bitmap or a constant blob cannot match the per-state glyph
  // population, and a text renderer not bound to state cannot make the mid-state frame differ.
  checks=checks+1
  let font11: *u8 = font8x8_table()
  let fb11:  *u8 = sys_mmap(72000)
  let fb11b: *u8 = sys_mmap(72000)
  let fb11c: *u8 = sys_mmap(72000)
  let s11: *u8 = sys_mmap(64)
  var sl: i64 = 0
  s11[sl]=84 as u8; sl=sl+1
  sl = nh_decint(s11, sl, g2[F_TURN])
  s11[sl]=88 as u8; sl=sl+1
  sl = nh_decint(s11, sl, g2[F_XP])
  s11[sl]=75 as u8; sl=sl+1
  sl = nh_decint(s11, sl, g2[F_KILLS])
  s11[sl]=0 as u8
  let s11c: *u8 = sys_mmap(64)
  var slc: i64 = 0
  s11c[slc]=84 as u8; slc=slc+1
  slc = nh_decint(s11c, slc, NH_T1W)
  s11c[slc]=88 as u8; slc=slc+1
  slc = nh_decint(s11c, slc, nv_xp)
  s11c[slc]=0 as u8
  var exp11: i64 = 0
  var ci11: i64 = 0
  while s11[ci11]!=(0 as u8) {
      let ch11: i64 = s11[ci11] & 0xff
      let go11: i64 = (ch11-0x20)*8
      var r11: i64 = 0
      while r11<8 {
          var b11: i64 = font11[go11+r11] & 0xff
          while b11>0 { exp11 = exp11 + (b11%2); b11=b11/2 }
          r11=r11+1
      }
      gh_glyph(fb11,  200, 120, font11, ch11, 4+ci11*9, 8)
      gh_glyph(fb11b, 200, 120, font11, ch11, 4+ci11*9, 8)
      ci11=ci11+1
  }
  var cc11: i64 = 0
  while s11c[cc11]!=(0 as u8) {
      gh_glyph(fb11c, 200, 120, font11, s11c[cc11] & 0xff, 4+cc11*9, 8)
      cc11=cc11+1
  }
  let ink11: i64 = gh_ink(fb11, 200, 120)
  let cka11: i64 = gh_frame_ck(fb11, 200, 120)
  let ckb11: i64 = gh_frame_ck(fb11b, 200, 120)
  let ckc11: i64 = gh_frame_ck(fb11c, 200, 120)
  var t11: i64=0
  if exp11>0 { if ink11==exp11 { if cka11==ckb11 { if ckc11!=cka11 { if sl>=6 { if slc>=4 {
      ww("T11 GREEN text-render: status line "); ww(s11); ww(" drawn as "); wn(sl)
      ww(" glyphs, ink "); wn(ink11); ww(" px == font-table-derived expectation EXACT, deterministic, ")
      ww("and the mid-save state renders a DIFFERENT frame (state-bound, not a cached bitmap)\n")
      t11=1; pass=pass+1
      mask=mask+nbit(14)
  } } } } } }
  if t11==0 {
      ww("T11 RED   text-render: exp="); wn(exp11); ww(" ink="); wn(ink11)
      ww(" ckA="); wn(cka11); ww(" ckB="); wn(ckb11); ww(" ckC="); wn(ckc11)
      ww(" sl="); wn(sl); ww(" slc="); wn(slc); ww("\n")
  }
984
  // ---------- T12 asset-pipeline-import (bit 25): the WON game's victory screen imports and
  // renders the standard-corpus mesh through the certified OBJ import chain (nx_objload ->
  // nx_trimesh), the exact part nx_bunny_gate certifies. Provenance is proven by the EXACT
  // banked Stanford canonical counts (35947 vertices / 69451 triangles); the scale/camera/floor
  // values are nx_bunny_gate's own calibrated view, reused not re-picked (composition reuses the
  // incumbent's calibration). Composition condition: this only renders on a WON run -- the way a
  // real title imports display assets for its win screen.
  checks=checks+1
  let tw12: i64 = 300
  let th12: i64 = 300
  let npx12: i64 = tw12*th12
  let bg12: i64 = 24 + 26*256 + 34*65536
  let fb12: *i64 = sys_mmap(npx12*8) as *i64
  let zb12: *i64 = sys_mmap(npx12*8) as *i64
  tm_set_spec(0)
  tm_set_tex(0)
  let ok12: i64 = obj_load("knowledge/stdassets/bunny.obj" as *u8, 1300, 205+200*256+195*65536)
  let nv12: i64 = tm_nv()
  let nt12: i64 = tm_nt()
  nh_clearfb(fb12, npx12, bg12)
  trimesh_zclear(zb12, npx12)
  trimesh_render(fb12, zb12, tw12, th12, 1300, 0-250, 2300, 520, 2)
  let fil12: i64 = nh_filled(fb12, npx12, bg12)
  let rck12: i64 = nh_fbck(fb12, npx12)
  nh_clearfb(fb12, npx12, bg12)
  trimesh_zclear(zb12, npx12)
  trimesh_render(fb12, zb12, tw12, th12, 1300, 0-250, 2300, 520, 2)
  let rck12b: i64 = nh_fbck(fb12, npx12)
  var t12: i64=0
  if g2[F_WIN]==1 { if ok12==1 { if nv12==35947 { if nt12==69451 { if tm_ovf()==0 { if fil12>npx12/12 { if rck12==rck12b {
      ww("T12 GREEN asset-import: WON run's victory screen renders the imported standard mesh -- ")
      ww("EXACT canonical Stanford counts (35947/69451, provenance by the numbers), ")
      wn(fil12); ww(" px rasterized (floor npx/12 = the part's own gate calibration), deterministic\n")
      t12=1; pass=pass+1
      mask=mask+nbit(25)
  } } } } } } }
  if t12==0 {
      ww("T12 RED   asset-import: win="); wn(g2[F_WIN]); ww(" ok="); wn(ok12)
      ww(" nv="); wn(nv12); ww(" nt="); wn(nt12); ww(" ovf="); wn(tm_ovf())
      ww(" filled="); wn(fil12); ww(" ckA="); wn(rck12); ww(" ckB="); wn(rck12b); ww("\n")
  }
1026
  // ---------- wiring evidence artifact: measured mask + run summary (board cross-checks payload[0]) ----------
  let art: *i64 = sys_mmap(16*8) as *i64
  art[0]=mask
  art[1]=fck
  art[2]=runturn
  art[3]=runkills
  art[4]=runxp
  art[5]=runlvl
  art[6]=NH_DEPTH
  art[7]=runwin
  let aw: i64 = gs_save("knowledge/nx_wire_nethack.sav" as *u8, NH_ART_SCHEMA, art, 8, 20260720)
  ww("\nwiring artifact knowledge/nx_wire_nethack.sav bytes="); wn(aw)
  ww(" exercised_mask="); wn(mask); ww(" (bits 3,6,7,9,11,14,15,18,25 when all their teeth pass)\n")
1040
  ww("\n=== nx_wire_nethack_gate "); wn(pass); ww("/"); wn(checks)
  // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
  // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
  // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
  let ctr__dry: *i64 = gv_ctr()
  ctr__dry[0] = pass
  ctr__dry[1] = checks
  let rc__dry: i64 = gv_verdict("WIRE-NETHACK-GATE" as *u8, ctr__dry, "teeth unchanged; verdict emission migrated onto the shared base class" as *u8)
  sys_exit(rc__dry)
  return rc__dry
1051}
nx_wire_nethack_gate.nx source

`nx_wire_nethack_gate.nx` source
