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

↩ module page · 1087 lines · 42427 B
1// nx_wire_crawl_gate.nx -- TITLE WIRING #4: Dungeon Crawl Stone Soup (roguelike). 2026-08-23.
2// Composes the SAME certified parts as the proven NetHack wiring (nx_wire_nethack_gate, 12/12 GREEN)
3// plus the LOOT part exactly as the proven Diablo II wiring exercises it (nx_wire_diablo2_gate 14/14):
4// every kill rolls an item through nx_loottable's lt_roll, audited in-loop (no duplicate affixes,
5// values in declared range), and the loot is CAUSAL in the economy -- tier>=2 drops grant a ration
6// that the inventory conservation ledger must then balance exactly.
7//
8// CAPS EXERCISED (bit = nx_gamebench capability index, set ONLY if its tooth passes; the mask is
9// written into knowledge/nx_wire_crawl.sav payload[0] so nx_gamebench_gate can cross-check):
10//   bit 3  procgen-world         bit 7  pathfinding-ai        bit 6  entity-component-sim
11//   bit 9  rpg-stats-progression bit 11 inventory-crafting    bit 14 text-render-typography
12//   bit 15 save-load-persistence bit 18 ui-menus-hud          bit 25 asset-pipeline-import
13//   bit 10 loot-item-tables (the crawl-specific addition; Diablo II lt_roll pattern)
14// Full mask when all teeth pass = 33868488 (NetHack's proven set) + 1024 (bit 10) = 33869512,
15// which EQUALS the board's required vector ttmk[8] -- readiness 1000 permil is reachable, measured.
16//
17// DIALECT (inherited from the donor, which found these traps): no else-if chains with declarations,
18// no ||, flag variables instead of else branches in game code; ASCII-only comments (the 08-22
19// non-ASCII-reached-codegen landmine); per-kill sys_mmap in the loot block mirrors the proven d2
20// wiring (about 18 kills per run -- not a hot loop).
21// license_tier: ORIGINAL  expect_exit: 0
22import "nx_syscalls.nx"
23import "nx_gamesave.nx"
24import "nx_rpgstats.nx"
25import "nx_entity_store.nx"
26import "nx_pathfind.nx"
27import "nx_loottable.nx"
28import "nx_gamehud.nx"
29import "nx_wire_harness.nx"
30import "nx_gate_verdict.nx"
31import "nx_trimesh.nx"
32import "nx_objload.nx"
33
34// ---- world shape (donor values: the NetHack loop's calibration, reused not re-picked) ----
35const CR_W:      i64 = 24
36const CR_H:      i64 = 12
37const CR_DEPTH:  i64 = 3
38const CR_NMON:   i64 = 6
39const CR_NITEM:  i64 = 5
40const CR_CAP:    i64 = 16
41const CR_NCOMP:  i64 = 4
42const CR_CARVE:  i64 = 140
43const CR_AGGRO:  i64 = 8
44const CR_MAXT:   i64 = 600
45const CR_XB:     i64 = 20
46const CR_XQ:     i64 = 10
47const CR_HPB:    i64 = 10
48const CR_HPC:    i64 = 2
49const CR_HPL:    i64 = 3
50const CR_CON:    i64 = 14
51const CR_BITE:   i64 = 2
52const CR_MHPB:   i64 = 12
53const CR_HEAL_R: i64 = 10
54const CR_HEAL_F: i64 = 25
55// loot shape (the d2 wiring's table dimensions, reused)
56const CR_NTIER:  i64 = 4
57const CR_NAFF:   i64 = 5
58// save shape: donor's 26 header fields + 8 loot fields = 34
59const CR_HDRN:   i64 = 34
60const CR_HDRZ:   i64 = 48        // header region zeroed on new/restore (grid starts at word 48)
61const CR_NSV:    i64 = 114       // 34 hdr + 1 nmon + 16*4 monsters + 5*3 items
62const CR_SCHEMA: i64 = 7339      // next in the x9 wire series (nethack 7307, d2 7338)
63const CR_ART_SCHEMA: i64 = 7319  // wiring-evidence artifact schema (nethack 7317, d2 7318)
64const CR_T1W:    i64 = 20        // transparency window: donor's calibration, win lands ~turn 62
65const CR_T2W:    i64 = 45
66// ---- arena offsets: donor layout shifted +16 words for the 8 loot header fields ----
67const CG_O_GRID:   i64 = 48
68const CG_O_ITEM:   i64 = 336
69const CG_O_ENT:    i64 = 352
70const CG_O_PATH:   i64 = 512
71const CG_O_G:      i64 = 808
72const CG_O_F:      i64 = 1104
73const CG_O_CAME:   i64 = 1400
74const CG_O_OPENF:  i64 = 1696
75const CG_O_CLOSED: i64 = 1992
76const CG_O_CARVE:  i64 = 2288
77const CG_O_HUD:    i64 = 2592
78const CG_WORDS:    i64 = 2656
79const CR_HUDINK:   i64 = 50
80// header field indices
81const F_WS: i64 = 0
82const F_DEPTH: i64 = 1
83const F_TURN: i64 = 2
84const F_PX: i64 = 3
85const F_PY: i64 = 4
86const F_XP: i64 = 5
87const F_LVL: i64 = 6
88const F_HP: i64 = 7
89const F_KILLS: i64 = 8
90const F_RATION: i64 = 9
91const F_FEAST: i64 = 10
92const F_PICKED: i64 = 11
93const F_USED: i64 = 12
94const F_WIN: i64 = 13
95const F_COMB: i64 = 14
96const F_EATR: i64 = 15
97const F_EATF: i64 = 16
98const F_PSTEPS: i64 = 17
99const F_ATT: i64 = 18
100const F_BITES: i64 = 19
101const F_SPAWNED: i64 = 20
102const F_SX: i64 = 21
103const F_SY: i64 = 22
104const F_NCARVE: i64 = 23
105const F_GENRNG: i64 = 24
106const F_ABAND: i64 = 25
107// loot header fields (crawl addition; ALL serialized, so save/load transparency covers loot state)
108const F_DROPS: i64 = 26
109const F_T0: i64 = 27
110const F_T1: i64 = 28
111const F_T2: i64 = 29
112const F_T3: i64 = 30
113const F_DUPAFF: i64 = 31
114const F_AFFBAD: i64 = 32
115const F_LOOTR: i64 = 33          // rations gained FROM LOOT (tier>=2) -- balances the ledger tooth
116
117func ww(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
118func 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
126}
127func cbit(i: i64) -> i64 { var v: i64=1; var k: i64=0; while k<i { v=v*2; k=k+1 } return v }
128func crng(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
136}
137func cabs(v: i64) -> i64 { if v<0 { return 0-v } return v }
138// loot tables: the PROVEN d2 wiring calibration, composed not re-picked
139func cr_tables(tw: *i64, ta: *i64, aw: *i64, alo: *i64, ahi: *i64) -> i64 {
  tw[0]=600; tw[1]=300; tw[2]=80; tw[3]=20
  ta[0]=0;   ta[1]=1;   ta[2]=2;  ta[3]=3
  aw[0]=30; aw[1]=25; aw[2]=20; aw[3]=15; aw[4]=10
  alo[0]=2;  ahi[0]=9
  alo[1]=5;  ahi[1]=20
  alo[2]=5;  ahi[2]=25
  alo[3]=4;  ahi[3]=15
  alo[4]=1;  ahi[4]=8
  return 0
149}
150// ---- level structure: PURE function of (worldseed, depth). Restore regenerates it exactly. ----
151func cr_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 + CG_O_GRID*8) as *i64
  let carve: *i64 = (g as i64 + CG_O_CARVE*8) as *i64
  var i: i64=0
  while i<CR_W*CR_H { grid[i]=1; i=i+1 }
  var cx: i64=1
  var cy: i64=1
  grid[cy*CR_W+cx]=0
  carve[0]=cy*CR_W+cx
  var nc: i64=1
  var steps: i64=0
  while steps<CR_CARVE {
      let d: i64 = crng(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<=CR_W-2 { if ty>=1 { if ty<=CR_H-2 {
          cx=tx; cy=ty
          if grid[cy*CR_W+cx]==1 { grid[cy*CR_W+cx]=0; carve[nc]=cy*CR_W+cx; nc=nc+1 }
      } } } }
      steps=steps+1
  }
  g[F_SX]=cx
  g[F_SY]=cy
  g[F_NCARVE]=nc
  return nc
