workshopsoft/ludic
2
0
Fork 0
Code Issues Pull requests Projects Releases 26 Packages Wiki Activity Actions

wip(0.S3): the packages migrated by ludic migrate state packages - every package test green

Browse source 
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Orkun ÇAKILKAYA 2026-09-25 14:02:21 +03:00
parent 1e8b5b0523
commit 07505e7ef2
294 changed files with 14996 additions and 14675 deletions
Download patch file Download diff file Expand all files Collapse all files

24
packages/ludic.compass/bearing.ludic
View file

@ -1,15 +1,15 @@
# bearing.ludic - the frame's marks as the strip reads them: how many, each one, where it bears
# from the viewer's facing and how far it is. A heading is the world's (0 toward -z, a quarter
# turn toward -x), a bearing is the heading less the viewer's yaw, in -pi .. pi.
export function compass_count() -> int {
if cmp_list == null { return 0 }
return len(cmp_list)
export function compass_count(compass_st: CompassState) -> int {
if compass_st.cmp_list == null { return 0 }
return len(compass_st.cmp_list)
}
# the i-th mark, or an empty one past the end
export function compass_at(i: int) -> CompassMark {
if i < 0 or i >= compass_count() { return new CompassMark }
return cmp_list[i]
export function compass_at(compass_st: CompassState, i: int) -> CompassMark {
if i < 0 or i >= compass_count(compass_st) { return new CompassMark }
return compass_st.cmp_list[i]
}
export function compass_wrap(a: float) -> float {
@ -33,13 +33,13 @@ export function compass_dist_to(x: float, z: float) -> float {
return Math.sqrt(dx * dx + dz * dz)
}
export function compass_bearing(i: int) -> float {
let m = compass_at(i)
export function compass_bearing(compass_st: CompassState, i: int) -> float {
let m = compass_at(compass_st, i)
return compass_bearing_to(m.x, m.z)
}
export function compass_dist(i: int) -> float {
let m = compass_at(i)
export function compass_dist(compass_st: CompassState, i: int) -> float {
let m = compass_at(compass_st, i)
return compass_dist_to(m.x, m.z)
}
@ -47,8 +47,8 @@ export function compass_dist(i: int) -> float {
export function compass_strip_t(bearing: float, half: float) -> float { return bearing / Math.max(half, 0.001) }
# the objective: the first tracked mark of the frame, or -1
export function compass_tracked() -> int {
for i in 0 .. compass_count() { if cmp_list[i].prio >= COMPASS_TRACKED { return i } }
export function compass_tracked(compass_st: CompassState) -> int {
for i in 0 .. compass_count(compass_st) { if compass_st.cmp_list[i].prio >= COMPASS_TRACKED { return i } }
return -1
}

42
packages/ludic.compass/gather.ludic
View file

@ -1,56 +1,56 @@
# gather.ludic - a frame's marks: begin, every provider marks, end sorts and culls. While a
# capture is open the marks go to whoever is listening instead, whatever the tier.
export function compass_begin() -> void { cmp_list = new []CompassMark }
export function compass_begin(compass_st: mut CompassState) -> void { compass_st.cmp_list = new []CompassMark }
# a provider's verb: a thing at (x, z), shown from compass `tier` up
export function compass_mark(x: float, z: float, icon: int, colour: int, tier: int, prio: int, label: string) -> void {
if cmp_list == null { compass_begin() }
export function compass_mark(compass_st: mut CompassState, x: float, z: float, icon: int, colour: int, tier: int, prio: int, label: string) -> void {
if compass_st.cmp_list == null { compass_begin(compass_st) }
let m = cmp_new(x, z, icon, colour, tier, prio, label)
if cmp_capturing {
push(cmp_caught, m)
if compass_st.cmp_capturing {
push(compass_st.cmp_caught, m)
return
}
if CompassWorld.tier() < tier { return }
push(cmp_list, m)
push(compass_st.cmp_list, m)
}
# highest priority first, the providers' order kept within one; then the cap
export function compass_end() -> void {
if cmp_list == null { compass_begin() }
export function compass_end(compass_st: mut CompassState) -> void {
if compass_st.cmp_list == null { compass_begin(compass_st) }
let out = new []CompassMark
for p in 0 .. 3 {
let want = COMPASS_TRACKED - p
for i in 0 .. len(cmp_list) { if cmp_band(cmp_list[i].prio) == want and len(out) < cmp_cap { push(out, cmp_list[i]) } }
for i in 0 .. len(compass_st.cmp_list) { if cmp_band(compass_st.cmp_list[i].prio) == want and len(out) < compass_st.cmp_cap { push(out, compass_st.cmp_list[i]) } }
}
cmp_list = out
compass_st.cmp_list = out
}
function cmp_band(p: int) -> int { return Math.clamp(p, COMPASS_PLAIN, COMPASS_TRACKED) }
# once a frame: ask every registered provider, in the registry's order
export function compass_gather() -> void {
compass_begin()
export function compass_gather(compass_st: mut CompassState) -> void {
compass_begin(compass_st)
if CompassWorld.tier() <= 0 { return }
for i in 0 .. COMPASS_FROM_COUNT {
let f = CompassProviders[i].gather
if f != null { f() }
}
compass_end()
compass_end(compass_st)
}
# someone else wants to know where the providers point (a guide's arrow): until the end every
# mark is theirs, whatever the tier, and the frame's list is left alone
export function compass_capture_begin() -> void {
cmp_capturing = true
cmp_caught = new []CompassMark
export function compass_capture_begin(compass_st: mut CompassState) -> void {
compass_st.cmp_capturing = true
compass_st.cmp_caught = new []CompassMark
}
export function compass_capture_end() -> []CompassMark {
cmp_capturing = false
var got = cmp_caught
cmp_caught = new []CompassMark
export function compass_capture_end(compass_st: mut CompassState) -> []CompassMark {
compass_st.cmp_capturing = false
var got = compass_st.cmp_caught
compass_st.cmp_caught = new []CompassMark
if got == null { got = new []CompassMark }
return got
}
export function compass_capturing() -> bool { return cmp_capturing }
export function compass_capturing(compass_st: CompassState) -> bool { return compass_st.cmp_capturing }

18
packages/ludic.compass/marks.ludic
View file

@ -22,15 +22,19 @@ export property CompassProvider {
export open registry CompassProviders of CompassProvider as COMPASS_FROM
var cmp_cap: int = 64
var cmp_list: []CompassMark = null # this frame's, sorted and culled
var cmp_capturing: bool = false
var cmp_caught: []CompassMark = null # what providers said while someone was listening
export state CompassState {
cmp_cap: int = 64
cmp_list: []CompassMark = null # this frame's, sorted and culled
cmp_capturing: bool = false
cmp_caught: []CompassMark = null # what providers said while someone was listening
cmp_ranges: []float = null
cmp_radar_from: int = 2 # marks of at least this tier are blips; the tracked one always is
}
# how many marks a frame keeps (the lowest priorities go first past it)
export function compass_config(cap: int) -> void {
cmp_cap = Math.max(cap, 1)
compass_begin()
export function compass_config(compass_st: mut CompassState, cap: int) -> void {
compass_st.cmp_cap = Math.max(cap, 1)
compass_begin(compass_st)
}
function cmp_new(x: float, z: float, icon: int, colour: int, tier: int, prio: int, label: string) -> CompassMark {

40
packages/ludic.compass/radar.ludic
View file

@ -1,40 +1,38 @@
# radar.ludic - the radar's tiers: a range for each compass tier (0 is no radar), which marks it
# shows, and where each falls on a unit disc with ahead at the top
var cmp_ranges: []float = null
var cmp_radar_from: int = 2 # marks of at least this tier are blips; the tracked one always is
export function compass_config_radar(ranges: []float, from_tier: int) -> void {
cmp_ranges = new []float
for i in 0 .. len(ranges) { push(cmp_ranges, ranges[i]) }
cmp_radar_from = from_tier
export function compass_config_radar(compass_st: mut CompassState, ranges: []float, from_tier: int) -> void {
compass_st.cmp_ranges = new []float
for i in 0 .. len(ranges) { push(compass_st.cmp_ranges, ranges[i]) }
compass_st.cmp_radar_from = from_tier
}
# how far the radar reaches with the viewer's compass, 0 without one; a tier past the table has
# the last range
export function compass_radar_range() -> float {
if cmp_ranges == null or len(cmp_ranges) == 0 { return 0.0 }
export function compass_radar_range(compass_st: CompassState) -> float {
if compass_st.cmp_ranges == null or len(compass_st.cmp_ranges) == 0 { return 0.0 }
let t = CompassWorld.tier()
if t < 0 { return 0.0 }
if t >= len(cmp_ranges) { return cmp_ranges[len(cmp_ranges) - 1] }
return cmp_ranges[t]
if t >= len(compass_st.cmp_ranges) { return compass_st.cmp_ranges[len(compass_st.cmp_ranges) - 1] }
return compass_st.cmp_ranges[t]
}
export function compass_radar_on() -> bool { return compass_radar_range() > 0.0 }
export function compass_radar_on(compass_st: CompassState) -> bool { return compass_radar_range(compass_st) > 0.0 }
# the i-th mark is a blip: a radar is carried, it is shown there and it is in range
export function compass_radar_has(i: int) -> bool {
if i < 0 or i >= compass_count() or not compass_radar_on() { return false }
let m = cmp_list[i]
if m.tier < cmp_radar_from and m.prio < COMPASS_TRACKED { return false }
return compass_dist(i) <= compass_radar_range()
export function compass_radar_has(compass_st: CompassState, i: int) -> bool {
if i < 0 or i >= compass_count(compass_st) or not compass_radar_on(compass_st) { return false }
let m = compass_st.cmp_list[i]
if m.tier < compass_st.cmp_radar_from and m.prio < COMPASS_TRACKED { return false }
return compass_dist(compass_st, i) <= compass_radar_range(compass_st)
}
# where on a unit disc: x right, y down, so ahead is (0, -1) and the edge is the range
export function compass_radar_x(i: int) -> float { return -Math.sin(compass_bearing(i)) * cmp_radar_frac(i) }
export function compass_radar_y(i: int) -> float { return -Math.cos(compass_bearing(i)) * cmp_radar_frac(i) }
export function compass_radar_x(compass_st: CompassState, i: int) -> float { return -Math.sin(compass_bearing(compass_st, i)) * cmp_radar_frac(compass_st, i) }
export function compass_radar_y(compass_st: CompassState, i: int) -> float { return -Math.cos(compass_bearing(compass_st, i)) * cmp_radar_frac(compass_st, i) }
function cmp_radar_frac(i: int) -> float {
let r = compass_radar_range()
function cmp_radar_frac(compass_st: CompassState, i: int) -> float {
let r = compass_radar_range(compass_st)
if r <= 0.0 { return 0.0 }
return Math.min(compass_dist(i) / r, 1.0)
return Math.min(compass_dist(compass_st, i) / r, 1.0)
}

178
packages/ludic.compass/tests/compass_test.ludic
View file

@ -6,120 +6,122 @@ import "ludic.base"
program CompassTest {
numbers float
var vx: float = 0.0
var vz: float = 0.0
var yaw: float = 0.0
var tier: int = 4
var objective: bool = true
state CompasstestState {
vx: float = 0.0
vz: float = 0.0
yaw: float = 0.0
tier: int = 4
objective: bool = true
}
function fk_x() -> float { return vx }
function fk_z() -> float { return vz }
function fk_yaw() -> float { return yaw }
function fk_tier() -> int { return tier }
function fk_x(compasstest_st: CompasstestState) -> float { return compasstest_st.vx }
function fk_z(compasstest_st: CompasstestState) -> float { return compasstest_st.vz }
function fk_yaw(compasstest_st: CompasstestState) -> float { return compasstest_st.yaw }
function fk_tier(compasstest_st: CompasstestState) -> int { return compasstest_st.tier }
bind CompassWorld { x: fn fk_x, z: fn fk_z, yaw: fn fk_yaw, tier: fn fk_tier }
function places() -> void {
compass_mark(0.0, -100.0, 1, 10, 1, COMPASS_PLAIN, "camp")
compass_mark(-50.0, 0.0, 2, 11, 2, COMPASS_PLAIN, "sign")
compass_mark(0.0, 300.0, 3, 12, 4, COMPASS_PLAIN, "legend")
compass_mark(10.0, 10.0, 4, 13, 1, COMPASS_NOTE, "my mark")
function places(compass_st: mut CompassState) -> void {
compass_mark(compass_st, 0.0, -100.0, 1, 10, 1, COMPASS_PLAIN, "camp")
compass_mark(compass_st, -50.0, 0.0, 2, 11, 2, COMPASS_PLAIN, "sign")
compass_mark(compass_st, 0.0, 300.0, 3, 12, 4, COMPASS_PLAIN, "legend")
compass_mark(compass_st, 10.0, 10.0, 4, 13, 1, COMPASS_NOTE, "my mark")
}
function goal() -> void { if objective { compass_mark(80.0, 0.0, 5, 14, 2, COMPASS_TRACKED, "the dock") } }
function goal(compass_st: mut CompassState, compasstest_st: CompasstestState) -> void { if compasstest_st.objective { compass_mark(compass_st, 80.0, 0.0, 5, 14, 2, COMPASS_TRACKED, "the dock") } }
def CompassProviders places { gather: fn places }
def CompassProviders goal { gather: fn goal }
function fresh() -> void {
compass_config(64)
compass_config_radar([0.0, 0.0, 0.0, 120.0, 260.0], 2)
vx = 0.0
vz = 0.0
yaw = 0.0
tier = 4
objective = true
function fresh(compass_st: mut CompassState, compasstest_st: mut CompasstestState) -> void {
compass_config(compass_st, 64)
compass_config_radar(compass_st, [0.0, 0.0, 0.0, 120.0, 260.0], 2)
compasstest_st.vx = 0.0
compasstest_st.vz = 0.0
compasstest_st.yaw = 0.0
compasstest_st.tier = 4
compasstest_st.objective = true
}
function labels() -> string {
function labels(compass_st: CompassState) -> string {
var s = ""
for i in 0 .. compass_count() { s = s + compass_at(i).label + ";" }
for i in 0 .. compass_count(compass_st) { s = s + compass_at(compass_st, i).label + ";" }
return s
}
test "every provider is asked, the tracked mark first, then the player's, then the rest in order" {
fresh()
compass_gather()
expect_eq(compass_count(), 5)
expect(labels() == "the dock;my mark;camp;sign;legend;")
expect_eq(compass_tracked(), 0)
test "every provider is asked, the tracked mark first, then the player's, then the rest in order" (compass_st: mut CompassState, compasstest_st: mut CompasstestState) {
fresh(compass_st, compasstest_st)
compass_gather(compass_st)
expect_eq(compass_count(compass_st), 5)
expect(labels(compass_st) == "the dock;my mark;camp;sign;legend;")
expect_eq(compass_tracked(compass_st), 0)
}
test "a mark shows from its tier up, and without a compass nothing is gathered" {
fresh()
tier = 1
compass_gather()
expect(labels() == "my mark;camp;")
expect_eq(compass_tracked(), -1)
tier = 0
compass_gather()
expect_eq(compass_count(), 0)
test "a mark shows from its tier up, and without a compass nothing is gathered" (compass_st: mut CompassState, compasstest_st: mut CompasstestState) {
fresh(compass_st, compasstest_st)
compasstest_st.tier = 1
compass_gather(compass_st)
expect(labels(compass_st) == "my mark;camp;")
expect_eq(compass_tracked(compass_st), -1)
compasstest_st.tier = 0
compass_gather(compass_st)
expect_eq(compass_count(compass_st), 0)
}
test "past the cap the lowest priorities go" {
fresh()
compass_config(2)
compass_gather()
expect(labels() == "the dock;my mark;")
test "past the cap the lowest priorities go" (compass_st: mut CompassState, compasstest_st: mut CompasstestState) {
fresh(compass_st, compasstest_st)
compass_config(compass_st, 2)
compass_gather(compass_st)
expect(labels(compass_st) == "the dock;my mark;")
}
test "a bearing is from the viewer's facing, a distance from where it stands" {
fresh()
compass_gather()
expect_near(compass_bearing(2), 0.0, 0.001)
expect_near(compass_dist(2), 100.0, 0.01)
expect_near(compass_bearing(3), 1.5708, 0.001)
expect_near(compass_bearing(0), -1.5708, 0.001)
yaw = 1.5708
expect_near(compass_bearing(3), 0.0, 0.001)
expect_near(compass_bearing(2), -1.5708, 0.001)
vx = -50.0
vz = 100.0
expect_near(compass_dist(3), 100.0, 0.01)
test "a bearing is from the viewer's facing, a distance from where it stands" (compass_st: mut CompassState, compasstest_st: mut CompasstestState) {
fresh(compass_st, compasstest_st)
compass_gather(compass_st)
expect_near(compass_bearing(compass_st, 2), 0.0, 0.001)
expect_near(compass_dist(compass_st, 2), 100.0, 0.01)
expect_near(compass_bearing(compass_st, 3), 1.5708, 0.001)
expect_near(compass_bearing(compass_st, 0), -1.5708, 0.001)
compasstest_st.yaw = 1.5708
expect_near(compass_bearing(compass_st, 3), 0.0, 0.001)
expect_near(compass_bearing(compass_st, 2), -1.5708, 0.001)
compasstest_st.vx = -50.0
compasstest_st.vz = 100.0
expect_near(compass_dist(compass_st, 3), 100.0, 0.01)
expect_near(compass_wrap(7.0), 7.0 - 6.2832, 0.001)
expect_near(compass_strip_t(0.5, 1.0), 0.5, 0.001)
}
test "a capture hears every mark whatever the tier and leaves the frame's list alone" {
fresh()
compass_gather()
tier = 1
compass_capture_begin()
expect(compass_capturing())
goal()
places()
let got = compass_capture_end()
expect(not compass_capturing())
test "a capture hears every mark whatever the tier and leaves the frame's list alone" (compass_st: mut CompassState, compasstest_st: mut CompasstestState) {
fresh(compass_st, compasstest_st)
compass_gather(compass_st)
compasstest_st.tier = 1
compass_capture_begin(compass_st)
expect(compass_capturing(compass_st))
goal(compass_st, compasstest_st)
places(compass_st)
let got = compass_capture_end(compass_st)
expect(not compass_capturing(compass_st))
expect_eq(len(got), 5)
expect(got[0].label == "the dock")
expect_eq(compass_count(), 5)
expect_eq(compass_count(compass_st), 5)
}
test "the radar: its range by tier, the blips in it, and where each falls on the disc" {
fresh()
tier = 2
compass_gather()
expect(not compass_radar_on())
expect(not compass_radar_has(0))
tier = 3
compass_gather()
expect(compass_radar_on())
expect_near(compass_radar_range(), 120.0, 0.01)
expect(compass_radar_has(0))
expect(not compass_radar_has(1))
expect(not compass_radar_has(2))
expect(compass_radar_has(3))
expect_near(compass_radar_x(3), -50.0 / 120.0, 0.001)
expect_near(compass_radar_y(3), 0.0, 0.001)
expect_near(compass_radar_x(0), 80.0 / 120.0, 0.001)
tier = 9
expect_near(compass_radar_range(), 260.0, 0.01)
test "the radar: its range by tier, the blips in it, and where each falls on the disc" (compass_st: mut CompassState, compasstest_st: mut CompasstestState) {
fresh(compass_st, compasstest_st)
compasstest_st.tier = 2
compass_gather(compass_st)
expect(not compass_radar_on(compass_st))
expect(not compass_radar_has(compass_st, 0))
compasstest_st.tier = 3
compass_gather(compass_st)
expect(compass_radar_on(compass_st))
expect_near(compass_radar_range(compass_st), 120.0, 0.01)
expect(compass_radar_has(compass_st, 0))
expect(not compass_radar_has(compass_st, 1))
expect(not compass_radar_has(compass_st, 2))
expect(compass_radar_has(compass_st, 3))
expect_near(compass_radar_x(compass_st, 3), -50.0 / 120.0, 0.001)
expect_near(compass_radar_y(compass_st, 3), 0.0, 0.001)
expect_near(compass_radar_x(compass_st, 0), 80.0 / 120.0, 0.001)
compasstest_st.tier = 9
expect_near(compass_radar_range(compass_st), 260.0, 0.01)
}
test "the eight points go round from the heading 0 toward -x" {