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

↩ module page · 220 lines · 10453 B
1// nx_wasm_mineworld_gate.nx -- NATIVE gate for the INFINITE procgen voxel world (the Minecraft-procgen rung).
2// T1 DETERMINISM: same seed+view renders byte-identical (checksum) -- twice, fresh.
3// T2 INFINITE+CONTINUOUS: terrain is defined at far/negative coords; |dh/dx| <= 3 across 120 blocks incl. biome
4//    borders (the continuous-amplitude blend = no border cliff); far render differs from spawn render.
5// T3 PROCGEN VARIETY + LIAR-KILL: >=5 distinct heights per region, two distant regions differ, >=2 biomes on a
6//    strip; NEG-CONTROL: the same variety detector run on a constant "liar" terrain MUST FAIL (detector is real).
7// T4 EDIT PERSISTENCE ACROSS ROAMING (the Minecraft-critical property the fixed 48x48 grid could not do):
8//    dig+place via the raycast+edit-table path (exactly what break_at/place_at wrap at base=0), roam the render
9//    window 200 blocks away and back -> edits still there, still render (frame checksum changes).
10// T5 CAVES+BEDROCK: natural interior air pockets exist (before any edits); y=0 always solid everywhere.
11// Windows never-brick N/A (pure user-space render); determinism doubles as the re-run-safe proof.
12// license_tier: ORIGINAL
13import "nx_syscalls.nx"
14import "nx_f32_hw.nx"
15import "nx_png.nx"
16import "nx_wasm_mineworld.nx"
17
18func hw(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
19func pn(v: i64) -> i64 {
  let b: *u8 = sys_mmap(32) as *u8
  var x: i64 = v
  var neg: i64 = 0
  if x < 0 { neg = 1; x = 0 - x }
  var i: i64 = 31
  if x == 0 { b[i] = 48 as u8; i = i - 1 }
  while x > 0 { b[i] = (48 + x % 10) as u8; x = x / 10; i = i - 1 }
  if neg == 1 { b[i] = 45 as u8; i = i - 1 }
  sys_write(1, (b as i64 + i + 1) as *u8, 31 - i)
  return 0
30}
31func fbsum(base: i64) -> i64 {
  let fb: *i64 = (base + fb_off()) as *i64
  var s: i64 = 0
  var i: i64 = 0
  while i < ww() * hh() { s = s * 31 + fb[i]; i = i + 1 }
  return s
37}
38func rend(base: i64, cgx: i64, cgz: i64, ycos: i64, ysin: i64, pcos: i64, psin: i64) -> i64 {
  let eye: i64 = terrain_h0(cgx, cgz) + 8
  let camx256: i64 = cgx * 256 + 128
  let camy256: i64 = eye * 256
  let camz256: i64 = cgz * 256 + 128
  let camx: i64 = f32_div(f32_of(camx256), f32_of(256))
  let camy: i64 = f32_div(f32_of(camy256), f32_of(256))
  let camz: i64 = f32_div(f32_of(camz256), f32_of(256))
  build_R(base, ycos, ysin, pcos, psin)
  render_at(base, camx, camy, camz, cgx, cgz)
  return 0
49}
50
51func main() -> i64 {
  let base: i64 = sys_mmap(mem_bytes()) as i64
  var fails: i64 = 0
54
  // ---- T1 determinism ----
  rend(base, 8, 8, 1000, 0, 927, 0 - 375)
  let c1: i64 = fbsum(base)
  // frame must actually contain terrain (the liar-kill that caught the inverted-pitch bug). Ground truth =
  // the renderer's own DRAWN-PIXEL counter (sky is a gradient now, so a sky-constant compare is meaningless).
  let dpx: i64 = drawn_px_at(base)
  if dpx * 3 < ww() * hh() { hw("T1 FAIL frame is mostly sky: drawn-px=" as *u8); pn(dpx); hw("\n" as *u8); fails = fails + 1 }
  else { hw("T1a PASS terrain fills the frame: drawn-px=" as *u8); pn(dpx); hw("\n" as *u8) }
  write_png((base + fb_off()) as *i64, ww(), hh(), "knowledge/nx_mineworld_1.png" as *u8)
  rend(base, 8, 8, 1000, 0, 927, 0 - 375)
  let c2: i64 = fbsum(base)
  if c1 == c2 { hw("T1 PASS determinism: re-render byte-identical\n" as *u8) }
  else { hw("T1 FAIL determinism\n" as *u8); fails = fails + 1 }
68
  // ---- T2 infinite + continuous ----
  var maxd: i64 = 0
  var prev: i64 = terrain_h0(0 - 61, 13)
  var gx: i64 = 0 - 60
  while gx <= 60 {
      let hh2: i64 = terrain_h0(gx, 13)
      var d: i64 = hh2 - prev
      if d < 0 { d = 0 - d }
      if d > maxd { maxd = d }
      prev = hh2
      gx = gx + 1
  }
  let hfar1: i64 = terrain_h0(10007, 0 - 9973)
  let hfar2: i64 = terrain_h0(10007, 0 - 9973)
  if maxd <= 3 { if hfar1 == hfar2 { if hfar1 >= 1 { if hfar1 <= 20 {
      hw("T2 PASS infinite+continuous: max step d=" as *u8); pn(maxd); hw(" far h=" as *u8); pn(hfar1); hw("\n" as *u8)
  } } } }
  if maxd > 3 { hw("T2 FAIL discontinuity d=" as *u8); pn(maxd); hw("\n" as *u8); fails = fails + 1 }
87
  // ---- T3 variety + biomes + liar-kill neg-control ----
  let seen: *i64 = sys_mmap(32 * 8) as *i64
  var dv: i64 = 0
  var rz: i64 = 0
  while rz < 20 {
      var rx: i64 = 0
      while rx < 20 {
          let hv: i64 = terrain_h0(rx, rz)
          if seen[hv] == 0 { seen[hv] = 1; dv = dv + 1 }
          rx = rx + 1
      }
      rz = rz + 1
  }
  var suma: i64 = 0
  var sumb: i64 = 0
  var k: i64 = 0
  while k < 400 {
      suma = suma * 31 + terrain_h0(k % 20, k / 20)
      sumb = sumb * 31 + terrain_h0(5000 + k % 20, 0 - 3000 + k / 20)
      k = k + 1
  }
  let bseen: *i64 = sys_mmap(8 * 8) as *i64
  var bcount: i64 = 0
  var bx: i64 = 0 - 400
  while bx <= 400 {
      let bio: i64 = biome_of(bx, 50)
      if bseen[bio] == 0 { bseen[bio] = 1; bcount = bcount + 1 }
      bx = bx + 16
  }
  // liar-kill: run the SAME distinct-count detector on a constant terrain -> must FAIL variety
  var nv: i64 = 0
  let nseen: *i64 = sys_mmap(32 * 8) as *i64
  var nk: i64 = 0
  while nk < 400 { let lh: i64 = 7; if nseen[lh] == 0 { nseen[lh] = 1; nv = nv + 1 } nk = nk + 1 }
  if dv >= 5 { if suma != sumb { if bcount >= 2 { if nv < 5 {
      hw("T3 PASS variety: distinct-h=" as *u8); pn(dv); hw(" biomes=" as *u8); pn(bcount)
      hw(" regions-differ=1 negctl-fails=1\n" as *u8)
  } } } }
  if dv < 5 { hw("T3 FAIL variety dv=" as *u8); pn(dv); hw("\n" as *u8); fails = fails + 1 }
  if suma == sumb { hw("T3 FAIL regions identical\n" as *u8); fails = fails + 1 }
  if bcount < 2 { hw("T3 FAIL biomes=" as *u8); pn(bcount); hw("\n" as *u8); fails = fails + 1 }
  if nv >= 5 { hw("T3 FAIL neg-control did not fail\n" as *u8); fails = fails + 1 }
130
  // ---- T5 caves + bedrock (BEFORE edits so air pockets are natural) ----
  var caves: i64 = 0
  var cz: i64 = 0
  while cz < 80 {
      var cx: i64 = 0
      while cx < 80 {
          let ch: i64 = terrain_h0(cx, cz)
          if ch >= 8 {
              var cy: i64 = 2
              while cy <= ch - 2 {
                  if solid_h(base, cx, cy, cz, ch) == 0 { caves = caves + 1 }
                  cy = cy + 1
              }
          }
          cx = cx + 1
      }
      cz = cz + 1
  }
  var bed: i64 = 1
  if solid_h(base, 0, 0, 0, 0 - 1) == 0 { bed = 0 }
  if solid_h(base, 0 - 33, 0, 17, 0 - 1) == 0 { bed = 0 }
  if solid_h(base, 4021, 0, 0 - 777, 0 - 1) == 0 { bed = 0 }
  if caves > 0 { if bed == 1 {
      hw("T5 PASS caves+bedrock: interior air cells=" as *u8); pn(caves); hw(" bedrock-solid=1\n" as *u8)
  } }
  if caves == 0 { hw("T5 FAIL no caves\n" as *u8); fails = fails + 1 }
  if bed == 0 { hw("T5 FAIL bedrock broken\n" as *u8); fails = fails + 1 }
158
  // ---- T2b far render differs + window-slide leaves no state ----
  rend(base, 0 - 500, 300, 866, 500, 985, 0 - 174)
  let cf: i64 = fbsum(base)
  write_png((base + fb_off()) as *i64, ww(), hh(), "knowledge/nx_mineworld_2.png" as *u8)
  rend(base, 8, 8, 1000, 0, 927, 0 - 375)
  let c3: i64 = fbsum(base)
  if cf != c1 { if c3 == c1 {
      hw("T2b PASS far(-500,300) frame differs; return-to-spawn frame identical (no window-state leak)\n" as *u8)
  } }
  if cf == c1 { hw("T2b FAIL far frame identical to spawn\n" as *u8); fails = fails + 1 }
  if c3 != c1 { hw("T2b FAIL window slide leaked state\n" as *u8); fails = fails + 1 }
170
  // ---- T4 edit persistence across roaming (raycast+edit-table = the break_at/place_at path at base) ----
  // pick two TREE-FREE dry columns for the edit test (trees are SOLID blocks now -- surface_y == terrain_h0
  // guarantees nothing stands or hangs over the column, so the down-ray hits the terrain top exactly)
  var gxa: i64 = 0 - 999
  var gza: i64 = 0
  var gxb: i64 = 0 - 999
  var gzb: i64 = 0
  var sz: i64 = 14
  while sz <= 26 {
      var sx: i64 = 4
      while sx <= 12 {
          if terrain_h0(sx, sz) > 4 { if surface_y(base, sx, sz) == terrain_h0(sx, sz) {
              if gxa == 0 - 999 { gxa = sx; gza = sz }
              else { if gxb == 0 - 999 { gxb = sx; gzb = sz } }
          } }
          sx = sx + 1
      }
      sz = sz + 1
  }
  var t4: i64 = 1
  if gxb == 0 - 999 { hw("T4 sub: no tree-free columns found\n" as *u8); t4 = 0 }
  rend(base, gxa, gza, 1000, 0, 0, 0 - 1000)
  let cpre: i64 = fbsum(base)
  let o: *i64 = sys_mmap(8 * 8) as *i64
  let hA: i64 = terrain_h0(gxa, gza)
  raycast(base, gxa * 256 + 128, (hA + 4) * 256, gza * 256 + 128, 0, 0 - 1000, 0, o)
  if o[0] != 1 { hw("T4 sub: rayA no-hit\n" as *u8); t4 = 0 }
  if o[2] != hA - 1 { hw("T4 sub: rayA hit gy=" as *u8); pn(o[2]); hw(" want " as *u8); pn(hA - 1); hw("\n" as *u8); t4 = 0 }
  mw_eset(base, o[1], o[2], o[3], 2)
  if solid(base, gxa, hA - 1, gza) != 0 { hw("T4 sub: dig not air\n" as *u8); t4 = 0 }
  let hB: i64 = terrain_h0(gxb, gzb)
  raycast(base, gxb * 256 + 128, (hB + 4) * 256, gzb * 256 + 128, 0, 0 - 1000, 0, o)
  if o[0] != 1 { hw("T4 sub: rayB no-hit\n" as *u8); t4 = 0 }
  mw_eset(base, o[4], o[5], o[6], 1)
  if solid(base, gxb, hB, gzb) != 1 { hw("T4 sub: place not solid\n" as *u8); t4 = 0 }
  // roam the window 200+ blocks away and back
  rend(base, 208, 208, 1000, 0, 927, 0 - 375)
  rend(base, gxa, gza, 1000, 0, 0, 0 - 1000)
  let cpost: i64 = fbsum(base)
  if solid(base, gxa, hA - 1, gza) != 0 { hw("T4 sub: dig lost after roam\n" as *u8); t4 = 0 }
  if solid(base, gxb, hB, gzb) != 1 { hw("T4 sub: place lost after roam\n" as *u8); t4 = 0 }
  if edit_count_at(base) != 2 { hw("T4 sub: edit_count=" as *u8); pn(edit_count_at(base)); hw("\n" as *u8); t4 = 0 }
  if cpost == cpre { hw("T4 sub: edits not visible in frame\n" as *u8); t4 = 0 }
  if t4 == 1 { hw("T4 PASS edits persist across 200-block roam + render differs (dig+place visible), count=2\n" as *u8) }
  else { hw("T4 FAIL edit persistence\n" as *u8); fails = fails + 1 }
216
  if fails == 0 { hw("VERDICT GREEN: mineworld infinite-procgen 5/5 (PNGs knowledge/nx_mineworld_1.png, _2.png)\n" as *u8) }
  else { hw("VERDICT RED fails=" as *u8); pn(fails); hw("\n" as *u8) }
  return fails
220}
nx_wasm_mineworld_gate.nx source

`nx_wasm_mineworld_gate.nx` source
