dsh-pet-live2d 2.2.0 → 2.3.1

package/lib/client.js

@@ -281,6 +281,153 @@ 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 属于作者命名为头/脸/眼/眉/嘴/耳/发（或尾/翅/鳍）的那些部件" ——
+     * 用的是作者自己的分类，不是猜名字。
+     *
+     * 返回的是 `[{ index, part }]`：`part` 留着，因为**判定时要按部件透明度过滤**
+     * （见 isDrawableVisible）—— 隐藏的配件几何还在原地。
+     *
+     * @returns {Array<{index:number, part:number}>|null} 表结构不认识时返回 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({ index: i, part: partIndex });
+      }
+      return out.length > 0 ? out : null;
+    };
+
+    /**
+     * 这个 drawable 现在"看得见"吗？
+     *
+     * **注意：判定里不拿它当闸门。** 我试过用透明度过滤隐藏配件，结果是"真尾巴一起
+     * 被滤掉"—— 这只宠物的尾巴/翅膀全是**可选配件**，同一时刻只有一个显形，其余靠
+     * **缩放成一点**藏起来（被面积下限排掉就够了）；而 `opacities` 表在渲染期未必是
+     * 最终值，拿它当闸门会误杀正在显形的那一个。
+     *
+     * 现在只留给诊断用（`partsDebug` / `partHitCounts` 报"过滤前 vs 过滤后"）。
+     * "隐藏翅膀抢走摸头"这个真问题改由**路由优先级**解决：摸头优先于摸尾巴。
+     */
+    const isDrawableVisible = (entry) => {
+      const im = model?.internalModel;
+      try {
+        if (typeof im?.getDrawableDynamicFlagIsVisible === "function"
+          && im.getDrawableDynamicFlagIsVisible(entry.index) === false) return false;
+      } catch {
+        /* 没有这个 API 就继续看透明度 */
+      }
+      const raw = im?.coreModel?._model;
+      const drawOpacity = raw?.drawables?.opacities?.[entry.index];
+      if (typeof drawOpacity === "number" && drawOpacity <= 0.001) return false;
+      const partOpacity = raw?.parts?.opacities?.[entry.part];
+      if (typeof partOpacity === "number" && partOpacity <= 0.001) return false;
+      return true;
+    };
+
+    /**
+     * 点在不在这些 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 entry of indices) {
+          const verts = verticesOf(entry.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 +1449,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 +1839,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 +1888,236 @@ 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]?.index ?? 0);
+          vertexProbe = v === undefined ? "undefined" : (v === null ? "null" : "len=" + v.length);
+        } catch (error) {
+          vertexProbe = "throw: " + String(error?.message ?? error);
+        }
+        const visible = (list) => (list === null ? 0 : list.filter((entry) => isDrawableVisible(entry)).length);
+        return {
+          parts: headParts.length,
+          drawableIndices: headIndices === null ? 0 : headIndices.length,
+          headVisible: visible(headIndices),
+          tailParts: tailParts.length,
+          tailDrawableIndices: tailIndices === null ? 0 : tailIndices.length,
+          tailVisible: visible(tailIndices),
+          apiOnInternalModel: has(im),
+          apiOnCoreModel: has(core),
+          vertexProbe,
+          box: headBox,
+        };
+      },
+      /**
+       * Diagnostic: 逐部件的透明度 / 几何范围 / drawable 数。
+       *
+       * "摸头顺带把摸尾巴也触发"这类问题要先分清是**隐藏的配件**（同一时刻只有一个
+       * 显形：狐狸尾 / 猫尾 / 狼尾 / 天使翅膀…）几何还留在原地，还是判定本身写错了。
+       *
+       * **必须挂在控制器上**：`tailParts` 是这一层的闭包变量，放到组件的 api 里会
+       * `tailParts is not defined`（我就这么错过一次，调用直接抛异常、外面只看到 undefined）。
+       */
+      partsDebug: (which) => {
+        const list = which === "tail" ? tailParts : headParts;
+        const raw = model?.internalModel?.coreModel?._model;
+        const im = model?.internalModel;
+        const partIds = raw?.parts?.ids === undefined ? [] : Array.from(raw.parts.ids).map(String);
+        const parent = raw?.drawables?.parentPartIndices;
+        const out = [];
+        for (const id of list) {
+          const index = partIds.indexOf(id);
+          const opacity = raw?.parts?.opacities?.[index];
+          let minX = Infinity;
+          let minY = Infinity;
+          let maxX = -Infinity;
+          let maxY = -Infinity;
+          let drawables = 0;
+          let visibleDrawables = 0;
+          if (parent !== undefined) {
+            for (let i = 0; i < parent.length; i += 1) {
+              if (parent[i] !== index) continue;
+              drawables += 1;
+              if (isDrawableVisible({ index: i, part: index })) visibleDrawables += 1;
+              try {
+                const verts = im?.getDrawableVertices?.(i);
+                if (verts === undefined || verts === null) continue;
+                for (let k = 0; k < verts.length; k += 2) {
+                  if (verts[k] < minX) minX = verts[k];
+                  if (verts[k] > maxX) maxX = verts[k];
+                  if (verts[k + 1] < minY) minY = verts[k + 1];
+                  if (verts[k + 1] > maxY) maxY = verts[k + 1];
+                }
+              } catch {
+                /* 读不到就跳过 */
+              }
+            }
+          }
+          out.push({
+            id,
+            partIndex: index,
+            opacity: typeof opacity === "number" ? Math.round(opacity * 1000) / 1000 : null,
+            drawables,
+            visibleDrawables,
+            box: maxX > minX
+              ? { minX: Math.round(minX), maxX: Math.round(maxX), minY: Math.round(minY), maxY: Math.round(maxY) }
+              : null,
+          });
+        }
+        return out;
+      },
+      /**
+       * Diagnostic: 每个部件在模型空间的命中点数（过滤前 / 过滤后）+ 它的 drawable
+       * 透明度范围。
+       *
+       * 采样**直接在模型空间**做，不经过 `vendor.Point` —— 第一版在 api 闭包里用了
+       * `vendor`（那是控制器里的变量，这里根本看不到），每次调用都抛异常被 catch 吞掉，
+       * 于是所有部件都报 0，看着像"这个部件完全没几何"。
+       */
+      partHitCounts: (which, cols = 48, rows = 36) => {
+        const parts = which === "tail" ? tailParts : headParts;
+        const im = model?.internalModel;
+        const raw = im?.coreModel?._model;
+        const partIds = raw?.parts?.ids === undefined ? [] : Array.from(raw.parts.ids).map(String);
+        const parent = raw?.drawables?.parentPartIndices;
+        const out = [];
+        for (const id of parts) {
+          const partIndex = partIds.indexOf(id);
+          const entries = [];
+          if (parent !== undefined) {
+            for (let i = 0; i < parent.length; i += 1) {
+              if (partIndex >= 0) {
+                if (parent[i] === partIndex) entries.push({ index: i, part: partIndex });
+              } else if (typeof im?.getDrawableIndex === "function" && im.getDrawableIndex(id) === i) {
+                // id 不在 parts.ids 里（它其实是个 drawable id）：按 drawable 找它自己。
+                entries.push({ index: i, part: -1 });
+              }
+            }
+          }
+          const opacities = [];
+          let minX = Infinity;
+          let minY = Infinity;
+          let maxX = -Infinity;
+          let maxY = -Infinity;
+          for (const entry of entries) {
+            const value = raw?.drawables?.opacities?.[entry.index];
+            if (typeof value === "number") opacities.push(Math.round(value * 1000) / 1000);
+            try {
+              const verts = im?.getDrawableVertices?.(entry.index);
+              if (verts === undefined || verts === null) continue;
+              for (let k = 0; k < verts.length; k += 2) {
+                if (verts[k] < minX) minX = verts[k];
+                if (verts[k] > maxX) maxX = verts[k];
+                if (verts[k + 1] < minY) minY = verts[k + 1];
+                if (verts[k + 1] > maxY) maxY = verts[k + 1];
+              }
+            } catch {
+              /* 跳过 */
+            }
+          }
+          let hitsAll = 0;
+          let hitsVisible = 0;
+          if (entries.length > 0 && maxX > minX && maxY > minY) {
+            const visible = entries.filter((entry) => isDrawableVisible(entry));
+            const pad = 20;
+            for (let iy = 0; iy < rows; iy += 1) {
+              for (let ix = 0; ix < cols; ix += 1) {
+                const px = (minX - pad) + (maxX - minX + pad * 2) * (ix + 0.5) / cols;
+                const py = (minY - pad) + (maxY - minY + pad * 2) * (iy + 0.5) / rows;
+                if (hitsPartsGeometry(entries, px, py) === true) hitsAll += 1;
+                if (visible.length > 0 && hitsPartsGeometry(visible, px, py) === true) hitsVisible += 1;
+              }
+            }
+          }
+          out.push({
+            id,
+            partIndex,
+            drawables: entries.length,
+            opacityMin: opacities.length === 0 ? null : Math.min(...opacities),
+            opacityMax: opacities.length === 0 ? null : Math.max(...opacities),
+            box: maxX > minX ? { minX: Math.round(minX), maxX: Math.round(maxX), minY: Math.round(minY), maxY: Math.round(maxY) } : null,
+            hitsAll,
+            hitsVisible,
+          });
+        }
+        return out;
+      },
       /**
        * Play a motion with its declared policy applied; used by the panel, the
        * tap reaction and the session-phase driver.
@@ -1908,7 +2305,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 +2437,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 +2553,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 +2627,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 +2656,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 +2710,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 +2825,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 +2964,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 +3012,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 +3439,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 +3831,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 +4005,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 +4111,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 +4276,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 +4331,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 +4354,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 +4719,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 +4947,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 +5140,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 +5457,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 +5519,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 +5553,26 @@ 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));
+          // **摸头优先于摸尾巴**：两者区域可能重叠（尾巴/翅膀挂件在身后，几何上会伸到
+          // 头部附近），先判头才符合直觉 —— 用户报的"摸头出的是摸尾巴的效果"就是
+          // 原来先判尾巴造成的。隐藏配件的问题另有 isDrawableVisible 兜着。
+          if (state.onHead && FLAGS.patEnabled) {
+            // 摸头：从 `patReactions` 里随机挑一个（默认是 重锤出击 / 问号 / 星星眼），
+            // 并且**故意不脸红**。表情类反应是"闪一下"，到点由自动清理收走，
+            // 所以摸头不会在用户选的槽位上留下永久表情。
+            const list = interactionReactions("patReactions");
+            if (list.length > 0) runReactionRef.current(pick(list));
+            say(pick(linesNow().pat));
+          } else 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 {
             // 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 +5789,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 +6242,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 +6375,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 +6385,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" }),
+      ]),
     ];
   }