init

.gitignore

@@ -0,0 +1,9 @@
+# 文件
+.DS_Store
+package-lock.json
+
+# 文件夹
+.vscode/
+node_modules/
+dist/
+build/

.npmignore

@@ -0,0 +1,5 @@
+# 文件夹
+node_modules/
+libs/
+build/
+src/

Notes.md

@@ -0,0 +1,11 @@
+发布版本
+
+```bash
+npm publish --otp <code>
+```
+
+删除指定版本
+
+```bash
+npm unpublish kunpocc-behaviortree@1.0.23 --otp <code>
+```

README.md

@@ -0,0 +1,141 @@
+## 行为树
+
+> 行为树是一种强大的 AI 决策系统，用于实现复杂的游戏 AI 行为。
+
+#### 基本概念
+
+1. 节点状态
+```typescript
+enum Status {
+    SUCCESS,  // 成功
+    FAILURE,  // 失败
+    RUNNING   // 运行中
+}
+```
+
+2. 节点类型
+- **动作节点 (Action)**：执行具体行为的叶子节点
+- **组合节点 (Composite)**：控制子节点执行顺序的节点
+- **条件节点 (Condition)**：判断条件的节点
+- **装饰节点 (Decorator)**：修饰其他节点行为的节点
+
+#### 使用示例
+
+```typescript
+import { 
+    BehaviorTree, 
+    Sequence, 
+    Selector, 
+    Parallel,
+    Success,
+    Failure,
+    WaitTime,
+    Agent,
+    Blackboard
+} from 'kunpocc-behaviortree';
+
+// 1. 创建行为树
+const tree = new BehaviorTree(
+    new Sequence(  // 顺序节点：按顺序执行所有子节点
+        new WaitTime(2),  // 等待2秒
+        new Selector(  // 选择节点：选择一个可执行的子节点
+            new Success(() => {
+                console.log("执行成功动作");
+            }),
+            new Failure(() => {
+                console.log("执行失败动作");
+            })
+        )
+    )
+);
+
+// 2. 创建代理和黑板
+const agent = new Agent();  // AI代理
+const blackboard = new Blackboard();  // 共享数据黑板
+
+// 3. 执行行为树
+tree.tick(agent, blackboard);
+```
+
+#### 常用节点
+
+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. 节点状态说明：
+   - `SUCCESS`：节点执行成功
+   - `FAILURE`：节点执行失败
+   - `RUNNING`：节点正在执行中
+2. 组合节点特性：
+   - `Sequence`：所有子节点返回 SUCCESS 才返回 SUCCESS
+   - `Selector`：任一子节点返回 SUCCESS 就返回 SUCCESS
+   - `Parallel`：并行执行所有子节点
+   - `MemSequence/MemSelector`：会记住上次执行位置
+3. 性能优化：
+   - 使用黑板共享数据，避免重复计算
+   - 合理使用记忆节点，减少重复执行
+   - 控制行为树的深度，避免过于复杂
+
+

package.json

@@ -0,0 +1,53 @@
+{
+    "name": "kunpocc-behaviortree",
+    "version": "0.0.1",
+    "description": "行为树",
+    "main": "./dist/kunpocc-behaviortree.cjs",
+    "module": "./dist/kunpocc-behaviortree.mjs",
+    "types": "./dist/kunpocc-behaviortree.d.ts",
+    "exports": {
+        ".": {
+            "require": "./dist/kunpocc-behaviortree.cjs",
+            "import": "./dist/kunpocc-behaviortree.mjs",
+            "types": "./dist/kunpocc-behaviortree.d.ts",
+            "default": "./dist/kunpocc-behaviortree.cjs"
+        },
+        "./min": {
+            "require": "./dist/kunpocc-behaviortree.min.cjs",
+            "import": "./dist/kunpocc-behaviortree.min.mjs"
+        }
+    },
+    "scripts": {
+        "clean": "rm -rf dist",
+        "build": "npm run clean && rollup -c rollup.config.mjs"
+    },
+    "files": [
+        "dist/kunpocc-behaviortree.cjs",
+        "dist/kunpocc-behaviortree.mjs",
+        "dist/kunpocc-behaviortree.min.cjs",
+        "dist/kunpocc-behaviortree.min.mjs",
+        "dist/kunpocc-behaviortree.d.ts",
+        "libs/lib.ali.api.d.ts",
+        "libs/lib.bytedance.api.d.ts",
+        "libs/lib.wx.api.d.ts"
+    ],
+    "author": "gongxh",
+    "license": "ISC",
+    "repository": {
+        "type": "gitlab",
+        "url": "https://github.com/Gongxh0901/kunpolibrary"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/"
+    },
+    "devDependencies": {
+        "@rollup/plugin-terser": "^0.4.4",
+        "@rollup/plugin-typescript": "^12.1.2",
+        "@types/lodash": "^4.17.13",
+        "@types/node": "^22.10.2",
+        "rollup": "^4.28.1",
+        "rollup-plugin-dts": "^6.1.1",
+        "ts-node": "^10.9.2",
+        "tslib": "^2.6.2"
+    }
+}

