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

↩ module page · 1160 lines · 47674 B
1// nx_wire_diablo2_gate.nx -- TITLE WIRING #2: Open Diablo II (ARPG). An actual playable hack-and-slash
2// loop built ONLY from certified parts: procgen act maps seed monster packs (nx_entity_store), every kill
3// grants XP (nx_rpgstats) and rolls LOOT (nx_loottable) whose affixes EQUIP as stat modifiers
4// (rs_apply_mods -- order-independent by construction), the act theme renders through nx_gamemusic, and
5// the whole game state round-trips through nx_gamesave with the GX-9 transparency test.
6//
7// CAPS EXERCISED (bit = nx_gamebench capability index; the measured mask is payload[0] of the artifact):
8//   bit 10 loot-item-tables   bit 9 rpg-stats-progression   bit 3 procgen-world
9//   bit 6  entity-component-sim   bit 16 audio-sfx-music    bit 15 save-load-persistence
10//   bit 18 ui-menus-hud (nx_gamehud: every DROP's equip-or-keep decision goes THROUGH a modal menu --
11//     item 0 carries the tier policy, the RETURNED id drives the equip mutation; HUD binds live
12//     hp/lvl/act/kills/tier per round, render-chain deterministic across replays)
13// NOT exercised (title requires, loop does not prove): bit 7 pathfinding, bit 0 render-2d,
14//   bit 17 input-realtime -- the board must down-score these for this title.
15//
16// FLAGSHIP (mutation target): the kill->loot wiring. Skipping the roll must drive the loot tooth RED
17// (no tiers observed) while the game still plays to a win (anti-vacuity stays GREEN).
18//
19// DIALECT: no `else if`, no `||`, no multiline `else` -- those DESYNC the nx_cc parser (found by the
20// NetHack wiring; minimal repro nx_wire_probe.nx aux2). Plain ifs + flag vars only.
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_loottable.nx"
27import "nx_gamemusic.nx"
28import "nx_audio_wav.nx"
29import "nx_gamehud.nx"
30import "nx_game_raster.nx"
31import "nx_frame_sanity.nx"
32import "nx_wire_harness.nx"
33import "nx_gate_verdict.nx"
34import "nx_pathfind.nx"
35import "nx_input_abstract.nx"
36import "nx_trimesh.nx"
37import "nx_objload.nx"
38
39// ---- world shape (data at the top, rule 11) ----
40const D2_W:     i64 = 20
41const D2_H:     i64 = 10
42const D2_ACTS:  i64 = 3
43const D2_NMON:  i64 = 8
44const D2_CAP:   i64 = 12
45const D2_NCOMP: i64 = 3          // 0=hp 1=xp_reward 2=packed pos
46const D2_CARVE: i64 = 90
47const D2_MAXT:  i64 = 400
48// rpg tuning
49const D2_XB:    i64 = 20
50const D2_XQ:    i64 = 10
51const D2_HPB:   i64 = 20
52const D2_HPC:   i64 = 2
53const D2_HPL:   i64 = 4
54const D2_CON:   i64 = 12
55const D2_BDMG:  i64 = 8          // base weapon damage before mods
56const D2_STRIKERS: i64 = 2       // how many monsters strike back per round
57// loot table (DATA)
58const D2_NTIER: i64 = 4          // normal / magic / rare / unique
59const D2_NAFF:  i64 = 5          // +dmg / +dmg% / +hp / +hp% / +armor
60// save shape
61const D2_HDRN:  i64 = 56        // 2026-08-23: grew 48 -> 56 for the wiring-drain fields
62const D2_NSV:   i64 = 93        // 56 hdr + 1 n + 12*3 monsters
63const D2_SCHEMA: i64 = 7338     // schema BUMPED with the header growth (old 7308 saves refuse cleanly)
64const D2_ART_SCHEMA: i64 = 7318
65// transparency window (full run wins ~turn 60-90; window must sit fully before the win)
66const D2_T1W:   i64 = 22
67const D2_T2W:   i64 = 46
68// game arena offsets (i64 words)
69const DG_O_GRID:  i64 = 64       // 200 cells
70const DG_O_CARVE: i64 = 272      // 208
71const DG_O_ENT:   i64 = 480      // en_words(12,3)=4+60+36+8=108 pad 112
72const DG_O_HUD:   i64 = 640      // nx_gamehud arena (GH_WORDS=64) APPENDED; UI transient, out of the save
73// 2026-08-23: pf_astar work arrays (transient, never serialized). 200 grid cells -> 208-word
74// spacing per array, same sizing rule the NetHack wire uses (288 cells -> 296 words).
75const DG_O_PG:     i64 = 704
76const DG_O_PF2:    i64 = 912
77const DG_O_PCAME:  i64 = 1120
78const DG_O_POPEN:  i64 = 1328
79const DG_O_PCLOSED: i64 = 1536
80const DG_O_PPATH:  i64 = 1744
81const DG_WORDS:   i64 = 1952
82const D2_HUDINK:  i64 = 50       // min ink px for a non-vacuous HUD frame (T10 guard)
83// header fields
84const D_WS: i64 = 0
85const D_ACT: i64 = 1
86const D_TURN: i64 = 2
87const D_XP: i64 = 3
88const D_LVL: i64 = 4
89const D_HP: i64 = 5
90const D_KILLS: i64 = 6
91const D_DROPS: i64 = 7
92const D_T0: i64 = 8
93const D_T1: i64 = 9
94const D_T2: i64 = 10
95const D_T3: i64 = 11
96const D_WIN: i64 = 12
97const D_SPAWNED: i64 = 13
98const D_EQUIPS: i64 = 14
99const D_GENRNG: i64 = 15
100const D_DUPAFF: i64 = 16         // duplicate-affix violations observed (must stay 0)
101const D_AFFBAD: i64 = 17         // affix value out of declared range (must stay 0)
102const D_WT: i64 = 18             // equipped weapon tier (-1 none)
103const D_WNA: i64 = 19            // weapon affix count
104const D_WPAIR: i64 = 20          // 6 pairs (affix,val) -> 20..31
105const D_AT: i64 = 32
106const D_ANA: i64 = 33
107const D_APAIR: i64 = 34          // 34..45
108const D_ORDCHK: i64 = 46         // multi-mod drops where fwd/rev order equality was verified
109const D_ORDBAD: i64 = 47         // order-dependence violations observed (must stay 0)
110// 2026-08-23 WIRING-QUEUE DRAIN fields (header grew 48 -> 56; serialize/restore/ck carry them
111// automatically because all three iterate 0..D2_HDRN)
112const D_PX: i64 = 48             // player x (click-to-move position, pf_astar-driven)
113const D_PY: i64 = 49             // player y
114const D_PSTEPS: i64 = 50         // A* steps actually walked
115const D_PATHBAD: i64 = 51        // path violations observed in-loop (must stay 0)
116const D_INEV: i64 = 52           // confirm edges consumed through the F1102 input part
117const D_WALKS: i64 = 53          // click-to-move approaches issued
118const D_INSCRIPT: i64 = 54       // 1 = input script armed; 0 = control run (nothing can equip)
119const D_RES55: i64 = 55          // reserved
120
121func ww(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
122func 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
130}
131func dbit(i: i64) -> i64 { var v: i64=1; var k: i64=0; while k<i { v=v*2; k=k+1 } return v }
132func drng(d: *i64) -> i64 {
  var x: i64 = d[D_GENRNG]
  x = x ^ (x << 13)
  x = x ^ (x >> 7)
  x = x ^ (x << 17)
  d[D_GENRNG] = x
  if x < 0 { return 0 - x }
  return x
140}
141func dckv(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
145}
146// loot tables as DATA (rule 11): weights per-mille-ish, affix ranges
147func d2_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      // +dmg
  alo[1]=5;  ahi[1]=20     // +dmg%
  alo[2]=5;  ahi[2]=25     // +hp
  alo[3]=4;  ahi[3]=15     // +hp%
  alo[4]=1;  ahi[4]=8      // +armor
  return 0