182}
183func cr_populate(g: *i64) -> i64 {
  let carve: *i64 = (g as i64 + CG_O_CARVE*8) as *i64
  let item: *i64 = (g as i64 + CG_O_ITEM*8) as *i64
  let a: *i64 = (g as i64 + CG_O_ENT*8) as *i64
  en_init(a, CR_CAP, CR_NCOMP)
  let nc: i64 = g[F_NCARVE]
  let d: i64 = g[F_DEPTH]
  var m: i64=0
  while m<CR_NMON {
      var placed: i64=0
      var guard: i64=0
      while placed==0 {
          guard=guard+1
          if guard>200 { placed=1 }
          let pick: i64 = 1 + (crng(g) % (nc-1))
          let cell: i64 = carve[pick]
          let mx: i64 = cell % CR_W
          let my: i64 = cell / CR_W
          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 = CR_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<CR_NITEM {
      var placed2: i64=0
      var guard2: i64=0
      while placed2==0 {
          guard2=guard2+1
          if guard2>200 { placed2=1 }
          let pick2: i64 = 1 + (crng(g) % (nc-1))
          let cell2: i64 = carve[pick2]
          let ix: i64 = cell2 % CR_W
          let iy: i64 = cell2 / CR_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 }
          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
253}
254func cr_new(g: *i64, ws: i64) -> i64 {
  var i: i64=0
  while i<CR_HDRZ { g[i]=0; i=i+1 }
  g[F_WS]=ws
  g[F_DEPTH]=1
  let l1: i64 = rs_level_for_xp(0, CR_XB, CR_XQ)
  g[F_LVL]=l1
  let hp0: i64 = rs_derived_hp(CR_CON, l1, CR_HPB, CR_HPC, CR_HPL)
  g[F_HP]=hp0
  cr_genstruct(g)
  cr_populate(g)
  let hud: *i64 = (g as i64 + CG_O_HUD*8) as *i64
  gh_init(hud, 5)
  return 0
268}
269func cr_serialize(g: *i64, S: *i64) -> i64 {
  var i: i64=0
  while i<CR_HDRN { S[i]=g[i]; i=i+1 }
  let a: *i64 = (g as i64 + CG_O_ENT*8) as *i64
  let n: i64 = en_count(a)
  S[CR_HDRN]=n
  var k: i64=0
  while k<CR_CAP*4 { S[CR_HDRN+1+k]=0; k=k+1 }
  k=0
  while k<n {
      let h: i64 = en_nth(a,k)
      let b: i64 = CR_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 + CG_O_ITEM*8) as *i64
  let ib: i64 = CR_HDRN+1+CR_CAP*4
  var q: i64=0
  while q<CR_NITEM*3 { S[ib+q]=item[q]; q=q+1 }
  return CR_NSV
296}
297func cr_restore(g: *i64, S: *i64) -> i64 {
  var i: i64=0
  while i<CR_HDRZ { g[i]=0; i=i+1 }
  g[F_WS]=S[F_WS]
  g[F_DEPTH]=S[F_DEPTH]
  cr_genstruct(g)
  i=0
  while i<CR_HDRN { g[i]=S[i]; i=i+1 }
  let a: *i64 = (g as i64 + CG_O_ENT*8) as *i64
  en_init(a, CR_CAP, CR_NCOMP)
  let n: i64 = S[CR_HDRN]
  var k: i64=0
  while k<n {
      let b: i64 = CR_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 + CG_O_ITEM*8) as *i64
  let ib: i64 = CR_HDRN+1+CR_CAP*4
  var q: i64=0
  while q<CR_NITEM*3 { item[q]=S[ib+q]; q=q+1 }
  let hud: *i64 = (g as i64 + CG_O_HUD*8) as *i64
  gh_init(hud, 5)
  return 0
325}
326func cr_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
330}
331func cr_ck(g: *i64) -> i64 {
  var ck: i64 = 1469598103
  var i: i64=0
  while i<CR_HDRN { ck = cr_ckv(ck, g[i]); i=i+1 }
  let a: *i64 = (g as i64 + CG_O_ENT*8) as *i64
  let n: i64 = en_count(a)
  ck = cr_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 = cr_ckv(ck, v)
          c=c+1
      }
      k=k+1
  }
  let item: *i64 = (g as i64 + CG_O_ITEM*8) as *i64
  var q: i64=0
  while q<CR_NITEM*3 { ck = cr_ckv(ck, item[q]); q=q+1 }
  return ck
353}
354func cr_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
366}
367// one game turn. returns the handle of a monster KILLED this turn (0 if none) -- the stale-handle witness.
368func cr_tick(g: *i64) -> i64 {
  if g[F_WIN]==1 { return 0 }
  let grid: *i64 = (g as i64 + CG_O_GRID*8) as *i64
  let a: *i64 = (g as i64 + CG_O_ENT*8) as *i64
  let item: *i64 = (g as i64 + CG_O_ITEM*8) as *i64
  var killed: i64 = 0
  let px: i64 = g[F_PX]
  let py: i64 = g[F_PY]
  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 = cabs(mx-px)+cabs(my-py)
          if dd==1 { adj=h }
      }
      k=k+1
  }
  // DIALECT: flag vars, no else chains (donor's parser-trap law)
  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)
          let kmx: i64 = en_get(a,adj,0)
          let kmy: i64 = en_get(a,adj,1)
          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], CR_XB, CR_XQ)
          if nl>g[F_LVL] {
              g[F_LVL]=nl
              let mh: i64 = rs_derived_hp(CR_CON, nl, CR_HPB, CR_HPC, CR_HPL)
              g[F_HP]=mh
          }
          // ---- THE LOOT WIRING (bit 10, the d2 pattern): every kill rolls through the certified
          // lt_roll; the killed monster's position feeds the seed; the item is audited in-loop
          // (duplicate affixes and out-of-range values are VIOLATION COUNTERS the tooth pins to 0);
          // tier>=2 drops are CAUSAL: they grant a ration the conservation ledger must balance. ----
          let ltw: *i64 = sys_mmap(8*8) as *i64
          let lta: *i64 = sys_mmap(8*8) as *i64
          let law: *i64 = sys_mmap(8*8) as *i64
          let lalo: *i64 = sys_mmap(8*8) as *i64
          let lahi: *i64 = sys_mmap(8*8) as *i64
          cr_tables(ltw,lta,law,lalo,lahi)
          let oaff: *i64 = sys_mmap(8*8) as *i64
          let oval: *i64 = sys_mmap(8*8) as *i64
          let onm: *i64 = sys_mmap(8) as *i64
          let lseed: i64 = g[F_WS]*1000003 + g[F_KILLS]*8009 + (kmy*CR_W+kmx)*127
          let tier: i64 = lt_roll(lseed, ltw, lta, CR_NTIER, law, lalo, lahi, CR_NAFF, oaff, oval, onm)
          if tier>=0 {
              g[F_DROPS]=g[F_DROPS]+1
              if tier==0 { g[F_T0]=g[F_T0]+1 }
              if tier==1 { g[F_T1]=g[F_T1]+1 }
              if tier==2 { g[F_T2]=g[F_T2]+1 }
              if tier==3 { g[F_T3]=g[F_T3]+1 }
              let got: i64 = onm[0]
              var x: i64=0
              while x<got {
                  var y: i64=x+1
                  while y<got {
                      if oaff[x]==oaff[y] { g[F_DUPAFF]=g[F_DUPAFF]+1 }
                      y=y+1
                  }
                  let av: i64 = oval[x]
                  let ai: i64 = oaff[x]
                  if av<lalo[ai] { g[F_AFFBAD]=g[F_AFFBAD]+1 }
                  if av>lahi[ai] { g[F_AFFBAD]=g[F_AFFBAD]+1 }
                  x=x+1
              }
              if tier>=2 {
                  g[F_RATION]=g[F_RATION]+1
                  g[F_LOOTR]=g[F_LOOTR]+1
              }
          }
      }
      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]>CR_DEPTH { g[F_WIN]=1 }
      if g[F_DEPTH]<=CR_DEPTH {
          let leftover: i64 = en_count(a)
          g[F_ABAND]=g[F_ABAND]+leftover
          cr_genstruct(g)
          cr_populate(g)
      }
  } } }
  if acted==0 { if g[F_WIN]==0 {
      let pg: *i64 = (g as i64 + CG_O_G*8) as *i64
      let pf: *i64 = (g as i64 + CG_O_F*8) as *i64
      let pc: *i64 = (g as i64 + CG_O_CAME*8) as *i64
      let po: *i64 = (g as i64 + CG_O_OPENF*8) as *i64
      let pz: *i64 = (g as i64 + CG_O_CLOSED*8) as *i64
      let pp: *i64 = (g as i64 + CG_O_PATH*8) as *i64
      let plen: i64 = pf_astar(grid, CR_W, CR_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 % CR_W
          let ny: i64 = nxt / CR_W
          let occ: i64 = cr_moncell(a, nx, ny, 0)
          if occ==0 { g[F_PX]=nx; g[F_PY]=ny; g[F_PSTEPS]=g[F_PSTEPS]+1 }
      }
  } }
  let qx: i64 = g[F_PX]
  let qy: i64 = g[F_PY]
  var q: i64=0
  while q<CR_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
  }
  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
  }
  let maxhp: i64 = rs_derived_hp(CR_CON, g[F_LVL], CR_HPB, CR_HPC, CR_HPL)
  let hud: *i64 = (g as i64 + CG_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)
          if choice==1 {
              g[F_FEAST]=g[F_FEAST]-1
              g[F_HP]=g[F_HP]+CR_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]+CR_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 }
  }
  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 = cabs(mx2-g[F_PX])
      let db: i64 = cabs(my2-g[F_PY])
      let d2: i64 = da+db
      if d2==1 {
          g[F_HP]=g[F_HP]-CR_BITE
          g[F_BITES]=g[F_BITES]+1
      }
      if d2>1 { if d2<=CR_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*CR_W+mtx]==0 {
                  occ2 = cr_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*CR_W+mx2]==0 {
                      occ3 = cr_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
575}
576func cr_hudchain(seed: i64, turns: i64, out: *i64) -> i64 {
  let g: *i64 = sys_mmap(CG_WORDS*8) as *i64
  cr_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 + CG_O_HUD*8) as *i64
  var chain: i64 = 1469598103
  var prev: i64 = 0
  var moved: i64 = 0
  var t: i64 = 0
  while t < turns {
      cr_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
615}
616func cr_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
627}
628func cr_clearfb(fb: *i64, n: i64, c: i64) -> i64 { var i: i64=0; while i<n { fb[i]=c; i=i+1 } return 0 }
629func cr_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 }
630func cr_fbck(fb: *i64, n: i64) -> i64 { var ck: i64=1469598103; var i: i64=0; while i<n { ck = cr_ckv(ck, fb[i]); i=i+1 } return ck }
631func cr_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]>=CR_MAXT { go=0 }
      if g[F_HP]<=0 { go=0 }
      if go==1 {
          let kh: i64 = cr_tick(g)
          if kh!=0 { if firstkill==0 { firstkill=kh } }
      }
  }
  return firstkill
