修改节点注释,重写文档

src/behaviortree/BTNode/BTNode.ts

@@ -4,7 +4,7 @@ import { Status } from "../header";
 export interface IBTNode {
     readonly children: IBTNode[];
     /** 本节点的的黑板引用 */
-    blackboard: IBlackboard;
+    local: IBlackboard;
     /**
      * 初始化节点
      * @param root 树根节点的黑板
@@ -33,6 +33,9 @@ export interface IBTNode {
      */
     setGlobal<T>(key: string, value: T): void;
     getGlobal<T>(key: string): T;
+
+    /** 获取关联的实体 */
+    getEntity<T>(): T;
 }
 
 
@@ -126,6 +129,10 @@ export abstract class BTNode implements IBTNode {
         }
     }
 
+    public getEntity<T>(): T {
+        return this._local.getEntity();
+    }
+
     /**
      * 设置获取全局黑板数据
      */
@@ -162,8 +169,4 @@ export abstract class BTNode implements IBTNode {
     public get local(): IBlackboard {
         return this._local;
     }
-
-    public get blackboard(): IBlackboard {
-        return this._local;
-    }
 }

src/behaviortree/BTNode/Composite.ts

@@ -2,44 +2,50 @@ import { Status } from "../header";
 import { Composite, MemoryComposite } from "./AbstractNodes";
 
 /**
- * 记忆选择节点
- * 选择不为 FAILURE 的节点，记住上次运行的子节点位置
- * 任意一个Child Node返回不为 FAILURE, 本Node向自己的Parent Node也返回Child Node状态
+ * 记忆选择节点 从上到下执行
+ * 遇到 FAILURE 继续下一个 
+ * 遇到 SUCCESS 返回 SUCCESS 下次重新开始
+ * 
+ * 遇到 RUNNING 返回 RUNNING 下次从该节点开始
  */
 export class MemSelector extends MemoryComposite {
     public tick(): Status {
         let index = this.get<number>(`__nMemoryRunningIndex`);
         for (let i = index; i < this.children.length; i++) {
             let status = this.children[i]!._execute();
-            if (status !== Status.FAILURE) {
-                if (status === Status.RUNNING) {
-                    this.set(`__nMemoryRunningIndex`, i);
-                }
+            if (status === Status.FAILURE) {
+                continue;
+            }
+            if (status === Status.SUCCESS) {
                 return status;
             }
+            this.set(`__nMemoryRunningIndex`, i);
+            return Status.RUNNING;
         }
         return Status.FAILURE;
     }
 }
 
 /**
- * 记忆顺序节点
- * 如果上次执行到 RUNNING 的节点, 下次进入节点后, 直接从 RUNNING 节点开始
- * 遇到 SUCCESS 或者 FAILURE 停止迭代
- * 任意一个Child Node返回不为 SUCCESS, 本Node向自己的Parent Node也返回Child Node状态
- * 所有节点都返回 SUCCESS, 本节点才返回 SUCCESS
+ * 记忆顺序节点 从上到下执行
+ * 遇到 SUCCESS 继续下一个
+ * 遇到 FAILURE 停止迭代 返回 FAILURE 下次重新开始
+ * 
+ * 遇到 RUNNING 返回 RUNNING 下次从该节点开始
  */
 export class MemSequence extends MemoryComposite {
     public tick(): Status {
         let index = this.get<number>(`__nMemoryRunningIndex`);
         for (let i = index; i < this.children.length; i++) {
             let status = this.children[i]!._execute();
-            if (status !== Status.SUCCESS) {
-                if (status === Status.RUNNING) {
-                    this.set(`__nMemoryRunningIndex`, i);
-                }
-                return status;
+            if (status === Status.SUCCESS) {
+                continue;
             }
+            if (status === Status.FAILURE) {
+                return Status.FAILURE;
+            }
+            this.set(`__nMemoryRunningIndex`, i);
+            return Status.RUNNING;
         }
         return Status.SUCCESS;
     }
@@ -47,7 +53,8 @@ export class MemSequence extends MemoryComposite {
 
 /**
  * 随机选择节点
- * 从Child Node中随机选择一个执行
+ * 随机选择一个子节点执行
+ * 返回子节点状态
  */
 export class RandomSelector extends Composite {
     public tick(): Status {
@@ -62,9 +69,9 @@ export class RandomSelector extends Composite {
 }
 
 /**
- * 选择节点，选择不为 FAILURE 的节点
- * 当执行本Node时，它将从begin到end迭代执行自己的Child Node：
- * 如遇到一个Child Node执行后返回 SUCCESS 或者 RUNNING，那停止迭代，本Node向自己的Parent Node也返回 SUCCESS 或 RUNNING
+ * 选择节点 从上到下执行
+ * 返回第一个不为 FAILURE 的子节点状态
+ * 否则返回 FAILURE
  */
 export class Selector extends Composite {
     public tick(): Status {
@@ -79,29 +86,26 @@ export class Selector extends Composite {
 }
 
 /**
- * 顺序节点
- * 当执行本类型Node时，它将从begin到end迭代执行自己的Child Node：
- * 遇到 FAILURE 或 RUNNING, 那停止迭代，返回FAILURE 或 RUNNING
- * 所有节点都返回 SUCCESS, 本节点才返回 SUCCESS
+ * 顺序节点 从上到下执行
+ * 遇到 SUCCESS 继续下一个
+ * 否则返回子节点状态
  */
 export class Sequence extends Composite {
     public tick(): Status {
         for (let i = 0; i < this.children.length; i++) {
             let status = this.children[i]!._execute();
-            if (status !== Status.SUCCESS) {
-                return status;
+            if (status === Status.SUCCESS) {
+                continue;
             }
+            return status;
         }
         return Status.SUCCESS;
     }
 }
 
 /**
- * 并行节点 每次进入全部执行一遍
- * 它将从begin到end迭代执行自己的Child Node：
- * 1. 任意子节点返回 FAILURE, 返回 FAILURE
- * 2. 否则 任意子节点返回 RUNNING, 返回 RUNNING
- * 3. 全部成功, 才返回 SUCCESS
+ * 并行节点 从上到下执行 全部执行一遍
+ * 返回优先级 FAILURE > RUNNING > SUCCESS
  */
 export class Parallel extends Composite {
     public tick(): Status {
@@ -110,11 +114,8 @@ export class Parallel extends Composite {
             let status = this.children[i]!._execute();
             if (result === Status.FAILURE || status === Status.FAILURE) {
                 result = Status.FAILURE;
-                continue;
-            }
-            if (status === Status.RUNNING) {
+            } else if (status === Status.RUNNING) {
                 result = Status.RUNNING;
-                continue;
             }
         }
         return result;
@@ -122,24 +123,18 @@ export class Parallel extends Composite {
 }
 
 /**
- * 并行节点 每次进入全部重新执行一遍
- * 它将从begin到end迭代执行自己的Child Node：
- * 1. 任意子节点返回 SUCCESS, 返回 SUCCESS 
- * 2. 否则, 任意子节点返回 FAILURE, 返回 FAILURE
- * 否则返回 RUNNING
+ * 并行节点 从上到下执行 全部执行一遍
+ * 返回优先级 SUCCESS > RUNNING > FAILURE
  */
 export class ParallelAnySuccess extends Composite {
     public tick(): Status {
-        let result = Status.RUNNING;
+        let result = Status.FAILURE;
         for (let i = 0; i < this.children.length; i++) {
             let status = this.children[i]!._execute();
             if (result === Status.SUCCESS || status === Status.SUCCESS) {
                 result = Status.SUCCESS;
-                continue;
-            }
-            if (status === Status.FAILURE) {
-                result = Status.FAILURE;
-                continue;
+            } else if (status === Status.RUNNING) {
+                result = Status.RUNNING;
             }
         }
         return result;

src/behaviortree/BehaviorTree.ts

@@ -46,7 +46,7 @@ export class BehaviorTree<T> {
      */
     private _initializeAllNodeIds(node: IBTNode, parent?: IBTNode): void {
         // 设置当前节点ID
-        node._initialize(this._blackboard, parent ? parent.blackboard : this._blackboard);
+        node._initialize(this._blackboard, parent ? parent.local : this._blackboard);
         // 递归设置所有子节点ID
         for (const child of node.children) {
             this._initializeAllNodeIds(child, node);

src/behaviortree/Blackboard.ts

@@ -11,6 +11,7 @@
  * 黑板数据接口
  */
 export interface IBlackboard {
+    getEntity<T>(): T;
     get<T>(key: string): T;
     set<T>(key: string, value: T): void;
     delete(key: string): void;
@@ -29,8 +30,8 @@ export class Blackboard implements IBlackboard {
 
     /** 实体 */
     private readonly _entity: any;
-    public get entity(): any {
-        return this._entity || this.parent?.entity;
+    public getEntity<T>(): T {
+        return this._entity;
     }
 
     constructor(parent?: Blackboard, entity?: any) {
@@ -38,8 +39,8 @@ export class Blackboard implements IBlackboard {
         if (parent) {
             parent.children.add(this);
         }
-
-        this._entity = entity;
+        // 优先使用传入的 entity，如果没有则从父级继承
+        this._entity = entity !== undefined ? entity : (parent?._entity ?? null);
     }
 
     /** 核心: 查找链实现 */