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

↩ module page · 764 lines · 32260 B
1// nx_wire_endlesssky_gate.nx -- TITLE WIRING #3: Endless Sky (space trading / adventure). An actual
2// playable trading loop built ONLY from certified parts: nx_worldsim holds 5 factions (player-trader +
3// 4 governments) whose economy CONSERVES wealth exactly (trades move credits, production is accounted);
4// nx_plotgen generates mission graphs that the REAL nx_story_vm executes stepwise (branches taken when
5// their flag-gates are satisfied, REFUSED when not); mission content round-trips through nx_gamesave as
6// a durable content file; ship outfits apply as nx_rpgstats modifiers to cargo capacity and the trading
7// skill ranks up through rs_skill_rank; the ambient theme renders through nx_gamemusic; the whole game
8// state passes the GX-9 save/load transparency test.
9//
10// CAPS EXERCISED (bit = nx_gamebench capability index; measured mask = artifact payload[0]):
11//   bit 21 world-sim-factions   bit 12 dialogue-tree-branching   bit 19 scripting-content-format
12//   bit 9  rpg-stats-progression   bit 16 audio-sfx-music   bit 15 save-load-persistence
13//   bit 18 ui-menus-hud (nx_gamehud: every OUTFIT PURCHASE decided through a modal menu, returned id
14//     drives the buy) + bit 0 render-2d (nx_game_raster: live mission-map frame, pure fn of state).
15// NOT exercised: none of the title's required vector remains unproven by this loop.
16//
17// FLAGSHIP (mutation target): CONSERVATION. Paying a mission reward by MINTING credits instead of
18// transferring them from the government's treasury must drive the economy tooth RED (total grew beyond
19// accounted production) while the game still plays to a win.
20//
21// DIALECT: no `else if`, no `||`, no multiline `else` (nx_cc parser desync -- see nx_wire_probe.nx aux2).
22// license_tier: ORIGINAL  expect_exit: 0
23import "nx_syscalls.nx"
24import "nx_gamehud.nx"
25import "nx_game_raster.nx"
26import "nx_frame_sanity.nx"
27import "nx_wire_harness.nx"
28import "nx_gamesave.nx"
29import "nx_rpgstats.nx"
30import "nx_worldsim.nx"
31import "nx_plotgen.nx"
32import "nx_gamemusic.nx"
33import "nx_audio_wav.nx"
34import "nx_gate_verdict.nx"
35import "nx_trimesh.nx"
36import "nx_objload.nx"
37
38// ---- shape (data at the top, rule 11) ----
39const ES_NFAC:   i64 = 5         // 0 = player-trader, 1..4 = governments
40const ES_RATE:   i64 = 3         // production per territory per tick
41const ES_MAXT:   i64 = 300
42const ES_MNODES: i64 = 12        // mission graph nodes
43const ES_MISSIONS_WIN: i64 = 3
44const ES_CREDITS_WIN:  i64 = 1500
45const ES_CARGO_BASE:   i64 = 40
46const ES_SKILL_TH:     i64 = 8   // trades per skill rank
47const ES_SKILL_MAX:    i64 = 5
48const ES_OUTFIT_MAX:   i64 = 4
49const ES_OUTFIT_COST:  i64 = 300
50// save shape
51const ES_HDRN:  i64 = 24
52const ES_WSW:   i64 = 52        // ws_words(5)
53const ES_NSV:   i64 = 76        // 24 hdr + 52 worldsim words
54const ES_SCHEMA: i64 = 7309
55const ES_CONTENT_SCHEMA: i64 = 7319
56const ES_ART_SCHEMA: i64 = 7329
57// transparency window (tune to sit fully before the measured win turn)
58const ES_T1W: i64 = 8
59const ES_T2W: i64 = 25
60// arena offsets (i64 words)
61const EW_O_WS:  i64 = 24
62const EO_CHT:   i64 = 80
63const EO_CHR:   i64 = 128
64const EO_CHS:   i64 = 176
65const EO_IEN:   i64 = 224
66const EO_HUD:   i64 = 240        // nx_gamehud arena APPENDED (transient UI; hud[63]=777 lazy-init marker
                               // so restore into a zeroed arena re-inits without touching e_new/e_restore)
