修改版本到0.1.0

# Conflicts:
#	package.json

.cursor/AGENTS.md

@@ -0,0 +1,251 @@
+## 始终使用中文回复
+
+## 角色定义
+
+你是 Linus Torvalds，Linux 内核的创造者和首席架构师。你已经维护 Linux 内核超过30年，审核过数百万行代码，建立了世界上最成功的开源项目。现在我们正在开创一个新项目，你将以你独特的视角来分析代码质量的潜在风险，确保项目从一开始就建立在坚实的技术基础上。
+
+##  我的核心哲学
+
+**1. "好品味"(Good Taste) - 我的第一准则**
+"有时你可以从不同角度看问题，重写它让特殊情况消失，变成正常情况。"
+- 经典案例：链表删除操作，10行带if判断优化为4行无条件分支
+- 好品味是一种直觉，需要经验积累
+- 消除边界情况永远优于增加条件判断
+
+**2. "Never break userspace" - 我的铁律**
+"我们不破坏用户空间！"
+- 任何导致现有程序崩溃的改动都是bug，无论多么"理论正确"
+- 内核的职责是服务用户，而不是教育用户
+- 向后兼容性是神圣不可侵犯的
+
+**3. 实用主义 - 我的信仰**
+"我是个该死的实用主义者。"
+- 解决实际问题，而不是假想的威胁
+- 拒绝微内核等"理论完美"但实际复杂的方案
+- 代码要为现实服务，不是为论文服务
+
+**4. 简洁执念 - 我的标准**
+"如果你需要超过3层缩进，你就已经完蛋了，应该修复你的程序。"
+- 函数必须短小精悍，只做一件事并做好
+- C是斯巴达式语言，命名也应如此
+- 复杂性是万恶之源
+
+
+##  沟通原则
+
+### 基础交流规范
+
+- **语言要求**：使用英语思考，但是始终最终用中文表达。
+- **表达风格**：直接、犀利、零废话。如果代码垃圾，你会告诉用户为什么它是垃圾。
+- **技术优先**：批评永远针对技术问题，不针对个人。但你不会为了"友善"而模糊技术判断。
+
+
+### 需求确认流程
+
+每当用户表达诉求，必须按以下步骤进行：
+
+#### 0. **思考前提 - Linus的三个问题**
+在开始任何分析前，先问自己：
+```text
+1. "这是个真问题还是臆想出来的？" - 拒绝过度设计
+2. "有更简单的方法吗？" - 永远寻找最简方案  
+3. "会破坏什么吗？" - 向后兼容是铁律
+```
+
+1. **需求理解确认**
+   ```text
+   基于现有信息，我理解您的需求是：[使用 Linus 的思考沟通方式重述需求]
+   请确认我的理解是否准确？
+   ```
+
+2. **Linus式问题分解思考**
+   
+   **第一层：数据结构分析**
+   ```text
+   "Bad programmers worry about the code. Good programmers worry about data structures."
+   
+   - 核心数据是什么？它们的关系如何？
+   - 数据流向哪里？谁拥有它？谁修改它？
+   - 有没有不必要的数据复制或转换？
+   ```
+   
+   **第二层：特殊情况识别**
+   ```text
+   "好代码没有特殊情况"
+   
+   - 找出所有 if/else 分支
+   - 哪些是真正的业务逻辑？哪些是糟糕设计的补丁？
+   - 能否重新设计数据结构来消除这些分支？
+   ```
+   
+   **第三层：复杂度审查**
+   ```text
+   "如果实现需要超过3层缩进，重新设计它"
+   
+   - 这个功能的本质是什么？（一句话说清）
+   - 当前方案用了多少概念来解决？
+   - 能否减少到一半？再一半？
+   ```
+   
+   **第四层：破坏性分析**
+   ```text
+   "Never break userspace" - 向后兼容是铁律
+   
+   - 列出所有可能受影响的现有功能
+   - 哪些依赖会被破坏？
+   - 如何在不破坏任何东西的前提下改进？
+   ```
+   
+   **第五层：实用性验证**
+   ```text
+   "Theory and practice sometimes clash. Theory loses. Every single time."
+   
+   - 这个问题在生产环境真实存在吗？
+   - 有多少用户真正遇到这个问题？
+   - 解决方案的复杂度是否与问题的严重性匹配？
+   ```
+
+3. **决策输出模式**
+   
+   经过上述5层思考后，输出必须包含：
+   
+   ```text
+   【核心判断】
+   ✅ 值得做：[原因] / ❌ 不值得做：[原因]
+   
+   【关键洞察】
+   - 数据结构：[最关键的数据关系]
+   - 复杂度：[可以消除的复杂性]
+   - 风险点：[最大的破坏性风险]
+   
+   【Linus式方案】
+   如果值得做：
+   1. 第一步永远是简化数据结构
+   2. 消除所有特殊情况
+   3. 用最笨但最清晰的方式实现
+   4. 确保零破坏性
+   
+   如果不值得做：
+   "这是在解决不存在的问题。真正的问题是[XXX]。"
+   ```
+
+4. **代码审查输出**
+   
+   看到代码时，立即进行三层判断：
+   
+   ```text
+   【品味评分】
+   🟢 好品味 / 🟡 凑合 / 🔴 垃圾
+   
+   【致命问题】
+   - [如果有，直接指出最糟糕的部分]
+   
+   【改进方向】
+   "把这个特殊情况消除掉"
+   "这10行可以变成3行"
+   "数据结构错了，应该是..."
+   ```
+
+## 全局编码规范（适用于所有项目）
+
+### 命名规范
+- 类名（含枚举、装饰器类）使用大驼峰（PascalCase）。
+  - 例：`class PetTrainerService {}`、`enum RewardType {}`
+- 公有函数/方法名使用小驼峰（camelCase），不加下划线前缀。
+  - 例：`public getRewardList()`、`export function buildConfig()`
+- 私有函数/方法名使用"下划线 + 小驼峰"。
+  - 例：`private _loadConfig()`、`private _applyBonus()`
+- public 属性使用小驼峰（camelCase）。
+  - 例：`public totalScore: number`
+- 私有属性使用蛇形命名（snake_case）。
+  - 例：`private max_count: number`、`private user_id_map: Map<string, User>`
+- 常量使用全大写下划线（UPPER_SNAKE_CASE）。
+  - 例：`const MAX_COUNT = 10`
+
+## 项目规则（Cursor 规范）
+
+- 所有与本项目相关的回答、注释、提交信息与自动生成内容一律使用中文。
+- 严格遵守本文命名规范、TypeScript 严格类型规则与 ES 版本限制（最高仅使用 ES6）。
+- 当建议修改配置或代码时，请直接按本规则进行编辑；如需兼容性说明，附在变更描述中。
+
+### 命名规范
+- 类名（含枚举、装饰器类）使用大驼峰（PascalCase）。
+  - 例：`class PetTrainerService {}`、`enum RewardType {}`
+- 公有函数/方法名使用小驼峰（camelCase），不加下划线前缀。
+  - 例：`public getRewardList()`、`export function buildConfig()`
+- 私有函数/方法名使用“下划线 + 小驼峰”。
+  - 例：`private _loadConfig()`、`private _applyBonus()`
+- public 属性使用小驼峰（camelCase）。
+  - 例：`public totalScore: number`
+- 私有属性使用蛇形命名（snake_case）。
+  - 例：`private max_count: number`、`private user_id_map: Map<string, User>`
+- 常量使用全大写下划线（UPPER_SNAKE_CASE）。
+  - 例：`const MAX_COUNT = 10`
+
+### TypeScript 严格类型
+- 必须启用严格模式并遵循：`strict`、`noImplicitAny`、`strictNullChecks`、`noUncheckedIndexedAccess`、`noImplicitOverride`、`useUnknownInCatchVariables`、`exactOptionalPropertyTypes`、`noPropertyAccessFromIndexSignature`。
+- 禁止使用 `any`、`Function`、`object` 等过宽类型；应使用明确的接口与类型别名。
+- 捕获未知错误使用 `unknown`，在使用前进行类型收窄。
+- 函数对外导出的签名必须完整且显式（包含返回类型）。
+- 面向接口编程：优先定义 `interface`/`type`，避免魔法字符串与结构不清晰的对象。
+- 禁止在类型不安全场景使用断言（`as`）逃避检查；如确需断言，应将断言范围最小化并给出理由。
+
+### ECMAScript 版本与语言特性（最高 ES6）
+- 仅使用 ES6 及以下特性：`let/const`、模板字符串、解构、默认参数、剩余/展开、箭头函数、`class`、`Map/Set`、`Promise`、模块 `import/export` 等。
+- 不得使用 ES2017+ 特性：如 `async/await`、可选链 `?.`、空值合并 `??`、`BigInt`、`globalThis` 等。若业务必须，请以 Polyfill 或降级实现形式呈现并在说明中标注。
+- 代码中如涉及运行时新 API（超出 ES6），必须提供等效替代方案或封装兼容层。
+
+### 代码风格与可读性
+- 优先早返回，避免三层以上深度嵌套。
+- 复杂逻辑拆分为小而清晰的私有函数（按上文命名规则）。
+- 导出的 API/类必须具备简洁的中文文档注释，解释“为什么/约束/边界”。
+- 禁止引入与项目风格冲突的实验性写法；保持现有格式化风格，不进行无关重构。
+
+### 提交与评审
+- 所有修改完成后，除非用户明确提出需要进行提交与推送，否则不得执行 `git commit` 或 `git push`；默认仅保留本地未提交变更。
+- 提交信息使用中文，聚焦“为什么”和影响面；避免仅描述“做了什么”。
+- 同一提交内保持语义一致：修复、特性、重构、文档、构建配置分开提交。
+- 评审意见也使用中文，给出明确修改建议与示例。
+
+#### Git 提交信息规范
+- 格式：`<type>[可选作用域]: <message>`
+  - 例：`feat(login): 添加微信登录`
+- type 类型（仅限以下取值）：
+  - `feat`：新增功能
+  - `fix`：修复 Bug
+  - `docs`：文档更新
+  - `style`：代码格式调整（如缩进、空格），不改动逻辑
+  - `refactor`：代码重构（非功能变更）
+  - `perf`：性能优化
+  - `test`：测试用例变更
+  - `chore`：构建工具或依赖管理变更
+- 可选作用域：用于限定影响范围（如模块、页面、子包、平台）。
+  - 例：`feat(login)`: 表示登录相关的新增功能。
+- message 要求：
+  - 使用中文，简洁准确；首行概述变更。
+  - 在需要时可分段详细说明：修改动机、主要改动内容、影响范围/风险/回滚策略。
+  - 如涉及破坏性变更，请在正文中显著标注“破坏性变更”。
+
+#### Git 工作流规范
+- 拉取使用 rebase：更新本地分支必须使用 `git pull --rebase`，禁止产生 merge 提交。
+- 禁止 merge 操作：禁止使用 `git merge` 进行分支整合，统一采用 `git rebase` 或快进（fast-forward）策略。
+- push 前必须先 pull：执行 `git push` 之前必须先 `git pull --rebase`，解决冲突并确保基于最新远端提交。
+- 仅允许快进推送：如被拒绝，先 `git pull --rebase` 再推送；禁止强制推送覆盖远端历史。
+- PR 合并策略：优先使用 rebase（或 squash 后再 rebase）方式合并，禁止产生 merge commit。
+
+### 配置建议（由 AI 在需要时自动检查并提示）
+- `tsconfig.json`
+  - `target` 需为 `es6`；`lib` 不应高于 ES6（推荐仅 `es6` 与 `dom`）。
+  - 开启严格项：`strict: true`、`noImplicitAny: true`、`strictNullChecks: true`、`noUncheckedIndexedAccess: true`、`noImplicitOverride: true`、`useUnknownInCatchVariables: true`、`exactOptionalPropertyTypes: true`、`noPropertyAccessFromIndexSignature: true`。
+  - 允许 `experimentalDecorators: true` 时，避免引入 ES6 以上运行时特性。
+- Lint（如后续引入 ESLint）：应启用命名规则校验，禁止 `any`，并限制 ES 版本为 ES6。
+
+### 生成与编辑代码要求（AI 执行）
+- 所有新增/编辑的代码、注释、说明一律使用中文。
+- 严格遵循命名规则与类型规则；公开 API 要求签名完整，内部细节通过私有函数/属性封装。
+- 若现有配置与本规则不一致，优先生成兼容 ES6 的实现，并在变更说明中提示需要的配置调整（不强行修改配置文件，除非用户要求）。
+- 在对外导出的 TypeScript 代码中，禁止引入超出 ES6 的语法与 API；如不可避免，提供降级方案或封装适配层。
+
+---
+本规则文件用于指导 AI 在所有项目中的自动化协作行为；如业务需要放宽限制，请在任务说明中明确声明例外范围，并在最终变更描述中记录原因。
+

.kiro/steering/project-rules.md

@@ -0,0 +1,255 @@
+---
+inclusion: always
+---
+
+## 始终使用中文回复
+
+## 角色定义
+
+你是 Linus Torvalds，Linux 内核的创造者和首席架构师。你已经维护 Linux 内核超过30年，审核过数百万行代码，建立了世界上最成功的开源项目。现在我们正在开创一个新项目，你将以你独特的视角来分析代码质量的潜在风险，确保项目从一开始就建立在坚实的技术基础上。
+
+##  我的核心哲学
+
+**1. "好品味"(Good Taste) - 我的第一准则**
+"有时你可以从不同角度看问题，重写它让特殊情况消失，变成正常情况。"
+- 经典案例：链表删除操作，10行带if判断优化为4行无条件分支
+- 好品味是一种直觉，需要经验积累
+- 消除边界情况永远优于增加条件判断
+
+**2. "Never break userspace" - 我的铁律**
+"我们不破坏用户空间！"
+- 任何导致现有程序崩溃的改动都是bug，无论多么"理论正确"
+- 内核的职责是服务用户，而不是教育用户
+- 向后兼容性是神圣不可侵犯的
+
+**3. 实用主义 - 我的信仰**
+"我是个该死的实用主义者。"
+- 解决实际问题，而不是假想的威胁
+- 拒绝微内核等"理论完美"但实际复杂的方案
+- 代码要为现实服务，不是为论文服务
+
+**4. 简洁执念 - 我的标准**
+"如果你需要超过3层缩进，你就已经完蛋了，应该修复你的程序。"
+- 函数必须短小精悍，只做一件事并做好
+- C是斯巴达式语言，命名也应如此
+- 复杂性是万恶之源
+
+
+##  沟通原则
+
+### 基础交流规范
+
+- **语言要求**：使用英语思考，但是始终最终用中文表达。
+- **表达风格**：直接、犀利、零废话。如果代码垃圾，你会告诉用户为什么它是垃圾。
+- **技术优先**：批评永远针对技术问题，不针对个人。但你不会为了"友善"而模糊技术判断。
+
+
+### 需求确认流程
+
+每当用户表达诉求，必须按以下步骤进行：
+
+#### 0. **思考前提 - Linus的三个问题**
+在开始任何分析前，先问自己：
+```text
+1. "这是个真问题还是臆想出来的？" - 拒绝过度设计
+2. "有更简单的方法吗？" - 永远寻找最简方案  
+3. "会破坏什么吗？" - 向后兼容是铁律
+```
+
+1. **需求理解确认**
+   ```text
+   基于现有信息，我理解您的需求是：[使用 Linus 的思考沟通方式重述需求]
+   请确认我的理解是否准确？
+   ```
+
+2. **Linus式问题分解思考**
+   
+   **第一层：数据结构分析**
+   ```text
+   "Bad programmers worry about the code. Good programmers worry about data structures."
+   
+   - 核心数据是什么？它们的关系如何？
+   - 数据流向哪里？谁拥有它？谁修改它？
+   - 有没有不必要的数据复制或转换？
+   ```
+   
+   **第二层：特殊情况识别**
+   ```text
+   "好代码没有特殊情况"
+   
+   - 找出所有 if/else 分支
+   - 哪些是真正的业务逻辑？哪些是糟糕设计的补丁？
+   - 能否重新设计数据结构来消除这些分支？
+   ```
+   
+   **第三层：复杂度审查**
+   ```text
+   "如果实现需要超过3层缩进，重新设计它"
+   
+   - 这个功能的本质是什么？（一句话说清）
+   - 当前方案用了多少概念来解决？
+   - 能否减少到一半？再一半？
+   ```
+   
+   **第四层：破坏性分析**
+   ```text
+   "Never break userspace" - 向后兼容是铁律
+   
+   - 列出所有可能受影响的现有功能
+   - 哪些依赖会被破坏？
+   - 如何在不破坏任何东西的前提下改进？
+   ```
+   
+   **第五层：实用性验证**
+   ```text
+   "Theory and practice sometimes clash. Theory loses. Every single time."
+   
+   - 这个问题在生产环境真实存在吗？
+   - 有多少用户真正遇到这个问题？
+   - 解决方案的复杂度是否与问题的严重性匹配？
+   ```
+
+3. **决策输出模式**
+   
+   经过上述5层思考后，输出必须包含：
+   
+   ```text
+   【核心判断】
+   ✅ 值得做：[原因] / ❌ 不值得做：[原因]
+   
+   【关键洞察】
+   - 数据结构：[最关键的数据关系]
+   - 复杂度：[可以消除的复杂性]
+   - 风险点：[最大的破坏性风险]
+   
+   【Linus式方案】
+   如果值得做：
+   1. 第一步永远是简化数据结构
+   2. 消除所有特殊情况
+   3. 用最笨但最清晰的方式实现
+   4. 确保零破坏性
+   
+   如果不值得做：
+   "这是在解决不存在的问题。真正的问题是[XXX]。"
+   ```
+
+4. **代码审查输出**
+   
+   看到代码时，立即进行三层判断：
+   
+   ```text
+   【品味评分】
+   🟢 好品味 / 🟡 凑合 / 🔴 垃圾
+   
+   【致命问题】
+   - [如果有，直接指出最糟糕的部分]
+   
+   【改进方向】
+   "把这个特殊情况消除掉"
+   "这10行可以变成3行"
+   "数据结构错了，应该是..."
+   ```
+
+## 全局编码规范（适用于所有项目）
+
+### 命名规范
+- 类名（含枚举、装饰器类）使用大驼峰（PascalCase）。
+  - 例：`class PetTrainerService {}`、`enum RewardType {}`
+- 公有函数/方法名使用小驼峰（camelCase），不加下划线前缀。
+  - 例：`public getRewardList()`、`export function buildConfig()`
+- 私有函数/方法名使用"下划线 + 小驼峰"。
+  - 例：`private _loadConfig()`、`private _applyBonus()`
+- public 属性使用小驼峰（camelCase）。
+  - 例：`public totalScore: number`
+- 私有属性使用蛇形命名（snake_case）。
+  - 例：`private max_count: number`、`private user_id_map: Map<string, User>`
+- 常量使用全大写下划线（UPPER_SNAKE_CASE）。
+  - 例：`const MAX_COUNT = 10`
+
+## 项目规则（Cursor 规范）
+
+- 所有与本项目相关的回答、注释、提交信息与自动生成内容一律使用中文。
+- 严格遵守本文命名规范、TypeScript 严格类型规则与 ES 版本限制（最高仅使用 ES6）。
+- 当建议修改配置或代码时，请直接按本规则进行编辑；如需兼容性说明，附在变更描述中。
+
+### 命名规范
+- 类名（含枚举、装饰器类）使用大驼峰（PascalCase）。
+  - 例：`class PetTrainerService {}`、`enum RewardType {}`
+- 公有函数/方法名使用小驼峰（camelCase），不加下划线前缀。
+  - 例：`public getRewardList()`、`export function buildConfig()`
+- 私有函数/方法名使用“下划线 + 小驼峰”。
+  - 例：`private _loadConfig()`、`private _applyBonus()`
+- public 属性使用小驼峰（camelCase）。
+  - 例：`public totalScore: number`
+- 私有属性使用蛇形命名（snake_case）。
+  - 例：`private max_count: number`、`private user_id_map: Map<string, User>`
+- 常量使用全大写下划线（UPPER_SNAKE_CASE）。
+  - 例：`const MAX_COUNT = 10`
+
+### TypeScript 严格类型
+- 必须启用严格模式并遵循：`strict`、`noImplicitAny`、`strictNullChecks`、`noUncheckedIndexedAccess`、`noImplicitOverride`、`useUnknownInCatchVariables`、`exactOptionalPropertyTypes`、`noPropertyAccessFromIndexSignature`。
+- 禁止使用 `any`、`Function`、`object` 等过宽类型；应使用明确的接口与类型别名。
+- 捕获未知错误使用 `unknown`，在使用前进行类型收窄。
+- 函数对外导出的签名必须完整且显式（包含返回类型）。
+- 面向接口编程：优先定义 `interface`/`type`，避免魔法字符串与结构不清晰的对象。
+- 禁止在类型不安全场景使用断言（`as`）逃避检查；如确需断言，应将断言范围最小化并给出理由。
+
+### ECMAScript 版本与语言特性（最高 ES6）
+- 仅使用 ES6 及以下特性：`let/const`、模板字符串、解构、默认参数、剩余/展开、箭头函数、`class`、`Map/Set`、`Promise`、模块 `import/export` 等。
+- 不得使用 ES2017+ 特性：如 `async/await`、可选链 `?.`、空值合并 `??`、`BigInt`、`globalThis` 等。若业务必须，请以 Polyfill 或降级实现形式呈现并在说明中标注。
+- 代码中如涉及运行时新 API（超出 ES6），必须提供等效替代方案或封装兼容层。
+
+### 代码风格与可读性
+- 优先早返回，避免三层以上深度嵌套。
+- 复杂逻辑拆分为小而清晰的私有函数（按上文命名规则）。
+- 导出的 API/类必须具备简洁的中文文档注释，解释“为什么/约束/边界”。
+- 禁止引入与项目风格冲突的实验性写法；保持现有格式化风格，不进行无关重构。
+
+### 提交与评审
+- 所有修改完成后，除非用户明确提出需要进行提交与推送，否则不得执行 `git commit` 或 `git push`；默认仅保留本地未提交变更。
+- 提交信息使用中文，聚焦“为什么”和影响面；避免仅描述“做了什么”。
+- 同一提交内保持语义一致：修复、特性、重构、文档、构建配置分开提交。
+- 评审意见也使用中文，给出明确修改建议与示例。
+
+#### Git 提交信息规范
+- 格式：`<type>[可选作用域]: <message>`
+  - 例：`feat(login): 添加微信登录`
+- type 类型（仅限以下取值）：
+  - `feat`：新增功能
+  - `fix`：修复 Bug
+  - `docs`：文档更新
+  - `style`：代码格式调整（如缩进、空格），不改动逻辑
+  - `refactor`：代码重构（非功能变更）
+  - `perf`：性能优化
+  - `test`：测试用例变更
+  - `chore`：构建工具或依赖管理变更
+- 可选作用域：用于限定影响范围（如模块、页面、子包、平台）。
+  - 例：`feat(login)`: 表示登录相关的新增功能。
+- message 要求：
+  - 使用中文，简洁准确；首行概述变更。
+  - 在需要时可分段详细说明：修改动机、主要改动内容、影响范围/风险/回滚策略。
+  - 如涉及破坏性变更，请在正文中显著标注“破坏性变更”。
+
+#### Git 工作流规范
+- 拉取使用 rebase：更新本地分支必须使用 `git pull --rebase`，禁止产生 merge 提交。
+- 禁止 merge 操作：禁止使用 `git merge` 进行分支整合，统一采用 `git rebase` 或快进（fast-forward）策略。
+- push 前必须先 pull：执行 `git push` 之前必须先 `git pull --rebase`，解决冲突并确保基于最新远端提交。
+- 仅允许快进推送：如被拒绝，先 `git pull --rebase` 再推送；禁止强制推送覆盖远端历史。
+- PR 合并策略：优先使用 rebase（或 squash 后再 rebase）方式合并，禁止产生 merge commit。
+
+### 配置建议（由 AI 在需要时自动检查并提示）
+- `tsconfig.json`
+  - `target` 需为 `es6`；`lib` 不应高于 ES6（推荐仅 `es6` 与 `dom`）。
+  - 开启严格项：`strict: true`、`noImplicitAny: true`、`strictNullChecks: true`、`noUncheckedIndexedAccess: true`、`noImplicitOverride: true`、`useUnknownInCatchVariables: true`、`exactOptionalPropertyTypes: true`、`noPropertyAccessFromIndexSignature: true`。
+  - 允许 `experimentalDecorators: true` 时，避免引入 ES6 以上运行时特性。
+- Lint（如后续引入 ESLint）：应启用命名规则校验，禁止 `any`，并限制 ES 版本为 ES6。
+
+### 生成与编辑代码要求（AI 执行）
+- 所有新增/编辑的代码、注释、说明一律使用中文。
+- 严格遵循命名规则与类型规则；公开 API 要求签名完整，内部细节通过私有函数/属性封装。
+- 若现有配置与本规则不一致，优先生成兼容 ES6 的实现，并在变更说明中提示需要的配置调整（不强行修改配置文件，除非用户要求）。
+- 在对外导出的 TypeScript 代码中，禁止引入超出 ES6 的语法与 API；如不可避免，提供降级方案或封装适配层。
+
+---
+
+本规则文件用于指导 Kiro 在本仓库内的所有自动化协作行为。如业务需要放宽限制，请在任务说明中明确声明例外范围，并在最终变更描述中记录原因。

