dsh-pet-live2d 2.2.0 → 2.3.0

package/CHANGELOG.md

@@ -1,5 +1,59 @@
 # 更新日志
 
+## 2.3.0
+
+### 摸头判定改成按模型自己的几何（不再是手绘方框）
+
+用户："看看摸头的区域能否精准匹配头部的模型而不是手绘区域。" 查下来比想象的糟：
+老实现用英文正则 `face|eye|mouth|nose|brow|cheek|head` 去猜哪些 drawable 是头，
+而这只模型的 drawable 叫 `Part46` / `lianhong` / `Face_line` 这种 —— **一个都匹配不上**，
+判定静默退化成"点哪都算头"，摸哪都在撒娇。
+
+现在的路是三段，全用模型自己的数据，没有猜的：
+
+1. **cdi3 的部件名**：作者给每个部件起了中文名（`Part46` = 脸蛋、`Part57/58` = 眼睛、
+   `Part14` = 头发、`Part45/68` = 耳朵…），宿主按名字挑出头部部件（这只宠物 21 个）；
+2. **部件 → drawable**：cdi3 的 `Parts` 是**部件** id，而 `getDrawableIndex()` 认的是
+   **drawable** id —— 两个命名空间不同名（实测 21 个部件一个都解不出来）。引擎原始表里有
+   `drawables.parentPartIndices` + `parts.ids`，两边一接就得到 96 个头部 drawable；
+3. **点在三角形内**：每次点击现读那批 drawable 的顶点与三角形索引（顶点是**当前帧变形
+   后**的，头歪着、身体摆着也准），先做包围盒排除再逐三角形判定。
+
+同一个网格上，新判定和旧方框**有 325 个格子不同**：新的是圆顶、带耳朵尖、下巴收窄的
+头部轮廓，旧的是个完美矩形。
+
+> 踩到的坑：顶点在**包装层**（`internalModel.getDrawableVertices`），三角形索引在
+> **core 层**（`internalModel.coreModel.getDrawableVertexIndices`）—— 只查一个就会
+> 静默 null、悄悄退回方框。所以测试里每一段**单独断言**（部件数 / drawable 下标数 /
+> 顶点可读 / 与旧规则不同 / 自身包围盒四角不全中），而不是只验最后那个 true/false。
+
+### 新互动：摸尾巴、鼠标绕圈转晕
+
+- **摸尾巴**：同一套几何判定，部件换成 cdi3 里命名为 尾/鳍/翅/翼 的那 15 个
+  （狐狸尾 / 猫尾 / 狼尾 / 大翅膀…都是可换配件）。默认反应：吐魂 / 问号。
+- **转圈转晕**：鼠标绕着角色转够圈数（默认 2 圈 / 1.6 秒内）就演「晕晕」。看的是
+  **累计转角**而不是"位置绕了几圈" —— 前者对半径不敏感，贴着角色转小圈和远远转大圈都算。
+- 三个互动（摸头 / 摸尾巴 / 转圈）各自可开关，反应候选在设置里点选，
+  候选就是**宠物自己的动作中文名与表情名**（不用记 id）。
+
+### 气泡：会话相位会说一句话，而且全部可配
+
+- 会话相位现在会弹一句台词（思考中 / 用工具 / 等你批准 / 等你回答 / 叫了帮手 / 消息排队 /
+  完成 / 出错），来源还是 DSH 的真实事件。
+- **所有气泡文本都能在设置里改**（问候 / 点击 / 摸头 / 摸尾巴 / 转晕 / 归位 / 加载失败 +
+  每个相位）。一组用 `|` 分隔多个变体、随机挑一句；**留空 = 用宠物默认**
+  （`pet.json` 的 `live2d.lines`），所以"看一眼"不会把默认改掉。
+- **位置可配**：左右 / 上下偏移两个滑杆，外加"一句话停留多久"。
+- **总开关**：关掉之后任何台词都不弹。
+
+### 顺手修掉两个潜伏的问题
+
+- **退化三角形**：`pointInTriangle` 对三个顶点几乎重合（面积 0）的三角形会返回 true ——
+  而隐藏的配件（缩放成一点）正好是这种，会让"每个点都算命中"。已加面积下限。
+- **转圈时间窗**：第一版写成 `now - 上次触发 > 窗口`，那个值一开始恒大于窗口，于是
+  每次移动都把累计清零，永远攒不够圈数（诊断读口里 `total` 一直停在 0.07）。
+  现在窗口从**这轮累计开始**算起。
+
 ## 2.2.0
 
 ### 多接三个会话状态（对着 DSH 0.1.7 的事件表挑的）

package/README.md

@@ -112,6 +112,32 @@ dsh plugin --profile web add "link:./dsh-pet-live2d/dsh-live2d-pet"
 
 右键面板的「装扮」页签跟着相位走 —— 会话中它显示的是**相位抽到的**，不是你上次手选的。
 
+### 互动：摸头 / 摸尾巴 / 转圈
+
+点她身上会有反应，判定用的是**模型自己的几何**，不是画出来的区域：
+
+| 互动 | 怎么触发 | 默认反应 |
+|---|---|---|
+| 摸头 | 点在**头部**（含头发、耳朵 —— 宿主读 cdi3 里作者的部件命名认出来的 21 个部件） | 重锤出击 / 问号 / 星星眼 随机一个，**不脸红** |
+| 摸尾巴 | 点在**尾巴/翅膀**上（狐狸尾 / 猫尾 / 狼尾 / 大翅膀…15 个部件） | 吐魂 / 问号 随机一个 |
+| 转圈转晕 | 鼠标**绕着角色转圈**：默认 2 圈、1.6 秒内 | 演「晕晕」 |
+
+- 摸头/摸尾巴按**三角面**判定：圆顶带耳朵尖的头部轮廓、尾巴的边缘都对得上，不是方框。
+  顶点是**当前帧变形后**的，所以头歪着、身体摆着也准。
+- 转圈看的是**累计转角**（不是位置绕了几圈），所以贴着角色转小圈、远远转大圈都算。
+- 三个互动各自可开关，反应也能改（见下）。共用的三句台词在「气泡」设置里。
+
+### 气泡：说什么、在哪、要不要
+
+她说话时会弹一个小气泡（问候、点击、摸头、摸尾巴、转晕、归位，以及**每个会话相位一句**：
+思考中 / 用工具 / 等你批准 / 等你回答 / 叫了帮手 / 消息排队 / 完成 / 出错）。
+
+- **所有文本都能改**：设置页「气泡」卡里逐条编辑。一组台词**用 `|` 分隔多个变体**
+  （随机挑一句）；**留空 = 用宠物默认**（`pet.json` 的 `live2d.lines`），所以"看一眼"不会
+  把默认改掉。
+- **位置可调**：左右 / 上下偏移两个滑杆（相对她头顶的默认位置），另有"一句话停留多久"。
+- **总开关**：关掉之后任何台词都不弹。
+
 ### 关系：同时（pairs）与前提（requires）
 
 条目下面缩进那一层是**关系**，两种刻意用不同前缀：

package/lib/client.js

@@ -281,6 +281,123 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
      * Runs once per attach. The values are model-space, so they stay valid
      * across resizes and drags; `hitsHead` maps through the live transform.
      */
