logo

开发者热搜

Vibe Gaming 一人工作室实战：用 AI 写代码开发并上线一款微信小游戏（消除类完整示例）

作者：4042026.11.14 09:24浏览量：0

简介：本文面向想用 AI 编码助手独立做游戏、但没有游戏开发经验的创作者，讲清 Vibe Gaming 的真实工作流：从玩法描述到 HTML 原型验证、AI 生成核心代码、迁移微信小游戏、素材生成、调试排查到提审上线。文中给出一款消除类小游戏的完整核心逻辑代码、微信小游戏平台适配层写法、可直接复制的结构化 Prompt 模板，以及审核与备案的避坑清单。承担主要编码工作的是 [ERNIE 5.5 Flash Preview 在线体验](https://console.bce.baidu.com/qianfan/onlineTest/chat/ERNIE-5.5-Flash-Preview)，它支持 1M tokens 长上下文，适合一次性吞下整个项目代码库并做跨文件修改；想先验证效果，可直接把需求贴进在线体验页试一轮。

一、先回答最关心的三个问题

目标 ：用 AI 编码助手 + 微信小游戏平台，以”一人工作室”的形态，在 3–5 天的碎片化时间里，把一款小游戏从创意做到真正上线——不是 Demo，不是”能跑一下的原型”，而是通过微信审核、完成备案、能在微信里被搜到的正式产品。

常见难点 ：

  1. 玩法在脑子里很清楚，但不知道怎么拆成可执行的开发任务；
  2. AI 生成的代码在浏览器能跑，一迁到微信小游戏就白屏；
  3. 代码越改越乱，AI “改一处崩三处”，最后不敢让它继续动；

  4. 卡在提审环节：资质、备案、类目、隐私协议，任何一项缺失都会被驳回。

    解决思路 ：把开发驱动力从”技术实现”转移到”创意表达”，用 原生 Canvas 2D + 平台适配层 的极简技术栈降低 AI 的出错率，再用长上下文模型维持整个项目的一致性。承担编码的模型选用 ERNIE 5.5 Flash Preview——它是文心系列基础模型 ERNIE 5.5 Flash 的预览版本，重点优化了编程、智能体、知识工作与深度研究能力，支持 1M tokens 长上下文，可结合工具调用与 Agent 工作流完成多步骤任务。对 Vibe Gaming 来说，长上下文意味着你可以把整个 src/ 目录一次性交给它，让它做全局重构而不是局部打补丁。

二、Vibe Gaming 的本质：你更像”产品导演”，而不是”码农”

传统小游戏开发流程大致是这样：

  1. 设计文档 → 技术选型 → 搭建框架 → 写逻辑 → 调 bug → 美术资源 → 测试 → 上线
  2.    ↑↑                                                    ↑↑
  3. 需要专业知识                                        需要专业技能

Vibe Gaming 的流程则是：

  1. 描述玩法 → AI 生成代码 → 试玩感受 → 用自然语言调整 → 循环迭代 → 上线
  2.    ↑                        ↑
  3. 只需要创意                只需要审美

关键区别在于： 开发者不再需要”知道怎么做”，只需要”知道想要什么” 。已经有人做出了三消 + 2048 的混合玩法、经典平台跳跃的复刻、讽刺打工人的像素风模拟经营——AI 代码贡献率普遍在 90% 以上。

一个典型的时间线（碎片化时间累计）：

阶段 耗时 你的角色 AI 的角色
创意构思 1h 定义核心循环、数值手感 提供玩法参考、命名、文案
HTML 原理验证 2h 试玩、判断”好不好玩” 生成单文件可运行原型
AI 生成核心代码 1天 拆模块、验收 写状态机、渲染、碰撞、存档
迁移微信小游戏 1天 提供平台文档、跑真机 写适配层、改 API 调用
素材生成 半天 定风格、挑图 生成代码/提示词，配合绘图工具出图
调试优化 1天 复现问题、描述现象 定位、修复、性能优化
提交审核 等待约 1 个月 备齐资质 生成隐私协议、文案、合规自查表
正式上线 — 看数据、迭代 分析留存、生成版本计划

三、技术选型：为什么坚持原生 Canvas 2D，而不是 Cocos / Unity

这是整个工作流能不能跑通的第一个关键决策。

维度 原生 JS + Canvas 2D Cocos Creator / Unity
AI 友好度 代码结构扁平，AI 能直接理解和修改 项目结构复杂（场景文件、预制体、组件序列化），AI 接入困难
调试效率 浏览器 F5 刷新即见效果 需编译、预览、清缓存
上下文占用 单文件几百行，轻松塞进上下文 一次改动牵动多个资源文件
迁移小游戏 写一个适配层即可 需引擎自带的小游戏构建管线
适合规模 单局 3–5 分钟的超休闲玩法 中大型、重度玩法

结论很直接： Vibe Gaming 阶段，AI 的”可修改性”比引擎的”功能完备性”更重要 。你做的是超休闲小游戏，不是开放世界。

一人工作室的最小工具链

  • 代码与调试 ：VS Code + 浏览器 DevTools
  • 原型验证 ：单个 index.html，双击即开
  • 小游戏迁移 ：微信开发者工具（小游戏项目模板）
  • 编码主力 ：ERNIE 5.5 Flash Preview（长上下文 + 代码能力）
  • 美术素材 ：AI 绘图工具或平台化创作服务，例如百度智能云千帆提供的 AI 作画 API，基于文心大模型做文生图，可按需调用生成不限定风格的图像；如果不想写接入代码，也可以用一念智能创作平台这类一站式工具，首页集成了 AI 海报、AI 作画、AI 视频等能力，并带素材库管理生成结果
  • 发布物料 ：商店截图、宣传短视频（可用 AI 视频生成能力从文案直接产出成片）

四、Step 1：把”感觉”翻译成可执行的玩法定义

AI 最大的失败来源不是能力不够，而是你给的需求太模糊。”做个好玩的三消”这种输入，只会得到一个能跑但手感糟糕的 demo。

一份合格的玩法定义至少包含六项：

  1. 核心循环 ：玩家 10 秒内在重复做什么？
  2. 操作方式 ：点击 / 滑动 / 长按，判定阈值多少像素？
  3. 胜负条件 ：限步数、限时间，还是无尽模式？
  4. 数值骨架 ：棋盘尺寸、元素种类、消除得分、连击倍率
  5. 反馈设计 ：消除特效、音效、震屏、飘分
  6. 视觉风格 ：像素 / 扁平 / 手绘，主色调，参考关键词

可直接复制的 Prompt 模板（玩法定义 → 技术方案）

  1. 【任务目标】
  2. 你要作为一名资深微信小游戏客户端工程师，把下面这份玩法描述转成一份可执行的
  3. 技术实现方案，并输出第一步的可运行代码。
  5. 【输入信息】
  6. - 游戏类型：三消 + 2048 混合玩法
  7. - 平台：微信小游戏（最终），先用纯 HTML + Canvas 2D 做原理验证
  8. - 棋盘：8 列 × 8 行，元素种类 5 种
  9. - 操作：手指滑动交换相邻元素，滑动距离阈值 24px
  10. - 核心循环：交换 → 三连及以上消除 → 上方元素下落 → 顶部补充新元素 → 连锁计分
  11. - 混合规则：每次消除后，被消除位置有 20% 概率生成一个数字方块（2/4），
  12.   数字方块不可被普通消除，两个相同数字方块相邻滑动可合并翻倍
  13. - 计分：基础消除每个 10 分，连锁层级 n 额外乘 n 倍
  14. - 结束条件：30 步用尽，或无可交换组合
  15. - 视觉：扁平像素风，深色背景 #1a1a2e，元素为高饱和纯色圆角方块
  17. 【执行要求】
  18. 1. 先输出一份不超过 400 字的技术方案，说明模块划分、数据结构、主循环设计；
  19. 2. 再输出完整代码，必须是单个 index.html 文件，内联 CSS 和 JS，双击即可运行；
  20. 3. 代码要求：不依赖任何第三方库；用 requestAnimationFrame 驱动；
  21.    把「游戏逻辑」和「渲染 / 输入」分成两个明确的对象，逻辑层不得直接调用 canvas API；
  22. 4. 关键函数写中文注释，说明为什么这样写，而不是复述代码；
  23. 5. 不要输出任何解释性文字之外的客套话，不要省略任何函数实现。
  25. 【预期输出】
  26. 1) 技术方案（模块划分 + 数据结构定义）
  27. 2) 完整 index.html 代码块
  28. 3) 一份「已知未实现项」清单，列出你为了控制篇幅而简化的地方