README.md

@@ -1,141 +1,196 @@
-## 行为树
+# 行为树
 
-> 行为树是一种强大的 AI 决策系统，用于实现复杂的游戏 AI 行为。
+> 一个简洁、高效的 TypeScript 行为树库。遵循"好品味"设计原则：简单数据结构，消除特殊情况，直接暴露问题。
 
-#### 基本概念
+[![npm version](https://badge.fury.io/js/kunpocc-behaviortree.svg)](https://badge.fury.io/js/kunpocc-behaviortree)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)
 
-1. 节点状态
+## 特性
+
+- 🎯 **简洁设计**: 零废话，直接解决问题
+- 🔧 **类型安全**: 完整 TypeScript 支持
+- 🚀 **高性能**: 优化的执行机制，最小开销  
+- 📦 **零依赖**: 纯净实现，无第三方依赖
+- 🔄 **状态管理**: 分层黑板系统，数据隔离清晰
+
+## 快速开始
+
+#### 安装
+
+```bash
+npm install kunpocc-behaviortree
+```
+
+#### 内置demo
+
+项目根目录下的 `bt-demo`文件夹
+
+demo是基于`cocos creator3.8.6`制作的
+
+
+
+## 核心概念
+
+### 状态类型
 ```typescript
 enum Status {
-    SUCCESS,  // 成功
+    SUCCESS,    // 成功
-    FAILURE,  // 失败
+    FAILURE,    // 失败  
-    RUNNING   // 运行中
+    RUNNING     // 运行中
 }
 ```
 
-2. 节点类型
+### 节点类型
-- **动作节点 (Action)**：执行具体行为的叶子节点
+- **组合节点**: 包含多个子节点  (Composite)
-- **组合节点 (Composite)**：控制子节点执行顺序的节点
+- **装饰节点**: 有且只有一个子节点（Decorator） 
-- **条件节点 (Condition)**：判断条件的节点
+- **叶子节点**: 不能包含子节点 (LeafNode)
-- **装饰节点 (Decorator)**：修饰其他节点行为的节点
+- **条件节点**: 特殊的叶子节点 (Condition)
 
-#### 使用示例
+
+
+## 装饰器
+
+> **自行实现的节点，通过装饰器把数据暴露给行为树编辑器**
+
+##### ClassAction - 行为节点装饰器
+
+##### ClassCondition - 条件节点装饰器
+
+##### ClassComposite - 组合节点装饰器
+
+##### ClassDecorator - 装饰节点装饰器
+
+##### prop - 属性装饰器
+
+
+
+## 内置节点
+
+### 组合节点 (Composite)
+
+##### Selector - 选择节点  
+* 选择第一个成功的子节点
+
+##### Sequence - 顺序节点
+* 按顺序执行子节点，执行过程中子节点返回非SUCCESS，则返回子节点状态，全部成功返回SUCCESS
+
+##### Parallel - 并行节点
+* 执行所有子节点，全部成功才成功
+* 并不是真正的并行，也有执行顺序
+
+##### RandomSelector - 随机选择节点
+* 随机选择一个子节点执行
+
+##### ParallelAnySuccess - 并行任一成功
+* 同时执行所有子节点，任一成功就成功
+
+
+
+### 装饰节点 (Decorator)
+
+##### ConditionDecorator - 条件装饰节点
+
+* 子类需实现
+
+  ```typescript
+  /**
+   * 判断是否满足条件
+   * @returns 是否满足条件
+   */
+  protected abstract isEligible(): boolean;
+  ```
+
+##### Inverter - 反转节点
+* 反转子节点的成功/失败状态
+
+##### LimitTime - 时间限制
+
+* 规定时间内,  向父节点返回子节点的结果，超时后返回失败
+
+##### LimitTicks - 次数限制
+
+* 执行次数(子节点非RUNNNG状态)内，向父节点返回子节点的结果，超过次数后返回失败
+
+##### Repeat - 重复节点
+* 重复执行指定次数
+
+##### RepeatUntilSuccess - 重复直到成功
+
+* 设置最大重试次数
+
+##### RepeatUntilFailure - 重复直到失败  
+
+* 设置最大重试次数
+
+##### WeightDecorator - 权重装饰节点
+
+* 用于随机选择节点的子节点的按权重随机
+
+
+
+### 叶子节点 (LeafNode)
+
+##### LeafNode - 叶子节点基类
+
+##### WaitTicks - 次数等待节点
+
+##### WaitTime - 时间等待节点
+
+### 条件节点 (Condition)
+
+##### Condition - 条件节点基类
+
+* 特殊的叶子节点，子类需实现
+
+  ```typescript
+  /**
+   * 判断是否满足条件
+   * @returns 是否满足条件
+   */
+  protected abstract isEligible(): boolean;
+  ```
+
+  
+
+## 黑板系统
+
+黑板系统提供分层数据存储，支持数据隔离和查找链：
 
 ```typescript
-import { 
+// 在节点中使用黑板
-    BehaviorTree, 
+new Action((node) => {
-    Sequence, 
+    // 直接获取实体
-    Selector, 
+    const entity = node.getEntity<Character>();
-    Parallel,
-    Success,
-    Failure,
-    WaitTime,
-    Agent,
-    Blackboard
-} from 'kunpocc-behaviortree';
     
-// 1. 创建行为树
+    // 本地数据（仅当前节点可见）
-const tree = new BehaviorTree(
+    node.set('local_count', 1);
-    new Sequence(  // 顺序节点：按顺序执行所有子节点
+    const count = node.get<number>('local_count');
-        new WaitTime(2),  // 等待2秒
-        new Selector(  // 选择节点：选择一个可执行的子节点
-            new Success(() => {
-                console.log("执行成功动作");
-            }),
-            new Failure(() => {
-                console.log("执行失败动作");
-            })
-        )
-    )
-);
     
-// 2. 创建代理和黑板
+    // 树级数据（整棵树可见）
-const agent = new Agent();  // AI代理
+    node.setRoot('tree_data', 'shared');
-const blackboard = new Blackboard();  // 共享数据黑板
+    const shared = node.getRoot<string>('tree_data');
     
-// 3. 执行行为树
+    // 全局数据（所有树可见）
-tree.tick(agent, blackboard);
+    node.setGlobal('global_config', config);
+    const config = node.getGlobal<Config>('global_config');
+    
+    return Status.SUCCESS;
+})
 ```
 
-#### 常用节点
-
-1. 组合节点
-
-   ```typescript
-   // 顺序节点：按顺序执行所有子节点，直到遇到失败或运行中的节点
-   new Sequence(childNode1, childNode2, childNode3);
-   
-   // 选择节点：选择第一个成功或运行中的子节点
-   new Selector(childNode1, childNode2, childNode3);
-   
-   // 并行节点：同时执行所有子节点
-   new Parallel(childNode1, childNode2, childNode3);
-   
-   // 记忆顺序节点：记住上次执行的位置
-   new MemSequence(childNode1, childNode2, childNode3);
-   
-   // 记忆选择节点：记住上次执行的位置
-   new MemSelector(childNode1, childNode2, childNode3);
-   
-   // 随机选择节点：随机选择一个子节点执行
-   new RandomSelector(childNode1, childNode2, childNode3);
-   ```
-
-2. 动作节点
-
-   ```typescript
-   // 成功节点
-   new Success(() => {
-       // 执行动作
-   });
-   
-   // 失败节点
-   new Failure(() => {
-       // 执行动作
-   });
-   
-   // 运行中节点
-   new Running(() => {
-       // 持续执行的动作
-   });
-   
-   // 等待节点
-   new WaitTime(2);  // 等待2秒
-   new WaitTicks(5);  // 等待5个tick
-   ```
-
-3. 使用黑板共享数据
-
-   ```typescript
-   // 在节点中使用黑板
-   class CustomAction extends Action {
-       tick(ticker: Ticker): Status {
-           // 获取数据
-           const data = ticker.blackboard.get("key");
-           
-           // 设置数据
-           ticker.blackboard.set("key", "value");
-           
-           return Status.SUCCESS;
-       }
-   }
-   ```
 
 
-#### 注意事项
+## 许可证
 
-1. 节点状态说明：
+ISC License - 详见 [LICENSE](LICENSE) 文件
-   - `SUCCESS`：节点执行成功
-   - `FAILURE`：节点执行失败
-   - `RUNNING`：节点正在执行中
-2. 组合节点特性：
-   - `Sequence`：所有子节点返回 SUCCESS 才返回 SUCCESS
-   - `Selector`：任一子节点返回 SUCCESS 就返回 SUCCESS
-   - `Parallel`：并行执行所有子节点
-   - `MemSequence/MemSelector`：会记住上次执行位置
-3. 性能优化：
-   - 使用黑板共享数据，避免重复计算
-   - 合理使用记忆节点，减少重复执行
-   - 控制行为树的深度，避免过于复杂
 
+## 贡献
 
+欢迎提交 Issue 和 Pull Request。请确保：
+1. 代码风格一致
+2. 添加适当的测试
+3. 更新相关文档
+
+---
+
+*"好的程序员关心数据结构，而不是代码。"* - 这个库遵循简洁设计原则，专注于解决实际问题。

bt-demo/.gitignore

@@ -0,0 +1,30 @@
+
+#///////////////////////////
+# Cocos Creator 3D Project
+#///////////////////////////
+library/
+temp/
+local/
+build/
+profiles/
+extensions/
+publish/
+#//////////////////////////
+# NPM
+#//////////////////////////
+node_modules/
+
+#//////////////////////////
+# VSCode
+#//////////////////////////
+.vscode/
+.creator/
+
+#//////////////////////////
+# WebStorm
+#//////////////////////////
+.idea/
+
+package-lock.json
+
+**/.DS_Store

bt-demo/README.md

@@ -0,0 +1,10 @@
+# 项目说明
+
+clone项目后，到项目根目录，执行以下命令，安装项目依赖库
+```bash
+npm i
+```
+
+重新用creator打开项目
+
+本项目使用的creator版本为3.8.6

bt-demo/assets/res.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "1.2.0",
+  "importer": "directory",
+  "imported": true,
+  "uuid": "de9afb2e-952c-4e0b-96df-cc676989bed9",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

bt-demo/assets/res/spine.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "1.2.0",
+  "importer": "directory",
+  "imported": true,
+  "uuid": "d5a536b5-db1b-42ac-8654-5f6a81341c3a",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

bt-demo/assets/res/spine/spineboy-pro.atlas

@@ -0,0 +1,286 @@
+
+spineboy-pro.png
+size: 1534,529
+format: RGBA8888
+filter: Linear,Linear
+repeat: none
+crosshair
+  rotate: false
+  xy: 449, 18
+  size: 89, 89
+  orig: 89, 89
+  offset: 0, 0
+  index: -1
+eye-indifferent
+  rotate: false
+  xy: 695, 10
+  size: 93, 89
+  orig: 93, 89
+  offset: 0, 0
+  index: -1
+eye-surprised
+  rotate: true
+  xy: 985, 178
+  size: 93, 89
+  orig: 93, 89
+  offset: 0, 0
+  index: -1
+front-bracer
+  rotate: true
+  xy: 1407, 103
+  size: 58, 80
+  orig: 58, 80
+  offset: 0, 0
+  index: -1
+front-fist-closed
+  rotate: true
+  xy: 1208, 203
+  size: 75, 82
+  orig: 75, 82
+  offset: 0, 0
+  index: -1
+front-fist-open
+  rotate: false
+  xy: 989, 89
+  size: 86, 87
+  orig: 86, 87
+  offset: 0, 0
+  index: -1
+front-foot
+  rotate: false
+  xy: 1077, 58
+  size: 126, 69
+  orig: 126, 69
+  offset: 0, 0
+  index: -1
+front-shin
+  rotate: true
+  xy: 803, 89
+  size: 82, 184
+  orig: 82, 184
+  offset: 0, 0
+  index: -1
+front-thigh
+  rotate: true
+  xy: 1062, 11
+  size: 45, 112
+  orig: 45, 112
+  offset: 0, 0
+  index: -1
+front-upper-arm
+  rotate: true
+  xy: 1205, 33
+  size: 46, 97
+  orig: 46, 97
+  offset: 0, 0
+  index: -1
+goggles
+  rotate: false
+  xy: 540, 101
+  size: 261, 166
+  orig: 261, 166
+  offset: 0, 0
+  index: -1
+gun
+  rotate: false
+  xy: 1301, 324
+  size: 209, 203
+  orig: 210, 203
+  offset: 0, 0
+  index: -1
+head
+  rotate: false
+  xy: 2, 75
+  size: 271, 298
+  orig: 271, 298
+  offset: 0, 0
+  index: -1
+hoverboard-board
+  rotate: false
+  xy: 2, 375
+  size: 492, 152
+  orig: 492, 152
+  offset: 0, 0
+  index: -1
+hoverboard-thruster
+  rotate: false
+  xy: 1472, 38
+  size: 60, 63
+  orig: 60, 64
+  offset: 0, 0
+  index: -1
+hoverglow-small
+  rotate: false
+  xy: 2, 2
+  size: 258, 71
+  orig: 274, 75
+  offset: 7, 2
+  index: -1
+mouth-grind
+  rotate: false
+  xy: 1203, 142
+  size: 93, 59
+  orig: 93, 59
+  offset: 0, 0
+  index: -1
+mouth-oooo
+  rotate: false
+  xy: 1205, 81
+  size: 93, 59
+  orig: 93, 59
+  offset: 0, 0
+  index: -1
+mouth-smile
+  rotate: false
+  xy: 1300, 98
+  size: 93, 59
+  orig: 93, 59
+  offset: 0, 0
+  index: -1
+muzzle-glow
+  rotate: false
+  xy: 496, 485
+  size: 42, 42
+  orig: 50, 50
+  offset: 4, 4
+  index: -1
+muzzle-ring
+  rotate: true
+  xy: 1301, 276
+  size: 46, 206
+  orig: 49, 209
+  offset: 1, 2
+  index: -1
+muzzle01
+  rotate: false
+  xy: 1077, 129
+  size: 124, 74
+  orig: 133, 79
+  offset: 3, 2
+  index: -1
+muzzle02
+  rotate: false
+  xy: 934, 12
+  size: 126, 75
+  orig: 135, 84
+  offset: 4, 5
+  index: -1
+muzzle03
+  rotate: false
+  xy: 540, 6
+  size: 153, 93
+  orig: 166, 106
+  offset: 7, 7
+  index: -1
+muzzle04
+  rotate: false
+  xy: 790, 5
+  size: 142, 82
+  orig: 149, 90
+  offset: 4, 4
+  index: -1
+muzzle05
+  rotate: false
+  xy: 1076, 205
+  size: 130, 73
+  orig: 135, 75
+  offset: 2, 1
+  index: -1
+neck
+  rotate: false
+  xy: 1489, 120
+  size: 35, 41
+  orig: 36, 41
+  offset: 0, 0
+  index: -1
+portal-bg
+  rotate: false
+  xy: 275, 109
+  size: 263, 264
+  orig: 266, 266
+  offset: 2, 1
+  index: -1
+portal-flare1
+  rotate: false
+  xy: 1407, 163
+  size: 103, 54
+  orig: 111, 60
+  offset: 4, 3
+  index: -1
+portal-flare2
+  rotate: false
+  xy: 1407, 219
+  size: 107, 55
+  orig: 114, 61
+  offset: 4, 3
+  index: -1
+portal-flare3
+  rotate: false
+  xy: 1298, 159
+  size: 107, 53
+  orig: 115, 59
+  offset: 5, 3
+  index: -1
+portal-shade
+  rotate: false
+  xy: 540, 269
+  size: 258, 258
+  orig: 266, 266
+  offset: 4, 4
+  index: -1
+portal-streaks1
+  rotate: false
+  xy: 800, 273
+  size: 249, 254
+  orig: 252, 256
+  offset: 1, 1
+  index: -1
+portal-streaks2
+  rotate: false
+  xy: 1051, 280
+  size: 248, 247
+  orig: 250, 249
+  offset: 1, 1
+  index: -1
+rear-bracer
+  rotate: true
+  xy: 1400, 46
+  size: 55, 70
+  orig: 56, 72
+  offset: 0, 2
+  index: -1
+rear-foot
+  rotate: false
+  xy: 1292, 214
+  size: 113, 60
+  orig: 113, 60
+  offset: 0, 0
+  index: -1
+rear-shin
+  rotate: true
+  xy: 275, 33
+  size: 74, 172
+  orig: 75, 178
+  offset: 1, 4
+  index: -1
+rear-thigh
+  rotate: true
+  xy: 1304, 41
+  size: 55, 94
+  orig: 55, 94
+  offset: 0, 0
+  index: -1
+rear-upper-arm
+  rotate: false
+  xy: 496, 396
+  size: 40, 87
+  orig: 40, 87
+  offset: 0, 0
+  index: -1
+torso
+  rotate: true
+  xy: 803, 173
+  size: 98, 180
+  orig: 98, 180
+  offset: 0, 0
+  index: -1

bt-demo/assets/res/spine/spineboy-pro.atlas.meta

@@ -0,0 +1,12 @@
+{
+  "ver": "1.0.0",
+  "importer": "*",
+  "imported": true,
+  "uuid": "e6a17488-4c37-468e-bf09-a613cf272d3e",
+  "files": [
+    ".atlas",
+    ".json"
+  ],
+  "subMetas": {},
+  "userData": {}
+}

bt-demo/assets/res/spine/spineboy-pro.json.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.2.7",
+  "importer": "spine-data",
+  "imported": true,
+  "uuid": "39a7d8cd-533a-479a-b909-9575bf720338",
+  "files": [
+    ".json"
+  ],
+  "subMetas": {},
+  "userData": {
+    "atlasUuid": "e6a17488-4c37-468e-bf09-a613cf272d3e"
+  }
+}

bt-demo/assets/res/spine/spineboy-pro.png.meta

@@ -0,0 +1,42 @@
+{
+  "ver": "1.0.27",
+  "importer": "image",
+  "imported": true,
+  "uuid": "74f9105a-c38b-4f5b-b7f2-f59cc6374074",
+  "files": [
+    ".json",
+    ".png"
+  ],
+  "subMetas": {
+    "6c48a": {
+      "importer": "texture",
+      "uuid": "74f9105a-c38b-4f5b-b7f2-f59cc6374074@6c48a",
+      "displayName": "spineboy-pro",
+      "id": "6c48a",
+      "name": "texture",
+      "userData": {
+        "wrapModeS": "repeat",
+        "wrapModeT": "repeat",
+        "minfilter": "linear",
+        "magfilter": "linear",
+        "mipfilter": "none",
+        "anisotropy": 0,
+        "isUuid": true,
+        "imageUuidOrDatabaseUri": "74f9105a-c38b-4f5b-b7f2-f59cc6374074",
+        "visible": false
+      },
+      "ver": "1.0.22",
+      "imported": true,
+      "files": [
+        ".json"
+      ],
+      "subMetas": {}
+    }
+  },
+  "userData": {
+    "type": "texture",
+    "hasAlpha": true,
+    "fixAlphaTransparencyArtifacts": false,
+    "redirect": "74f9105a-c38b-4f5b-b7f2-f59cc6374074@6c48a"
+  }
+}

bt-demo/assets/resources.meta

@@ -0,0 +1,14 @@
+{
+  "ver": "1.2.0",
+  "importer": "directory",
+  "imported": true,
+  "uuid": "9d91ce52-ffe8-43c0-a118-9ace6bd9cf45",
+  "files": [],
+  "subMetas": {},
+  "userData": {
+    "isBundle": true,
+    "bundleConfigID": "default",
+    "bundleName": "resources",
+    "priority": 8
+  }
+}

bt-demo/assets/resources/config.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "1.2.0",
+  "importer": "directory",
+  "imported": true,
+  "uuid": "1ea023b5-0ab6-4613-b157-3098b11c379b",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

bt-demo/assets/resources/config/bt_config.json

@@ -0,0 +1,148 @@
+{
+    "bt-tree1": [
+        {
+            "id": "1759488688188_qejfcso50",
+            "className": "Selector",
+            "parameters": {},
+            "children": [
+                "1759488707759_2bmdm1fqt",
+                "1759488725107_v8u160t95",
+                "1759488737637_axpz9aqaz",
+                "1759482034741_cf3mqaqdj"
+            ]
+        },
+        {
+            "id": "1759479318405_bptb8ltcp",
+            "className": "LimitTime",
+            "parameters": {
+                "_max": 2
+            },
+            "children": [
+                "1758089736854_t55n54hkh"
+            ]
+        },
+        {
+            "id": "1759479295671_jflit2ek8",
+            "className": "LimitTime",
+            "parameters": {
+                "_max": 2
+            },
+            "children": [
+                "1758089659917_vjumiu9hy"
+            ]
+        },
+        {
+            "id": "1758089659917_vjumiu9hy",
+            "className": "BTAnimation",
+            "parameters": {
+                "_name": "walk",
+                "_loop": true
+            },
+            "children": []
+        },
+        {
+            "id": "1758089736854_t55n54hkh",
+            "className": "BTAnimation",
+            "parameters": {
+                "_name": "run",
+                "_loop": true
+            },
+            "children": []
+        },
+        {
+            "id": "1758089757615_dp9tw9ka1",
+            "className": "BTAnimation",
+            "parameters": {
+                "_name": "jump",
+                "_loop": false
+            },
+            "children": []
+        },
+        {
+            "id": "1759478407706_w30m4btux",
+            "className": "BTAnimation",
+            "parameters": {
+                "_name": "idle",
+                "_loop": true
+            },
+            "children": []
+        },
+        {
+            "id": "1759481172259_xou25wj2n",
+            "className": "BTConditionRandom",
+            "parameters": {
+                "_value": 0.3
+            },
+            "children": []
+        },
+        {
+            "id": "1759481282875_5orqavi5y",
+            "className": "BTConditionRandom",
+            "parameters": {
+                "_value": 0.4
+            },
+            "children": []
+        },
+        {
+            "id": "1759481307863_ja6q4q9bz",
+            "className": "BTConditionRandom",
+            "parameters": {
+                "_value": 0.3
+            },
+            "children": []
+        },
+        {
+            "id": "1759482034741_cf3mqaqdj",
+            "className": "LimitTime",
+            "parameters": {
+                "_max": 3
+            },
+            "children": [
+                "1759478407706_w30m4btux"
+            ]
+        },
+        {
+            "id": "1759488707759_2bmdm1fqt",
+            "className": "Sequence",
+            "parameters": {},
+            "children": [
+                "1759481172259_xou25wj2n",
+                "1759479295671_jflit2ek8"
+            ]
+        },
+        {
+            "id": "1759488725107_v8u160t95",
+            "className": "Sequence",
+            "parameters": {},
+            "children": [
+                "1759481282875_5orqavi5y",
+                "1759479318405_bptb8ltcp"
+            ]
+        },
+        {
+            "id": "1759488737637_axpz9aqaz",
+            "className": "Sequence",
+            "parameters": {},
+            "children": [
+                "1759481307863_ja6q4q9bz",
+                "1758089757615_dp9tw9ka1"
+            ]
+        }
+    ],
+    "bt-tree2": [
+        {
+            "id": "1757930589538_qisfksbwz",
+            "className": "MemSequence",
+            "parameters": {},
+            "children": [
+                "1758090634327_mf36nwkdt"
+            ]
+        },
+        {
+            "id": "1758090634327_mf36nwkdt",
+            "className": "Selector",
+            "parameters": {},
+            "children": []
+        }
+    ]
+}

bt-demo/assets/resources/config/bt_config.json.meta

@@ -0,0 +1,11 @@
+{
+  "ver": "2.0.1",
+  "importer": "json",
+  "imported": true,
+  "uuid": "c8aeef5d-6d0e-4093-848e-7d8f1ca30261",
+  "files": [
+    ".json"
+  ],
+  "subMetas": {},
+  "userData": {}
+}

bt-demo/assets/resources/prefab.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "1.2.0",
+  "importer": "directory",
+  "imported": true,
+  "uuid": "6b9b2da1-08c2-4c40-ab35-e7cb5bb30872",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

bt-demo/assets/resources/prefab/spineboy.prefab

@@ -0,0 +1,147 @@
+[
+  {
+    "__type__": "cc.Prefab",
+    "_name": "spineboy",
+    "_objFlags": 0,
+    "__editorExtras__": {},
+    "_native": "",
+    "data": {
+      "__id__": 1
+    },
+    "optimizationPolicy": 0,
+    "persistent": false
+  },
+  {
+    "__type__": "cc.Node",
+    "_name": "spineboy",
+    "_objFlags": 0,
+    "__editorExtras__": {},
+    "_parent": null,
+    "_children": [],
+    "_active": true,
+    "_components": [
+      {
+        "__id__": 2
+      },
+      {
+        "__id__": 4
+      }
+    ],
+    "_prefab": {
+      "__id__": 6
+    },
+    "_lpos": {
+      "__type__": "cc.Vec3",
+      "x": 0,
+      "y": 0,
+      "z": -1000
+    },
+    "_lrot": {
+      "__type__": "cc.Quat",
+      "x": 0,
+      "y": 0,
+      "z": 0,
+      "w": 1
+    },
+    "_lscale": {
+      "__type__": "cc.Vec3",
+      "x": 0.3,
+      "y": 0.3,
+      "z": 1
+    },
+    "_mobility": 0,
+    "_layer": 1073741824,
+    "_euler": {
+      "__type__": "cc.Vec3",
+      "x": 0,
+      "y": 0,
+      "z": 0
+    },
+    "_id": ""
+  },
+  {
+    "__type__": "cc.UITransform",
+    "_name": "",
+    "_objFlags": 0,
+    "__editorExtras__": {},
+    "node": {
+      "__id__": 1
+    },
+    "_enabled": true,
+    "__prefab": {
+      "__id__": 3
+    },
+    "_contentSize": {
+      "__type__": "cc.Size",
+      "width": 419.8399963378906,
+      "height": 686.0800170898438
+    },
+    "_anchorPoint": {
+      "__type__": "cc.Vec2",
+      "x": 0.45412539378136013,
+      "y": 0.011660447470739235
+    },
+    "_id": ""
+  },
+  {
+    "__type__": "cc.CompPrefabInfo",
+    "fileId": "dfVeZdqm9E15k7OBD615QP"
+  },
+  {
+    "__type__": "sp.Skeleton",
+    "_name": "",
+    "_objFlags": 0,
+    "__editorExtras__": {},
+    "node": {
+      "__id__": 1
+    },
+    "_enabled": true,
+    "__prefab": {
+      "__id__": 5
+    },
+    "_customMaterial": null,
+    "_srcBlendFactor": 2,
+    "_dstBlendFactor": 4,
+    "_color": {
+      "__type__": "cc.Color",
+      "r": 255,
+      "g": 255,
+      "b": 255,
+      "a": 255
+    },
+    "_skeletonData": {
+      "__uuid__": "39a7d8cd-533a-479a-b909-9575bf720338",
+      "__expectedType__": "sp.SkeletonData"
+    },
+    "defaultSkin": "default",
+    "defaultAnimation": "jump",
+    "_premultipliedAlpha": true,
+    "_timeScale": 1,
+    "_preCacheMode": 0,
+    "_cacheMode": 0,
+    "_sockets": [],
+    "_useTint": false,
+    "_debugMesh": false,
+    "_debugBones": false,
+    "_debugSlots": false,
+    "_enableBatch": false,
+    "loop": true,
+    "_id": ""
+  },
+  {
+    "__type__": "cc.CompPrefabInfo",
+    "fileId": "deHPJ9jpdJZq/2PP1E2haI"
+  },
+  {
+    "__type__": "cc.PrefabInfo",
+    "root": {
+      "__id__": 1
+    },
+    "asset": {
+      "__id__": 0
+    },
+    "fileId": "fcg4LyhU9MpITaQy7lW8Ru",
+    "instance": null,
+    "targetOverrides": null
+  }
+]

bt-demo/assets/resources/prefab/spineboy.prefab.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.50",
+  "importer": "prefab",
+  "imported": true,
+  "uuid": "610db270-416d-42a9-a228-67b0fe1beee4",
+  "files": [
+    ".json"
+  ],
+  "subMetas": {},
+  "userData": {
+    "syncNodeName": "spineboy"
+  }
+}

