dsh-pet-dom 2.0.0

package/README.md

@@ -0,0 +1,77 @@
+# dsh-pet-dom
+
+> DeepSeek Harness Web 界面里的**桌面宠物** —— 一只会在页面上自由跳跃、攀爬、奔跑的 Miku 桌宠。
+> 由经典 uni-app「桌宠」项目与更早的 VB6「DeskTop Miku」纯浏览器移植而来。
+
+![桌宠控制台界面](https://unpkg.com/dsh-pet-dom@2.0.0/assets/cover.png)
+
+## 它能做什么
+
+- **在真实页面上跳跃**：会自动察觉页面上的"可落脚区域"（消息、侧栏、按钮、悬浮挂件……），用真实的跳跃曲线跳来跳去
+- **物理手感**：跳跃弧线、重力下坠、快速飘落、落地吸附——像真有一只小东西在页面上活动
+- **跟着页面走**：页面滚动时它会"乘"着所站的区域一起走；区域被删除时自然坠落
+- **两种玩法模式**：
+  - **默认（自动）**：挂机看它自己玩 —— 待机、走路、跳跃巡视、突发小动作（蹦跳/胡桃摇/散步）
+  - **游戏（键盘控制）**：你可以接管它
+- **可调的视觉效果**：高亮显示"可跳跃边缘"（每个位置不同颜色），透明度、合并程度随心调
+- **随界面换肤**：自动跟随 DSH 页面的深色/浅色主题
+
+## 游戏模式按键
+
+| 按键 | 功能 |
+|---|---|
+| <kbd>←</kbd> / <kbd>A</kbd> | 左移（空中可向左调向） |
+| <kbd>→</kbd> / <kbd>D</kbd> | 右移（空中可向右调向） |
+| <kbd>空格</kbd> / <kbd>↑</kbd> / <kbd>W</kbd> | 跳跃（空中可连跳，踩空气上升） |
+| <kbd>↓</kbd> / <kbd>S</kbd> | 快速下落（站在表面时＝摔落） |
+| <kbd>H</kbd> | 胡桃摇 |
+
+> 与键盘翻页冲突？打开控制台 → 打开「禁用 ↑↓」。
+
+## 控制台
+
+页面右上角浮动面板（可拖动、可收起；双击宠物可以唤回）：
+
+- **模式切换**：默认（自动）/ 游戏（键盘控制）
+- **高亮可跳跃边缘**：开关 + 透明度滑块（5%~100%）
+- **表面合并**：把距离接近的区域合并成"大平台"（0~200px）
+- **主题色**：6 种预设 + 自定义取色（边缘高亮线随主题衍生出整条同色系）
+- **禁用 ↑↓**：防止与浏览器翻页冲突（跳/落改用空格与 S）
+
+所有设置自动保存，刷新页面后恢复。
+
+## 安装
+
+```sh
+# 发布后（推荐）
+dsh plugin --profile web add dsh-pet-dom
+
+# 本地开发安装
+dsh plugin --profile web add link:<本插件包绝对路径>
+```
+
+安装完成后**重启 `dsh web`**，刷新页面即可看到桌宠。
+
+## 开发提示
+
+`lib/mascot.js`（桌宠本体）与 `lib/console.js`（控制台）、`lib/brain.js`（决策逻辑）在每次请求时实时读取 —— 本地修改后**刷新页面即生效**，无需重复重启服务。
+
+## 文件结构
+
+```text
+dsh-pet-dom/
+├── package.json
+├── cordis.patch.yml      # 插件挂载声明
+├── README.md
+├── assets/
+│   └── miku.gif          # 角色精灵图
+└── lib/
+    ├── index.js          # 宿主侧（路由与注入）
+    ├── mascot.js         # 客户端桌宠本体
+    ├── brain.js          # 决策逻辑（纯函数，可测试）
+    └── console.js        # 控制台 UI
+```
+
+## 许可
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,15 @@
+# ============================================================================
+# dsh-pet-dom —— DSH bundle patch
+# ============================================================================
+# 本文件是插件的"挂载声明"。DSH 启动时按 bundle 层栈叠加各插件 patch，
+# 本文件会把桌宠挂件插入 Web profile 的配置树。
+#
+# 安装方式（不再需要手工复制/手工改 profile patch）：
+#   dsh plugin --profile web add link:<本插件包绝对路径>
+# 发布后可直接：
+#   dsh plugin --profile web add dsh-pet-dom
+# ============================================================================
+
+- insert:
+    - id: dsh-pet-dom
+      name: dsh-pet-dom

package/lib/brain.js

@@ -0,0 +1,198 @@
+// ============================================================================
+// dsh-pet-dom —— lib/brain.js 规划大脑（纯函数，无 DOM）
+// ============================================================================
+// 设计原则（可测试性）：
+//   · 全部是纯函数：输入「抽象世界」surfaces 数组 + 物理参数 + 注入的 rng()
+//   · 不接触 DOM / 不读全局状态 → 可在 Node 直接单测（test/planning.test.mjs）
+//   · 浏览器侧以 ESM 引入（test-world.html 用 <script type="module">）
+//
+// 世界模型：
+//   surface = { id: string, x, y, w, h }   // 屏幕坐标（y 越小越高）
+//   graph   = { nodes: [id], edges: { [fromId]: [{ to: id, cost }] } }
+//
+// 物理参数（与 mascot.js 保持一致；可由调用方覆盖）：
+//   G 重力, VX_MAX 水平冲量上限, MAX_RISE 单跳可上高度上限, JUMP_RANGE 单跳水平上限,
+//   SIMILAR_PCT 近优阈值（软随机：cost 差 ≤ x% 视为“相近”）
+// ============================================================================
+
+export const DEFAULT_PHYS = {
+  G: 0.3,
+  VX_MAX: 10,
+  MAX_RISE: 600,
+  JUMP_RANGE: 480,
+  SIMILAR_PCT: 0.12
+}
+
+// ---------- L1 感知：扫描射线 ----------
+// from = {x, y}（例如宠物碰撞体中心）。dir = 'ahead' | 'up' | 'down'
+// 返回最近命中的 surface（或 null）；按“交点距离”排序取最近
+export function raycast(surfaces, from, dir, range) {
+  if (!surfaces || !surfaces.length) return null
+  let best = null
+  let bestDist = Infinity
+  for (const s of surfaces) {
+    const inX = from.x >= s.x && from.x <= s.x + s.w
+    const inY = from.y >= s.y && from.y <= s.y + s.h
+    let dist
+    if (dir === 'ahead') {
+      // 正前方：平台左缘在 from.x 右侧，且 y 带与 from.y 相交
+      if (s.x + s.w <= from.x || !inY) continue
+      dist = s.x - from.x
+    } else if (dir === 'up') {
+      // 上方：平台顶在 from.y 上方，x 带相交
+      if (s.y >= from.y || !inX) continue
+      dist = from.y - s.y
+    } else if (dir === 'down') {
+      // 下方：平台顶在 from.y 下方(或脚下)，x 带相交
+      if (s.y + s.h < from.y - 2 || !inX) continue
+      dist = Math.abs(s.y - from.y)
+    } else {
+      return null
+    }
+    if (dist >= 0 && dist < bestDist) { bestDist = dist; best = s }
+  }
+  if (best && range && bestDist > range) return null
+  return best
+}
+
+// ---------- L2 规划：建图（可达性边） ----------
+// 两个 surface 之间的水平间隙（重叠为 0）
+function gapX(a, b) {
+  const l = Math.max(a.x, b.x)
+  const r = Math.min(a.x + a.w, b.x + b.w)
+  return r > l ? 0 : Math.max(a.x - b.x - b.w, b.x - a.x - a.w)
+}
+
+// A -> B 是否可跳：高差用「A 顶到 B 顶」；上升 ≤ MAX_RISE 且水平间隙 ≤ JUMP_RANGE；
+// 下降/平走几乎总是可达（也受水平限制）。成本 = 水平 + |垂直差|*1.15，上升边 *1.2
+// footprintW = 实际执行跳跃时宠物碰撞体宽度（最坏情形，如 jumpHoriz 31.7px）。
+// 启发式处理（"站得住/落得下"两个影响因素）：
+//   · 平台宽 < footprintW + 8 → 碰撞体放上去都贴边，站不稳 → 不作节点（过滤窄面板）
+//   · 间隙可行性按半步碰撞宽保守缩水（跳过去还需在目标上"放得下"碰撞体）
+//   · footprintW = 0（旧调用）→ 不施加过滤，行为与以前完全一致
+export function buildGraph(surfaces, phys = DEFAULT_PHYS, footprintW = 0) {
+  const fw = footprintW || 0
+  const byId = {}
+  for (const s of surfaces) { if (fw > 0 && !(s.w >= fw + 8)) continue; byId[s.id] = s }   // 站不稳 → 删节点
+  const nodes = Object.keys(byId)
+  const edges = {}
+  for (const id of nodes) edges[id] = []
+  for (const a of nodes.map(id => byId[id])) {
+    for (const b of nodes.map(id => byId[id])) {
+      if (a.id === b.id) continue
+      const dx = gapX(a, b)
+      if (dx > phys.JUMP_RANGE - fw * 0.5) continue      // 碰撞体占用的跨越余量（fw=0 无影响）
+      const rise = a.y - b.y                    // >0 表示 B 更高
+      if (rise > phys.MAX_RISE) continue
+      const cost = dx + Math.abs(rise) * 1.15
+      edges[a.id].push({ to: b.id, cost: rise > 0 ? cost * 1.2 : cost })
+    }
+  }
+  return { nodes, edges, surfaces: nodes.map(id => byId[id]), byId }
+}
+
+// ---------- L2 规划：A* 寻路 ----------
+function heuristic(a, b) {
+  return Math.abs(a.x - b.x) + Math.abs(a.y - b.y)
+}
+
+// 返回 [fromId, ..., goalId] 或 null；默认取"成本最优"，近优路径用 kPath 可选（软随机在调用处做）
+export function planRoute(graph, fromId, goalId) {
+  if (!graph || !graph.byId[fromId] || !graph.byId[goalId]) return null
+  if (fromId === goalId) return [fromId]
+  const open = [{ id: fromId, g: 0, f: heuristic(graph.byId[fromId], graph.byId[goalId]), prev: null }]
+  const closed = {}
+  const openMap = { [fromId]: 0 }
+  while (open.length) {
+    let bi = 0
+    for (let i = 1; i < open.length; i++) if (open[i].f < open[bi].f) bi = i
+    const cur = open.splice(bi, 1)[0]
+    if (closed[cur.id]) continue
+    closed[cur.id] = cur
+    if (cur.id === goalId) {
+      const path = []
+      let n = cur
+      while (n) { path.unshift(n.id); n = n.prev }
+      return path
+    }
+    for (const e of (graph.edges[cur.id] || [])) {
+      if (closed[e.to]) continue
+      const g = cur.g + e.cost
+      if (openMap[e.to] !== undefined && g >= openMap[e.to]) continue
+      openMap[e.to] = g
+      open.push({ id: e.to, g, f: g + heuristic(graph.byId[e.to], graph.byId[goalId]), prev: cur })
+    }
+  }
+  return null
+}
+
+// ---------- 软随机决策 ----------
+// candidates = [{id, cost}]（非空）。rng() ∈ [0,1)
+// 返回 { id, mode: 'best' | 'soft' }：
+//   明显最优（cost 比其他低 > similarPct）→ best；
+//   多个候选 cost 相近（≤ similarPct 差）→ 均匀随机选一个（soft）
+export function softPick(candidates, similarPct = DEFAULT_PHYS.SIMILAR_PCT, rng = Math.random) {
+  if (!candidates || !candidates.length) return null
+  if (candidates.length === 1) return { id: candidates[0].id, mode: 'best' }
+  const sorted = [...candidates].sort((a, b) => a.cost - b.cost)
+  const best = sorted[0]
+  const near = sorted.filter(c => c.cost <= best.cost * (1 + similarPct))
+  if (near.length === 1) return { id: best.id, mode: 'best' }
+  const pick = near[Math.floor(rng() * near.length)]
+  return { id: pick.id, mode: 'soft' }
+}
+
+// 备注：softPick 的"近优组"已含所有相近候选项；若要避免连续选同一项，调用处可把上次选项排除或降权。
+
+// ---------- L4 突发 ----------
+// 返回 { trigger: bool, type: 'hop' | 'shake' | 'wander' }
+// 间隔窗口 [minMs, maxMs]；now - lastAt > 下一个窗口 → 触发一次，窗口随机重掷
+export function whimTick(now, lastAt, windowMs = [2000, 4000], rng = Math.random) {
+  const nextMs = windowMs[0] + rng() * (windowMs[1] - windowMs[0])
+  if (now - lastAt < nextMs) return { trigger: false, type: null }
+  const r = rng()
+  const type = r < 0.45 ? 'hop' : (r < 0.75 ? 'shake' : 'wander')
+  return { trigger: true, type }
+}
+
+// ---------- 目标选择（决策层，软随机）----------
+// 从 fromId 可达的平台中，"软随机"挑一个作为目标：
+//   候选=所有可达平台；cost = A* 路径成本（或距离）；类别权重：随机探索/登顶/最远
+export function pickGoal(graph, fromId, rng = Math.random, prefer = [0.6, 0.25, 0.15]) {
+  if (!graph || !graph.byId[fromId]) return null
+  const candidates = []
+  for (const id of graph.nodes) {
+    if (id === fromId) continue
+    const path = planRoute(graph, fromId, id)
+    if (!path) continue
+    candidates.push({ id, cost: pathCost(graph, path) })
+  }
+  if (!candidates.length) return null
+  // 类别权重：随机探索 / 登顶(最高平台) / 最远 —— 先按权重挑类别，再从该类别候选软随机
+  const r = rng()
+  const cat = r < prefer[0] ? 'random' : (r < prefer[0] + prefer[1] ? 'summit' : 'far')
+  let pool = candidates
+  if (cat === 'summit') {
+    const maxH = Math.max(...graph.surfaces.map(s => s.y))
+    pool = candidates.filter(c => graph.byId[c.id].y === maxH)
+    if (!pool.length) pool = candidates
+  } else if (cat === 'far') {
+    const maxC = Math.max(...candidates.map(c => c.cost))
+    pool = candidates.filter(c => c.cost === maxC)
+    if (!pool.length) pool = candidates
+  }
+  const picked = softPick(pool, DEFAULT_PHYS.SIMILAR_PCT, rng)
+  return picked ? picked.id : null
+}
+
+// A* 路径总成本（供目标排序）
+function pathCost(graph, path) {
+  let c = 0
+  for (let i = 1; i < path.length; i++) {
+    const e = (graph.edges[path[i - 1]] || []).find(x => x.to === path[i])
+    if (e) c += e.cost
+  }
+  return c
+}
+
+export default { DEFAULT_PHYS, raycast, buildGraph, planRoute, softPick, whimTick, pickGoal }