rollup.config.mjs

@@ -0,0 +1,86 @@
+import terser from '@rollup/plugin-terser';
+import typescript from '@rollup/plugin-typescript';
+import dts from 'rollup-plugin-dts';
+
+export default [
+    {
+        // 生成未压缩的 JS 文件
+        input: 'src/kunpocc-behaviortree.ts',
+        external: ['cc', 'fairygui-cc'],
+        output: [
+            {
+                file: 'dist/kunpocc-behaviortree.mjs',
+                format: 'esm',
+                name: 'kunpocc-behaviortree'
+            },
+            {
+                file: 'dist/kunpocc-behaviortree.cjs',
+                format: 'cjs',
+                name: 'kunpocc-behaviortree'
+            }
+        ],
+        plugins: [
+            typescript({
+                tsconfig: './tsconfig.json',
+                importHelpers: false,
+                compilerOptions: {
+                    target: "es6",
+                    module: "es6",
+                    experimentalDecorators: true, // 启用ES装饰器。
+                    strict: true,
+                    strictNullChecks: false,
+                    moduleResolution: "Node",
+                    skipLibCheck: true,
+                    esModuleInterop: true,
+                }
+            })
+        ]
+    },
+    {
+        // 生成压缩的 JS 文件
+        input: 'src/kunpocc-behaviortree.ts',
+        external: ['cc', 'fairygui-cc'],
+        output: [
+            {
+                file: 'dist/kunpocc-behaviortree.min.mjs',
+                format: 'esm',
+                name: 'kunpocc-behaviortree'
+            },
+            {
+                file: 'dist/kunpocc-behaviortree.min.cjs',
+                format: 'cjs',
+                name: 'kunpocc-behaviortree'
+            }
+        ],
+        plugins: [
+            typescript({
+                tsconfig: './tsconfig.json',
+                importHelpers: false,
+                compilerOptions: {
+                    target: "es6",
+                    module: "es6",
+                    experimentalDecorators: true, // 启用ES装饰器。
+                    strict: true,
+                    strictNullChecks: false,
+                    moduleResolution: "Node",
+                    skipLibCheck: true,
+                    esModuleInterop: true,
+                }
+            }),
+            terser()
+        ]
+    },
+    {
+        // 生成声明文件的配置
+        input: 'src/kunpocc-behaviortree.ts',
+        output: {
+            file: 'dist/kunpocc-behaviortree.d.ts',
+            format: 'es'
+        },
+        plugins: [dts({
+            compilerOptions: {
+                stripInternal: true
+            }
+        })]
+    }
+]; 

src/behaviortree/Agent.ts

@@ -0,0 +1,48 @@
+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, 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/BTNode/Action.ts