644}
645func main() -> i64 {
  ww("=== nx_wire_crawl_gate: does Dungeon Crawl'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 = 5151
  let g1: *i64 = sys_mmap(CG_WORDS*8) as *i64
  let g2: *i64 = sys_mmap(CG_WORDS*8) as *i64
  let S: *i64 = sys_mmap(CR_NSV*8+64) as *i64
  let S2: *i64 = sys_mmap(CR_NSV*8+64) as *i64
655
  // ---------- T1 procgen-world (bit 3): deterministic, seed-diverse, stairs reachable ----------
  checks=checks+1
  cr_new(g1, SEED)
  cr_new(g2, SEED)
  let cka: i64 = cr_ck(g1)
  let ckb: i64 = cr_ck(g2)
  cr_new(g2, SEED+1)
  let grid1: *i64 = (g1 as i64 + CG_O_GRID*8) as *i64
  let grid2: *i64 = (g2 as i64 + CG_O_GRID*8) as *i64
  var diff: i64=0
  var i: i64=0
  while i<CR_W*CR_H { if grid1[i]!=grid2[i] { diff=diff+1 } i=i+1 }
  let pg1: *i64 = (g1 as i64 + CG_O_G*8) as *i64
  let pf1: *i64 = (g1 as i64 + CG_O_F*8) as *i64
  let pc1: *i64 = (g1 as i64 + CG_O_CAME*8) as *i64
  let po1: *i64 = (g1 as i64 + CG_O_OPENF*8) as *i64
  let pz1: *i64 = (g1 as i64 + CG_O_CLOSED*8) as *i64
  let pp1: *i64 = (g1 as i64 + CG_O_PATH*8) as *i64
  let plen0: i64 = pf_astar(grid1, CR_W, CR_H, 1, 1, g1[F_SX], g1[F_SY], pg1, pf1, pc1, po1, pz1, pp1)
  let a1: *i64 = (g1 as i64 + CG_O_ENT*8) as *i64
  let item1: *i64 = (g1 as i64 + CG_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*CR_W+mx]!=0 { badcell=badcell+1 }
      k=k+1
  }
  k=0
  while k<CR_NITEM {
      let ix: i64=item1[k*3]
      let iy: i64=item1[k*3+1]
      if grid1[iy*CR_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+cbit(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")
  }
705
  // ---------- 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 % CR_W
      let y0: i64 = c0 / CR_W
      let x1: i64 = c1 % CR_W
      let y1: i64 = c1 / CR_W
      let ad: i64 = cabs(x1-x0)+cabs(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+cbit(7)
  } }
  if t2==0 { ww("T2 RED   pathfinding: plen="); wn(plen0); ww(" pathok="); wn(pathok); ww("\n") }
730
  // ---------- full deterministic run (the actual game) ----------
  cr_new(g1, SEED)
  let fk: i64 = cr_run_full(g1)
  let a1b: *i64 = (g1 as i64 + CG_O_ENT*8) as *i64
  let fck: i64 = cr_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(" lootr="); wn(g1[F_LOOTR])
  ww(" drops="); wn(g1[F_DROPS]); ww(" used="); wn(g1[F_USED]); ww(" combines="); wn(g1[F_COMB])
  ww(" psteps="); wn(g1[F_PSTEPS]); ww(" ck="); wn(fck); ww("\n")
746
  // ---------- 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+cbit(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")
  }
766
  // ---------- T4 rpg-stats-progression (bit 9) ----------
  checks=checks+1
  let wantlvl: i64 = rs_level_for_xp(g1[F_XP], CR_XB, CR_XQ)
  let maxhp: i64 = rs_derived_hp(CR_CON, g1[F_LVL], CR_HPB, CR_HPC, CR_HPL)
  let thresh: i64 = rs_xp_for_level(g1[F_LVL], CR_XB, CR_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+cbit(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")
  }
784
  // ---------- T5 inventory-crafting (bit 11): ledger conserves exactly, LOOT INCLUDED ----------
  checks=checks+1
  // rations entering the economy = picked up + granted by loot; every one is held, eaten, or crafted
  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
  // Floors DERIVED for the loot economy (first live run, seed 5151: picked=1 lootr=5 and both
  // conservation equalities EXACT): the pickup MECHANISM needs one witness (>=1), and the donor's
  // volume bar -- 3 rations entering the economy -- is now fed by BOTH inflows (picked + loot).
  // Weakening would be keeping >=3 on picked alone and calling 6 total insufficient.
  if g1[F_PICKED]>=1 { if g1[F_PICKED]+g1[F_LOOTR]>=3 { if g1[F_USED]>=1 { if g1[F_COMB]>=1 {
      if g1[F_PICKED]+g1[F_LOOTR]==led1 { if g1[F_COMB]==led2 {
          ww("T5 GREEN inventory-crafting: picked "); wn(g1[F_PICKED]); ww(" + loot-granted ")
          wn(g1[F_LOOTR]); 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 WITH the loot inflow)\n")
          t5=1; pass=pass+1
          mask=mask+cbit(11)
      } }
  } } } }
  if t5==0 {
      ww("T5 RED   inventory: picked="); wn(g1[F_PICKED]); ww(" lootr="); wn(g1[F_LOOTR])
      ww(" led1="); wn(led1); ww(" comb="); wn(g1[F_COMB]); ww(" led2="); wn(led2)
      ww(" used="); wn(g1[F_USED]); ww("\n")
  }
810
  // ---------- T6 save-load TRANSPARENCY (bit 15, FLAGSHIP) ----------
  checks=checks+1
  let bank: *i64 = sys_mmap((CR_T2W-CR_T1W+2)*8) as *i64
  cr_new(g1, SEED)
  var t: i64=0
  while t<CR_T1W { cr_tick(g1); t=t+1 }
  let g1a: *i64 = (g1 as i64 + CG_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 nv_drops: i64 = g1[F_DROPS]
  let ckt1: i64 = cr_ck(g1)
  bank[0]=ckt1
  t=CR_T1W
  while t<CR_T2W { cr_tick(g1); t=t+1; let c: i64 = cr_ck(g1); bank[t-CR_T1W]=c }
  let contwin: i64 = g1[F_WIN]
  cr_new(g2, SEED)
  t=0
  while t<CR_T1W { cr_tick(g2); t=t+1 }
  cr_serialize(g2,S2)
  let sr: i64 = gs_save("knowledge/nx_wire_crawl_mid.sav" as *u8, CR_SCHEMA, S2, CR_NSV, 20260823)
  var zi: i64=0
  while zi<CG_WORDS { g2[zi]=0; zi=zi+1 }
  let Sl: *i64 = sys_mmap(CR_NSV*8+64) as *i64
  let lr: i64 = gs_load("knowledge/nx_wire_crawl_mid.sav" as *u8, Sl, CR_NSV, 0 as *i64)
  cr_restore(g2, Sl)
  let ckr: i64 = cr_ck(g2)
  var mismatch: i64=0
  if ckr!=bank[0] { mismatch=mismatch+1 }
  t=CR_T1W
  while t<CR_T2W {
      cr_tick(g2)
      t=t+1
      let c2: i64 = cr_ck(g2)
      if c2!=bank[t-CR_T1W] { mismatch=mismatch+1 }
  }
  cr_serialize(g1,S)
  cr_serialize(g2,S2)
  var fdiff: i64=0
  i=0
  while i<CR_NSV { if S[i]!=S2[i] { fdiff=fdiff+1 } i=i+1 }
  var t6: i64=0
  if sr>0 { if lr==CR_NSV { if mismatch==0 { if fdiff==0 { if nv_alive>=1 { if nv_xp>0 { if nv_picked+nv_drops>=1 { if contwin==0 {
      ww("T6 GREEN save/load TRANSPARENT: save at turn "); wn(CR_T1W)
      ww(" -> load into ZEROED arena -> resume to "); wn(CR_T2W)
      ww(": all "); wn(CR_T2W-CR_T1W+1); ww(" per-turn checksums identical, 0/"); wn(CR_NSV)
      ww(" state fields differ (loot counters INSIDE the save; 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+cbit(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")
  }
868
  // ---------- 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_crawl_mid.sav" as *u8, lenp)
  var t7: i64=0
  if (raw as i64)!=0 {
      let rl: i64 = lenp[0]
      let flip: i64 = 48+24
      raw[flip] = (raw[flip] as i64 ^ 255) as u8
      let cfd: i64 = sys_openat_wr("knowledge/nx_wire_crawl_corrupt.sav" as *u8, 0x1a4)
      if cfd>=0 {
          sys_write(cfd, raw, rl)
          sys_close(cfd)
          let Sc: *i64 = sys_mmap(CR_NSV*8+64) as *i64
          Sc[0]=777777
          let cr: i64 = gs_load("knowledge/nx_wire_crawl_corrupt.sav" as *u8, Sc, CR_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") }
895
  // ---------- T8 determinism: two independent full runs, bit-identical ----------
  checks=checks+1
  cr_new(g2, SEED)
  cr_run_full(g2)
  let fck2: i64 = cr_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") }
908
  // ---------- 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]<CR_MAXT { if g2[F_KILLS]>=4 { if g2[F_DEPTH]==CR_DEPTH+1 { if g2[F_HP]>0 {
      ww("T9 GREEN the game was PLAYED and WON: "); wn(CR_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")
  }
921
  // ---------- 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 + CG_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 = cr_hudchain(SEED, CR_T2W, o10a)
  let ch10b: i64 = cr_hudchain(SEED, CR_T2W, o10b)
  var t10: i64=0
  if ch10a==ch10b { if o10a[0]>=2 { if o10a[1]>=CR_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(CR_T2W); ww(" turns ("); wn(o10a[0])
      ww(" frame changes, "); wn(o10a[1]); ww(" ink px)\n")
      t10=1; pass=pass+1
      mask=mask+cbit(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")
  }
943
  // ---------- T11 text-render-typography (bit 14): state-bound glyph status line, ink EXACT ----------
  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 = cr_decint(s11, sl, g2[F_TURN])
  s11[sl]=88 as u8; sl=sl+1
  sl = cr_decint(s11, sl, g2[F_XP])
  s11[sl]=75 as u8; sl=sl+1
  sl = cr_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 = cr_decint(s11c, slc, CR_T1W)
  s11c[slc]=88 as u8; slc=slc+1
  slc = cr_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+cbit(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")
  }
1003
  // ---------- T12 asset-pipeline-import (bit 25): WON run's victory screen renders the canonical
  // Stanford mesh through the certified OBJ chain (nx_bunny_gate's own calibrated view, reused) ----------
  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()
  cr_clearfb(fb12, npx12, bg12)
  trimesh_zclear(zb12, npx12)
  trimesh_render(fb12, zb12, tw12, th12, 1300, 0-250, 2300, 520, 2)
  let fil12: i64 = cr_filled(fb12, npx12, bg12)
  let rck12: i64 = cr_fbck(fb12, npx12)
  cr_clearfb(fb12, npx12, bg12)
  trimesh_zclear(zb12, npx12)
  trimesh_render(fb12, zb12, tw12, th12, 1300, 0-250, 2300, 520, 2)
  let rck12b: i64 = cr_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+cbit(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")
  }
1040
  // ---------- T13 loot-item-tables (bit 10, THE CRAWL ADDITION): every kill rolls through the
  // certified lt_roll; the histogram partition must SUM; the in-loop audits must be clean; and the
  // loot inflow must equal what the ledger absorbed (t2+t3 == lootr, the causal coupling). ----------
  checks=checks+1
  let histsum: i64 = g2[F_T0]+g2[F_T1]+g2[F_T2]+g2[F_T3]
  var t13: i64=0
  if g2[F_DROPS]==g2[F_KILLS] { if g2[F_KILLS]>=4 { if histsum==g2[F_DROPS] {
      if g2[F_DUPAFF]==0 { if g2[F_AFFBAD]==0 { if g2[F_LOOTR]==g2[F_T2]+g2[F_T3] {
          ww("T13 GREEN loot: "); wn(g2[F_DROPS]); ww(" drops == "); wn(g2[F_KILLS])
          ww(" kills (every kill rolled); tier histogram "); wn(g2[F_T0]); ww("/"); wn(g2[F_T1])
          ww("/"); wn(g2[F_T2]); ww("/"); wn(g2[F_T3]); ww(" SUMS to drops; 0 duplicate-affix and 0 ")
          ww("out-of-range violations across the campaign; loot-granted rations "); wn(g2[F_LOOTR])
          ww(" == tier2+tier3 drops EXACT (the loot is causal in the economy)\n")
          t13=1; pass=pass+1
          mask=mask+cbit(10)
      } } }
  } } }
  if t13==0 {
      ww("T13 RED   loot: drops="); wn(g2[F_DROPS]); ww(" kills="); wn(g2[F_KILLS])
      ww(" hist="); wn(g2[F_T0]); ww("/"); wn(g2[F_T1]); ww("/"); wn(g2[F_T2]); ww("/"); wn(g2[F_T3])
      ww(" dupaff="); wn(g2[F_DUPAFF]); ww(" affbad="); wn(g2[F_AFFBAD])
      ww(" lootr="); wn(g2[F_LOOTR]); ww("\n")
  }
1064
  // ---------- 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]=CR_DEPTH
  art[7]=runwin
  let aw: i64 = gs_save("knowledge/nx_wire_crawl.sav" as *u8, CR_ART_SCHEMA, art, 8, 20260823)
  ww("\nwiring artifact knowledge/nx_wire_crawl.sav bytes="); wn(aw)
  ww(" exercised_mask="); wn(mask); ww(" (bits 3,6,7,9,10,11,14,15,18,25 when all their teeth pass)\n")
1078
  ww("\n=== nx_wire_crawl_gate "); wn(pass); ww("/"); wn(checks)
  if pass == checks { ww(" GREEN ===\n") } else { ww(" RED ===\n") }
  let ctr__v: *i64 = gv_ctr()
  ctr__v[0] = pass
  ctr__v[1] = checks
  let rc__v: i64 = gv_verdict("WIRE-CRAWL-GATE" as *u8, ctr__v, "the 4th wired title: NetHack's proven loop + the d2 loot pattern, mask measured not asserted" as *u8)
  sys_exit(rc__v)
  return rc__v
1087}
nx_wire_crawl_gate.nx source

`nx_wire_crawl_gate.nx` source