157}
158// ---- act map: PURE function of (ws, act); carve + pack spawn (positions drive loot seeds) ----
159func d2_genact(d: *i64) -> i64 {
  d[D_GENRNG] = d[D_WS]*1000 + d[D_ACT]*7919
  if d[D_GENRNG]==0 { d[D_GENRNG]=1 }
  let grid: *i64 = (d as i64 + DG_O_GRID*8) as *i64
  let carve: *i64 = (d as i64 + DG_O_CARVE*8) as *i64
  var i: i64=0
  while i<D2_W*D2_H { grid[i]=1; i=i+1 }
  var cx: i64=1
  var cy: i64=1
  grid[cy*D2_W+cx]=0
  carve[0]=cy*D2_W+cx
  var nc: i64=1
  var steps: i64=0
  while steps<D2_CARVE {
      let dd: i64 = drng(d)%4
      var tx: i64=cx
      var ty: i64=cy
      if dd==0 { tx=cx+1 }
      if dd==1 { tx=cx-1 }
      if dd==2 { ty=cy+1 }
      if dd==3 { ty=cy-1 }
      if tx>=1 { if tx<=D2_W-2 { if ty>=1 { if ty<=D2_H-2 {
          cx=tx; cy=ty
          if grid[cy*D2_W+cx]==1 { grid[cy*D2_W+cx]=0; carve[nc]=cy*D2_W+cx; nc=nc+1 }
      } } } }
      steps=steps+1
  }
  let a: *i64 = (d as i64 + DG_O_ENT*8) as *i64
  en_init(a, D2_CAP, D2_NCOMP)
  let act: i64 = d[D_ACT]
  var m: i64=0
  while m<D2_NMON {
      var placed: i64=0
      var guard: i64=0
      while placed==0 {
          guard=guard+1
          if guard>200 { placed=1 }
          let pick: i64 = 1 + (drng(d) % (nc-1))
          let cell: i64 = carve[pick]
          var clash: i64=0
          var k: i64=0
          while k<en_count(a) {
              let h: i64 = en_nth(a,k)
              let op: i64 = en_get(a,h,2)
              if op==cell { clash=1 }
              k=k+1
          }
          if clash==0 { if placed==0 {
              let h2: i64 = en_spawn(a)
              if h2!=EN_NULL {
                  let mhp: i64 = 20 + act*10
                  en_set(a,h2,0,mhp)
                  let mxp: i64 = 20*act
                  en_set(a,h2,1,mxp)
                  en_set(a,h2,2,cell)
                  d[D_SPAWNED]=d[D_SPAWNED]+1
                  placed=1
              }
          } }
      }
      m=m+1
  }
  // 2026-08-23: the player enters every act at the carve origin -- the click-to-move walk
  // (pf_astar, bit 7) starts here; the drunkard's-walk carve guarantees every monster cell
  // is floor-connected to this origin by construction.
  d[D_PX]=1
  d[D_PY]=1
  return nc
227}
228func d2_new(d: *i64, ws: i64) -> i64 {
  var i: i64=0
  while i<D2_HDRN { d[i]=0; i=i+1 }
  d[D_WS]=ws
  d[D_ACT]=1
  d[D_LVL]=1
  d[D_WT]=0-1
  d[D_AT]=0-1
  let hp0: i64 = rs_derived_hp(D2_CON, 1, D2_HPB, D2_HPC, D2_HPL)
  d[D_HP]=hp0
  d[D_INSCRIPT]=1
  d2_genact(d)
  let hud: *i64 = (d as i64 + DG_O_HUD*8) as *i64
  gh_init(hud, 5)
  return 0
243}
244// build the weapon-damage mod list from equipped weapon pairs (affix 0 -> +dmg, 1 -> +dmg%)
245func d2_wmods(d: *i64, mods: *i64) -> i64 {
  var n: i64=0
  var i: i64=0
  while i<d[D_WNA] {
      let af: i64 = d[D_WPAIR + i*2]
      let vl: i64 = d[D_WPAIR + i*2 + 1]
      if af==0 { mods[n*2]=0; mods[n*2+1]=vl; n=n+1 }
      if af==1 { mods[n*2]=1; mods[n*2+1]=vl; n=n+1 }
      i=i+1
  }
  return n
256}
257// armor-hp mod list from equipped armor pairs (affix 2 -> +hp, 3 -> +hp%)
258func d2_amods(d: *i64, mods: *i64) -> i64 {
  var n: i64=0
  var i: i64=0
  while i<d[D_ANA] {
      let af: i64 = d[D_APAIR + i*2]
      let vl: i64 = d[D_APAIR + i*2 + 1]
      if af==2 { mods[n*2]=0; mods[n*2+1]=vl; n=n+1 }
      if af==3 { mods[n*2]=1; mods[n*2+1]=vl; n=n+1 }
      i=i+1
  }
  return n
269}
270func d2_maxhp(d: *i64) -> i64 {
  let base: i64 = rs_derived_hp(D2_CON, d[D_LVL], D2_HPB, D2_HPC, D2_HPL)
  let am: *i64 = sys_mmap(16*8) as *i64
  let an: i64 = d2_amods(d, am)
  return rs_apply_mods(base, am, an)
275}
276// one combat round. returns handle of a monster KILLED this round (0 none).
277func d2_tick(d: *i64) -> i64 {
  if d[D_WIN]==1 { return 0 }
  let a: *i64 = (d as i64 + DG_O_ENT*8) as *i64
  var killed: i64=0
  if en_count(a)==0 {
      // act cleared
      if d[D_ACT]>=D2_ACTS { d[D_WIN]=1 }
      if d[D_WIN]==0 {
          d[D_ACT]=d[D_ACT]+1
          d2_genact(d)
          let mh: i64 = d2_maxhp(d)
          d[D_HP]=mh
      }
      d[D_TURN]=d[D_TURN]+1
      return 0
  }
  // target = alive monster NEAREST the act entrance (1,1), tie -> lowest dense index
  var best: i64=0
  var bestd: i64=999999
  var k: i64=0
  while k<en_count(a) {
      let h: i64 = en_nth(a,k)
      let pos: i64 = en_get(a,h,2)
      let mx: i64 = pos % D2_W
      let my: i64 = pos / D2_W
      var dx: i64 = mx-1
      if dx<0 { dx=0-dx }
      var dy: i64 = my-1
      if dy<0 { dy=0-dy }
      let dist: i64 = dx+dy
      if dist<bestd { bestd=dist; best=h }
      k=k+1
  }
  // ---- CLICK-TO-MOVE THROUGH THE CERTIFIED PART (bit 7, 2026-08-23): the player WALKS to the
  // chosen target via pf_astar on the live act grid, arriving adjacent, before any strike lands.
  // Every step is validated IN-LOOP (4-adjacency + floor); any violation increments D_PATHBAD,
  // which the pathfind tooth requires to be ZERO across the whole campaign.
  let wgrid: *i64 = (d as i64 + DG_O_GRID*8) as *i64
  let tpos2: i64 = en_get(a,best,2)
  let ptx: i64 = tpos2 % D2_W
  let pty: i64 = tpos2 / D2_W
  var pdx: i64 = d[D_PX]-ptx
  if pdx<0 { pdx=0-pdx }
  var pdy: i64 = d[D_PY]-pty
  if pdy<0 { pdy=0-pdy }
  if pdx+pdy>1 {
      let wpg: *i64 = (d as i64 + DG_O_PG*8) as *i64
      let wpf: *i64 = (d as i64 + DG_O_PF2*8) as *i64
      let wpc: *i64 = (d as i64 + DG_O_PCAME*8) as *i64
      let wpo: *i64 = (d as i64 + DG_O_POPEN*8) as *i64
      let wpz: *i64 = (d as i64 + DG_O_PCLOSED*8) as *i64
      let wpp: *i64 = (d as i64 + DG_O_PPATH*8) as *i64
      let plen: i64 = pf_astar(wgrid, D2_W, D2_H, d[D_PX], d[D_PY], ptx, pty, wpg, wpf, wpc, wpo, wpz, wpp)
      if plen>=1 {
          var pi: i64=1
          while pi<=plen {
              let c0: i64 = wpp[pi-1]
              let c1: i64 = wpp[pi]
              let x0: i64 = c0 % D2_W
              let y0: i64 = c0 / D2_W
              let x1: i64 = c1 % D2_W
              let y1: i64 = c1 / D2_W
              var ad: i64 = x1-x0
              if ad<0 { ad=0-ad }
              var ad2: i64 = y1-y0
              if ad2<0 { ad2=0-ad2 }
              if ad+ad2!=1 { d[D_PATHBAD]=d[D_PATHBAD]+1 }
              if wgrid[c1]!=0 { d[D_PATHBAD]=d[D_PATHBAD]+1 }
              pi=pi+1
          }
          let stopc: i64 = wpp[plen-1]
          d[D_PX]=stopc % D2_W
          d[D_PY]=stopc / D2_W
          d[D_PSTEPS]=d[D_PSTEPS]+(plen-1)
          d[D_WALKS]=d[D_WALKS]+1
      }
      if plen<1 { d[D_PATHBAD]=d[D_PATHBAD]+1 }
  }
  // player strikes: damage through the ORDER-INDEPENDENT modifier pipeline
  let wm: *i64 = sys_mmap(16*8) as *i64
  let wn2: i64 = d2_wmods(d, wm)
  let dmg: i64 = rs_apply_mods(D2_BDMG + d[D_LVL], wm, wn2)
  let thp: i64 = en_get(a,best,0) - dmg
  if thp>0 { en_set(a,best,0,thp) }
  if thp<=0 {
      let reward: i64 = en_get(a,best,1)
      let mpos: i64 = en_get(a,best,2)
      en_destroy(a,best)
      killed=best
      d[D_KILLS]=d[D_KILLS]+1
      d[D_XP]=d[D_XP]+reward
      let nl: i64 = rs_level_for_xp(d[D_XP], D2_XB, D2_XQ)
      if nl>d[D_LVL] {
          d[D_LVL]=nl
          let mh2: i64 = d2_maxhp(d)
          d[D_HP]=mh2
      }
      // ---- THE LOOT WIRING (flagship): every kill rolls an item; position feeds the seed ----
      let tw: *i64 = sys_mmap(8*8) as *i64
      let ta: *i64 = sys_mmap(8*8) as *i64
      let aw: *i64 = sys_mmap(8*8) as *i64
      let alo: *i64 = sys_mmap(8*8) as *i64
      let ahi: *i64 = sys_mmap(8*8) as *i64
      d2_tables(tw,ta,aw,alo,ahi)
      let oaff: *i64 = sys_mmap(8*8) as *i64
      let oval: *i64 = sys_mmap(8*8) as *i64
      let onum: *i64 = sys_mmap(8) as *i64
      let seed: i64 = d[D_WS]*1000003 + d[D_KILLS]*8009 + mpos*127
      let tier: i64 = lt_roll(seed, tw, ta, D2_NTIER, aw, alo, ahi, D2_NAFF, oaff, oval, onum)
      if tier>=0 {
          d[D_DROPS]=d[D_DROPS]+1
          if tier==0 { d[D_T0]=d[D_T0]+1 }
          if tier==1 { d[D_T1]=d[D_T1]+1 }
          if tier==2 { d[D_T2]=d[D_T2]+1 }
          if tier==3 { d[D_T3]=d[D_T3]+1 }
          // audit the item: no duplicate affixes, values in declared range (counters, checked by teeth)
          let got: i64 = onum[0]
          var x: i64=0
          while x<got {
              var y: i64=x+1
              while y<got {
                  if oaff[x]==oaff[y] { d[D_DUPAFF]=d[D_DUPAFF]+1 }
                  y=y+1
              }
              let av: i64 = oval[x]
              let ai: i64 = oaff[x]
              if av<alo[ai] { d[D_AFFBAD]=d[D_AFFBAD]+1 }
              if av>ahi[ai] { d[D_AFFBAD]=d[D_AFFBAD]+1 }
              x=x+1
          }
          // order-independence audit ON THE DROP: map every affix to a stat mod (dmg OR hp pool),
          // and whenever an item carries 2+ mods, prove fwd-apply == rev-apply right here in the loop.
          let am2: *i64 = sys_mmap(16*8) as *i64
          var an2: i64=0
          var q2: i64=0
          while q2<got {
              let af2: i64 = oaff[q2]
              let vl2: i64 = oval[q2]
              if af2==0 { am2[an2*2]=0; am2[an2*2+1]=vl2; an2=an2+1 }
              if af2==1 { am2[an2*2]=1; am2[an2*2+1]=vl2; an2=an2+1 }
              if af2==2 { am2[an2*2]=0; am2[an2*2+1]=vl2; an2=an2+1 }
              if af2==3 { am2[an2*2]=1; am2[an2*2+1]=vl2; an2=an2+1 }
              q2=q2+1
          }
          if an2>=2 {
              let fw2: i64 = rs_apply_mods(100, am2, an2)
              let rv2: *i64 = sys_mmap(16*8) as *i64
              var r2: i64=0
              while r2<an2 {
                  rv2[r2*2]   = am2[(an2-1-r2)*2]
                  rv2[r2*2+1] = am2[(an2-1-r2)*2+1]
                  r2=r2+1
              }
              let rw2: i64 = rs_apply_mods(100, rv2, an2)
              d[D_ORDCHK]=d[D_ORDCHK]+1
              if fw2!=rw2 { d[D_ORDBAD]=d[D_ORDBAD]+1 }
          }
          // equip policy THROUGH THE MENU (bit 18): even drops weapons, odd armor; higher tier
          // replaces. The policy rides menu ORDER (item 0 = the policy action: equip when strictly
          // higher tier, else keep) and the RETURNED id drives the mutation -- causal, and the full
          // wrap on every drop exercises gh_menu_move's ring arithmetic. Decisions unchanged
          // => every banked checksum must hold (the golden-ck acceptance for this wire).
          let slot: i64 = d[D_DROPS]%2
          let hud: *i64 = (d as i64 + DG_O_HUD*8) as *i64
          var curt: i64 = d[D_AT]
          if slot==0 { curt = d[D_WT] }
          var pol: i64 = 2
          if tier>curt { pol = 1 }
          var alt: i64 = 1
          if pol==1 { alt = 2 }
          // ---- CONFIRM THROUGH THE CERTIFIED INPUT PART (bit 17, F1102, 2026-08-23): the menu
          // decision is only reached when a REAL pressed EDGE of the confirm action arrives via
          // ia_bind/ia_key/ia_frame. Per-drop the arena is fresh and the press is scripted, so
          // save/load transparency and determinism hold by construction; a control run with the
          // script DISABLED (D_INSCRIPT=0) can never equip -- input is CAUSAL, not decoration.
          var dec: i64 = 2
          if d[D_INSCRIPT]==1 {
              let iap: *i64 = sys_mmap(ia_words()*8) as *i64
              ia_init(iap)
              ia_bind(iap, 65, IA_A)
              ia_key(iap, 65, 1)
              let edges: i64 = ia_frame(iap)
              if (edges/IA_A)%2==1 {
                  d[D_INEV]=d[D_INEV]+1
                  dec = wh_menu_pick2(hud, pol, tier, alt, curt)   // MIGRATED to nx_wire_harness
              }
          }
          if dec==1 { if slot==0 {
              d[D_WT]=tier
              d[D_WNA]=got
              var w2: i64=0
              while w2<6 { d[D_WPAIR+w2*2]=0; d[D_WPAIR+w2*2+1]=0; w2=w2+1 }
              w2=0
              while w2<got { d[D_WPAIR+w2*2]=oaff[w2]; d[D_WPAIR+w2*2+1]=oval[w2]; w2=w2+1 }
              d[D_EQUIPS]=d[D_EQUIPS]+1
          } }
          if dec==1 { if slot==1 {
              d[D_AT]=tier
              d[D_ANA]=got
              var w3: i64=0
              while w3<6 { d[D_APAIR+w3*2]=0; d[D_APAIR+w3*2+1]=0; w3=w3+1 }
              w3=0
              while w3<got { d[D_APAIR+w3*2]=oaff[w3]; d[D_APAIR+w3*2+1]=oval[w3]; w3=w3+1 }
              d[D_EQUIPS]=d[D_EQUIPS]+1
          } }
      }
  }
  // up to D2_STRIKERS monsters strike back
  var struck: i64=0
  var k2: i64=0
  while k2<en_count(a) {
      if struck<D2_STRIKERS {
          d[D_HP]=d[D_HP]-(2+d[D_ACT])
          struck=struck+1
      }
      k2=k2+1
  }
  d[D_TURN]=d[D_TURN]+1
  return killed
496}
497// render-2d (bit 0): the live campaign as a 2D raster frame -- PURE function of game state via the
498// certified nx_game_raster part. Grid floor/wall cells, monsters as hp-shaded discs at their REAL
499// entity positions, act/kills status bars. 20x10 cells at 16px + 20px strip = 320x180.
500const R2_CELL: i64 = 16
501const R2_W:    i64 = 320
502const R2_H:    i64 = 180
503func d2_render(d: *i64, fb: *i64) -> i64 {
  let grid: *i64 = (d as i64 + DG_O_GRID*8) as *i64
  let a: *i64 = (d as i64 + DG_O_ENT*8) as *i64
  gr_clear(fb, R2_W, R2_H, gr_pack(18, 14, 22))
  var cy: i64 = 0
  while cy < D2_H {
      var cx: i64 = 0
      while cx < D2_W {
          if grid[cy*D2_W+cx] == 0 {
              gr_rect(fb, R2_W, R2_H, cx*R2_CELL+1, cy*R2_CELL+1, cx*R2_CELL+R2_CELL-2, cy*R2_CELL+R2_CELL-2, gr_pack(70, 60, 50))
          }
          cx = cx + 1
      }
      cy = cy + 1
  }
  var k: i64 = 0
  while k < en_count(a) {
      let h: i64 = en_nth(a, k)
      let pos: i64 = en_get(a, h, 2)
      let mx: i64 = pos % D2_W
      let my: i64 = pos / D2_W
      var hpc: i64 = en_get(a, h, 0) * 12
      if hpc > 255 { hpc = 255 }
      gr_disc(fb, R2_W, R2_H, mx*R2_CELL+8, my*R2_CELL+8, 6, gr_pack(hpc, 40, 40))
      k = k + 1
  }
  gr_rect(fb, R2_W, R2_H, 0, 162, 4 + d[D_ACT]*30, 168, gr_pack(90, 140, 240))
  gr_rect(fb, R2_W, R2_H, 0, 171, 4 + d[D_KILLS]*10, 177, gr_pack(240, 200, 60))
  return 0
532}
533// MIGRATED to nx_wire_harness (wh_fbck): thin wrapper kept so call sites + the golden-ck proof are
534// unchanged; the checksum body is now the ONE shared definition.
535func d2_fbck(fb: *i64) -> i64 {
  return wh_fbck(fb, R2_W*R2_H)
537}
538// T11 instrument: replay, rendering per round; chain frame cks. out[0]=changed frames, out[1]=mid-frame
539// fs metrics base (fs written to out[2..7]), returns the chain.
540func d2_rchain(seed: i64, turns: i64, out: *i64) -> i64 {
  let d: *i64 = sys_mmap(DG_WORDS*8) as *i64
  d2_new(d, seed)
  let fb: *i64 = sys_mmap(R2_W*R2_H*8) as *i64
  var chain: i64 = 1469598103
  var prev: i64 = 0
  var moved: i64 = 0
  var t: i64 = 0
  while t < turns {
      d2_tick(d)
      d2_render(d, fb)
      let fk: i64 = d2_fbck(fb)
      if t > 0 { if fk != prev { moved = moved + 1 } }
      prev = fk
      chain = (chain*131 + (fk & 0xFFFFFFFF)) & 0x7FFFFFFFFFFFFFFF
      if t == turns/2 { fs_score_i64(fb, R2_W, R2_H, ((out as i64) + 2*8) as *i64) }
      t = t + 1
  }
  out[0] = moved
  return chain
560}
561// T10 instrument: replay a real campaign for `turns`, binding the HUD to live state and rendering
562// every round. out[0]=frames changed vs previous, out[1]=final ink px, out[2]=menu selections.
563func d2_hudchain(seed: i64, turns: i64, out: *i64) -> i64 {
  let d: *i64 = sys_mmap(DG_WORDS*8) as *i64
  d2_new(d, 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]="ACT" as i64
  labels[3]="KILLS" as i64
  labels[4]="TIER" as i64
  let mlabels: *i64 = sys_mmap(8*8) as *i64
  mlabels[0]="equip" as i64
  mlabels[1]="keep" as i64
  let fb: *u8 = sys_mmap(72000)
  let hud: *i64 = (d as i64 + DG_O_HUD*8) as *i64
  var chain: i64 = 1469598103
  var prev: i64 = 0
  var moved: i64 = 0
  var t: i64 = 0
  while t < turns {
      d2_tick(d)
      gh_slot_set(hud, 0, d[D_HP])
      gh_slot_set(hud, 1, d[D_LVL])
      gh_slot_set(hud, 2, d[D_ACT])
      gh_slot_set(hud, 3, d[D_KILLS])
      gh_slot_set(hud, 4, d[D_WT])
      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
602}
603func d2_run_full(d: *i64) -> i64 {
  var firstkill: i64=0
  var go: i64=1
  while go==1 {
      if d[D_WIN]==1 { go=0 }
      if d[D_TURN]>=D2_MAXT { go=0 }
      if d[D_HP]<=0 { go=0 }
      if go==1 {
          let kh: i64 = d2_tick(d)
          if kh!=0 { if firstkill==0 { firstkill=kh } }
      }
  }
  return firstkill
616}
617func d2_serialize(d: *i64, S: *i64) -> i64 {
  var i: i64=0
  while i<D2_HDRN { S[i]=d[i]; i=i+1 }
  let a: *i64 = (d as i64 + DG_O_ENT*8) as *i64
  let n: i64 = en_count(a)
  S[D2_HDRN]=n
  var z: i64=0
  while z<D2_CAP*3 { S[D2_HDRN+1+z]=0; z=z+1 }
  var k: i64=0
  while k<n {
      let h: i64 = en_nth(a,k)
      let b: i64 = D2_HDRN+1+k*3
      let v0: i64 = en_get(a,h,0)
      let v1: i64 = en_get(a,h,1)
      let v2: i64 = en_get(a,h,2)
      S[b]=v0
      S[b+1]=v1
      S[b+2]=v2
      k=k+1
  }
  return D2_NSV
638}
639func d2_restore(d: *i64, S: *i64) -> i64 {
  var i: i64=0
  while i<D2_HDRN { d[i]=0; i=i+1 }
  d[D_WS]=S[D_WS]
  d[D_ACT]=S[D_ACT]
  d2_genact(d)                  // grid: pure fn of (ws,act); entities get overwritten below
  // full header AFTER genact (genact clobbers D_GENRNG/D_SPAWNED with fresh-act values)
  i=0
  while i<D2_HDRN { d[i]=S[i]; i=i+1 }
  let a: *i64 = (d as i64 + DG_O_ENT*8) as *i64
  en_init(a, D2_CAP, D2_NCOMP)
  let n: i64 = S[D2_HDRN]
  var k: i64=0
  while k<n {
      let b: i64 = D2_HDRN+1+k*3
      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])
      k=k+1
  }
  let hud: *i64 = (d as i64 + DG_O_HUD*8) as *i64
  gh_init(hud, 5)               // UI transient: fresh menu machine on restore, game state untouched
  return 0
