dsh-pet-live2d 2.3.0 → 2.3.2

package/CHANGELOG.md

@@ -1,5 +1,73 @@
 # 更新日志
 
+## 2.3.2
+
+### 修：摸尾巴又摸不到了（这次是真的）
+
+用户报的："现在又摸不到尾巴了。"（还发了一张圈出尾巴位置的截图，帮了大忙 —— 尾巴是
+**右侧那只鲸鱼尾鳍**，不是翅膀。）
+
+**真正的根因**：判定每块 drawable 时用的是**映射时算好并存下来的下标**（`entry.index`），
+而不是**调用时按 id 现查的下标**。这两者只要有一处对不上，取到的顶点就是别人的 ——
+表现是"每块单独测都能命中，聚合起来一个都不中"。
+
+单块测（`drawableProbe`）之所以一直正常，正是因为它**每次都按 id 现查下标**。
+现在聚合路径也这么做了：`hitsPartsGeometry` 在循环里用 `im.getDrawableIndex(entry.id)`
+重新解一次，解不出来才退回缓存值。
+
+修好后同一网格上的读数：`hitsTail` 从 **0 → 509** 命中（48×48），头部 1113、重叠 689
+—— 重叠仍然存在（翅膀的几何本来就伸到头顶上方），所以**摸头优先于摸尾巴**那条继续保留：
+点头部给摸头，尾巴自己的区域照样摸得到。
+
+### 一段该记下来的教训：坏掉的诊断比没有诊断更糟
+
+这轮我查了很久，很大一部分时间是被**自己写的诊断函数**骗了：`partHitCounts` 里调了
+`api.drawableProbe(...)`，而 `api` 是控制器**返回出去**的对象，控制器内部根本看不到它
+—— 每次调用都抛 `api is not defined`，被外面的 try/catch 吞掉，于是 `hitsAll`/`hitsVisible`
+**恒为 0**。外面看到的却是"这个部件完全没有几何"，一条**看起来像产品坏了**的读数。
+
+代价：我据此排除了三个正确假设（透明度过滤、下标空间、包围盒预筛），还改坏过一次
+（把顶点整条换成 core 层，连头部判定都变成 0 命中，已还原）。
+
+教训：**诊断函数自己也要先自证**（拿一个已知能命中的样本去测它），读数与事实矛盾时
+先怀疑测量工具，再怀疑被测对象。
+
+## 2.3.1
+
+### 修：摸头会出摸尾巴的效果
+
+用户报的："现在摸头也是出现的摸尾巴的效果，而且这是 live2d 会动的，这个判断网格似乎是静态的。"
+
+两个原因叠在一起：
+
+1. **这只宠物的尾巴/翅膀是三选一的可选配件**（狐狸尾 / 猫尾 / 狼尾 / 天使翅膀…），
+   同一时刻只有一个显形，其余**几何还留在原地** → 判定区域会重叠。实测 1112 个头部
+   命中点里有 **697 个同时命中尾巴**。
+2. 点击路由原来**先判尾巴、再判头** → 重叠区的点击一律算摸尾巴。
+
+现在**摸头优先于摸尾巴**：点头部一定给摸头的台词/反应，只有"没命中头部"才看尾巴。
+
+顺带把一条**太弱的测试**补强：原来只断言"存在只命中尾巴的点"（在 697 点重叠下依然是绿的），
+现在断的是**路由**（点头部给的必须是摸头的台词）—— 这才是用户实际遇到的问题。
+
+### 关于"判断网格似乎是静态的"
+
+查证结果（都有读数支撑）：
+
+- **头部判定是跟着动的**：同一网格隔 2.5 秒重采，命中格子会变（模型呼吸/摆动）。
+  每次点击都是现读**当前帧**的顶点，不是缓存的网格。
+- **尾巴/翅膀的几何在没戴配件时是退化的**（缩成一点 → 被面积下限排掉），所以
+  "摸尾巴"在没有尾巴的造型下**本来就该没反应**——你之前能看到反应，是模型当时正戴着
+  翅膀/尾巴。测试里现在有一条**一致性断言**把这件事写死：有几何就该有命中，
+  几何全退化就该一个都不中。
+- 真正"静态"的是**点击穿透用的那层粗网格遮罩**（剪影），它按定时重建、粒度也粗 ——
+  它只决定"这一下算不算落在角色身上"，不参与摸头/摸尾巴的判定。
+
+> 试过用透明度过滤隐藏配件，结果**把真尾巴一起滤掉了**（`visibleDrawables: 4/11`）：
+> 隐藏是靠缩放、而 `opacities` 表在渲染期未必是最终值，拿它当闸门会误杀正在显形的那一个。
+> 所以放弃了这条思路，改用"路由优先级"解决重叠 —— 保留的诊断读口
+> `partsDebug()` / `partHitCounts()` 仍会报"过滤前 vs 过滤后"，方便下次判断。
+
 ## 2.3.0
 
 ### 摸头判定改成按模型自己的几何（不再是手绘方框）

