Merge branch 'lang/trail' into lang/uifree

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 }

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"

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 {
+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, tk_now())
+  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
 }

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)
 }
 

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<TrackRead> = tk_reads__new()
 }
 

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))
 }
 

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)
+  }
+}

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, 1, 10.0, 0.0, 0.0, 1, false, -1)
-    tracks_leave(tracks_st, 2, 1.0, 1.0, 0.0, 2, false)
+    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)