diff --git a/assets/RuntimeBridge.ts b/assets/RuntimeBridge.ts new file mode 100644 index 0000000..f4af6f8 --- /dev/null +++ b/assets/RuntimeBridge.ts @@ -0,0 +1,1844 @@ +// ============================================================================ +// yyka-runtime-inspector —— 游戏侧桥接脚本（常驻节点版，供用户安装进项目 assets） +// +// 特性： +// · 常驻节点：onLoad 时 director.addPersistRootNode(this.node)，跨场景存活。 +// · 自动连接：脚本被加载后，监听场景启动并自动创建常驻节点，无需手动摆放节点 +// 也无需手动调用 connect()。若想手动控制，可放置节点后设 autoConnect=false。 +// · 自动重连：连接断开后按 reconnectDelay 自动重连。 +// +// 用法（两种任选其一）： +// A. 推荐：让安装按钮把本脚本装进 assets 后，脚本会在首次场景自动创建常驻节点。 +// B. 手动：新建空节点，挂上 RuntimeBridge 组件，配置 host/port/autoConnect。 +// 局域网真机时把 host 设为电脑 IP。 +// +// 端口默认 33000，与插件主进程内嵌的 WS 服务一致。 +// ============================================================================ +import { + _decorator, + Asset, + assetManager, + AudioSource, + Canvas, + Color, + Collider, + Collider2D, + Component, + Director, + director, + EventTouch, + game, + Graphics, + Layers, + Material, + Node, + PhysicsSystem, + profiler, + Quat, + Rect, + RenderRoot2D, + RigidBody, + RigidBody2D, + Size, + sys, + SystemEvent, + Touch, + UITransform, + Vec2, + Vec3, + Vec4, +} from 'cc'; + +const { ccclass, property, menu } = _decorator; + +const DEFAULT_HOST = '127.0.0.1'; +const DEFAULT_PORT = 33000; +/** 固定连接令牌：与插件静态令牌一致，不做动态生成、不依赖组件属性。 */ +const TOKEN = 'www.yyka.cn'; +/** 自动引导时创建的常驻节点名 */ +const PERSIST_NODE_NAME = '__yyka_runtime_bridge__'; +/** 桥接脚本版本：面板据此判断游戏侧是否在跑旧脚本 */ +const BRIDGE_VERSION = '1.0.254'; + +// ============================================================================ +// 全局 console 拦截：把游戏里的 log/warn/error 转发给插件面板。 +// 未连接时先积压到 consoleQueue，连接建立后再补发，避免丢日志。 +// ============================================================================ +const _origLog = console.log.bind(console); +const _origWarn = console.warn.bind(console); +const _origError = console.error.bind(console); +const consoleQueue: { evt: string; level: string; text: string; t: number }[] = []; + +function fmtConsoleArgs(args: any[]): string { + return args + .map((a) => { + try { + if (typeof a === 'string') { + return a; + } + if (a instanceof Error) { + return a.stack || String(a); + } + const s = JSON.stringify(a); + return s === undefined ? String(a) : s; + } catch { + return String(a); + } + }) + .join(' '); +} + +/** 已知的引擎内部告警噪音：变量填空类型时 getComponent 会警告「Type must be non-nil」， + * 纯属引擎内部提示、无业务价值。判定命中则既不打印到游戏控制台也不转发给面板。 */ +function isEngineNoise(args: any[]): boolean { + const text = fmtConsoleArgs(args); + return /getComponent: Type must be non-nil/.test(text); +} + +function pushConsole(level: string, args: any[]): void { + const item = { evt: 'console', level, text: fmtConsoleArgs(args), t: Date.now() }; + const inst = RuntimeBridge._instance; + if (inst) { + inst.sendConsoleMsg(item); + } else { + consoleQueue.push(item); + if (consoleQueue.length > 200) { + consoleQueue.shift(); + } + } +} + +function hookConsole(): void { + if ((console as any).__yykaHooked) { + return; + } + (console as any).__yykaHooked = true; + const wrap = (orig: (...a: any[]) => void, level: string) => (...args: any[]) => { + if (isEngineNoise(args)) { + return; // 引擎内部告警：不打印到真实控制台，也不转发 + } + orig(...args); + pushConsole(level, args); + }; + console.log = wrap(_origLog, 'log'); + console.warn = wrap(_origWarn, 'warn'); + console.error = wrap(_origError, 'error'); +} + +/** 捕获未被 console 覆盖的全局异常/未处理 Promise 拒绝。 */ +function hookGlobalErrors(): void { + try { + const g: any = globalThis as any; + if (g.__yykaErrHooked) { + return; + } + g.__yykaErrHooked = true; + if (typeof g.addEventListener === 'function') { + g.addEventListener('error', (e: any) => { + const err = e && e.error; + const text = e && e.message ? String(e.message) : (err ? String(err) : '未知错误'); + const stack = err && err.stack ? `\n${err.stack}` : ''; + pushConsole('error', [`[window.error] ${text}${stack}`]); + }); + g.addEventListener('unhandledrejection', (e: any) => { + const r = e && e.reason; + const text = r && r.stack ? r.stack : (r && r.message ? String(r.message) : String(r)); + pushConsole('error', [`[unhandledrejection] ${text}`]); + }); + } + } catch { + /* ignore */ + } +} + +// 模块求值即启用日志拦截，尽可能早地捕获游戏日志与报错 +hookConsole(); +hookGlobalErrors(); +hookApi(); + +/** 拦截空类型组件查询：getComponent/getComponentsInChildren 传入 undefined/空串时， + * 引擎会在内部反复打印 `getComponent: Type must be non-nil` 刷屏（走引擎自有告警通道， + * 不经过 console 钩子）。这里在 API 入口短路空类型，从源头消除告警， + * 行为与引擎返回 undefined / [] 一致（仅不再报警）。 */ +function hookApi(): void { + try { + if ((Node.prototype as any).__yykaApiHooked) { + return; + } + (Node.prototype as any).__yykaApiHooked = true; + const origGet = Node.prototype.getComponent; + const origGetInChildren = Node.prototype.getComponentsInChildren; + const empty = (t: any) => + t === null || t === undefined || (typeof t === 'string' && !t.trim()); + Node.prototype.getComponent = function (type: any, ...rest: any[]) { + if (empty(type)) return null; + return origGet.call(this, type, ...rest); + } as any; + Node.prototype.getComponentsInChildren = function (type: any) { + if (empty(type)) return []; + return origGetInChildren.call(this, type); + } as any; + } catch { + /* ignore */ + } +} + +/** 识别当前运行环境类型，随连接 URL 上报给插件，供面板显示客户端来源。 */ +function detectClientType(): string { + try { + if (sys.isNative) { + const p = sys.platform; + if (p === sys.Platform.ANDROID || p === sys.Platform.IOS) { + return 'device'; + } + return 'simulator'; + } + if (sys.isBrowser) { + const ua = (typeof navigator !== 'undefined' && navigator.userAgent) || ''; + // 编辑器内置预览运行于 Electron 环境 + if (/electron|cocoscreator/i.test(ua)) { + return 'editor'; + } + return 'h5'; + } + } catch { + /* 检测失败按未知处理 */ + } + return 'unknown'; +} + + +@ccclass('RuntimeBridge') +@menu('Debug/RuntimeBridge') +export class RuntimeBridge extends Component { + /** 全局单例，避免重复实例 */ + static _instance: RuntimeBridge | null = null; + + @property({ tooltip: '加载后是否自动连接' }) + autoConnect = true; + + @property({ tooltip: 'WS 服务地址' }) + host = '192.168.2.17'; + + @property({ tooltip: 'WS 服务端口' }) + port = DEFAULT_PORT; + + @property({ tooltip: '断开后自动重连延迟（秒）' }) + reconnectDelay = 2; + + @property({ tooltip: '启用时以该帧率向插件推送预览画面（0 表示关闭）' }) + previewFps = 0; + + private _ws: WebSocket | null = null; + private _timer: ReturnType | null = null; + private _reconnectTimer: ReturnType | null = null; + private _frameTimer: ReturnType | null = null; + private _manualClose = false; + /** 本次连接是否成功建立过（用于区分"被拒/不通"与"正常断开"） */ + private _everOpened = false; + /** 从未成功建立连接的连续失败次数，防止无限重连刷屏 */ + private _failCount = 0; + /** 实际连接的地址（候选列表中当前项） */ + private _connHost = DEFAULT_HOST; + /** 候选连接地址：用户配置优先，失败自动尝试模拟器/真机常见的宿主机地址 */ + private _addrCandidates: string[] = []; + private _addrIdx = 0; + private _muted = false; + private _resVol = new WeakMap(); + private _frameCount = 0; + private _lastStatsT = 0; + private _highlightOverlay: Node | null = null; + // ===== 画面抓帧缓存 ===== + // WebGL 画布未开 preserveDrawingBuffer 时，present 后缓冲区即被清空，非渲染时机 + // 对 #GameCanvas 调 toDataURL 只能得到纯黑。因此改在导演每次绘帧完成（EVENT_AFTER_DRAW， + // 此时默认缓冲仍持有本帧内容）时把画面缓存起来；截图/预览直接喂缓存帧，保证非黑。 + private _lastFrame: string | null = null; + private _capStamp = 0; + private _capHooked = false; + /** 最近一次场景启动时记录的场景名（H5 早期 getScene() 可能为 null，用缓存兜底）。 */ + private _sceneName = ''; + + /** 当前场景名：优先实时取 director.getScene()，取不到/为空时用缓存兜底，再无名字时给占位名。 */ + private currentSceneName(): string { + const scene: any = director.getScene(); + const live = scene && (scene.name || scene._name || ''); + return String(live || this._sceneName || 'main'); + } + + onLoad() { + if (RuntimeBridge._instance) { + // 已存在实例，销毁多余节点，避免重复连接 + this.node.destroy(); + return; + } + RuntimeBridge._instance = this; + // 常驻：跨场景存活 + if (!director.isPersistRootNode(this.node)) { + director.addPersistRootNode(this.node); + } + // 记录当前场景名，供 query-tree 在 getScene() 尚未就绪时兜底 + this._sceneName = director.getScene()?.name ?? ''; + // 安装绘帧完成钩子：让截图/预览在 AFTER_DRAW 拿到非黑画面（WebGL 缓冲会被清）。 + this.installFrameHook(); + if (this.autoConnect && !this._ws) { + this.connect(); + } + // 帧计数：用于统计 fps + director.on(Director.EVENT_AFTER_UPDATE, this.onFrame, this); + } + + private onFrame(): void { + this._frameCount++; + } + + /** 渲染/内存统计：drawCall / 三角形 / fps / 堆内存(MB)。 */ + private collectStats(): { drawCall: number; triangles: number; fps: number; memUsed: number; memTotal: number } { + // profiler.stats 里的字段可能是 PerfCounter 对象（带 value 属性），统一转成数字 + const toNum = (v: any): number => { + if (typeof v === 'number' && isFinite(v)) { + return v; + } + if (v && typeof v === 'object' && typeof v.value === 'number' && isFinite(v.value)) { + return v.value; + } + return 0; + }; + let drawCall = 0; + let triangles = 0; + try { + // 最优先：gfx 设备统计（director.root.device.numDrawCalls / numTris）， + // 不依赖 profiler 模块是否被功能裁剪，数据源与 profiler 一致 + const root: any = (director as any).root; + const dev = root && root.device; + if (dev) { + const dc = toNum(dev.numDrawCalls); + const tri = toNum(dev.numTris); + if (dc || tri) { + drawCall = dc; + triangles = tri; + } + } + // 其次：新版引擎的 profiler 统计（cc.profiler.stats: draws / tricount） + // 注意 3.x 里字段名是 draws 而不是 drawCall + if (!drawCall && !triangles) { + const prof: any = (profiler as any) || (globalThis as any).cc?.profiler; + const pst = prof && prof.stats; + if (pst) { + const dc = toNum(pst.draws ?? pst.drawCall ?? 0); + const tri = toNum(pst.tricount ?? pst.triangles ?? 0); + if (dc || tri) { + drawCall = dc; + triangles = tri; + } + } + } + // 再次：RenderScene 统计（默认关闭，需先 setStatistics(true)） + if (!drawCall && !triangles) { + const scene: any = director.getScene(); + const rs: any = scene && scene.getRenderScene ? scene.getRenderScene() : null; + if (rs) { + try { + rs.setStatistics && rs.setStatistics(true); + } catch (e) { + /* ignore */ + } + const st = rs.statistics; + if (st) { + const dc = toNum(st.drawCall ?? st.drawCalls ?? st.draws ?? 0); + const tri = toNum(st.triangle ?? st.triangles ?? st.triangleCount ?? 0); + if (dc || tri) { + drawCall = dc; + triangles = tri; + } + } + } + } + // 兜底：director.getStats()（部分版本可用） + if (!drawCall && !triangles) { + const d: any = director as any; + const stats: any = typeof d.getStats === 'function' ? d.getStats() : null; + if (stats) { + drawCall = toNum(stats.drawCall ?? stats.draws ?? 0); + triangles = toNum(stats.triangles ?? stats.trianglesCount ?? 0); + } + } + } catch (e) { + drawCall = 0; + triangles = 0; + } + // 堆内存（MB）：浏览器预览可用 performance.memory；原生/无此接口则为 0 + let memUsed = 0; + let memTotal = 0; + try { + const pm: any = (globalThis as any).performance && (globalThis as any).performance.memory; + if (pm) { + memUsed = Math.round(pm.usedJSHeapSize / 1048576); + memTotal = Math.round(pm.totalJSHeapSize / 1048576); + } + } catch (e) { + memUsed = 0; + memTotal = 0; + } + const now = Date.now(); + const dtSec = this._lastStatsT ? (now - this._lastStatsT) / 1000 : 1; + const fps = dtSec > 0 ? Math.round(this._frameCount / dtSec) : 0; + this._frameCount = 0; + this._lastStatsT = now; + return { drawCall, triangles, fps, memUsed, memTotal }; + } + + /** 资源/对象统计：场景节点与组件数 + assetManager 中各类资源数量。 */ + private getResourceStats(): any { + const out: any = { + nodes: 0, + components: 0, + textures: 0, + sprites: 0, + materials: 0, + meshes: 0, + audioClips: 0, + animations: 0, + prefabs: 0, + spriteAtlases: 0, + jsons: 0, + texts: 0, + others: 0, + totalAssets: 0, + }; + const scene = director.getScene(); + if (scene) { + scene.walk(() => { + out.nodes++; + }); + try { + out.components = scene.getComponentsInChildren(Component).length; + } catch { + /* ignore */ + } + } + try { + const am: any = assetManager as any; + const assets: any = am && am.assets; + if (assets && typeof assets.forEach === 'function') { + out.totalAssets = 0; + assets.forEach((asset: any) => { + out.totalAssets++; + const cls = asset && asset.constructor ? asset.constructor.name : ''; + switch (cls) { + case 'Texture2D': out.textures++; break; + case 'SpriteFrame': out.sprites++; break; + case 'Material': out.materials++; break; + case 'Mesh': out.meshes++; break; + case 'AudioClip': out.audioClips++; break; + case 'AnimationClip': out.animations++; break; + case 'Prefab': out.prefabs++; break; + case 'SpriteAtlas': out.spriteAtlases++; break; + case 'JsonAsset': out.jsons++; break; + case 'TextAsset': out.texts++; break; + default: out.others++; break; + } + }); + } + } catch { + /* ignore */ + } + return out; + } + + /** 列出已加载资产（面板资产选择弹层用）。payload: { type?: string } */ + private listAssets(payload: any): any { + const out: any[] = []; + const typeSet = new Set(); + const filter = payload && payload.type ? String(payload.type) : ''; + try { + const am: any = assetManager as any; + const assets: any = am && am.assets; + if (assets && typeof assets.forEach === 'function') { + assets.forEach((asset: any) => { + if (!asset) { + return; + } + const cls = asset.constructor?.name ?? (asset as any).__classname__ ?? ''; + if (cls) { + typeSet.add(cls); + } + if (filter && cls !== filter) { + return; + } + out.push({ + name: String((asset as any).name ?? ''), + uuid: String((asset as any).uuid ?? (asset as any)._id ?? ''), + type: cls, + }); + }); + } + } catch { + /* ignore */ + } + out.sort((a: any, b: any) => (a.name || '').localeCompare(b.name || '')); + return { assets: out, types: [...typeSet].sort() }; + } + + /** 按 uuid 从已加载资产中查找资产对象。 */ + private findAsset(uuid: string): any { + if (!uuid) { + return null; + } + try { + const am: any = assetManager as any; + const assets: any = am && am.assets; + let found: any = null; + if (assets && typeof assets.forEach === 'function') { + assets.forEach((asset: any) => { + if (found) { + return; + } + if (asset && String((asset as any).uuid ?? (asset as any)._id ?? '') === uuid) { + found = asset; + } + }); + } + return found; + } catch { + return null; + } + } + + onDestroy() { + if (RuntimeBridge._instance === this) { + RuntimeBridge._instance = null; + } + director.off(Director.EVENT_AFTER_UPDATE, this.onFrame, this); + this._manualClose = true; + this.stopPreview(); + this.clearHighlight(); + this.disconnect(); + } + + /** 固定连接地址：不做多地址尝试/排队，始终用界面配置的 host（默认 127.0.0.1）。 */ + private buildAddrCandidates(): string[] { + return [(this.host || '').trim() || DEFAULT_HOST]; + } + + /** 建立（或重建）连接。 */ + connect() { + this._manualClose = false; + this._everOpened = false; + if (this._ws && this._ws.readyState === WebSocket.OPEN) { + return; + } + this.clearReconnect(); + if (this._addrCandidates.length === 0) { + this._addrCandidates = this.buildAddrCandidates(); + this._addrIdx = 0; + } + this._connHost = this._addrCandidates[this._addrIdx] || this.host || DEFAULT_HOST; + const q = `?token=${encodeURIComponent(TOKEN)}`; + const ctype = detectClientType(); + const sep = '&'; + this._ws = new WebSocket(`ws://${this._connHost}:${this.port}${q}${sep}client=${ctype}`); + + this._ws.onopen = () => { + this._everOpened = true; + this._failCount = 0; + this._addrIdx = 0; + console.log('[yyka-runtime-inspector] 已连接:', this._connHost + ':' + this.port); + this.flushConsole(); + this.send({ evt: 'hello', nodeCount: this.countNodes() }); + if (this.previewFps > 0) { + this.startPreview(this.previewFps); + } + // 定时上报，验证全链路 + this._timer = setInterval(() => { + this.send({ + evt: 'ping', + t: Date.now(), + ver: BRIDGE_VERSION, + scene: this.currentSceneName(), + nodeCount: this.countNodes(), + }); + }, 1000); + }; + + this._ws.onmessage = (evt: MessageEvent) => { + this.onMessage(evt); + }; + + this._ws.onclose = (evt: CloseEvent) => { + this.clearTimer(); + this._ws = null; + // 原生(libwebsockets)的失败信息主要在 onclose 里（不一定先触发 onerror）， + // 尽量提取 code/reason，打印出来辅助诊断。 + const closeCode = evt && typeof evt.code === 'number' ? evt.code : -1; + const closeReason = evt && evt.reason ? String(evt.reason) : ''; + if (closeCode === 4001) { + console.error('[yyka-runtime-inspector] 连接被拒绝：令牌(token)与插件不一致，请检查'); + return; + } + if (closeCode === 4002) { + // 被新连接顶替：本实例降级为"待机"，不再自动重连，避免互踢循环 + console.warn('[yyka-runtime-inspector] 已被新的游戏连接顶替，本实例停止自动重连'); + return; + } + // 1000=正常关闭、1005=未收到关闭码，跳过；其余视为异常关闭，打印细节 + if (closeCode !== 1000 && closeCode !== 1005) { + console.warn( + '[yyka-runtime-inspector] 连接关闭: ' + this._connHost + ':' + this.port + + ' | code=' + closeCode + + ' | reason=' + (closeReason || '(空)') + + (this._everOpened ? '' : '（从未成功建立连接）') + ); + } + if (!this._manualClose) { + if (!this._everOpened) { + // 从未成功建立连接就断开：换下一个候选地址重试（覆盖模拟器/真机网络差异） + this._addrIdx++; + if (this._addrIdx >= this._addrCandidates.length) { + console.warn('[yyka-runtime-inspector] 连接失败，停止自动重连'); + this._addrIdx = 0; + return; + } + const next = this._addrCandidates[this._addrIdx]; + console.warn('[yyka-runtime-inspector] ' + this._connHost + ':' + this.port + ' 连接失败，尝试 ' + next + ':' + this.port); + } + this.scheduleReconnect(); + } + }; + + this._ws.onerror = (err) => { + // 尽量把错误对象转成可读字符串：浏览器/原生(libwebsockets)传的事件对象结构不同， + // 兼容 字符串 / Error / {message,reason,error,type,code,name} / 其他对象(JSON 兜底)。 + let reason = ''; + try { + const e: any = err; + if (typeof err === 'string') { + reason = err; + } else if (err instanceof Error) { + reason = err.message || err.stack || String(err); + } else if (err && typeof err === 'object') { + reason = e.message || e.reason || e.error || e.type || e.code || e.name || e.target?.url || ''; + if (!reason) { + try { + const keys = Object.keys(e); + reason = keys.length ? JSON.stringify(e) : String(err); + } catch { + reason = String(err); + } + } + } else { + reason = String(err); + } + } catch { + reason = String(err); + } + if (!reason) { + reason = String(err); + } + console.warn('[yyka-runtime-inspector] 连接失败: ' + this._connHost + ':' + this.port + + ' | 原因=' + reason); + }; + } + + /** 供全局 console 拦截器调用：连接已建立时直接转发一条控制台消息。 */ + sendConsoleMsg(item: { evt: string; level: string; text: string; t: number }): void { + if (this._ws && this._ws.readyState === WebSocket.OPEN) { + this.send(item); + } else { + consoleQueue.push(item); + if (consoleQueue.length > 200) { + consoleQueue.shift(); + } + } + } + + /** 连接建立后补发积压的 console 日志。 */ + private flushConsole(): void { + while (consoleQueue.length) { + const it = consoleQueue.shift(); + if (it) { + this.send(it); + } + } + } + + /** 断开连接（不再自动重连）。 */ + disconnect() { + this.clearReconnect(); + this.clearTimer(); + if (this._ws) { + this._ws.close(); + this._ws = null; + } + } + + private scheduleReconnect() { + if (this._manualClose) { + return; + } + this._reconnectTimer = setTimeout(() => this.connect(), this.reconnectDelay * 1000); + } + + private clearReconnect() { + if (this._reconnectTimer) { + clearTimeout(this._reconnectTimer); + this._reconnectTimer = null; + } + } + + private clearTimer() { + if (this._timer) { + clearInterval(this._timer); + this._timer = null; + } + } + + /** 接收来自插件的命令。可带 requestId（需回包），也可 fire-and-forget。 */ + private onMessage(evt: MessageEvent): void { + let msg: any = null; + try { + msg = JSON.parse(String(evt.data)); + } catch { + return; + } + if (!msg || typeof msg.cmd !== 'string') { + return; + } + let data: any; + try { + data = this.handleCommand(msg.cmd, msg.payload ?? {}); + } catch (e: any) { + data = { error: String(e?.message ?? e) }; + } + // 带 requestId 的命令需要回包；否则忽略结果 + if (typeof msg.requestId === 'number') { + this.send({ requestId: msg.requestId, evt: 'response', data }); + } + } + + /** 分发命令并同步返回结果。 */ + private handleCommand(cmd: string, payload: any): any { + switch (cmd) { + case 'query-tree': + return this.buildTree(payload); + case 'get-inspector': + return this.getInspector(payload); + case 'set-property': + return this.setProperty(payload); + case 'set-preview': { + const enabled = !!payload?.enabled; + const fps = payload?.fps || this.previewFps || 10; + if (enabled) { + this.startPreview(fps); + } else { + this.stopPreview(); + } + return { ok: true, preview: enabled, fps }; + } + case 'set-mute': { + this.setMute(!!payload?.muted); + return { ok: true, muted: this._muted }; + } + case 'get-stats': { + return this.collectStats(); + } + case 'capture-frame': { + const data = this.captureFrame(); + return data ? { ok: true, data } : { error: '捕获画面失败' }; + } + case 'get-resource-stats': { + return this.getResourceStats(); + } + case 'set-physics-debug': { + this.setPhysicsDebug(!!payload?.enabled); + return { ok: true, physicsDebug: !!payload?.enabled }; + } + case 'query-physics': { + return this.queryPhysics(); + } + case 'simulate-click': { + return this.simulateClick(payload); + } + case 'highlight': { + return this.setHighlight(payload); + } + case 'list-scenes': { + return this.listScenes(); + } + case 'load-scene': { + return this.loadScene(payload); + } + case 'list-assets': { + return this.listAssets(payload); + } + default: + return { error: `未知命令: ${cmd}` }; + } + } + + /** 启动预览抓帧推送。 */ + private startPreview(fps: number): void { + this.stopPreview(); + const period = Math.max(50, Math.round(1000 / fps)); + this._frameTimer = setInterval(() => { + const data = this.captureFrame(); + if (data) { + this.send({ evt: 'frame', data }); + } + }, period); + } + + private stopPreview(): void { + if (this._frameTimer) { + clearInterval(this._frameTimer); + this._frameTimer = null; + } + } + + /** 静音/恢复：遍历当前场景所有 AudioSource，记录原音量并置 0 或恢复。 */ + private setMute(muted: boolean): void { + this._muted = muted; + this.applyMute(); + } + + private applyMute(): void { + const scene = director.getScene(); + if (!scene) { + return; + } + const sources = scene.getComponentsInChildren(AudioSource) as AudioSource[]; + for (const s of sources) { + if (!this._resVol.has(s)) { + this._resVol.set(s, s.volume); + } + s.volume = this._muted ? 0 : (this._resVol.get(s) ?? 1); + } + } + + /** 开启/关闭物理调试绘制（3D 物理系统的 debug draw）。 */ + private setPhysicsDebug(enabled: boolean): void { + const PS: any = PhysicsSystem as any; + try { + const ps = PS && PS.instance; + if (!ps) { + return; + } + ps.enable = true; + if (enabled) { + const flagsCls = PS.DebugDrawFlags; + const shape = flagsCls?.SHAPE ?? 1; + const joint = flagsCls?.JOINT ?? 2; + const constraint = flagsCls?.CONSTRAINT ?? 4; + ps.debugDrawFlags = shape | joint | constraint; + } else { + ps.debugDrawFlags = (PS.DebugDrawFlags?.NONE) ?? 0; + } + } catch (e: any) { + console.error('[yyka-runtime-inspector] setPhysicsDebug 失败:', e); + } + } + + /** 查询当前物理系统状态与场景内刚体/碰撞体数量。 */ + private queryPhysics(): any { + const out: any = { + enabled: false, + debugDrawFlags: 0, + gravity: null, + bodies: 0, + colliders: 0, + bodies2d: 0, + colliders2d: 0, + }; + const PS: any = PhysicsSystem as any; + try { + const ps = PS && PS.instance; + if (ps) { + out.enabled = !!ps.enable; + out.debugDrawFlags = ps.debugDrawFlags ?? 0; + const g = ps.gravity; + out.gravity = g ? { x: g.x, y: g.y, z: g.z } : null; + } + } catch { + /* 忽略：物理模块未启用或版本差异 */ + } + const scene = director.getScene(); + if (scene) { + try { + out.bodies = scene.getComponentsInChildren(RigidBody).length; + out.colliders = scene.getComponentsInChildren(Collider).length; + } catch { + /* 忽略 */ + } + try { + out.bodies2d = scene.getComponentsInChildren(RigidBody2D).length; + out.colliders2d = scene.getComponentsInChildren(Collider2D).length; + } catch { + /* 忽略 */ + } + } + return out; + } + + /** 抓取当前游戏画面，编码为 JPEG base64。失败返回 null。 + * 直接对 WebGL 画布 toDataURL 在非渲染时机是纯黑（缓冲被清）， + * 因此优先返回 AFTER_DRAW 钩子缓存的本帧画面；无缓存或非 WebGL 时才即时抓。 */ + private captureFrame(): string | null { + try { + if (this._lastFrame) { + return this._lastFrame; + } + const canvas: HTMLCanvasElement = (game as any).canvas; + if (!canvas) { + return null; + } + return canvas.toDataURL('image/jpeg', 0.6); + } catch { + return null; + } + } + + /** 安装绘帧完成钩子：渲染后把画面存入缓存（节流，避免每帧都做 JPEG 编码）。 + * 必须在导演每帧的 AFTER_DRAW 触发才能拿到非黑画面。 */ + private installFrameHook(): void { + if (this._capHooked) { + return; + } + this._capHooked = true; + try { + director.on(Director.EVENT_AFTER_DRAW, this._afterDrawCb); + } catch { + /* 引擎未就绪/事件名差异时忽略 */ + } + } + + private _afterDrawCb = (): void => { + const now = Date.now(); + if (now - this._capStamp < 80) { + return; // 节流 ~12fps，够截图与低帧预览用，避免每帧 JPEG 编码开销 + } + this._capStamp = now; + try { + const canvas: HTMLCanvasElement = (game as any).canvas; + if (canvas) { + this._lastFrame = canvas.toDataURL('image/jpeg', 0.6); + } + } catch { + /* 单帧失败不致命 */ + } + }; + + /** 返回单个节点的核心属性 + 组件列表及其可编辑属性。payload: { id } */ + private getInspector(payload: any): any { + const node = this.findNode(payload?.id); + if (!node) { + return { error: `未找到节点: ${payload?.id}` }; + } + const p = node.position; + const e = node.eulerAngles ?? node.rotation; + const s = node.scale; + const w = node.worldPosition; + const components = (node.components || []).map((c: any) => { + const type: string = c.__classname__ ?? c.constructor?.name ?? 'Component'; + const data: any = { + type, + enabled: c.enabled ?? true, + props: this.enumerateEditable(c), + }; + // Widget 专属：输出对齐状态，供面板渲染官方风格的对齐面板 + if (type === 'cc.Widget' || type === 'Widget') { + const w: any = c; + data.widget = { + alignMode: typeof w.alignMode === 'number' ? w.alignMode : 0, + targetName: w.target && typeof w.target === 'object' ? String((w.target as any).name ?? '') : '', + left: w.left ?? 0, + right: w.right ?? 0, + top: w.top ?? 0, + bottom: w.bottom ?? 0, + isAbsLeft: !!w.isAbsLeft, + isAbsRight: !!w.isAbsRight, + isAbsTop: !!w.isAbsTop, + isAbsBottom: !!w.isAbsBottom, + isAlignLeft: !!w.isAlignLeft, + isAlignRight: !!w.isAlignRight, + isAlignTop: !!w.isAlignTop, + isAlignBottom: !!w.isAlignBottom, + isAlignHorizontalCenter: !!w.isAlignHorizontalCenter, + isAlignVerticalCenter: !!w.isAlignVerticalCenter, + }; + } + return data; + }); + return { + id: (node as any)._id ?? '', + name: node.name, + props: { + active: { t: 'bool', v: !!node.active, editable: true }, + layer: { t: 'number', v: node.layer, editable: true }, + position: { t: 'vec3', v: { x: p.x, y: p.y, z: p.z }, editable: true }, + euler: { t: 'vec3', v: { x: e.x, y: e.y, z: e.z }, editable: true }, + scale: { t: 'vec3', v: { x: s.x, y: s.y, z: s.z }, editable: true }, + worldPosition: { t: 'vec3', v: { x: w.x, y: w.y, z: w.z }, editable: false }, + }, + components, + }; + } + + /** 写回一条属性。payload 见下 */ + private setProperty(payload: any): any { + const node = this.findNode(payload?.id); + if (!node) { + return { error: `未找到节点: ${payload?.id}` }; + } + const v = payload?.value; + try { + const field = payload?.field; + const detail = (extra: any = {}) => ({ ok: true, node: node.name, ...extra }); + if (field === 'position') { + node.setPosition(new Vec3(v.x ?? 0, v.y ?? 0, v.z ?? 0)); + this.syncRigidBody(node); + return detail({ field, value: v }); + } + if (field === 'euler') { + node.setRotationFromEuler(v.x ?? 0, v.y ?? 0, v.z ?? 0); + this.syncRigidBody(node); + return detail({ field, value: v }); + } + if (field === 'scale') { + node.setScale(new Vec3(v.x ?? 1, v.y ?? 1, v.z ?? 1)); + this.syncRigidBody(node); + return detail({ field, value: v }); + } + if (field === 'active') { + node.active = !!v; + return detail({ field, value: !!v }); + } + if (field === 'layer') { + node.layer = Number(v) || 0; + return detail({ field, value: node.layer }); + } + // 组件属性：payload.includes { comp: 索引, key: 属性名, value: 原始值 } + if (typeof payload?.comp === 'number' && node.components) { + const comp: any = node.components[payload.comp]; + if (!comp) { + return { error: `组件索引越界: ${payload.comp}` }; + } + if (payload.key === '__enabled') { + comp.enabled = !!v; + return detail({ key: '__enabled', value: !!v }); + } + const cur = comp[payload.key]; + const compType: string = comp.__classname__ ?? comp.constructor?.name ?? ''; + // Widget 对齐属性：写回后立即触发对齐计算 + if ((compType === 'cc.Widget' || compType === 'Widget') && + ['left', 'right', 'top', 'bottom', 'isAbsLeft', 'isAbsRight', 'isAbsTop', 'isAbsBottom', + 'isAlignLeft', 'isAlignRight', 'isAlignTop', 'isAlignBottom', + 'isAlignHorizontalCenter', 'isAlignVerticalCenter', 'alignMode'].includes(payload.key)) { + comp[payload.key] = v; + try { + comp.updateAlignment?.(); + } catch { + /* ignore */ + } + return detail({ key: payload.key, value: v }); + } + // Widget 对齐目标：按运行时节点 id 赋 target + if ((compType === 'cc.Widget' || compType === 'Widget') && payload.key === '__widget_target') { + const target = v ? this.findNode(String(v)) : null; + comp.target = target ?? null; + try { + comp.updateAlignment?.(); + } catch { + /* ignore */ + } + return detail({ key: '__widget_target', value: target ? String((target as any).name ?? '') : '' }); + } + // 引用写回：value 携带运行时节点 id + 组件类型，从节点上取组件赋给引用 + if (v && typeof v === 'object' && v.__refNode && cur && typeof cur === 'object') { + const n = this.findNode(String(v.__refNode)); + if (!n) { + return { error: `未找到引用节点: ${v.__refNode}` }; + } + const target = v.componentType === 'cc.Node' ? n : (n as any).getComponent?.(v.componentType); + if (!target) { + return { error: `节点 ${n.name} 上不存在组件 ${v.componentType}` }; + } + comp[payload.key] = target; + return detail({ key: payload.key, value: v }); + } + // 资产引用写回：value 携带资产 uuid（spriteFrame / material 等），从已加载资产中查找赋给引用 + if (v && typeof v === 'object' && v.__refAsset) { + const asset = this.findAsset(String(v.__refAsset)); + if (!asset) { + return { error: `未找到资产: ${v.__refAsset}` }; + } + if (Array.isArray(cur) && typeof payload.index === 'number') { + const idx = payload.index; + if (idx < 0 || idx >= cur.length) { + return { error: `数组下标越界: ${idx}/${cur.length}` }; + } + cur[idx] = asset; + return detail({ key: payload.key, index: idx, value: v }); + } + comp[payload.key] = asset; + return detail({ key: payload.key, value: v }); + } + // 材质参数写回：payload.key='__material_prop'，value={ propKey, value } + // index 为数字时定位 sharedMaterials 数组项，否则用 customMaterial / material + if (payload.key === '__material_prop') { + let mat: any = null; + if (typeof payload.index === 'number' && Array.isArray(comp.sharedMaterials)) { + mat = comp.sharedMaterials[payload.index]; + } else if (comp.customMaterial) { + mat = comp.customMaterial; + } else if (comp.material) { + mat = comp.material; + } + if (!mat || typeof mat.setProperty !== 'function') { + return { error: '材质不可用或不可编辑' }; + } + const info = payload.value || {}; + const pv = info.value; + let setVal: any = pv; + if (pv && typeof pv === 'object') { + if ('r' in pv) { + setVal = new Color((pv.r ?? 0) / 255, (pv.g ?? 0) / 255, (pv.b ?? 0) / 255, (pv.a ?? 255) / 255); + } else if ('w' in pv) { + setVal = new Vec4(pv.x ?? 0, pv.y ?? 0, pv.z ?? 0, pv.w ?? 0); + } else if ('z' in pv) { + setVal = new Vec3(pv.x ?? 0, pv.y ?? 0, pv.z ?? 0); + } else { + setVal = new Vec2(pv.x ?? 0, pv.y ?? 0); + } + } + try { + mat.setProperty(String(info.propKey), setVal); + } catch (e) { + return { error: `设置材质参数失败: ${e}` }; + } + return detail({ key: '__material_prop', value: String(info.propKey) }); + } + // 数组项写回：payload.index 指明下标 + if (Array.isArray(cur) && typeof payload.index === 'number') { + const idx = payload.index; + if (idx < 0 || idx >= cur.length) { + return { error: `数组下标越界: ${idx}/${cur.length}` }; + } + const item = cur[idx]; + if (item instanceof Vec3 && v && typeof v === 'object') { + item.set(v.x ?? 0, v.y ?? 0, v.z ?? 0); + } else if (item instanceof Vec2 && v && typeof v === 'object') { + item.set(v.x ?? 0, v.y ?? 0); + } else if (item instanceof Color && v && typeof v === 'object') { + item.set((v.r ?? 0) / 255, (v.g ?? 0) / 255, (v.b ?? 0) / 255, (v.a ?? 255) / 255); + } else if (item instanceof Quat && v && typeof v === 'object') { + item.set(v.x ?? 0, v.y ?? 0, v.z ?? 0, v.w ?? 1); + } else if (item instanceof Vec4 && v && typeof v === 'object') { + item.set(v.x ?? 0, v.y ?? 0, v.z ?? 0, v.w ?? 0); + } else if (item instanceof Rect && v && typeof v === 'object') { + item.set(v.x ?? 0, v.y ?? 0, v.w ?? 0, v.h ?? 0); + } else if (item instanceof Size && v && typeof v === 'object') { + item.set(v.w ?? 0, v.h ?? 0); + } else { + cur[idx] = v; + } + return detail({ key: payload.key, index: idx, value: v }); + } + // 引用置空：原值是 cc 对象，写入 null + if (v === null && cur && typeof cur === 'object') { + comp[payload.key] = null; + return detail({ key: payload.key, value: null }); + } + if (cur instanceof Vec3 && v && typeof v === 'object') { + cur.set(v.x ?? 0, v.y ?? 0, v.z ?? 0); + } else if (cur instanceof Vec2 && v && typeof v === 'object') { + cur.set(v.x ?? 0, v.y ?? 0); + } else if (cur instanceof Color && v && typeof v === 'object') { + // 面板按 0-255 传输，Color 内部为 0-1 + cur.set((v.r ?? 0) / 255, (v.g ?? 0) / 255, (v.b ?? 0) / 255, (v.a ?? 255) / 255); + } else if (cur instanceof Quat && v && typeof v === 'object') { + cur.set(v.x ?? 0, v.y ?? 0, v.z ?? 0, v.w ?? 1); + } else if (cur instanceof Vec4 && v && typeof v === 'object') { + cur.set(v.x ?? 0, v.y ?? 0, v.z ?? 0, v.w ?? 0); + } else if (cur instanceof Rect && v && typeof v === 'object') { + cur.set(v.x ?? 0, v.y ?? 0, v.w ?? 0, v.h ?? 0); + } else if (cur instanceof Size && v && typeof v === 'object') { + cur.set(v.w ?? 0, v.h ?? 0); + } else { + comp[payload.key] = v; + } + return detail({ key: payload.key, value: v }); + } + return { error: '无法识别的 set-property 载荷' }; + } catch (err: any) { + return { error: `写回失败: ${String(err?.message ?? err)}` }; + } + } + + /** 写回节点变换后同步刚体：清零速度并唤醒，避免物理模拟立即把变换拉回去。 */ + private syncRigidBody(node: Node): void { + const rb3 = node.getComponent(RigidBody); + if (rb3) { + try { + rb3.wakeUp(); + rb3.setLinearVelocity(new Vec3(0, 0, 0)); + rb3.setAngularVelocity(new Vec3(0, 0, 0)); + (rb3 as any).syncFromNode?.(); + } catch { + /* ignore */ + } + return; + } + const rb2 = node.getComponent(RigidBody2D); + if (rb2) { + try { + rb2.wakeUp(); + rb2.linearVelocity = new Vec2(0, 0); + rb2.angularVelocity = 0; + (rb2 as any).syncFromNode?.(); + } catch { + /* ignore */ + } + } + } + + /** 枚举组件上由 @property 声明（装饰器生成的 __props__ 元数据）的可编辑属性。 + * 相比 Object.keys 运行时反射，只显示显式声明的字段，更贴近编辑器属性面板。 */ + private enumerateEditable(comp: any): any[] { + if (!comp) { + return []; + } + const out: any[] = []; + const seen = new Set(); + // 白名单：引擎内部序列化字段 → 公开访问器（如 Renderable 的 _materials → sharedMaterials）， + // 避免把 _node/_parent/_children 等内部结构字段暴露出来。 + const PUBLIC_MAP: Record = { _materials: 'sharedMaterials' }; + // 沿原型链收集静态 __props__（CCObject 起，含系统组件继承的属性） + let cls: any = comp.constructor; + let guard = 0; + while (cls && cls !== Object && guard++ < 20) { + if (Array.isArray(cls.__props__)) { + const propTypes: any[] = Array.isArray(cls.__propTypes__) ? cls.__propTypes__ : []; + for (const name of cls.__props__) { + if (typeof name !== 'string' || !name) { + continue; + } + const mappedKey = PUBLIC_MAP[name] ?? ''; + if (!mappedKey && name.startsWith('_')) { + continue; // 非白名单的下划线内部字段 + } + const displayKey = mappedKey || name; + if (seen.has(displayKey)) { + continue; // 同一公开属性只显示一次（如 _materials 与 sharedMaterials 并存时） + } + seen.add(displayKey); + if (name === 'enabled' || name === 'node') { + continue; // 结构性只读属性不参与编辑：enabled 由组件头部开关负责，node 是组件挂载节点 + } + let value: any; + try { + value = comp[mappedKey || name]; + } catch { + continue; + } + // 值为空的资产引用（如未赋值的 spriteFrame）：按 __propTypes__ 推断类型，仍显示为可选择的空资产 + if (value === null || value === undefined) { + const idx = cls.__props__.indexOf(name); + const pt = idx >= 0 ? propTypes[idx] : null; + const typeName = this.assetTypeName(pt); + if (typeName) { + out.push({ + key: mappedKey || name, + t: 'asset', + v: { type: typeName, name: '', uuid: '', settable: true }, + editable: true, + }); + } + continue; + } + let d: any = null; + // 枚举：值为 number 且 __propTypes__ 对应当前字段的类型是枚举对象 + if (typeof value === 'number' && propTypes.length) { + const idx = cls.__props__.indexOf(name); + const pt = idx >= 0 ? propTypes[idx] : null; + const opts = this.tryEnumOptions(pt); + if (opts) { + d = { t: 'enum', v: value, options: opts, editable: true }; + } + } + if (!d) { + d = this.toDescriptor(value); + } + if (!d) { + continue; + } + out.push({ key: mappedKey || name, ...d }); + } + } + cls = Object.getPrototypeOf(cls); + } + return out; + } + + /** 尝试把运行时枚举对象展开为 {name,value} 列表；非枚举返回 null。 */ + private tryEnumOptions(enumObj: any): { name: string; value: number }[] | null { + if (!enumObj || (typeof enumObj !== 'object' && typeof enumObj !== 'function')) { + return null; + } + const out: { name: string; value: number }[] = []; + let anyNum = false; + try { + for (const k of Object.keys(enumObj)) { + const v = enumObj[k]; + if (typeof v === 'number') { + out.push({ name: k, value: v }); + anyNum = true; + } + } + } catch { + return null; + } + return anyNum ? out : null; + } + + /** 判断 __propTypes__ 项是否为 Asset 子类，返回类名（如 SpriteFrame）；非资产类型返回空串。 */ + private assetTypeName(pt: any): string { + try { + if (!pt) { + return ''; + } + const cls = typeof pt === 'function' ? pt : pt.constructor; + if (!cls || !cls.prototype) { + return ''; + } + let proto = cls.prototype; + while (proto) { + if (proto === Asset.prototype) { + return String(cls.name ?? ''); + } + proto = Object.getPrototypeOf(proto); + } + return ''; + } catch { + return ''; + } + } + + /** 把运行时值转成可 JSON 序列化、可编辑的表述；不可编辑对象返回 null。 */ + private toDescriptor(value: any): any | null { + if (value === null || value === undefined) { + return null; + } + if (typeof value === 'number') { + return { t: 'number', v: value, editable: true }; + } + if (typeof value === 'string') { + return { t: 'string', v: value, editable: true }; + } + if (typeof value === 'boolean') { + return { t: 'bool', v: value, editable: true }; + } + if (value instanceof Vec3) { + return { t: 'vec3', v: { x: value.x, y: value.y, z: value.z }, editable: true }; + } + if (value instanceof Vec2) { + return { t: 'vec2', v: { x: value.x, y: value.y }, editable: true }; + } + if (value instanceof Quat) { + return { t: 'quat', v: { x: value.x, y: value.y, z: value.z, w: value.w }, editable: true }; + } + if (value instanceof Vec4) { + return { t: 'vec4', v: { x: value.x, y: value.y, z: value.z, w: value.w }, editable: true }; + } + if (value instanceof Rect) { + return { t: 'rect', v: { x: value.x, y: value.y, w: value.width, h: value.height }, editable: true }; + } + if (value instanceof Size) { + return { t: 'size', v: { w: value.width, h: value.height }, editable: true }; + } + if (value instanceof Color) { + return { + t: 'color', + v: { r: Math.round(value.r * 255), g: Math.round(value.g * 255), b: Math.round(value.b * 255), a: Math.round(value.a * 255) }, + editable: true, + }; + } + if (Array.isArray(value)) { + const items: any[] = value.slice(0, 8).map((it) => { + const d = this.toDescriptor(it); + return d || { t: 'raw', v: this.rawPreview(it), editable: false }; + }); + return { t: 'array', v: items, len: value.length, editable: true }; + } + // 资产引用（SpriteFrame / Material / Texture2D / Prefab 等）：官方 ui-asset 风格显示 + if (value instanceof Asset) { + const clsName = (value as any).__classname__ ?? value.constructor?.name ?? ''; + const d: any = { + t: 'asset', + v: { + type: String(clsName), + name: String((value as any).name ?? ''), + uuid: String((value as any).uuid ?? ''), + settable: true, + }, + editable: true, // 允许置空 + }; + // 材质实例：附带可编辑参数（mainColor / float / vec 等），面板展开编辑 + if (value instanceof Material) { + d.t = 'material'; + d.v.props = this.serializeMaterialProps(value); + } + return d; + } + // Cocos 对象引用（Node / Component；Vec3 等已在上方处理） + if (value && typeof value === 'object' && (value as any).__classname__) { + const clsName = (value as any).__classname__ ?? value.constructor?.name ?? ''; + const refName = (value as any).name ?? ''; + const refUuid = (value as any).uuid ?? (value as any)._id ?? ''; + const compType = (value as any).__classname__ ?? ''; + return { + t: 'ref', + v: { + type: String(clsName), + name: String(refName), + uuid: String(refUuid), + componentType: String(compType), + settable: true, // 可写回为场景内另一节点的组件/节点 + }, + editable: true, // 允许置空 + }; + } + return null; // 其他对象暂不编辑 + } + + /** 数组/对象项的紧凑预览文本。 */ + private rawPreview(v: any): string { + try { + const s = JSON.stringify(v); + return s === undefined ? String(v) : s; + } catch { + return String(v); + } + } + + /** 序列化材质实例的可编辑参数（material.properties）。 */ + private serializeMaterialProps(m: any): any[] { + const out: any[] = []; + try { + const props: any = (m as any).properties; + if (!props || typeof props !== 'object') { + return out; + } + for (const k of Object.keys(props)) { + const p = props[k]; + if (!p || !('value' in p)) { + continue; + } + const val = p.value; + let d: any = null; + if (typeof val === 'number') { + d = { t: 'float', v: val }; + } else if (val instanceof Color) { + d = { + t: 'color', + v: { r: Math.round(val.r * 255), g: Math.round(val.g * 255), b: Math.round(val.b * 255), a: Math.round(val.a * 255) }, + }; + } else if (val instanceof Vec4) { + d = { t: 'vec4', v: { x: val.x, y: val.y, z: val.z, w: val.w } }; + } else if (val instanceof Vec3) { + d = { t: 'vec3', v: { x: val.x, y: val.y, z: val.z } }; + } else if (val instanceof Vec2) { + d = { t: 'vec2', v: { x: val.x, y: val.y } }; + } else if (val && typeof val === 'object' && (val as any).__classname__) { + // 纹理等资产参数：只读显示 + d = { + t: 'texture', + v: { + type: String((val as any).__classname__ ?? ''), + name: String((val as any).name ?? ''), + }, + }; + } + if (d) { + out.push({ key: k, type: String(p.type ?? ''), ...d }); + } + } + } catch { + /* ignore */ + } + return out; + } + + /** 序列化场景节点树。payload: { filter?: string } */ + private buildTree(payload: any): any { + const scene = director.getScene(); + const sceneName = this.currentSceneName(); + const filter = payload && payload.filter ? String(payload.filter).toLowerCase() : ''; + const roots: any[] = []; + if (scene) { + for (const c of scene.children) { + const sub = this.serializeNode(c, filter); + if (sub) { + roots.push(sub); + } + } + } + return { scene: sceneName, filter, roots }; + } + + private serializeNode(node: Node, filter: string): any | null { + const name = node.name ?? ''; + // 隐藏插件内部节点（如高亮线框覆盖层），避免混入节点树 + if (name === '__yyka_highlight__') { + return null; + } + const children: any[] = []; + if (node.children && node.children.length) { + for (const c of node.children) { + const sub = this.serializeNode(c, filter); + if (sub) { + children.push(sub); + } + } + } + const selfMatch = !filter || name.toLowerCase().includes(filter); + if (children.length === 0 && !selfMatch) { + return null; + } + return { + id: (node as any)._id ?? '', + name, + active: !!node.activeInHierarchy, + layer: node.layer, + comps: node.components ? node.components.length : 0, + type: this.nodeType(node), + children, + }; + } + + /** 按优先级取节点主组件类名（供面板显示类型图标）。 */ + private nodeType(node: Node): string { + const ICONED = [ + 'cc.Camera', 'cc.Canvas', 'cc.Label', 'cc.Sprite', 'cc.Button', 'cc.Mask', + 'cc.Graphics', 'cc.RichText', 'cc.Layout', 'cc.ScrollView', 'cc.ScrollBar', + 'cc.PageView', 'cc.PageViewIndicator', 'cc.EditBox', 'cc.Toggle', + 'cc.ToggleContainer', 'cc.ProgressBar', 'cc.Slider', 'cc.Widget', + 'cc.SafeArea', 'cc.VideoPlayer', 'cc.WebView', 'cc.MeshRenderer', + 'cc.SkinnedMeshRenderer', 'cc.SkinnedMeshBatchRenderer', 'cc.ParticleSystem', + 'cc.ParticleSystem2D', 'cc.Terrain', 'cc.TiledMap', 'cc.DirectionalLight', + 'cc.PointLight', 'cc.SpotLight', 'cc.SphereLight', 'cc.RangedDirectionalLight', + 'cc.AudioSource', 'cc.Animation', 'cc.SkeletalAnimation', + 'cc.animation.AnimationController', 'cc.RigidBody', 'cc.RigidBody2D', + 'cc.BoxCollider', 'cc.BoxCollider2D', 'cc.CircleCollider2D', + 'cc.PolygonCollider2D', 'cc.MeshCollider', 'cc.SphereCollider', + 'cc.CapsuleCollider', 'cc.ConeCollider', 'cc.CylinderCollider', + 'cc.PlaneCollider', 'cc.SimplexCollider', 'cc.TerrainCollider', 'cc.Line', + 'cc.MotionStreak', 'cc.UIMeshRenderer', 'cc.Billboard', 'cc.LODGroup', + 'cc.ReflectionProbe', 'cc.LightProbeGroup', 'dragonBones.ArmatureDisplay', + 'sp.Skeleton', + ]; + const set = new Set(ICONED); + if (node.components) { + for (const c of node.components) { + const cls: string = (c as any).__classname__ ?? (c as any).constructor?.name ?? ''; + const full = cls.includes('.') ? cls : `cc.${cls}`; + if (set.has(full)) { + return full; + } + } + } + return ''; + } + + /** 按引擎 _id 查找场景中的节点。 */ + private findNode(id: string): Node | null { + const scene = director.getScene(); + if (!scene) { + return null; + } + const stack: Node[] = scene.children.slice(); + while (stack.length) { + const n = stack.pop()!; + if ((n as any)._id === id) { + return n; + } + if (n.children && n.children.length) { + stack.push(...n.children); + } + } + return null; + } + + /** 高亮/遮罩指定节点。payload: { id, mode: 'highlight'|'mask' }。id 为空串则清除覆盖层。 */ + private setHighlight(payload: any): any { + this.clearHighlight(); + const id = typeof payload?.id === 'string' ? payload.id : ''; + if (!id) { + return { ok: true, cleared: true }; + } + const node = this.findNode(id); + if (!node) { + return { error: `未找到节点: ${id}` }; + } + if (!node.activeInHierarchy) { + return { error: `节点 ${node.name} 未激活，无法高亮` }; + } + const ut = node.getComponent(UITransform); + if (!ut || ut.contentSize.width <= 0 || ut.contentSize.height <= 0) { + return { error: `节点 ${node.name} 没有有效 UITransform，无法高亮` }; + } + const canvas = this.findCanvasRoot(); + if (!canvas) { + return { error: '场景中未找到 Canvas/RenderRoot2D，无法渲染高亮' }; + } + const bb = ut.getBoundingBoxToWorld(); + const mode = payload?.mode === 'mask' ? 'mask' : 'highlight'; + + // 覆盖层挂在 Canvas 下（RenderRoot2D 提供渲染），UI_2D 层、置为最后一个子节点 + const overlay = new Node('__yyka_highlight__'); + overlay.layer = Layers.Enum.UI_2D; + canvas.addChild(overlay); + const g = overlay.addComponent(Graphics); + + // 目标节点世界包围盒 → Canvas 本地坐标 + const canvasUt = canvas.getComponent(UITransform); + const localMin = canvasUt ? canvasUt.convertToNodeSpaceAR(new Vec3(bb.x, bb.y, 0)) : new Vec3(bb.x, bb.y, 0); + const localMax = canvasUt + ? canvasUt.convertToNodeSpaceAR(new Vec3(bb.x + bb.width, bb.y + bb.height, 0)) + : new Vec3(bb.x + bb.width, bb.y + bb.height, 0); + + if (mode === 'mask') { + // 遮罩：Canvas 外圈半透明黑框，目标区域挖空 + const cs = canvasUt ? canvasUt.contentSize : new Size(0, 0); + const w = cs.width; + const h = cs.height; + const minX = localMin.x; + const minY = localMin.y; + const maxX = localMax.x; + const maxY = localMax.y; + g.fillColor = new Color(0, 0, 0, 170); + g.rect(-w / 2, maxY, w, h / 2 - maxY); // 上 + g.rect(-w / 2, -h / 2, w, minY + h / 2); // 下 + g.rect(-w / 2, minY, minX + w / 2, maxY - minY); // 左 + g.rect(maxX, minY, w / 2 - maxX, maxY - minY); // 右 + g.fill(); + } else { + // 高亮：亮蓝色描边 + 半透明填充 + g.lineWidth = 3; + g.strokeColor = new Color(59, 130, 246, 255); + g.fillColor = new Color(59, 130, 246, 40); + g.rect(localMin.x, localMin.y, localMax.x - localMin.x, localMax.y - localMin.y); + g.stroke(); + g.fill(); + } + this._highlightOverlay = overlay; + return { ok: true, mode, node: node.name }; + } + + /** 移除当前高亮覆盖层（如有）。 */ + private clearHighlight(): void { + if (this._highlightOverlay) { + const ov = this._highlightOverlay; + this._highlightOverlay = null; + if (ov.isValid) { + ov.destroy(); + } + } + } + + /** 查找场景中可作为 UI 渲染根的节点（带 Canvas 或 RenderRoot2D 组件）。 */ + private findCanvasRoot(): Node | null { + const scene = director.getScene(); + if (!scene) { + return null; + } + const stack: Node[] = scene.children.slice(); + while (stack.length) { + const n = stack.pop()!; + if (n.getComponent(Canvas) || n.getComponent(RenderRoot2D)) { + return n; + } + if (n.children && n.children.length) { + stack.push(...n.children); + } + } + return null; + } + + /** 模拟一次触摸点击：按 id 取节点 UI 中心点，或按 x/y 坐标命中最上层 UI 节点，再派发 TOUCH_START/TOUCH_END。 */ + private simulateClick(payload: any): any { + const scene = director.getScene(); + if (!scene) { + return { error: '场景不存在' }; + } + let target: Node | null = null; + const point = new Vec2(); + if (typeof payload?.id === 'string' && payload.id) { + target = this.findNode(payload.id); + if (!target) { + return { error: `未找到节点: ${payload.id}` }; + } + const ut = target.getComponent(UITransform); + if (!ut) { + return { error: `节点 ${target.name} 没有 UITransform，无法确定点击位置` }; + } + const w = target.worldPosition; + point.set(w.x, w.y); + } else if (typeof payload?.x === 'number' && typeof payload?.y === 'number') { + point.set(payload.x, payload.y); + target = this.hitTestUI(point); + } else { + return { error: '需要参数 id（节点 id）或 x/y（UI 坐标）' }; + } + if (!target) { + return { error: `坐标 (${point.x}, ${point.y}) 未命中任何 UI 节点` }; + } + const touch = new Touch(); + touch.setTouchInfo(0, point.x, point.y); + const start = new EventTouch([touch], true, SystemEvent.EventType.TOUCH_START); + target.dispatchEvent(start); + const end = new EventTouch([touch], true, SystemEvent.EventType.TOUCH_END); + target.dispatchEvent(end); + return { ok: true, node: target.name, x: point.x, y: point.y }; + } + + /** 节点是否挂在 Canvas/RenderRoot2D 下的 UI 树中。不在 UI 渲染根下的 UITransform 取包围盒会触发引擎崩溃。 */ + private hasUiRoot(n: Node): boolean { + let cur: Node | null = n; + while (cur) { + if (cur.getComponent(Canvas) || cur.getComponent(RenderRoot2D)) { + return true; + } + cur = cur.parent; + } + return false; + } + + /** 按 UI 坐标找命中的最上层节点（遍历顺序靠后的视为更上层）。 */ + private hitTestUI(point: Vec2): Node | null { + const scene = director.getScene(); + if (!scene) { + return null; + } + let hit: Node | null = null; + scene.walk((n: Node) => { + if (!n.activeInHierarchy || !this.hasUiRoot(n)) { + return; + } + const ut = n.getComponent(UITransform); + if (!ut || ut.contentSize.width <= 0 || ut.contentSize.height <= 0) { + return; + } + try { + if (ut.getBoundingBoxToWorld().contains(point)) { + hit = n; + } + } catch { + /* 个别节点包围盒计算异常，跳过即可，不影响命中判断 */ + } + }); + return hit; + } + + /** 列出当前场景及已加载场景名。 */ + private listScenes(): any { + const current = this.currentSceneName(); + const map = (director as any)._loadedSceneMap; + const scenes: string[] = []; + if (map && typeof map === 'object') { + for (const k of Object.keys(map)) { + if (k && !scenes.includes(k)) { + scenes.push(k); + } + } + } + if (current && !scenes.includes(current)) { + scenes.unshift(current); + } + return { current, scenes }; + } + + /** 运行时加载指定场景（跳转）。 */ + private loadScene(payload: any): any { + const name = String(payload?.name ?? ''); + if (!name) { + return { error: '缺少场景名' }; + } + const ok = director.loadScene(name); + return ok ? { ok: true, scene: name } : { error: `场景加载失败或不存在: ${name}` }; + } + + /** 发送一条 JSON 消息给插件。 */ + private send(obj: unknown): void { + if (this._ws && this._ws.readyState === WebSocket.OPEN) { + let payload: string; + try { + payload = JSON.stringify(obj); + } catch { + // 序列化失败（如循环引用）时降级为字符串，避免在消息回调里抛异常 + payload = JSON.stringify(String(obj)); + } + if (payload !== undefined) { + this._ws.send(payload); + } + } + } + + private countNodes(): number { + const scene = director.getScene(); + if (!scene) { + return 0; + } + let n = 0; + scene.walk(() => { + n++; + }); + return n; + } +} + +// ---- 自动引导：脚本被加载后，在场景启动时创建常驻节点，无需手动摆放/调用 ---- +// 注意：预览对脚本做热重载时，本模块会重新求值，但 director 中的常驻节点仍在。 +// 因此一律按名字查重，已存在同名节点就跳过，绝不再新建，避免常驻节点重复累积。 +(function bootstrap() { + /** 递归查找场景中是否存在指定名字的节点。 */ + function findByName(root: Node, name: string): Node | null { + if (!root) { + return null; + } + if (root.name === name) { + return root; + } + const children = root.children; + if (children) { + for (const c of children) { + const found = findByName(c, name); + if (found) { + return found; + } + } + } + return null; + } + + director.on(Director.EVENT_AFTER_SCENE_LAUNCH, () => { + const scene: any = director.getScene(); + const sceneName = String((scene && (scene.name || scene._name)) || ''); + if (RuntimeBridge._instance) { + // 场景切换后刷新场景名缓存，供 getScene() 未就绪时兜底 + RuntimeBridge._instance._sceneName = sceneName; + return; + } + if (!scene) { + return; + } + // 已存在同名常驻节点（可能是本模块之前的实例，或热重载前遗留）则跳过 + if (findByName(scene, PERSIST_NODE_NAME)) { + return; + } + const node = new Node(PERSIST_NODE_NAME); + scene.addChild(node); + const inst = node.addComponent(RuntimeBridge) as RuntimeBridge; // onLoad 中会 addPersistRootNode 并 connect + if (sceneName && !inst._sceneName) { + inst._sceneName = sceneName; // onLoad 时 getScene() 可能尚未就绪，补上本次回调已拿到的场景名 + } + }); +})(); \ No newline at end of file diff --git a/assets/RuntimeBridge.ts.meta b/assets/RuntimeBridge.ts.meta new file mode 100644 index 0000000..7175fdf --- /dev/null +++ b/assets/RuntimeBridge.ts.meta @@ -0,0 +1,9 @@ +{ + "ver": "4.0.24", + "importer": "typescript", + "imported": true, + "uuid": "8ee138cf-ab76-449a-8b25-5ef56e1fe190", + "files": [], + "subMetas": {}, + "userData": {} +} diff --git a/assets/scene/main.scene b/assets/scene/main.scene index edebd74..dd611fa 100644 --- a/assets/scene/main.scene +++ b/assets/scene/main.scene @@ -18,12 +18,15 @@ "_children": [ { "__id__": 2 + }, + { + "__id__": 111 } ], "_active": true, "_components": [], "_prefab": { - "__id__": 111 + "__id__": 113 }, "_lpos": { "__type__": "cc.Vec3", @@ -54,7 +57,7 @@ }, "autoReleaseAssets": false, "_globals": { - "__id__": 112 + "__id__": 114 }, "_id": "89cd0565-e1e7-4d4c-b1f5-8a3061282934" }, @@ -3094,6 +3097,68 @@ "_lockFlags": 0, "_id": "c5V1EV8IpMtrIvY1OE9t2u" }, + { + "__type__": "cc.Node", + "_name": "__yyka_runtime_bridge__", + "_objFlags": 0, + "__editorExtras__": {}, + "_parent": { + "__id__": 1 + }, + "_children": [], + "_active": true, + "_components": [ + { + "__id__": 112 + } + ], + "_prefab": null, + "_lpos": { + "__type__": "cc.Vec3", + "x": 0, + "y": 0, + "z": 0 + }, + "_lrot": { + "__type__": "cc.Quat", + "x": 0, + "y": 0, + "z": 0, + "w": 1 + }, + "_lscale": { + "__type__": "cc.Vec3", + "x": 1, + "y": 1, + "z": 1 + }, + "_mobility": 0, + "_layer": 1073741824, + "_euler": { + "__type__": "cc.Vec3", + "x": 0, + "y": 0, + "z": 0 + }, + "_id": "10Wutln0FALLw7Ag4OGxu6" + }, + { + "__type__": "8ee13jPq3ZEmoslXvVuH+GQ", + "_name": "", + "_objFlags": 0, + "__editorExtras__": {}, + "node": { + "__id__": 111 + }, + "_enabled": true, + "__prefab": null, + "autoConnect": true, + "host": "192.168.2.17", + "port": 33000, + "reconnectDelay": 2, + "previewFps": 0, + "_id": "8cJOa28jFPzKVV0UycbPQZ" + }, { "__type__": "cc.PrefabInfo", "root": null, @@ -3113,28 +3178,28 @@ { "__type__": "cc.SceneGlobals", "ambient": { - "__id__": 113 + "__id__": 115 }, "shadows": { - "__id__": 114 + "__id__": 116 }, "_skybox": { - "__id__": 115 + "__id__": 117 }, "fog": { - "__id__": 116 + "__id__": 118 }, "octree": { - "__id__": 117 + "__id__": 119 }, "skin": { - "__id__": 118 + "__id__": 120 }, "lightProbeInfo": { - "__id__": 119 + "__id__": 121 }, "postSettings": { - "__id__": 120 + "__id__": 122 }, "bakedWithStationaryMainLight": false, "bakedWithHighpLightmap": false diff --git a/extensions/YYKA运行时工作台/.release-sig b/extensions/YYKA运行时工作台/.release-sig new file mode 100644 index 0000000..5f76d35 --- /dev/null +++ b/extensions/YYKA运行时工作台/.release-sig @@ -0,0 +1 @@ +bc52de6deb41df5b03ab84d33014e35c \ No newline at end of file diff --git a/extensions/YYKA运行时工作台/README.txt b/extensions/YYKA运行时工作台/README.txt new file mode 100644 index 0000000..5aa4bad --- /dev/null +++ b/extensions/YYKA运行时工作台/README.txt @@ -0,0 +1,5 @@ +yyka-runtime-inspector 1.0.254 +---------------------------------------- +将整个目录作为 Cocos Creator 扩展安装（或复制到扩展目录）。 +依赖已随目录复制（node_modules），无需额外 npm install。 +游戏侧桥接脚本样例见 runtime-bridge-sample（未打包，需从源码取）。 \ No newline at end of file diff --git a/extensions/YYKA运行时工作台/dist/main.js b/extensions/YYKA运行时工作台/dist/main.js new file mode 100644 index 0000000..ffb807c --- /dev/null +++ b/extensions/YYKA运行时工作台/dist/main.js @@ -0,0 +1,615 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.methods = void 0; +exports.load = load; +exports.unload = unload; +// @ts-ignore +const package_json_1 = __importDefault(require("../package.json")); +const fs_extra_1 = require("fs-extra"); +const path_1 = require("path"); +const os_1 = require("os"); +const ws_server_1 = require("./ws-server"); +const mcp_server_1 = require("./mcp-server"); +const DEFAULT_PORT = 33000; +/** 固定静态连接令牌：不做动态生成，保证脚本/节点令牌与插件始终一致。 */ +const STATIC_TOKEN = 'www.yyka.cn'; +let server = null; +let logBuffer = []; +/** 面板已消费到的缓冲位置：queryLog 改为增量取走而非清空，避免饿死 MCP 的非破坏性 getLogs。 */ +let logCursor = 0; +const serverToken = STATIC_TOKEN; +let mcpHost = null; +const pending = new Map(); +let requestSeq = 0; +function ensureServer() { + if (!server) { + server = new ws_server_1.WsServer(); + } + return server; +} +function getServerState() { + var _a, _b, _c, _d, _e, _f; + const info = (_a = server === null || server === void 0 ? void 0 : server.clientInfo) !== null && _a !== void 0 ? _a : null; + return { + running: (_b = server === null || server === void 0 ? void 0 : server.isRunning) !== null && _b !== void 0 ? _b : false, + port: (_c = server === null || server === void 0 ? void 0 : server.boundPort) !== null && _c !== void 0 ? _c : 0, + clients: (_d = server === null || server === void 0 ? void 0 : server.clients) !== null && _d !== void 0 ? _d : 0, + clientType: (_e = info === null || info === void 0 ? void 0 : info.type) !== null && _e !== void 0 ? _e : '', + clientUrl: (_f = info === null || info === void 0 ? void 0 : info.url) !== null && _f !== void 0 ? _f : '', + }; +} +function pushLog(item) { + logBuffer.push(item); + while (logBuffer.length > 200) { + logBuffer.shift(); + if (logCursor > 0) { + logCursor--; + } + } +} +/** 客户端类型 → 中文标签（日志用）。 */ +function typeLabel(type) { + switch (type) { + case 'h5': + return '浏览器预览'; + case 'editor': + return '编辑器预览'; + case 'simulator': + return '模拟器'; + case 'device': + return '真机'; + case 'unknown': + default: + return '未知来源'; + } +} +/** 从项目 settings 中递归查找数值端口。 */ +function findNumericPort(cfg) { + if (!cfg || typeof cfg !== 'object') { + return 0; + } + if (typeof cfg.port === 'number' && cfg.port > 0) { + return cfg.port; + } + if (typeof cfg.port === 'string' && !Number.isNaN(Number(cfg.port))) { + return Number(cfg.port); + } + for (const k of Object.keys(cfg)) { + const v = cfg[k]; + if (v && typeof v === 'object') { + const p = findNumericPort(v); + if (p > 0) { + return p; + } + } + } + return 0; +} +/** + * 读取当前项目的预览配置，得出浏览器预港口/URL。 + * 用于面板内嵌 iframe 预览的默认地址。 + */ +function getPreviewInfo() { + var _a; + const projectPath = (_a = Editor.Project) === null || _a === void 0 ? void 0 : _a.path; + const candidates = ['settings/preview.json', 'settings/v2/packages/preview.json']; + if (projectPath) { + for (const rel of candidates) { + try { + const p = (0, path_1.join)(projectPath, rel); + if (!(0, fs_extra_1.existsSync)(p)) { + continue; + } + const cfg = (0, fs_extra_1.readJsonSync)(p); + const port = findNumericPort(cfg); + if (port > 0) { + return { host: 'localhost', port, url: `http://localhost:${port}/`, found: p }; + } + } + catch (_b) { + // 忽略解析失败，尝试下一个候选文件 + } + } + } + return { host: 'localhost', port: 7456, url: 'http://localhost:7456/', found: '' }; +} +/** 处理来自游戏侧的消息：优先匹配 pending 请求，否则进入日志缓冲。 */ +function handleIncoming(data) { + var _a; + const m = data && typeof data === 'object' ? data : null; + if (m && typeof m.requestId === 'number' && pending.has(m.requestId)) { + const p = pending.get(m.requestId); + pending.delete(m.requestId); + if (p.timer) + clearTimeout(p.timer); + p.resolve((_a = m.data) !== null && _a !== void 0 ? _a : m); + return; + } + // 命令回包/握手等内部协议消息不进入日志，避免 requestId/response/hello 刷屏 + if (m && (m.evt === 'response' || m.evt === 'request' || m.evt === 'hello')) { + return; + } + pushLog(data); +} +/** 按限制条数与级别读取最近日志（不清空缓冲，供面板/MCP 使用）。 */ +function getLogsInternal(limit, level) { + const items = []; + for (let i = logBuffer.length - 1; i >= 0 && items.length < limit; i--) { + const it = logBuffer[i]; + if (!it || typeof it !== 'object') { + continue; + } + // 过滤掉心跳/握手/预览帧等噪声，只保留控制台与系统消息 + if (it.evt !== 'console' && it.evt !== 'sys') { + continue; + } + if (level && it.evt === 'console' && it.level !== level) { + continue; + } + items.unshift(it); + } + return items; +} +/** 返回 MCP 服务状态与连接配置（URL + 令牌）。 */ +function getMcpState() { + var _a, _b; + return { + running: (_a = mcpHost === null || mcpHost === void 0 ? void 0 : mcpHost.isRunning) !== null && _a !== void 0 ? _a : false, + port: (_b = mcpHost === null || mcpHost === void 0 ? void 0 : mcpHost.boundPort) !== null && _b !== void 0 ? _b : 0, + token: serverToken, + url: (mcpHost === null || mcpHost === void 0 ? void 0 : mcpHost.isRunning) ? `http://127.0.0.1:${mcpHost.boundPort}/mcp` : '', + }; +} +/** 向游戏侧桥接脚本发送一条请求，并等待其回包。 */ +function callGame(cmd, payload, timeout = 5000) { + return new Promise((resolve, reject) => { + if (!server || !server.isRunning) { + reject(new Error('WS 服务未运行，请先启动服务')); + return; + } + const requestId = ++requestSeq; + const timer = setTimeout(() => { + if (pending.has(requestId)) { + pending.delete(requestId); + reject(new Error(`命令超时(>${timeout}ms): ${cmd}`)); + } + }, timeout); + pending.set(requestId, { resolve, reject, timer }); + server.broadcast({ requestId, cmd, payload }); + }); +} +/** 获取宿主机第一个非内网 IPv4 地址（用于注入桥接脚本，供模拟器/真机通过局域网连上插件服务）。 */ +function getHostLanIP() { + var _a; + // 优先返回内网私有段地址（Wi-Fi/有线网卡），避免选到虚拟机或 VPN 虚拟网卡导致真机连不通 + let fallback = ''; + try { + for (const name of Object.keys((0, os_1.networkInterfaces)())) { + for (const net of (_a = (0, os_1.networkInterfaces)()[name]) !== null && _a !== void 0 ? _a : []) { + if (net.family === 'IPv4' && !net.internal) { + const a = net.address.split('.').map(Number); + const isPrivate = a[0] === 10 || + (a[0] === 172 && a[1] >= 16 && a[1] <= 31) || + (a[0] === 192 && a[1] === 168); + if (isPrivate) { + return net.address; + } + if (!fallback) { + fallback = net.address; + } + } + } + } + } + catch (_b) { + /* ignore */ + } + return fallback; +} +/** + * @zh 为扩展的主进程的注册方法 + */ +/** 收集目录下所有 .scene 文件。 */ +function collectSceneFiles(dir, out) { + let entries; + try { + entries = (0, fs_extra_1.readdirSync)(dir, { withFileTypes: true }); + } + catch (_a) { + return; + } + for (const e of entries) { + const p = (0, path_1.join)(dir, e.name); + if (e.isDirectory()) { + collectSceneFiles(p, out); + } + else if (e.isFile() && e.name.endsWith('.scene')) { + out.push(p); + } + } +} +/** 遍历场景 JSON 中的节点树，对匹配指定脚本 uuid 的组件执行回调。 */ +function walkSceneComponents(sceneJson, compUuid, cb) { + const walkNode = (node) => { + if (!node || typeof node !== 'object') { + return; + } + if (node.__type__ === 'cc.Node') { + for (const c of node._components || []) { + if (c && c.__type__ === compUuid) { + cb(c); + } + } + for (const ch of node._children || []) { + walkNode(ch); + } + } + }; + walkNode(sceneJson && sceneJson.scene); +} +exports.methods = { + openPanel() { + Editor.Panel.open(package_json_1.default.name); + }, + openPreviewPanel() { + Editor.Panel.open(`${package_json_1.default.name}.preview`); + }, + /** + * 启动 WS 服务。返回当前服务状态。 + */ + async startServer(port = DEFAULT_PORT) { + const ws = ensureServer(); + ws.token = serverToken; + try { + if (!ws.isRunning) { + ws.on('message', (_client, data) => handleIncoming(data)); + ws.on('connection', (_client, info) => pushLog({ evt: 'sys', msg: `客户端已连接 (${typeLabel(info === null || info === void 0 ? void 0 : info.type)})` })); + ws.on('disconnect', (_client, info) => pushLog({ evt: 'sys', msg: `客户端已断开 (${typeLabel(info === null || info === void 0 ? void 0 : info.type)})` })); + ws.on('auth-fail', (got, url) => pushLog({ evt: 'sys', msg: `连接被拒绝：客户端令牌(${got}) ≠ 服务端令牌(${serverToken})` })); + await ws.start(port); + } + } + catch (err) { + pushLog({ evt: 'sys', msg: `启动服务失败: ${String(err)}` }); + } + return getServerState(); + }, + /** + * 停止 WS 服务。返回当前服务状态。 + */ + async stopServer() { + if (server) { + await server.stop(); + } + return getServerState(); + }, + getServerState() { + return getServerState(); + }, + /** + * 返回固定连接令牌（静态 token）。 + */ + getToken() { + return serverToken; + }, + /** + * 读取当前项目预览配置得出的预港口/URL（供面板内嵌 iframe 用）。 + */ + getPreviewInfo() { + return getPreviewInfo(); + }, + /** + * 读取当前项目设计分辨率（Project Settings → general.designResolution）。 + * 首选编辑器内置 `project/query-config`（实时读配置缓存），多模块/按键都试一遍； + * 失败再退回到读 settings/v2/packages/project.json 文件，兜底 960×640。 + */ + async getProjectsSettings() { + var _a; + try { + const modules = ['general', 'engine', 'project']; + for (const mod of modules) { + try { + const d = await Editor.Message.request('project', 'query-config', mod, 'designResolution'); + if (d && Number(d.width) > 0 && Number(d.height) > 0) { + return { designResolution: { width: Number(d.width), height: Number(d.height) } }; + } + } + catch (_b) { + // 该模块无此配置，尝试下一个 + } + } + } + catch (_c) { + // 继续走文件兜底 + } + const projectPath = (_a = Editor.Project) === null || _a === void 0 ? void 0 : _a.path; + const candidates = [ + 'settings/v2/packages/project.json', + 'settings/project.json', + ]; + if (projectPath) { + for (const rel of candidates) { + try { + const p = (0, path_1.join)(projectPath, rel); + if (!(0, fs_extra_1.existsSync)(p)) + continue; + const cfg = (0, fs_extra_1.readJsonSync)(p); + const d = cfg && cfg.general && cfg.general.designResolution; + if (d && Number(d.width) > 0 && Number(d.height) > 0) { + return { designResolution: { width: Number(d.width), height: Number(d.height) } }; + } + } + catch (_d) { + // 忽略解析失败，尝试下一个候选文件 + } + } + } + return { designResolution: { width: 960, height: 640 } }; + }, + /** + * 面板向游戏侧桥接脚本广播一条 fire-and-forget 命令。 + * args: { cmd: string, payload?: any } + */ + sendCommand(args) { + if (server) { + server.broadcast({ cmd: args === null || args === void 0 ? void 0 : args.cmd, payload: args === null || args === void 0 ? void 0 : args.payload }); + } + return getServerState(); + }, + /** + * 面板请求游戏侧数据：向游戏发带 requestId 的命令并等待回包。 + * args: { cmd: string, payload?: any, timeout?: number } + */ + async queryCommand(args) { + var _a; + const r = await callGame(args === null || args === void 0 ? void 0 : args.cmd, args === null || args === void 0 ? void 0 : args.payload, (_a = args === null || args === void 0 ? void 0 : args.timeout) !== null && _a !== void 0 ? _a : 5000); + return r; + }, + /** + * 取回自上次查询以来收到的消息（游戏 → 面板）。按游标增量读取，不破坏缓冲。 + */ + queryLog() { + const batch = logBuffer.slice(logCursor); + logCursor = logBuffer.length; + return batch; + }, + /** + * 读取最近日志（不清空缓冲），供 MCP/AI Agent 使用。 + * args: { limit?: number, level?: 'all'|'log'|'warn'|'error' } + */ + getLogs(args) { + const limit = Math.max(1, Math.min(200, Number(args === null || args === void 0 ? void 0 : args.limit) || 50)); + const level = (args === null || args === void 0 ? void 0 : args.level) === 'log' || (args === null || args === void 0 ? void 0 : args.level) === 'warn' || (args === null || args === void 0 ? void 0 : args.level) === 'error' ? args.level : ''; + return getLogsInternal(limit, level); + }, + /** + * 启动 MCP 服务（HTTP Streamable，供 Codex 等 AI Agent 连接）。 + */ + async startMcp(port = mcp_server_1.MCP_DEFAULT_PORT) { + if (!mcpHost) { + mcpHost = new mcp_server_1.McpHttpServer(); + } + try { + if (!mcpHost.isRunning) { + const token = serverToken; + await mcpHost.start(port, token, { + callGame, + getServerState, + getToken: () => serverToken, + getLogs: (l, lv) => getLogsInternal(l, lv), + }); + pushLog({ evt: 'sys', msg: `MCP 服务已启动: http://127.0.0.1:${mcpHost.boundPort}/mcp` }); + } + } + catch (err) { + pushLog({ evt: 'sys', msg: `MCP 服务启动失败: ${String(err)}` }); + } + return getMcpState(); + }, + /** + * 停止 MCP 服务。 + */ + async stopMcp() { + if (mcpHost) { + await mcpHost.stop(); + pushLog({ evt: 'sys', msg: 'MCP 服务已停止' }); + } + return getMcpState(); + }, + /** + * 返回 MCP 服务状态与连接配置（URL + 令牌）。 + */ + getMcpState() { + return getMcpState(); + }, + /** + * 把游戏侧桥接脚本 RuntimeBridge.ts 自动安装到当前项目的 assets 目录。 + */ + async installBridge() { + var _a; + const projectPath = (_a = Editor.Project) === null || _a === void 0 ? void 0 : _a.path; + if (!projectPath) { + return { ok: false, msg: '无法获取项目路径（Editor.Project.path 为空）' }; + } + const src = (0, path_1.join)(__dirname, '../runtime-bridge-sample/RuntimeBridge.ts'); + const assetsDir = (0, path_1.join)(projectPath, 'assets'); + if (!(0, fs_extra_1.existsSync)(src)) { + return { ok: false, msg: `未找到桥接脚本模板: ${src}` }; + } + if (!(0, fs_extra_1.existsSync)(assetsDir)) { + return { ok: false, msg: `找不到项目的 assets 目录: ${assetsDir}` }; + } + const dest = (0, path_1.join)(assetsDir, 'RuntimeBridge.ts'); + const overwrote = (0, fs_extra_1.existsSync)(dest); + const currentToken = serverToken; + // 保留用户自定义 host/port（如真机调试时改为电脑 IP），避免每次覆盖被重置。 + // 优先取场景中已存在常驻节点组件的现值（用户最近可能直接在节点上配置）， + // 其次取已安装脚本文件里的默认值。 + let keepHost = ''; + let keepPort = 0; + if (overwrote) { + try { + const oldContent = (0, fs_extra_1.readFileSync)(dest, 'utf-8'); + const hm = /host\s*=\s*'([^']*)'/.exec(oldContent); + const pm = /port\s*=\s*(\d+)/.exec(oldContent); + if (hm) { + keepHost = hm[1]; + } + if (pm) { + keepPort = Number(pm[1]); + } + } + catch (_b) { + /* 读取失败则用模板默认值 */ + } + } + // 解析桥接脚本组件 uuid，用于在场景文件中定位已存在的 RuntimeBridge 组件 + let compUuid = ''; + const metaPath = dest + '.meta'; + try { + if ((0, fs_extra_1.existsSync)(metaPath)) { + const meta = (0, fs_extra_1.readJsonSync)(metaPath); + compUuid = (meta && meta.uuid) || ''; + } + } + catch (_c) { + /* 忽略 meta 读取失败 */ + } + let sceneFiles = []; + if (compUuid) { + try { + collectSceneFiles(assetsDir, sceneFiles); + // 第一遍：以已存在常驻节点组件上的 host/port 为准（用户配置），覆盖脚本旧值 + for (const sp of sceneFiles) { + try { + const sj = (0, fs_extra_1.readJsonSync)(sp); + walkSceneComponents(sj, compUuid, (comp) => { + if (typeof comp.host === 'string' && comp.host) { + keepHost = comp.host; + } + if (typeof comp.port === 'number' && comp.port > 0) { + keepPort = comp.port; + } + }); + } + catch (_d) { + /* 单个场景解析失败跳过 */ + } + } + } + catch (_e) { + /* 扫描失败则跳过场景同步 */ + } + } + // 桥接脚本内置固定令牌 www.yyka.cn，无需注入； + // 仅把 BRIDGE_VERSION 同步为插件版本号，避免面板显示过时版本 + const srcContent = (0, fs_extra_1.readFileSync)(src, 'utf-8'); + let injected = srcContent.replace(/BRIDGE_VERSION = '[^']*'/, `BRIDGE_VERSION = '${package_json_1.default.version}'`); + // 默认连接地址：用户配置过 host 则保留（如真机调试时自定义的电脑 IP）； + // 否则自动注入宿主机局域网 IP —— 固定 127.0.0.1 时真机/模拟器连的是设备自身回环，无法接通插件服务 + const lanIP = getHostLanIP(); + if (keepHost) { + injected = injected.replace('host = DEFAULT_HOST;', `host = '${keepHost}';`); + } + else if (lanIP) { + injected = injected.replace('host = DEFAULT_HOST;', `host = '${lanIP}';`); + } + if (keepPort) { + injected = injected.replace('port = DEFAULT_PORT;', `port = ${keepPort};`); + } + (0, fs_extra_1.writeFileSync)(dest, injected, 'utf-8'); + try { + await Editor.Message.request('asset-db', 'refresh-asset', dest); + } + catch (err) { + console.warn('[yyka-runtime-inspector] refresh-asset failed:', err); + } + // 第二遍：把已存在常驻节点的 host/port 同步为最新配置； + // token 已改为脚本内置常量，顺带清掉旧版本场景里残留的 token 字段，避免误导 + if (compUuid) { + for (const sp of sceneFiles) { + try { + const sj = (0, fs_extra_1.readJsonSync)(sp); + let changed = false; + walkSceneComponents(sj, compUuid, (comp) => { + if (keepHost) { + comp.host = keepHost; + } + if (keepPort) { + comp.port = keepPort; + } + if (typeof comp.token !== 'undefined') { + delete comp.token; + changed = true; + } + if (keepHost || keepPort) { + changed = true; + } + }); + if (changed) { + (0, fs_extra_1.writeJsonSync)(sp, sj, { spaces: 2 }); + console.log(`[yyka-runtime-inspector] 已同步常驻节点属性: ${sp}`); + try { + await Editor.Message.request('asset-db', 'refresh-asset', sp); + } + catch (_f) { + /* ignore */ + } + } + } + catch (_g) { + /* 单个场景同步失败跳过 */ + } + } + } + return { ok: true, path: dest, overwrote, token: currentToken, scenes: sceneFiles.length }; + }, + /** + * 通知游戏侧高亮/遮罩指定节点。id 为空串则清除。 + */ + async highlightNode(id, mode = 'highlight') { + try { + const res = await callGame('highlight', { id: id || '', mode: mode === 'mask' ? 'mask' : 'highlight' }, 3000); + return res; + } + catch (err) { + return { error: String(err) }; + } + }, +}; +/** + * @zh 扩展启动时自动拉起 WS 服务，便于游戏侧随时连接。 + */ +function load() { + console.log('[yyka-runtime-inspector] load, starting ws server...'); + // 令牌为固定静态值，服务启动时自动带上鉴权 + exports.methods.startServer(); + // 每次打开插件自动安装最新桥接脚本（保留用户自定义 host/port），保证游戏侧脚本与插件版本同步 + exports.methods.installBridge().then((res) => { + if (res && res.ok) { + pushLog({ evt: 'sys', msg: `桥接脚本${res.overwrote ? '已更新' : '已安装'}: ${res.path}` }); + } + else if (res && res.msg) { + console.warn('[yyka-runtime-inspector] auto installBridge skipped:', res.msg); + } + }).catch((err) => { + console.warn('[yyka-runtime-inspector] auto installBridge failed:', err); + }); +} +/** + * @zh 卸载扩展时关闭 WS 服务。 + */ +function unload() { + if (server) { + server.stop(); + server = null; + } + if (mcpHost) { + mcpHost.stop(); + mcpHost = null; + } +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"main.js","sourceRoot":"","sources":["../source/main.ts"],"names":[],"mappings":"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","sourcesContent":["// @ts-ignore\nimport packageJSON from '../package.json';\nimport { existsSync, readFileSync, readJsonSync, readdirSync, writeFileSync, writeJsonSync } from 'fs-extra';\nimport { join } from 'path';\nimport { networkInterfaces } from 'os';\nimport { WsServer } from './ws-server';\nimport { McpHttpServer, MCP_DEFAULT_PORT } from './mcp-server';\n\nconst DEFAULT_PORT = 33000;\n\n/** 固定静态连接令牌：不做动态生成，保证脚本/节点令牌与插件始终一致。 */\nconst STATIC_TOKEN = 'www.yyka.cn';\n\nlet server: WsServer | null = null;\nlet logBuffer: unknown[] = [];\n/** 面板已消费到的缓冲位置：queryLog 改为增量取走而非清空，避免饿死 MCP 的非破坏性 getLogs。 */\nlet logCursor = 0;\nconst serverToken = STATIC_TOKEN;\nlet mcpHost: McpHttpServer | null = null;\n\n// 请求/响应：面板发出带 requestId 的命令，等游戏侧桥接脚本回包后 resolve。\ninterface PendingReq {\n    resolve: (v: any) => void;\n    reject: (e: Error) => void;\n    timer: any;\n}\nconst pending = new Map<number, PendingReq>();\nlet requestSeq = 0;\n\nfunction ensureServer(): WsServer {\n    if (!server) {\n        server = new WsServer();\n    }\n    return server;\n}\n\nfunction getServerState() {\n    const info = server?.clientInfo ?? null;\n    return {\n        running: server?.isRunning ?? false,\n        port: server?.boundPort ?? 0,\n        clients: server?.clients ?? 0,\n        clientType: info?.type ?? '',\n        clientUrl: info?.url ?? '',\n    };\n}\n\nfunction pushLog(item: unknown) {\n    logBuffer.push(item);\n    while (logBuffer.length > 200) {\n        logBuffer.shift();\n        if (logCursor > 0) {\n            logCursor--;\n        }\n    }\n}\n\n/** 客户端类型 → 中文标签（日志用）。 */\nfunction typeLabel(type?: string): string {\n    switch (type) {\n        case 'h5':\n            return '浏览器预览';\n        case 'editor':\n            return '编辑器预览';\n        case 'simulator':\n            return '模拟器';\n        case 'device':\n            return '真机';\n        case 'unknown':\n        default:\n            return '未知来源';\n    }\n}\n\n/** 从项目 settings 中递归查找数值端口。 */\nfunction findNumericPort(cfg: any): number {\n    if (!cfg || typeof cfg !== 'object') {\n        return 0;\n    }\n    if (typeof cfg.port === 'number' && cfg.port > 0) {\n        return cfg.port;\n    }\n    if (typeof cfg.port === 'string' && !Number.isNaN(Number(cfg.port))) {\n        return Number(cfg.port);\n    }\n    for (const k of Object.keys(cfg)) {\n        const v = cfg[k];\n        if (v && typeof v === 'object') {\n            const p = findNumericPort(v);\n            if (p > 0) {\n                return p;\n            }\n        }\n    }\n    return 0;\n}\n\n/**\n * 读取当前项目的预览配置，得出浏览器预港口/URL。\n * 用于面板内嵌 iframe 预览的默认地址。\n */\nfunction getPreviewInfo(): { host: string; port: number; url: string; found: string } {\n    const projectPath = (Editor as any).Project?.path;\n    const candidates = ['settings/preview.json', 'settings/v2/packages/preview.json'];\n    if (projectPath) {\n        for (const rel of candidates) {\n            try {\n                const p = join(projectPath, rel);\n                if (!existsSync(p)) {\n                    continue;\n                }\n                const cfg = readJsonSync(p);\n                const port = findNumericPort(cfg);\n                if (port > 0) {\n                    return { host: 'localhost', port, url: `http://localhost:${port}/`, found: p };\n                }\n            } catch {\n                // 忽略解析失败，尝试下一个候选文件\n            }\n        }\n    }\n    return { host: 'localhost', port: 7456, url: 'http://localhost:7456/', found: '' };\n}\n\n/** 处理来自游戏侧的消息：优先匹配 pending 请求，否则进入日志缓冲。 */\nfunction handleIncoming(data: unknown) {\n    const m = data && typeof data === 'object' ? (data as any) : null;\n    if (m && typeof m.requestId === 'number' && pending.has(m.requestId)) {\n        const p = pending.get(m.requestId)!;\n        pending.delete(m.requestId);\n        if (p.timer) clearTimeout(p.timer);\n        p.resolve(m.data ?? m);\n        return;\n    }\n    // 命令回包/握手等内部协议消息不进入日志，避免 requestId/response/hello 刷屏\n    if (m && (m.evt === 'response' || m.evt === 'request' || m.evt === 'hello')) {\n        return;\n    }\n    pushLog(data);\n}\n\n/** 按限制条数与级别读取最近日志（不清空缓冲，供面板/MCP 使用）。 */\nfunction getLogsInternal(limit: number, level: string): unknown[] {\n    const items: unknown[] = [];\n    for (let i = logBuffer.length - 1; i >= 0 && items.length < limit; i--) {\n        const it: any = logBuffer[i];\n        if (!it || typeof it !== 'object') {\n            continue;\n        }\n        // 过滤掉心跳/握手/预览帧等噪声，只保留控制台与系统消息\n        if (it.evt !== 'console' && it.evt !== 'sys') {\n            continue;\n        }\n        if (level && it.evt === 'console' && it.level !== level) {\n            continue;\n        }\n        items.unshift(it);\n    }\n    return items;\n}\n\n/** 返回 MCP 服务状态与连接配置（URL + 令牌）。 */\nfunction getMcpState() {\n    return {\n        running: mcpHost?.isRunning ?? false,\n        port: mcpHost?.boundPort ?? 0,\n        token: serverToken,\n        url: mcpHost?.isRunning ? `http://127.0.0.1:${mcpHost.boundPort}/mcp` : '',\n    };\n}\n\n/** 向游戏侧桥接脚本发送一条请求，并等待其回包。 */\nfunction callGame(cmd: string, payload?: unknown, timeout = 5000): Promise<any> {\n    return new Promise((resolve, reject) => {\n        if (!server || !server.isRunning) {\n            reject(new Error('WS 服务未运行，请先启动服务'));\n            return;\n        }\n        const requestId = ++requestSeq;\n        const timer = setTimeout(() => {\n            if (pending.has(requestId)) {\n                pending.delete(requestId);\n                reject(new Error(`命令超时(>${timeout}ms): ${cmd}`));\n            }\n        }, timeout);\n        pending.set(requestId, { resolve, reject, timer });\n        server.broadcast({ requestId, cmd, payload });\n    });\n}\n\n/** 获取宿主机第一个非内网 IPv4 地址（用于注入桥接脚本，供模拟器/真机通过局域网连上插件服务）。 */\nfunction getHostLanIP(): string {\n    // 优先返回内网私有段地址（Wi-Fi/有线网卡），避免选到虚拟机或 VPN 虚拟网卡导致真机连不通\n    let fallback = '';\n    try {\n        for (const name of Object.keys(networkInterfaces())) {\n            for (const net of networkInterfaces()[name] ?? []) {\n                if (net.family === 'IPv4' && !net.internal) {\n                    const a = net.address.split('.').map(Number);\n                    const isPrivate =\n                        a[0] === 10 ||\n                        (a[0] === 172 && a[1] >= 16 && a[1] <= 31) ||\n                        (a[0] === 192 && a[1] === 168);\n                    if (isPrivate) {\n                        return net.address;\n                    }\n                    if (!fallback) {\n                        fallback = net.address;\n                    }\n                }\n            }\n        }\n    } catch {\n        /* ignore */\n    }\n    return fallback;\n}\n\n/**\n * @zh 为扩展的主进程的注册方法\n */\n/** 收集目录下所有 .scene 文件。 */\nfunction collectSceneFiles(dir: string, out: string[]): void {\n    let entries;\n    try {\n        entries = readdirSync(dir, { withFileTypes: true });\n    } catch {\n        return;\n    }\n    for (const e of entries) {\n        const p = join(dir, e.name);\n        if (e.isDirectory()) {\n            collectSceneFiles(p, out);\n        } else if (e.isFile() && e.name.endsWith('.scene')) {\n            out.push(p);\n        }\n    }\n}\n\n/** 遍历场景 JSON 中的节点树，对匹配指定脚本 uuid 的组件执行回调。 */\nfunction walkSceneComponents(sceneJson: any, compUuid: string, cb: (comp: any) => void): void {\n    const walkNode = (node: any) => {\n        if (!node || typeof node !== 'object') {\n            return;\n        }\n        if (node.__type__ === 'cc.Node') {\n            for (const c of node._components || []) {\n                if (c && c.__type__ === compUuid) {\n                    cb(c);\n                }\n            }\n            for (const ch of node._children || []) {\n                walkNode(ch);\n            }\n        }\n    };\n    walkNode(sceneJson && sceneJson.scene);\n}\n\nexport const methods: { [key: string]: (...any: any) => any } = {\n    openPanel() {\n        Editor.Panel.open(packageJSON.name);\n    },\n\n    openPreviewPanel() {\n        Editor.Panel.open(`${packageJSON.name}.preview`);\n    },\n\n    /**\n     * 启动 WS 服务。返回当前服务状态。\n     */\n    async startServer(port: number = DEFAULT_PORT) {\n        const ws = ensureServer();\n        ws.token = serverToken;\n        try {\n            if (!ws.isRunning) {\n                ws.on('message', (_client, data) => handleIncoming(data));\n                ws.on('connection', (_client, info) => pushLog({ evt: 'sys', msg: `客户端已连接 (${typeLabel(info?.type)})` }));\n                ws.on('disconnect', (_client, info) => pushLog({ evt: 'sys', msg: `客户端已断开 (${typeLabel(info?.type)})` }));\n                ws.on('auth-fail', (got: string, url: string) =>\n                    pushLog({ evt: 'sys', msg: `连接被拒绝：客户端令牌(${got}) ≠ 服务端令牌(${serverToken})` }));\n                await ws.start(port);\n            }\n        } catch (err) {\n            pushLog({ evt: 'sys', msg: `启动服务失败: ${String(err)}` });\n        }\n        return getServerState();\n    },\n\n    /**\n     * 停止 WS 服务。返回当前服务状态。\n     */\n    async stopServer() {\n        if (server) {\n            await server.stop();\n        }\n        return getServerState();\n    },\n\n    getServerState() {\n        return getServerState();\n    },\n\n    /**\n     * 返回固定连接令牌（静态 token）。\n     */\n    getToken() {\n        return serverToken;\n    },\n\n    /**\n     * 读取当前项目预览配置得出的预港口/URL（供面板内嵌 iframe 用）。\n     */\n    getPreviewInfo() {\n        return getPreviewInfo();\n    },\n\n    /**\n     * 读取当前项目设计分辨率（Project Settings → general.designResolution）。\n     * 首选编辑器内置 `project/query-config`（实时读配置缓存），多模块/按键都试一遍；\n     * 失败再退回到读 settings/v2/packages/project.json 文件，兜底 960×640。\n     */\n    async getProjectsSettings() {\n        try {\n            const modules = ['general', 'engine', 'project'];\n            for (const mod of modules) {\n                try {\n                    const d = await Editor.Message.request('project' as any, 'query-config' as any, mod, 'designResolution');\n                    if (d && Number(d.width) > 0 && Number(d.height) > 0) {\n                        return { designResolution: { width: Number(d.width), height: Number(d.height) } };\n                    }\n                } catch {\n                    // 该模块无此配置，尝试下一个\n                }\n            }\n        } catch {\n            // 继续走文件兜底\n        }\n        const projectPath = (Editor as any).Project?.path;\n        const candidates = [\n            'settings/v2/packages/project.json',\n            'settings/project.json',\n        ];\n        if (projectPath) {\n            for (const rel of candidates) {\n                try {\n                    const p = join(projectPath, rel);\n                    if (!existsSync(p)) continue;\n                    const cfg = readJsonSync(p);\n                    const d = cfg && cfg.general && cfg.general.designResolution;\n                    if (d && Number(d.width) > 0 && Number(d.height) > 0) {\n                        return { designResolution: { width: Number(d.width), height: Number(d.height) } };\n                    }\n                } catch {\n                    // 忽略解析失败，尝试下一个候选文件\n                }\n            }\n        }\n        return { designResolution: { width: 960, height: 640 } };\n    },\n\n    /**\n     * 面板向游戏侧桥接脚本广播一条 fire-and-forget 命令。\n     * args: { cmd: string, payload?: any }\n     */\n    sendCommand(args: { cmd: string; payload?: unknown }) {\n        if (server) {\n            server.broadcast({ cmd: args?.cmd, payload: args?.payload });\n        }\n        return getServerState();\n    },\n\n    /**\n     * 面板请求游戏侧数据：向游戏发带 requestId 的命令并等待回包。\n     * args: { cmd: string, payload?: any, timeout?: number }\n     */\n    async queryCommand(args: { cmd: string; payload?: unknown; timeout?: number }) {\n        const r = await callGame(args?.cmd, args?.payload, args?.timeout ?? 5000);\n        return r;\n    },\n\n    /**\n     * 取回自上次查询以来收到的消息（游戏 → 面板）。按游标增量读取，不破坏缓冲。\n     */\n    queryLog() {\n        const batch = logBuffer.slice(logCursor);\n        logCursor = logBuffer.length;\n        return batch;\n    },\n\n    /**\n     * 读取最近日志（不清空缓冲），供 MCP/AI Agent 使用。\n     * args: { limit?: number, level?: 'all'|'log'|'warn'|'error' }\n     */\n    getLogs(args: { limit?: number; level?: string }) {\n        const limit = Math.max(1, Math.min(200, Number(args?.limit) || 50));\n        const level = args?.level === 'log' || args?.level === 'warn' || args?.level === 'error' ? args.level : '';\n        return getLogsInternal(limit, level);\n    },\n\n    /**\n     * 启动 MCP 服务（HTTP Streamable，供 Codex 等 AI Agent 连接）。\n     */\n    async startMcp(port: number = MCP_DEFAULT_PORT) {\n        if (!mcpHost) {\n            mcpHost = new McpHttpServer();\n        }\n        try {\n            if (!mcpHost.isRunning) {\n                const token = serverToken;\n                await mcpHost.start(port, token, {\n                    callGame,\n                    getServerState,\n                    getToken: () => serverToken,\n                    getLogs: (l: number, lv: string) => getLogsInternal(l, lv),\n                });\n                pushLog({ evt: 'sys', msg: `MCP 服务已启动: http://127.0.0.1:${mcpHost.boundPort}/mcp` });\n            }\n        } catch (err) {\n            pushLog({ evt: 'sys', msg: `MCP 服务启动失败: ${String(err)}` });\n        }\n        return getMcpState();\n    },\n\n    /**\n     * 停止 MCP 服务。\n     */\n    async stopMcp() {\n        if (mcpHost) {\n            await mcpHost.stop();\n            pushLog({ evt: 'sys', msg: 'MCP 服务已停止' });\n        }\n        return getMcpState();\n    },\n\n    /**\n     * 返回 MCP 服务状态与连接配置（URL + 令牌）。\n     */\n    getMcpState() {\n        return getMcpState();\n    },\n\n    /**\n     * 把游戏侧桥接脚本 RuntimeBridge.ts 自动安装到当前项目的 assets 目录。\n     */\n    async installBridge() {\n        const projectPath = (Editor as any).Project?.path;\n        if (!projectPath) {\n            return { ok: false, msg: '无法获取项目路径（Editor.Project.path 为空）' };\n        }\n        const src = join(__dirname, '../runtime-bridge-sample/RuntimeBridge.ts');\n        const assetsDir = join(projectPath, 'assets');\n        if (!existsSync(src)) {\n            return { ok: false, msg: `未找到桥接脚本模板: ${src}` };\n        }\n        if (!existsSync(assetsDir)) {\n            return { ok: false, msg: `找不到项目的 assets 目录: ${assetsDir}` };\n        }\n        const dest = join(assetsDir, 'RuntimeBridge.ts');\n        const overwrote = existsSync(dest);\n        const currentToken = serverToken;\n        // 保留用户自定义 host/port（如真机调试时改为电脑 IP），避免每次覆盖被重置。\n        // 优先取场景中已存在常驻节点组件的现值（用户最近可能直接在节点上配置），\n        // 其次取已安装脚本文件里的默认值。\n        let keepHost = '';\n        let keepPort = 0;\n        if (overwrote) {\n            try {\n                const oldContent = readFileSync(dest, 'utf-8');\n                const hm = /host\\s*=\\s*'([^']*)'/.exec(oldContent);\n                const pm = /port\\s*=\\s*(\\d+)/.exec(oldContent);\n                if (hm) {\n                    keepHost = hm[1];\n                }\n                if (pm) {\n                    keepPort = Number(pm[1]);\n                }\n            } catch {\n                /* 读取失败则用模板默认值 */\n            }\n        }\n        // 解析桥接脚本组件 uuid，用于在场景文件中定位已存在的 RuntimeBridge 组件\n        let compUuid = '';\n        const metaPath = dest + '.meta';\n        try {\n            if (existsSync(metaPath)) {\n                const meta = readJsonSync(metaPath);\n                compUuid = (meta && meta.uuid) || '';\n            }\n        } catch {\n            /* 忽略 meta 读取失败 */\n        }\n        let sceneFiles: string[] = [];\n        if (compUuid) {\n            try {\n                collectSceneFiles(assetsDir, sceneFiles);\n                // 第一遍：以已存在常驻节点组件上的 host/port 为准（用户配置），覆盖脚本旧值\n                for (const sp of sceneFiles) {\n                    try {\n                        const sj = readJsonSync(sp);\n                        walkSceneComponents(sj, compUuid, (comp) => {\n                            if (typeof comp.host === 'string' && comp.host) {\n                                keepHost = comp.host;\n                            }\n                            if (typeof comp.port === 'number' && comp.port > 0) {\n                                keepPort = comp.port;\n                            }\n                        });\n                    } catch {\n                        /* 单个场景解析失败跳过 */\n                    }\n                }\n            } catch {\n                /* 扫描失败则跳过场景同步 */\n            }\n        }\n        // 桥接脚本内置固定令牌 www.yyka.cn，无需注入；\n        // 仅把 BRIDGE_VERSION 同步为插件版本号，避免面板显示过时版本\n        const srcContent = readFileSync(src, 'utf-8');\n        let injected = srcContent.replace(/BRIDGE_VERSION = '[^']*'/, `BRIDGE_VERSION = '${packageJSON.version}'`);\n        // 默认连接地址：用户配置过 host 则保留（如真机调试时自定义的电脑 IP）；\n        // 否则自动注入宿主机局域网 IP —— 固定 127.0.0.1 时真机/模拟器连的是设备自身回环，无法接通插件服务\n        const lanIP = getHostLanIP();\n        if (keepHost) {\n            injected = injected.replace('host = DEFAULT_HOST;', `host = '${keepHost}';`);\n        } else if (lanIP) {\n            injected = injected.replace('host = DEFAULT_HOST;', `host = '${lanIP}';`);\n        }\n        if (keepPort) {\n            injected = injected.replace('port = DEFAULT_PORT;', `port = ${keepPort};`);\n        }\n        writeFileSync(dest, injected, 'utf-8');\n        try {\n            await Editor.Message.request('asset-db', 'refresh-asset', dest);\n        } catch (err) {\n            console.warn('[yyka-runtime-inspector] refresh-asset failed:', err);\n        }\n        // 第二遍：把已存在常驻节点的 host/port 同步为最新配置；\n        // token 已改为脚本内置常量，顺带清掉旧版本场景里残留的 token 字段，避免误导\n        if (compUuid) {\n            for (const sp of sceneFiles) {\n                try {\n                    const sj = readJsonSync(sp);\n                    let changed = false;\n                    walkSceneComponents(sj, compUuid, (comp) => {\n                        if (keepHost) {\n                            comp.host = keepHost;\n                        }\n                        if (keepPort) {\n                            comp.port = keepPort;\n                        }\n                        if (typeof comp.token !== 'undefined') {\n                            delete comp.token;\n                            changed = true;\n                        }\n                        if (keepHost || keepPort) {\n                            changed = true;\n                        }\n                    });\n                    if (changed) {\n                        writeJsonSync(sp, sj, { spaces: 2 });\n                        console.log(`[yyka-runtime-inspector] 已同步常驻节点属性: ${sp}`);\n                        try {\n                            await Editor.Message.request('asset-db', 'refresh-asset', sp);\n                        } catch {\n                            /* ignore */\n                        }\n                    }\n                } catch {\n                    /* 单个场景同步失败跳过 */\n                }\n            }\n        }\n        return { ok: true, path: dest, overwrote, token: currentToken, scenes: sceneFiles.length };\n    },\n\n    /**\n     * 通知游戏侧高亮/遮罩指定节点。id 为空串则清除。\n     */\n    async highlightNode(id: string, mode: string = 'highlight') {\n        try {\n            const res = await callGame('highlight', { id: id || '', mode: mode === 'mask' ? 'mask' : 'highlight' }, 3000);\n            return res;\n        } catch (err) {\n            return { error: String(err) };\n        }\n    },\n};\n\n/**\n * @zh 扩展启动时自动拉起 WS 服务，便于游戏侧随时连接。\n */\nexport function load() {\n    console.log('[yyka-runtime-inspector] load, starting ws server...');\n    // 令牌为固定静态值，服务启动时自动带上鉴权\n    methods.startServer();\n    // 每次打开插件自动安装最新桥接脚本（保留用户自定义 host/port），保证游戏侧脚本与插件版本同步\n    methods.installBridge().then((res: { ok?: boolean; overwrote?: boolean; path?: string; msg?: string }) => {\n        if (res && res.ok) {\n            pushLog({ evt: 'sys', msg: `桥接脚本${res.overwrote ? '已更新' : '已安装'}: ${res.path}` });\n        } else if (res && res.msg) {\n            console.warn('[yyka-runtime-inspector] auto installBridge skipped:', res.msg);\n        }\n    }).catch((err: unknown) => {\n        console.warn('[yyka-runtime-inspector] auto installBridge failed:', err);\n    });\n}\n\n/**\n * @zh 卸载扩展时关闭 WS 服务。\n */\nexport function unload() {\n    if (server) {\n        server.stop();\n        server = null;\n    }\n    if (mcpHost) {\n        mcpHost.stop();\n        mcpHost = null;\n    }\n}"]} \ No newline at end of file diff --git a/extensions/YYKA运行时工作台/dist/mcp-server.js b/extensions/YYKA运行时工作台/dist/mcp-server.js new file mode 100644 index 0000000..b440c77 --- /dev/null +++ b/extensions/YYKA运行时工作台/dist/mcp-server.js @@ -0,0 +1,517 @@ +"use strict"; +var __asyncValues = (this && this.__asyncValues) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); + function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } + function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.McpHttpServer = exports.MCP_DEFAULT_PORT = void 0; +const http_1 = __importDefault(require("http")); +const zod_1 = require("zod"); +const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js"); +const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js"); +/** MCP 服务默认端口（HTTP Streamable）。 */ +exports.MCP_DEFAULT_PORT = 33010; +const text = (s, isError = false) => ({ + content: [{ type: 'text', text: s }], + isError, +}); +const json = (v, isError = false) => ({ + content: [{ type: 'text', text: JSON.stringify(v, null, 2) }], + isError, +}); +/** 统计节点树总节点数。 */ +function countNodes(roots) { + let n = 0; + const walk = (list) => { + for (const r of list) { + n++; + if (Array.isArray(r.children)) { + walk(r.children); + } + } + }; + walk(roots !== null && roots !== void 0 ? roots : []); + return n; +} +/** 把节点树裁剪到指定深度（在序列化结果上处理，无需改桥接脚本）。 */ +function pruneTree(roots, maxDepth) { + const walk = (list, depth) => { + return (list !== null && list !== void 0 ? list : []).map((r) => { + const out = { + id: r.id, + name: r.name, + active: r.active, + layer: r.layer, + comps: r.comps, + }; + if (Array.isArray(r.children) && depth < maxDepth) { + out.children = walk(r.children, depth + 1); + } + else if (Array.isArray(r.children) && r.children.length) { + out.children = `...${r.children.length} 个子节点（超出 max_depth）`; + } + return out; + }); + }; + return walk(roots !== null && roots !== void 0 ? roots : [], 0); +} +function fmtT(ts) { + const d = new Date(ts); + const p = (n) => String(n).padStart(2, '0'); + return `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`; +} +/** + * 内嵌在主进程的 MCP 服务（Streamable HTTP）。 + * 工具直接代理到游戏侧桥接脚本（query-tree / get-inspector / set-property / capture-frame 等）， + * 供 Codex 等 AI Agent 连接并观察、操作正在运行的游戏。 + */ +class McpHttpServer { + constructor() { + this.srv = null; + this.port = 0; + this.token = ''; + this.deps = null; + /** 每个会话持有独立的 McpServer 实例（SDK 限制一个 Protocol 只能连接一个 Transport）。 */ + this.sessions = new Map(); + } + get isRunning() { + return !!this.srv; + } + get boundPort() { + return this.port; + } + checkAuth(req) { + if (!this.token) { + return true; + } + return req.headers.authorization === `Bearer ${this.token}`; + } + async readBody(req, maxBytes = 1024 * 1024) { + var _a, e_1, _b, _c; + const chunks = []; + let size = 0; + try { + for (var _d = true, req_1 = __asyncValues(req), req_1_1; req_1_1 = await req_1.next(), _a = req_1_1.done, !_a; _d = true) { + _c = req_1_1.value; + _d = false; + const chunk = _c; + const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)); + size += buf.length; + if (size > maxBytes) { + throw new Error('body too large'); + } + chunks.push(buf); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (!_d && !_a && (_b = req_1.return)) await _b.call(req_1); + } + finally { if (e_1) throw e_1.error; } + } + const raw = Buffer.concat(chunks).toString('utf-8'); + if (!raw) { + return undefined; + } + try { + return JSON.parse(raw); + } + catch (_e) { + return raw; + } + } + async handle(req, res) { + var _a; + if (!this.checkAuth(req)) { + res.writeHead(401, { 'Content-Type': 'application/json' }); + res.end(JSON.stringify({ error: 'unauthorized' })); + return; + } + const url = (_a = req.url) !== null && _a !== void 0 ? _a : ''; + if (!url.startsWith('/mcp')) { + res.writeHead(404, { 'Content-Type': 'application/json' }); + res.end(JSON.stringify({ error: 'not found' })); + return; + } + const sessionId = req.headers['mcp-session-id']; + let session = sessionId ? this.sessions.get(sessionId) : undefined; + if (sessionId && !session) { + res.writeHead(404, { 'Content-Type': 'application/json' }); + res.end(JSON.stringify({ error: 'invalid session id' })); + return; + } + try { + if (!session) { + // 新会话：为每个会话创建独立的 McpServer 实例，避免 Protocol 重复连接报错 + const deps = this.deps; + if (!deps) { + res.writeHead(503, { 'Content-Type': 'application/json' }); + res.end(JSON.stringify({ error: 'server not ready' })); + return; + } + const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({ + sessionIdGenerator: undefined, + }); + const sid = transport.sessionId; + const mcp = this.buildServer(deps); + session = { transport, mcp }; + this.sessions.set(sid, session); + transport.onclose = () => { + if (this.sessions.get(sid) === session) { + this.sessions.delete(sid); + } + }; + await mcp.connect(transport); + } + const parsedBody = req.method === 'POST' ? await this.readBody(req) : undefined; + await session.transport.handleRequest(req, res, parsedBody); + } + catch (err) { + try { + if (!res.headersSent) { + res.writeHead(500, { 'Content-Type': 'application/json' }); + } + res.end(JSON.stringify({ error: String(err) })); + } + catch (_b) { + /* ignore */ + } + } + } + /** 注册工具集。 */ + buildServer(deps) { + const mcp = new mcp_js_1.McpServer({ name: 'yyka-runtime-inspector', version: '1.0.0' }); + const noClient = () => { + const st = deps.getServerState(); + return !st.running || st.clients === 0; + }; + mcp.registerTool('get_runtime_info', { + title: '获取运行时信息', + description: '获取当前连接的游戏实例信息：连接状态、场景名、节点数量、FPS、DrawCall、三角形数、内存占用、物理系统状态、桥接版本。游戏未连接时返回错误。', + inputSchema: zod_1.z.object({}), + }, async () => { + var _a; + if (noClient()) { + return text('游戏未连接：请先启动 WS 服务、运行游戏并确认桥接脚本已连接。', true); + } + try { + const [stats, tree] = await Promise.all([ + deps.callGame('get-stats', undefined, 4000), + deps.callGame('query-tree', {}, 4000), + ]); + const st = deps.getServerState(); + return json({ + connected: true, + clients: st.clients, + wsPort: st.port, + scene: (_a = tree === null || tree === void 0 ? void 0 : tree.scene) !== null && _a !== void 0 ? _a : '', + nodeCount: countNodes(tree === null || tree === void 0 ? void 0 : tree.roots), + stats: stats !== null && stats !== void 0 ? stats : {}, + }); + } + catch (err) { + return text(`获取运行时信息失败: ${String(err)}`, true); + } + }); + mcp.registerTool('get_node_tree', { + title: '获取节点树', + description: '获取当前场景的运行时节点树（名称/激活/层级/组件数）。可用 filter 按节点名筛选；max_depth 限制展开深度避免输出过大。', + inputSchema: zod_1.z.object({ + filter: zod_1.z.string().optional().describe('按节点名关键字筛选（可选）'), + max_depth: zod_1.z.number().optional().describe('最大展开深度，默认 20（可选）'), + }), + }, async (args) => { + var _a, _b; + if (noClient()) { + return text('游戏未连接。', true); + } + try { + const tree = await deps.callGame('query-tree', { filter: (_a = args === null || args === void 0 ? void 0 : args.filter) !== null && _a !== void 0 ? _a : '' }, 8000); + if (tree && Array.isArray(tree.roots)) { + const depth = typeof (args === null || args === void 0 ? void 0 : args.max_depth) === 'number' ? Math.max(1, Math.min(50, args.max_depth)) : 20; + return json({ scene: (_b = tree.scene) !== null && _b !== void 0 ? _b : '', roots: pruneTree(tree.roots, depth) }); + } + return text('获取节点树失败。', true); + } + catch (err) { + return text(`获取节点树失败: ${String(err)}`, true); + } + }); + mcp.registerTool('get_node_info', { + title: '获取节点信息', + description: '按节点 id 获取节点详情：位置/旋转/缩放/激活/层级等 Transform 属性，以及所有组件及其可编辑属性（含枚举、数组、向量、颜色、引用等）。', + inputSchema: zod_1.z.object({ + id: zod_1.z.string().describe('节点 id（来自 get_node_tree）'), + }), + }, async (args) => { + if (noClient()) { + return text('游戏未连接。', true); + } + if (!(args === null || args === void 0 ? void 0 : args.id)) { + return text('缺少参数 id。', true); + } + try { + const r = await deps.callGame('get-inspector', { id: args.id }, 8000); + if (r && r.error) { + return text(String(r.error), true); + } + return json(r !== null && r !== void 0 ? r : {}); + } + catch (err) { + return text(`获取节点信息失败: ${String(err)}`, true); + } + }); + mcp.registerTool('set_node_property', { + title: '修改运行时属性', + description: '修改运行中节点的属性。节点级：field 取 position/euler/scale（value 为 {x,y,z}）、active（value 为 boolean）、layer（value 为 number）。组件级：传 comp 组件索引（0 起）与 key 属性名，value 为属性值（向量/颜色传对象，枚举传数字）。', + inputSchema: zod_1.z.object({ + id: zod_1.z.string().describe('节点 id（来自 get_node_tree）'), + field: zod_1.z.string().optional().describe('节点级字段：position | euler | scale | active | layer'), + value: zod_1.z.any().optional().describe('要写入的值'), + comp: zod_1.z.number().optional().describe('组件索引（0 起，与 get_node_info 的 components 顺序一致）'), + key: zod_1.z.string().optional().describe('组件属性名'), + }), + }, async (args) => { + if (noClient()) { + return text('游戏未连接。', true); + } + if (!(args === null || args === void 0 ? void 0 : args.id)) { + return text('缺少参数 id。', true); + } + try { + const payload = { id: args.id }; + if (typeof args.field === 'string') { + payload.field = args.field; + payload.value = args.value; + } + if (typeof args.comp === 'number') { + payload.comp = args.comp; + payload.key = args.key; + payload.value = args.value; + } + const r = await deps.callGame('set-property', payload, 8000); + if (r && r.error) { + return text(String(r.error), true); + } + return json(r !== null && r !== void 0 ? r : { ok: true }); + } + catch (err) { + return text(`修改属性失败: ${String(err)}`, true); + } + }); + mcp.registerTool('get_screenshot', { + title: '获取游戏截图', + description: '抓取当前游戏画面并返回图片（JPEG），用于视觉验证游戏状态。', + inputSchema: zod_1.z.object({}), + }, async () => { + if (noClient()) { + return text('游戏未连接。', true); + } + try { + const r = await deps.callGame('capture-frame', {}, 6000); + const dataUrl = r && typeof r.data === 'string' ? r.data : ''; + const base64 = dataUrl.includes(',') ? dataUrl.split(',')[1] : dataUrl; + if (!base64) { + return text('截图失败：游戏侧未能捕获画面。', true); + } + return { + content: [{ type: 'image', data: base64, mimeType: 'image/jpeg' }], + }; + } + catch (err) { + return text(`截图失败: ${String(err)}`, true); + } + }); + mcp.registerTool('get_logs', { + title: '获取运行时日志', + description: '获取游戏侧最近的控制台日志（console.log/warn/error）。level 可选 log/warn/error，默认全部。', + inputSchema: zod_1.z.object({ + limit: zod_1.z.number().optional().describe('返回条数，默认 50'), + level: zod_1.z.string().optional().describe('过滤级别：all | log | warn | error'), + }), + }, async (args) => { + const limit = typeof (args === null || args === void 0 ? void 0 : args.limit) === 'number' ? Math.max(1, Math.min(200, args.limit)) : 50; + const level = typeof (args === null || args === void 0 ? void 0 : args.level) === 'string' ? args.level : 'all'; + const items = deps.getLogs(limit, level); + if (!items.length) { + return text('（暂无日志）'); + } + const lines = items.map((it) => { + var _a, _b; + if (it && it.evt === 'console') { + const tag = it.level === 'error' ? 'ERROR' : it.level === 'warn' ? 'WARN ' : 'LOG '; + return `${fmtT(it.t)} [${tag}] ${it.text}`; + } + if (it && it.evt === 'sys') { + return `${fmtT((_a = it.t) !== null && _a !== void 0 ? _a : Date.now())} [SYS] ${(_b = it.msg) !== null && _b !== void 0 ? _b : ''}`; + } + return JSON.stringify(it); + }); + return text(lines.join('\n')); + }); + mcp.registerTool('wait', { + title: '等待', + description: '等待指定毫秒（1-60000），常用于等待游戏状态变化后再查询。', + inputSchema: zod_1.z.object({ + ms: zod_1.z.number().describe('毫秒数，1-60000'), + }), + }, async (args) => { + const ms = Math.max(1, Math.min(60000, Number(args === null || args === void 0 ? void 0 : args.ms) || 0)); + await new Promise((r) => setTimeout(r, ms)); + return text(`已等待 ${ms}ms`); + }); + mcp.registerTool('execute_command', { + title: '执行游戏命令', + description: '向游戏侧桥接脚本发送任意命令。常用：get-stats、get-resource-stats、query-physics、set-preview({enabled,fps})、set-mute({muted})、set-physics-debug({enabled})。', + inputSchema: zod_1.z.object({ + cmd: zod_1.z.string().describe('命令名'), + payload: zod_1.z.any().optional().describe('命令参数（可选）'), + }), + }, async (args) => { + if (noClient()) { + return text('游戏未连接。', true); + } + if (!(args === null || args === void 0 ? void 0 : args.cmd)) { + return text('缺少参数 cmd。', true); + } + try { + const r = await deps.callGame(String(args.cmd), args.payload, 8000); + return json(r !== null && r !== void 0 ? r : {}); + } + catch (err) { + return text(`命令执行失败: ${String(err)}`, true); + } + }); + mcp.registerTool('click', { + title: '模拟点击', + description: '模拟一次触摸点击。传 id 则点击该节点（取其 UI 中心点）；传 x/y 则点击屏幕（UI 坐标）上命中的最上层节点。常用于触发按钮、开始游戏等操作。', + inputSchema: zod_1.z.object({ + id: zod_1.z.string().optional().describe('节点 id（来自 get_node_tree）'), + x: zod_1.z.number().optional().describe('UI 横坐标（与 id 二选一）'), + y: zod_1.z.number().optional().describe('UI 纵坐标（与 id 二选一）'), + }), + }, async (args) => { + if (noClient()) { + return text('游戏未连接。', true); + } + if (!(args === null || args === void 0 ? void 0 : args.id) && (typeof (args === null || args === void 0 ? void 0 : args.x) !== 'number' || typeof (args === null || args === void 0 ? void 0 : args.y) !== 'number')) { + return text('需要参数 id（节点 id）或 x/y（UI 坐标）。', true); + } + try { + const payload = {}; + if (typeof args.id === 'string' && args.id) { + payload.id = args.id; + } + else { + payload.x = args.x; + payload.y = args.y; + } + const r = await deps.callGame('simulate-click', payload, 8000); + if (r && r.error) { + return text(String(r.error), true); + } + return json(r !== null && r !== void 0 ? r : { ok: true }); + } + catch (err) { + return text(`模拟点击失败: ${String(err)}`, true); + } + }); + mcp.registerTool('list_scenes', { + title: '列出场景', + description: '列出当前运行场景及已加载场景名，用于确认跳转目标。', + inputSchema: zod_1.z.object({}), + }, async () => { + if (noClient()) { + return text('游戏未连接。', true); + } + try { + const r = await deps.callGame('list-scenes', {}, 6000); + return json(r !== null && r !== void 0 ? r : { current: '', scenes: [] }); + } + catch (err) { + return text(`列出场景失败: ${String(err)}`, true); + } + }); + mcp.registerTool('load_scene', { + title: '跳转场景', + description: '运行时加载指定名称的场景（场景跳转）。场景名可先通过 list_scenes 查看。', + inputSchema: zod_1.z.object({ + name: zod_1.z.string().describe('场景名'), + }), + }, async (args) => { + if (noClient()) { + return text('游戏未连接。', true); + } + if (!(args === null || args === void 0 ? void 0 : args.name)) { + return text('缺少参数 name。', true); + } + try { + const r = await deps.callGame('load-scene', { name: String(args.name) }, 6000); + if (r && r.error) { + return text(String(r.error), true); + } + return json(r !== null && r !== void 0 ? r : { ok: true }); + } + catch (err) { + return text(`跳转场景失败: ${String(err)}`, true); + } + }); + return mcp; + } + /** 启动 HTTP 服务。port 被占用时抛错。 */ + async start(port, token, deps) { + if (this.srv) { + return; + } + this.token = token; + this.deps = deps; + const srv = http_1.default.createServer((req, res) => { + this.handle(req, res).catch(() => { + /* handled inside */ + }); + }); + await new Promise((resolve, reject) => { + const onError = (err) => { + srv.removeListener('listening', onListening); + reject(err); + }; + const onListening = () => { + srv.removeListener('error', onError); + resolve(); + }; + srv.once('error', onError); + srv.once('listening', onListening); + srv.listen(port, '127.0.0.1'); + }); + this.srv = srv; + this.port = port; + } + /** 停止服务并关闭所有会话。 */ + async stop() { + const srv = this.srv; + this.srv = null; + this.port = 0; + this.deps = null; + for (const { transport } of this.sessions.values()) { + try { + await transport.close(); + } + catch (_a) { + /* ignore */ + } + } + this.sessions.clear(); + if (srv) { + await new Promise((resolve) => srv.close(() => resolve())); + } + } +} +exports.McpHttpServer = McpHttpServer; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mcp-server.js","sourceRoot":"","sources":["../source/mcp-server.ts"],"names":[],"mappings":"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","sourcesContent":["import http from 'http';\nimport { z } from 'zod';\nimport { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';\nimport { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';\n\n/** MCP 服务默认端口（HTTP Streamable）。 */\nexport const MCP_DEFAULT_PORT = 33010;\n\n/** 主进程向 MCP 服务提供的依赖能力。 */\nexport interface McpDeps {\n    /** 向游戏侧桥接脚本发命令并等待回包。 */\n    callGame: (cmd: string, payload?: unknown, timeout?: number) => Promise<any>;\n    /** 当前 WS 服务状态。 */\n    getServerState: () => { running: boolean; port: number; clients: number };\n    /** 当前连接令牌。 */\n    getToken: () => string;\n    /** 读取最近日志（不清空缓冲）。 */\n    getLogs: (limit: number, level: string) => unknown[];\n}\n\ninterface ToolResult {\n    content: ({ type: 'text'; text: string } | { type: 'image'; data: string; mimeType: string })[];\n    isError?: boolean;\n    [key: string]: unknown;\n}\n\nconst text = (s: string, isError = false): ToolResult => ({\n    content: [{ type: 'text', text: s }],\n    isError,\n});\n\nconst json = (v: unknown, isError = false): ToolResult => ({\n    content: [{ type: 'text', text: JSON.stringify(v, null, 2) }],\n    isError,\n});\n\n/** 统计节点树总节点数。 */\nfunction countNodes(roots: any[]): number {\n    let n = 0;\n    const walk = (list: any[]) => {\n        for (const r of list) {\n            n++;\n            if (Array.isArray(r.children)) {\n                walk(r.children);\n            }\n        }\n    };\n    walk(roots ?? []);\n    return n;\n}\n\n/** 把节点树裁剪到指定深度（在序列化结果上处理，无需改桥接脚本）。 */\nfunction pruneTree(roots: any[], maxDepth: number): any[] {\n    const walk = (list: any[], depth: number): any[] => {\n        return (list ?? []).map((r) => {\n            const out: any = {\n                id: r.id,\n                name: r.name,\n                active: r.active,\n                layer: r.layer,\n                comps: r.comps,\n            };\n            if (Array.isArray(r.children) && depth < maxDepth) {\n                out.children = walk(r.children, depth + 1);\n            } else if (Array.isArray(r.children) && r.children.length) {\n                out.children = `...${r.children.length} 个子节点（超出 max_depth）`;\n            }\n            return out;\n        });\n    };\n    return walk(roots ?? [], 0);\n}\n\nfunction fmtT(ts: number): string {\n    const d = new Date(ts);\n    const p = (n: number) => String(n).padStart(2, '0');\n    return `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;\n}\n\n/**\n * 内嵌在主进程的 MCP 服务（Streamable HTTP）。\n * 工具直接代理到游戏侧桥接脚本（query-tree / get-inspector / set-property / capture-frame 等），\n * 供 Codex 等 AI Agent 连接并观察、操作正在运行的游戏。\n */\nexport class McpHttpServer {\n    private srv: http.Server | null = null;\n    private port = 0;\n    private token = '';\n    private deps: McpDeps | null = null;\n    /** 每个会话持有独立的 McpServer 实例（SDK 限制一个 Protocol 只能连接一个 Transport）。 */\n    private sessions = new Map<string, { transport: StreamableHTTPServerTransport; mcp: McpServer }>();\n\n    get isRunning(): boolean {\n        return !!this.srv;\n    }\n\n    get boundPort(): number {\n        return this.port;\n    }\n\n    private checkAuth(req: http.IncomingMessage): boolean {\n        if (!this.token) {\n            return true;\n        }\n        return req.headers.authorization === `Bearer ${this.token}`;\n    }\n\n    private async readBody(req: http.IncomingMessage, maxBytes = 1024 * 1024): Promise<unknown> {\n        const chunks: Buffer[] = [];\n        let size = 0;\n        for await (const chunk of req) {\n            const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));\n            size += buf.length;\n            if (size > maxBytes) {\n                throw new Error('body too large');\n            }\n            chunks.push(buf);\n        }\n        const raw = Buffer.concat(chunks).toString('utf-8');\n        if (!raw) {\n            return undefined;\n        }\n        try {\n            return JSON.parse(raw);\n        } catch {\n            return raw;\n        }\n    }\n\n    private async handle(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {\n        if (!this.checkAuth(req)) {\n            res.writeHead(401, { 'Content-Type': 'application/json' });\n            res.end(JSON.stringify({ error: 'unauthorized' }));\n            return;\n        }\n        const url = req.url ?? '';\n        if (!url.startsWith('/mcp')) {\n            res.writeHead(404, { 'Content-Type': 'application/json' });\n            res.end(JSON.stringify({ error: 'not found' }));\n            return;\n        }\n        const sessionId = req.headers['mcp-session-id'] as string | undefined;\n        let session = sessionId ? this.sessions.get(sessionId) : undefined;\n        if (sessionId && !session) {\n            res.writeHead(404, { 'Content-Type': 'application/json' });\n            res.end(JSON.stringify({ error: 'invalid session id' }));\n            return;\n        }\n        try {\n            if (!session) {\n                // 新会话：为每个会话创建独立的 McpServer 实例，避免 Protocol 重复连接报错\n                const deps = this.deps;\n                if (!deps) {\n                    res.writeHead(503, { 'Content-Type': 'application/json' });\n                    res.end(JSON.stringify({ error: 'server not ready' }));\n                    return;\n                }\n                const transport = new StreamableHTTPServerTransport({\n                    sessionIdGenerator: undefined,\n                });\n                const sid = transport.sessionId as string;\n                const mcp = this.buildServer(deps);\n                session = { transport, mcp };\n                this.sessions.set(sid, session);\n                transport.onclose = () => {\n                    if (this.sessions.get(sid) === session) {\n                        this.sessions.delete(sid);\n                    }\n                };\n                await mcp.connect(transport);\n            }\n            const parsedBody = req.method === 'POST' ? await this.readBody(req) : undefined;\n            await session.transport.handleRequest(req, res, parsedBody);\n        } catch (err) {\n            try {\n                if (!res.headersSent) {\n                    res.writeHead(500, { 'Content-Type': 'application/json' });\n                }\n                res.end(JSON.stringify({ error: String(err) }));\n            } catch {\n                /* ignore */\n            }\n        }\n    }\n\n    /** 注册工具集。 */\n    private buildServer(deps: McpDeps): McpServer {\n        const mcp = new McpServer({ name: 'yyka-runtime-inspector', version: '1.0.0' });\n        const noClient = (): boolean => {\n            const st = deps.getServerState();\n            return !st.running || st.clients === 0;\n        };\n\n        mcp.registerTool(\n            'get_runtime_info',\n            {\n                title: '获取运行时信息',\n                description:\n                    '获取当前连接的游戏实例信息：连接状态、场景名、节点数量、FPS、DrawCall、三角形数、内存占用、物理系统状态、桥接版本。游戏未连接时返回错误。',\n                inputSchema: z.object({}),\n            },\n            async () => {\n                if (noClient()) {\n                    return text('游戏未连接：请先启动 WS 服务、运行游戏并确认桥接脚本已连接。', true);\n                }\n                try {\n                    const [stats, tree] = await Promise.all([\n                        deps.callGame('get-stats', undefined, 4000),\n                        deps.callGame('query-tree', {}, 4000),\n                    ]);\n                    const st = deps.getServerState();\n                    return json({\n                        connected: true,\n                        clients: st.clients,\n                        wsPort: st.port,\n                        scene: tree?.scene ?? '',\n                        nodeCount: countNodes(tree?.roots),\n                        stats: stats ?? {},\n                    });\n                } catch (err) {\n                    return text(`获取运行时信息失败: ${String(err)}`, true);\n                }\n            },\n        );\n\n        mcp.registerTool(\n            'get_node_tree',\n            {\n                title: '获取节点树',\n                description:\n                    '获取当前场景的运行时节点树（名称/激活/层级/组件数）。可用 filter 按节点名筛选；max_depth 限制展开深度避免输出过大。',\n                inputSchema: z.object({\n                    filter: z.string().optional().describe('按节点名关键字筛选（可选）'),\n                    max_depth: z.number().optional().describe('最大展开深度，默认 20（可选）'),\n                }),\n            },\n            async (args: any) => {\n                if (noClient()) {\n                    return text('游戏未连接。', true);\n                }\n                try {\n                    const tree = await deps.callGame('query-tree', { filter: args?.filter ?? '' }, 8000);\n                    if (tree && Array.isArray(tree.roots)) {\n                        const depth = typeof args?.max_depth === 'number' ? Math.max(1, Math.min(50, args.max_depth)) : 20;\n                        return json({ scene: tree.scene ?? '', roots: pruneTree(tree.roots, depth) });\n                    }\n                    return text('获取节点树失败。', true);\n                } catch (err) {\n                    return text(`获取节点树失败: ${String(err)}`, true);\n                }\n            },\n        );\n\n        mcp.registerTool(\n            'get_node_info',\n            {\n                title: '获取节点信息',\n                description:\n                    '按节点 id 获取节点详情：位置/旋转/缩放/激活/层级等 Transform 属性，以及所有组件及其可编辑属性（含枚举、数组、向量、颜色、引用等）。',\n                inputSchema: z.object({\n                    id: z.string().describe('节点 id（来自 get_node_tree）'),\n                }),\n            },\n            async (args: any) => {\n                if (noClient()) {\n                    return text('游戏未连接。', true);\n                }\n                if (!args?.id) {\n                    return text('缺少参数 id。', true);\n                }\n                try {\n                    const r = await deps.callGame('get-inspector', { id: args.id }, 8000);\n                    if (r && r.error) {\n                        return text(String(r.error), true);\n                    }\n                    return json(r ?? {});\n                } catch (err) {\n                    return text(`获取节点信息失败: ${String(err)}`, true);\n                }\n            },\n        );\n\n        mcp.registerTool(\n            'set_node_property',\n            {\n                title: '修改运行时属性',\n                description:\n                    '修改运行中节点的属性。节点级：field 取 position/euler/scale（value 为 {x,y,z}）、active（value 为 boolean）、layer（value 为 number）。组件级：传 comp 组件索引（0 起）与 key 属性名，value 为属性值（向量/颜色传对象，枚举传数字）。',\n                inputSchema: z.object({\n                    id: z.string().describe('节点 id（来自 get_node_tree）'),\n                    field: z.string().optional().describe('节点级字段：position | euler | scale | active | layer'),\n                    value: z.any().optional().describe('要写入的值'),\n                    comp: z.number().optional().describe('组件索引（0 起，与 get_node_info 的 components 顺序一致）'),\n                    key: z.string().optional().describe('组件属性名'),\n                }),\n            },\n            async (args: any) => {\n                if (noClient()) {\n                    return text('游戏未连接。', true);\n                }\n                if (!args?.id) {\n                    return text('缺少参数 id。', true);\n                }\n                try {\n                    const payload: any = { id: args.id };\n                    if (typeof args.field === 'string') {\n                        payload.field = args.field;\n                        payload.value = args.value;\n                    }\n                    if (typeof args.comp === 'number') {\n                        payload.comp = args.comp;\n                        payload.key = args.key;\n                        payload.value = args.value;\n                    }\n                    const r = await deps.callGame('set-property', payload, 8000);\n                    if (r && r.error) {\n                        return text(String(r.error), true);\n                    }\n                    return json(r ?? { ok: true });\n                } catch (err) {\n                    return text(`修改属性失败: ${String(err)}`, true);\n                }\n            },\n        );\n\n        mcp.registerTool(\n            'get_screenshot',\n            {\n                title: '获取游戏截图',\n                description: '抓取当前游戏画面并返回图片（JPEG），用于视觉验证游戏状态。',\n                inputSchema: z.object({}),\n            },\n            async () => {\n                if (noClient()) {\n                    return text('游戏未连接。', true);\n                }\n                try {\n                    const r = await deps.callGame('capture-frame', {}, 6000);\n                    const dataUrl = r && typeof r.data === 'string' ? r.data : '';\n                    const base64 = dataUrl.includes(',') ? dataUrl.split(',')[1] : dataUrl;\n                    if (!base64) {\n                        return text('截图失败：游戏侧未能捕获画面。', true);\n                    }\n                    return {\n                        content: [{ type: 'image', data: base64, mimeType: 'image/jpeg' }],\n                    };\n                } catch (err) {\n                    return text(`截图失败: ${String(err)}`, true);\n                }\n            },\n        );\n\n        mcp.registerTool(\n            'get_logs',\n            {\n                title: '获取运行时日志',\n                description: '获取游戏侧最近的控制台日志（console.log/warn/error）。level 可选 log/warn/error，默认全部。',\n                inputSchema: z.object({\n                    limit: z.number().optional().describe('返回条数，默认 50'),\n                    level: z.string().optional().describe('过滤级别：all | log | warn | error'),\n                }),\n            },\n            async (args: any) => {\n                const limit = typeof args?.limit === 'number' ? Math.max(1, Math.min(200, args.limit)) : 50;\n                const level = typeof args?.level === 'string' ? args.level : 'all';\n                const items = deps.getLogs(limit, level);\n                if (!items.length) {\n                    return text('（暂无日志）');\n                }\n                const lines = items.map((it: any) => {\n                    if (it && it.evt === 'console') {\n                        const tag = it.level === 'error' ? 'ERROR' : it.level === 'warn' ? 'WARN ' : 'LOG  ';\n                        return `${fmtT(it.t)} [${tag}] ${it.text}`;\n                    }\n                    if (it && it.evt === 'sys') {\n                        return `${fmtT(it.t ?? Date.now())} [SYS] ${it.msg ?? ''}`;\n                    }\n                    return JSON.stringify(it);\n                });\n                return text(lines.join('\\n'));\n            },\n        );\n\n        mcp.registerTool(\n            'wait',\n            {\n                title: '等待',\n                description: '等待指定毫秒（1-60000），常用于等待游戏状态变化后再查询。',\n                inputSchema: z.object({\n                    ms: z.number().describe('毫秒数，1-60000'),\n                }),\n            },\n            async (args: any) => {\n                const ms = Math.max(1, Math.min(60000, Number(args?.ms) || 0));\n                await new Promise((r) => setTimeout(r, ms));\n                return text(`已等待 ${ms}ms`);\n            },\n        );\n\n        mcp.registerTool(\n            'execute_command',\n            {\n                title: '执行游戏命令',\n                description:\n                    '向游戏侧桥接脚本发送任意命令。常用：get-stats、get-resource-stats、query-physics、set-preview({enabled,fps})、set-mute({muted})、set-physics-debug({enabled})。',\n                inputSchema: z.object({\n                    cmd: z.string().describe('命令名'),\n                    payload: z.any().optional().describe('命令参数（可选）'),\n                }),\n            },\n            async (args: any) => {\n                if (noClient()) {\n                    return text('游戏未连接。', true);\n                }\n                if (!args?.cmd) {\n                    return text('缺少参数 cmd。', true);\n                }\n                try {\n                    const r = await deps.callGame(String(args.cmd), args.payload, 8000);\n                    return json(r ?? {});\n                } catch (err) {\n                    return text(`命令执行失败: ${String(err)}`, true);\n                }\n            },\n        );\n\n        mcp.registerTool(\n            'click',\n            {\n                title: '模拟点击',\n                description:\n                    '模拟一次触摸点击。传 id 则点击该节点（取其 UI 中心点）；传 x/y 则点击屏幕（UI 坐标）上命中的最上层节点。常用于触发按钮、开始游戏等操作。',\n                inputSchema: z.object({\n                    id: z.string().optional().describe('节点 id（来自 get_node_tree）'),\n                    x: z.number().optional().describe('UI 横坐标（与 id 二选一）'),\n                    y: z.number().optional().describe('UI 纵坐标（与 id 二选一）'),\n                }),\n            },\n            async (args: any) => {\n                if (noClient()) {\n                    return text('游戏未连接。', true);\n                }\n                if (!args?.id && (typeof args?.x !== 'number' || typeof args?.y !== 'number')) {\n                    return text('需要参数 id（节点 id）或 x/y（UI 坐标）。', true);\n                }\n                try {\n                    const payload: any = {};\n                    if (typeof args.id === 'string' && args.id) {\n                        payload.id = args.id;\n                    } else {\n                        payload.x = args.x;\n                        payload.y = args.y;\n                    }\n                    const r = await deps.callGame('simulate-click', payload, 8000);\n                    if (r && r.error) {\n                        return text(String(r.error), true);\n                    }\n                    return json(r ?? { ok: true });\n                } catch (err) {\n                    return text(`模拟点击失败: ${String(err)}`, true);\n                }\n            },\n        );\n\n        mcp.registerTool(\n            'list_scenes',\n            {\n                title: '列出场景',\n                description: '列出当前运行场景及已加载场景名，用于确认跳转目标。',\n                inputSchema: z.object({}),\n            },\n            async () => {\n                if (noClient()) {\n                    return text('游戏未连接。', true);\n                }\n                try {\n                    const r = await deps.callGame('list-scenes', {}, 6000);\n                    return json(r ?? { current: '', scenes: [] });\n                } catch (err) {\n                    return text(`列出场景失败: ${String(err)}`, true);\n                }\n            },\n        );\n\n        mcp.registerTool(\n            'load_scene',\n            {\n                title: '跳转场景',\n                description: '运行时加载指定名称的场景（场景跳转）。场景名可先通过 list_scenes 查看。',\n                inputSchema: z.object({\n                    name: z.string().describe('场景名'),\n                }),\n            },\n            async (args: any) => {\n                if (noClient()) {\n                    return text('游戏未连接。', true);\n                }\n                if (!args?.name) {\n                    return text('缺少参数 name。', true);\n                }\n                try {\n                    const r = await deps.callGame('load-scene', { name: String(args.name) }, 6000);\n                    if (r && r.error) {\n                        return text(String(r.error), true);\n                    }\n                    return json(r ?? { ok: true });\n                } catch (err) {\n                    return text(`跳转场景失败: ${String(err)}`, true);\n                }\n            },\n        );\n\n        return mcp;\n    }\n\n    /** 启动 HTTP 服务。port 被占用时抛错。 */\n    async start(port: number, token: string, deps: McpDeps): Promise<void> {\n        if (this.srv) {\n            return;\n        }\n        this.token = token;\n        this.deps = deps;\n        const srv = http.createServer((req, res) => {\n            this.handle(req, res).catch(() => {\n                /* handled inside */\n            });\n        });\n        await new Promise<void>((resolve, reject) => {\n            const onError = (err: Error) => {\n                srv.removeListener('listening', onListening);\n                reject(err);\n            };\n            const onListening = () => {\n                srv.removeListener('error', onError);\n                resolve();\n            };\n            srv.once('error', onError);\n            srv.once('listening', onListening);\n            srv.listen(port, '127.0.0.1');\n        });\n        this.srv = srv;\n        this.port = port;\n    }\n\n    /** 停止服务并关闭所有会话。 */\n    async stop(): Promise<void> {\n        const srv = this.srv;\n        this.srv = null;\n        this.port = 0;\n        this.deps = null;\n        for (const { transport } of this.sessions.values()) {\n            try {\n                await transport.close();\n            } catch {\n                /* ignore */\n            }\n        }\n        this.sessions.clear();\n        if (srv) {\n            await new Promise<void>((resolve) => srv.close(() => resolve()));\n        }\n    }\n}\n"]} \ No newline at end of file diff --git a/extensions/YYKA运行时工作台/dist/panels/default/computed.js b/extensions/YYKA运行时工作台/dist/panels/default/computed.js new file mode 100644 index 0000000..c5b07ac --- /dev/null +++ b/extensions/YYKA运行时工作台/dist/panels/default/computed.js @@ -0,0 +1,69 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = { + flatTree() { + var _a; + const out = []; + this.flatten((_a = this.tree.roots) !== null && _a !== void 0 ? _a : [], 0, out); + return out; + }, + /** 节点选择弹层：全部节点（不依赖展开状态）+ 搜索过滤。 */ + pickerRows() { + var _a; + const out = []; + const walk = (nodes, depth) => { + for (const n of nodes) { + const row = n; + row.depth = depth; + row.hasChildren = !!(n.children && n.children.length); + out.push(row); + if (row.hasChildren) { + walk(n.children, depth + 1); + } + } + }; + walk((_a = this.tree.roots) !== null && _a !== void 0 ? _a : [], 0); + const f = (this.nodePicker.filter || '').trim().toLowerCase(); + return f ? out.filter((r) => r.name.toLowerCase().includes(f)) : out; + }, + /** 资产选择弹层：按类型过滤 + 搜索过滤。 */ + assetRows() { + let rows = this.assetPicker.list; + if (this.assetPicker.type) { + rows = rows.filter((r) => r.type === this.assetPicker.type); + } + const f = (this.assetPicker.filter || '').trim().toLowerCase(); + if (f) { + rows = rows.filter((r) => (r.name || '').toLowerCase().includes(f) || (r.type || '').toLowerCase().includes(f)); + } + return rows; + }, + filteredLogs() { + const f = this.logFilter; + if (f === 'all') { + return this.logs; + } + return this.logs.filter((l) => { + const m = l && typeof l === 'object' ? l : null; + if (m && m.evt === 'console') { + return m.level === f; + } + return true; // 非 console 消息（sys/写回提示）始终显示 + }); + }, + clientTypeMeta() { + switch (this.state.clientType) { + case 'h5': + return { label: '浏览器', cls: 'h5' }; + case 'editor': + return { label: '编辑器', cls: 'editor' }; + case 'simulator': + return { label: '模拟器', cls: 'simulator' }; + case 'device': + return { label: '真机', cls: 'device' }; + default: + return { label: '未知?', cls: 'unknown' }; + } + }, +}; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/extensions/YYKA运行时工作台/dist/panels/default/index.js b/extensions/YYKA运行时工作台/dist/panels/default/index.js new file mode 100644 index 0000000..5b049fc --- /dev/null +++ b/extensions/YYKA运行时工作台/dist/panels/default/index.js @@ -0,0 +1,65 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const fs_extra_1 = require("fs-extra"); +const path_1 = require("path"); +const vue_1 = require("vue"); +const state_1 = __importDefault(require("./state")); +const computed_1 = __importDefault(require("./computed")); +const watch_1 = __importDefault(require("./watch")); +const lifecycle_1 = require("./lifecycle"); +const utils_1 = __importDefault(require("./methods/utils")); +const tree_1 = __importDefault(require("./methods/tree")); +const inspector_1 = __importDefault(require("./methods/inspector")); +const pickers_1 = __importDefault(require("./methods/pickers")); +const logs_1 = __importDefault(require("./methods/logs")); +const perf_1 = __importDefault(require("./methods/perf")); +const res_1 = __importDefault(require("./methods/res")); +const preview_1 = __importDefault(require("./methods/preview")); +const mcp_1 = __importDefault(require("./methods/mcp")); +const server_1 = __importDefault(require("./methods/server")); +const panelDataMap = new WeakMap(); +/** 根组件：由各功能域模块组合而成（状态/计算/监听/生命周期/方法全部拆分到独立文件）。 */ +const rootComponent = (0, vue_1.defineComponent)({ + data: state_1.default, + computed: computed_1.default, + watch: watch_1.default, + mounted: lifecycle_1.mounted, + beforeUnmount: lifecycle_1.beforeUnmount, + methods: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, utils_1.default), tree_1.default), inspector_1.default), pickers_1.default), logs_1.default), perf_1.default), res_1.default), preview_1.default), mcp_1.default), server_1.default), + template: (0, fs_extra_1.readFileSync)((0, path_1.join)(__dirname, '../../../static/template/default/app.html'), 'utf-8'), +}); +module.exports = Editor.Panel.define({ + listeners: { + show() { + console.log('show'); + }, + hide() { + console.log('hide'); + }, + }, + template: (0, fs_extra_1.readFileSync)((0, path_1.join)(__dirname, '../../../static/template/default/index.html'), 'utf-8'), + style: (0, fs_extra_1.readFileSync)((0, path_1.join)(__dirname, '../../../static/style/default/index.css'), 'utf-8'), + $: { + app: '#app', + }, + methods: {}, + ready() { + if (this.$.app) { + const app = (0, vue_1.createApp)(rootComponent); + app.config.compilerOptions.isCustomElement = (tag) => tag.startsWith('ui-'); + app.mount(this.$.app); + panelDataMap.set(this, app); + } + }, + beforeClose() { }, + close() { + const app = panelDataMap.get(this); + if (app) { + app.unmount(); + } + }, +}); +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/extensions/YYKA运行时工作台/dist/panels/default/lifecycle.js b/extensions/YYKA运行时工作台/dist/panels/default/lifecycle.js new file mode 100644 index 0000000..55fe32e --- /dev/null +++ b/extensions/YYKA运行时工作台/dist/panels/default/lifecycle.js @@ -0,0 +1,56 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.mounted = mounted; +exports.beforeUnmount = beforeUnmount; +/** 一次性清理：幂等，可安全地被卸载流程 + 窗口 unload 事件重复触发。 + * 拖出为浮窗后关闭时，Cocos 不一定会调用面板 close()/unmount()， + * 因此额外监听 pagehide/beforeunload 兜底，避免预览引擎、游戏 DOM、定时器残留。 */ +function doDispose() { + if (this._disposed) + return; + this._disposed = true; + window.clearInterval(this.interval); + window.clearInterval(this.perfTimer); + window.clearInterval(this.resTimer); + window.clearTimeout(this.filterTimer); + window.clearTimeout(this.copyTimer); + window.clearTimeout(this.mcpCopyTimer); + if (this.stopHostSync) + this.stopHostSync(); // 停止游戏宿主定期同步 + if (this.teardownPreview) + this.teardownPreview(); // 停主循环/调度器/音频、释放资源 + try { + const host = document.getElementById('yyka-game-host'); + if (host) + host.remove(); // 移除顶层游戏 DOM，避免浮窗关闭后画面残留 + } + catch (_) { /* ignore */ } + window.removeEventListener('pointermove', this.onDragMove); + window.removeEventListener('pointerup', this.endDrag); + window.removeEventListener('pointercancel', this.endDrag); + window.removeEventListener('resize', this.onResize); + window.removeEventListener('pagehide', this._onPageHide); + window.removeEventListener('beforeunload', this._onPageHide); +} +async function mounted() { + this.ensureServer(); + this.refresh(); + await this.initPreviewInfo(); + this.$nextTick(() => this.renderPreview()); + this.loadMcpState(); + this.interval = window.setInterval(() => this.refresh(), 1000); + window.addEventListener('pointermove', this.onDragMove); + window.addEventListener('pointerup', this.endDrag); + window.addEventListener('pointercancel', this.endDrag); + window.addEventListener('resize', this.onResize); + // 拖出为独立浮窗后直接关窗时，仅关窗口不触发下文的 beforeUnmount，需在此兜底清理 + this._onPageHide = () => doDispose.call(this); + window.addEventListener('pagehide', this._onPageHide); + window.addEventListener('beforeunload', this._onPageHide); +} +function beforeUnmount() { + window.removeEventListener('pagehide', this._onPageHide); + window.removeEventListener('beforeunload', this._onPageHide); + doDispose.call(this); +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/extensions/YYKA运行时工作台/dist/panels/default/methods/inspector.js b/extensions/YYKA运行时工作台/dist/panels/default/methods/inspector.js new file mode 100644 index 0000000..d761add --- /dev/null +++ b/extensions/YYKA运行时工作台/dist/panels/default/methods/inspector.js @@ -0,0 +1,376 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +// @ts-ignore +const package_json_1 = __importDefault(require("../../../../package.json")); +/** 属性检查器：读取/写回节点与组件属性。 */ +exports.default = { + async loadInspector() { + if (!this.selectedId) { + this.inspector = null; + return; + } + this.inspectorLoading = true; + try { + const res = await Editor.Message.request(package_json_1.default.name, 'query-command', { cmd: 'get-inspector', timeout: 2500, payload: { id: this.selectedId } }); + this.inspector = res && res.id ? res : { error: String((res && res.error) || '获取属性失败') }; + } + catch (err) { + this.inspector = { error: `获取属性失败: ${String(err)}` }; + } + finally { + this.inspectorLoading = false; + } + }, + async sendSet(payload) { + // 关键修复：payload 里可能混入 Vue reactive Proxy（如 vec3 属性对象）， + // Editor.Message.request 经结构化克隆传参，Proxy 无法克隆会抛 + // "An object could not be cloned"。发送前深拷贝为纯对象。 + let plain; + try { + plain = JSON.parse(JSON.stringify(payload)); + } + catch (_a) { + plain = Object.assign({}, payload); + } + try { + const res = await Editor.Message.request(package_json_1.default.name, 'query-command', { cmd: 'set-property', timeout: 1500, payload: plain }); + if (!res || typeof res !== 'object') { + this.logs.push('[写回] 无响应：命令未到达游戏（检查桥接脚本版本）'); + return; + } + if (res.error) { + this.logs.push(`[写回] 游戏返回: ${res.error}`); + return; + } + const label = res.node ? `${res.node}` : (payload.field || payload.key || ''); + this.logs.push(`[写回] 已设置 ${label} = ${JSON.stringify(payload.value)}`); + // 单向语义：保留本地乐观值，不被游戏回读覆盖。 + // 仅做一次静默回读用于诊断——若游戏逻辑/动画后覆盖了设定值，只记日志提示， + // 不回写 UI，避免"双向绑定"把编辑框刷成游戏当前值。 + const e = this.inspector; + const localVal = this.getLocalValue(payload); + try { + const back = await Editor.Message.request(package_json_1.default.name, 'query-command', { cmd: 'get-inspector', timeout: 1500, payload: { id: this.selectedId } }); + const cur = back && back.props && !back.error ? this.pickValue(back, payload) : undefined; + if (cur !== undefined && localVal !== undefined) { + const a = JSON.stringify(cur); + const b = JSON.stringify(localVal); + if (a !== b) { + this.logs.push(`[写回] 注意：回读值 ${a} 与设定值 ${b} 不同，可能被游戏逻辑/动画/物理每帧覆盖`); + } + } + } + catch (_b) { + /* 静默回读失败不影响编辑 */ + } + finally { + // 恢复本地乐观值到 UI（若上面的回读请求把本地对象引用改了） + if (e && !e.error) { + this.applyLocalValue(e, payload, localVal); + } + } + } + catch (err) { + this.logs.push(`[写回] ${String(err)}`); + } + }, + onNodeBool(field, val) { + if (!this.inspector) { + return; + } + this.inspector.props[field].v = val; + this.sendSet({ id: this.selectedId, field, value: val }); + }, + onNodeNumber(field, raw) { + if (!this.inspector) { + return; + } + const v = this.toNum(raw); + this.inspector.props[field].v = v; + this.sendSet({ id: this.selectedId, field, value: v }); + }, + onNodeVec(field, axis, raw) { + if (!this.inspector || !this.inspector.props || !this.inspector.props[field]) { + return; + } + const cur = this.inspector.props[field].v; + cur[axis] = this.toNum(raw); + this.sendSet({ id: this.selectedId, field, value: cur }); + }, + onCompScalar(compIdx, key, raw, t) { + if (!this.inspector) { + return; + } + const prop = this.inspector.components[compIdx].props.find((p) => p.key === key); + let val = raw; + if (t === 'number') { + val = this.toNum(raw); + } + else if (t === 'bool') { + val = raw === true || raw === 'true'; + } + if (prop) { + prop.v = val; + } + this.sendSet({ id: this.selectedId, comp: compIdx, key, value: val }); + }, + onCompVec(compIdx, key, axis, raw) { + if (!this.inspector) { + return; + } + const prop = this.inspector.components[compIdx].props.find((p) => p.key === key); + prop.v[axis] = this.toNum(raw); + this.sendSet({ id: this.selectedId, comp: compIdx, key, value: prop.v }); + }, + onCompColor(compIdx, key, raw) { + if (!this.inspector) { + return; + } + const prop = this.inspector.components[compIdx].props.find((p) => p.key === key); + const v = this.arrToColor(raw); + if (prop) { + prop.v = v; + this.sendSet({ id: this.selectedId, comp: compIdx, key, value: v }); + } + }, + onCompArrayColor(compIdx, key, index, raw) { + if (!this.inspector) { + return; + } + const prop = this.inspector.components[compIdx].props.find((p) => p.key === key); + const v = this.arrToColor(raw); + if (prop && prop.v[index] && prop.v[index].v) { + prop.v[index].v = v; + this.sendSet({ id: this.selectedId, comp: compIdx, key, index, value: v }); + } + }, + onCompEnabled(compIdx, val) { + if (!this.inspector) { + return; + } + this.inspector.components[compIdx].enabled = val; + this.sendSet({ id: this.selectedId, comp: compIdx, key: '__enabled', value: val }); + }, + onCompEnum(compIdx, key, raw) { + if (!this.inspector) { + return; + } + const val = Number(raw); + const prop = this.inspector.components[compIdx].props.find((p) => p.key === key); + if (prop) { + prop.v = val; + } + this.sendSet({ id: this.selectedId, comp: compIdx, key, value: val }); + }, + onCompArray(compIdx, key, index, raw, t) { + if (!this.inspector) { + return; + } + let val = raw; + if (t === 'number') { + val = this.toNum(raw); + } + else if (t === 'bool') { + val = raw === true || raw === 'true'; + } + const prop = this.inspector.components[compIdx].props.find((p) => p.key === key); + if (prop && prop.v[index]) { + prop.v[index].v = val; + } + this.sendSet({ id: this.selectedId, comp: compIdx, key, index, value: val }); + }, + onCompArrayVec(compIdx, key, index, axis, raw) { + if (!this.inspector) { + return; + } + const prop = this.inspector.components[compIdx].props.find((p) => p.key === key); + if (prop && prop.v[index] && prop.v[index].v) { + prop.v[index].v[axis] = this.toNum(raw); + this.sendSet({ id: this.selectedId, comp: compIdx, key, index, value: prop.v[index].v }); + } + }, + onCompNull(compIdx, key) { + if (!this.inspector) { + return; + } + const prop = this.inspector.components[compIdx].props.find((p) => p.key === key); + if (prop) { + prop.v = null; + } + this.sendSet({ id: this.selectedId, comp: compIdx, key, value: null }); + }, + /** 数组项置空（资产引用数组，如 materials）。 */ + onCompArrayNull(compIdx, key, index) { + if (!this.inspector) { + return; + } + const prop = this.inspector.components[compIdx].props.find((p) => p.key === key); + if (prop && prop.v && prop.v[index]) { + prop.v[index] = { t: 'raw', v: null, editable: false }; + } + this.sendSet({ id: this.selectedId, comp: compIdx, key, index, value: null }); + }, + /** 材质参数写回：index 为数字时定位 sharedMaterials 数组项，undefined 用 customMaterial/material。 */ + onCompMaterialProp(compIdx, key, index, propKey, value) { + var _a; + if (!this.inspector) { + return; + } + const comp = this.inspector.components[compIdx]; + const prop = comp === null || comp === void 0 ? void 0 : comp.props.find((p) => p.key === key); + const holder = index === undefined ? prop : (_a = prop === null || prop === void 0 ? void 0 : prop.v) === null || _a === void 0 ? void 0 : _a[index]; + if (holder && holder.v && Array.isArray(holder.v.props)) { + const mp = holder.v.props.find((x) => x.key === propKey); + if (mp) { + mp.v = value; + } + } + this.sendSet({ id: this.selectedId, comp: compIdx, key: '__material_prop', index, value: { propKey, value } }); + }, + /** Widget 专属：写回对齐模式/边距/目标（数值字段先转数字）。 */ + onWidgetSet(compIdx, key, raw) { + if (!this.inspector) { + return; + } + const comp = this.inspector.components[compIdx]; + if (!comp || !comp.widget) { + return; + } + let val = raw; + if (key === 'left' || key === 'right' || key === 'top' || key === 'bottom') { + val = this.toNum(raw); + } + else if (key === 'alignMode') { + val = Number(raw); + } + comp.widget[key] = val; + if (key === '__widget_target') { + comp.widget.targetName = val ? String(val) : ''; + } + this.sendSet({ id: this.selectedId, comp: compIdx, key, value: val }); + }, + /** Widget 专属：切换对齐标志（center 同时切水平+垂直居中；角键同时切两个边）。 */ + onWidgetToggle(compIdx, key) { + if (!this.inspector) { + return; + } + const comp = this.inspector.components[compIdx]; + if (!comp || !comp.widget) { + return; + } + const cornerMap = { + __top_left: ['isAlignTop', 'isAlignLeft'], + __top_right: ['isAlignTop', 'isAlignRight'], + __bottom_left: ['isAlignBottom', 'isAlignLeft'], + __bottom_right: ['isAlignBottom', 'isAlignRight'], + }; + if (key === 'center') { + comp.widget.isAlignHorizontalCenter = !comp.widget.isAlignHorizontalCenter; + comp.widget.isAlignVerticalCenter = !comp.widget.isAlignVerticalCenter; + this.sendSet({ id: this.selectedId, comp: compIdx, key: 'isAlignHorizontalCenter', value: comp.widget.isAlignHorizontalCenter }); + this.sendSet({ id: this.selectedId, comp: compIdx, key: 'isAlignVerticalCenter', value: comp.widget.isAlignVerticalCenter }); + return; + } + const corner = cornerMap[key]; + if (corner) { + for (const k of corner) { + comp.widget[k] = !comp.widget[k]; + } + for (const k of corner) { + this.sendSet({ id: this.selectedId, comp: compIdx, key: k, value: comp.widget[k] }); + } + return; + } + comp.widget[key] = !comp.widget[key]; + this.sendSet({ id: this.selectedId, comp: compIdx, key, value: comp.widget[key] }); + }, + /** 兼容 ui-color 的不同输出格式，统一为 {r,g,b,a}(0-255)。 */ + arrToColor(raw) { + if (Array.isArray(raw)) { + return { + r: this.toNum(raw[0]), + g: this.toNum(raw[1]), + b: this.toNum(raw[2]), + a: raw[3] !== undefined ? this.toNum(raw[3]) : 255, + }; + } + if (raw && typeof raw === 'object' && 'r' in raw) { + return { + r: this.toNum(raw.r), + g: this.toNum(raw.g), + b: this.toNum(raw.b), + a: raw.a !== undefined ? this.toNum(raw.a) : 255, + }; + } + return this.parseColor(raw); + }, + /** ref 引用是否为节点引用（cc.Node）；组件引用返回 false，用于区分 ui-node / ui-component 显示。 */ + isNodeRef(p) { + return !p || !p.componentType || p.componentType === 'cc.Node'; + }, + /** 从当前 inspector 中取正在编辑字段的本地乐观值（写回后不该被回读覆盖）。 */ + getLocalValue(payload) { + var _a, _b, _c, _d, _e, _f, _g, _h; + try { + if (payload.comp !== undefined) { + const comp = (_b = (_a = this.inspector) === null || _a === void 0 ? void 0 : _a.components) === null || _b === void 0 ? void 0 : _b[payload.comp]; + const p = (_c = comp === null || comp === void 0 ? void 0 : comp.props) === null || _c === void 0 ? void 0 : _c.find((x) => x.key === payload.key); + const v = p && (payload.index === undefined ? p.v : (_e = (_d = p.v) === null || _d === void 0 ? void 0 : _d[payload.index]) === null || _e === void 0 ? void 0 : _e.v); + return v === undefined ? undefined : JSON.parse(JSON.stringify(v)); + } + if (payload.field !== undefined) { + const v = (_h = (_g = (_f = this.inspector) === null || _f === void 0 ? void 0 : _f.props) === null || _g === void 0 ? void 0 : _g[payload.field]) === null || _h === void 0 ? void 0 : _h.v; + return v === undefined ? undefined : JSON.parse(JSON.stringify(v)); + } + } + catch ( /* ignore */_j) { /* ignore */ } + return undefined; + }, + /** 从回读结果中取同一字段实际值（对比诊断用）。 */ + pickValue(back, payload) { + var _a, _b, _c, _d, _e, _f; + try { + if (payload.comp !== undefined) { + const comp = (_a = back.components) === null || _a === void 0 ? void 0 : _a[payload.comp]; + const p = (_b = comp === null || comp === void 0 ? void 0 : comp.props) === null || _b === void 0 ? void 0 : _b.find((x) => x.key === payload.key); + const v = p && (payload.index === undefined ? p.v : (_d = (_c = p.v) === null || _c === void 0 ? void 0 : _c[payload.index]) === null || _d === void 0 ? void 0 : _d.v); + return v === undefined ? undefined : JSON.parse(JSON.stringify(v)); + } + if (payload.field !== undefined) { + const v = (_f = (_e = back.props) === null || _e === void 0 ? void 0 : _e[payload.field]) === null || _f === void 0 ? void 0 : _f.v; + return v === undefined ? undefined : JSON.parse(JSON.stringify(v)); + } + } + catch ( /* ignore */_g) { /* ignore */ } + return undefined; + }, + /** 把 UI 中正在编辑的字段恢复成本地乐观值（回读请求不改写编辑框）。 */ + applyLocalValue(insp, payload, val) { + var _a, _b, _c, _d; + if (val === undefined) { + return; + } + try { + if (payload.comp !== undefined) { + const comp = (_a = insp.components) === null || _a === void 0 ? void 0 : _a[payload.comp]; + const p = (_b = comp === null || comp === void 0 ? void 0 : comp.props) === null || _b === void 0 ? void 0 : _b.find((x) => x.key === payload.key); + if (p) { + if (payload.index === undefined) { + p.v = val; + } + else if ((_c = p.v) === null || _c === void 0 ? void 0 : _c[payload.index]) { + p.v[payload.index].v = val; + } + } + } + else if (payload.field !== undefined && ((_d = insp.props) === null || _d === void 0 ? void 0 : _d[payload.field])) { + insp.props[payload.field].v = val; + } + } + catch ( /* ignore */_e) { /* ignore */ } + }, +}; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inspector.js","sourceRoot":"","sources":["../../../../source/panels/default/methods/inspector.ts"],"names":[],"mappings":"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","sourcesContent":["// @ts-ignore\nimport packageJSON from '../../../../package.json';\n\n/** 属性检查器：读取/写回节点与组件属性。 */\nexport default {\n    async loadInspector(this: any) {\n        if (!this.selectedId) {\n            this.inspector = null;\n            return;\n        }\n        this.inspectorLoading = true;\n        try {\n            const res = await Editor.Message.request(\n                packageJSON.name as any,\n                'query-command' as any,\n                { cmd: 'get-inspector', timeout: 2500, payload: { id: this.selectedId } } as any,\n            );\n            this.inspector = res && res.id ? res : { error: String((res && res.error) || '获取属性失败') };\n        } catch (err) {\n            this.inspector = { error: `获取属性失败: ${String(err)}` };\n        } finally {\n            this.inspectorLoading = false;\n        }\n    },\n    async sendSet(this: any, payload: any) {\n        // 关键修复：payload 里可能混入 Vue reactive Proxy（如 vec3 属性对象），\n        // Editor.Message.request 经结构化克隆传参，Proxy 无法克隆会抛\n        // \"An object could not be cloned\"。发送前深拷贝为纯对象。\n        let plain: any;\n        try {\n            plain = JSON.parse(JSON.stringify(payload));\n        } catch {\n            plain = { ...payload };\n        }\n        try {\n            const res = await Editor.Message.request(\n                packageJSON.name as any,\n                'query-command' as any,\n                { cmd: 'set-property', timeout: 1500, payload: plain } as any,\n            );\n            if (!res || typeof res !== 'object') {\n                this.logs.push('[写回] 无响应：命令未到达游戏（检查桥接脚本版本）');\n                return;\n            }\n            if (res.error) {\n                this.logs.push(`[写回] 游戏返回: ${res.error}`);\n                return;\n            }\n            const label = res.node ? `${res.node}` : (payload.field || payload.key || '');\n            this.logs.push(`[写回] 已设置 ${label} = ${JSON.stringify(payload.value)}`);\n            // 单向语义：保留本地乐观值，不被游戏回读覆盖。\n            // 仅做一次静默回读用于诊断——若游戏逻辑/动画后覆盖了设定值，只记日志提示，\n            // 不回写 UI，避免\"双向绑定\"把编辑框刷成游戏当前值。\n            const e = this.inspector;\n            const localVal = this.getLocalValue(payload);\n            try {\n                const back = await Editor.Message.request(\n                    packageJSON.name as any,\n                    'query-command' as any,\n                    { cmd: 'get-inspector', timeout: 1500, payload: { id: this.selectedId } } as any,\n                );\n                const cur = back && back.props && !back.error ? this.pickValue(back, payload) : undefined;\n                if (cur !== undefined && localVal !== undefined) {\n                    const a = JSON.stringify(cur);\n                    const b = JSON.stringify(localVal);\n                    if (a !== b) {\n                        this.logs.push(`[写回] 注意：回读值 ${a} 与设定值 ${b} 不同，可能被游戏逻辑/动画/物理每帧覆盖`);\n                    }\n                }\n            } catch {\n                /* 静默回读失败不影响编辑 */\n            } finally {\n                // 恢复本地乐观值到 UI（若上面的回读请求把本地对象引用改了）\n                if (e && !e.error) {\n                    this.applyLocalValue(e, payload, localVal);\n                }\n            }\n        } catch (err) {\n            this.logs.push(`[写回] ${String(err)}`);\n        }\n    },\n    onNodeBool(this: any, field: string, val: boolean) {\n        if (!this.inspector) {\n            return;\n        }\n        this.inspector.props[field].v = val;\n        this.sendSet({ id: this.selectedId, field, value: val });\n    },\n    onNodeNumber(this: any, field: string, raw: string) {\n        if (!this.inspector) {\n            return;\n        }\n        const v = this.toNum(raw);\n        this.inspector.props[field].v = v;\n        this.sendSet({ id: this.selectedId, field, value: v });\n    },\n    onNodeVec(this: any, field: string, axis: string, raw: string) {\n        if (!this.inspector || !this.inspector.props || !this.inspector.props[field]) {\n            return;\n        }\n        const cur = this.inspector.props[field].v;\n        cur[axis] = this.toNum(raw);\n        this.sendSet({ id: this.selectedId, field, value: cur });\n    },\n    onCompScalar(this: any, compIdx: number, key: string, raw: any, t: string) {\n        if (!this.inspector) {\n            return;\n        }\n        const prop = this.inspector.components[compIdx].props.find((p: any) => p.key === key);\n        let val = raw;\n        if (t === 'number') {\n            val = this.toNum(raw);\n        } else if (t === 'bool') {\n            val = raw === true || raw === 'true';\n        }\n        if (prop) {\n            prop.v = val;\n        }\n        this.sendSet({ id: this.selectedId, comp: compIdx, key, value: val });\n    },\n    onCompVec(this: any, compIdx: number, key: string, axis: string, raw: string) {\n        if (!this.inspector) {\n            return;\n        }\n        const prop = this.inspector.components[compIdx].props.find((p: any) => p.key === key);\n        prop.v[axis] = this.toNum(raw);\n        this.sendSet({ id: this.selectedId, comp: compIdx, key, value: prop.v });\n    },\n    onCompColor(this: any, compIdx: number, key: string, raw: any) {\n        if (!this.inspector) {\n            return;\n        }\n        const prop = this.inspector.components[compIdx].props.find((p: any) => p.key === key);\n        const v = this.arrToColor(raw);\n        if (prop) {\n            prop.v = v;\n            this.sendSet({ id: this.selectedId, comp: compIdx, key, value: v });\n        }\n    },\n    onCompArrayColor(this: any, compIdx: number, key: string, index: number, raw: any) {\n        if (!this.inspector) {\n            return;\n        }\n        const prop = this.inspector.components[compIdx].props.find((p: any) => p.key === key);\n        const v = this.arrToColor(raw);\n        if (prop && prop.v[index] && prop.v[index].v) {\n            prop.v[index].v = v;\n            this.sendSet({ id: this.selectedId, comp: compIdx, key, index, value: v });\n        }\n    },\n    onCompEnabled(this: any, compIdx: number, val: boolean) {\n        if (!this.inspector) {\n            return;\n        }\n        this.inspector.components[compIdx].enabled = val;\n        this.sendSet({ id: this.selectedId, comp: compIdx, key: '__enabled', value: val });\n    },\n    onCompEnum(this: any, compIdx: number, key: string, raw: any) {\n        if (!this.inspector) {\n            return;\n        }\n        const val = Number(raw);\n        const prop = this.inspector.components[compIdx].props.find((p: any) => p.key === key);\n        if (prop) {\n            prop.v = val;\n        }\n        this.sendSet({ id: this.selectedId, comp: compIdx, key, value: val });\n    },\n    onCompArray(this: any, compIdx: number, key: string, index: number, raw: any, t: string) {\n        if (!this.inspector) {\n            return;\n        }\n        let val = raw;\n        if (t === 'number') {\n            val = this.toNum(raw);\n        } else if (t === 'bool') {\n            val = raw === true || raw === 'true';\n        }\n        const prop = this.inspector.components[compIdx].props.find((p: any) => p.key === key);\n        if (prop && prop.v[index]) {\n            prop.v[index].v = val;\n        }\n        this.sendSet({ id: this.selectedId, comp: compIdx, key, index, value: val });\n    },\n    onCompArrayVec(this: any, compIdx: number, key: string, index: number, axis: string, raw: string) {\n        if (!this.inspector) {\n            return;\n        }\n        const prop = this.inspector.components[compIdx].props.find((p: any) => p.key === key);\n        if (prop && prop.v[index] && prop.v[index].v) {\n            prop.v[index].v[axis] = this.toNum(raw);\n            this.sendSet({ id: this.selectedId, comp: compIdx, key, index, value: prop.v[index].v });\n        }\n    },\n    onCompNull(this: any, compIdx: number, key: string) {\n        if (!this.inspector) {\n            return;\n        }\n        const prop = this.inspector.components[compIdx].props.find((p: any) => p.key === key);\n        if (prop) {\n            prop.v = null;\n        }\n        this.sendSet({ id: this.selectedId, comp: compIdx, key, value: null });\n    },\n    /** 数组项置空（资产引用数组，如 materials）。 */\n    onCompArrayNull(this: any, compIdx: number, key: string, index: number) {\n        if (!this.inspector) {\n            return;\n        }\n        const prop = this.inspector.components[compIdx].props.find((p: any) => p.key === key);\n        if (prop && prop.v && prop.v[index]) {\n            prop.v[index] = { t: 'raw', v: null, editable: false };\n        }\n        this.sendSet({ id: this.selectedId, comp: compIdx, key, index, value: null });\n    },\n    /** 材质参数写回：index 为数字时定位 sharedMaterials 数组项，undefined 用 customMaterial/material。 */\n    onCompMaterialProp(this: any, compIdx: number, key: string, index: number | undefined, propKey: string, value: any) {\n        if (!this.inspector) {\n            return;\n        }\n        const comp = this.inspector.components[compIdx];\n        const prop = comp?.props.find((p: any) => p.key === key);\n        const holder = index === undefined ? prop : prop?.v?.[index];\n        if (holder && holder.v && Array.isArray(holder.v.props)) {\n            const mp = holder.v.props.find((x: any) => x.key === propKey);\n            if (mp) {\n                mp.v = value;\n            }\n        }\n        this.sendSet({ id: this.selectedId, comp: compIdx, key: '__material_prop', index, value: { propKey, value } });\n    },\n    /** Widget 专属：写回对齐模式/边距/目标（数值字段先转数字）。 */\n    onWidgetSet(this: any, compIdx: number, key: string, raw: any) {\n        if (!this.inspector) {\n            return;\n        }\n        const comp = this.inspector.components[compIdx];\n        if (!comp || !comp.widget) {\n            return;\n        }\n        let val: any = raw;\n        if (key === 'left' || key === 'right' || key === 'top' || key === 'bottom') {\n            val = this.toNum(raw);\n        } else if (key === 'alignMode') {\n            val = Number(raw);\n        }\n        comp.widget[key] = val;\n        if (key === '__widget_target') {\n            comp.widget.targetName = val ? String(val) : '';\n        }\n        this.sendSet({ id: this.selectedId, comp: compIdx, key, value: val });\n    },\n    /** Widget 专属：切换对齐标志（center 同时切水平+垂直居中；角键同时切两个边）。 */\n    onWidgetToggle(this: any, compIdx: number, key: string) {\n        if (!this.inspector) {\n            return;\n        }\n        const comp = this.inspector.components[compIdx];\n        if (!comp || !comp.widget) {\n            return;\n        }\n        const cornerMap: Record<string, string[]> = {\n            __top_left: ['isAlignTop', 'isAlignLeft'],\n            __top_right: ['isAlignTop', 'isAlignRight'],\n            __bottom_left: ['isAlignBottom', 'isAlignLeft'],\n            __bottom_right: ['isAlignBottom', 'isAlignRight'],\n        };\n        if (key === 'center') {\n            comp.widget.isAlignHorizontalCenter = !comp.widget.isAlignHorizontalCenter;\n            comp.widget.isAlignVerticalCenter = !comp.widget.isAlignVerticalCenter;\n            this.sendSet({ id: this.selectedId, comp: compIdx, key: 'isAlignHorizontalCenter', value: comp.widget.isAlignHorizontalCenter });\n            this.sendSet({ id: this.selectedId, comp: compIdx, key: 'isAlignVerticalCenter', value: comp.widget.isAlignVerticalCenter });\n            return;\n        }\n        const corner = cornerMap[key];\n        if (corner) {\n            for (const k of corner) {\n                comp.widget[k] = !comp.widget[k];\n            }\n            for (const k of corner) {\n                this.sendSet({ id: this.selectedId, comp: compIdx, key: k, value: comp.widget[k] });\n            }\n            return;\n        }\n        comp.widget[key] = !comp.widget[key];\n        this.sendSet({ id: this.selectedId, comp: compIdx, key, value: comp.widget[key] });\n    },\n    /** 兼容 ui-color 的不同输出格式，统一为 {r,g,b,a}(0-255)。 */\n    arrToColor(this: any, raw: any): { r: number; g: number; b: number; a: number } {\n        if (Array.isArray(raw)) {\n            return {\n                r: this.toNum(raw[0]),\n                g: this.toNum(raw[1]),\n                b: this.toNum(raw[2]),\n                a: raw[3] !== undefined ? this.toNum(raw[3]) : 255,\n            };\n        }\n        if (raw && typeof raw === 'object' && 'r' in raw) {\n            return {\n                r: this.toNum(raw.r),\n                g: this.toNum(raw.g),\n                b: this.toNum(raw.b),\n                a: raw.a !== undefined ? this.toNum(raw.a) : 255,\n            };\n        }\n        return this.parseColor(raw);\n    },\n\n    /** ref 引用是否为节点引用（cc.Node）；组件引用返回 false，用于区分 ui-node / ui-component 显示。 */\n    isNodeRef(this: any, p: any): boolean {\n        return !p || !p.componentType || p.componentType === 'cc.Node';\n    },\n\n    /** 从当前 inspector 中取正在编辑字段的本地乐观值（写回后不该被回读覆盖）。 */\n    getLocalValue(this: any, payload: any): any {\n        try {\n            if (payload.comp !== undefined) {\n                const comp = this.inspector?.components?.[payload.comp];\n                const p = comp?.props?.find((x: any) => x.key === payload.key);\n                const v = p && (payload.index === undefined ? p.v : p.v?.[payload.index]?.v);\n                return v === undefined ? undefined : JSON.parse(JSON.stringify(v));\n            }\n            if (payload.field !== undefined) {\n                const v = this.inspector?.props?.[payload.field]?.v;\n                return v === undefined ? undefined : JSON.parse(JSON.stringify(v));\n            }\n        } catch { /* ignore */ }\n        return undefined;\n    },\n    /** 从回读结果中取同一字段实际值（对比诊断用）。 */\n    pickValue(this: any, back: any, payload: any): any {\n        try {\n            if (payload.comp !== undefined) {\n                const comp = back.components?.[payload.comp];\n                const p = comp?.props?.find((x: any) => x.key === payload.key);\n                const v = p && (payload.index === undefined ? p.v : p.v?.[payload.index]?.v);\n                return v === undefined ? undefined : JSON.parse(JSON.stringify(v));\n            }\n            if (payload.field !== undefined) {\n                const v = back.props?.[payload.field]?.v;\n                return v === undefined ? undefined : JSON.parse(JSON.stringify(v));\n            }\n        } catch { /* ignore */ }\n        return undefined;\n    },\n    /** 把 UI 中正在编辑的字段恢复成本地乐观值（回读请求不改写编辑框）。 */\n    applyLocalValue(this: any, insp: any, payload: any, val: any): void {\n        if (val === undefined) {\n            return;\n        }\n        try {\n            if (payload.comp !== undefined) {\n                const comp = insp.components?.[payload.comp];\n                const p = comp?.props?.find((x: any) => x.key === payload.key);\n                if (p) {\n                    if (payload.index === undefined) {\n                        p.v = val;\n                    } else if (p.v?.[payload.index]) {\n                        p.v[payload.index].v = val;\n                    }\n                }\n            } else if (payload.field !== undefined && insp.props?.[payload.field]) {\n                insp.props[payload.field].v = val;\n            }\n        } catch { /* ignore */ }\n    },\n};\n"]} \ No newline at end of file diff --git a/extensions/YYKA运行时工作台/dist/panels/default/methods/logs.js b/extensions/YYKA运行时工作台/dist/panels/default/methods/logs.js new file mode 100644 index 0000000..22b13bd --- /dev/null +++ b/extensions/YYKA运行时工作台/dist/panels/default/methods/logs.js @@ -0,0 +1,66 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +/** 日志面板：格式化/过滤/自动滚动/复制/清空。 */ +exports.default = { + logClass(l) { + const m = l && typeof l === 'object' ? l : null; + return m && m.evt === 'console' ? `lv-${m.level}` : ''; + }, + logText(l) { + const m = l && typeof l === 'object' ? l : null; + if (m && m.evt === 'console') { + return m.text; + } + return this.fmt(l); + }, + logLevel(l) { + const m = l && typeof l === 'object' ? l : null; + return m && m.evt === 'console' ? String(m.level) : 'info'; + }, + logLevelText(l) { + return this.logLevel(l).toUpperCase(); + }, + logTime(l) { + const m = l && typeof l === 'object' ? l : null; + const t = m && typeof m.t === 'number' ? m.t : 0; + if (!t) { + return ''; + } + const d = new Date(t); + const p = (n) => String(n).padStart(2, '0'); + return `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`; + }, + scrollLogToBottom() { + // 用户正在向上翻历史时暂停跟随 + if (this.logUserUp) { + return; + } + this.$nextTick(() => { + const el = this.$refs.logList; + if (!el) { + return; + } + el.scrollTop = el.scrollHeight; + }); + }, + onLogScroll() { + const el = this.$refs.logList; + if (!el) { + return; + } + // 主动滚离底部 → 记录；滚回底部附近 → 恢复自动跟随 + this.logUserUp = el.scrollHeight - el.scrollTop - el.clientHeight >= 40; + }, + async copyLogs() { + const text = this.filteredLogs.map((l) => this.logText(l)).join('\n'); + await this.writeClipboard(text); + }, + clearLogs() { + this.logs = []; + this.logUserUp = false; + }, + async copyLogLine(l) { + await this.writeClipboard(this.fmt(l)); + }, +}; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/extensions/YYKA运行时工作台/dist/panels/default/methods/mcp.js b/extensions/YYKA运行时工作台/dist/panels/default/methods/mcp.js new file mode 100644 index 0000000..5310843 --- /dev/null +++ b/extensions/YYKA运行时工作台/dist/panels/default/methods/mcp.js @@ -0,0 +1,81 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +// @ts-ignore +const package_json_1 = __importDefault(require("../../../../package.json")); +/** MCP 服务：配置弹窗 / 启停 / 端口修改 / 配置复制。 */ +exports.default = { + openMcpDialog() { + this.showMcpDialog = true; + this.mcpPort = this.mcp.port || 33010; + }, + closeMcpDialog() { + this.showMcpDialog = false; + }, + async toggleMcp() { + if (this.mcpBusy) { + return; + } + this.mcpBusy = true; + try { + if (this.mcp.running) { + await Editor.Message.request(package_json_1.default.name, 'stop-mcp'); + } + else { + await Editor.Message.request(package_json_1.default.name, 'start-mcp', this.mcpPort); + } + await this.loadMcpState(); + } + finally { + this.mcpBusy = false; + } + }, + /** 保存弹窗中修改的端口并重启 MCP 服务（端口变化时）。 */ + async applyMcpPort() { + const port = Math.max(1, Math.min(65535, Math.floor(Number(this.mcpPort) || 33010))); + this.mcpPort = port; + if (this.mcp.running && this.mcp.port !== port) { + this.mcpBusy = true; + try { + await Editor.Message.request(package_json_1.default.name, 'stop-mcp'); + await Editor.Message.request(package_json_1.default.name, 'start-mcp', port); + await this.loadMcpState(); + } + finally { + this.mcpBusy = false; + } + } + else if (!this.mcp.running) { + // 未运行则仅保存端口，供后续启动使用 + this.mcpPort = port; + } + }, + async loadMcpState() { + try { + const st = await Editor.Message.request(package_json_1.default.name, 'get-mcp-state'); + if (st && typeof st === 'object') { + this.mcp = { + running: !!st.running, + port: Number(st.port) || 0, + url: String(st.url || ''), + token: String(st.token || ''), + }; + } + } + catch (_a) { + /* 忽略 */ + } + }, + async copyMcpConfig() { + const text = `{\n "mcpServers": {\n "yyka-runtime-inspector": {\n "url": "${this.mcp.url}",\n "headers": { "Authorization": "Bearer ${this.mcp.token}" }\n }\n }\n}`; + await this.writeClipboard(text); + this.mcpCopied = true; + window.clearTimeout(this.mcpCopyTimer); + this.mcpCopyTimer = window.setTimeout(() => { + this.mcpCopied = false; + }, 1600); + }, +}; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWNwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc291cmNlL3BhbmVscy9kZWZhdWx0L21ldGhvZHMvbWNwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsYUFBYTtBQUNiLDRFQUFtRDtBQUVuRCxzQ0FBc0M7QUFDdEMsa0JBQWU7SUFDWCxhQUFhO1FBQ1QsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLENBQUM7UUFDMUIsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksSUFBSSxLQUFLLENBQUM7SUFDMUMsQ0FBQztJQUNELGNBQWM7UUFDVixJQUFJLENBQUMsYUFBYSxHQUFHLEtBQUssQ0FBQztJQUMvQixDQUFDO0lBQ0QsS0FBSyxDQUFDLFNBQVM7UUFDWCxJQUFJLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUNmLE9BQU87UUFDWCxDQUFDO1FBQ0QsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLENBQUM7UUFDcEIsSUFBSSxDQUFDO1lBQ0QsSUFBSSxJQUFJLENBQUMsR0FBRyxDQUFDLE9BQU8sRUFBRSxDQUFDO2dCQUNuQixNQUFNLE1BQU0sQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLHNCQUFXLENBQUMsSUFBVyxFQUFFLFVBQWlCLENBQUMsQ0FBQztZQUM3RSxDQUFDO2lCQUFNLENBQUM7Z0JBQ0osTUFBTSxNQUFNLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxzQkFBVyxDQUFDLElBQVcsRUFBRSxXQUFrQixFQUFFLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUM1RixDQUFDO1lBQ0QsTUFBTSxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7UUFDOUIsQ0FBQztnQkFBUyxDQUFDO1lBQ1AsSUFBSSxDQUFDLE9BQU8sR0FBRyxLQUFLLENBQUM7UUFDekIsQ0FBQztJQUNMLENBQUM7SUFDRCxtQ0FBbUM7SUFDbkMsS0FBSyxDQUFDLFlBQVk7UUFDZCxNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsRUFBRSxJQUFJLENBQUMsR0FBRyxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ3JGLElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDO1FBQ3BCLElBQUksSUFBSSxDQUFDLEdBQUcsQ0FBQyxPQUFPLElBQUksSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLEtBQUssSUFBSSxFQUFFLENBQUM7WUFDN0MsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLENBQUM7WUFDcEIsSUFBSSxDQUFDO2dCQUNELE1BQU0sTUFBTSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsc0JBQVcsQ0FBQyxJQUFXLEVBQUUsVUFBaUIsQ0FBQyxDQUFDO2dCQUN6RSxNQUFNLE1BQU0sQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLHNCQUFXLENBQUMsSUFBVyxFQUFFLFdBQWtCLEVBQUUsSUFBSSxDQUFDLENBQUM7Z0JBQ2hGLE1BQU0sSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1lBQzlCLENBQUM7b0JBQVMsQ0FBQztnQkFDUCxJQUFJLENBQUMsT0FBTyxHQUFHLEtBQUssQ0FBQztZQUN6QixDQUFDO1FBQ0wsQ0FBQzthQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQzNCLG9CQUFvQjtZQUNwQixJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQztRQUN4QixDQUFDO0lBQ0wsQ0FBQztJQUNELEtBQUssQ0FBQyxZQUFZO1FBQ2QsSUFBSSxDQUFDO1lBQ0QsTUFBTSxFQUFFLEdBQUcsTUFBTSxNQUFNLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxzQkFBVyxDQUFDLElBQVcsRUFBRSxlQUFzQixDQUFDLENBQUM7WUFDekYsSUFBSSxFQUFFLElBQUksT0FBTyxFQUFFLEtBQUssUUFBUSxFQUFFLENBQUM7Z0JBQy9CLElBQUksQ0FBQyxHQUFHLEdBQUc7b0JBQ1AsT0FBTyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsT0FBTztvQkFDckIsSUFBSSxFQUFFLE1BQU0sQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQztvQkFDMUIsR0FBRyxFQUFFLE1BQU0sQ0FBQyxFQUFFLENBQUMsR0FBRyxJQUFJLEVBQUUsQ0FBQztvQkFDekIsS0FBSyxFQUFFLE1BQU0sQ0FBQyxFQUFFLENBQUMsS0FBSyxJQUFJLEVBQUUsQ0FBQztpQkFDaEMsQ0FBQztZQUNOLENBQUM7UUFDTCxDQUFDO1FBQUMsV0FBTSxDQUFDO1lBQ0wsUUFBUTtRQUNaLENBQUM7SUFDTCxDQUFDO0lBQ0QsS0FBSyxDQUFDLGFBQWE7UUFDZixNQUFNLElBQUksR0FBRyx3RUFBd0UsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLG1EQUFtRCxJQUFJLENBQUMsR0FBRyxDQUFDLEtBQUssb0JBQW9CLENBQUM7UUFDdkwsTUFBTSxJQUFJLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ2hDLElBQUksQ0FBQyxTQUFTLEdBQUcsSUFBSSxDQUFDO1FBQ3RCLE1BQU0sQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBQ3ZDLElBQUksQ0FBQyxZQUFZLEdBQUcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxHQUFHLEVBQUU7WUFDdkMsSUFBSSxDQUFDLFNBQVMsR0FBRyxLQUFLLENBQUM7UUFDM0IsQ0FBQyxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQ2IsQ0FBQztDQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBAdHMtaWdub3JlXG5pbXBvcnQgcGFja2FnZUpTT04gZnJvbSAnLi4vLi4vLi4vLi4vcGFja2FnZS5qc29uJztcblxuLyoqIE1DUCDmnI3liqHvvJrphY3nva7lvLnnqpcgLyDlkK/lgZwgLyDnq6/lj6Pkv67mlLkgLyDphY3nva7lpI3liLbjgIIgKi9cbmV4cG9ydCBkZWZhdWx0IHtcbiAgICBvcGVuTWNwRGlhbG9nKHRoaXM6IGFueSkge1xuICAgICAgICB0aGlzLnNob3dNY3BEaWFsb2cgPSB0cnVlO1xuICAgICAgICB0aGlzLm1jcFBvcnQgPSB0aGlzLm1jcC5wb3J0IHx8IDMzMDEwO1xuICAgIH0sXG4gICAgY2xvc2VNY3BEaWFsb2codGhpczogYW55KSB7XG4gICAgICAgIHRoaXMuc2hvd01jcERpYWxvZyA9IGZhbHNlO1xuICAgIH0sXG4gICAgYXN5bmMgdG9nZ2xlTWNwKHRoaXM6IGFueSkge1xuICAgICAgICBpZiAodGhpcy5tY3BCdXN5KSB7XG4gICAgICAgICAgICByZXR1cm47XG4gICAgICAgIH1cbiAgICAgICAgdGhpcy5tY3BCdXN5ID0gdHJ1ZTtcbiAgICAgICAgdHJ5IHtcbiAgICAgICAgICAgIGlmICh0aGlzLm1jcC5ydW5uaW5nKSB7XG4gICAgICAgICAgICAgICAgYXdhaXQgRWRpdG9yLk1lc3NhZ2UucmVxdWVzdChwYWNrYWdlSlNPTi5uYW1lIGFzIGFueSwgJ3N0b3AtbWNwJyBhcyBhbnkpO1xuICAgICAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICAgICAgICBhd2FpdCBFZGl0b3IuTWVzc2FnZS5yZXF1ZXN0KHBhY2thZ2VKU09OLm5hbWUgYXMgYW55LCAnc3RhcnQtbWNwJyBhcyBhbnksIHRoaXMubWNwUG9ydCk7XG4gICAgICAgICAgICB9XG4gICAgICAgICAgICBhd2FpdCB0aGlzLmxvYWRNY3BTdGF0ZSgpO1xuICAgICAgICB9IGZpbmFsbHkge1xuICAgICAgICAgICAgdGhpcy5tY3BCdXN5ID0gZmFsc2U7XG4gICAgICAgIH1cbiAgICB9LFxuICAgIC8qKiDkv53lrZjlvLnnqpfkuK3kv67mlLnnmoTnq6/lj6Plubbph43lkK8gTUNQIOacjeWKoe+8iOerr+WPo+WPmOWMluaXtu+8ieOAgiAqL1xuICAgIGFzeW5jIGFwcGx5TWNwUG9ydCh0aGlzOiBhbnkpIHtcbiAgICAgICAgY29uc3QgcG9ydCA9IE1hdGgubWF4KDEsIE1hdGgubWluKDY1NTM1LCBNYXRoLmZsb29yKE51bWJlcih0aGlzLm1jcFBvcnQpIHx8IDMzMDEwKSkpO1xuICAgICAgICB0aGlzLm1jcFBvcnQgPSBwb3J0O1xuICAgICAgICBpZiAodGhpcy5tY3AucnVubmluZyAmJiB0aGlzLm1jcC5wb3J0ICE9PSBwb3J0KSB7XG4gICAgICAgICAgICB0aGlzLm1jcEJ1c3kgPSB0cnVlO1xuICAgICAgICAgICAgdHJ5IHtcbiAgICAgICAgICAgICAgICBhd2FpdCBFZGl0b3IuTWVzc2FnZS5yZXF1ZXN0KHBhY2thZ2VKU09OLm5hbWUgYXMgYW55LCAnc3RvcC1tY3AnIGFzIGFueSk7XG4gICAgICAgICAgICAgICAgYXdhaXQgRWRpdG9yLk1lc3NhZ2UucmVxdWVzdChwYWNrYWdlSlNPTi5uYW1lIGFzIGFueSwgJ3N0YXJ0LW1jcCcgYXMgYW55LCBwb3J0KTtcbiAgICAgICAgICAgICAgICBhd2FpdCB0aGlzLmxvYWRNY3BTdGF0ZSgpO1xuICAgICAgICAgICAgfSBmaW5hbGx5IHtcbiAgICAgICAgICAgICAgICB0aGlzLm1jcEJ1c3kgPSBmYWxzZTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfSBlbHNlIGlmICghdGhpcy5tY3AucnVubmluZykge1xuICAgICAgICAgICAgLy8g5pyq6L+Q6KGM5YiZ5LuF5L+d5a2Y56uv5Y+j77yM5L6b5ZCO57ut5ZCv5Yqo5L2/55SoXG4gICAgICAgICAgICB0aGlzLm1jcFBvcnQgPSBwb3J0O1xuICAgICAgICB9XG4gICAgfSxcbiAgICBhc3luYyBsb2FkTWNwU3RhdGUodGhpczogYW55KSB7XG4gICAgICAgIHRyeSB7XG4gICAgICAgICAgICBjb25zdCBzdCA9IGF3YWl0IEVkaXRvci5NZXNzYWdlLnJlcXVlc3QocGFja2FnZUpTT04ubmFtZSBhcyBhbnksICdnZXQtbWNwLXN0YXRlJyBhcyBhbnkpO1xuICAgICAgICAgICAgaWYgKHN0ICYmIHR5cGVvZiBzdCA9PT0gJ29iamVjdCcpIHtcbiAgICAgICAgICAgICAgICB0aGlzLm1jcCA9IHtcbiAgICAgICAgICAgICAgICAgICAgcnVubmluZzogISFzdC5ydW5uaW5nLFxuICAgICAgICAgICAgICAgICAgICBwb3J0OiBOdW1iZXIoc3QucG9ydCkgfHwgMCxcbiAgICAgICAgICAgICAgICAgICAgdXJsOiBTdHJpbmcoc3QudXJsIHx8ICcnKSxcbiAgICAgICAgICAgICAgICAgICAgdG9rZW46IFN0cmluZyhzdC50b2tlbiB8fCAnJyksXG4gICAgICAgICAgICAgICAgfTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfSBjYXRjaCB7XG4gICAgICAgICAgICAvKiDlv73nlaUgKi9cbiAgICAgICAgfVxuICAgIH0sXG4gICAgYXN5bmMgY29weU1jcENvbmZpZyh0aGlzOiBhbnkpIHtcbiAgICAgICAgY29uc3QgdGV4dCA9IGB7XFxuICBcIm1jcFNlcnZlcnNcIjoge1xcbiAgICBcInl5a2EtcnVudGltZS1pbnNwZWN0b3JcIjoge1xcbiAgICAgIFwidXJsXCI6IFwiJHt0aGlzLm1jcC51cmx9XCIsXFxuICAgICAgXCJoZWFkZXJzXCI6IHsgXCJBdXRob3JpemF0aW9uXCI6IFwiQmVhcmVyICR7dGhpcy5tY3AudG9rZW59XCIgfVxcbiAgICB9XFxuICB9XFxufWA7XG4gICAgICAgIGF3YWl0IHRoaXMud3JpdGVDbGlwYm9hcmQodGV4dCk7XG4gICAgICAgIHRoaXMubWNwQ29waWVkID0gdHJ1ZTtcbiAgICAgICAgd2luZG93LmNsZWFyVGltZW91dCh0aGlzLm1jcENvcHlUaW1lcik7XG4gICAgICAgIHRoaXMubWNwQ29weVRpbWVyID0gd2luZG93LnNldFRpbWVvdXQoKCkgPT4ge1xuICAgICAgICAgICAgdGhpcy5tY3BDb3BpZWQgPSBmYWxzZTtcbiAgICAgICAgfSwgMTYwMCk7XG4gICAgfSxcbn07XG4iXX0= \ No newline at end of file diff --git a/extensions/YYKA运行时工作台/dist/panels/default/methods/perf.js b/extensions/YYKA运行时工作台/dist/panels/default/methods/perf.js new file mode 100644 index 0000000..adf4eef --- /dev/null +++ b/extensions/YYKA运行时工作台/dist/panels/default/methods/perf.js @@ -0,0 +1,209 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +// @ts-ignore +const package_json_1 = __importDefault(require("../../../../package.json")); +/** 性能曲线：采样 + Canvas 自绘（无第三方图表依赖）。 */ +exports.default = { + stopPerfSampling() { + if (this.perfTimer) { + window.clearInterval(this.perfTimer); + this.perfTimer = 0; + } + }, + async samplePerf() { + var _a, _b, _c, _d, _e, _f; + if (this.state.clients <= 0) { + return; + } + try { + const s = (await Editor.Message.request(package_json_1.default.name, 'query-command', { cmd: 'get-stats' })); + if (s && typeof s === 'object') { + this.stats = { + drawCall: (_a = s.drawCall) !== null && _a !== void 0 ? _a : 0, + triangles: (_c = (_b = s.triangles) !== null && _b !== void 0 ? _b : s.triangle) !== null && _c !== void 0 ? _c : 0, + fps: (_d = s.fps) !== null && _d !== void 0 ? _d : 0, + memUsed: (_e = s.memUsed) !== null && _e !== void 0 ? _e : 0, + memTotal: (_f = s.memTotal) !== null && _f !== void 0 ? _f : 0, + }; + this.perf.push({ fps: this.stats.fps, dc: this.stats.drawCall }); + // 滑动窗口：满 400 条后移除最旧一条，数组恒定 400，绘制持续进行 + if (this.perf.length > 400) { + this.perf.shift(); + } + this.drawPerf(); + } + } + catch (_g) { + /* 忽略采样失败 */ + } + }, + drawPerf() { + const el = this.$refs.perfCanvas; + if (!el) { + return; + } + const dpr = window.devicePixelRatio || 1; + const cw = el.clientWidth; + const ch = el.clientHeight; + if (cw <= 0 || ch <= 0) { + return; + } + const W = Math.round(cw * dpr); + const H = Math.round(ch * dpr); + if (el.width !== W || el.height !== H) { + el.width = W; + el.height = H; + } + const ctx = el.getContext('2d'); + if (!ctx) { + return; + } + ctx.setTransform(dpr, 0, 0, dpr, 0, 0); + ctx.clearRect(0, 0, cw, ch); + const pts = this.perf; + // 绘图区：左右留刻度空间，顶部留 4，底部留 16 放 x 轴时间标签 + const plot = { l: 36, r: cw - 44, t: 6, b: ch - 16 }; + const pw = Math.max(1, plot.r - plot.l); + const ph = Math.max(1, plot.b - plot.t); + const start = Math.max(0, pts.length - 90); + const n = pts.length - start; + const stepX = pw / 90; + const xAt = (idx) => plot.l + (idx - start) * stepX; + const maxFps = 60; + const maxDc = Math.max(20, ...pts.map((p) => p.dc)) * 1.1; + const dcMax = Math.max(20, Math.ceil(maxDc / 20) * 20); + const yAt = (v, max) => plot.b - (Math.min(max, v) / max) * ph; + // ---- 网格 + 帧率轴刻度（左，绿 0/20/40/60） ---- + ctx.font = '10px sans-serif'; + ctx.textBaseline = 'middle'; + ctx.strokeStyle = 'rgba(128,128,128,0.18)'; + ctx.lineWidth = 1; + for (const v of [0, 20, 40, 60]) { + const y = Math.round(yAt(v, maxFps)) + 0.5; + ctx.beginPath(); + ctx.moveTo(plot.l, y); + ctx.lineTo(plot.r, y); + ctx.stroke(); + ctx.fillStyle = '#4ade80'; + ctx.textAlign = 'right'; + ctx.fillText(String(v), plot.l - 4, y); + } + // ---- 绘制调用轴刻度（右，黄 0/mid/max） ---- + for (const v of [0, Math.round(dcMax / 2), dcMax]) { + const y = Math.round(yAt(v, dcMax)) + 0.5; + ctx.beginPath(); + ctx.moveTo(plot.l, y); + ctx.lineTo(plot.r, y); + ctx.stroke(); + ctx.fillStyle = '#fbbf24'; + ctx.textAlign = 'left'; + ctx.fillText(String(v), plot.r + 4, y); + } + // ---- x 轴时间标签（底部） ---- + ctx.fillStyle = '#888'; + ctx.textAlign = 'center'; + ctx.fillText('-80s', xAt(start), plot.b + 9); + ctx.fillText('-60s', xAt(start + 30), plot.b + 9); + ctx.fillText('-40s', xAt(start + 60), plot.b + 9); + ctx.fillText('-20s', xAt(start + 80), plot.b + 9); + ctx.fillText('0s', plot.r, plot.b + 9); + if (n < 2) { + return; + } + // ---- Catmull-Rom → 三次贝塞尔平滑曲线 ---- + const drawSeries = (get, max, color) => { + ctx.strokeStyle = color; + ctx.lineWidth = 1.5; + ctx.lineJoin = 'round'; + ctx.lineCap = 'round'; + ctx.beginPath(); + ctx.moveTo(xAt(start), yAt(get(pts[start]), max)); + if (n === 2) { + ctx.lineTo(xAt(start + 1), yAt(get(pts[start + 1]), max)); + } + else { + for (let i = start; i < pts.length - 1; i++) { + const p0i = Math.max(start, i - 1); + const p2i = i + 1; + const p3i = Math.min(pts.length - 1, i + 2); + const cp1x = xAt(i) + (xAt(p2i) - xAt(p0i)) / 6; + const cp1y = yAt(get(pts[i]), max) + (yAt(get(pts[p2i]), max) - yAt(get(pts[p0i]), max)) / 6; + const cp2x = xAt(p2i) - (xAt(p3i) - xAt(i)) / 6; + const cp2y = yAt(get(pts[p2i]), max) - (yAt(get(pts[p3i]), max) - yAt(get(pts[i]), max)) / 6; + ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, xAt(p2i), yAt(get(pts[p2i]), max)); + } + } + ctx.stroke(); + }; + drawSeries((p) => p.fps, maxFps, '#4ade80'); + drawSeries((p) => p.dc, dcMax, '#fbbf24'); + // ---- 悬停/点击峰值：十字线 + 圆点 + 数值提示框 ---- + if (this.hoverIdx >= 0 && this.hoverIdx >= start && this.hoverIdx < pts.length) { + const p = pts[this.hoverIdx]; + const x = xAt(this.hoverIdx); + ctx.strokeStyle = 'rgba(255,255,255,0.35)'; + ctx.beginPath(); + ctx.moveTo(Math.round(x) + 0.5, plot.t); + ctx.lineTo(Math.round(x) + 0.5, plot.b); + ctx.stroke(); + const hoverSeries = [ + [(p) => p.fps, maxFps, '#4ade80'], + [(p) => p.dc, dcMax, '#fbbf24'], + ]; + for (const [get, max, color] of hoverSeries) { + ctx.fillStyle = color; + ctx.beginPath(); + ctx.arc(x, yAt(get(p), max), 3, 0, Math.PI * 2); + ctx.fill(); + } + const rel = this.hoverIdx - (pts.length - 1); + const lines = [`${rel}s`, `帧率 ${p.fps}`, `绘制调用 ${p.dc}`]; + const lineH = 14; + const boxW = 118; + const boxH = lines.length * lineH + 8; + let bx = plot.l + 4; + const by = plot.t + 4; + if (x + 140 > cw) { + bx = x - boxW - 8; + } + ctx.fillStyle = 'rgba(25,25,25,0.92)'; + ctx.strokeStyle = 'rgba(128,128,128,0.5)'; + ctx.fillRect(bx, by, boxW, boxH); + ctx.strokeRect(bx, by, boxW, boxH); + ctx.textAlign = 'left'; + lines.forEach((ln, i) => { + ctx.fillStyle = i === 0 ? '#aaa' : i === 1 ? '#4ade80' : '#fbbf24'; + ctx.fillText(ln, bx + 6, by + 10 + i * lineH); + }); + } + }, + onPerfMove(e) { + const el = this.$refs.perfCanvas; + if (!el || !this.perf.length) { + return; + } + const rect = el.getBoundingClientRect(); + const cw = el.clientWidth; + // 与 drawPerf 保持一致的绘图区换算 + const plotL = 36; + const plotR = cw - 44; + const stepX = Math.max(1, plotR - plotL) / 90; + const start = Math.max(0, this.perf.length - 90); + const idx = start + Math.round((e.clientX - rect.left - plotL) / stepX); + const clamped = Math.max(start, Math.min(this.perf.length - 1, idx)); + if (clamped !== this.hoverIdx) { + this.hoverIdx = clamped; + this.drawPerf(); + } + }, + onPerfLeave() { + if (this.hoverIdx !== -1) { + this.hoverIdx = -1; + this.drawPerf(); + } + }, +}; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"perf.js","sourceRoot":"","sources":["../../../../source/panels/default/methods/perf.ts"],"names":[],"mappings":"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","sourcesContent":["// @ts-ignore\nimport packageJSON from '../../../../package.json';\n\n/** 性能曲线：采样 + Canvas 自绘（无第三方图表依赖）。 */\nexport default {\n    stopPerfSampling(this: any) {\n        if (this.perfTimer) {\n            window.clearInterval(this.perfTimer);\n            this.perfTimer = 0;\n        }\n    },\n    async samplePerf(this: any) {\n        if (this.state.clients <= 0) {\n            return;\n        }\n        try {\n            const s = (await Editor.Message.request(\n                packageJSON.name as any,\n                'query-command' as any,\n                { cmd: 'get-stats' } as any,\n            )) as any;\n            if (s && typeof s === 'object') {\n                this.stats = {\n                    drawCall: s.drawCall ?? 0,\n                    triangles: s.triangles ?? s.triangle ?? 0,\n                    fps: s.fps ?? 0,\n                    memUsed: s.memUsed ?? 0,\n                    memTotal: s.memTotal ?? 0,\n                };\n                this.perf.push({ fps: this.stats.fps, dc: this.stats.drawCall });\n                // 滑动窗口：满 400 条后移除最旧一条，数组恒定 400，绘制持续进行\n                if (this.perf.length > 400) {\n                    this.perf.shift();\n                }\n                this.drawPerf();\n            }\n        } catch {\n            /* 忽略采样失败 */\n        }\n    },\n    drawPerf(this: any) {\n        const el = this.$refs.perfCanvas as HTMLCanvasElement | undefined;\n        if (!el) {\n            return;\n        }\n        const dpr = window.devicePixelRatio || 1;\n        const cw = el.clientWidth;\n        const ch = el.clientHeight;\n        if (cw <= 0 || ch <= 0) {\n            return;\n        }\n        const W = Math.round(cw * dpr);\n        const H = Math.round(ch * dpr);\n        if (el.width !== W || el.height !== H) {\n            el.width = W;\n            el.height = H;\n        }\n        const ctx = el.getContext('2d');\n        if (!ctx) {\n            return;\n        }\n        ctx.setTransform(dpr, 0, 0, dpr, 0, 0);\n        ctx.clearRect(0, 0, cw, ch);\n        const pts = this.perf;\n        // 绘图区：左右留刻度空间，顶部留 4，底部留 16 放 x 轴时间标签\n        const plot = { l: 36, r: cw - 44, t: 6, b: ch - 16 };\n        const pw = Math.max(1, plot.r - plot.l);\n        const ph = Math.max(1, plot.b - plot.t);\n        const start = Math.max(0, pts.length - 90);\n        const n = pts.length - start;\n        const stepX = pw / 90;\n        const xAt = (idx: number) => plot.l + (idx - start) * stepX;\n        const maxFps = 60;\n        const maxDc = Math.max(20, ...pts.map((p: { fps: number; dc: number }) => p.dc)) * 1.1;\n        const dcMax = Math.max(20, Math.ceil(maxDc / 20) * 20);\n        const yAt = (v: number, max: number) => plot.b - (Math.min(max, v) / max) * ph;\n\n        // ---- 网格 + 帧率轴刻度（左，绿 0/20/40/60） ----\n        ctx.font = '10px sans-serif';\n        ctx.textBaseline = 'middle';\n        ctx.strokeStyle = 'rgba(128,128,128,0.18)';\n        ctx.lineWidth = 1;\n        for (const v of [0, 20, 40, 60]) {\n            const y = Math.round(yAt(v, maxFps)) + 0.5;\n            ctx.beginPath();\n            ctx.moveTo(plot.l, y);\n            ctx.lineTo(plot.r, y);\n            ctx.stroke();\n            ctx.fillStyle = '#4ade80';\n            ctx.textAlign = 'right';\n            ctx.fillText(String(v), plot.l - 4, y);\n        }\n        // ---- 绘制调用轴刻度（右，黄 0/mid/max） ----\n        for (const v of [0, Math.round(dcMax / 2), dcMax]) {\n            const y = Math.round(yAt(v, dcMax)) + 0.5;\n            ctx.beginPath();\n            ctx.moveTo(plot.l, y);\n            ctx.lineTo(plot.r, y);\n            ctx.stroke();\n            ctx.fillStyle = '#fbbf24';\n            ctx.textAlign = 'left';\n            ctx.fillText(String(v), plot.r + 4, y);\n        }\n        // ---- x 轴时间标签（底部） ----\n        ctx.fillStyle = '#888';\n        ctx.textAlign = 'center';\n        ctx.fillText('-80s', xAt(start), plot.b + 9);\n        ctx.fillText('-60s', xAt(start + 30), plot.b + 9);\n        ctx.fillText('-40s', xAt(start + 60), plot.b + 9);\n        ctx.fillText('-20s', xAt(start + 80), plot.b + 9);\n        ctx.fillText('0s', plot.r, plot.b + 9);\n\n        if (n < 2) {\n            return;\n        }\n        // ---- Catmull-Rom → 三次贝塞尔平滑曲线 ----\n        const drawSeries = (get: (p: { fps: number; dc: number }) => number, max: number, color: string) => {\n            ctx.strokeStyle = color;\n            ctx.lineWidth = 1.5;\n            ctx.lineJoin = 'round';\n            ctx.lineCap = 'round';\n            ctx.beginPath();\n            ctx.moveTo(xAt(start), yAt(get(pts[start]), max));\n            if (n === 2) {\n                ctx.lineTo(xAt(start + 1), yAt(get(pts[start + 1]), max));\n            } else {\n                for (let i = start; i < pts.length - 1; i++) {\n                    const p0i = Math.max(start, i - 1);\n                    const p2i = i + 1;\n                    const p3i = Math.min(pts.length - 1, i + 2);\n                    const cp1x = xAt(i) + (xAt(p2i) - xAt(p0i)) / 6;\n                    const cp1y = yAt(get(pts[i]), max) + (yAt(get(pts[p2i]), max) - yAt(get(pts[p0i]), max)) / 6;\n                    const cp2x = xAt(p2i) - (xAt(p3i) - xAt(i)) / 6;\n                    const cp2y = yAt(get(pts[p2i]), max) - (yAt(get(pts[p3i]), max) - yAt(get(pts[i]), max)) / 6;\n                    ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, xAt(p2i), yAt(get(pts[p2i]), max));\n                }\n            }\n            ctx.stroke();\n        };\n        drawSeries((p) => p.fps, maxFps, '#4ade80');\n        drawSeries((p) => p.dc, dcMax, '#fbbf24');\n\n        // ---- 悬停/点击峰值：十字线 + 圆点 + 数值提示框 ----\n        if (this.hoverIdx >= 0 && this.hoverIdx >= start && this.hoverIdx < pts.length) {\n            const p = pts[this.hoverIdx];\n            const x = xAt(this.hoverIdx);\n            ctx.strokeStyle = 'rgba(255,255,255,0.35)';\n            ctx.beginPath();\n            ctx.moveTo(Math.round(x) + 0.5, plot.t);\n            ctx.lineTo(Math.round(x) + 0.5, plot.b);\n            ctx.stroke();\n            const hoverSeries: [(p: { fps: number; dc: number }) => number, number, string][] = [\n                [(p) => p.fps, maxFps, '#4ade80'],\n                [(p) => p.dc, dcMax, '#fbbf24'],\n            ];\n            for (const [get, max, color] of hoverSeries) {\n                ctx.fillStyle = color;\n                ctx.beginPath();\n                ctx.arc(x, yAt(get(p), max), 3, 0, Math.PI * 2);\n                ctx.fill();\n            }\n            const rel = this.hoverIdx - (pts.length - 1);\n            const lines = [`${rel}s`, `帧率 ${p.fps}`, `绘制调用 ${p.dc}`];\n            const lineH = 14;\n            const boxW = 118;\n            const boxH = lines.length * lineH + 8;\n            let bx = plot.l + 4;\n            const by = plot.t + 4;\n            if (x + 140 > cw) {\n                bx = x - boxW - 8;\n            }\n            ctx.fillStyle = 'rgba(25,25,25,0.92)';\n            ctx.strokeStyle = 'rgba(128,128,128,0.5)';\n            ctx.fillRect(bx, by, boxW, boxH);\n            ctx.strokeRect(bx, by, boxW, boxH);\n            ctx.textAlign = 'left';\n            lines.forEach((ln, i) => {\n                ctx.fillStyle = i === 0 ? '#aaa' : i === 1 ? '#4ade80' : '#fbbf24';\n                ctx.fillText(ln, bx + 6, by + 10 + i * lineH);\n            });\n        }\n    },\n    onPerfMove(this: any, e: MouseEvent) {\n        const el = this.$refs.perfCanvas as HTMLCanvasElement | undefined;\n        if (!el || !this.perf.length) {\n            return;\n        }\n        const rect = el.getBoundingClientRect();\n        const cw = el.clientWidth;\n        // 与 drawPerf 保持一致的绘图区换算\n        const plotL = 36;\n        const plotR = cw - 44;\n        const stepX = Math.max(1, plotR - plotL) / 90;\n        const start = Math.max(0, this.perf.length - 90);\n        const idx = start + Math.round((e.clientX - rect.left - plotL) / stepX);\n        const clamped = Math.max(start, Math.min(this.perf.length - 1, idx));\n        if (clamped !== this.hoverIdx) {\n            this.hoverIdx = clamped;\n            this.drawPerf();\n        }\n    },\n    onPerfLeave(this: any) {\n        if (this.hoverIdx !== -1) {\n            this.hoverIdx = -1;\n            this.drawPerf();\n        }\n    },\n};\n"]} \ No newline at end of file diff --git a/extensions/YYKA运行时工作台/dist/panels/default/methods/pickers.js b/extensions/YYKA运行时工作台/dist/panels/default/methods/pickers.js new file mode 100644 index 0000000..7cd8e8d --- /dev/null +++ b/extensions/YYKA运行时工作台/dist/panels/default/methods/pickers.js @@ -0,0 +1,121 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +// @ts-ignore +const package_json_1 = __importDefault(require("../../../../package.json")); +/** 节点选择 / 资产选择弹层。 */ +exports.default = { + /** 打开节点选择弹层：mode='ref' 选择组件引用，mode='widget' 选择 Widget 对齐目标。 */ + openNodePicker(mode, compIdx, key, componentType) { + this.nodePicker = { + visible: true, + mode, + compIdx, + key, + componentType: componentType || 'cc.Node', + filter: '', + }; + }, + closeNodePicker() { + this.nodePicker.visible = false; + }, + /** 弹层选中运行时节点：ref 写组件引用，widget 写对齐目标。 */ + onNodePick(row) { + if (!this.inspector) { + return; + } + const comp = this.inspector.components[this.nodePicker.compIdx]; + if (!comp) { + this.nodePicker.visible = false; + return; + } + if (this.nodePicker.mode === 'ref') { + this.sendSet({ + id: this.selectedId, + comp: this.nodePicker.compIdx, + key: this.nodePicker.key, + value: { __refNode: row.id, componentType: this.nodePicker.componentType }, + }); + const prop = comp.props.find((p) => p.key === this.nodePicker.key); + if (prop && prop.v && typeof prop.v === 'object') { + prop.v = Object.assign(Object.assign({}, prop.v), { name: row.name }); + } + } + else { + this.sendSet({ id: this.selectedId, comp: this.nodePicker.compIdx, key: '__widget_target', value: row.id }); + if (comp.widget) { + comp.widget.targetName = row.name; + } + } + this.nodePicker.visible = false; + }, + /** 打开资产选择弹层：index>=0 时写回数组项（如 sharedMaterials[i]）。 */ + async openAssetPicker(compIdx, key, index, curType) { + this.assetPicker = { + visible: true, + compIdx, + key, + index, + filter: '', + type: curType || '', + types: [], + list: [], + loading: true, + }; + try { + const res = (await Editor.Message.request(package_json_1.default.name, 'query-command', { cmd: 'list-assets', timeout: 2500, payload: { type: curType || '' } })); + if (res && Array.isArray(res.assets)) { + this.assetPicker.list = res.assets; + this.assetPicker.types = res.types || []; + } + else { + this.logs.push('[资产] ' + String((res && res.error) || '获取资产列表失败')); + } + } + catch (err) { + this.logs.push(`[资产] ${String(err)}`); + } + finally { + this.assetPicker.loading = false; + } + }, + closeAssetPicker() { + this.assetPicker.visible = false; + }, + /** 弹层选中资产：按 uuid 写回资产引用（属性或数组项）。 */ + async onAssetPick(row) { + if (!this.inspector) { + return; + } + const ap = this.assetPicker; + const comp = this.inspector.components[ap.compIdx]; + if (!comp) { + this.closeAssetPicker(); + return; + } + this.sendSet({ + id: this.selectedId, + comp: ap.compIdx, + key: ap.key, + index: ap.index >= 0 ? ap.index : undefined, + value: { __refAsset: row.uuid }, + }); + // 本地乐观更新：写回后 sendSet 会回读刷新，这里仅即时反馈 + const prop = comp.props.find((p) => p.key === ap.key); + if (prop && prop.v && typeof prop.v === 'object') { + if (ap.index >= 0 && Array.isArray(prop.v)) { + const it = prop.v[ap.index]; + if (it && it.v && typeof it.v === 'object') { + it.v = Object.assign(Object.assign({}, it.v), { name: row.name, type: row.type, uuid: row.uuid }); + } + } + else if (prop.v && typeof prop.v === 'object') { + prop.v = Object.assign(Object.assign({}, prop.v), { name: row.name, type: row.type, uuid: row.uuid }); + } + } + this.closeAssetPicker(); + }, +}; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pickers.js","sourceRoot":"","sources":["../../../../source/panels/default/methods/pickers.ts"],"names":[],"mappings":"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","sourcesContent":["// @ts-ignore\nimport packageJSON from '../../../../package.json';\nimport type { TreeRow } from '../types';\n\n/** 节点选择 / 资产选择弹层。 */\nexport default {\n    /** 打开节点选择弹层：mode='ref' 选择组件引用，mode='widget' 选择 Widget 对齐目标。 */\n    openNodePicker(this: any, mode: 'ref' | 'widget', compIdx: number, key: string, componentType: string) {\n        this.nodePicker = {\n            visible: true,\n            mode,\n            compIdx,\n            key,\n            componentType: componentType || 'cc.Node',\n            filter: '',\n        };\n    },\n    closeNodePicker(this: any) {\n        this.nodePicker.visible = false;\n    },\n    /** 弹层选中运行时节点：ref 写组件引用，widget 写对齐目标。 */\n    onNodePick(this: any, row: TreeRow) {\n        if (!this.inspector) {\n            return;\n        }\n        const comp = this.inspector.components[this.nodePicker.compIdx];\n        if (!comp) {\n            this.nodePicker.visible = false;\n            return;\n        }\n        if (this.nodePicker.mode === 'ref') {\n            this.sendSet({\n                id: this.selectedId,\n                comp: this.nodePicker.compIdx,\n                key: this.nodePicker.key,\n                value: { __refNode: row.id, componentType: this.nodePicker.componentType },\n            });\n            const prop = comp.props.find((p: any) => p.key === this.nodePicker.key);\n            if (prop && prop.v && typeof prop.v === 'object') {\n                prop.v = { ...prop.v, name: row.name };\n            }\n        } else {\n            this.sendSet({ id: this.selectedId, comp: this.nodePicker.compIdx, key: '__widget_target', value: row.id });\n            if (comp.widget) {\n                comp.widget.targetName = row.name;\n            }\n        }\n        this.nodePicker.visible = false;\n    },\n    /** 打开资产选择弹层：index>=0 时写回数组项（如 sharedMaterials[i]）。 */\n    async openAssetPicker(this: any, compIdx: number, key: string, index: number, curType: string) {\n        this.assetPicker = {\n            visible: true,\n            compIdx,\n            key,\n            index,\n            filter: '',\n            type: curType || '',\n            types: [],\n            list: [],\n            loading: true,\n        };\n        try {\n            const res = (await Editor.Message.request(\n                packageJSON.name as any,\n                'query-command' as any,\n                { cmd: 'list-assets', timeout: 2500, payload: { type: curType || '' } } as any,\n            )) as any;\n            if (res && Array.isArray(res.assets)) {\n                this.assetPicker.list = res.assets;\n                this.assetPicker.types = res.types || [];\n            } else {\n                this.logs.push('[资产] ' + String((res && res.error) || '获取资产列表失败'));\n            }\n        } catch (err) {\n            this.logs.push(`[资产] ${String(err)}`);\n        } finally {\n            this.assetPicker.loading = false;\n        }\n    },\n    closeAssetPicker(this: any) {\n        this.assetPicker.visible = false;\n    },\n    /** 弹层选中资产：按 uuid 写回资产引用（属性或数组项）。 */\n    async onAssetPick(this: any, row: { name: string; uuid: string; type: string }) {\n        if (!this.inspector) {\n            return;\n        }\n        const ap = this.assetPicker;\n        const comp = this.inspector.components[ap.compIdx];\n        if (!comp) {\n            this.closeAssetPicker();\n            return;\n        }\n        this.sendSet({\n            id: this.selectedId,\n            comp: ap.compIdx,\n            key: ap.key,\n            index: ap.index >= 0 ? ap.index : undefined,\n            value: { __refAsset: row.uuid },\n        });\n        // 本地乐观更新：写回后 sendSet 会回读刷新，这里仅即时反馈\n        const prop = comp.props.find((p: any) => p.key === ap.key);\n        if (prop && prop.v && typeof prop.v === 'object') {\n            if (ap.index >= 0 && Array.isArray(prop.v)) {\n                const it = prop.v[ap.index];\n                if (it && it.v && typeof it.v === 'object') {\n                    it.v = { ...it.v, name: row.name, type: row.type, uuid: row.uuid };\n                }\n            } else if (prop.v && typeof prop.v === 'object') {\n                prop.v = { ...prop.v, name: row.name, type: row.type, uuid: row.uuid };\n            }\n        }\n        this.closeAssetPicker();\n    },\n};\n"]} \ No newline at end of file diff --git a/extensions/YYKA运行时工作台/dist/panels/default/methods/preview.js b/extensions/YYKA运行时工作台/dist/panels/default/methods/preview.js new file mode 100644 index 0000000..71eb3a1 --- /dev/null +++ b/extensions/YYKA运行时工作台/dist/panels/default/methods/preview.js @@ -0,0 +1,1658 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +// @ts-ignore +const package_json_1 = __importDefault(require("../../../../package.json")); +/** + * 预览：地址读取/刷新/连通性探测 + 无 iframe 的 DOM 渲染 + 左右分隔条拖拽。 + * + * 面板内直接渲染游戏（不用 iframe）的加载链路： + * 1. 按序加载引擎脚本（