169 lines
6.9 KiB
Text
169 lines
6.9 KiB
Text
# hints_test.ludic - the rail sorted by urgency and capped, ties in registry order, the card walked
|
|
# along it and put down when it stops being true, muting by key across a save, cards from a file
|
|
import "ludic.hints"
|
|
import "ludic.base"
|
|
program HintsTest {
|
|
numbers float
|
|
def Hints thirsty { urgency: HINTS_NOTE, line: k"hints.thirsty", title: k"hints.water", s1: k"hints.drink_shore", pic1: "water", item2: 7 }
|
|
def Hints parched { urgency: HINTS_URGENT, line: k"hints.drink_now", title: k"hints.water_now" }
|
|
def Hints rain { urgency: HINTS_TIP, line: k"hints.rain" }
|
|
def Hints cold { urgency: HINTS_WARN, line: k"hints.cold" }
|
|
def Hints night { urgency: HINTS_TIP, line: k"hints.night" }
|
|
def Hints from "cards.lres"
|
|
|
|
state HintsTestState {
|
|
on: []bool = null
|
|
showing: bool = true
|
|
}
|
|
|
|
function fake_true(hints_test_st: HintsTestState, i: int) -> bool { return hints_test_st.on[i] }
|
|
function fake_showing(hints_test_st: HintsTestState) -> bool { return hints_test_st.showing }
|
|
bind HintsWorld { true_now: fn fake_true, showing: fn fake_showing }
|
|
|
|
function fresh(hints_st: mut HintsState, hints_test_st: mut HintsTestState) -> void {
|
|
hints_test_st.on = new []bool
|
|
for i in 0 .. HINT_COUNT { push(hints_test_st.on, false) }
|
|
hints_test_st.showing = true
|
|
hints_config(hints_st, 3, 1.0)
|
|
hints_reset(hints_st)
|
|
hints_mutes_load(hints_st, Value.list())
|
|
}
|
|
|
|
function count(hints_st: HintsState, what: int) -> int {
|
|
let fs = q_drain(hints_facts(hints_st))
|
|
var n = 0
|
|
for i in 0 .. len(fs) { if fs[i].what == what { n += 1 } }
|
|
return n
|
|
}
|
|
|
|
test "the registry is the game's, and a file adds to it" {
|
|
expect_eq(HINT_COUNT, 7)
|
|
expect_eq(hints_find("parched"), HINT_PARCHED)
|
|
expect_eq(Hints[HINT_BEAR].urgency, HINTS_URGENT)
|
|
expect(Hints[HINT_FIRE].later == k"hints.carry_logs")
|
|
expect(hints_step_icon(HINT_THIRSTY, 1) == "water")
|
|
expect_eq(hints_step_item(HINT_THIRSTY, 2), 7)
|
|
expect(hints_step_text(HINT_THIRSTY, 1) == string(k"hints.drink_shore"))
|
|
}
|
|
|
|
test "the most urgent true cards, capped, ties in registry order" (hints_st: mut HintsState, hints_test_st: mut HintsTestState) {
|
|
fresh(hints_st, hints_test_st)
|
|
for i in 0 .. HINT_COUNT { hints_test_st.on[i] = true }
|
|
hints_tick(hints_st, 1.0)
|
|
expect_eq(hints_count(hints_st), 3)
|
|
expect_eq(hints_at(hints_st, 0), HINT_PARCHED)
|
|
expect_eq(hints_at(hints_st, 1), HINT_BEAR)
|
|
expect_eq(hints_at(hints_st, 2), HINT_COLD)
|
|
hints_test_st.on[HINT_PARCHED] = false
|
|
hints_test_st.on[HINT_BEAR] = false
|
|
hints_tick(hints_st, 0.5)
|
|
expect_eq(hints_at(hints_st, 0), HINT_PARCHED) # not a second yet: the rail holds
|
|
hints_tick(hints_st, 0.6)
|
|
expect_eq(hints_at(hints_st, 0), HINT_COLD)
|
|
expect_eq(hints_at(hints_st, 1), HINT_THIRSTY)
|
|
expect_eq(hints_at(hints_st, 2), HINT_FIRE)
|
|
}
|
|
|
|
test "nothing on the rail while it is not showing" (hints_st: mut HintsState, hints_test_st: mut HintsTestState) {
|
|
fresh(hints_st, hints_test_st)
|
|
hints_test_st.on[HINT_COLD] = true
|
|
hints_test_st.showing = false
|
|
hints_sort(hints_st)
|
|
expect_eq(len(hints_rail(hints_st)), 0)
|
|
expect_eq(hints_count(hints_st), 0)
|
|
hints_test_st.showing = true
|
|
hints_sort(hints_st)
|
|
expect_eq(len(hints_rail(hints_st)), 1)
|
|
let kept = new []int
|
|
hints_rail_into(hints_st, kept)
|
|
hints_rail_into(hints_st, kept)
|
|
expect_eq(len(kept), 1)
|
|
expect_eq(kept[0], hints_rail(hints_st)[0])
|
|
}
|
|
|
|
test "the key opens the picked chip, the arrows walk round, the key puts it down" (hints_st: mut HintsState, hints_test_st: mut HintsTestState) {
|
|
fresh(hints_st, hints_test_st)
|
|
hints_test_st.on[HINT_COLD] = true
|
|
hints_test_st.on[HINT_THIRSTY] = true
|
|
hints_test_st.on[HINT_RAIN] = true
|
|
hints_sort(hints_st)
|
|
hints_key(hints_st)
|
|
expect_eq(hints_card(hints_st), HINT_COLD)
|
|
hints_move(hints_st, 1)
|
|
expect_eq(hints_card(hints_st), HINT_THIRSTY)
|
|
expect(hints_hot(hints_st, 1))
|
|
hints_move(hints_st, -1)
|
|
hints_move(hints_st, -1)
|
|
expect_eq(hints_card(hints_st), HINT_RAIN)
|
|
hints_key(hints_st)
|
|
expect_eq(hints_card(hints_st), -1)
|
|
expect_eq(count(hints_st, HINTS_F_OPENED), 4)
|
|
}
|
|
|
|
test "the card follows its subject as the rail re-sorts, and goes when it is no longer true" (hints_st: mut HintsState, hints_test_st: mut HintsTestState) {
|
|
fresh(hints_st, hints_test_st)
|
|
hints_test_st.on[HINT_THIRSTY] = true
|
|
hints_test_st.on[HINT_RAIN] = true
|
|
hints_sort(hints_st)
|
|
hints_open(hints_st, 1)
|
|
expect_eq(hints_card(hints_st), HINT_RAIN)
|
|
hints_test_st.on[HINT_COLD] = true
|
|
hints_sort(hints_st)
|
|
expect_eq(hints_card(hints_st), HINT_RAIN)
|
|
expect_eq(hints_pick(hints_st), 2)
|
|
hints_test_st.on[HINT_RAIN] = false
|
|
hints_sort(hints_st)
|
|
expect_eq(hints_card(hints_st), -1)
|
|
expect_eq(count(hints_st, HINTS_F_CLOSED), 0) # it went; nobody put it down
|
|
}
|
|
|
|
test "I know this: muted off the rail, counted, given back" (hints_st: mut HintsState, hints_test_st: mut HintsTestState) {
|
|
fresh(hints_st, hints_test_st)
|
|
hints_test_st.on[HINT_COLD] = true
|
|
hints_test_st.on[HINT_THIRSTY] = true
|
|
hints_sort(hints_st)
|
|
hints_key(hints_st)
|
|
hints_mute_card(hints_st)
|
|
expect_eq(hints_card(hints_st), -1)
|
|
expect(hints_muted(hints_st, HINT_COLD))
|
|
expect_eq(hints_mute_count(hints_st), 1)
|
|
expect_eq(count(hints_st, HINTS_F_MUTED), 1)
|
|
hints_tick(hints_st, 0.0) # the next pass comes at once
|
|
expect_eq(hints_at(hints_st, 0), HINT_THIRSTY)
|
|
expect_eq(hints_count(hints_st), 1)
|
|
hints_unmute_all(hints_st)
|
|
hints_tick(hints_st, 0.0)
|
|
expect_eq(hints_at(hints_st, 0), HINT_COLD)
|
|
expect_eq(count(hints_st, HINTS_F_UNMUTED), 1)
|
|
}
|
|
|
|
test "mutes are kept by key, and a key this build lacks is carried through" (hints_st: mut HintsState, hints_test_st: mut HintsTestState) {
|
|
fresh(hints_st, hints_test_st)
|
|
hints_mute(hints_st, HINT_NIGHT, true)
|
|
hints_mute(hints_st, HINT_BEAR, true)
|
|
let l = hints_mutes_save(hints_st)
|
|
expect_eq(Value.count(l), 2)
|
|
Value.add(l, Value.str("gone_card"))
|
|
Value.add(l, Value.int(3)) # not a key: ignored
|
|
hints_mutes_load(hints_st, l)
|
|
expect(hints_muted(hints_st, HINT_NIGHT))
|
|
expect(hints_muted(hints_st, HINT_BEAR))
|
|
expect(not hints_muted(hints_st, HINT_RAIN))
|
|
expect_eq(hints_mute_count(hints_st), 2)
|
|
let back = hints_mutes_save(hints_st)
|
|
expect_eq(Value.count(back), 3)
|
|
expect(Value.as_str(Value.at(back, 2)) == "gone_card")
|
|
hints_mutes_load(hints_st, null)
|
|
expect_eq(hints_mute_count(hints_st), 0)
|
|
}
|
|
|
|
test "as a system it ticks the rail" (base_st: mut BaseState, hints_st: mut HintsState, hints_test_st: mut HintsTestState) {
|
|
fresh(hints_st, hints_test_st)
|
|
core_clear(base_st)
|
|
core_add(base_st, hints_system())
|
|
core_reset_all(base_st)
|
|
hints_test_st.on[HINT_FIRE] = true
|
|
core_tick_all(base_st, tick_new(1.0, 1, 0.0))
|
|
expect_eq(hints_at(hints_st, 0), HINT_FIRE)
|
|
}
|
|
}
|