68const EG_WORDS: i64 = 304
69const ES_HUDINK: i64 = 30        // T11 experiential min ink (mission map is sparser than a 3D scene)
70// header fields
71const E_SEED: i64 = 0
72const E_TICK: i64 = 1
73const E_TRADES: i64 = 2
74const E_MDONE: i64 = 3
75const E_CUR: i64 = 4
76const E_FLAGS: i64 = 5
77const E_GATED: i64 = 6
78const E_BLOCKED: i64 = 7
79const E_OUTFITS: i64 = 8
80const E_WIN: i64 = 9
81const E_EXPADD: i64 = 10        // accumulated ACCOUNTED production
82const E_START: i64 = 11         // total wealth at game start
83const E_NMODS: i64 = 12
84const E_MODP: i64 = 13          // 4 pairs (kind,val) -> 13..20
85const E_STEPS: i64 = 21         // mission steps executed via sv_choose
86const E_RES1: i64 = 22
87const E_RES2: i64 = 23
88
89func ww(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
90func 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
98}
99func ebit(i: i64) -> i64 { var v: i64=1; var k: i64=0; while k<i { v=v*2; k=k+1 } return v }
100func eckv(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
104}
105func e_ws(e: *i64) -> *i64 { return (e as i64 + EW_O_WS*8) as *i64 }
106func e_mseed(e: *i64) -> i64 { return e[E_SEED]*31 + e[E_MDONE]*101 + 7 }
107// outfit catalog (DATA): kind 0 = +cargo, kind 1 = +cargo%
108func e_outfit_kind(i: i64) -> i64 { if i%2==0 { return 0 } return 1 }
109func e_outfit_val(i: i64) -> i64 {
  if i==0 { return 15 }
  if i==1 { return 20 }
  if i==2 { return 10 }
  return 25
114}
115func e_new(e: *i64, seed: i64) -> i64 {
  var i: i64=0
  while i<ES_HDRN { e[i]=0; i=i+1 }
  e[E_SEED]=seed
  let w: *i64 = e_ws(e)
  ws_init(w, ES_NFAC, seed*7+1)
  ws_set_res(w, 0, 500)
  ws_set_pop(w, 0, 100)
  ws_set_terr(w, 0, 0)                 // the player produces nothing: wealth only MOVES to them
  var f: i64=1
  while f<ES_NFAC {
      ws_set_res(w, f, 2000 + f*500)
      ws_set_pop(w, f, 500)
      ws_set_terr(w, f, 2 + f)
      f=f+1
  }
  e[E_START]=ws_total_res(w)
  let cht: *i64 = (e as i64 + EO_CHT*8) as *i64
  let chr: *i64 = (e as i64 + EO_CHR*8) as *i64
  let chs: *i64 = (e as i64 + EO_CHS*8) as *i64
  let ien: *i64 = (e as i64 + EO_IEN*8) as *i64
  let ms: i64 = e_mseed(e)
  pg_gen(cht, chr, chs, ien, ES_MNODES, ms)
  return 0
139}
140func e_cargo(e: *i64) -> i64 {
  let mods: *i64 = (e as i64 + E_MODP*8) as *i64
  return rs_apply_mods(ES_CARGO_BASE, mods, e[E_NMODS])
143}
144// one game tick
145func e_tick(e: *i64) -> i64 {
  if e[E_WIN]==1 { return 0 }
  let w: *i64 = e_ws(e)
  // 1. accounted production, then the world tick
  let exp: i64 = ws_production(w, ES_RATE)
  e[E_EXPADD]=e[E_EXPADD]+exp
  ws_tick(w, ES_RATE)
  // 2. a trading run: buy from gov A, sell to gov B at a margin; cargo caps the load
  let gA: i64 = 1 + (e[E_TICK]%4)
  let gB: i64 = 1 + ((e[E_TICK]+1)%4)
  var load: i64 = 50 + (e[E_TICK]%30)
  let cargo: i64 = e_cargo(e)
  if load>cargo { load=cargo }
  let skill: i64 = rs_skill_rank(e[E_TRADES], ES_SKILL_TH, ES_SKILL_MAX)
  let margin: i64 = load/5 + skill*2
  let m1: i64 = ws_trade(w, 0, gA, load)
  let back: i64 = m1 + margin
  ws_trade(w, gB, 0, back)
  e[E_TRADES]=e[E_TRADES]+1
  // 3. one mission step through the REAL story VM: prefer the branch choice, fall back to the spine
  let cht: *i64 = (e as i64 + EO_CHT*8) as *i64
  let chr: *i64 = (e as i64 + EO_CHR*8) as *i64
  let chs: *i64 = (e as i64 + EO_CHS*8) as *i64
  let ien: *i64 = (e as i64 + EO_IEN*8) as *i64
  let fl: *i64 = (e as i64 + E_FLAGS*8) as *i64
  let base: i64 = e[E_CUR]*SV_NCH
  var stepped: i64=0
  if cht[base+1]>=0 {
      let wasreq: i64 = chr[base+1]
      let nxt: i64 = sv_choose(cht, chr, chs, e[E_CUR], 1, fl)
      if nxt>=0 {
          if wasreq>0 { e[E_GATED]=e[E_GATED]+1 }
          e[E_CUR]=nxt
          stepped=1
          e[E_STEPS]=e[E_STEPS]+1
      }
      if nxt<0 { e[E_BLOCKED]=e[E_BLOCKED]+1 }
  }
  if stepped==0 {
      let nx2: i64 = sv_choose(cht, chr, chs, e[E_CUR], 0, fl)
      if nx2>=0 { e[E_CUR]=nx2; e[E_STEPS]=e[E_STEPS]+1 }
  }
  if sv_is_end(ien, e[E_CUR])==1 {
      // mission complete: the reward is a CONSERVED TRANSFER from the issuing government
      let gv: i64 = 1 + (e[E_MDONE]%4)
      let rew: i64 = 200 + e[E_MDONE]*50
      ws_trade(w, gv, 0, rew)
      e[E_MDONE]=e[E_MDONE]+1
      e[E_CUR]=0
      e[E_FLAGS]=0
      let ms: i64 = e_mseed(e)
      pg_gen(cht, chr, chs, ien, ES_MNODES, ms)
  }
  // 4. outfit purchase THROUGH THE MENU (bit 18): when a purchase is affordable the shipyard menu
  // opens [buy, hold]; the RETURNED id drives the trade -- causal, full-wrap exercised per decision;
  // policy (buy when affordable) rides menu ORDER so behavior and every banked ck are unchanged.
  if e[E_OUTFITS]<ES_OUTFIT_MAX {
      let credits: i64 = ws_res(w,0)
      let need: i64 = 800 + 400*e[E_OUTFITS]
      if credits>need {
          let hud: *i64 = (e as i64 + EO_HUD*8) as *i64
          if hud[63]!=777 { gh_init(hud, 5); hud[63]=777 }
          let dec: i64 = wh_menu_pick2(hud, 1, ES_OUTFIT_COST, 2, credits)   // MIGRATED to nx_wire_harness
          var paid: i64 = 0
          if dec==1 { paid = ws_trade(w, 0, 1, ES_OUTFIT_COST) }
          if paid==ES_OUTFIT_COST {
              let oi: i64 = e[E_OUTFITS]
              let kk: i64 = e_outfit_kind(oi)
              let vv: i64 = e_outfit_val(oi)
              e[E_MODP + e[E_NMODS]*2]=kk
              e[E_MODP + e[E_NMODS]*2 + 1]=vv
              e[E_NMODS]=e[E_NMODS]+1
              e[E_OUTFITS]=e[E_OUTFITS]+1
          }
      }
  }
  // 5. win check
  if e[E_MDONE]>=ES_MISSIONS_WIN { if ws_res(w,0)>=ES_CREDITS_WIN { e[E_WIN]=1 } }
  e[E_TICK]=e[E_TICK]+1
  return 0
225}
226func e_run_full(e: *i64) -> i64 {
  var go: i64=1
  while go==1 {
      if e[E_WIN]==1 { go=0 }
      if e[E_TICK]>=ES_MAXT { go=0 }
      if go==1 { e_tick(e) }
  }
  return e[E_TICK]
234}
235// render-2d (bit 0): the galaxy as a live 2D faction map via the certified nx_game_raster part.
236// PURE fn of state -- 5 faction columns, bar height = wealth, disc size = territory, plus a top strip
237// for missions-done + credits. 320x180.
238const ER2_W: i64 = 320
239const ER2_H: i64 = 180
240func e_render(e: *i64, fb: *i64) -> i64 {
  let w: *i64 = e_ws(e)
  gr_clear(fb, ER2_W, ER2_H, gr_pack(8, 10, 24))
  var f: i64=0
  while f<ES_NFAC {
      let cx: i64 = 24 + f*60
      let res: i64 = ws_res(w, f)
      var bh: i64 = res/40
      if bh>150 { bh=150 }
      if bh<1 { bh=1 }
      var cr: i64 = 90
      var cg: i64 = 140
      var cb: i64 = 240
      if f>0 { cr = 60 + f*40; cg = 90; cb = 110 + f*20 }
      gr_rect(fb, ER2_W, ER2_H, cx-14, 158-bh, cx+14, 158, gr_pack(cr, cg, cb))
      let terr: i64 = ws_terr(w, f)
      var rad: i64 = 3 + terr
      if rad>14 { rad=14 }
      gr_disc(fb, ER2_W, ER2_H, cx, 168, rad, gr_pack(cr, cg, cb))
      f=f+1
  }
  gr_rect(fb, ER2_W, ER2_H, 0, 2, 6 + e[E_MDONE]*24, 8, gr_pack(240, 200, 60))
  var credbar: i64 = ws_res(w,0)/20
  if credbar>316 { credbar=316 }
  gr_rect(fb, ER2_W, ER2_H, 0, 11, 4 + credbar, 16, gr_pack(120, 220, 140))
  return 0
266}
267func e_fbck(fb: *i64) -> i64 {
  return wh_fbck(fb, ER2_W*ER2_H)      // MIGRATED to nx_wire_harness (shared frame checksum)
269}
270// T11 instrument: replay, rendering per tick; out[0]=changed frames, out[1]=final ink, out[2..7]=mid fs.
271func e_rchain(seed: i64, ticks: i64, out: *i64) -> i64 {
  let e: *i64 = sys_mmap(EG_WORDS*8) as *i64
  e_new(e, seed)
  let fb: *i64 = sys_mmap(ER2_W*ER2_H*8) as *i64
  var chain: i64 = 1469598103
  var prev: i64=0
  var moved: i64=0
  var ink: i64=0
  var t: i64=0
  while t<ticks {
      e_tick(e)
      e_render(e, fb)
      let fk: i64 = e_fbck(fb)
      if t>0 { if fk!=prev { moved=moved+1 } }
      prev=fk
      chain = (chain*131 + (fk & 0xFFFFFFFF)) & 0x7FFFFFFFFFFFFFFF
      if t==ticks/2 { fs_score_i64(fb, ER2_W, ER2_H, ((out as i64) + 2*8) as *i64) }
      t=t+1
  }
  var q: i64=0
  while q<ER2_W*ER2_H { if (fb[q] & 0xFFFFFF)!=gr_pack(8,10,24) { ink=ink+1 } q=q+1 }
  out[0]=moved
  out[1]=ink*1000/(ER2_W*ER2_H)
  return chain
295}
296func e_serialize(e: *i64, S: *i64) -> i64 {
  var i: i64=0
  while i<ES_HDRN { S[i]=e[i]; i=i+1 }
  let w: *i64 = e_ws(e)
  var k: i64=0
  while k<ES_WSW { S[ES_HDRN+k]=w[k]; k=k+1 }
  return ES_NSV
303}
304func e_restore(e: *i64, S: *i64) -> i64 {
  var i: i64=0
  while i<ES_HDRN { e[i]=S[i]; i=i+1 }
  let w: *i64 = e_ws(e)
  var k: i64=0
  while k<ES_WSW { w[k]=S[ES_HDRN+k]; k=k+1 }
  // the mission graph is a PURE function of (seed, missions_done): regenerate it
  let cht: *i64 = (e as i64 + EO_CHT*8) as *i64
  let chr: *i64 = (e as i64 + EO_CHR*8) as *i64
  let chs: *i64 = (e as i64 + EO_CHS*8) as *i64
  let ien: *i64 = (e as i64 + EO_IEN*8) as *i64
  let ms: i64 = e_mseed(e)
  pg_gen(cht, chr, chs, ien, ES_MNODES, ms)
  return 0
318}
319// checksum over hdr + the FULL worldsim arena (graph is a pure fn of hdr fields, covered transitively)
320func e_ck(e: *i64) -> i64 {
  var ck: i64 = 1469598103
  var i: i64=0
  while i<ES_HDRN { ck = eckv(ck, e[i]); i=i+1 }
  let w: *i64 = e_ws(e)
  var k: i64=0
  while k<ES_WSW { ck = eckv(ck, w[k]); k=k+1 }
  return ck
328}
329// the ambient theme (different DATA than the D2 theme -- data-driven songs are the part's claim)
330func e_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
333}
334func e_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(12*3*8) as *i64
  e_song(mel,0, 0,5,3)
  e_song(mel,1, 4,5,3)
  e_song(mel,2, 7,5,3)
  e_song(mel,3, 4,5,3)
  e_song(mel,4, 0,5,6)
  e_song(mel,5, 0-1,0,3)
  e_song(mel,6, 9,4,3)
  e_song(mel,7, 0,5,3)
  e_song(mel,8, 4,5,6)
  e_song(mel,9, 0-1,0,3)
  e_song(mel,10, 7,4,6)
  e_song(mel,11, 0,5,6)
  let pad: *i64 = sys_mmap(6*3*8) as *i64
  e_song(pad,0, 0,3,12)
  e_song(pad,1, 7,2,12)
  e_song(pad,2, 9,2,12)
  e_song(pad,3, 4,3,6)
  e_song(pad,4, 0,3,6)
  e_song(pad,5, 0-1,0,6)
  let TS: i64 = 1000
  mus_render(smp, nsamp, mel, 12, 8000, 8000, TS)
  mus_render(smp, nsamp, pad, 6, 8000, 6000, TS)
  return nsamp