+    /** 头部 / 尾巴部件 id（宿主从 cdi3 的作者命名里挑的）。空 = 该互动退回旧行为。 */
+    let headParts = [];
+    let tailParts = [];
+    /** 由 parts 解出来的 drawable 下标（换模型要重算，缓存起来）。 */
+    let headIndices = null;
+    let tailIndices = null;
+
+    /**
+     * 部件 id → drawable 下标：cdi3 的部件名 → 引擎原始表。
+     *
+     * 为什么不直接用部件 id 去 `getDrawableIndex()`：cdi3 的 `Parts` 是**部件** id
+     * （`Part46`、`neck_m` 这种），而那个 API 认的是 **drawable** id（`lianhong`、
+     * `Face_line` 这种）—— 两个命名空间不同名，拿部件 id 查永远是 -1（实测这只模型
+     * 21 个头部部件一个都解不出来，判定静默退回方框）。
+     *
+     * 引擎的原始表里有 `drawables.parentPartIndices` 和 `parts.ids`，两边一接就得到
+     * "哪些 drawable 属于作者命名为头/脸/眼/眉/嘴/耳/发（或尾/翅/鳍）的那些部件" ——
+     * 用的是作者自己的分类，不是猜名字。
+     *
+     * @returns {number[]|null} drawable 下标；表结构不认识时返回 null（退回旧行为）
+     */
+    const drawableIndicesForParts = (parts) => {
+      const raw = model?.internalModel?.coreModel?._model;
+      const parent = raw?.drawables?.parentPartIndices;
+      const partIds = raw?.parts?.ids;
+      if (parent === undefined || partIds === undefined) return null;
+      const ids = Array.from(partIds).map(String);
+      if (ids.length === 0 || parts.length === 0) return null;
+      const wanted = new Set(parts);
+      const out = [];
+      for (let i = 0; i < parent.length; i += 1) {
+        const partIndex = parent[i];
+        if (partIndex < 0 || partIndex >= ids.length) continue;
+        if (!wanted.has(ids[partIndex])) continue;
+        out.push(i);
+      }
+      return out.length > 0 ? out : null;
+    };
+
+    /**
+     * 点在不在这些 drawable 的**三角面**里（模型空间）。
+     *
+     * @param {number[]|null} indices drawable 下标（null = 解不出来）
+     * @returns {boolean|null} `null` = 读不到顶点（调用方落回旧行为，别把宠物变哑巴）
+     */
+    const hitsPartsGeometry = (indices, x, y) => {
+      const im = model?.internalModel;
+      if (im === undefined || im === null) return null;
+      // 顶点在**包装层**、三角形索引在**core 层**（实测：`im` 有 getDrawableVertices，
+      // `im.coreModel` 才有 getDrawableVertexIndices）—— 只查一个就会静默返回 null、
+      // 悄悄退回方框判定。两边各取所长。
+      const verticesOf = typeof im.getDrawableVertices === "function"
+        ? (index) => im.getDrawableVertices(index)
+        : (typeof im.coreModel?.getDrawableVertices === "function"
+          ? (index) => im.coreModel.getDrawableVertices(index)
+          : null);
+      const indicesOf = typeof im.getDrawableVertexIndices === "function"
+        ? (index) => im.getDrawableVertexIndices(index)
+        : (typeof im.coreModel?.getDrawableVertexIndices === "function"
+          ? (index) => im.coreModel.getDrawableVertexIndices(index)
+          : null);
+      if (verticesOf === null || indicesOf === null) return null;
+      if (indices === null) return null;
+      let read = false;
+      try {
+        for (const index of indices) {
+          const verts = verticesOf(index);
+          if (verts === undefined || verts === null || verts.length < 6) continue;
+          read = true;
+          // 先用这个 drawable 的包围盒排除（绝大多数部件一眼就出局，不用扫三角形）。
+          let minX = Infinity;
+          let minY = Infinity;
+          let maxX = -Infinity;
+          let maxY = -Infinity;
+          for (let i = 0; i < verts.length; i += 2) {
+            const vx = verts[i];
+            const vy = verts[i + 1];
+            if (vx < minX) minX = vx;
+            if (vx > maxX) maxX = vx;
+            if (vy < minY) minY = vy;
+            if (vy > maxY) maxY = vy;
+          }
+          if (x < minX || x > maxX || y < minY || y > maxY) continue;
+          const indices = indicesOf(index);
+          if (indices === undefined || indices === null) continue;
+          for (let i = 0; i + 2 < indices.length; i += 3) {
+            if (pointInTriangle(x, y, verts, indices[i], indices[i + 1], indices[i + 2])) return true;
+          }
+        }
+      } catch {
+        // 读到一半炸了：当作"读不到"，让调用方用方框兜底。
+        return null;
+      }
+      return read ? false : null;
+    };
+
+    /** 点 (x,y) 在 verts 的第 i0/i1/i2 号顶点组成的三角形里吗（同向叉积法）。 */
+    const pointInTriangle = (x, y, verts, i0, i1, i2) => {
+      const ax = verts[i0 * 2];
+      const ay = verts[i0 * 2 + 1];
+      const bx = verts[i1 * 2];
+      const by = verts[i1 * 2 + 1];
+      const cx = verts[i2 * 2];
+      const cy = verts[i2 * 2 + 1];
+      // 退化三角形（三个点几乎重合）**面积为零**，叉积全 0 → 下面的判定会返回 true，
+      // 于是"每个点都算命中"。隐藏的部件（缩放成一点）正好是这种，必须直接排掉。
+      const area = (bx - ax) * (cy - ay) - (cx - ax) * (by - ay);
+      if (Math.abs(area) < 1e-6) return false;
+      const d1 = (x - bx) * (ay - by) - (ax - bx) * (y - by);
+      const d2 = (x - cx) * (by - cy) - (bx - cx) * (y - cy);
+      const d3 = (x - ax) * (cy - ay) - (cx - ax) * (y - ay);
+      const hasNeg = d1 < 0 || d2 < 0 || d3 < 0;
+      const hasPos = d1 > 0 || d2 > 0 || d3 > 0;
+      return !(hasNeg && hasPos);
+    };
+
+
     const measureHead = (nextModel) => {
       try {
         const im = nextModel?.internalModel;
@@ -1302,6 +1419,7 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
         ambientCursor = 0;
         poseSnapshots.clear();
         paramIndexCache.clear();
+        headIndices = null;
         const idleDuration = idleName === null ? 0 : (groups[idleName]?.[0]?.duration ?? 0);
         ambientPeriodMs = idleDuration > 0 ? idleDuration : 4000;
         // Locate the head once, from the model's own geometry; it is stored in
@@ -1691,28 +1809,47 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
         }
         return false;
       },
+      /** Head-part ids, pushed in by the component once the catalog is ready. */
+      setHeadParts(ids) {
+        headParts = Array.isArray(ids) ? ids.filter((id) => typeof id === "string") : [];
+        // 换宠物 / 换模型：下标缓存必须作废，否则会拿旧模型的 drawable 判定。
+        headIndices = null;
+      },
+      /** Tail-part ids（同上，摸尾巴用）。 */
+      setTailParts(ids) {
+        tailParts = Array.isArray(ids) ? ids.filter((id) => typeof id === "string") : [];
+        tailIndices = null;
+      },
       idleName: () => idleName,
       groups: () => groups,
       /** Declared playback policy for one motion group (diagnostics). */
       optionsFor,
       /** Whether the idle fidget is allowed to pick this motion group. */
       fidgetAllowed,