@@ -0,0 +1,189 @@
+import { Status } from "../header";
+import { Ticker } from "../Ticker";
+import { BaseNode } from "./BaseNode";
+
+/**
+ * 动作节点
+ * 没有子节点
+ */
+export abstract class Action extends BaseNode {
+    constructor() {
+        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
+ * 超次，返回SUCCESS
+ */
+export class WaitTicks extends Action {
+    /** 最大次数 @internal */
+    private _maxTicks: number;
+    /** 经过的次数 @internal */
+    private _elapsedTicks: number;
+    constructor(maxTicks: number = 0) {
+        super();
+        this._maxTicks = maxTicks;
+        this._elapsedTicks = 0;
+    }
+
+    /**
+     * 打开
+     * @param {Ticker} ticker 
+     */
+    public open(ticker: Ticker): void {
+        this._elapsedTicks = 0;
+    }
+
+    /**
+     * 执行
+     * @param {Ticker} ticker 
+     * @returns {Status} 
+     */
+    public tick(ticker: Ticker): Status {
+        if (++this._elapsedTicks >= this._maxTicks) {
+            this._elapsedTicks = 0;
+            return Status.SUCCESS;
+        }
+        return Status.RUNNING;
+    }
+}
+
+/**
+ * 时间等待节点(无子节点)
+ * 时间到后返回SUCCESS，否则返回RUNING
+ */
+export class WaitTime extends Action {
+    /** 等待时间(毫秒 ms) @internal */
+    private _duration: number;
+    constructor(duration: number = 0) {
+        super();
+        this._duration = duration * 1000;
+    }
+
+    /**
+     * 打开
+     * @param {Ticker} ticker 
+     */
+    public open(ticker: Ticker): void {
+        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 {
+        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/BaseNode.ts

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1,206 @@
+import { Status } from "../header";
+import { Ticker } from "../Ticker";
+import { BaseNode } from "./BaseNode";
+
+/**
+ * 可以包含多个节点的集合装饰器基类
+ *
+ */
+export abstract class Composite extends BaseNode {
+    constructor(...children: BaseNode[]) {
+        super(children);
+    }
+}
+
+/**
+ * 记忆选择节点
+ * 选择不为 FAILURE 的节点
+ * 任意一个Child Node返回不为 FAILURE, 本Node向自己的Parent Node也返回Child Node状态
+ */
+export class MemSelector 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.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
+ */
+export class Selector extends Composite {
+    /**
+     * 执行
+     * @param {Ticker} ticker 
+     * @returns {Status} 
+     */
+    public tick(ticker: Ticker): Status {
+        for (let i = 0; i < this.children.length; i++) {
+            let status = this.children[i]._execute(ticker);
+            if (status !== Status.FAILURE) {
+                return status;
+            }
+        }
+        return Status.FAILURE;
+    }
+}
+
+/**
+ * 顺序节点
+ * 当执行本类型Node时，它将从begin到end迭代执行自己的Child Node：
+ * 遇到 FAILURE 或 RUNING, 那停止迭代，返回FAILURE 或 RUNING
+ * 所有节点都返回 SUCCESS, 本节点才返回 SUCCESS
+ */
+export class Sequence extends Composite {
+    /**
+     * 执行
+     * @param {Ticker} ticker 
+     * @returns {Status} 
+     */
+    public tick(ticker: Ticker): Status {
+        for (let i = 0; i < this.children.length; i++) {
+            let status = this.children[i]._execute(ticker);
+            if (status !== Status.SUCCESS) {
+                return status;
+            }
+        }
+        return Status.SUCCESS;
+    }
+}
+
+/**
+ * 并行节点 每次进入全部重新执行一遍
+ * 当执行本类型Node时，它将从begin到end迭代执行自己的Child Node：
+ * 1. 当存在Child Node执行后返回 FAILURE, 本节点返回 FAILURE
+ * 2. 当存在Child Node执行后返回 RUNING, 本节点返回 RUNING
+ * 所有节点都返回 SUCCESS, 本节点才返回 SUCCESS
+ */
+export class Parallel extends Composite {
+    /**
+     * 执行
+     * @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);
+            if (status == Status.FAILURE) {
+                result = Status.FAILURE;
+            } else if (result == Status.SUCCESS && status == Status.RUNNING) {
+                result = Status.RUNNING;
+            }
+        }
+        return result;
+    }
+}
+
+/**
+ * 并行节点 每次进入全部重新执行一遍
+ * 当执行本类型Node时，它将从begin到end迭代执行自己的Child Node：
+ * 1. 当存在Child Node执行后返回 FAILURE, 本节点返回 FAILURE
+ * 2. 任意 Child Node 返回 SUCCESS, 本节点返回 SUCCESS
+ * 否则返回 RUNNING
+ */
+export class ParallelAnySuccess extends Composite {
+    /**
+     * 执行
+     * @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);
+            if (status == Status.FAILURE) {
+                result = Status.FAILURE;
+            } else if (result == Status.RUNNING && status == Status.SUCCESS) {
+                result = Status.SUCCESS;
+            }
+        }
+        return result;
+    }
+}

src/behaviortree/BTNode/Condition.ts

@@ -0,0 +1,24 @@
+import { Status } from "../header";
+import { Ticker } from "../Ticker";
+import { Action } from "./Action";
+
+/**
+ * 条件节点
+ */
+export class Condition extends Action {
+    /** 执行函数 @internal */
+    private _func: (subject: any) => boolean = null;
+    constructor(func: (subject: any) => boolean) {
+        super();
+        this._func = func;
+    }
+
+    /**
+     * 执行
+     * @param {Ticker} ticker 
+     * @returns {Status} 
+     */
+    public tick(ticker: Ticker): Status {
+        return this._func(ticker.subject) ? Status.SUCCESS : Status.FAILURE;
+    }
+}

src/behaviortree/BTNode/Decorator.ts

@@ -0,0 +1,367 @@
+import { Status } from "../header";
+import { Ticker } from "../Ticker";
+import { BaseNode } from "./BaseNode";
+
+/**
+ * 修饰节点基类
+ * 只能包含一个子节点
+ */
+export abstract class Decorator extends BaseNode {
+    constructor(child: BaseNode) {
+        super([child]);
+    }
+}
+
+/**
+ * 失败节点
+ * 必须且只能包含一个子节点
+ * 直接返回 FAILURE
+ * @extends Decorator
+ */
+export class Failer extends Decorator {
+    /**
+     * 执行
+     * @param {Ticker} ticker 
+     * @returns {Status} 
+     */
+    public tick(ticker: Ticker): Status {
+        if (this.children.length !== 1) {
+            throw new Error("(Failer)节点必须包含一个子节点");
+        }
+        let child = this.children[0];
+        child._execute(ticker);
+        return Status.FAILURE;
+    }
+}
+
+/**
+ * 结果反转节点
+ * 必须且只能包含一个子节点
+ * 第一个Child Node节点, 返回 FAILURE, 本Node向自己的Parent Node也返回 SUCCESS
+ * 第一个Child Node节点, 返回 SUCCESS, 本Node向自己的Parent Node也返回 FAILURE
+ */
+export class Inverter extends Decorator {
+    /**
+     * 执行
+     * @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;
+        } else if (status === Status.FAILURE) {
+            status = Status.SUCCESS;
+        }
+        return status;
+    }
+}
+
+/**
+ * 次数限制节点
+ * 必须且只能包含一个子节点
+ * 次数限制内, 根据Child Node的结果, 本Node向自己的Parent Node也返回相同的结果
+ * 次数超过后, 直接返回 FAILURE
+ */
+export class LimiterTicks extends Decorator {
+    /** 最大次数 @internal */
+    private _maxTicks: number;
+    /** 当前执行过的次数 @internal */
+    private _elapsedTicks: number;
+
+    /**
+     * 创建
+     * @param maxTicks 最大次数
+     * @param child 子节点
+     */
+    constructor(maxTicks: number, child: BaseNode) {
+        super(child);
+        this._maxTicks = maxTicks;
+        this._elapsedTicks = 0;
+    }
+
+    /**
+     * 打开
+     * @param {Ticker} ticker 
+     */
+    public open(ticker: Ticker): void {
+        super.open(ticker);
+        this._elapsedTicks = 0;
+    }
+
+    /**
+     * 执行
+     * @param {Ticker} ticker 
+     * @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);
+    }
+}
+
+/**
+ * 时间限制节点
+ * 只能包含一个子节点
+ * 规定时间内, 根据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的次数不计算在内）
+ */
+export class Repeater 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("(Repeater)节点必须包含一个子节点");
+        }
+
+        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
+ */
+export class Succeeder extends Decorator {
+    /**
+     * 执行
+     * @param {Ticker} ticker 
+     * @returns {Status} 
+     */
+    public tick(ticker: Ticker): Status {
+        if (this.children.length !== 1) {
+            throw new Error("(Succeeder)节点必须包含一个子节点");
+        }
+        let child = this.children[0];
+        child._execute(ticker);
+        return Status.SUCCESS;
+    }
+}

src/behaviortree/BehaviorTree.ts

@@ -0,0 +1,61 @@
+import { Blackboard } from "./Blackboard";
+import { BaseNode } from "./BTNode/BaseNode";
+import { createUUID } from "./header";
+import { Ticker } from "./Ticker";
+
+/**
+ * 行为树
+ * 所有节点全部添加到树中
+ */
+export class BehaviorTree {
+    /** 行为树ID @internal */
+    private _id: string;
+    /** 行为树跟节点 @internal */
+    private _root: BaseNode;
+    /**
+     * constructor
+     * @param root 根节点
+     */
+    constructor(root: BaseNode) {
+        this._id = createUUID();
+        this._root = root;
+    }
+
+    /**
+     * 执行
+     * @param subject 主体
+     * @param blackboard 黑板
+     * @param ticker 更新器
+     */
+    public tick(subject: any, blackboard: Blackboard, ticker?: Ticker): void {
+        ticker = ticker || new Ticker(subject, blackboard, this);
+        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;
+    }
+
+    get root(): BaseNode {
+        return this._root;
+    }
+}

src/behaviortree/Blackboard.ts

@@ -0,0 +1,105 @@
+/**
+ * 行为树数据
+ */
+interface ITreeData {
+    nodeMemory: { [nodeScope: string]: any };
+    openNodes: any[];
+}
+
+/** 平台 */
+export class Blackboard {
+    /** 行为树打断保护 */
+    public interruptDefend: boolean = false;
+    /** 打断行为树的标记 */
+    public interrupt: boolean = false;
+    /** 基础记忆 @internal */
+    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 {
+        if (!this._treeMemory[treeScope]) {
+            this._treeMemory[treeScope] = {
+                nodeMemory: {},
+                openNodes: [],
+            };
+        }
+        return this._treeMemory[treeScope];
+    }
+
+    /**
+     * 获取节点记忆
+     * @param treeMemory 树记忆
+     * @param nodeScope 节点范围
+     * @returns 节点记忆
+     * @internal
+     */
+    private _getNodeMemory(treeMemory: ITreeData, nodeScope: string): { [key: string]: any } {
+        let memory = treeMemory.nodeMemory;
+        if (!memory[nodeScope]) {
+            memory[nodeScope] = {};
+        }
+        return memory[nodeScope];
+    }
+
+    /**
+     * 获取记忆
+     * @param treeScope 树范围
+     * @param nodeScope 节点范围
+     * @returns 记忆
+     * @internal
+     */
+    private _getMemory(treeScope?: string, nodeScope?: string): { [key: string]: any } {
+        let memory = this._baseMemory;
+        if (treeScope) {
+            memory = this._getTreeMemory(treeScope);
+            if (nodeScope) {
+                memory = this._getNodeMemory(memory, nodeScope);
+            }
+        }
+        return memory;
+    }
+}

src/behaviortree/Ticker.ts

@@ -0,0 +1,55 @@
+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 {
+        this.openNodes.pop();
+    }
+
+    /**
+     * 退出节点
+     * @param node 节点
+     */
+    public exitNode(node: BaseNode): void { }
+}

src/behaviortree/header.ts

@@ -0,0 +1,27 @@
+export const 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/kunpocc-behaviortree.ts

@@ -0,0 +1,14 @@
+
+/** 行为树 */
+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

@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "target": "es6",    // 
+        "module": "commonjs",    // 
+        "experimentalDecorators": true, // 启用ES装饰器。
+        "strict": true,
+        "strictNullChecks": false,
+        "moduleResolution": "Node",
+        "skipLibCheck": true,
+        "esModuleInterop": true,
+        "stripInternal": true,
+        "types": []
+    },
+    "include": [
+        "./src/**/*"
+        // "libs"
+    ],
+    // 排除
+    "exclude": [
+        "node_modules",
+        "dist",
+        "build"
+    ]
+}