bt-demo/assets/scene.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "1.2.0",
+  "importer": "directory",
+  "imported": true,
+  "uuid": "6f3166a3-36ba-4512-bae8-889c2a7d7d98",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

bt-demo/assets/scene/GameEntry.scene

@@ -0,0 +1,726 @@
+[
+  {
+    "__type__": "cc.SceneAsset",
+    "_name": "GameEntry",
+    "_objFlags": 0,
+    "__editorExtras__": {},
+    "_native": "",
+    "scene": {
+      "__id__": 1
+    }
+  },
+  {
+    "__type__": "cc.Scene",
+    "_name": "GameEntry",
+    "_objFlags": 0,
+    "__editorExtras__": {},
+    "_parent": null,
+    "_children": [
+      {
+        "__id__": 2
+      }
+    ],
+    "_active": true,
+    "_components": [],
+    "_prefab": {
+      "__id__": 22
+    },
+    "_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
+    },
+    "autoReleaseAssets": false,
+    "_globals": {
+      "__id__": 25
+    },
+    "_id": "bef93422-3e63-4c0f-a5cf-d926e7360673"
+  },
+  {
+    "__type__": "cc.Node",
+    "_name": "Canvas",
+    "_objFlags": 0,
+    "__editorExtras__": {},
+    "_parent": {
+      "__id__": 1
+    },
+    "_children": [
+      {
+        "__id__": 3
+      },
+      {
+        "__id__": 6
+      },
+      {
+        "__id__": 8
+      }
+    ],
+    "_active": true,
+    "_components": [
+      {
+        "__id__": 19
+      },
+      {
+        "__id__": 20
+      },
+      {
+        "__id__": 21
+      }
+    ],
+    "_prefab": null,
+    "_lpos": {
+      "__type__": "cc.Vec3",
+      "x": 375,
+      "y": 667,
+      "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": "beI88Z2HpFELqR4T5EMHpg"
+  },
+  {
+    "__type__": "cc.Node",
+    "_name": "entry",
+    "_objFlags": 0,
+    "__editorExtras__": {},
+    "_parent": {
+      "__id__": 2
+    },
+    "_children": [],
+    "_active": true,
+    "_components": [
+      {
+        "__id__": 4
+      },
+      {
+        "__id__": 5
+      }
+    ],
+    "_prefab": null,
+    "_lpos": {
+      "__type__": "cc.Vec3",
+      "x": 0,
+      "y": 0,
+      "z": 1000
+    },
+    "_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": "6eSMYbFu9DJL1bKl9DnMo6"
+  },
+  {
+    "__type__": "cc.UITransform",
+    "_name": "",
+    "_objFlags": 0,
+    "__editorExtras__": {},
+    "node": {
+      "__id__": 3
+    },
+    "_enabled": true,
+    "__prefab": null,
+    "_contentSize": {
+      "__type__": "cc.Size",
+      "width": 100,
+      "height": 100
+    },
+    "_anchorPoint": {
+      "__type__": "cc.Vec2",
+      "x": 0.5,
+      "y": 0.5
+    },
+    "_id": "8ekQXh8+BP/6BzVmjL7OPr"
+  },
+  {
+    "__type__": "e5804qewX9N9op0d4aH4r7B",
+    "_name": "",
+    "_objFlags": 0,
+    "__editorExtras__": {},
+    "node": {
+      "__id__": 3
+    },
+    "_enabled": true,
+    "__prefab": null,
+    "skeleton": null,
+    "btConfig": {
+      "__uuid__": "c8aeef5d-6d0e-4093-848e-7d8f1ca30261",
+      "__expectedType__": "cc.JsonAsset"
+    },
+    "_id": "69LhmWaZRIUpmYvdiN82Ha"
+  },
+  {
+    "__type__": "cc.Node",
+    "_name": "Camera",
+    "_objFlags": 0,
+    "__editorExtras__": {},
+    "_parent": {
+      "__id__": 2
+    },
+    "_children": [],
+    "_active": true,
+    "_components": [
+      {
+        "__id__": 7
+      }
+    ],
+    "_prefab": null,
+    "_lpos": {
+      "__type__": "cc.Vec3",
+      "x": 0,
+      "y": 0,
+      "z": 1000
+    },
+    "_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": "ebFwiq8gBFaYpqYbdoDODe"
+  },
+  {
+    "__type__": "cc.Camera",
+    "_name": "",
+    "_objFlags": 0,
+    "__editorExtras__": {},
+    "node": {
+      "__id__": 6
+    },
+    "_enabled": true,
+    "__prefab": null,
+    "_projection": 0,
+    "_priority": 1,
+    "_fov": 45,
+    "_fovAxis": 0,
+    "_orthoHeight": 667,
+    "_near": 0,
+    "_far": 2000,
+    "_color": {
+      "__type__": "cc.Color",
+      "r": 0,
+      "g": 0,
+      "b": 0,
+      "a": 255
+    },
+    "_depth": 1,
+    "_stencil": 0,
+    "_clearFlags": 0,
+    "_rect": {
+      "__type__": "cc.Rect",
+      "x": 0,
+      "y": 0,
+      "width": 1,
+      "height": 1
+    },
+    "_aperture": 19,
+    "_shutter": 7,
+    "_iso": 0,
+    "_screenScale": 1,
+    "_visibility": 1107296259,
+    "_targetTexture": null,
+    "_postProcess": null,
+    "_usePostProcess": false,
+    "_cameraType": -1,
+    "_trackingType": 0,
+    "_id": "63WIch3o5BEYRlXzTT0oWc"
+  },
+  {
+    "__type__": "cc.Node",
+    "_objFlags": 0,
+    "_parent": {
+      "__id__": 2
+    },
+    "_prefab": {
+      "__id__": 9
+    },
+    "__editorExtras__": {}
+  },
+  {
+    "__type__": "cc.PrefabInfo",
+    "root": {
+      "__id__": 8
+    },
+    "asset": {
+      "__uuid__": "610db270-416d-42a9-a228-67b0fe1beee4",
+      "__expectedType__": "cc.Prefab"
+    },
+    "fileId": "fcg4LyhU9MpITaQy7lW8Ru",
+    "instance": {
+      "__id__": 10
+    },
+    "targetOverrides": null,
+    "nestedPrefabInstanceRoots": null
+  },
+  {
+    "__type__": "cc.PrefabInstance",
+    "fileId": "2eYzhZYv5Mi5OETcYel3W3",
+    "prefabRootNode": null,
+    "mountedChildren": [],
+    "mountedComponents": [],
+    "propertyOverrides": [
+      {
+        "__id__": 11
+      },
+      {
+        "__id__": 13
+      },
+      {
+        "__id__": 14
+      },
+      {
+        "__id__": 15
+      },
+      {
+        "__id__": 16
+      },
+      {
+        "__id__": 18
+      }
+    ],
+    "removedComponents": []
+  },
+  {
+    "__type__": "CCPropertyOverrideInfo",
+    "targetInfo": {
+      "__id__": 12
+    },
+    "propertyPath": [
+      "_lpos"
+    ],
+    "value": {
+      "__type__": "cc.Vec3",
+      "x": 0,
+      "y": 0,
+      "z": 0
+    }
+  },
+  {
+    "__type__": "cc.TargetInfo",
+    "localID": [
+      "fcg4LyhU9MpITaQy7lW8Ru"
+    ]
+  },
+  {
+    "__type__": "CCPropertyOverrideInfo",
+    "targetInfo": {
+      "__id__": 12
+    },
+    "propertyPath": [
+      "_name"
+    ],
+    "value": "spineboy"
+  },
+  {
+    "__type__": "CCPropertyOverrideInfo",
+    "targetInfo": {
+      "__id__": 12
+    },
+    "propertyPath": [
+      "_lrot"
+    ],
+    "value": {
+      "__type__": "cc.Quat",
+      "x": 0,
+      "y": 0,
+      "z": 0,
+      "w": 1
+    }
+  },
+  {
+    "__type__": "CCPropertyOverrideInfo",
+    "targetInfo": {
+      "__id__": 12
+    },
+    "propertyPath": [
+      "_euler"
+    ],
+    "value": {
+      "__type__": "cc.Vec3",
+      "x": 0,
+      "y": 0,
+      "z": 0
+    }
+  },
+  {
+    "__type__": "CCPropertyOverrideInfo",
+    "targetInfo": {
+      "__id__": 17
+    },
+    "propertyPath": [
+      "defaultAnimation"
+    ],
+    "value": "idle"
+  },
+  {
+    "__type__": "cc.TargetInfo",
+    "localID": [
+      "deHPJ9jpdJZq/2PP1E2haI"
+    ]
+  },
+  {
+    "__type__": "CCPropertyOverrideInfo",
+    "targetInfo": {
+      "__id__": 17
+    },
+    "propertyPath": [
+      "_premultipliedAlpha"
+    ],
+    "value": true
+  },
+  {
+    "__type__": "cc.UITransform",
+    "_name": "",
+    "_objFlags": 0,
+    "__editorExtras__": {},
+    "node": {
+      "__id__": 2
+    },
+    "_enabled": true,
+    "__prefab": null,
+    "_contentSize": {
+      "__type__": "cc.Size",
+      "width": 0,
+      "height": 0
+    },
+    "_anchorPoint": {
+      "__type__": "cc.Vec2",
+      "x": 0.5,
+      "y": 0.5
+    },
+    "_id": "d6rUX5yfhMlKoWX2bSbawx"
+  },
+  {
+    "__type__": "cc.Canvas",
+    "_name": "",
+    "_objFlags": 0,
+    "__editorExtras__": {},
+    "node": {
+      "__id__": 2
+    },
+    "_enabled": true,
+    "__prefab": null,
+    "_cameraComponent": {
+      "__id__": 7
+    },
+    "_alignCanvasWithScreen": true,
+    "_id": "12O/ljcVlEqLmVm3U2gEOQ"
+  },
+  {
+    "__type__": "cc.Widget",
+    "_name": "",
+    "_objFlags": 0,
+    "__editorExtras__": {},
+    "node": {
+      "__id__": 2
+    },
+    "_enabled": true,
+    "__prefab": null,
+    "_alignFlags": 18,
+    "_target": null,
+    "_left": 375,
+    "_right": 375,
+    "_top": 667,
+    "_bottom": 667,
+    "_horizontalCenter": 0,
+    "_verticalCenter": 0,
+    "_isAbsLeft": true,
+    "_isAbsRight": true,
+    "_isAbsTop": true,
+    "_isAbsBottom": true,
+    "_isAbsHorizontalCenter": true,
+    "_isAbsVerticalCenter": true,
+    "_originalWidth": 0,
+    "_originalHeight": 0,
+    "_alignMode": 2,
+    "_lockFlags": 0,
+    "_id": "c5V1EV8IpMtrIvY1OE9t2u"
+  },
+  {
+    "__type__": "cc.PrefabInfo",
+    "root": null,
+    "asset": null,
+    "fileId": "bef93422-3e63-4c0f-a5cf-d926e7360673",
+    "instance": null,
+    "targetOverrides": [
+      {
+        "__id__": 23
+      }
+    ],
+    "nestedPrefabInstanceRoots": [
+      {
+        "__id__": 8
+      }
+    ]
+  },
+  {
+    "__type__": "cc.TargetOverrideInfo",
+    "source": {
+      "__id__": 5
+    },
+    "sourceInfo": null,
+    "propertyPath": [
+      "skeleton"
+    ],
+    "target": {
+      "__id__": 8
+    },
+    "targetInfo": {
+      "__id__": 24
+    }
+  },
+  {
+    "__type__": "cc.TargetInfo",
+    "localID": [
+      "deHPJ9jpdJZq/2PP1E2haI"
+    ]
+  },
+  {
+    "__type__": "cc.SceneGlobals",
+    "ambient": {
+      "__id__": 26
+    },
+    "shadows": {
+      "__id__": 27
+    },
+    "_skybox": {
+      "__id__": 28
+    },
+    "fog": {
+      "__id__": 29
+    },
+    "octree": {
+      "__id__": 30
+    },
+    "skin": {
+      "__id__": 31
+    },
+    "lightProbeInfo": {
+      "__id__": 32
+    },
+    "postSettings": {
+      "__id__": 33
+    },
+    "bakedWithStationaryMainLight": false,
+    "bakedWithHighpLightmap": false
+  },
+  {
+    "__type__": "cc.AmbientInfo",
+    "_skyColorHDR": {
+      "__type__": "cc.Vec4",
+      "x": 0,
+      "y": 0,
+      "z": 0,
+      "w": 0.520833125
+    },
+    "_skyColor": {
+      "__type__": "cc.Vec4",
+      "x": 0,
+      "y": 0,
+      "z": 0,
+      "w": 0.520833125
+    },
+    "_skyIllumHDR": 20000,
+    "_skyIllum": 20000,
+    "_groundAlbedoHDR": {
+      "__type__": "cc.Vec4",
+      "x": 0,
+      "y": 0,
+      "z": 0,
+      "w": 0
+    },
+    "_groundAlbedo": {
+      "__type__": "cc.Vec4",
+      "x": 0,
+      "y": 0,
+      "z": 0,
+      "w": 0
+    },
+    "_skyColorLDR": {
+      "__type__": "cc.Vec4",
+      "x": 0.2,
+      "y": 0.5,
+      "z": 0.8,
+      "w": 1
+    },
+    "_skyIllumLDR": 20000,
+    "_groundAlbedoLDR": {
+      "__type__": "cc.Vec4",
+      "x": 0.2,
+      "y": 0.2,
+      "z": 0.2,
+      "w": 1
+    }
+  },
+  {
+    "__type__": "cc.ShadowsInfo",
+    "_enabled": false,
+    "_type": 0,
+    "_normal": {
+      "__type__": "cc.Vec3",
+      "x": 0,
+      "y": 1,
+      "z": 0
+    },
+    "_distance": 0,
+    "_planeBias": 1,
+    "_shadowColor": {
+      "__type__": "cc.Color",
+      "r": 76,
+      "g": 76,
+      "b": 76,
+      "a": 255
+    },
+    "_maxReceived": 4,
+    "_size": {
+      "__type__": "cc.Vec2",
+      "x": 512,
+      "y": 512
+    }
+  },
+  {
+    "__type__": "cc.SkyboxInfo",
+    "_envLightingType": 0,
+    "_envmapHDR": null,
+    "_envmap": null,
+    "_envmapLDR": null,
+    "_diffuseMapHDR": null,
+    "_diffuseMapLDR": null,
+    "_enabled": false,
+    "_useHDR": true,
+    "_editableMaterial": null,
+    "_reflectionHDR": null,
+    "_reflectionLDR": null,
+    "_rotationAngle": 0
+  },
+  {
+    "__type__": "cc.FogInfo",
+    "_type": 0,
+    "_fogColor": {
+      "__type__": "cc.Color",
+      "r": 200,
+      "g": 200,
+      "b": 200,
+      "a": 255
+    },
+    "_enabled": false,
+    "_fogDensity": 0.3,
+    "_fogStart": 0.5,
+    "_fogEnd": 300,
+    "_fogAtten": 5,
+    "_fogTop": 1.5,
+    "_fogRange": 1.2,
+    "_accurate": false
+  },
+  {
+    "__type__": "cc.OctreeInfo",
+    "_enabled": false,
+    "_minPos": {
+      "__type__": "cc.Vec3",
+      "x": -1024,
+      "y": -1024,
+      "z": -1024
+    },
+    "_maxPos": {
+      "__type__": "cc.Vec3",
+      "x": 1024,
+      "y": 1024,
+      "z": 1024
+    },
+    "_depth": 8
+  },
+  {
+    "__type__": "cc.SkinInfo",
+    "_enabled": false,
+    "_blurRadius": 0.01,
+    "_sssIntensity": 3
+  },
+  {
+    "__type__": "cc.LightProbeInfo",
+    "_giScale": 1,
+    "_giSamples": 1024,
+    "_bounces": 2,
+    "_reduceRinging": 0,
+    "_showProbe": true,
+    "_showWireframe": true,
+    "_showConvex": false,
+    "_data": null,
+    "_lightProbeSphereVolume": 1
+  },
+  {
+    "__type__": "cc.PostSettingsInfo",
+    "_toneMappingType": 0
+  }
+]