最后那条”已知未实现项”很关键。它能把 AI 的隐性妥协暴露出来，避免你以为功能做完了，实际少了一半。

五、Step 2：HTML 原理验证——先证明”好玩”，再谈”能上线”

这一步的唯一目的是 验证手感 ，不要考虑任何平台相关的东西。

原型阶段就要刻意做一件事： 把逻辑层和平台层分开 。这是后面迁移成本能压到一天以内的根本原因。

  1. // core.js —— 纯逻辑，不碰任何渲染和平台 API
  2. export const ROWS = 8, COLS = 8, TYPES = 5;
  4. export function createBoard() {
  5.   const board = [];
  6.   for (let r = 0; r < ROWS; r++) {
  7.     board[r] = [];
  8.     for (let c = 0; c < COLS; c++) {
  9.       let t;
  10.       // 发牌时避免开局自带三连
  11.       do {
  12.         t = Math.floor(Math.random() * TYPES);
  13.       } while (
  14.         (c >= 2 && board[r][c - 1] === t && board[r][c - 2] === t) ||
  15.         (r >= 2 && board[r - 1][c] === t && board[r - 2][c] === t)
  16.       );
  17.       board[r][c] = { type: t, num: 0 };
  18.     }
  19.   }
  20.   return board;
  21. }
  23. // 找出所有三连及以上的坐标，返回 Set<"r,c">
  24. export function findMatches(board) {
  25.   const hit = new Set();
  27.   for (let r = 0; r < ROWS; r++) {
  28.     let run = 1;
  29.     for (let c = 1; c <= COLS; c++) {
  30.       const same = c < COLS &&
  31.         board[r][c].num === 0 && board[r][c].num === board[r][c - 1].num &&
  32.         board[r][c].type === board[r][c - 1].type;
  33.       if (same) {
  34.         run++;
  35.       } else {
  36.         if (run >= 3) for (let k = c - run; k < c; k++) hit.add(`${r},${k}`);
  37.         run = 1;
  38.       }
  39.     }
  40.   }
  42.   for (let c = 0; c < COLS; c++) {
  43.     let run = 1;
  44.     for (let r = 1; r <= ROWS; r++) {
  45.       const same = r < ROWS &&
  46.         board[r][c].num === 0 && board[r][c].num === board[r - 1][c].num &&
  47.         board[r][c].type === board[r - 1][c].type;
  48.       if (same) {
  49.         run++;
  50.       } else {
  51.         if (run >= 3) for (let k = r - run; k < r; k++) hit.add(`${k},${c}`);
  52.         run = 1;
  53.       }
  54.     }
  55.   }
  56.   return hit;
  57. }
  59. export function isAdjacent(a, b) {
  60.   return Math.abs(a.r - b.r) + Math.abs(a.c - b.c) === 1;
  61. }
  63. export function swap(board, a, b) {
  64.   const t = board[a.r][a.c];
  65.   board[a.r][a.c] = board[b.r][b.c];
  66.   board[b.r][b.c] = t;
  67. }
  69. // 下落 + 补充，返回本次的连锁层级
  70. export function collapse(board) {
  71.   for (let c = 0; c < COLS; c++) {
  72.     let write = ROWS - 1;
  73.     for (let r = ROWS - 1; r >= 0; r--) {
  74.       if (board[r][c]) {
  75.         board[write][c] = board[r][c];
  76.         if (write !== r) board[r][c] = null;
  77.         write--;
  78.       }
  79.     }
  80.     for (let r = write; r >= 0; r--) {
  81.       board[r][c] = { type: Math.floor(Math.random() * TYPES), num: 0 };
  82.     }
  83.   }
  84. }
  86. export function hasValidMove(board) {
  87.   for (let r = 0; r < ROWS; r++) {
  88.     for (let c = 0; c < COLS; c++) {
  89.       if (c + 1 < COLS) {
  90.         swap(board, { r, c }, { r, c: c + 1 });
  91.         const ok = findMatches(board).size > 0;
  92.         swap(board, { r, c }, { r, c: c + 1 });
  93.         if (ok) return true;
  94.       }
  95.       if (r + 1 < ROWS) {
  96.         swap(board, { r, c }, { r: r + 1, c });
  97.         const ok = findMatches(board).size > 0;
  98.         swap(board, { r, c }, { r: r + 1, c });
  99.         if (ok) return true;
  100.       }
  101.     }
  102.   }
  103.   return false;
  104. }

