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

feat(base): 0.R4 - a queue keeps its own count, so every package verb takes only its own state; ludic migrate state --prune

Browse source 
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>
This commit is contained in:
Orkun ÇAKILKAYA 2026-09-26 04:19:56 +03:00
parent 8cf4b3fed6
commit 71735b10a2
151 changed files with 58668 additions and 54719 deletions
Download patch file Download diff file Expand all files Collapse all files

26
packages/ludic.fishing/run.ludic
View file

@ -1,20 +1,20 @@
# run.ludic - `dt` real seconds of a line in the water: the wait, the bite, and the fight
function fishing_run_wait(base_st: mut BaseState, fishing_st: mut FishingState) -> void {
function fishing_run_wait(fishing_st: mut FishingState) -> void {
if fishing_st.fishing_t >= 0.0 { return }
fishing_st.fishing_st = FISHING_BITE_ON
fishing_st.fishing_t = 1.6
fishing_st.fishing_sp = fishing_pick(fishing_st)
fishing_say(base_st, fishing_st, FISHING_BITE)
fishing_say(fishing_st, FISHING_BITE)
}
# a fish that runs: the marker is all over the bar and nothing done with it helps
function fishing_run_runs(base_st: mut BaseState, fishing_st: mut FishingState, dt: float) -> float {
function fishing_run_runs(fishing_st: mut FishingState, dt: float) -> float {
let k = FishSpecies[fishing_st.fishing_sp]
if fishing_st.fishing_run_t > 0.0 {
fishing_st.fishing_run_t = fishing_st.fishing_run_t - dt
if fishing_st.fishing_run_t <= 0.0 {
fishing_st.fishing_run_t = 0.0
fishing_say(base_st, fishing_st, FISHING_TIRED)
fishing_say(fishing_st, FISHING_TIRED)
}
return 4.2
}
@ -24,17 +24,17 @@ function fishing_run_runs(base_st: mut BaseState, fishing_st: mut FishingState,
fishing_st.fishing_run_left -= 1
fishing_st.fishing_run_t = 2.2
fishing_st.fishing_run_next = 4.0 + fishing_rand(fishing_st) * 4.0
fishing_say(base_st, fishing_st, FISHING_RUNS)
fishing_say(fishing_st, FISHING_RUNS)
}
}
return k.speed + k.speed_per_hit * float(fishing_st.fishing_won)
}
function fishing_run_reel(base_st: mut BaseState, fishing_st: mut FishingState, dt: float) -> void {
let sp = fishing_run_runs(base_st, fishing_st, dt)
function fishing_run_reel(fishing_st: mut FishingState, dt: float) -> void {
let sp = fishing_run_runs(fishing_st, dt)
if fishing_st.fishing_gentle_on {
fishing_st.fishing_ring_t = fishing_st.fishing_ring_t - dt
if fishing_st.fishing_ring_t <= 0.0 { fishing_lost(base_st, fishing_st, FISHING_LINE_SNAPPED) }
if fishing_st.fishing_ring_t <= 0.0 { fishing_lost(fishing_st, FISHING_LINE_SNAPPED) }
return
}
fishing_st.fishing_mark = fishing_st.fishing_mark + sp * fishing_st.fishing_dir * dt
@ -46,19 +46,19 @@ function fishing_run_reel(base_st: mut BaseState, fishing_st: mut FishingState,
fishing_st.fishing_mark = 0.0
fishing_st.fishing_dir = 1.0
}
if fishing_st.fishing_t < 0.0 { fishing_lost(base_st, fishing_st, FISHING_SLACK) }
if fishing_st.fishing_t < 0.0 { fishing_lost(fishing_st, FISHING_SLACK) }
}
export function fishing_run(base_st: mut BaseState, fishing_st: mut FishingState, dt: float) -> void {
export function fishing_run(fishing_st: mut FishingState, dt: float) -> void {
if fishing_st.fishing_st == FISHING_OFF { return }
fishing_st.fishing_t = fishing_st.fishing_t - dt
if fishing_st.fishing_st == FISHING_WAIT {
fishing_run_wait(base_st, fishing_st)
fishing_run_wait(fishing_st)
return
}
if fishing_st.fishing_st == FISHING_BITE_ON {
if fishing_st.fishing_t < 0.0 { fishing_lost(base_st, fishing_st, FISHING_MISSED) }
if fishing_st.fishing_t < 0.0 { fishing_lost(fishing_st, FISHING_MISSED) }
return
}
fishing_run_reel(base_st, fishing_st, dt)
fishing_run_reel(fishing_st, dt)
}

8
packages/ludic.fishing/state.ludic
View file

@ -42,8 +42,8 @@ export function fishing_config(fishing_st: mut FishingState, min_depth: float, d
fishing_st.fishing_dice = rng_new(seed)
}
export function fishing_facts(base_st: mut BaseState, fishing_st: mut FishingState) -> Queue<FishingFact> {
if fishing_st.fishing_fact_q == null { fishing_st.fishing_fact_q = queue_new(base_st, "fishing.facts") }
export function fishing_facts(fishing_st: mut FishingState) -> Queue<FishingFact> {
if fishing_st.fishing_fact_q == null { fishing_st.fishing_fact_q = queue_new("fishing.facts") }
return fishing_st.fishing_fact_q
}
@ -52,7 +52,7 @@ function fishing_rand(fishing_st: mut FishingState) -> float {
return rng_float(fishing_st.fishing_dice)
}
function fishing_say(base_st: mut BaseState, fishing_st: mut FishingState, what: int) -> void {
function fishing_say(fishing_st: mut FishingState, what: int) -> void {
let f = new FishingFact
f.what = what
f.species = fishing_st.fishing_sp
@ -64,7 +64,7 @@ function fishing_say(base_st: mut BaseState, fishing_st: mut FishingState, what:
f.lure = fishing_st.fishing_lure_on
f.x = fishing_st.fishing_bx
f.z = fishing_st.fishing_bz
q_push(base_st, fishing_facts(base_st, fishing_st), f)
q_push(fishing_facts(fishing_st), f)
}
export function fishing_state(fishing_st: FishingState) -> int { return fishing_st.fishing_st }

10
packages/ludic.fishing/system.ludic
View file

@ -1,12 +1,12 @@
# system.ludic - fishing as a system: its tick, and the record in its own save section (a line in
# the water is never saved)
export function fishing_reset(base_st: mut BaseState, fishing_st: mut FishingState) -> void {
export function fishing_reset(fishing_st: mut FishingState) -> void {
fishing_stop(fishing_st)
fishing_st.fishing_n = 0
fishing_st.fishing_big = 0
fishing_st.fishing_leg = false
fishing_st.fishing_dice = rng_new(fishing_st.fishing_seed_n)
q_clear(base_st, fishing_facts(base_st, fishing_st))
q_clear(fishing_facts(fishing_st))
}
# the record outright (staging, a test, the network's word)
@ -24,12 +24,12 @@ export function fishing_save(fishing_st: FishingState) -> Val {
return v
}
export function fishing_load(base_st: mut BaseState, fishing_st: mut FishingState, v: Val, version: int) -> void {
fishing_reset(base_st, fishing_st)
export function fishing_load(fishing_st: mut FishingState, v: Val, version: int) -> void {
fishing_reset(fishing_st)
fishing_record_set(fishing_st, sv_int(v, "caught", 0), sv_int(v, "biggest", 0), sv_bool(v, "legend", false))
}
function fishing_sys_tick(base_st: mut BaseState, fishing_st: mut FishingState, t: Tick) -> void { fishing_run(base_st, fishing_st, t.dt) }
function fishing_sys_tick(fishing_st: mut FishingState, t: Tick) -> void { fishing_run(fishing_st, t.dt) }
export function fishing_system() -> System {
let s = system_new("fishing", PH_SIMULATE)

192
packages/ludic.fishing/tests/fishing_test.ludic
View file

@ -28,9 +28,9 @@ program FishingTest {
bind FishingWorld { depth: fn depth, afloat: fn afloat, has_bait: fn has_bait, has_lure: fn has_lure, skill: fn fake_skill, level: fn fake_level }
function fresh(base_st: mut BaseState, fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) -> void {
function fresh(fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) -> void {
fishing_config(fishing_st, 0.15, 2.5, 99)
fishing_reset(base_st, fishing_st)
fishing_reset(fishing_st)
fishing_test_st.bait = false
fishing_test_st.lure = false
fishing_test_st.boat = false
@ -38,89 +38,89 @@ program FishingTest {
fishing_test_st.skill = 0.0
}
function facts(base_st: mut BaseState, fishing_st: mut FishingState) -> []FishingFact { return q_drain(base_st, fishing_facts(base_st, fishing_st)) }
function facts(fishing_st: mut FishingState) -> []FishingFact { return q_drain(fishing_facts(fishing_st)) }
function saw(fs: []FishingFact, what: int) -> bool {
for i in 0 .. len(fs) { if fs[i].what == what { return true } }
return false
}
# run until it bites, then strike
function hook(base_st: mut BaseState, fishing_st: mut FishingState) -> void {
function hook(fishing_st: mut FishingState) -> void {
fishing_set_wait(fishing_st, 0.0)
fishing_run(base_st, fishing_st, 0.02)
fishing_press(base_st, fishing_st)
fishing_run(fishing_st, 0.02)
fishing_press(fishing_st)
}
# hold the marker in the green and press, until it is landed or `n` presses are spent
function play(base_st: mut BaseState, fishing_st: mut FishingState, n: int) -> void {
function play(fishing_st: mut FishingState, n: int) -> void {
for i in 0 .. n {
if fishing_state(fishing_st) != FISHING_REEL { return }
var guard = 0
while (fishing_running(fishing_st) or fishing_marker(fishing_st) <= fishing_window_lo(fishing_st) or fishing_marker(fishing_st) >= fishing_window_hi(fishing_st)) and guard < 4000 {
fishing_run(base_st, fishing_st, 0.005)
fishing_run(fishing_st, 0.005)
guard += 1
}
if fishing_state(fishing_st) == FISHING_REEL { fishing_press(base_st, fishing_st) }
if fishing_state(fishing_st) == FISHING_REEL { fishing_press(fishing_st) }
}
}
test "a cast lands only in water, and never twice" (base_st: mut BaseState, fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(base_st, fishing_st, fishing_test_st)
expect_eq(fishing_cast(base_st, fishing_st, 5.0, 0.0), FISHING_NOT_WATER)
test "a cast lands only in water, and never twice" (fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(fishing_st, fishing_test_st)
expect_eq(fishing_cast(fishing_st, 5.0, 0.0), FISHING_NOT_WATER)
expect(not fishing_active(fishing_st))
expect_eq(fishing_cast(base_st, fishing_st, 20.0, 0.0), FISHING_CAST_OK)
expect_eq(fishing_cast(fishing_st, 20.0, 0.0), FISHING_CAST_OK)
expect_eq(fishing_state(fishing_st), FISHING_WAIT)
expect_eq(fishing_cast(base_st, fishing_st, 20.0, 0.0), FISHING_BUSY)
expect_eq(fishing_cast(fishing_st, 20.0, 0.0), FISHING_BUSY)
fishing_test_st.boat = true
fishing_stop(fishing_st)
expect_eq(fishing_cast(base_st, fishing_st, 0.0, 0.0), FISHING_CAST_OK)
expect_eq(fishing_cast(fishing_st, 0.0, 0.0), FISHING_CAST_OK)
}
test "bait is used and said, and halves the wait" (base_st: mut BaseState, fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(base_st, fishing_st, fishing_test_st)
fishing_cast(base_st, fishing_st, 20.0, 0.0)
expect(not saw(facts(base_st, fishing_st), FISHING_BAIT_USED))
test "bait is used and said, and halves the wait" (fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(fishing_st, fishing_test_st)
fishing_cast(fishing_st, 20.0, 0.0)
expect(not saw(facts(fishing_st), FISHING_BAIT_USED))
var plain = 0
while fishing_state(fishing_st) == FISHING_WAIT {
fishing_run(base_st, fishing_st, 0.1)
fishing_run(fishing_st, 0.1)
plain += 1
}
expect(plain <= 201)
fresh(base_st, fishing_st, fishing_test_st)
fresh(fishing_st, fishing_test_st)
fishing_test_st.bait = true
fishing_cast(base_st, fishing_st, 20.0, 0.0)
let fs = facts(base_st, fishing_st)
fishing_cast(fishing_st, 20.0, 0.0)
let fs = facts(fishing_st)
expect(saw(fs, FISHING_BAIT_USED))
expect(fs[0].bait)
var baited = 0
while fishing_state(fishing_st) == FISHING_WAIT {
fishing_run(base_st, fishing_st, 0.1)
fishing_run(fishing_st, 0.1)
baited += 1
}
expect(baited <= 101)
}
test "a bite missed is gone, a bite struck is hooked" (base_st: mut BaseState, fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(base_st, fishing_st, fishing_test_st)
fishing_cast(base_st, fishing_st, 20.0, 0.0)
test "a bite missed is gone, a bite struck is hooked" (fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(fishing_st, fishing_test_st)
fishing_cast(fishing_st, 20.0, 0.0)
fishing_set_wait(fishing_st, 0.0)
fishing_run(base_st, fishing_st, 0.02)
fishing_run(fishing_st, 0.02)
expect_eq(fishing_state(fishing_st), FISHING_BITE_ON)
expect(fishing_species(fishing_st) >= 0)
fishing_run(base_st, fishing_st, 2.0)
fishing_run(fishing_st, 2.0)
expect(not fishing_active(fishing_st))
expect(saw(facts(base_st, fishing_st), FISHING_MISSED))
fishing_cast(base_st, fishing_st, 20.0, 0.0)
hook(base_st, fishing_st)
expect(saw(facts(fishing_st), FISHING_MISSED))
fishing_cast(fishing_st, 20.0, 0.0)
hook(fishing_st)
expect_eq(fishing_state(fishing_st), FISHING_REEL)
expect(saw(facts(base_st, fishing_st), FISHING_HOOKED))
expect(saw(facts(fishing_st), FISHING_HOOKED))
}
test "everyday fish only without a lure, sized and weighed from the data" (base_st: mut BaseState, fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(base_st, fishing_st, fishing_test_st)
test "everyday fish only without a lure, sized and weighed from the data" (fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(fishing_st, fishing_test_st)
for i in 0 .. 40 {
fishing_cast(base_st, fishing_st, 20.0, 0.0)
hook(base_st, fishing_st)
fishing_cast(fishing_st, 20.0, 0.0)
hook(fishing_st)
let s = fishing_species(fishing_st)
expect(s != FISH_OLD_MAROON)
let k = FishSpecies[s]
@ -130,13 +130,13 @@ program FishingTest {
expect(fishing_weight_of(FISH_CUTTHROAT, 50) > fishing_weight_of(FISH_CUTTHROAT, 30))
}
test "reeled in the green three times, it is landed and counted" (base_st: mut BaseState, fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(base_st, fishing_st, fishing_test_st)
fishing_cast(base_st, fishing_st, 20.0, 0.0)
hook(base_st, fishing_st)
facts(base_st, fishing_st)
play(base_st, fishing_st, 3)
let fs = facts(base_st, fishing_st)
test "reeled in the green three times, it is landed and counted" (fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(fishing_st, fishing_test_st)
fishing_cast(fishing_st, 20.0, 0.0)
hook(fishing_st)
facts(fishing_st)
play(fishing_st, 3)
let fs = facts(fishing_st)
expect(saw(fs, FISHING_CAUGHT))
expect_eq(fishing_caught(fishing_st), 1)
expect(fishing_biggest(fishing_st) > 0)
@ -146,109 +146,109 @@ program FishingTest {
expect(last.x == 20.0)
}
test "a press outside the green throws the hook" (base_st: mut BaseState, fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(base_st, fishing_st, fishing_test_st)
fishing_cast(base_st, fishing_st, 20.0, 0.0)
hook(base_st, fishing_st)
while fishing_marker(fishing_st) < fishing_window_hi(fishing_st) + 0.01 { fishing_run(base_st, fishing_st, 0.005) }
fishing_press(base_st, fishing_st)
expect(saw(facts(base_st, fishing_st), FISHING_LINE_SNAPPED))
test "a press outside the green throws the hook" (fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(fishing_st, fishing_test_st)
fishing_cast(fishing_st, 20.0, 0.0)
hook(fishing_st)
while fishing_marker(fishing_st) < fishing_window_hi(fishing_st) + 0.01 { fishing_run(fishing_st, 0.005) }
fishing_press(fishing_st)
expect(saw(facts(fishing_st), FISHING_LINE_SNAPPED))
expect(not fishing_active(fishing_st))
}
test "a fight left alone goes slack" (base_st: mut BaseState, fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(base_st, fishing_st, fishing_test_st)
fishing_cast(base_st, fishing_st, 20.0, 0.0)
hook(base_st, fishing_st)
for i in 0 .. 700 { fishing_run(base_st, fishing_st, 0.02) }
expect(saw(facts(base_st, fishing_st), FISHING_SLACK))
test "a fight left alone goes slack" (fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(fishing_st, fishing_test_st)
fishing_cast(fishing_st, 20.0, 0.0)
hook(fishing_st)
for i in 0 .. 700 { fishing_run(fishing_st, 0.02) }
expect(saw(facts(fishing_st), FISHING_SLACK))
expect_eq(fishing_caught(fishing_st), 0)
}
test "a legend takes the lure, runs, turns, and is landed at five" (base_st: mut BaseState, fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(base_st, fishing_st, fishing_test_st)
test "a legend takes the lure, runs, turns, and is landed at five" (fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(fishing_st, fishing_test_st)
fishing_test_st.lure = true
fishing_cast(base_st, fishing_st, 20.0, 0.0)
hook(base_st, fishing_st)
fishing_cast(fishing_st, 20.0, 0.0)
hook(fishing_st)
expect_eq(fishing_species(fishing_st), FISH_OLD_MAROON)
expect_eq(fishing_need(fishing_st), 5)
let w0 = fishing_window(fishing_st)
play(base_st, fishing_st, 2)
play(fishing_st, 2)
expect(fishing_window(fishing_st) < w0)
for i in 0 .. 400 {
if not fishing_running(fishing_st) { fishing_run(base_st, fishing_st, 0.02) }
if not fishing_running(fishing_st) { fishing_run(fishing_st, 0.02) }
}
let fs = facts(base_st, fishing_st)
let fs = facts(fishing_st)
expect(saw(fs, FISHING_RUNS))
if fishing_running(fishing_st) {
let before = fishing_hits(fishing_st)
fishing_press(base_st, fishing_st)
fishing_press(fishing_st)
expect_eq(fishing_hits(fishing_st), before - 1)
}
play(base_st, fishing_st, 40)
play(fishing_st, 40)
expect(fishing_legend_caught(fishing_st))
let last = facts(base_st, fishing_st)
let last = facts(fishing_st)
expect(last[len(last) - 1].lure)
}
test "gentle: one press inside the ring, and the ring closes" (base_st: mut BaseState, fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(base_st, fishing_st, fishing_test_st)
test "gentle: one press inside the ring, and the ring closes" (fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(fishing_st, fishing_test_st)
fishing_test_st.level = FISHING_GENTLE
fishing_cast(base_st, fishing_st, 20.0, 0.0)
hook(base_st, fishing_st)
fishing_cast(fishing_st, 20.0, 0.0)
hook(fishing_st)
expect(fishing_gentle(fishing_st))
expect_eq(fishing_need(fishing_st), 1)
fishing_press(base_st, fishing_st)
fishing_press(fishing_st)
expect_eq(fishing_caught(fishing_st), 1)
fishing_cast(base_st, fishing_st, 20.0, 0.0)
hook(base_st, fishing_st)
fishing_run(base_st, fishing_st, 2.1)
expect(saw(facts(base_st, fishing_st), FISHING_LINE_SNAPPED))
fishing_cast(fishing_st, 20.0, 0.0)
hook(fishing_st)
fishing_run(fishing_st, 2.1)
expect(saw(facts(fishing_st), FISHING_LINE_SNAPPED))
}
test "a legend fights on gentle too" (base_st: mut BaseState, fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(base_st, fishing_st, fishing_test_st)
test "a legend fights on gentle too" (fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(fishing_st, fishing_test_st)
fishing_test_st.level = FISHING_GENTLE
fishing_test_st.lure = true
fishing_cast(base_st, fishing_st, 20.0, 0.0)
hook(base_st, fishing_st)
fishing_cast(fishing_st, 20.0, 0.0)
hook(fishing_st)
expect(not fishing_gentle(fishing_st))
expect_eq(fishing_need(fishing_st), 5)
}
test "hard closes the window for everyday fish, relaxed keeps it centred" (base_st: mut BaseState, fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(base_st, fishing_st, fishing_test_st)
fishing_cast(base_st, fishing_st, 20.0, 0.0)
hook(base_st, fishing_st)
test "hard closes the window for everyday fish, relaxed keeps it centred" (fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(fishing_st, fishing_test_st)
fishing_cast(fishing_st, 20.0, 0.0)
hook(fishing_st)
expect(fishing_window_lo(fishing_st) + fishing_window_hi(fishing_st) > 0.999 and fishing_window_lo(fishing_st) + fishing_window_hi(fishing_st) < 1.001)
fishing_stop(fishing_st)
fishing_test_st.level = FISHING_HARD
fishing_cast(base_st, fishing_st, 20.0, 0.0)
hook(base_st, fishing_st)
fishing_cast(fishing_st, 20.0, 0.0)
hook(fishing_st)
let w0 = fishing_window(fishing_st)
play(base_st, fishing_st, 1)
play(fishing_st, 1)
expect(fishing_window(fishing_st) < w0)
}
test "skill makes a fish bigger" (base_st: mut BaseState, fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(base_st, fishing_st, fishing_test_st)
test "skill makes a fish bigger" (fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(fishing_st, fishing_test_st)
fishing_test_st.skill = 1.0
fishing_cast(base_st, fishing_st, 20.0, 0.0)
hook(base_st, fishing_st)
fishing_cast(fishing_st, 20.0, 0.0)
hook(fishing_st)
let k = FishSpecies[fishing_species(fishing_st)]
expect(fishing_cm(fishing_st) >= k.cm_min + 60)
}
test "the record is saved, and a line in the water is not" (base_st: mut BaseState, fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(base_st, fishing_st, fishing_test_st)
test "the record is saved, and a line in the water is not" (fishing_st: mut FishingState, fishing_test_st: mut FishingTestState) {
fresh(fishing_st, fishing_test_st)
fishing_record_set(fishing_st, 7, 52, true)
fishing_cast(base_st, fishing_st, 20.0, 0.0)
fishing_cast(fishing_st, 20.0, 0.0)
let root = save_tree()
save_section(root, "fishing", 1, fishing_save(fishing_st))
let text = save_encode(root)
fishing_reset(base_st, fishing_st)
fishing_reset(fishing_st)
let n = load_section(save_decode(text), "fishing")
fishing_load(base_st, fishing_st, n.data, n.version)
fishing_load(fishing_st, n.data, n.version)
expect_eq(fishing_caught(fishing_st), 7)
expect_eq(fishing_biggest(fishing_st), 52)
expect(fishing_legend_caught(fishing_st))

38
packages/ludic.fishing/verbs.ludic
View file

@ -4,7 +4,7 @@ export const FISHING_NOT_WATER: int = 1
export const FISHING_BUSY: int = 2
# a line into (x, z): bait halves the wait (and is a fact, for the game to take from the pack)
export function fishing_cast(base_st: mut BaseState, fishing_st: mut FishingState, x: float, z: float) -> int {
export function fishing_cast(fishing_st: mut FishingState, x: float, z: float) -> int {
if fishing_st.fishing_st != FISHING_OFF { return FISHING_BUSY }
fishing_st.fishing_bx = x
fishing_st.fishing_bz = z
@ -17,8 +17,8 @@ export function fishing_cast(base_st: mut BaseState, fishing_st: mut FishingStat
var wait = 6.0 + fishing_rand(fishing_st) * 14.0
if fishing_st.fishing_bait_on { wait = wait * 0.5 }
fishing_st.fishing_t = wait * FishingWorld.bite_mult()
if fishing_st.fishing_bait_on { fishing_say(base_st, fishing_st, FISHING_BAIT_USED) }
fishing_say(base_st, fishing_st, FISHING_CAST)
if fishing_st.fishing_bait_on { fishing_say(fishing_st, FISHING_BAIT_USED) }
fishing_say(fishing_st, FISHING_CAST)
return FISHING_CAST_OK
}
@ -32,7 +32,7 @@ export function fishing_stop(fishing_st: mut FishingState) -> void {
fishing_st.fishing_run_t = 0.0
}
function fishing_strike(base_st: mut BaseState, fishing_st: mut FishingState) -> void {
function fishing_strike(fishing_st: mut FishingState) -> void {
let k = FishSpecies[fishing_st.fishing_sp]
fishing_st.fishing_st = FISHING_REEL
fishing_st.fishing_won = 0
@ -51,55 +51,55 @@ function fishing_strike(base_st: mut BaseState, fishing_st: mut FishingState) ->
fishing_st.fishing_ring_t = 2.0
}
fishing_new_window(fishing_st)
fishing_say(base_st, fishing_st, FISHING_HOOKED)
fishing_say(fishing_st, FISHING_HOOKED)
}
function fishing_land(base_st: mut BaseState, fishing_st: mut FishingState) -> void {
function fishing_land(fishing_st: mut FishingState) -> void {
fishing_st.fishing_n += 1
if fishing_st.fishing_len > fishing_st.fishing_big { fishing_st.fishing_big = fishing_st.fishing_len }
if FishSpecies[fishing_st.fishing_sp].legend { fishing_st.fishing_leg = true }
fishing_say(base_st, fishing_st, FISHING_CAUGHT)
fishing_say(fishing_st, FISHING_CAUGHT)
fishing_stop(fishing_st)
}
function fishing_lost(base_st: mut BaseState, fishing_st: mut FishingState, what: int) -> void {
fishing_say(base_st, fishing_st, what)
function fishing_lost(fishing_st: mut FishingState, what: int) -> void {
fishing_say(fishing_st, what)
fishing_stop(fishing_st)
}
function fishing_reel_press(base_st: mut BaseState, fishing_st: mut FishingState) -> void {
function fishing_reel_press(fishing_st: mut FishingState) -> void {
if fishing_st.fishing_gentle_on {
if fishing_st.fishing_ring_t > 0.0 { fishing_land(base_st, fishing_st) } else { fishing_lost(base_st, fishing_st, FISHING_LINE_SNAPPED) }
if fishing_st.fishing_ring_t > 0.0 { fishing_land(fishing_st) } else { fishing_lost(fishing_st, FISHING_LINE_SNAPPED) }
return
}
if fishing_st.fishing_run_t > 0.0 {
fishing_st.fishing_won = Math.max(fishing_st.fishing_won - 1, 0)
fishing_say(base_st, fishing_st, FISHING_CHECKED)
fishing_say(fishing_st, FISHING_CHECKED)
return
}
if fishing_in_window(fishing_st) {
fishing_st.fishing_won += 1
fishing_new_window(fishing_st)
if fishing_st.fishing_won >= fishing_st.fishing_need_n { fishing_land(base_st, fishing_st) } else { fishing_say(base_st, fishing_st, FISHING_GOOD) }
if fishing_st.fishing_won >= fishing_st.fishing_need_n { fishing_land(fishing_st) } else { fishing_say(fishing_st, FISHING_GOOD) }
return
}
if FishSpecies[fishing_st.fishing_sp].legend and fishing_st.fishing_won > 0 {
fishing_st.fishing_won -= 1
fishing_say(base_st, fishing_st, FISHING_TURNED)
fishing_say(fishing_st, FISHING_TURNED)
return
}
fishing_lost(base_st, fishing_st, FISHING_LINE_SNAPPED)
fishing_lost(fishing_st, FISHING_LINE_SNAPPED)
}
# the button: waiting it reels in, on a bite it strikes, on a fish it reels
export function fishing_press(base_st: mut BaseState, fishing_st: mut FishingState) -> void {
export function fishing_press(fishing_st: mut FishingState) -> void {
if fishing_st.fishing_st == FISHING_WAIT {
fishing_lost(base_st, fishing_st, FISHING_REELED_IN)
fishing_lost(fishing_st, FISHING_REELED_IN)
return
}
if fishing_st.fishing_st == FISHING_BITE_ON {
fishing_strike(base_st, fishing_st)
fishing_strike(fishing_st)
return
}
if fishing_st.fishing_st == FISHING_REEL { fishing_reel_press(base_st, fishing_st) }
if fishing_st.fishing_st == FISHING_REEL { fishing_reel_press(fishing_st) }
}