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

70
packages/ludic.things/tests/things_test.ludic
View file

@ -44,28 +44,28 @@ program ThingsTest {
function on_restored(things_test_st: mut ThingsTestState, t: Thing) -> void { things_test_st.back += 1 }
bind ThingsWorld { ground: fn hill, placed: fn on_placed, removed: fn on_removed, shown: fn on_shown, restored: fn on_restored }
function put(base_st: mut BaseState, things_st: mut ThingsState, kind: int, x: float, z: float) -> Thing { return thing_spawn(base_st, things_st, kind, "m", x, 0.0, z, 0.0, 0) }
function facts(base_st: mut BaseState, things_st: mut ThingsState) -> []ThingFact { return q_drain(base_st, things_facts(base_st, things_st)) }
function put(things_st: mut ThingsState, kind: int, x: float, z: float) -> Thing { return thing_spawn(things_st, kind, "m", x, 0.0, z, 0.0, 0) }
function facts(things_st: mut ThingsState) -> []ThingFact { return q_drain(things_facts(things_st)) }
test "a spawn is drawn, numbered and said" (base_st: mut BaseState, things_st: mut ThingsState, things_test_st: ThingsTestState) {
test "a spawn is drawn, numbered and said" (things_st: mut ThingsState, things_test_st: ThingsTestState) {
things_clear(things_st)
let a = put(base_st, things_st, TH_TENT, 1.0, 1.0)
let b = put(base_st, things_st, TH_FIRE, 2.0, 2.0)
let a = put(things_st, TH_TENT, 1.0, 1.0)
let b = put(things_st, TH_FIRE, 2.0, 2.0)
expect_eq(things_test_st.drawn, 2)
expect(a.uid != b.uid)
expect_eq(things_count(things_st), 2)
let fs = facts(base_st, things_st)
let fs = facts(things_st)
expect_eq(len(fs), 2)
expect_eq(fs[1].what, THING_PLACED)
expect_eq(fs[1].kind, TH_FIRE)
expect(thing_by_uid(things_st, b.uid) == b)
}
test "the spatial questions see only what is active" (base_st: mut BaseState, things_st: mut ThingsState, things_test_st: ThingsTestState) {
test "the spatial questions see only what is active" (things_st: mut ThingsState, things_test_st: ThingsTestState) {
things_clear(things_st)
let near = put(base_st, things_st, TH_BRANCH, 1.0, 0.0)
let far = put(base_st, things_st, TH_BRANCH, 5.0, 0.0)
put(base_st, things_st, TH_FIRE, 3.0, 0.0)
let near = put(things_st, TH_BRANCH, 1.0, 0.0)
let far = put(things_st, TH_BRANCH, 5.0, 0.0)
put(things_st, TH_FIRE, 3.0, 0.0)
expect(thing_nearest(things_st, TH_BRANCH, 0.0, 0.0) == near)
expect(thing_nearest(things_st, -1, 3.2, 0.0).kind == TH_FIRE)
expect_eq(len(things_within(things_st, 0.0, 0.0, 3.5)), 2)
@ -79,51 +79,51 @@ program ThingsTest {
expect_eq(things_test_st.shows, 1)
}
test "remove and move tell the port" (base_st: mut BaseState, things_st: mut ThingsState, things_test_st: ThingsTestState) {
test "remove and move tell the port" (things_st: mut ThingsState, things_test_st: ThingsTestState) {
things_clear(things_st)
let a = put(base_st, things_st, TH_TENT, 1.0, 1.0)
put(base_st, things_st, TH_TENT, 2.0, 2.0)
facts(base_st, things_st)
thing_remove(base_st, things_st, a)
let a = put(things_st, TH_TENT, 1.0, 1.0)
put(things_st, TH_TENT, 2.0, 2.0)
facts(things_st)
thing_remove(things_st, a)
expect_eq(things_test_st.gone, 1)
expect_eq(things_count(things_st), 1)
expect_eq(facts(base_st, things_st)[0].what, THING_REMOVED)
expect_eq(facts(things_st)[0].what, THING_REMOVED)
let b = thing_find(things_st, TH_TENT, -1)
thing_move(b, 4.0, 0.0, 1.0)
expect_near(b.y, 2.0, 0.001)
let c = thing_put(base_st, things_st, TH_BRANCH, "stick", 2.0, 0.0, 0.0, 0.25, 1.9, 7)
let c = thing_put(things_st, TH_BRANCH, "stick", 2.0, 0.0, 0.0, 0.25, 1.9, 7)
expect_near(c.y, 0.75, 0.001)
expect_near(thing_reach(c), 1.9, 0.001)
expect_eq(c.id, 7)
}
test "the kind answers: name, prompt, use, reach" (base_st: mut BaseState, things_st: mut ThingsState) {
test "the kind answers: name, prompt, use, reach" (things_st: mut ThingsState) {
things_clear(things_st)
let t = put(base_st, things_st, TH_TENT, 0.0, 0.0)
let t = put(things_st, TH_TENT, 0.0, 0.0)
expect(thing_name(t) == "A tent")
t.owner = 0
expect(thing_name(t) == "Your tent")
let f = put(base_st, things_st, TH_FIRE, 0.0, 0.0)
let f = put(things_st, TH_FIRE, 0.0, 0.0)
expect(thing_prompt(f) == "Light it")
thing_use(base_st, things_st, f)
thing_use(things_st, f)
expect(thing_prompt(f) == "Add wood")
expect(thing_prompt(t) == "")
expect(not thing_can_use(t))
expect_near(thing_reach(f), 2.2, 0.001)
expect_near(thing_reach(put(base_st, things_st, TH_BRANCH, 0.0, 0.0)), 1.5, 0.001)
expect_near(thing_reach(put(base_st, things_st, TH_SIGN, 0.0, 0.0)), 9.0, 0.001)
let fs = facts(base_st, things_st)
expect_near(thing_reach(put(things_st, TH_BRANCH, 0.0, 0.0)), 1.5, 0.001)
expect_near(thing_reach(put(things_st, TH_SIGN, 0.0, 0.0)), 9.0, 0.001)
let fs = facts(things_st)
expect_eq(fs[len(fs) - 3].what, THING_USED)
}
test "ticks and a restock" (base_st: mut BaseState, things_st: mut ThingsState, things_test_st: ThingsTestState) {
test "ticks and a restock" (things_st: mut ThingsState, things_test_st: ThingsTestState) {
things_clear(things_st)
let l = put(base_st, things_st, TH_LURE, 0.0, 0.0)
let l = put(things_st, TH_LURE, 0.0, 0.0)
l.timer = 1.0
let b = put(base_st, things_st, TH_BRANCH, 0.0, 0.0)
let f = put(base_st, things_st, TH_FIRE, 0.0, 0.0)
thing_use(base_st, things_st, b)
thing_use(base_st, things_st, f)
let b = put(things_st, TH_BRANCH, 0.0, 0.0)
let f = put(things_st, TH_FIRE, 0.0, 0.0)
thing_use(things_st, b)
thing_use(things_st, f)
expect_eq(things_test_st.wood, 1)
things_tick(things_st, 0.6)
expect(l.active)
@ -135,19 +135,19 @@ program ThingsTest {
expect_eq(f.used, 1)
}
test "the save keeps what the port keeps, by the kind's key" (base_st: mut BaseState, things_st: mut ThingsState, things_test_st: ThingsTestState) {
test "the save keeps what the port keeps, by the kind's key" (things_st: mut ThingsState, things_test_st: ThingsTestState) {
things_clear(things_st)
let l = put(base_st, things_st, TH_LURE, 3.0, 4.0)
let l = put(things_st, TH_LURE, 3.0, 4.0)
l.owner = 0
l.timer = 2.5
put(base_st, things_st, TH_TENT, 0.0, 0.0)
put(things_st, TH_TENT, 0.0, 0.0)
let root = save_tree()
save_section(root, "things", 1, things_save(things_st))
let text = save_encode(root)
things_clear(things_st)
put(base_st, things_st, TH_LURE, 9.0, 9.0)
put(things_st, TH_LURE, 9.0, 9.0)
let n = load_section(save_decode(text), "things")
things_load(base_st, things_st, n.data, n.version)
things_load(things_st, n.data, n.version)
expect_eq(things_count(things_st), 1)
let t = thing_find(things_st, TH_LURE, -1)
expect_near(t.x, 3.0, 0.001)