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

↩ module page · 236 lines · 11305 B
1// nx_sudoku_wasm_gate.nx -- native proof of the sovereign sudoku browser game (base-relative, so the
2// SAME code this drives with base=an mmap'd buffer is the code that runs in the browser with base=0).
3//
4// INHERITS THE VERDICT BASE CLASS (gv_ctr/gv_head/gv_check/gv_verdict) rather than hand-rolling one.
5// The first version of this gate counted its own teeth and called sys_exit itself; /api/build REFUSED
6// it at the door (nx_gatedry: CUSTOM-VERDICT, L009/D001) and was right to. A hand-rolled counter can
7// print "passed 22/20", and a gate that returns a bare 0 after printing RED silently blesses every
8// failure it finds, because the control plane derives GREEN from the EXIT CODE. Inheriting makes
9// declared == executed by construction.
10//
11// WHAT THIS GATE EXISTS TO STOP. A game module can pass every logic test and still render nothing --
12// absent drawing code has no failure mode, so a blank framebuffer looks exactly like a working one to
13// a logic-only suite. So there are teeth on the PIXELS as well as the rules, each with a control:
14//   * render must produce many distinct colours (a blank or single-colour frame FAILS)
15//   * the frame must DIFFER from a poisoned buffer (proves render WROTE, rather than the buffer
16//     happening to already hold something)
17//   * a digit must actually be drawn: placing a value must change the pixels inside THAT cell, and an
18//     empty cell must measure exactly 0 ink, which is what stops a saturating measure passing
19//   * and the anti-vacuity twin -- placing a value on a GIVEN must change NOTHING, pixels included
20// license_tier: ORIGINAL   No hw writes (Rule 26).   expect_exit: 0
21import "nx_gate_verdict.nx"
22import "nx_sudoku_wasm.nx"
23
24// distinct framebuffer colours, saturating at cap. A blank frame yields 1.
25func distinct_colors(base: i64, cap: i64) -> i64 {
  let fb: *i64 = (base + O_FB) as *i64
  let seen: *i64 = sys_mmap(cap*8) as *i64
  var n: i64 = 0
  var i: i64 = 0
  let total: i64 = ww()*hh()
  while i < total {
      let c: i64 = fb[i]
      var found: i64 = 0
      var j: i64 = 0
      while j<n { if seen[j]==c { found=1; j=n } else { j=j+1 } }
      if found==0 { if n<cap { seen[n]=c; n=n+1 } }
      i = i + 1
  }
  return n
40}
41
42// Count glyph pixels inside one cell -- the direct evidence a digit was drawn.
43// The background is sampled from the CELL'S OWN interior corner, not from the page margin. An earlier
44// version used fb[0] (page background) and therefore counted every interior pixel as ink: it returned
45// 576 = 24*24 for a full and an empty cell alike. A measure that saturates discriminates nothing, and
46// it made the neg-control tooth pass vacuously too. The corner at +4,+4 is provably outside the glyph
47// box (an 18px glyph in a 30px cell starts at +6) and inside the grid rules.
48func cell_ink(base: i64, idx: i64) -> i64 {
  let fb: *i64 = (base + O_FB) as *i64
  let r: i64 = idx/9
  let c: i64 = idx-r*9
  let x0: i64 = MARGIN + c*CELL + 4
  let y0: i64 = MARGIN + r*CELL + 4
  let bgc: i64 = fb[y0*ww() + x0]
  var n: i64 = 0
  var y: i64 = y0
  while y < y0+CELL-8 {
      var x: i64 = x0
      while x < x0+CELL-8 {
          if fb[y*ww()+x]!=bgc { n=n+1 }
          x=x+1
      }
      y=y+1
  }
  return n
66}
67func first_empty(base: i64) -> i64 {
  var i: i64 = 0
  while i<81 { if given(base,i)==0 { return i } i=i+1 }
  return 0-1
71}
72func first_given(base: i64) -> i64 {
  var i: i64 = 0
  while i<81 { if given(base,i)==1 { return i } i=i+1 }
  return 0-1
76}
77
78func main() -> i64 {
  gv_head("=== NX-SUDOKU-WASM GATE (sovereign browser sudoku; base-relative, no JS, no float) ===" as *u8)
  let ctr: *i64 = gv_ctr()
  let buf: *u8 = sys_mmap(O_END + 4096)
  let base: i64 = buf as i64
83
  // ---------- T1: a puzzle is generated, within the proven clue bounds ----------
  let c0: i64 = init_impl(base)
  gv_puts("  clues=" as *u8); gv_num(c0); gv_puts(" (floor 17, must be < 81)\n" as *u8)
  var ok: i64 = 0
  if c0>=17 { if c0<81 { ok=1 } }
  gv_check("T1 generated puzzle respects the 17-clue floor and is not a full grid" as *u8, ok, ctr)
90
  // ---------- T2: the generated puzzle has EXACTLY ONE solution ----------
  // counted on a scratch copy through the SHARED core -- the same counter the bank tool uses.
  sc_copy(base+O_CORE, SC_G, SC_WORK)
  let nsol: i64 = sc_count(base+O_CORE, SC_WORK, 0, 0)
  gv_puts("  solutions=" as *u8); gv_num(nsol); gv_puts("\n" as *u8)
  gv_check("T2 puzzle is uniquely solvable (counted, not assumed)" as *u8, nsol==1, ctr)
97
  // ---------- T3: every given agrees with the solution it was carved from ----------
  ok = 1
  var i: i64 = 0
  while i<81 { if given(base,i)==1 { if sc_get(base+O_CORE,SC_G,i)!=soln(base,i) { ok=0 } } i=i+1 }
  gv_check("T3 every given clue matches the solution" as *u8, ok, ctr)
103
  // ---------- T4: RENDER NON-VACUITY -- a blank or single-colour frame must fail ----------
  let nc: i64 = distinct_colors(base, 64)
  gv_puts("  distinct_colors=" as *u8); gv_num(nc); gv_puts(" (a blank frame would be 1)\n" as *u8)
  gv_check("T4 render produced a non-trivial frame (>=6 distinct colours)" as *u8, nc>=6, ctr)
108
  // ---------- T5: render actually WRITES -- control against a poisoned buffer ----------
  let fb: *i64 = (base + O_FB) as *i64
  let poison: i64 = 123456789
  var p: i64 = 0
  while p < ww()*hh() { fb[p]=poison; p=p+1 }
  var poisoned: i64 = 0
  if fb[0]==poison { poisoned=1 }
  // assert the fixture REACHED the condition before asserting the outcome
  gv_check("T5a fixture reached the poisoned state" as *u8, poisoned, ctr)
  render_impl(base)
  var left: i64 = 0
  p = 0
  while p < ww()*hh() { if fb[p]==poison { left=left+1 } p=p+1 }
  gv_puts("  poison_pixels_remaining=" as *u8); gv_num(left); gv_puts("\n" as *u8)
  gv_check("T5b render overwrote every pixel (it truly draws the whole frame)" as *u8, left==0, ctr)
124
  // ---------- T6: placing a digit draws it -- pixels inside THAT cell must change ----------
  let e: i64 = first_empty(base)
  // select FIRST and re-render, so the selection highlight is not what gets measured; the only
  // difference between before and after is then the glyph itself.
  st_put(base, S_SEL, e)
  render_impl(base)
  let before: i64 = cell_ink(base, e)
  tick_impl(base, 5)
  let after: i64 = cell_ink(base, e)
  gv_puts("  cell_ink empty=" as *u8); gv_num(before)
  gv_puts(" with_digit=" as *u8); gv_num(after); gv_puts("\n" as *u8)
  // before==0 is the ANTI-SATURATION assertion: it proves the measure can read "nothing drawn".
  ok = 0
  if before==0 { if after>0 { if cur_get(base,e)==5 { ok=1 } } }
  gv_check("T6 an empty cell measures 0 ink and placing a digit draws pixels in it" as *u8, ok, ctr)
140
  // ---------- T7: ANTI-VACUITY TWIN -- a GIVEN is immutable, in state AND pixels ----------
  let g: i64 = first_given(base)
  let gval: i64 = cur_get(base, g)
  st_put(base, S_SEL, g)
  render_impl(base)
  let gink: i64 = cell_ink(base, g)
  let ch: i64 = tick_impl(base, 9)
  gv_puts("  given_ink=" as *u8); gv_num(gink); gv_puts(" (must be > 0, else this control is vacuous)\n" as *u8)
  ok = 0
  if gink>0 { if cur_get(base,g)==gval { if cell_ink(base,g)==gink { if ch==0 { ok=1 } } } }
  gv_check("T7 neg-control: writing over a given changes nothing (state, pixels, or return)" as *u8, ok, ctr)
152
  // ---------- T8: solved detection, both directions ----------
  i = 0
  while i<81 { cur_put(base, i, soln(base,i)); i=i+1 }
  check_solved(base)
  let sv1: i64 = st_get(base,S_SOLVED)
  let e2: i64 = first_empty(base)
  var wrongv: i64 = soln(base,e2) + 1
  if wrongv>9 { wrongv = 1 }
  cur_put(base, e2, wrongv)
  check_solved(base)
  let sv2: i64 = st_get(base,S_SOLVED)
  ok = 0
  if sv1==1 { if sv2==0 { ok=1 } }
  gv_check("T8 solved detection fires on a correct grid and clears on one wrong cell" as *u8, ok, ctr)
167
  // ---------- T9: score counts only correct player entries ----------
  i = 0
  while i<81 { if given(base,i)==0 { cur_put(base,i,0) } i=i+1 }
  let s0: i64 = score_impl(base)
  cur_put(base, e2, soln(base,e2))
  let s1: i64 = score_impl(base)
  cur_put(base, e2, wrongv)
  let s2: i64 = score_impl(base)
  gv_puts("  score empty=" as *u8); gv_num(s0)
  gv_puts(" correct=" as *u8); gv_num(s1)
  gv_puts(" wrong=" as *u8); gv_num(s2); gv_puts("\n" as *u8)
  ok = 0
  if s0==0 { if s1==1 { if s2==0 { ok=1 } } }
  gv_check("T9 score rises on a correct entry and not on a wrong one" as *u8, ok, ctr)
182
  // ---------- T10: navigation wraps and stays in range ----------
  st_put(base, S_SEL, 0)
  tick_impl(base, 10)
  let selL: i64 = st_get(base,S_SEL)
  st_put(base, S_SEL, 0)
  tick_impl(base, 12)
  let selU: i64 = st_get(base,S_SEL)
  ok = 0
  if selL==8 { if selU==72 { ok=1 } }
  gv_check("T10 selection wraps left 0->8 and up 0->72" as *u8, ok, ctr)
193
  // ---------- T11: DETERMINISM -- same seed, same puzzle ----------
  let b2buf: *u8 = sys_mmap(O_END + 4096)
  let b2: i64 = b2buf as i64
  init_impl(b2)
  ok = 1
  i = 0
  while i<81 {
      if sc_get(base+O_CORE,SC_SOL,i)!=sc_get(b2+O_CORE,SC_SOL,i) { ok=0; i=81 } else { i=i+1 }
  }
  gv_check("T11 the fixed init seed reproduces an identical puzzle" as *u8, ok, ctr)
204
  // ---------- T12: a NEW puzzle is actually different, and still unique ----------
  let ss1: i64 = sc_get(b2+O_CORE,SC_SOL,0)*100 + sc_get(b2+O_CORE,SC_SOL,40)
  tick_impl(b2, 20)
  let ss2: i64 = sc_get(b2+O_CORE,SC_SOL,0)*100 + sc_get(b2+O_CORE,SC_SOL,40)
  sc_copy(b2+O_CORE, SC_G, SC_WORK)
  let n2: i64 = sc_count(b2+O_CORE, SC_WORK, 0, 0)
  ok = 0
  if ss1!=ss2 { if n2==1 { ok=1 } }
  gv_check("T12 new-puzzle yields a different grid that is also uniquely solvable" as *u8, ok, ctr)
214
  // ---------- T13: tap hit-testing, inside and outside the grid ----------
  // Touch is the primary input on a phone, so the module owns cell hit testing and the page never
  // computes a cell. Both directions: a point inside a known cell selects exactly that cell, and a
  // point outside selects nothing AND leaves the selection untouched.
  let want: i64 = 4*9 + 6
  let cx: i64 = MARGIN + 6*CELL + CELL/2
  let cy: i64 = MARGIN + 4*CELL + CELL/2
  let hit: i64 = tap_impl(base, cx, cy)
  st_put(base, S_SEL, want)
  let miss: i64 = tap_impl(base, 1, 1)
  let selAfter: i64 = st_get(base, S_SEL)
  gv_puts("  tap_center=" as *u8); gv_num(hit)
  gv_puts(" want=" as *u8); gv_num(want)
  gv_puts(" tap_outside=" as *u8); gv_num(miss)
  gv_puts(" sel_preserved=" as *u8); gv_num(selAfter); gv_puts("\n" as *u8)
  ok = 0
  if hit==want { if miss==(0-1) { if selAfter==want { ok=1 } } }
  gv_check("T13 tap selects the cell under the point and refuses points outside the grid" as *u8, ok, ctr)
233
  return gv_verdict("NX-SUDOKU-WASM-GATE" as *u8, ctr,
      "sovereign NishiLang sudoku: rules+solver+generator+renderer in one base-relative module, no JS logic, no float; uniqueness COUNTED via the shared nx_sudoku_core; pixel teeth include a poisoned-buffer control and an anti-saturation empty-cell assertion" as *u8)
236}
nx_sudoku_wasm_gate.nx source

`nx_sudoku_wasm_gate.nx` source
