/** 配置版本号 */

version: string;

/** 配置类型标识 */

type: string;

/** 元数据信息 */

metadata?: BehaviorTreeMetadata;

/** 根节点配置 */

tree: NodeConfig;

/** 行为树名称 */

name?: string;

/** 版本信息 */

version?: string;

/** 创建时间 */

created?: string;

/** 导出类型 */

exportType?: string;

/** 更新周期（秒） */

updatePeriod?: number;

/** 描述信息 */

description?: string;

/** 作者信息 */

author?: string;

/** 扩展属性 */

[key: string]: unknown;

/** 节点唯一标识符 */

id: string;

/** 节点类型 */

type: string;

/** 命名空间（可选） */

namespace?: string;

/** 节点属性配置 */

properties?: Record<string, NodePropertyConfig>;

/** 子节点配置数组 */

children?: NodeConfig[];

/** 属性类型 */

type: string;

/** 属性值 */

value: NodePropertyValue;

/** 节点列表 */

nodes: BehaviorTreeNodeConfig[];

/** 黑板变量配置 */

blackboard?: BlackboardVariableConfig[];

/** 元数据信息 */

metadata?: BehaviorTreeMetadata;

/** 节点唯一标识符 */

id: string;

/** 节点类型 */

type: string;

/** 节点显示名称 */

name: string;

/** 节点属性 */

properties?: Record<string, NodePropertyValue>;

/** 子节点ID列表 */

children?: string[];

/** 条件配置（用于条件装饰器等） */

condition?: ConditionConfig;

/** 变量名称 */

name: string;

/** 变量类型 */

type: string;

/** 变量初始值 */

value: BlackboardVariableValue;

/** 变量描述 */

description?: string;

/** 变量分组 */

group?: string;

/** 变量约束条件 */

constraints?: {

/** 最小值（数值类型） */

min?: number;

/** 最大值（数值类型） */

max?: number;

/** 只读标志 */

readonly?: boolean;

/** 可选值列表（枚举类型） */

options?: BlackboardVariableValue[];

};

/** 构建好的行为树实例 */

tree: BehaviorTree<T>;

/** 初始化的黑板实例 */

blackboard: Blackboard;

/** 增强的执行上下文 */

context: T;

/** 执行上下文 */

private _context: T;

/** 当前创建的节点 */

private _currentNode: Behavior<T> | undefined;

/** 父节点堆栈，用于流畅API构建 */

private _parentNodeStack: Array<Behavior<T>> = new Array<Behavior<T>>();

