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

4
packages/ludic.fire/decide.ludic
View file

@ -18,12 +18,12 @@ export function fire_cost(fire_st: FireState, how: int) -> int {
return 0
}
export function fire_apply(base_st: mut BaseState, fire_st: mut FireState, how: int) -> void {
export function fire_apply(fire_st: mut FireState, how: int) -> void {
if how == FIRE_FEED { fire_st.fr_fuel = fire_st.fr_fuel + fire_st.fr_log_minutes }
if how == FIRE_LIGHT {
fire_st.fr_lit = true
fire_st.fr_fuel = fire_st.fr_light_minutes
fr_fact(base_st, fire_st, FIRE_LIT)
fr_fact(fire_st, FIRE_LIT)
}
}

8
packages/ludic.fire/state.ludic
View file

@ -43,16 +43,16 @@ export property FireFact {
# the facts, oldest first; the game drains them into its notices
export function fire_facts(base_st: mut BaseState, fire_st: mut FireState) -> Queue<FireFact> {
if fire_st.fr_facts == null { fire_st.fr_facts = queue_new(base_st, "fire.facts") }
export function fire_facts(fire_st: mut FireState) -> Queue<FireFact> {
if fire_st.fr_facts == null { fire_st.fr_facts = queue_new("fire.facts") }
return fire_st.fr_facts
}
function fr_fact(base_st: mut BaseState, fire_st: mut FireState, what: int) -> void {
function fr_fact(fire_st: mut FireState, what: int) -> void {
let f = new FireFact
f.what = what
f.fuel = fire_st.fr_fuel
q_push(base_st, fire_facts(base_st, fire_st), f)
q_push(fire_facts(fire_st), f)
}
# a game's numbers: logs to light, minutes a new fire and a log are worth, when it is low

6
packages/ludic.fire/system.ludic
View file

@ -1,5 +1,5 @@
# system.ludic - the fire as a system: PH_SIMULATE, and its own save section
function fire_tick(base_st: mut BaseState, fire_st: mut FireState, t: Tick) -> void { fire_run(base_st, fire_st, t.hours) }
function fire_tick(fire_st: mut FireState, t: Tick) -> void { fire_run(fire_st, t.hours) }
export function fire_save(fire_st: FireState) -> Val {
let v = Value.object()
@ -9,8 +9,8 @@ export function fire_save(fire_st: FireState) -> Val {
return v
}
export function fire_load(base_st: mut BaseState, fire_st: mut FireState, v: Val, version: int) -> void {
fire_reset(base_st, fire_st)
export function fire_load(fire_st: mut FireState, v: Val, version: int) -> void {
fire_reset(fire_st)
fire_st.fr_lit = sv_bool(v, "lit", false)
fire_st.fr_fuel = sv_float(v, "fuel", 0.0)
fire_st.fr_rain_h = sv_float(v, "rain_h", 0.0)

94
packages/ludic.fire/tests/fire_test.ludic
View file

@ -23,44 +23,44 @@ program FireTest {
allowed: fn fake_allowed
}
function fresh(base_st: mut BaseState, fire_st: mut FireState) -> void {
function fresh(fire_st: mut FireState) -> void {
fire_config(fire_st, 3, 120.0, 60.0, 15.0)
fire_config_reach(fire_st, 3.6, 3.5)
fire_reset(base_st, fire_st)
fire_reset(fire_st)
}
function facts(base_st: mut BaseState, fire_st: mut FireState) -> []FireFact { return q_drain(base_st, fire_facts(base_st, fire_st)) }
function facts(fire_st: mut FireState) -> []FireFact { return q_drain(fire_facts(fire_st)) }
function count(fs: []FireFact, what: int) -> int {
var n = 0
for i in 0 .. len(fs) { if fs[i].what == what { n += 1 } }
return n
}
function light(base_st: mut BaseState, fire_st: mut FireState) -> void { fire_apply(base_st, fire_st, fire_decide(fire_st, 3)) }
function light(fire_st: mut FireState) -> void { fire_apply(fire_st, fire_decide(fire_st, 3)) }
test "three logs light it, and that is a fact" (base_st: mut BaseState, fire_st: mut FireState) {
fresh(base_st, fire_st)
test "three logs light it, and that is a fact" (fire_st: mut FireState) {
fresh(fire_st)
expect_eq(fire_decide(fire_st, 2), FIRE_NO_WOOD)
expect_eq(fire_decide(fire_st, 3), FIRE_LIGHT)
expect_eq(fire_cost(fire_st, FIRE_LIGHT), 3)
light(base_st, fire_st)
light(fire_st)
expect(fire_lit(fire_st))
expect(fire_fuel(fire_st) == 120.0)
expect_eq(count(facts(base_st, fire_st), FIRE_LIT), 1)
expect_eq(count(facts(fire_st), FIRE_LIT), 1)
}
test "a lit fire takes a log for an hour" (base_st: mut BaseState, fire_st: mut FireState) {
fresh(base_st, fire_st)
light(base_st, fire_st)
test "a lit fire takes a log for an hour" (fire_st: mut FireState) {
fresh(fire_st)
light(fire_st)
expect_eq(fire_decide(fire_st, 0), FIRE_NO_LOG)
expect_eq(fire_decide(fire_st, 1), FIRE_FEED)
expect_eq(fire_cost(fire_st, FIRE_FEED), 1)
fire_apply(base_st, fire_st, FIRE_FEED)
fire_apply(fire_st, FIRE_FEED)
expect(fire_fuel(fire_st) == 180.0)
}
test "a ban and a soaked ring refuse, a tarp keeps it dry" (base_st: mut BaseState, fire_st: mut FireState, fire_test_st: mut FireTestState) {
fresh(base_st, fire_st)
test "a ban and a soaked ring refuse, a tarp keeps it dry" (fire_st: mut FireState, fire_test_st: mut FireTestState) {
fresh(fire_st)
fire_test_st.ban = true
expect_eq(fire_decide(fire_st, 5), FIRE_BANNED)
fire_test_st.ban = false
@ -71,55 +71,55 @@ program FireTest {
expect_eq(fire_decide(fire_st, 5), FIRE_LIGHT)
}
test "it burns a minute a minute, runs low, and goes out as facts" (base_st: mut BaseState, fire_st: mut FireState) {
fresh(base_st, fire_st)
light(base_st, fire_st)
facts(base_st, fire_st)
fire_run(base_st, fire_st, 1.5)
test "it burns a minute a minute, runs low, and goes out as facts" (fire_st: mut FireState) {
fresh(fire_st)
light(fire_st)
facts(fire_st)
fire_run(fire_st, 1.5)
expect(fire_fuel(fire_st) == 30.0)
expect(not fire_low(fire_st))
fire_run(base_st, fire_st, 0.3)
fire_run(fire_st, 0.3)
expect(fire_low(fire_st))
expect_eq(count(facts(base_st, fire_st), FIRE_LOW_FUEL), 1)
fire_run(base_st, fire_st, 0.5)
expect_eq(count(facts(fire_st), FIRE_LOW_FUEL), 1)
fire_run(fire_st, 0.5)
expect(not fire_lit(fire_st))
expect(fire_fuel(fire_st) == 0.0)
expect_eq(count(facts(base_st, fire_st), FIRE_WENT_OUT), 1)
expect_eq(count(facts(fire_st), FIRE_WENT_OUT), 1)
}
test "the rain burns it twice as fast, and under a tarp it counts the hours" (base_st: mut BaseState, fire_st: mut FireState, fire_test_st: mut FireTestState) {
fresh(base_st, fire_st)
light(base_st, fire_st)
test "the rain burns it twice as fast, and under a tarp it counts the hours" (fire_st: mut FireState, fire_test_st: mut FireTestState) {
fresh(fire_st)
light(fire_st)
fire_test_st.wet = true
fire_run(base_st, fire_st, 0.5)
fire_run(fire_st, 0.5)
expect(fire_fuel(fire_st) == 60.0)
fire_test_st.tarp = true
fire_run(base_st, fire_st, 0.5)
fire_run(fire_st, 0.5)
expect(fire_fuel(fire_st) == 30.0)
expect(fire_rain_hours(fire_st) == 0.5)
fire_morning(fire_st)
expect(fire_rain_hours(fire_st) == 0.0)
}
test "a machine that does not own the world burns nothing, but is told" (base_st: mut BaseState, fire_st: mut FireState, fire_test_st: mut FireTestState) {
fresh(base_st, fire_st)
light(base_st, fire_st)
test "a machine that does not own the world burns nothing, but is told" (fire_st: mut FireState, fire_test_st: mut FireTestState) {
fresh(fire_st)
light(fire_st)
fire_test_st.owns = false
fire_run(base_st, fire_st, 5.0)
fire_run(fire_st, 5.0)
expect(fire_fuel(fire_st) == 120.0)
facts(base_st, fire_st)
fire_told(base_st, fire_st, false, 0.0, true)
facts(fire_st)
fire_told(fire_st, false, 0.0, true)
expect(not fire_lit(fire_st))
expect_eq(count(facts(base_st, fire_st), FIRE_WENT_OUT), 1)
fire_told(base_st, fire_st, true, 50.0, true)
fire_told(base_st, fire_st, false, 0.0, false)
expect_eq(q_len(fire_facts(base_st, fire_st)), 0)
expect_eq(count(facts(fire_st), FIRE_WENT_OUT), 1)
fire_told(fire_st, true, 50.0, true)
fire_told(fire_st, false, 0.0, false)
expect_eq(q_len(fire_facts(fire_st)), 0)
}
test "it warms and cooks close, and only while lit" (base_st: mut BaseState, fire_st: mut FireState) {
fresh(base_st, fire_st)
test "it warms and cooks close, and only while lit" (fire_st: mut FireState) {
fresh(fire_st)
expect(not fire_warms(fire_st, 1.0))
light(base_st, fire_st)
light(fire_st)
expect(fire_warms(fire_st, 3.5))
expect(not fire_warms(fire_st, 3.7))
expect(fire_cooks(fire_st, 3.4))
@ -128,18 +128,18 @@ program FireTest {
expect(not fire_cooks(fire_st, 0.0))
}
test "a save section reads back the same fire" (base_st: mut BaseState, fire_st: mut FireState, fire_test_st: mut FireTestState) {
fresh(base_st, fire_st)
light(base_st, fire_st)
test "a save section reads back the same fire" (fire_st: mut FireState, fire_test_st: mut FireTestState) {
fresh(fire_st)
light(fire_st)
fire_test_st.wet = true
fire_test_st.tarp = true
fire_run(base_st, fire_st, 0.25)
fire_run(fire_st, 0.25)
let root = save_tree()
save_section(root, "fire", 1, fire_save(fire_st))
let text = save_encode(root)
fire_reset(base_st, fire_st)
fire_reset(fire_st)
let n = load_section(save_decode(text), "fire")
fire_load(base_st, fire_st, n.data, n.version)
fire_load(fire_st, n.data, n.version)
expect(fire_lit(fire_st))
expect(fire_fuel(fire_st) == 105.0)
expect(fire_rain_hours(fire_st) == 0.25)

18
packages/ludic.fire/verbs.ludic
View file

@ -1,13 +1,13 @@
# verbs.ludic - the fire burning down, and the only other ways it changes
function fr_out(base_st: mut BaseState, fire_st: mut FireState) -> void {
function fr_out(fire_st: mut FireState) -> void {
fire_st.fr_lit = false
fire_st.fr_fuel = 0.0
fr_fact(base_st, fire_st, FIRE_WENT_OUT)
fr_fact(fire_st, FIRE_WENT_OUT)
}
# `gh` game hours of burning; in the rain it burns twice as fast with nothing over the ring,
# and under cover it counts the hours it held. Only the machine that owns the world burns it.
export function fire_run(base_st: mut BaseState, fire_st: mut FireState, gh: float) -> void {
export function fire_run(fire_st: mut FireState, gh: float) -> void {
if not fire_st.fr_lit or not FireWorld.owns_world() { return }
let was = fire_st.fr_fuel
fire_st.fr_fuel = fire_st.fr_fuel - gh * 60.0
@ -15,10 +15,10 @@ export function fire_run(base_st: mut BaseState, fire_st: mut FireState, gh: flo
if FireWorld.sheltered() { fire_st.fr_rain_h = fire_st.fr_rain_h + gh } else { fire_st.fr_fuel = fire_st.fr_fuel - gh * 60.0 }
}
if fire_st.fr_fuel < 0.0 {
fr_out(base_st, fire_st)
fr_out(fire_st)
return
}
if was >= fire_st.fr_low_minutes and fire_st.fr_fuel < fire_st.fr_low_minutes { fr_fact(base_st, fire_st, FIRE_LOW_FUEL) }
if was >= fire_st.fr_low_minutes and fire_st.fr_fuel < fire_st.fr_low_minutes { fr_fact(fire_st, FIRE_LOW_FUEL) }
}
# put out, and nothing said (the night burns it down)
@ -34,11 +34,11 @@ export function fire_set_burning(fire_st: mut FireState, fuel: float) -> void {
}
# what the machine that owns the world says the fire is; going out is a fact when `say`
export function fire_told(base_st: mut BaseState, fire_st: mut FireState, lit: bool, fuel: float, say: bool) -> void {
export function fire_told(fire_st: mut FireState, lit: bool, fuel: float, say: bool) -> void {
let was = fire_st.fr_lit
fire_st.fr_lit = lit
fire_st.fr_fuel = fuel
if was and not lit and say { fr_fact(base_st, fire_st, FIRE_WENT_OUT) }
if was and not lit and say { fr_fact(fire_st, FIRE_WENT_OUT) }
}
# the rain hours outright (staging, a test)
@ -47,9 +47,9 @@ export function fire_set_rain_hours(fire_st: mut FireState, h: float) -> void {
# a new day: the rain hours start again
export function fire_morning(fire_st: mut FireState) -> void { fire_st.fr_rain_h = 0.0 }
export function fire_reset(base_st: mut BaseState, fire_st: mut FireState) -> void {
export function fire_reset(fire_st: mut FireState) -> void {
fire_st.fr_lit = false
fire_st.fr_fuel = 0.0
fire_st.fr_rain_h = 0.0
q_clear(base_st, fire_facts(base_st, fire_st))
q_clear(fire_facts(fire_st))
}