bt-demo/assets/scene/GameEntry.scene.meta

@@ -0,0 +1,11 @@
+{
+  "ver": "1.1.50",
+  "importer": "scene",
+  "imported": true,
+  "uuid": "bef93422-3e63-4c0f-a5cf-d926e7360673",
+  "files": [
+    ".json"
+  ],
+  "subMetas": {},
+  "userData": {}
+}

bt-demo/assets/script.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "1.2.0",
+  "importer": "directory",
+  "imported": true,
+  "uuid": "448b0525-daf3-4ad4-be4a-04a7e181f028",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

bt-demo/assets/script/BTNode.ts

@@ -0,0 +1,72 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-09-17
+ * @Description: 定义一些行为节点
+ */
+
+import { sp } from "cc";
+import { BT } from "./Header";
+
+@BT.ClassAction("BTAnimation", { name: "播放动画", group: "动画", desc: "通过动画名播放动画，播放完成后返回成功" })
+export class BTAnimation extends BT.LeafNode {
+    @BT.prop({ type: BT.ParamType.string, description: "动画名" })
+    private _name: string = "";
+
+    @BT.prop({ type: BT.ParamType.bool, description: "是否循环" })
+    private _loop: boolean = false;
+
+    private _complete: boolean = false;
+
+    protected open(): void {
+        super.open();
+        this._complete = false;
+
+        console.log("open", this._name, this._loop);
+
+        let skeleton = this.getEntity<sp.Skeleton>();
+        skeleton.setAnimation(0, this._name, this._loop);
+
+        if (!this._loop) {
+            skeleton.setCompleteListener(() => {
+                this._complete = true;
+            });
+        }
+    }
+
+    public tick(): BT.Status {
+        if (!this._loop && this._complete) {
+            return BT.Status.SUCCESS;
+        }
+        return BT.Status.RUNNING;
+    }
+
+    protected close(): void {
+        super.close();
+        console.log("close", this._name, this._loop);
+    }
+}
+
+/** 条件节点 */
+@BT.ClassCondition("BTConditionRandom", { name: "随机条件节点", group: "基础条件节点", desc: "随机0-1的值，大于设置值返回成功，否则返回失败" })
+export class BTConditionRandom extends BT.Condition {
+
+    @BT.prop({ type: BT.ParamType.float, description: "值", defaultValue: 0.5 })
+    private _value: number = 0.5;
+
+    public isEligible(): boolean {
+        return Math.random() > this._value;
+    }
+}
+
+
+/** 条件装饰节点 */
+@BT.ClassDecorator("BTCondition", { name: "条件装饰节点", group: "基础装饰节点", desc: "随机0-1的值，大于设置值返回成功，否则返回失败" })
+export class BTCondition extends BT.ConditionDecorator {
+
+    @BT.prop({ type: BT.ParamType.float, description: "值" })
+    private _value: number = 0.5;
+
+    public isEligible(): boolean {
+        return Math.random() > this._value;
+    }
+}

bt-demo/assets/script/BTNode.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "6c8cc47c-1976-432a-aa59-932cb74f41a2",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

bt-demo/assets/script/GameEntry.ts

@@ -0,0 +1,23 @@
+import { _decorator, Component, JsonAsset, sp } from 'cc';
+import { BT } from './Header';
+const { ccclass, property, menu } = _decorator;
+@ccclass("GameEntry")
+@menu("kunpo/GameEntry")
+export class GameEntry extends Component {
+    @property(sp.Skeleton)
+    private skeleton: sp.Skeleton = null;
+
+    @property(JsonAsset)
+    private btConfig: JsonAsset = null;
+
+    private _tree: BT.BehaviorTree<sp.Skeleton> = null;
+    start(): void {
+        console.log("btConfig", this.btConfig);
+        let btTree1: BT.INodeConfig[] = this.btConfig.json["bt-tree1"]
+        this._tree = BT.createBehaviorTree(btTree1, this.skeleton);
+    }
+
+    protected update(dt: number): void {
+        this._tree.tick(dt);
+    }
+}

bt-demo/assets/script/GameEntry.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "e5804a9e-c17f-4df6-8a74-778687e2bec1",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

bt-demo/assets/script/Header.ts

@@ -0,0 +1,9 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-09-17
+ * @Description: 头文件
+ */
+
+import * as BT from "kunpocc-behaviortree";
+export { BT };
+

bt-demo/assets/script/Header.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "17dd8d23-3e47-454a-9e47-69e371273e3b",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

bt-demo/assets/script/Math.ts

@@ -0,0 +1,73 @@
+interface Math {
+    /**
+     * 限制值
+     * @param value 当前值
+     * @param min 最小值
+     * @param max 最大值
+     */
+    clampf(value: number, min: number, max: number): number;
+
+    /**
+     * 随机从 min 到 max 的整数(包含min和max)
+     * @param min
+     * @param max
+     */
+    rand(min: number, max: number): number;
+
+    /**
+     * 随机从 min 到 max的数
+     * @param min
+     * @param max
+     */
+    randRange(min: number, max: number): number;
+
+    /**
+     * 角度转弧度
+     * @param angle 角度
+     */
+    rad(angle: number): number;
+
+    /**
+     * 弧度转角度
+     * @param radian 弧度
+     */
+    deg(radian: number): number;
+
+    /**
+     * 数值平滑渐变
+     * @param num1
+     * @param num2
+     * @param elapsedTime
+     * @param responseTime
+     */
+    smooth(num1: number, num2: number, elapsedTime: number, responseTime: number): number;
+}
+
+Math.clampf = function (value: number, min: number, max: number): number {
+    return Math.min(Math.max(value, min), max);
+};
+
+Math.rand = function (min: number, max: number): number {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+};
+
+Math.randRange = function (min: number, max: number): number {
+    return Math.random() * (max - min) + min;
+};
+
+Math.rad = function (angle: number): number {
+    return (angle * Math.PI) / 180;
+};
+
+Math.deg = function (radian: number): number {
+    return (radian * 180) / Math.PI;
+};
+
+Math.smooth = function (num1: number, num2: number, elapsedTime: number, responseTime: number): number {
+    let out: number = num1;
+    if (elapsedTime > 0) {
+        out = out + (num2 - num1) * (elapsedTime / (elapsedTime + responseTime));
+    }
+    return out;
+};
+

bt-demo/assets/script/Math.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "a336ce23-5d73-4280-b2e9-084389a3877e",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

bt-demo/extensions-config/.gitignore

@@ -0,0 +1 @@
+local/

bt-demo/extensions-config/bt-editor/bt-tree1.json

@@ -0,0 +1,302 @@
+{
+    "name": "bt-tree1",
+    "description": "",
+    "nodes": [
+        {
+            "id": "1759488688188_qejfcso50",
+            "className": "Selector",
+            "name": "选择节点",
+            "position": {
+                "x": -60,
+                "y": -200
+            },
+            "parameters": {},
+            "children": [
+                "1759488707759_2bmdm1fqt",
+                "1759488725107_v8u160t95",
+                "1759488737637_axpz9aqaz",
+                "1759482034741_cf3mqaqdj"
+            ],
+            "alias": "根节点"
+        },
+        {
+            "id": "1759479318405_bptb8ltcp",
+            "className": "LimitTime",
+            "name": "时间限制器",
+            "position": {
+                "x": -40,
+                "y": 40
+            },
+            "parameters": {
+                "_max": 2
+            },
+            "children": [
+                "1758089736854_t55n54hkh"
+            ]
+        },
+        {
+            "id": "1759479295671_jflit2ek8",
+            "className": "LimitTime",
+            "name": "时间限制器",
+            "position": {
+                "x": -360,
+                "y": 40
+            },
+            "parameters": {
+                "_max": 2
+            },
+            "children": [
+                "1758089659917_vjumiu9hy"
+            ]
+        },
+        {
+            "id": "1758089659917_vjumiu9hy",
+            "className": "BTAnimation",
+            "name": "播放动画",
+            "position": {
+                "x": -360,
+                "y": 160
+            },
+            "parameters": {
+                "_name": "walk",
+                "_loop": true
+            },
+            "children": []
+        },
+        {
+            "id": "1758089736854_t55n54hkh",
+            "className": "BTAnimation",
+            "name": "播放动画",
+            "position": {
+                "x": -40,
+                "y": 160
+            },
+            "parameters": {
+                "_name": "run",
+                "_loop": true
+            },
+            "children": []
+        },
+        {
+            "id": "1758089757615_dp9tw9ka1",
+            "className": "BTAnimation",
+            "name": "播放动画",
+            "position": {
+                "x": 260,
+                "y": 40
+            },
+            "parameters": {
+                "_name": "jump",
+                "_loop": false
+            },
+            "children": []
+        },
+        {
+            "id": "1759478407706_w30m4btux",
+            "className": "BTAnimation",
+            "name": "播放动画",
+            "position": {
+                "x": 420,
+                "y": 40
+            },
+            "parameters": {
+                "_name": "idle",
+                "_loop": true
+            },
+            "children": []
+        },
+        {
+            "id": "1759481172259_xou25wj2n",
+            "className": "BTConditionRandom",
+            "name": "随机条件节点",
+            "position": {
+                "x": -520,
+                "y": 40
+            },
+            "parameters": {
+                "_value": 0.3
+            },
+            "children": []
+        },
+        {
+            "id": "1759481282875_5orqavi5y",
+            "className": "BTConditionRandom",
+            "name": "随机条件节点",
+            "position": {
+                "x": -200,
+                "y": 40
+            },
+            "parameters": {
+                "_value": 0.4
+            },
+            "children": []
+        },
+        {
+            "id": "1759481307863_ja6q4q9bz",
+            "className": "BTConditionRandom",
+            "name": "随机条件节点",
+            "position": {
+                "x": 120,
+                "y": 40
+            },
+            "parameters": {
+                "_value": 0.3
+            },
+            "children": []
+        },
+        {
+            "id": "1759482034741_cf3mqaqdj",
+            "className": "LimitTime",
+            "name": "时间限制器",
+            "position": {
+                "x": 420,
+                "y": -80
+            },
+            "parameters": {
+                "_max": 3
+            },
+            "children": [
+                "1759478407706_w30m4btux"
+            ],
+            "alias": "待机动画"
+        },
+        {
+            "id": "1759488707759_2bmdm1fqt",
+            "className": "Sequence",
+            "name": "顺序节点",
+            "position": {
+                "x": -440,
+                "y": -80
+            },
+            "parameters": {},
+            "children": [
+                "1759481172259_xou25wj2n",
+                "1759479295671_jflit2ek8"
+            ],
+            "alias": "行走动画分支"
+        },
+        {
+            "id": "1759488725107_v8u160t95",
+            "className": "Sequence",
+            "name": "顺序节点",
+            "position": {
+                "x": -120,
+                "y": -80
+            },
+            "parameters": {},
+            "children": [
+                "1759481282875_5orqavi5y",
+                "1759479318405_bptb8ltcp"
+            ],
+            "alias": "奔跑动画分支"
+        },
+        {
+            "id": "1759488737637_axpz9aqaz",
+            "className": "Sequence",
+            "name": "顺序节点",
+            "position": {
+                "x": 180,
+                "y": -80
+            },
+            "parameters": {},
+            "children": [
+                "1759481307863_ja6q4q9bz",
+                "1758089757615_dp9tw9ka1"
+            ],
+            "alias": "跳跃动画分支"
+        }
+    ],
+    "connections": [
+        {
+            "id": "conn_1759479306749_wnwlz1638",
+            "sourceNodeId": "1759479295671_jflit2ek8",
+            "targetNodeId": "1758089659917_vjumiu9hy",
+            "sourcePointType": "child",
+            "targetPointType": "parent"
+        },
+        {
+            "id": "conn_1759479325803_ln42r7198",
+            "sourceNodeId": "1759479318405_bptb8ltcp",
+            "targetNodeId": "1758089736854_t55n54hkh",
+            "sourcePointType": "child",
+            "targetPointType": "parent"
+        },
+        {
+            "id": "conn_1759482041141_ok8gnqp0o",
+            "sourceNodeId": "1759482034741_cf3mqaqdj",
+            "targetNodeId": "1759478407706_w30m4btux",
+            "sourcePointType": "child",
+            "targetPointType": "parent"
+        },
+        {
+            "id": "conn_1759488698126_dou7vxvo0",
+            "sourceNodeId": "1759488688188_qejfcso50",
+            "targetNodeId": "1759482034741_cf3mqaqdj",
+            "sourcePointType": "child",
+            "targetPointType": "parent"
+        },
+        {
+            "id": "conn_1759488712210_gn0eom3zv",
+            "sourceNodeId": "1759488688188_qejfcso50",
+            "targetNodeId": "1759488707759_2bmdm1fqt",
+            "sourcePointType": "child",
+            "targetPointType": "parent"
+        },
+        {
+            "id": "conn_1759488719553_mag45k9dx",
+            "sourceNodeId": "1759488707759_2bmdm1fqt",
+            "targetNodeId": "1759481172259_xou25wj2n",
+            "sourcePointType": "child",
+            "targetPointType": "parent"
+        },
+        {
+            "id": "conn_1759488720799_ksfwij12z",
+            "sourceNodeId": "1759488707759_2bmdm1fqt",
+            "targetNodeId": "1759479295671_jflit2ek8",
+            "sourcePointType": "child",
+            "targetPointType": "parent"
+        },
+        {
+            "id": "conn_1759488728262_shaymep9m",
+            "sourceNodeId": "1759488688188_qejfcso50",
+            "targetNodeId": "1759488725107_v8u160t95",
+            "sourcePointType": "child",
+            "targetPointType": "parent"
+        },
+        {
+            "id": "conn_1759488732106_yg23eiw3l",
+            "sourceNodeId": "1759488725107_v8u160t95",
+            "targetNodeId": "1759481282875_5orqavi5y",
+            "sourcePointType": "child",
+            "targetPointType": "parent"
+        },
+        {
+            "id": "conn_1759488733833_08kf67zp1",
+            "sourceNodeId": "1759488725107_v8u160t95",
+            "targetNodeId": "1759479318405_bptb8ltcp",
+            "sourcePointType": "child",
+            "targetPointType": "parent"
+        },
+        {
+            "id": "conn_1759488741448_2in7yz3v7",
+            "sourceNodeId": "1759488688188_qejfcso50",
+            "targetNodeId": "1759488737637_axpz9aqaz",
+            "sourcePointType": "child",
+            "targetPointType": "parent"
+        },
+        {
+            "id": "conn_1759488742689_15z7fchvc",
+            "sourceNodeId": "1759488737637_axpz9aqaz",
+            "targetNodeId": "1759481307863_ja6q4q9bz",
+            "sourcePointType": "child",
+            "targetPointType": "parent"
+        },
+        {
+            "id": "conn_1759488745870_5rllaj2oe",
+            "sourceNodeId": "1759488737637_axpz9aqaz",
+            "targetNodeId": "1758089757615_dp9tw9ka1",
+            "sourcePointType": "child",
+            "targetPointType": "parent"
+        }
+    ]
+}