-      /**
-       * Whether a tap landed on the head (requirement #1).
+    /**
+     * Whether a tap landed on the head (requirement #1).
        *
-       * The stored box is in MODEL space, so the click is pushed through the
-       * model's own inverse transform — the same mapping the engine uses for
-       * gaze — which keeps it correct at any pet size or position.
+       * 有 cdi3 部件名时**按模型自己的三角面**判定：把点映到模型空间，对每个头部
+       * drawable 先做包围盒快速排除，再做点在三角形内 —— 用的就是模型当前的几何
+       * （发型边缘、脸部轮廓都对），而不是一个手调内边距的方框。顶点每次点击现读，
+       * 所以头歪着、身体摆着也是准的。
        *
-       * Returns true when the head could not be measured: an unrecognised model
-       * keeps the previous "any tap reacts" behaviour instead of going inert.
+       * 没有部件名（换宠物、没 cdi3）时退回旧行为：用英文部件名猜出来的方框；
+       * 连那个都测不到就返回 true —— 不认识的模型保持"点哪都算头"，而不是变哑巴。
        */
       hitsHead(x, y) {
-        if (headBox === null || model === null || vendor === null) return true;
+        if (model === null || vendor === null) return true;
         try {
           // Pass one arg only: the engine then clones into a fresh Point, so
           // the stage-space input and the model-space output never alias.
           const point = model.toModelPosition(new vendor.Point(x, y));
+          if (headParts.length > 0) {
+            if (headIndices === null) headIndices = drawableIndicesForParts(headParts);
+            const hit = hitsPartsGeometry(headIndices, point.x, point.y);
+            // 几何判定只在"真的能读到顶点"时算数；读不到就落回方框。
+            if (hit !== null) return hit;
+          }
+          if (headBox === null) return true;
           return point.x >= headBox.minX && point.x <= headBox.maxX
             && point.y >= headBox.minY && point.y <= headBox.maxY;
         } catch {
@@ -1721,6 +1858,100 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
       },
       /** Diagnostic: the measured head box in model space, or null. */
       headBox: () => headBox,
+      /**
+       * 这一下点在尾巴上吗？
+       *
+       * 和摸头同一套判定（模型自己的三角面），只是部件集合换成 cdi3 里命名为
+       * 尾/鳍/翅/翼 的那些。**没有尾巴部件时返回 false**（不是 true）：摸尾巴是个
+       * 新增的互动，测不出来就不该乱触发（摸头那边相反，它要兼容旧模型）。
+       */
+      hitsTail(x, y) {
+        if (model === null || vendor === null) return false;
+        if (tailParts.length === 0) return false;
+        try {
+          const point = model.toModelPosition(new vendor.Point(x, y));
+          if (tailIndices === null) tailIndices = drawableIndicesForParts(tailParts);
+          const hit = hitsPartsGeometry(tailIndices, point.x, point.y);
+          return hit === true;
+        } catch {
+          return false;
+        }
+      },
+      /**
+       * Diagnostic: **旧**方框规则（手调内边距的那个），用来跟几何判定对比。
+       *
+       * 存在的意义是测试：能证明"新规则真的不一样"，而不是两条路返回同一个答案。
+       */
+      hitsHeadBox: (x, y) => {
+        if (headBox === null || model === null || vendor === null) return null;
+        try {
+          const point = model.toModelPosition(new vendor.Point(x, y));
+          return point.x >= headBox.minX && point.x <= headBox.maxX
+            && point.y >= headBox.minY && point.y <= headBox.maxY;
+        } catch {
+          return null;
+        }
+      },
+      /** Diagnostic: 头部部件（来自 cdi3 的作者命名），空数组 = 退回旧判定。 */
+      headPartIDs: () => headParts.slice(),
+      /** Diagnostic: 模型声明的全部 drawable 名（认"头"只能靠这些名字）。 */
+      drawableIDs: () => {
+        const im = model?.internalModel;
+        return typeof im?.getDrawableIDs === "function" ? Array.from(im.getDrawableIDs()).map(String) : [];
+      },
+      /**
+       * Diagnostic: 引擎原始表里 drawable → 父部件 的对应关系。
+       *
+       * cdi3 的 `Parts` 是**部件** id（`Part46` 这种），`getDrawableIndex()` 认的是
+       * drawable id（`lianhong` 这种）—— 两个命名空间不同名，直接拿部件 id 去查永远是 -1。
+       * 引擎的原始表里带着 `parentPartIndices`，把两边接起来才能用上作者的命名。
+       */
+      partTables: () => {
+        const core = model?.internalModel?.coreModel;
+        const raw = core?._model;
+        const parts = raw?.parts;
+        const drawables = raw?.drawables;
+        return {
+          partKeys: parts === undefined ? [] : Object.keys(parts),
+          partIds: parts?.ids === undefined ? [] : Array.from(parts.ids).map(String),
+          drawableKeys: drawables === undefined ? [] : Object.keys(drawables),
+          parentPartIndices: drawables?.parentPartIndices === undefined
+            ? null
+            : Array.from(drawables.parentPartIndices).slice(0, 12),
+        };
+      },
+      /**
+       * Diagnostic: 摸头判定的内部状态。
+       *
+       * cdi3 的 `Parts` 是**部件**（part）id，而 `getDrawableIndex()` 认的是 **drawable**
+       * id —— 两个命名空间不一定同名（这只模型里就不同）。所以这里要把"挑到的部件"
+       * 和"真的能在模型里解出下标的"分开报，否则判定静默退回方框、外面看不出来。
+       */
+      headDebug: () => {
+        if (headIndices === null) headIndices = drawableIndicesForParts(headParts);
+        if (tailIndices === null) tailIndices = drawableIndicesForParts(tailParts);
+        const im = model?.internalModel;
+        const core = im?.coreModel;
+        const has = (target) => ["getDrawableVertices", "getDrawableVertexIndices", "getDrawableIndex", "getDrawableBounds", "getDrawableIDs"]
+          .filter((name) => typeof target?.[name] === "function");
+        let vertexProbe = "n/a";
+        try {
+          const v = im?.getDrawableVertices?.(headIndices?.[0] ?? 0);
+          vertexProbe = v === undefined ? "undefined" : (v === null ? "null" : "len=" + v.length);
+        } catch (error) {
+          vertexProbe = "throw: " + String(error?.message ?? error);
+        }
+        return {
+          parts: headParts.length,
+          drawableIndices: headIndices === null ? 0 : headIndices.length,
+          tailParts: tailParts.length,
+          tailDrawableIndices: tailIndices === null ? 0 : tailIndices.length,
+          apiOnInternalModel: has(im),
+          apiOnCoreModel: has(core),
+          vertexProbe,
+          box: headBox,
+        };
+      },
       /**
        * Play a motion with its declared policy applied; used by the panel, the
        * tap reaction and the session-phase driver.
@@ -1908,7 +2139,7 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
       + "--pp-accent:rgba(90,140,230,.15);--pp-accent-2:rgba(90,140,230,.18);"
       + "--pp-accent-3:rgba(90,140,230,.26);--pp-shadow:0 14px 34px rgba(20,30,50,.18);"
       + "--pp-shadow-sm:0 8px 20px rgba(20,30,50,.14)}",
-    ROOT_SEL + " [data-bubble]{position:absolute;left:50%;bottom:100%;transform:translateX(-50%);margin-bottom:6px;max-width:min(240px,60vw);width:max-content;padding:7px 11px;border-radius:12px;background:linear-gradient(160deg,var(--pp-bubble-a),var(--pp-bubble-b));border:1px solid var(--pp-line);box-shadow:var(--pp-shadow-sm);color:var(--pp-ink);font:400 12px/1.5 inherit;white-space:pre-wrap;pointer-events:none}",
+    ROOT_SEL + " [data-bubble]{position:absolute;left:50%;bottom:100%;transform:translateX(-50%) translate(var(--bubble-x,0px),var(--bubble-y,0px));margin-bottom:6px;max-width:min(240px,60vw);width:max-content;padding:7px 11px;border-radius:12px;background:linear-gradient(160deg,var(--pp-bubble-a),var(--pp-bubble-b));border:1px solid var(--pp-line);box-shadow:var(--pp-shadow-sm);color:var(--pp-ink);font:400 12px/1.5 inherit;white-space:pre-wrap;pointer-events:none}",
     // Sits outside the pet's box entirely, so it must re-arm itself.
     ROOT_SEL + " [data-panel]{position:absolute;right:calc(100% + 10px);bottom:0;width:270px;max-height:min(440px,72vh);display:flex;flex-direction:column;border-radius:14px;overflow:hidden;background:var(--pp-surface);backdrop-filter:blur(14px);border:1px solid var(--pp-line);box-shadow:var(--pp-shadow);color:var(--pp-ink);font:400 12px/1.5 inherit;pointer-events:auto}",
     ROOT_SEL + " [data-panel] header{display:flex;align-items:center;gap:6px;padding:9px 11px;border-bottom:1px solid var(--pp-line-soft);font-weight:600}",
@@ -2040,6 +2271,24 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
     // 滑杆外观（轨道/圆钮/填充）和面板底部那根共用，见 sliderLook。
     ...sliderLook(scope + " input[type=range]"),
     scope + " input[type=checkbox]{accent-color:rgba(120,170,255,.9)}",
+    // ---- 台词 / 互动 ---------------------------------------------------
+    // 台词是**文本**输入（不是数字），要能看清自己写了什么：给足宽度、字色正常，
+    // 只在 hover/focus 时提亮边框 —— 和权重那个"读数旋钮"是两种东西，别共用样式。
+    scope + " [data-line-row]{display:grid;grid-template-columns:120px 1fr;align-items:center;"
+      + "gap:6px;padding:2px 0}",
+    scope + " input[type=text]{box-sizing:border-box;width:100%;min-width:0;font:inherit;"
+      + "font-size:11px;color:inherit;background:rgba(127,127,127,.08);"
+      + "border:1px solid rgba(127,127,127,.28);border-radius:7px;padding:2px 7px}",
+    scope + " input[type=text]:hover{border-color:rgba(127,127,127,.5)}",
+    scope + " input[type=text]:focus-visible{outline:2px solid rgba(120,170,255,.5);outline-offset:1px}",
+    scope + " [data-note-inline]{font-size:10px;opacity:.55;margin-left:6px}",
+    // 反应候选：一行 chips（和槽位选项同一套观感），选中的加底色。
+    scope + " [data-reaction-set]{padding:5px 0 2px}",
+    scope + " [data-reaction-set] [data-chips]{display:flex;flex-wrap:wrap;gap:4px;padding-top:4px}",
+    scope + " [data-reaction-set] [data-chips] button{font-size:10px;padding:2px 8px;"
+      + "border-radius:999px;border:1px solid rgba(127,127,127,.28);background:rgba(127,127,127,.08)}",
+    scope + " [data-reaction-set] [data-chips] button[data-on]{background:rgba(120,170,255,.28);"
+      + "border-color:rgba(120,170,255,.6)}",
     scope + " code{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:11px;"
       + "opacity:.7;font-variant-numeric:tabular-nums}",
 
@@ -2138,11 +2387,42 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
 
   // ------------------------------------------------------------ lines
 
-  const LINES = {
-    greet: ["你好呀，我是鲸鱼娘～", "今天也一起加油吧！", "终于见到你了", "摸鱼时间到？"],
-    click: ["呀！", "痒痒的～", "干嘛呀", "摸摸头？", "嘿嘿"],
-    reset: ["表情归位～", "清清爽爽"],
-    loadFailed: ["呜呜，模型加载失败了"],
+  /**
+   * 台词：**宠物默认 + 用户覆盖**。
+   *
+   * 默认值写在 pet.json 的 `live2d.lines` 里（宠物自己的声音），用户在设置页改过的存
+   * 浏览器（`PHASE_OVERRIDES.lines`）。每条都是**一组**（随机挑一句），相位台词是单句。
+   */
+  const LINE_KEYS = ["greet", "click", "pat", "tail", "spin", "reset", "loadFailed"];
+  const PHASE_LINE_KEYS = ["thinking", "tool", "waiting", "asking", "helper", "queued", "done", "failed"];
+
+  /** 把一条"用 | 分隔"的输入切成台词数组（设置页的输入框就是这个格式）。 */
+  const splitLineInput = (text) =>
+    String(text ?? "")
+      .split("|")
+      .map((part) => part.trim())
+      .filter((part) => part !== "");
+
+  /** 台词数组 -> 输入框里的一行。 */
+  const joinLineInput = (list) => (Array.isArray(list) ? list.join(" | ") : "");
+
+  /** 有效台词：宠物默认 + 用户覆盖（覆盖为空就退回默认）。 */
+  const linesNow = () => {
+    const base = MANIFEST.current?.lines ?? {};
+    const over = PHASE_OVERRIDES.lines ?? {};
+    const out = {};
+    for (const key of LINE_KEYS) {
+      const mine = Array.isArray(over[key]) ? over[key].filter((s) => typeof s === "string" && s !== "") : [];
+      const fallback = Array.isArray(base[key]) ? base[key].filter((s) => typeof s === "string" && s !== "") : [];
+      out[key] = mine.length > 0 ? mine : fallback;
+    }
+    out.phase = {};
+    for (const key of PHASE_LINE_KEYS) {
+      const mine = typeof over.phase?.[key] === "string" ? over.phase[key] : undefined;
+      const fallback = typeof base.phase?.[key] === "string" ? base.phase[key] : "";
+      out.phase[key] = mine !== undefined ? mine : fallback;
+    }
+    return out;
   };
 
   function pick(list) {
@@ -2181,6 +2461,13 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
     /** 摸鱼：静置多久才算「闲下来」，以及之后每次摸鱼的随机间隔上界（ms）。 */
     fidgetQuietMs: 12000,
     fidgetGapMs: 26000,
+    /** 气泡相对角色默认位置（头顶）的偏移，px；以及一句话停留多久。 */
+    bubbleOffsetX: 0,
+    bubbleOffsetY: 0,
+    bubbleHoldMs: 4200,
+    /** 鼠标绕圈：在 spinWindowMs 内累计转过 spinTurns 圈就算转晕。 */
+    spinTurns: 2,
+    spinWindowMs: 1600,
   };
 
   /** 出厂值快照（「恢复默认」用）。 */
@@ -2203,12 +2490,22 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
     // 摸鱼那一组单独排，界面上分开展示（见 TUNING_GROUPS）。
     { key: "fidgetQuietMs", label: "静置多久开始", min: 2000, max: 120000, step: 1000, group: "fidget" },
     { key: "fidgetGapMs", label: "之后最长间隔", min: 4000, max: 300000, step: 1000, group: "fidget" },
+    // 互动与气泡（见「互动」那张卡）。
+    { key: "bubbleOffsetX", label: "气泡左右偏移 px", min: -240, max: 240, step: 2, group: "bubble" },
+    { key: "bubbleOffsetY", label: "气泡上下偏移 px", min: -240, max: 240, step: 2, group: "bubble" },
+    { key: "bubbleHoldMs", label: "一句话停留 ms", min: 800, max: 15000, step: 200, group: "bubble" },
+    { key: "spinTurns", label: "转几圈算晕", min: 1, max: 6, step: 0.5, group: "interact" },
+    { key: "spinWindowMs", label: "要在多少 ms 内", min: 300, max: 6000, step: 100, group: "interact" },
   ];
   /** 可调项的分组（没写 group 的都归「手感」）。hint 显示在卡片右上角。 */
   const TUNING_GROUPS = [
     { id: "feel", label: "手感", hint: "指针 / 嘴 / 眨眼" },
     { id: "fidget", label: "摸鱼节奏", hint: "多久开始、间隔多长" },
+    { id: "interact", label: "互动", hint: "摸头 / 摸尾巴 / 转圈" },
+    { id: "bubble", label: "气泡", hint: "显示什么 · 在哪" },
   ];
