code wiki / (root) / nx_beach_contact_gate.nx
`nx_beach_contact_gate.nx` source

↩ module page · 775 lines · 30516 B
1// nx_beach_contact_gate.nx -- BEACH GROUND CONTACT: every body path that can leave feet under the
2// rendered sand has a tooth, and each tooth prints the numbers it judged (2026-09-11 beach lane).
3// Causes held here, from the 2026-09-11 fall-through diagnosis: rank 1 collision floor versus the
4// rendered field; rank 2 block-sized camera pops while walking; rank 3 an NPC buried by a window
5// shift and never walked out; rank 4 player support with feet under the field, and the stale-spawn
6// respawn that reaches it; rank 5 an NPC push across a rise; rank 6 arrivals placed on overhead
7// structures. Also a large-dt fall (15 fixed ticks per 250 ms frame from the window top) and NPCs held
8// at both window corners. A checker the current engine cannot fail is paired with a neg-control that
9// runs the SAME checker over the served rule on the same data, so a checker that cannot fire is
10// visible. Native world and fixtures only; browser visual acceptance stays with the operator.
11// license_tier: ORIGINAL
12import "nx_wasm_craft.nx"
13import "nx_gate_verdict.nx"
14import "nx_dec_emit.nx"
15
16const BCG_BLOCK_Q8: i64 = 256            // one block in Q8 world units (the engine's S_CX: 256 = one block)
17const BCG_BODY_CELLS: i64 = 2            // the two body cells mob_fits proves above a floor
18const BCG_CLAMP_BLOCKS: i64 = 2          // wc_shift's window clamp margin in blocks
19const BCG_STRUCTURE: i64 = 6             // a non-terrain solid; the legacy teeth plant the same block
20const BCG_FLAT_HQ: i64 = 1152            // the legacy teeth's flat field corner height
21const BCG_FIX_COL: i64 = 10              // the legacy teeth's fixture column
22const BCG_PATCH_REACH: i64 = 4           // half-width in blocks of a rewritten fixture field
23const BCG_WALK_TICKS: i64 = 240          // four seconds of the page's 60 Hz fixed tick per heading
24const BCG_HEADINGS: i64 = 4              // +x, -x, +z, -z
25const BCG_EDGE_BLOCKS: i64 = 4           // walks stop this far from the window edge; the shift has its own tooth
26const BCG_BURY_BLOCKS: i64 = 2           // the diagnosed burial depth the NPC rise limit never climbs
27const BCG_SHIFT_MAX: i64 = 8             // window slides allowed before the spawn must reach the clamp
28const BCG_SETTLE_TICKS: i64 = 60         // one second of fixed ticks after a placement, push or respawn
29const BCG_EDGE_TICKS: i64 = 240          // ticks the corner NPCs are observed
30const BCG_PAGE_DT_MS: i64 = 250          // the page's NXFRAME_OOR_MS frame clamp
31const BCG_TICK_US: i64 = 16667           // the page accumulator's 16.6667 ms fixed tick
32const BCG_MS_US: i64 = 1000
33const BCG_FALL_TICKS: i64 = 900          // fifteen seconds; a fall from the window top lands long before
34const BCG_PROBES: i64 = 6                // depths under the field probed by the support tooth
35const BCG_PUSH_BOX_Q8: i64 = 100         // apply2_impl's body-presence push distance
36const BCG_PUSH_GAP_Q8: i64 = SPEED+SPEED/2   // an NPC one and a half walk steps behind the player
37const BCG_PUSH_COL: i64 = WX/2           // mid-window, so no window slide fires during the push ticks
38const BCG_CANOPY_REACH: i64 = 9          // canopy half-width in blocks: summon ring 4..7 blocks, passport 3
39const BCG_PASS_ARRIVALS: i64 = 3         // wc_pass_apply spawns at most three companions
40const BCG_STALE_SINK_Q8: i64 = EYE/2     // a stale spawn height: feet under the sand, eye above it
41
42func bcg_number(value: i64, scratch: *u8) -> i64 {
let n: i64=nx_dec_emit_u63(scratch,0,value)
sys_write(1,scratch,n)
return 0
46}
47func bcg_abs(v: i64) -> i64 {
if v < 0 { return 0-v }
return v
50}
51// Q8 depth of feet under a floor; 0 when at or above it.
52func bcg_below(feet: i64, floor: i64) -> i64 {
if feet < floor { return floor-feet }
return 0
55}
56// A solid the terrain field does not replace, written from primitives rather than the engine's contact helper.
57func bcg_structure(base: i64, x: i64, y: i64, z: i64) -> i64 {
if vsolid(base,x,y,z) != 1 { return 0 }
if wsp(base)[P_SURF] == 1 { if wterrain(vget(base,x,y,z)) == 1 { return 0 } }
return 1
61}
62// Independent placement oracle: the lowest feet height at or above the terrain field whose body cells
63// hold no structure. Voxel identities fall back to the column scan.
64func bcg_place_oracle(base: i64, xq: i64, zq: i64) -> i64 {
if wsp(base)[P_SURF] != 1 { return wc_contact_floor_q(base,xq,zq,WY-1) }
var feet: i64 = wc_surface_source(base,xq,zq)
if feet < 0 { return -1 }
var cell: i64 = feet/BCG_BLOCK_Q8
while cell < WY && cell*BCG_BLOCK_Q8 < feet+BCG_BODY_CELLS*BCG_BLOCK_Q8 {
if bcg_structure(base,xq/BCG_BLOCK_Q8,cell,zq/BCG_BLOCK_Q8) == 1 { feet=(cell+1)*BCG_BLOCK_Q8 }
cell=cell+1
}
return feet
74}
75func bcg_arena() -> i64 { return sys_mmap(CRAFT_EXT_TOTAL) as i64 }
76func bcg_world() -> i64 {
let base: i64 = bcg_arena()
init_impl_v(base,BEACH_RELEASE_WORLD,CRAFT_DEFAULT_SEED)
return base
80}
81func bcg_free(base: i64) -> i64 {
sys_munmap(base as *u8,CRAFT_EXT_TOTAL)
return 0
84}
85
86func bcg_checks() -> i64 {
let base: i64 = sys_mmap(CRAFT_TOTAL) as i64
let spec: *i64 = wsp(base)
spec[P_SURF] = 1
spec[P_WATER] = 0
vset(base, 10, 4, 10, 5)
hq_set(base,10,10,1152)
hq_set(base,11,10,1408)
hq_set(base,10,11,1152)
hq_set(base,11,11,1408)
let px: i64 = 10*256+128
let pz: i64 = 10*256+128
let surface: i64 = wc_surface_source(base,px,pz)
let floor: i64 = wstand_here(base,px,pz)-EYE
if surface != 1536 { return 2 }
if floor != 1536 { return 3 }
if surface-floor != 0 { return 4 }
vset(base,10,8,10,6)
if wc_contact_floor_q(base,px,pz,WY-1) != 2304 { return 5 }
if wc_contact_floor_q(base,-1,pz,WY-1) != -1 { return 6 }
spec[P_SURF] = 0
if wc_contact_floor_q(base,px,pz,WY-1) != 2304 { return 7 }
vset(base,10,8,10,0)
if wc_contact_floor_q(base,px,pz,WY-1) != 1280 { return 8 }
spec[P_SURF] = 1
hq_set(base,10,11,1280)
hq_set(base,11,11,1536)
var sx: i64 = 0
while sx < 256 {
var sz: i64 = 0
while sz < 256 {
 let x: i64 = 10*256+sx
 let z: i64 = 10*256+sz
 let expected: i64 = 1408+sx+sz/2
 if wc_surface_source(base,x,z) != expected { return 10 }
 if wstand_here(base,x,z)-EYE != expected { return 11 }
 if wstand(base,x,z,expected+EYE) != expected+EYE { return 12 }
 sz = sz+1
}
sx = sx+1
}
if wstand(base,px,pz,EYE) != -1 { return 13 }
if wstand(base,-1,pz,1536+EYE) != -1 { return 14 }
if wc_contact_floor_q(base,(WX-1)*256,pz,WY-1) != -1 { return 15 }
spec[P_WATER] = 8
vset(base,10,8,10,4)
if wstand_here(base,px,pz) != 9*256+EYE-96 { return 16 }
wc_spec(base,2)
var seed: i64 = 1
while seed <= 16 {
gencol(base,10,10,10,10,seed)
gencol(base,11,10,11,10,seed)
gencol(base,10,11,10,11,seed)
gencol(base,11,11,11,11,seed)
var offset: i64 = 0
while offset < 256 {
 let gx: i64 = 10*256+offset
 let gz: i64 = 10*256+255-offset
 let field: i64 = wc_surface_source(base,gx,gz)
 if field < 0 { return 20 }
 if wc_contact_floor_q(base,gx,gz,WY-1) != field { return 21 }
 offset = offset+1
}
seed=seed+1
}
let generated: i64 = sys_mmap(CRAFT_TOTAL) as i64
init_impl_v(generated,2,17)
let gs: *i64 = wst(generated)
if gs[S_CY] != wstand_here(generated,gs[S_CX],gs[S_CZ]) { return 30 }
let gm: *i64 = mobp(generated)
if en_count(gm) <= 0 { return 31 }
var ci: i64 = 0
while ci < en_count(gm) {
let handle: i64 = en_nth(gm,ci)
let expectedfloor: i64 = wc_contact_floor_q(generated,en_get(gm,handle,MC_X),en_get(gm,handle,MC_Z),WY-1)
if expectedfloor < 0 { return 32 }
if en_get(gm,handle,MC_Y) != expectedfloor { return 33 }
ci=ci+1
}
let initial: *i64 = sys_mmap(MOB_CAP*16) as *i64
let observed: *i64 = sys_mmap(MOB_CAP*24) as *i64
let actorCount: i64 = en_count(gm)
let numberText: *u8 = sys_mmap(NX_DEC_EMIT_MAX_BYTES)
ci=0
while ci < en_count(gm) {
let handle: i64 = en_nth(gm,ci)
observed[ci*3]=handle
initial[ci*2]=en_get(gm,handle,MC_X)
initial[ci*2+1]=en_get(gm,handle,MC_Z)
ci=ci+1
}
var frame: i64 = 0
while frame < 120 {
gs[S_T]=gs[S_T]+1
mob_tick(generated)
if en_count(gm) != actorCount { return 37 }
ci=0
while ci < en_count(gm) {
 let handle: i64 = en_nth(gm,ci)
 if handle != observed[ci*3] { return 38 }
 let floorNow: i64 = wc_contact_floor_q(generated,en_get(gm,handle,MC_X),en_get(gm,handle,MC_Z),WY-1)
 if floorNow < 0 { return 34 }
 if en_get(gm,handle,MC_Y) < floorNow { return 35 }
 let clearance: i64 = en_get(gm,handle,MC_Y)-floorNow
 if clearance > observed[ci*3+2] { observed[ci*3+2]=clearance }
 if en_get(gm,handle,MC_X) != initial[ci*2] || en_get(gm,handle,MC_Z) != initial[ci*2+1] { observed[ci*3+1]=observed[ci*3+1]+1 }
 ci=ci+1
}
frame=frame+1
}
var moved: i64 = 0
var stationary: i64 = 0
ci=0
while ci < en_count(gm) {
let handle: i64 = en_nth(gm,ci)
if observed[ci*3+1] > 0 { moved=moved+1 } else { stationary=stationary+1 }
sys_write(1,"ACTOR handle=" as *u8,13); bcg_number(handle,numberText)
sys_write(1," displaced_frames=" as *u8,18); bcg_number(observed[ci*3+1],numberText)
sys_write(1," max_clearance_q8=" as *u8,18); bcg_number(observed[ci*3+2],numberText)
sys_write(1,"\n" as *u8,1)
ci=ci+1
}
sys_write(1,"CAST moved=" as *u8,11); bcg_number(moved,numberText)
sys_write(1," stationary=" as *u8,12); bcg_number(stationary,numberText)
sys_write(1,"\n" as *u8,1)
if moved == 0 { return 36 }
let trapped: i64 = sys_mmap(CRAFT_TOTAL) as i64
init_impl_v(trapped,2,17)
let tm: *i64 = mobp(trapped)
let ts: *i64 = wst(trapped)
let tn: *i64 = (trapped+O_NEED) as *i64
let savedGait: *i64 = sys_mmap(MOB_CAP*8) as *i64
ci=0
while ci < en_count(tm) {
let h: i64 = en_nth(tm,ci)
savedGait[ci]=tn[ci*4+WC_NEED_GAIT]
let tx: i64 = en_get(tm,h,MC_X)>>8
let tz: i64 = en_get(tm,h,MC_Z)>>8
let ty: i64 = (en_get(tm,h,MC_Y)>>8)+1
var ax: i64 = tx-1
while ax <= tx+1 {
 var az: i64 = tz-1
 while az <= tz+1 {
  var ay: i64 = ty
  while ay < WY { vset(trapped,ax,ay,az,6); ay=ay+1 }
  az=az+1
 }
 ax=ax+1
}
ci=ci+1
}
ts[S_T]=ts[S_T]+1
mob_tick(trapped)
let applied: *i64 = (trapped+O_MOBAUX) as *i64
ci=0
while ci < en_count(tm) {
if applied[ci*3] != 0 || applied[ci*3+1] != 0 { return 39 }
if tn[ci*4+WC_NEED_GAIT] != savedGait[ci] { return 40 }
ci=ci+1
}
return 0
247}
248
249// RANK 1: the collision floor is the rendered field on every structure-free column of the served seed.
250func bcg_census(ctr: *i64) -> i64 {
let base: i64 = bcg_world()
var checked: i64 = 0
var fieldOnly: i64 = 0
var structured: i64 = 0
var mismatch: i64 = 0
var servedBelow: i64 = 0
var servedBlock: i64 = 0
var servedEye: i64 = 0
var servedMax: i64 = 0
var x: i64 = 0
while x < WX-1 {
var z: i64 = 0
while z < WZ-1 {
 let xq: i64 = x*BCG_BLOCK_Q8+BCG_BLOCK_Q8/2
 let zq: i64 = z*BCG_BLOCK_Q8+BCG_BLOCK_Q8/2
 let field: i64 = wc_surface_source(base,xq,zq)
 let contact: i64 = wc_contact_floor_q(base,xq,zq,WY-1)
 checked=checked+1
 if contact > field { structured=structured+1 } else {
  fieldOnly=fieldOnly+1
  if contact != field { mismatch=mismatch+1 }
 }
 let top: i64 = wground(base,x,z)
 if top >= 0 {
  let gap: i64 = field-(top+1)*BCG_BLOCK_Q8
  if gap > 0 { servedBelow=servedBelow+1 }
  if gap > BCG_BLOCK_Q8 { servedBlock=servedBlock+1 }
  if gap > EYE { servedEye=servedEye+1 }
  if gap > servedMax { servedMax=gap }
 }
 z=z+1
}
x=x+1
}
gv_kv("rank1_columns_checked",checked)
gv_kv("rank1_field_only_columns",fieldOnly)
gv_kv("rank1_structure_columns",structured)
gv_kv("rank1_partition_sum",fieldOnly+structured)
gv_kv("rank1_contact_field_mismatch_columns",mismatch)
gv_kv("served_rule_feet_under_field_columns",servedBelow)
gv_kv("served_rule_gap_over_one_block_columns",servedBlock)
gv_kv("served_rule_gap_over_eye_height_columns",servedEye)
gv_kv("served_rule_gap_max_q8",servedMax)
gv_check("rank1 contact floor equals the rendered field on every structure-free column of world 2 seed 20260728",(checked > 0 && fieldOnly+structured == checked && mismatch == 0) as i64,ctr)
gv_check("neg-control-served-voxel-top-rule-puts-feet-under-the-field-on-the-same-columns",(servedBelow > 0) as i64,ctr)
bcg_free(base)
return 0
298}
299
300// RANK 2: walking the served seed in four headings never pops the camera by a block, never leaves the
301// feet under the field, and a grounded tick always rests exactly on contact support.
302func bcg_walk(ctr: *i64) -> i64 {
let base: i64 = bcg_world()
let s: *i64 = wst(base)
let edgeLo: i64 = BCG_EDGE_BLOCKS*BCG_BLOCK_Q8
let edgeHiX: i64 = (WX-BCG_EDGE_BLOCKS)*BCG_BLOCK_Q8
let edgeHiZ: i64 = (WZ-BCG_EDGE_BLOCKS)*BCG_BLOCK_Q8
var ticks: i64 = 0
var movedTicks: i64 = 0
var groundedTicks: i64 = 0
var below: i64 = 0
var pops: i64 = 0
var groundedMismatch: i64 = 0
var maxRise: i64 = 0
var maxDrop: i64 = 0
var servedBelow: i64 = 0
var servedPops: i64 = 0
var heading: i64 = 0
while heading < BCG_HEADINGS {
s[S_CX]=s[S_SPX]; s[S_CY]=s[S_SPY]; s[S_CZ]=s[S_SPZ]; s[S_VY]=0; s[S_GROUNDED]=1
var mx: i64 = 0
var mz: i64 = 0
if heading == 0 { mx=SPEED }
if heading == 1 { mx=0-SPEED }
if heading == 2 { mz=SPEED }
if heading == 3 { mz=0-SPEED }
var servedPrev: i64 = -1
var walking: i64 = 1
var t: i64 = 0
while walking == 1 && t < BCG_WALK_TICKS {
 let nx: i64 = s[S_CX]+mx
 let nz: i64 = s[S_CZ]+mz
 if nx < edgeLo || nz < edgeLo || nx > edgeHiX || nz > edgeHiZ { walking=0 } else {
  let px: i64 = s[S_CX]
  let pz: i64 = s[S_CZ]
  let py: i64 = s[S_CY]
  wc_player_motion(base,mx,mz,0)
  ticks=ticks+1
  if s[S_CX] != px || s[S_CZ] != pz { movedTicks=movedTicks+1 }
  let field: i64 = wc_surface_source(base,s[S_CX],s[S_CZ])
  if field >= 0 { if bcg_below(s[S_CY]-EYE,field) > 0 { below=below+1 } }
  let dy: i64 = s[S_CY]-py
  if bcg_abs(dy) >= BCG_BLOCK_Q8 { pops=pops+1 }
  if dy > maxRise { maxRise=dy }
  if 0-dy > maxDrop { maxDrop=0-dy }
  if s[S_GROUNDED] == 1 {
   groundedTicks=groundedTicks+1
   if wc_player_support(base,s[S_CX],s[S_CZ],s[S_CY]-EYE) != s[S_CY] { groundedMismatch=groundedMismatch+1 }
  }
  let top: i64 = wground(base,s[S_CX]/BCG_BLOCK_Q8,s[S_CZ]/BCG_BLOCK_Q8)
  if top >= 0 {
   let served: i64 = (top+1)*BCG_BLOCK_Q8+EYE
   if field >= 0 { if bcg_below(served-EYE,field) > 0 { servedBelow=servedBelow+1 } }
   if servedPrev >= 0 { if bcg_abs(served-servedPrev) >= BCG_BLOCK_Q8 { servedPops=servedPops+1 } }
   servedPrev=served
  }
  t=t+1
 }
}
heading=heading+1
}
gv_kv("rank2_walk_ticks",ticks)
gv_kv("rank2_walk_moved_ticks",movedTicks)
gv_kv("rank2_walk_grounded_ticks",groundedTicks)
gv_kv("rank2_walk_max_rise_per_tick_q8",maxRise)
gv_kv("rank2_walk_max_drop_per_tick_q8",maxDrop)
gv_kv("served_rule_walk_ticks_feet_under_field",servedBelow)
gv_kv("served_rule_walk_block_pops",servedPops)
gv_check("rank2 walk fixture moved the player and grounded it on this seed",(movedTicks > 0 && groundedTicks > 0) as i64,ctr)
gv_check_eq("rank2 walk ticks with feet under the rendered field",below,0,ctr)
gv_check_eq("rank2 walk ticks with a block-sized camera pop or drop",pops,0,ctr)
gv_check_eq("rank2 walk grounded ticks whose height differs from contact support",groundedMismatch,0,ctr)
gv_check("neg-control-served-voxel-top-rule-pops-a-block-on-the-same-walk",(servedPops > 0) as i64,ctr)
bcg_free(base)
return 0
376}
377
378// RANK 3: a window shift clamps an NPC onto another column and must not leave her buried; her own tick
379// must lift a girl found under her floor.
380func bcg_shift_burial(ctr: *i64) -> i64 {
let base: i64 = bcg_world()
let m: *i64 = mobp(base)
let gs: *i64 = wst(base)
let h: i64 = en_nth(m,0)
let hz: i64 = en_get(m,h,MC_Z)
let landing: i64 = (BCG_CLAMP_BLOCKS+SHIFT_STRIDE)*BCG_BLOCK_Q8
let planned: i64 = bcg_place_oracle(base,landing,hz)
en_set(m,h,MC_X,BCG_BLOCK_Q8+BCG_BLOCK_Q8/2)
en_set(m,h,MC_Y,planned-BCG_BURY_BLOCKS*BCG_BLOCK_Q8)
wc_shift(base,SHIFT_STRIDE,0)
let seatX: i64 = en_get(m,h,MC_X)
let floorAfter: i64 = bcg_place_oracle(base,seatX,en_get(m,h,MC_Z))
let yAfter: i64 = en_get(m,h,MC_Y)
var worst: i64 = 0
var t: i64 = 0
while t < BCG_SETTLE_TICKS {
gs[S_T]=gs[S_T]+1
mob_tick(base)
let d: i64 = bcg_below(en_get(m,h,MC_Y),wc_surface_source(base,en_get(m,h,MC_X),en_get(m,h,MC_Z)))
if d > worst { worst=d }
t=t+1
}
gv_kv("rank3_shift_landing_x_q8",seatX)
gv_kv("rank3_planned_floor_q8",planned)
gv_kv("rank3_floor_after_shift_q8",floorAfter)
gv_kv("rank3_npc_y_after_shift_q8",yAfter)
gv_kv("rank3_worst_under_field_after_shift_q8",worst)
gv_check("rank3 shift fixture clamped the npc onto a column whose floor is two blocks above her feet",(seatX == BCG_CLAMP_BLOCKS*BCG_BLOCK_Q8 && planned >= 0 && floorAfter == planned) as i64,ctr)
gv_check_eq("rank3 npc q8 under her floor straight after the window shift",bcg_below(yAfter,floorAfter),0,ctr)
gv_check_eq("rank3 npc worst q8 under the field over the ticks after the shift",worst,0,ctr)
bcg_free(base)
let own: i64 = bcg_world()
let om: *i64 = mobp(own)
let os: *i64 = wst(own)
let oh: i64 = en_nth(om,0)
let ownFloor: i64 = bcg_place_oracle(own,en_get(om,oh,MC_X),en_get(om,oh,MC_Z))
en_set(om,oh,MC_Y,ownFloor-BCG_BURY_BLOCKS*BCG_BLOCK_Q8)
os[S_T]=os[S_T]+1
mob_tick(own)
let lifted: i64 = bcg_below(en_get(om,oh,MC_Y),wc_surface_source(own,en_get(om,oh,MC_X),en_get(om,oh,MC_Z)))
gv_kv("rank3_own_column_floor_q8",ownFloor)
gv_kv("rank3_own_column_under_field_after_tick_q8",lifted)
gv_check_eq("rank3 buried npc q8 under the field after one tick of her own",lifted,0,ctr)
bcg_free(own)
return 0
426}
427
428// RANK 4: player support never discards the field above the feet. Feet under a flat field at six
429// depths are lifted onto it within one tick and held; a body above the field falls and lands on it.
430func bcg_support_depths(ctr: *i64) -> i64 {
let base: i64 = bcg_arena()
let spec: *i64 = wsp(base)
spec[P_SURF]=1
spec[P_WATER]=0
var cx: i64 = BCG_FIX_COL-BCG_PATCH_REACH
while cx <= BCG_FIX_COL+BCG_PATCH_REACH {
var cz: i64 = BCG_FIX_COL-BCG_PATCH_REACH
while cz <= BCG_FIX_COL+BCG_PATCH_REACH { hq_set(base,cx,cz,BCG_FLAT_HQ); cz=cz+1 }
cx=cx+1
}
let s: *i64 = wst(base)
let p: i64 = BCG_FIX_COL*BCG_BLOCK_Q8+BCG_BLOCK_Q8/2
let field: i64 = wc_surface_source(base,p,p)
var failures: i64 = 0
var firstDepth: i64 = -1
var firstEye: i64 = 0
var i: i64 = 0
while i < BCG_PROBES {
var depth: i64 = 1
if i == 1 { depth=BCG_BLOCK_Q8-1 }
if i == 2 { depth=BCG_BLOCK_Q8 }
if i == 3 { depth=EYE-1 }
if i == 4 { depth=EYE }
if i == 5 { depth=EYE+BCG_BLOCK_Q8 }
s[S_CX]=p; s[S_CZ]=p; s[S_CY]=field+EYE-depth; s[S_VY]=0; s[S_GROUNDED]=0
var bad: i64 = 0
var t: i64 = 0
while t < BCG_SETTLE_TICKS {
 wc_player_vertical_apply(base,0)
 if s[S_CY] != field+EYE { bad=1 }
 t=t+1
}
if s[S_GROUNDED] != 1 { bad=1 }
if bad == 1 {
 failures=failures+1
 if firstDepth < 0 { firstDepth=depth; firstEye=s[S_CY] }
}
i=i+1
}
s[S_CX]=p; s[S_CZ]=p; s[S_CY]=field+EYE+BCG_BLOCK_Q8; s[S_VY]=0; s[S_GROUNDED]=0
var t2: i64 = 0
while t2 < BCG_SETTLE_TICKS { wc_player_vertical_apply(base,0); t2=t2+1 }
gv_kv("rank4_field_q8",field)
gv_kv("rank4_first_failing_depth_q8",firstDepth)
gv_kv("rank4_first_failing_eye_y_q8",firstEye)
gv_kv("rank4_control_eye_y_q8",s[S_CY])
gv_check_eq("rank4 fixture field height q8",field,BCG_FLAT_HQ+BCG_BLOCK_Q8,ctr)
gv_check_eq("rank4 probe depths under the field not lifted onto it and held",failures,0,ctr)
gv_check_eq("rank4 control body a block above the field lands on it (q8 error)",bcg_abs(s[S_CY]-(field+EYE)),0,ctr)
bcg_free(base)
return 0
482}
483
484// RANK 4 entry: after window slides clamp the spawn column, a stale stored height must not respawn the
485// player under the sand (the H key and the void rescue share wc_respawn).
486func bcg_respawn(ctr: *i64) -> i64 {
let base: i64 = bcg_world()
let s: *i64 = wst(base)
let startX: i64 = s[S_SPX]
var shifts: i64 = 0
while shifts < BCG_SHIFT_MAX && s[S_SPX] > BCG_CLAMP_BLOCKS*BCG_BLOCK_Q8 {
wc_shift(base,SHIFT_STRIDE,0)
shifts=shifts+1
}
let spawnFloor: i64 = bcg_place_oracle(base,s[S_SPX],s[S_SPZ])
s[S_SPY]=spawnFloor+EYE-BCG_STALE_SINK_Q8
wc_respawn(base)
let eyeAfterRespawn: i64 = s[S_CY]
var below: i64 = 0
var worst: i64 = 0
var t: i64 = 0
while t < BCG_SETTLE_TICKS {
wc_player_motion(base,0,0,0)
let d: i64 = bcg_below(s[S_CY]-EYE,wc_surface_source(base,s[S_CX],s[S_CZ]))
if d > 0 { below=below+1 }
if d > worst { worst=d }
t=t+1
}
gv_kv("rank4_respawn_start_spawn_x_q8",startX)
gv_kv("rank4_respawn_shifts",shifts)
gv_kv("rank4_respawn_clamped_spawn_x_q8",s[S_SPX])
gv_kv("rank4_respawn_spawn_floor_q8",spawnFloor)
gv_kv("rank4_respawn_eye_after_respawn_q8",eyeAfterRespawn)
gv_kv("rank4_respawn_worst_feet_under_field_q8",worst)
gv_check("rank4 respawn fixture clamped the spawn column and found its floor",(shifts > 0 && s[S_SPX] == BCG_CLAMP_BLOCKS*BCG_BLOCK_Q8 && spawnFloor >= 0) as i64,ctr)
gv_check_eq("rank4 respawn ticks with feet under the field after the clamp",below,0,ctr)
bcg_free(base)
return 0
519}
520
521// NPCs held at both window corners: the field is sampled where they stand and they never stand under it.
522func bcg_edge_npc(ctr: *i64) -> i64 {
let base: i64 = bcg_world()
let m: *i64 = mobp(base)
let gs: *i64 = wst(base)
let maxX: i64 = (WX-BCG_CLAMP_BLOCKS)*BCG_BLOCK_Q8
let maxZ: i64 = (WZ-BCG_CLAMP_BLOCKS)*BCG_BLOCK_Q8
let minQ: i64 = BCG_CLAMP_BLOCKS*BCG_BLOCK_Q8
let hHi: i64 = en_nth(m,0)
let hLo: i64 = en_nth(m,1)
en_set(m,hHi,MC_X,maxX)
en_set(m,hHi,MC_Z,maxZ)
en_set(m,hHi,MC_Y,bcg_place_oracle(base,maxX,maxZ))
en_set(m,hLo,MC_X,minQ)
en_set(m,hLo,MC_Z,minQ)
en_set(m,hLo,MC_Y,bcg_place_oracle(base,minQ,minQ))
var invalid: i64 = 0
var below: i64 = 0
var moved: i64 = 0
var farX: i64 = 0
var nearX: i64 = maxX
var t: i64 = 0
while t < BCG_EDGE_TICKS {
gs[S_T]=gs[S_T]+1
mob_tick(base)
var j: i64 = 0
while j < 2 {
 var hh: i64 = hHi
 var startX: i64 = maxX
 var startZ: i64 = maxZ
 if j == 1 { hh=hLo; startX=minQ; startZ=minQ }
 let ex: i64 = en_get(m,hh,MC_X)
 let ez: i64 = en_get(m,hh,MC_Z)
 let field: i64 = wc_surface_source(base,ex,ez)
 if field < 0 { invalid=invalid+1 } else { if en_get(m,hh,MC_Y) < field { below=below+1 } }
 if ex != startX || ez != startZ { moved=moved+1 }
 if ex > farX { farX=ex }
 if ex < nearX { nearX=ex }
 j=j+1
}
t=t+1
}
gv_kv("edge_far_x_q8",farX)
gv_kv("edge_near_x_q8",nearX)
gv_kv("edge_moved_observations",moved)
gv_kv("edge_unsampled_observations",invalid)
gv_kv("edge_under_field_observations",below)
gv_check("edge corner npcs observed away from their start",(moved > 0) as i64,ctr)
gv_check_eq("edge observations where a corner npc stood where the field cannot be sampled",invalid,0,ctr)
gv_check_eq("edge observations where a corner npc stood under the field",below,0,ctr)
gv_check("neg-control-the-field-sampler-refuses-the-last-window-column",(wc_surface_source(base,(WX-1)*BCG_BLOCK_Q8,maxZ) < 0) as i64,ctr)
bcg_free(base)
return 0
574}
575
576// RANK 5: an NPC body pushing the player across a one-block rise never leaves the feet under the field.
577func bcg_push(ctr: *i64) -> i64 {
let base: i64 = bcg_world()
let spec: *i64 = wsp(base)
spec[P_WATER]=0
let s: *i64 = wst(base)
var cx: i64 = BCG_PUSH_COL-BCG_PATCH_REACH
while cx <= BCG_PUSH_COL+BCG_PATCH_REACH {
var cz: i64 = BCG_PUSH_COL-BCG_PATCH_REACH
while cz <= BCG_PUSH_COL+BCG_PATCH_REACH {
 var hqv: i64 = BCG_FLAT_HQ
 if cx > BCG_PUSH_COL { hqv=BCG_FLAT_HQ+BCG_BLOCK_Q8 }
 hq_set(base,cx,cz,hqv)
 var y: i64 = 0
 while y < WY { if bcg_structure(base,cx,y,cz) == 1 { vset(base,cx,y,cz,0) }; y=y+1 }
 cz=cz+1
}
cx=cx+1
}
let px: i64 = BCG_PUSH_COL*BCG_BLOCK_Q8+BCG_BLOCK_Q8/2
let pz: i64 = BCG_PUSH_COL*BCG_BLOCK_Q8+BCG_BLOCK_Q8/2
s[S_CX]=px; s[S_CZ]=pz; s[S_CY]=wc_surface_source(base,px,pz)+EYE; s[S_VY]=0; s[S_GROUNDED]=1
s[S_SPX]=px; s[S_SPY]=s[S_CY]; s[S_SPZ]=pz
let m: *i64 = mobp(base)
en_init(m,MOB_CAP,MOB_NCOMP)
let h: i64 = en_spawn(m)
en_set(m,h,MC_X,px-BCG_PUSH_GAP_Q8)
en_set(m,h,MC_Z,pz)
en_set(m,h,MC_Y,s[S_CY]-EYE)
let startFeet: i64 = s[S_CY]-EYE
let servedGap: i64 = bcg_below(startFeet,wc_surface_source(base,px-BCG_PUSH_GAP_Q8+BCG_PUSH_BOX_Q8,pz))
var below: i64 = 0
var worst: i64 = 0
var farX: i64 = px
var t: i64 = 0
while t < BCG_SETTLE_TICKS {
apply2_impl(base,0,0,0,0,0,0,0,0,0)
let d: i64 = bcg_below(s[S_CY]-EYE,wc_surface_source(base,s[S_CX],s[S_CZ]))
if d > 0 { below=below+1 }
if d > worst { worst=d }
if s[S_CX] > farX { farX=s[S_CX] }
t=t+1
}
gv_kv("rank5_start_x_q8",px)
gv_kv("rank5_far_x_q8",farX)
gv_kv("rank5_worst_feet_under_field_q8",worst)
gv_kv("served_rule_push_feet_under_field_q8",servedGap)
gv_check("rank5 push fixture moved the player across the rise",(farX > px) as i64,ctr)
gv_check_eq("rank5 push ticks with feet under the field",below,0,ctr)
gv_check("neg-control-served-push-without-a-stand-check-leaves-feet-under-the-rise",(servedGap > 0) as i64,ctr)
bcg_free(base)
return 0
628}
629
630// Plant one structure cell above the body span of every field point in a column, so a body standing on
631// the field fits beneath it while a scan from the sky meets the canopy first.
632func bcg_canopy(base: i64, cx: i64, cz: i64) -> i64 {
var high: i64 = hq_get(base,cx,cz)
if hq_get(base,cx+1,cz) > high { high=hq_get(base,cx+1,cz) }
if hq_get(base,cx,cz+1) > high { high=hq_get(base,cx,cz+1) }
if hq_get(base,cx+1,cz+1) > high { high=hq_get(base,cx+1,cz+1) }
let fieldTop: i64 = high+BCG_BLOCK_Q8
let cell: i64 = (fieldTop+BCG_BODY_CELLS*BCG_BLOCK_Q8+BCG_BLOCK_Q8-1)/BCG_BLOCK_Q8
vset(base,cx,cell,cz,BCG_STRUCTURE)
return cell
641}
642
643// RANK 6: summoned girls and passport arrivals stand on the lowest body-fitting floor, never on a canopy.
644func bcg_placement(ctr: *i64) -> i64 {
let base: i64 = bcg_world()
let s: *i64 = wst(base)
let m: *i64 = mobp(base)
let pcx: i64 = s[S_CX]/BCG_BLOCK_Q8
let pcz: i64 = s[S_CZ]/BCG_BLOCK_Q8
var planted: i64 = 0
var cx: i64 = pcx-BCG_CANOPY_REACH
while cx <= pcx+BCG_CANOPY_REACH {
var cz: i64 = pcz-BCG_CANOPY_REACH
while cz <= pcz+BCG_CANOPY_REACH {
 if cx >= BCG_CLAMP_BLOCKS && cz >= BCG_CLAMP_BLOCKS && cx < WX-BCG_CLAMP_BLOCKS && cz < WZ-BCG_CLAMP_BLOCKS {
  bcg_canopy(base,cx,cz)
  planted=planted+1
 }
 cz=cz+1
}
cx=cx+1
}
let summoned: i64 = summon_impl(base)
var covered: i64 = 0
var misplaced: i64 = 0
var k: i64 = 0
while k < en_count(m) {
let h: i64 = en_nth(m,k)
let x: i64 = en_get(m,h,MC_X)
let z: i64 = en_get(m,h,MC_Z)
if bcg_abs(x/BCG_BLOCK_Q8-pcx) <= BCG_CANOPY_REACH && bcg_abs(z/BCG_BLOCK_Q8-pcz) <= BCG_CANOPY_REACH {
 covered=covered+1
 if en_get(m,h,MC_Y) != bcg_place_oracle(base,x,z) { misplaced=misplaced+1 }
}
k=k+1
}
let pass: *i64 = passp(base)
pass[0]=PASS_MAGIC
pass[1]=1
pass[11]=BCG_PASS_ARRIVALS
var pc: i64 = 0
while pc < BCG_PASS_ARRIVALS { pass[12+pc*3]=pc; pass[13+pc*3]=0; pass[14+pc*3]=pc+1; pc=pc+1 }
pass[21]=wc_pass_ck(pass)
let before: i64 = en_count(m)
let passRc: i64 = wc_pass_apply(base)
let arrivals: i64 = en_count(m)-before
var passMisplaced: i64 = 0
k=before
while k < en_count(m) {
let h: i64 = en_nth(m,k)
if en_get(m,h,MC_Y) != bcg_place_oracle(base,en_get(m,h,MC_X),en_get(m,h,MC_Z)) { passMisplaced=passMisplaced+1 }
k=k+1
}
gv_kv("rank6_canopy_columns",planted)
gv_kv("rank6_cast_after_summon",summoned)
gv_kv("rank6_girls_under_canopies",covered)
gv_kv("rank6_summon_misplaced",misplaced)
gv_kv("rank6_passport_rc",passRc)
gv_kv("rank6_passport_arrivals",arrivals)
gv_kv("rank6_passport_misplaced",passMisplaced)
gv_check("rank6 placement fixture planted canopies over summoned and arriving girls",(planted > 0 && covered > 0 && arrivals > 0) as i64,ctr)
gv_check_eq("rank6 summoned girls not on the lowest body-fitting floor",misplaced,0,ctr)
gv_check_eq("rank6 passport arrivals not on the lowest body-fitting floor",passMisplaced,0,ctr)
bcg_free(base)
return 0
706}
707
708// LARGE DT: the page clamps a frame to 250 ms and runs fixed ticks; 15 ticks per frame is the uncapped
709// worst. A fall from the window top never passes under the field and rests exactly on support.
710func bcg_fall(ctr: *i64) -> i64 {
let base: i64 = bcg_world()
let s: *i64 = wst(base)
let perFrame: i64 = (BCG_PAGE_DT_MS*BCG_MS_US+BCG_TICK_US-1)/BCG_TICK_US
let field0: i64 = wc_surface_source(base,s[S_CX],s[S_CZ])
let start: i64 = (WY-BCG_BODY_CELLS)*BCG_BLOCK_Q8
s[S_CY]=start
s[S_VY]=0
s[S_GROUNDED]=0
var below: i64 = 0
var overspeed: i64 = 0
var landed: i64 = -1
var ghostY: i64 = start
var ghostV: i64 = 0
var ghostBelow: i64 = 0
var t: i64 = 0
while t < BCG_FALL_TICKS {
var f: i64 = 0
while f < perFrame {
 wc_player_motion(base,0,0,0)
 if bcg_below(s[S_CY]-EYE,wc_surface_source(base,s[S_CX],s[S_CZ])) > 0 { below=below+1 }
 if s[S_VY] < 0-VTERM { overspeed=overspeed+1 }
 if landed < 0 && s[S_GROUNDED] == 1 { landed=t }
 ghostV=ghostV-GRAV
 if ghostV < 0-VTERM { ghostV=0-VTERM }
 ghostY=ghostY+ghostV
 if bcg_below(ghostY-EYE,field0) > 0 { ghostBelow=ghostBelow+1 }
 f=f+1
 t=t+1
}
}
let support: i64 = wc_player_support(base,s[S_CX],s[S_CZ],s[S_CY]-EYE)
gv_kv("largedt_ticks_per_frame",perFrame)
gv_kv("largedt_field_q8",field0)
gv_kv("largedt_landed_tick",landed)
gv_kv("largedt_final_eye_q8",s[S_CY])
gv_kv("largedt_support_q8",support)
gv_kv("largedt_unsupported_integrator_under_field_ticks",ghostBelow)
gv_check_eq("large-dt fall ticks with feet under the field at 15 fixed ticks per 250 ms frame",below,0,ctr)
gv_check_eq("large-dt fall ticks faster than terminal velocity",overspeed,0,ctr)
gv_check("large-dt fall landed and rests exactly on contact support",(landed >= 0 && s[S_GROUNDED] == 1 && s[S_CY] == support) as i64,ctr)
s[S_CY]=field0+EYE+1
s[S_VY]=0-VTERM
s[S_GROUNDED]=0
wc_player_motion(base,0,0,0)
gv_check_eq("terminal-velocity tick from one q8 above the field lands on it (q8 error)",bcg_abs(s[S_CY]-(field0+EYE)),0,ctr)
gv_check("neg-control-an-integrator-without-support-falls-through-the-field-on-the-same-fall",(ghostBelow > 0) as i64,ctr)
bcg_free(base)
return 0
759}
760
761func main() -> i64 {
let c: *i64 = gv_ctr()
let result: i64 = bcg_checks()
gv_check_eq("main-world ground and cast contact regression exit code",result,0,c)
bcg_census(c)
bcg_walk(c)
bcg_shift_burial(c)
bcg_support_depths(c)
bcg_respawn(c)
bcg_edge_npc(c)
bcg_push(c)
bcg_placement(c)
bcg_fall(c)
return gv_verdict("BEACH-CONTACT",c,"Native main world and fixtures; browser visual acceptance is separate.")
775}
nx_beach_contact_gate.nx source

`nx_beach_contact_gate.nx` source