bt-demo/extensions-config/bt-editor/bt-tree2.json

@@ -0,0 +1,39 @@
+{
+    "name": "bt-tree2",
+    "description": "",
+    "nodes": [
+        {
+            "id": "1757930589538_qisfksbwz",
+            "className": "MemSequence",
+            "name": "记忆顺序节点",
+            "position": {
+                "x": -60,
+                "y": -280
+            },
+            "parameters": {},
+            "children": [
+                "1758090634327_mf36nwkdt"
+            ]
+        },
+        {
+            "id": "1758090634327_mf36nwkdt",
+            "className": "Selector",
+            "name": "选择节点",
+            "position": {
+                "x": 20,
+                "y": -80
+            },
+            "parameters": {},
+            "children": []
+        }
+    ],
+    "connections": [
+        {
+            "id": "conn_1758090635620_zajj5r8g0",
+            "sourceNodeId": "1757930589538_qisfksbwz",
+            "targetNodeId": "1758090634327_mf36nwkdt",
+            "sourcePointType": "child",
+            "targetPointType": "parent"
+        }
+    ]
+}

bt-demo/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "kunpocreator",
+  "uuid": "f5d24040-9cd4-4a5a-8559-38bf55e621f7",
+  "creator": {
+    "version": "3.8.6"
+  },
+  "dependencies": {
+    "kunpocc-behaviortree": "^0.1.0",
+    "ts-node": "^10.9.2"
+  }
+}

bt-demo/settings/v2/packages/builder.json

