dsh-pet-dom 2.0.0

package/lib/mascot.js

@@ -0,0 +1,1050 @@
+// ============================================================================
+// dsh-pet-dom —— 客户端桌宠本体 v2.0（ESM 模块；大脑来自 lib/brain.js）
+// ============================================================================
+// 2.0 特性（M1+P2）：
+//  · 默认在浏览器窗口最底下，正常运动
+//  · 表面收集：节流扫描视口内"高 DOM"，作为可落脚的顶面（含 id）
+//  · 物理引擎感：重力 + 冲量跳跃 + 表面碰撞落地 + 落地压缩缓冲；跳跃高度可很高
+//  · 决策大脑（brain.js）：扫描射线 → 平台图 → A* 路线 → 逐段执行；软随机 + 随机突发
+//  · 吸引距离缩小（≈1.35x 桌宠），拖拽为主
+// 继承 1.0：精灵图帧循环 / 待机 / 胡桃摇 / 左右走 / 拖拽 / 位置记忆 / 单一互斥状态机
+// ============================================================================
+
+import { DEFAULT_PHYS, raycast, buildGraph, planRoute, softPick, whimTick, pickGoal } from '/dsh-pet-dom/brain.js'
+import { createPetConsole } from '/dsh-pet-dom/console.js'
+
+window.__petDomLoaded = true
+
+  var SPRITE_URL = '/dsh-pet-dom/miku.gif'
+  var ACTIONS = {
+    idle:      { frameWidth: 58.9, frameHeight: 62,  frameCount: 19, offsetY: 0 },
+    active:    { frameWidth: 84.0, frameHeight: 65,  frameCount: 11, offsetY: -430 },
+    runRight:  { frameWidth: 77.0, frameHeight: 65,  frameCount: 7,  offsetY: -65 },
+    runLeft:   { frameWidth: 77.0, frameHeight: 65,  frameCount: 7,  offsetY: -65 },
+    jumpUp:    { frameWidth: 77.8, frameHeight: 101, frameCount: 8,  offsetY: -131 },
+    jumpHoriz: { frameWidth: 84.5, frameHeight: 67,  frameCount: 8,  offsetY: -233 }
+  }
+
+  var STORAGE_KEY = 'pet_dom_position'
+  // 物理 & 2.0 参数
+  var G = 0.3                     // 重力（px/frame²@60fps；低一点→腾空更慢更久，好落在 DOM 上）
+  var G_FALL = 0.15               // 下坠重力（vy>0 时用）：比 G 低 → 下落更慢更"轻"，落点更准
+  var V_FALL_MAX = 5              // 终端下落速度（px/帧）：到达后匀速飘落 → 与高度无关，越高越不砸
+  var MOVE_INTERVAL = 2600        // 空闲决策周期（路线跟随更频繁）
+  var SURFACE_MIN_H = 24          // 表面最小高度（放宽：tab 栏/会话项/悬浮小 widget 都能进）
+  var SURFACE_MIN_W = 60          // 表面最小宽度
+  var SURFACE_MAX = 160           // 最多收集表面数（面多时决策图仍秒算）
+  var TOP_SAFE = 44               // 站立安全线：表面顶面 ≥ 此值（= 宠物帧高×0.7，站上后至少七成身体在屏内）
+                                  // 顶面过小（站上去必然整个悬出/超上界）的面不是合法表面 —— 检测时过滤，不是跳时才裁
+  var dedupGap = 90               // 表面合并距离（px）：两表面边缘距离 < 此值 → 视为同一台（保留更大的）；
+                                  // 控制台可调（0 = 不合并，仅完全重叠去重）；默认 90px
+  var highlightAlpha = 0.2        // 高亮透明度（主线 alpha；上亮线 = alpha+0.12），控制台可调，默认 20%
+  var SURFACE_SCAN_MS = 1200      // 表面扫描节流（降频，避免布局抖动）
+  var SCAN_BUDGET = 2400          // 每次扫描最多看多少个元素（DSH Web 全页约 2.4k 元素，预算须覆盖内容区）
+
+  // 游戏模式（键盘接管；物理规则不变，玩家代替大脑）
+  var GAME_MODE = false
+  var gameDir = 0                  // -1 左 / 0 / 1 右（键盘实时，空中可调）
+  var GAME_JUMP = 170              // 地面/表面起跳高度（need）
+  var GAME_JUMP_AIR = 150          // 多段跳（踩空气上天）高度：空中任意次按跳
+  var disableUpDown = false        // 禁用 ↑/↓（与页面翻页冲突时开启；空格/W 跳、S 快落仍可用）
+  var highlightOn = false          // 高亮可跳跃上界（顶边线）
+  var highlightColor = '#a855f7'   // 高亮主题色
+  var jumpGoalId = null            // 本次跳跃目标表面 id（精准吸附锁定；null=自由跳）
+  var petConsole = null            // 控制台（init 里创建；模块顶层引用供 API）
+
+  // ---------- DOM ----------
+  var el = document.createElement('div')
+  el.className = 'starry-pet-dom'
+  el.style.position = 'fixed'
+  el.style.zIndex = '2147483001'   // 极高层级：盖住页面一切，且高于控制台 UI（宠物不躲在控制台后面）
+  el.style.cursor = 'grab'
+  el.style.backgroundRepeat = 'no-repeat'
+  el.style.backgroundSize = 'auto'
+  el.style.pointerEvents = 'auto'
+  el.style.userSelect = 'none'
+  el.style.webkitUserSelect = 'none'
+  el.style.backgroundImage = "url('" + SPRITE_URL + "')"
+  document.body.appendChild(el)
+  var styleEl2 = document.createElement('style')
+  styleEl2.textContent = '.starry-pet-dom:active{cursor:grabbing}.starry-pet-dom{margin:0;padding:0;border:0}'
+  document.head.appendChild(styleEl2)
+
+  // ---------- 状态 ----------
+  var state = {
+    currentAction: 'idle',
+    currentFrame: 0,
+    position: { x: 0, y: 0 },
+    faceLeft: false,
+    dragStartX: 0, dragStartY: 0, dragMoved: false
+  }
+  var BEHAVIOR = 'idle'      // idle | walk | shake | attract | jump | drag | fall
+  var vy = 0                 // 垂直速度
+  var vx = 0                 // 水平速度
+  var airborne = false       // 是否腾空
+  var groundY = 0            // 当前地面（表面顶 或 窗口底）
+  var onSurface = null       // 当前所站表面 rect（null=窗口底）
+  var surfaces = []          // 表面列表
+  var walkTargetX = null     // 行走目标 x
+  var fallFromY = null       // 下坠起点（跳过当前表面及以上，避免"下跳又落回原表面"）
+  var jumpTargetX = null     // 跳跃锚定 x（到达后停水平速度，避免飞过头）
+  var lastMouseMoveTime = Date.now()
+  var lastFrameTs = 0
+  var lastPhysicsTs = 0
+  var lastSurfaceAt = 0
+  var petIdCounter = 0        // 稳定表面 id（按元素分配，不随去重顺序漂移）
+  var lastGroundChk = 0
+  var lastMouseEvent = null
+  var lastMouse = { x: window.innerWidth / 2, y: window.innerHeight / 2 }
+
+  // 大脑/决策状态（P2/P3）
+  var currentRoute = null        // 规划路线 [ids]（P3 持久执行）
+  var routeIdx = 0               // 当前在路线的第几段（P3 逐段推进）
+  var currentGoal = null         // 当前目标 id
+  var lastDecision = null        // 决策日志（调试可视化）
+  var lastWhimAt = 0
+  var whimRestUntil = 0         // 突发后短暂休息（再回计划）
+  var seedRng = null             // 种子化 RNG（调试重放）；null = Math.random
+  function rng() { return seedRng ? seedRng() : Math.random() }
+  function mulberry32(a) {
+    a = a >>> 0
+    return function () {
+      a |= 0; a = (a + 0x6D2B79F5) | 0
+      var t = Math.imul(a ^ (a >>> 15), 1 | a)
+      t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t
+      return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+    }
+  }
+  function setSeed(n) { seedRng = (n === undefined || n === null) ? null : mulberry32(n) }
+
+  // ---------- 工具 ----------
+  function curr() { return ACTIONS[state.currentAction] }
+  function frameWidth() { return curr().frameWidth }
+  function frameHeight() { return curr().frameHeight }
+  function currentOffsetY() { return curr().offsetY }
+  function currentFrameCount() { return curr().frameCount }
+  function clamp(v, lo, hi) { return v < lo ? lo : (v > hi ? hi : v) }
+  function feet() { return state.position.y + frameHeight() }
+  // 颜色派生：amt>0 混白（亮化），amt<0 混黑（加深）—— 返回 hex
+  function shade(hex, amt) {
+    var n = parseInt(hex.slice(1), 16) || 0
+    var r = (n >> 16) & 255, g = (n >> 8) & 255, b = n & 255
+    var t = amt > 0 ? 255 : 0, a = Math.abs(amt)
+    r = Math.round(r + (t - r) * a); g = Math.round(g + (t - g) * a); b = Math.round(b + (t - b) * a)
+    return '#' + r.toString(16).padStart(2, '0') + g.toString(16).padStart(2, '0') + b.toString(16).padStart(2, '0')
+  }
+  // hex → rgba（高亮线半透明用）
+  function hexToRgba(hex, alpha) {
+    var n = parseInt(hex.slice(1), 16) || 0
+    return 'rgba(' + ((n >> 16) & 255) + ',' + ((n >> 8) & 255) + ',' + (n & 255) + ',' + alpha + ')'
+  }
+  // ---------- OKLab/OKLCH 感知均匀色彩（Björn Ottosson 算法；Tailwind/现代 CSS 同思路）----------
+  // srgb(hex) → OKLab
+  function srgbToOklab(hex) {
+    var n = parseInt(hex.slice(1), 16)
+    var r = ((n >> 16) & 255) / 255, g = ((n >> 8) & 255) / 255, b = (n & 255) / 255
+    r = r <= 0.04045 ? r / 12.92 : Math.pow((r + 0.055) / 1.055, 2.4)
+    g = g <= 0.04045 ? g / 12.92 : Math.pow((g + 0.055) / 1.055, 2.4)
+    b = b <= 0.04045 ? b / 12.92 : Math.pow((b + 0.055) / 1.055, 2.4)
+    var l = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b
+    var m = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b
+    var s = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b
+    var l3 = Math.cbrt(l), m3 = Math.cbrt(m), s3 = Math.cbrt(s)
+    return [
+      0.2104542553 * l3 + 0.7936177850 * m3 - 0.0040720468 * s3,
+      1.9779984951 * l3 - 2.4285922050 * m3 + 0.4505937099 * s3,
+      0.0259040371 * l3 + 0.7827717662 * m3 - 0.8086757660 * s3
+    ]
+  }
+  // OKLab → srgb(hex)
+  function oklabToSrgb(L, a, b) {
+    var l3 = L + 0.3963377774 * a + 0.2158037573 * b
+    var m3 = L - 0.1055613458 * a - 0.0638541728 * b
+    var s3 = L - 0.0894841775 * a - 1.2914855480 * b
+    var l = l3 * l3 * l3, m = m3 * m3 * m3, s = s3 * s3 * s3
+    var r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s
+    var g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s
+    var b2 = -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s
+    var lin = function (v) { return v <= 0.0031308 ? v * 12.92 : 1.055 * Math.pow(v, 1 / 2.4) - 0.055 }
+    var to = function (v) { return Math.round(Math.max(0, Math.min(1, lin(v))) * 255).toString(16).padStart(2, '0') }
+    return '#' + to(r) + to(g) + to(b2)
+  }
+  function oklchOf(hex) {
+    var lab = srgbToOklab(hex)
+    var C = Math.sqrt(lab[1] * lab[1] + lab[2] * lab[2])
+    var H = Math.atan2(lab[2], lab[1]) * 180 / Math.PI
+    return [lab[0], C, H < 0 ? H + 360 : H]
+  }
+  function oklchToHex(L, C, H) {
+    var hr = H * Math.PI / 180
+    return oklabToSrgb(L, C * Math.cos(hr), C * Math.sin(hr))
+  }
+  // 【专门算法】派生色卡：OKLCH 中【色相 H 锁死】（100% 不出色系），
+  // 只动感知明度 L / 彩度 C 的阶梯（亮档降彩不刺眼、深档保彩不发灰）—— 感知均匀，档位分明
+  // 入口安全阀：用户自定义/主题色过浅（亮度>200）→ 先压深 45% 再派生，保证整条色带落在可见区
+  function derivePalette(color, n) {
+    var n16 = parseInt(color.slice(1), 16) || 0
+    var lum = 0.299 * ((n16 >> 16) & 255) + 0.587 * ((n16 >> 8) & 255) + 0.114 * (n16 & 255)
+    if (lum > 200) {
+      var r0 = Math.round(((n16 >> 16) & 255) * 0.55), g0 = Math.round(((n16 >> 8) & 255) * 0.55), b0 = Math.round((n16 & 255) * 0.55)
+      color = '#' + r0.toString(16).padStart(2, '0') + g0.toString(16).padStart(2, '0') + b0.toString(16).padStart(2, '0')
+    }
+    var c = oklchOf(color)
+    var L = c[0], C = c[1], H = c[2]
+    var DL = [0.02, -0.08, 0.10, -0.15, 0.16]    // 明度阶梯（围绕主色）
+    var DC = [0.00, -0.03, -0.11, -0.05, -0.18]  // 彩度阶梯：亮档降彩（浅而不灰）
+    var out = []
+    for (var i = 0; i < n; i++) {
+      var k = i % 5
+      out.push(oklchToHex(
+        Math.min(0.96, Math.max(0.30, L + DL[k])),
+        Math.max(0.02, C + DC[k]), H
+      ))
+    }
+    return out
+  }
+  // 碰撞体：比精灵帧裁剪小 —— 宽度 = 帧宽 * 3/8（水平居中），高度略小；落点/贴边都以它为准
+  function collW() { return frameWidth() * 0.375 }
+  // 全部姿态里最宽的碰撞体（跳跃/腾空时都是 77.8~84.5 帧宽 → 29.2~31.7px），
+  // 传给大脑作 footprint：规划按"最坏情形"算站得住/落得下
+  function maxCollW() {
+    var m = 0
+    for (var k in ACTIONS) m = Math.max(m, ACTIONS[k].frameWidth * 0.375)
+    return m
+  }
+  function collX() { return state.position.x + (frameWidth() - collW()) / 2 }
+  function xOverlapColl(s) { return (collX() + collW() > s.x + 2) && (collX() < s.x + s.w - 2) }
+
+  // ---------- 渲染 ----------
+  function render() {
+    var w = frameWidth(), h = frameHeight()
+    el.style.width = w + 'px'
+    el.style.height = h + 'px'
+    el.style.left = state.position.x + 'px'
+    el.style.top = state.position.y + 'px'
+    el.style.backgroundPosition = (-state.currentFrame * w) + 'px ' + currentOffsetY() + 'px'
+    var mirror = state.currentAction === 'runLeft' || ((state.currentAction === 'jumpHoriz' || state.currentAction === 'jumpUp') && state.faceLeft)
+    el.style.transform = mirror ? 'rotateY(180deg)' : 'none'
+  }
+  function squash() {
+    el.style.transition = 'transform .06s ease'
+    el.style.transform = 'scaleY(0.86) scaleX(1.08)'
+    setTimeout(function () { el.style.transition = ''; el.style.transform = ''; if (state.faceLeft) el.style.transform = 'rotateY(180deg)' }, 110)
+  }
+
+  // ---------- 位置持久化 ----------
+  function savePosition() { try { localStorage.setItem(STORAGE_KEY, JSON.stringify(state.position)) } catch (e) {} }
+  function readPosition() {
+    try {
+      var saved = JSON.parse(localStorage.getItem(STORAGE_KEY) || 'null')
+      if (saved && typeof saved.x === 'number' && typeof saved.y === 'number') return saved
+    } catch (e) {}
+    return null
+  }
+  function clampPosition() {
+    var maxX = window.innerWidth - frameWidth()
+    state.position.x = Math.max(0, Math.min(maxX, state.position.x))
+    // 非腾空：不强制 y ≥ 0（允许随表面滚动骑出视口上沿——物理一致，滚回来即可见）
+    if (!airborne) { state.position.y = Math.min(window.innerHeight - frameHeight() - 2, state.position.y) }
+    savePosition()
+  }
+
+  // ---------- 动作切换 ----------
+  function setAction(action) {
+    if (state.currentAction === action) return
+    state.currentAction = action
+    state.currentFrame = 0
+    if (action !== 'jumpHoriz' && action !== 'jumpUp') state.faceLeft = false
+    // 站在地面上时：动作帧高变化 → 自动把脚底对齐当前地面（防"落地瞬间姿态变化碰撞体变化→误判悬空"）
+    if (!airborne && BEHAVIOR !== 'drag' && BEHAVIOR !== 'fall') {
+      state.position.y = groundY - frameHeight()
+    }
+    render()
+  }
+  function setBehavior(b) {
+    if (BEHAVIOR === b) return
+    BEHAVIOR = b
+    if (b !== 'walk') walkTargetX = null
+  }
+
+  // ---------- 表面收集（节流扫描视口内高 DOM 顶面）----------
+  function collectSurfaces(force, fresh) {
+    var now = Date.now()
+    if (!force && now - lastSurfaceAt < SURFACE_SCAN_MS) return
+    // 移动/跳跃时不扫（减少卡顿）；决策/启动时 force 扫
+    if (!force && (airborne || BEHAVIOR === 'walk' || BEHAVIOR === 'attract' || BEHAVIOR === 'jump')) return
+    lastSurfaceAt = now
+    var out = []
+    try {
+      // 通用遍历：整棵渲染树（含任意 shadow DOM 子树 —— 组件化 UI 的内部块与普通块同权）
+      var els = []
+      ;(function scan(root) {
+        var list = root.querySelectorAll ? root.querySelectorAll('*') : []
+        for (var i = 0; i < list.length; i++) {
+          els.push(list[i])
+          if (list[i].shadowRoot) scan(list[i].shadowRoot)
+        }
+      })(document.body)
+      var steps = 0
+      var TAG_SKIP = { IMG: 1, SVG: 1, CANVAS: 1, VIDEO: 1, AUDIO: 1, IFRAME: 1, PICTURE: 1, EMBED: 1, OBJECT: 1 }
+      for (var i = 0; i < els.length; i++) {
+        var nm = els[i]
+        if (nm === el) continue
+        if (nm.closest('[data-pet-ignore]')) continue    // 标记忽略的容器（如调试面板/测试 UI）
+        // 便宜预筛不计预算（文档序上万节点也不会把预算耗尽）
+        if (nm.offsetHeight < SURFACE_MIN_H || nm.offsetWidth < SURFACE_MIN_W) continue
+        if (TAG_SKIP[nm.tagName]) continue
+        steps++
+        if (steps > SCAN_BUDGET) break                  // 预算只消耗在"深检候选"上
+        // 统一法则（通解，不针对任何具体页面/组件）：
+        //   一个元素是"表面" ⟺ ① 真实渲染（非 none/hidden/opacity>0.2）
+        //                      ② 属于内容层而非媒体资源（img/video/canvas/iframe 只是盒内资源，盒子才可站）
+        //                      ③ 尺寸 ≥ 最小可站（MIN_H×MIN_W，可调）
+        //                      ④ 顶面在视口内（top < 视口高 且 bottom > 0）
+        //                      ⑤ 不是全屏布局容器（≥0.8×视口 —— 布局层站上去无意义）
+        //   不再特判：fixed/sticky 位置（悬浮挂件可站）、顶部区域（顶部栏可站，悬挂由钳制+上界挤落兜底）
+        var cs = getComputedStyle(nm)
+        if (cs.display === 'none' || cs.visibility === 'hidden' || parseFloat(cs.opacity) <= 0.2) continue
+        if (cs.pointerEvents === 'none') continue                          // 装饰/不可交互背景（法则②语义）
+        if (nm.getAttribute('aria-hidden') === 'true') continue
+        var r = nm.getBoundingClientRect()
+        if (r.width < SURFACE_MIN_W || r.height < SURFACE_MIN_H) continue
+        if (r.bottom <= 0 || r.top >= window.innerHeight) continue
+        if (r.top < TOP_SAFE) continue              // 站立安全线：站上去明显超上界的面 → 不是表面（检测时过滤）
+        if (r.height >= window.innerHeight * 0.8) continue
+        if (!nm.__petId) nm.__petId = 's' + (petIdCounter++)   // 稳定 id（元素件上）
+        out.push({ id: nm.__petId, x: r.left, y: r.top, w: r.width, h: r.height, el: nm })
+      }
+      out.sort(function (a, b) { return (a.y - b.y) || (a.x - b.x) })
+      var dedup = []
+      for (var k = 0; k < out.length; k++) {
+        var dup = false
+        for (var m = 0; m < dedup.length; m++) {
+          // 合并：两个台边缘距离 < dedupGap（可调，默认 3px）→ 视为同一台（不看尺寸差 —— 距离说了算）；
+          // 保留"更长"的那个（面积大者占位，替换）
+          var d = dedup[m]
+          if (Math.abs(d.y - out[k].y) < dedupGap && Math.abs(d.x - out[k].x) < dedupGap) {
+            if (out[k].w * out[k].h > d.w * d.h) dedup[m] = out[k]   // 更大（更长）的台留下
+            dup = true
+            break
+          }
+        }
+        if (!dup) dedup.push(out[k])
+      }
+      // 【浮动表面池】旧成员保留：仍连接且尺寸未剧变 → 留在列表（滚动/重排导致 rect 变化只更新坐标）；
+      // 新扫到的面并进来（按元素去重）；仅 删除 或 尺寸剧变 才移除。
+      // 这样"能跳的面 = 在列表的面 = 高亮的面"三者稳定一致（之前每轮全量重建 → 面进出列表 →
+      // 宠物站上了/跳得了某些面但高亮没跟上 = 你看到"默认模式能跳的面比高亮多"）。
+      var merged = []
+      if (!fresh) {
+        for (var p = 0; p < surfaces.length && merged.length < SURFACE_MAX; p++) {
+          var oldS = surfaces[p]
+          if (!oldS.el || oldS.el.isConnected === false) continue
+          var orr
+          try { orr = oldS.el.getBoundingClientRect() } catch (e) { continue }
+          if (Math.abs(orr.height - oldS.h) > 60 || Math.abs(orr.width - oldS.w) > 60) continue   // 尺寸剧变 → 重扫接管
+          merged.push({ id: oldS.id, x: orr.left, y: orr.top, w: orr.width, h: orr.height, el: oldS.el })
+        }
+      }
+      for (var q = 0; q < dedup.length && merged.length < SURFACE_MAX; q++) {
+        var has = false
+        for (var z = 0; z < merged.length; z++) { if (merged[z].el === dedup[q].el) { has = true; break } }
+        if (!has) merged.push(dedup[q])
+      }
+      surfaces = merged
+      if (highlightOn) applyHighlight()   // 扫描后为（新）表面刷派生色高亮
+    } catch (e) {}
+  }
+
+  // ---------- 物理（rAF 循环里：腾空时重力积分 + 表面碰撞落地）----------
+  function physics(now) {
+    if (!airborne) { lastPhysicsTs = now; return }
+    var dt = clamp((now - lastPhysicsTs) / 16.7, 0.05, 3)
+    lastPhysicsTs = now
+    var prevFeet = feet()
+    // 分段重力：上升段（vy≤0）用 G 保跳跃弧线；下坠段（vy>0）用低重力 + 终端速度
+    // （0.15 加速度只拖延"起步"，速度仍会越积越大；终端速度让它变成恒定慢速飘落）
+    vy += (vy > 0 ? G_FALL : G) * dt
+    if (vy > V_FALL_MAX) vy = V_FALL_MAX
+    state.position.x += vx * dt
+    state.position.y += vy * dt
+    // x 夹在视口内（弧线全程飞，不再中途剪断水平速度）
+    var maxX = window.innerWidth - frameWidth()
+    if (state.position.x < 0) state.position.x = 0
+    if (state.position.x > maxX) state.position.x = maxX
+    var feetNow = feet()
+    if (vy > 0) {
+      var land = null
+      for (var i = 0; i < surfaces.length; i++) {
+        var s = surfaces[i]
+        // 分层实时 rect：距脚底 300px 内的面用实时（滚动/重排不悬空落旧位）；远的用快照（160 面也不拖帧）
+        var sr = (s.el && Math.abs(s.y - feetNow) < 300) ? s.el.getBoundingClientRect() : s
+        if (sr.top < TOP_SAFE) continue                                   // 跳跃实际表面同理：顶面过安全线 → 落点无效（穿透）
+        if (fallFromY !== null && sr.top <= fallFromY + 2) continue   // 跳过当前表面及以上（下坠中）
+        var crossed = (sr.top >= prevFeet - 5 && sr.top <= feetNow)   // 严格穿越（收紧防提前粘；每帧位移≤15px 不隧穿）
+        // 精准跳跃：near 吸附只对目标表面开放（±14）；自由跳（游戏模式/落摔）放宽 ±18 —— 邻近层不粘，目标层稳吸
+        var near = (Math.abs(feetNow - sr.top) <= (jumpGoalId === null ? 18 : 14)) && (jumpGoalId === null || s.id === jumpGoalId)
+        var overlap = (collX() + collW() > sr.left + 2) && (collX() < sr.left + sr.width - 2)
+        if ((crossed || near) && overlap) {
+          if (!land || sr.top < land.y) land = { id: s.id, x: sr.left, y: sr.top, w: sr.width, h: sr.height, el: s.el }
+        }
+      }
+      if (!land && feetNow >= window.innerHeight - 2) land = { x: 0, y: window.innerHeight, w: window.innerWidth, h: 0 }
+      if (land) doLand(land)
+    }
+    render()
+  }
+  function xOverlap(x, w, s) {
+    return (x + w > s.x + 2) && (x < s.x + s.w - 2)
+  }
+  function doLand(s) {
+    if (s.y >= window.innerHeight - 1) { groundY = window.innerHeight; onSurface = null }
+    else { groundY = s.y; onSurface = s }
+    state.position.y = Math.max(groundY - frameHeight(), -30)   // 站立钳制：顶面在屏顶附近时"悬挂"（只露头 30px，不整体出屏）
+    vy = 0; vx = 0
+    airborne = false
+    fallFromY = null
+    jumpTargetX = null
+    jumpGoalId = null
+    setBehavior('idle')
+    setAction('idle')
+    squash()
+    render()
+    // P3 路线推进 / 失败恢复
+    var landedId = onSurface ? onSurface.id : null
+    if (currentRoute && routeIdx >= 0 && routeIdx + 1 < currentRoute.length) {
+      if (landedId === currentRoute[routeIdx + 1]) {
+        routeIdx++
+        var reachedGoal = (routeIdx + 1 >= currentRoute.length)
+        lastDecision = { t: Date.now(), cur: landedId, goal: reachedGoal ? null : currentGoal, route: reachedGoal ? null : currentRoute, mode: reachedGoal ? 'done' : 'advance' }
+        if (reachedGoal) { currentGoal = null; currentRoute = null; routeIdx = 0 }
+      } else {
+        // 落偏/摔到别处 → 恢复：清路线，下个周期由实际位置重规划
+        lastDecision = { t: Date.now(), cur: landedId, goal: null, route: null, mode: 'recover' }
+        currentGoal = null; currentRoute = null; routeIdx = 0
+      }
+    }
+  }
+
+  // ---------- 跳跃 / 落下 ----------
+  var jumpFrameMs = 100   // 跳跃动画帧间隔（按本次跳跃预计空中时长自适应；非跳跃动作 100ms 循环）
+  // 预计空中时长（帧）：上升 tUp + 下坠（apex→目标顶面实际落差 dropH，不是 need！）
+  // 供弧线水平速度分配 + 动画帧速共用同一模型，避免"动画播完≠落地"
+  function airTimeFrames(need, rise) {
+    var tUp = Math.sqrt(2 * need / G)                   // 上升帧数 v0/G（v0=√(2·G·need)）
+    var dropH = Math.max(40, need - rise)                // apex → 目标顶面的实际坠落高度
+    var tDrop = 33 + Math.max(0, (dropH - 82) / 5)       // G_FALL 0.15 加速到终端速度 5 的帧数 + 匀速段
+    return tUp + Math.max(24, tDrop)
+  }
+  // 按本次跳跃的预计空中时长算动画帧速（大跳 → 慢动作，小跳 → 快动作；播完≈落地）
+  function setJumpAnimSpeed(need, rise, frameCount) {
+    jumpFrameMs = Math.max(40, Math.min(250, airTimeFrames(need, rise) * 16.7 / frameCount))
+  }
+  // 横跳到目标表面顶面（物理冲量 + 水平速度，抛物线会自然落在目标上；支持向下弧线落）
+  function jumpOnto(s) {
+    if (airborne) return
+    var rise = feet() - s.y                     // >0 = 目标顶高于当前脚下（要向上跳）；<0 = 目标更低（小抛后弧线下落）
+    if (rise < 0) fallFromY = feet() + 2        // 下跳弧线：跳过起点块及更上面的面 → "跳下去"不是绕圈落回原块
+    else fallFromY = null                       // 上跳：清下跳残留基线（否则挡中间层）
+    jumpGoalId = s.id ? s.id : null             // 精准跳跃：锁定目标面（near 吸附仅对目标开放）
+    // 大余量：半隐式积分离散误差 + 跳跃帧高变化都算进去；需要多高就按比例再加
+    var need = Math.max(80, rise * 1.15 + 60)
+    // 峰顶自适应裁顶：峰顶不出屏幕顶（随脚下高度缩放 → 本就在高处时小跳；地面大跳保留）
+    need = Math.min(need, Math.max(24, feet() - 10))
+    var v0 = Math.sqrt(2 * G * need)               // 初速度
+    vy = -v0
+    var targetX = clamp(s.x + s.w / 2 - frameWidth() / 2, 0, window.innerWidth - frameWidth())
+    var dirX = targetX - state.position.x
+    // 弧线物理：水平速度按整个飞行时间分配（上升+下坠到目标顶面）→ 完整抛物线弧线飞向落点；
+    // 不再"到目标 x 就停水平竖直砸落"（落地由 crossing 检测命中，doLand 清 vx）
+    var T = airTimeFrames(need, rise)
+    vx = clamp(dirX / T, -10, 10)
+    jumpTargetX = null
+    airborne = true
+    setBehavior('jump')
+    state.faceLeft = dirX < 0
+    // 双样式跳跃（v1 传统：横跳 h / 上跃 v）：
+    //   横向距离小（近身跳，≤80px）→ 上跃样式 jumpUp（垂直弧，落回/落上目标）
+    //   横向距离大 → 横跳样式 jumpHoriz（弧线飞向落点）
+    var styleV = Math.abs(dirX) <= 80
+    setJumpAnimSpeed(need, rise, styleV ? ACTIONS.jumpUp.frameCount : ACTIONS.jumpHoriz.frameCount)
+    setAction(styleV ? 'jumpUp' : 'jumpHoriz')
+    render()
+  }
+  // 上跳查看（垂直到能看到该表面高度，再落回）
+  function jumpUpInspect(s) {
+    if (airborne) return
+    var rise = feet() - s.y
+    var need = Math.max(110, rise * 1.15 + 80)
+    vy = -Math.sqrt(2 * G * need)
+    vx = 0
+    airborne = true
+    setBehavior('jump')
+    state.faceLeft = false
+    setJumpAnimSpeed(need, rise, ACTIONS.jumpUp.frameCount)
+    setAction('jumpUp')
+    render()
+  }
+  // 从当前表面跳下（重力坠落到下一层/窗口底）
+  function fallDown() {
+    if (airborne) return
+    airborne = true
+    vy = 0.6
+    vx = 0
+    fallFromY = onSurface ? onSurface.y : groundY
+    jumpGoalId = null
+    setBehavior('fall')
+    setAction('idle')
+    render()
+  }
+
+  // ---------- 游戏模式（键盘接管；物理规则不变） ----------
+  function setGameMode(m) {
+    GAME_MODE = (m === true || m === 'game')   // console 传 'game'；API 传布尔 true
+    gameDir = 0
+    currentGoal = null; currentRoute = null; routeIdx = 0
+    if (!airborne && BEHAVIOR !== 'drag') { setBehavior('idle'); setAction('idle') }
+    render()
+  }
+  function setHighlight(on, color) {
+    highlightOn = !!on
+    if (color) highlightColor = color
+    applyHighlight()
+  }
+  function setDedupGap(px) {
+    dedupGap = Math.min(200, Math.max(0, parseInt(px, 10) || 3))   // 0~200px（用户上限）
+    collectSurfaces(true, true)  // 合并阈值变化 → 清池全量重建（否则浮动池保留旧面，合并永不生效）
+  }
+  function setHighlightAlpha(v) {
+    highlightAlpha = Math.min(1, Math.max(0.05, parseFloat(v) || 0.5))
+    applyHighlight()
+  }
+  function setDisableUpDown(v) { disableUpDown = !!v }
+  // 高亮可跳跃上界：每个表面用【不同的派生色】（主题色系错色卡，按位置循环分配）——
+  // 色相±18°步进 + 明暗交替，相邻面板一眼可区分；每面双层线（上亮线 + 本面主色线）
+  var hlOwned = []                // 高亮所有权清单：上次刷过的元素（先清后刷 → 被合并/删除的面残留线被擦掉）
+  function applyHighlight() {
+    // 先擦旧：所有曾高亮的元素重置（被合并删除的面不再残留）
+    for (var r = 0; r < hlOwned.length; r++) {
+      if (hlOwned[r].style) hlOwned[r].style.boxShadow = ''
+    }
+    hlOwned = []
+    var arr = surfaces
+    if (!arr.length) return
+    if (!highlightOn) return
+    var sorted = arr.slice().sort(function (a, b) { return a.y - b.y })   // y 越小越高；按空间顺序分配错色
+    var pal = derivePalette(highlightColor, 5)
+    for (var i = 0; i < sorted.length; i++) {
+      var s = sorted[i]
+      if (!s.el) continue
+      var c = pal[i % pal.length]                                          // 本面派生色（hex）
+      var a = highlightAlpha
+      s.el.style.boxShadow = 'inset 0 2px 0 ' + hexToRgba(shade(c, 0.35), Math.min(1, a + 0.12)) + ', inset 0 4px 0 ' + hexToRgba(c, a)
+      hlOwned.push(s.el)
+    }
+  }
+  // 起跳：地面/表面 → 第一次跳；空中 → 多段跳（踩空气上天，任意次；空中方向由键左右调整）
+  // 关键：起跳/二段跳都要清 fallFromY —— 摔落（fallDown）留下的"跳过当前面及以上"基线
+  // 会挡住所有比摔落起点高的层 → 玩家二段跳爬不回去 = "游戏模式跳不了高 UI 层"
+  function gameJump() {
+    // 上界裁顶（与默认模式 jumpOnto 同法则）：apex 距屏顶 ≥10px —— 顶部起跳被"天花板"压住，不越界
+    var need = Math.min(!airborne ? GAME_JUMP : GAME_JUMP_AIR, Math.max(24, feet() - 10))
+    // 双样式随机（v1 传统 h/v）：每次按跳随机 横跳(jumpHoriz) / 上跃(jumpUp)
+    var styleV = Math.random() < 0.45
+    if (!airborne) {
+      vy = -Math.sqrt(2 * G * need)
+      if (styleV) vx = 0
+      jumpTargetX = null
+      jumpGoalId = null           // 玩家自由跳：不锁定目标（附近层都可吸附）
+      fallFromY = null
+      airborne = true
+      setBehavior('jump')
+      setAction(styleV ? 'jumpUp' : 'jumpHoriz')
+    } else {
+      vy = -Math.sqrt(2 * G * need)
+      if (styleV) vx = 0          // 上跃段：竖直；横跳段：保留水平（空中可继续左右调）
+      fallFromY = null            // 二段跳：可爬回摔落起点以上的层
+      jumpGoalId = null
+      setAction(styleV ? 'jumpUp' : 'jumpHoriz')   // 重播跳跃动画（帧归零）
+    }
+    render()
+  }
+  function gameFastFall() {
+    if (airborne) { vy = Math.max(vy, 9); return }   // 空中：快落（加速度压低终端速度）
+    if (BEHAVIOR === 'drag' || BEHAVIOR === 'shake') return
+    fallDown()                                        // 站在表面/地面：摔落（物理引擎接管，落到下方表面/窗口底）
+  }
+  function onKeyDown(e) {
+    if (!GAME_MODE) return
+    var t = e.target
+    if (t && (t.tagName === 'INPUT' || t.tagName === 'TEXTAREA' || t.isContentEditable)) return
+    var c = e.code
+    if (c === 'ArrowLeft' || c === 'KeyA') { gameDir = -1; e.preventDefault() }
+    else if (c === 'ArrowRight' || c === 'KeyD') { gameDir = 1; e.preventDefault() }
+    else if (c === 'Space' || c === 'ArrowUp' || c === 'KeyW') {
+      if (c === 'ArrowUp' && disableUpDown) return      // 禁用上下键：↑ 不响应（空格/W 仍可跳）
+      gameJump(); e.preventDefault()
+    }
+    else if (c === 'ArrowDown' || c === 'KeyS') {
+      if (c === 'ArrowDown' && disableUpDown) return    // 禁用上下键：↓ 不响应（S 仍快落）
+      gameFastFall(); e.preventDefault()
+    }
+    else if (c === 'KeyH') { if (!airborne) startShake() }
+  }
+  function onKeyUp(e) {
+    if (!GAME_MODE) return
+    var c = e.code
+    if ((c === 'ArrowLeft' || c === 'KeyA') && gameDir === -1) gameDir = 0
+    if ((c === 'ArrowRight' || c === 'KeyD') && gameDir === 1) gameDir = 0
+  }
+  // 游戏模式移动（tick 内每帧）：地面左右跑；空中左右微调 vx（控制弧线方向）
+  function gameMove(fdt) {
+    if (!GAME_MODE) return
+    if (gameDir === 0) {
+      if (!airborne && BEHAVIOR === 'walk') { setBehavior('idle'); setAction('idle') }
+      return
+    }
+    if (airborne) {
+      vx = clamp(vx + gameDir * 0.35 * fdt, -7, 7)
+      state.faceLeft = gameDir < 0
+    } else {
+      var maxX = window.innerWidth - frameWidth()
+      state.position.x = clamp(state.position.x + gameDir * 3.4 * fdt, 0, maxX)
+      state.faceLeft = gameDir < 0
+      if (BEHAVIOR !== 'drag') { setBehavior('walk'); setAction(gameDir > 0 ? 'runRight' : 'runLeft') }
+    }
+  }
+
+  // ---------- 地面行为 ----------
+  function startWalk() {
+    if (airborne) return
+    setBehavior('walk')
+    var half = window.innerWidth / 2
+    var cx = state.position.x + frameWidth() / 2
+    var dir = cx < half ? 'right' : 'left'
+    var dist = 220 + Math.random() * 300        // 更长距离 → 走得更久（步速已按 dt 放缓）
+    walkTargetX = dir === 'right'
+      ? Math.min(window.innerWidth - frameWidth(), state.position.x + dist)
+      : Math.max(0, state.position.x - dist)
+    state.faceLeft = dir === 'left'
+    setAction(dir === 'right' ? 'runRight' : 'runLeft')
+  }
+  function startShake() {
+    if (airborne) return
+    setBehavior('shake')
+    setAction('active')
+    setTimeout(function () {
+      if (BEHAVIOR === 'shake' && !airborne) { setBehavior('idle'); setAction('idle') }
+    }, 4000)
+  }
+
+  // 找"更高"的表面（比当前地面高的、且横向上接近的）
+  function pickHigherSurface() {
+    var cx = collX() + collW() / 2     // 碰撞体中心
+    var best = null, bestScore = Infinity
+    for (var i = 0; i < surfaces.length; i++) {
+      var s = surfaces[i]
+      if (s.y >= groundY - 6) continue          // 必须更高（顶面在当前位置上方）
+      var dx = Math.max(0, Math.max(cx - (s.x + s.w), s.x - cx))
+      if (dx > 220) continue                     // 太远
+      var score = Math.abs(groundY - s.y) * 0.6 + dx
+      if (score < bestScore) { bestScore = score; best = s }
+    }
+    return best
+  }
+
+  // ---------- 决策大脑（P2：扫描射线 → 平台图 → A* 路线 → 逐段执行；软随机 + 突发）----------
+  // brain 世界：surfaces → [{id,x,y,w,h}]
+  function brainWorld() {
+    return surfaces.map(function (s) { return { id: s.id, x: s.x, y: s.y, w: s.w, h: s.h } })
+  }
+  // 当前所站平台的 id（站在窗口底则 null）
+  function currentSurfaceId() {
+    if (!onSurface) return null
+    if (onSurface.id) return onSurface.id
+    for (var i = 0; i < surfaces.length; i++) if (surfaces[i].el === onSurface.el) return surfaces[i].id
+    return null
+  }
+  function findSurfaceById(id) {
+    for (var i = 0; i < surfaces.length; i++) if (surfaces[i].id === id) return surfaces[i]
+    return null
+  }
+  // 定向走：走向目标 x（targetX）
+  function walkTo(targetX) {
+    if (airborne) return
+    setBehavior('walk')
+    var maxX = window.innerWidth - frameWidth()
+    walkTargetX = clamp(targetX, 0, maxX)
+    state.faceLeft = walkTargetX < state.position.x
+    setAction(state.faceLeft ? 'runLeft' : 'runRight')
+  }
+  // 突发动作
+  function doWhim(type) {
+    if (type === 'hop') jumpOnto(currentOrNearby())
+    else if (type === 'shake') startShake()
+    else startWalk()
+  }
+  function currentOrNearby() {
+    // 突发跳：对着附近"更高"平台跳（若没有则小上跳一次；假目标随当前高度走，不再绝对贴顶）
+    var h = pickHigherSurface()
+    return h || { x: state.position.x, y: Math.max(44, groundY - 220), w: frameWidth(), h: frameHeight() }
+  }
+  // 执行路线一段：向 route[idx+1] 进发（跳上 / 走过去落下）
+  function executeStep(graph, route, idx) {
+    var nextId = route ? route[idx + 1] : null
+    var cur = route ? graph.byId[route[idx]] : null
+    if (!nextId) { if (rng() < 0.5) startWalk(); else startShake(); return }
+    var nextS = findSurfaceById(nextId)
+    if (!nextS) { if (rng() < 0.5) startWalk(); else startShake(); return }
+    var rise = cur ? (cur.y - nextS.y) : 0      // >0 = 目标更高
+    var targetX = nextS.x + nextS.w / 2 - frameWidth() / 2
+    if (rise > 0 || rng() < 0.5) {
+      jumpOnto(nextS)                            // 更高：必跳；平/更低：50% 也是弧线跳过去
+    } else {
+      walkTo(targetX)                            // 其余：走过去（窄平台走到边缘自然落）
+    }
+  }
+
+  // 最近平台（按水平距离）
+  function nearestPlatform() {
+    var cx = collX() + collW() / 2
+    var best = null, bestD = Infinity
+    for (var i = 0; i < surfaces.length; i++) {
+      var s = surfaces[i]
+      if (s.y >= groundY - 4) continue            // 只看上方平台
+      var d = Math.abs((s.x + s.w / 2) - cx)
+      if (d < bestD) { bestD = d; best = s }
+    }
+    return best
+  }
+
+  // 散步：在平台上（或窗口底）水平走走
+  function roam() {
+    var maxX = window.innerWidth - frameWidth()
+    var tx
+    if (onSurface && onSurface.w > 180) {
+      tx = onSurface.x + 50 + rng() * Math.max(10, (onSurface.w - 110 - frameWidth()))
+    } else {
+      tx = rng() * maxX
+    }
+    walkTo(clamp(tx, 0, maxX))
+    lastDecision = { t: Date.now(), cur: currentSurfaceId(), goal: null, route: null, mode: 'roam' }
+  }
+
+  // 决策（大脑驱动）：先续行当前路线，否则规划新路线
+  function decideNext() {
+    if (GAME_MODE) return                       // 游戏模式：玩家接管，大脑休息
+    if (BEHAVIOR !== 'idle' || airborne) return
+    if (Date.now() < whimRestUntil) return          // 突发后短暂休息，再回计划
+    collectSurfaces()
+    // 随机突发（不打断腾空；在 idle/落地后触发；= 打断当前计划，真"任性"）
+    var w = whimTick(Date.now(), lastWhimAt, [4500, 9000], rng)
+    if (w.trigger) {
+      lastWhimAt = Date.now()
+      whimRestUntil = Date.now() + 1200
+      currentGoal = null; currentRoute = null; routeIdx = 0
+      lastDecision = { t: Date.now(), cur: null, goal: null, route: null, mode: 'whim', type: w.type }
+      doWhim(w.type)
+      return
+    }
+    // 扫描 + 建图
+    var world = brainWorld()
+    if (!world.length) { if (rng() < 0.5) startWalk(); else startShake(); return }
+    var graph = buildGraph(world, DEFAULT_PHYS, maxCollW())
+    var curId = currentSurfaceId()
+    if (!curId) {
+      // 站在窗口底：走向最近的平台，够近就跳上去
+      var target = nearestPlatform()
+      if (target) {
+        var cx = collX() + collW() / 2
+        var dxNow = (target.x + target.w / 2) - cx
+        if (Math.abs(dxNow) > 260) { walkTo(target.x + target.w / 2 - frameWidth() / 2); return }
+        jumpOnto(target)
+        return
+      }
+      if (rng() < 0.5) startWalk(); else startShake()
+      return
+    }
+    // 续行：若还在路线上（当前站 = route[idx]），继续下一段
+    if (currentRoute && routeIdx >= 0 && currentRoute[routeIdx] === curId && routeIdx + 1 < currentRoute.length) {
+      executeStep(graph, currentRoute, routeIdx)
+      return
+    }
+    // 偶尔散散步（水平行走），与闯关穿插
+    if (rng() < 0.35) { roam(); return }
+    // 规划新目标/路线
+    var goal = pickGoal(graph, curId, rng)
+    if (goal && goal !== curId) {
+      var route = planRoute(graph, curId, goal)
+      lastDecision = { t: Date.now(), cur: curId, goal: goal, route: route || null, mode: 'plan' }
+      currentGoal = goal
+      currentRoute = route
+      routeIdx = 0
+      if (route && route.length >= 2) executeStep(graph, route, 0)
+      else { if (rng() < 0.5) startWalk(); else startShake() }
+    } else {
+      lastDecision = { t: Date.now(), cur: curId, goal: null, route: null, mode: 'wander' }
+      currentGoal = null; currentRoute = null; routeIdx = 0
+      if (rng() < 0.6) startWalk(); else startShake()
+    }
+  }
+
+  // ---------- 主循环（rAF：帧循环 + 行走 + 常驻引力 + 物理）----------
+  var lastTickTs = 0
+  function tick(now) {
+    var fdt = clamp((now - lastTickTs) / 16.7, 0.05, 3)
+    lastTickTs = now
+    // 帧推进：跳跃动画按本次跳跃时长自适应帧速（大跳慢动作/小跳快动作），非跳跃动作 100ms 循环
+    var frameMs = (state.currentAction === 'jumpUp' || state.currentAction === 'jumpHoriz') ? jumpFrameMs : 100
+    if (now - lastFrameTs >= frameMs) {
+      lastFrameTs = now
+      var jumpAct = state.currentAction === 'jumpUp' || state.currentAction === 'jumpHoriz'
+      state.currentFrame += 1
+      if (jumpAct) {
+        // 跳跃动画只播一遍：播完最后一帧 → 恢复默认 idle（不定格跳跃姿态；空中也回 idle 待机）
+        if (state.currentFrame >= currentFrameCount()) setAction('idle')
+      } else {
+        state.currentFrame = state.currentFrame % currentFrameCount()
+      }
+    }
+    // 常驻引力：站地上但没贴住当前地面（悬空/地面变了）→ 立即下坠（缓冲阈值放宽到 12px）
+    if (!airborne && BEHAVIOR !== 'drag' && Math.abs(feet() - groundY) > 12) {
+      fallDown()
+    }
+    // 所站的 DOM 表面：删除（isConnected=false）→ 重力接管下落；
+    // 移动（如滚动上移/面板位移）→ 宠物"骑乘"：按表面位移贴上去，不掉下来
+    if (!airborne && BEHAVIOR !== 'drag' && onSurface && onSurface.el && now - lastGroundChk > 150) {
+      lastGroundChk = now
+      var groundGone = onSurface.el.isConnected === false
+      if (!groundGone) {
+        try {
+          var nr = onSurface.el.getBoundingClientRect()
+          var dxs = nr.left - onSurface.x
+          var dys = nr.top - onSurface.y
+          if (Math.abs(dxs) > 0.5 || Math.abs(dys) > 0.5) {
+            if (dys > 6) {
+              // 表面向下移走（滚动下移/消息下移）：不强制跟随 —— 支撑消失，重力系统接管（悬空下坠，落回或掉落）
+              onSurface = null
+              fallDown()
+            } else {
+              // 表面向上/横向移动：骑乘跟随（保持站在顶面；x 夹在视口内防穿帮）
+              state.position.x = clamp(state.position.x + dxs, 0, window.innerWidth - frameWidth())
+              state.position.y += dys
+              onSurface.x = nr.left; onSurface.y = nr.top
+              onSurface.w = nr.width; onSurface.h = nr.height
+              groundY = nr.top
+              render()
+            }
+          }
+        } catch (e) { groundGone = true }
+      }
+      // 横向逃逸兜底：表面横移超出视口/宠物被 clamp 跟不上（碰撞体与表面完全分离）→ 掉落
+      if (!groundGone && !airborne && onSurface &&
+          (collX() + collW() < onSurface.x - 4 || collX() > onSurface.x + onSurface.w + 4)) {
+        onSurface = null
+        fallDown()
+      }
+      if (groundGone) {
+        onSurface = null
+        fallDown()
+      }
+    }
+    // 上界限位：脚底越过站立安全线（骑乘/站立被推到顶部只剩不到七成身体在屏内）→ 强制挤落；
+    // 与收集过滤同一安全线：任何路径都踩不进"顶面 < TOP_SAFE 的表面"
+    if (!airborne && BEHAVIOR !== 'drag' && feet() < TOP_SAFE) {
+      fallDown()
+      onSurface = null
+    }
+    // 吸引是"短暂反应"：鼠标停在附近 1.5s 不动 → 解除吸引回 idle（拖动为主）
+    if (BEHAVIOR === 'attract' && now - lastMouseMoveTime > 1500) {
+      setBehavior('idle')
+      setAction('idle')
+    }
+    // 行走（地面水平移动，按 dt 换算真实时间；走出表面边缘 → 掉落）
+    if (BEHAVIOR === 'walk' && walkTargetX !== null && !airborne) {
+      var dx = walkTargetX - state.position.x
+      var step = clamp(dx, -1.6 * fdt, 1.6 * fdt)
+      state.position.x += step
+      if (Math.abs(dx) <= 1.6 * fdt) {
+        walkTargetX = null
+        setBehavior('idle')
+        setAction('idle')
+      } else if (onSurface &&
+        (collX() + collW() < onSurface.x - 2 || collX() > onSurface.x + onSurface.w - 2)) {
+        fallDown()                                   // 碰撞体走出表面 → 摔下去
+      }
+      clampPosition()
+    }
+    gameMove(fdt)           // 游戏模式：键盘方向移动/空中调向
+    physics(now)
+    render()
+    requestAnimationFrame(tick)
+  }
+
+  // ---------- 吸引（简单方法：宠物组件内 mousemove 触发一次反应，防抖动=一次 hover 只触发一次）----------
+  var mouseOverPet = false
+  function onPetMouse(e) {
+    lastMouseMoveTime = Date.now()
+    if (BEHAVIOR === 'drag' || airborne || BEHAVIOR === 'jump') return
+    if (mouseOverPet) return          // 防抖动：已在宠物上时不重复触发
+    mouseOverPet = true
+    lastMouseEvent = e
+    // 吸引反应：朝鼠标方向短暂靠近一点（一次而已），随后回 idle
+    var cx = state.position.x + frameWidth() / 2
+    var ddir = (e.clientX - frameWidth() / 2) - state.position.x
+    setBehavior('attract')
+    state.faceLeft = ddir < 0
+    setAction(ddir >= 0 ? 'runRight' : 'runLeft')
+    state.position.x += clamp(ddir, -3, 3)
+    clampPosition()
+    render()
+    setTimeout(function () {
+      if (BEHAVIOR === 'attract') { setBehavior('idle'); setAction('idle'); render() }
+    }, 450)
+  }
+
+  // ---------- 拖拽 ----------
+  function startDrag(e) {
+    e.stopPropagation()
+    setBehavior('drag')
+    state.dragMoved = false
+    state.dragStartX = state.position.x
+    state.dragStartY = state.position.y
+    var clientX, clientY
+    if (e.touches) { clientX = e.touches[0].clientX; clientY = e.touches[0].clientY }
+    else { clientX = e.clientX; clientY = e.clientY }
+    window.__petDomDragOffset = { x: clientX - state.position.x, y: clientY - state.position.y }
+    document.addEventListener('mousemove', onDrag)
+    document.addEventListener('mouseup', stopDrag)
+    document.addEventListener('touchmove', onDrag)
+    document.addEventListener('touchend', stopDrag)
+    setAction('active')
+    render()
+  }
+  function onDrag(e) {
+    if (BEHAVIOR !== 'drag') return
+    var clientX, clientY
+    if (e.touches) { clientX = e.touches[0].clientX; clientY = e.touches[0].clientY }
+    else { clientX = e.clientX; clientY = e.clientY }
+    var off = window.__petDomDragOffset
+    var nx = clientX - off.x, ny = clientY - off.y
+    state.position.x = clamp(nx, 0, window.innerWidth - frameWidth())
+    state.position.y = clamp(ny, 0, window.innerHeight - frameHeight())
+    if (Math.abs(state.position.x - state.dragStartX) > 4 || Math.abs(state.position.y - state.dragStartY) > 4) state.dragMoved = true
+    savePosition()
+    render()
+  }
+  function stopDrag() {
+    document.removeEventListener('mousemove', onDrag)
+    document.removeEventListener('mouseup', stopDrag)
+    document.removeEventListener('touchmove', onDrag)
+    document.removeEventListener('touchend', stopDrag)
+    // 先置腾空再恢复动作（否则 setAction 的"地面对齐"会把位置瞬间拉回地面）
+    airborne = true
+    vy = 0.6
+    vx = 0
+    setBehavior('idle')
+    setAction('idle')
+    // 松手后从释放点自然坠落，落到下方最近表面/窗口底
+  }
+
+  // ---------- 启动 ----------
+  function init() {
+    var saved = readPosition()
+    if (saved) {
+      state.position = saved
+    } else {
+      // 默认：浏览器窗口最底下
+      state.position = { x: window.innerWidth / 2 - frameWidth() / 2, y: window.innerHeight - frameHeight() - 2 }
+    }
+    groundY = window.innerHeight
+    onSurface = null
+    airborne = false
+    clampPosition()
+    collectSurfaces(true)
+    setInterval(collectSurfaces, SURFACE_SCAN_MS)
+    setInterval(decideNext, MOVE_INTERVAL)
+    window.addEventListener('resize', function () { collectSurfaces(true); clampPosition(); render() })
+    // 滚动节流刷新（capture 捕获所有滚动容器）：新表面/高亮跟手，不等 1200ms 扫描
+    var scrollFlush = 0
+    window.addEventListener('scroll', function () {
+      var now2 = Date.now()
+      if (now2 - scrollFlush < 300) return
+      scrollFlush = now2
+      collectSurfaces(true)
+      if (highlightOn) applyHighlight()
+    }, { capture: true, passive: true })
+    // 控制台（右上角悬浮面板；双击宠物唤回）
+    petConsole = createPetConsole({
+      onMode: function (m) { setGameMode(m) },
+      onHighlight: function (on, color) { setHighlight(on, color) },
+      onTheme: function (color) { if (highlightOn) setHighlight(true, color) },
+      onDedupGap: function (px) { setDedupGap(px) },
+      onHighlightAlpha: function (v) { setHighlightAlpha(v) },
+      onDisableUpDown: function (v) { setDisableUpDown(v) }
+    })
+    window.addEventListener('keydown', onKeyDown)
+    window.addEventListener('keyup', onKeyUp)
+    window.addEventListener('blur', function () { gameDir = 0 })
+    el.addEventListener('dblclick', function () { if (petConsole && petConsole.show) petConsole.show() })
+    el.addEventListener('mousemove', onPetMouse)
+    el.addEventListener('mouseleave', function () { mouseOverPet = false })
+    el.addEventListener('mousedown', startDrag)
+    el.addEventListener('touchstart', startDrag)
+    el.addEventListener('click', function (e) { e.stopPropagation() })
+    render()
+    requestAnimationFrame(tick)
+  }
+
+  // ---------- 测试/开发控制 API ----------
+  window.__petDom = {
+    forceAction: function (name) {
+      if (!ACTIONS[name]) return { ok: false, action: state.currentAction }
+      airborne = false; vy = 0; vx = 0
+      setBehavior('idle'); setAction(name); render()
+      return { ok: true, action: name }
+    },
+    info: function () {
+      return {
+        action: state.currentAction, behavior: BEHAVIOR,
+        x: Math.round(state.position.x), y: Math.round(state.position.y),
+        groundY: Math.round(groundY), airborne: airborne,
+        surfaces: surfaces.length, onSurface: onSurface ? Math.round(onSurface.y) : null,
+        coll: { x: Math.round(collX()), y: Math.round(state.position.y + frameHeight() - frameHeight() * 0.92), w: Math.round(collW()), h: Math.round(frameHeight() * 0.92) },
+        onEl: onSurface ? (onSurface.el ? ((onSurface.el.className + '').slice(0, 24) + '#' + (onSurface.el.tagName || '')) : 'NOEL') : null
+      }
+    },
+    jumpTo: function (i) { collectSurfaces(true); if (surfaces[i]) jumpOnto(surfaces[i]); return { surfaces: surfaces.length } },
+    jumpInspect: function (i) { collectSurfaces(true); if (surfaces[i]) jumpUpInspect(surfaces[i]); return { surfaces: surfaces.length } },
+    fall: function () { fallDown() },
+    walk: function () { if (!airborne) startWalk() },
+    shake: function () { if (!airborne) startShake() },
+    surfaces: function () {
+      collectSurfaces(true)
+      return surfaces.map(function (s) { return { x: Math.round(s.x), y: Math.round(s.y), w: Math.round(s.w), h: Math.round(s.h) } })
+    },
+    // —— P2 大脑调试 ——
+    world: function () { collectSurfaces(true); return brainWorld() },
+    rays: function () {
+      collectSurfaces(true)
+      var from = { x: collX() + collW() / 2, y: state.position.y + frameHeight() }
+      var w = brainWorld()
+      return {
+        from: { x: Math.round(from.x), y: Math.round(from.y) },
+        ahead: raycast(w, from, 'ahead', 700) ? { id: raycast(w, from, 'ahead', 700).id, x: Math.round(raycast(w, from, 'ahead', 700).x), y: Math.round(raycast(w, from, 'ahead', 700).y) } : null,
+        up: raycast(w, from, 'up', 500) ? { id: raycast(w, from, 'up', 500).id, x: Math.round(raycast(w, from, 'up', 500).x), y: Math.round(raycast(w, from, 'up', 500).y) } : null,
+        down: raycast(w, from, 'down', 300) ? { id: raycast(w, from, 'down', 300).id, x: Math.round(raycast(w, from, 'down', 300).x), y: Math.round(raycast(w, from, 'down', 300).y) } : null
+      }
+    },
+    route: function () { return { goal: currentGoal, route: currentRoute } },
+    decision: function () { return lastDecision },
+    setSeed: function (n) { setSeed(n); return n === undefined ? 'seed=off' : 'seed=' + n },
+    planNow: function () { decideNext(); return lastDecision },
+    // —— 控制台/游戏模式 ——
+    gameMode: function () { return GAME_MODE },
+    setGameMode: function (m) { setGameMode(m); return GAME_MODE },
+    consoleShow: function () { if (petConsole && petConsole.show) petConsole.show() },
+    setHighlight: function (on, color) { setHighlight(on, color); return highlightOn }
+  }
+
+  init()