注意 core.js 里 没有出现任何 canvas、ctx、document 。这一条纪律，让同一份逻辑文件可以原封不动地跑在浏览器和微信小游戏里。

六、Step 3：让 AI 生成完整代码，而不是零散片段

这一步最容易踩的坑是”挤牙膏式提问”：一次要一个函数，最后拿到一堆互相不兼容的碎片。

正确做法是 一次性给足上下文，要求完整文件输出 。ERNIE 5.5 Flash Preview 的 1M tokens 长上下文在这里价值明显——你可以把 core.js、原型 HTML、以及微信小游戏的适配文档一起贴进去，让它做跨文件的一致性修改，而不是只看到一个函数就瞎猜接口。

迭代指令示例（自然语言调整）

  1. 现在棋盘是 8×8，试玩后感觉单局太长。请做三处调整，其余逻辑保持不变：
  2. 1. 棋盘改为 7 列 × 9 行（竖向更长，更适合手机竖屏单手操作）；
  3. 2. 步数从 30 步改为 22 步；
  4. 3. 连锁层级 ≥3 时增加一次全屏轻微震屏反馈，幅度随层级递增，上限 6px。
  6. 要求：
  7. - 只输出被修改的函数完整代码，并标注文件路径；
  8. - 修改前先列出你会触碰的所有函数，等我确认后再输出代码；
  9. - 如果某项调整会破坏 hasValidMove 的判定逻辑，先告诉我风险，不要擅自改判定规则。