+  /** 这几组自己排进了「互动」「气泡」卡里，不要再单独出一张卡。 */
+  const TUNING_GROUPS_INLINE = ["fidget", "interact", "bubble"];
   const tuningGroupOf = (field) => field.group ?? "feel";
   const TUNING_KEY = "dsh-pet-live2d.settings.v1";
   /** 装扮存档的 key。放这里是因为开关（applyFlag）也要用它清存档。 */
@@ -2247,7 +2544,7 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
    * 姿势本身的性质 —— 在摸鱼表里改它，右键面板点同一个姿势、相位池里抽到它，
    * 行为必须一致。所以它单独存一层，而不是挂在条目上。
    */
-  const PHASE_OVERRIDES = { phases: {}, fidget: {}, relations: {} };
+  const PHASE_OVERRIDES = { phases: {}, fidget: {}, relations: {}, lines: {} };
 
   /** 槽位 id -> 中文标签（关系行显示「贴纸」而不是 `sticker`）。 */
   const slotLabelOf = (slotId) =>
@@ -2362,7 +2659,18 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
    *
    * 和数字项分开存：它们不是滑杆，校验方式也不同（true/false）。
    */
-  const FLAGS = { outfitArchive: true };
+  const FLAGS = {
+    /** 装扮是否跨启动记住（那六件穿在身上的东西）。 */
+    outfitArchive: true,
+    /** 气泡总开关：关掉之后任何台词都不弹（含问候、摸头、相位）。 */
+    bubbleEnabled: true,
+    /** 摸头互动（判定用的是模型自己的几何，见 hitsHead）。 */
+    patEnabled: true,
+    /** 摸尾巴互动。 */
+    tailEnabled: true,
+    /** 鼠标绕圈转晕。 */
+    spinEnabled: true,
+  };
   const FLAG_DEFAULTS = Object.freeze(Object.assign({}, FLAGS));
   const OVERRIDE_KEY = "dsh-pet-live2d.settings.v2";
 
@@ -2490,6 +2798,36 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
         if (typeof flags[key] === "boolean") FLAGS[key] = flags[key];
       }
     }