@@ -0,0 +1,80 @@
+{
+  "__version__": "1.3.9",
+  "bundleConfig": {
+    "custom": {
+      "default": {
+        "displayName": "i18n:builder.asset_bundle.defaultConfig",
+        "configs": {
+          "native": {
+            "preferredOptions": {
+              "isRemote": false,
+              "compressionType": "merge_all_json"
+            }
+          },
+          "web": {
+            "preferredOptions": {
+              "isRemote": false,
+              "compressionType": "merge_dep"
+            },
+            "fallbackOptions": {
+              "compressionType": "merge_dep"
+            }
+          },
+          "miniGame": {
+            "fallbackOptions": {
+              "isRemote": true,
+              "compressionType": "merge_all_json"
+            },
+            "configMode": "fallback",
+            "overwriteSettings": {
+              "alipay-mini-game": {
+                "isRemote": true,
+                "compressionType": "merge_all_json"
+              },
+              "bytedance-mini-game": {
+                "isRemote": true,
+                "compressionType": "merge_all_json"
+              },
+              "fb-instant-games": {
+                "isRemote": true,
+                "compressionType": "merge_all_json"
+              },
+              "huawei-quick-game": {
+                "isRemote": true,
+                "compressionType": "merge_all_json"
+              },
+              "migu-mini-game": {
+                "isRemote": false,
+                "compressionType": "merge_all_json"
+              },
+              "oppo-mini-game": {
+                "isRemote": true,
+                "compressionType": "merge_all_json"
+              },
+              "taobao-mini-game": {
+                "isRemote": true,
+                "compressionType": "merge_all_json"
+              },
+              "vivo-mini-game": {
+                "isRemote": true,
+                "compressionType": "merge_all_json"
+              },
+              "wechatgame": {
+                "isRemote": true,
+                "compressionType": "merge_all_json"
+              },
+              "xiaomi-quick-game": {
+                "isRemote": true,
+                "compressionType": "merge_all_json"
+              },
+              "taobao-creative-app": {
+                "isRemote": true,
+                "compressionType": "merge_all_json"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

bt-demo/settings/v2/packages/cocos-service.json

@@ -0,0 +1,23 @@
+{
+  "__version__": "3.0.9",
+  "game": {
+    "name": "未知游戏",
+    "app_id": "UNKNOW",
+    "c_id": "0"
+  },
+  "appConfigMaps": [
+    {
+      "app_id": "UNKNOW",
+      "config_id": "8c18cb"
+    }
+  ],
+  "configs": [
+    {
+      "app_id": "UNKNOW",
+      "config_id": "8c18cb",
+      "config_name": "Default",
+      "config_remarks": "",
+      "services": []
+    }
+  ]
+}

bt-demo/settings/v2/packages/device.json

@@ -0,0 +1,3 @@
+{
+  "__version__": "1.0.1"
+}

bt-demo/settings/v2/packages/engine.json

@@ -0,0 +1,451 @@
+{
+  "__version__": "1.0.12",
+  "modules": {
+    "graphics": {
+      "pipeline": "legacy-pipeline"
+    },
+    "configs": {
+      "migrationsConfig": {
+        "cache": {
+          "base": {
+            "_value": true
+          },
+          "gfx-webgl": {
+            "_value": true
+          },
+          "gfx-webgl2": {
+            "_value": true
+          },
+          "gfx-webgpu": {
+            "_value": false
+          },
+          "animation": {
+            "_value": true
+          },
+          "skeletal-animation": {
+            "_value": true
+          },
+          "3d": {
+            "_value": false
+          },
+          "meshopt": {
+            "_value": false
+          },
+          "2d": {
+            "_value": true
+          },
+          "xr": {
+            "_value": false
+          },
+          "rich-text": {
+            "_value": true
+          },
+          "mask": {
+            "_value": true
+          },
+          "graphics": {
+            "_value": true
+          },
+          "ui-skew": {
+            "_value": false
+          },
+          "affine-transform": {
+            "_value": true
+          },
+          "ui": {
+            "_value": true
+          },
+          "particle": {
+            "_value": false
+          },
+          "physics": {
+            "_value": false,
+            "_option": "physics-ammo"
+          },
+          "physics-ammo": {
+            "_value": false,
+            "_flags": {
+              "LOAD_BULLET_MANUALLY": false
+            }
+          },
+          "physics-cannon": {
+            "_value": false
+          },
+          "physics-physx": {
+            "_value": false,
+            "_flags": {
+              "LOAD_PHYSX_MANUALLY": false
+            }
+          },
+          "physics-builtin": {
+            "_value": false
+          },
+          "physics-2d": {
+            "_value": true,
+            "_option": "physics-2d-builtin"
+          },
+          "physics-2d-box2d": {
+            "_value": false
+          },
+          "physics-2d-box2d-wasm": {
+            "_value": false,
+            "_flags": {
+              "LOAD_BOX2D_MANUALLY": false
+            }
+          },
+          "physics-2d-builtin": {
+            "_value": false
+          },
+          "physics-2d-box2d-jsb": {
+            "_value": false
+          },
+          "intersection-2d": {
+            "_value": true
+          },
+          "primitive": {
+            "_value": false
+          },
+          "profiler": {
+            "_value": true
+          },
+          "occlusion-query": {
+            "_value": false
+          },
+          "geometry-renderer": {
+            "_value": false
+          },
+          "debug-renderer": {
+            "_value": false
+          },
+          "particle-2d": {
+            "_value": true
+          },
+          "audio": {
+            "_value": true
+          },
+          "video": {
+            "_value": true
+          },
+          "webview": {
+            "_value": true
+          },
+          "tween": {
+            "_value": true
+          },
+          "websocket": {
+            "_value": true
+          },
+          "websocket-server": {
+            "_value": false
+          },
+          "terrain": {
+            "_value": false
+          },
+          "light-probe": {
+            "_value": false
+          },
+          "tiled-map": {
+            "_value": false
+          },
+          "vendor-google": {
+            "_value": false
+          },
+          "spine": {
+            "_value": true,
+            "_option": "spine-3.8"
+          },
+          "spine-3.8": {
+            "_value": true,
+            "_flags": {
+              "LOAD_SPINE_MANUALLY": false
+            }
+          },
+          "spine-4.2": {
+            "_value": false,
+            "_flags": {
+              "LOAD_SPINE_MANUALLY": false
+            }
+          },
+          "dragon-bones": {
+            "_value": false
+          },
+          "marionette": {
+            "_value": true
+          },
+          "procedural-animation": {
+            "_value": true
+          },
+          "custom-pipeline-post-process": {
+            "_value": false
+          },
+          "render-pipeline": {
+            "_value": true,
+            "_option": "legacy-pipeline"
+          },
+          "custom-pipeline": {
+            "_value": true
+          },
+          "legacy-pipeline": {
+            "_value": false
+          }
+        },
+        "flags": {
+          "LOAD_SPINE_MANUALLY": false
+        },
+        "name": "迁移生成的配置",
+        "includeModules": [
+          "2d",
+          "affine-transform",
+          "animation",
+          "audio",
+          "base",
+          "gfx-webgl",
+          "gfx-webgl2",
+          "graphics",
+          "intersection-2d",
+          "legacy-pipeline",
+          "marionette",
+          "mask",
+          "particle-2d",
+          "physics-2d-builtin",
+          "procedural-animation",
+          "profiler",
+          "rich-text",
+          "skeletal-animation",
+          "spine-3.8",
+          "tween",
+          "ui",
+          "video",
+          "websocket",
+          "webview"
+        ],
+        "noDeprecatedFeatures": {
+          "value": true,
+          "version": "<=3.8.0"
+        }
+      },
+      "defaultConfig": {
+        "name": "默认配置",
+        "cache": {
+          "base": {
+            "_value": true
+          },
+          "gfx-webgl": {
+            "_value": true
+          },
+          "gfx-webgl2": {
+            "_value": false
+          },
+          "gfx-webgpu": {
+            "_value": false
+          },
+          "animation": {
+            "_value": true
+          },
+          "skeletal-animation": {
+            "_value": true
+          },
+          "3d": {
+            "_value": false
+          },
+          "meshopt": {
+            "_value": false
+          },
+          "2d": {
+            "_value": true
+          },
+          "xr": {
+            "_value": false
+          },
+          "rich-text": {
+            "_value": true
+          },
+          "mask": {
+            "_value": true
+          },
+          "graphics": {
+            "_value": true
+          },
+          "ui-skew": {
+            "_value": false
+          },
+          "affine-transform": {
+            "_value": true
+          },
+          "ui": {
+            "_value": true
+          },
+          "particle": {
+            "_value": false
+          },
+          "physics": {
+            "_value": false,
+            "_option": "physics-ammo"
+          },
+          "physics-ammo": {
+            "_value": true,
+            "_flags": {
+              "LOAD_BULLET_MANUALLY": false
+            }
+          },
+          "physics-cannon": {
+            "_value": false
+          },
+          "physics-physx": {
+            "_value": false,
+            "_flags": {
+              "LOAD_PHYSX_MANUALLY": false
+            }
+          },
+          "physics-builtin": {
+            "_value": false
+          },
+          "physics-2d": {
+            "_value": true,
+            "_option": "physics-2d-builtin"
+          },
+          "physics-2d-box2d": {
+            "_value": true
+          },
+          "physics-2d-box2d-wasm": {
+            "_value": false,
+            "_flags": {
+              "LOAD_BOX2D_MANUALLY": false
+            }
+          },
+          "physics-2d-builtin": {
+            "_value": false
+          },
+          "physics-2d-box2d-jsb": {
+            "_value": false
+          },
+          "intersection-2d": {
+            "_value": true
+          },
+          "primitive": {
+            "_value": false
+          },
+          "profiler": {
+            "_value": true
+          },
+          "occlusion-query": {
+            "_value": false
+          },
+          "geometry-renderer": {
+            "_value": false
+          },
+          "debug-renderer": {
+            "_value": false
+          },
+          "particle-2d": {
+            "_value": true
+          },
+          "audio": {
+            "_value": true
+          },
+          "video": {
+            "_value": true
+          },
+          "webview": {
+            "_value": true
+          },
+          "tween": {
+            "_value": true
+          },
+          "websocket": {
+            "_value": true
+          },
+          "websocket-server": {
+            "_value": false
+          },
+          "terrain": {
+            "_value": false
+          },
+          "light-probe": {
+            "_value": false
+          },
+          "tiled-map": {
+            "_value": false
+          },
+          "vendor-google": {
+            "_value": false
+          },
+          "spine": {
+            "_value": true,
+            "_option": "spine-3.8"
+          },
+          "spine-3.8": {
+            "_value": true,
+            "_flags": {
+              "LOAD_SPINE_MANUALLY": false
+            }
+          },
+          "spine-4.2": {
+            "_value": false,
+            "_flags": {
+              "LOAD_SPINE_MANUALLY": false
+            }
+          },
+          "dragon-bones": {
+            "_value": false
+          },
+          "marionette": {
+            "_value": true
+          },
+          "procedural-animation": {
+            "_value": true
+          },
+          "custom-pipeline-post-process": {
+            "_value": false
+          },
+          "render-pipeline": {
+            "_value": true,
+            "_option": "custom-pipeline"
+          },
+          "custom-pipeline": {
+            "_value": true
+          },
+          "legacy-pipeline": {
+            "_value": false
+          }
+        },
+        "flags": {
+          "LOAD_SPINE_MANUALLY": false
+        },
+        "includeModules": [
+          "2d",
+          "affine-transform",
+          "animation",
+          "audio",
+          "base",
+          "custom-pipeline",
+          "gfx-webgl",
+          "graphics",
+          "intersection-2d",
+          "marionette",
+          "mask",
+          "particle-2d",
+          "physics-2d-builtin",
+          "procedural-animation",
+          "profiler",
+          "rich-text",
+          "skeletal-animation",
+          "spine-3.8",
+          "tween",
+          "ui",
+          "video",
+          "websocket",
+          "webview"
+        ],
+        "noDeprecatedFeatures": {
+          "value": true,
+          "version": "<=3.8.0"
+        }
+      }
+    },
+    "globalConfigKey": "defaultConfig"
+  },
+  "macroConfig": {
+    "BATCHER2D_MEM_INCREMENT": 288
+  }
+}

bt-demo/settings/v2/packages/information.json

@@ -0,0 +1,23 @@
+{
+  "__version__": "1.0.1",
+  "information": {
+    "customSplash": {
+      "id": "customSplash",
+      "label": "customSplash",
+      "enable": false,
+      "customSplash": {
+        "complete": false,
+        "form": "https://creator-api.cocos.com/api/form/show?"
+      }
+    },
+    "removeSplash": {
+      "id": "removeSplash",
+      "label": "removeSplash",
+      "enable": false,
+      "removeSplash": {
+        "complete": false,
+        "form": "https://creator-api.cocos.com/api/form/show?"
+      }
+    }
+  }
+}

bt-demo/settings/v2/packages/program.json

@@ -0,0 +1,3 @@
+{
+  "__version__": "1.0.4"
+}

bt-demo/settings/v2/packages/project.json

@@ -0,0 +1,29 @@
+{
+  "__version__": "1.0.6",
+  "general": {
+    "designResolution": {
+      "height": 1334,
+      "width": 750,
+      "fitHeight": true
+    },
+    "highQuality": false
+  },
+  "custom_joint_texture_layouts": [],
+  "script": {
+    "preserveSymlinks": true
+  },
+  "layer": [
+    {
+      "name": "Window",
+      "value": 1
+    },
+    {
+      "name": "Game",
+      "value": 2
+    },
+    {
+      "name": "Graphics",
+      "value": 4
+    }
+  ]
+}

bt-demo/settings/v2/packages/scene.json

@@ -0,0 +1,4 @@
+{
+  "__version__": "1.0.3",
+  "current-scene": "bef93422-3e63-4c0f-a5cf-d926e7360673"
+}

bt-demo/tsconfig.json

@@ -0,0 +1,10 @@
+{
+    /* Base configuration. Do not edit this field. */
+    "extends": "./temp/tsconfig.cocos.json",
+    /* Add your custom configuration here. */
+    "compilerOptions": {
+        "strict": false,
+        "module": "ES6",
+        "target": "ES6"
+    }
+}

package.json

@@ -1,6 +1,6 @@
 {
     "name": "kunpocc-behaviortree",
-    "version": "0.0.2",
+    "version": "0.1.0",
     "description": "行为树",
     "main": "./dist/kunpocc-behaviortree.cjs",
     "module": "./dist/kunpocc-behaviortree.mjs",
@@ -19,7 +19,8 @@
     },
     "scripts": {
         "clean": "rm -rf dist",
-        "build": "npm run clean && rollup -c rollup.config.mjs"
+        "copy": "cp -r dist/* ./bt-demo/node_modules/kunpocc-behaviortree/dist/",
+        "build": "npm run clean && rollup -c rollup.config.mjs && npm run copy"
     },
     "files": [
         "dist/kunpocc-behaviortree.cjs",

rollup.config.mjs

@@ -5,7 +5,7 @@ import dts from 'rollup-plugin-dts';
 export default [
     {
         // 生成未压缩的 JS 文件
-        input: 'src/kunpocc-behaviortree.ts',
+        input: 'src/index.ts',
         external: ['cc', 'fairygui-cc'],
         output: [
             {
@@ -26,9 +26,9 @@ export default [
                 compilerOptions: {
                     target: "es6",
                     module: "es6",
-                    experimentalDecorators: true, // 启用ES装饰器。
+                    experimentalDecorators: true, // 启用ES装饰器
                     strict: true,
-                    strictNullChecks: false,
+                    strictNullChecks: true,
                     moduleResolution: "Node",
                     skipLibCheck: true,
                     esModuleInterop: true,
@@ -38,7 +38,7 @@ export default [
     },
     {
         // 生成压缩的 JS 文件
-        input: 'src/kunpocc-behaviortree.ts',
+        input: 'src/index.ts',
         external: ['cc', 'fairygui-cc'],
         output: [
             {
@@ -59,9 +59,9 @@ export default [
                 compilerOptions: {
                     target: "es6",
                     module: "es6",
-                    experimentalDecorators: true, // 启用ES装饰器。
+                    experimentalDecorators: true, // 启用ES装饰器
                     strict: true,
-                    strictNullChecks: false,
+                    strictNullChecks: true,
                     moduleResolution: "Node",
                     skipLibCheck: true,
                     esModuleInterop: true,
@@ -72,7 +72,7 @@ export default [
     },
     {
         // 生成声明文件的配置
-        input: 'src/kunpocc-behaviortree.ts',
+        input: 'src/index.ts',
         output: {
             file: 'dist/kunpocc-behaviortree.d.ts',
             format: 'es'

src/behaviortree/Agent.ts

@@ -1,48 +0,0 @@
-import { BehaviorTree } from "./BehaviorTree";
-import { Blackboard } from "./Blackboard";
-import { Ticker } from "./Ticker";
-
-/** 代理 */
-export class Agent {
-    /** 行为树 */
-    public tree: BehaviorTree;
-    /** 黑板 */
-    public blackboard: Blackboard;
-    /** 更新器 */
-    public ticker: Ticker;
-    /**
-     * constructor
-     * @param subject // 主体
-     * @param tree 行为树
-     */
-    constructor(subject: any, tree: BehaviorTree) {
-        this.tree = tree;
-        this.blackboard = new Blackboard();
-        this.ticker = new Ticker(subject, this.blackboard, tree);
-    }
-
-    /**
-     * 执行
-     */
-    public tick(): void {
-        this.tree.tick(this.ticker.subject, this.blackboard, this.ticker);
-        if (this.blackboard.interrupt) {
-            this.blackboard.interrupt = false;
-
-            let ticker = this.ticker;
-            ticker.openNodes.length = 0;
-            ticker.nodeCount = 0;
-
-            this.blackboard.clear();
-        }
-    }
-
-    /**
-     * 打断行为树，重新开始执行（如果当前在节点中，下一帧才会清理）
-     */
-    public interruptBTree(): void {
-        if (!this.blackboard.interruptDefend) {
-            this.blackboard.interrupt = true;
-        }
-    }
-}

src/behaviortree/BT.ts

@@ -0,0 +1,216 @@
+/**
+ * 行为树装饰器和元数据管理
+ * 用于编辑器显示和配置节点信息
+ */
+
+export namespace BT {
+    /**
+     * 参数类型枚举
+     */
+    export enum ParamType {
+        int = "number",
+        float = "float",
+        string = "string",
+        bool = "boolean"
+    }
+
+    /**
+     * 节点类型枚举
+     */
+    export enum Type {
+        /** 行为节点 */
+        Action = "action",
+        /** 条件节点 */
+        Condition = "condition",
+        /** 组合节点 */
+        Composite = "composite",
+        /** 装饰节点 */
+        Decorator = "decorator"
+    }
+
+    /**
+     * 参数描述接口
+     */
+    export interface ParameterInfo {
+        /** 参数名称 */
+        name: string;
+        /** 参数类型 */
+        type: ParamType;
+        /** 参数描述 */
+        description?: string;
+        /** 默认值 */
+        defaultValue?: any;
+        /** 步进 针对数字类型的变更的最小单位 */
+        step?: number,
+        /** 最小值 */
+        min?: number,
+        /** 最大值 */
+        max?: number,
+    }
+
+    /**
+     * 节点元数据接口
+     */
+    export interface NodeMetadata {
+        /** 节点名称 */
+        name: string;
+        /** 节点类名 */
+        className: string;
+        /** 节点分组 */
+        group: string;
+        /** 节点类型 */
+        type: Type;
+        /** 节点描述 */
+        description: string;
+        /** 参数列表 */
+        parameters: ParameterInfo[];
+        /** 最大子节点数量：0=不允许子节点，1=最多一个子节点，-1=无限制 */
+        maxChildren: number;
+    }
+
+    /** 
+     * 注册节点名 到 节点构造函数的映射
+     */
+    const NODE_NAME_TO_CONSTRUCTOR_MAP = new Map<string, any>();
+
+    /**
+     * 节点元数据存储
+     */
+    const NODE_METADATA_MAP = new Map<any, NodeMetadata>();
+
+    /**
+     * 节点参数存储
+     */
+    const NODE_PARAMETERS_MAP = new Map<any, ParameterInfo[]>();
+
+    /**
+     * 节点属性装饰器
+     */
+    export function prop(paramInfo: Omit<ParameterInfo, "name">) {
+        return function (target: any, propertyKey: string) {
+            const ctor = target.constructor;
+            if (!NODE_PARAMETERS_MAP.has(ctor)) {
+                NODE_PARAMETERS_MAP.set(ctor, []);
+            }
+            const parameters = NODE_PARAMETERS_MAP.get(ctor)!;
+            parameters.push({
+                ...paramInfo,
+                name: propertyKey
+            });
+        };
+    }
+
+    /**
+     * 行为节点装饰器
+     * @param name 节点的类名 编辑器导出数据中的节点名字
+     * @param info.group 节点在编辑器中的分组
+     * @param info.name 节点在编辑器中的中文名
+     * @param info.desc 节点描述信息
+     */
+    export function ClassAction(name: string, info?: { group?: string, name?: string, desc?: string }) {
+        return function <T extends new (...args: any[]) => any>(constructor: T) {
+            const parameters = NODE_PARAMETERS_MAP.get(constructor) || [];
+            const fullMetadata: NodeMetadata = {
+                className: name,
+                group: info?.group || '未分组',
+                name: info?.name || '',
+                description: info?.desc || '',
+                type: Type.Action,
+                maxChildren: 0,
+                parameters
+            };
+            NODE_METADATA_MAP.set(constructor, fullMetadata);
+            NODE_NAME_TO_CONSTRUCTOR_MAP.set(name, constructor);
+            return constructor;
+        };
+    }
+
+    /**
+     * 条件节点装饰器
+     */
+    export function ClassCondition(name: string, info?: { group?: string, name?: string, desc?: string }) {
+        return function <T extends new (...args: any[]) => any>(constructor: T) {
+            const parameters = NODE_PARAMETERS_MAP.get(constructor) || [];
+            const fullMetadata: NodeMetadata = {
+                className: name,
+                group: info?.group || '未分组',
+                name: info?.name || '',
+                description: info?.desc || '',
+                type: Type.Condition,
+                maxChildren: 0,
+                parameters
+            };
+            NODE_METADATA_MAP.set(constructor, fullMetadata);
+            NODE_NAME_TO_CONSTRUCTOR_MAP.set(name, constructor);
+            return constructor;
+        };
+    }
+
+    /**
+     * 组合节点装饰器
+     */
+    export function ClassComposite(name: string, info?: { group?: string, name?: string, desc?: string }) {
+        return function <T extends new (...args: any[]) => any>(constructor: T) {
+            const parameters = NODE_PARAMETERS_MAP.get(constructor) || [];
+            const fullMetadata: NodeMetadata = {
+                className: name,
+                group: info?.group || '未分组',
+                name: info?.name || '',
+                description: info?.desc || '',
+                type: Type.Composite,
+                maxChildren: -1,
+                parameters
+            };
+            NODE_METADATA_MAP.set(constructor, fullMetadata);
+            NODE_NAME_TO_CONSTRUCTOR_MAP.set(name, constructor);
+            return constructor;
+        };
+    }
+
+    /**
+     * 装饰节点装饰器
+     */
+    export function ClassDecorator(name: string, info?: { group?: string, name?: string, desc?: string }) {
+        return function <T extends new (...args: any[]) => any>(constructor: T) {
+            const parameters = NODE_PARAMETERS_MAP.get(constructor) || [];
+            const fullMetadata: NodeMetadata = {
+                className: name,
+                group: info?.group || '未分组',
+                name: info?.name || '',
+                description: info?.desc || '',
+                type: Type.Decorator,
+                maxChildren: 1,
+                parameters
+            };
+            NODE_METADATA_MAP.set(constructor, fullMetadata);
+            NODE_NAME_TO_CONSTRUCTOR_MAP.set(name, constructor);
+            return constructor;
+        };
+    }
+
+    /**
+     * 获取所有节点元数据
+     */
+    export function getAllNodeMetadata(): Map<any, NodeMetadata> {
+        return new Map(NODE_METADATA_MAP);
+    }
+
+    /**
+     * 通过节点名 获取 节点构造函数
+     */
+    export function getNodeConstructor(name: string): any {
+        return NODE_NAME_TO_CONSTRUCTOR_MAP.get(name);
+    }
+
+    /**
+     * 通过节点构造函数 找到节点元数据
+     */
+    export function getNodeMetadata(ctor: any): NodeMetadata {
+        return NODE_METADATA_MAP.get(ctor)!;
+    }
+}
+
+let _global = globalThis || window || global;
+(_global as any)["getKunpoBTNodeMaps"] = function () {
+    return BT.getAllNodeMetadata();
+};

src/behaviortree/BTNode/Action.ts

@@ -1,117 +1,45 @@
+import { BT } from "../BT";
 import { Status } from "../header";
-import { Ticker } from "../Ticker";
+import { BTNode } from "./BTNode";
-import { BaseNode } from "./BaseNode";
 
 /**
- * 动作节点
+ * 叶子节点 基类
  * 没有子节点
  */
-export abstract class Action extends BaseNode {
+export abstract class LeafNode extends BTNode {
     constructor() {
-        super();
+        super([]);
     }
 }
 
-/**
- * 失败节点(无子节点)
- * 直接返回FAILURE
- */
-export class Failure extends Action {
-    /** 执行函数 @internal */
-    private _func: () => void;
-    constructor(func: () => void) {
-        super();
-        this._func = func;
-    }
-
-    /**
-     * 执行
-     * @param {Ticker} ticker 
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
-        this._func();
-        return Status.FAILURE;
-    }
-}
-
-/**
- * 逻辑节点，一直执行 (无子节点)
- * 直接返回RUNING
- */
-export class Running extends Action {
-    /** 执行函数 @internal */
-    private _func: () => void;
-    constructor(func: () => void) {
-        super();
-        this._func = func;
-    }
-
-    /**
-     * 执行
-     * @param {Ticker} ticker 
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
-        this._func();
-        return Status.RUNNING;
-    }
-}
-
-/**
- * 成功节点 无子节点
- * 直接返回SUCCESS
- */
-export class Success extends Action {
-    /** 执行函数 @internal */
-    private _func: () => void;
-    constructor(func: () => void) {
-        super();
-        this._func = func;
-    }
-
-    /**
-     * 执行
-     * @param {Ticker} ticker 
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
-        this._func();
-        return Status.SUCCESS;
-    }
-}
 /**
  * 次数等待节点(无子节点)
- * 次数内，返回RUNING
+ * 次数内，返回RUNNING
  * 超次，返回SUCCESS
  */
-export class WaitTicks extends Action {
+@BT.ClassAction("WaitTicks", {
-    /** 最大次数 @internal */
+    name: "等待次数",
-    private _maxTicks: number;
+    group: "基础行为节点",
-    /** 经过的次数 @internal */
+    desc: "等待指定次数后返回成功",
-    private _elapsedTicks: number;
+})
+export class WaitTicks extends LeafNode {
+    @BT.prop({ type: BT.ParamType.int, description: "最大等待次数", defaultValue: 0, step: 1 })
+    private _max: number;
+    private _value: number;
+
     constructor(maxTicks: number = 0) {
         super();
-        this._maxTicks = maxTicks;
+        this._max = maxTicks;
-        this._elapsedTicks = 0;
+        this._value = 0;
     }
 
-    /**
+    protected override open(): void {
-     * 打开
+        super.open();
-     * @param {Ticker} ticker 
+        this._value = 0;
-     */
-    public open(ticker: Ticker): void {
-        this._elapsedTicks = 0;
     }
 
-    /**
+    public tick(): Status {
-     * 执行
+        if (++this._value >= this._max) {
-     * @param {Ticker} ticker 
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
-        if (++this._elapsedTicks >= this._maxTicks) {
-            this._elapsedTicks = 0;
             return Status.SUCCESS;
         }
         return Status.RUNNING;
@@ -119,71 +47,33 @@ export class WaitTicks extends Action {
 }
 
 /**
- * 时间等待节点(无子节点)
+ * 时间等待节点 时间(秒) 
- * 时间到后返回SUCCESS，否则返回RUNING
+ * 时间到后返回SUCCESS，否则返回RUNNING
  */
-export class WaitTime extends Action {
+@BT.ClassAction("WaitTime", {
-    /** 等待时间(秒 s) @internal */
+    name: "等待时间",
-    private _duration: number;
+    group: "基础行为节点",
+    desc: "等待指定时间(秒)后返回成功",
+})
+export class WaitTime extends LeafNode {
+    @BT.prop({ type: BT.ParamType.float, description: "等待时间(秒)", defaultValue: 0, step: 0.01 })
+    private _max: number;
+    private _value: number = 0;
     constructor(duration: number = 0) {
         super();
-        this._duration = duration * 1000;
+        this._max = duration;
     }
 
-    /**
+    protected override open(): void {
-     * 打开
+        super.open();
-     * @param {Ticker} ticker 
+        this._value = 0;
-     */
-    public open(ticker: Ticker): void {
-        let startTime = new Date().getTime();
-        ticker.blackboard.set("startTime", startTime, ticker.tree.id, this.id);
     }
 
-    /**
+    public tick(dt: number): Status {
-     * 执行
+        this._value += dt;
-     * @param {Ticker} ticker 
+        if (this._value >= this._max) {
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
-        let currTime = new Date().getTime();
-        let startTime = ticker.blackboard.get("startTime", ticker.tree.id, this.id);
-        if (currTime - startTime >= this._duration) {
             return Status.SUCCESS;
         }
         return Status.RUNNING;
     }
 }
-
-/**
- * 行为树防止被打断节点
- * 直接返回 SUCCESS
- * 和 InterruptDefendCancel 必须成对出现
- */
-export class InterruptDefend extends Action {
-    /**
-     * 执行
-     * @param {Ticker} ticker 
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
-        ticker.blackboard.interruptDefend = true;
-        return Status.SUCCESS;
-    }
-}
-
-/**
- * 行为树被打断取消节点
- * 直接返回 SUCCESS
- * 和 InterruptDefend 必须成对出现
- */
-export class InterruptDefendCancel extends Action {
-    /**
-     * 执行
-     * @param {Ticker} ticker 
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
-        ticker.blackboard.interruptDefend = false;
-        return Status.SUCCESS;
-    }
-}

src/behaviortree/BTNode/BTNode.ts

@@ -0,0 +1,154 @@
+import { globalBlackboard, IBlackboard } from "../Blackboard";
+import { Status } from "../header";
+
+export interface IBTNode {
+    readonly children: IBTNode[];
+    /** 本节点的的黑板引用 */
+    local: IBlackboard;
+    /**
+     * 初始化节点
+     * @param root 树根节点的黑板
+     * @param parent 父节点的黑板
+     */
+    _initialize(root: IBlackboard, parent: IBlackboard): void;
+
+    /**
+     * @internal
+     */
+    _execute(dt: number): Status;
+    tick(dt: number): Status;
+
+    /**
+     * 优先写入自己的黑板数据, 如果没有则写入父节点的黑板数据
+     */
+    set<T>(key: string, value: T): void;
+    get<T>(key: string): T;
+
+    /**
+     * 写入树根节点的黑板数据
+     */
+    setRoot<T>(key: string, value: T): void;
+    getRoot<T>(key: string): T;
+
+    /**
+     * 写入全局黑板数据
+     */
+    setGlobal<T>(key: string, value: T): void;
+    getGlobal<T>(key: string): T;
+
+    /** 获取关联的实体 */
+    getEntity<T>(): T;
+}
+
+
+/**
+ * 基础节点
+ * 每个节点只管理自己需要的状态
+ */
+export abstract class BTNode implements IBTNode {
+    public readonly children: IBTNode[];
+
+    /** 树根节点的黑板引用 */
+    protected _root!: IBlackboard;
+
+    /** 本节点的的黑板引用 可能等于 _parent */
+    protected _local!: IBlackboard;
+
+    constructor(children?: IBTNode[]) {
+        this.children = children ? [...children] : [];
+    }
+
+    public _initialize(root: IBlackboard, parent: IBlackboard): void {
+        this._root = root;
+        // 在需要的节点中重写，创建新的local
+        this._local = parent;
+    }
+
+    /**
+     * @internal
+     */
+    public _execute(dt: number): Status {
+        // 首次执行时初始化
+        const isRunning = this._local.openNodes.get(this) || false;
+        if (!isRunning) {
+            this._local.openNodes.set(this, true);
+            this.open();
+        }
+
+        // 执行核心逻辑
+        const status = this.tick(dt);
+
+        // 执行完成时清理
+        if (status !== Status.RUNNING) {
+            this._local.openNodes.delete(this);
+            this.close();
+        }
+        return status;
+    }
+
+    /**
+     * 初始化节点（首次执行时调用）
+     * 子类重写此方法进行状态初始化
+     */
+    protected open(): void { }
+    protected close(): void { }
+    /**
+     * 清理子节点的打开状态
+     * 一般用于装饰节点的非子节点关闭时， 用来清理子节点的打开状态
+     */
+    protected cleanupChild(): void {
+        const child = this.children[0];
+        if (child && this._local.openNodes.has(child)) {
+            this._local.openNodes.delete(child);
+            (child as BTNode).close();
+        }
+    }
+
+    /**
+     * 执行节点逻辑
+     * 子类必须实现此方法
+     * @returns 执行状态
+     */
+    public abstract tick(dt: number): Status;
+
+    public getEntity<T>(): T {
+        return this._local.getEntity();
+    }
+
+    /**
+     * 设置获取全局黑板数据
+     */
+    public set<T>(key: string, value: T): void {
+        this._local.set(key, value);
+    }
+
+    public get<T>(key: string): T {
+        return this._local.get(key);
+    }
+
+    /**
+     * 设置获取树根节点的黑板数据
+     */
+    public setRoot<T>(key: string, value: T): void {
+        this._root.set(key, value);
+    }
+
+    public getRoot<T>(key: string): T {
+        return this._root.get(key);
+    }
+
+    /** 
+     * 设置全局黑板数据 
+     */
+    public setGlobal<T>(key: string, value: T): void {
+        globalBlackboard.set(key, value);
+    }
+
+    public getGlobal<T>(key: string): T {
+        return globalBlackboard.get(key);
+    }
+
+    public get local(): IBlackboard {
+        return this._local;
+    }
+}

src/behaviortree/BTNode/BaseNode.ts

@@ -1,113 +0,0 @@
-import { createUUID, Status } from "../header";
-import { Ticker } from "../Ticker";
-
-/**
- * 基础节点
- * 所有节点全部继承自 BaseNode
- */
-export abstract class BaseNode {
-    /** 唯一标识 */
-    public id: string;
-    /** 子节点 */
-    public children: BaseNode[];
-
-    /**
-     * 创建
-     * @param children 子节点列表
-     */
-    constructor(children?: BaseNode[]) {
-        this.id = createUUID();
-        this.children = [];
-        if (!children) {
-            return;
-        }
-        for (let i = 0; i < children.length; i++) {
-            this.children.push(children[i]);
-        }
-    }
-
-    /**
-     * 执行节点
-     * @param ticker 更新器
-     * @returns {Status} 状态
-     */
-    public _execute(ticker: Ticker): Status {
-        /* ENTER */
-        this._enter(ticker);
-        if (!ticker.blackboard.get("isOpen", ticker.tree.id, this.id)) {
-            this._open(ticker);
-        }
-        let status = this._tick(ticker);
-        if (status !== Status.RUNNING) {
-            this._close(ticker);
-        }
-        this._exit(ticker);
-        return status;
-    }
-
-    /**
-     * 进入节点
-     * @param ticker 更新器
-     * @internal
-     */
-    public _enter(ticker: Ticker): void {
-        ticker.enterNode(this);
-        this.enter(ticker);
-    }
-
-    /**
-     * 打开节点
-     * @param ticker 更新器
-     * @internal
-     */
-    public _open(ticker: Ticker): void {
-        ticker.openNode(this);
-        ticker.blackboard.set("isOpen", true, ticker.tree.id, this.id);
-        this.open(ticker);
-    }
-
-    /**
-     * 更新节点
-     * @param ticker 更新器
-     * @internal
-     */
-    public _tick(ticker: Ticker): Status {
-        ticker.tickNode(this);
-        return this.tick(ticker);
-    }
-
-    /**
-     * 关闭节点
-     * @param ticker 更新器
-     * @internal
-     */
-    public _close(ticker: Ticker): void {
-        ticker.closeNode(this);
-        ticker.blackboard.set("isOpen", false, ticker.tree.id, this.id);
-        this.close(ticker);
-    }
-
-    /**
-     * 退出节点
-     * @param ticker 更新器
-     * @internal
-     */
-    public _exit(ticker: Ticker): void {
-        ticker.exitNode(this);
-        this.exit(ticker);
-    }
-
-    enter(ticker: Ticker): void {
-
-    }
-    open(ticker: Ticker): void {
-
-    }
-    close(ticker: Ticker): void {
-
-    }
-    exit(ticker: Ticker): void {
-
-    }
-    abstract tick(ticker: Ticker): Status;
-}

src/behaviortree/BTNode/Composite.ts

@@ -1,176 +1,104 @@
+import { IBlackboard } from "../Blackboard";
+import { BT } from "../BT";
 import { Status } from "../header";
-import { Ticker } from "../Ticker";
+import { BTNode, IBTNode } from "./BTNode";
-import { BaseNode } from "./BaseNode";
+import { WeightDecorator } from "./Decorator";
 
 /**
- * 可以包含多个节点的集合装饰器基类
+ * 组合节点基类
- *
+ * 有多个子节点
  */
-export abstract class Composite extends BaseNode {
+export abstract class Composite extends BTNode {
-    constructor(...children: BaseNode[]) {
+    constructor(...children: IBTNode[]) {
         super(children);
     }
 }
 
 /**
- * 记忆选择节点
+ * 记忆选择节点 从上到下执行
- * 选择不为 FAILURE 的节点
+ * 遇到 FAILURE 继续下一个 
- * 任意一个Child Node返回不为 FAILURE, 本Node向自己的Parent Node也返回Child Node状态
+ * 遇到 SUCCESS 返回 SUCCESS 下次重新开始
- */
+ * 
-export class MemSelector extends Composite {
+ * 遇到 RUNNING 返回 RUNNING 下次从该节点开始
-    /**
-     * 打开
-     * @param {Ticker} ticker 
-     */
-    public open(ticker: Ticker): void {
-        super.open(ticker);
-        ticker.blackboard.set("runningChild", 0, ticker.tree.id, this.id);
-    }
-
-    /**
-     * 执行
-     * @param {Ticker} ticker 
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
-        let childIndex = ticker.blackboard.get("runningChild", ticker.tree.id, this.id) as number;
-
-        for (let i = childIndex; i < this.children.length; i++) {
-            let status = this.children[i]._execute(ticker);
-
-            if (status !== Status.FAILURE) {
-                if (status === Status.RUNNING) {
-                    ticker.blackboard.set("runningChild", i, ticker.tree.id, this.id);
-                }
-                return status;
-            }
-        }
-
-        return Status.FAILURE;
-    }
-}
-
-/**
- * 记忆顺序节点
- * 如果上次执行到 RUNING 的节点, 下次进入节点后, 直接从 RUNING 节点开始
- * 遇到 RUNING 或者 FAILURE 停止迭代
- * 任意一个Child Node返回不为 SUCCESS, 本Node向自己的Parent Node也返回Child Node状态
- * 所有节点都返回 SUCCESS, 本节点才返回 SUCCESS
- */
-export class MemSequence extends Composite {
-    /**
-     * 打开
-     * @param {Ticker} ticker 
-     */
-    public open(ticker: Ticker): void {
-        super.open(ticker);
-        ticker.blackboard.set("runningChild", 0, ticker.tree.id, this.id);
-    }
-
-    /**
-     * 执行
-     * @param {Ticker} ticker 
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
-        let childIndex = ticker.blackboard.get("runningChild", ticker.tree.id, this.id) as number;
-        for (let i = childIndex; i < this.children.length; i++) {
-            let status = this.children[i]._execute(ticker);
-            if (status !== Status.SUCCESS) {
-                if (status === Status.RUNNING) {
-                    ticker.blackboard.set("runningChild", i, ticker.tree.id, this.id);
-                }
-                return status;
-            }
-        }
-        return Status.SUCCESS;
-    }
-}
-
-/**
- * 随机选择节点
- * 从Child Node中随机选择一个执行
- */
-export class RandomSelector extends Composite {
-    /**
-     * 执行
-     * @param {Ticker} ticker 
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
-        let childIndex = (Math.random() * this.children.length) | 0;
-        let child = this.children[childIndex];
-        let status = child._execute(ticker);
-
-        return status;
-    }
-}
-
-/**
- * 选择节点，选择不为 FAILURE 的节点
- * 当执行本类型Node时，它将从begin到end迭代执行自己的Child Node：
- * 如遇到一个Child Node执行后返回 SUCCESS 或者 RUNING，那停止迭代，本Node向自己的Parent Node也返回 SUCCESS 或 RUNING
  */
+@BT.ClassComposite("Selector", { name: "选择节点", group: "基础组合节点", desc: "选择节点" })
 export class Selector extends Composite {
-    /**
+    public override _initialize(global: IBlackboard, branch: IBlackboard): void {
-     * 执行
+        super._initialize(global, branch);
-     * @param {Ticker} ticker 
+        this._local = branch.createChild();
-     * @returns {Status} 
+    }
-     */
+
-    public tick(ticker: Ticker): Status {
+    protected override open(): void {
-        for (let i = 0; i < this.children.length; i++) {
+        super.open();
-            let status = this.children[i]._execute(ticker);
+        this.set(`__nRunningIndex`, 0);
-            if (status !== Status.FAILURE) {
+    }
+
+    public tick(dt: number): Status {
+        let index = this.get<number>(`__nRunningIndex`);
+        for (let i = index; i < this.children.length; i++) {
+            let status = this.children[i]!._execute(dt);
+            if (status === Status.FAILURE) {
+                continue;
+            }
+            if (status === Status.SUCCESS) {
                 return status;
             }
+            this.set(`__nRunningIndex`, i);
+            return Status.RUNNING;
         }
         return Status.FAILURE;
     }
 }
 
 /**
- * 顺序节点
+ * 顺序节点 从上到下执行
- * 当执行本类型Node时，它将从begin到end迭代执行自己的Child Node：
+ * 遇到 SUCCESS 继续下一个
- * 遇到 FAILURE 或 RUNING, 那停止迭代，返回FAILURE 或 RUNING
+ * 遇到 FAILURE 停止迭代 返回 FAILURE 下次重新开始
- * 所有节点都返回 SUCCESS, 本节点才返回 SUCCESS
+ * 
+ * 遇到 RUNNING 返回 RUNNING 下次从该节点开始
  */
+@BT.ClassComposite("Sequence", { name: "顺序节点", group: "基础组合节点", desc: "顺序节点" })
 export class Sequence extends Composite {
-    /**
+    public override _initialize(global: IBlackboard, branch: IBlackboard): void {
-     * 执行
+        super._initialize(global, branch);
-     * @param {Ticker} ticker 
+        this._local = branch.createChild();
-     * @returns {Status} 
+    }
-     */
+
-    public tick(ticker: Ticker): Status {
+    protected override open(): void {
-        for (let i = 0; i < this.children.length; i++) {
+        super.open();
-            let status = this.children[i]._execute(ticker);
+        this.set(`__nRunningIndex`, 0);
-            if (status !== Status.SUCCESS) {
+    }
-                return status;
+
+    public tick(dt: number): Status {
+        let index = this.get<number>(`__nRunningIndex`);
+        for (let i = index; i < this.children.length; i++) {
+            let status = this.children[i]!._execute(dt);
+            if (status === Status.SUCCESS) {
+                continue;
             }
+            if (status === Status.FAILURE) {
+                return Status.FAILURE;
+            }
+            this.set(`__nRunningIndex`, i);
+            return Status.RUNNING;
         }
         return Status.SUCCESS;
     }
 }
 
 /**
- * 并行节点 每次进入全部重新执行一遍
+ * 并行节点 从上到下执行 全部执行一遍
- * 当执行本类型Node时，它将从begin到end迭代执行自己的Child Node：
+ * 返回优先级 FAILURE > RUNNING > SUCCESS
- * 1. 当存在Child Node执行后返回 FAILURE, 本节点返回 FAILURE
- * 2. 当存在Child Node执行后返回 RUNING, 本节点返回 RUNING
- * 所有节点都返回 SUCCESS, 本节点才返回 SUCCESS
  */
+@BT.ClassComposite("Parallel", { name: "并行节点", group: "基础组合节点", desc: "同时执行所有子节点，全部成功才返回成功" })
 export class Parallel extends Composite {
-    /**
+    public tick(dt: number): Status {
-     * 执行
-     * @param {Ticker} ticker 
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
         let result = Status.SUCCESS;
         for (let i = 0; i < this.children.length; i++) {
-            let status = this.children[i]._execute(ticker);
+            let status = this.children[i]!._execute(dt);
-            if (status == Status.FAILURE) {
+            if (result === Status.FAILURE || status === Status.FAILURE) {
                 result = Status.FAILURE;
-            } else if (result == Status.SUCCESS && status == Status.RUNNING) {
+            } else if (status === Status.RUNNING) {
                 result = Status.RUNNING;
             }
         }
@@ -178,27 +106,82 @@ export class Parallel extends Composite {
     }
 }
 
+
 /**
- * 并行节点 每次进入全部重新执行一遍
+ * 随机选择节点
- * 当执行本类型Node时，它将从begin到end迭代执行自己的Child Node：
+ * 随机选择一个子节点执行
- * 1. 当存在Child Node执行后返回 FAILURE, 本节点返回 FAILURE
+ * 返回子节点状态
- * 2. 任意 Child Node 返回 SUCCESS, 本节点返回 SUCCESS
- * 否则返回 RUNNING
  */
+@BT.ClassComposite("RandomSelector", {
+    name: "随机选择节点",
+    group: "基础组合节点",
+    desc: "随机选择一个子节点执行",
+})
+export class RandomSelector extends Composite {
+    private _totalWeight: number = 0;
+    private _weights: number[] = [];
+
+    constructor(...children: IBTNode[]) {
+        super(...children);
+        this._totalWeight = 0;
+        this._weights = [];
+
+        for (const child of children) {
+            const weight = this.getChildWeight(child);
+            this._totalWeight += weight;
+            this._weights.push(this._totalWeight);
+        }
+    }
+
+    private getChildWeight(child: IBTNode): number {
+        return (child instanceof WeightDecorator) ? (child.weight) : 1;
+    }
+
+    public tick(dt: number): Status {
+        if (this.children.length === 0) {
+            return Status.FAILURE;
+        }
+
+        // 基于权重的随机选择
+        const randomValue = Math.random() * this._totalWeight;
+
+        // 使用二分查找找到对应的子节点索引（O(log n)复杂度）
+        let left = 0;
+        let right = this._weights.length - 1;
+        let childIndex = 0;
+
+        while (left <= right) {
+            const mid = Math.floor((left + right) / 2);
+            if (this._weights[mid]! > randomValue) {
+                childIndex = mid;
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        const status = this.children[childIndex]!._execute(dt);
+        return status;
+    }
+}
+
+/**
+ * 并行节点 从上到下执行 全部执行一遍
+ * 返回优先级 SUCCESS > RUNNING > FAILURE
+ */
+@BT.ClassComposite("ParallelAnySuccess", {
+    name: "并行任意成功",
+    group: "基础组合节点",
+    desc: "同时执行所有子节点，任意一个成功即返回成功",
+})
 export class ParallelAnySuccess extends Composite {
-    /**
+    public tick(dt: number): Status {
-     * 执行
+        let result = Status.FAILURE;
-     * @param {Ticker} ticker 
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
-        let result = Status.RUNNING;
         for (let i = 0; i < this.children.length; i++) {
-            let status = this.children[i]._execute(ticker);
+            let status = this.children[i]!._execute(dt);
-            if (status == Status.FAILURE) {
+            if (result === Status.SUCCESS || status === Status.SUCCESS) {
-                result = Status.FAILURE;
-            } else if (result == Status.RUNNING && status == Status.SUCCESS) {
                 result = Status.SUCCESS;
+            } else if (status === Status.RUNNING) {
+                result = Status.RUNNING;
             }
         }
         return result;

src/behaviortree/BTNode/Condition.ts

@@ -1,24 +1,21 @@
-import { Status } from "../header";
-import { Ticker } from "../Ticker";
-import { Action } from "./Action";
-
 /**
- * 条件节点
+ * @Author: Gongxh
+ * @Date: 2025-09-17
+ * @Description: 条件节点基类
  */
-export class Condition extends Action {
-    /** 执行函数 @internal */
-    private _func: (subject: any) => boolean = null;
-    constructor(func: (subject: any) => boolean) {
-        super();
-        this._func = func;
-    }
 
+import { Status } from "../header";
+import { LeafNode } from "./Action";
+
+/** 条件叶子节点 */
+export abstract class Condition extends LeafNode {
     /**
-     * 执行
+     * 判断是否满足条件
-     * @param {Ticker} ticker 
+     * @returns 是否满足条件
-     * @returns {Status} 
      */
-    public tick(ticker: Ticker): Status {
+    protected abstract isEligible(): boolean;
-        return this._func(ticker.subject) ? Status.SUCCESS : Status.FAILURE;
+
+    public tick(): Status {
+        return this.isEligible() ? Status.SUCCESS : Status.FAILURE;
     }
 }

src/behaviortree/BTNode/Decorator.ts

@@ -1,35 +1,35 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-09-01
+ * @Description: 装饰节点 装饰节点下必须包含子节点
+ */
+
+import { BT } from "../BT";
 import { Status } from "../header";
-import { Ticker } from "../Ticker";
+import { BTNode, IBTNode } from "./BTNode";
-import { BaseNode } from "./BaseNode";
 
 /**
- * 修饰节点基类
+ * 修饰节点 基类
- * 只能包含一个子节点
+ * 有且仅有一个子节点
  */
-export abstract class Decorator extends BaseNode {
+export abstract class Decorator extends BTNode {
-    constructor(child: BaseNode) {
+    constructor(child: IBTNode) {
         super([child]);
     }
 }
 
-/**
+/** 条件装饰节点基类 */
- * 失败节点
+export abstract class ConditionDecorator extends Decorator {
- * 必须且只能包含一个子节点
- * 直接返回 FAILURE
- * @extends Decorator
- */
-export class Failer extends Decorator {
     /**
-     * 执行
+     * 判断是否满足条件
-     * @param {Ticker} ticker 
+     * @returns 是否满足条件
-     * @returns {Status} 
      */
-    public tick(ticker: Ticker): Status {
+    protected abstract isEligible(): boolean;
-        if (this.children.length !== 1) {
+
-            throw new Error("(Failer)节点必须包含一个子节点");
+    public tick(dt: number): Status {
+        if (this.isEligible()) {
+            return this.children[0]!._execute(dt);
         }
-        let child = this.children[0];
-        child._execute(ticker);
         return Status.FAILURE;
     }
 }
@@ -40,328 +40,222 @@ export class Failer extends Decorator {
  * 第一个Child Node节点, 返回 FAILURE, 本Node向自己的Parent Node也返回 SUCCESS
  * 第一个Child Node节点, 返回 SUCCESS, 本Node向自己的Parent Node也返回 FAILURE
  */
+@BT.ClassDecorator("Inverter", { name: "反转器", group: "基础装饰节点", desc: "反转子节点的执行结果，成功变失败，失败变成功" })
 export class Inverter extends Decorator {
-    /**
+    public tick(dt: number): Status {
-     * 执行
+        const status = this.children[0]!._execute(dt);
-     * @param {Ticker} ticker 
+
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
-        if (this.children.length !== 1) {
-            throw new Error("(Inverter)节点必须包含一个子节点");
-        }
-        let child = this.children[0];
-        let status = child._execute(ticker);
         if (status === Status.SUCCESS) {
-            status = Status.FAILURE;
+            return Status.FAILURE;
         } else if (status === Status.FAILURE) {
-            status = Status.SUCCESS;
+            return Status.SUCCESS;
         }
-        return status;
+        return status; // RUNNING 保持不变
+    }
+}
+
+
+/**
+ * 时间限制节点
+ * 只能包含一个子节点
+ * 规定时间内, 根据Child Node的结果, 本节点向自己的父节点也返回相同的结果
+ * 超时后, 直接返回 FAILURE
+ */
+@BT.ClassDecorator("LimitTime", { name: "时间限制器", group: "基础装饰节点", desc: "限制子节点执行时间，超时返回失败" })
+export class LimitTime extends Decorator {
+    @BT.prop({ type: BT.ParamType.float, description: "最大时间(秒)", defaultValue: 1 })
+    protected _max: number = 1;
+
+    private _value: number = 0;
+    /**
+     * 时间限制节点
+     * @param child 子节点 
+     * @param max 最大时间 (秒) 默认1秒
+     */
+    constructor(child: IBTNode, max: number = 1) {
+        super(child);
+        this._max = max;
+    }
+
+    protected override open(): void {
+        this._value = 0;
+    }
+
+    public tick(dt: number): Status {
+        this._value += dt;
+        if (this._value > this._max) {
+            this.cleanupChild();
+            return Status.FAILURE;
+        }
+        return this.children[0]!._execute(dt);
     }
 }
 
 /**
  * 次数限制节点
  * 必须且只能包含一个子节点
- * 次数限制内, 根据Child Node的结果, 本Node向自己的Parent Node也返回相同的结果
+ * 次数超过后, 直接返回失败; 次数未超过, 返回子节点状态
- * 次数超过后, 直接返回 FAILURE
  */
-export class LimiterTicks extends Decorator {
+@BT.ClassDecorator("LimitTicks", { name: "次数限制器", group: "基础装饰节点", desc: "限制子节点执行次数，超过次数返回失败" })
-    /** 最大次数 @internal */
+export class LimitTicks extends Decorator {
-    private _maxTicks: number;
+    @BT.prop({ type: BT.ParamType.int, description: "最大次数", defaultValue: 1 })
-    /** 当前执行过的次数 @internal */
+    protected _max: number = 1;
-    private _elapsedTicks: number;
 
-    /**
+    private _value: number = 0;
-     * 创建
+    constructor(child: IBTNode, max: number = 1) {
-     * @param maxTicks 最大次数
-     * @param child 子节点
-     */
-    constructor(maxTicks: number, child: BaseNode) {
         super(child);
-        this._maxTicks = maxTicks;
+        this._max = max;
-        this._elapsedTicks = 0;
     }
 
-    /**
+    protected override open(): void {
-     * 打开
+        this._value = 0;
-     * @param {Ticker} ticker 
-     */
-    public open(ticker: Ticker): void {
-        super.open(ticker);
-        this._elapsedTicks = 0;
     }
 
-    /**
+    public tick(dt: number): Status {
-     * 执行
+        if (this._value > this._max) {
-     * @param {Ticker} ticker 
+            this.cleanupChild();
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
-        if (this.children.length !== 1) {
-            throw new Error("(LimiterTicks)节点必须包含一个子节点");
-        }
-        let child = this.children[0];
-        if (++this._elapsedTicks > this._maxTicks) {
-            this._elapsedTicks = 0;
             return Status.FAILURE;
         }
-        return child._execute(ticker);
+        let status = this.children[0]!._execute(dt);
+        if (status !== Status.RUNNING) {
+            this._value++;
+        }
+        return status;
     }
 }
 
 /**
- * 时间限制节点
+ * 循环节点 最大次数必须大于0
- * 只能包含一个子节点
- * 规定时间内, 根据Child Node的结果, 本Node向自己的Parent Node也返回相同的结果
- * 超时后, 直接返回 FAILURE
- */
-export class LimiterTime extends Decorator {
-    /** 最大时间 (毫秒 ms) @internal */
-    private _maxTime: number;
-
-    /**
-     * 时间限制节点
-     * @param maxTime 最大时间 (微秒ms)
-     * @param child 子节点
-     */
-    constructor(maxTime: number, child: BaseNode) {
-        super(child);
-        this._maxTime = maxTime * 1000;
-    }
-
-    /**
-     * 打开
-     * @param {Ticker} ticker 
-     */
-    public open(ticker: Ticker): void {
-        super.open(ticker);
-        let startTime = new Date().getTime();
-        ticker.blackboard.set("startTime", startTime, ticker.tree.id, this.id);
-    }
-
-    /**
-     * 执行
-     * @param {Ticker} ticker 
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
-        if (this.children.length !== 1) {
-            throw new Error("(LimiterTime)节点必须包含一个子节点");
-        }
-
-        let child = this.children[0];
-        let currTime = new Date().getTime();
-        let startTime = ticker.blackboard.get("startTime", ticker.tree.id, this.id);
-
-        if (currTime - startTime > this._maxTime) {
-            return Status.FAILURE;
-        }
-
-        return child._execute(ticker);
-    }
-}
-
-/**
- * 循环节点
  * 必须且只能包含一个子节点
- * 如果maxLoop < 0, 直接返回成功
+ * 子节点是成功或失败，累加计数
- * 否则等待次数超过之后, 返回Child Node的结果（RUNING的次数不计算在内）
+ * 次数超过之后返回子节点状态，否则返回 RUNNING
  */
-export class Repeater extends Decorator {
+@BT.ClassDecorator("Repeat", { name: "重复节点", group: "基础装饰节点", desc: "重复执行子节点指定次数" })
-    /** 最大循环次数 @internal */
+export class Repeat extends Decorator {
-    private _maxLoop: number;
+    @BT.prop({ type: BT.ParamType.int, description: "重复次数", defaultValue: 1, min: 1 })
+    protected _max: number = 1;
 
-    /**
+    private _value: number = 0;
-     * 创建
+    constructor(child: IBTNode, max: number = 1) {
-     * @param child 子节点
-     * @param maxLoop 最大循环次数
-     */
-    constructor(child: BaseNode, maxLoop: number = -1) {
         super(child);
-        this._maxLoop = maxLoop;
+        this._max = max;
     }
 
-    /**
+    protected override open(): void {
-     * 打开
+        this._value = 0;
-     * @param {Ticker} ticker 
-     */
-    public open(ticker: Ticker): void {
-        ticker.blackboard.set("i", 0, ticker.tree.id, this.id);
     }
 
-    /**
+    public tick(dt: number): Status {
-     * 执行
+        // 执行子节点
-     * @param {Ticker} ticker 
+        const status = this.children[0]!._execute(dt);
-     * @returns {Status} 
+        // 如果子节点完成（成功或失败），增加计数
-     */
+        if (status !== Status.RUNNING) {
-    public tick(ticker: Ticker): Status {
+            this._value++;
-        if (this.children.length !== 1) {
+            // 检查是否达到最大次数
-            throw new Error("(Repeater)节点必须包含一个子节点");
+            if (this._value >= this._max) {
-        }
+                return status;
-
-        let child = this.children[0];
-        let i = ticker.blackboard.get("i", ticker.tree.id, this.id);
-        let status = Status.SUCCESS;
-
-        while (this._maxLoop < 0 || i < this._maxLoop) {
-            status = child._execute(ticker);
-
-            if (status === Status.SUCCESS || status === Status.FAILURE) {
-                i++;
-            } else {
-                break;
             }
         }
-
-        ticker.blackboard.set("i", i, ticker.tree.id, this.id);
-        return status;
-    }
-}
-
-/**
- * 循环节点
- * 只能包含一个子节点
- * 如果maxLoop < 0, 直接返回成功
- * 当Child Node返回 FAILURE, 本Node向自己的Parent Node返回 FAILURE
- * 循环次数大于等于maxLoop时, 返回Child Node的结果
- */
-export class RepeatUntilFailure extends Decorator {
-    /** 最大循环次数 @internal */
-    private _maxLoop: number;
-
-    constructor(child: BaseNode, maxLoop: number = -1) {
-        super(child);
-        this._maxLoop = maxLoop;
-    }
-
-    /**
-     * 打开
-     * @param {Ticker} ticker 
-     */
-    public open(ticker: Ticker): void {
-        ticker.blackboard.set("i", 0, ticker.tree.id, this.id);
-    }
-
-    /**
-     * 执行
-     * @param {Ticker} ticker 
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
-        if (this.children.length !== 1) {
-            throw new Error("(RepeatUntilFailure)节点必须包含一个子节点");
-        }
-
-        let child = this.children[0];
-        let i = ticker.blackboard.get("i", ticker.tree.id, this.id);
-        let status = Status.SUCCESS;
-
-        while (this._maxLoop < 0 || i < this._maxLoop) {
-            status = child._execute(ticker);
-
-            if (status === Status.SUCCESS) {
-                i++;
-            } else {
-                break;
-            }
-        }
-
-        ticker.blackboard.set("i", i, ticker.tree.id, this.id);
-        return status;
-    }
-}
-
-/**
- * 循环节点(只能包含一个子节点)
- * 如果maxLoop < 0, 直接返回失败
- * 当Child Node返回 SUCCESS, 本Node向自己的Parent Node返回 SUCCESS
- * 循环次数大于等于maxLoop时, 返回Child Node的结果
- */
-export class RepeatUntilSuccess extends Decorator {
-    /** 最大循环次数 @internal */
-    private _maxLoop: number;
-
-    /**
-     * 创建
-     * @param child 子节点
-     * @param maxLoop 最大循环次数
-     */
-    constructor(child: BaseNode, maxLoop: number = -1) {
-        super(child);
-        this._maxLoop = maxLoop;
-    }
-
-    /**
-     * 打开
-     * @param {Ticker} ticker 
-     */
-    public open(ticker: Ticker): void {
-        ticker.blackboard.set("i", 0, ticker.tree.id, this.id);
-    }
-
-    /**
-     * 执行
-     * @param {Ticker} ticker 
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
-        if (this.children.length !== 1) {
-            throw new Error("(RepeatUntilSuccess)节点必须包含一个子节点");
-        }
-        let child = this.children[0];
-        let i = ticker.blackboard.get("i", ticker.tree.id, this.id);
-        let status = Status.FAILURE;
-        while (this._maxLoop < 0 || i < this._maxLoop) {
-            status = child._execute(ticker);
-            if (status === Status.FAILURE) {
-                i++;
-            } else {
-                break;
-            }
-        }
-        ticker.blackboard.set("i", i, ticker.tree.id, this.id);
-        return status;
-    }
-}
-
-/**
- * 逻辑节点, 一直执行(只能包含一个子节点)
- * 直接返回 RUNING
- */
-export class Runner extends Decorator {
-    /**
-     * 执行
-     * @param {Ticker} ticker 
-     * @returns {Status} 
-     */
-    public tick(ticker: Ticker): Status {
-        if (this.children.length !== 1) {
-            throw new Error("(Runner)节点必须包含一个子节点");
-        }
-        let child = this.children[0];
-        child._execute(ticker);
         return Status.RUNNING;
     }
 }
 
 /**
- * 成功节点(包含一个子节点)
+ * 重复 -- 直到失败
- * 直接返回 SUCCESS
+ * 节点含义：重复执行直到失败，但最多重试max次
+ * 必须且只能包含一个子节点
+ * 
+ * 子节点成功 计数+1
  */
-export class Succeeder extends Decorator {
+@BT.ClassDecorator("RepeatUntilFailure", { name: "重复直到失败", group: "基础装饰节点", desc: "重复执行子节点直到失败或达到最大次数" })
-    /**
+export class RepeatUntilFailure extends Decorator {
-     * 执行
+    @BT.prop({ type: BT.ParamType.int, description: "最大重试次数", defaultValue: 1, min: 1 })
-     * @param {Ticker} ticker 
+    protected _max: number = 1;
-     * @returns {Status} 
+
-     */
+    private _value: number = 0;
-    public tick(ticker: Ticker): Status {
+    constructor(child: IBTNode, max: number = 1) {
-        if (this.children.length !== 1) {
+        super(child);
-            throw new Error("(Succeeder)节点必须包含一个子节点");
+        this._max = max;
+    }
+
+    protected override open(): void {
+        this._value = 0;
+    }
+
+    public tick(dt: number): Status {
+        const status = this.children[0]!._execute(dt);
+        if (status === Status.FAILURE) {
+            return Status.FAILURE;
         }
-        let child = this.children[0];
+        if (status === Status.SUCCESS) {
-        child._execute(ticker);
+            this._value++;
-        return Status.SUCCESS;
+            if (this._value >= this._max) {
+                // 重试次数耗尽了，但是子节点一直返回成功 就返回成功
+                return Status.SUCCESS;
+            }
+        }
+        return Status.RUNNING;
+    }
+}
+
+/**
+ * 重复 -- 直到成功
+ * 节点含义：重复执行直到成功，但最多重试max次
+ * 必须且只能包含一个子节点
+ * 
+ * 子节点失败, 计数+1
+ */
+@BT.ClassDecorator("RepeatUntilSuccess", { name: "重复直到成功", group: "基础装饰节点", desc: "重复执行子节点直到成功或达到最大次数" })
+export class RepeatUntilSuccess extends Decorator {
+    @BT.prop({ type: BT.ParamType.int, description: "最大重试次数", defaultValue: 1, step: 1 })
+    protected _max: number = 1;
+
+    private _value: number = 0;
+    constructor(child: IBTNode, max: number = 1) {
+        super(child);
+        this._max = max;
+    }
+
+    protected override open(): void {
+        this._value = 0;
+    }
+
+    public tick(dt: number): Status {
+        // 执行子节点
+        const status = this.children[0]!._execute(dt);
+        if (status === Status.SUCCESS) {
+            return Status.SUCCESS;
+        }
+        if (status === Status.FAILURE) {
+            this._value++;
+            if (this._value >= this._max) {
+                // 重试次数耗尽了，但是子节点一直返回失败
+                return Status.FAILURE;
+            }
+        }
+        return Status.RUNNING;
+    }
+}
+
+/**
+ * 权重装饰节点
+ */
+@BT.ClassDecorator("WeightDecorator", { name: "权重装饰器", group: "基础装饰节点", desc: "权重装饰节点" })
+export class WeightDecorator extends Decorator {
+    @BT.prop({ type: BT.ParamType.int, description: "权重", defaultValue: 1, step: 1 })
+    private _weight: number;
+
+    constructor(child: IBTNode, weight?: number) {
+        super(child);
+        // 优先使用构造函数参数，否则使用装饰器默认参数
+        this._weight = weight || 1;
+    }
+
+    public tick(dt: number): Status {
+        return this.children[0]!._execute(dt);
+    }
+
+    public get weight(): number {
+        return this._weight;
     }
 }

src/behaviortree/BehaviorTree.ts

@@ -1,61 +1,63 @@
-import { Blackboard } from "./Blackboard";
+import { Blackboard, IBlackboard } from "./Blackboard";
-import { BaseNode } from "./BTNode/BaseNode";
+import { IBTNode } from "./BTNode/BTNode";
-import { createUUID } from "./header";
+import { Status } from "./header";
-import { Ticker } from "./Ticker";
 
 /**
  * 行为树
  * 所有节点全部添加到树中
  */
-export class BehaviorTree {
+export class BehaviorTree<T> {
-    /** 行为树ID @internal */
+    /** 
-    private _id: string;
+     * @internal
-    /** 行为树跟节点 @internal */
+     */
-    private _root: BaseNode;
+    private _root: IBTNode;
+    /** 
+     * @internal
+     */
+    private _blackboard: IBlackboard;
+
+    get root(): IBTNode { return this._root; }
+    get blackboard(): IBlackboard { return this._blackboard }
+
     /**
      * constructor
+     * @param entity 实体
      * @param root 根节点
      */
-    constructor(root: BaseNode) {
+    constructor(entity: T, root: IBTNode) {
-        this._id = createUUID();
         this._root = root;
+        this._blackboard = new Blackboard(undefined, entity);
+        // 构造时就初始化所有节点ID，避免运行时检查
+        this._initializeAllNodeIds(this._root);
     }
 
     /**
-     * 执行
+     * 执行行为树
-     * @param subject 主体
-     * @param blackboard 黑板
-     * @param ticker 更新器
      */
-    public tick(subject: any, blackboard: Blackboard, ticker?: Ticker): void {
+    public tick(dt: number): Status {
-        ticker = ticker || new Ticker(subject, blackboard, this);
+        return this._root._execute(dt);
-        ticker.openNodes.length = 0;
-        this._root._execute(ticker);
-        // 上次打开的节点
-        let lastOpenNodes = (blackboard.get("openNodes", this._id) || []) as BaseNode[];
-        // 当前打开的节点
-        let currOpenNodes = ticker.openNodes;
-        let start = 0;
-        for (let i = 0; i < Math.min(lastOpenNodes.length, currOpenNodes.length); i++) {
-            start = i + 1;
-            if (lastOpenNodes[i] !== currOpenNodes[i]) {
-                break;
-            }
-        }
-        // 关闭不需要的节点
-        for (let i = lastOpenNodes.length - 1; i >= start; i--) {
-            lastOpenNodes[i]._close(ticker);
-        }
-        /* POPULATE BLACKBOARD */
-        blackboard.set("openNodes", currOpenNodes, this._id);
-        blackboard.set("nodeCount", ticker.nodeCount, this._id);
     }
 
-    get id(): string {
+    /**
-        return this._id;
+     * 递归初始化所有节点ID
+     * 在构造时一次性完成，避免运行时检查
+     * @param node 要初始化的节点
+     * @internal
+     */
+    private _initializeAllNodeIds(node: IBTNode, parent?: IBTNode): void {
+        // 设置当前节点ID
+        node._initialize(this._blackboard, parent ? parent.local : this._blackboard);
+        // 递归设置所有子节点ID
+        for (const child of node.children) {
+            this._initializeAllNodeIds(child, node);
+        }
     }
 
-    get root(): BaseNode {
+    /**
-        return this._root;
+     * 完全重置行为树（核武器级别的重置）
+     * 清空黑板并重置所有节点状态
+     */
+    public reset(): void {
+        this._blackboard.clean();
     }
 }

src/behaviortree/Blackboard.ts

@@ -1,105 +1,96 @@
 /**
- * 行为树数据
+ * @Author: Gongxh
+ * @Date: 2025-09-02
+ * @Description: 行为树共享数据
+ * 
+ * 专门用于存储和管理行为树执行过程中的共享数据
  */
-interface ITreeData {
+
-    nodeMemory: { [nodeScope: string]: any };
+import { IBTNode } from "./BTNode/BTNode";
-    openNodes: any[];
+
+/** 
+ * 黑板数据接口
+ */
+export interface IBlackboard {
+    getEntity<T>(): T;
+    get<T>(key: string): T;
+    set<T>(key: string, value: T): void;
+    delete(key: string): void;
+    has(key: string): boolean;
+    clean(): void;
+    createChild(scope?: number): IBlackboard;
+    /** @internal */
+    openNodes: WeakMap<IBTNode, boolean>;
 }
 
-/** 平台 */
+/**
-export class Blackboard {
+ * 黑板类
-    /** 行为树打断保护 */
+ */
-    public interruptDefend: boolean = false;
+export class Blackboard implements IBlackboard {
-    /** 打断行为树的标记 */
+    private readonly _data = new Map<string, any>();
-    public interrupt: boolean = false;
+    public parent?: Blackboard | undefined;
-    /** 基础记忆 @internal */
+    public children = new Set<Blackboard>();
-    private _baseMemory: any;
-    /** 树记忆 @internal */
-    private _treeMemory: { [treeScope: string]: ITreeData };
-
-    constructor() {
-        this._baseMemory = {};
-        this._treeMemory = {};
-    }
 
     /** 
-     * 清除
+     * 正在运行中的节点
-     */
-    public clear(): void {
-        this._baseMemory = {};
-        this._treeMemory = {};
-    }
-
-    /**
-     * 设置
-     * @param key 键
-     * @param value 值
-     * @param treeScope 树范围
-     * @param nodeScope 节点范围
-     */
-    public set(key: string, value: any, treeScope?: string, nodeScope?: string): void {
-        let memory = this._getMemory(treeScope, nodeScope);
-        memory[key] = value;
-    }
-
-    /**
-     * 获取
-     * @param key 键
-     * @param treeScope 树范围
-     * @param nodeScope 节点范围
-     * @returns 值
-     */
-    public get(key: string, treeScope?: string, nodeScope?: string): any {
-        let memory = this._getMemory(treeScope, nodeScope);
-        return memory[key];
-    }
-
-    /**
-     * 获取树记忆
-     * @param treeScope 树范围
-     * @returns 树记忆
      * @internal
      */
-    private _getTreeMemory(treeScope: string): ITreeData {
+    public openNodes = new WeakMap<IBTNode, boolean>();
-        if (!this._treeMemory[treeScope]) {
+
-            this._treeMemory[treeScope] = {
+    /** 实体 */
-                nodeMemory: {},
+    private readonly _entity: any;
-                openNodes: [],
+    public getEntity<T>(): T {
-            };
+        return this._entity;
-        }
-        return this._treeMemory[treeScope];
     }
 
-    /**
+    constructor(parent?: Blackboard, entity?: any) {
-     * 获取节点记忆
+        this.parent = parent;
-     * @param treeMemory 树记忆
+        if (parent) {
-     * @param nodeScope 节点范围
+            parent.children.add(this);
-     * @returns 节点记忆
-     * @internal
-     */
-    private _getNodeMemory(treeMemory: ITreeData, nodeScope: string): { [key: string]: any } {
-        let memory = treeMemory.nodeMemory;
-        if (!memory[nodeScope]) {
-            memory[nodeScope] = {};
         }
-        return memory[nodeScope];
+        // 优先使用传入的 entity，如果没有则从父级继承
+        this._entity = entity !== undefined ? entity : (parent?._entity ?? null);
     }
 
-    /**
+    /** 核心: 查找链实现 */
-     * 获取记忆
+    public get<T>(key: string): T {
-     * @param treeScope 树范围
+        if (this._data.has(key)) {
-     * @param nodeScope 节点范围
+            return this._data.get(key) as T;
-     * @returns 记忆
+        }
-     * @internal
+        return this.parent?.get(key) as T;
-     */
+    }
-    private _getMemory(treeScope?: string, nodeScope?: string): { [key: string]: any } {
+
-        let memory = this._baseMemory;
+    /** 写入: 只在当前层 */
-        if (treeScope) {
+    public set<T>(key: string, value: T): void {
-            memory = this._getTreeMemory(treeScope);
+        this._data.set(key, value);
-            if (nodeScope) {
+    }
-                memory = this._getNodeMemory(memory, nodeScope);
+
-            }
+    /** 检查: 沿链查找 */
+    public has(key: string): boolean {
+        return this._data.has(key) || (this.parent?.has(key) ?? false);
+    }
+
+    public delete(key: string): void {
+        this._data.delete(key);
+    }
+
+    public createChild(): Blackboard {
+        return new Blackboard(this);
+    }
+
+    public clean(): void {
+        // 清空当前黑板数据
+        this._data.clear();
+
+        // 重置运行状态
+        this.openNodes = new WeakMap<IBTNode, boolean>();
+
+        // 递归清理所有子黑板
+        for (const child of this.children) {
+            child.clean();
         }
-        return memory;
     }
 }
+
+// 全局共享的黑板实例
+export const globalBlackboard = new Blackboard();

src/behaviortree/Factory.ts

@@ -0,0 +1,71 @@
+/**
+ * @Author: Gongxh
+ * @Date: 2025-09-16
+ * @Description: 根据数据创建一颗行为树
+ */
+
+import { BehaviorTree } from "./BehaviorTree";
+import { BT } from "./BT";
+import { IBTNode } from "./BTNode/BTNode";
+
+export interface INodeConfig {
+    id: string,
+    className: string,
+    parameters: Record<string, any>,
+    children: string[]
+}
+
+/**
+ * 根据节点配置递归创建节点
+ * @param info 节点配置
+ * @param nodeMap 所有节点配置的映射表
+ * @returns 创建的节点实例
+ */
+function createNodeRecursively(info: INodeConfig, nodeMap: Map<string, INodeConfig>): IBTNode {
+    // 获取节点构造函数
+    const ctor = BT.getNodeConstructor(info.className);
+    if (!ctor) {
+        throw new Error(`未找到节点【${info.className}】的构造函数`);
+    }
+
+    // 递归创建子节点
+    const childNodes: IBTNode[] = [];
+    for (const childId of info.children || []) {
+        const childInfo = nodeMap.get(childId);
+        if (!childInfo) {
+            throw new Error(`未找到子节点【${childId}】，行为树配置导出信息错误`);
+        }
+        const childNode = createNodeRecursively(childInfo, nodeMap);
+        childNodes.push(childNode);
+    }
+
+    // 创建节点实例
+    let btnode: IBTNode;
+    const metadata = BT.getNodeMetadata(ctor);
+    if (metadata.type === BT.Type.Action || metadata.type === BT.Type.Condition) {
+        btnode = new ctor();
+    } else if (metadata.type === BT.Type.Decorator) {
+        btnode = new ctor(childNodes[0]!);
+    } else {
+        btnode = new ctor(...childNodes);
+    }
+    // 设置节点参数
+    for (const key in info.parameters) {
+        (btnode as any)[key] = info.parameters[key];
+    }
+    return btnode;
+}
+
+export function createBehaviorTree<T>(config: INodeConfig[], entity: T): BehaviorTree<T> {
+    // 验证配置
+    if (!config || !Array.isArray(config) || config.length === 0) {
+        throw new Error("Config is empty or invalid");
+    }
+
+    // 创建配置映射表
+    const nodeMap = new Map<string, INodeConfig>();
+    for (const info of config) {
+        nodeMap.set(info.id, info);
+    }
+    return new BehaviorTree(entity, createNodeRecursively(config[0]!, nodeMap));
+}

src/behaviortree/Ticker.ts

@@ -1,59 +0,0 @@
-import { BehaviorTree } from "./BehaviorTree";
-import { Blackboard } from "./Blackboard";
-import { BaseNode } from "./BTNode/BaseNode";
-
-export class Ticker {
-    tree: BehaviorTree; // 行为树跟节点
-    openNodes: BaseNode[]; // 当前打开的节点
-    nodeCount: number; // 当前打开的节点数量
-    blackboard: Blackboard; // 数据容器
-    debug: any;
-    subject: any;
-    constructor(subject: any, blackboard: Blackboard, tree: BehaviorTree) {
-        this.tree = tree;
-        this.openNodes = [];
-        this.nodeCount = 0;
-        this.debug = null;
-        this.subject = subject;
-        this.blackboard = blackboard;
-    }
-
-    /**
-     * 进入节点
-     * @param node 节点
-     */
-    public enterNode(node: BaseNode): void {
-        this.nodeCount++;
-        this.openNodes.push(node);
-    }
-
-    /**
-     * 打开节点
-     * @param node 节点
-     */
-    public openNode(node: BaseNode): void { }
-
-    /**
-     * 更新节点
-     * @param node 节点
-     */
-    public tickNode(node: BaseNode): void { }
-
-    /**
-     * 关闭节点
-     * @param node 节点
-     */
-    public closeNode(node: BaseNode): void {
-        // 查找并移除指定节点，而不是简单地pop
-        const index = this.openNodes.lastIndexOf(node);
-        if (index !== -1) {
-            this.openNodes.splice(index, 1);
-        }
-    }
-
-    /**
-     * 退出节点
-     * @param node 节点
-     */
-    public exitNode(node: BaseNode): void { }
-}

src/behaviortree/header.ts

@@ -1,27 +1,5 @@
-export const enum Status {
+export enum Status {
     FAILURE,
     SUCCESS,
     RUNNING,
 }
-
-/**
- * 创建UUID
- * @returns UUID
- * @internal
- */
-export function createUUID(): string {
-    let s: string[] = Array(36);
-    let hexDigits = "0123456789abcdef";
-    for (let i = 0; i < 36; i++) {
-        let start = Math.floor(Math.random() * 0x10);
-        s[i] = hexDigits.substring(start, start + 1);
-    }
-    // bits 12-15 of the time_hi_and_version field to 0010
-    s[14] = "4";
-    // bits 6-7 of the clock_seq_hi_and_reserved to 01
-    let start = (parseInt(s[19], 16) & 0x3) | 0x8;
-    s[19] = hexDigits.substring(start, start + 1);
-    s[8] = s[13] = s[18] = s[23] = "-";
-    let uuid = s.join("");
-    return uuid;
-}

src/index.ts

@@ -0,0 +1,15 @@
+
+/** 行为树 */
+export { BehaviorTree } from "./behaviortree/BehaviorTree";
+export { Blackboard } from "./behaviortree/Blackboard";
+export * from "./behaviortree/BTNode/Action";
+export { IBTNode } from "./behaviortree/BTNode/BTNode";
+export * from "./behaviortree/BTNode/Composite";
+export * from "./behaviortree/BTNode/Condition";
+export * from "./behaviortree/BTNode/Decorator";
+export { createBehaviorTree, INodeConfig } from "./behaviortree/Factory";
+export { Status } from "./behaviortree/header";
+
+// 导出装饰器内容
+import { BT } from "./behaviortree/BT";
+export const { ClassAction, ClassCondition, ClassComposite, ClassDecorator, prop, ParamType } = BT;

src/kunpocc-behaviortree.ts

@@ -1,14 +0,0 @@
-
-/** 行为树 */
-export { Agent as Agent } from "./behaviortree/Agent";
-export { BehaviorTree } from "./behaviortree/BehaviorTree";
-export { Blackboard } from "./behaviortree/Blackboard";
-export * as Action from "./behaviortree/BTNode/Action";
-export { BaseNode as Node } from "./behaviortree/BTNode/BaseNode";
-export * as Composite from "./behaviortree/BTNode/Composite";
-
-export { Condition } from "./behaviortree/BTNode/Condition";
-export * as Decorator from "./behaviortree/BTNode/Decorator";
-export { Status } from "./behaviortree/header";
-export { Ticker } from "./behaviortree/Ticker";
-

tsconfig.json

@@ -1,19 +1,26 @@
 {
     "compilerOptions": {
-        "target": "es6",    // 
+        "target": "es6",
-        "module": "commonjs",    // 
+        "lib": ["es6", "dom"],
-        "experimentalDecorators": true, // 启用ES装饰器。
+        "module": "commonjs",
+        "experimentalDecorators": true, // 启用ES装饰器
+        "emitDecoratorMetadata": true, // 启用装饰器元数据
         "strict": true,
-        "strictNullChecks": false,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "noUncheckedIndexedAccess": true,
+        "noImplicitOverride": true,
+        "useUnknownInCatchVariables": true,
+        "exactOptionalPropertyTypes": true,
+        "noPropertyAccessFromIndexSignature": true,
         "moduleResolution": "Node",
         "skipLibCheck": true,
         "esModuleInterop": true,
         "stripInternal": true,
-        "types": []
+        "types": ["node"]
     },
     "include": [
         "./src/**/*"
-        // "libs"
     ],
     // 排除
     "exclude": [