361}
362
363func main() -> i64 {
  ww("=== nx_wire_endlesssky_gate: does the trading/adventure loop run on the certified parts? ===\n\n")
  var pass: i64=0
  var checks: i64=0
  var mask: i64=0
  let SEED: i64 = 1701
  let e1: *i64 = sys_mmap(EG_WORDS*8) as *i64
  let e2: *i64 = sys_mmap(EG_WORDS*8) as *i64
  let S: *i64 = sys_mmap(ES_NSV*8+64) as *i64
  let S2: *i64 = sys_mmap(ES_NSV*8+64) as *i64
373
  // ---------- full deterministic run ----------
  e_new(e1, SEED)
  e_run_full(e1)
  let w1: *i64 = e_ws(e1)
  let fck: i64 = e_ck(e1)
  let runwin: i64 = e1[E_WIN]
  let runtick: i64 = e1[E_TICK]
  let runmiss: i64 = e1[E_MDONE]
  let runcred: i64 = ws_res(w1,0)
  ww("  [run] ticks="); wn(e1[E_TICK]); ww(" win="); wn(e1[E_WIN])
  ww(" missions="); wn(e1[E_MDONE]); ww(" credits="); wn(runcred)
  ww(" trades="); wn(e1[E_TRADES]); ww(" steps="); wn(e1[E_STEPS])
  ww(" gated-taken="); wn(e1[E_GATED]); ww(" blocked="); wn(e1[E_BLOCKED])
  ww(" outfits="); wn(e1[E_OUTFITS]); ww(" ck="); wn(fck); ww("\n")
388
  // ---------- T1 world-sim-factions (bit 21, FLAGSHIP): conservation + accounted growth ----------
  checks=checks+1
  var t1: i64=0
  let endtot: i64 = ws_total_res(w1)
  let expect: i64 = e1[E_START] + e1[E_EXPADD]
  let r01: i64 = ws_rel(w1,0,1)
  let r10: i64 = ws_rel(w1,1,0)
  var negbal: i64=0
  var f: i64=0
  while f<ES_NFAC { if ws_res(w1,f)<0 { negbal=negbal+1 } f=f+1 }
  if endtot==expect { if r01==r10 { if r01>0 { if negbal==0 {
      ww("T1 GREEN worldsim: total "); wn(e1[E_START]); ww(" + accounted production "); wn(e1[E_EXPADD])
      ww(" == final "); wn(endtot); ww(" EXACT across "); wn(e1[E_TRADES]*2)
      ww("+ trades; relations symmetric (rel(0,1)="); wn(r01); ww("==rel(1,0)="); wn(r10)
      ww(", warmed by trade), 0 negative balances\n")
      t1=1; pass=pass+1
      mask=mask+ebit(21)
  } } } }
  if t1==0 {
      ww("T1 RED   worldsim: end="); wn(endtot); ww(" expect="); wn(expect)
      ww(" r01="); wn(r01); ww(" r10="); wn(r10); ww(" negbal="); wn(negbal); ww("\n")
  }
411
  // ---------- T2 dialogue-tree-branching (bit 12): gates TAKEN and REFUSED in-loop ----------
  checks=checks+1
  var t2: i64=0
  if e1[E_GATED]>=1 { if e1[E_BLOCKED]>=1 { if e1[E_STEPS]>=10 { if e1[E_MDONE]>=1 {
      ww("T2 GREEN dialogue: "); wn(e1[E_STEPS]); ww(" sv_choose steps; ")
      wn(e1[E_GATED]); ww(" flag-gated branches TAKEN (requirement satisfied), ")
      wn(e1[E_BLOCKED]); ww(" gated choices REFUSED (requirement unmet) -- branching is enforced, not decorative\n")
      t2=1; pass=pass+1
      mask=mask+ebit(12)
  } } } }
  if t2==0 {
      ww("T2 RED   dialogue: steps="); wn(e1[E_STEPS]); ww(" gated="); wn(e1[E_GATED])
      ww(" blocked="); wn(e1[E_BLOCKED]); ww(" missions="); wn(e1[E_MDONE]); ww("\n")
  }
426
  // ---------- T3 scripting-content-format (bit 19): mission content round-trips through a FILE ----------
  checks=checks+1
  var t3: i64=0
  let CN: i64 = ES_MNODES*SV_NCH*3 + ES_MNODES
  let cbuf: *i64 = sys_mmap(CN*8+64) as *i64
  let gt: *i64 = sys_mmap(ES_MNODES*SV_NCH*8+64) as *i64
  let gr: *i64 = sys_mmap(ES_MNODES*SV_NCH*8+64) as *i64
  let gs2: *i64 = sys_mmap(ES_MNODES*SV_NCH*8+64) as *i64
  let ge: *i64 = sys_mmap(ES_MNODES*8+64) as *i64
  e_new(e2, SEED)
  let ms0: i64 = e_mseed(e2)
  pg_gen(gt, gr, gs2, ge, ES_MNODES, ms0)
  var ci: i64=0
  while ci<ES_MNODES*SV_NCH { cbuf[ci]=gt[ci]; ci=ci+1 }
  var c2i: i64=0
  while c2i<ES_MNODES*SV_NCH { cbuf[ES_MNODES*SV_NCH + c2i]=gr[c2i]; c2i=c2i+1 }
  var c3i: i64=0
  while c3i<ES_MNODES*SV_NCH { cbuf[ES_MNODES*SV_NCH*2 + c3i]=gs2[c3i]; c3i=c3i+1 }
  var c4i: i64=0
  while c4i<ES_MNODES { cbuf[ES_MNODES*SV_NCH*3 + c4i]=ge[c4i]; c4i=c4i+1 }
  let csr: i64 = gs_save("knowledge/nx_wire_es_missions.sav" as *u8, ES_CONTENT_SCHEMA, cbuf, CN, 20260720)
  let cload: *i64 = sys_mmap(CN*8+64) as *i64
  let clr: i64 = gs_load("knowledge/nx_wire_es_missions.sav" as *u8, cload, CN, 0 as *i64)
  var cdiff: i64=0
  ci=0
  while ci<CN { if cload[ci]!=cbuf[ci] { cdiff=cdiff+1 } ci=ci+1 }
  // and the loaded content matches what the LIVE game executes for mission 0 (same pure generator)
  let cht2: *i64 = (e2 as i64 + EO_CHT*8) as *i64
  var gdiff: i64=0
  ci=0
  while ci<ES_MNODES*SV_NCH { if cht2[ci]!=cload[ci] { gdiff=gdiff+1 } ci=ci+1 }
  if csr>0 { if clr==CN { if cdiff==0 { if gdiff==0 { if runmiss>=1 {
      ww("T3 GREEN content-format: mission graph ("); wn(CN)
      ww(" fields) saved to knowledge/nx_wire_es_missions.sav, loaded back 0-diff, matches the live")
      ww(" game's executed mission 0, and the engine walked it to "); wn(runmiss); ww(" completions\n")
      t3=1; pass=pass+1
      mask=mask+ebit(19)
  } } } } }
  if t3==0 {
      ww("T3 RED   content: save="); wn(csr); ww(" load="); wn(clr); ww(" cdiff="); wn(cdiff)
      ww(" gdiff="); wn(gdiff); ww(" missions="); wn(runmiss); ww("\n")
  }
469
  // ---------- T4 rpg-stats (bit 9): outfits ORDER-INDEPENDENT + skill rank exact ----------
  checks=checks+1
  var t4: i64=0
  let mods: *i64 = (e1 as i64 + E_MODP*8) as *i64
  let nm: i64 = e1[E_NMODS]
  let cfwd: i64 = rs_apply_mods(ES_CARGO_BASE, mods, nm)
  let mrev: *i64 = sys_mmap(16*8) as *i64
  var r: i64=0
  while r<nm {
      mrev[r*2]   = mods[(nm-1-r)*2]
      mrev[r*2+1] = mods[(nm-1-r)*2+1]
      r=r+1
  }
  let crev: i64 = rs_apply_mods(ES_CARGO_BASE, mrev, nm)
  let rank: i64 = rs_skill_rank(e1[E_TRADES], ES_SKILL_TH, ES_SKILL_MAX)
  if nm>=2 { if cfwd==crev { if cfwd>ES_CARGO_BASE { if rank>=1 { if rank<=ES_SKILL_MAX {
      ww("T4 GREEN rpgstats: "); wn(nm); ww(" outfit mods -> cargo "); wn(cfwd)
      ww(" (fwd == rev "); wn(crev); ww(", ORDER-INDEPENDENT, > base "); wn(ES_CARGO_BASE)
      ww("); trading skill rank "); wn(rank); ww(" from "); wn(e1[E_TRADES]); ww(" trades (exact, capped)\n")
      t4=1; pass=pass+1
      mask=mask+ebit(9)
  } } } } }
  if t4==0 {
      ww("T4 RED   rpgstats: nmods="); wn(nm); ww(" fwd="); wn(cfwd); ww(" rev="); wn(crev)
      ww(" rank="); wn(rank); ww("\n")
  }
496
  // ---------- T5 music (bit 16): ambient theme, bounded + deterministic ----------
  checks=checks+1
  var t5: i64=0
  let NS: i64 = 40000
  let smp: *i64 = sys_mmap(NS*8+64) as *i64
  e_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 = eckv(sck1, smp[si]); si=si+1 }
  let smp2: *i64 = sys_mmap(NS*8+64) as *i64
  e_render_theme(smp2, NS)
  var sck2: i64=1469598103
  si=0
  while si<NS { sck2 = eckv(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_endlesssky.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: ambient theme (2 layers) "); wn(nonz)
      ww(" non-zero samples, 0 past ceiling, byte-identical re-render (ck "); wn(sck1)
      ww("), RIFF WAV "); wn(wlen); ww("B -> knowledge/nx_wire_endlesssky.wav\n")
      t5=1; pass=pass+1
      mask=mask+ebit(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("\n")
  }
537
  // ---------- T6 save/load TRANSPARENCY (bit 15) ----------
  checks=checks+1
  var t6: i64=0
  let bank: *i64 = sys_mmap((ES_T2W-ES_T1W+2)*8) as *i64
  e_new(e1, SEED)
  var t: i64=0
  while t<ES_T1W { e_tick(e1); t=t+1 }
  let nv_trades: i64 = e1[E_TRADES]
  let nv_prod: i64 = e1[E_EXPADD]
  let nv_prog: i64 = e1[E_MDONE]*100 + e1[E_CUR]
  let ckt1: i64 = e_ck(e1)
  bank[0]=ckt1
  t=ES_T1W
  while t<ES_T2W { e_tick(e1); t=t+1; let c: i64 = e_ck(e1); bank[t-ES_T1W]=c }
  let contwin: i64 = e1[E_WIN]
  e_new(e2, SEED)
  t=0
  while t<ES_T1W { e_tick(e2); t=t+1 }
  e_serialize(e2,S2)
  let sr: i64 = gs_save("knowledge/nx_wire_endlesssky_mid.sav" as *u8, ES_SCHEMA, S2, ES_NSV, 20260720)
  var zi: i64=0
  while zi<EG_WORDS { e2[zi]=0; zi=zi+1 }
  let Sl: *i64 = sys_mmap(ES_NSV*8+64) as *i64
  let lr: i64 = gs_load("knowledge/nx_wire_endlesssky_mid.sav" as *u8, Sl, ES_NSV, 0 as *i64)
  e_restore(e2, Sl)
  let ckr: i64 = e_ck(e2)
  var mismatch: i64=0
  if ckr!=bank[0] { mismatch=mismatch+1 }
  t=ES_T1W
  while t<ES_T2W {
      e_tick(e2)
      t=t+1
      let c2v: i64 = e_ck(e2)
      if c2v!=bank[t-ES_T1W] { mismatch=mismatch+1 }
  }
  e_serialize(e1,S)
  e_serialize(e2,S2)
  var fdiff: i64=0
  var i2: i64=0
  while i2<ES_NSV { if S[i2]!=S2[i2] { fdiff=fdiff+1 } i2=i2+1 }
  if sr>0 { if lr==ES_NSV { if mismatch==0 { if fdiff==0 { if nv_trades>=1 { if nv_prod>0 { if nv_prog>0 { if contwin==0 {
      ww("T6 GREEN save/load TRANSPARENT: save tick "); wn(ES_T1W)
      ww(" -> ZEROED arena -> resume to "); wn(ES_T2W); ww(": all "); wn(ES_T2W-ES_T1W+1)
      ww(" per-tick checksums identical, 0/"); wn(ES_NSV)
      ww(" fields differ (world live: trades="); wn(nv_trades)
      ww(" production="); wn(nv_prod); ww(" mission-progress="); wn(nv_prog); ww(")\n")
      t6=1; pass=pass+1
      mask=mask+ebit(15)
  } } } } } } } }
  if t6==0 {
      ww("T6 RED   transparency: save="); wn(sr); ww(" load="); wn(lr)
      ww(" mism="); wn(mismatch); ww(" fdiff="); wn(fdiff); ww(" trades="); wn(nv_trades)
      ww(" prod="); wn(nv_prod); ww(" prog="); wn(nv_prog); ww(" contwin="); wn(contwin); ww("\n")
  }
592
  // ---------- 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_endlesssky_mid.sav" as *u8, lenp)
  if (raw as i64)!=0 {
      let rl: i64 = lenp[0]
      let flip: i64 = 48+40
      raw[flip] = (raw[flip] as i64 ^ 255) as u8
      let cfd: i64 = sys_openat_wr("knowledge/nx_wire_endlesssky_corrupt.sav" as *u8, 0x1a4)
      if cfd>=0 {
          sys_write(cfd, raw, rl)
          sys_close(cfd)
          let Sc: *i64 = sys_mmap(ES_NSV*8+64) as *i64
          Sc[0]=777777
          let cr: i64 = gs_load("knowledge/nx_wire_endlesssky_corrupt.sav" as *u8, Sc, ES_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") }
618
  // ---------- T8 determinism ----------
  checks=checks+1
  var t8: i64=0
  e_new(e2, SEED)
  e_run_full(e2)
  let fck2: i64 = e_ck(e2)
  if fck==fck2 { if runwin==e2[E_WIN] {
      ww("T8 GREEN deterministic: two independent full runs -> identical final checksum "); wn(fck)
      ww(" at tick "); wn(e2[E_TICK]); ww("\n")
      t8=1; pass=pass+1
  } }
  if t8==0 { ww("T8 RED   run1 ck="); wn(fck); ww(" run2 ck="); wn(fck2); ww("\n") }
631
  // ---------- T9 anti-vacuity: the trader PLAYED and WON ----------
  checks=checks+1
  var t9: i64=0
  let w2: *i64 = e_ws(e2)
  let cred2: i64 = ws_res(w2,0)
  if e2[E_WIN]==1 { if e2[E_TICK]>10 { if e2[E_TICK]<ES_MAXT { if e2[E_MDONE]>=ES_MISSIONS_WIN { if cred2>=ES_CREDITS_WIN { if e2[E_TRADES]>=10 {
      ww("T9 GREEN the trader PLAYED and WON: "); wn(e2[E_MDONE]); ww(" missions + ")
      wn(cred2); ww(" credits (from 500) in "); wn(e2[E_TICK]); ww(" ticks, ")
      wn(e2[E_TRADES]); ww(" trade runs\n")
      t9=1; pass=pass+1
  } } } } } }
  if t9==0 {
      ww("T9 RED   loop hollow: win="); wn(e2[E_WIN]); ww(" ticks="); wn(e2[E_TICK])
      ww(" missions="); wn(e2[E_MDONE]); ww(" credits="); wn(cred2); ww(" trades="); wn(e2[E_TRADES]); ww("\n")
  }
647
  // ---------- T10 ui-menus-hud (bit 18): every outfit buy decided through the shipyard menu ----------
  checks=checks+1
  let hud1: *i64 = (e1 as i64 + EO_HUD*8) as *i64
  let esel: i64 = hud1[GH_F_NSEL]
  // CAUSAL invariant: E_OUTFITS is incremented ONLY inside the dec==1 (menu "buy") branch, so every
  // purchase passed through a menu decision. nsel counts ALL shipyard visits (a menu can open and the
  // buy not complete when a later mission reward is still pending) => nsel >= outfits >= 1. The buy
  // policy rides menu ORDER, so removing the menu (mutation: select "hold") drops outfits to 0 = RED.
  var t10: i64=0
  if esel>=1 { if e1[E_OUTFITS]>=1 { if esel>=e1[E_OUTFITS] { t10=1 } } }
  if t10==1 {
      ww("T10 GREEN ui-menus-hud: "); wn(e1[E_OUTFITS]); ww(" outfit purchases ALL gated by menu buy-decisions (")
      wn(esel); ww(" shipyard visits >= "); wn(e1[E_OUTFITS]); ww(" completed buys)\n")
      pass=pass+1
      mask=mask+ebit(18)
  }
  if t10==0 { ww("T10 RED   ui-menus-hud: nsel="); wn(esel); ww(" outfits="); wn(e1[E_OUTFITS]); ww("\n") }
665
  // ---------- T11 render-2d-raster (bit 0): the galaxy renders as a live faction map ----------
  checks=checks+1
  let o11a: *i64 = sys_mmap(8*8) as *i64
  let o11b: *i64 = sys_mmap(8*8) as *i64
  let ch11a: i64 = e_rchain(SEED, ES_T2W, o11a)
  let ch11b: i64 = e_rchain(SEED, ES_T2W, o11b)
  let fsth11: *i64 = sys_mmap(FS_NMETRIC*8) as *i64
  fs_default_th(fsth11)
  fsth11[2]=1
  fsth11[3]=0
  let fsm11: *i64 = ((o11a as i64) + 2*8) as *i64
  var t11: i64=0
  if ch11a==ch11b { if o11a[0]>=2 { if o11a[1]>=ES_HUDINK { if fsm11[0]<=fsth11[0] { if fsm11[1]<=fsth11[1] { t11=1 } } } } }
  if t11==1 {
      ww("T11 GREEN render-2d: faction map deterministic over "); wn(ES_T2W); ww(" ticks, ")
      wn(o11a[0]); ww(" frame changes, "); wn(o11a[1]); ww(" ink px, no blown/void (")
      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+ebit(0)
  }
  if t11==0 {
      ww("T11 RED   render-2d: chA="); wn(ch11a); ww(" chB="); wn(ch11b); ww(" changes="); wn(o11a[0])
      ww(" ink="); wn(o11a[1]); ww(" fs="); wn(fsm11[0]); ww("/"); wn(fsm11[1]); ww("\n")
  }
690
  // ---------- T12 asset-pipeline-import (bit 25): the WON campaign's victory hangar renders the
  // imported 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 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()
  var zc12: i64=0
  while zc12<npx12 { fb12[zc12]=bg12; zc12=zc12+1 }
  trimesh_zclear(zb12, npx12)
  trimesh_render(fb12, zb12, tw12, th12, 1300, 0-250, 2300, 520, 2)
  var fil12: i64=0
  var ck12a: i64=1469598103
  var fi12: i64=0
  while fi12<npx12 {
      if fb12[fi12]!=bg12 { fil12=fil12+1 }
      ck12a = eckv(ck12a, fb12[fi12])
      fi12=fi12+1
  }
  zc12=0
  while zc12<npx12 { fb12[zc12]=bg12; zc12=zc12+1 }
  trimesh_zclear(zb12, npx12)
  trimesh_render(fb12, zb12, tw12, th12, 1300, 0-250, 2300, 520, 2)
  var ck12b: i64=1469598103
  fi12=0
  while fi12<npx12 { ck12b = eckv(ck12b, fb12[fi12]); fi12=fi12+1 }
  var t12a: i64=0
  if e2[E_WIN]==1 { if ok12==1 { if nv12==35947 { if nt12==69451 { if tm_ovf()==0 { if fil12>npx12/12 { if ck12a==ck12b {
      ww("T12 GREEN asset-import: WON campaign's victory hangar 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")
      t12a=1; pass=pass+1
      mask=mask+ebit(25)
  } } } } } } }
  if t12a==0 {
      ww("T12 RED   asset-import: win="); wn(e2[E_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(ck12a); ww(" ckB="); wn(ck12b); ww("\n")
  }
739
  // ---------- wiring evidence artifact ----------
  let art: *i64 = sys_mmap(16*8) as *i64
  art[0]=mask
  art[1]=fck
  art[2]=runtick
  art[3]=runmiss
  art[4]=runcred
  art[5]=e1[E_TRADES]
  art[6]=e1[E_GATED]
  art[7]=runwin
  let aw2: i64 = gs_save("knowledge/nx_wire_endlesssky.sav" as *u8, ES_ART_SCHEMA, art, 8, 20260720)
  ww("\nwiring artifact knowledge/nx_wire_endlesssky.sav bytes="); wn(aw2)
  ww(" exercised_mask="); wn(mask); ww(" (bits 0,9,12,15,16,18,19,21,25 when all their teeth pass)\n")
753
  ww("\n=== nx_wire_endlesssky_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-ENDLESSSKY-GATE" as *u8, ctr__dry, "teeth unchanged; verdict emission migrated onto the shared base class" as *u8)
  sys_exit(rc__dry)
  return rc__dry
764}
nx_wire_endlesssky_gate.nx source

`nx_wire_endlesssky_gate.nx` source