“先列出会触碰的函数，等我确认”——这个约束能显著降低 AI 顺手重构无关代码的概率。

七、Step 4：迁移到微信小游戏（最容易白屏的一步）

微信小游戏 没有 DOM 和 BOM 。document.getElementById、localStorage、<img> 标签全部不可用。这就是为什么原型阶段必须做逻辑与渲染的分离。

目录结构

  1. game/
  2. ├── game.js              // 入口
  3. ├── game.json            // 全局配置
  4. ├── project.config.json  // 项目配置
  5. ├── js/
  6. │   ├── core.js          // 从原型直接搬过来，零修改
  7. │   ├── adapter.js       // 平台适配层（关键）
  8. │   ├── render.js        // 渲染
  9. │   └── main.js          // 主循环与状态机
  10. └── images/              // 图标、音效

平台适配层

  1. // js/adapter.js —— 所有平台差异集中在这里，其他文件只调用这一层
  2. const sysInfo = wx.getWindowInfo
  3.   ? wx.getWindowInfo()
  4.   : wx.getSystemInfoSync();
  6. const canvas = wx.createCanvas();
  7. canvas.width = sysInfo.windowWidth * sysInfo.pixelRatio;
  8. canvas.height = sysInfo.windowHeight * sysInfo.pixelRatio;
  10. const ctx = canvas.getContext('2d');
  11. ctx.scale(sysInfo.pixelRatio, sysInfo.pixelRatio);
  13. export const platform = {
  14.   canvas,
  15.   ctx,
  16.   view: {
  17.     width: sysInfo.windowWidth,
  18.     height: sysInfo.windowHeight,
  19.     dpr: sysInfo.pixelRatio,
  20.   },
  22.   // 存储：小游戏没有 localStorage
  23.   setItem: (k, v) => wx.setStorageSync(k, v),
  24.   getItem: (k) => wx.getStorageSync(k),
  26.   // 触摸：小游戏没有 addEventListener
  27.   onTouchStart: (fn) => wx.onTouchStart((e) => fn(e.touches)),
  28.   onTouchMove: (fn) => wx.onTouchMove((e) => fn(e.touches)),
  29.   onTouchEnd: (fn) => wx.onTouchEnd((e) => fn(e.changedTouches)),
  31.   // 震动反馈
  32.   vibrate: (type) => wx.vibrateShort({ type: type || 'light' }),
  34.   // 图片：不能用 new Image()，要用 createImage()
  35.   createImage: () => wx.createImage(),
  36. };
  38. export default platform;

