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

↩ module page · 297 lines · 13323 B
1// nx_game_gen2.nx -- the POLYMORPHIC game-system generator (X-GAME-GEN-001: "generate-a-game:
2// game systems as emitter SHAPES -> GAME SPEC -> Builder emits the game").  Generalizes
3// nx_game_gen (which hard-codes the dungenc table, dungeon-only) to ALL SIX proven game-system
4// FSM types by SOURCING each type's transition table from its build_<type>.spec -- the same DATA
5// the hand-authored _pe_<type> FSM (shape 18 STATE_MACHINE) was gated on.  So the emitted game's
6// FSM is, by construction, the PROVEN one (DRY: the table is never duplicated here).
7//
8//   CLI:  nx_game_gen2 <name> <THEME> <type> [difficulty]
9//         type = dungenc | twrwave | abround | stealth | datesim | fightfsm
10//         writes knowledge/specs/<name>.spec  (name/title/economy + fsm+rows from build_<type>.spec)
11//   SELF-GATE (run with no args, the way nx_sov_build_run invokes it): generate all 6 types to
12//   scratch, re-parse each emitted game-spec, assert its FSM == the source build_<type>.spec FSM,
13//   assert the 6 tables are DISTINCT (polymorphic, not all-dungenc), and assert an UNKNOWN type is
14//   REFUSED.  GAMEGEN2-GATE verdict=GREEN iff all sourced-ok + distinct>=2 + neg refused.
15//
16// HONEST SCOPE: the economy shell (walls/foes/hp, difficulty-scaled -- the deterministic tier
17// table) is the dungeon default; the FSM (the game SYSTEM) is the polymorphic shape.  Per-type
18// economy templates are a refinement.  Sovereign syscalls only.  license_tier: ORIGINAL
19import "nx_syscalls.nx"
20import "nx_itoa_lib.nx"   // shared MSB-first emitter (zero-alloc)
21const K_MAGIC_65536: i64 = 65536
22const K_MAGIC_2048: i64 = 2048
23
24func gg_w(fd: i64, s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(fd, s, n); return 0 }
25func gg_c(fd: i64, c: i64) -> i64 { let b: *u8 = sys_mmap(8); b[0] = c as u8; sys_write(fd, b, 1); return 0 }
26// MIGRATED to the shared emitter (debt 1785563586). The old body mmapped a scratch buffer
27// per call and never freed it. At PAGE granularity that is 4096B leaked PER CALL -- the
28// defect that took 28.5GB of a 36GB host in nx_ts_lumadiff (2MB input, ~3.66M calls).
29// nxi_* is MSB-first, allocates NOTHING, and emits identical bytes including the sign.
30func gg_wn(fd: i64, v: i64) -> i64 { nxi_fd(fd, v); return 0 }
31func gg_streq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 }
  if b[i] != (0 as u8) { return 0 }
  return 1
36}
37func gg_cat(dst: *u8, off: i64, s: *u8) -> i64 { var i: i64 = 0; while s[i] != (0 as u8) { dst[off+i] = s[i]; i = i + 1 } return off + i }
38
39func gg_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 - 1 }
  var n: i64 = 0
  var r: i64 = sys_read(fd, buf, cap - 1)
  while r > 0 { n = n + r; r = sys_read(fd, buf + n, cap - 1 - n) }
  sys_close(fd)
  return n
