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

↩ module page · 510 lines · 21655 B
1// nx_game_edit.nx -- the FINE-CONTROL EDITOR KERNEL (G-ECO-004): the Godot-class editor's
2// core primitive, the second authoring front-end of the Nishi game ecosystem.  A structured,
3// VALIDATED, preservation-correct EDIT on a data game-spec.  Two mutation kinds (both = the
4// same responsibility: edit ONE spec field, copy everything else verbatim, keep it emitter-valid):
5//
6//   (1) DIFFICULTY KNOB:  nx_game_edit <in.spec> <out.spec> <key> <value>
7//       key = one of the 8 economy knobs (walls enemy_base enemy_per_level ehp_base ehp_per_level
8//       loot dmg_base dmg_rand); value must be in the knob's DATA-DRIVEN range.
9//   (2) FSM TRANSITION CELL (the visual FSM-table editor's core):
10//       nx_game_edit <in.spec> <out.spec> fsm <state> <event> <value>
11//       sets transition table cell (state,event) = value (-1 = no transition, else a state index).
12//
13//   Both copy every line of <in.spec> VERBATIM except the one edited field -- name/title/other
14//   params/other FSM rows/needs/comments all preserved.
15//
16//   SELF-GATE (no args, the way nx_sov_build_run invokes it): on game_crypt.spec assert BOTH
17//   (a) KNOB walls=30 applies, enemy_base/ehp_base/dmg_base + 6 FSM rows + title unchanged, and
18//   unknown-key/over-range/under-range REFUSE; and (b) FSM cell (1,4)->-1 applies, cells (1,1)=2
19//   and (1,3)=3 + row count + walls unchanged, and bad-state/bad-event/bad-value REFUSE.
20//   GAMEEDIT-GATE verdict=GREEN iff all hold.  Live-preview-by-emit is the next rung (here
21//   preview = the edited spec RE-PARSES valid, the contract the emitter requires).
22//
23// HONEST: knob/cell RANGES are DATA (no buried magic numbers).  TUTOR-authored tooling (the editor
24// front-end); the GAMES remain emitter output.  Feature-add, not a measured-exceed claim.
25// Sovereign syscalls only.  license_tier: ORIGINAL
26import "nx_syscalls.nx"
27const K_MAGIC_65536: i64 = 65536
28const K_MAGIC_99999: i64 = 99999
29
30func ge_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 }
31func ge_c(fd: i64, c: i64) -> i64 { let b: *u8 = sys_mmap(8); b[0] = c as u8; sys_write(fd, b, 1); return 0 }
32func ge_wn(fd: i64, v: i64) -> i64 {
  var m: i64 = v
  if m < 0 { ge_c(fd, 45); m = 0 - m }
  let bb: *u8 = sys_mmap(28); let t: *u8 = sys_mmap(28); var k: i64 = 0
  if m == 0 { t[0] = 48 as u8; k = 1 }
  while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var i: i64 = 0
  while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }
  sys_write(fd, bb, k); return 0
