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

↩ module page · 221 lines · 10138 B
1// nx_procgen_terrain_gate.nx -- Gx/PROCGEN: rule-grounded, seed-diverse procedural terrain (the Infinigen
2// direction: procedural, asset-free, parametric-for-diversity, NOT random noise). FBM value-noise heightfield ->
3// D8 flow-direction -> flow-accumulation (descending-elevation pass = a real WATERSHED) -> rivers that PROVABLY
4// flow downhill (the clay-audit named "rivers that don't flow downhill" as the failure) -> shaded-relief render
5// (hillshade x altitude colormap, rivers blue). Three SEEDS side-by-side = parametric diversity (don't overfit to
6// one environment). All integer, deterministic, sovereign. Honest: this is coherence rung 1, not photoreal yet.
7// D001 MIGRATION 2026-09-02 (procgen PG19): the verdict was hand-rolled (PASS/FAIL prints, a fails counter, sys_exit(1)), so
8// /api/promote refused it and nothing outside could read its outcome. Every tooth is now a gv_check and the exit code IS the
9// verdict (nx_gate_verdict). The measurements, thresholds and the PNG are unchanged.
10// license_tier: ORIGINAL  expect_exit: 0
11import "nx_syscalls.nx"
12import "nx_gate_verdict.nx"
13import "nx_png_write.nx"
14
15func pt_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
16func pt_pn(v: i64) -> i64 { let b: *u8=sys_mmap(32) as *u8; var x: i64=v; var ng: i64=0; if x<0{ng=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 ng==1{b[i]=45 as u8;i=i-1} sys_write(1,(b as i64+i+1) as *u8,31-i); return 0 }
17
18// integer hash -> [0,4095]
19func pt_hash2(x: i64, y: i64, seed: i64) -> i64 {
  var a: i64=(x+1)*73856093 + (y+1)*19349663 + (seed+1)*83492791
  a = a % 16777216
  if a<0 { a = a + 16777216 }
  a = (a*1103515245 + 12345) % 16777216
  if a<0 { a = a + 16777216 }
  return a % 4096
26}
27// smoothstep on Q12 t in [0,4096]
28func pt_smooth(t: i64) -> i64 { let t2: i64=(t*t)/4096; return (t2*(3*4096 - 2*t))/4096 }
29// value noise at (px,py) with `lat` lattice cells across dim `sz`, seed -> [0,4095]
30func pt_vnoise(px: i64, py: i64, lat: i64, sz: i64, seed: i64) -> i64 {
  let fx: i64=(px*lat*4096)/sz
  let fy: i64=(py*lat*4096)/sz
  let gx: i64=fx/4096; let tx: i64=fx-gx*4096
  let gy: i64=fy/4096; let ty: i64=fy-gy*4096
  let c00: i64=pt_hash2(gx,gy,seed)
  let c10: i64=pt_hash2(gx+1,gy,seed)
  let c01: i64=pt_hash2(gx,gy+1,seed)
  let c11: i64=pt_hash2(gx+1,gy+1,seed)
  let sx: i64=pt_smooth(tx); let sy: i64=pt_smooth(ty)
  let top: i64=c00 + ((c10-c00)*sx)/4096
  let bot: i64=c01 + ((c11-c01)*sx)/4096
  return top + ((bot-top)*sy)/4096
43}
44// FBM 5 octaves -> [0,HMAX]
45func pt_fbm(px: i64, py: i64, sz: i64, seed: i64) -> i64 {
  var h: i64=0; var amp: i64=2048; var lat: i64=5; var norm: i64=0; var o: i64=0
  while o<5 {
      let v: i64=pt_vnoise(px,py,lat,sz,seed+o*131)
      h = h + (v*amp)/4096
      norm = norm + amp
      amp = amp/2
      lat = lat*2
      o = o+1
  }
  if norm<1 { norm=1 }
  return (h*4000)/norm
57}
58
59func main() -> i64 {
  pt_puts("=== nx_procgen_terrain_gate -- rule-grounded seed-diverse procedural terrain (Infinigen direction) ===\n" as *u8)
  let ctr: *i64=gv_ctr()
  let TW: i64=280; let TH: i64=280; let GAP: i64=20
  let W: i64=TW*3+GAP*2; let H: i64=TH
  let N: i64=TW*TH
  let rgb: *u8=sys_mmap(W*H*3+16)
  var i: i64=0
  while i<W*H { let o: i64=i*3; rgb[o]=10 as u8; rgb[o+1]=12 as u8; rgb[o+2]=18 as u8; i=i+1 }
  let hf: *i64=sys_mmap(N*8) as *i64
  let dn: *i64=sys_mmap(N*8) as *i64
  let ac: *i64=sys_mmap(N*8) as *i64
  let order: *i64=sys_mmap(N*8) as *i64
  let NB: i64=260
  let cnt: *i64=sys_mmap(NB*8) as *i64
  let pos: *i64=sys_mmap(NB*8) as *i64
  // dx/dy for 8 neighbors
  let ndx: *i64=sys_mmap(8*8) as *i64
  let ndy: *i64=sys_mmap(8*8) as *i64
  ndx[0]=0-1; ndx[1]=0; ndx[2]=1; ndx[3]=0-1; ndx[4]=1; ndx[5]=0-1; ndx[6]=0; ndx[7]=1
  ndy[0]=0-1; ndy[1]=0-1; ndy[2]=0-1; ndy[3]=0; ndy[4]=0; ndy[5]=1; ndy[6]=1; ndy[7]=1
  var globaldownhill: i64=0; var globalriver: i64=0; var hrange0: i64=0
  var s: i64=0
  while s<3 {
      let seed: i64=1000 + s*777
      // 1) heightfield
      var hmin: i64=999999; var hmax: i64=0
      var py: i64=0
      while py<TH {
          var px: i64=0
          while px<TW {
              let hv: i64=pt_fbm(px,py,TW,seed)
              hf[py*TW+px]=hv
              if hv<hmin { hmin=hv }
              if hv>hmax { hmax=hv }
              px=px+1
          }
          py=py+1
      }
      if s==0 { hrange0=hmax-hmin }
      // 2) D8 flow direction (interior; border -> self)
      var c: i64=0
      while c<N {
          dn[c]=c; ac[c]=1
          c=c+1
      }
      py=1
      while py<TH-1 {
          var px: i64=1
          while px<TW-1 {
              let ci: i64=py*TW+px
              let hc: i64=hf[ci]
              var best: i64=hc; var bidx: i64=ci
              var k: i64=0
              while k<8 {
                  let ni: i64=(py+ndy[k])*TW + (px+ndx[k])
                  if hf[ni]<best { best=hf[ni]; bidx=ni }
                  k=k+1
              }
              dn[ci]=bidx
              px=px+1
          }
          py=py+1
      }
      // 3) counting sort by height/16 ascending
      var b: i64=0
      while b<NB { cnt[b]=0; b=b+1 }
      c=0
      while c<N { var bb: i64=hf[c]/16; if bb<0 {bb=0} if bb>=NB {bb=NB-1} cnt[bb]=cnt[bb]+1; c=c+1 }
      pos[0]=0; b=1
      while b<NB { pos[b]=pos[b-1]+cnt[b-1]; b=b+1 }
      c=0
      while c<N { var bb: i64=hf[c]/16; if bb<0 {bb=0} if bb>=NB {bb=NB-1} order[pos[bb]]=c; pos[bb]=pos[bb]+1; c=c+1 }
      // 4) flow accumulation: process descending height
      var oi: i64=N-1
      while oi>=0 {
          let cell: i64=order[oi]
          let d: i64=dn[cell]
          if d!=cell { ac[d]=ac[d]+ac[cell] }
          oi=oi-1
      }
      // 5) render into canvas at x-offset
      let xoff: i64=s*(TW+GAP)
      var rdownhill: i64=0; var rriver: i64=0
      py=1
      while py<TH-1 {
          var px: i64=1
          while px<TW-1 {
              let ci: i64=py*TW+px
              let hc: i64=hf[ci]
              // hillshade from gradient
              let dzdx: i64=hf[ci+1]-hf[ci-1]
              let dzdy: i64=hf[ci+TW]-hf[ci-TW]
              var shade: i64=150 + (0-dzdx-dzdy)/6
              if shade<40 { shade=40 }
              if shade>255 { shade=255 }
              // altitude colormap
              var br: i64=0; var bg: i64=0; var bb2: i64=0
              if hc<700 { br=40; bg=90; bb2=140 }
              else { if hc<1600 { br=70; bg=120; bb2=60 }
              else { if hc<2600 { br=110; bg=95; bb2=60 }
              else { if hc<3300 { br=140; bg=132; bb2=122 }
              else { br=222; bg=222; bb2=228 } } } }
              let isriver: i64=ac[ci]
              if isriver>90 { br=50; bg=110; bb2=205 }
              var rr: i64=(br*shade)/255; var gg: i64=(bg*shade)/255; var bl: i64=(bb2*shade)/255
              if rr>255 {rr=255} if gg>255 {gg=255} if bl>255 {bl=255}
              let ox: i64=xoff+px
              if ox<W { let o: i64=(py*W+ox)*3
                  rgb[o]=rr as u8; rgb[o+1]=gg as u8; rgb[o+2]=bl as u8 }
              // downhill proof: river cells whose downstream is strictly lower
              if isriver>90 { let d: i64=dn[ci]
                  if d!=ci { rriver=rriver+1; if hf[d]<hc { rdownhill=rdownhill+1 } } }
              px=px+1
          }
          py=py+1
      }
      globaldownhill=globaldownhill+rdownhill; globalriver=globalriver+rriver
      pt_puts("  seed "); pt_pn(seed); pt_puts(": hrange="); pt_pn(hmax-hmin); pt_puts(" rivercells="); pt_pn(rriver); pt_puts(" downhill="); pt_pn(rdownhill); pt_puts("\n" as *u8)
      s=s+1
  }
  nx_png_write_rgb("knowledge/nx_procgen_terrain.png\x00" as *u8, rgb, W, H)
  pt_puts("  wrote knowledge/nx_procgen_terrain.png\n" as *u8)
  // T1 varied heightfield
  var t1: i64=0
  if hrange0>1500 { t1=1 }
  pt_puts("  hrange(seed0)="); pt_pn(hrange0); pt_puts("\n" as *u8)
  gv_check("T1 heightfield is varied, not flat (seed0 height range over 1500)" as *u8, t1, ctr)
  // T2 water flows downhill (watershed coherence)
  var pct: i64=0
  if globalriver>0 { pct=(globaldownhill*100)/globalriver }
  pt_puts("  river cells="); pt_pn(globalriver); pt_puts(" flowing-downhill="); pt_pn(pct); pt_puts("%\n" as *u8)
  var t2: i64=0
  if globalriver>200 { if pct>=95 { t2=1 } }
  gv_check("T2 rivers provably flow downhill: over 200 river cells and at least 95 percent with a strictly lower downstream cell (a real watershed, not noise)" as *u8, t2, ctr)
  // T3 seed diversity (parametric = don't overfit)
  var dsum: i64=0; var samp: i64=0; var sy2: i64=10
  while sy2<TH-10 {
      var sx2: i64=10
      while sx2<TW-10 {
          let a: i64=pt_fbm(sx2,sy2,TW,1000)
          let c2: i64=pt_fbm(sx2,sy2,TW,1000+2*777)
          var dd: i64=a-c2; if dd<0 {dd=0-dd}
          dsum=dsum+dd; samp=samp+1
          sx2=sx2+23
      }
      sy2=sy2+23
  }
  var davg: i64=0
  if samp>0 { davg=dsum/samp }
  pt_puts("  seed diversity avg|dh|="); pt_pn(davg); pt_puts("\n" as *u8)
  var t3: i64=0
  if davg>200 { t3=1 }
  gv_check("T3 seeds produce diverse terrain: mean absolute height difference between two seeds over 200 (parametric, no overfit)" as *u8, t3, ctr)
  // T4 png
  let szp: *i64=sys_mmap(16) as *i64
  let rb: *u8=sys_read_file("knowledge/nx_procgen_terrain.png\x00" as *u8, szp)
  var t4: i64=0
  if (rb as i64)!=0 { if szp[0]>1000 { t4=1 } }
  if (rb as i64)!=0 { pt_puts("  png bytes="); pt_pn(szp[0]); pt_puts("\n" as *u8) }
  gv_check("T4 the shaded-relief PNG was written and reads back over 1000 bytes" as *u8, t4, ctr)
  return gv_verdict("nx_procgen_terrain_gate" as *u8, ctr, "rule-grounded, seed-diverse, watershed-coherent procedural terrain (Infinigen direction, sovereign integer); coherence rung, not photoreal" as *u8)
221}
nx_procgen_terrain_gate.nx source

`nx_procgen_terrain_gate.nx` source
