cortico-world-hearthstone 0.3.1 → 0.3.2

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # 变更记录
 
+## 0.3.2
+
+**听歌时让路（可选，默认关）**
+
+设置页「高级」里多了一个开关。打开后，检测到 QQ 音乐 / 网易云在跑，就按安静处理：
+不主动解说回合和告警，你问的时候照答，关掉播放器自动恢复。
+
+默认关是有意的 —— 两件事同时进行、各说各的，很多人就喜欢那样，不该替人决定。
+觉得吵再打开。注意：播放器挂着没放也算「在跑」，这时同样会安静。
+
+**顺带修掉一个会让她「突然不说话」的问题**
+
+判断「日志文件被重写」的旧条件太松：读完 position 正好等于文件大小是常态，
+而炉石每写一次都会改 mtime，于是每轮都可能被误判成「文件被重写」——
+一旦误判，读取位置归零、整份日志同步重读一遍，而重读进来的回合会被去重挡掉，
+**外面看就是整段静默**。
+
+现在加了文件头 256 字节的指纹比对：只有内容真的变了才当重写。原有那条
+「同样大小被整体重写」的用例仍然通过。
+
 ## 0.3.1
 
 **装完就能用：自己把炉石的 Power 日志打开**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cortico-world-hearthstone",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "type": "module",
   "description": "Cortico World: 陪打炉石 —— 读对局日志,知道双方的血量、场面、手牌与水晶,在关键节点开口。只看不动游戏,不代打。需要先打开炉石的 Power 日志。",
   "author": {

package/src/config.ts

@@ -31,6 +31,16 @@ export interface HearthstoneConfigSection extends WorldSection {
   speakAlerts: boolean;
   /** normal = 按上面两项自己开口;quiet = 只看不说,等被问。 */
   mode: 'normal' | 'quiet';
+  /**
+   * 听歌时让路。
+   *
+   * 打开后：检测到 QQ 音乐 / 网易云在跑，就按 `quiet` 处理——不主动解说回合和告警，
+   * 你问的时候照答。让的是「主动开口」这一层，工具调用不受影响。
+   *
+   * **默认关。** 两件事同时进行、各说各的，这是很多人喜欢的状态。
+   * 看到进程也不等于真在放歌，挂着不动也会让路。
+   */
+  yieldToMusic: boolean;
   /** 残血阈值:生命值降到这个数以下算告警。 */
   alertHealth: number;
   /** 对手场上随从达到这个数算被压场。 */
@@ -64,6 +74,7 @@ export const HEARTHSTONE_DEFAULTS = (): HearthstoneConfigSection => ({
   adviceInTurn: true,
   speakAlerts: true,
   mode: 'normal',
+  yieldToMusic: false,
   alertHealth: 10,
   swarmCount: 4,
   historySize: 200,
@@ -120,6 +131,11 @@ export function hearthstoneConfigGroups(): ConfigGroup[] {
         title: '高级（一般不用动）',
         description: '阈值和模型。默认值是按真实对局调过的,没遇到具体问题就别改。',
         properties: {
+          'worlds.hearthstone.yieldToMusic': {
+            type: 'boolean',
+            title: '听歌时让路',
+            description: '打开后：检测到 QQ 音乐 / 网易云在跑，就不主动解说（回合提醒和告警都停），你问的时候照答；关掉播放器自动恢复。默认关——两件事同时进行、各说各的，很多人反而喜欢。注意：播放器挂着没放也算「在跑」，这时同样会安静。',
+          },
           'worlds.hearthstone.alertHealth': {
             type: 'integer',
             title: '残血线',

package/src/log-source.ts

@@ -169,6 +169,8 @@ export class PowerLogTail {
   private failures = 0;
   /** 上一次看到的修改时间:用来识别「文件被整体重写成同样大小」这种只比长度抓不到的情况。 */
   private lastMtimeMs = 0;
+  /** 文件开头 256 字节的内容指纹。只在怀疑被整体重写时读一次，不是每轮都读。 */
+  private headSig = '';
   /** 上次重新扫目录找日志的时刻。 */
   private lastResolveAt = 0;
   /** 上次定位的结果(含「没找到」)。缓存到下一次重扫。 */
@@ -250,6 +252,8 @@ export class PowerLogTail {
         this.decoder = new StringDecoder('utf8');
         this.partial = '';
         this.lastMtimeMs = 0;
+        // 换了文件，旧指纹作废，下一轮重新取
+        this.headSig = '';
         this.opts.log?.info(`开始读炉石日志:${nextPath}(${found?.why ?? ''},从第 ${this.offset} 字节起)`);
       }
       this.opts.onSwitch?.(nextPath);
@@ -262,18 +266,45 @@ export class PowerLogTail {
     this.drain(nextPath);
   }
 
+  /** 读文件开头一小段当指纹。读不到返回空串（空串不会等于任何已有指纹，因此不会误起重写）。 */
+  private headSignature(path: string): string {
+    try {
+      const size = statSize(path);
+      if (size <= 0) return '';
+      const fd = openSync(path, 'r');
+      const buf = Buffer.allocUnsafe(Math.min(256, size));
+      try {
+        readSync(fd, buf, 0, buf.length, 0);
+      } finally {
+        closeSync(fd);
+      }
+      return buf.toString('latin1');
+    } catch {
+      return '';
+    }
+  }
+
   private drain(path: string, initial = false): void {
     const stat = statOrNull(path);
     if (!stat) return;
     const { size, mtimeMs } = stat;
 
-    // 两种「文件被换掉」:变短了,或者长度没变但内容被整体重写(mtime 动了、长度没长)。
-    // 只看 size 会漏掉后一种 —— 新一局恰好和上一局同样大小时就会安静地卡住。
-    const rewritten = size < this.offset || (mtimeMs !== this.lastMtimeMs && size <= this.offset && size > 0);
+    // 「文件变短」一定是被换掉了。
+    //
+    // 「长度没变但 mtime 动了」必须再确认**内容真的变了**才算重写，否则正常轮询会误判 ——
+    // 读完 offset 正好等于 size 是常态，而炉石每写一次都会改 mtime。误判的代价是 offset 归零、
+    // 整份日志同步重读一遍，而重读进来的回合早被解析器 `lastQueuedTurn` 去重挡掉，
+    // **外面看着就是炉石这条链路突然不出声**（2026-10-27 实测：第 21、23 回合和结束事件
+    // 就这么丢的）。所以这里加一道 256 字节的内容比对，只在可疑时读一次。
+    const truncated = size < this.offset;
+    if (!this.headSig) this.headSig = this.headSignature(path);
+    const suspect = !truncated && size === this.offset && size > 0 && mtimeMs !== this.lastMtimeMs;
+    const rewritten = truncated || (suspect && this.headSignature(path) !== this.headSig);
     if (rewritten && this.offset > 0) {
       this.offset = startOffsetFor(path, size);
       this.decoder = new StringDecoder('utf8');
       this.partial = '';
+      this.headSig = this.headSignature(path);
     }
     this.lastMtimeMs = mtimeMs;
 

package/src/peer.ts

@@ -0,0 +1,56 @@
+/**
+ * 对端扩展对应的程序在不在跑。
+ *
+ * 为什么需要这一层：两个扩展装在同一个宿主里，各推各的事件，**互相不认识** ——
+ * 宿主只给了「往同一个对话推事件」这一条路，没有 world 之间互查状态的接口。
+ * 而「听歌的时候别解说」这种需求是真的，进程列表就是唯一不需要跨扩展通信、
+ * 也不用改宿主就能拿到的信号。
+ *
+ * 代价要说清楚：**看到进程 ≠ 正在听**。播放器挂着没放也算在跑，这时炉石同样会安静。
+ * 所以它只能躲在用户自己打开的开关后面，不能默认开。
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const run = promisify(execFile);
+
+/** 缓存时长：tasklist 一次要一两百毫秒，不能每次要判断都跑一遍。 */
+const TTL_MS = 15_000;
+
+let lastAt = 0;
+let lastHit = false;
+
+/**
+ * 名单里任一进程在跑就返回 true。
+ *
+ * 查询失败时返回 false（当作没在跑）—— 这个方向是刻意的：宁可多说几句，
+ * 也不要因为一次 tasklist 失败就让她整场闭麦，那种「突然不说话」最难排查。
+ */
+export async function isPeerRunning(names: readonly string[]): Promise<boolean> {
+  const now = Date.now();
+  if (now - lastAt < TTL_MS) return lastHit;
+
+  let hit = false;
+  try {
+    // /FO CSV 一行一个进程，形如 "QQMusic.exe","1234","Console","1","1,234 K"
+    const { stdout } = await run('tasklist', ['/NH', '/FO', 'CSV'], {
+      timeout: 4000,
+      windowsHide: true,
+      maxBuffer: 4 << 20,
+    });
+    const lower = stdout.toLowerCase();
+    hit = names.some((name) => lower.includes(`"${name.toLowerCase()}"`));
+  } catch {
+    hit = false;
+  }
+
+  lastAt = now;
+  lastHit = hit;
+  return hit;
+}
+
+/** 测试用：把缓存清掉。 */
+export function resetPeerCache(): void {
+  lastAt = 0;
+  lastHit = false;
+}

package/src/world.ts

@@ -25,6 +25,7 @@ import {
   describeLimit, describePowerLogging, ensureLogSizeUnlimited, ensurePowerLogging, installDirFromLog,
   logConfigPath, type PowerLogResult,
 } from './log-config.ts';
+import { isPeerRunning } from './peer.ts';
 import { advise, buildModelPrompt, renderAdvice } from './advice.ts';
 import { askModel, pickKey, type LlmConfig } from './llm.ts';
 import { composeTurnEvent, settleTurnWatermark, shouldAnnounceTurn } from './turn-event.ts';
@@ -138,6 +139,7 @@ export interface HearthstoneWorldOptions {
 
 type Phase = 'no-log' | 'watching' | 'in-game' | 'ended';
 
+
 interface WatchStatus {
   phase: Phase;
   path: string | null;
@@ -299,6 +301,14 @@ export class HearthstoneWorld implements World {
    * 日志里不可能有对局数据，这时亮红灯是**如实报告**，不是误报。
    */
   private powerLog: PowerLogResult | null = null;
+  /**
+   * 播放器在不在跑（「听歌时让路」用）。
+   *
+   * 由定时器维护、`onLines` 里同步读 —— 那边是同步函数，不能在里面 await tasklist。
+   * 开关没开时常为 false，探测也直接跳过，不白花这一两百毫秒。
+   */
+  private musicRunning = false;
+  private peerTimer: ReturnType<typeof setInterval> | null = null;
   private chain: Promise<void> = Promise.resolve();
   private lastSnapshot: GameSnapshot | null = null;
   private announcedStart = false;
@@ -379,6 +389,20 @@ export class HearthstoneWorld implements World {
 
   /* ---------- 生命周期 ---------- */
 
+  /**
+   * 看一眼播放器在不在跑。只在「听歌时让路」打开时才真去查 tasklist。
+   *
+   * 单独拿出来是因为 `onLines` 是同步的 —— 那边不能 await，只能读这里维护的字段。
+   * 查询失败按「没在跑」处理：宁可多说几句，也不要因为一次查询失败整场闭麦。
+   */
+  private async probePeers(): Promise<void> {
+    if (!this.cfg.yieldToMusic) {
+      this.musicRunning = false;
+      return;
+    }
+    this.musicRunning = await isPeerRunning(['QQMusic.exe', 'cloudmusic.exe']);
+  }
+
   async start(host: WorldHost): Promise<void> {
     this.host = host;
     this.log = host.log;
@@ -391,6 +415,10 @@ export class HearthstoneWorld implements World {
     } else {
       this.log?.info(`Power 日志:${describePowerLogging(this.powerLog)}`);
     }
+    // 「听歌时让路」用：每 15 秒看一眼播放器在不在（开关没开就直接返回，不白跑 tasklist）。
+    void this.probePeers();
+    this.peerTimer = setInterval(() => void this.probePeers(), 15_000);
+    this.peerTimer.unref?.();
     this.parser.setHistoryLimit(this.opts.cfg.historySize);
     this.tail = new PowerLogTail({
       getPath: () => resolvePowerLog({ logPath: this.cfg.logPath, installDir: this.cfg.installDir }),
@@ -414,6 +442,10 @@ export class HearthstoneWorld implements World {
   }
 
   async stop(): Promise<void> {
+    if (this.peerTimer) {
+      clearInterval(this.peerTimer);
+      this.peerTimer = null;
+    }
     this.tail?.stop();
     this.tail = null;
     this.clearPendingEndTimer();
@@ -591,19 +623,21 @@ export class HearthstoneWorld implements World {
       this.enqueue(() => this.push('hearthstone.game.start', 'hearthstone.game.start', `[happy]${startText(snapshot)}`, 'flush'));
     }
 
-    const quiet = initial || this.cfg.mode === 'quiet';
+    // 「听歌时让路」：播放器在跑就按安静处理。让的是**主动解说**这一层（回合提醒、告警），
+    // 工具调用和被问时的回答不受影响 —— 让路不等于拒答。
+    const quiet = initial || this.cfg.mode === 'quiet' || this.musicRunning;
 
-    // 回合事件由解析器按「进入行动阶段」记下来,这里只管取走并开口。
-    // 不能在批次边界判断 isMyTurn —— 一批跨几个回合时,批末早不是当时的局面了。
-    // 回合提醒:由**这一批结束时算出来的快照**驱动,不再靠标签回调排队。
-    //
-    // 为什么改:以前在 CURRENT_PLAYER / STEP 的回调里排队,那条路依赖
-    // `isMyTurnNow()`(按玩家名分桶)判断轮次。长时间跑下来桶会失准,结果是整整一局
-    // 一个回合事件都排不出来。快照里的 isMyTurn 和后面算建议用的是同一份数据,
-    // 不会出现「判定说轮到我、数据却显示是对手」。
+    // 回合事件由解析器**逐回合**记下来（每进一次我的行动阶段就记一个点），这里逐个取走再开口。
     //
-    // 资源没刷新(水晶 0)时不更新 lastAnnouncedTurn,下一批自然重试;报过就不再报,
-    // 所以同一回合不会重复开口。
+    // 不能拿「这一批结束时的快照」代表整批 —— 那是以前的写法，也是漏报的病根。
+    // 同一份真实日志，只改批大小，实测：
+    //   批   400 行 → 报 1,3,5,...,23 共 12 次，全对
+    //   批  2000 行 → 只报 7 次，漏 5 个
+    //   批  6000 行 → 只报 2 次
+    //   批 15000 行 → 一次都不报
+    // 因为批末早不是那些回合的局面了：批尾落在对方回合或已结束时，中间所有回合一起被吞。
+    // 而 tail 一旦卡顿（文件被占用、休眠唤醒、大日志读得慢），积压就是几万行一起涌进来。
+    // 按队列补报与批大小无关，才是稳的。
     if (!quiet && this.cfg.speakTurns && shouldAnnounceTurn(snapshot, this.lastAnnouncedTurn)) {
       const point: TurnPoint = {
         turn: snapshot.turn,