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

↩ module page · 254 lines · 13054 B
1// Private actual-engine qualification. No network, production data or hardware writes.
2import "nx_wasm_craft_move_t72.nx"
3import "nx_gate_verdict.nx"
4func dg_equal(a: *u8,b: *u8,n: i64) -> i64 {
var i: i64 = 0
while i < n { if a[i] != b[i] { return 0 }; i = i + 1 }
return 1
8}
9func dg_copy(a: *u8,b: *u8,n: i64) -> i64 {
var i: i64 = 0
while i < n { a[i] = b[i]; i = i + 1 }
return n
13}
14func dg_legacy_q(base: i64,x: i64,z: i64,seed: i64) -> i64 {
let sp: *i64 = wsp(base)
return wclamp(sp[P_TBASE]*256 + wnoise(x,z,16,seed)*sp[P_TAMP1] + wnoise(x,z,5,seed+7)*sp[P_TAMP2],256,(WY-8)*256)
17}
18func dg_hq_parity(base: i64) -> i64 {
let s: *i64 = wst(base)
var errors: i64 = 0; var z: i64 = 0
while z < WZ {
var x: i64 = 0
while x < WX {
 let wanted: i64 = wsp_beach_ocean_q(wsp(base),x+s[S_WOX],z+s[S_WOZ],wheight_qe(base,x+s[S_WOX],z+s[S_WOZ],s[S_SEED]))
 if hq_get(base,x,z) != wanted { errors = errors + 1 }
 x = x + 1
}
z = z + 1
}
return errors
31}
32func main() -> i64 {
let arena: *u8 = sys_mmap(CRAFT_EXT_TOTAL)
let capture: *u8 = sys_mmap(CRAFT_EXT_TOTAL)
if (arena as i64) <= 0 || (capture as i64) <= 0 { return 3 }
let base: i64 = arena as i64
let sp: *i64 = wsp(base); let s: *i64 = wst(base)
let ctr: *i64 = gv_ctr()
gv_head("DUNES / actual shared heightfield and contact" as *u8)
gv_check_eq("slot fits existing spec allocation",WC_SPECN*8,O_EJRN-O_SPEC,ctr)
gv_check_eq("one gen-time allowlist admits dune slot",genp_dune_gen_ok(P_DUNE),1,ctr)
gv_check_eq("allowlist census",genp_gen_count(),GA_ADMITTED,ctr)
var identity: i64 = 0; var other_bad: i64 = 0
while identity < 4 {
wc_spec(base,identity)
if identity != 2 { if sp[P_DUNE] != 0 { other_bad = other_bad + 1 } }
identity = identity + 1
}
gv_check_eq("other identities retain disabled dune data",other_bad,0,ctr)
wc_spec(base,2)
gv_check_eq("Beach explicitly enables reviewed recipe",sp[P_DUNE],BEACH_DUNE_RECIPE,ctr)
gv_check_eq("Beach packed recipe valid",genp_dune_valid(sp[P_DUNE]),1,ctr)
gv_check_eq("negative packed data refused",genp_dune_valid(0-1),0,ctr)
gv_check_eq("reserved bits refused",genp_dune_valid(GA_DUNE_PACK_MAX+1),0,ctr)
gv_check_eq("sub-grid wavelength refused",genp_dune_valid(768+(3 << GA_DUNE_WAVE_SHIFT)),0,ctr)
var bad: i64 = 0; var changed: i64 = 0; var varied: i64 = 0
var minrelief: i64 = BEACH_DUNE_AMPLITUDE_Q8; var maxrelief: i64 = 0
var maxstep: i64 = 0; var z: i64 = 0-32
while z < 128 {
var x: i64 = 0-32
while x < 128 {
 let a: i64 = wc_dune_relief_q(sp,x,z,123)
 let b: i64 = wc_dune_relief_q(sp,x,z,321)
 if a < 0 || a > BEACH_DUNE_AMPLITUDE_Q8 { bad = bad + 1 }
 if a < minrelief { minrelief = a }; if a > maxrelief { maxrelief = a }
 if a != b { varied = varied + 1 }
 var step: i64 = a-wc_dune_relief_q(sp,x+1,z,123)
 if step < 0 { step = 0-step }
 if step > maxstep { maxstep = step }
 if z >= 100 { if a != 0 { bad = bad + 1 } }
 let enabled: i64 = wheight_q(base,x,z,123)
 sp[P_DUNE] = 0
 let disabled: i64 = wheight_q(base,x,z,123)
 if disabled != dg_legacy_q(base,x,z,123) { bad = bad + 1 }
 let raw: i64 = wclamp(sp[P_TBASE]+wnoise(x,z,16,123)*sp[P_TAMP1]/256+wnoise(x,z,5,130)*sp[P_TAMP2]/256,1,WY-8)
 if wheight_raw(base,x,z,123) != raw { bad = bad + 1 }
 sp[P_DUNE] = BEACH_DUNE_RECIPE
 if enabled != disabled { changed = changed + 1 }
 if wheight_raw(base,x,z,123) != wclamp(raw+enabled/256-disabled/256,1,WY-8) { bad = bad + 1 }
 x = x + 1
}
z = z + 1
}
gv_check_eq("25600 signed-coordinate samples bounded and disabled baseline exact",bad,0,ctr)
gv_check("enabled geometry changes sampled terrain" as *u8,changed > 0,ctr)
gv_check("seed changes dune shape" as *u8,varied > 0,ctr)
gv_kv("changed_samples",changed); gv_kv("seed_changed_samples",varied)
gv_kv("relief_min_q8",minrelief); gv_kv("relief_max_q8",maxrelief); gv_kv("max_sampled_x_step_q8",maxstep)
89
var direction:i64=0;var directional_bad:i64=0
while direction<4 {
sp[P_OCEAN]=direction+(612<<2)+(20<<12)+(4<<18)
var distance:i64=0-2
while distance<=2 {
 var x:i64=40;var zz:i64=100-distance
 if direction==1{zz=100+distance};if direction==2{x=100-distance;zz=40};if direction==3{x=100+distance;zz=40}
 let relief:i64=wc_dune_relief_q(sp,x,zz,123)
 let enabled_q:i64=wheight_q(base,x,zz,123);let enabled_raw:i64=wheight_raw(base,x,zz,123)
 sp[P_DUNE]=0
 let disabled_q:i64=wheight_q(base,x,zz,123);let disabled_raw:i64=wheight_raw(base,x,zz,123)
 sp[P_DUNE]=BEACH_DUNE_RECIPE
 if distance<=0{if relief!=0||enabled_q!=disabled_q||enabled_raw!=disabled_raw{directional_bad=directional_bad+1}}
 if enabled_raw!=wclamp(disabled_raw+enabled_q/256-disabled_q/256,1,WY-8){directional_bad=directional_bad+1}
 distance=distance+1
};direction=direction+1
}
gv_check_eq("all four coast orientations preserve zero-relief shoreline raw and HQ",directional_bad,0,ctr)
wc_spec(base,2)
let boot_start: i64 = sys_clock_now_us()
init_impl_v(base,2,20260728)
gv_kv("enabled_boot_us",sys_clock_now_us()-boot_start)
gv_check_eq("initial complete HQ matches absolute native terrain",dg_hq_parity(base),0,ctr)
let floor: i64 = wc_surface_source(base,s[S_CX],s[S_CZ])
gv_check_eq("player feet start on admitted support",s[S_CY]-EYE,wc_contact_floor_q(base,s[S_CX],s[S_CZ],WY-1),ctr)
gv_check_eq("standing player body is clear",wc_player_position_clear(base,s[S_CX],s[S_CY],s[S_CZ]),1,ctr)
let mobs0: *i64 = mobp(base); var k: i64 = 0; var npc_bad: i64 = 0
while k < en_count(mobs0) {
let h: i64 = en_nth(mobs0,k)
let mx: i64 = en_get(mobs0,h,MC_X); let mz: i64 = en_get(mobs0,h,MC_Z)
if en_get(mobs0,h,MC_Y) != wc_contact_floor_q(base,mx,mz,WY-1) { npc_bad = npc_bad + 1 }
k = k + 1
}
gv_check("actual NPC contact population nonempty" as *u8,k > 0,ctr)
gv_check_eq("actual initial NPC roots match native contact",npc_bad,0,ctr); gv_kv("npc_count",k)
let shift_start: i64 = sys_clock_now_us()
wc_shift(base,16,0-16)
gv_kv("enabled_shift_us",sys_clock_now_us()-shift_start)
gv_check_eq("shifted complete HQ matches same absolute surface",dg_hq_parity(base),0,ctr)
dg_copy(capture,(base+O_HQ) as *u8,WX*WZ*8)
wc_hq_restore(base)
gv_check_eq("derived restore produces exact shifted HQ bytes",dg_equal(capture,(base+O_HQ) as *u8,WX*WZ*8),1,ctr)
wc_edit(base,32,24,32,6)
let save_bytes: i64 = wc_save_build(base)
dg_copy(capture,(base+O_SAVE) as *u8,save_bytes)
init_impl_v(base,2,999)
dg_copy((base+O_SAVE) as *u8,capture,save_bytes)
gv_check_eq("same recipe save loads through bounded native door",wc_save_apply_bytes(base,save_bytes),0,ctr)
gv_check_eq("saved seed and origin regenerate complete HQ",dg_hq_parity(base),0,ctr)
gv_check_eq("saved edit and journal survive",ej_get(base,48,24,16),6,ctr)
// v7 snapshots the existing generation allowlist; styles remain current surface-owned.
141
// Reuse the same world identity while changing active generation inputs.
let saved_dune:i64=wc_save_recipe(base)[SAVE_RECIPE_COUNT]
sp[P_DUNE]=0;sp[P_TBASE]=3
gv_check_eq("v7 load restores source generation inputs across active recipe change",wc_save_apply_bytes(base,save_bytes),0,ctr)
gv_check_eq("v7 source dune recipe restored",wsp(base)[P_DUNE],saved_dune,ctr)
gv_check_eq("v7 restored recipe regenerates complete HQ",dg_hq_parity(base),0,ctr)
gv_check_eq("v7 voxel payload retained",dg_equal(wvx(base),(base+O_SAVE+SAVE_HDR) as *u8,WX*WY*WZ),1,ctr)
gv_check_eq("exported save offset owns the dedicated image",save_off(),O_SAVE,ctr)
gv_check_eq("exported save capacity matches serialized bytes",save_capacity(),SAVE_LEN,ctr)
gv_check("save arena follows all inspection state",O_SAVE>=O_INSPECTION+INSPECTION_WORDS*8,ctr)
gv_check("save arena excludes physical spring state",O_SAVE>=O_SOFT+MOB_CAP*SB_PTS*SD_STRIDE*8,ctr)
gv_check_eq("visitor allocation floor follows save image",O_WCM,O_SAVE+SAVE_LEN,ctr)
gv_kv("dedicated_save_arena_bytes",SAVE_LEN)
gv_check_eq("same saved image loads twice without being overwritten",wc_save_apply_bytes(base,save_bytes),0,ctr)
gv_check_eq("repeat restore leaves valid image checksum",wc_save_ck(base),((base+O_SAVE) as *i64)[11],ctr)
var malformed:i64=0
while malformed<3 {
let valid_bytes:i64=wc_save_build(base)
let recipe:*i64=wc_save_recipe(base)
if malformed==0{recipe[0]=SAVE_RECIPE_COUNT+1}
if malformed==1{recipe[SAVE_RECIPE_COUNT]=0-1}
if malformed==2{recipe[SAVE_RECIPE_COUNT]=GA_DUNE_PACK_MAX+1}
dg_copy(capture,arena,CRAFT_EXT_TOTAL)
gv_check_eq("malformed v7 metadata refused",wc_save_apply_bytes(base,valid_bytes),SAVE_RC_RECIPE,ctr)
gv_check_eq("malformed v7 refusal preserves entire arena",dg_equal(capture,arena,CRAFT_EXT_TOTAL),1,ctr)
malformed=malformed+1
}
wc_save_build(base)
170
gv_kv("save_recipe_identity_persisted",1)
let gp: *i64 = wgp(base)
gp[0] = GENP_MAGIC; gp[1] = 1; gp[2] = P_DUNE; gp[3] = 0
let baseline_start: i64 = sys_clock_now_us()
init_impl_v(base,2,20260728)
gv_kv("disabled_boot_us",sys_clock_now_us()-baseline_start)
gv_check_eq("gen-time override disables Beach relief before generation",sp[P_DUNE],0,ctr)
gv_check_eq("override application count",s[S_GENP],1,ctr)
gp[3] = BEACH_DUNE_RECIPE
init_impl_v(base,2,20260728)
gv_check_eq("gen-time override enables actual Beach height cache",dg_hq_parity(base),0,ctr)
182
var refusal:i64=0
while refusal<3 {
gp[0]=GENP_MAGIC;gp[1]=2;gp[2]=P_DUNE;gp[3]=BEACH_DUNE_RECIPE
gp[4]=P_WPIPE;gp[5]=0
var expected_rc:i64=WC_INIT_DUNE_COMPOSITION
if refusal==0{gp[3]=0-1;expected_rc=WC_INIT_DUNE_INVALID}
if refusal==1{gp[5]=1}
if refusal==2{gp[4]=P_ERODE;gp[5]=1}
dg_copy(capture,arena,CRAFT_EXT_TOTAL)
gv_check_eq("invalid or mixed relief recipe refused before init",init_impl_v(base,2,20260728),expected_rc,ctr)
gv_check_eq("init refusal preserves entire active arena",dg_equal(capture,arena,CRAFT_EXT_TOTAL),1,ctr)
refusal=refusal+1
}
gp[1]=1;gp[2]=P_DUNE;gp[3]=0
init_impl_v(base,2,20260728)
let legacy_bytes:i64=SAVE_HDR+SAVE_BODY_V6
wc_save_build(base)
let legacy:*i64=(base+O_SAVE) as *i64
legacy[1]=SAVE_VER6;legacy[11]=wc_save_ck(base)
dg_copy(capture,(base+O_SAVE) as *u8,legacy_bytes)
gp[3]=BEACH_DUNE_RECIPE;init_impl_v(base,2,20260728)
dg_copy((base+O_SAVE) as *u8,capture,legacy_bytes)
gv_check_eq("legacy v6 still loads",wc_save_apply_bytes(base,legacy_bytes),0,ctr)
gv_check_eq("legacy v6 explicitly restores zero relief",sp[P_DUNE],0,ctr)
gv_check_eq("legacy v6 HQ matches preserved zero-relief voxels",dg_hq_parity(base),0,ctr)
208
// Generate actual voxel columns and HQ through the same owner for every coast orientation.
var dgdir:i64=0;var column_bad:i64=0;var column_count:i64=0
while dgdir<4 {
wc_spec(base,2);sp[P_OCEAN]=dgdir+(612<<2)+(20<<12)+(4<<18)
var dd:i64=0-4
while dd<=4 {
 var ax:i64=40;var az:i64=100-dd
 if dgdir==1{az=100+dd};if dgdir==2{ax=100-dd;az=40};if dgdir==3{ax=100+dd;az=40}
 gencol(base,32,32,ax,az,123)
 let top:i64=wsp_beach_ocean(sp,ax,az,wheight(base,ax,az,123))
 let wantedq:i64=wsp_beach_ocean_q(sp,ax,az,wheight_qe(base,ax,az,123))
 if hq_get(base,32,32)!=wantedq{column_bad=column_bad+1}
 if vget(base,32,top,32)==0{column_bad=column_bad+1}
 if top>=sp[P_WATER]{if vget(base,32,top+1,32)!=0{column_bad=column_bad+1}}
 column_count=column_count+1;dd=dd+1
};dgdir=dgdir+1
}
gv_check_eq("four shore directions actual voxel top and HQ agree",column_bad,0,ctr)
gv_kv("generated_coast_columns",column_count)
gp[0]=GENP_MAGIC;gp[1]=1;gp[2]=P_DUNE;gp[3]=0
init_impl_v(base,2,20260728)
wc_save_build(base)
let v5hd:*i64=(base+O_SAVE) as *i64
v5hd[1]=SAVE_VER5;v5hd[11]=wc_save_ck_v5(base)
let v5bytes:i64=SAVE_HDR+SAVE_BODY_V5
dg_copy(capture,(base+O_SAVE) as *u8,v5bytes)
gp[3]=BEACH_DUNE_RECIPE;init_impl_v(base,2,999)
dg_copy((base+O_SAVE) as *u8,capture,v5bytes)
gv_check_eq("legacy v5 image still loads",wc_save_apply_bytes(base,v5bytes),0,ctr)
gv_check_eq("legacy v5 selects explicit zero relief",sp[P_DUNE],0,ctr)
gv_check_eq("legacy v5 derived HQ matches its zero-relief recipe",dg_hq_parity(base),0,ctr)
var invalid:i64=0
while invalid<3 {
let n:i64=wc_save_build(base)
let ih:*i64=(base+O_SAVE) as *i64
var wanted:i64=SAVE_RC_LENGTH;var inputn:i64=n-8
if invalid==1{ih[1]=SAVE_VER+1;inputn=n;wanted=0-2}
if invalid==2{let rr:*i64=wc_save_recipe(base);rr[SAVE_RECIPE_COUNT]=BEACH_DUNE_RECIPE;var ri:i64=0;var ra:i64=1;while ri<WC_SPECN{if genp_dune_gen_ok(ri)==1{if ri==P_WPIPE{rr[ra]=1};ra=ra+1};ri=ri+1};ih[11]=wc_save_ck(base);inputn=n;wanted=SAVE_RC_RECIPE}
dg_copy(capture,arena,CRAFT_EXT_TOTAL)
gv_check_eq("truncated unknown-version or incompatible serialized recipe refused",wc_save_apply_bytes(base,inputn),wanted,ctr)
gv_check_eq("serialized boundary refusal preserves complete arena",dg_equal(capture,arena,CRAFT_EXT_TOTAL),1,ctr)
invalid=invalid+1
}
sys_munmap(arena,CRAFT_EXT_TOTAL); sys_munmap(capture,CRAFT_EXT_TOTAL)
return gv_verdict("BEACH-DUNES" as *u8,ctr,"native geometry/contact; browser GPU parity, near/mid visuals and v5/v6 historical recipe inputs beyond zero-relief remain unknown" as *u8)
254}
nx_craft_relief_canonical_gate_t143.nx source

`nx_craft_relief_canonical_gate_t143.nx` source