入口与主循环

  1. // game.js
  2. import { platform } from './js/adapter.js';
  3. import { createBoard, findMatches, swap, isAdjacent, collapse, hasValidMove } from './js/core.js';
  4. import { render } from './js/render.js';
  6. const board = createBoard();
  7. let steps = 22;
  8. let score = 0;
  9. let first = null;
  11. function resolveChain() {
  12.   let chain = 0;
  13.   let hit = findMatches(board);
  14.   while (hit.size > 0) {
  15.     chain++;
  16.     score += hit.size * 10 * chain;
  17.     hit.forEach((key) => {
  18.       const [r, c] = key.split(',').map(Number);
  19.       board[r][c] = null;
  20.     });
  21.     collapse(board);
  22.     hit = findMatches(board);
  23.   }
  24.   if (chain >= 3) platform.vibrate('heavy');
  25.   if (!hasValidMove(board)) {
  26.     // 死局重排，而不是直接结束——超休闲游戏的关键留存设计
  27.     shuffleBoard(board);
  28.   }
  29. }
  31. function onTouchEnd(p) {
  32.   const cell = pickCell(p);
  33.   if (!cell) return;
  34.   if (!first) {
  35.     first = cell;
  36.     return;
  37.   }
  38.   if (isAdjacent(first, cell)) {
  39.     swap(board, first, cell);
  40.     if (findMatches(board).size > 0) {
  41.       steps--;
  42.       resolveChain();
  43.     } else {
  44.       swap(board, first, cell); // 无效交换回滚
  45.     }
  46.     first = null;
  47.   } else {
  48.     first = cell;
  49.   }
  50. }
  52. let last = Date.now();
  53. function loop() {
  54.   const now = Date.now();
  55.   const dt = now - last;
  56.   last = now;
  57.   update(dt);
  58.   render(platform.ctx, board, { score, steps });
  59.   requestAnimationFrame(loop);
  60. }
  62. platform.onTouchEnd(onTouchEnd);
  63. loop();

迁移检查清单

检查项 浏览器写法 小游戏写法
画布获取 document.querySelector('canvas') wx.createCanvas()
屏幕信息 window.innerWidth wx.getWindowInfo()
本地存储 localStorage wx.setStorageSync
图片对象 new Image() wx.createImage()
触摸事件 addEventListener wx.onTouchStart 等
震动 navigator.vibrate wx.vibrateShort
音频 new Audio() wx.createInnerAudioContext()
分包加载 无此概念 subpackages 按需加载

八、Step 5：素材生成——美术不一定要会画画

超休闲小游戏的美术门槛其实很低：纯色圆角方块 + 一套统一风格的图标 + 一个能听的音效，就够了。

两条路径：

  • 走 API ：调用文生图服务批量产出图标和背景，适合能写一点接入代码的开发者；
  • 走平台 ：用带素材库的一站式创作平台，生成结果直接进”我的草稿/作品”，还能二次编辑，省去文件管理。

给 AI 绘图写提示词时，务必固定三件事： 风格锚点、配色表、输出尺寸 。否则 20 个图标会有 20 种画风。

  1. 像素风游戏图标，单个物体居中，纯色背景 #1a1a2e，
  2. 高饱和配色（#ff6b6b / #feca57 / #48dbfb / #1dd1a1 / #a55eea），
  3. 16-bit 复古质感，硬边描边，无渐变，无文字，正方形构图，128×128

九、Step 6：调试与问题排查

AI 写的代码出问题时，最忌讳的描述是”报错了，帮我修一下”。要给出 现象 + 复现步骤 + 已排除的可能 。

现象 高概率原因 排查方式
真机白屏，开发者工具正常 用了 DOM API 或 new Image() 全局搜索 document.、window.、localStorage
触摸无响应 坐标未换算 dpr 打印 e.touches 与逻辑坐标对比
消除后棋盘错乱 collapse 里 null 未正确处理 单独跑 100 次随机棋盘的 collapse 单测
帧率随时间下降 每帧 new 对象 / 未复用 ctx 用开发者工具 Performance 面板看 GC 频率
死局无法继续 hasValidMove 未覆盖数字方块规则 构造只含数字方块的极端棋盘测试
审核驳回 类目资质、隐私协议、IP 侵权 见下一节

