//编译时间Mon Apr 18 2022 14:55:11 GMT+0800 (GMT+08:00)
/**
 * sLib
 * Base TS game lib, S for simple, standard, stable, and Sean;
 * 通用基础库，设计理念为所有项目共用的一些基础方法，不于具体业务相关联，纯TS实现，不对外部及任何引擎有依赖
 * @author Sean
 */
declare namespace slib {
    /**控制logI,logW,logE输出的开关 */
    let LOG_ENABLE: boolean;
    function logI(message?: string, ...args: any[]): void;
    function logW(message?: string, ...args: any[]): void;
    function logE(message?: string, ...args: any[]): void;
    class StringUtil {
        /**
         * 是否为无效字符串，null或undefined都会返回true
         * @param str
         */
        static isEmpty(str: string): boolean;
        /**
         * 格式化，类似c++的sprintf
         * @param text
         * @param formatParam
         */
        static format(text?: string, ...formatParam: any[]): string;
        static formatWithArray(text: string, formatParam: any[], paramCnt?: number): string;
        /**
         * 获取字符串长度,中文字当2个字符
         * @static
         * @param {string} str
         * @return {*}  {number}
         * @memberof StringUtil
         */
        static getStringLen(str: string): number;
        /**
         * 将指定的秒数转换为 hh:mm:ss 的字符串
         * @param sec 秒数
         */
        static formatTimeBySecs(secs: number): string;
    }
    class TypeUtil {
        /**是否为undefined或null */
        static isUndefinedOrNull(obj: any): boolean;
    }
    class ArrayUtil {
        /**
         * 从目标数组中删掉指定的元素
         * @param list 目标数组
         * @param element 要删除的元素
         * @returns 要删除的元素，若不在目标数组中，则返回null
         */
        static removeElement<T>(list: T[], element: T): T;
    }
    class MathUtil {
        /**
         * 获得[n-m)区间中的一个随机整数，包括n,不包括m
         */
        static getRandom(n: number, m: number): number;
        /**是否为有效数据，null,undefined,NaN,null皆为无效 */
        static isValidNumber(num: number): boolean;
        /**
         * 限制value的值在min和max之间， 如果value小于min，返回min。 如果value大于max，返回max，否则返回value
         */
        static clamp(value: number, min: number, max: number): number;
        /**
         * 插值
         * @param min 最小值
         * @param max 最大值
         * @param t 系数
         * @returns 所求值
         */
        static lerp(min: number, max: number, t: number): number;
        /**
         * 将弧度转化为角度
         * @param rad 弧度
         */
        static getDegreeByRadian(rad: number): number;
        /**
         * 将角度转化为弧度
         * @param degree 角度
         */
        static getRadianByDegree(degree: number): number;
        /**
         * 根据向量求角度
         * @param x
         * @param y
         * @returns 返回值为与x轴的夹角，带正负号，正值为x轴逆时针方向，负值为x轴顺时针方向
        */
        static getDegByVec(x: number, y: number): number;
        /**
         * 根据向量求弧度
         * @param x
         * @param y
         * @returns 返回值为与x轴的夹角，带正负号，正值为x轴逆时针方向，负值为x轴顺时针方向
        */
        static getRadianByVec(x: number, y: number): number;
        /**根据向量求角度，返回值在 [0,360]之间，代表从x轴逆时针方向旋转的角度 */
        static get360DegByVec(x: number, y: number): number;
        /**根据向量求弧度，返回值在 [0,2Pi]之间，代表从x轴逆时针方向旋转的弧度 */
        static get2PiRadianByVec(x: number, y: number): number;
        /**
         * 根据权重列表进行一次随机，返回命中的索引
         * @param list 权重列表
         * @returns 命中的索引
         */
        static randomTestByWeightList(list: number[]): number;
    }
}
declare namespace slib.astar {
    /**格子节点 */
    class GridNode {
        private _x;
        get x(): number;
        private _y;
        get y(): number;
        weight: number;
        /**是否已遍历过，内部使用，外部无需关注 */
        visited: boolean;
        /**父节点 内部使用，外部无需关注 */
        parent: GridNode;
        /**是否在关闭列表中  内部使用，外部无需关注*/
        closed: boolean;
        /**内部使用，外部无需关注 */
        h: number;
        /**内部使用，外部无需关注 */
        g: number;
        /**内部使用，外部无需关注 */
        f: number;
        /**内部使用，外部无需关注 */
        cleanNode(): void;
        /**
         *
         * @param x
         * @param y
         * @param weight 权重，计算G值时使用此值，越大代表移动代价越高，0表示为障碍物
         */
        constructor(x: number, y: number, weight: number);
        /**是否是障碍物 */
        get isWall(): boolean;
        /**移动代价，用于计算G值 */
        getCost(fromNeighbor: GridNode): number;
        toString(): string;
    }
    /**A星格子网格类 */
    class Graph {
        protected _diagonal: boolean;
        get diagonal(): boolean;
        protected _grid: GridNode[][];
        get grid(): GridNode[][];
        protected _dirtyNodes: GridNode[];
        private _neighborsRet;
        /**
         *
         * @param gridIn 权重的二维数组，格式为[x][y]，第一个下标为列数，第二个下表为行数
         * @param diagonal 是否允许斜向移动
         */
        constructor(gridIn: number[][], diagonal?: boolean);
        cleanDirty(): void;
        markDirty(node: GridNode): void;
        /**
         * 获取目标格子相邻的格子
         * @param node
         * @returns 注意返回的数组为唯一实例，会随着下一次调用改变，请及时处理
         */
        neighbors(node: GridNode): GridNode[];
    }
    function pathTo(node: GridNode): GridNode[];
    class AStar {
        /**
         *
         * @param graph 寻路网格
         * @param start 起点
         * @param end 终点
         * @param closest 当目标点不可到达时，是否寻路至最近的点
         * @param heuristic 启发函数，用于在寻路时估计当前格子到终点的距离，即计算H值，默认使用manhattan方法
         * @returns 找不到路径时返回null
         */
        search(graph: Graph, start: GridNode, end: GridNode, closest?: boolean, heuristic?: (pos0: GridNode, pos1: GridNode) => number): GridNode[];
        protected getHeap(): math.BinaryHeap<GridNode>;
    }
    namespace heuristics {
        function manhattan(pos0: GridNode, pos1: GridNode): number;
    }
}
declare namespace slib.comp {
    /**摇杆数据模型，设计思路为，传入摇杆半径和按压点，可获得摇杆坐标和力度数据
     * 使用方法，设置半径和基准点，当操作摇杆时调用tap接口传入按压点，释放时调用release接口，修改基准点时调用setStartPos接口，所有坐标都需要与基准点在同一坐标系下
     */
    class JoyStick implements inter.IDestroy {
        destroyed: boolean;
        private _startX;
        /**基准点X */
        get startX(): number;
        private _startY;
        /**基准点Y */
        get startY(): number;
        private _radius;
        get radius(): number;
        /**X轴方向力度，正负代表方向，范围 0-1 */
        get strengthX(): number;
        /**Y轴方向力度，正负代表方向，范围 0-1 */
        get strengthY(): number;
        private _stickX;
        /**摇杆坐标X */
        get stickX(): number;
        private _stickY;
        /**摇杆坐标Y */
        get stickY(): number;
        private _tapping;
        /**是否在按压中 */
        get tapping(): boolean;
        /**
         * @param radius 最大半径
         */
        constructor(radius?: number, startX?: number, startY?: number);
        /**修改摇杆基准点 */
        setStartPos(posX: number, posY: number): void;
        tap(tapX: number, tapY: number): void;
        release(): void;
        destroy(): void;
    }
}
declare namespace slib.config {
    /**配置基类 */
    class ConfigBase {
        /**ID 不可重复 */
        ID: number;
    }
}
declare namespace slib.config {
    /**配置管理器，使用方法：setTable 后 parse， 即可获取数据 */
    class ConfigManager {
        private _map;
        /**所有的配置都在这里 */
        get map(): object;
        private m_temp;
        /**
         * 传入配置表数据，传入后需调用parse方法，将传入的数据解析为对应的类
         * @param name 表的名字，区分表用
         * @param data 数据数组，json导出为数组形式，解析后的object
         * @param cls 对应的类
         */
        setTable(name: string, data: any[], cls: new () => ConfigBase): void;
        /**获取某张表的配置数量 */
        getTableCount(name: string): number;
        /**获取某张表的最大ID */
        getTableMaxID(name: string): number;
        /**解析后将清空所有缓存的数据 */
        parse(): void;
        /**
         * 根据表名和ID取出数据
         * @param tableName
         * @param id
         * @returns 找不到则返回null
         */
        getConfig(tableName: string, id: number): ConfigBase;
    }
}
declare namespace slib.pool {
    /**池元素基类，若继承此基类，则不可在构造函数中传入参数，避免池管理器创建对象时出错 */
    class PoolUnit implements inter.IPoolUnit {
        inPool: boolean;
        /**从池中取出时的初始化接口，建议子类复写，在此时初始化数据 */
        onInitFromPool(): void;
        /**回收到池中时调用的接口，建议子类复写，在此时清除内部相关引用 */
        onRecoverToPool(): void;
    }
}
declare namespace slib.pool {
    class PoolManager<T extends inter.IPoolUnit> {
        private _pool;
        private _warnNum;
        /**警告数量，若池中元素数量超过设定值则打印警告，默认为200 */
        get warnNum(): number;
        private _class;
        constructor(T: any);
        /**
         * 设置警告数量，查看warnNum属性
         * @param num
         */
        setWarnNum(num: number): void;
        getUnit(): T;
        /**注意，若不是由PoolManager创建的，也会回收到池中 */
        recoverUnit(unit: T): void;
    }
}
declare namespace slib.event {
    /**事件派发器 */
    class EventDispatcher {
        private static _pool;
        private _map;
        addEventListener(event: string, callBack: Function, thisObj: any): void;
        removeEventListener(event: string, callBack: Function): void;
        dispatchEvent(event: string, arg?: any): void;
        /**清除所有监听 */
        clearAll(): void;
    }
}
declare namespace slib.frame {
    class Battle {
        destroyed: boolean;
        private _battleLastTime;
        /**战斗持续时间 */
        get battleLastTime(): number;
        protected _moduleList: BattleBaseModule[];
        private _lazyUpdateDelta;
        private _lazyUpdateFlag;
        addModule(module: BattleBaseModule): void;
        init(): void;
        start(): void;
        update(delta: number): void;
        stop(): void;
        destroy(): void;
    }
}
declare namespace slib.frame {
    class BattleBaseModule {
        /**主战斗引用 */
        protected _battle: Battle;
        get battle(): Battle;
        constructor(battle: Battle);
        initModule(): void;
        startModule(): void;
        stopModule(): void;
        update(delta: number): void;
        /**在所有module的update结束后进行 */
        lateUpdate(delta: number): void;
        /**两帧调用一次，可处理一些并不需要频繁更新的逻辑 */
        lazyUpdate(delta: number): void;
        destroy(): void;
    }
}
declare namespace slib.frame {
    /**可控制心跳的timer */
    class FrameTimer implements inter.IUpdate {
        private _interval;
        private _intervalCount;
        private _count;
        private _callBack;
        private _callBackThisObj;
        private _running;
        /**是否正在运行 */
        get running(): boolean;
        /**
         * @param interval 间隔，需要与update中传入的参数为同一单位
         * @param callBack
         * @param callBackThisObj
         * @param count 0为无限
         */
        init(interval: number, callBack: Function, callBackThisObj: any, count?: number): void;
        start(): void;
        update(delta: number): void;
        stop(): void;
        destroy(): void;
    }
}
/**接口相关 */
declare namespace slib.inter {
    interface IDestroy {
        /**是否被销毁过 */
        destroyed: boolean;
        destroy(): void;
    }
    interface IUpdate {
        /**
         * 每帧刷新调用的接口
         * @param delta
         */
        update(delta: number): void;
    }
    interface IPoolUnit {
        /**是否在池中 */
        inPool: boolean;
        /**从池中取出时的初始化接口，建议子类复写，在此时初始化数据 */
        onInitFromPool(): void;
        /**回收到池中时调用的接口，建议子类复写，在此时清除内部相关引用 */
        onRecoverToPool(): void;
    }
}
declare namespace slib.math {
    /**最小二叉堆，根节点为最小值，父节点总是小于或等于子节点，在一个频繁修改的数组中，若总是需要获取最小值，使用二叉堆性能较高 */
    class BinaryHeap<T> {
        private _content;
        private _scoreFunction;
        /**
         *
         * @param scoreFunction 排序值函数，二叉树根据此函数返回的值进行排序
         */
        constructor(scoreFunction: (element: T) => number);
        /**所有节点数量 */
        get size(): number;
        /**添加节点 */
        push(element: T): void;
        /**取最小值节点 */
        pop(): T;
        /**删除所有子节点 */
        clear(): void;
        /**移除某个节点，二叉堆会在移除的节点处重新排序 */
        remove(node: T): void;
        /**
         * 某个节点的值改变了，重排二叉堆
         * @param node 需要重排的节点
         * @param reduce true表示减小，false表示增加
         */
        rescoreElement(node: T, reduce?: boolean): void;
        /**从索引n开始向上查找，将大的父节点下沉 */
        private sinkDown;
        /**从索引n开始向下查找，将小的子节点上浮 */
        private bubbleUp;
    }
}
declare namespace slib.math {
    /**2d向量简易封装 */
    class Vector extends pool.PoolUnit {
        private static _poolManager;
        private static _inited;
        /**从对象池中获取 */
        static get(): Vector;
        static recover(p: Vector): void;
        private _x;
        get x(): number;
        private _y;
        get y(): number;
        /**模长 */
        get magnitude(): number;
        /**模长的平方数，在需要比较向量长度时，可比较两向量的模长平方数，省去开方计算 */
        get sqrMagnitude(): number;
        constructor(x: number, y: number);
        setValue(valueX: number, valueY: number): Vector;
        setX(valueX: number): void;
        setY(valueY: number): void;
        /**当x,y都为0时，不会产生变化 */
        normalize(): void;
        scale(value: number): void;
    }
}
/**2d移动模型 */
declare namespace slib.move2d {
    enum Dir {
        LEFT = 0,
        RIGHT = 1,
        UP = 2,
        DOWN = 3
    }
    /**2d移动模型，可根据设置速度、加速度、方向进行移动，需由外部调用update接口更新 */
    class ActorMove2d implements inter.IUpdate, inter.IDestroy {
        destroyed: boolean;
        private _posChangeCallBack;
        private _posChangeCallBackThisObj;
        private _speed;
        /**速度 */
        get speed(): number;
        private _accelerate;
        /**加速度*/
        get accelerate(): number;
        private _dirNormal;
        /**方向法向量 */
        get dirNormal(): math.Vector;
        protected _stepVec: math.Vector;
        /**步进向量 每次调用onFrameUpdate后更新*/
        get stepVec(): math.Vector;
        /**步进模长 每次调用onFrameUpdate后更新*/
        protected _stepLen: number;
        private _pos;
        get pos(): math.Vector;
        active: boolean;
        constructor(x: number, y: number);
        /**设置前进方向 */
        setDir(x: number, y: number): void;
        /**直接设置前进方向的法向量，可节省一次归一运算 */
        setDirNormal(x: number, y: number): void;
        /**步进接口，更新一帧数据
         * @param delta 单位秒
         */
        update(delta: number): void;
        /**手动设置位置，不会触发位移回调 */
        setPos(x: number, y: number): void;
        /**
         * 当调用onFrameUpdate时会触发此接口，调用posChangeCallBack，子类可复写此方法，控制调用的时机
         * @param dis 前进的距离
         */
        protected callBallBack(dis: number): void;
        /**
        * 绑定位移回调函数，在产生位移时才会触发回调
        * @param func 回调函数，参数 dis:number，前进的距离
        */
        bindPosChangeCallback(callBack: Function, thisObj: any): void;
        /**
         * 设置速度，若设置负值，速度会变为0
         * @param value
         */
        setSpeed(value: number): void;
        /**设置加速度，若设置负值，则产生减速效果 */
        setAcceleration(value: number): void;
        destroy(): void;
    }
}
declare namespace slib.move2d {
    /**在ActorMove2d的基础上改为根据路径列表前进，setDir接口会失效 */
    class ActorMove2dPath extends ActorMove2d {
        private _pathList;
        get pathList(): math.Vector[];
        private _curTarget;
        private _pathIndex;
        /**当前正在追逐的节点索引 */
        get pathIndex(): number;
        private _changePointCallBack;
        private _changePointCallBackThisObj;
        private _posChangeCallBackFlag;
        /**
         * 注意，若设置了加速度，只在行走时加速度才参与计算
         * @param value 加速度
         */
        setAcceleration(value: number): void;
        /**
        * 设置路径列表，若路径点与当前位置相同，则会跳到下一个路径点，直到位置不同
        * @param pathList 传入的路径列表，内部只会引用此数组，不修改其中的数据
        */
        start(pathList: math.Vector[]): void;
        /**
         * 绑定路径点切换时的回调函数，当走过一个点时会触发一次，若出发后此实例的pathIndex属性为-1，则表示路径已走完
         * @param callBack
         * @param thisObj
         */
        bindPointChangeCallBack(callBack: Function, thisObj: any): void;
        setDir(): void;
        stop(): void;
        private gotoPathPoint;
        update(delta: number): void;
        protected callBallBack(dis: number): void;
        /**
        * 当前路径点切换时调用
        * @returns true为成功，false为路径点已走完了
        */
        private checkNextPathPoint;
        /**当前路径点切换时调用，供子类复写，第一个点不会触发 */
        protected onGoToNextPoint(): void;
        destroy(): void;
    }
}
/**状态机相关 */
declare namespace slib.sm {
    /**
     * 单个状态基类
     */
    class SMBaseState {
        static nullTransitionId: number;
        static nullStateId: number;
        stateMachine: XStateMachine;
        get id(): number;
        set id(value: number);
        get isRunning(): boolean;
        isDestroy: boolean;
        /**切换到此状态时，上一个状态ID */
        lastStateId: number;
        protected map: Map<number, number>;
        protected m_stateId: number;
        /**
         * 定义事件和状态的跳转关系
         * @param trans 事件类型
         * @param id 状态类型
         */
        addTransition(trans: number, id: number): void;
        deleteTransition(trans: number): void;
        getOutputState(trans: number): number;
        /**状态被触发时的调用 */
        onEnter(data?: object): void;
        /**离开状态的调用，状态机destory时，也会调用当前状态的onLeave接口 */
        onLeave(): void;
        onReason(transID: number, data?: object): void;
        onUpdate(data?: object): void;
        /**状态机destro时触发 */
        onDestory(): void;
        onGetDebugInfomation(): string;
    }
}
declare namespace slib.sm {
    /**
         * 状态机控制类
         */
    class XStateMachine {
        protected m_states: SMBaseState[];
        protected m_currentStateID: number;
        private m_oldStateID;
        protected m_currentState: SMBaseState;
        getCurrentStateID(): number;
        performTransition(trans: number, data?: object): void;
        protected addState(s: SMBaseState): void;
        protected getStateById(id: number): SMBaseState;
        protected onStateChange(): void;
        destory(): void;
        protected onDestory(): void;
    }
}