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

↩ module page · 231 lines · 11276 B
1// nx_coc_engine.nx -- M1 MILESTONE: a Corruption-of-Champions-class TEXT-RPG ENGINE emitted by COMPOSING
2// certified parts. This is the recombinator claim made concrete for the adult-emitter program: a playable
3// branching text RPG with stats, transformation, adult-gated wardrobe, and persistence -- ZERO new game
4// logic, only composition of parts each certified-to-exceed ONCE (game_parts.tsv doctrine).
5//
6//   PLOT       nx_plotgen  (pg_gen)      -- generates a SOLVABLE branching narrative graph
7//   EXECUTION  nx_story_vm (sv_choose)   -- runs the graph as a data-driven state machine
8//   STATS      nx_rpgstats (rs_*)        -- XP curve, level, saturating HP, skill
9//   BODY       nx_wardrobe_state (ws_*)  -- clothing/exposure/TRANSFORMATION, ADULT-GATED by construction
10//   SAVE       nx_gamesave (gs_save)     -- atomic bit-exact persistence
11//
12// SELF-PROVING (self-gating like nx_frontier_engine): P1 winnable, P2 LOSABLE (a CoC-class game MUST be
13// losable or it is hollow), P3 deterministic, P4 save/load transparent, P5 ADULT-GATE HOLDS THROUGH THE
14// WHOLE LOOP (a minor can never reach an exposed wardrobe state, and an ADULT on the same seed DOES -- the
15// gate is real AND targeted), P6 solvable (the generated plot has a reachable ending).
16//
17// HONEST SCOPE: this is the ENGINE (state machine + stats + transformation + adult-gating + persistence).
18// Narrative PROSE slots into the story-graph nodes as a later LLM-authored rung (nx_story_vm's design).
19// Emits a JSON proof line so agents/workflows can emit-and-prove an M1 game on demand (MCP tool).
20// license_tier: ORIGINAL  expect_exit: 0
21import "nx_syscalls.nx"
22import "nx_gamesave.nx"
23import "nx_rpgstats.nx"
24import "nx_story_vm.nx"
25import "nx_plotgen.nx"
26import "nx_wardrobe_state.nx"
27const CE_MAGIC_20260724: i64 = 20260724
28const CE_MAGIC_424242: i64 = 424242
29const CE_MAGIC_4096: i64 = 4096
30
31const CE_NODES:   i64 = 12
32const CE_LEN:     i64 = 16          // save vector: [0]node [1]flags [2]hp [3]xp [4]level [5]cycle [6..15]wardrobe(10)
33const CE_MAXHP:   i64 = 100
34const CE_TARGET:  i64 = 3           // win requires level >= this
35const CE_HAZ_PCT: i64 = 45          // chance a node is a hazard
36const CE_HEAL:    i64 = 8           // cautious recovers between nodes
37const CE_TOLL:    i64 = 22          // reckless pays a detour toll in HP
38const CE_XPBASE:  i64 = 100
39const CE_XPQUAD:  i64 = 20
40const CE_M63:     i64 = 0x7FFFFFFFFFFFFFFF
41const CE_FNV:     i64 = 1099511628211
42const CE_MIXA:    i64 = 2654435761
43const CE_MIXB:    i64 = 1274126177
44
45func ce_hash(node: i64, seed: i64) -> i64 {
  var h: i64 = seed ^ (node * CE_MIXA)
  h = (h ^ (h >> 13)) * CE_MIXB
  h = h ^ (h >> 7)
  return h & CE_M63
50}
51
52// run one playthrough. policy 0=cautious(spine,heal) 1=reckless(detour,toll). fills V; res[0]=outcome(1 win/
53// 0 lose) res[1]=frame_chain res[2]=final_level res[3]=cycles res[4]=exposure_attempts.
54func ce_run(V: *i64, res: *i64, seed: i64, policy: i64, age: i64) -> i64 {
  let N: i64 = CE_NODES
  let ct: *i64 = sys_mmap(N*SV_NCH*8) as *i64
  let cq: *i64 = sys_mmap(N*SV_NCH*8) as *i64
  let cs: *i64 = sys_mmap(N*SV_NCH*8) as *i64
  let ie: *i64 = sys_mmap(N*8) as *i64
  pg_gen(ct, cq, cs, ie, N, seed)
61
  var z: i64 = 0
  while z < CE_LEN { V[z] = 0; z = z+1 }
  V[0] = 0                                   // node
  V[2] = CE_MAXHP                            // hp
  V[4] = 1                                   // level
  let w: *i64 = (V as i64 + 48) as *i64      // wardrobe sub-vector at V[6]
  ws_init(w, age, 0)
69
  var fck: i64 = seed & CE_M63
  var expo: i64 = 0
  var running: i64 = 1
  var steps: i64 = 0
  let maxsteps: i64 = N * 3
  while running == 1 {
      let node: i64 = V[0]
      if steps >= maxsteps { running = 0 }
      if running == 1 { if sv_is_end(ie, node) == 1 { running = 0 } }
      if running == 1 { if V[2] <= 0 { running = 0 } }
      if running == 1 {
          let h: i64 = ce_hash(node, seed)
          // encounter reward
          let xpgain: i64 = 20 + (h % 30)
          V[3] = rs_sadd(V[3], xpgain)
          V[4] = rs_level_for_xp(V[3], CE_XPBASE, CE_XPQUAD)
          // hazard toll
          let hz: i64 = (h / 100) % 100
          if hz < CE_HAZ_PCT { V[2] = V[2] - (15 + (h % 20)) }
          // transformation on some nodes (form change; coherence-preserving)
          if (h % 7) == 0 { ws_morph(w, (h / 7) % WS_NMORPH) }
          // wardrobe exposure ATTEMPT on some nodes -> ADULT-GATED (refused for a minor, state intact)
          if (h % 5) == 0 { expo = expo + 1; ws_set(w, 2, 0) }
          // choose next by policy
          var nxt: i64 = 0-1
          if policy == 0 {
              V[2] = rs_clamp(V[2] + CE_HEAL, 0, CE_MAXHP)
              nxt = sv_choose(ct, cq, cs, node, 0, (V as i64 + 8) as *i64)
          }
          if policy == 1 {
              // RUSH: never rest, pay a toll at every node, push the spine through every hazard.
              // Genre-honest stakes: without resting the HP/hazard system genuinely kills you.
              V[2] = V[2] - CE_TOLL
              nxt = sv_choose(ct, cq, cs, node, 0, (V as i64 + 8) as *i64)
          }
          if nxt < 0 { nxt = sv_choose(ct, cq, cs, node, 0, (V as i64 + 8) as *i64) }
          if nxt < 0 { running = 0 }
          if nxt >= 0 {
              V[0] = nxt
              V[5] = V[5] + 1
              fck = (fck * CE_FNV) ^ (V[0] + V[2]*7 + V[4]*13 + ws_exposure(w)*17)
              fck = fck & CE_M63
          }
          steps = steps + 1
      }
  }
  var outcome: i64 = 0
  if sv_is_end(ie, V[0]) == 1 { if V[2] > 0 { if V[4] >= CE_TARGET { outcome = 1 } } }
  res[0] = outcome
  res[1] = fck
  res[2] = V[4]
  res[3] = V[5]
  res[4] = expo
  return outcome
124}
125
126func jc(o: *u8, at: i64, s: *u8) -> i64 { var i: i64=0; var a: i64=at; while s[i]!=(0 as u8){o[a]=s[i]; a=a+1; i=i+1} return a }
127func jn(o: *u8, at: i64, v: i64) -> i64 {
  var a: i64=at; var m: i64=v
  if m==0 { o[a]=48 as u8; return a+1 }
  if m<0 { o[a]=45 as u8; a=a+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 }
  var q: i64=k-1
  while q>=0 { o[a]=t[q]; a=a+1; q=q-1 }
  return a
136}
137
138func main() -> i64 {
  let ADULT_SEED: i64 = CE_MAGIC_20260724
  let LOSE_SEED:  i64 = 777
141
  let Vw: *i64 = sys_mmap(CE_LEN*8) as *i64      // adult cautious (winner)
  let rW: *i64 = sys_mmap(8*8) as *i64
  ce_run(Vw, rW, ADULT_SEED, 0, 25)
145
  // P2: reckless on a hazard seed dies
  let Vl: *i64 = sys_mmap(CE_LEN*8) as *i64
  let rL: *i64 = sys_mmap(8*8) as *i64
  ce_run(Vl, rL, LOSE_SEED, 1, 25)
150
  // P3: determinism -- same seed+policy twice -> identical frame chain
  let Vd: *i64 = sys_mmap(CE_LEN*8) as *i64
  let rD: *i64 = sys_mmap(8*8) as *i64
  ce_run(Vd, rD, ADULT_SEED, 0, 25)
155
  // P4: save/load transparent -- save the winner, load into a ZEROED vector, compare
  let wrote: i64 = gs_save("knowledge/nx_coc_save.sav" as *u8, 900, Vw, CE_LEN, CE_MAGIC_424242)
  let Vp: *i64 = sys_mmap(CE_LEN*8) as *i64
  var zz: i64 = 0
  while zz < CE_LEN { Vp[zz] = 0; zz = zz+1 }
  let got: i64 = gs_load("knowledge/nx_coc_save.sav" as *u8, Vp, CE_LEN, 0 as *i64)
  var loadok: i64 = 1
  if got != CE_LEN { loadok = 0 }
  zz = 0
  while zz < CE_LEN { if Vp[zz] != Vw[zz] { loadok = 0 } zz = zz+1 }
166
  // P5: adult gate holds through the WHOLE loop. Minor run vs adult run on the SAME seed.
  let Vm: *i64 = sys_mmap(CE_LEN*8) as *i64
  let rM: *i64 = sys_mmap(8*8) as *i64
  ce_run(Vm, rM, ADULT_SEED, 0, 16)                        // a 16-year-old
  let wm: *i64 = (Vm as i64 + 48) as *i64
  let wa: *i64 = (Vw as i64 + 48) as *i64
  // chest is zone 2 -> wardrobe slot w[2+2]=w[4]
  let minor_chest: i64 = wm[4]
  let adult_chest: i64 = wa[4]
  var gate_held: i64 = 0
  // minor's chest NEVER dropped below modest (exposure refused), AND coherent, AND at least one attempt happened
  if minor_chest >= WS_MODEST { if ws_coherent(wm) == 1 { if rM[4] > 0 { gate_held = 1 } } }
  // targeted: an ADULT on the same seed with attempts DID expose (gate is not a blanket disable)
  var gate_targeted: i64 = 0
  if adult_chest < WS_MODEST { if rW[4] > 0 { gate_targeted = 1 } }
182
  // P6: solvability -- the generated plot has a reachable ending via pg_walk
  let ct: *i64 = sys_mmap(CE_NODES*SV_NCH*8) as *i64
  let cq: *i64 = sys_mmap(CE_NODES*SV_NCH*8) as *i64
  let cs: *i64 = sys_mmap(CE_NODES*SV_NCH*8) as *i64
  let ie: *i64 = sys_mmap(CE_NODES*8) as *i64
  pg_gen(ct, cq, cs, ie, CE_NODES, ADULT_SEED)
  let endnode: i64 = pg_walk(ct, cq, cs, ie, CE_NODES, CE_NODES*3)
190
  // ---- verdicts ----
  var p1: i64 = 0
  if rW[0] == 1 { p1 = 1 }                                  // adult cautious WON
  var p2: i64 = 0
  if rL[0] == 0 { if Vl[2] <= 0 { p2 = 1 } }                // reckless LOST by dying
  var p3: i64 = 0
  if rD[1] == rW[1] { p3 = 1 }                             // determinism: identical frame chain
  var p4: i64 = loadok
  if wrote <= 0 { p4 = 0 }
  var p5: i64 = 0
  if gate_held == 1 { if gate_targeted == 1 { p5 = 1 } }
  var p6: i64 = 0
  if endnode >= 0 { if sv_is_end(ie, endnode) == 1 { p6 = 1 } }
  let pass: i64 = p1 + p2 + p3 + p4 + p5 + p6
205
  let jb: *u8 = sys_mmap(CE_MAGIC_4096)
  var j: i64 = 0
  j = jc(jb, j, "{\x22game\x22:\x22nx_coc_engine\x22,\x22class\x22:\x22CoC-class text-RPG engine (composed certified parts)\x22" as *u8)
  j = jc(jb, j, ",\x22proofs_pass\x22:" as *u8); j = jn(jb, j, pass); j = jc(jb, j, ",\x22proofs_total\x22:6" as *u8)
  j = jc(jb, j, ",\x22P1_winnable\x22:" as *u8); j = jn(jb, j, p1)
  j = jc(jb, j, ",\x22P2_losable\x22:" as *u8); j = jn(jb, j, p2)
  j = jc(jb, j, ",\x22P3_deterministic\x22:" as *u8); j = jn(jb, j, p3)
  j = jc(jb, j, ",\x22P4_save_transparent\x22:" as *u8); j = jn(jb, j, p4)
  j = jc(jb, j, ",\x22P5_adult_gate_holds\x22:" as *u8); j = jn(jb, j, p5)
  j = jc(jb, j, ",\x22P6_solvable\x22:" as *u8); j = jn(jb, j, p6)
  j = jc(jb, j, ",\x22win_level\x22:" as *u8); j = jn(jb, j, rW[2])
  j = jc(jb, j, ",\x22win_cycles\x22:" as *u8); j = jn(jb, j, rW[3])
  j = jc(jb, j, ",\x22lose_hp\x22:" as *u8); j = jn(jb, j, Vl[2])
  j = jc(jb, j, ",\x22lose_cycles\x22:" as *u8); j = jn(jb, j, rL[3])
  j = jc(jb, j, ",\x22minor_chest_cov\x22:" as *u8); j = jn(jb, j, minor_chest)
  j = jc(jb, j, ",\x22adult_chest_cov\x22:" as *u8); j = jn(jb, j, adult_chest)
  j = jc(jb, j, ",\x22exposure_attempts\x22:" as *u8); j = jn(jb, j, rW[4])
  j = jc(jb, j, ",\x22frame_chain\x22:" as *u8); j = jn(jb, j, rW[1])
  j = jc(jb, j, ",\x22nodes\x22:" as *u8); j = jn(jb, j, CE_NODES)
  j = jc(jb, j, ",\x22parts\x22:\x22plotgen+story_vm+rpgstats+wardrobe_state+gamesave\x22" as *u8)
  j = jc(jb, j, ",\x22honest\x22:\x22ENGINE (state machine+stats+transformation+adult-gating+persistence); prose slots into story-graph nodes as a later LLM-authored rung. Adult invariant fails closed BY CONSTRUCTION through the whole loop.\x22}" as *u8)
  sys_write(1, jb, j)
  sys_write(1, "\n" as *u8, 1)
  if pass != 6 { return 1 }
  return 0
231}
nx_coc_engine.nx source

`nx_coc_engine.nx` source
