144 lines
6.2 KiB
Text
144 lines
6.2 KiB
Text
# tracks_test.ludic - prints go into a ring per kind and are drawn through the hook, they age on
|
|
# the world's clock, the nearest is found, a read is a fact every time and a count once, and the
|
|
# reader's state saves
|
|
import "ludic.tracks"
|
|
import "ludic.base"
|
|
program TracksTest {
|
|
numbers float
|
|
state TracksTestState {
|
|
now: float = 0.0
|
|
skill: int = 1
|
|
placed_n: int = 0
|
|
placed_last: int = -1
|
|
}
|
|
|
|
function fake_now(tracks_test_st: TracksTestState) -> float { return tracks_test_st.now }
|
|
function fake_skill(tracks_test_st: TracksTestState) -> int { return tracks_test_st.skill }
|
|
function fake_bearing(yaw: float) -> string {
|
|
if yaw > 0.0 { return "east" }
|
|
return "west"
|
|
}
|
|
function fake_placed(tracks_test_st: mut TracksTestState, kind: int, i: int) -> void {
|
|
tracks_test_st.placed_n += 1
|
|
tracks_test_st.placed_last = i
|
|
}
|
|
|
|
bind TracksWorld { now: fn fake_now, skill: fn fake_skill, bearing: fn fake_bearing, placed: fn fake_placed }
|
|
|
|
function fresh(tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) -> void {
|
|
tracks_test_st.now = 10.0
|
|
tracks_test_st.skill = 1
|
|
tracks_test_st.placed_n = 0
|
|
tracks_test_st.placed_last = -1
|
|
tracks_config(tracks_st, 3, 4)
|
|
tracks_config_reading(tracks_st, 1, 0.5, 2.5)
|
|
tracks_reset(tracks_st)
|
|
}
|
|
|
|
function reads(tracks_st: TracksState) -> []TrackRead { return q_drain(tracks_reads(tracks_st)) }
|
|
|
|
test "a print goes into its kind's ring and is drawn" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
|
|
fresh(tracks_st, tracks_test_st)
|
|
let i = tracks_leave(tracks_st, 1, 5.0, 6.0, 1.0, 7, false, -1)
|
|
expect_eq(i, 0)
|
|
expect_eq(tracks_count(tracks_st, 1), 1)
|
|
expect_eq(tracks_count(tracks_st, 0), 0)
|
|
expect_eq(tracks_test_st.placed_n, 1)
|
|
let s = tracks_slot(tracks_st, 1, 0)
|
|
expect(tracks_x(tracks_st, s) == 5.0 and tracks_z(tracks_st, s) == 6.0)
|
|
expect_eq(tracks_sp(tracks_st, s), 7)
|
|
}
|
|
|
|
test "a full ring writes over its oldest print" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
|
|
fresh(tracks_st, tracks_test_st)
|
|
for n in 0 .. 5 { tracks_leave(tracks_st, 2, float(n), 0.0, 0.0, n, false, -1) }
|
|
expect_eq(tracks_count(tracks_st, 2), 4)
|
|
expect_eq(tracks_test_st.placed_last, 0)
|
|
expect_eq(tracks_sp(tracks_st, tracks_slot(tracks_st, 2, 0)), 4)
|
|
}
|
|
|
|
test "a print ages on the world's clock" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
|
|
fresh(tracks_st, tracks_test_st)
|
|
tracks_leave(tracks_st, 1, 0.0, 0.0, 0.0, 1, false, -1)
|
|
tracks_test_st.now = 13.0
|
|
let s = tracks_slot(tracks_st, 1, 0)
|
|
expect(tracks_age(tracks_st, s) == 3.0)
|
|
expect_eq(tracks_fresh_of(tracks_st, tracks_age(tracks_st, s)), TRACK_OLD)
|
|
expect_eq(tracks_fresh_of(tracks_st, 0.2), TRACK_FRESH)
|
|
expect_eq(tracks_fresh_of(tracks_st, 1.0), TRACK_RECENT)
|
|
}
|
|
|
|
test "the nearest print within reach, or none" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
|
|
fresh(tracks_st, tracks_test_st)
|
|
tracks_leave(tracks_st, 1, 10.0, 0.0, 0.0, 1, false, -1)
|
|
tracks_leave(tracks_st, 2, 1.0, 1.0, 0.0, 2, false, -1)
|
|
expect_eq(tracks_nearest(tracks_st, 0.0, 0.0, 2.0), tracks_slot(tracks_st, 2, 0))
|
|
expect_eq(tracks_nearest(tracks_st, 50.0, 50.0, 2.0), -1)
|
|
}
|
|
|
|
test "a print read twice is two facts and one count" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
|
|
fresh(tracks_st, tracks_test_st)
|
|
tracks_leave(tracks_st, 1, 0.0, 0.0, 1.0, 3, true, -1)
|
|
let s = tracks_nearest(tracks_st, 0.0, 0.0, 2.0)
|
|
tracks_read(tracks_st, s)
|
|
tracks_read(tracks_st, s)
|
|
let rs = reads(tracks_st)
|
|
expect_eq(len(rs), 2)
|
|
expect(rs[0].first and not rs[1].first)
|
|
expect_eq(rs[0].source, TRACK_PRINT)
|
|
expect_eq(rs[0].kind, 1)
|
|
expect(rs[0].legend)
|
|
expect(rs[0].bearing == "east")
|
|
expect_eq(tracks_read_count(tracks_st), 1)
|
|
expect(tracks_has_bearing(tracks_st) and tracks_last_yaw(tracks_st) == 1.0)
|
|
}
|
|
|
|
test "a reader without the skill cannot name the animal" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
|
|
fresh(tracks_st, tracks_test_st)
|
|
tracks_test_st.skill = 0
|
|
tracks_leave(tracks_st, 1, 0.0, 0.0, 0.0, 3, false, -1)
|
|
tracks_read(tracks_st, tracks_slot(tracks_st, 1, 0))
|
|
expect(not reads(tracks_st)[0].named)
|
|
}
|
|
|
|
test "a sign that is not a print is told, and counts when it is the first" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
|
|
fresh(tracks_st, tracks_test_st)
|
|
tracks_note(tracks_st, 4, TRACK_SCAT, false, -1.0, true)
|
|
tracks_note(tracks_st, 4, TRACK_SCAT, false, -1.0, false)
|
|
let rs = reads(tracks_st)
|
|
expect_eq(len(rs), 2)
|
|
expect_eq(rs[0].source, TRACK_SCAT)
|
|
expect_eq(tracks_read_count(tracks_st), 1)
|
|
}
|
|
|
|
test "a written-over slot is a new, unread print" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
|
|
fresh(tracks_st, tracks_test_st)
|
|
tracks_leave(tracks_st, 0, 0.0, 0.0, 0.0, 1, false, -1)
|
|
tracks_read(tracks_st, tracks_slot(tracks_st, 0, 0))
|
|
for n in 0 .. 4 { tracks_leave(tracks_st, 0, 0.0, 0.0, 0.0, 2, false, -1) }
|
|
expect(not tracks_was_read(tracks_st, tracks_slot(tracks_st, 0, 0)))
|
|
}
|
|
|
|
test "clearing the ground forgets the prints, not the reader" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
|
|
fresh(tracks_st, tracks_test_st)
|
|
tracks_leave(tracks_st, 1, 0.0, 0.0, 0.0, 1, false, -1)
|
|
tracks_read(tracks_st, tracks_slot(tracks_st, 1, 0))
|
|
tracks_clear(tracks_st)
|
|
expect_eq(tracks_count(tracks_st, 1), 0)
|
|
expect_eq(tracks_read_count(tracks_st), 1)
|
|
}
|
|
|
|
test "a save section reads back the same reader" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) {
|
|
fresh(tracks_st, tracks_test_st)
|
|
tracks_note(tracks_st, 1, TRACK_SIGN, true, 0.0, true)
|
|
tracks_note_bearing(tracks_st, 2.5)
|
|
let root = save_tree()
|
|
save_section(root, "tracks", 1, tracks_save(tracks_st))
|
|
let text = save_encode(root)
|
|
tracks_reset(tracks_st)
|
|
let n = load_section(save_decode(text), "tracks")
|
|
tracks_load(tracks_st, n.data, n.version)
|
|
expect_eq(tracks_read_count(tracks_st), 1)
|
|
expect(tracks_has_bearing(tracks_st) and tracks_last_yaw(tracks_st) == 2.5)
|
|
}
|
|
}
|