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.effects/state.ludic
View file

@ -33,8 +33,8 @@ function ef_all(effects_st: mut EffectsState) -> []Effect {
}
# the facts: what ended and why, oldest first; the game drains it
export function effects_ended(base_st: mut BaseState, effects_st: mut EffectsState) -> Queue<EffectEnded> {
if effects_st.ef_ended == null { effects_st.ef_ended = queue_new(base_st, "effects.ended") }
export function effects_ended(effects_st: mut EffectsState) -> Queue<EffectEnded> {
if effects_st.ef_ended == null { effects_st.ef_ended = queue_new("effects.ended") }
return effects_st.ef_ended
}

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

@ -1,10 +1,10 @@
# system.ludic - the effects as a system: reset, a tick in game hours, and its own save section
export function effects_reset(base_st: mut BaseState, effects_st: mut EffectsState) -> void {
export function effects_reset(effects_st: mut EffectsState) -> void {
effects_clear(effects_st)
q_clear(base_st, effects_ended(base_st, effects_st))
q_clear(effects_ended(effects_st))
}
function effects_tick(base_st: mut BaseState, effects_st: mut EffectsState, t: Tick) -> void { effects_run(base_st, effects_st, t.hours * 60.0) }
function effects_tick(effects_st: mut EffectsState, t: Tick) -> void { effects_run(effects_st, t.hours * 60.0) }
export function effects_save(effects_st: mut EffectsState) -> Val {
let l = Value.list()

92
packages/ludic.effects/tests/effects_test.ludic
View file

@ -8,24 +8,24 @@ program EffectsTest {
const WARMTH: int = 1
const CARRY: int = 2
function fresh(base_st: mut BaseState, effects_st: mut EffectsState) -> void {
function fresh(effects_st: mut EffectsState) -> void {
effects_config(effects_st, 8, 3)
effects_reset(base_st, effects_st)
effects_reset(effects_st)
}
function ended(base_st: mut BaseState, effects_st: mut EffectsState) -> []EffectEnded { return q_drain(base_st, effects_ended(base_st, effects_st)) }
function waiting(base_st: mut BaseState, effects_st: mut EffectsState) -> int { return q_len(effects_ended(base_st, effects_st)) }
function ended(effects_st: mut EffectsState) -> []EffectEnded { return q_drain(effects_ended(effects_st)) }
function waiting(effects_st: mut EffectsState) -> int { return q_len(effects_ended(effects_st)) }
function tick_minutes(m: float) -> void {
let s = effects_system()
s.tick(tick_new(0.016, 0, m / 60.0))
}
test "the sum is per kind, and a kind with nothing running is zero" (base_st: mut BaseState, effects_st: mut EffectsState) {
fresh(base_st, effects_st)
effects_add(base_st, effects_st, LEGS, 8.0, 20.0, false, "Fizz")
effects_add(base_st, effects_st, LEGS, 6.0, 45.0, false, "Trail mix")
effects_add(base_st, effects_st, WARMTH, 12.0, 50.0, false, "Stew")
test "the sum is per kind, and a kind with nothing running is zero" (effects_st: mut EffectsState) {
fresh(effects_st)
effects_add(effects_st, LEGS, 8.0, 20.0, false, "Fizz")
effects_add(effects_st, LEGS, 6.0, 45.0, false, "Trail mix")
effects_add(effects_st, WARMTH, 12.0, 50.0, false, "Stew")
expect(effects_sum(effects_st, LEGS) == 14.0)
expect(effects_sum(effects_st, WARMTH) == 12.0)
expect(effects_sum(effects_st, CARRY) == 0.0)
@ -33,42 +33,42 @@ program EffectsTest {
expect(not effects_has(effects_st, CARRY))
}
test "the same kind from the same label replaces itself rather than stacking" (base_st: mut BaseState, effects_st: mut EffectsState) {
fresh(base_st, effects_st)
effects_add(base_st, effects_st, LEGS, 8.0, 20.0, false, "Fizz")
effects_add(base_st, effects_st, LEGS, 8.0, 20.0, false, "Fizz")
test "the same kind from the same label replaces itself rather than stacking" (effects_st: mut EffectsState) {
fresh(effects_st)
effects_add(effects_st, LEGS, 8.0, 20.0, false, "Fizz")
effects_add(effects_st, LEGS, 8.0, 20.0, false, "Fizz")
expect_eq(effects_count(effects_st), 1)
expect(effects_sum(effects_st, LEGS) == 8.0)
}
test "a fourth bonus pushes the oldest out and says so" (base_st: mut BaseState, effects_st: mut EffectsState) {
fresh(base_st, effects_st)
effects_add(base_st, effects_st, LEGS, 1.0, 10.0, true, "a")
effects_add(base_st, effects_st, LEGS, 1.0, 30.0, true, "b")
effects_add(base_st, effects_st, WARMTH, 1.0, 40.0, true, "c")
effects_add(base_st, effects_st, CARRY, 1.0, 50.0, true, "d")
test "a fourth bonus pushes the oldest out and says so" (effects_st: mut EffectsState) {
fresh(effects_st)
effects_add(effects_st, LEGS, 1.0, 10.0, true, "a")
effects_add(effects_st, LEGS, 1.0, 30.0, true, "b")
effects_add(effects_st, WARMTH, 1.0, 40.0, true, "c")
effects_add(effects_st, CARRY, 1.0, 50.0, true, "d")
expect_eq(effects_bonus_count(effects_st), 3)
let gone = ended(base_st, effects_st)
let gone = ended(effects_st)
expect_eq(len(gone), 1)
expect(gone[0].label == "a")
expect_eq(gone[0].why, EFFECT_PUSHED_OUT)
}
test "a full ring drops the one nearest its end" (base_st: mut BaseState, effects_st: mut EffectsState) {
fresh(base_st, effects_st)
test "a full ring drops the one nearest its end" (effects_st: mut EffectsState) {
fresh(effects_st)
effects_config(effects_st, 2, 3)
effects_add(base_st, effects_st, LEGS, 1.0, 10.0, false, "short")
effects_add(base_st, effects_st, WARMTH, 1.0, 90.0, false, "long")
effects_add(base_st, effects_st, CARRY, 1.0, 50.0, false, "new")
effects_add(effects_st, LEGS, 1.0, 10.0, false, "short")
effects_add(effects_st, WARMTH, 1.0, 90.0, false, "long")
effects_add(effects_st, CARRY, 1.0, 50.0, false, "new")
expect_eq(effects_count(effects_st), 2)
expect(not effects_has(effects_st, LEGS))
expect_eq(ended(base_st, effects_st)[0].why, EFFECT_CROWDED_OUT)
expect_eq(ended(effects_st)[0].why, EFFECT_CROWDED_OUT)
}
test "a delayed one counts only once it has begun" (base_st: mut BaseState, effects_st: mut EffectsState) {
fresh(base_st, effects_st)
effects_add(base_st, effects_st, LEGS, 8.0, 20.0, false, "Fizz")
effects_add_after(base_st, effects_st, 20.0, LEGS, -5.0, 15.0, false, "Sugar crash")
test "a delayed one counts only once it has begun" (effects_st: mut EffectsState) {
fresh(effects_st)
effects_add(effects_st, LEGS, 8.0, 20.0, false, "Fizz")
effects_add_after(effects_st, 20.0, LEGS, -5.0, 15.0, false, "Sugar crash")
expect(effects_sum(effects_st, LEGS) == 8.0)
expect_eq(len(effects_live(effects_st)), 1)
tick_minutes(25.0)
@ -77,30 +77,30 @@ program EffectsTest {
expect_eq(effects_count(effects_st), 0)
}
test "running down in game hours reports each ending" (base_st: mut BaseState, effects_st: mut EffectsState) {
fresh(base_st, effects_st)
effects_add(base_st, effects_st, WARMTH, -10.0, 10.0, false, "Wet through")
test "running down in game hours reports each ending" (effects_st: mut EffectsState) {
fresh(effects_st)
effects_add(effects_st, WARMTH, -10.0, 10.0, false, "Wet through")
tick_minutes(5.0)
expect_eq(waiting(base_st, effects_st), 0)
expect_eq(waiting(effects_st), 0)
tick_minutes(6.0)
expect_eq(effects_count(effects_st), 0)
let gone = ended(base_st, effects_st)
let gone = ended(effects_st)
expect_eq(gone[0].why, EFFECT_RAN_OUT)
expect(gone[0].label == "Wet through")
}
test "clear stops everything and says nothing" (base_st: mut BaseState, effects_st: mut EffectsState) {
fresh(base_st, effects_st)
effects_add(base_st, effects_st, LEGS, 1.0, 10.0, false, "a")
test "clear stops everything and says nothing" (effects_st: mut EffectsState) {
fresh(effects_st)
effects_add(effects_st, LEGS, 1.0, 10.0, false, "a")
effects_clear(effects_st)
expect_eq(effects_count(effects_st), 0)
expect_eq(waiting(base_st, effects_st), 0)
expect_eq(waiting(effects_st), 0)
}
test "a save section reads back the same ring" (base_st: mut BaseState, effects_st: mut EffectsState) {
fresh(base_st, effects_st)
effects_add(base_st, effects_st, LEGS, 8.5, 20.0, true, "Fizz")
effects_add_after(base_st, effects_st, 20.0, LEGS, -5.0, 15.0, false, "Sugar crash")
test "a save section reads back the same ring" (effects_st: mut EffectsState) {
fresh(effects_st)
effects_add(effects_st, LEGS, 8.5, 20.0, true, "Fizz")
effects_add_after(effects_st, 20.0, LEGS, -5.0, 15.0, false, "Sugar crash")
let root = save_tree()
save_section(root, "effects", 1, effects_save(effects_st))
let text = save_encode(root)
@ -117,9 +117,9 @@ program EffectsTest {
expect(b.label == "Sugar crash")
}
test "the copy a reader gets does not change the ring" (base_st: mut BaseState, effects_st: mut EffectsState) {
fresh(base_st, effects_st)
effects_add(base_st, effects_st, LEGS, 3.0, 10.0, false, "a")
test "the copy a reader gets does not change the ring" (effects_st: mut EffectsState) {
fresh(effects_st)
effects_add(effects_st, LEGS, 3.0, 10.0, false, "a")
let e = effects_at(effects_st, 0)
e.mag = 100.0
expect(effects_sum(effects_st, LEGS) == 3.0)

22
packages/ludic.effects/verbs.ludic
View file

@ -1,13 +1,13 @@
# verbs.ludic - the only way the ring changes. The same kind from the same label replaces
# itself; a bonus past the cap pushes out the oldest bonus; a full ring drops the nearest end.
function ef_end(base_st: mut BaseState, effects_st: mut EffectsState, i: int, why: int) -> void {
function ef_end(effects_st: mut EffectsState, i: int, why: int) -> void {
let all = ef_all(effects_st)
let e = new EffectEnded
e.kind = all[i].kind
e.label = all[i].label
e.why = why
e.bonus = all[i].bonus
q_push(base_st, effects_ended(base_st, effects_st), e)
q_push(effects_ended(effects_st), e)
ef_drop(effects_st, i)
}
@ -29,15 +29,15 @@ function ef_nearest_end(effects_st: mut EffectsState, bonus_only: bool) -> int {
return at
}
function ef_make_room(base_st: mut BaseState, effects_st: mut EffectsState, bonus: bool) -> void {
function ef_make_room(effects_st: mut EffectsState, bonus: bool) -> void {
if bonus {
while effects_bonus_count(effects_st) >= effects_st.ef_bonus_max and ef_nearest_end(effects_st, true) >= 0 { ef_end(base_st, effects_st, ef_nearest_end(effects_st, true), EFFECT_PUSHED_OUT) }
while effects_bonus_count(effects_st) >= effects_st.ef_bonus_max and ef_nearest_end(effects_st, true) >= 0 { ef_end(effects_st, ef_nearest_end(effects_st, true), EFFECT_PUSHED_OUT) }
}
if len(ef_all(effects_st)) >= effects_st.ef_max and ef_nearest_end(effects_st, false) >= 0 { ef_end(base_st, effects_st, ef_nearest_end(effects_st, false), EFFECT_CROWDED_OUT) }
if len(ef_all(effects_st)) >= effects_st.ef_max and ef_nearest_end(effects_st, false) >= 0 { ef_end(effects_st, ef_nearest_end(effects_st, false), EFFECT_CROWDED_OUT) }
}
# begin one `after` game minutes from now, lasting `minutes` once it has begun
export function effects_add_after(base_st: mut BaseState, effects_st: mut EffectsState, after: float, kind: int, mag: float, minutes: float, bonus: bool, label: string) -> void {
export function effects_add_after(effects_st: mut EffectsState, after: float, kind: int, mag: float, minutes: float, bonus: bool, label: string) -> void {
let all = ef_all(effects_st)
for i in 0 .. len(all) {
if all[i].kind == kind and all[i].label == label {
@ -46,7 +46,7 @@ export function effects_add_after(base_st: mut BaseState, effects_st: mut Effect
return
}
}
ef_make_room(base_st, effects_st, bonus)
ef_make_room(effects_st, bonus)
let e = new Effect
e.kind = kind
e.mag = mag
@ -57,15 +57,15 @@ export function effects_add_after(base_st: mut BaseState, effects_st: mut Effect
push(ef_all(effects_st), e)
}
export function effects_add(base_st: mut BaseState, effects_st: mut EffectsState, kind: int, mag: float, minutes: float, bonus: bool, label: string) -> void {
effects_add_after(base_st, effects_st, 0.0, kind, mag, minutes, bonus, label)
export function effects_add(effects_st: mut EffectsState, kind: int, mag: float, minutes: float, bonus: bool, label: string) -> void {
effects_add_after(effects_st, 0.0, kind, mag, minutes, bonus, label)
}
# everything stops at once, and says nothing: a new trip or a night's sleep
export function effects_clear(effects_st: mut EffectsState) -> void { effects_st.ef_list = new []Effect }
# run them down by `minutes` of game time; a delayed one waits first
export function effects_run(base_st: mut BaseState, effects_st: mut EffectsState, minutes: float) -> void {
export function effects_run(effects_st: mut EffectsState, minutes: float) -> void {
var i = 0
while i < len(ef_all(effects_st)) {
let e = ef_all(effects_st)[i]
@ -75,6 +75,6 @@ export function effects_run(base_st: mut BaseState, effects_st: mut EffectsState
continue
}
e.left = e.left - minutes
if e.left < 0.0 { ef_end(base_st, effects_st, i, EFFECT_RAN_OUT) } else { i += 1 }
if e.left < 0.0 { ef_end(effects_st, i, EFFECT_RAN_OUT) } else { i += 1 }
}
}