+    // 互动反应候选：三组标签数组。
+    const interactions = saved.interactions;
+    if (interactions !== null && typeof interactions === "object") {
+      const next = {};
+      for (const [key, list] of Object.entries(interactions)) {
+        if (!Array.isArray(list)) continue;
+        const clean = list.filter((label) => typeof label === "string" && label !== "");
+        if (clean.length > 0) next[key] = clean;
+      }
+      if (Object.keys(next).length > 0) PHASE_OVERRIDES.interactions = next;
+    }
+    // 台词覆盖：两层（每条一组 + 相位的单句）。数组要清掉空串，否则 `[""]` 会被
+    // 当成"用户改过"，`linesNow()` 就永远拿不到宠物默认了。
+    const lines = saved.lines;
+    if (lines !== null && typeof lines === "object") {
+      const next = {};
+      for (const [key, value] of Object.entries(lines)) {
+        if (key === "phase") {
+          const phases = {};
+          for (const [phase, text] of Object.entries(value ?? {})) {
+            if (typeof text === "string") phases[phase] = text;
+          }
+          if (Object.keys(phases).length > 0) next.phase = phases;
+        } else if (Array.isArray(value)) {
+          const clean = value.filter((text) => typeof text === "string" && text !== "");
+          if (clean.length > 0) next[key] = clean;
+        }
+      }
+      if (Object.keys(next).length > 0) PHASE_OVERRIDES.lines = next;
+    }
   };
 
   /** 改一处覆盖：写进 store、存档、广播（两个设置界面立刻同步）。 */
@@ -2508,6 +2846,27 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
         };
       }
     }
+    if (patch.interactions !== undefined) {
+      for (const [key, list] of Object.entries(patch.interactions)) {
+        PHASE_OVERRIDES.interactions[key] = Array.isArray(list) ? list.slice() : [];
+      }
+    }
+    // 台词是**两层**（每条一组，相位再一层），所以逐层合并 —— 直接 Object.assign 的话
+    // 改一句相位台词会把其它相位整片冲掉。
+    if (patch.lines !== undefined) {
+      const current = PHASE_OVERRIDES.lines ?? {};
+      const next = Object.assign({}, current);
+      for (const [key, value] of Object.entries(patch.lines)) {
+        if (key === "phase") {
+          next.phase = Object.assign({}, current.phase, value);
+        } else if (Array.isArray(value)) {
+          next[key] = value.slice();
+        } else if (typeof value === "string") {
+          next[key] = value;
+        }
+      }
+      PHASE_OVERRIDES.lines = next;
+    }
     saveOverrides();
     notifySettings();
   };
@@ -2914,6 +3273,31 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
     { expression: "星星眼" },
   ];
 
+  /**
+   * 互动的反应候选：宠物默认（pet.json 的 `patReactions` / `tailReactions` /
+   * `spinReactions`）+ 用户覆盖（`PHASE_OVERRIDES.interactions`）。
+   *
+   * 条目是**标签**（「重锤出击」「星星眼」这种）：先当动作组找（宠物会给动作起中文名），
+   * 找不到就当表达式名。这样设置界面里可以拿宠物自己的清单当候选，用户不用记 id。
+   */
+  const interactionReactions = (key) => {
+    const mine = PHASE_OVERRIDES.interactions?.[key];
+    const list = Array.isArray(mine) && mine.length > 0 ? mine : (MANIFEST.current?.[key] ?? []);
+    return Array.isArray(list) ? list.filter((name) => typeof name === "string" && name !== "") : [];
+  };
+
+  /** 跑一条反应（由点击/转圈触发）。 */
+  const runReactionRef = { current: () => false };
+
+  /**
+   * 转圈检测的读数（诊断用）。
+   *
+   * "绕着转圈没反应"这类问题必须能分辨**三种**可能：事件没来（moves 不动）、
+   * 累计不够（total 不涨）、还是触发了但被别的东西盖住（fires 涨了却没效果）。
+   * 只看最后那个"弹没弹台词"是分不出来的。
+   */
+  const spinStatsRef = { current: { moves: 0, total: 0, fires: 0 } };
+
   /**
    * How long a session phase keeps replaying its motion.
    *
@@ -3281,6 +3665,27 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
         fidgetSlots: Object.keys(PHASE_OVERRIDES.fidget),
         relationKeys: Object.keys(PHASE_OVERRIDES.relations),
         phases: Object.keys(PHASE_OVERRIDES.phases),
+        interactions: Object.keys(PHASE_OVERRIDES.interactions ?? {}),
+        lines: Object.keys(PHASE_OVERRIDES.lines ?? {}),
+        linePhases: Object.keys(PHASE_OVERRIDES.lines?.phase ?? {}),
+        flags: Object.assign({}, FLAGS),
+      });
+      // 台词的**有效值**（宠物默认 + 用户覆盖）—— "改文本"这类断言要能直接读到结果，
+      // 而不是去 DOM 里抠 input.value（那是"界面显示了什么"，不是"她真的会说什么"）。
+      api.effectiveLines = () => linesNow();
+      /** 某个互动的**有效**反应候选（同样是与宠物默认合并后的结果）。 */
+      api.effectiveReactions = (key) => interactionReactions(key);
+      /** 台词的字段清单（测试用它确认"每一个字段都有输入框"）。 */
+      api.lineFields = () => ({
+        plain: LINE_FIELDS.map((field) => field.key),
+        phase: PHASE_LINE_FIELDS.map((field) => field.key),
+      });
+      /** 转圈检测的读数：moves（事件到没到）/ total（累计角）/ fires（触发了几次）。 */
+      api.spinDebug = () => Object.assign({}, spinStatsRef.current, {
+        enabled: FLAGS.spinEnabled,
+        turns: TUNING.spinTurns,
+        windowMs: TUNING.spinWindowMs,
+        threshold: TUNING.spinTurns * Math.PI * 2,
       });
     }, []);
     /**
@@ -3434,10 +3839,19 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
       ? (catalog.pets.find((entry) => entry.id === petId) ?? catalog.pets[0])
       : undefined;
 
+    /**
+     * 弹一句气泡。
+     *
+     * 三件可配的事都收在这里（用户要的"所有文本都可配 / 位置可配 / 可以开关"）：
+     * 气泡总开关关掉时**直接不弹**（连问候也不弹）；位置偏移走 TUNING，渲染时当 CSS 变量；
+     * 文本本身由调用方从 `linesNow()` 取（宠物默认 + 用户覆盖）。
+     */
     const say = useCallback((text) => {
+      if (!FLAGS.bubbleEnabled) return;
+      if (typeof text !== "string" || text === "") return;
       setBubble(text);
       window.clearTimeout(bubbleTimer.current);
-      bubbleTimer.current = window.setTimeout(() => setBubble(null), 4200);
+      bubbleTimer.current = window.setTimeout(() => setBubble(null), TUNING.bubbleHoldMs);
     }, []);
 
     useEffect(() => () => window.clearTimeout(bubbleTimer.current), []);
@@ -3531,6 +3945,10 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
       phaseExpressionRef.current = Object.assign({}, phaseBaseRef.current.expressions);
       // 设置界面（含 DSH 设置页那个独立组件）需要清单里有哪些动作/表情/槽位。
       MANIFEST.current = pet;
+      // 头部部件（宿主从 cdi3 的作者命名里挑的，21 个）交给控制器：摸头判定按这些
+      // 部件的**真实三角面**测，而不是一个手调内边距的方框。
+      motion.current.setHeadParts(pet.headParts ?? []);
+      motion.current.setTailParts(pet.tailParts ?? []);
       // 清单换了（换宠物 / pet.json 改了槽位结构）就先剪一遍存档：
       // 旧槽位的覆盖会让"关系指向不存在的槽位"这类问题**静默**发生。
       pruneOverrides(pet);
@@ -3692,7 +4110,7 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
       boot().catch((reason) => {
         if (!disposed) {
           setError(String((reason && reason.message) || reason));
-          say(pick(LINES.loadFailed));
+          say(pick(linesNow().loadFailed));
         }
       });
 
@@ -3747,7 +4165,7 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
     useEffect(() => {
       if (!ready || greeted.current) return;
       greeted.current = true;
-      say(pick(LINES.greet));
+      say(pick(linesNow().greet));
     }, [ready, say]);
 
 
@@ -3770,10 +4188,62 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
       let resting = false;
       focusDefault();
       resting = true;
