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

feat(base): 0.R4 - a queue keeps its own count, so every package verb takes only its own state; ludic migrate state --prune

Browse source 
ludic.base's Queue<T> carries a QueueTag (its name and pending count): queue_new(name), q_push(q, v),
q_drain(q), q_clear(q) take no BaseState, and core_undrained(tags) names the given queues still holding
facts. A reducer on a package's state can now call that package's verbs (wallet_earn(wallet_st, n)).

ludic migrate state --prune (ludicc --migrate-prune) takes out each state parameter a function no
longer uses, nor anything it calls, and the argument that fills it - including an argument for a
parameter the callee has dropped, which is taken out before the call is checked, so a generic's T is
told by the argument that says it. A reducer keeps its state. --dry-run now counts the edits it would
make. Every package was moved with it: 608 base_st parameters and their arguments, 1889 edits.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Orkun ÇAKILKAYA 2026-09-26 04:19:56 +03:00
parent 8cf4b3fed6
commit 71735b10a2
151 changed files with 58668 additions and 54719 deletions
Download patch file Download diff file Expand all files Collapse all files

72
packages/ludic.tracks/tests/tracks_test.ludic
View file

@ -25,20 +25,20 @@ program TracksTest {
bind TracksWorld { now: fn fake_now, skill: fn fake_skill, bearing: fn fake_bearing, placed: fn fake_placed }
function fresh(base_st: mut BaseState, tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) -> void {
function fresh(tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) -> void {
tracks_test_st.now = 10.0
tracks_test_st.skill = 1
tracks_test_st.placed_n = 0
tracks_test_st.placed_last = -1
tracks_config(tracks_st, 3, 4)
tracks_config_reading(tracks_st, 1, 0.5, 2.5)
tracks_reset(base_st, tracks_st)
tracks_reset(tracks_st)
}
function reads(base_st: mut BaseState, tracks_st: mut TracksState) -> []TrackRead { return q_drain(base_st, tracks_reads(base_st, tracks_st)) }
function reads(tracks_st: mut TracksState) -> []TrackRead { return q_drain(tracks_reads(tracks_st)) }
test "a print goes into its kind's ring and is drawn" (base_st: mut BaseState, tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(base_st, tracks_st, tracks_test_st)
test "a print goes into its kind's ring and is drawn" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(tracks_st, tracks_test_st)
let i = tracks_leave(tracks_st, 1, 5.0, 6.0, 1.0, 7, false)
expect_eq(i, 0)
expect_eq(tracks_count(tracks_st, 1), 1)
@ -49,16 +49,16 @@ program TracksTest {
expect_eq(tracks_sp(tracks_st, s), 7)
}
test "a full ring writes over its oldest print" (base_st: mut BaseState, tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(base_st, tracks_st, tracks_test_st)
test "a full ring writes over its oldest print" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(tracks_st, tracks_test_st)
for n in 0 .. 5 { tracks_leave(tracks_st, 2, float(n), 0.0, 0.0, n, false) }
expect_eq(tracks_count(tracks_st, 2), 4)
expect_eq(tracks_test_st.placed_last, 0)
expect_eq(tracks_sp(tracks_st, tracks_slot(tracks_st, 2, 0)), 4)
}
test "a print ages on the world's clock" (base_st: mut BaseState, tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(base_st, tracks_st, tracks_test_st)
test "a print ages on the world's clock" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(tracks_st, tracks_test_st)
tracks_leave(tracks_st, 1, 0.0, 0.0, 0.0, 1, false)
tracks_test_st.now = 13.0
let s = tracks_slot(tracks_st, 1, 0)
@ -68,21 +68,21 @@ program TracksTest {
expect_eq(tracks_fresh_of(tracks_st, 1.0), TRACK_RECENT)
}
test "the nearest print within reach, or none" (base_st: mut BaseState, tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(base_st, tracks_st, tracks_test_st)
test "the nearest print within reach, or none" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(tracks_st, tracks_test_st)
tracks_leave(tracks_st, 1, 10.0, 0.0, 0.0, 1, false)
tracks_leave(tracks_st, 2, 1.0, 1.0, 0.0, 2, false)
expect_eq(tracks_nearest(tracks_st, 0.0, 0.0, 2.0), tracks_slot(tracks_st, 2, 0))
expect_eq(tracks_nearest(tracks_st, 50.0, 50.0, 2.0), -1)
}
test "a print read twice is two facts and one count" (base_st: mut BaseState, tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(base_st, tracks_st, tracks_test_st)
test "a print read twice is two facts and one count" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(tracks_st, tracks_test_st)
tracks_leave(tracks_st, 1, 0.0, 0.0, 1.0, 3, true)
let s = tracks_nearest(tracks_st, 0.0, 0.0, 2.0)
tracks_read(base_st, tracks_st, s)
tracks_read(base_st, tracks_st, s)
let rs = reads(base_st, tracks_st)
tracks_read(tracks_st, s)
tracks_read(tracks_st, s)
let rs = reads(tracks_st)
expect_eq(len(rs), 2)
expect(rs[0].first and not rs[1].first)
expect_eq(rs[0].source, TRACK_PRINT)
@ -93,51 +93,51 @@ program TracksTest {
expect(tracks_has_bearing(tracks_st) and tracks_last_yaw(tracks_st) == 1.0)
}
test "a reader without the skill cannot name the animal" (base_st: mut BaseState, tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(base_st, tracks_st, tracks_test_st)
test "a reader without the skill cannot name the animal" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(tracks_st, tracks_test_st)
tracks_test_st.skill = 0
tracks_leave(tracks_st, 1, 0.0, 0.0, 0.0, 3, false)
tracks_read(base_st, tracks_st, tracks_slot(tracks_st, 1, 0))
expect(not reads(base_st, tracks_st)[0].named)
tracks_read(tracks_st, tracks_slot(tracks_st, 1, 0))
expect(not reads(tracks_st)[0].named)
}
test "a sign that is not a print is told, and counts when it is the first" (base_st: mut BaseState, tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(base_st, tracks_st, tracks_test_st)
tracks_note(base_st, tracks_st, 4, TRACK_SCAT, false, -1.0, true)
tracks_note(base_st, tracks_st, 4, TRACK_SCAT, false, -1.0, false)
let rs = reads(base_st, tracks_st)
test "a sign that is not a print is told, and counts when it is the first" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(tracks_st, tracks_test_st)
tracks_note(tracks_st, 4, TRACK_SCAT, false, -1.0, true)
tracks_note(tracks_st, 4, TRACK_SCAT, false, -1.0, false)
let rs = reads(tracks_st)
expect_eq(len(rs), 2)
expect_eq(rs[0].source, TRACK_SCAT)
expect_eq(tracks_read_count(tracks_st), 1)
}
test "a written-over slot is a new, unread print" (base_st: mut BaseState, tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(base_st, tracks_st, tracks_test_st)
test "a written-over slot is a new, unread print" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(tracks_st, tracks_test_st)
tracks_leave(tracks_st, 0, 0.0, 0.0, 0.0, 1, false)
tracks_read(base_st, tracks_st, tracks_slot(tracks_st, 0, 0))
tracks_read(tracks_st, tracks_slot(tracks_st, 0, 0))
for n in 0 .. 4 { tracks_leave(tracks_st, 0, 0.0, 0.0, 0.0, 2, false) }
expect(not tracks_was_read(tracks_st, tracks_slot(tracks_st, 0, 0)))
}
test "clearing the ground forgets the prints, not the reader" (base_st: mut BaseState, tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(base_st, tracks_st, tracks_test_st)
test "clearing the ground forgets the prints, not the reader" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(tracks_st, tracks_test_st)
tracks_leave(tracks_st, 1, 0.0, 0.0, 0.0, 1, false)
tracks_read(base_st, tracks_st, tracks_slot(tracks_st, 1, 0))
tracks_read(tracks_st, tracks_slot(tracks_st, 1, 0))
tracks_clear(tracks_st)
expect_eq(tracks_count(tracks_st, 1), 0)
expect_eq(tracks_read_count(tracks_st), 1)
}
test "a save section reads back the same reader" (base_st: mut BaseState, tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(base_st, tracks_st, tracks_test_st)
tracks_note(base_st, tracks_st, 1, TRACK_SIGN, true, 0.0, true)
test "a save section reads back the same reader" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
fresh(tracks_st, tracks_test_st)
tracks_note(tracks_st, 1, TRACK_SIGN, true, 0.0, true)
tracks_note_bearing(tracks_st, 2.5)
let root = save_tree()
save_section(root, "tracks", 1, tracks_save(tracks_st))
let text = save_encode(root)
tracks_reset(base_st, tracks_st)
tracks_reset(tracks_st)
let n = load_section(save_decode(text), "tracks")
tracks_load(base_st, tracks_st, n.data, n.version)
tracks_load(tracks_st, n.data, n.version)
expect_eq(tracks_read_count(tracks_st), 1)
expect(tracks_has_bearing(tracks_st) and tracks_last_yaw(tracks_st) == 2.5)
}