From 6e465b233f04ea54f31cc6d1c0f882ec67343653 Mon Sep 17 00:00:00 2001 From: Orkuncakilkaya Date: Sun, 27 Sep 2026 21:31:14 +0300 Subject: [PATCH] wip(tracks): phase 5 - a print names its maker, and a read print points at the next one (the chain); goes with maroon-lake phase-5 Co-Authored-By: Claude Opus 5.5 --- packages/ludic.tracks/chain.ludic | 60 ++++++++ packages/ludic.tracks/index.ludic | 1 + packages/ludic.tracks/leave.ludic | 8 +- packages/ludic.tracks/read.ludic | 1 + packages/ludic.tracks/state.ludic | 6 + packages/ludic.tracks/system.ludic | 1 + packages/ludic.tracks/tests/chain_test.ludic | 132 ++++++++++++++++++ packages/ludic.tracks/tests/tracks_test.ludic | 20 +-- 8 files changed, 216 insertions(+), 13 deletions(-) create mode 100644 packages/ludic.tracks/chain.ludic create mode 100644 packages/ludic.tracks/tests/chain_test.ludic diff --git a/packages/ludic.tracks/chain.ludic b/packages/ludic.tracks/chain.ludic new file mode 100644 index 00000000..cf89c8a9 --- /dev/null +++ b/packages/ludic.tracks/chain.ludic @@ -0,0 +1,60 @@ +# chain.ludic - a trail to follow. Reading a print names its maker, and the next clue is the +# newest print that animal left later within TRACK_CHAIN_R of it; reading that one moves the trail +# on. A legend's print names no maker, a print of another animal starts a new trail, and a trail +# not read for TRACK_CHAIN_H game hours (ten real minutes at the valley's pace) goes cold. +export const TRACK_CHAIN_R: float = 60.0 +export const TRACK_CHAIN_H: float = 10.0 + +function tk_chain_read(tracks_st: mut TracksState, t: Track) -> void { + if t.legend or t.maker < 0 { + tracks_st.tk_chain = -1 + return + } + tracks_st.tk_chain = t.maker + tracks_st.tk_chain_x = t.x + tracks_st.tk_chain_z = t.z + tracks_st.tk_chain_made = t.made + tracks_st.tk_chain_h = tk_now() +} + +# the animal whose trail is being followed, -1 none or gone cold +export function tracks_chain_maker(tracks_st: TracksState) -> int { + if tracks_st.tk_chain < 0 or tk_now() - tracks_st.tk_chain_h > TRACK_CHAIN_H { return -1 } + return tracks_st.tk_chain +} + +# where the trail's last read sign is (the fallback's centre: the animal itself, when near it) +export function tracks_chain_x(tracks_st: TracksState) -> float { return tracks_st.tk_chain_x } +export function tracks_chain_z(tracks_st: TracksState) -> float { return tracks_st.tk_chain_z } + +# the next clue: a slot, or -1 when the trail has none left in reach (or none is followed) +export function tracks_chain_next(tracks_st: TracksState) -> int { + let m = tracks_chain_maker(tracks_st) + if m < 0 { return -1 } + return tracks_after(tracks_st, m, tracks_st.tk_chain_x, tracks_st.tk_chain_z, tracks_st.tk_chain_made, TRACK_CHAIN_R) +} + +# the newest print `maker` left after `made`, within r of (x, z), -1 none +export function tracks_after(tracks_st: TracksState, maker: int, x: float, z: float, made: float, r: float) -> int { + if tracks_st.tk_ring == null or maker < 0 { return -1 } + var best = -1 + var best_made = made + for k in 0 .. tracks_st.tk_kinds { + for i in 0 .. tracks_st.tk_count[k] { + let s = k * tracks_st.tk_cap + i + let t = tracks_st.tk_ring[s] + if t.maker != maker or t.made <= best_made { continue } + let dx = t.x - x + let dz = t.z - z + if dx * dx + dz * dz > r * r { continue } + best = s + best_made = t.made + } + } + return best +} + +export function tracks_maker(tracks_st: TracksState, slot: int) -> int { return tracks_st.tk_ring[slot].maker } + +# the trail dropped (a sign of another animal read some other way, a new world) +export function tracks_chain_end(tracks_st: mut TracksState) -> void { tracks_st.tk_chain = -1 } diff --git a/packages/ludic.tracks/index.ludic b/packages/ludic.tracks/index.ludic index 509116de..50d3fb83 100644 --- a/packages/ludic.tracks/index.ludic +++ b/packages/ludic.tracks/index.ludic @@ -7,5 +7,6 @@ import "state.ludic" import "config.ludic" import "leave.ludic" import "read.ludic" +import "chain.ludic" import "queries.ludic" import "system.ludic" diff --git a/packages/ludic.tracks/leave.ludic b/packages/ludic.tracks/leave.ludic index d7b95414..f05a2b76 100644 --- a/packages/ludic.tracks/leave.ludic +++ b/packages/ludic.tracks/leave.ludic @@ -3,7 +3,7 @@ function tk_ok(tracks_st: TracksState, kind: int) -> bool { return tracks_st.tk_ring != null and kind >= 0 and kind < tracks_st.tk_kinds } # a print made at `made` game hours (another machine's, arriving here); the ring index, or -1 -export function tracks_leave_at(tracks_st: mut TracksState, kind: int, x: float, z: float, yaw: float, sp: int, legend: bool, made: float) -> int { +export function tracks_leave_at(tracks_st: mut TracksState, kind: int, x: float, z: float, yaw: float, sp: int, legend: bool, maker: int, made: float) -> int { if not tk_ok(tracks_st, kind) { return -1 } var i = tracks_st.tk_next[kind] if tracks_st.tk_count[kind] < tracks_st.tk_cap { @@ -17,14 +17,15 @@ export function tracks_leave_at(tracks_st: mut TracksState, kind: int, x: float, t.yaw = yaw t.sp = sp t.legend = legend + t.maker = maker t.made = made t.read = false TracksWorld.placed(kind, i) return i } -export function tracks_leave(tracks_st: mut TracksState, kind: int, x: float, z: float, yaw: float, sp: int, legend: bool) -> int { - return tracks_leave_at(tracks_st, kind, x, z, yaw, sp, legend, tk_now()) +export function tracks_leave(tracks_st: mut TracksState, kind: int, x: float, z: float, yaw: float, sp: int, legend: bool, maker: int) -> int { + return tracks_leave_at(tracks_st, kind, x, z, yaw, sp, legend, maker, tk_now()) } # the ground forgets every print (a new world) @@ -34,4 +35,5 @@ export function tracks_clear(tracks_st: mut TracksState) -> void { tracks_st.tk_count[k] = 0 tracks_st.tk_next[k] = 0 } + tracks_st.tk_chain = -1 } diff --git a/packages/ludic.tracks/read.ludic b/packages/ludic.tracks/read.ludic index 0e989e0a..d039da3f 100644 --- a/packages/ludic.tracks/read.ludic +++ b/packages/ludic.tracks/read.ludic @@ -28,6 +28,7 @@ export function tracks_read(tracks_st: mut TracksState, slot: int) -> void { f.first = not t.read t.read = true tracks_note_bearing(tracks_st, t.yaw) + tk_chain_read(tracks_st, t) tk_push(tracks_st, f) } diff --git a/packages/ludic.tracks/state.ludic b/packages/ludic.tracks/state.ludic index 303b244a..29d92b55 100644 --- a/packages/ludic.tracks/state.ludic +++ b/packages/ludic.tracks/state.ludic @@ -28,6 +28,7 @@ export property Track { yaw: float = 0.0 sp: int = 0 legend: bool = false + maker: int = -1 # the animal that left it (the game's nid), -1 not known made: float = 0.0 read: bool = false } @@ -59,6 +60,11 @@ export state TracksState { tk_read_n: int = 0 # signs read for the first time, of every source tk_yaw: float = 0.0 # the heading of the last sign read tk_has_yaw: bool = false + tk_chain: int = -1 # the maker of the trail being followed, -1 none (chain.ludic) + tk_chain_x: float = 0.0 # the last of its signs read: where, and when it was made + tk_chain_z: float = 0.0 + tk_chain_made: float = 0.0 + tk_chain_h: float = 0.0 # when it was read, in game hours tk_reads: Queue = tk_reads__new() } diff --git a/packages/ludic.tracks/system.ludic b/packages/ludic.tracks/system.ludic index 981d6a30..9a5d6dd3 100644 --- a/packages/ludic.tracks/system.ludic +++ b/packages/ludic.tracks/system.ludic @@ -4,6 +4,7 @@ export function tracks_reset(tracks_st: mut TracksState) -> void { tracks_st.tk_read_n = 0 tracks_st.tk_yaw = 0.0 tracks_st.tk_has_yaw = false + tracks_st.tk_chain = -1 q_clear(tracks_reads(tracks_st)) } diff --git a/packages/ludic.tracks/tests/chain_test.ludic b/packages/ludic.tracks/tests/chain_test.ludic new file mode 100644 index 00000000..03ada4cc --- /dev/null +++ b/packages/ludic.tracks/tests/chain_test.ludic @@ -0,0 +1,132 @@ +# chain_test.ludic - a trail to follow: a read print points at the newest later one its maker left +# within reach, reading that moves the trail on, and it ends on a legend, another animal, time, +# the ring writing over it, or a new world +import "ludic.tracks" +import "ludic.base" +program TracksChainTest { + 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)) } + + # a deer walking east, a print every 3 m from x = 0, an hour apart each + function walk(tracks_st: mut TracksState, tracks_test_st: mut TracksTestState, maker: int, n: int) -> void { + for k in 0 .. n { + tracks_leave(tracks_st, 1, float(k) * 3.0, 0.0, 1.0, 7, false, maker) + tracks_test_st.now += 0.1 + } + } + + test "a read print points at the newest later one in reach, and reading it moves on" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) { + fresh(tracks_st, tracks_test_st) + tracks_config(tracks_st, 3, 64) + walk(tracks_st, tracks_test_st, 42, 40) + expect_eq(tracks_chain_next(tracks_st), -1) + tracks_read(tracks_st, tracks_nearest(tracks_st, 0.0, 0.0, 1.0)) + expect_eq(tracks_chain_maker(tracks_st), 42) + let n = tracks_chain_next(tracks_st) + expect(n >= 0) + expect_eq(tracks_maker(tracks_st, n), 42) + expect(tracks_x(tracks_st, n) <= TRACK_CHAIN_R) + expect(tracks_x(tracks_st, n) > TRACK_CHAIN_R - 3.0) + tracks_read(tracks_st, n) + let m = tracks_chain_next(tracks_st) + expect(tracks_x(tracks_st, m) > tracks_x(tracks_st, n)) + } + + test "another animal's prints are not the trail" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) { + fresh(tracks_st, tracks_test_st) + tracks_config(tracks_st, 3, 64) + tracks_leave(tracks_st, 1, 0.0, 0.0, 1.0, 7, false, 1) + tracks_test_st.now += 0.1 + tracks_leave(tracks_st, 1, 10.0, 0.0, 1.0, 7, false, 2) + tracks_read(tracks_st, tracks_nearest(tracks_st, 0.0, 0.0, 1.0)) + expect_eq(tracks_chain_next(tracks_st), -1) + tracks_read(tracks_st, tracks_nearest(tracks_st, 10.0, 0.0, 1.0)) + expect_eq(tracks_chain_maker(tracks_st), 2) + } + + test "a legend's print names no maker and ends the trail" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) { + fresh(tracks_st, tracks_test_st) + tracks_config(tracks_st, 3, 64) + walk(tracks_st, tracks_test_st, 5, 4) + tracks_leave(tracks_st, 1, 100.0, 0.0, 1.0, 9, true, 6) + tracks_read(tracks_st, tracks_nearest(tracks_st, 0.0, 0.0, 1.0)) + expect_eq(tracks_chain_maker(tracks_st), 5) + tracks_read(tracks_st, tracks_nearest(tracks_st, 100.0, 0.0, 1.0)) + expect_eq(tracks_chain_maker(tracks_st), -1) + expect_eq(tracks_chain_next(tracks_st), -1) + } + + test "a trail goes cold after its hours, and a new world forgets it" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) { + fresh(tracks_st, tracks_test_st) + tracks_config(tracks_st, 3, 64) + walk(tracks_st, tracks_test_st, 42, 10) + tracks_read(tracks_st, tracks_nearest(tracks_st, 0.0, 0.0, 1.0)) + expect(tracks_chain_next(tracks_st) >= 0) + tracks_test_st.now += TRACK_CHAIN_H + 0.5 + expect_eq(tracks_chain_maker(tracks_st), -1) + expect_eq(tracks_chain_next(tracks_st), -1) + tracks_test_st.now -= TRACK_CHAIN_H + 0.5 + tracks_clear(tracks_st) + expect_eq(tracks_chain_maker(tracks_st), -1) + } + + test "the trail survives the ring writing over the print it came from" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) { + fresh(tracks_st, tracks_test_st) + tracks_config(tracks_st, 3, 8) + walk(tracks_st, tracks_test_st, 42, 4) + tracks_read(tracks_st, tracks_nearest(tracks_st, 0.0, 0.0, 1.0)) + for k in 0 .. 8 { tracks_leave(tracks_st, 1, 500.0, 0.0, 0.0, 7, false, 99) } + expect_eq(tracks_chain_maker(tracks_st), 42) + expect_eq(tracks_chain_next(tracks_st), -1) + tracks_leave(tracks_st, 1, 20.0, 0.0, 0.0, 7, false, 42) + expect_eq(tracks_x(tracks_st, tracks_chain_next(tracks_st)), 20.0) + } + + test "followed five times along a 200 m walk, the trail ends within reach of the animal" (tracks_st: mut TracksState, tracks_test_st: mut TracksTestState) { + fresh(tracks_st, tracks_test_st) + tracks_config(tracks_st, 3, 128) + walk(tracks_st, tracks_test_st, 7, 67) + let deer_x = 66.0 * 3.0 + var at = tracks_nearest(tracks_st, 0.0, 0.0, 1.0) + tracks_read(tracks_st, at) + for k in 0 .. 5 { + let n = tracks_chain_next(tracks_st) + if n < 0 { break } + expect(tracks_x(tracks_st, n) > tracks_x(tracks_st, at)) + at = n + tracks_read(tracks_st, at) + } + expect(deer_x - tracks_x(tracks_st, at) <= TRACK_CHAIN_R) + expect(tracks_x(tracks_st, at) > 150.0) + } +} diff --git a/packages/ludic.tracks/tests/tracks_test.ludic b/packages/ludic.tracks/tests/tracks_test.ludic index ae193349..dda4b635 100644 --- a/packages/ludic.tracks/tests/tracks_test.ludic +++ b/packages/ludic.tracks/tests/tracks_test.ludic @@ -39,7 +39,7 @@ program TracksTest { 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) + 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) @@ -51,7 +51,7 @@ program TracksTest { 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) } + 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) @@ -59,7 +59,7 @@ program TracksTest { 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) + 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) @@ -70,15 +70,15 @@ program TracksTest { 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) - tracks_leave(tracks_st, 2, 1.0, 1.0, 0.0, 2, false) + 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) + 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) @@ -96,7 +96,7 @@ program TracksTest { 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) + 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) } @@ -113,15 +113,15 @@ program TracksTest { 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) + 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) } + 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) + 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)