+      // 转圈检测的状态：上一次的角度、累计转角、这轮累计的起始时刻、上次触发时刻。
+      let spinLastAngle = null;
+      let spinTotal = 0;
+      let spinStartedAt = 0;
+      let spinLastFire = 0;
+      const spinTrack = (rect, x, y) => {
+        if (!FLAGS.spinEnabled) return;
+        spinStatsRef.current.moves += 1;
+        const cx = rect.width / 2;
+        const cy = rect.height / 2;
+        const dx = x - cx;
+        const dy = y - cy;
+        // 太靠近中心时角度会剧烈抖动（半径趋近 0）：跳过，不参与累计。
+        if (Math.hypot(dx, dy) < rect.width * 0.12) return;
+        const angle = Math.atan2(dy, dx);
+        if (spinLastAngle === null) {
+          spinLastAngle = angle;
+          spinStartedAt = Date.now();
+          return;
+        }
+        let delta = angle - spinLastAngle;
+        // 归一化到 (-π, π]，否则跨越 ±π 时会出现一整个 2π 的假增量。
+        if (delta > Math.PI) delta -= Math.PI * 2;
+        if (delta < -Math.PI) delta += Math.PI * 2;
+        spinLastAngle = angle;
+        const now = Date.now();
+        // "要在多少 ms 内转够 N 圈"：窗口从**这轮累计开始**算起，超时就整轮作废、
+        // 从这一下重新开始。原来写的是 `now - spinLastFire > 窗口` —— 那个值一开始
+        // 恒大于窗口，于是每次移动都把累计清零，永远攒不到 π（诊断读口里 total 一直是 0.07）。
+        if (now - spinStartedAt > TUNING.spinWindowMs) {
+          spinTotal = 0;
+          spinStartedAt = now;
+        }
+        spinTotal += delta;
+        spinStatsRef.current.total = spinTotal;
+        if (Math.abs(spinTotal) < TUNING.spinTurns * Math.PI * 2) return;
+        if (now - spinLastFire < 1500) return;
+        spinTotal = 0;
+        spinStartedAt = now;
+        spinLastFire = now;
+        spinStatsRef.current.fires += 1;
+        lastInteraction.current = now;
+        const list = interactionReactions("spinReactions");
+        if (list.length > 0) runReactionRef.current(pick(list));
+        say(pick(linesNow().spin));
+      };
       const onMove = (event) => {
         const rect = stage.getBoundingClientRect();
         const x = event.clientX - rect.left;
         const y = event.clientY - rect.top;
+        // ---- 鼠标围着转圈 → 转晕 ------------------------------------------
+        // 判定的是"围绕舞台中心的**累计转角**"：每次移动取与上一次的夹角增量
+        // （归一化到 ±180°），在一段时间窗内累计；够 spinTurns 圈就触发一次。
+        // 用累计角而不是"位置绕了几圈"，是因为前者对半径不敏感 —— 贴着角色转
+        // 小圈和远远地转大圈都算，符合"逗她"的直觉。
+        spinTrack(rect, x, y);
         const near = x >= -TUNING.gazeRange && y >= -TUNING.gazeRange
           && x <= rect.width + TUNING.gazeRange && y <= rect.height + TUNING.gazeRange;
         if (near) {
@@ -4083,6 +4553,30 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
       armExpressionClear();
     }, [armExpressionClear]);
 
+    /**
+     * 跑一条互动反应（点击 / 转圈触发）。
+     *
+     * 标签先当**动作组**找（宠物在 catalog.json 里给动作起了中文名），找不到就当
+     * **表达式**闪一下（闪完由 EXPRESSION_HOLD_MS 自动收，不会永久占着槽位）。
+     */
+    const runReaction = useCallback((label) => {
+      if (typeof label !== "string" || label === "") return false;
+      const groups = motion.current.groups();
+      const entry = (petRef.current?.motions ?? []).find((item) => item.label === label);
+      const group = entry !== undefined && Array.isArray(groups[entry.group]) ? entry.group : undefined;
+      if (group !== undefined) {
+        motion.current.playOnce(group, 0, { kind: "tap" });
+        return true;
+      }
+      if (Array.isArray(groups[label])) {
+        motion.current.playOnce(label, 0, { kind: "tap" });
+        return true;
+      }
+      flashExpression(label);
+      return true;
+    }, [flashExpression]);
+    runReactionRef.current = runReaction;
+
     /**
      * Choose an option within one dress-up slot.
      *
@@ -4287,7 +4781,7 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
       }
       commitPinsRef.current();
       motion.current.resetToRest();
-      say(pick(LINES.reset));
+      say(pick(linesNow().reset));
     }, [applyExpressions, say]);
 
     /**
@@ -4480,6 +4974,10 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
           phasePinsRef.current[expression] = true;
           commitPinsRef.current();
         }
+        // 相位台词（pet.json 的 `lines.phase.<相位>`，用户可在设置里改）。
+        // 空字符串 = 这个相位不弹（idle 就没有），所以这里只是"有才弹"。
+        const line = linesNow().phase[phase] ?? "";
+        if (line !== "") say(line);
       };
       // The sustain loop lives in the controller, but the phase -> group map
       // comes from the pet manifest, so hand the resolver over. 池子里抽到过动作的
@@ -4793,6 +5291,14 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
       return motion.current.hitsHead(clientX - rect.left, clientY - rect.top);
     }, []);
 
+    /** 摸尾巴的命中（和摸头同一套，坐标换算也一样走舞台矩形）。 */
+    const hitsTail = useCallback((clientX, clientY) => {
+      const stage = stageRef.current;
+      if (stage === null) return false;
+      const rect = stage.getBoundingClientRect();
+      return motion.current.hitsTail(clientX - rect.left, clientY - rect.top);
+    }, []);
+
     /**
      * Right-click on the pet opens the whole control panel.
      *
@@ -4847,10 +5353,11 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
         // Resolved once, at press time: the model keeps swaying, so asking
         // again on release could answer differently than the press did.
         onHead: hitsHead(event.clientX, event.clientY),
+        onTail: hitsTail(event.clientX, event.clientY),
       };
       setDragging(true);
       try { event.currentTarget.setPointerCapture(event.pointerId); } catch { /* not capturable */ }
-    }, [hitsModel, hitsHead]);
+    }, [hitsModel, hitsHead, hitsTail]);
 
     useEffect(() => {
       const onMove = (event) => {
@@ -4880,25 +5387,23 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
           });
         } else if (state.onModel) {
           lastInteraction.current = Date.now();
-          if (state.onHead) {
-            // Patting the head picks ONE of three reactions at random
-            // (requirement #5) — and deliberately does not blush. The two face
-            // reactions are transient: they are flashed and the auto-clear
-            // takes them away, so a pat never leaves a permanent face on a
-            // slot the user chose.
-            const reaction = pick(HEAD_PAT_REACTIONS);
-            if (reaction.motion !== undefined) {
-              const groups = motion.current.groups();
-              const tap = [reaction.motion, "TapHead", "tap_head"].find((group) => Array.isArray(groups[group]));
-              if (tap !== undefined) motion.current.playOnce(tap, 0, { kind: "tap" });
-            } else if (reaction.expression !== undefined) {
-              flashExpression(reaction.expression);
-            }
-            say(pick(LINES.click));
+          if (state.onTail && FLAGS.tailEnabled) {
+            // 摸尾巴：判据和摸头同一套（模型自己的三角面），部件集合是 cdi3 里
+            // 命名为尾/鳍/翅/翼 的那些。反应从 pet.json 的 `tailReactions` 里随机。
+            const list = interactionReactions("tailReactions");
+            if (list.length > 0) runReactionRef.current(pick(list));
+            say(pick(linesNow().tail));
+          } else if (state.onHead && FLAGS.patEnabled) {
+            // 摸头：从 `patReactions` 里随机挑一个（默认是 重锤出击 / 问号 / 星星眼），
+            // 并且**故意不脸红**。表情类反应是"闪一下"，到点由自动清理收走，
+            // 所以摸头不会在用户选的槽位上留下永久表情。
+            const list = interactionReactions("patReactions");
+            if (list.length > 0) runReactionRef.current(pick(list));
+            say(pick(linesNow().pat));
           } else {
             // Anywhere else on the character is a lighter acknowledgement —
             // deliberately WITHOUT 重锤出击, which now belongs to the head only.
-            say(pick(LINES.click));
+            say(pick(linesNow().click));
           }
         }
       };