一个实用技巧：让 AI 帮你写 逻辑层单元测试 。逻辑层不依赖平台 API，天然可测，把 core.js 跑在 Node 里验证，能挡掉大部分迁移后的诡异 bug。

  1. 请为 core.js 编写一组可在 Node 环境直接运行的测试，不引入任何测试框架，
  2. 用 assert 模块即可。必须覆盖：
  3. 1. createBoard 生成的棋盘不存在开局三连；
  4. 2. findMatches 能识别横向 4 连、纵向 5 连、以及 L 形交叉（交叉点只计一次）；
  5. 3. collapse 后棋盘无 null，且列内元素相对顺序不变；
  6. 4. hasValidMove 在构造的死局棋盘上返回 false；
  7. 5. 随机跑 500 次「随机交换 → 消除 → 下落」循环，棋盘始终不越界、不出现 undefined。
  8. 输出单个 test.js 文件，末尾打印通过用例数。

十、Step 7：提审与上线——预留一个月，别踩这些坑

技术做完只算一半。真正让”一人工作室”卡住的是合规环节。

  • 资质与备案 ：小游戏需按微信公众平台最新要求提交主体资质、游戏版号或备案信息、软件著作权等材料，具体清单和流程以官方文档为准，建议开发第一天就去查，不要等到提审前一周。
  • IP 风险 ：原文提到有人”复刻经典平台跳跃游戏”——玩法机制通常不受保护，但 角色形象、关卡地图、音乐、名称 受保护。像素风”看起来像”某款知名游戏，同样可能被驳回或投诉。做致敬，不要做复刻。
  • 实名与防沉迷 ：接入平台提供的实名认证与未成年人保护能力，不要自行绕过。
  • 隐私协议 ：只要收集任何用户信息（包括设备信息、存储），就必须有隐私协议并在后台配置。
  • 诱导分享 ：设置”分享得复活””分享解锁关卡”是高频驳回原因。
  • 虚拟支付 ：iOS 端小游戏虚拟支付有严格限制，涉及内购务必提前确认资质。

等待审核的一个月里，别闲着：让 AI 帮你产出商店文案、 screenshots 说明、以及一份数据埋点方案，上线即可看留存。

十一、把 AI 用成”团队”，而不是”工具”

一人工作室真正的杠杆，在于把 AI 当 teammate 用。几个已经验证有效的做法：

  1. 角色化提问 ：让它同时扮演”客户端工程师 + 数值策划 + 审核顾问”，一次给出三个视角的意见，你再做决策。
  2. 先方案后代码 ：任何超过 50 行的改动，都要求先输出方案和风险点，确认后再写代码。
  3. 维护一份 DESIGN.md ：把玩法定义、数值表、已知问题写在项目根目录，每次对话开头让它先读这个文件。这是长上下文最划算的用法。
  4. 每次只改一件事 ：改完立刻试玩，确认手感，再进入下一项。批量修改是崩盘的主要来源。
  5. 保留”能跑的那一版” ：用 git 或至少手动备份目录，AI 改崩了能一秒回退。

十二、关键步骤回顾

  1. 定义玩法 ：核心循环、操作阈值、数值骨架、反馈设计、视觉风格，六项写全；
  2. 选技术栈 ：原生 JS + Canvas 2D，逻辑层与平台层严格分离；
  3. 原型验证 ：单文件 HTML，先证明”好玩”；
  4. AI 生成 ：一次性给足上下文，要求完整文件 + 已知未实现项清单；
  5. 迁移小游戏 ：所有平台差异收进 adapter.js，按检查清单逐项替换 API；
  6. 素材与调试 ：固定风格锚点批量出图，逻辑层写单元测试；
  7. 合规提审 ：资质、备案、隐私协议、IP 风险，开发第一天就开始准备。

想动手的话，建议从一个更小的目标开始：先只做”能交换、能消除、能计分”三件事，跑通浏览器到微信小游戏的完整链路，再往上加混合玩法。可以直接把你的玩法描述贴进 ERNIE 5.5 Flash Preview 在线体验，用第四节的 Prompt 模板试一轮，看看它给出的技术方案是否符合你的预期。如果打算把它接进自己的工具链、做批量代码生成或 Agent 化的自动迭代流程，可以前往 百度智能云千帆模型详情页 查看模型能力说明与接入方式。

需要说明的是，本文中的代码示例需在本地 Node 环境或微信开发者工具中实际运行验证，模型本身输出的是文本形式的代码与方案，渲染、真机调试、出图与视频生成等环节仍需配合相应工具和执行环境完成。

相关文章推荐

发表评论

最热文章

关于作者

  • 被阅读数
  • 被赞数
  • 被收藏数
活动
咨询