package/README.md

@@ -124,6 +124,10 @@ dsh plugin --profile web add "link:./dsh-pet-live2d/dsh-live2d-pet"
 
 - 摸头/摸尾巴按**三角面**判定：圆顶带耳朵尖的头部轮廓、尾巴的边缘都对得上，不是方框。
   顶点是**当前帧变形后**的，所以头歪着、身体摆着也准。
+- **摸头优先于摸尾巴**：这两个区域可能有重叠（尾巴/翅膀挂件在身后，几何上会伸到头部
+  附近），重叠处算摸头。
+- **尾巴/翅膀是可选配件**：没戴的时候它们的几何是退化的，"摸尾巴"就是没反应 ——
+  这是对的，不是坏了。戴上翅膀/尾巴（装扮槽）之后才摸得到。
 - 转圈看的是**累计转角**（不是位置绕了几圈），所以贴着角色转小圈、远远转大圈都算。
 - 三个互动各自可开关，反应也能改（见下）。共用的三句台词在「气泡」设置里。
 

package/lib/client.js

@@ -289,7 +289,7 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
     let tailIndices = null;
 
     /**
-     * 部件 id → drawable 下标：cdi3 的部件名 → 引擎原始表。
+     * 部件 id → drawable 下标（带所属部件下标）：cdi3 的部件名 → 引擎原始表。
      *
      * 为什么不直接用部件 id 去 `getDrawableIndex()`：cdi3 的 `Parts` 是**部件** id
      * （`Part46`、`neck_m` 这种），而那个 API 认的是 **drawable** id（`lianhong`、
@@ -300,26 +300,78 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
      * "哪些 drawable 属于作者命名为头/脸/眼/眉/嘴/耳/发（或尾/翅/鳍）的那些部件" ——
      * 用的是作者自己的分类，不是猜名字。
      *
-     * @returns {number[]|null} drawable 下标；表结构不认识时返回 null（退回旧行为）
+     * 返回的是 `[{ index, part }]`：`part` 留着，因为**判定时要按部件透明度过滤**
+     * （见 isDrawableVisible）—— 隐藏的配件几何还在原地。
+     *
+     * @returns {Array<{index:number, part:number}>|null} 表结构不认识时返回 null
      */
     const drawableIndicesForParts = (parts) => {
       const raw = model?.internalModel?.coreModel?._model;
+      const im = model?.internalModel;
       const parent = raw?.drawables?.parentPartIndices;
       const partIds = raw?.parts?.ids;
-      if (parent === undefined || partIds === undefined) return null;
+      const coreIds = raw?.drawables?.ids;
+      if (parent === undefined || partIds === undefined || coreIds === 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 coreIndexById = new Map();
+      for (let i = 0; i < coreIds.length; i += 1) coreIndexById.set(String(coreIds[i]), i);
+      // **以包装层的顺序为主**：顶点就是按 `internalModel.getDrawableIDs()` 的顺序读的
+      // （单块 `drawableProbe` 走得通的正是这条路）。反过来"遍历原始表再翻译下标"，
+      // 只要两套顺序有一处不一致，取到的顶点就是别的 drawable —— 表现就是"几何明明
+      // 又大又真，聚合判定一个都不中"。这里逐个 id 反查它属于哪个部件，不存在歧义。
+      const wrapperIds = typeof im?.getDrawableIDs === "function"
+        ? Array.from(im.getDrawableIDs()).map(String)
+        : null;
       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);
+      if (wrapperIds !== null) {
+        for (let w = 0; w < wrapperIds.length; w += 1) {
+          const coreIndex = coreIndexById.get(wrapperIds[w]);
+          if (coreIndex === undefined) continue;
+          const partIndex = parent[coreIndex];
+          if (partIndex === undefined || partIndex < 0 || partIndex >= ids.length) continue;
+          if (!wanted.has(ids[partIndex])) continue;
+          out.push({ id: wrapperIds[w], index: w, coreIndex, part: partIndex });
+        }
+      } else {
+        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({ id: String(coreIds[i]), index: i, coreIndex: 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 的**三角面**里（模型空间）。
      *
@@ -329,24 +381,29 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
     const hitsPartsGeometry = (indices, x, y) => {
       const im = model?.internalModel;
       if (im === undefined || im === null) return null;
-      // 顶点在**包装层**、三角形索引在**core 层**（实测：`im` 有 getDrawableVertices，
-      // `im.coreModel` 才有 getDrawableVertexIndices）—— 只查一个就会静默返回 null、
-      // 悄悄退回方框判定。两边各取所长。
+      // 顶点用**包装层**的（core 的 `getDrawableVertices` 不在同一个坐标空间里：整条换成
+      // core 之后连头部判定都变成 0 命中）。三角形索引只有 core 有；两套按**同一个下标**
+      // 取用时是自洽的（单块 `drawableProbe` 用同一组合能命中，已实测）。
+      const core = im.coreModel;
       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);
+        : (typeof core?.getDrawableVertices === "function" ? (index) => core.getDrawableVertices(index) : null);
+      const indicesOf = typeof core?.getDrawableVertexIndices === "function"
+        ? (index) => core.getDrawableVertexIndices(index)
+        : (typeof im.getDrawableVertexIndices === "function" ? (index) => im.getDrawableVertexIndices(index) : null);
       if (verticesOf === null || indicesOf === null) return null;
       if (indices === null) return null;
       let read = false;
       try {
-        for (const index of indices) {
+        for (const entry of indices) {
+          // **调用时用 id 重新解一次下标**，别信缓存的 `entry.index`：
+          // 单块 `drawableProbe` 走得通、聚合路径走不通，两者剩下的唯一差别就是这个
+          // （它每次都用 id 现查，聚合路径用映射时算好并存下来的那份）。
+          let index = entry.index;
+          if (typeof entry.id === "string" && typeof im.getDrawableIndex === "function") {
+            const fresh = im.getDrawableIndex(entry.id);
+            if (fresh >= 0) index = fresh;
+          }
           const verts = verticesOf(index);
           if (verts === undefined || verts === null || verts.length < 6) continue;
           read = true;
@@ -1936,22 +1993,278 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
           .filter((name) => typeof target?.[name] === "function");
         let vertexProbe = "n/a";
         try {
-          const v = im?.getDrawableVertices?.(headIndices?.[0] ?? 0);
+          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,
+            // 每块报：id / 包装层下标 / 原始表下标。
+            // **别再在这里调 `api.xxx`**：`api` 是控制器返回出去的那个对象，控制器内部
+            // 看不到它 —— 调了就是 `api is not defined`，整个函数抛异常、所有读数变 0，
+            // 而外面看起来像"这个部件完全没有几何"（我为此白查了三轮）。
+            entries: entries.map((entry) => ({
+              id: entry.id ?? null,
+              index: entry.index,
+              core: entry.coreIndex,
+              part: entry.part,
+            })),
+          });
+        }
+        return out;
+      },
+      /**
+       * Diagnostic: 全部 drawable 的 id / 所属部件名 / 顶点数 / 包围盒（模型空间）。
+       *
+       * 找"她身上真正在画尾巴的那一个"用这个：作者给**部件**起了中文名（尾巴翅膀/猫尾/
+       * 大翅膀…），但 drawable 本身多半叫 `ArtMesh123`。按包围盒的位置就能认出来
+       * （尾巴在身体下后方、翅膀在两侧）。
+       */
+      drawableTable: () => {
+        const im = model?.internalModel;
+        const raw = im?.coreModel?._model;
+        const ids = typeof im?.getDrawableIDs === "function" ? Array.from(im.getDrawableIDs()).map(String) : [];
+        const partIds = raw?.parts?.ids === undefined ? [] : Array.from(raw.parts.ids).map(String);
+        const parent = raw?.drawables?.parentPartIndices;
+        const cdi3Names = MANIFEST.current?.partNames ?? {};
+        return ids.map((id, index) => {
+          const partIndex = parent === undefined ? -1 : parent[index];
+          const partId = partIndex >= 0 && partIndex < partIds.length ? partIds[partIndex] : null;
+          let minX = Infinity;
+          let minY = Infinity;
+          let maxX = -Infinity;
+          let maxY = -Infinity;
+          let vertexCount = 0;
+          try {
+            const verts = im?.getDrawableVertices?.(index);
+            if (verts !== undefined && verts !== null) {
+              vertexCount = Math.floor(verts.length / 2);
+              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 {
+            /* 跳过 */
+          }
+          return {
+            id,
+            index,
+            partId,
+            partName: partId === null ? "(无部件)" : (cdi3Names[partId] ?? partId),
+            vertexCount,
+            box: maxX > minX ? { minX: Math.round(minX), maxX: Math.round(maxX), minY: Math.round(minY), maxY: Math.round(maxY) } : null,
+          };
+        });
+      },
+      /**
+       * Diagnostic: 单看一个 drawable 的三角面判定为什么命中/不命中。
+       *
+       * 头部判定好用、尾巴判定一个都不中（而它的几何明明又大又真）——这种"同一段代码
+       * 对不同 drawable 表现不同"的问题，只能把中间量摊开看：顶点数、索引数、索引范围、
+       * 以及用**它自己的重心**去测的结果。
+       */
+      drawableProbe: (id) => {
+        const im = model?.internalModel;
+        const index = typeof im?.getDrawableIndex === "function" ? im.getDrawableIndex(id) : -1;
+        if (index < 0) return { id, found: false };
+        const vertices = im?.getDrawableVertices?.(index);
+        const indices = (typeof im?.getDrawableVertexIndices === "function"
+          ? im.getDrawableVertexIndices(index)
+          : im?.coreModel?.getDrawableVertexIndices?.(index));
+        const verts = vertices === undefined || vertices === null ? [] : Array.from(vertices);
+        const idx = indices === undefined || indices === null ? [] : Array.from(indices);
+        let minIndex = Infinity;
+        let maxIndex = -Infinity;
+        for (const value of idx) {
+          if (value < minIndex) minIndex = value;
+          if (value > maxIndex) maxIndex = value;
+        }
+        const vertexCount = Math.floor(verts.length / 2);
+        // 用顶点的平均位置当查询点：它一定在几何内部（凸的情况下）。
+        let sumX = 0;
+        let sumY = 0;
+        for (let i = 0; i < verts.length; i += 2) {
+          sumX += verts[i];
+          sumY += verts[i + 1];
+        }
+        const cx = vertexCount === 0 ? 0 : sumX / vertexCount;
+        const cy = vertexCount === 0 ? 0 : sumY / vertexCount;
+        let triangles = 0;
+        let degenerate = 0;
+        let contains = 0;
+        for (let i = 0; i + 2 < idx.length; i += 3) {
+          triangles += 1;
+          const a = idx[i];
+          const b = idx[i + 1];
+          const c = idx[i + 2];
+          if (a * 2 + 1 >= verts.length || b * 2 + 1 >= verts.length || c * 2 + 1 >= verts.length) continue;
+          const area = (verts[b * 2] - verts[a * 2]) * (verts[c * 2 + 1] - verts[a * 2 + 1])
+            - (verts[c * 2] - verts[a * 2]) * (verts[b * 2 + 1] - verts[a * 2 + 1]);
+          if (Math.abs(area) < 1e-6) {
+            degenerate += 1;
+            continue;
+          }
+          if (pointInTriangle(cx, cy, verts, a, b, c)) contains += 1;
+        }
+        return {
+          id,
+          found: true,
+          index,
+          vertexCount,
+          indexCount: idx.length,
+          minIndex: Number.isFinite(minIndex) ? minIndex : null,
+          maxIndex: Number.isFinite(maxIndex) ? maxIndex : null,
+          triangles,
+          degenerate,
+          centroidHits: contains,
+          centroid: { x: Math.round(cx), y: Math.round(cy) },
+        };
+      },
       /**
        * Play a motion with its declared policy applied; used by the panel, the
        * tap reaction and the session-phase driver.
@@ -5387,19 +5700,22 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
           });
         } else if (state.onModel) {
           lastInteraction.current = Date.now();
-          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) {
+          // **摸头优先于摸尾巴**：两者区域可能重叠（尾巴/翅膀挂件在身后，几何上会伸到
+          // 头部附近），先判头才符合直觉 —— 用户报的"摸头出的是摸尾巴的效果"就是
+          // 原来先判尾巴造成的。隐藏配件的问题另有 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.

package/lib/index.js

@@ -356,6 +356,31 @@ function readReactionList(value) {
   return Array.isArray(value) ? value.filter((name) => typeof name === 'string' && name !== '') : []
 }
 
+/**
+ * 部件 id → 作者给的中文名（`Part46` → `脸蛋`）。
+ *
+ * 诊断用（`drawableTable()`）：把 drawable 归到有意义的部件名下，才能一眼看出
+ * "她身上真正在画尾巴的是哪个 drawable" —— 光看 `ArtMesh123` 是认不出来的。
+ */
+function readPartNames(dir, modelPath) {
+  try {
+    const base = modelPath.replace(/\.model3\.json$/i, '')
+    const file = findCdi3(dir, base)
+    if (file === undefined) return {}
+    const parts = readJson(file)?.Parts
+    if (!Array.isArray(parts)) return {}
+    const out = {}
+    for (const part of parts) {
+      if (part === null || typeof part !== 'object') continue
+      if (typeof part.Id !== 'string' || typeof part.Name !== 'string') continue
+      if (part.Name !== '') out[part.Id] = part.Name
+    }
+    return out
+  } catch {
+    return {}
+  }
+}
+
 /** Scan one pet directory into a catalog entry, or undefined when unusable. */
 export function scanPet(dir, id) {
   const manifestFile = join(dir, 'pet.json')
@@ -512,6 +537,8 @@ export function scanPet(dir, id) {
     // 空数组 = 没 cdi3 或没挑到，浏览器半区退回旧行为。
     headParts: readPartsMatching(dir, modelPath, HEAD_PART_NAME_HINTS),
     tailParts: readPartsMatching(dir, modelPath, TAIL_PART_NAME_HINTS),
+    // 部件 id → 中文名（诊断用，见客户端 drawableTable()）。
+    partNames: readPartNames(dir, modelPath),
     // 台词：宠物自己的声音（问候 / 点击 / 摸头 / 摸尾巴 / 转晕 / 归位 / 每个相位）。
     // 用户能在设置里逐条改，改过的存浏览器；这里是**默认值**。
     lines: typeof block.lines === 'object' && block.lines !== null ? block.lines : {},
@@ -719,6 +746,7 @@ function catalogRoute() {
           motionGuards: pet.motionGuards,
           headParts: pet.headParts,
           tailParts: pet.tailParts,
+          partNames: pet.partNames,
           lines: pet.lines,
           patReactions: pet.patReactions,
           tailReactions: pet.tailReactions,

package/package.json

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