@esengine/ai
Version:
用于Laya、Cocos Creator等JavaScript游戏引擎的高性能AI系统库：行为树、实用AI和有限状态机
4,481 lines • 137 kB
TypeScript
/**
* @esengine/ai v2.0.25
* TypeScript definitions
*/
/**
* 数组扩展器和高效数据结构工具
* 提供栈、队列等数据结构的高效实现
*/
declare class ArrayExt {
/**
* 将数组打乱顺序（Fisher-Yates洗牌算法）
* 时间复杂度: O(n)，空间复杂度: O(1)
*
* @param list 要打乱的数组
* @throws {Error} 当数组为null或undefined时抛出错误
*/
static shuffle<T>(list: Array<T>): void;
/**
* 取出数组第一个项（不移除）
* @param list 目标数组
* @returns 第一个元素
* @throws {Error} 当数组为空时抛出错误
*/
static peek<T>(list: Array<T>): T;
/**
* 向数组头部添加一个项
* @param list 目标数组
* @param item 要添加的项
*/
static unshift<T>(list: Array<T>, item: T): void;
/**
* 移除数组第一个项并返回它
* @param list 目标数组
* @returns 移除的元素，如果数组为空则返回undefined
*/
static pop<T>(list: Array<T>): T | undefined;
/**
* 向数组尾部添加一个项
* @param list 目标数组
* @param item 要添加的项
*/
static append<T>(list: Array<T>, item: T): void;
/**
* 移除数组最后一个项并返回它
* @param list 目标数组
* @returns 移除的元素，如果数组为空则返回undefined
*/
static removeLast<T>(list: Array<T>): T | undefined;
/**
* 检查数组是否为空
* @param list 目标数组
* @returns 是否为空
*/
static isEmpty<T>(list: Array<T>): boolean;
/**
* 获取数组大小
* @param list 目标数组
* @returns 数组长度
*/
static size<T>(list: Array<T>): number;
/**
* 清空数组
* @param list 目标数组
*/
static clear<T>(list: Array<T>): void;
}
/**
* 高效的双端队列实现
* 使用环形缓冲区，避免数组头部插入的性能问题
*
* @template T 队列中元素的类型
*
* @example
* ```typescript
* const deque = new Deque<number>(32);
* deque.push(1);
* deque.unshift(0);
* console.log(deque.peekFirst()); // 0
* console.log(deque.peekLast()); // 1
* ```
*/
declare class Deque<T> {
private _buffer;
private _head;
private _tail;
private _size;
private _capacity;
/**
* 创建双端队列
* @param initialCapacity 初始容量，必须大于0，默认16
*/
constructor(initialCapacity?: number);
/**
* 向队列头部添加元素
* @param item 要添加的元素
*/
unshift(item: T): void;
/**
* 向队列尾部添加元素
* @param item 要添加的元素
*/
push(item: T): void;
/**
* 从队列头部移除元素
* @returns 移除的元素，如果队列为空则返回undefined
*/
shift(): T | undefined;
/**
* 从队列尾部移除元素
* @returns 移除的元素，如果队列为空则返回undefined
*/
pop(): T | undefined;
/**
* 查看队列头部元素（不移除）
* @returns 头部元素，如果队列为空则返回undefined
*/
peekFirst(): T | undefined;
/**
* 查看队列尾部元素（不移除）
* @returns 尾部元素，如果队列为空则返回undefined
*/
peekLast(): T | undefined;
/**
* 获取队列大小
*/
get size(): number;
/**
* 检查队列是否为空
*/
get isEmpty(): boolean;
/**
* 清空队列
*/
clear(): void;
/**
* 扩容队列（内部使用）
* 当队列满时自动调用，容量翻倍
*/
private _resize;
/**
* 将队列转换为数组
* @returns 包含队列所有元素的数组（从头到尾的顺序）
*/
toArray(): T[];
}
/**
* 高性能伪随机数生成器
* 使用xorshift128算法，比原生Math.random()更快且质量更好
*
* @example
* ```typescript
* // 设置种子（可选，默认使用当前时间）
* Random.setSeed(12345);
*
* // 生成0-1之间的随机数
* const value = Random.value();
*
* // 生成指定范围的随机数
* const rangeValue = Random.range(10, 20);
*
* // 生成随机整数
* const intValue = Random.integer(1, 100);
*
* // 随机布尔值
* const bool = Random.boolean();
*
* // 带概率的布尔值
* const probBool = Random.chance(0.7); // 70%概率返回true
* ```
*/
declare class Random {
private static _x;
private static _y;
private static _z;
private static _w;
private static _initialized;
/**
* 设置随机数种子
* @param seed 种子值，如果不提供则使用当前时间
*/
static setSeed(seed?: number): void;
/**
* 生成下一个32位无符号整数（内部使用）
* 使用xorshift128算法
*/
private static next;
/**
* 生成0到1之间的随机浮点数（不包括1）
* @returns 0 <= value < 1的随机数
*/
static value(): number;
/**
* 生成指定范围内的随机浮点数
* @param min 最小值（包含）
* @param max 最大值（不包含）
* @returns min <= value < max的随机数
*/
static range(min?: number, max?: number): number;
/**
* 生成指定范围内的随机整数
* @param min 最小值（包含）
* @param max 最大值（包含）
* @returns min <= value <= max的随机整数
*/
static integer(min: number, max: number): number;
/**
* 生成随机布尔值
* @returns 随机的true或false
*/
static boolean(): boolean;
/**
* 根据概率生成布尔值
* @param probability 返回true的概率（0-1之间）
* @returns 根据概率返回的布尔值
*/
static chance(probability: number): boolean;
/**
* 从数组中随机选择一个元素
* @param array 要选择的数组
* @returns 随机选中的元素
*/
static choice<T>(array: T[]): T;
/**
* 从数组中随机选择多个不重复的元素
* @param array 要选择的数组
* @param count 选择的数量
* @returns 随机选中的元素数组
*/
static sample<T>(array: T[], count: number): T[];
/**
* 生成符合正态分布的随机数（Box-Muller变换）
* @param mean 均值
* @param standardDeviation 标准差
* @returns 符合正态分布的随机数
*/
static gaussian(mean?: number, standardDeviation?: number): number;
/**
* 获取当前随机数生成器的状态（用于保存/恢复）
* @returns 生成器状态对象
*/
static getState(): {
x: number;
y: number;
z: number;
w: number;
};
/**
* 恢复随机数生成器的状态
* @param state 要恢复的状态对象
*/
static setState(state: {
x: number;
y: number;
z: number;
w: number;
}): void;
}
/**
* 高性能断言工具类
*
* @description
* 提供类型安全的断言方法，支持开发和生产环境的不同行为。
* 在生产环境中可以禁用断言以提高性能。
*
* @example
* ```typescript
* // 基本断言
* Assert.isTrue(player.health > 0, '玩家血量必须大于0');
* Assert.isNotNull(gameObject, '游戏对象不能为空');
*
* // 类型安全的断言
* const value: unknown = getData();
* Assert.isNumber(value, '数据必须是数字');
* // 现在 value 的类型被缩窄为 number
*
* // 配置断言行为
* Assert.setEnabled(false); // 在生产环境中禁用
* ```
*/
declare class Assert {
/** 是否启用断言检查 */
private static _enabled;
/** 是否在断言失败时抛出异常而不是仅记录 */
private static _throwOnFailure;
/**
* 设置是否启用断言
* @param enabled 是否启用
*/
static setEnabled(enabled: boolean): void;
/**
* 设置断言失败时的行为
* @param throwOnFailure 是否抛出异常，false则仅记录到控制台
*/
static setThrowOnFailure(throwOnFailure: boolean): void;
/**
* 断言失败处理
* @param message 错误消息
* @param args 附加参数
*/
static fail(message?: string, ...args: any[]): never;
/**
* 断言条件为真
* @param condition 要检查的条件
* @param message 失败时的错误消息
* @param args 附加参数
*/
static isTrue(condition: boolean, message?: string, ...args: any[]): asserts condition;
/**
* 断言条件为假
* @param condition 要检查的条件
* @param message 失败时的错误消息
* @param args 附加参数
*/
static isFalse(condition: boolean, message?: string, ...args: any[]): asserts condition is false;
/**
* 断言对象不为null或undefined
* @param obj 要检查的对象
* @param message 失败时的错误消息
* @param args 附加参数
*/
static isNotNull<T>(obj: T | null | undefined, message?: string, ...args: any[]): asserts obj is T;
/**
* 断言对象为null或undefined
* @param obj 要检查的对象
* @param message 失败时的错误消息
* @param args 附加参数
*/
static isNull(obj: any, message?: string, ...args: any[]): asserts obj is null | undefined;
/**
* 断言值为数字类型
* @param value 要检查的值
* @param message 失败时的错误消息
* @param args 附加参数
*/
static isNumber(value: unknown, message?: string, ...args: any[]): asserts value is number;
/**
* 断言值为字符串类型
* @param value 要检查的值
* @param message 失败时的错误消息
* @param args 附加参数
*/
static isString(value: unknown, message?: string, ...args: any[]): asserts value is string;
/**
* 断言值为布尔类型
* @param value 要检查的值
* @param message 失败时的错误消息
* @param args 附加参数
*/
static isBoolean(value: unknown, message?: string, ...args: any[]): asserts value is boolean;
/**
* 断言值为函数类型
* @param value 要检查的值
* @param message 失败时的错误消息
* @param args 附加参数
*/
static isFunction(value: unknown, message?: string, ...args: any[]): asserts value is Function;
/**
* 断言值为对象类型（非null）
* @param value 要检查的值
* @param message 失败时的错误消息
* @param args 附加参数
*/
static isObject(value: unknown, message?: string, ...args: any[]): asserts value is object;
/**
* 断言数组不为空
* @param array 要检查的数组
* @param message 失败时的错误消息
* @param args 附加参数
*/
static isNotEmpty<T>(array: T[], message?: string, ...args: any[]): asserts array is [T, ...T[]];
/**
* 断言字符串不为空
* @param str 要检查的字符串
* @param message 失败时的错误消息
* @param args 附加参数
*/
static isNotEmptyString(str: string | null | undefined, message?: string, ...args: any[]): asserts str is string;
/**
* 断言数值在指定范围内
* @param value 要检查的数值
* @param min 最小值（包含）
* @param max 最大值（包含）
* @param message 失败时的错误消息
* @param args 附加参数
*/
static inRange(value: number, min: number, max: number, message?: string, ...args: any[]): void;
/**
* 断言值是指定类型的实例
* @param value 要检查的值
* @param constructor 构造函数
* @param message 失败时的错误消息
* @param args 附加参数
*/
static isInstanceOf<T>(value: unknown, constructor: new (...args: any[]) => T, message?: string, ...args: any[]): asserts value is T;
/**
* 断言数组包含指定元素
* @param array 要检查的数组
* @param element 要查找的元素
* @param message 失败时的错误消息
* @param args 附加参数
*/
static contains<T>(array: T[], element: T, message?: string, ...args: any[]): void;
/**
* 获取当前断言配置
* @returns 配置对象
*/
static getConfig(): {
enabled: boolean;
throwOnFailure: boolean;
};
}
/**
* 日志级别枚举
*/
declare enum LogLevel {
/** 调试信息 */
Debug = 0,
/** 一般信息 */
Info = 1,
/** 警告信息 */
Warn = 2,
/** 错误信息 */
Error = 3,
/** 关闭日志 */
None = 4
}
/**
* 日志配置接口
*/
interface LoggerConfig {
/** 最小日志级别 */
minLevel: LogLevel;
/** 是否启用时间戳 */
enableTimestamp: boolean;
/** 是否启用堆栈跟踪（仅错误级别） */
enableStackTrace: boolean;
/** 是否启用性能模式（减少字符串格式化） */
performanceMode: boolean;
/** 自定义前缀 */
prefix?: string;
/** 是否启用批量模式 */
batchMode?: boolean;
/** 批量大小 */
batchSize?: number;
/** 批量刷新间隔（毫秒） */
batchFlushInterval?: number;
}
/**
* 高性能日志系统
*
* @description
* 提供分级日志记录功能，支持性能优化模式。
* 在性能模式下，会跳过不必要的字符串格式化和时间戳计算。
* 支持批量输出和延迟日志记录。
*
* @example
* ```typescript
* // 基本使用
* Logger.info('游戏开始');
* Logger.warn('玩家血量低', { health: 10 });
* Logger.error('网络连接失败', error);
*
* // 配置日志系统
* Logger.configure({
* minLevel: LogLevel.Warn,
* enableTimestamp: true,
* performanceMode: false,
* batchMode: true,
* batchSize: 50
* });
*
* // 性能敏感的代码中
* Logger.setPerformanceMode(true);
* ```
*/
declare class Logger {
private static _config;
/** 批量日志缓冲区 */
private static _logBuffer;
/** 批量模式配置 */
private static _batchConfig;
/** 性能模式下的简化日志函数 */
private static _fastLog;
/** 日志级别名称映射 */
private static readonly _levelNames;
/** 日志级别样式映射（用于浏览器控制台） */
private static readonly _levelStyles;
/**
* 配置日志系统
* @param config 日志配置
*/
static configure(config: Partial<LoggerConfig>): void;
/**
* 初始化性能模式
*/
private static _initializePerformanceMode;
/**
* 设置最小日志级别
* @param level 最小日志级别
*/
static setMinLevel(level: LogLevel): void;
/**
* 设置性能模式
* @param enabled 是否启用性能模式
*/
static setPerformanceMode(enabled: boolean): void;
/**
* 启用批量模式
* @param enabled 是否启用
* @param maxSize 批量大小
* @param flushInterval 刷新间隔（毫秒）
*/
static setBatchMode(enabled: boolean, maxSize?: number, flushInterval?: number): void;
/**
* 记录调试信息
* @param message 消息
* @param data 附加数据
*/
static debug(message: string, data?: any): void;
/**
* 记录一般信息
* @param message 消息
* @param data 附加数据
*/
static info(message: string, data?: any): void;
/**
* 记录警告信息
* @param message 消息
* @param data 附加数据
*/
static warn(message: string, data?: any): void;
/**
* 记录错误信息
* @param message 消息
* @param error 错误对象或附加数据
*/
static error(message: string, error?: any): void;
/**
* 内部日志记录方法
* @param level 日志级别
* @param message 消息
* @param data 附加数据
*/
private static _log;
/**
* 添加日志到批量缓冲区
*/
private static _addToBatch;
/**
* 刷新批量日志
*/
static flushLogs(): void;
/**
* 性能模式输出日志条目
*/
private static _performanceLogEntry;
/**
* 标准模式输出日志条目
*/
private static _standardLogEntry;
/**
* 格式化时间戳
*/
private static _formatTimestamp;
/**
* 性能模式日志输出
* @param level 日志级别
* @param message 消息
* @param data 附加数据
*/
private static _performanceLog;
/**
* 标准模式日志输出
* @param level 日志级别
* @param message 消息
* @param data 附加数据
*/
private static _standardLog;
/**
* 获取时间戳字符串
* @returns 格式化的时间戳
*/
private static _getTimestamp;
/**
* 根据日志级别获取对应的console方法
* @param level 日志级别
* @returns console方法
*/
private static _getConsoleMethod;
/**
* 获取当前配置
* @returns 当前日志配置的副本
*/
static getConfig(): Readonly<LoggerConfig>;
/**
* 创建带前缀的日志器
* @param prefix 前缀
* @returns 新的日志器实例
*/
static createPrefixed(prefix: string): PrefixedLogger;
}
/**
* 带前缀的日志器
* 用于为特定模块或组件创建专用的日志器
*/
declare class PrefixedLogger {
private readonly _prefix;
constructor(_prefix: string);
debug(message: string, data?: any): void;
info(message: string, data?: any): void;
warn(message: string, data?: any): void;
error(message: string, error?: any): void;
}
/**
* 时间管理器配置选项
*/
interface TimeManagerConfig {
/** 最大帧间时间差（秒） */
maxDeltaTime?: number;
/** 时间缩放比例 */
timeScale?: number;
/** 是否使用高精度时间 */
useHighPrecision?: boolean;
}
/**
* 全局时间管理器
*
* @description
* 提供高性能的时间管理功能，减少重复的时间计算开销。
* 使用时间池化技术，在每帧开始时统一计算时间，避免多次调用performance.now()。
*
* @example
* ```typescript
* // 在游戏主循环开始时更新时间
* TimeManager.updateFrame();
*
* // 获取当前时间（无额外计算开销）
* const currentTime = TimeManager.getCurrentTime();
* const deltaTime = TimeManager.getDeltaTime();
*
* // 配置时间管理器
* TimeManager.configure({
* maxDeltaTime: 0.1,
* timeScale: 1.0,
* useHighPrecision: true
* });
* ```
*/
declare class TimeManager {
/** 当前时间（秒） */
private static _currentTime;
/** 上一帧时间（秒） */
private static _lastTime;
/** 帧间时间差（秒） */
private static _deltaTime;
/** 未缩放的帧间时间差（秒） */
private static _unscaledDeltaTime;
/** 时间缩放比例 */
private static _timeScale;
/** 最大允许的帧间时间差（防止时间跳跃） */
private static _maxDeltaTime;
/** 是否使用高精度时间 */
private static _useHighPrecision;
/** 是否已初始化 */
private static _initialized;
/** 帧计数器 */
private static _frameCount;
/** 启动时间 */
private static _startTime;
/** 时间更新回调列表 */
private static _updateCallbacks;
/**
* 配置时间管理器
* @param config 配置选项
*/
static configure(config: TimeManagerConfig): void;
/**
* 初始化时间管理器
*/
static initialize(): void;
/**
* 更新帧时间（应在每帧开始时调用）
* @param externalDeltaTime 可选的外部提供的时间差
*/
static updateFrame(externalDeltaTime?: number): void;
/**
* 获取系统时间（毫秒）
*/
private static _getSystemTime;
/**
* 触发时间更新回调
*/
private static _triggerUpdateCallbacks;
/**
* 获取当前时间（秒）
* @returns 从初始化开始的累计时间
*/
static getCurrentTime(): number;
/**
* 获取帧间时间差（秒）
* @returns 当前帧与上一帧的时间差
*/
static getDeltaTime(): number;
/**
* 获取未缩放的帧间时间差（秒）
* @returns 未应用时间缩放的帧间时间差
*/
static getUnscaledDeltaTime(): number;
/**
* 获取时间缩放比例
*/
static getTimeScale(): number;
/**
* 设置时间缩放比例
* @param scale 缩放比例，0表示暂停，1表示正常速度
*/
static setTimeScale(scale: number): void;
/**
* 获取帧计数
*/
static getFrameCount(): number;
/**
* 获取平均帧率
*/
static getAverageFPS(): number;
/**
* 获取当前帧率
*/
static getCurrentFPS(): number;
/**
* 添加时间更新回调
* @param callback 回调函数
*/
static addUpdateCallback(callback: (deltaTime: number) => void): void;
/**
* 移除时间更新回调
* @param callback 要移除的回调函数
*/
static removeUpdateCallback(callback: (deltaTime: number) => void): void;
/**
* 清除所有时间更新回调
*/
static clearUpdateCallbacks(): void;
/**
* 重置时间管理器
*/
static reset(): void;
/**
* 获取时间管理器统计信息
*/
static getStats(): {
currentTime: number;
deltaTime: number;
unscaledDeltaTime: number;
timeScale: number;
frameCount: number;
averageFPS: number;
currentFPS: number;
maxDeltaTime: number;
useHighPrecision: boolean;
};
}
/**
* 错误处理级别枚举
*/
declare enum ErrorLevel {
/** 开发模式 - 严格检查，抛出所有错误 */
Development = 0,
/** 测试模式 - 记录错误但不中断执行 */
Testing = 1,
/** 生产模式 - 最小化错误处理，优先性能 */
Production = 2,
/** 静默模式 - 完全禁用错误处理 */
Silent = 3
}
/**
* 错误处理配置
*/
interface ErrorHandlerConfig {
/** 错误处理级别 */
level: ErrorLevel;
/** 是否启用断言 */
enableAssertions: boolean;
/** 是否启用类型检查 */
enableTypeChecking: boolean;
/** 是否启用性能监控 */
enablePerformanceMonitoring: boolean;
/** 错误回调函数 */
onError?: (error: Error, context?: any) => void;
/** 警告回调函数 */
onWarning?: (message: string, context?: any) => void;
}
/**
* 性能监控数据
*/
interface PerformanceData {
functionName: string;
executionTime: number;
callCount: number;
averageTime: number;
maxTime: number;
minTime: number;
}
/**
* 高性能错误处理系统
*
* @description
* 提供可配置的错误处理策略，支持开发和生产环境的不同行为。
* 在生产环境中可以完全禁用错误检查以提高性能。
*
* @example
* ```typescript
* // 配置错误处理器
* ErrorHandler.configure({
* level: ErrorLevel.Development,
* enableAssertions: true,
* enableTypeChecking: true
* });
*
* // 使用断言
* ErrorHandler.assert(player.health > 0, '玩家血量必须大于0');
*
* // 类型检查
* ErrorHandler.checkType(value, 'number', '值必须是数字');
*
* // 性能监控
* const result = ErrorHandler.monitor('expensiveFunction', () => {
* return expensiveOperation();
* });
* ```
*/
declare class ErrorHandler {
private static _config;
/** 性能监控数据 */
private static _performanceData;
/** 错误统计 */
private static _errorStats;
/**
* 配置错误处理器
* @param config 配置选项
*/
static configure(config: Partial<ErrorHandlerConfig>): void;
/**
* 设置错误处理级别
* @param level 错误处理级别
*/
static setLevel(level: ErrorLevel): void;
/**
* 断言检查
* @param condition 条件
* @param message 错误消息
* @param context 上下文信息
*/
static assert(condition: boolean, message: string, context?: any): asserts condition;
/**
* 类型检查
* @param value 要检查的值
* @param expectedType 期望的类型
* @param message 错误消息
* @param context 上下文信息
*/
static checkType(value: any, expectedType: string, message?: string, context?: any): void;
/**
* 非空检查
* @param value 要检查的值
* @param message 错误消息
* @param context 上下文信息
*/
static checkNotNull<T>(value: T | null | undefined, message?: string, context?: any): asserts value is T;
/**
* 范围检查
* @param value 要检查的值
* @param min 最小值
* @param max 最大值
* @param message 错误消息
* @param context 上下文信息
*/
static checkRange(value: number, min: number, max: number, message?: string, context?: any): void;
/**
* 数组边界检查
* @param array 数组
* @param index 索引
* @param message 错误消息
* @param context 上下文信息
*/
static checkArrayBounds<T>(array: T[], index: number, message?: string, context?: any): void;
/**
* 性能监控装饰器
* @param name 函数名称
* @param fn 要监控的函数
* @returns 函数执行结果
*/
static monitor<T>(name: string, fn: () => T): T;
/**
* 异步性能监控
* @param name 函数名称
* @param fn 要监控的异步函数
* @returns Promise结果
*/
static monitorAsync<T>(name: string, fn: () => Promise<T>): Promise<T>;
/**
* 记录性能数据
*/
private static _recordPerformance;
/**
* 处理错误
*/
private static _handleError;
/**
* 发出警告
* @param message 警告消息
* @param context 上下文信息
*/
static warn(message: string, context?: any): void;
/**
* 获取性能统计信息
*/
static getPerformanceStats(): ReadonlyMap<string, Readonly<PerformanceData>>;
/**
* 获取错误统计信息
*/
static getErrorStats(): Readonly<typeof ErrorHandler._errorStats>;
/**
* 重置统计信息
*/
static resetStats(): void;
/**
* 获取当前配置
*/
static getConfig(): Readonly<ErrorHandlerConfig>;
/**
* 创建带错误处理的函数包装器
* @param fn 原函数
* @param name 函数名称
* @param enableMonitoring 是否启用性能监控
* @returns 包装后的函数
*/
static wrap<TArgs extends any[], TReturn>(fn: (...args: TArgs) => TReturn, name: string, enableMonitoring?: boolean): (...args: TArgs) => TReturn;
}
/**
* 错误处理装饰器工厂
* @param options 装饰器选项
*/
declare function errorHandler(options?: {
name?: string;
enableMonitoring?: boolean;
enableTypeChecking?: boolean;
}): <T extends (...args: any[]) => any>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
/**
* 事件管理器配置
*/
interface EventManagerConfig {
/** 是否启用自动清理 */
enableAutoCleanup: boolean;
/** 清理间隔（毫秒） */
cleanupInterval: number;
/** 最大监听器数量 */
maxListeners: number;
/** 监听器过期时间（毫秒） */
listenerExpirationTime: number;
/** 是否启用性能监控 */
enablePerformanceMonitoring: boolean;
}
/**
* 事件统计信息
*/
interface EventStats {
/** 总监听器数量 */
totalListeners: number;
/** 活跃监听器数量 */
activeListeners: number;
/** 总事件触发次数 */
totalEvents: number;
/** 平均事件处理时间 */
averageEventTime: number;
/** 最后清理时间 */
lastCleanupTime: number;
}
/**
* 高性能事件管理器
*
* @description
* 提供带自动清理机制的事件管理系统，防止内存泄漏。
* 支持弱引用、优先级、一次性监听器等高级功能。
*
* @example
* ```typescript
* const eventManager = new EventManager({
* enableAutoCleanup: true,
* cleanupInterval: 30000, // 30秒清理一次
* maxListeners: 1000
* });
*
* // 添加监听器
* const listenerId = eventManager.on('playerDeath', (data) => {
* console.log('玩家死亡:', data);
* });
*
* // 添加弱引用监听器（自动清理）
* eventManager.onWeak('gameUpdate', callback, gameObject);
*
* // 触发事件
* eventManager.emit('playerDeath', { playerId: 123 });
*
* // 移除监听器
* eventManager.off('playerDeath', listenerId);
* ```
*/
declare class EventManager {
private readonly _listeners;
private readonly _config;
private _stats;
private _cleanupTimer;
private _nextListenerId;
/**
* 创建事件管理器
* @param config 配置选项
*/
constructor(config?: Partial<EventManagerConfig>);
/**
* 添加事件监听器
* @param eventName 事件名称
* @param callback 回调函数
* @param options 监听器选项
* @returns 监听器ID
*/
on<T = any>(eventName: string, callback: (data: T) => void, options?: {
once?: boolean;
priority?: number;
weak?: boolean;
owner?: object;
}): string;
/**
* 添加弱引用监听器（自动清理）
* @param eventName 事件名称
* @param callback 回调函数
* @param owner 拥有者对象
* @param options 其他选项
* @returns 监听器ID
*/
onWeak<T = any>(eventName: string, callback: (data: T) => void, owner: object, options?: {
once?: boolean;
priority?: number;
}): string;
/**
* 添加一次性监听器
* @param eventName 事件名称
* @param callback 回调函数
* @param options 其他选项
* @returns 监听器ID
*/
once<T = any>(eventName: string, callback: (data: T) => void, options?: {
priority?: number;
weak?: boolean;
owner?: object;
}): string;
/**
* 移除事件监听器
* @param eventName 事件名称
* @param listenerId 监听器ID
* @returns 是否成功移除
*/
off(eventName: string, listenerId: string): boolean;
/**
* 移除所有指定事件的监听器
* @param eventName 事件名称
* @returns 移除的监听器数量
*/
offAll(eventName: string): number;
/**
* 移除拥有者的所有监听器
* @param owner 拥有者对象
* @returns 移除的监听器数量
*/
offByOwner(owner: object): number;
/**
* 触发事件
* @param eventName 事件名称
* @param data 事件数据
* @returns 成功调用的监听器数量
*/
emit<T = any>(eventName: string, data?: T): number;
/**
* 检查是否有指定事件的监听器
* @param eventName 事件名称
* @returns 是否有监听器
*/
hasListeners(eventName: string): boolean;
/**
* 获取指定事件的监听器数量
* @param eventName 事件名称
* @returns 监听器数量
*/
getListenerCount(eventName: string): number;
/**
* 获取所有事件名称
* @returns 事件名称数组
*/
getEventNames(): string[];
/**
* 执行清理操作
* @param force 是否强制清理所有监听器
* @returns 清理的监听器数量
*/
cleanup(force?: boolean): number;
/**
* 启动自动清理
*/
private _startAutoCleanup;
/**
* 停止自动清理
*/
private _stopAutoCleanup;
/**
* 执行清理操作
*/
private _performCleanup;
/**
* 生成监听器ID
*/
private _generateListenerId;
/**
* 更新活跃监听器数量
*/
private _updateActiveListeners;
/**
* 更新平均事件处理时间
*/
private _updateAverageEventTime;
/**
* 获取统计信息
*/
getStats(): Readonly<EventStats>;
/**
* 重置统计信息
*/
resetStats(): void;
/**
* 获取配置信息
*/
getConfig(): Readonly<EventManagerConfig>;
/**
* 销毁事件管理器
*/
destroy(): void;
}
/**
* 类型检查结果
*/
interface TypeCheckResult<T = any> {
/** 是否通过检查 */
success: boolean;
/** 检查的值 */
value: T;
/** 错误信息 */
error?: string;
/** 期望的类型 */
expectedType?: string;
/** 实际的类型 */
actualType?: string;
}
/**
* 类型验证器接口
*/
interface TypeValidator<T> {
/** 验证函数 */
validate: (value: unknown) => value is T;
/** 类型名称 */
typeName: string;
/** 错误消息模板 */
errorMessage?: string;
}
/**
* 复合类型验证器
*/
interface CompositeValidator<T> {
/** 验证函数 */
validate: (value: unknown) => TypeCheckResult<T>;
/** 类型名称 */
typeName: string;
}
/**
* 高性能运行时类型检查工具
*
* @description
* 提供全面的运行时类型检查和类型守卫功能，替代不安全的类型断言。
* 支持基础类型、复合类型、自定义验证器等。
*
* @example
* ```typescript
* // 基础类型检查
* if (TypeGuards.isString(value)) {
* // value 现在是 string 类型
* console.log(value.toUpperCase());
* }
*
* // 复合类型检查
* const result = TypeGuards.checkObject(data, {
* name: TypeGuards.validators.string,
* age: TypeGuards.validators.number,
* email: TypeGuards.validators.optional(TypeGuards.validators.string)
* });
*
* // 数组类型检查
* if (TypeGuards.isArrayOf(value, TypeGuards.isNumber)) {
* // value 现在是 number[] 类型
* const sum = value.reduce((a, b) => a + b, 0);
* }
*
* // 自定义验证器
* const isPositiveNumber = TypeGuards.createValidator<number>(
* (value): value is number => typeof value === 'number' && value > 0,
* 'PositiveNumber'
* );
* ```
*/
declare class TypeGuards {
/** 内置验证器 */
static readonly validators: {
/** 字符串验证器 */
string: TypeValidator<string>;
/** 数字验证器 */
number: TypeValidator<number>;
/** 布尔值验证器 */
boolean: TypeValidator<boolean>;
/** 函数验证器 */
function: TypeValidator<Function>;
/** 对象验证器 */
object: TypeValidator<object>;
/** 数组验证器 */
array: TypeValidator<any[]>;
/** 非空验证器 */
notNull: TypeValidator<any>;
/** 整数验证器 */
integer: TypeValidator<number>;
/** 正数验证器 */
positiveNumber: TypeValidator<number>;
/** 非负数验证器 */
nonNegativeNumber: TypeValidator<number>;
/** 非空字符串验证器 */
nonEmptyString: TypeValidator<string>;
/** 可选验证器工厂 */
optional: <T>(validator: TypeValidator<T>) => TypeValidator<T | undefined>;
/** 可空验证器工厂 */
nullable: <T>(validator: TypeValidator<T>) => TypeValidator<T | null>;
/** 联合类型验证器工厂 */
union: <T extends readonly TypeValidator<any>[]>(...validators: T) => TypeValidator<T[number] extends TypeValidator<infer U> ? U : never>;
};
/**
* 检查是否为字符串
*/
static isString(value: unknown): value is string;
/**
* 检查是否为数字
*/
static isNumber(value: unknown): value is number;
/**
* 检查是否为布尔值
*/
static isBoolean(value: unknown): value is boolean;
/**
* 检查是否为函数
*/
static isFunction(value: unknown): value is Function;
/**
* 检查是否为对象（非null）
*/
static isObject(value: unknown): value is object;
/**
* 检查是否为数组
*/
static isArray(value: unknown): value is any[];
/**
* 检查是否为null或undefined
*/
static isNullish(value: unknown): value is null | undefined;
/**
* 检查是否不为null或undefined
*/
static isNotNull<T>(value: T | null | undefined): value is T;
/**
* 检查是否为指定类型的数组
*/
static isArrayOf<T>(value: unknown, itemGuard: (item: unknown) => item is T): value is T[];
/**
* 检查是否为字符串数组
*/
static isStringArray(value: unknown): value is string[];
/**
* 检查是否为数字数组
*/
static isNumberArray(value: unknown): value is number[];
/**
* 检查是否为指定类的实例
*/
static isInstanceOf<T>(value: unknown, constructor: new (...args: any[]) => T): value is T;
/**
* 检查对象是否具有指定的属性
*/
static hasProperty<K extends string>(value: unknown, property: K): value is Record<K, unknown>;
/**
* 检查对象是否具有指定类型的属性
*/
static hasPropertyOfType<K extends string, T>(value: unknown, property: K, typeGuard: (value: unknown) => value is T): value is Record<K, T>;
/**
* 创建自定义验证器
*/
static createValidator<T>(guard: (value: unknown) => value is T, typeName: string, errorMessage?: string): TypeValidator<T>;
/**
* 检查对象结构
*/
static checkObject<T extends Record<string, any>>(value: unknown, schema: {
[K in keyof T]: TypeValidator<T[K]>;
}): TypeCheckResult<T>;
/**
* 安全类型转换
*/
static safeCast<T>(value: unknown, validator: TypeValidator<T>): TypeCheckResult<T>;
/**
* 断言类型（开发模式下抛出错误）
*/
static assertType<T>(value: unknown, validator: TypeValidator<T>, message?: string): asserts value is T;
/**
* 尝试类型转换
*/
static tryConvert<T>(value: unknown, converter: (value: unknown) => T, validator: TypeValidator<T>): TypeCheckResult<T>;
/**
* 字符串转数字
*/
static stringToNumber(value: unknown): TypeCheckResult<number>;
/**
* 任意值转字符串
*/
static toString(value: unknown): TypeCheckResult<string>;
/**
* 任意值转布尔值
*/
static toBoolean(value: unknown): TypeCheckResult<boolean>;
/**
* 检查数字是否在指定范围内
*/
static isInRange(value: unknown, min: number, max: number, inclusive?: boolean): value is number;
/**
* 检查字符串长度是否在指定范围内
*/
static isStringLengthInRange(value: unknown, minLength: number, maxLength: number): value is string;
/**
* 检查数组长度是否在指定范围内
*/
static isArrayLengthInRange(value: unknown, minLength: number, maxLength: number): value is any[];
/**
* 检查字符串是否匹配正则表达式
*/
static matchesPattern(value: unknown, pattern: RegExp): value is string;
/**
* 检查是否为有效的电子邮件地址
*/
static isEmail(value: unknown): value is string;
/**
* 检查是否为有效的URL
*/
static isUrl(value: unknown): value is string;
/**
* 检查是否为有效的UUID
*/
static isUuid(value: unknown): value is string;
}
/**
* 行为树节点的执行状态枚举
*
* @description 定义了行为树中每个节点可能的执行状态
*/
declare enum TaskStatus {
/**
* 无效状态 - 节点尚未执行或已被重置
*/
Invalid = 0,
/**
* 成功状态 - 节点执行完成且成功
*/
Success = 1,
/**
* 失败状态 - 节点执行完成但失败
*/
Failure = 2,
/**
* 运行中状态 - 节点正在执行，需要在下一帧继续
*/
Running = 3
}
/**
* 行为树节点的抽象基类
*
* @description 所有行为树节点的基类，定义了节点的生命周期和基本行为
* @template T 上下文对象类型，通常包含游戏状态、AI数据等
*
* @example
* ```typescript
* class CustomAction<GameContext> extends Behavior<GameContext> {
* update(context: GameContext): TaskStatus {
* // 执行自定义逻辑
* return TaskStatus.Success;
* }
* }
* ```
*/
declare abstract class Behavior<T> {
/**
* 当前节点的执行状态
* @default TaskStatus.Invalid
*/
status: TaskStatus;
/**
* 抽象方法：节点的核心执行逻辑
*
* @description 子类必须实现此方法来定义节点的具体行为
* @param context 上下文对象，包含执行所需的数据
* @returns 执行后的状态（Success、Failure或Running）
*/
abstract update(context: T): TaskStatus;
/**
* 重置节点状态为无效
*
* @description 使该节点的状态无效，复合节点可以重写此方法来同时重置子节点
*/
invalidate(): void;
/**
* 节点开始执行时的回调
*
* @description 在节点首次执行或状态从Invalid变为其他状态时调用
* 用于初始化变量、重置状态等准备工作
*/
onStart(): void;
/**
* 节点执行结束时的回调
*
* @description 当节点状态变为Success或Failure时调用
* 用于清理资源、记录结果等收尾工作
*/
onEnd(): void;
/**
* 节点执行的主要入口点
*
* @description 处理节点的完整执行流程，包括生命周期管理
* 1. 如果状态为Invalid，调用onStart()
* 2. 调用update()执行核心逻辑
* 3. 如果状态不为Running，调用onEnd()
*
* @param context 执行上下文
* @returns 执行后的状态
*/
tick(context: T): TaskStatus;
}
/**
* 黑板变量类型枚举
*/
declare enum BlackboardValueType {
String = "string",
Number = "number",
Boolean = "boolean",
Vector2 = "vector2",
Vector3 = "vector3",
Object = "object",
Array = "array"
}
/**
* 黑板变量定义接口
*/
interface BlackboardVariable {
/** 变量名称 */
name: string;
/** 变量类型 */
type: BlackboardValueType;
/** 当前值 */
value: any;
/** 默认值 */
defaultValue: any;
/** 变量描述 */
description?: string;
/** 是否只读 */
readonly?: boolean;
/** 变量分组 */
group?: string;
/** 最小值（仅数字类型） */
min?: number;
/** 最大值（仅数字类型） */
max?: number;
/** 可选值列表 */
options?: any[];
}
/**
* 黑板监听器接口
*/
interface BlackboardListener {
/** 变量名称 */
variableName: string;
/** 回调函数 */
callback: (newValue: any, oldValue: any) => void;
/** 监听器ID */
id: string;
}
/**
* 行为树黑板系统
*
* @description
* 提供类型安全的变量存储和访问机制，支持：
* - 类型化变量定义和访问
* - 变量监听和回调
* - 序列化和反序列化
* - 实时调试和编辑
*
* @example
* ```typescript
* // 创建黑板实例
* const blackboard = new Blackboard();
*
* // 定义变量
* blackboard.defineVariable('playerHealth', BlackboardValueType.Number, 100, {
* description: '玩家生命值',
* min: 0,
* max: 100
* });
*
* // 设置和获取值
* blackboard.setValue('playerHealth', 80);
* const health = blackboard.getValue<number>('playerHealth');
*
* // 监听变量变化
* blackboard.addListener('playerHealth', (newVal, oldVal) => {
* console.log(`玩家生命值从 ${oldVal} 变为 ${newVal}`);
* });
* ```
*/
declare class Blackboard {
/** 变量定义存储 */
private _variables;
/** 变量监听器存储 */
private _listeners;
/** 监听器计数器 */
private _listenerIdCounter;
/** 变量修改历史 */
private _history;
/** 是否启用历史记录 */
enableHistory: boolean;
/**
* 定义一个黑板变量
*
* @param name 变量名
* @param type 变量类型
* @param defaultValue 默认值
* @param options 额外选项
*/
defineVariable(name: string, type: BlackboardValueType, defaultValue: any, options?: Partial<BlackboardVariable>): void;
/**
* 设置变量值
*
* @param name 变量名
* @param value 新值
* @param force 是否强制设置（忽略只读限制）
*/
setValue<T = any>(name: string, value: T, force?: boolean): boolean;
/**
* 获取变量值
*
* @param name 变量名
* @param defaultValue 变量不存在时的默认返回值
* @returns 变量值
*/
getValue<T = any>(name: string, defaultValue?: T): T;
/**
* 检查变量是否存在
*/
hasVariable(name: string): boolean;
/**
* 获取变量定义
*/
getVariableDefinition(name: string): BlackboardVariable | undefined;
/**
* 获取所有变量名称
*/
getVariableNames(): string[];
/**
* 按分组获取变量
*/
getVariablesByGroup(group: string): BlackboardVariable[];
/**
* 获取所有分组
*/
getGroups(): string[];
/**
* 重置变量到默认值
*/
resetVariable(name: string): boolean;
/**
* 重置所有变量到默认值
*/
resetAll(): void;
/**
* 删除变量
*/
removeVariable(name: string): boolean;
/**
* 添加变量监听器
*/
addListener(variableName: string, callback: (newValue: any, oldValue: any) => void): string;
/**
* 移除监听器
*/
removeListener(listenerId: string): boolean;
/**
* 序列化黑板数据
*/
serialize(): string;
/**
* 从序列化数据恢复黑板
*/
deserialize(data: string): boolean;
/**
* 获取修改历史
*/
getHistory(): Array<{
variableName: string;
oldValue: any;
newValue: any;
timestamp: number;
}>;
/**
* 清空历史记录
*/
clearHistory(): void;
/**
* 验证值类型
*/
private _validateValueType;
/**
* 检查是否为Vector2
*/
private _isVector2;
/**
* 检查是否为Vector3
*/
private _isVector3;
/**
* 深拷贝值
*/
private _cloneValue;
/**
* 通知监听器
*/
private _notifyListeners;
}
/**
* 行为树控制器
*
* @description 管理行为树的执行，支持定时更新和上下文管理
* @template T 上下文对象类型
*
* @example
* ```typescript
* // 创建游戏AI的行为树
* interface GameContext {
* player: Player;
* enemies: Enemy[];
* gameTime: number;
* }
*
* const context: GameContext = { ... };
* const rootNode = new Selector(...);
* const behaviorTree = new BehaviorTree(context, rootNode, 0.1); // 每100ms更新一次
*
* // 在游戏循环中调用
* behaviorTree.tick();
* ```
*/
declare class BehaviorTree<T> {
/**
* 行为树更新周期（秒）
*
* @description
* - 大于0：按照指定间隔更新（如0.2表示每秒更新5次）
* - 小于等于0：每帧都更新
* @default 0.2
*/
updatePeriod: number;
/** 执行上下文，包含行为树运行所需的所有数据 */
private _context;
/** 黑板实例，用于节点间的数据共享 */
private _blackboard;
/** 行为树的根节点 */
private _root;
/** 距离下次更新的剩余时间 */
private _elapsedTime;
/** 上次更新的时间戳（秒） */
private _lastTime;
/** 是否启用性能优化模式 */
private _performanceMode;
/** 性能统计信息 */
private _stats;
/**
* 创建行为树实例
*
* @param context 执行上下文对象
* @param rootNode 根节点
* @param updatePeriod 更新周期，0表示每帧更新
* @param performanceMode 是否启用性能优化模式，默认false
* @param blackboard 可选的黑板实例，如果不提供将自动创建
* @throws {Error} 当context或rootNode为null时抛出错误
*/
constructor(context: T, rootNode: Behavior<T>, updatePeriod?: number, performanceMode?: boolean, blackboard?: Blackboard);
/**
* 获取当前时间（秒）
* 优先使用全局时间管理器，回退到本地时间计算
*/
private _getCurrentTime;
/**
* 更新行为树
*
* @description
* 根据updatePeriod设置决定是否执行根节点：
* - updatePeriod > 0：按时间间隔更新
* - updatePeriod <= 0：每次调用都更新
*
* 通常在游戏主循环中每帧调用此方法
*
* @param deltaTime 可选的时间差值（秒），如果提供则使用此值而不是计算
*/
tick(deltaTime?: number): void;
/**
* 执行根节点
*/
private _executeRoot;
/**
* 更新性能统计信息
* @param executionTime 执行时间
*/
private _updateStats;
/**
* 获取当前上下文
* @returns 执行上下文对象
*/
getContext(): T;
/**
* 获取黑板实例
* @returns 黑板实例
*/
getBlackboard(): Blackboard;
/**
* 更新上下文
* @param context 新的上下文对象
* @throws {Error} 当context为null时抛出错误
*/
setContext(context: T): void;
/**
* 获取根节点
* @returns 根节点实例
*/
getRoot(): Behavior<T>;
/**
* 设置新的根节点
* @param rootNode 新的根节点
* @throws {Error} 当rootNode为null时抛出错误
*/
setRoot(rootNode: Behavior<T>): void;
/**
* 强制重置整个行为树
* @description 将根节点及其所有子节点重置为Invalid状态
*/
reset(): void;
/**
* 设置性能模式
* @param enabled 是否启用性能模式
*/
setPerformanceMode(enabled: boolean): void;
/**
* 获取性能统计信息
* @returns 性能统计对象
*/
getStats(): Readonly<typeof this._stats>;
/**
* 重置性能统计信息
*/
resetStats(): void;
/**
* 检查行为树是否处于活动状态
* @returns 是否有待处理的更新
*/
isActive(): boolean;
/**
* 获取到下次更新的剩余时间
* @returns 剩余时间（秒），如果是每帧更新模式则返回0
*/
getTimeToNextUpdate(): number;
}
declare enum AbortTypes {
/**
* 没有中止类型。即使其他条件更改了状态，当前操作也将始终运行
*/
None = 0,
/**
* 如果一个更重要的有条件的任务改变了状态，它可以发出一个中止指令，使低优先级的任务停止运行，并将控制权转回高优先级的分支。
* 这种类型应该被设置在作为讨论中的复合体的子体的复合体上。
* 父复合体将检查它的子体，看它们是否有LowerPriority中止。
*/
LowerPriority = 1,
/**
* 只有当它们都是复合体的子任务时，条件任务才能中止一个行动任务。
* 这个AbortType只影响它所设置的实际的Composite，不像LowerPriority会影响其父Composite。
*/
Self = 2,
/**
* 检查LowerPriority和Self aborts
*/
Both = 3
}
/**
* 支持的黑板变量类型联合类型
*/
type BlackboardVariableValue = string | number | boolean | object | unknown[];
/**
* 节点属性值类型
*/
type NodePropertyValue = string | number | boolean | object;
/**
* 执行上下文基础接口
*/
interface ExecutionContext {
blackboard?: Blackboard;
[key: string]: unknown;
}
/**
* 条件配置接口
*/
interface ConditionConfig {
type: string;
properties?: Record<string, NodePropertyConfig>;
}
/**
* 行为树配置接口
* @description 定义行为树的完整配置结构
*/
interface BehaviorTreeConfig {
/** 配置版本号 */
version: string;
/** 配置类型标识 */
type: string;
/** 元数据信息 */
metadata?: BehaviorTreeMetadata;
/** 根节点配置 */
tree: NodeConfig;
}
/**
* 行为树元数据接口
* @description 包含行为树的描述性信息
*/
interface BehaviorTreeMetadata {
/** 行为树名称 */
name?: string;
/** 版本信息 */
version?: string;
/** 创建时间 */
created?: string;
/** 导出类型 */
exportType?: string;
/** 更新周期（秒） */
updatePeriod?: number;
/** 描述信息 */
description?: string;
/** 作者信息 */
author?: string;
/** 扩展属性 */
[key: string]: unknown;
}
/**
* 节点配置接口
* @description 定义单个行为树节点的配置结构
*/
interface NodeConfig {
/** 节点唯一标识符 */
id: string;
/** 节点类型 */
type: string;
/** 命名空间（可选） */
namespace?: string;
/** 节点属性配置 */
properties?: Record<string, NodePropertyConfig>;
/** 子节点配置数组 */
children?: NodeConfig[];
}
/**
* 节点属性配置接口
* @description 定义节点属性的类型和值
*/
interface NodePropertyConfig {
/** 属性类型 */
type: string;
/** 属性值 */
value: NodePropertyValue;
}
/**
* 行为树JSON配置接口
* @description 用于从JSON文件加载行为树配置的标准格式
*/
interface BehaviorTreeJSONConfig {
/** 节点列表 */
nodes: BehaviorTreeNodeConfig[];
/** 黑板变量配置 */
blackboard?: BlackboardVariableConfig[];
/** 元数据信息 */
metadata?: BehaviorTreeMetadata;
}
/**
* 行为树节点配置接口
* @description JSON格式中的节点配置结构
*/
interface BehaviorTreeNodeConfig {
/** 节点唯一标识符 */
id: string;
/** 节点类型 */
type: string;
/** 节点显示名称 */
name: string;
/** 节点属性 */
properties?: Record<string, NodePropertyValue>;
/** 子节点ID列表 */
children?: string[];
/** 条件配置（用于条件装饰器等） */
condition?: ConditionConfig;
}
/**
* 黑板变量配置接口
* @description 定义黑板变量的完整配置信息
*/
interface BlackboardVariableConfig {
/** 变量名称 */
name: string;
/** 变量类型 */
type: string;
/** 变量初始值 */
value: BlackboardVariableValue;
/** 变量描述 */
description?: string;
/** 变量分组 */
group?: string;
/** 变量约束条件 */
constraints?: {
/** 最小值（数值类型） */
min?: number;
/** 最大值（数值类型） */
max?: number;
/** 只读标志 */
readonly?: boolean;
/** 可选值列表（枚举类型） */
options?: BlackboardVariableValue[];
};
}
/**
* 行为树构建结果接口
* @description fromBehaviorTreeConfig方法的返回结果
*/
interface BehaviorTreeBuildResult<T> {
/** 构建好的行为树实例 */
tree: BehaviorTree<T>;
/** 初始化的黑板实例 */
blackboard: Blackboard;
/** 增强的执行上下文 */
context: T;
}
/**
* 行为树构建器类
* @description 提供构建行为树的流畅API和配置加载功能
* @template T 执行上下文类型
*
* @example
* ```typescript
* // 使用流畅API构建
* const tree = BehaviorTreeBuilder.begin(context)
* .selector()
* .sequence()
* .logAction("开始执行")
* .waitAction(1.0)
* .endComposite()
* .logAction("备选方案")
* .endComposite()
* .build();
*
* // 从JSON配置构建
* const result = BehaviorTreeBuilder.fromBehaviorTreeConfig(jsonConfig, context);
* ```
*/
declare class BehaviorTreeBuilder<T> {
/** 执行上下文 */
private _context;
/** 当前创建的节点 */
private _currentNode;
/** 父节点堆栈，用于流畅API构建 */
private _parentNodeStack;
/**
* 构造函数
* @param context 执行上下文
*/
constructor(context: T);
/**
* 开始构建行为树
* @param context 执行上下文
* @returns 新的构建器实例
*/
static begin<T>(context: T): BehaviorTreeBuilder<T>;
/**
* 设置子节点到父节点
* @param child 子节点
* @returns 构建器实例
*/
private setChildOnParent;
/**
* 将节点推入父节点堆栈
* @param composite 复合节点或装饰器节点
* @returns 构建器实例
*/
private pushParentNode;
/**
* 结束装饰器节点
* @returns 构建器实例
*/
private endDecorator;
/**
* 添加动作节点
* @param func 动作执行函数
* @returns 构建器实例
*/
action(func: (t: T) => TaskStatus): BehaviorTreeBuilder<T>;
/**
* 添加返回布尔值的动作节点
* @param func 返回布尔值的函数
* @returns 构建器实例
*/
actionR(func: (t: T) => boolean): BehaviorTreeBuilder<T>;
/**
* 添加条件节点
* @param func 条件检查函数
* @returns 构建器实例
*/
conditional(func: (t: T) => TaskStatus): BehaviorTreeBuilder<T>;
/**
* 添加返回布尔值的条件节点
* @param func 返回布尔值的条件函数
* @returns 构建器实例
*/
conditionalR(func: (t: T) => boolean): BehaviorTreeBuilder<T>;
/**
* 添加日志动作节点
* @param text 日志文本
* @returns 构建器实例
*/
logAction(text: string): BehaviorTreeBuilder<T>;
/**
* 添加等待动作节点
* @param waitTime 等待时间（秒）
* @returns 构建器实例
*/
waitAction(waitTime: number): BehaviorTreeBuilder<T>;
/**
* 添加子行为树节点
* @param subTree 子行为树实例
* @returns 构建器实例
*/
subTree(subTree: BehaviorTree<T>): BehaviorTreeBuilder<T>;
/**
* 添加条件装饰器
* @param func 条件函数
* @param shouldReevaluate 是否重新评估
* @returns 构建器实例
*/
conditionalDecorator(func: (t: T) => TaskStatus, shouldReevaluate?: boolean): BehaviorTreeBuilder<T>;
/**
* 添加返回布尔值的条件装饰器
* @param func 返回布尔值的条件函数
* @param shouldReevaluate 是否重新评估
* @returns 构建器实例
*/
conditionalDecoratorR(func: (t: T) => boolean, shouldReevaluate?: boolean): BehaviorTreeBuilder<T>;
/**
* 添加总是失败装饰器
* @returns 构建器实例
*/
alwaysFail(): BehaviorTreeBuilder<T>;
/**
* 添加总是成功装饰器
* @returns 构建器实例
*/
alwaysSucceed(): BehaviorTreeBuilder<T>;
/**
* 添加反转装饰器
* @returns 构建器实例
*/
inverter(): BehaviorTreeBuilder<T>;
/**
* 添加重复装饰器
* @param count 重复次数
* @returns 构建器实例
*/
repeater(count: number): BehaviorTreeBuilder<T>;
/**
* 添加直到失败装饰器
* @returns 构建器实例
*/
untilFail(): BehaviorTreeBuilder<T>;
/**
* 添加直到成功装饰器
* @returns 构建器实例
*/
untilSuccess(): BehaviorTreeBuilder<T>;
/**
* 添加并行节点
* @returns 构建器实例
*/
paraller(): BehaviorTreeBuilder<T>;
/**
* 添加并行选择器节点
* @returns 构建器实例
*/
parallelSelector(): BehaviorTreeBuilder<T>;
/**
* 添加选择器节点
* @param abortType 中止类型
* @returns 构建器实例
*/
selector(abortType?: AbortTypes): BehaviorTreeBuilder<T>;
/**
* 添加随机选择器节点
* @returns 构建器实例
*/
randomSelector(): BehaviorTreeBuilder<T>;
/**
* 添加序列节点
* @param abortType 中止类型
* @returns 构建器实例
*/
sequence(abortType?: AbortTypes): BehaviorTreeBuilder<T>;
/**
* 添加随机序列节点
* @returns 构建器实例
*/
randomSequence(): BehaviorTreeBuilder<T>;
/**
* 结束复合节点
* @returns 构建器实例
*/
endComposite(): BehaviorTreeBuilder<T>;
/**
* 构建最终的行为树
* @param updatePeriod 更新周期（秒），默认0.2秒
* @returns 构建好的行为树实例
*/
build(updatePeriod?: number): BehaviorTree<T>;
/**
* 从配置对象创建行为树
* @param config 行为树配置
* @param context 执行上下文
* @returns 构建好的行为树
*/
static fromConfig<T>(config: BehaviorTreeConfig, context: T): BehaviorTree<T>;
/**
* 从JSON配置创建行为树
* @description 自动初始化黑板变量和构建节点树，提供一键式行为树创建
* @param config JSON格式的行为树配置
* @param context 执行上下文（可选，如果不提供将创建默认上下文）
* @returns 包含行为树、黑板和增强上下文的结果对象
*
* @example
* ```typescript
* const config = {
* nodes: [...],
* blackboard: [...],
* metadata: { name: "MyBehaviorTree" }
* };
* const result = BehaviorTreeBuilder.fromBehaviorTreeConfig(config, context);
* const { tree, blackboard, context: enhancedContext } = result;
* ```
*/
static fromBehaviorTreeConfig<T extends ExecutionContext = ExecutionContext>(config: BehaviorTreeJSONConfig, context?: T): BehaviorTreeBuildResult<T>;
/**
* 映射字符串类型到BlackboardValueType枚举
* @param typeString 类型字符串
* @returns 对应的黑板值类型枚举
*/
private static mapToBlackboardType;
/**
* 转换黑板变量值到正确的类型
* @param value 原始值（通常来自JSON，都是字符串）
* @param targetType 目标类型
* @returns 转换后的值
*/
private static convertBlackboardValue;
/**
* 从节点配置创建节点实例
* @param nodeConfig 节点配置
* @returns 创建的节点实例
*/
private static createNodeFromConfig;
/**
* 解析中止类型字符串为枚举值
* @param value 中止类型字符串
* @returns 对应的中止类型枚举值
*/
private static getAbortType;
/**
* 从JSON节点配置创建节点实例
* @description 递归创建节点树，支持所有标准行为树节点类型
* @param nodeConfig 当前节点配置
* @param nodeMap 节点ID到配置的映射表
* @param context 执行上下文
* @returns 创建的节点实例
*/
private static createNodeFromJSONConfig;
/**
* 创建条件函数
* @param condition 条件配置
* @param context 执行上下文
* @returns 条件检查函数
*/
private static createConditionFunction;
/**
* 替换对象中的黑板变量引用
* @param obj 要处理的对象
* @param blackboard 黑板实例
* @returns 替换后的对象
*/
private static replaceBlackboardVariables;
/**
* 提取嵌套属性值
* @param prop 属性配置对象或直接值
* @returns 提取的值
*/
private static extractNestedValue;
}
/**
* 通用对象池，用于减少对象创建和销毁的开销
*
* @template T 池中对象的类型
*
* @example
* ```typescript
* // 创建一个ExecuteAction的对象池
* const actionPool = new ObjectPool(
* () => new ExecuteAction(() => TaskStatus.Success),
* (action) => action.invalidate(),
* 50 // 最大池大小
* );
*
* // 获取对象
* const action = actionPool.get();
*
* // 使用完毕后归还
* actionPool.release(action);
* ```
*/
declare class ObjectPool<T> {
private _pool;
private _createFn;
private _resetFn?;
private _maxSize;
/**
* 创建对象池
* @param createFn 创建新对象的函数
* @param resetFn 重置对象状态的函数（可选）
* @param maxSize 池的最大大小，必须大于0，默认100
* @throws {Error} 当maxSize小于等于0时抛出错误
*/
constructor(createFn: () => T, resetFn?: (obj: T) => void, maxSize?: number);
/**
* 从池中获取一个对象
* 如果池为空，则创建新对象
* @returns 池中的对象或新创建的对象
*/
get(): T;
/**
* 将对象归还到池中
* @param obj 要归还的对象
* @throws {Error} 当obj为null或undefined时抛出错误
*/
release(obj: T): void;
/**
* 预填充池
* @param count 要预创建的对象数量，必须大于等于0
* @throws {Error} 当count小于0时抛出错误
*/
prewarm(count: number): void;
/**
* 清空池
*/
clear(): void;
/**
* 获取池的当前大小
*/
get size(): number;
/**
* 获取池的最大大小
*/
get maxSize(): number;
/**
* 设置池的最大大小
* @param value 新的最大大小，必须大于0
* @throws {Error} 当value小于等于0时抛出错误
*/
set maxSize(value: number);
/**
* 获取池的使用率（0-1之间）
* @returns 当前大小与最大大小的比率
*/
get utilization(): number;
/**
* 检查池是否为空
*/
get isEmpty(): boolean;
/**
* 检查池是否已满
*/
get isFull(): boolean;
}
/**
* 行为树节点池管理器
* 为常用的行为树节点类型提供专门的对象池
*
* @example
* ```typescript
* const poolManager = BehaviorNodePoolManager.getInstance();
*
* // 注册节点池
* poolManager.registerPool('ExecuteAction',
* () => new ExecuteAction(() => TaskStatus.Success),
* (action) => action.invalidate()
* );
*
* // 获取和归还对象
* const action = poolManager.get<ExecuteAction>('ExecuteAction');
* poolManager.release('ExecuteAction', action);
* ```
*/
declare class BehaviorNodePoolManager {
private static _instance;
private _pools;
private constructor();
/**
* 获取单例实例
*/
static getInstance(): BehaviorNodePoolManager;
/**
* 注册一个节点类型的对象池
* @param typeName 节点类型名称，不能为空字符串
* @param createFn 创建函数
* @param resetFn 重置函数
* @param maxSize 最大池大小，默认50
* @throws {Error} 当typeName为空或已存在时抛出错误
*/
registerPool<T>(typeName: string, createFn: () => T, resetFn?: (obj: T) => void, maxSize?: number): void;
/**
* 从指定类型的池中获取对象
* @param typeName 节点类型名称
* @returns 池中的对象，如果池不存在则返回null
*/
get<T>(typeName: string): T | null;
/**
* 将对象归还到对应的池中
* @param typeName 节点类型名称
* @param obj 要归还的对象
* @returns 是否成功归还
*/
release<T>(typeName: string, obj: T): boolean;
/**
* 预热所有池
* @param count 每个池预创建的对象数量，默认10
*/
prewarmAll(count?: number): void;
/**
* 清空所有池
*/
clearAll(): void;
/**
* 移除指定类型的池
* @param typeName 节点类型名称
* @returns 是否成功移除
*/
removePool(typeName: string): boolean;
/**
* 获取池的统计信息
* @returns 包含所有池统计信息的对象
*/
getStats(): {
[typeName: string]: {
size: number;
maxSize: number;
utilization: number;
};
};
/**
* 获取已注册的池类型列表
*/
getRegisteredTypes(): string[];
}
/**
* 高性能分层对象池系统
*
* @description
* 提供比原始ObjectPool更高性能的对象池实现：
* - 使用WeakSet跟踪池中对象，避免includes()开销
* - 实现分层池，根据使用频率分配不同大小的池
* - 支持全局内存限制和自动清理
* - 提供详细的性能统计
*
* @template T 池中对象的类型
*/
/**
* 对象池配置选项
*/
interface PoolConfig {
/** 初始池大小 */
initialSize?: number;
/** 最大池大小 */
maxSize?: number;
/** 池的优先级（影响内存清理顺序） */
priority?: PoolPriority;
/** 是否启用统计信息收集 */
enableStats?: boolean;
/** 对象验证函数 */
validator?: (obj: any) => boolean;
}
/**
* 池优先级枚举
*/
declare enum PoolPriority {
/** 低优先级 - 优先清理 */
Low = 0,
/** 普通优先级 */
Normal = 1,
/** 高优先级 - 最后清理 */
High = 2,
/** 关键优先级 - 不会被自动清理 */
Critical = 3
}
/**
* 池统计信息
*/
interface PoolStats {
/** 当前池大小 */
currentSize: number;
/** 最大池大小 */
maxSize: number;
/** 总获取次数 */
totalGets: number;
/** 总归还次数 */
totalReleases: number;
/** 总创建次数 */
totalCreations: number;
/** 命中率（从池中获取的比例） */
hitRate: number;
/** 使用率 */
utilization: number;
/** 优先级 */
priority: PoolPriority;
}
/**
* 高性能对象池
*/
declare class AdvancedObjectPool<T extends object> {
private readonly _pool;
private readonly _poolSet;
private readonly _createFn;
private readonly _resetFn?;
private readonly _validator?;
private readonly _config;
private _stats;
private _lastCleanupTime;
private readonly _cleanupInterval;
/**
* 创建高性能对象池
* @param createFn 创建新对象的函数
* @param resetFn 重置对象状态的函数（可选）
* @param config 池配置选项
*/
constructor(createFn: () => T, resetFn?: (obj: T) => void, config?: PoolConfig);
/**
* 从池中获取一个对象
* @returns 池中的对象或新创建的对象
*/
get(): T;
/**
* 将对象归还到池中
* @param obj 要归还的对象
* @returns 是否成功归还
*/
release(obj: T): boolean;
/**
* 创建新对象
*/
private _createObject;
/**
* 更新统计信息
*/
private _updateStats;
/**
* 预填充池
* @param count 要预创建的对象数量
*/
prewarm(count: number): void;
/**
* 清空池
* @param force 是否强制清空（忽略优先级）
*/
clear(force?: boolean): void;
/**
* 收缩池到指定大小
* @param targetSize 目标大小
*/
shrink(targetSize: number): void;
/**
* 执行定期清理
*/
performMaintenance(): void;
/**
* 获取池的当前大小
*/
get size(): number;
/**
* 获取池的最大大小
*/
get maxSize(): number;
/**
* 获取池的优先级
*/
get priority(): PoolPriority;
/**
* 设置池的最大大小
*/
set maxSize(value: number);
/**
* 获取池的统计信息
*/
getStats(): Readonly<PoolStats>;
/**
* 重置统计信息
*/
resetStats(): void;
/**
* 检查池是否为空
*/
get isEmpty(): boolean;
/**
* 检查池是否已满
*/
get isFull(): boolean;
}
/**
* 全局高级池管理器
*/
declare class AdvancedPoolManager {
private static _pools;
private static _maintenanceInterval;
private static _lastMaintenanceTime;
/**
* 注册池到全局管理器
*/
static registerPool<T extends object>(pool: AdvancedObjectPool<T>): void;
/**
* 从全局管理器注销池
*/
static unregisterPool<T extends object>(pool: AdvancedObjectPool<T>): void;
/**
* 执行全局内存清理
*/
static performGlobalCleanup(): void;
/**
* 执行全局维护
*/
static performGlobalMaintenance(): void;
/**
* 获取全局统计信息
*/
static getGlobalStats(): {
totalPools: number;
totalObjects: number;
totalMemoryUsage: number;
poolsByPriority: Record<PoolPriority, number>;
};
/**
* 清理所有池
*/
static clearAllPools(force?: boolean): void;
}
/**
* 事件处理器接口
* @template TContext 执行上下文类型，通常包含 node、component、blackboard 等
* @template TParams 参数类型，可以是具体的参数对象类型
*/
interface IEventHandler<TContext = IBehaviorTreeContext, TParams = Record<string, any>> {
(context: TContext, parameters?: TParams): ActionResult;
}
/**
* 条件检查器接口
* @template TContext 执行上下文类型
* @template TParams 参数类型
*/
interface IConditionChecker<TContext = IBehaviorTreeContext, TParams = Record<string, any>> {
(context: TContext, parameters?: TParams): boolean;
}
/**
* 行为树执行上下文的基础接口
* 这是一个通用的基础接口
* 用户可以扩展这个接口来定义自己的上下文类型
*/
interface IBehaviorTreeContext {
/** 黑板实例 */
blackboard?: any;
/** 事件注册表 */
eventRegistry?: EventRegistry;
/** 其他自定义属性 - 用户可以添加任何引擎特定的属性 */
[key: string]: any;
}
/**
* 行为树动作结果类型
* 支持TaskStatus枚举、字符串字面量、boolean和Promise
*/
type ActionResult = TaskStatus | 'success' | 'failure' | 'running' | boolean | Promise<ActionResult>;
/**
* 事件注册表类
* 管理行为树中的动作和条件事件处理器
* 支持精确匹配和正则表达式匹配
*
* @example
* ```typescript
* // 定义自定义上下文类型
* interface GameContext extends IBehaviorTreeContext {
* player: Player;
* enemies: Enemy[];
* }
*
* // 定义参数类型
* interface MoveParams {
* targetX: number;
* targetY: number;
* speed?: number;
* }
*
* const registry = new EventRegistry();
*
* // 注册精确匹配的动作处理器
* registry.registerAction<GameContext, MoveParams>(
* 'move-to',
* (context, params) => {
* context.player.moveTo(params.targetX, params.targetY, params.speed || 1);
* return 'success';
* }
* );
*
* // 注册正则表达式动作处理器 - 匹配所有以 "enemy." 开头的事件
* registry.registerActionRegex<GameContext>(
* /^enemy\..+$/,
* (context, params) => {
* // 处理所有敌人相关的动作：enemy.attack, enemy.move, enemy.die 等
* console.log('处理敌人动作:', params);
* return 'success';
* }
* );
*
* // 注册正则表达式条件检查器 - 匹配所有以 "player." 开头的条件
* registry.registerConditionRegex<GameContext>(
* /^player\..+$/,
* (context, params) => {
* // 处理所有玩家相关的条件：player.alive, player.hasItem, player.canMove 等
* return context.player.health > 0;
* }
* );
*
* // 异步动作示例
* registry.registerAction<GameContext>(
* 'async-action',
* async (context) => {
* await context.player.performComplexAction();
* return 'success';
* }
* );
* ```
*/
declare class EventRegistry {
private actionHandlers;
private conditionHandlers;
private regexActionHandlers;
private regexConditionHandlers;
/**
* 注册动作处理器
* @template TContext 上下文类型
* @template TParams 参数类型
* @param eventName 事件名称
* @param handler 处理器函数，必须返回 ActionResult 类型
*/
registerAction<TContext = IBehaviorTreeContext, TParams = Record<string, any>>(eventName: string, handler: IEventHandler<TContext, TParams>): void;
/**
* 注册正则表达式动作处理器
* @template TContext 上下文类型
* @template TParams 参数类型
* @param eventPattern 事件名称正则表达式
* @param handler 处理器函数，必须返回 ActionResult 类型
*/
registerActionRegex<TContext = IBehaviorTreeContext, TParams = Record<string, any>>(eventPattern: RegExp, handler: IEventHandler<TContext, TParams>): void;
/**
* 注册条件检查器
* @template TContext 上下文类型
* @template TParams 参数类型
* @param eventName 事件名称
* @param checker 检查器函数，必须返回 boolean 类型
*/
registerCondition<TContext = IBehaviorTreeContext, TParams = Record<string, any>>(eventName: string, checker: IConditionChecker<TContext, TParams>): void;
/**
* 注册正则表达式条件检查器
* @template TContext 上下文类型
* @template TParams 参数类型
* @param eventPattern 事件名称正则表达式
* @param checker 检查器函数，必须返回 boolean 类型
*/
registerConditionRegex<TContext = IBehaviorTreeContext, TParams = Record<string, any>>(eventPattern: RegExp, checker: IConditionChecker<TContext, TParams>): void;
/**
* 获取动作处理器
* @param eventName 事件名称
* @returns 处理器函数或undefined
*/
getActionHandler(eventName: string): IEventHandler | undefined;
/**
* 获取条件检查器
* @param eventName 事件名称
* @returns 检查器函数或undefined
*/
getConditionHandler(eventName: string): IConditionChecker | undefined;
getAllEventNames(): string[];
/**
* 获取所有正则表达式模式
* @returns 包含所有注册的正则表达式模式的数组
*/
getAllRegexPatterns(): RegExp[];
/**
* 测试事件名是否匹配任何已注册的处理器（包括正则表达式）
* @param eventName 事件名称
* @returns 是否有匹配的处理器
*/
hasHandler(eventName: string): boolean;
clear(): void;
}
declare class GlobalEventRegistry {
private static instance;
static getInstance(): EventRegistry;
}
/**
* 事件系统模块
*
* 提供完整的事件驱动行为树支持，包括：
* - EventRegistry: 事件注册表
* - 事件处理器接口
* - 全局事件管理
*/
type ActionHandler = (context: any, parameters?: any) => any;
type ConditionChecker = (context: any, parameters?: any) => boolean;
/**
* 执行函数动作包装器
*
* @description
* 包装一个函数以便可以作为行为树节点使用，避免为简单逻辑创建子类。
* 适合快速原型开发和简单的行为逻辑。
*
* @template T 上下文类型
*
* @example
* ```typescript
* // 创建简单的执行动作
* const moveAction = new ExecuteAction<GameContext>((context) => {
* context.player.move();
* return TaskStatus.Success;
* });
*
* // 带条件的执行动作
* const attackAction = new ExecuteAction<GameContext>((context) => {
* if (context.enemy.isInRange()) {
* context.player.attack();
* return TaskStatus.Success;
* }
* return TaskStatus.Failure;
* });
* ```
*/
declare class ExecuteAction<T> extends Behavior<T> {
/**
* 执行函数
* @type {(context: T) => TaskStatus}
*/
private readonly _action;
/** 是否启用错误处理（默认true） */
private readonly _enableErrorHandling;
/** 动作名称（用于调试和错误日志） */
private readonly _name?;
/**
* 创建执行动作
* @param action 要执行的函数，不能为null
* @param options 配置选项
* @throws {Error} 当action为null或undefined时抛出错误
*/
constructor(action: (context: T) => TaskStatus, options?: {
/** 是否启用错误处理，默认true */
enableErrorHandling?: boolean;
/** 动作名称，用于调试 */
name?: string;
});
/**
* 执行包装的函数
* @param context 执行上下文
* @returns 执行结果状态
*/
update(context: T): TaskStatus;
/**
* 验证TaskStatus是否有效
* @param status 要验证的状态
* @returns 是否为有效状态
*/
private isValidTaskStatus;
/**
* 获取动作名称
* @returns 动作名称或函数名
*/
getName(): string;
/**
* 创建一个始终成功的执行动作
* @param action 要执行的无返回值函数
* @param name 动作名称
* @returns 新的ExecuteAction实例
*/
static createAlwaysSuccess<T>(action: (context: T) => void, name?: string): ExecuteAction<T>;
/**
* 创建一个条件执行动作
* @param predicate 条件函数
* @param name 动作名称
* @returns 新的ExecuteAction实例
*/
static createConditional<T>(predicate: (context: T) => boolean, name?: string): ExecuteAction<T>;
}
/**
* 简单的任务，它将输出指定的文本并返回成功。 它可以用于调试。
*/
declare class LogAction<T> extends Behavior<T> {
/** 文本 */
text: string;
/** 是否输出error还是log */
isError: boolean;
constructor(text: string);
update(_context: T): TaskStatus;
}
/**
* 时间上下文接口
* 定义包含时间信息的上下文对象结构
*/
interface ITimeContext {
/** 帧间时间差（秒） */
deltaTime: number;
}
/**
* 等待指定时间的行为节点
*
* @description
* 在指定时间内返回Running状态，时间到达后返回Success状态。
* 支持外部时间管理以提高性能。
*
* @template T 上下文类型
*
* @example
* ```typescript
* // 基本用法
* const waitAction = new WaitAction<any>(2.0); // 等待2秒
*
* // 使用外部时间管理
* interface GameContext extends ITimeContext {
* player: Player;
* deltaTime: number;
* }
* const waitAction = new WaitAction<GameContext>(1.5, true);
* ```
*/
declare class WaitAction<T> extends Behavior<T> {
/** 等待的时间（秒） */
waitTime: number;
/** 已等待的时间（秒） */
private _elapsedTime;
/** 是否使用外部时间管理 */
private _useExternalTime;
/** 上次更新的时间戳（用于内部时间计算） */
private _lastUpdateTime;
/**
* 创建等待动作
* @param waitTime 等待时间（秒），必须大于0
* @param useExternalTime 是否使用外部时间管理，默认false
* @throws {Error} 当waitTime小于等于0时抛出错误
*/
constructor(waitTime: number, useExternalTime?: boolean);
onStart(): void;
/**
* 更新等待状态
* @param context 上下文对象，如果包含deltaTime属性则使用外部时间
* @returns 当前执行状态
*/
update(context: T): TaskStatus;
/**
* 计算内部时间差
* @returns 时间差（秒）
*/
private _calculateInternalDeltaTime;
/**
* 获取等待进度（0-1）
* @returns 当前进度百分比
*/
getProgress(): number;
/**
* 获取剩余等待时间
* @returns 剩余时间（秒）
*/
getRemainingTime(): number;
/**
* 设置新的等待时间
* @param newWaitTime 新的等待时间（秒）
* @param resetProgress 是否重置当前进度，默认false
* @throws {Error} 当newWaitTime小于等于0时抛出错误
*/
setWaitTime(newWaitTime: number, resetProgress?: boolean): void;
/**
* 检查是否已完成等待
* @returns 是否已完成
*/
isCompleted(): boolean;
}
/**
* 作为子项运行整个BehaviorTree并返回成功
*/
declare class BehaviorTreeReference<T> extends Behavior<T> {
private _childTree;
constructor(tree: BehaviorTree<T>);
update(_context: T): TaskStatus;
}
/**
* 设置黑板变量值
*
* @description 将指定值或另一个黑板变量的值设置到目标变量
*
* @example
* ```typescript
* // 设置固定值
* const setHealth = new SetBlackboardValue<GameContext>('playerHealth', 100);
*
* // 从另一个变量复制值
* const copyValue = new SetBlackboardValue<GameContext>('targetHealth', null, 'playerHealth');
* ```
*/
declare class SetBlackboardValue<T> extends Behavior<T> {
/** 目标变量名 */
variableName: string;
/** 要设置的值（与sourceVariable二选一） */
value: any;
/** 源变量名（与value二选一） */
sourceVariable?: string;
/** 是否强制设置（忽略只读限制） */
force: boolean;
constructor(variableName: string, value?: any, sourceVariable?: string, force?: boolean);
update(context: T & {
blackboard?: Blackboard;
}): TaskStatus;
/**
* 将值转换为目标类型
*/
private convertValueToTargetType;
}
/**
* 增加数值型黑板变量
*
* @description 将数值型变量增加指定的数值，支持从另一个变量获取增量
*/
declare class AddToBlackboardValue<T> extends Behavior<T> {
/** 目标变量名 */
variableName: string;
/** 增量值（与incrementVariable二选一） */
increment: number;
/** 增量来源变量名（与increment二选一） */
incrementVariable?: string;
constructor(variableName: string, increment: number, incrementVariable?: string);
update(context: T & {
blackboard?: Blackboard;
}): TaskStatus;
}
/**
* 切换布尔型黑板变量
*
* @description 将布尔型变量的值取反
*/
declare class ToggleBlackboardBool<T> extends Behavior<T> {
/** 目标变量名 */
variableName: string;
constructor(variableName: string);
update(context: T & {
blackboard?: Blackboard;
}): TaskStatus;
}
/**
* 重置黑板变量到默认值
*
* @description 将指定变量重置为其定义时的默认值
*/
declare class ResetBlackboardVariable<T> extends Behavior<T> {
/** 目标变量名 */
variableName: string;
constructor(variableName: string);
update(context: T & {
blackboard?: Blackboard;
}): TaskStatus;
}
/**
* 等待黑板变量满足条件
*
* @description 等待指定的黑板变量满足某个条件，常用于同步操作
*/
declare class WaitForBlackboardCondition<T> extends Behavior<T> {
/** 要监听的变量名 */
variableName: string;
/** 期望的值 */
expectedValue: any;
/** 比较函数（可选，默认使用严格相等比较） */
compareFn?: (currentValue: any, expectedValue: any) => boolean;
constructor(variableName: string, expectedValue: any, compareFn?: (currentValue: any, expectedValue: any) => boolean);
update(context: T & {
blackboard?: Blackboard;
}): TaskStatus;
}
/**
* 记录黑板变量到控制台
*
* @description 将黑板变量的当前值记录到控制台，用于调试
*/
declare class LogBlackboardValue<T> extends Behavior<T> {
/** 要记录的变量名 */
variableName: string;
/** 日志前缀 */
prefix: string;
constructor(variableName: string, prefix?: string);
update(context: T & {
blackboard?: Blackboard;
}): TaskStatus;
}
/**
* 数学运算黑板变量
*
* @description 对数值型黑板变量执行数学运算
*/
declare enum MathOperation {
Add = "add",
Subtract = "subtract",
Multiply = "multiply",
Divide = "divide",
Modulo = "modulo",
Power = "power",
Min = "min",
Max = "max"
}
declare class MathBlackboardOperation<T> extends Behavior<T> {
/** 目标变量名 */
targetVariable: string;
/** 第一个操作数变量名 */
operand1Variable: string;
/** 第二个操作数（可以是值或变量名） */
operand2: number | string;
/** 数学操作类型 */
operation: MathOperation;
constructor(targetVariable: string, operand1Variable: string, operand2: number | string, operation: MathOperation);
update(context: T & {
blackboard?: Blackboard;
}): TaskStatus;
}
/**
* 复合节点基类
*
* 所有复合节点（如Sequence、Selector等）都必须继承此类。
* 提供子节点管理和中止类型处理的基础功能。
*
* @template T 上下文类型
* @abstract
*/
declare abstract class Composite<T> extends Behavior<T> {
/** 中止类型，决定节点在何种情况下会被中止*/
abortType: AbortTypes;
/** 子节点数组*/
protected _children: Array<Behavior<T>>;
/** 是否存在低优先级条件中止 */
protected _hasLowerPriorityConditionalAbort: boolean;
/** 当前执行的子节点索引 */
protected _currentChildIndex: number;
/**
* 使节点及其所有子节点无效
*
* 重写父类方法，递归使所有子节点无效
*/
invalidate(): void;
/**
* 节点开始执行时的初始化
*
* 检查是否存在低优先级条件中止，并重置当前子节点索引
*/
onStart(): void;
/**
* 节点执行结束时的清理
*
* 使所有子节点无效，为下一次执行做准备
*/
onEnd(): void;
/**
* 检查子节点中是否存在低优先级条件中止
*
* 遍历所有子节点，查找设置了LowerPriority中止类型的节点
*
* @returns 如果存在低优先级条件中止则返回true，否则返回false
* @private
*/
private hasLowerPriorityConditionalAbortInChildren;
/**
* 添加子节点
*
* @param child 要添加的子节点
*/
addChild(child: Behavior<T>): void;
/**
* 检查第一个子节点是否为条件节点
*
* 用于处理条件性中止逻辑
*
* @returns 如果第一个子节点是条件节点则返回true，否则返回false
*/
isFirstChildConditional(): boolean;
/**
* 更新自中止条件节点
*
* 检查当前索引之前的条件节点状态变化，支持自中止功能。
* 当条件节点状态不符合预期时，会重置当前索引并使后续子节点无效。
*
* @param context 执行上下文
* @param statusCheck 期望的状态值
* @protected
*/
protected updateSelfAbortConditional(context: T, statusCheck: TaskStatus): void;
/**
* 更新低优先级中止条件节点
*
* 检查具有低优先级中止类型的组合节点，当其条件节点状态发生变化时
* 执行中止操作。
*
* @param context 执行上下文
* @param statusCheck 期望的状态值
* @protected
*/
protected updateLowerPriorityAbortConditional(context: T, statusCheck: TaskStatus): void;
/**
* 更新条件节点状态
*
* 辅助方法，用于获取条件节点或条件装饰器的任务状态
*
* @param context 执行上下文
* @param node 要更新的节点
* @returns 节点的执行状态
* @private
*/
private updateConditionalNode;
}
/**
* 并行组合器
*
* @description
* 同时执行所有子节点，直到满足终止条件：
* - 任何子节点失败时返回失败
* - 所有子节点成功时返回成功
* - 其他情况返回运行中
*
* @template T 上下文类型
*/
declare class Parallel<T> extends Composite<T> {
/** 缓存的子节点数量，避免重复访问length属性*/
private _childCount;
onStart(): void;
update(context: T): TaskStatus;
/**
* 添加子节点时更新缓存
*/
addChild(child: Behavior<T>): void;
}
/**
* 并行选择器
*
* @description
* 同时执行所有子节点，直到满足终止条件：
* - 任何子节点成功时返回成功
* - 所有子节点失败时返回失败
* - 其他情况返回运行中
*
* @template T 上下文类型
*/
declare class ParallelSelector<T> extends Composite<T> {
/** 缓存的子节点数量，避免重复访问length属性*/
private _childCount;
onStart(): void;
update(context: T): TaskStatus;
/**
* 添加子节点时更新缓存
*/
addChild(child: Behavior<T>): void;
}
/**
* 选择器组合器
*
* @description
* 类似于逻辑"或"操作，按顺序执行子节点直到找到成功的节点：
* - 任何子节点成功时返回成功
* - 所有子节点失败时返回失败
* - 子节点运行中时返回运行中
*
* @template T 上下文类型
*/
declare class Selector<T> extends Composite<T> {
/** 缓存的子节点数量，避免重复访问length属性*/
private _childCount;
constructor(abortType?: AbortTypes);
onStart(): void;
update(context: T): TaskStatus;
/**
* 重写invalidate方法，确保在节点无效化时重置索引
*/
invalidate(): void;
/**
* 添加子节点时更新缓存
*/
addChild(child: Behavior<T>): void;
/**
* 处理条件性中止
*/
private handleConditionalAborts;
}
/**
* 随机选择器节点
*
* @description
* 与Selector相同的执行逻辑，但在开始时会随机打乱子节点的执行顺序。
* 适用于需要随机化选择优先级的场景，增加AI决策的多样性。
*
* @template T 上下文类型
*
* @example
* ```typescript
* // 创建一个随机选择攻击方式的选择器
* const randomAttack = new RandomSelector<GameContext>();
* randomAttack.addChild(new MeleeAttack());
* randomAttack.addChild(new RangedAttack());
* randomAttack.addChild(new SpecialAttack());
* // 每次执行时，攻击方式的优先级都会被随机打乱
* ```
*/
declare class RandomSelector<T> extends Selector<T> {
/** 是否在每次重新开始时都重新洗牌*/
private _reshuffleOnRestart;
/** 原始子节点顺序的备份 */
private _originalOrder;
/**
* 创建随机选择器节点
* @param abortType 中止类型，默认为None
* @param reshuffleOnRestart 是否在每次重新开始时都重新洗牌，默认true
*/
constructor(abortType?: AbortTypes, reshuffleOnRestart?: boolean);
/**
* 节点开始时的处理
* 随机打乱子节点顺序
*/
onStart(): void;
/**
* 重置节点状态
* 如果启用了reshuffleOnRestart，会在下次开始时重新洗牌
*/
invalidate(): void;
/**
* 设置是否在重新开始时重新洗牌
* @param enabled 是否启用
*/
setReshuffleOnRestart(enabled: boolean): void;
/**
* 获取是否在重新开始时重新洗牌
* @returns 当前设置
*/
getReshuffleOnRestart(): boolean;
/**
* 恢复原始子节点顺序
* @description 将子节点顺序恢复到添加时的原始顺序
*/
restoreOriginalOrder(): void;
/**
* 手动重新洗牌子节点
* @description 立即重新洗牌子节点顺序，不等待下次开始
*/
reshuffleNow(): void;
}
/**
* 序列组合器
*
* @description
* 类似于逻辑"与"操作，按顺序执行子节点直到所有节点成功：
* - 任何子节点失败时返回失败
* - 所有子节点成功时返回成功
* - 子节点运行中时返回运行中
*
* @template T 上下文类型
*/
declare class Sequence<T> extends Composite<T> {
/** 缓存的子节点数量，避免重复访问length属性*/
private _childCount;
constructor(abortType?: AbortTypes);
onStart(): void;
update(context: T): TaskStatus;
/**
* 重写invalidate方法，确保在节点无效化时重置索引
*/
invalidate(): void;
/**
* 添加子节点时更新缓存
*/
addChild(child: Behavior<T>): void;
/**
* 处理条件性中止
*/
private handleConditionalAborts;
}
/**
* 随机序列节点
*
* @description
* 与Sequence相同的执行逻辑，但在开始时会随机打乱子节点的执行顺序。
* 适用于需要随机化行为执行顺序的场景，增加AI行为的不可预测性。
*
* @template T 上下文类型
*
* @example
* ```typescript
* // 创建一个随机执行巡逻点的序列
* const randomPatrol = new RandomSequence<GameContext>();
* randomPatrol.addChild(new MoveToPoint(point1));
* randomPatrol.addChild(new MoveToPoint(point2));
* randomPatrol.addChild(new MoveToPoint(point3));
* // 每次执行时，巡逻点的顺序都会被随机打乱
* ```
*/
declare class RandomSequence<T> extends Sequence<T> {
/** 是否在每次重新开始时都重新洗牌*/
private _reshuffleOnRestart;
/** 原始子节点顺序的备份 */
private _originalOrder;
/**
* 创建随机序列节点
* @param abortType 中止类型，默认为None
* @param reshuffleOnRestart 是否在每次重新开始时都重新洗牌，默认true
*/
constructor(abortType?: AbortTypes, reshuffleOnRestart?: boolean);
/**
* 节点开始时的处理
* 随机打乱子节点顺序
*/
onStart(): void;
/**
* 重置节点状态
* 如果启用了reshuffleOnRestart，会在下次开始时重新洗牌
*/
invalidate(): void;
/**
* 设置是否在重新开始时重新洗牌
* @param enabled 是否启用
*/
setReshuffleOnRestart(enabled: boolean): void;
/**
* 获取是否在重新开始时重新洗牌
* @returns 当前设置
*/
getReshuffleOnRestart(): boolean;
/**
* 恢复原始子节点顺序
* @description 将子节点顺序恢复到添加时的原始顺序
*/
restoreOriginalOrder(): void;
/**
* 手动重新洗牌子节点
* @description 立即重新洗牌子节点顺序，不等待下次开始
*/
reshuffleNow(): void;
}
interface IConditional<T> {
readonly discriminator: 'IConditional';
update(context: T): TaskStatus;
}
declare function isIConditional(obj: any): obj is IConditional<any>;
/**
* 执行动作条件包装器
*
* @description
* 包装一个ExecuteAction，使其可以作为条件节点使用。
* 适用于需要将简单的函数逻辑用作条件判断的场景。
*
* @template T 上下文类型
*
* @example
* ```typescript
* // 创建一个检查玩家血量的条件
* const healthCheck = new ExecuteActionConditional<GameContext>((context) => {
* return context.player.health > 50 ? TaskStatus.Success : TaskStatus.Failure;
* }, { name: 'HealthCheck' });
*
* // 创建一个检查敌人距离的条件
* const enemyInRange = ExecuteActionConditional.createPredicate<GameContext>(
* (context) => context.getClosestEnemy()?.distance < 10,
* 'EnemyInRange'
* );
* ```
*/
declare class ExecuteActionConditional<T> extends ExecuteAction<T> implements IConditional<T> {
/** 条件节点标识符 */
readonly discriminator: "IConditional";
/**
* 创建执行动作条件
* @param action 条件判断函数，应返回Success或Failure
* @param options 配置选项
*/
constructor(action: (context: T) => TaskStatus, options?: {
/** 是否启用错误处理，默认true */
enableErrorHandling?: boolean;
/** 条件名称，用于调试 */
name?: string;
});
/**
* 创建基于布尔值的条件
* @param predicate 返回布尔值的判断函数
* @param name 条件名称
* @returns 新的ExecuteActionConditional实例
*/
static createPredicate<T>(predicate: (context: T) => boolean, name?: string): ExecuteActionConditional<T>;
/**
* 创建数值比较条件
* @param getValue 获取数值的函数
* @param threshold 阈值
* @param comparison 比较类型
* @param name 条件名称
* @returns 新的ExecuteActionConditional实例
*/
static createNumericComparison<T>(getValue: (context: T) => number, threshold: number, comparison: 'greater' | 'less' | 'equal' | 'greaterEqual' | 'lessEqual', name?: string): ExecuteActionConditional<T>;
/**
* 创建属性存在检查条件
* @param getProperty 获取属性的函数
* @param name 条件名称
* @returns 新的ExecuteActionConditional实例
*/
static createPropertyExists<T>(getProperty: (context: T) => any, name?: string): ExecuteActionConditional<T>;
/**
* 创建组合条件（AND逻辑）
* @param conditions 条件函数数组
* @param name 条件名称
* @returns 新的ExecuteActionConditional实例
*/
static createAnd<T>(conditions: Array<(context: T) => boolean>, name?: string): ExecuteActionConditional<T>;
/**
* 创建组合条件（OR逻辑）
* @param conditions 条件函数数组
* @param name 条件名称
* @returns 新的ExecuteActionConditional实例
*/
static createOr<T>(conditions: Array<(context: T) => boolean>, name?: string): ExecuteActionConditional<T>;
}
/**
* 当随机概率高于successProbability概率时返回成功。
* 否则它将返回失败。
* successProbability应该在0和1之间
*/
declare class RandomProbability<T> extends Behavior<T> implements IConditional<T> {
readonly discriminator: "IConditional";
/** 任务返回成功的机会 */
private _successProbability;
constructor(successProbability: number);
update(_context: T): TaskStatus;
}
/**
* 黑板比较操作符
*/
declare enum CompareOperator {
Equal = "equal",
NotEqual = "notEqual",
Greater = "greater",
GreaterOrEqual = "greaterOrEqual",
Less = "less",
LessOrEqual = "lessOrEqual",
Contains = "contains",
NotContains = "notContains"
}
/**
* 黑板值比较条件
*
* @description 比较黑板变量与指定值或另一个黑板变量
*
* @example
* ```typescript
* // 检查玩家生命值是否大于50
* const healthCheck = new BlackboardValueComparison<GameContext>(
* 'playerHealth',
* CompareOperator.Greater,
* 50
* );
*
* // 比较两个黑板变量
* const compareVars = new BlackboardValueComparison<GameContext>(
* 'playerHealth',
* CompareOperator.Greater,
* null,
* 'enemyHealth'
* );
* ```
*/
declare class BlackboardValueComparison<T> implements IConditional<T> {
readonly discriminator: "IConditional";
/** 要比较的黑板变量名 */
variableName: string;
/** 比较操作符 */
operator: CompareOperator;
/** 比较值（与compareVariable二选一） */
compareValue: any;
/** 要比较的另一个黑板变量名（与compareValue二选一） */
compareVariable?: string;
constructor(variableName: string, operator: CompareOperator, compareValue?: any, compareVariable?: string);
/**
* 检查条件是否满足
*/
update(context: T & {
blackboard?: Blackboard;
}): TaskStatus;
/**
* 执行比较操作
*/
private _performComparison;
}
/**
* 黑板变量存在性检查
*
* @description 检查指定的黑板变量是否存在且不为null/undefined
*/
declare class BlackboardVariableExists<T> implements IConditional<T> {
readonly discriminator: "IConditional";
/** 要检查的变量名 */
variableName: string;
/** 是否反转结果（检查变量不存在或为null） */
invert: boolean;
constructor(variableName: string, invert?: boolean);
update(context: T & {
blackboard?: Blackboard;
}): TaskStatus;
}
/**
* 黑板变量类型检查
*
* @description 检查黑板变量是否为指定类型
*/
declare class BlackboardVariableTypeCheck<T> implements IConditional<T> {
readonly discriminator: "IConditional";
/** 要检查的变量名 */
variableName: string;
/** 期望的变量类型 */
expectedType: BlackboardValueType;
constructor(variableName: string, expectedType: BlackboardValueType);
update(context: T & {
blackboard?: Blackboard;
}): TaskStatus;
}
/**
* 黑板变量范围检查
*
* @description 检查数值型黑板变量是否在指定范围内
*/
declare class BlackboardVariableRangeCheck<T> implements IConditional<T> {
readonly discriminator: "IConditional";
/** 要检查的变量名 */
variableName: string;
/** 最小值（包含） */
minValue: number;
/** 最大值（包含） */
maxValue: number;
constructor(variableName: string, minValue: number, maxValue: number);
update(context: T & {
blackboard?: Blackboard;
}): TaskStatus;
}
declare abstract class Decorator<T> extends Behavior<T> {
child: Behavior<T>;
invalidate(): void;
}
/**
* 将总是返回失败，除了当子任务正在运行时
*/
declare class AlwaysFail<T> extends Decorator<T> {
update(context: T): TaskStatus;
}
/**
* 将总是返回成功，除了当子任务正在运行时
*/
declare class AlwaysSucceed<T> extends Decorator<T> {
update(context: T): TaskStatus;
}
/**
* 装饰器，只有在满足条件的情况下才会运行其子程序。
* 默认情况下，该条件将在每一次执行中被重新评估
*/
declare class ConditionalDecorator<T> extends Decorator<T> implements IConditional<T> {
readonly discriminator: "IConditional";
/** 中止类型，决定节点在何种情况下会被中止 */
abortType: AbortTypes;
private _conditional;
private _shouldReevaluate;
private _conditionalStatus;
constructor(conditional: IConditional<T>, shouldReevalute?: boolean, abortType?: AbortTypes);
invalidate(): void;
onStart(): void;
update(context: T): TaskStatus;
/**
* 在shouldReevaluate标志之后执行条件，或者用一个选项来强制更新。
* 终止将强制更新，以确保他们在条件变化时得到适当的数据。
*/
executeConditional(context: T, forceUpdate?: boolean): TaskStatus;
}
/**
* 反转结果的子节点
*/
declare class Inverter<T> extends Decorator<T> {
update(context: T): TaskStatus;
}
/**
* 重复执行装饰器
*
* @description
* 重复执行其子节点，直到达到指定次数或条件满足。
* 支持无限重复、失败时停止等多种模式。
*
* @template T 上下文类型
*
* @example
* ```typescript
* // 重复3次
* const repeater = new Repeater<GameContext>(3);
* repeater.child = new AttackAction();
*
* // 无限重复，失败时停止
* const infiniteRepeater = new Repeater<GameContext>(-1, true);
*
* // 重复直到成功
* const untilSuccess = Repeater.createUntilSuccess<GameContext>();
* ```
*/
declare class Repeater<T> extends Decorator<T> {
/** 重复执行其子任务的次数（-1表示无限重复） */
count: number;
/** 如果子任务返回失败，该任务是否应该停止重复 */
endOnFailure: boolean;
/** 如果子任务返回成功，该任务是否应该停止重复 */
endOnSuccess: boolean;
/** 当前已执行的迭代次数 */
private _iterationCount;
/** 最后一次子节点的执行结果 */
private _lastChildStatus;
/**
* 创建重复装饰器
* @param count 重复次数，-1表示无限重复，必须是整数
* @param endOnFailure 子节点失败时是否停止，默认false
* @param endOnSuccess 子节点成功时是否停止，默认false
* @throws {Error} 当count不是有效整数时抛出错误
*/
constructor(count: number, endOnFailure?: boolean, endOnSuccess?: boolean);
/**
* 是否永远重复
*/
get repeatForever(): boolean;
/**
* 设置是否永远重复
*/
set repeatForever(value: boolean);
onStart(): void;
update(context: T): TaskStatus;
/**
* 获取当前执行次数
* @returns 已执行的次数
*/
getIterationCount(): number;
/**
* 获取剩余执行次数
* @returns 剩余次数，无限重复时返回-1
*/
getRemainingCount(): number;
/**
* 获取执行进度（0-1）
* @returns 进度百分比，无限重复时返回-1
*/
getProgress(): number;
/**
* 获取最后一次子节点的执行结果
* @returns 最后的执行状态
*/
getLastChildStatus(): TaskStatus;
/**
* 重置重复器状态
*/
reset(): void;
/**
* 创建一个重复直到成功的装饰器
* @param maxAttempts 最大尝试次数，-1表示无限
* @returns 新的Repeater实例
*/
static createUntilSuccess<T>(maxAttempts?: number): Repeater<T>;
/**
* 创建一个重复直到失败的装饰器
* @param maxAttempts 最大尝试次数，-1表示无限
* @returns 新的Repeater实例
*/
static createUntilFailure<T>(maxAttempts?: number): Repeater<T>;
/**
* 创建一个无限重复的装饰器
* @returns 新的Repeater实例
*/
static createInfinite<T>(): Repeater<T>;
}
/**
* 将继续执行其子任务，直到子任务返回失败
*/
declare class UntilFail<T> extends Decorator<T> {
update(context: T): TaskStatus;
}
/**
* 将继续执行其子任务，直到子任务返回成功
*/
declare class UntilSuccess<T> extends Decorator<T> {
update(context: T): TaskStatus;
}
/**
* 冷却装饰器
*
* @description 在指定时间内阻止子节点重复执行，实现技能冷却等机制
*/
declare class CooldownDecorator<T> extends Decorator<T> {
/** 冷却时间（秒） */
private cooldownTime;
/** 上次执行时间 */
private lastExecutionTime;
constructor(cooldownTime: number);
onStart(): void;
update(context: T): TaskStatus;
onEnd(): void;
/**
* 重置冷却时间
*/
resetCooldown(): void;
/**
* 获取剩余冷却时间
*/
getRemainingCooldownTime(): number;
/**
* 检查是否在冷却中
*/
isOnCooldown(): boolean;
}
/**
* 超时装饰器
*
* @description 如果子节点执行时间超过指定限制，则强制返回失败状态
*/
declare class TimeoutDecorator<T> extends Decorator<T> {
/** 超时时间（秒） */
private timeoutDuration;
/** 开始执行时间 */
private startTime;
/** 是否已开始执行 */
private hasStarted;
constructor(timeoutDuration: number);
onStart(): void;
update(context: T): TaskStatus;
onEnd(): void;
/**
* 获取剩余时间
*/
getRemainingTime(): number;
/**
* 获取已执行时间
*/
getElapsedTime(): number;
/**
* 检查是否已超时
*/
isTimedOut(): boolean;
}
/**
* 概率装饰器
*
* @description 以指定概率执行子节点，用于实现随机性行为
*/
declare class ChanceDecorator<T> extends Decorator<T> {
/** 成功概率（0.0 - 1.0） */
private successChance;
constructor(successChance: number);
onStart(): void;
update(context: T): TaskStatus;
onEnd(): void;
/**
* 设置成功概率
*/
setSuccessChance(chance: number): void;
/**
* 获取成功概率
*/
getSuccessChance(): number;
/**
* 获取成功概率百分比
*/
getSuccessChancePercentage(): number;
}
//# sourceMappingURL=index.d.ts.map
type index_d$2_ActionHandler = ActionHandler;
type index_d$2_ActionResult = ActionResult;
type index_d$2_AddToBlackboardValue<T> = AddToBlackboardValue<T>;
declare const index_d$2_AddToBlackboardValue: typeof AddToBlackboardValue;
type index_d$2_AdvancedObjectPool<T extends object> = AdvancedObjectPool<T>;
declare const index_d$2_AdvancedObjectPool: typeof AdvancedObjectPool;
type index_d$2_AdvancedPoolManager = AdvancedPoolManager;
declare const index_d$2_AdvancedPoolManager: typeof AdvancedPoolManager;
type index_d$2_AlwaysFail<T> = AlwaysFail<T>;
declare const index_d$2_AlwaysFail: typeof AlwaysFail;
type index_d$2_AlwaysSucceed<T> = AlwaysSucceed<T>;
declare const index_d$2_AlwaysSucceed: typeof AlwaysSucceed;
type index_d$2_Behavior<T> = Behavior<T>;
declare const index_d$2_Behavior: typeof Behavior;
type index_d$2_BehaviorNodePoolManager = BehaviorNodePoolManager;
declare const index_d$2_BehaviorNodePoolManager: typeof BehaviorNodePoolManager;
type index_d$2_BehaviorTree<T> = BehaviorTree<T>;
declare const index_d$2_BehaviorTree: typeof BehaviorTree;
type index_d$2_BehaviorTreeBuildResult<T> = BehaviorTreeBuildResult<T>;
type index_d$2_BehaviorTreeBuilder<T> = BehaviorTreeBuilder<T>;
declare const index_d$2_BehaviorTreeBuilder: typeof BehaviorTreeBuilder;
type index_d$2_BehaviorTreeConfig = BehaviorTreeConfig;
type index_d$2_BehaviorTreeJSONConfig = BehaviorTreeJSONConfig;
type index_d$2_BehaviorTreeMetadata = BehaviorTreeMetadata;
type index_d$2_BehaviorTreeNodeConfig = BehaviorTreeNodeConfig;
type index_d$2_BehaviorTreeReference<T> = BehaviorTreeReference<T>;
declare const index_d$2_BehaviorTreeReference: typeof BehaviorTreeReference;
type index_d$2_Blackboard = Blackboard;
declare const index_d$2_Blackboard: typeof Blackboard;
type index_d$2_BlackboardListener = BlackboardListener;
type index_d$2_BlackboardValueComparison<T> = BlackboardValueComparison<T>;
declare const index_d$2_BlackboardValueComparison: typeof BlackboardValueComparison;
type index_d$2_BlackboardValueType = BlackboardValueType;
declare const index_d$2_BlackboardValueType: typeof BlackboardValueType;
type index_d$2_BlackboardVariable = BlackboardVariable;
type index_d$2_BlackboardVariableConfig = BlackboardVariableConfig;
type index_d$2_BlackboardVariableExists<T> = BlackboardVariableExists<T>;
declare const index_d$2_BlackboardVariableExists: typeof BlackboardVariableExists;
type index_d$2_BlackboardVariableRangeCheck<T> = BlackboardVariableRangeCheck<T>;
declare const index_d$2_BlackboardVariableRangeCheck: typeof BlackboardVariableRangeCheck;
type index_d$2_BlackboardVariableTypeCheck<T> = BlackboardVariableTypeCheck<T>;
declare const index_d$2_BlackboardVariableTypeCheck: typeof BlackboardVariableTypeCheck;
type index_d$2_BlackboardVariableValue = BlackboardVariableValue;
type index_d$2_ChanceDecorator<T> = ChanceDecorator<T>;
declare const index_d$2_ChanceDecorator: typeof ChanceDecorator;
type index_d$2_CompareOperator = CompareOperator;
declare const index_d$2_CompareOperator: typeof CompareOperator;
type index_d$2_Composite<T> = Composite<T>;
declare const index_d$2_Composite: typeof Composite;
type index_d$2_ConditionChecker = ConditionChecker;
type index_d$2_ConditionConfig = ConditionConfig;
type index_d$2_ConditionalDecorator<T> = ConditionalDecorator<T>;
declare const index_d$2_ConditionalDecorator: typeof ConditionalDecorator;
type index_d$2_CooldownDecorator<T> = CooldownDecorator<T>;
declare const index_d$2_CooldownDecorator: typeof CooldownDecorator;
type index_d$2_Decorator<T> = Decorator<T>;
declare const index_d$2_Decorator: typeof Decorator;
type index_d$2_EventRegistry = EventRegistry;
declare const index_d$2_EventRegistry: typeof EventRegistry;
type index_d$2_ExecuteAction<T> = ExecuteAction<T>;
declare const index_d$2_ExecuteAction: typeof ExecuteAction;
type index_d$2_ExecuteActionConditional<T> = ExecuteActionConditional<T>;
declare const index_d$2_ExecuteActionConditional: typeof ExecuteActionConditional;
type index_d$2_ExecutionContext = ExecutionContext;
type index_d$2_GlobalEventRegistry = GlobalEventRegistry;
declare const index_d$2_GlobalEventRegistry: typeof GlobalEventRegistry;
type index_d$2_IBehaviorTreeContext = IBehaviorTreeContext;
type index_d$2_IConditionChecker<TContext = IBehaviorTreeContext, TParams = Record<string, any>> = IConditionChecker<TContext, TParams>;
type index_d$2_IConditional<T> = IConditional<T>;
type index_d$2_IEventHandler<TContext = IBehaviorTreeContext, TParams = Record<string, any>> = IEventHandler<TContext, TParams>;
type index_d$2_ITimeContext = ITimeContext;
type index_d$2_Inverter<T> = Inverter<T>;
declare const index_d$2_Inverter: typeof Inverter;
type index_d$2_LogAction<T> = LogAction<T>;
declare const index_d$2_LogAction: typeof LogAction;
type index_d$2_LogBlackboardValue<T> = LogBlackboardValue<T>;
declare const index_d$2_LogBlackboardValue: typeof LogBlackboardValue;
type index_d$2_MathBlackboardOperation<T> = MathBlackboardOperation<T>;
declare const index_d$2_MathBlackboardOperation: typeof MathBlackboardOperation;
type index_d$2_MathOperation = MathOperation;
declare const index_d$2_MathOperation: typeof MathOperation;
type index_d$2_NodeConfig = NodeConfig;
type index_d$2_NodePropertyConfig = NodePropertyConfig;
type index_d$2_NodePropertyValue = NodePropertyValue;
type index_d$2_ObjectPool<T> = ObjectPool<T>;
declare const index_d$2_ObjectPool: typeof ObjectPool;
type index_d$2_Parallel<T> = Parallel<T>;
declare const index_d$2_Parallel: typeof Parallel;
type index_d$2_ParallelSelector<T> = ParallelSelector<T>;
declare const index_d$2_ParallelSelector: typeof ParallelSelector;
type index_d$2_PoolConfig = PoolConfig;
type index_d$2_PoolPriority = PoolPriority;
declare const index_d$2_PoolPriority: typeof PoolPriority;
type index_d$2_PoolStats = PoolStats;
type index_d$2_RandomProbability<T> = RandomProbability<T>;
declare const index_d$2_RandomProbability: typeof RandomProbability;
type index_d$2_RandomSelector<T> = RandomSelector<T>;
declare const index_d$2_RandomSelector: typeof RandomSelector;
type index_d$2_RandomSequence<T> = RandomSequence<T>;
declare const index_d$2_RandomSequence: typeof RandomSequence;
type index_d$2_Repeater<T> = Repeater<T>;
declare const index_d$2_Repeater: typeof Repeater;
type index_d$2_ResetBlackboardVariable<T> = ResetBlackboardVariable<T>;
declare const index_d$2_ResetBlackboardVariable: typeof ResetBlackboardVariable;
type index_d$2_Selector<T> = Selector<T>;
declare const index_d$2_Selector: typeof Selector;
type index_d$2_Sequence<T> = Sequence<T>;
declare const index_d$2_Sequence: typeof Sequence;
type index_d$2_SetBlackboardValue<T> = SetBlackboardValue<T>;
declare const index_d$2_SetBlackboardValue: typeof SetBlackboardValue;
type index_d$2_TaskStatus = TaskStatus;
declare const index_d$2_TaskStatus: typeof TaskStatus;
type index_d$2_TimeoutDecorator<T> = TimeoutDecorator<T>;
declare const index_d$2_TimeoutDecorator: typeof TimeoutDecorator;
type index_d$2_ToggleBlackboardBool<T> = ToggleBlackboardBool<T>;
declare const index_d$2_ToggleBlackboardBool: typeof ToggleBlackboardBool;
type index_d$2_UntilFail<T> = UntilFail<T>;
declare const index_d$2_UntilFail: typeof UntilFail;
type index_d$2_UntilSuccess<T> = UntilSuccess<T>;
declare const index_d$2_UntilSuccess: typeof UntilSuccess;
type index_d$2_WaitAction<T> = WaitAction<T>;
declare const index_d$2_WaitAction: typeof WaitAction;
type index_d$2_WaitForBlackboardCondition<T> = WaitForBlackboardCondition<T>;
declare const index_d$2_WaitForBlackboardCondition: typeof WaitForBlackboardCondition;
declare const index_d$2_isIConditional: typeof isIConditional;
declare namespace index_d$2 {
export { index_d$2_AddToBlackboardValue as AddToBlackboardValue, index_d$2_AdvancedObjectPool as AdvancedObjectPool, index_d$2_AdvancedPoolManager as AdvancedPoolManager, index_d$2_AlwaysFail as AlwaysFail, index_d$2_AlwaysSucceed as AlwaysSucceed, index_d$2_Behavior as Behavior, index_d$2_BehaviorNodePoolManager as BehaviorNodePoolManager, index_d$2_BehaviorTree as BehaviorTree, index_d$2_BehaviorTreeBuilder as BehaviorTreeBuilder, index_d$2_BehaviorTreeReference as BehaviorTreeReference, index_d$2_Blackboard as Blackboard, index_d$2_BlackboardValueComparison as BlackboardValueComparison, index_d$2_BlackboardValueType as BlackboardValueType, index_d$2_BlackboardVariableExists as BlackboardVariableExists, index_d$2_BlackboardVariableRangeCheck as BlackboardVariableRangeCheck, index_d$2_BlackboardVariableTypeCheck as BlackboardVariableTypeCheck, index_d$2_ChanceDecorator as ChanceDecorator, index_d$2_CompareOperator as CompareOperator, index_d$2_Composite as Composite, index_d$2_ConditionalDecorator as ConditionalDecorator, index_d$2_CooldownDecorator as CooldownDecorator, index_d$2_Decorator as Decorator, index_d$2_EventRegistry as EventRegistry, index_d$2_ExecuteAction as ExecuteAction, index_d$2_ExecuteActionConditional as ExecuteActionConditional, index_d$2_GlobalEventRegistry as GlobalEventRegistry, index_d$2_Inverter as Inverter, index_d$2_LogAction as LogAction, index_d$2_LogBlackboardValue as LogBlackboardValue, index_d$2_MathBlackboardOperation as MathBlackboardOperation, index_d$2_MathOperation as MathOperation, index_d$2_ObjectPool as ObjectPool, index_d$2_Parallel as Parallel, index_d$2_ParallelSelector as ParallelSelector, index_d$2_PoolPriority as PoolPriority, index_d$2_RandomProbability as RandomProbability, index_d$2_RandomSelector as RandomSelector, index_d$2_RandomSequence as RandomSequence, index_d$2_Repeater as Repeater, index_d$2_ResetBlackboardVariable as ResetBlackboardVariable, index_d$2_Selector as Selector, index_d$2_Sequence as Sequence, index_d$2_SetBlackboardValue as SetBlackboardValue, index_d$2_TaskStatus as TaskStatus, index_d$2_TimeoutDecorator as TimeoutDecorator, index_d$2_ToggleBlackboardBool as ToggleBlackboardBool, index_d$2_UntilFail as UntilFail, index_d$2_UntilSuccess as UntilSuccess, index_d$2_WaitAction as WaitAction, index_d$2_WaitForBlackboardCondition as WaitForBlackboardCondition, index_d$2_isIConditional as isIConditional };
export type { index_d$2_ActionHandler as ActionHandler, index_d$2_ActionResult as ActionResult, index_d$2_BehaviorTreeBuildResult as BehaviorTreeBuildResult, index_d$2_BehaviorTreeConfig as BehaviorTreeConfig, index_d$2_BehaviorTreeJSONConfig as BehaviorTreeJSONConfig, index_d$2_BehaviorTreeMetadata as BehaviorTreeMetadata, index_d$2_BehaviorTreeNodeConfig as BehaviorTreeNodeConfig, index_d$2_BlackboardListener as BlackboardListener, index_d$2_BlackboardVariable as BlackboardVariable, index_d$2_BlackboardVariableConfig as BlackboardVariableConfig, index_d$2_BlackboardVariableValue as BlackboardVariableValue, index_d$2_ConditionChecker as ConditionChecker, index_d$2_ConditionConfig as ConditionConfig, index_d$2_ExecutionContext as ExecutionContext, index_d$2_IBehaviorTreeContext as IBehaviorTreeContext, index_d$2_IConditionChecker as IConditionChecker, index_d$2_IConditional as IConditional, index_d$2_IEventHandler as IEventHandler, index_d$2_ITimeContext as ITimeContext, index_d$2_NodeConfig as NodeConfig, index_d$2_NodePropertyConfig as NodePropertyConfig, index_d$2_NodePropertyValue as NodePropertyValue, index_d$2_PoolConfig as PoolConfig, index_d$2_PoolStats as PoolStats };
}
/**
* 状态构造函数类型定义
*/
type StateConstructor<T> = new (...args: any[]) => State<T>;
/**
* 状态机实现
*
* @description
* 基于"状态作为对象"模式的状态机实现。
* 每个状态使用单独的类，适合复杂的状态管理系统。
*
* @template T 上下文类型
*
* @example
* ```typescript
* interface GameContext {
* player: Player;
* enemies: Enemy[];
* }
*
* const context: GameContext = { ... };
* const machine = new StateMachine(context, new IdleState());
*
* machine.addState(new AttackState());
* machine.addState(new DefendState());
*
* // 在游戏循环中更新
* machine.update(deltaTime);
*
* // 切换状态
* machine.changeState(AttackState);
* ```
*/
declare class StateMachine<T> {
/** 状态改变时的回调函数 */
onStateChanged?: () => void;
/** 获取当前状态 */
get currentState(): State<T>;
/** 前一个状态 */
previousState?: State<T>;
/** 在当前状态中的经过时间（秒） */
elapsedTimeInState: number;
/** 当前状态实例 */
protected _currentState: State<T>;
/** 执行上下文 */
protected _context: T;
/** 状态实例缓存 */
private _states;
/**
* 创建状态机
* @param context 执行上下文
* @param initialState 初始状态实例
* @throws {Error} 当context或initialState为null时抛出错误
*/
constructor(context: T, initialState: State<T>);
/**
* 将状态添加到状态机
* @param state 要添加的状态实例
* @throws {Error} 当state为null或已存在时抛出错误
*/
addState(state: State<T>): void;
/**
* 移除指定类型的状态
* @param stateType 状态构造函数
* @returns 是否成功移除
*/
removeState<R extends State<T>>(stateType: StateConstructor<R>): boolean;
/**
* 使用提供的时间差更新状态机
* @param deltaTime 时间差（秒）
* @throws {Error} 当deltaTime为负数或无效时抛出错误
*/
update(deltaTime: number): void;
/**
* 从状态机获取特定状态实例，而不改变当前状态
* @param stateType 状态构造函数
* @returns 状态实例，如果不存在则返回null
*/
getState<R extends State<T>>(stateType: StateConstructor<R>): R | null;
/**
* 更改当前状态
* @param newStateType 新状态的构造函数
* @returns 新状态实例，如果切换失败则返回null
*/
changeState<R extends State<T>>(newStateType: StateConstructor<R>): R | null;
/**
* 强制切换到指定状态（即使是相同状态也会重新初始化）
* @param stateType 状态构造函数
* @returns 状态实例，如果切换失败则返回null
*/
forceChangeState<R extends State<T>>(stateType: StateConstructor<R>): R | null;
/**
* 检查当前是否为指定状态
* @param stateType 状态构造函数
* @returns 是否为指定状态
*/
isInState<R extends State<T>>(stateType: StateConstructor<R>): boolean;
/**
* 获取所有已注册的状态类型
* @returns 状态构造函数数组
*/
getRegisteredStateTypes(): StateConstructor<T>[];
/**
* 获取状态机的统计信息
* @returns 包含状态数量和当前状态信息的对象
*/
getStats(): {
stateCount: number;
currentStateName: string;
elapsedTimeInState: number;
previousStateName?: string;
};
}
declare abstract class State<T> {
protected _machine: StateMachine<T>;
protected _context: T;
setMachineAndContext(machine: StateMachine<T>, context: T): void;
/**
* 在设置machine和context之后直接调用，允许状态执行任何所需的设置
*
* @memberof State
*/
onInitialized(): void;
/**
* 当状态变为活动状态时调用
*
* @memberof State
*/
begin(): void;
/**
* 在更新之前调用，允许状态最后一次机会改变状态
*
* @memberof State
*/
reason(): void;
/**
* 每个帧调用此状态为活动状态
*
* @abstract
* @param {number} deltaTime
* @memberof State
*/
abstract update(deltaTime: number): void;
/**
* 此状态不再是活动状态时调用
*
* @memberof State
*/
end(): void;
}
/**
* 简单状态机实现
*
* @description
* 基于枚举的简单状态机，通过约定的方法名来处理状态逻辑。
* 适合简单的状态管理场景，状态逻辑直接写在状态机类中。
*
* @template TEnum 状态枚举类型
*
* @example
* ```typescript
* enum PlayerState {
* Idle = "Idle",
* Running = "Running",
* Jumping = "Jumping"
* }
*
* class PlayerStateMachine extends SimpleStateMachine<PlayerState> {
* constructor() {
* super(PlayerState);
* this.initialState = PlayerState.Idle;
* }
*
* // 状态方法按照 "状态名_enter/tick/exit" 的约定命名
* Idle_enter() {
* console.log("进入空闲状态");
* }
*
* Idle_tick() {
* // 空闲状态逻辑
* }
*
* Idle_exit() {
* console.log("退出空闲状态");
* }
*
* Running_enter() {
* console.log("开始跑步");
* }
*
* Running_tick() {
* // 跑步状态逻辑
* }
*
* Running_exit() {
* console.log("停止跑步");
* }
* }
* ```
*/
declare abstract class SimpleStateMachine<TEnum extends string | number> {
/** 在当前状态中的经过时间 */
protected elapsedTimeInState: number;
/** 前一个状态 */
protected previousState?: TEnum;
/** 状态方法缓存 */
private _stateCache;
/** 当前状态的方法缓存 */
private _stateMethods;
/** 当前状态 */
private _currentState?;
/**
* 获取当前状态
*/
protected get currentState(): TEnum | undefined;
/**
* 设置当前状态
* @param value 新状态
*/
protected set currentState(value: TEnum);
/**
* 设置初始状态
* @param value 初始状态
*/
protected set initialState(value: TEnum);
/**
* 创建简单状态机
* @param stateEnum 状态枚举对象
*/
constructor(stateEnum: Record<string, TEnum>);
/**
* 配置并缓存状态方法
* @param stateName 状态名称
* @param stateEnum 状态枚举值
*/
private configureAndCacheState;
/**
* 检查方法是否存在
* @param methodName 方法名
* @returns 方法是否存在且为函数
*/
private hasMethod;
/**
* 更新状态机
* @param deltaTime 时间差
*/
update(deltaTime: number): void;
/**
* 强制切换到指定状态
* @param newState 新状态
*/
protected changeState(newState: TEnum): void;
/**
* 检查当前是否为指定状态
* @param state 要检查的状态
* @returns 是否为指定状态
*/
protected isInState(state: TEnum): boolean;
/**
* 获取状态机统计信息
* @returns 统计信息对象
*/
protected getStats(): {
currentState?: TEnum;
previousState?: TEnum;
elapsedTimeInState: number;
registeredStatesCount: number;
};
}
//# sourceMappingURL=index.d.ts.map
type index_d$1_SimpleStateMachine<TEnum extends string | number> = SimpleStateMachine<TEnum>;
declare const index_d$1_SimpleStateMachine: typeof SimpleStateMachine;
type index_d$1_State<T> = State<T>;
declare const index_d$1_State: typeof State;
type index_d$1_StateMachine<T> = StateMachine<T>;
declare const index_d$1_StateMachine: typeof StateMachine;
declare namespace index_d$1 {
export {
index_d$1_SimpleStateMachine as SimpleStateMachine,
index_d$1_State as State,
index_d$1_StateMachine as StateMachine,
};
}
interface IAction<T> {
execute(context: T): void;
}
/**
* 封装一个Action并生成一个分数，Reasoner可以使用该分数来决定使用哪个代价
*/
interface IConsideration<T> {
action: IAction<T>;
getScore(context: T): number;
}
/**
* UtilityAI的根节点推理器
*
* @description
* 推理器负责从多个考虑因素中选择最佳的行动方案。
* 它是效用AI系统的核心组件，通过评估各种考虑因素来做出决策。
*
* @template T 上下文类型
*
* @example
* ```typescript
* class MyReasoner extends Reasoner<GameContext> {
* protected selectBestConsideration(context: GameContext): IConsideration<GameContext> {
* // 实现选择逻辑
* return this._considerations[0];
* }
* }
*
* const reasoner = new MyReasoner();
* reasoner.addConsideration(new AttackConsideration());
* reasoner.addConsideration(new DefendConsideration());
*
* const action = reasoner.select(gameContext);
* if (action) {
* action.execute(gameContext);
* }
* ```
*/
declare abstract class Reasoner<T> {
/**
* 默认考虑因素，当没有其他考虑因素可用时使用
* 通常返回一个固定的低分数
*/
defaultConsideration: IConsideration<T>;
/**
* 考虑因素列表
* 推理器将从这些考虑因素中选择最佳的一个
*/
protected _considerations: Array<IConsideration<T>>;
/**
* 选择并返回最佳行动
*
* @param context 决策上下文
* @returns 选中的行动，如果没有可用行动则返回null
*/
select(context: T): IAction<T> | null;
/**
* 选择最佳考虑因素的抽象方法
* 子类必须实现此方法来定义具体的选择策略
*
* @param context 决策上下文
* @returns 选中的考虑因素，如果没有合适的则返回默认考虑因素
*/
protected abstract selectBestConsideration(context: T): IConsideration<T>;
/**
* 添加考虑因素到推理器
*
* @param consideration 要添加的考虑因素
* @returns 返回自身以支持链式调用
* @throws {Error} 当consideration为null或undefined时抛出错误
*/
addConsideration(consideration: IConsideration<T>): Reasoner<T>;
/**
* 移除指定的考虑因素
*
* @param consideration 要移除的考虑因素
* @returns 是否成功移除
*/
removeConsideration(consideration: IConsideration<T>): boolean;
/**
* 清空所有考虑因素
*/
clearConsiderations(): void;
/**
* 获取考虑因素数量
*
* @returns 当前考虑因素的数量
*/
getConsiderationCount(): number;
/**
* 获取所有考虑因素的只读副本
*
* @returns 考虑因素数组的副本
*/
getConsiderations(): ReadonlyArray<IConsideration<T>>;
/**
* 设置默认考虑因素
*
* @param defaultConsideration 新的默认考虑因素
* @returns 返回自身以支持链式调用
* @throws {Error} 当defaultConsideration为null或undefined时抛出错误
*/
setDefaultConsideration(defaultConsideration: IConsideration<T>): Reasoner<T>;
/**
* 检查是否有可用的考虑因素
*
* @returns 是否有考虑因素可用
*/
hasConsiderations(): boolean;
}
declare class UtilityAI<T> {
/**
* 行为树应该多久更新一次。 updatePeriod为0.2将使树每秒更新5次
*/
updatePeriod: number;
private _context;
private _rootReasoner;
private _elapsedTime;
constructor(context: T, rootSelector: Reasoner<T>, updatePeriod?: number);
tick(deltaTime: number): void;
}
/**
* 总是返回一个固定的分数。 作为默认考虑，提供双重任务。
*/
declare class FixedScoreConsideration<T> implements IConsideration<T> {
score: number;
action: IAction<T>;
constructor(score?: number);
getScore(_context: T): number;
}
/**
* 选择高于默认考虑分数的第一个考虑因素
*
* @description
* 遍历所有考虑因素，返回第一个分数高于或等于默认分数的考虑因素。
* 如果没有找到合适的考虑因素，则返回默认考虑因素。
*
* @template T 上下文类型
*/
declare class FirstScoreReasoner<T> extends Reasoner<T> {
/**
* 选择最佳考虑因素
* @param context 决策上下文
* @returns 选中的考虑因素
*/
protected selectBestConsideration(context: T): IConsideration<T>;
}
/**
* 选择评分最高的考虑因素
*
* @description
* 遍历所有考虑因素，找到评分最高的一个。
* 如果没有考虑因素的分数高于默认分数，则返回默认考虑因素。
*
* @template T 上下文类型
*/
declare class HighestScoreReasoner<T> extends Reasoner<T> {
/**
* 选择最佳考虑因素
* @param context 决策上下文
* @returns 选中的考虑因素
*/
protected selectBestConsideration(context: T): IConsideration<T>;
}
//# sourceMappingURL=index.d.ts.map
type index_d_FirstScoreReasoner<T> = FirstScoreReasoner<T>;
declare const index_d_FirstScoreReasoner: typeof FirstScoreReasoner;
type index_d_FixedScoreConsideration<T> = FixedScoreConsideration<T>;
declare const index_d_FixedScoreConsideration: typeof FixedScoreConsideration;
type index_d_HighestScoreReasoner<T> = HighestScoreReasoner<T>;
declare const index_d_HighestScoreReasoner: typeof HighestScoreReasoner;
type index_d_IAction<T> = IAction<T>;
type index_d_IConsideration<T> = IConsideration<T>;
type index_d_Reasoner<T> = Reasoner<T>;
declare const index_d_Reasoner: typeof Reasoner;
type index_d_UtilityAI<T> = UtilityAI<T>;
declare const index_d_UtilityAI: typeof UtilityAI;
declare namespace index_d {
export { index_d_FirstScoreReasoner as FirstScoreReasoner, index_d_FixedScoreConsideration as FixedScoreConsideration, index_d_HighestScoreReasoner as HighestScoreReasoner, index_d_Reasoner as Reasoner, index_d_UtilityAI as UtilityAI };
export type { index_d_IAction as IAction, index_d_IConsideration as IConsideration };
}
export { ArrayExt, Assert, BehaviorTree, BehaviorTreeBuilder, index_d$2 as BehaviourTree, Blackboard, BlackboardValueType, Deque, ErrorHandler, ErrorLevel, EventManager, EventRegistry, index_d$1 as FSM, GlobalEventRegistry, LogLevel, Logger, PrefixedLogger, Random, State, StateMachine, TaskStatus, TimeManager, TypeGuards, index_d as UtilityAI, UtilityAI as UtilityAICore, errorHandler };
export type { ActionHandler, ActionResult, BehaviorTreeBuildResult, BehaviorTreeJSONConfig, BehaviorTreeNodeConfig, BlackboardVariableConfig, CompositeValidator, ConditionChecker, ErrorHandlerConfig, EventManagerConfig, ExecutionContext, IBehaviorTreeContext, IConditionChecker, IEventHandler, LoggerConfig, TimeManagerConfig, TypeCheckResult, TypeValidator };