feedback1c WJ: Hidden Core damage broadcasts count only the hidden leader

Player report: "隐藏boss还没打就出了造成50%伤害播报". The BOSS_HIT ticker
("{0}博士对敌方领袖造成的伤害超过20/50/80%!") divided the player's boss damage of
the whole match (stats.bossDamage, Final Assault + Hidden Core) by the hidden
leader's pool, so the Hidden Core's first hit already announced 50 % or 80 %.
The share is now the player's damage to the current round's pool
(SharedBossPool.byPlayer) over its size; 领袖伤害 on the result keeps both rounds.

The browser's ticker strip plays its queue 5.2 s per line, so a Final Assault
line could still play over the fresh hidden leader: a BOSS_HIT line is now
dropped once the round it came in is over (ui/ticker.js tickerLineLive; lines
carry their type and round from main.js).

docs/META.md

@@ -592,8 +592,11 @@ is called without protocol validation); 1 per second per player (`RATE`).
 Tickers (`m.ticker { text, id, type, priority, playerId }`) from `config.broadcasts`: SHOP_LEVEL, GOLDEN_CHAR,
 CHAR_DAMAGE (per board unit per battle, highest threshold; summons created in battle once per unit type — a client
 result may only name the unit types its lineup can field, fields.js validateClientResult), BOSS_HIT (20/50/80 % of the
-pool per player), CHAR_GIFT (to the
-receiver only), plus CUSTOM texts (eliminations, 联防, hidden core).
+current leader per player, each threshold once per boss round: the player's damage to that round's shared pool,
+`SharedBossPool.byPlayer`, over its size — the Final Assault and the Hidden Core count apart, while `stats.bossDamage`,
+the result's 领袖伤害, adds both up; the browser's strip, which plays its queue 5.2 s per line, drops a BOSS_HIT line
+once the round it came in is over — public/js/ui/ticker.js `tickerLineLive`), CHAR_GIFT (to the receiver only), plus
+CUSTOM texts (eliminations, 联防, hidden core).
 
 ---
 

public/js/main.js