/**

public constructor(context: T) {

this._context = context;

}

/**

public static begin<T>(context: T): BehaviorTreeBuilder<T> {

return new BehaviorTreeBuilder<T>(context);

}

/**

private setChildOnParent(child: Behavior<T>): BehaviorTreeBuilder<T> {

const parent = this._parentNodeStack[this._parentNodeStack.length - 1];

if (parent instanceof Composite) {

(parent as Composite<T>).addChild(child);

}

else if (parent instanceof Decorator) {

// 装饰器只有一个子节点，所以自动结束

(parent as Decorator<T>).child = child;

this.endDecorator();

}

return this;

}

/**

private pushParentNode(composite: Behavior<T>): BehaviorTreeBuilder<T> {

if (this._parentNodeStack.length > 0) {

this.setChildOnParent(composite);

}

this._parentNodeStack.push(composite);

return this;

}

/**

private endDecorator(): BehaviorTreeBuilder<T> {

this._currentNode = this._parentNodeStack.pop();

return this;

}

/**

public action(func: (t: T) => TaskStatus): BehaviorTreeBuilder<T> {

if (this._parentNodeStack.length === 0) {

throw new Error("无法创建无嵌套的动作节点，它必须是一个叶节点");

}

return this.setChildOnParent(new ExecuteAction<T>(func));

}

/**

public actionR(func: (t: T) => boolean): BehaviorTreeBuilder<T> {

return this.action(t => func(t) ? TaskStatus.Success : TaskStatus.Failure);

}

/**

public executeAction(func: (t: T) => TaskStatus): BehaviorTreeBuilder<T> {

return this.action(func);

}

/**

public conditional(func: (t: T) => TaskStatus): BehaviorTreeBuilder<T> {

if (this._parentNodeStack.length === 0) {

throw new Error("无法创建无嵌套的条件节点，它必须是一个叶节点");

}

return this.setChildOnParent(new ExecuteActionConditional<T>(func));

}

/**

public conditionalR(func: (t: T) => boolean): BehaviorTreeBuilder<T> {

return this.conditional(t => func(t) ? TaskStatus.Success : TaskStatus.Failure);

}

/**

public logAction(text: string): BehaviorTreeBuilder<T> {

if (this._parentNodeStack.length === 0) {

throw new Error("无法创建无嵌套的动作节点，它必须是一个叶节点");

}

return this.setChildOnParent(new LogAction<T>(text));

}

/**

public waitAction(waitTime: number): BehaviorTreeBuilder<T> {

if (this._parentNodeStack.length === 0) {

throw new Error("无法创建无嵌套的动作节点，它必须是一个叶节点");

}

return this.setChildOnParent(new WaitAction<T>(waitTime));

}

/**

public subTree(subTree: BehaviorTree<T>): BehaviorTreeBuilder<T> {

if (this._parentNodeStack.length === 0) {

throw new Error("无法创建无嵌套的动作节点，它必须是一个叶节点");

}

return this.setChildOnParent(new BehaviorTreeReference<T>(subTree));

}

/**

public setBlackboardValue(variableName: string, value: any, sourceVariable?: string, force: boolean = false): BehaviorTreeBuilder<T> {

if (this._parentNodeStack.length === 0) {

throw new Error("无法创建无嵌套的动作节点，它必须是一个叶节点");

}

return this.setChildOnParent(new SetBlackboardValue<T>(variableName, value, sourceVariable, force));

}

/**

public conditionalDecorator(func: (t: T) => TaskStatus, shouldReevaluate?: boolean, abortType?: AbortTypes): BehaviorTreeBuilder<T>;

public conditionalDecorator(func: (t: T) => boolean, shouldReevaluate?: boolean, abortType?: AbortTypes): BehaviorTreeBuilder<T>;

public conditionalDecorator(func: (t: T) => TaskStatus | boolean, shouldReevaluate: boolean = true, abortType: AbortTypes = AbortTypes.None): BehaviorTreeBuilder<T> {

const wrappedFunc = (t: T): TaskStatus => {

const result = func(t);

if (typeof result === 'boolean') {

return result ? TaskStatus.Success : TaskStatus.Failure;

}

return result;

};

const conditional = new ExecuteActionConditional<T>(wrappedFunc);

return this.pushParentNode(new ConditionalDecorator<T>(conditional, shouldReevaluate, abortType));

}

/**

public conditionalDecoratorR(func: (t: T) => boolean, shouldReevaluate: boolean = true): BehaviorTreeBuilder<T> {

return this.conditionalDecorator(t => func(t) ? TaskStatus.Success : TaskStatus.Failure, shouldReevaluate);

}

/**

public alwaysFail(): BehaviorTreeBuilder<T> {

return this.pushParentNode(new AlwaysFail<T>());

}

/**

public alwaysSucceed(): BehaviorTreeBuilder<T> {

return this.pushParentNode(new AlwaysSucceed<T>());

}

/**

public inverter(): BehaviorTreeBuilder<T> {

return this.pushParentNode(new Inverter());

}

/**

public repeater(count: number): BehaviorTreeBuilder<T> {

return this.pushParentNode(new Repeater<T>(count));

}

/**

public untilFail(): BehaviorTreeBuilder<T> {

return this.pushParentNode(new UntilFail<T>());

}

/**

public untilSuccess(): BehaviorTreeBuilder<T> {

return this.pushParentNode(new UntilSuccess<T>());

}

/**

public paraller(): BehaviorTreeBuilder<T> {

return this.pushParentNode(new Parallel<T>());

}

/**

public parallel(): BehaviorTreeBuilder<T> {

return this.paraller();

}

/**

public parallelSelector(): BehaviorTreeBuilder<T> {

return this.pushParentNode(new ParallelSelector<T>());

}

/**

public selector(abortType: AbortTypes = AbortTypes.None): BehaviorTreeBuilder<T> {

return this.pushParentNode(new Selector<T>(abortType));

}

/**

public randomSelector(): BehaviorTreeBuilder<T> {

return this.pushParentNode(new RandomSelector());

}

/**

public sequence(abortType: AbortTypes = AbortTypes.None): BehaviorTreeBuilder<T> {

return this.pushParentNode(new Sequence<T>(abortType));

}

/**

public randomSequence(): BehaviorTreeBuilder<T> {

return this.pushParentNode(new RandomSequence<T>());

}

/**

public endComposite(): BehaviorTreeBuilder<T> {

const topNode = this._parentNodeStack[this._parentNodeStack.length - 1];

if (!(topNode instanceof Composite)) {

throw new Error("尝试结束复合器，但顶部节点是装饰器");

}

this._currentNode = this._parentNodeStack.pop();

return this;

}

/**

public build(updatePeriod: number = 0.2): BehaviorTree<T> {

if (!this._currentNode) {

throw new Error('无法创建零节点的行为树');

}

return new BehaviorTree<T>(this._context, this._currentNode, updatePeriod);

}

/**

public static fromConfig<T>(config: BehaviorTreeConfig, context: T): BehaviorTree<T> {

try {

if (!config || !config.tree) {

throw new Error('配置无效：缺少tree属性');

}

const rootNode = BehaviorTreeBuilder.createNodeFromConfig<T>(config.tree);

const updatePeriod = config.metadata?.updatePeriod ?? 0.2;

return new BehaviorTree<T>(context, rootNode, updatePeriod);

} catch (error) {

const errorMessage = error instanceof Error ? error.message : String(error);

throw new Error(`从配置创建行为树失败: ${errorMessage}`);

}

}

/**

public static fromBehaviorTreeConfig<T extends ExecutionContext = ExecutionContext>(

config: BehaviorTreeJSONConfig,

context?: T

): BehaviorTreeBuildResult<T> {

try {

// 验证配置

if (!config || !config.nodes || config.nodes.length === 0) {

throw new Error('配置无效：缺少nodes属性或nodes为空');

}

// 创建黑板并初始化变量

const blackboard = new Blackboard();

if (config.blackboard && config.blackboard.length > 0) {

for (const variable of config.blackboard) {

// 映射类型字符串到枚举

const blackboardType = BehaviorTreeBuilder.mapToBlackboardType(variable.type);

// 转换值类型以匹配黑板期望的类型

const convertedValue = BehaviorTreeBuilder.convertBlackboardValue(variable.value, blackboardType);

blackboard.defineVariable(

variable.name,

blackboardType,

convertedValue,

{

description: variable.description,

group: variable.group || 'Default',

readonly: variable.constraints?.readonly ?? false

}

);

}

}

// 创建或增强执行上下文

const enhancedContext = (context || {}) as T;

enhancedContext.blackboard = blackboard;

// 构建节点树

const nodeMap = new Map<string, BehaviorTreeNodeConfig>();

// 建立节点映射

for (const node of config.nodes) {

nodeMap.set(node.id, node);

}

// 找到根节点（通常是第一个节点或type为'root'的节点）

const rootNodeConfig = config.nodes.find(n => n.type === 'root') || config.nodes[0];

if (!rootNodeConfig) {

throw new Error('未找到根节点');

}

// 递归构建节点树

const rootNode = BehaviorTreeBuilder.createNodeFromJSONConfig<T>(rootNodeConfig, nodeMap, enhancedContext);

// 创建行为树

const updatePeriod = config.metadata?.updatePeriod ?? 0.2;

const tree = new BehaviorTree<T>(enhancedContext, rootNode, updatePeriod, false, blackboard);

return { tree, blackboard, context: enhancedContext };

} catch (error) {

const errorMessage = error instanceof Error ? error.message : String(error);

throw new Error(`从配置创建行为树失败: ${errorMessage}`);

}

}

/**

private static mapToBlackboardType(typeString: string): BlackboardValueType {

switch (typeString.toLowerCase()) {

case 'string':

return BlackboardValueType.String;

case 'number':

return BlackboardValueType.Number;

case 'boolean':

return BlackboardValueType.Boolean;

case 'vector2':

return BlackboardValueType.Vector2;

case 'vector3':

return BlackboardValueType.Vector3;

case 'object':

return BlackboardValueType.Object;

case 'array':

return BlackboardValueType.Array;

default:

console.warn(`未知的变量类型: ${typeString}, 默认使用Object类型`);

return BlackboardValueType.Object;

}

}

/**

private static convertBlackboardValue(value: any, targetType: BlackboardValueType): any {

// 为不同类型提供合理的默认值

if (value === null || value === undefined || value === '') {

switch (targetType) {

case BlackboardValueType.String:

return '';

case BlackboardValueType.Number:

return 0;

case BlackboardValueType.Boolean:

return false; // 布尔类型默认为false

case BlackboardValueType.Vector2:

return { x: 0, y: 0 };

case BlackboardValueType.Vector3:

return { x: 0, y: 0, z: 0 };

case BlackboardValueType.Object:

return {};

case BlackboardValueType.Array:

return [];

default:

return null;

}

}

switch (targetType) {

case BlackboardValueType.String:

return String(value);

case BlackboardValueType.Number:

if (typeof value === 'string') {

const num = parseFloat(value);

if (isNaN(num)) {

console.warn(`无法将 "${value}" 转换为数字，使用默认值 0`);

return 0;

}

return num;

}

return typeof value === 'number' ? value : 0;

case BlackboardValueType.Boolean:

if (typeof value === 'string') {

// 处理空字符串的情况

if (value === '') return false;

return value.toLowerCase() === 'true';

}

return Boolean(value);

case BlackboardValueType.Vector2:

if (typeof value === 'string') {

try {

const parsed = JSON.parse(value);

return parsed && typeof parsed === 'object' && 'x' in parsed && 'y' in parsed

? parsed

: { x: 0, y: 0 };

} catch {

console.warn(`无法解析Vector2值 "${value}"，使用默认值 {x:0, y:0}`);

return { x: 0, y: 0 };

}

}

return value && typeof value === 'object' && 'x' in value && 'y' in value

? value

: { x: 0, y: 0 };

case BlackboardValueType.Vector3:

if (typeof value === 'string') {

try {

const parsed = JSON.parse(value);

return parsed && typeof parsed === 'object' && 'x' in parsed && 'y' in parsed && 'z' in parsed

? parsed

: { x: 0, y: 0, z: 0 };

} catch {

console.warn(`无法解析Vector3值 "${value}"，使用默认值 {x:0, y:0, z:0}`);

return { x: 0, y: 0, z: 0 };

}

}

return value && typeof value === 'object' && 'x' in value && 'y' in value && 'z' in value

? value

: { x: 0, y: 0, z: 0 };

case BlackboardValueType.Object:

if (typeof value === 'string') {

try {

return JSON.parse(value);

} catch {

console.warn(`无法解析Object值 "${value}"，使用默认值 {}`);

return {};

}

}

return typeof value === 'object' ? value : {};

case BlackboardValueType.Array:

if (typeof value === 'string') {

try {

const parsed = JSON.parse(value);

return Array.isArray(parsed) ? parsed : [];

} catch {

console.warn(`无法解析Array值 "${value}"，使用默认值 []`);

return [];

}

}

return Array.isArray(value) ? value : [];

default:

return value;

}

}

/**

private static createNodeFromConfig<T>(nodeConfig: NodeConfig): Behavior<T> {

let node: Behavior<T>;

// 根据节点类型创建对应的节点实例

switch (nodeConfig.type) {

// 复合节点

case 'Sequence':

const sequenceAbortValue = nodeConfig.properties?.abortType?.value;

const sequenceAbortType = BehaviorTreeBuilder.getAbortType(

typeof sequenceAbortValue === 'string' ? sequenceAbortValue : 'None'

);

node = new Sequence<T>(sequenceAbortType);

break;

case 'Selector':

const selectorAbortValue = nodeConfig.properties?.abortType?.value;

const selectorAbortType = BehaviorTreeBuilder.getAbortType(

typeof selectorAbortValue === 'string' ? selectorAbortValue : 'None'

);

node = new Selector<T>(selectorAbortType);

break;

case 'Parallel':

node = new Parallel<T>();

break;

case 'ParallelSelector':

node = new ParallelSelector<T>();

break;

case 'RandomSelector':

node = new RandomSelector<T>();

break;

case 'RandomSequence':

node = new RandomSequence<T>();

break;

// 装饰器节点

case 'AlwaysSucceed':

node = new AlwaysSucceed<T>();

break;

case 'AlwaysFail':

node = new AlwaysFail<T>();

break;

case 'Inverter':

node = new Inverter<T>();

break;

case 'Repeater':

const countValue = nodeConfig.properties?.count?.value;

const count = typeof countValue === 'number' ? countValue : 1;

node = new Repeater<T>(count);

break;

case 'UntilSuccess':

node = new UntilSuccess<T>();

break;

case 'UntilFail':

node = new UntilFail<T>();

break;

// 动作节点

case 'LogAction':

const messageValue = nodeConfig.properties?.message?.value;

const message = typeof messageValue === 'string' ? messageValue : 'Default log message';

node = new LogAction<T>(message);

break;

case 'WaitAction':

const waitTimeValue = nodeConfig.properties?.waitTime?.value;

const waitTime = typeof waitTimeValue === 'number' ? waitTimeValue : 1.0;

node = new WaitAction<T>(waitTime);

break;

case 'ExecuteAction':

// 对于自定义动作，我们创建一个默认的执行函数

const actionCode = nodeConfig.properties?.actionCode?.value;

if (actionCode && typeof actionCode === 'string') {

try {

// 简单的代码执行（在实际项目中应该更安全地处理）

const actionFunc = new Function('context', 'TaskStatus', `

node = new ExecuteAction<T>((context: T) => {

try {

return actionFunc(context, TaskStatus);

} catch (error) {

console.error('执行动作失败:', error);

return TaskStatus.Failure;

}

});

} catch (error) {

console.warn('解析动作代码失败，使用默认动作:', error);

node = new ExecuteAction<T>(() => TaskStatus.Success);

}

} else {

node = new ExecuteAction<T>(() => TaskStatus.Success);

}

break;

default:

console.warn('⚠️ 未知的节点类型:', nodeConfig.type, '，使用默认动作节点');

node = new ExecuteAction<T>(() => TaskStatus.Success);

break;

}

// 为复合节点和装饰器添加子节点

if (nodeConfig.children && nodeConfig.children.length > 0) {

if (node instanceof Composite) {

// 复合节点可以有多个子节点

for (const childConfig of nodeConfig.children) {

const childNode = BehaviorTreeBuilder.createNodeFromConfig<T>(childConfig);