@@ -5115,7 +5620,14 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
           ...(maskPath === "" ? {} : { onPointerDown, onContextMenu }),
         }),
       ),
-      bubble === null ? null : h("div", { "data-bubble": "" }, bubble),
+      // 气泡的偏移量走 CSS 变量（值，不是布局）：位置规则仍然只写在样式表里。
+      bubble === null ? null : h("div", {
+        "data-bubble": "",
+        style: {
+          "--bubble-x": TUNING.bubbleOffsetX + "px",
+          "--bubble-y": TUNING.bubbleOffsetY + "px",
+        },
+      }, bubble),
       panel,
     );
   }
@@ -5561,6 +6073,129 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
    * 按标签页条件渲染的 —— 一切到"设置"，Pet 的 hook 数量就变了，React 会抛
    * "Rendered more hooks than during the previous render" 并把**整只宠物**卸载。
    */
+  /** 设置页里每条台词的标题（顺序 = 显示顺序）。 */
+  const LINE_FIELDS = [
+    { key: "greet", label: "开始的时候" },
+    { key: "click", label: "点她身上（不是头和尾巴）" },
+    { key: "pat", label: "摸摸头" },
+    { key: "tail", label: "摸尾巴" },
+    { key: "spin", label: "被转晕" },
+    { key: "reset", label: "点「归位」" },
+    { key: "loadFailed", label: "模型加载失败" },
+  ];
+  const PHASE_LINE_FIELDS = [
+    { key: "thinking", label: "思考中" },
+    { key: "tool", label: "用工具" },
+    { key: "waiting", label: "等你批准" },
+    { key: "asking", label: "等你回答" },
+    { key: "helper", label: "叫了帮手" },
+    { key: "queued", label: "消息排队" },
+    { key: "done", label: "这一轮完成" },
+    { key: "failed", label: "出错" },
+  ];
+
+  /**
+   * 互动：三个开关 + 三套反应候选。
+   *
+   * 候选直接用**宠物自己的清单**（动作的中文名 + 表情名），用户不用记 id —— 
+   * `runReaction()` 也是这个顺序：先当动作组找，找不到就闪一下表情。
+   */
+  function InteractControls() {
+    useSettings();
+    const listFor = (key) => {
+      const mine = PHASE_OVERRIDES.interactions?.[key];
+      if (Array.isArray(mine) && mine.length > 0) return mine;
+      const base = MANIFEST.current?.[key];
+      return Array.isArray(base) ? base : [];
+    };
+    const toggle = (key, label) => {
+      const next = listFor(key).slice();
+      const at = next.indexOf(label);
+      if (at >= 0) next.splice(at, 1);
+      else next.push(label);
+      applyOverride({ interactions: { [key]: next } });
+    };
+    const pet = MANIFEST.current ?? {};
+    const candidates = Array.from(new Set([
+      ...(pet.motions ?? []).map((motion) => motion.label),
+      ...(pet.expressions ?? []).map((expression) => expression.label),
+    ].filter((label) => typeof label === "string" && label !== "")));
+    const switchRow = (key, label, note) => h("label", { "data-flag-row": key },
+      h("input", {
+        type: "checkbox",
+        checked: FLAGS[key] === true,
+        "data-flag": key,
+        onChange: (event) => applyFlag(key, event.target.checked),
+      }),
+      h("span", { "data-row-label": "" }, label),
+      note === undefined ? null : h("span", { "data-note-inline": "" }, note),
+    );
+    const reactionRow = (key, title, note) => h("div", { "data-reaction-set": key },
+      h("div", { "data-row-label": "" }, title, note === undefined ? null : h("span", { "data-note-inline": "" }, note)),
+      h("div", { "data-chips": "" }, candidates.length === 0
+        ? h("span", { "data-note-inline": "" }, "这只宠物没有可选的动作/表情")
+        : candidates.map((label) => {
+          const on = listFor(key).includes(label);
+          return h("button", {
+            key: label,
+            type: "button",
+            "data-reaction-chip": key + ":" + label,
+            ...(on ? { "data-on": "" } : {}),
+            onClick: () => toggle(key, label),
+          }, label);
+        })),
+    );
+    return h("div", { "data-settings": "", "data-setting": "interact" },
+      switchRow("patEnabled", "摸头有反应"),
+      switchRow("tailEnabled", "摸尾巴有反应"),
+      switchRow("spinEnabled", "鼠标绕着转圈会晕"),
+      h(TuningControls, { key: "spin", group: "interact" }),
+      reactionRow("patReactions", "摸头时演什么", "（随机一个）"),
+      reactionRow("tailReactions", "摸尾巴时演什么", "（随机一个）"),
+      reactionRow("spinReactions", "转晕时演什么", "（随机一个）"),
+    );
+  }
+
+  /**
+   * 台词：所有气泡文本。
+   *
+   * 一组 = 一行输入，**用 `|` 分隔多个变体**（随机挑一句）；相位台词是单句。
+   * 留空就退回宠物默认（`pet.json` 的 `live2d.lines`），所以"看一眼"不会把默认改掉。
+   */
+  function LineControls() {
+    useSettings();
+    const effective = linesNow();
+    const setLines = (patch) => applyOverride({ lines: patch });
+    const row = (id, label, value, onInput, placeholder) => h("label", { "data-line-row": id },
+      h("span", { "data-row-label": "" }, label),
+      h("input", {
+        type: "text",
+        value,
+        placeholder,
+        "data-line-input": id,
+        onChange: (event) => onInput(event.target.value),
+      }),
+    );
+    return h("div", { "data-settings": "", "data-setting": "lines" },
+      h("div", { "data-note": "" }, "多个变体用 | 分隔（随机挑一句）。留空 = 用宠物默认。"),
+      ...LINE_FIELDS.map((field) => row(
+        field.key,
+        field.label,
+        joinLineInput(effective[field.key]),
+        (text) => setLines({ [field.key]: splitLineInput(text) }),
+        joinLineInput(MANIFEST.current?.lines?.[field.key]),
+      )),
+      h("div", { "data-row-label": "", "data-note": "" }, "会话相位"),
+      ...PHASE_LINE_FIELDS.map((field) => row(
+        "phase:" + field.key,
+        field.label,
+        effective.phase?.[field.key] ?? "",
+        (text) => setLines({ phase: { [field.key]: text } }),
+        MANIFEST.current?.lines?.phase?.[field.key] ?? "",
+      )),
+    );
+  }
+
   function PetSettingsBody() {
     useSettings();
     const card = (key, title, hint, body) => h("div", { key, "data-card": key },
@@ -5571,7 +6206,7 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
       h("div", { "data-card-body": "" }, body),
     );
     return [
-      ...TUNING_GROUPS.filter((group) => group.id !== "fidget").map((group) => card(
+      ...TUNING_GROUPS.filter((group) => !TUNING_GROUPS_INLINE.includes(group.id)).map((group) => card(
         "tune-" + group.id, group.label, group.hint, h(TuningControls, { group: group.id }))),
       card("phases", "会话相位", "每个相位一组池子", h(PhaseControls, null)),
       // 「摸鱼节奏」（多久摸一次）和「摸鱼」（摸鱼做什么）是同一件事的两半，原来
@@ -5581,6 +6216,22 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
         h(FidgetControls, { key: "pools" }),
       ]),
       card("outfit", "装扮", null, h(OutfitControls, null)),
+      // 互动与气泡：开关、反应候选、以及**所有**气泡文本都在这两张卡里。
+      card("interact", "互动", "摸头 / 摸尾巴 / 转圈", h(InteractControls, null)),
+      card("bubble", "气泡", "显示什么 · 在哪 · 停留多久", [
+        h("label", { "data-flag-row": "bubbleEnabled" },
+          h("input", {
+            type: "checkbox",
+            checked: FLAGS.bubbleEnabled === true,
+            "data-flag": "bubbleEnabled",
+            onChange: (event) => applyFlag("bubbleEnabled", event.target.checked),
+          }),
+          h("span", { "data-row-label": "" }, "显示气泡"),
+          h("span", { "data-note-inline": "" }, FLAGS.bubbleEnabled ? "" : "已关：任何台词都不弹"),
+        ),
+        h(TuningControls, { key: "bubble", group: "bubble" }),
+        h(LineControls, { key: "lines" }),
+      ]),
     ];
   }
 