@@ -217,7 +217,9 @@ function wireNet() {
   });
   net.on('m.ticker', (msg) => {
     if (typeof msg.text !== 'string') return;
-    store.set((s) => ({ ticker: [...s.ticker.slice(-(TICKER_KEEP - 1)), { id: ++seq, text: msg.text, at: Date.now() }] }));
+    // type + the round it came in: a BOSS_HIT line is dropped once its boss round is over (ui/ticker.js tickerLineLive)
+    const type = typeof msg.type === 'string' ? msg.type : null;
+    store.set((s) => ({ ticker: [...s.ticker.slice(-(TICKER_KEEP - 1)), { id: ++seq, text: msg.text, at: Date.now(), type, round: s.match?.public?.round ?? null }] }));
   });
   net.on('m.emote', (msg) => {
     store.set((s) => ({ emotes: [...s.emotes.slice(-(EMOTE_KEEP - 1)), { seq: ++seq, playerId: msg.playerId, id: msg.id, at: Date.now() }] }));

public/js/ui/ticker.js

@@ -1,5 +1,9 @@
 // Broadcast ticker (m.ticker): a strip under the top bar; each line slides in from the right, stays
 // TICKER_MS and leaves; queued lines play in order (only the newest QUEUE_MAX are kept).
+// A leader-damage line (BOSS_HIT "{0}博士对敌方领袖造成的伤害超过X%!") is news about the leader in play: it is dropped,
+// queued or on screen, once the round it came in is over — the queue can lag a line by up to QUEUE_MAX × TICKER_MS, and
+// a Final Assault line must never play over the Hidden Core's fresh leader (player report after 0.1.0: "隐藏boss还没打
+// 就出了造成50%伤害播报"). Lines carry `type` and `round` from main.js (the m.ticker handler).
 
 import { useEffect, useRef, useState } from '../../vendor/hooks.module.js';
 import { html } from './components.js';
@@ -10,13 +14,27 @@ import { audio } from '../audio.js';
 const TICKER_MS = 5200;
 const QUEUE_MAX = 4;
 
+/**
+ * Whether a ticker line may still play in `round` (m.public.round): every line except a BOSS_HIT line from another
+ * round (the Final Assault's lines once the Hidden Core's round started). Lines without a round always play.
+ * @param {{ type?: string|null, round?: number|null }|null} line
+ * @param {number|null} round
+ */
+export function tickerLineLive(line, round) {
+  if (!line || line.type !== 'BOSS_HIT') return true;
+  return line.round == null || round == null || line.round === round;
+}
+
 /** Ticker strip bound to store.ticker. */
 export function Ticker() {
   const items = useStore((s) => s.ticker);
+  const round = useStore((s) => s.match?.public?.round ?? null);
   const seen = useRef(null);
   const queue = useRef([]);
+  const roundRef = useRef(round);
   const [cur, setCur] = useState(null);
   const timer = useRef(null);
+  roundRef.current = round;
 
   useEffect(() => {
     const list = Array.isArray(items) ? items : [];
@@ -32,14 +50,21 @@ export function Ticker() {
     if (!cur) next();
   }, [items]);
 
+  // a new round: the last round's leader-damage lines leave the queue and the strip
+  useEffect(() => {
+    queue.current = queue.current.filter((t) => tickerLineLive(t, round));
+    if (cur && !tickerLineLive(cur, round)) next();
+  }, [round]);
+
   useEffect(() => () => clearTimeout(timer.current), []);
 
   function next() {
-    const it = queue.current.shift() || null;
+    let it = queue.current.shift() || null;
+    while (it && !tickerLineLive(it, roundRef.current)) it = queue.current.shift() || null;
     setCur(it);
+    clearTimeout(timer.current);
     if (it) {
       audio.sfx('broadcast', { volume: 0.5 });
-      clearTimeout(timer.current);
       timer.current = setTimeout(next, TICKER_MS);
     }
   }

server/match/Match.js

@@ -2794,13 +2794,16 @@ export class Match {
       for (const ps of alive) ps.lpAtFinal = Math.max(0, ps.lp);
     }
     const bossId = hidden ? this.hiddenBossId : this.bossId;
+    // BOSS_HIT tickers ("对敌方领袖造成的伤害超过20% / 50% / 80%"): the player's damage to THIS leader over its pool —
+    // the pool's own per-player tally, one pool per boss round. stats.bossDamage (the result's 领袖伤害) adds up both
+    // rounds, so it would credit the Final Assault's damage to the hidden leader ("隐藏boss还没打就出了50%播报").
     const hitSteps = new Map();
-    this.bossPool = new SharedBossPool(bossPoolHp(this.gd, bossId, alive.length), {
+    const pool = new SharedBossPool(bossPoolHp(this.gd, bossId, alive.length), {
       onHit: (pid, dmg) => {
         const ps = this.players.get(pid);
         if (!ps) return;
         ps.stats.bossDamage += dmg;
-        const share = ps.stats.bossDamage / this.bossPool.maxHp;
+        const share = (pool.byPlayer.get(pid) || 0) / pool.maxHp;
         const done = hitSteps.get(pid) || 0;
         let reached = done;
         BOSS_HIT_STEPS.forEach((s, i) => { if (share >= s) reached = Math.max(reached, i + 1); });
@@ -2810,6 +2813,7 @@ export class Match {
         }
       },
     });
+    this.bossPool = pool;
     const groups = pairPlayers(alive);
     const reuse = this.bossWaves && this.bossWaves.length === groups.length && this.bossWaves.every((w, i) => w.players.join() === groups[i].map((p) => p.playerId).join());
     this.fields = groups.map((g, i) => {

server/match/finalAssault.js

@@ -26,6 +26,9 @@
 //     follows the same rule, server/sim/spec.js). Before, the per-player crediting of a report could leave 3.6e-12 that
 //     the browser could never deal (user playtest #6 item 5).
 //   * No IN_BATTLE layer gains (flags.layerGainsEnabled = false).
+//   * BOSS_HIT tickers (BOSS_HIT_STEPS 20 / 50 / 80 %): a player's damage to the round's pool (SharedBossPool.byPlayer)
+//     over its size, each threshold once per boss round — the Hidden Core never counts the Final Assault's damage
+//     (player report after 0.1.0: "隐藏boss还没打就出了造成50%伤害播报").
 //   * Hidden Core eligibility (after an R14 win): difficulty in hiddenCore.difficulties, the mode has a hidden round,
 //     Σ activated layers of the alive players measured at the end of the boss round's prep > threshold (solo 350 /
 //     co-op 1200) and team LP > minTeamLpExclusive (1).
@@ -33,6 +36,11 @@
 import { BOSS_ROW_OFFSET, COLS, BOSS_POOL_MIN_HP } from '../sim/constants.js';
 import { mirrorDir, normDir } from '../sim/dir.js';
 
+/**
+ * BOSS_HIT ticker thresholds (activity_table autoChessData.broadcastList comment_boss_hit_1..3, paramList 0.2 / 0.5 /
+ * 0.8: "{0}博士对敌方领袖造成的伤害超过20%!"): a player's damage to the current leader's pool over that pool
+ * (SharedBossPool.byPlayer — one pool per boss round, so the Final Assault and the Hidden Core count apart).
+ */
 export const BOSS_HIT_STEPS = [0.2, 0.5, 0.8];
 
 /**
@@ -80,7 +88,7 @@ export class SharedBossPool {
   constructor(hp, { onHit = null } = {}) {
     this.maxHp = Math.max(1, hp);
     this.hp = this.maxHp;
-    /** playerId → damage dealt */
+    /** playerId → damage dealt to this pool (this boss round only; the BOSS_HIT tickers' share) */
     this.byPlayer = new Map();
     this.onHit = onHit;
   }

test/match/bosshit-ticker.test.js

@@ -0,0 +1,123 @@
+// BOSS_HIT tickers ("{0}博士对敌方领袖造成的伤害超过20% / 50% / 80%!", activity_table autoChessData.broadcastList
+// comment_boss_hit_1..3, paramList 0.2 / 0.5 / 0.8) — player report after 0.1.0: "隐藏boss还没打就出了造成50%伤害播报".
+//
+// Reproduced with real bot matches (real sim) that reach the 隐秘核心: the Hidden Core's very first hit (a few dozen
+// HP of a 900000 pool) already announced "超过50%". The ticker divided the player's damage of the WHOLE match
+// (stats.bossDamage, Final Assault + Hidden Core: the result screen's 领袖伤害) by the hidden leader's pool, so the
+// Final Assault's damage counted as damage to the hidden leader. The share is now the player's damage to the current
+// leader's pool (SharedBossPool.byPlayer, one pool per boss round) over that pool: each boss round announces its own
+// 20 / 50 / 80 % — on server-run fields, under client-side combat and after a server takeover alike. (The browser's
+// strip also played a Final Assault line late, into the Hidden Core: test/ui/bosshit-ticker.test.js.)
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { PHASE } from '../../shared/constants.js';
+import { BOSS_HIT_STEPS } from '../../server/match/finalAssault.js';
+import { makeMatch, checkInvariants } from './harness.js';
+
+/**
+ * A match (fake battles) driven through the Final Assault (one hit clears it) into the Hidden Core, whose fields deal
+ * `hiddenDps` (a share of the hidden pool per game second). Every BOSS_HIT ticker is recorded with the phase and the
+ * player's real share of the leader in play at that moment (the current pool).
+ */
+function toHiddenCore({ mode = 'coop', difficulty = 'NORMAL', humans = 1, clientCombat = false, seed = 61, bossId, hiddenBossId, hiddenDps = 0.02, onHidden = null }) {
+  const h = makeMatch({ mode, difficulty, humans, seed, fake: true, clientCombat, instant: !clientCombat,
+    script: (b) => (b.kind === 'boss' ? { bossDps: 1e9 } : b.kind === 'hidden' ? { bossDps: b.sharedBoss.maxHp * hiddenDps } : {}) }).start();
+  const m = h.m;
+  m.bossId = bossId;
+  m.hiddenBossId = hiddenBossId;
+  const hits = [];
+  h.onBroadcast.push((msg) => {
+    if (msg.t !== 'm.ticker' || msg.type !== 'BOSS_HIT') return;
+    const pool = m.bossPool;
+    hits.push({ phase: m.phase, playerId: msg.playerId, text: msg.text, id: msg.id,
+      share: pool ? (pool.byPlayer.get(msg.playerId) || 0) / pool.maxHp : null,
+      leaderHpPct: pool ? pool.hp / pool.maxHp : null });
+  });
+  if (clientCombat) h.autoHumans();
+  h.drive(() => m.phase === PHASE.PREP && m.round === m.gd.bossRound);
+  // Σ activated layers above the hidden-core threshold (solo 350 / co-op 1200), every player
+  for (const p of m.players.values()) { p.bondCountBonus.yanShip = 3; p.layers.yanShip = 601; p.recompute(); }
+  h.drive(() => m.phase === PHASE.HIDDEN_CORE || h.ended != null);
+  assert.equal(m.phase, PHASE.HIDDEN_CORE, 'reached the Hidden Core');
+  if (onHidden) onHidden(h);
+  const end = h.runToEnd({ maxSteps: 6e6 });
+  return { h, m, end, hits };
+}
+
+/** The threshold a BOSS_HIT ticker announces (its config param, from the text: "超过N%"). */
+const stepOf = (hit) => Number(/超过(\d+)%/.exec(hit.text)[1]) / 100;
+
+/** Every ticker of `phase` announces at most what the player really dealt to that leader, in rising order, once each. */
+function assertTruthful(hits, phase, players) {
+  const inPhase = hits.filter((x) => x.phase === phase);
+  for (const x of inPhase) {
+    assert.ok(x.share + 1e-9 >= stepOf(x), `${phase}: "${x.text}" while ${x.playerId} had dealt ${(x.share * 100).toFixed(2)} % of this leader (leader at ${(x.leaderHpPct * 100).toFixed(2)} %)`);
+  }
+  for (const pid of players) {
+    const steps = inPhase.filter((x) => x.playerId === pid).map(stepOf);
+    assert.deepEqual(steps, [...steps].sort((a, b) => a - b), `${phase} ${pid}: rising thresholds`);
+    assert.equal(new Set(steps).size, steps.length, `${phase} ${pid}: each threshold once`);
+  }
+  return inPhase;
+}
+
+test('C1 (solo 险境, server-run fields): the Hidden Core\'s first hit announces nothing — the Final Assault\'s damage is not damage to the hidden leader', () => {
+  // the reported case: a Final Assault pool (盐风主教昆图斯, 险境) larger than half the hidden leader's (假想敌：铳)
+  const { m, end, hits } = toHiddenCore({ mode: 'solo', difficulty: 'HARD', bossId: 'boss_4', hiddenBossId: 'boss_9', hiddenDps: 0.01 });
+  assert.equal(end.hiddenReached, true);
+  const fa = assertTruthful(hits, PHASE.FINAL_ASSAULT, ['p_0']);
+  assert.deepEqual(fa.map(stepOf), [0.8], 'the Final Assault cleared by one hit: 80 %');
+  const hidden = assertTruthful(hits, PHASE.HIDDEN_CORE, ['p_0']);
+  assert.deepEqual(hidden.map(stepOf), BOSS_HIT_STEPS, 'the Hidden Core announces its own 20 / 50 / 80 % as they are reached');
+  assert.ok(hidden[0].leaderHpPct <= 0.8 + 1e-9, `the first hidden ticker comes after 20 % of the hidden leader (leader at ${(hidden[0].leaderHpPct * 100).toFixed(2)} %)`);
+  // the result screen's 领袖伤害 keeps the whole match: the Final Assault's pool plus the hidden one
+  assert.ok(end.players[0].stats.bossDamage > m.bossPool.maxHp, `领袖伤害 ${end.players[0].stats.bossDamage}`);
+  checkInvariants(m);
+  m.dispose();
+});
+
+for (const humans of [2, 4]) {
+  test(`C1 (${humans} players, client-side combat): every BOSS_HIT of the Hidden Core matches the player's damage to the hidden leader`, () => {
+    const { m, end, hits } = toHiddenCore({ mode: 'coop', difficulty: 'NORMAL', humans, clientCombat: true, seed: 62 + humans, bossId: 'boss_4', hiddenBossId: 'boss_8', hiddenDps: 0.02 });
+    assert.equal(end.hiddenReached, true);
+    const ids = [...m.players.keys()];
+    assertTruthful(hits, PHASE.FINAL_ASSAULT, ids);
+    const hidden = assertTruthful(hits, PHASE.HIDDEN_CORE, ids);
+    assert.ok(hidden.length > 0, 'the Hidden Core still announces real damage');
+    // the stats keep the whole match: the first field player's 领袖伤害 covers both rounds
+    const row = end.players.find((p) => p.playerId === ids[0]);
+    assert.ok(row.stats.bossDamage > 0);
+    checkInvariants(m);
+    m.dispose();
+  });
+}
+
+test('C1 (2 players, server-run fields — SP_COMBAT=server): the hidden pool\'s tickers follow the hidden-core damage only', () => {
+  const { m, end, hits } = toHiddenCore({ mode: 'coop', difficulty: 'HARD', humans: 2, clientCombat: false, seed: 66, bossId: 'boss_4', hiddenBossId: 'boss_8', hiddenDps: 0.02 });
+  assert.equal(end.hiddenReached, true);
+  assertTruthful(hits, PHASE.FINAL_ASSAULT, ['p_0', 'p_1']);
+  const hidden = assertTruthful(hits, PHASE.HIDDEN_CORE, ['p_0', 'p_1']);
+  // the even split: both players pass 20 % of the hidden leader
+  for (const pid of ['p_0', 'p_1']) assert.ok(hidden.some((x) => x.playerId === pid && stepOf(x) === 0.2), `${pid}: 20 %`);
+  checkInvariants(m);
+  m.dispose();
+});
+
+test('C1 (solo, client-side combat, server takeover mid-fight): the re-simulated hidden field\'s credits announce the hidden-core share only', () => {
+  let tookOver = false;
+  const { m, end, hits } = toHiddenCore({ mode: 'solo', difficulty: 'HARD', clientCombat: true, seed: 67, bossId: 'boss_4', hiddenBossId: 'boss_9', hiddenDps: 0.02,
+    onHidden: (h) => {
+      h.sched.advance(3000); // the browser reported a few seconds of the fight
+      h.m.onDisconnect('p_0');
+      tookOver = h.m.fields[0].mode === 'server';
+      h.m.onReconnect('p_0');
+    } });
+  assert.ok(tookOver, 'the server took the hidden field over (CreditPool)');
+  assert.equal(end.hiddenReached, true);
+  assertTruthful(hits, PHASE.FINAL_ASSAULT, ['p_0']);
+  const hidden = assertTruthful(hits, PHASE.HIDDEN_CORE, ['p_0']);
+  assert.deepEqual(hidden.map(stepOf), BOSS_HIT_STEPS);
+  checkInvariants(m);
+  m.dispose();
+});

test/ui/bosshit-ticker.test.js

@@ -0,0 +1,37 @@
+// Player report after 0.1.0, client part: "隐藏boss还没打就出了造成50%伤害播报". Besides the server's share (fixed in
+// 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).
+
+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');
+
+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%!' };
+  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');
+  // solo FUNNY's boss round 9
+  assert.equal(tickerLineLive({ ...fa, round: 9 }, 9), true);
+  // other lines are not about the leader in play
+  for (const type of ['SHOP_LEVEL', 'GOLDEN_CHAR', 'CHAR_DAMAGE', 'CHAR_GIFT', 'CUSTOM', null, undefined]) {
+    assert.equal(tickerLineLive({ type, round: 14, text: 'x' }, 15), true, String(type));
+  }
+  // no round known (an old line, a reconnect before m.public): plays
+  assert.equal(tickerLineLive({ type: 'BOSS_HIT', round: null }, 15), true);
+  assert.equal(tickerLineLive(fa, null), true);
+  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', () => {
+  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');
+  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');
+});