47}
48
49// parse every signed int on line [ls,le) into tmp; returns count (the word "param"/"row"/"fsm" has no digits, skipped)
50func gg_line_ints(buf: *u8, ls: i64, le: i64, tmp: *i64) -> i64 {
  var cnt: i64 = 0
  var i: i64 = ls
  while i < le {
      let c: i64 = buf[i] as i64
      var start: i64 = 0
      if c == 45 { start = 1 }
      if c >= 48 { if c <= 57 { start = 1 } }
      if start == 1 {
          var neg: i64 = 0
          if c == 45 { neg = 1; i = i + 1 }
          var v: i64 = 0
          var go: i64 = 1
          while go == 1 {
              if i >= le { go = 0 } else {
                  let d: i64 = buf[i] as i64
                  if d >= 48 { if d <= 57 { v = v * 10 + (d - 48); i = i + 1 } else { go = 0 } } else { go = 0 }
              }
          }
          if neg == 1 { v = 0 - v }
          tmp[cnt] = v; cnt = cnt + 1
      } else { i = i + 1 }
  }
  return cnt
74}
75
76// extract the FSM table from a spec buffer. key=1 -> build spec ("param" lines: 1st=hdr ns ne s0, rest=rows);
77// key=0 -> game spec ("fsm ns ne" line + "row" lines). out[0]=ns out[1]=ne out[3+r*ne+c]=cell. returns 1 ok.
78func gg_extract_fsm(buf: *u8, n: i64, key: i64, out: *i64) -> i64 {
  let tmp: *i64 = sys_mmap(64 * 8) as *i64
  var ns: i64 = 0; var ne: i64 = 0
  var pcount: i64 = 0          // build: param-lines seen ; game: rows seen
  var have_hdr: i64 = 0
  var i: i64 = 0
  while i < n {
      var le: i64 = i
      var s: i64 = 1
      while s == 1 { if le >= n { s = 0 } else { if buf[le] == (10 as u8) { s = 0 } else { le = le + 1 } } }
      if le > i { if buf[i] != (35 as u8) {
          // first non-space token
          var t0: i64 = i
          while t0 < le { if buf[t0] == (32 as u8) { t0 = le } else { t0 = t0 + 1 } }   // t0 = end of first token (or le)
          // identify keyword by first char(s)
          if key == 1 {
              // build spec: "param ..." lines only
              if buf[i] == (112 as u8) {   // 'p' -> param
                  let m: i64 = gg_line_ints(buf, i, le, tmp)
                  if pcount == 0 { ns = tmp[0]; ne = tmp[1]; out[0] = ns; out[1] = ne; out[2] = tmp[2]; have_hdr = 1 }
                  else {
                      let rr: i64 = pcount - 1
                      var c: i64 = 0
                      while c < ne { out[3 + rr * ne + c] = tmp[c]; c = c + 1 }
                  }
                  pcount = pcount + 1
              }
          } else {
              // game spec: "fsm ns ne" then "row ..."
              if buf[i] == (102 as u8) {   // 'f' -> fsm
                  let m: i64 = gg_line_ints(buf, i, le, tmp)
                  ns = tmp[0]; ne = tmp[1]; out[0] = ns; out[1] = ne; out[2] = 0; have_hdr = 1
              } else { if buf[i] == (114 as u8) {   // 'r' -> row
                  let m: i64 = gg_line_ints(buf, i, le, tmp)
                  var c: i64 = 0
                  while c < ne { out[3 + pcount * ne + c] = tmp[c]; c = c + 1 }
                  pcount = pcount + 1
              } }
          }
      } }
      i = le + 1
  }
  if have_hdr == 0 { return 0 }
  var rows_needed: i64 = ns
  if key == 1 { if pcount == ns + 1 { return 1 } return 0 }
  if pcount == rows_needed { return 1 }
  return 0
125}
126
127// read knowledge/specs/build_<type>.spec -> out fsm table. returns 1 ok / 0 missing-or-malformed.
128func gg_build_fsm(typ: *u8, out: *i64) -> i64 {
  let path: *u8 = sys_mmap(256)
  var o: i64 = 0
  o = gg_cat(path, o, "knowledge/specs/build_" as *u8); o = gg_cat(path, o, typ); o = gg_cat(path, o, ".spec" as *u8); path[o] = 0 as u8
  let buf: *u8 = sys_mmap(K_MAGIC_65536)
  let n: i64 = gg_read(path, buf, K_MAGIC_65536)
  if n <= 0 { return 0 }
  return gg_extract_fsm(buf, n, 1, out)
136}
137
138// difficulty tier 0..3
139func gg_tier(d: *u8) -> i64 {
  if gg_streq(d, "easy" as *u8) == 1 { return 0 }
  if gg_streq(d, "normal" as *u8) == 1 { return 1 }
  if gg_streq(d, "hard" as *u8) == 1 { return 2 }
  if gg_streq(d, "nightmare" as *u8) == 1 { return 3 }
  return 1
145}
146
147func gg_kv(fd: i64, key: *u8, v: i64) -> i64 { gg_w(fd, key); gg_c(fd, 32); gg_wn(fd, v); gg_c(fd, 10); return 0 }
148
149// write a complete game-spec: name/title/economy(tier-scaled)/needs + fsm+rows from ftab.
150func gg_emit_spec(fd: i64, name: *u8, theme: *u8, typ: *u8, tier: i64, ftab: *i64) -> i64 {
  let walls: i64 = 16 + tier * 6
  let eb: i64 = 2 + tier
  let hb: i64 = 14 + tier * 6
  let hpl: i64 = 3 + tier
  var loot: i64 = 4 - tier
  if loot < 1 { loot = 1 }
  var db: i64 = 10 - tier
  if db < 6 { db = 6 }
  gg_w(fd, "# generated by nx_game_gen2 (polymorphic intent->spec); FSM sourced from build_" as *u8); gg_w(fd, typ); gg_w(fd, ".spec\n" as *u8)
  gg_w(fd, "name " as *u8); gg_w(fd, name); gg_c(fd, 10)
  gg_w(fd, "title THE " as *u8); gg_w(fd, theme); gg_c(fd, 10)
  gg_kv(fd, "walls" as *u8, walls)
  gg_kv(fd, "enemy_base" as *u8, eb)
  gg_kv(fd, "enemy_per_level" as *u8, 1)
  gg_kv(fd, "ehp_base" as *u8, hb)
  gg_kv(fd, "ehp_per_level" as *u8, hpl)
  gg_kv(fd, "loot" as *u8, loot)
  gg_kv(fd, "dmg_base" as *u8, db)
  gg_kv(fd, "dmg_rand" as *u8, 8)
  gg_w(fd, "needs save\n" as *u8)
  let ns: i64 = ftab[0]; let ne: i64 = ftab[1]
  gg_w(fd, "fsm " as *u8); gg_wn(fd, ns); gg_c(fd, 32); gg_wn(fd, ne); gg_c(fd, 10)
  var r: i64 = 0
  while r < ns {
      gg_w(fd, "row" as *u8)
      var c: i64 = 0
      while c < ne { gg_c(fd, 32); gg_wn(fd, ftab[3 + r * ne + c]); c = c + 1 }
      gg_c(fd, 10)
      r = r + 1
  }
  return 0
182}
183
184// compare two extracted fsm tables (ns,ne,cells). 1 equal / 0 differ.
185func gg_fsm_eq(a: *i64, b: *i64) -> i64 {
  if a[0] != b[0] { return 0 }
  if a[1] != b[1] { return 0 }
  let cells: i64 = a[0] * a[1]
  var i: i64 = 0
  while i < cells { if a[3 + i] != b[3 + i] { return 0 } i = i + 1 }
  return 1
192}
193// a cheap order-sensitive signature of an fsm table (for distinctness)
194func gg_fsm_sig(a: *i64) -> i64 {
  var sig: i64 = a[0] * 131 + a[1]
  let cells: i64 = a[0] * a[1]
  var i: i64 = 0
  while i < cells { sig = sig * 31 + a[3 + i] + 7; i = i + 1 }
  return sig
200}
201
202func gg_gate_report(fd: i64, navail: i64, sourced: i64, distinct: i64, neg: i64, ok: i64) -> i64 {
  gg_w(fd, "GAMEGEN2-GATE authored=organ types_available=" as *u8); gg_wn(fd, navail)
  gg_w(fd, " fsm_sourced_ok=" as *u8); gg_wn(fd, sourced)
  gg_w(fd, " distinct_tables=" as *u8); gg_wn(fd, distinct)
  gg_w(fd, " neg_unknown_refused=" as *u8); gg_wn(fd, neg)
  if ok == 1 { gg_w(fd, " verdict=GREEN\n" as *u8) } else { gg_w(fd, " verdict=RED\n" as *u8) }
  return 0
209}
210
211func main(argc: i64, argv: *i64) -> i64 {
  if argc >= 4 {
      // CLI generate
      let name: *u8 = argv[1] as *u8
      let theme: *u8 = argv[2] as *u8
      let typ: *u8 = argv[3] as *u8
      var diff: *u8 = "normal" as *u8
      if argc >= 5 { diff = argv[4] as *u8 }
      let ftab: *i64 = sys_mmap(K_MAGIC_2048) as *i64
      if gg_build_fsm(typ, ftab) == 0 { gg_w(1, "GAMEGEN2 REFUSED: unknown type (no build_" as *u8); gg_w(1, typ); gg_w(1, ".spec)\n" as *u8); sys_exit(1); return 1 }
      let path: *u8 = sys_mmap(256)
      var o: i64 = gg_cat(path, 0, "knowledge/specs/" as *u8); o = gg_cat(path, o, name); o = gg_cat(path, o, ".spec" as *u8); path[o] = 0 as u8
      let fd: i64 = sys_openat_wr(path, 0x1a4)
      if fd < 0 { gg_w(1, "GAMEGEN2 REFUSED: cannot open spec path\n" as *u8); sys_exit(1); return 1 }
      gg_emit_spec(fd, name, theme, typ, gg_tier(diff), ftab)
      sys_close(fd)
      gg_w(1, "GAMEGEN2 GREEN name=" as *u8); gg_w(1, name); gg_w(1, " type=" as *u8); gg_w(1, typ)
      gg_w(1, " -> " as *u8); gg_w(1, path); gg_c(1, 10)
      sys_exit(0); return 0
  }
231
  // SELF-GATE: generate all 6 proven types, prove each emitted FSM == its build-spec source.
  let N: i64 = 6
  let types: *i64 = sys_mmap(N * 8) as *i64
  types[0] = "dungenc" as *u8 as i64
  types[1] = "twrwave" as *u8 as i64
  types[2] = "abround" as *u8 as i64
  types[3] = "stealth" as *u8 as i64
  types[4] = "datesim" as *u8 as i64
  types[5] = "fightfsm" as *u8 as i64
241
  let src: *i64 = sys_mmap(K_MAGIC_2048) as *i64
  let gen: *i64 = sys_mmap(K_MAGIC_2048) as *i64
  let sigs: *i64 = sys_mmap(N * 8) as *i64
  var navail: i64 = 0
  var sourced: i64 = 0
  var t: i64 = 0
  while t < N {
      let typ: *u8 = types[t] as *u8
      if gg_build_fsm(typ, src) == 1 {
          navail = navail + 1
          // emit to scratch game-spec
          let sp: *u8 = sys_mmap(256)
          var o: i64 = gg_cat(sp, 0, "/tmp/_ggtest_" as *u8); o = gg_cat(sp, o, typ); o = gg_cat(sp, o, ".spec" as *u8); sp[o] = 0 as u8
          let fd: i64 = sys_openat_wr(sp, 0x1a4)
          if fd >= 0 {
              gg_emit_spec(fd, "_ggtest" as *u8, "PROOF" as *u8, typ, 1, src)
              sys_close(fd)
              // re-parse the emitted game-spec FSM
              let buf: *u8 = sys_mmap(K_MAGIC_65536)
              let nn: i64 = gg_read(sp, buf, K_MAGIC_65536)
              if nn > 0 { if gg_extract_fsm(buf, nn, 0, gen) == 1 {
                  if gg_fsm_eq(src, gen) == 1 { sourced = sourced + 1; sigs[t] = gg_fsm_sig(gen) }
              } }
          }
      } else { sigs[t] = 0 }
      t = t + 1
  }
  // distinctness over the sourced tables
  var distinct: i64 = 0
  var a: i64 = 0
  while a < N {
      if sigs[a] != 0 {
          var seen: i64 = 0
          var b: i64 = 0
          while b < a { if sigs[b] == sigs[a] { seen = 1 } b = b + 1 }
          if seen == 0 { distinct = distinct + 1 }
      }
      a = a + 1
  }
  // negative control: an unknown type must NOT yield a build fsm
  let bog: *i64 = sys_mmap(K_MAGIC_2048) as *i64
  var neg: i64 = 1
  if gg_build_fsm("nosuchtype" as *u8, bog) == 1 { neg = 0 }
285
  var ok: i64 = 1
  if sourced != navail { ok = 0 }
  if navail < 2 { ok = 0 }
  if distinct < 2 { ok = 0 }
  if neg != 1 { ok = 0 }
291
  gg_gate_report(1, navail, sourced, distinct, neg, ok)
  let lf: i64 = sys_openat_append("knowledge/status/game_gen2.log" as *u8, 420)
  if lf >= 0 { gg_gate_report(lf, navail, sourced, distinct, neg, ok); sys_close(lf) }
  if ok == 1 { sys_exit(0); return 0 }
  sys_exit(1); return 1
297}
nx_game_gen2.nx source

`nx_game_gen2.nx` source