663}
664// independent-of-serializer checksum (the T-transparency verifier must not share the save's amnesia)
665func d2_ck(d: *i64) -> i64 {
  var ck: i64 = 1469598103
  var i: i64=0
  while i<D2_HDRN { ck = dckv(ck, d[i]); i=i+1 }
  let a: *i64 = (d as i64 + DG_O_ENT*8) as *i64
  let n: i64 = en_count(a)
  ck = dckv(ck, n)
  var k: i64=0
  while k<n {
      let h: i64 = en_nth(a,k)
      var c: i64=0
      while c<3 {
          let v: i64 = en_get(a,h,c)
          ck = dckv(ck, v)
          c=c+1
      }
      k=k+1
  }
  return ck
684}
685// the act theme: data-driven song, layered melody+bass, rendered deterministically
686func d2_song(sng: *i64, k: i64, a2: i64, b2: i64, c2: i64) -> i64 {
  sng[k*3]=a2; sng[k*3+1]=b2; sng[k*3+2]=c2
  return 0
689}
690func d2_render_theme(smp: *i64, nsamp: i64) -> i64 {
  var i: i64=0
  while i<nsamp { smp[i]=0; i=i+1 }
  let mel: *i64 = sys_mmap(16*3*8) as *i64
  d2_song(mel,0, 9,3,2)
  d2_song(mel,1, 0,4,2)
  d2_song(mel,2, 2,4,2)
  d2_song(mel,3, 3,4,4)
  d2_song(mel,4, 2,4,2)
  d2_song(mel,5, 0,4,2)
  d2_song(mel,6, 9,3,4)
  d2_song(mel,7, 0-1,0,2)
  d2_song(mel,8, 7,3,2)
  d2_song(mel,9, 9,3,2)
  d2_song(mel,10, 0,4,4)
  d2_song(mel,11, 9,3,2)
  d2_song(mel,12, 7,3,2)
  d2_song(mel,13, 5,3,4)
  d2_song(mel,14, 0-1,0,2)
  d2_song(mel,15, 9,2,4)
  let bas: *i64 = sys_mmap(8*3*8) as *i64
  d2_song(bas,0, 9,2,8)
  d2_song(bas,1, 5,2,8)
  d2_song(bas,2, 7,2,8)
  d2_song(bas,3, 9,2,8)
  d2_song(bas,4, 0-1,0,8)
  d2_song(bas,5, 9,1,8)
  d2_song(bas,6, 5,2,4)
  d2_song(bas,7, 9,2,4)
  let TS: i64 = 1000
  mus_render(smp, nsamp, mel, 16, 8000, 9000, TS)
  mus_render(smp, nsamp, bas, 8, 8000, 7000, TS)
  return nsamp
723}
724
725// T14 helpers: i64 trimesh framebuffer clear / filled census / checksum (same shapes the
726// certified nx_bunny_gate uses on this exact part chain)
727func d_clearfb(fb: *i64, n: i64, c: i64) -> i64 { var i: i64=0; while i<n { fb[i]=c; i=i+1 } return 0 }
728func d_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 }
729func d_fbck(fb: *i64, n: i64) -> i64 { var ck: i64=1469598103; var i: i64=0; while i<n { ck = dckv(ck, fb[i]); i=i+1 } return ck }
730
731func main() -> i64 {
  ww("=== nx_wire_diablo2_gate: does the ARPG genre loop run on the certified parts? ===\n\n")
  var pass: i64=0
  var checks: i64=0
  var mask: i64=0
  let SEED: i64 = 777
  let d1: *i64 = sys_mmap(DG_WORDS*8) as *i64
  let d2: *i64 = sys_mmap(DG_WORDS*8) as *i64
  let S: *i64 = sys_mmap(D2_NSV*8+64) as *i64
  let S2: *i64 = sys_mmap(D2_NSV*8+64) as *i64
741
  // ---------- T1 procgen-world (bit 3): act map deterministic + seed-diverse ----------
  checks=checks+1
  var t1: i64=0
  d2_new(d1, SEED)
  d2_new(d2, SEED)
  let cka: i64 = d2_ck(d1)
  let ckb: i64 = d2_ck(d2)
  d2_new(d2, SEED+1)
  let ckc: i64 = d2_ck(d2)
  let grid1: *i64 = (d1 as i64 + DG_O_GRID*8) as *i64
  let a1: *i64 = (d1 as i64 + DG_O_ENT*8) as *i64
  var badcell: i64=0
  var k: i64=0
  while k<en_count(a1) {
      let h: i64 = en_nth(a1,k)
      let pos: i64 = en_get(a1,h,2)
      if grid1[pos]!=0 { badcell=badcell+1 }
      k=k+1
  }
  if cka==ckb { if cka!=ckc { if badcell==0 { if en_count(a1)==D2_NMON {
      ww("T1 GREEN procgen: same seed identical (ck "); wn(cka)
      ww("), seed+1 differs (ck "); wn(ckc); ww("), all "); wn(D2_NMON)
      ww(" pack monsters on carved floor\n")
      t1=1; pass=pass+1
      mask=mask+dbit(3)
  } } } }
  if t1==0 {
      ww("T1 RED   procgen: ckA="); wn(cka); ww(" ckB="); wn(ckb); ww(" ckC="); wn(ckc)
      ww(" badcell="); wn(badcell); ww("\n")
  }
772
  // ---------- full deterministic run ----------
  d2_new(d1, SEED)
  let fk: i64 = d2_run_full(d1)
  let a1b: *i64 = (d1 as i64 + DG_O_ENT*8) as *i64
  let fck: i64 = d2_ck(d1)
  let runwin: i64 = d1[D_WIN]
  let runturn: i64 = d1[D_TURN]
  let runkills: i64 = d1[D_KILLS]
  let runxp: i64 = d1[D_XP]
  let runlvl: i64 = d1[D_LVL]
  let rundrops: i64 = d1[D_DROPS]
  // captured HERE because T6 reuses the d1 arena for the partial save/load run -- reading
  // d1[D_PSTEPS] after T6 would compare a 46-turn partial against the full campaign (measured:
  // exactly that mistake made T12 read 43 vs 54 on its first run)
  let runpsteps: i64 = d1[D_PSTEPS]
  ww("  [run] turns="); wn(d1[D_TURN]); ww(" act="); wn(d1[D_ACT]); ww(" win="); wn(d1[D_WIN])
  ww(" kills="); wn(d1[D_KILLS]); ww(" xp="); wn(d1[D_XP]); ww(" level="); wn(d1[D_LVL])
  ww(" hp="); wn(d1[D_HP]); ww(" drops="); wn(d1[D_DROPS])
  ww(" tiers="); wn(d1[D_T0]); ww("/"); wn(d1[D_T1]); ww("/"); wn(d1[D_T2]); ww("/"); wn(d1[D_T3])
  ww(" equips="); wn(d1[D_EQUIPS]); ww(" ck="); wn(fck); ww("\n")
793
  // ---------- T2 loot-item-tables (bit 10, FLAGSHIP): kills drop audited items ----------
  checks=checks+1
  var t2: i64=0
  if d1[D_DROPS]==d1[D_KILLS] { if d1[D_DROPS]>=20 {
      if d1[D_T0]>0 { if d1[D_T1]>0 { if d1[D_T2]>0 { if d1[D_T3]>0 {
          if d1[D_DUPAFF]==0 { if d1[D_AFFBAD]==0 { if d1[D_EQUIPS]>=1 {
              ww("T2 GREEN loot: "); wn(d1[D_DROPS]); ww(" drops from "); wn(d1[D_KILLS])
              ww(" kills, ALL 4 tiers observed ("); wn(d1[D_T0]); ww("/"); wn(d1[D_T1])
              ww("/"); wn(d1[D_T2]); ww("/"); wn(d1[D_T3])
              ww("), 0 duplicate affixes, 0 out-of-range values, "); wn(d1[D_EQUIPS])
              ww(" equips\n")
              t2=1; pass=pass+1
              mask=mask+dbit(10)
          } } }
      } } } }
  } }
  if t2==0 {
      ww("T2 RED   loot: drops="); wn(d1[D_DROPS]); ww(" kills="); wn(d1[D_KILLS])
      ww(" tiers="); wn(d1[D_T0]); ww("/"); wn(d1[D_T1]); ww("/"); wn(d1[D_T2]); ww("/"); wn(d1[D_T3])
      ww(" dup="); wn(d1[D_DUPAFF]); ww(" bad="); wn(d1[D_AFFBAD]); ww("\n")
  }
815
  // ---------- T3 rpg-stats (bit 9): curve exact + equipped mods ORDER-INDEPENDENT ----------
  checks=checks+1
  var t3: i64=0
  let wantlvl: i64 = rs_level_for_xp(d1[D_XP], D2_XB, D2_XQ)
  let wm: *i64 = sys_mmap(16*8) as *i64
  let wnn: i64 = d2_wmods(d1, wm)
  let fwd: i64 = rs_apply_mods(D2_BDMG + d1[D_LVL], wm, wnn)
  // reverse the mod list and re-apply: order independence is the part's flagship, proven IN the title
  let wr: *i64 = sys_mmap(16*8) as *i64
  var r: i64=0
  while r<wnn {
      wr[r*2]   = wm[(wnn-1-r)*2]
      wr[r*2+1] = wm[(wnn-1-r)*2+1]
      r=r+1
  }
  let rev: i64 = rs_apply_mods(D2_BDMG + d1[D_LVL], wr, wnn)
  if d1[D_XP]>0 { if d1[D_LVL]>1 { if d1[D_LVL]==wantlvl { if fwd==rev { if wnn>=1 {
      if d1[D_ORDCHK]>=3 { if d1[D_ORDBAD]==0 {
          ww("T3 GREEN rpgstats: xp "); wn(d1[D_XP]); ww(" -> level "); wn(d1[D_LVL])
          ww(" EXACT; equipped dmg fwd "); wn(fwd); ww(" == rev "); wn(rev)
          ww("; ORDER-INDEPENDENCE verified on "); wn(d1[D_ORDCHK])
          ww(" multi-mod drops in-loop, 0 violations\n")
          t3=1; pass=pass+1
          mask=mask+dbit(9)
      } }
  } } } } }
  if t3==0 {
      ww("T3 RED   rpgstats: xp="); wn(d1[D_XP]); ww(" lvl="); wn(d1[D_LVL]); ww(" want="); wn(wantlvl)
      ww(" fwd="); wn(fwd); ww(" rev="); wn(rev); ww(" nmods="); wn(wnn)
      ww(" ordchk="); wn(d1[D_ORDCHK]); ww(" ordbad="); wn(d1[D_ORDBAD]); ww("\n")
  }
847
  // ---------- T4 entity store (bit 6): stale handle + census ----------
  checks=checks+1
  var t4: i64=0
  var stale: i64=0-1
  if fk!=0 { stale = en_valid(a1b, fk) }
  let alive: i64 = en_count(a1b)
  let census: i64 = d1[D_SPAWNED] - d1[D_KILLS]
  if fk!=0 { if stale==0 { if alive==census {
      ww("T4 GREEN entity store: first-killed handle "); wn(fk)
      ww(" DETECTABLY STALE; census exact: spawned "); wn(d1[D_SPAWNED])
      ww(" - kills "); wn(d1[D_KILLS]); ww(" = alive "); wn(alive); ww("\n")
      t4=1; pass=pass+1
      mask=mask+dbit(6)
  } } }
  if t4==0 {
      ww("T4 RED   entity: fk="); wn(fk); ww(" stale="); wn(stale)
      ww(" alive="); wn(alive); ww(" census="); wn(census); ww("\n")
  }
866
  // ---------- T5 audio-sfx-music (bit 16): the act theme renders, bounded + deterministic ----------
  checks=checks+1
  var t5: i64=0
  let NS: i64 = 40000
  let smp: *i64 = sys_mmap(NS*8+64) as *i64
  d2_render_theme(smp, NS)
  var over: i64=0
  var nonz: i64=0
  var si: i64=0
  while si<NS {
      var v: i64=smp[si]
      if v<0 { v=0-v }
      if v>MUS_SAMPMAX { over=over+1 }
      if v>0 { nonz=nonz+1 }
      si=si+1
  }
  var sck1: i64=1469598103
  si=0
  while si<NS { sck1 = dckv(sck1, smp[si]); si=si+1 }
  let smp2: *i64 = sys_mmap(NS*8+64) as *i64
  d2_render_theme(smp2, NS)
  var sck2: i64=1469598103
  si=0
  while si<NS { sck2 = dckv(sck2, smp2[si]); si=si+1 }
  let wbuf: *u8 = sys_mmap(NS*4+128)
  let wlen: i64 = wav_render_stereo(smp, smp, NS, 8000, wbuf)
  wav_save("knowledge/nx_wire_diablo2.wav" as *u8, wbuf, wlen)
  var riff: i64=0
  if wbuf[0]==(82 as u8) { if wbuf[1]==(73 as u8) { if wbuf[2]==(70 as u8) { if wbuf[3]==(70 as u8) { riff=1 } } } }
  if nonz>10000 { if over==0 { if sck1==sck2 { if riff==1 { if wlen>100 {
      ww("T5 GREEN music: act theme (2 layered tracks) "); wn(nonz)
      ww(" non-zero samples, 0 past the saturating ceiling, byte-identical re-render (ck "); wn(sck1)
      ww("), real RIFF WAV "); wn(wlen); ww("B -> knowledge/nx_wire_diablo2.wav\n")
      t5=1; pass=pass+1
      mask=mask+dbit(16)
  } } } } }
  if t5==0 {
      ww("T5 RED   music: nonz="); wn(nonz); ww(" over="); wn(over)
      ww(" ck1="); wn(sck1); ww(" ck2="); wn(sck2); ww(" riff="); wn(riff); ww(" wlen="); wn(wlen); ww("\n")
  }
907
  // ---------- T6 save/load TRANSPARENCY (bit 15) ----------
  checks=checks+1
  var t6: i64=0
  let bank: *i64 = sys_mmap((D2_T2W-D2_T1W+2)*8) as *i64
  d2_new(d1, SEED)
  var t: i64=0
  while t<D2_T1W { d2_tick(d1); t=t+1 }
  let g1a: *i64 = (d1 as i64 + DG_O_ENT*8) as *i64
  let nv_alive: i64 = en_count(g1a)
  let nv_xp: i64 = d1[D_XP]
  let nv_drops: i64 = d1[D_DROPS]
  let ckt1: i64 = d2_ck(d1)
  bank[0]=ckt1
  t=D2_T1W
  while t<D2_T2W { d2_tick(d1); t=t+1; let c: i64 = d2_ck(d1); bank[t-D2_T1W]=c }
  let contwin: i64 = d1[D_WIN]
  d2_new(d2, SEED)
  t=0
  while t<D2_T1W { d2_tick(d2); t=t+1 }
  d2_serialize(d2,S2)
  let sr: i64 = gs_save("knowledge/nx_wire_diablo2_mid.sav" as *u8, D2_SCHEMA, S2, D2_NSV, 20260720)
  var zi: i64=0
  while zi<DG_WORDS { d2[zi]=0; zi=zi+1 }
  let Sl: *i64 = sys_mmap(D2_NSV*8+64) as *i64
  let lr: i64 = gs_load("knowledge/nx_wire_diablo2_mid.sav" as *u8, Sl, D2_NSV, 0 as *i64)
  d2_restore(d2, Sl)
  let ckr: i64 = d2_ck(d2)
  var mismatch: i64=0
  if ckr!=bank[0] { mismatch=mismatch+1 }
  t=D2_T1W
  while t<D2_T2W {
      d2_tick(d2)
      t=t+1
      let c2v: i64 = d2_ck(d2)
      if c2v!=bank[t-D2_T1W] { mismatch=mismatch+1 }
  }
  d2_serialize(d1,S)
  d2_serialize(d2,S2)
  var fdiff: i64=0
  var i2: i64=0
  while i2<D2_NSV { if S[i2]!=S2[i2] { fdiff=fdiff+1 } i2=i2+1 }
  if sr>0 { if lr==D2_NSV { if mismatch==0 { if fdiff==0 { if nv_alive>=1 { if nv_xp>0 { if nv_drops>=1 { if contwin==0 {
      ww("T6 GREEN save/load TRANSPARENT: save turn "); wn(D2_T1W)
      ww(" -> ZEROED arena -> resume to "); wn(D2_T2W); ww(": all "); wn(D2_T2W-D2_T1W+1)
      ww(" per-turn checksums identical, 0/"); wn(D2_NSV)
      ww(" fields differ (world non-trivial: alive="); wn(nv_alive)
      ww(" xp="); wn(nv_xp); ww(" drops="); wn(nv_drops); ww(")\n")
      t6=1; pass=pass+1
      mask=mask+dbit(15)
  } } } } } } } }
  if t6==0 {
      ww("T6 RED   transparency: save="); wn(sr); ww(" load="); wn(lr)
      ww(" mism="); wn(mismatch); ww(" fdiff="); wn(fdiff); ww(" alive="); wn(nv_alive)
      ww(" xp="); wn(nv_xp); ww(" drops="); wn(nv_drops); ww(" contwin="); wn(contwin); ww("\n")
  }
963
  // ---------- T7 corruption refused ----------
  checks=checks+1
  var t7: i64=0
  let lenp: *i64 = sys_mmap(8) as *i64
  lenp[0]=0
  let raw: *u8 = sys_read_file("knowledge/nx_wire_diablo2_mid.sav" as *u8, lenp)
  if (raw as i64)!=0 {
      let rl: i64 = lenp[0]
      let flip: i64 = 48+16
      raw[flip] = (raw[flip] as i64 ^ 255) as u8
      let cfd: i64 = sys_openat_wr("knowledge/nx_wire_diablo2_corrupt.sav" as *u8, 0x1a4)
      if cfd>=0 {
          sys_write(cfd, raw, rl)
          sys_close(cfd)
          let Sc: *i64 = sys_mmap(D2_NSV*8+64) as *i64
          Sc[0]=777777
          let cr: i64 = gs_load("knowledge/nx_wire_diablo2_corrupt.sav" as *u8, Sc, D2_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) and caller state untouched\n")
      pass=pass+1
  }
  if t7==0 { ww("T7 RED   corrupt-save handling failed\n") }
989
  // ---------- T8 determinism ----------
  checks=checks+1
  var t8: i64=0
  d2_new(d2, SEED)
  d2_run_full(d2)
  let fck2: i64 = d2_ck(d2)
  if fck==fck2 { if runwin==d2[D_WIN] {
      ww("T8 GREEN deterministic: two independent full runs -> identical final checksum "); wn(fck)
      ww(" at turn "); wn(d2[D_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") }
1002
  // ---------- T9 anti-vacuity: the ARPG was PLAYED and WON ----------
  checks=checks+1
  var t9: i64=0
  if d2[D_WIN]==1 { if d2[D_TURN]>20 { if d2[D_TURN]<D2_MAXT { if d2[D_KILLS]==D2_ACTS*D2_NMON { if d2[D_HP]>0 {
      ww("T9 GREEN the ARPG was PLAYED and WON: "); wn(D2_ACTS); ww(" acts cleared, ")
      wn(d2[D_KILLS]); ww(" kills in "); wn(d2[D_TURN]); ww(" rounds, survived at hp "); wn(d2[D_HP]); ww("\n")
      t9=1; pass=pass+1
  } } } } }
  if t9==0 {
      ww("T9 RED   loop hollow: win="); wn(d2[D_WIN]); ww(" turns="); wn(d2[D_TURN])
      ww(" kills="); wn(d2[D_KILLS]); ww(" hp="); wn(d2[D_HP]); ww("\n")
  }
1015
  // ---------- T10 ui-menus-hud (bit 18): every drop decided through the menu; HUD binds live state ----------
  checks=checks+1
  let hud2: *i64 = (d2 as i64 + DG_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 = d2_hudchain(SEED, D2_T2W, o10a)
  let ch10b: i64 = d2_hudchain(SEED, D2_T2W, o10b)
  var t10: i64=0
  if ch10a==ch10b { if o10a[0]>=2 { if o10a[1]>=D2_HUDINK { if menusel>=1 { if menusel==d2[D_DROPS] {
      ww("T10 GREEN ui-menus-hud: "); wn(menusel); ww(" drops ALL decided through menu selections (nsel==drops), ")
      ww("HUD chain deterministic over "); wn(D2_T2W); ww(" rounds ("); wn(o10a[0])
      ww(" frame changes, "); wn(o10a[1]); ww(" ink px)\n")
      t10=1; pass=pass+1
      mask=mask+dbit(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(" drops="); wn(d2[D_DROPS]); ww("\n")
  }
1037
  // ---------- T11 render-2d-raster (bit 0): the campaign renders as a live 2D frame ----------
  checks=checks+1
  let o11a: *i64 = sys_mmap(8*8) as *i64
  let o11b: *i64 = sys_mmap(8*8) as *i64
  let ch11a: i64 = d2_rchain(SEED, D2_T2W, o11a)
  let ch11b: i64 = d2_rchain(SEED, D2_T2W, o11b)
  let fsth11: *i64 = sys_mmap(FS_NMETRIC*8) as *i64
  fs_default_th(fsth11)
  let fsm11: *i64 = ((o11a as i64) + 2*8) as *i64
  var t11: i64=0
  if ch11a==ch11b { if o11a[0]>=2 { if fs_verdict(fsm11, fsth11)==1 { t11=1 } } }
  if t11==1 {
      ww("T11 GREEN render-2d: frame chain deterministic over "); wn(D2_T2W); ww(" rounds, ")
      wn(o11a[0]); ww(" frame changes, mid-frame experiential sane (")
      wn(fsm11[0]); ww("/"); wn(fsm11[1]); ww("/"); wn(fsm11[2]); ww("/"); wn(fsm11[3]); ww("/"); wn(fsm11[4]); ww(")\n")
      pass=pass+1
      mask=mask+dbit(0)
  }
  if t11==0 {
      ww("T11 RED   render-2d: chA="); wn(ch11a); ww(" chB="); wn(ch11b); ww(" changes="); wn(o11a[0])
      ww(" fs="); wn(fsm11[0]); ww("/"); wn(fsm11[1]); ww("/"); wn(fsm11[2]); ww("/"); wn(fsm11[3]); ww("/"); wn(fsm11[4]); ww("\n")
  }
1060
  // ---------- T12 pathfinding-ai (bit 7): the part drives every approach, validated in-loop ----------
  checks=checks+1
  var t12: i64=0
  if d2[D_WALKS]>=D2_NMON { if d2[D_PSTEPS]>=d2[D_WALKS] { if d2[D_PATHBAD]==0 { if d2[D_PSTEPS]==runpsteps {
      ww("T12 GREEN pathfinding: "); wn(d2[D_WALKS]); ww(" click-to-move approaches, ")
      wn(d2[D_PSTEPS]); ww(" A* steps walked, every step 4-adjacent floor validated IN-LOOP ")
      ww("(0 violations; floors derived: walks >= one act's packs, steps >= walks), identical across independent runs\n")
      t12=1; pass=pass+1
      mask=mask+dbit(7)
  } } } }
  if t12==0 {
      ww("T12 RED   pathfinding: walks="); wn(d2[D_WALKS]); ww(" psteps="); wn(d2[D_PSTEPS])
      ww(" pathbad="); wn(d2[D_PATHBAD]); ww(" run1-psteps="); wn(d1[D_PSTEPS]); ww("\n")
  }
1075
  // ---------- T13 input-realtime (bit 17): equips are CAUSED by edges routed through F1102 ----------
  checks=checks+1
  let dctl: *i64 = sys_mmap(DG_WORDS*8) as *i64
  d2_new(dctl, SEED)
  dctl[D_INSCRIPT]=0
  d2_run_full(dctl)
  let ctlck: i64 = d2_ck(dctl)
  var t13: i64=0
  if d2[D_INEV]==d2[D_DROPS] { if d2[D_INEV]>=1 { if d2[D_EQUIPS]>=1 { if dctl[D_INEV]==0 { if dctl[D_EQUIPS]==0 { if ctlck!=fck2 {
      ww("T13 GREEN input: "); wn(d2[D_INEV]); ww(" confirm edges routed through the F1102 part (one per drop), ")
      wn(d2[D_EQUIPS]); ww(" equips all edge-caused; CONTROL run with the script disabled: 0 edges, 0 equips, ")
      ww("different campaign (ck "); wn(ctlck); ww(" != "); wn(fck2); ww(") -- input is CAUSAL, not decoration\n")
      t13=1; pass=pass+1
      mask=mask+dbit(17)
  } } } } } }
  if t13==0 {
      ww("T13 RED   input: inev="); wn(d2[D_INEV]); ww(" drops="); wn(d2[D_DROPS])
      ww(" equips="); wn(d2[D_EQUIPS]); ww(" ctl-inev="); wn(dctl[D_INEV])
      ww(" ctl-equips="); wn(dctl[D_EQUIPS]); ww(" ctlck="); wn(ctlck); ww(" fck2="); wn(fck2); ww("\n")
  }
1096
  // ---------- T14 asset-pipeline-import (bit 25): the WON campaign's victory screen imports and
  // renders the standard-corpus mesh through the certified OBJ chain (nx_objload -> nx_trimesh),
  // the exact part nx_bunny_gate certifies: EXACT canonical Stanford counts (35947/69451) prove
  // provenance; scale/camera/floor are that gate's own calibration, reused not re-picked. ----------
  checks=checks+1
  let tw14: i64 = 300
  let th14: i64 = 300
  let npx14: i64 = tw14*th14
  let bg14: i64 = 24 + 26*256 + 34*65536
  let fb14: *i64 = sys_mmap(npx14*8) as *i64
  let zb14: *i64 = sys_mmap(npx14*8) as *i64
  tm_set_spec(0)
  tm_set_tex(0)
  let ok14: i64 = obj_load("knowledge/stdassets/bunny.obj" as *u8, 1300, 205+200*256+195*65536)
  let nv14: i64 = tm_nv()
  let nt14: i64 = tm_nt()
  d_clearfb(fb14, npx14, bg14)
  trimesh_zclear(zb14, npx14)
  trimesh_render(fb14, zb14, tw14, th14, 1300, 0-250, 2300, 520, 2)
  let fil14: i64 = d_filled(fb14, npx14, bg14)
  let rck14: i64 = d_fbck(fb14, npx14)
  d_clearfb(fb14, npx14, bg14)
  trimesh_zclear(zb14, npx14)
  trimesh_render(fb14, zb14, tw14, th14, 1300, 0-250, 2300, 520, 2)
  let rck14b: i64 = d_fbck(fb14, npx14)
  var t14: i64=0
  if d2[D_WIN]==1 { if ok14==1 { if nv14==35947 { if nt14==69451 { if tm_ovf()==0 { if fil14>npx14/12 { if rck14==rck14b {
      ww("T14 GREEN asset-import: WON campaign's victory screen renders the imported standard mesh -- ")
      ww("EXACT canonical Stanford counts (35947/69451, provenance by the numbers), ")
      wn(fil14); ww(" px rasterized (floor npx/12 = the part's own gate calibration), deterministic\n")
      t14=1; pass=pass+1
      mask=mask+dbit(25)
  } } } } } } }
  if t14==0 {
      ww("T14 RED   asset-import: win="); wn(d2[D_WIN]); ww(" ok="); wn(ok14)
      ww(" nv="); wn(nv14); ww(" nt="); wn(nt14); ww(" ovf="); wn(tm_ovf())
      ww(" filled="); wn(fil14); ww(" ckA="); wn(rck14); ww(" ckB="); wn(rck14b); ww("\n")
  }
1135
  // ---------- wiring evidence artifact ----------
  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]=rundrops
  art[7]=runwin
  let aw2: i64 = gs_save("knowledge/nx_wire_diablo2.sav" as *u8, D2_ART_SCHEMA, art, 8, 20260720)
  ww("\nwiring artifact knowledge/nx_wire_diablo2.sav bytes="); wn(aw2)
  ww(" exercised_mask="); wn(mask); ww(" (bits 0,3,6,7,9,10,15,16,17,18,25 when all their teeth pass)\n")
1149
  ww("\n=== nx_wire_diablo2_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-DIABLO2-GATE" as *u8, ctr__dry, "teeth unchanged; verdict emission migrated onto the shared base class" as *u8)
  sys_exit(rc__dry)
  return rc__dry
1160}
nx_wire_diablo2_gate.nx source

`nx_wire_diablo2_gate.nx` source
