dsh-pet-live2d 2.3.0 → 2.3.1

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # 更新日志
 
+## 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,7 +300,10 @@ 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;
@@ -315,11 +318,38 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
         const partIndex = parent[i];
         if (partIndex < 0 || partIndex >= ids.length) continue;
         if (!wanted.has(ids[partIndex])) continue;
-        out.push(i);
+        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 的**三角面**里（模型空间）。
      *
@@ -346,8 +376,8 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
       if (indices === null) return null;
       let read = false;
       try {
-        for (const index of indices) {
-          const verts = verticesOf(index);
+        for (const entry of indices) {
+          const verts = verticesOf(entry.index);
           if (verts === undefined || verts === null || verts.length < 6) continue;
           read = true;
           // 先用这个 drawable 的包围盒排除（绝大多数部件一眼就出局，不用扫三角形）。
@@ -1936,22 +1966,158 @@ 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,
+          });
+        }
+        return out;
+      },
       /**
        * Play a motion with its declared policy applied; used by the panel, the
        * tap reaction and the session-phase driver.
@@ -5387,19 +5553,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/package.json

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