feedback1c WJ: ticker queue helpers; a newer leader-damage line replaces the older one

Review follow-up for the Hidden Core broadcast fix. The strip's queue rules are
now pure, exported helpers (tickerSupersedes, enqueueTickerLines,
pruneTickerLines, nextTickerLine) with unit tests across a round 14 -> 15
change, instead of source regex checks only.

A player's newer BOSS_HIT line of the same round replaces their older one,
queued or on screen (it names a higher threshold), so a burst finish shows its
highest milestone before the round ends and the last round's lines are dropped.
Lines now carry playerId from main.js. The solo match test is labelled 绝境
(HARD), the difficulty it runs.

test/ui/bosshit-ticker.test.js

@@ -2,16 +2,24 @@
 // server/match/Match.js, test/match/bosshit-ticker.test.js) the ticker strip plays its queue in order, TICKER_MS (5.2 s)
 // per line and up to QUEUE_MAX (4) lines behind: in a headless-Chrome run the Final Assault's "超过20%" / "超过80%"
 // lines played 2–8 s into the Hidden Core with its leader at 96 % / 53 %. A leader-damage line (BOSS_HIT) now plays
-// only during the round it came in (ui/ticker.js tickerLineLive; main.js stamps each line with its type and round).
+// only during the round it came in, and a player's newer BOSS_HIT line of the round supersedes their older one, queued
+// or on screen (ui/ticker.js: tickerLineLive, tickerSupersedes, enqueueTickerLines, pruneTickerLines, nextTickerLine;
+// main.js stamps each line with its type, player and round). The strip component is a thin shell over these helpers.
 
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 
-const { tickerLineLive } = await import('../../public/js/ui/ticker.js');
+const { tickerLineLive, tickerSupersedes, enqueueTickerLines, pruneTickerLines, nextTickerLine } = await import('../../public/js/ui/ticker.js');
+
+let ids = 0;
+/** A BOSS_HIT line of `playerId` for threshold `pct` that came in during `round`. */
+const hit = (playerId, pct, round) => ({ id: ++ids, type: 'BOSS_HIT', playerId, round, text: `${playerId}博士对敌方领袖造成的伤害超过${pct}%!` });
+const line = (type, round, text = type) => ({ id: ++ids, type, playerId: null, round, text });
+const texts = (q) => q.map((t) => t.text);
 
 test('tickerLineLive: a BOSS_HIT line plays only in the round it came in; every other line always plays', () => {
-  const fa = { type: 'BOSS_HIT', round: 14, text: 'P博士对敌方领袖造成的伤害超过50%!' };
+  const fa = hit('P', 50, 14);
   assert.equal(tickerLineLive(fa, 14), true, 'during the Final Assault');
   assert.equal(tickerLineLive(fa, 15), false, 'the Hidden Core\'s round: the Final Assault\'s line is stale');
   assert.equal(tickerLineLive({ ...fa, round: 15 }, 15), true, 'the Hidden Core\'s own line');
@@ -27,11 +35,125 @@ test('tickerLineLive: a BOSS_HIT line plays only in the round it came in; every
   assert.equal(tickerLineLive(null, 15), true);
 });
 
-test('main.js stamps every ticker line with its type and the round it came in; the strip filters on a round change', () => {
+test('round 14 → 15: the Final Assault\'s leader-damage lines leave the queue and the strip; other lines stay, in order', () => {
+  const queue = [hit('A', 50, 14), line('GOLDEN_CHAR', 14, 'A博士的X干员晋升为精锐'), hit('B', 20, 14), hit('A', 80, 14), line('CUSTOM', 15, '隐秘核心已解锁')];
+  // a Final Assault line on screen when the Hidden Core's round starts
+  const r = pruneTickerLines(queue, hit('B', 50, 14), 15);
+  assert.equal(r.dropCur, true, 'the Final Assault line on screen leaves');
+  assert.deepEqual(texts(r.queue), ['A博士的X干员晋升为精锐', '隐秘核心已解锁']);
+  const n = nextTickerLine(r.queue, 15);
+  assert.equal(n.line.text, 'A博士的X干员晋升为精锐');
+  assert.deepEqual(texts(n.queue), ['隐秘核心已解锁']);
+  // a CUSTOM / CHAR_DAMAGE line on screen stays
+  assert.equal(pruneTickerLines(queue, line('CUSTOM', 14), 15).dropCur, false);
+  assert.equal(pruneTickerLines(queue, line('CHAR_DAMAGE', 14), 15).dropCur, false);
+  assert.equal(pruneTickerLines(queue, null, 15).dropCur, false);
+  // the same round (a field's prep → battle, a reconnect re-sending m.public): nothing leaves
+  assert.equal(pruneTickerLines(queue, hit('B', 50, 14), 14).dropCur, false);
+  assert.equal(pruneTickerLines(queue, null, 14).queue.length, queue.length);
+  // the Hidden Core's own lines live in its round
+  const hidden = pruneTickerLines([hit('A', 20, 15)], null, 15);
+  assert.equal(hidden.queue.length, 1);
+});
+
+test('nextTickerLine skips stale leader-damage lines (the line timer firing after a round change)', () => {
+  const queue = [hit('A', 20, 14), hit('B', 50, 14), line('SHOP_LEVEL', 14, 'B博士将调度中心等级提升为6级'), hit('A', 20, 15)];
+  const a = nextTickerLine(queue, 15);
+  assert.equal(a.line.text, 'B博士将调度中心等级提升为6级');
+  const b = nextTickerLine(a.queue, 15);
+  assert.equal(b.line.text, 'A博士对敌方领袖造成的伤害超过20%!');
+  assert.equal(b.line.round, 15);
+  assert.deepEqual(nextTickerLine(b.queue, 15), { line: null, queue: [] });
+  assert.deepEqual(nextTickerLine([hit('A', 20, 14)], 15), { line: null, queue: [] }, 'only stale lines: nothing to show');
+  // the queue passed in is not changed
+  assert.equal(queue.length, 4);
+});
+
+test('a player\'s newer leader-damage line of the round supersedes their older one, on screen or queued', () => {
+  assert.equal(tickerSupersedes(hit('A', 50, 14), hit('A', 20, 14)), true);
+  assert.equal(tickerSupersedes(hit('A', 50, 14), hit('B', 20, 14)), false, 'another player');
+  assert.equal(tickerSupersedes(hit('A', 20, 15), hit('A', 80, 14)), false, 'another round (the Hidden Core after the Final Assault)');
+  assert.equal(tickerSupersedes(hit(null, 50, 14), hit(null, 20, 14)), false, 'player unknown');
+  assert.equal(tickerSupersedes(line('CHAR_DAMAGE', 14), line('CHAR_DAMAGE', 14)), false, 'other line types queue as before');
+  assert.equal(tickerSupersedes(hit('A', 50, 14), line('CUSTOM', 14)), false);
+
+  // on screen: A's 20 % is replaced at once by A's 50 %, then 80 % (one batch)
+  const a20 = hit('A', 20, 14);
+  const onScreen = enqueueTickerLines([], a20, [hit('A', 50, 14), hit('A', 80, 14)]);
+  assert.equal(onScreen.cur.text, 'A博士对敌方领袖造成的伤害超过80%!');
+  assert.deepEqual(onScreen.queue, []);
+  // queued: B's 20 % gives way to B's 50 %, which takes its turn at the back; other lines keep their order
+  const shop = line('SHOP_LEVEL', 14, 'A博士将调度中心等级提升为6级');
+  const queued = enqueueTickerLines([hit('B', 20, 14), shop], a20, [hit('B', 50, 14)]);
+  assert.equal(queued.cur, a20, 'the line on screen is another player\'s: it stays');
+  assert.deepEqual(texts(queued.queue), ['A博士将调度中心等级提升为6级', 'B博士对敌方领袖造成的伤害超过50%!']);
+  // nothing on screen: lines queue (the strip then shows the first)
+  const idle = enqueueTickerLines([], null, [hit('A', 20, 14), line('CUSTOM', 14, 'x')]);
+  assert.equal(idle.cur, null);
+  assert.equal(idle.queue.length, 2);
+  // only the newest QUEUE_MAX (4) stay queued
+  const many = enqueueTickerLines([], a20, [1, 2, 3, 4, 5, 6].map((i) => line('CUSTOM', 14, `c${i}`)));
+  assert.deepEqual(texts(many.queue), ['c3', 'c4', 'c5', 'c6']);
+});
+
+/**
+ * The strip's timeline, composed from the helpers the way ui/ticker.js composes them: each event is
+ * { at (s), round } with `lines` arriving (stamped with that round) or a round change. Returns what is on screen when.
+ */
+function playStrip(events, until) {
+  const TICKER_S = 5.2;
+  let queue = [], cur = null, curUntil = Infinity, round = null;
+  const shown = [];
+  const show = (it, at) => { cur = it; curUntil = it ? at + TICKER_S : Infinity; if (it) shown.push({ at, round, text: it.text }); };
+  const advance = (to) => {
+    while (cur && curUntil <= to) { const at = curUntil; const n = nextTickerLine(queue, round); queue = n.queue; show(n.line, at); }
+  };
+  for (const ev of [...events, { at: until }]) {
+    advance(ev.at);
+    if (ev.round != null && ev.round !== round) {
+      round = ev.round;
+      const r = pruneTickerLines(queue, cur, round);
+      queue = r.queue;
+      if (r.dropCur) { const n = nextTickerLine(queue, round); queue = n.queue; show(n.line, ev.at); }
+    }
+    if (ev.lines) {
+      const fresh = ev.lines.map((l) => ({ ...l, round }));
+      const r = enqueueTickerLines(queue, cur, fresh);
+      queue = r.queue;
+      if (r.cur !== cur) show(r.cur, ev.at);
+      else if (!cur) { const n = nextTickerLine(queue, round); queue = n.queue; show(n.line, ev.at); }
+    }
+  }
+  return shown;
+}
+
+test('timeline: a Final Assault burst shows its top milestone before the round ends, and none of it plays over the Hidden Core', () => {
+  // the reviewer's headless run: the Final Assault ends in a burst (20 → 50 → 80 % within 1.5 s), a shop-level line is
+  // still queued, the Hidden Core's round starts 3 s later (SETTLE) with "隐秘核心已解锁"
+  const shown = playStrip([
+    { at: 0, round: 14, lines: [line('SHOP_LEVEL', null, 'B博士将调度中心等级提升为6级')] },
+    { at: 1, round: 14, lines: [hit('A', 20)] },
+    { at: 2, round: 14, lines: [hit('A', 50)] },
+    { at: 2.5, round: 14, lines: [hit('A', 80)] },
+    { at: 5.5, round: 15, lines: [line('CUSTOM', null, '隐秘核心已解锁')] },
+    { at: 30, round: 15, lines: [hit('A', 20)] },
+  ], 60);
+  const r14 = shown.filter((s) => s.round === 14).map((s) => s.text);
+  const r15 = shown.filter((s) => s.round === 15).map((s) => s.text);
+  // the shop line plays first (0 – 5.2 s); A's lines collapse into the 80 % line, which plays at 5.2 s until the round change
+  assert.deepEqual(r14, ['B博士将调度中心等级提升为6级', 'A博士对敌方领袖造成的伤害超过80%!']);
+  assert.ok(!r15.some((t) => t.includes('超过80%') || t.includes('超过50%')), `no Final Assault line in the Hidden Core: ${r15.join(' | ')}`);
+  assert.deepEqual(r15, ['隐秘核心已解锁', 'A博士对敌方领袖造成的伤害超过20%!']);
+  assert.equal(shown.find((s) => s.text === '隐秘核心已解锁').at, 5.5, 'the Hidden Core\'s unlock line shows as its round starts');
+});
+
+test('main.js stamps every ticker line with its type, player and round; the strip is built on the helpers', () => {
   const main = readFileSync(new URL('../../public/js/main.js', import.meta.url), 'utf8');
   const handler = main.slice(main.indexOf("net.on('m.ticker'"), main.indexOf("net.on('m.emote'"));
-  assert.match(handler, /type,\s*round:\s*s\.match\?\.public\?\.round/, 'the m.ticker handler keeps type and round');
+  assert.match(handler, /type, playerId, round:\s*s\.match\?\.public\?\.round/, 'the m.ticker handler keeps type, player and round');
   const strip = readFileSync(new URL('../../public/js/ui/ticker.js', import.meta.url), 'utf8');
-  assert.match(strip, /useStore\(\(s\) => s\.match\?\.public\?\.round/, 'the strip follows m.public.round');
-  assert.match(strip, /\}, \[round\]\);/, 'a round change re-filters the queue and the line on screen');
+  const comp = strip.slice(strip.indexOf('export function Ticker('));
+  assert.match(comp, /useStore\(\(s\) => s\.match\?\.public\?\.round/, 'the strip follows m.public.round');
+  for (const fn of ['enqueueTickerLines(', 'pruneTickerLines(', 'nextTickerLine(']) assert.ok(comp.includes(fn), `the strip uses ${fn})`);
+  assert.match(comp, /\}, \[round\]\);/, 'a round change re-filters the queue and the line on screen');
 });