package/lib/index.js

@@ -274,6 +274,88 @@ function normaliseSlots(raw) {
   return out
 }
 
+/**
+ * 名字里带这些字的部件算"头"：作者在 cdi3 里给每个部件起了中文名
+ * （`Part46` = 脸蛋、`Part57/58` = 眼睛、`Part14` = 头发、`Part45/68` = 耳朵…）。
+ */
+const HEAD_PART_NAME_HINTS = /头|脸|面|眼|眉|嘴|耳|发|eye|face|hair|head|ear|brow|mouth|cheek|nose/i
+
+/**
+ * 名字里带这些字的部件算"尾巴/翅膀"（这只宠物有 15 个：狐狸尾 / 猫尾 / 狼尾 / 大翅膀…，
+ * 都是可换的配件，同一时刻只有一个是显形的）。
+ */
+const TAIL_PART_NAME_HINTS = /尾|鳍|翅|翼|fin|tail|wing/i
+
+/**
+ * 从 cdi3 里按名字挑部件。
+ *
+ * 为什么要读 cdi3：摸头/摸尾巴要知道"哪些 drawable 是头、是尾巴"。原来浏览器半区用的是
+ * 写死的英文正则（`face|eye|mouth|…`），而这只模型的 drawable id 是 `Part46` 这种 ——
+ * **一个都匹配不上**，于是判定静默退化成"点哪都算头"。作者自己的中文名才是权威分类。
+ *
+ * @returns {string[]} 部件 id；没有 cdi3 或没挑到就是空数组（浏览器半区会退回旧行为）。
+ */
+function readPartsMatching(dir, modelPath, hints) {
+  try {
+    const base = modelPath.replace(/\.model3\.json$/i, '')
+    const file = findCdi3(dir, base)
+    if (file === undefined) return []
+    const cdi3 = readJson(file)
+    const parts = cdi3?.Parts
+    if (!Array.isArray(parts)) return []
+    const out = []
+    for (const part of parts) {
+      if (part === null || typeof part !== 'object') continue
+      const id = typeof part.Id === 'string' ? part.Id : undefined
+      if (id === undefined || id === '') continue
+      const name = typeof part.Name === 'string' ? part.Name : ''
+      if (!hints.test(name) && !hints.test(id)) continue
+      out.push(id)
+    }
+    return out
+  } catch {
+    return []
+  }
+}
+
+/**
+ * 找 cdi3.json。
+ *
+ * 它**不在** model3.json 的引用里（那是 Cubism Editor 的元数据，运行时不读），所以只能
+ * 按约定找：与模型同名的 `<base>.cdi3.json` 优先，其次模型旁边、再其次宠物目录和它的
+ * 直接子目录 —— 这只宠物就放在 `model/` 子目录里，只在根目录找会一个都挑不到。
+ */
+function findCdi3(dir, base) {
+  const direct = [join(dir, base + '.cdi3.json'), join(dir, 'model', base + '.cdi3.json')]
+  for (const file of direct) {
+    if (existsSync(file)) return file
+  }
+  const roots = [dir]
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory() && entry.name !== 'node_modules') roots.push(join(dir, entry.name))
+    }
+  } catch {
+    /* 读不了就只用 dir 本身 */
+  }
+  for (const root of roots) {
+    try {
+      const hit = readdirSync(root).find((name) => name.toLowerCase().endsWith('.cdi3.json'))
+      if (hit !== undefined) return join(root, hit)
+    } catch {
+      /* 跳过读不了的目录 */
+    }
+  }
+  return undefined
+}
+
+/**
+ * 互动反应候选：一串标签（动作的中文名，或表情名）。非字符串/空的都丢掉。
+ */
+function readReactionList(value) {
+  return Array.isArray(value) ? value.filter((name) => typeof name === 'string' && name !== '') : []
+}
+
 /** Scan one pet directory into a catalog entry, or undefined when unusable. */
 export function scanPet(dir, id) {
   const manifestFile = join(dir, 'pet.json')
@@ -426,6 +508,17 @@ export function scanPet(dir, id) {
     // premise is missing (a selfie with no phone out, a spray with no whale)
     // must not play at all, from ANY path: the panel, a fidget or a phase.
     motionGuards: typeof block.motionGuards === 'object' && block.motionGuards !== null ? block.motionGuards : {},
+    // 头部 / 尾巴部件（部件 id）：摸头、摸尾巴按这些部件的**真实几何**判定。
+    // 空数组 = 没 cdi3 或没挑到，浏览器半区退回旧行为。
+    headParts: readPartsMatching(dir, modelPath, HEAD_PART_NAME_HINTS),
+    tailParts: readPartsMatching(dir, modelPath, TAIL_PART_NAME_HINTS),
+    // 台词：宠物自己的声音（问候 / 点击 / 摸头 / 摸尾巴 / 转晕 / 归位 / 每个相位）。
+    // 用户能在设置里逐条改，改过的存浏览器；这里是**默认值**。
+    lines: typeof block.lines === 'object' && block.lines !== null ? block.lines : {},
+    // 互动反应候选（标签：动作的中文名或表情名）。摸头 / 摸尾巴 / 转晕各一组。
+    patReactions: readReactionList(block.patReactions),
+    tailReactions: readReactionList(block.tailReactions),
+    spinReactions: readReactionList(block.spinReactions),
     // 摸鱼默认盯哪几个槽位。以前这六个是**写死在浏览器半区**的（"宠物自己的身子"），
     // 但宠物作者（和用户）会想改：这只宠物把「自拍」也放进了摸鱼池。写在这里之后，
     // "默认集合"也成了宠物自己声明的东西，用户加的槽位照样覆盖在上面。
@@ -624,6 +717,12 @@ function catalogRoute() {
           expressionSlots: pet.expressionSlots,
           looksByPhase: pet.looksByPhase,
           motionGuards: pet.motionGuards,
+          headParts: pet.headParts,
+          tailParts: pet.tailParts,
+          lines: pet.lines,
+          patReactions: pet.patReactions,
+          tailReactions: pet.tailReactions,
+          spinReactions: pet.spinReactions,
           fidgetSlots: pet.fidgetSlots,
           hiddenMotions: pet.hiddenMotions,
           motionOptions: pet.motionOptions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-pet-live2d",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Live2D 桌宠插件：为 DSH Web GUI 挂一只可拖动、会跟随鼠标、能换动作与表情的 Live2D 宠物。",
   "type": "module",
   "main": "lib/index.js",

package/pets/ds-whale-girl/pet.json

@@ -610,6 +610,64 @@
         ]
       }
     },
+    "lines": {
+      "greet": [
+        "你好呀，我是鲸鱼娘～",
+        "今天也一起加油吧！",
+        "终于见到你了",
+        "摸鱼时间到？"
+      ],
+      "click": [
+        "呀！",
+        "痒痒的～",
+        "干嘛呀",
+        "摸摸头？",
+        "嘿嘿"
+      ],
+      "pat": [
+        "嘿嘿，好舒服～",
+        "再摸一下嘛",
+        "唔…头发要乱了"
+      ],
+      "tail": [
+        "呀！尾巴不能乱摸！",
+        "尾巴…痒痒的",
+        "别拽尾巴啦"
+      ],
+      "spin": [
+        "呜…转晕了…",
+        "别转了别转了"
+      ],
+      "reset": [
+        "表情归位～",
+        "清清爽爽"
+      ],
+      "loadFailed": [
+        "呜呜，模型加载失败了"
+      ],
+      "phase": {
+        "thinking": "让我想想…",
+        "tool": "正在忙…",
+        "waiting": "需要你确认一下",
+        "asking": "在等你回答哦",
+        "helper": "叫了帮手一起弄",
+        "queued": "收到，记下了",
+        "done": "搞定！",
+        "failed": "呜…出错了"
+      }
+    },
+    "patReactions": [
+      "重锤出击",
+      "问号",
+      "星星眼"
+    ],
+    "tailReactions": [
+      "吐魂",
+      "问号"
+    ],
+    "spinReactions": [
+      "晕晕"
+    ],
     "hiddenMotions": [
       "OpenCase",
       "BubbleGum"