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

↩ module page · 168 lines · 7203 B
1// nx_engine_phys_gate.nx -- ★ENGINE PHYSICS RUNG 1 (the census GAP axis): a rigid body FALLS under gravity, IMPACTS
2// the generated terrain, BOUNCES with restitution, and comes to REST exactly on the surface -- integer-deterministic.
3// (First physics rung = point-mass + ground collision; placed in-gate now, promoted to an organ when object-object
4// collision/inertia arrive -- ecosystem-placement noted.) T1 it falls. T2 it rests ON the surface. T3 it really
5// BOUNCED (dynamics, not a teleport-clamp). T4 causal: no gravity -> no fall. T5 bit-deterministic trajectories.
6// T6 evidence: air | impact | rest over the streamed worldpipe terrain (textured + sun-shadowed).
7// license_tier: ORIGINAL  expect_exit: 0
8import "nx_syscalls.nx"
9import "nx_png.nx"
10import "nx_trimesh.nx"
11import "nx_worldpipe.nx"
12import "nx_objload.nx"
13
14func hw(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
15func 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 }
16func clearfb(fb: *i64, n: i64, c: i64) -> i64 { var i: i64=0; while i<n { fb[i]=c; i=i+1 } return 0 }
17
18const BR: i64 = 292                    // body radius (the bunny's half-height at scale 450)
19const GRAV: i64 = 40                   // gravity per tick (units/tick^2; tick = 1/64 s)
20const REST: i64 = 340                  // restitution x1024 (energy lost each bounce)
21
22// simulate a drop at (x,z) from y0. out: [0]=final y, [1]=ticks, [2]=bounces, [3]=trajectory hash, [4]=min y seen
23func sim_drop(x: i64, z: i64, y0: i64, grav: i64, out: *i64) -> i64 {
  let ground: i64 = wp_height(x, z)
  var y: i64 = y0
  var v: i64 = 0
  var bounces: i64 = 0
  var h: i64 = 1469598103934665603
  var miny: i64 = y0
  var t: i64 = 0
  while t < 500 {
      v = v + grav
      y = y - v/16
      if y - BR <= ground {
          y = ground + BR
          if v > 120 { v = 0 - v*REST/1024; bounces = bounces + 1 } else { v = 0 }
      }
      if y < miny { miny = y }
      h = (h ^ y) * 1099511628211
      t = t + 1
  }
  out[0] = y
  out[1] = t
  out[2] = bounces
  out[3] = h
  out[4] = miny
  return ground
48}
49
50func main() -> i64 {
  hw("=== nx_engine_phys_gate -- physics rung 1: fall, bounce, rest on the generated world ===\n" as *u8)
  var fails: i64 = 0
  wp_init(1)
  wp_hydro_bake()
55
  let out: *i64 = sys_mmap(64) as *i64
  let dropX: i64 = 900
  let dropZ: i64 = 620
  let ground: i64 = sim_drop(dropX, dropZ, 1400, GRAV, out)
  let finalY: i64 = out[0]
  let bounces: i64 = out[2]
  let hashA: i64 = out[3]
  hw("  drop from 1400 over ground="); pn(ground); hw(": final y="); pn(finalY); hw(" (contact "); pn(finalY-BR); hw(") bounces="); pn(bounces); hw("\n" as *u8)
64
  // ---- T1 it falls ----
  var t1: i64 = 0
  if out[4] < 1400 - 200 { t1 = 1 }
  if t1 == 1 { hw("T1 PASS gravity pulls it down\n" as *u8) } else { fails=fails+1; hw("T1 FAIL\n" as *u8) }
69
  // ---- T2 it RESTS exactly on the surface ----
  var off: i64 = finalY - BR - ground
  if off < 0 { off = 0-off }
  var t2: i64 = 0
  if off <= 2 { t2 = 1 }
  if t2 == 1 { hw("T2 PASS at rest ON the terrain surface (contact off by "); pn(off); hw(")\n" as *u8) }
  else { fails=fails+1; hw("T2 FAIL off="); pn(off); hw("\n" as *u8) }
77
  // ---- T3 real dynamics: it bounced before settling ----
  var t3: i64 = 0
  if bounces >= 1 { if bounces <= 8 { t3 = 1 } }
  if t3 == 1 { hw("T3 PASS it BOUNCED "); pn(bounces); hw(" time(s) with restitution before settling (dynamics, not a clamp)\n" as *u8) }
  else { fails=fails+1; hw("T3 FAIL\n" as *u8) }
83
  // ---- T4 causal: no gravity -> no fall ----
  sim_drop(dropX, dropZ, 1400, 0, out)
  var t4: i64 = 0
  if out[0] == 1400 { t4 = 1 }
  if t4 == 1 { hw("T4 PASS CAUSAL: without gravity it floats exactly where it was\n" as *u8) }
  else { fails=fails+1; hw("T4 FAIL\n" as *u8) }
90
  // ---- T5 bit-deterministic trajectory ----
  sim_drop(dropX, dropZ, 1400, GRAV, out)
  var t5: i64 = 0
  if out[3] == hashA { t5 = 1 }
  if t5 == 1 { hw("T5 PASS the whole trajectory is BIT-DETERMINISTIC (hash-equal across runs -- replayable physics)\n" as *u8) }
  else { fails=fails+1; hw("T5 FAIL\n" as *u8) }
97
  // ---- T6 evidence: air | impact | rest ----
  tm_set_spec(0)
  tm_set_image(0 as *u8, 0, 0)
  let PW: i64 = 360
  let PH: i64 = 330
  let GW: i64 = PW*3
  let gal: *i64 = sys_mmap(GW*PH*8) as *i64
  clearfb(gal, GW*PH, 30 + 40*256 + 58*65536)
  var slot: i64 = 0
  while slot < 3 {
      var by: i64 = 1400
      if slot == 1 { by = ground + BR + 40 }
      if slot == 2 { by = ground + BR }
      // terrain chunk around the drop point + the bunny at sim height
      tm_reset()
      let okB: i64 = obj_load("knowledge/stdassets/bunny.obj" as *u8, 1300, 214+208*256+198*65536)
      tm_place(0, tm_nv(), dropX, by, dropZ, 450)
      let terrFrom: i64 = tm_nv()
      var gz: i64 = 0
      while gz < 33 {
          var gx: i64 = 0
          while gx < 33 {
              let wx: i64 = dropX + (gx-16)*110
              let wz: i64 = dropZ + (gz-16)*110
              var hh: i64 = wp_height(wx, wz)
              let slope: i64 = wp_iabs(wp_height(wx+110, wz) - hh) + wp_iabs(wp_height(wx, wz+110) - hh)
              let col: i64 = wp_surface(wx, wz, hh, slope)
              if hh < 0-14 { hh = 0-14 }
              let vi: i64 = tm_vert(wx, hh, wz)
              tm_vcol(vi, col)
              gx = gx + 1
          }
          gz = gz + 1
      }
      gz = 0
      while gz < 32 {
          var qx: i64 = 0
          while qx < 32 {
              let v0: i64 = terrFrom + gz*33 + qx
              tm_quad(v0, v0+1, v0+34, v0+33, 0)
              qx = qx + 1
          }
          gz = gz + 1
      }
      tm_compute_normals()
      tm_place(0, tm_nv(), 0-dropX, 0-ground-500, 0-dropZ, 1000)
      tm_set_sun(340, 780, 0-300)
      tm_shadow_bake()
      tm_set_tex(70)
      tm_set_shadow(1)
      let fb: *i64 = sys_mmap(PW*PH*8) as *i64
      clearfb(fb, PW*PH, 30 + 40*256 + 58*65536)
      trimesh_render_aa(fb, PW, PH, 620, 0-300, 4600, 430, 2)
      tm_set_shadow(0)
      tm_set_tex(0)
      var y: i64 = 0
      while y < PH {
          var x: i64 = 0
          while x < PW { gal[y*GW + slot*PW + x] = fb[y*PW + x]; x = x + 1 }
          y = y + 1
      }
      slot = slot + 1
  }
  write_png(gal, GW, PH, "knowledge/nx_engine_phys.png" as *u8)
  hw("T6 evidence -> knowledge/nx_engine_phys.png (air | impact | rest)\n" as *u8)
163
  if fails == 0 { hw("ENGINE-PHYS-GATE GREEN -- physics rung 1: gravity, terrain impact, restitution bounces, exact rest -- bit-deterministic (replayable). Residual: rotation/inertia, object-object collision, friction, joints/ragdoll.\n" as *u8); sys_exit(0); return 0 }
  hw("ENGINE-PHYS-GATE RED fails="); pn(fails); hw("\n" as *u8)
  sys_exit(1)
  return 1
168}
nx_engine_phys_gate.nx source

`nx_engine_phys_gate.nx` source
