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

wip(0.S3): packages and examples migrated again from their pre-0.S sources in one run

Browse source 
ludic migrate state packages <every example program> packages/ludic.lab/example/plate.ludic
  1804 vars into 126 states, 64 into lets; 23498 edits in 460 files

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Orkun ÇAKILKAYA 2026-09-25 15:31:34 +03:00
parent 5ffe50ed02
commit 19fcf60599
459 changed files with 17862 additions and 17603 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -2,32 +2,32 @@
function ef_live(e: Effect) -> bool { return e.delay < 0.01 }
# what the rules should add for a kind right now (a delayed one counts only once it begins)
export function effects_sum(kind: int) -> float {
let all = ef_all()
export function effects_sum(effects_st: mut EffectsState, kind: int) -> float {
let all = ef_all(effects_st)
var t = 0.0
for i in 0 .. len(all) { if all[i].kind == kind and ef_live(all[i]) { t = t + all[i].mag } }
return t
}
export function effects_has(kind: int) -> bool {
let all = ef_all()
export function effects_has(effects_st: mut EffectsState, kind: int) -> bool {
let all = ef_all(effects_st)
for i in 0 .. len(all) { if all[i].kind == kind and ef_live(all[i]) { return true } }
return false
}
export function effects_bonus_count() -> int {
let all = ef_all()
export function effects_bonus_count(effects_st: mut EffectsState) -> int {
let all = ef_all(effects_st)
var n = 0
for i in 0 .. len(all) { if all[i].bonus { n += 1 } }
return n
}
# everything held, delayed or not, in the order added
export function effects_count() -> int { return len(ef_all()) }
export function effects_count(effects_st: mut EffectsState) -> int { return len(ef_all(effects_st)) }
# a copy, so a reader cannot change the ring
export function effects_at(i: int) -> Effect {
let src = ef_all()[i]
export function effects_at(effects_st: mut EffectsState, i: int) -> Effect {
let src = ef_all(effects_st)[i]
let e = new Effect
e.kind = src.kind
e.mag = src.mag
@ -39,9 +39,9 @@ export function effects_at(i: int) -> Effect {
}
# the indices of the ones that have begun, for a read-out
export function effects_live() -> []int {
export function effects_live(effects_st: mut EffectsState) -> []int {
let out = new []int
let all = ef_all()
let all = ef_all(effects_st)
for i in 0 .. len(all) { if ef_live(all[i]) { push(out, i) } }
return out
}

32
packages/ludic.effects/state.ludic
View file

@ -20,27 +20,29 @@ export property EffectEnded {
bonus: bool = false
}
var ef_list: []Effect = null
var ef_max: int = 8
var ef_bonus_max: int = 3
var ef_ended: Queue<EffectEnded> = null
export state EffectsState {
ef_list: []Effect = null
ef_max: int = 8
ef_bonus_max: int = 3
ef_ended: Queue<EffectEnded> = null
}
function ef_all() -> []Effect {
if ef_list == null { ef_list = new []Effect }
return ef_list
function ef_all(effects_st: mut EffectsState) -> []Effect {
if effects_st.ef_list == null { effects_st.ef_list = new []Effect }
return effects_st.ef_list
}
# the facts: what ended and why, oldest first; the game drains it
export function effects_ended() -> Queue<EffectEnded> {
if ef_ended == null { ef_ended = queue_new("effects.ended") }
return ef_ended
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") }
return effects_st.ef_ended
}
# how many may run at once, and how many of those may be bonuses
export function effects_config(max: int, bonus_max: int) -> void {
ef_max = max
ef_bonus_max = bonus_max
export function effects_config(effects_st: mut EffectsState, max: int, bonus_max: int) -> void {
effects_st.ef_max = max
effects_st.ef_bonus_max = bonus_max
}
export function effects_capacity() -> int { return ef_max }
export function effects_bonus_capacity() -> int { return ef_bonus_max }
export function effects_capacity(effects_st: EffectsState) -> int { return effects_st.ef_max }
export function effects_bonus_capacity(effects_st: EffectsState) -> int { return effects_st.ef_bonus_max }

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

@ -1,14 +1,14 @@
# system.ludic - the effects as a system: reset, a tick in game hours, and its own save section
export function effects_reset() -> void {
effects_clear()
q_clear(effects_ended())
export function effects_reset(base_st: mut BaseState, effects_st: mut EffectsState) -> void {
effects_clear(effects_st)
q_clear(base_st, effects_ended(base_st, effects_st))
}
function effects_tick(t: Tick) -> void { effects_run(t.hours * 60.0) }
function effects_tick(base_st: mut BaseState, effects_st: mut EffectsState, t: Tick) -> void { effects_run(base_st, effects_st, t.hours * 60.0) }
export function effects_save() -> Val {
export function effects_save(effects_st: mut EffectsState) -> Val {
let l = Value.list()
let all = ef_all()
let all = ef_all(effects_st)
for i in 0 .. len(all) {
let o = Value.object()
sv_put_int(o, "k", all[i].kind)
@ -24,12 +24,12 @@ export function effects_save() -> Val {
return v
}
export function effects_load(v: Val, version: int) -> void {
effects_clear()
export function effects_load(effects_st: mut EffectsState, v: Val, version: int) -> void {
effects_clear(effects_st)
if Value.has(v, "list") == 0 { return }
let l = Value.get(v, "list")
for i in 0 .. Value.count(l) {
if len(ef_all()) >= ef_max { break }
if len(ef_all(effects_st)) >= effects_st.ef_max { break }
let o = Value.at(l, i)
let e = new Effect
e.kind = sv_int(o, "k", 0)
@ -38,7 +38,7 @@ export function effects_load(v: Val, version: int) -> void {
e.delay = sv_float(o, "d", 0.0)
e.bonus = sv_bool(o, "b", false)
e.label = sv_str(o, "l", "")
push(ef_all(), e)
push(ef_all(effects_st), e)
}
}

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

@ -8,120 +8,120 @@ program EffectsTest {
const WARMTH: int = 1
const CARRY: int = 2
function fresh() -> void {
effects_config(8, 3)
effects_reset()
function fresh(base_st: mut BaseState, effects_st: mut EffectsState) -> void {
effects_config(effects_st, 8, 3)
effects_reset(base_st, effects_st)
}
function ended() -> []EffectEnded { return q_drain(effects_ended()) }
function waiting() -> int { return q_len(effects_ended()) }
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 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" {
fresh()
effects_add(LEGS, 8.0, 20.0, false, "Fizz")
effects_add(LEGS, 6.0, 45.0, false, "Trail mix")
effects_add(WARMTH, 12.0, 50.0, false, "Stew")
expect(effects_sum(LEGS) == 14.0)
expect(effects_sum(WARMTH) == 12.0)
expect(effects_sum(CARRY) == 0.0)
expect(effects_has(WARMTH))
expect(not effects_has(CARRY))
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")
expect(effects_sum(effects_st, LEGS) == 14.0)
expect(effects_sum(effects_st, WARMTH) == 12.0)
expect(effects_sum(effects_st, CARRY) == 0.0)
expect(effects_has(effects_st, WARMTH))
expect(not effects_has(effects_st, CARRY))
}
test "the same kind from the same label replaces itself rather than stacking" {
fresh()
effects_add(LEGS, 8.0, 20.0, false, "Fizz")
effects_add(LEGS, 8.0, 20.0, false, "Fizz")
expect_eq(effects_count(), 1)
expect(effects_sum(LEGS) == 8.0)
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")
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" {
fresh()
effects_add(LEGS, 1.0, 10.0, true, "a")
effects_add(LEGS, 1.0, 30.0, true, "b")
effects_add(WARMTH, 1.0, 40.0, true, "c")
effects_add(CARRY, 1.0, 50.0, true, "d")
expect_eq(effects_bonus_count(), 3)
let gone = ended()
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")
expect_eq(effects_bonus_count(effects_st), 3)
let gone = ended(base_st, 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" {
fresh()
effects_config(2, 3)
effects_add(LEGS, 1.0, 10.0, false, "short")
effects_add(WARMTH, 1.0, 90.0, false, "long")
effects_add(CARRY, 1.0, 50.0, false, "new")
expect_eq(effects_count(), 2)
expect(not effects_has(LEGS))
expect_eq(ended()[0].why, EFFECT_CROWDED_OUT)
test "a full ring drops the one nearest its end" (base_st: mut BaseState, effects_st: mut EffectsState) {
fresh(base_st, 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")
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)
}
test "a delayed one counts only once it has begun" {
fresh()
effects_add(LEGS, 8.0, 20.0, false, "Fizz")
effects_add_after(20.0, LEGS, -5.0, 15.0, false, "Sugar crash")
expect(effects_sum(LEGS) == 8.0)
expect_eq(len(effects_live()), 1)
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")
expect(effects_sum(effects_st, LEGS) == 8.0)
expect_eq(len(effects_live(effects_st)), 1)
tick_minutes(25.0)
expect(effects_sum(LEGS) == -5.0)
expect(effects_sum(effects_st, LEGS) == -5.0)
tick_minutes(20.0)
expect_eq(effects_count(), 0)
expect_eq(effects_count(effects_st), 0)
}
test "running down in game hours reports each ending" {
fresh()
effects_add(WARMTH, -10.0, 10.0, false, "Wet through")
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")
tick_minutes(5.0)
expect_eq(waiting(), 0)
expect_eq(waiting(base_st, effects_st), 0)
tick_minutes(6.0)
expect_eq(effects_count(), 0)
let gone = ended()
expect_eq(effects_count(effects_st), 0)
let gone = ended(base_st, effects_st)
expect_eq(gone[0].why, EFFECT_RAN_OUT)
expect(gone[0].label == "Wet through")
}
test "clear stops everything and says nothing" {
fresh()
effects_add(LEGS, 1.0, 10.0, false, "a")
effects_clear()
expect_eq(effects_count(), 0)
expect_eq(waiting(), 0)
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")
effects_clear(effects_st)
expect_eq(effects_count(effects_st), 0)
expect_eq(waiting(base_st, effects_st), 0)
}
test "a save section reads back the same ring" {
fresh()
effects_add(LEGS, 8.5, 20.0, true, "Fizz")
effects_add_after(20.0, LEGS, -5.0, 15.0, false, "Sugar crash")
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")
let root = save_tree()
save_section(root, "effects", 1, effects_save())
save_section(root, "effects", 1, effects_save(effects_st))
let text = save_encode(root)
effects_clear()
effects_clear(effects_st)
let n = load_section(save_decode(text), "effects")
expect(n.found)
effects_load(n.data, n.version)
expect_eq(effects_count(), 2)
let a = effects_at(0)
effects_load(effects_st, n.data, n.version)
expect_eq(effects_count(effects_st), 2)
let a = effects_at(effects_st, 0)
expect(a.mag == 8.5)
expect(a.bonus)
let b = effects_at(1)
let b = effects_at(effects_st, 1)
expect(b.delay == 20.0)
expect(b.label == "Sugar crash")
}
test "the copy a reader gets does not change the ring" {
fresh()
effects_add(LEGS, 3.0, 10.0, false, "a")
let e = effects_at(0)
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")
let e = effects_at(effects_st, 0)
e.mag = 100.0
expect(effects_sum(LEGS) == 3.0)
expect(effects_sum(effects_st, LEGS) == 3.0)
}
}

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

@ -1,26 +1,26 @@
# 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(i: int, why: int) -> void {
let all = ef_all()
function ef_end(base_st: mut BaseState, 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(effects_ended(), e)
ef_drop(i)
q_push(base_st, effects_ended(base_st, effects_st), e)
ef_drop(effects_st, i)
}
function ef_drop(i: int) -> void {
let all = ef_all()
function ef_drop(effects_st: mut EffectsState, i: int) -> void {
let all = ef_all(effects_st)
let rest = new []Effect
for k in 0 .. len(all) { if k != i { push(rest, all[k]) } }
ef_list = rest
effects_st.ef_list = rest
}
# the one with the least time left (of the bonuses only, when asked); -1 when there is none
function ef_nearest_end(bonus_only: bool) -> int {
let all = ef_all()
function ef_nearest_end(effects_st: mut EffectsState, bonus_only: bool) -> int {
let all = ef_all(effects_st)
var at = -1
for i in 0 .. len(all) {
if bonus_only and not all[i].bonus { continue }
@ -29,16 +29,16 @@ function ef_nearest_end(bonus_only: bool) -> int {
return at
}
function ef_make_room(bonus: bool) -> void {
function ef_make_room(base_st: mut BaseState, effects_st: mut EffectsState, bonus: bool) -> void {
if bonus {
while effects_bonus_count() >= ef_bonus_max and ef_nearest_end(true) >= 0 { ef_end(ef_nearest_end(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(base_st, effects_st, ef_nearest_end(effects_st, true), EFFECT_PUSHED_OUT) }
}
if len(ef_all()) >= ef_max and ef_nearest_end(false) >= 0 { ef_end(ef_nearest_end(false), EFFECT_CROWDED_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) }
}
# begin one `after` game minutes from now, lasting `minutes` once it has begun
export function effects_add_after(after: float, kind: int, mag: float, minutes: float, bonus: bool, label: string) -> void {
let all = ef_all()
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 {
let all = ef_all(effects_st)
for i in 0 .. len(all) {
if all[i].kind == kind and all[i].label == label {
all[i].mag = mag
@ -46,7 +46,7 @@ export function effects_add_after(after: float, kind: int, mag: float, minutes:
return
}
}
ef_make_room(bonus)
ef_make_room(base_st, effects_st, bonus)
let e = new Effect
e.kind = kind
e.mag = mag
@ -54,27 +54,27 @@ export function effects_add_after(after: float, kind: int, mag: float, minutes:
e.delay = after
e.bonus = bonus
e.label = label
push(ef_all(), e)
push(ef_all(effects_st), e)
}
export function effects_add(kind: int, mag: float, minutes: float, bonus: bool, label: string) -> void {
effects_add_after(0.0, kind, mag, minutes, bonus, label)
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)
}
# everything stops at once, and says nothing: a new trip or a night's sleep
export function effects_clear() -> void { ef_list = new []Effect }
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(minutes: float) -> void {
export function effects_run(base_st: mut BaseState, effects_st: mut EffectsState, minutes: float) -> void {
var i = 0
while i < len(ef_all()) {
let e = ef_all()[i]
while i < len(ef_all(effects_st)) {
let e = ef_all(effects_st)[i]
if e.delay > 0.0 {
e.delay = e.delay - minutes
i += 1
continue
}
e.left = e.left - minutes
if e.left < 0.0 { ef_end(i, EFFECT_RAN_OUT) } else { i += 1 }
if e.left < 0.0 { ef_end(base_st, effects_st, i, EFFECT_RAN_OUT) } else { i += 1 }
}
}