Orkuncakilkaya
71735b10a2
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>
128 lines
4.9 KiB
Text
128 lines
4.9 KiB
Text
# clock_test.ludic - the hours run at the rate the world's rest allows, only on the machine that
|
|
# owns it; a day turns past midnight or by a verb, as a fact; the calendar is a function of the day
|
|
import "ludic.clock"
|
|
import "ludic.base"
|
|
program ClockTest {
|
|
numbers float
|
|
state ClockTestState {
|
|
owns: bool = true
|
|
rest: float = 1.0
|
|
}
|
|
|
|
function fake_owns(clock_test_st: ClockTestState) -> bool { return clock_test_st.owns }
|
|
function fake_rest(clock_test_st: ClockTestState) -> float { return clock_test_st.rest }
|
|
function fake_seed() -> int { return 42 }
|
|
|
|
bind ClockWorld { owns_world: fn fake_owns, rest_scale: fn fake_rest, seed: fn fake_seed }
|
|
|
|
function fresh(clock_st: mut ClockState, clock_test_st: mut ClockTestState) -> void {
|
|
clock_test_st.owns = true
|
|
clock_test_st.rest = 1.0
|
|
clock_config(clock_st, 8.0, 20.0, 6.0)
|
|
clock_config_moon(clock_st, 29.5, 0.2, 0.8)
|
|
clock_set_scale(clock_st, 60.0)
|
|
let seasons = new []int
|
|
for m in 0 .. 12 { push(seasons, m / 3) }
|
|
clock_calendar(clock_st, 10, seasons)
|
|
clock_reset(clock_st)
|
|
}
|
|
|
|
function turned(clock_st: mut ClockState) -> []DayTurned { return q_drain(clock_days(clock_st)) }
|
|
function waiting(clock_st: mut ClockState) -> int { return q_len(clock_days(clock_st)) }
|
|
function run_hours(h: float) -> void {
|
|
let s = clock_system()
|
|
s.tick(tick_new(0.016, 0, h))
|
|
}
|
|
|
|
test "a trip starts on day one at the start hour, the moon inside its range" (clock_st: mut ClockState, clock_test_st: mut ClockTestState) {
|
|
fresh(clock_st, clock_test_st)
|
|
expect_eq(clock_day(clock_st), 1)
|
|
expect(clock_hours(clock_st) == 8.0)
|
|
expect(clock_moon(clock_st) >= 0.2 and clock_moon(clock_st) < 0.8)
|
|
expect(clock_hhmm(clock_st) == "08:00")
|
|
}
|
|
|
|
test "the same seed gives the same moon" (clock_st: mut ClockState, clock_test_st: mut ClockTestState) {
|
|
fresh(clock_st, clock_test_st)
|
|
let a = clock_moon(clock_st)
|
|
clock_reset(clock_st)
|
|
expect(clock_moon(clock_st) == a)
|
|
}
|
|
|
|
test "a real minute is a game hour at scale 60, and resting speeds it" (clock_st: mut ClockState, clock_test_st: mut ClockTestState) {
|
|
fresh(clock_st, clock_test_st)
|
|
expect(clock_hours_in(clock_st, 60.0) == 1.0)
|
|
clock_test_st.rest = 4.0
|
|
expect(clock_rate(clock_st) == 240.0)
|
|
}
|
|
|
|
test "past midnight the day turns, once, as a fact" (clock_st: mut ClockState, clock_test_st: mut ClockTestState) {
|
|
fresh(clock_st, clock_test_st)
|
|
run_hours(15.0)
|
|
expect_eq(waiting(clock_st), 0)
|
|
run_hours(2.5)
|
|
expect_eq(clock_day(clock_st), 2)
|
|
expect(clock_hours(clock_st) == 1.5)
|
|
let t = turned(clock_st)
|
|
expect_eq(len(t), 1)
|
|
expect_eq(t[0].day, 2)
|
|
expect_eq(t[0].how, DAY_STAYED_UP)
|
|
}
|
|
|
|
test "a machine that does not own the world does not move it" (clock_st: mut ClockState, clock_test_st: mut ClockTestState) {
|
|
fresh(clock_st, clock_test_st)
|
|
clock_test_st.owns = false
|
|
run_hours(20.0)
|
|
expect(clock_hours(clock_st) == 8.0)
|
|
expect_eq(clock_day(clock_st), 1)
|
|
}
|
|
|
|
test "a night slept turns the day and moves the moon a month's share" (clock_st: mut ClockState, clock_test_st: mut ClockTestState) {
|
|
fresh(clock_st, clock_test_st)
|
|
let m0 = clock_moon(clock_st)
|
|
clock_set_hours(clock_st, 6.5)
|
|
clock_new_day(clock_st)
|
|
expect_eq(clock_day(clock_st), 2)
|
|
expect(clock_moon(clock_st) > m0)
|
|
expect_eq(turned(clock_st)[0].how, DAY_SLEPT)
|
|
}
|
|
|
|
test "night is outside the day's hours, and the hour wraps" (clock_st: mut ClockState, clock_test_st: mut ClockTestState) {
|
|
fresh(clock_st, clock_test_st)
|
|
clock_set_hours(clock_st, 21.0)
|
|
expect(clock_is_night(clock_st))
|
|
clock_set_hours(clock_st, 12.0)
|
|
expect(not clock_is_night(clock_st))
|
|
clock_set_hours(clock_st, 25.0)
|
|
expect(clock_hours(clock_st) == 1.0)
|
|
}
|
|
|
|
test "the calendar is a function of the day" (clock_st: mut ClockState, clock_test_st: mut ClockTestState) {
|
|
fresh(clock_st, clock_test_st)
|
|
expect_eq(clock_season_of(clock_st, 1), 0)
|
|
expect_eq(clock_month_of(clock_st, 31), 3)
|
|
expect_eq(clock_season_of(clock_st, 31), 1)
|
|
expect_eq(clock_day_of_month_of(clock_st, 35), 5)
|
|
expect_eq(clock_year_of(clock_st, 121), 2)
|
|
expect_eq(clock_first_day_of(clock_st, 2), 61)
|
|
clock_set_day(clock_st, 28)
|
|
expect_eq(clock_days_to_change(clock_st), 3)
|
|
expect_eq(clock_season(clock_st), 0)
|
|
}
|
|
|
|
test "a save section reads back the same clock" (clock_st: mut ClockState, clock_test_st: mut ClockTestState) {
|
|
fresh(clock_st, clock_test_st)
|
|
clock_set_day(clock_st, 17)
|
|
clock_set_hours(clock_st, 13.25)
|
|
clock_set_moon(clock_st, 0.375)
|
|
let root = save_tree()
|
|
save_section(root, "clock", 1, clock_save(clock_st))
|
|
let text = save_encode(root)
|
|
clock_reset(clock_st)
|
|
let n = load_section(save_decode(text), "clock")
|
|
clock_load(clock_st, n.data, n.version)
|
|
expect_eq(clock_day(clock_st), 17)
|
|
expect(clock_hours(clock_st) == 13.25)
|
|
expect(clock_moon(clock_st) == 0.375)
|
|
}
|
|
}
|