Orkuncakilkaya
93bc8a90db
dispatch lowered to ludic_act_push(k, new A { ... }): a fresh record every dispatch, and an input
system dispatches Move and FrameTime every frame. The queue now keeps a list per action
(kept<k>, used<k>); ludic_act_new__A hands out the next (made only when all are queued), new's
emitter fills it field by field as it fills a fresh one (every field, default or given), and
drain_actions sets every used<k> back to 0 once the queue is empty. A reducer only ever reads
its action during the drain, so nothing sees a record after it is reused. Actions are visible
to the program's file, where the queue lives, as reducers already were.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
51 lines
1.6 KiB
Text
51 lines
1.6 KiB
Text
# actions_test.ludic - 0.R: the runner drains the action queue after every phase, so what an input
|
|
# system dispatches is reduced before the simulation reads it, the same tick
|
|
import "ludic.base"
|
|
program ActionsTest {
|
|
numbers float
|
|
state Door {
|
|
open: bool = false
|
|
seen: string = ""
|
|
}
|
|
action Knock { times: int }
|
|
reducer Door on Knock(d: mut Door, a: Knock) {
|
|
if a.times >= 2 { d.open = true }
|
|
}
|
|
state Tally {
|
|
sum: int = 0
|
|
words: string = ""
|
|
}
|
|
action Note { n: int = 7, word: string = "hi" }
|
|
reducer Tally on Note(t: mut Tally, a: Note) {
|
|
t.sum = t.sum + a.n
|
|
t.words = t.words + a.word
|
|
}
|
|
function input_tick(t: Tick) -> void { dispatch Knock { times: 2 } }
|
|
function sim_tick(d: mut Door, t: Tick) -> void {
|
|
if d.open { d.seen = d.seen + "o" } else { d.seen = d.seen + "c" }
|
|
}
|
|
test "an input system's action is reduced before the simulation's phase" (b: mut BaseState, d: Door) {
|
|
core_clear(b)
|
|
let i = system_new("input", PH_INPUT)
|
|
i.tick = fn input_tick
|
|
core_add(b, i)
|
|
let s = system_new("sim", PH_SIMULATE)
|
|
s.tick = fn sim_tick
|
|
core_add(b, s)
|
|
core_tick_all(b, tick_new(0.016, 1, 0.0))
|
|
expect(d.open)
|
|
expect_eq(d.seen, "o")
|
|
}
|
|
test "a dispatched record is kept and filled again: what a dispatch leaves out is its default, not the last one's" (t: Tally) {
|
|
dispatch Note { n: 1, word: "a" }
|
|
dispatch Note { n: 2, word: "b" }
|
|
drain_actions()
|
|
expect_eq(t.sum, 3)
|
|
dispatch Note { }
|
|
dispatch Note { word: "c" }
|
|
dispatch Note { n: 5 }
|
|
drain_actions()
|
|
expect_eq(t.sum, 3 + 7 + 7 + 5)
|
|
expect_eq(t.words, "abhichi")
|
|
}
|
|
}
|