41}
42
43func ge_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
44func ge_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
49}
50func ge_atoi(s: *u8) -> i64 {
  var p: i64 = 0; var neg: i64 = 0
  if s[0] == (45 as u8) { neg = 1; p = 1 }
  var v: i64 = 0
  while s[p] != (0 as u8) { let c: i64 = s[p] as i64; if c >= 48 { if c <= 57 { v = v * 10 + (c - 48) } } p = p + 1 }
  if neg == 1 { return 0 - v }
  return v
57}
58
59func ge_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
67}
68
69// write a base-10 int into dst at off; return new offset
70func ge_catn(dst: *u8, off: i64, v: i64) -> i64 {
  var m: i64 = v; var w: i64 = off
  if m < 0 { dst[w] = 45 as u8; w = w + 1; m = 0 - m }
  let t: *u8 = sys_mmap(28); var k: i64 = 0
  if m == 0 { t[0] = 48 as u8; k = 1 }
  while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var i: i64 = 0
  while i < k { dst[w] = t[k - 1 - i]; w = w + 1; i = i + 1 }
  return w
79}
80
81// --- spec re-parse helpers (same line-start+space convention as nx_game_emit) ---
82func ge_match(buf: *u8, pos: i64, key: *u8) -> i64 {
  var i: i64 = 0
  while key[i] != (0 as u8) { if buf[pos + i] != key[i] { return 0 } i = i + 1 }
  return 1
86}
87func ge_linestart(buf: *u8, pos: i64) -> i64 {
  if pos == 0 { return 1 }
  if buf[pos - 1] == (10 as u8) { return 1 }
  return 0
91}
92func ge_find(buf: *u8, len: i64, key: *u8) -> i64 {
  let kl: i64 = ge_len(key)
  var i: i64 = 0
  while i < len {
      if ge_linestart(buf, i) == 1 { if ge_match(buf, i, key) == 1 { if buf[i + kl] == (32 as u8) { return i + kl + 1 } } }
      i = i + 1
  }
  return 0 - 1
100}
101func ge_pint(buf: *u8, pos: i64) -> i64 {
  var p: i64 = pos
  while buf[p] == (32 as u8) { p = p + 1 }
  var neg: i64 = 0
  if buf[p] == (45 as u8) { neg = 1; p = p + 1 }
  var v: i64 = 0; var go: i64 = 1
  while go == 1 { let c: i64 = buf[p] as i64; if c < 48 { go = 0 } if c > 57 { go = 0 } if go == 1 { v = v * 10 + (c - 48); p = p + 1 } }
  if neg == 1 { return 0 - v }
  return v
110}
111// advance p past one signed integer token (p must sit on its first char after space-skip)
112func ge_skipint(buf: *u8, pos: i64) -> i64 {
  var p: i64 = pos
  if buf[p] == (45 as u8) { p = p + 1 }
  var d: i64 = 1
  while d == 1 { let c: i64 = buf[p] as i64; if c < 48 { d = 0 } if c > 57 { d = 0 } if d == 1 { p = p + 1 } }
  return p
118}
119func ge_int(buf: *u8, len: i64, key: *u8, dflt: i64) -> i64 {
  let p: i64 = ge_find(buf, len, key)
  if p < 0 { return dflt }
  return ge_pint(buf, p)
123}
124// the 2nd int on the "fsm ns ne" line (= ne); -1 if absent
125func ge_fsm_ne(buf: *u8, len: i64) -> i64 {
  let p: i64 = ge_find(buf, len, "fsm" as *u8)
  if p < 0 { return 0 - 1 }
  var q: i64 = p
  while buf[q] == (32 as u8) { q = q + 1 }
  q = ge_skipint(buf, q)
  return ge_pint(buf, q)
132}
133func ge_count_rows(buf: *u8, len: i64) -> i64 {
  var n: i64 = 0; var i: i64 = 0
  while i < len {
      if ge_linestart(buf, i) == 1 { if ge_match(buf, i, "row" as *u8) == 1 { if buf[i + 3] == (32 as u8) { n = n + 1 } } }
      i = i + 1
  }
  return n
140}
141func ge_title_crypt(buf: *u8, len: i64) -> i64 {
  let p: i64 = ge_find(buf, len, "title" as *u8)
  if p < 0 { return 0 }
  return ge_match(buf, p, "THE CRYPT" as *u8)
145}
146// value of FSM cell (state,event) by walking "row" lines; -999 if not found
147func ge_fsm_cell(buf: *u8, len: i64, state: i64, event: i64) -> i64 {
  var rowidx: i64 = 0; var i: i64 = 0
  while i < len {
      if ge_linestart(buf, i) == 1 { if ge_match(buf, i, "row" as *u8) == 1 { if buf[i + 3] == (32 as u8) {
          if rowidx == state {
              var p: i64 = i + 3
              var col: i64 = 0
              while col <= event {
                  while buf[p] == (32 as u8) { p = p + 1 }
                  if col == event { return ge_pint(buf, p) }
                  p = ge_skipint(buf, p)
                  col = col + 1
              }
          }
          rowidx = rowidx + 1
      } } }
      i = i + 1
  }
  return 0 - 999
166}
167
168// the knob DESIGN TABLE (data-driven ranges): 1 iff <key> is a known economy knob AND value in [min,max].
169func ge_knob_ok(key: *u8, value: i64) -> i64 {
  let names: *i64 = sys_mmap(8 * 8) as *i64
  let mins: *i64 = sys_mmap(8 * 8) as *i64
  let maxs: *i64 = sys_mmap(8 * 8) as *i64
  names[0] = "walls" as *u8 as i64;           mins[0] = 0; maxs[0] = 120
  names[1] = "enemy_base" as *u8 as i64;       mins[1] = 0; maxs[1] = 50
  names[2] = "enemy_per_level" as *u8 as i64;  mins[2] = 0; maxs[2] = 20
  names[3] = "ehp_base" as *u8 as i64;         mins[3] = 1; maxs[3] = 500
  names[4] = "ehp_per_level" as *u8 as i64;    mins[4] = 0; maxs[4] = 100
  names[5] = "loot" as *u8 as i64;             mins[5] = 0; maxs[5] = 50
  names[6] = "dmg_base" as *u8 as i64;         mins[6] = 1; maxs[6] = 200
  names[7] = "dmg_rand" as *u8 as i64;         mins[7] = 0; maxs[7] = 200
  var i: i64 = 0
  while i < 8 {
      if ge_streq(key, names[i] as *u8) == 1 {
          if value >= mins[i] { if value <= maxs[i] { return 1 } }
          return 0
      }
      i = i + 1
  }
  return 0
190}
191
192// apply ONE knob edit into outbuf. returns new length, or -1 if REFUSED (bad knob/value/absent key).
193func ge_apply(inbuf: *u8, inlen: i64, key: *u8, value: i64, outbuf: *u8) -> i64 {
  if ge_knob_ok(key, value) == 0 { return 0 - 1 }
  let kl: i64 = ge_len(key)
  var w: i64 = 0
  var i: i64 = 0
  var replaced: i64 = 0
  while i < inlen {
      var le: i64 = i
      var go: i64 = 1
      while go == 1 {
          if le >= inlen { go = 0 } else { if inbuf[le] == (10 as u8) { go = 0 } else { le = le + 1 } }
      }
      var ismatch: i64 = 0
      if replaced == 0 { if i + kl < le {
          var j: i64 = 0; var ok: i64 = 1
          while j < kl { if inbuf[i + j] != key[j] { ok = 0 } j = j + 1 }
          if ok == 1 { if inbuf[i + kl] == (32 as u8) { ismatch = 1 } }
      } }
      if ismatch == 1 {
          var c: i64 = 0
          while c < kl { outbuf[w] = key[c]; w = w + 1; c = c + 1 }
          outbuf[w] = 32 as u8; w = w + 1
          w = ge_catn(outbuf, w, value)
          replaced = 1
      } else {
          var c: i64 = i
          while c < le { outbuf[w] = inbuf[c]; w = w + 1; c = c + 1 }
      }
      if le < inlen { outbuf[w] = 10 as u8; w = w + 1 }
      i = le + 1
  }
  if replaced == 0 { return 0 - 1 }
  return w
226}
227
228// parse up to ne signed ints on a row line [after, le) into tmp; returns count
229func ge_row_ints(buf: *u8, after: i64, le: i64, tmp: *i64, ne: i64) -> i64 {
  var p: i64 = after
  var c: i64 = 0
  while c < ne {
      var sk: i64 = 1
      while sk == 1 { if p >= le { sk = 0 } else { if buf[p] == (32 as u8) { p = p + 1 } else { sk = 0 } } }
      if p >= le { return c }
      tmp[c] = ge_pint(buf, p)
      p = ge_skipint(buf, p)
      c = c + 1
  }
  return c
241}
242
243// apply ONE FSM-cell edit into outbuf. returns new length, or -1 if REFUSED.
244func ge_apply_fsm(inbuf: *u8, inlen: i64, state: i64, event: i64, value: i64, outbuf: *u8) -> i64 {
  let ns: i64 = ge_int(inbuf, inlen, "fsm" as *u8, 0 - 1)
  let ne: i64 = ge_fsm_ne(inbuf, inlen)
  if ns < 0 { return 0 - 1 }
  if ne < 0 { return 0 - 1 }
  if state < 0 { return 0 - 1 }
  if state >= ns { return 0 - 1 }
  if event < 0 { return 0 - 1 }
  if event >= ne { return 0 - 1 }
  if value < 0 - 1 { return 0 - 1 }
  if value >= ns { return 0 - 1 }
  let tmp: *i64 = sys_mmap(256 * 8) as *i64
  var w: i64 = 0
  var i: i64 = 0
  var rowidx: i64 = 0
  var done: i64 = 0
  while i < inlen {
      var le: i64 = i
      var go: i64 = 1
      while go == 1 { if le >= inlen { go = 0 } else { if inbuf[le] == (10 as u8) { go = 0 } else { le = le + 1 } } }
      var edit_this: i64 = 0
      if ge_match(inbuf, i, "row" as *u8) == 1 { if i + 3 < le { if inbuf[i + 3] == (32 as u8) {
          if rowidx == state { if done == 0 { edit_this = 1 } }
          rowidx = rowidx + 1
      } } }
      if edit_this == 1 {
          ge_row_ints(inbuf, i + 3, le, tmp, ne)
          tmp[event] = value
          outbuf[w] = 114 as u8; w = w + 1
          outbuf[w] = 111 as u8; w = w + 1
          outbuf[w] = 119 as u8; w = w + 1
          var c: i64 = 0
          while c < ne { outbuf[w] = 32 as u8; w = w + 1; w = ge_catn(outbuf, w, tmp[c]); c = c + 1 }
          done = 1
      } else {
          var c4: i64 = i
          while c4 < le { outbuf[w] = inbuf[c4]; w = w + 1; c4 = c4 + 1 }
      }
      if le < inlen { outbuf[w] = 10 as u8; w = w + 1 }
      i = le + 1
  }
  if done == 0 { return 0 - 1 }
  return w
287}
288
289// copy the idx-th space-delimited token of line [ls,le) into out (NUL-term); 1 if found, 0 if absent.
290func ge_tok(buf: *u8, ls: i64, le: i64, idx: i64, out: *u8) -> i64 {
  var p: i64 = ls
  var cur: i64 = 0
  while p < le {
      var sk: i64 = 1
      while sk == 1 { if p >= le { sk = 0 } else { if buf[p] == (32 as u8) { p = p + 1 } else { sk = 0 } } }
      if p >= le { return 0 }
      var te: i64 = p
      var sk2: i64 = 1
      while sk2 == 1 { if te >= le { sk2 = 0 } else { if buf[te] == (32 as u8) { sk2 = 0 } else { te = te + 1 } } }
      if cur == idx {
          var w: i64 = 0; var q: i64 = p
          while q < te { out[w] = buf[q]; w = w + 1; q = q + 1 }
          out[w] = 0 as u8
          return 1
      }
      cur = cur + 1
      p = te
  }
  return 0
310}
311
312// apply a multi-line edit SCRIPT atomically (all-or-nothing). Each non-blank/non-# line is either
313//   "knob <key> <value>"  or  "fsm <state> <event> <value>"
314// returns final spec length in outbuf, or -1 if ANY edit is invalid (then NOTHING is written = transactional).
315func ge_apply_batch(inbuf: *u8, inlen: i64, script: *u8, slen: i64, outbuf: *u8) -> i64 {
  let A: *u8 = sys_mmap(K_MAGIC_65536)
  let B: *u8 = sys_mmap(K_MAGIC_65536)
  var ci: i64 = 0
  while ci < inlen { A[ci] = inbuf[ci]; ci = ci + 1 }
  var curIsA: i64 = 1
  var curlen: i64 = inlen
  var okall: i64 = 1
  var applied: i64 = 0
  let t0: *u8 = sys_mmap(64); let t1: *u8 = sys_mmap(64); let t2: *u8 = sys_mmap(64); let t3: *u8 = sys_mmap(64)
  var i: i64 = 0
  while i < slen {
      var le: i64 = i
      var go: i64 = 1
      while go == 1 { if le >= slen { go = 0 } else { if script[le] == (10 as u8) { go = 0 } else { le = le + 1 } } }
      if okall == 1 { if le > i { if script[i] != (35 as u8) {
          if ge_tok(script, i, le, 0, t0) == 1 { if t0[0] != (0 as u8) {
              var src: *u8 = A; var dst: *u8 = B
              if curIsA == 0 { src = B; dst = A }
              var res: i64 = 0 - 1
              if ge_streq(t0, "knob" as *u8) == 1 {
                  if ge_tok(script, i, le, 1, t1) == 1 { if ge_tok(script, i, le, 2, t2) == 1 {
                      res = ge_apply(src, curlen, t1, ge_atoi(t2), dst)
                  } }
              }
              if ge_streq(t0, "fsm" as *u8) == 1 {
                  if ge_tok(script, i, le, 1, t1) == 1 { if ge_tok(script, i, le, 2, t2) == 1 { if ge_tok(script, i, le, 3, t3) == 1 {
                      res = ge_apply_fsm(src, curlen, ge_atoi(t1), ge_atoi(t2), ge_atoi(t3), dst)
                  } } }
              }
              if res < 0 { okall = 0 } else { curlen = res; curIsA = 1 - curIsA; applied = applied + 1 }
          } }
      } } }
      i = le + 1
  }
  if okall == 0 { return 0 - 1 }
  if applied == 0 { return 0 - 1 }
  var src2: *u8 = A
  if curIsA == 0 { src2 = B }
  var c: i64 = 0
  while c < curlen { outbuf[c] = src2[c]; c = c + 1 }
  return curlen
357}
358
359func ge_report(fd: i64, r: *i64, ok: i64) -> i64 {
  ge_w(fd, "GAMEEDIT-GATE authored=organ knob[walls30->" as *u8); ge_wn(fd, r[0])
  ge_w(fd, " eb2->" as *u8); ge_wn(fd, r[1])
  ge_w(fd, " ehp18->" as *u8); ge_wn(fd, r[2])
  ge_w(fd, " dmg8->" as *u8); ge_wn(fd, r[3])
  ge_w(fd, " rows6->" as *u8); ge_wn(fd, r[4])
  ge_w(fd, " title=" as *u8); ge_wn(fd, r[5])
  ge_w(fd, " neg=" as *u8); ge_wn(fd, r[6]); ge_wn(fd, r[7]); ge_wn(fd, r[8])
  ge_w(fd, "] fsm[cell_1_4->" as *u8); ge_wn(fd, r[9])
  ge_w(fd, " keep_1_1=2->" as *u8); ge_wn(fd, r[10])
  ge_w(fd, " keep_1_3=3->" as *u8); ge_wn(fd, r[11])
  ge_w(fd, " rows6->" as *u8); ge_wn(fd, r[12])
  ge_w(fd, " walls20->" as *u8); ge_wn(fd, r[13])
  ge_w(fd, " neg=" as *u8); ge_wn(fd, r[14]); ge_wn(fd, r[15]); ge_wn(fd, r[16])
  ge_w(fd, "] batch[walls30->" as *u8); ge_wn(fd, r[17])
  ge_w(fd, " dmg25->" as *u8); ge_wn(fd, r[18])
  ge_w(fd, " cell_1_4->" as *u8); ge_wn(fd, r[19])
  ge_w(fd, " title=" as *u8); ge_wn(fd, r[20])
  ge_w(fd, " eb2->" as *u8); ge_wn(fd, r[21])
  ge_w(fd, " rows6->" as *u8); ge_wn(fd, r[22])
  ge_w(fd, " atomic_badbatch_refused=" as *u8); ge_wn(fd, r[23])
  if ok == 1 { ge_w(fd, "] verdict=GREEN\n" as *u8) } else { ge_w(fd, "] verdict=RED\n" as *u8) }
  return 0
382}
383
384func main(argc: i64, argv: *i64) -> i64 {
  if argc >= 5 {
      let inp: *u8 = argv[1] as *u8
      let outp: *u8 = argv[2] as *u8
      let inbuf: *u8 = sys_mmap(K_MAGIC_65536)
      let n: i64 = ge_read(inp, inbuf, K_MAGIC_65536)
      if n <= 0 { ge_w(1, "GAMEEDIT REFUSED: cannot read in-spec\n" as *u8); sys_exit(1); return 1 }
      let outbuf: *u8 = sys_mmap(K_MAGIC_65536)
      var m: i64 = 0 - 1
      var handled: i64 = 0
      if ge_streq(argv[3] as *u8, "fsm" as *u8) == 1 {
          handled = 1
          if argc < 7 { ge_w(1, "GAMEEDIT REFUSED: fsm edit needs <state> <event> <value>\n" as *u8); sys_exit(1); return 1 }
          m = ge_apply_fsm(inbuf, n, ge_atoi(argv[4] as *u8), ge_atoi(argv[5] as *u8), ge_atoi(argv[6] as *u8), outbuf)
      }
      if ge_streq(argv[3] as *u8, "batch" as *u8) == 1 {
          handled = 1
          let scriptbuf: *u8 = sys_mmap(K_MAGIC_65536)
          let sn: i64 = ge_read(argv[4] as *u8, scriptbuf, K_MAGIC_65536)
          if sn <= 0 { ge_w(1, "GAMEEDIT REFUSED: cannot read batch script\n" as *u8); sys_exit(1); return 1 }
          m = ge_apply_batch(inbuf, n, scriptbuf, sn, outbuf)
      }
      if handled == 0 {
          m = ge_apply(inbuf, n, argv[3] as *u8, ge_atoi(argv[4] as *u8), outbuf)
      }
      if m < 0 { ge_w(1, "GAMEEDIT REFUSED: invalid knob/cell, value out of range, or field absent\n" as *u8); sys_exit(1); return 1 }
      let fd: i64 = sys_openat_wr(outp, 0x1a4)
      if fd < 0 { ge_w(1, "GAMEEDIT REFUSED: cannot open out-spec\n" as *u8); sys_exit(1); return 1 }
      sys_write(fd, outbuf, m); sys_close(fd)
      ge_w(1, "GAMEEDIT GREEN " as *u8); ge_w(1, argv[3] as *u8); ge_w(1, " -> " as *u8); ge_w(1, outp); ge_c(1, 10)
      sys_exit(0); return 0
  }
416
  // SELF-GATE
  let r: *i64 = sys_mmap(64 * 8) as *i64
  let inbuf: *u8 = sys_mmap(K_MAGIC_65536)
  let n: i64 = ge_read("knowledge/specs/game_crypt.spec" as *u8, inbuf, K_MAGIC_65536)
  if n <= 0 { ge_w(1, "GAMEEDIT-GATE verdict=RED (cannot read game_crypt.spec)\n" as *u8); sys_exit(1); return 1 }
  let scratch: *u8 = sys_mmap(K_MAGIC_65536)
423
  // (a) KNOB edit: walls=30
  let outbuf: *u8 = sys_mmap(K_MAGIC_65536)
  let m: i64 = ge_apply(inbuf, n, "walls" as *u8, 30, outbuf)
  r[0] = 0 - 1; r[1] = 0 - 1; r[2] = 0 - 1; r[3] = 0 - 1; r[4] = 0 - 1; r[5] = 0
  if m > 0 {
      r[0] = ge_int(outbuf, m, "walls" as *u8, 0 - 1)
      r[1] = ge_int(outbuf, m, "enemy_base" as *u8, 0 - 1)
      r[2] = ge_int(outbuf, m, "ehp_base" as *u8, 0 - 1)
      r[3] = ge_int(outbuf, m, "dmg_base" as *u8, 0 - 1)
      r[4] = ge_count_rows(outbuf, m)
      r[5] = ge_title_crypt(outbuf, m)
  }
  r[6] = 0
  if ge_apply(inbuf, n, "foo" as *u8, 5, scratch) < 0 { r[6] = 1 }
  r[7] = 0
  if ge_apply(inbuf, n, "walls" as *u8, K_MAGIC_99999, scratch) < 0 { r[7] = 1 }
  r[8] = 0
  if ge_apply(inbuf, n, "walls" as *u8, 0 - 5, scratch) < 0 { r[8] = 1 }
442
  // (b) FSM-cell edit: (1,4) -> -1 (remove the flee transition)
  let fbuf: *u8 = sys_mmap(K_MAGIC_65536)
  let fm: i64 = ge_apply_fsm(inbuf, n, 1, 4, 0 - 1, fbuf)
  r[9] = 0 - 999; r[10] = 0 - 999; r[11] = 0 - 999; r[12] = 0 - 1; r[13] = 0 - 1
  if fm > 0 {
      r[9] = ge_fsm_cell(fbuf, fm, 1, 4)
      r[10] = ge_fsm_cell(fbuf, fm, 1, 1)
      r[11] = ge_fsm_cell(fbuf, fm, 1, 3)
      r[12] = ge_count_rows(fbuf, fm)
      r[13] = ge_int(fbuf, fm, "walls" as *u8, 0 - 1)
  }
  r[14] = 0
  if ge_apply_fsm(inbuf, n, 99, 0, 0, scratch) < 0 { r[14] = 1 }
  r[15] = 0
  if ge_apply_fsm(inbuf, n, 0, 99, 0, scratch) < 0 { r[15] = 1 }
  r[16] = 0
  if ge_apply_fsm(inbuf, n, 1, 4, 99, scratch) < 0 { r[16] = 1 }
460
  // (c) TRANSACTIONAL BATCH: 3 chained edits applied atomically
  let bbuf: *u8 = sys_mmap(K_MAGIC_65536)
  let sc: *u8 = "knob walls 30\nknob dmg_base 25\nfsm 1 4 -1\n" as *u8
  let bm: i64 = ge_apply_batch(inbuf, n, sc, ge_len(sc), bbuf)
  r[17] = 0 - 1; r[18] = 0 - 1; r[19] = 0 - 999; r[20] = 0; r[21] = 0 - 1; r[22] = 0 - 1
  if bm > 0 {
      r[17] = ge_int(bbuf, bm, "walls" as *u8, 0 - 1)
      r[18] = ge_int(bbuf, bm, "dmg_base" as *u8, 0 - 1)
      r[19] = ge_fsm_cell(bbuf, bm, 1, 4)
      r[20] = ge_title_crypt(bbuf, bm)
      r[21] = ge_int(bbuf, bm, "enemy_base" as *u8, 0 - 1)
      r[22] = ge_count_rows(bbuf, bm)
  }
  // atomicity: a batch with ONE bad edit must refuse the WHOLE batch (no partial apply / no output)
  let badsc: *u8 = "knob walls 30\nknob nosuch 5\nfsm 1 4 -1\n" as *u8
  r[23] = 0
  if ge_apply_batch(inbuf, n, badsc, ge_len(badsc), scratch) < 0 { r[23] = 1 }
478
  var ok: i64 = 1
  if r[0] != 30 { ok = 0 }
  if r[1] != 2 { ok = 0 }
  if r[2] != 18 { ok = 0 }
  if r[3] != 8 { ok = 0 }
  if r[4] != 6 { ok = 0 }
  if r[5] != 1 { ok = 0 }
  if r[6] != 1 { ok = 0 }
  if r[7] != 1 { ok = 0 }
  if r[8] != 1 { ok = 0 }
  if r[9] != 0 - 1 { ok = 0 }
  if r[10] != 2 { ok = 0 }
  if r[11] != 3 { ok = 0 }
  if r[12] != 6 { ok = 0 }
  if r[13] != 20 { ok = 0 }
  if r[14] != 1 { ok = 0 }
  if r[15] != 1 { ok = 0 }
  if r[16] != 1 { ok = 0 }
  if r[17] != 30 { ok = 0 }
  if r[18] != 25 { ok = 0 }
  if r[19] != 0 - 1 { ok = 0 }
  if r[20] != 1 { ok = 0 }
  if r[21] != 2 { ok = 0 }
  if r[22] != 6 { ok = 0 }
  if r[23] != 1 { ok = 0 }
504
  ge_report(1, r, ok)
  let lf: i64 = sys_openat_append("knowledge/status/game_edit.log" as *u8, 420)
  if lf >= 0 { ge_report(lf, r, ok); sys_close(lf) }
  if ok == 1 { sys_exit(0); return 0 }
  sys_exit(1); return 1
510}
nx_game_edit.nx source

`nx_game_edit.nx` source
