init

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;
+    }
+}