Orkuncakilkaya
bf36bc8a8f
- runtime: HEADLESS_FRAME_PATH, STICK_DEADZONE / STICK_LEFT_X/Y, key and byte codes as char literals throughout (`k == 'w'`, `fill(rt_map, ' ', …)`) - ludic.gameplay/stats: drop the duplicate `stat_field` (it answered "atk" for every build stat); Stats.base uses stats_field_name - ludic.shooter: compare aim modes and fire patterns with AimMode.* and WeaponPattern.* instead of raw ints; STICK_RIGHT_X/Y - ludic.npcai: DecisionMade / brain_set_state use AiState.* - examples/games/menu.ludic uses Font.load / Ui.* with FONT_PATH and BACKDROP named; strings.ludic header says what it prints - whole tree: `x = x + 1` → `x += 1` (single-term right-hand sides only), `0 - x` → `-x`, ASCII codes → char literals; every .ludic and every ```ludic fence reformatted with the fixed formatter (whitespace only) Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
125 lines
6.4 KiB
Text
125 lines
6.4 KiB
Text
# physics.ludic — the 2D collision / physics-lite foundation (#65): the
|
|
# engine-owned `esys_move` system integrating velocity + gravity and resolving
|
|
# swept-AABB collision against solid `Collider` entities, driven straight from
|
|
# `entry` (tick_fixed runs the Update phase where the engine ticks Body).
|
|
#
|
|
# Everything is integer + Q16.16 fixed-point and deterministic, so a full run
|
|
# prints: 184 1 1 284 1 1 50 51 104 1 134 1 120 0 1 1 1 0 1 1 1
|
|
program Physics {
|
|
property Position { x: int = 0, y: int = 0 }
|
|
property Body {
|
|
vx: fixed = 0.0, vy: fixed = 0.0,
|
|
gravity: fixed = 0.0, max_fall: fixed = 0.0,
|
|
rx: fixed = 0.0, ry: fixed = 0.0,
|
|
policy: int = 0,
|
|
on_ground: int = 0, hit_wall: int = 0, hit_ceiling: int = 0
|
|
}
|
|
property Collider {
|
|
w: int = 0, h: int = 0, offx: int = 0, offy: int = 0,
|
|
is_trigger: int = 0, one_way: int = 0, layer: int = 0, mask: int = 0,
|
|
hit: int = 0, entered: int = 0, exited: int = 0
|
|
}
|
|
|
|
function tick_n(n: int) -> void { var i = 0; while i < n { tick_fixed(); i += 1 } }
|
|
function bi(b: bool) -> int { if b { return 1 }; return 0 }
|
|
|
|
# despawn every live entity carrying a property, so each scenario starts clean.
|
|
function clear_prop(name: pointer) -> void {
|
|
let p = World.prop_id(name)
|
|
if p < 0 { return }
|
|
var e = World.query_next(p, 0)
|
|
while e >= 0 { despawn e; e = World.query_next(p, 0) }
|
|
}
|
|
function clear() -> void { clear_prop("Body"); clear_prop("Collider") }
|
|
|
|
entry {
|
|
let pb = World.prop_id("Body")
|
|
let pc = World.prop_id("Collider")
|
|
let pp = World.prop_id("Position")
|
|
let f_y = World.field_id(pp, "y")
|
|
let f_x = World.field_id(pp, "x")
|
|
let f_vx = World.field_id(pb, "vx")
|
|
let f_vy = World.field_id(pb, "vy")
|
|
let f_grd = World.field_id(pb, "on_ground")
|
|
let f_hw = World.field_id(pb, "hit_wall")
|
|
let f_hit = World.field_id(pc, "hit")
|
|
let f_ent = World.field_id(pc, "entered")
|
|
let f_ext = World.field_id(pc, "exited")
|
|
|
|
# ---- A. gravity + landing on a solid floor entity ----------------------
|
|
clear()
|
|
spawn Floor { Position { x: 0, y: 200 }, Collider { w: 400, h: 16 } }
|
|
spawn Runner { Position { x: 50, y: 40 }, Body { gravity: fixed(1), max_fall: fixed(6) }, Collider { w: 16, h: 16 } }
|
|
var a = World.query_next(pb, 0)
|
|
tick_n(80)
|
|
print(World.get(a, pp, f_y)) # 184 — feet rest on the floor top (200)
|
|
print(World.get(a, pb, f_grd)) # 1 — on_ground
|
|
print(bi(World.get(a, pb, f_vy) == 0)) # 1 — vertical velocity zeroed
|
|
|
|
# ---- B. horizontal run into a solid wall -------------------------------
|
|
clear()
|
|
spawn Floor { Position { x: 0, y: 200 }, Collider { w: 400, h: 16 } }
|
|
spawn Wall { Position { x: 300, y: 0 }, Collider { w: 16, h: 400 } }
|
|
spawn Runner { Position { x: 100, y: 184 }, Body { gravity: fixed(1), max_fall: fixed(6) }, Collider { w: 16, h: 16 } }
|
|
a = World.query_next(pb, 0)
|
|
# re-apply the run velocity each frame, the way a controller drives it from
|
|
# held input — so hit_wall stays asserted while pressed against the wall.
|
|
var bi2 = 0
|
|
while bi2 < 80 { World.set(a, pb, f_vx, fixed(4)); tick_fixed(); bi2 += 1 }
|
|
print(World.get(a, pp, f_x)) # 284 — right edge stops at the wall (300)
|
|
print(World.get(a, pb, f_hw)) # 1 — hit_wall while pressed
|
|
print(bi(World.get(a, pb, f_vx) == 0)) # 1 — the sweep zeroed it this frame
|
|
|
|
# ---- C. sub-pixel accumulation (top-down, no gravity) ------------------
|
|
clear()
|
|
spawn Runner { Position { x: 50, y: 50 }, Body { vx: 0.25, policy: 1 }, Collider { w: 16, h: 16 } }
|
|
a = World.query_next(pb, 0)
|
|
tick_n(3)
|
|
print(World.get(a, pp, f_x)) # 50 — 0.75px accumulated, no whole step yet
|
|
tick_n(1)
|
|
print(World.get(a, pp, f_x)) # 51 — the 4th quarter-pixel carries one px
|
|
|
|
# ---- D. landing on a solid platform entity -----------------------------
|
|
clear()
|
|
spawn Plat { Position { x: 400, y: 120 }, Collider { w: 64, h: 8 } }
|
|
spawn Runner { Position { x: 410, y: 40 }, Body { gravity: fixed(1), max_fall: fixed(6) }, Collider { w: 16, h: 16 } }
|
|
a = World.query_next(pb, 0)
|
|
tick_n(60)
|
|
print(World.get(a, pp, f_y)) # 104 — feet on the platform top (120)
|
|
print(World.get(a, pb, f_grd)) # 1
|
|
|
|
# ---- E. one-way platform: land from above, pass through from below -----
|
|
clear()
|
|
spawn Plat { Position { x: 400, y: 150 }, Collider { w: 64, h: 8, one_way: 1 } }
|
|
spawn Runner { Position { x: 405, y: 60 }, Body { gravity: fixed(1), max_fall: fixed(6) }, Collider { w: 16, h: 16 } }
|
|
let e1 = World.query_next(pb, 0)
|
|
spawn Riser { Position { x: 430, y: 200 }, Body { vy: fixed(-4), policy: 1 }, Collider { w: 16, h: 16 } }
|
|
var e2 = World.query_next(pb, 0)
|
|
if e2 == e1 { e2 = World.query_next(pb, e1 + 1) }
|
|
tick_n(20)
|
|
print(World.get(e1, pp, f_y)) # 134 — landed on the one-way top (150)
|
|
print(World.get(e1, pb, f_grd)) # 1
|
|
print(World.get(e2, pp, f_y)) # 120 — rose straight through it (200 - 4*20)
|
|
|
|
# ---- F. trigger / sensor: enter + exit edges over a moving body --------
|
|
clear()
|
|
spawn Sensor { Position { x: 500, y: 100 }, Collider { w: 32, h: 32, is_trigger: 1 } }
|
|
let sid = World.query_next(pc, 0)
|
|
spawn Runner { Position { x: 460, y: 108 }, Body { vx: fixed(4), policy: 1 }, Collider { w: 16, h: 16 } }
|
|
let aid = World.query_next(pb, 0)
|
|
tick_n(6) # x=484 — not yet overlapping
|
|
print(World.get(sid, pc, f_ent)) # 0
|
|
print(bi(World.get(sid, pc, f_hit) < 0)) # 1 — nothing inside
|
|
tick_n(1) # x=488 — overlap begins this frame
|
|
print(World.get(sid, pc, f_ent)) # 1 — entered edge
|
|
print(bi(World.get(sid, pc, f_hit) == aid)) # 1 — reports the body inside
|
|
tick_n(10) # x=528 — still inside, no new edge
|
|
print(World.get(sid, pc, f_ent)) # 0
|
|
print(bi(World.get(sid, pc, f_hit) == aid)) # 1
|
|
tick_n(1) # x=532 — overlap ends this frame
|
|
print(World.get(sid, pc, f_ext)) # 1 — exited edge
|
|
print(bi(World.get(sid, pc, f_hit) < 0)) # 1 — empty again
|
|
|
|
quit()
|
|
}
|
|
}
|