Test_Project_Cocos/kunpolibrary
1
0
Fork 0
mirror of https://github.com/Gongxh0901/kunpolibrary synced 2025-10-09 16:45:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

添加内部属性标记

Browse Source
This commit is contained in:
宫欣海
2025-03-07 16:02:00 +08:00
parent b6551e9bbf
commit 897d618a0b
71 changed files with 909 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/behaviortree/Agent.ts
View File

@@ -4,8 +4,11 @@ import { Ticker } from "./Ticker";
/** 代理 */
export class Agent {
/** 行为树 */
public tree: BehaviorTree;
/** 黑板 */
public blackboard: Blackboard;
/** 更新器 */
public ticker: Ticker;
/**
* constructor
@@ -18,6 +21,9 @@ export class Agent {
this.ticker = new Ticker(subject, this.blackboard, tree);
}
/**
* 执行
*/
public tick(): void {
this.tree.tick(this, this.blackboard, this.ticker);
if (this.blackboard.interrupt) {

52
src/behaviortree/BTNode/Action.ts
View File

@@ -17,12 +17,18 @@ export abstract class Action extends BaseNode {
* 直接返回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;
@@ -34,12 +40,18 @@ export class Failure extends Action {
* 直接返回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;
@@ -51,12 +63,18 @@ export class Running extends Action {
* 直接返回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;
@@ -68,9 +86,9 @@ export class Success extends Action {
* 超次，返回SUCCESS
*/
export class WaitTicks extends Action {
/** 最大次数 */
/** 最大次数 @internal */
private _maxTicks: number;
/** 经过的次数 */
/** 经过的次数 @internal */
private _elapsedTicks: number;
constructor(maxTicks: number = 0) {
super();
@@ -78,10 +96,19 @@ export class WaitTicks extends Action {
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;
@@ -96,18 +123,27 @@ export class WaitTicks extends Action {
* 时间到后返回SUCCESS，否则返回RUNING
*/
export class WaitTime extends Action {
/** 等待时间(毫秒 ms) */
/** 等待时间(毫秒 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);
@@ -124,6 +160,11 @@ export class WaitTime extends Action {
* 和 InterruptDefendCancel 必须成对出现
*/
export class InterruptDefend extends Action {
/**
* 执行
* @param {Ticker} ticker
* @returns {Status}
*/
public tick(ticker: Ticker): Status {
ticker.blackboard.interruptDefend = true;
return Status.SUCCESS;
@@ -136,6 +177,11 @@ export class InterruptDefend extends Action {
* 和 InterruptDefend 必须成对出现
*/
export class InterruptDefendCancel extends Action {
/**
* 执行
* @param {Ticker} ticker
* @returns {Status}
*/
public tick(ticker: Ticker): Status {
ticker.blackboard.interruptDefend = false;
return Status.SUCCESS;

11
src/behaviortree/BTNode/BaseNode.ts
View File

@@ -26,7 +26,11 @@ export abstract class BaseNode {
}
}
/** 执行节点 */
/**
* 执行节点
* @param ticker 更新器
* @returns {Status} 状态
*/
public _execute(ticker: Ticker): Status {
/* ENTER */
this._enter(ticker);
@@ -44,6 +48,7 @@ export abstract class BaseNode {
/**
* 进入节点
* @param ticker 更新器
* @internal
*/
public _enter(ticker: Ticker): void {
ticker.enterNode(this);
@@ -53,6 +58,7 @@ export abstract class BaseNode {
/**
* 打开节点
* @param ticker 更新器
* @internal
*/
public _open(ticker: Ticker): void {
ticker.openNode(this);
@@ -63,6 +69,7 @@ export abstract class BaseNode {
/**
* 更新节点
* @param ticker 更新器
* @internal
*/
public _tick(ticker: Ticker): Status {
ticker.tickNode(this);
@@ -72,6 +79,7 @@ export abstract class BaseNode {
/**
* 关闭节点
* @param ticker 更新器
* @internal
*/
public _close(ticker: Ticker): void {
ticker.closeNode(this);
@@ -82,6 +90,7 @@ export abstract class BaseNode {
/**
* 退出节点
* @param ticker 更新器
* @internal
*/
public _exit(ticker: Ticker): void {
ticker.exitNode(this);

55
src/behaviortree/BTNode/Composite.ts
View File

@@ -18,12 +18,21 @@ export abstract class Composite extends BaseNode {
* 任意一个Child Node返回不为 FAILURE, 本Node向自己的Parent Node也返回Child Node状态
*/
export class MemSelector extends Composite {
open(ticker: Ticker): void {
/**
* 打开
* @param {Ticker} ticker
*/
public open(ticker: Ticker): void {
super.open(ticker);
ticker.blackboard.set("runningChild", 0, ticker.tree.id, this.id);
}
tick(ticker: Ticker): Status {
/**
* 执行
* @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++) {
@@ -49,12 +58,21 @@ export class MemSelector extends Composite {
* 所有节点都返回 SUCCESS, 本节点才返回 SUCCESS
*/
export class MemSequence extends Composite {
open(ticker: Ticker): void {
/**
* 打开
* @param {Ticker} ticker
*/
public open(ticker: Ticker): void {
super.open(ticker);
ticker.blackboard.set("runningChild", 0, ticker.tree.id, this.id);
}
tick(ticker: Ticker): Status {
/**
* 执行
* @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);
@@ -74,7 +92,12 @@ export class MemSequence extends Composite {
* 从Child Node中随机选择一个执行
*/
export class RandomSelector extends Composite {
tick(ticker: Ticker): Status {
/**
* 执行
* @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);
@@ -89,7 +112,12 @@ export class RandomSelector extends Composite {
* 如遇到一个Child Node执行后返回 SUCCESS 或者 RUNING，那停止迭代，本Node向自己的Parent Node也返回 SUCCESS 或 RUNING
*/
export class Selector extends Composite {
tick(ticker: Ticker): Status {
/**
* 执行
* @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) {
@@ -107,6 +135,11 @@ export class Selector extends Composite {
* 所有节点都返回 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);
@@ -126,6 +159,11 @@ export class Sequence extends Composite {
* 所有节点都返回 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++) {
@@ -148,6 +186,11 @@ export class Parallel extends Composite {
* 否则返回 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++) {

8
src/behaviortree/BTNode/Condition.ts
View File

@@ -6,13 +6,19 @@ 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;
}
tick(ticker: Ticker): Status {
/**
* 执行
* @param {Ticker} ticker
* @returns {Status}
*/
public tick(ticker: Ticker): Status {
return this._func(ticker.subject) ? Status.SUCCESS : Status.FAILURE;
}
}

119
src/behaviortree/BTNode/Decorator.ts
View File

@@ -19,6 +19,11 @@ export abstract class Decorator extends BaseNode {
* @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)节点必须包含一个子节点");
@@ -36,7 +41,12 @@ export class Failer extends Decorator {
* 第一个Child Node节点, 返回 SUCCESS, 本Node向自己的Parent Node也返回 FAILURE
*/
export class Inverter extends Decorator {
tick(ticker: Ticker): Status {
/**
* 执行
* @param {Ticker} ticker
* @returns {Status}
*/
public tick(ticker: Ticker): Status {
if (this.children.length !== 1) {
throw new Error("(Inverter)节点必须包含一个子节点");
}
@@ -58,9 +68,9 @@ export class Inverter extends Decorator {
* 次数超过后, 直接返回 FAILURE
*/
export class LimiterTicks extends Decorator {
/** 最大次数 */
/** 最大次数 @internal */
private _maxTicks: number;
/** 当前执行过的次数 */
/** 当前执行过的次数 @internal */
private _elapsedTicks: number;
/**
@@ -74,12 +84,21 @@ export class LimiterTicks extends Decorator {
this._elapsedTicks = 0;
}
open(ticker: Ticker): void {
/**
* 打开
* @param {Ticker} ticker
*/
public open(ticker: Ticker): void {
super.open(ticker);
this._elapsedTicks = 0;
}
tick(ticker: Ticker): Status {
/**
* 执行
* @param {Ticker} ticker
* @returns {Status}
*/
public tick(ticker: Ticker): Status {
if (this.children.length !== 1) {
throw new Error("(LimiterTicks)节点必须包含一个子节点");
}
@@ -99,7 +118,7 @@ export class LimiterTicks extends Decorator {
* 超时后, 直接返回 FAILURE
*/
export class LimiterTime extends Decorator {
/** 最大时间 (毫秒 ms) */
/** 最大时间 (毫秒 ms) @internal */
private _maxTime: number;
/**
@@ -112,13 +131,22 @@ export class LimiterTime extends Decorator {
this._maxTime = maxTime * 1000;
}
open(ticker: Ticker): void {
/**
* 打开
* @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);
}
tick(ticker: Ticker): Status {
/**
* 执行
* @param {Ticker} ticker
* @returns {Status}
*/
public tick(ticker: Ticker): Status {
if (this.children.length !== 1) {
throw new Error("(LimiterTime)节点必须包含一个子节点");
}
@@ -142,18 +170,33 @@ export class LimiterTime extends Decorator {
* 否则等待次数超过之后, 返回Child Node的结果（RUNING的次数不计算在内）
*/
export class Repeater extends Decorator {
maxLoop: number;
/** 最大循环次数 @internal */
private _maxLoop: number;
/**
* 创建
* @param child 子节点
* @param maxLoop 最大循环次数
*/
constructor(child: BaseNode, maxLoop: number = -1) {
super(child);
this.maxLoop = maxLoop;
this._maxLoop = maxLoop;
}
open(ticker: Ticker): void {
/**
* 打开
* @param {Ticker} ticker
*/
public open(ticker: Ticker): void {
ticker.blackboard.set("i", 0, ticker.tree.id, this.id);
}
tick(ticker: Ticker): Status {
/**
* 执行
* @param {Ticker} ticker
* @returns {Status}
*/
public tick(ticker: Ticker): Status {
if (this.children.length !== 1) {
throw new Error("(Repeater)节点必须包含一个子节点");
}
@@ -162,7 +205,7 @@ export class Repeater extends Decorator {
let i = ticker.blackboard.get("i", ticker.tree.id, this.id);
let status = Status.SUCCESS;
while (this.maxLoop < 0 || i < this.maxLoop) {
while (this._maxLoop < 0 || i < this._maxLoop) {
status = child._execute(ticker);
if (status === Status.SUCCESS || status === Status.FAILURE) {
@@ -185,18 +228,28 @@ export class Repeater extends Decorator {
* 循环次数大于等于maxLoop时, 返回Child Node的结果
*/
export class RepeatUntilFailure extends Decorator {
maxLoop: number;
/** 最大循环次数 @internal */
private _maxLoop: number;
constructor(child: BaseNode, maxLoop: number = -1) {
super(child);
this.maxLoop = maxLoop;
this._maxLoop = maxLoop;
}
open(ticker: Ticker): void {
/**
* 打开
* @param {Ticker} ticker
*/
public open(ticker: Ticker): void {
ticker.blackboard.set("i", 0, ticker.tree.id, this.id);
}
tick(ticker: Ticker): Status {
/**
* 执行
* @param {Ticker} ticker
* @returns {Status}
*/
public tick(ticker: Ticker): Status {
if (this.children.length !== 1) {
throw new Error("(RepeatUntilFailure)节点必须包含一个子节点");
}
@@ -205,7 +258,7 @@ export class RepeatUntilFailure extends Decorator {
let i = ticker.blackboard.get("i", ticker.tree.id, this.id);
let status = Status.SUCCESS;
while (this.maxLoop < 0 || i < this.maxLoop) {
while (this._maxLoop < 0 || i < this._maxLoop) {
status = child._execute(ticker);
if (status === Status.SUCCESS) {
@@ -227,17 +280,33 @@ export class RepeatUntilFailure extends Decorator {
* 循环次数大于等于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;
}
open(ticker: Ticker): void {
/**
* 打开
* @param {Ticker} ticker
*/
public open(ticker: Ticker): void {
ticker.blackboard.set("i", 0, ticker.tree.id, this.id);
}
tick(ticker: Ticker): Status {
/**
* 执行
* @param {Ticker} ticker
* @returns {Status}
*/
public tick(ticker: Ticker): Status {
if (this.children.length !== 1) {
throw new Error("(RepeatUntilSuccess)节点必须包含一个子节点");
}
@@ -262,6 +331,11 @@ export class RepeatUntilSuccess extends Decorator {
* 直接返回 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)节点必须包含一个子节点");
@@ -277,6 +351,11 @@ export class Runner extends Decorator {
* 直接返回 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)节点必须包含一个子节点");

14
src/behaviortree/BehaviorTree.ts
View File

@@ -8,15 +8,25 @@ import { Ticker } from "./Ticker";
* 所有节点全部添加到树中
*/
export class BehaviorTree {
/** 行为树ID */
/** 行为树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;

51
src/behaviortree/Blackboard.ts
View File

@@ -8,9 +8,13 @@ interface ITreeData {
/** 平台 */
export class Blackboard {
public interruptDefend: boolean = false; // 行为树打断保护
public interrupt: boolean = false; // 打断行为树的标记
/** 行为树打断保护 */
public interruptDefend: boolean = false;
/** 打断行为树的标记 */
public interrupt: boolean = false;
/** 基础记忆 @internal */
private _baseMemory: any;
/** 树记忆 @internal */
private _treeMemory: { [treeScope: string]: ITreeData };
constructor() {
@@ -18,21 +22,44 @@ export class Blackboard {
this._treeMemory = {};
}
clear(): void {
/**
* 清除
*/
public clear(): void {
this._baseMemory = {};
this._treeMemory = {};
}
set(key: string, value: any, treeScope?: string, nodeScope?: string): void {
/**
* 设置
* @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;
}
get(key: string, treeScope?: string, nodeScope?: string): any {
/**
* 获取
* @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] = {
@@ -43,6 +70,13 @@ export class Blackboard {
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]) {
@@ -51,6 +85,13 @@ export class Blackboard {
return memory[nodeScope];
}
/**
* 获取记忆
* @param treeScope 树范围
* @param nodeScope 节点范围
* @returns 记忆
* @internal
*/
private _getMemory(treeScope?: string, nodeScope?: string): { [key: string]: any } {
let memory = this._baseMemory;
if (treeScope) {

35
src/behaviortree/Ticker.ts
View File

@@ -18,23 +18,38 @@ export class Ticker {
this.blackboard = blackboard;
}
/** 进入节点 */
enterNode(node: BaseNode): void {
/**
* 进入节点
* @param node 节点
*/
public enterNode(node: BaseNode): void {
this.nodeCount++;
this.openNodes.push(node);
}
/** 打开节点 */
openNode(node: BaseNode): void { }
/**
* 打开节点
* @param node 节点
*/
public openNode(node: BaseNode): void { }
/** 更新节点 */
tickNode(node: BaseNode): void { }
/**
* 更新节点
* @param node 节点
*/
public tickNode(node: BaseNode): void { }
/** 关闭节点 */
closeNode(node: BaseNode): void {
/**
* 关闭节点
* @param node 节点
*/
public closeNode(node: BaseNode): void {
this.openNodes.pop();
}
/** 退出节点 */
exitNode(node: BaseNode): void { }
/**
* 退出节点
* @param node 节点
*/
public exitNode(node: BaseNode): void { }
}

5
src/behaviortree/header.ts
View File

@@ -4,6 +4,11 @@ export const enum Status {
RUNNING,
}
/**
* 创建UUID
* @returns UUID
* @internal
*/
export function createUUID(): string {
let s: string[] = Array(36);
let hexDigits = "0123456789abcdef";