light-h5-core-lib 2.8.3 → 2.9.1

package/LightCore.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SelfDecrypt = exports.NumberUtil = exports.BooleanUtil = exports.Crc32Util = exports.PromiseUtil = exports.BeizerUtil = exports.UniqueIDUtil = exports.StringUtil = exports.RandomNumUtil = exports.FloatDigitUtil = exports.DateUtil = exports.BitUtil = exports.MD5 = exports.BaseSingleton = exports.PoolObj = void 0;
+exports.CollisionDetectionUtil = exports.SelfDecrypt = exports.NumberUtil = exports.BooleanUtil = exports.Crc32Util = exports.PromiseUtil = exports.BeizerUtil = exports.UniqueIDUtil = exports.StringUtil = exports.RandomNumUtil = exports.FloatDigitUtil = exports.DateUtil = exports.BitUtil = exports.MD5 = exports.BaseSingleton = exports.PoolObj = void 0;
 var PoolObj_1 = require("./pool/PoolObj");
 Object.defineProperty(exports, "PoolObj", { enumerable: true, get: function () { return PoolObj_1.PoolObj; } });
 var BaseSingleton_1 = require("./common/base/BaseSingleton");
@@ -34,6 +34,8 @@ var NumberUtil_1 = require("./common/util/NumberUtil");
 Object.defineProperty(exports, "NumberUtil", { enumerable: true, get: function () { return NumberUtil_1.NumberUtil; } });
 var SelfDecrypt_1 = require("./common/util/SelfDecrypt");
 Object.defineProperty(exports, "SelfDecrypt", { enumerable: true, get: function () { return SelfDecrypt_1.SelfDecrypt; } });
+var CollisionDetectionUtil_1 = require("./common/util/CollisionDetectionUtil");
+Object.defineProperty(exports, "CollisionDetectionUtil", { enumerable: true, get: function () { return CollisionDetectionUtil_1.CollisionDetectionUtil; } });
 module.exports = {
     PoolObj: PoolObj_1.PoolObj,
     BaseSingleton: BaseSingleton_1.BaseSingleton,
@@ -50,4 +52,5 @@ module.exports = {
     BooleanUtil: BooleanUtil_1.BooleanUtil,
     NumberUtil: NumberUtil_1.NumberUtil,
     SelfDecrypt: SelfDecrypt_1.SelfDecrypt,
+    CollisionDetectionUtil: CollisionDetectionUtil_1.CollisionDetectionUtil,
 };

package/common/util/CollisionDetectionUtil.js

@@ -0,0 +1,310 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollisionDetectionUtil = void 0;
+/**
+ * 碰撞检测工具
+ * @author Aonaufly
+ */
+var CollisionDetectionUtil = /** @class */ (function () {
+    function CollisionDetectionUtil() {
+    }
+    /**
+     * AABB检测
+     * @param aAnchor A的锚点（0~1）
+     * @param bAnchor B的描点（0~1）
+     * @param aBox
+     * @param bBox
+     */
+    CollisionDetectionUtil.aABB = function (aAnchor, bAnchor, aBox, bBox) {
+        if (!CollisionDetectionUtil._aabb) {
+            CollisionDetectionUtil._aabb = new AABB();
+        }
+        var result = CollisionDetectionUtil._aabb.conllision(aAnchor, bAnchor, aBox, bBox);
+        CollisionDetectionUtil._aabb.clear();
+        return result;
+    };
+    /**
+     * OBB检测
+     * @param aCenter A的中心位置
+     * @param bCenter B的中心位置
+     * @param aOBB
+     * @param bOBB
+     */
+    CollisionDetectionUtil.oBB = function (aCenter, bCenter, aOBB, bOBB) {
+        if (!CollisionDetectionUtil._obb) {
+            CollisionDetectionUtil._obb = new OBB();
+        }
+        var result = CollisionDetectionUtil._obb.conllision(aCenter, bCenter, aOBB, bOBB);
+        CollisionDetectionUtil._obb.clear();
+        return result;
+    };
+    /**
+     * 多边形检测
+     * @param aVertices A的每个点的位置
+     * @param bVertices B的每个点的位置
+     */
+    CollisionDetectionUtil.polygon = function (aVertices, bVertices) {
+        if (!CollisionDetectionUtil._polygon) {
+            CollisionDetectionUtil._polygon = new Polygon();
+        }
+        var result = CollisionDetectionUtil._polygon.conllision(null, null, aVertices, bVertices);
+        CollisionDetectionUtil._polygon.clear();
+        return result;
+    };
+    /**
+     * 检测旋转矩形和圆形是否相交<br>
+     * <div style="color: #FF0000;">锚点都为0.5</div>
+     * @param circle 圆形
+     * @param rect 矩形
+     */
+    CollisionDetectionUtil.circle2Rect = function (circle, rect) {
+        var angle = rect.angle / Math.PI * 180;
+        var rectMidPointX = rect.position.x;
+        var rectMidPointY = rect.position.y;
+        var rectLeftBottomX = rect.position.x - rect.width / 2;
+        var rectLeftBottomY = rect.position.y - rect.height / 2;
+        var unrotatedCircleX = Math.cos(-angle) * (circle.position.x - rectMidPointX) - Math.sin(-angle) * (circle.position.y - rectMidPointY) + rectMidPointX;
+        var unrotatedCircleY = Math.sin(-angle) * (circle.position.x - rectMidPointX) + Math.cos(-angle) * (circle.position.y - rectMidPointY) + rectMidPointY;
+        var closestX = 0, closestY = 0;
+        if (unrotatedCircleX < rectLeftBottomX)
+            closestX = rectLeftBottomX;
+        else if (unrotatedCircleX > rectLeftBottomX + rect.width)
+            closestX = rectLeftBottomX + rect.width;
+        else
+            closestX = unrotatedCircleX;
+        if (unrotatedCircleY < rectLeftBottomY)
+            closestY = rectLeftBottomY;
+        else if (unrotatedCircleY > rectLeftBottomY + rect.height)
+            closestY = rectLeftBottomY + rect.height;
+        else
+            closestY = unrotatedCircleY;
+        var findDistance = function (fromX, fromY, toX, toY) {
+            var a = Math.abs(fromX - toX);
+            var b = Math.abs(fromY - toY);
+            return Math.sqrt((a * a) + (b * b));
+        };
+        var distance = findDistance(unrotatedCircleX, unrotatedCircleY, closestX, closestY);
+        return distance < circle.radius;
+    };
+    /**
+     * 2个圆形是否碰撞
+     */
+    CollisionDetectionUtil.circle2Circle = function (aCircle, bCircle) {
+        var distance = Math.sqrt(Math.pow((aCircle.position.x - bCircle.position.x), 2) + Math.pow((aCircle.position.y - bCircle.position.y), 2));
+        return distance <= aCircle.radius + bCircle.radius;
+    };
+    /**
+     * 判断某个点的位置是否位于椭圆内
+     * @param pos 点的位置
+     * @param centerPos 椭圆中心点
+     * @param ellipseAxis 椭圆轴
+     * @returns
+     */
+    CollisionDetectionUtil.IsInEllipse = function (pos, centerPos, ellipseAxis) {
+        var diffX = pos.x - centerPos.x;
+        var diffY = pos.y - centerPos.y;
+        return ((diffX * diffX) / (ellipseAxis.x * ellipseAxis.x) + (diffY * diffY) / (ellipseAxis.y * ellipseAxis.y)) <= 1;
+    };
+    return CollisionDetectionUtil;
+}());
+exports.CollisionDetectionUtil = CollisionDetectionUtil;
+//#region 碰撞检测基类
+var CollisionBase = /** @class */ (function () {
+    function CollisionBase() {
+    }
+    CollisionBase.prototype.clear = function () {
+        this._aAnchor = null;
+        this._bAnchor = null;
+    };
+    /**
+     * 碰撞检测处理
+     */
+    CollisionBase.prototype.conllision = function (aAnchor, bAnchor) {
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
+        }
+        this._aAnchor = aAnchor;
+        this._bAnchor = bAnchor;
+        return this.check();
+    };
+    CollisionBase.prototype.destroy = function () {
+        this.clear();
+    };
+    return CollisionBase;
+}());
+//#endregion
+//#region AABB碰撞（2个矩形的简单碰撞）
+var AABB = /** @class */ (function (_super) {
+    __extends(AABB, _super);
+    function AABB() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AABB.prototype.conllision = function (aAnchor, bAnchor, aBox, bBox) {
+        this._aBox = aBox;
+        this._bBox = bBox;
+        return _super.prototype.conllision.call(this, aAnchor, bAnchor);
+    };
+    AABB.prototype.check = function () {
+        var aX = this._aBox.x - this._aAnchor.x * this._aBox.width;
+        var aY = this._aBox.y - this._aAnchor.y * this._aBox.height;
+        var bX = this._bBox.x - this._bAnchor.x * this._bBox.width;
+        var bY = this._bBox.y - this._bAnchor.y * this._bBox.height;
+        return aX < bX + this._bBox.width &&
+            aX + this._aBox.width > bX &&
+            aY < bY + this._bBox.height &&
+            aY + this._aBox.height > bY;
+    };
+    AABB.prototype.clear = function () {
+        this._aBox = null;
+        this._bBox = null;
+        _super.prototype.clear.call(this);
+    };
+    return AABB;
+}(CollisionBase));
+//#endregion
+//#region OBB适用于旋转的矩形，需要使用分离轴定理（SAT）进行检测
+var OBB = /** @class */ (function (_super) {
+    __extends(OBB, _super);
+    function OBB() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    OBB.prototype.clear = function () {
+        this._aOBB = null;
+        this._bOBB = null;
+        _super.prototype.clear.call(this);
+    };
+    OBB.prototype.conllision = function (aAnchor, bAnchor, aOBB, bOBB) {
+        this._aOBB = aOBB;
+        this._bOBB = bOBB;
+        return _super.prototype.conllision.call(this, aAnchor, bAnchor);
+    };
+    OBB.prototype.getVertices = function (isA) {
+        var obbInfo = isA ? this._aOBB : this._bOBB;
+        var center = isA ? this._aAnchor : this._bAnchor;
+        var rad = obbInfo.angle * Math.PI / 180;
+        var cos = Math.cos(rad);
+        var sin = Math.sin(rad);
+        var halfWidth = obbInfo.width / 2;
+        var halfHeight = obbInfo.height / 2;
+        return [
+            {
+                x: center.x + cos * halfWidth - sin * halfHeight,
+                y: center.y + sin * halfWidth + cos * halfHeight
+            },
+            {
+                x: center.x - cos * halfWidth - sin * halfHeight,
+                y: center.y - sin * halfWidth + cos * halfHeight
+            },
+            {
+                x: center.x - cos * halfWidth + sin * halfHeight,
+                y: center.y - sin * halfWidth - cos * halfHeight
+            },
+            {
+                x: center.x + cos * halfWidth + sin * halfHeight,
+                y: center.y + sin * halfWidth - cos * halfHeight
+            }
+        ];
+    };
+    OBB.prototype.getAxes = function (isA) {
+        var vertices = this.getVertices(isA);
+        return [
+            { x: vertices[1].x - vertices[0].x, y: vertices[1].y - vertices[0].y },
+            { x: vertices[2].x - vertices[1].x, y: vertices[2].y - vertices[1].y }
+        ];
+    };
+    OBB.prototype.project = function (axis, isA) {
+        var vertices = this.getVertices(isA);
+        var min = Infinity;
+        var max = -Infinity;
+        vertices.forEach(function (vertex) {
+            var dot = vertex.x * axis.x + vertex.y * axis.y;
+            min = Math.min(min, dot);
+            max = Math.max(max, dot);
+        });
+        return { min: min, max: max };
+    };
+    OBB.prototype.check = function () {
+        var axes = this.getAxes(true).concat(this.getAxes(false));
+        for (var _i = 0, axes_1 = axes; _i < axes_1.length; _i++) {
+            var axis = axes_1[_i];
+            var proj1 = this.project(axis, true);
+            var proj2 = this.project(axis, false);
+            if (proj1.max < proj2.min || proj2.max < proj1.min) {
+                return false;
+            }
+        }
+        return true;
+    };
+    return OBB;
+}(CollisionBase));
+//#endregion
+//#region 多边形
+var Polygon = /** @class */ (function (_super) {
+    __extends(Polygon, _super);
+    function Polygon() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Polygon.prototype.conllision = function (aAnchor, bAnchor, aVertices, bVertices) {
+        this._aVertices = aVertices;
+        this._bVertices = bVertices;
+        return _super.prototype.conllision.call(this, null, null);
+    };
+    Polygon.prototype.getAxes = function (isA) {
+        var vertices = isA ? this._aVertices : this._bVertices;
+        var axes = [];
+        for (var i = 0; i < vertices.length; i++) {
+            var p1 = vertices[i];
+            var p2 = vertices[(i + 1) % vertices.length];
+            var edge = { x: p2.x - p1.x, y: p2.y - p1.y };
+            var normal = { x: -edge.y, y: edge.x };
+            axes.push(normal);
+        }
+        return axes;
+    };
+    Polygon.prototype.project = function (axis, isA) {
+        var min = Infinity;
+        var max = -Infinity;
+        var vertices = isA ? this._aVertices : this._bVertices;
+        vertices.forEach(function (vertex) {
+            var dot = vertex.x * axis.x + vertex.y * axis.y;
+            min = Math.min(min, dot);
+            max = Math.max(max, dot);
+        });
+        return { min: min, max: max };
+    };
+    Polygon.prototype.clear = function () {
+        this._aVertices = null;
+        this._bVertices = null;
+        _super.prototype.clear.call(this);
+    };
+    Polygon.prototype.check = function () {
+        var axes = this.getAxes(true).concat(this.getAxes(false));
+        for (var _i = 0, axes_2 = axes; _i < axes_2.length; _i++) {
+            var axis = axes_2[_i];
+            var proj1 = this.project(axis, true);
+            var proj2 = this.project(axis, false);
+            if (proj1.max < proj2.min || proj2.max < proj1.min) {
+                return false;
+            }
+        }
+        return true;
+    };
+    return Polygon;
+}(CollisionBase));
+//#endregion

package/common/util/StringUtil.js

@@ -25,6 +25,44 @@ var StringUtil = /** @class */ (function () {
         }
         return str;
     };
+    /**
+     * 字符串的格式化 , 从1开始
+     * @param str 源字符串
+     * @param args 填充参数
+     */
+    StringUtil.formatWithStart1 = function (str) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        if (!args || args.length == 0)
+            return str;
+        for (var i = 1, j = args.length; i <= j; i++) {
+            str = str.replace("{".concat(i, "}"), args[i - 1]);
+        }
+        return str;
+    };
+    /**
+     * 单个替换
+     */
+    StringUtil.replace = function (text, searchValue, replaceValue, ignoreCase) {
+        if (ignoreCase === void 0) { ignoreCase = false; }
+        var flags = ignoreCase ? 'gi' : 'g';
+        var esc = searchValue.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return text.replace(new RegExp(esc, flags), replaceValue);
+    };
+    /**
+     * 批量替换
+     */
+    StringUtil.replaceBatch = function (text, map, ignoreCase) {
+        if (ignoreCase === void 0) { ignoreCase = false; }
+        if (!Object.keys(map).length)
+            return text;
+        var flags = ignoreCase ? 'gi' : 'g';
+        var keys = Object.keys(map).sort(function (a, b) { return b.length - a.length; }); // 长优先
+        var pattern = keys.map(function (k) { return k.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }).join('|');
+        return text.replace(new RegExp(pattern, flags), function (m) { var _a; return (_a = map[m]) !== null && _a !== void 0 ? _a : m; });
+    };
     /**
      * 将字符串中所有的\/替换成/
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "light-h5-core-lib",
-  "version": "2.8.3",
+  "version": "2.9.1",
   "description": "light core lib",
   "main": "./LightCore.js",
   "types": "./type/index.d.ts",

package/pool/PoolObj.js

@@ -8,23 +8,95 @@ exports.PoolObj = void 0;
 var PoolObj = /** @class */ (function () {
     /**
      * @param cap 容量(容积)
+     * @param initCreateNum 初始化创建的数量 （createCallback != null 有效）
+     * @param createCallback Item创建函数
+     * @param clearCallback Item清理函数
+     * @param destroyCallback Item销毁函数
      */
-    function PoolObj(cap) {
+    function PoolObj(cap, initCreateNum, createCallback, clearCallback, destroyCallback) {
         if (cap === void 0) { cap = 5; }
+        if (initCreateNum === void 0) { initCreateNum = 0; }
+        if (createCallback === void 0) { createCallback = null; }
+        if (clearCallback === void 0) { clearCallback = null; }
+        if (destroyCallback === void 0) { destroyCallback = null; }
         this._cap = cap;
+        this._createCallback = createCallback;
+        this._clearCallback = clearCallback;
+        this._destroyCallback = destroyCallback;
         this._pool = [];
+        this.initCreate(initCreateNum);
     }
+    /**
+     * 初始化一些数量的item
+     */
+    PoolObj.prototype.initCreate = function (initCreateNum) {
+        if (initCreateNum <= 0)
+            return;
+        if (!this._createCallback)
+            return;
+        var maxNum = Math.min(this._cap, initCreateNum);
+        for (var i = 0; i < maxNum; i++) {
+            this._pool.push(this._createCallback());
+        }
+    };
+    /**
+     * 放入到对象池
+     * @return 放入到对象池是否成功
+     */
     PoolObj.prototype.put = function (obj) {
-        if (!obj || this._pool.length >= this._cap)
+        if (!obj)
+            return false;
+        if (this._pool.length >= this._cap) {
+            this._destroyCallback && this._destroyCallback(obj);
             return false;
+        }
+        this._clearCallback && this._clearCallback(obj);
         this._pool.push(obj);
         return true;
     };
+    /**
+     * 获得一个Item<br>
+     * <b style="color:green">如果size==0，则自动使用createCallback创建</b><br>
+     * <b style="color:red">⚠️如果size==0 && createCallback==null,则返回null</b>
+     */
     PoolObj.prototype.one = function () {
-        if (this._pool.length == 0)
-            return null;
+        if (this._pool.length == 0) {
+            if (!this._createCallback)
+                return null;
+            return this._createCallback();
+        }
         return this._pool.shift();
     };
+    Object.defineProperty(PoolObj.prototype, "isExistCreateCallback", {
+        /**
+         * 是否存在Item创建方法
+         */
+        get: function () {
+            return this._createCallback != null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PoolObj.prototype, "isExistClearCallback", {
+        /**
+         * 是否存在Item的清理函数
+         */
+        get: function () {
+            return this._clearCallback != null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PoolObj.prototype, "isExistDestroyCallback", {
+        /**
+         * 是否存在Item的销毁函数
+         */
+        get: function () {
+            return this._destroyCallback != null;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(PoolObj.prototype, "cap", {
         /**
          * 获取容量(容积)
@@ -58,13 +130,10 @@ var PoolObj = /** @class */ (function () {
         var obj;
         for (var i = 0, j = this._pool.length; i < j; i++) {
             obj = this._pool[i];
-            if (obj.destroy) {
-                obj.destroy();
-            }
-            else if (obj.onDestroy) {
-                obj.onDestroy();
+            if (obj) {
+                this._destroyCallback && this._destroyCallback(obj);
+                obj = null;
             }
-            obj = null;
         }
         this._pool.length = 0;
     };
@@ -72,6 +141,9 @@ var PoolObj = /** @class */ (function () {
         if (!isCleared) {
             this.clear();
         }
+        this._createCallback = null;
+        this._clearCallback = null;
+        this._destroyCallback = null;
         this._pool && (this._pool = null);
     };
     return PoolObj;

package/type/index.d.ts

@@ -13,12 +13,44 @@ export interface IClear extends IDestroy {
 export declare class PoolObj<T> implements IClear {
 	private _pool;
 	private _cap;
+	private _createCallback;
+	private _clearCallback;
+	private _destroyCallback;
 	/**
 	 * @param cap 容量(容积)
+	 * @param initCreateNum 初始化创建的数量 （createCallback != null 有效）
+	 * @param createCallback Item创建函数
+	 * @param clearCallback Item清理函数
+	 * @param destroyCallback Item销毁函数
+	 */
+	constructor(cap?: number, initCreateNum?: number, createCallback?: () => T, clearCallback?: (item: T) => void, destroyCallback?: (item: T) => void);
+	/**
+	 * 初始化一些数量的item
+	 */
+	private initCreate;
+	/**
+	 * 放入到对象池
+	 * @return 放入到对象池是否成功
 	 */
-	constructor(cap?: number);
 	put(obj: T): boolean;
+	/**
+	 * 获得一个Item<br>
+	 * <b style="color:green">如果size==0，则自动使用createCallback创建</b><br>
+	 * <b style="color:red">⚠️如果size==0 && createCallback==null,则返回null</b>
+	 */
 	one(): T;
+	/**
+	 * 是否存在Item创建方法
+	 */
+	get isExistCreateCallback(): boolean;
+	/**
+	 * 是否存在Item的清理函数
+	 */
+	get isExistClearCallback(): boolean;
+	/**
+	 * 是否存在Item的销毁函数
+	 */
+	get isExistDestroyCallback(): boolean;
 	/**
 	 * 获取容量(容积)
 	 */
@@ -191,6 +223,20 @@ export declare class StringUtil {
 	 * @param args 填充参数
 	 */
 	static format(str: string, ...args: any): string;
+	/**
+	 * 字符串的格式化 , 从1开始
+	 * @param str 源字符串
+	 * @param args 填充参数
+	 */
+	static formatWithStart1(str: string, ...args: any): string;
+	/**
+	 * 单个替换
+	 */
+	static replace(text: string, searchValue: string, replaceValue: string, ignoreCase?: boolean): string;
+	/**
+	 * 批量替换
+	 */
+	static replaceBatch(text: string, map: ReplacerMap, ignoreCase?: boolean): string;
 	/**
 	 * 将字符串中所有的\/替换成/
 	 */
@@ -203,6 +249,7 @@ export declare class StringUtil {
 	static string2UTF8Buffer(str: string): ArrayBuffer;
 	static buffer2UTF8String: (buffer: ArrayBuffer) => string;
 }
+export type ReplacerMap = Record<string, string>;
 /**
  * 唯一ID生成器
  * @author Aonaufly
@@ -331,5 +378,84 @@ export declare class SelfDecrypt {
 	 */
 	static decryptBase64(b64: string, key: string): string;
 }
+/**
+ * 碰撞检测工具
+ * @author Aonaufly
+ */
+export declare class CollisionDetectionUtil {
+	private static _aabb;
+	private static _obb;
+	private static _polygon;
+	/**
+	 * AABB检测
+	 * @param aAnchor A的锚点（0~1）
+	 * @param bAnchor B的描点（0~1）
+	 * @param aBox
+	 * @param bBox
+	 */
+	static aABB(aAnchor: Vec2, bAnchor: Vec2, aBox: IBoxInfo, bBox: IBoxInfo): boolean;
+	/**
+	 * OBB检测
+	 * @param aCenter A的中心位置
+	 * @param bCenter B的中心位置
+	 * @param aOBB
+	 * @param bOBB
+	 */
+	static oBB(aCenter: Vec2, bCenter: Vec2, aOBB: IOBBInfo, bOBB: IOBBInfo): boolean;
+	/**
+	 * 多边形检测
+	 * @param aVertices A的每个点的位置
+	 * @param bVertices B的每个点的位置
+	 */
+	static polygon(aVertices: Vec2[], bVertices: Vec2[]): boolean;
+	/**
+	 * 检测旋转矩形和圆形是否相交<br>
+	 * <div style="color: #FF0000;">锚点都为0.5</div>
+	 * @param circle 圆形
+	 * @param rect 矩形
+	 */
+	static circle2Rect(circle: {
+		position: Vec2;
+		radius: number;
+	}, rect: {
+		position: Vec2;
+		width: number;
+		height: number;
+		angle: number;
+	}): boolean;
+	/**
+	 * 2个圆形是否碰撞
+	 */
+	static circle2Circle(aCircle: {
+		position: Vec2;
+		radius: number;
+	}, bCircle: {
+		position: Vec2;
+		radius: number;
+	}): boolean;
+	/**
+	 * 判断某个点的位置是否位于椭圆内
+	 * @param pos 点的位置
+	 * @param centerPos 椭圆中心点
+	 * @param ellipseAxis 椭圆轴
+	 * @returns
+	 */
+	static IsInEllipse(pos: Vec2, centerPos: Vec2, ellipseAxis: Vec2): boolean;
+}
+export interface IBoxInfo {
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+}
+export interface Vec2 {
+	x: number;
+	y: number;
+}
+export interface IOBBInfo {
+	width: number;
+	height: number;
+	angle: number;
+}
 
 export {};

package/common/util/CryptUtil.js

@@ -1,43 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CryptUtil = void 0;
-var crypto_es_1 = __importDefault(require("crypto-es"));
-/**
- * 加解密工具
- * @author Aonaufly
- */
-var CryptUtil = /** @class */ (function () {
-    function CryptUtil() {
-    }
-    //#region AES-256 ECB
-    /** 加密函数AES-256 ECB */
-    CryptUtil.encryptAes = function (plainText, key) {
-        var keyBytes = crypto_es_1.default.enc.Utf8.parse(key);
-        var encrypted = crypto_es_1.default.AES.encrypt(crypto_es_1.default.enc.Utf8.parse(plainText), keyBytes, {
-            mode: crypto_es_1.default.mode.ECB,
-            padding: crypto_es_1.default.pad.Pkcs7,
-        });
-        return encrypted.toString();
-    };
-    /**解密函数AES-256 ECB*/
-    CryptUtil.decryptAes = function (cipherText, key) {
-        var keyBytes = crypto_es_1.default.enc.Utf8.parse(key);
-        var decrypted = crypto_es_1.default.AES.decrypt(cipherText, keyBytes, {
-            mode: crypto_es_1.default.mode.ECB,
-            padding: crypto_es_1.default.pad.Pkcs7,
-        });
-        return crypto_es_1.default.enc.Utf8.stringify(decrypted);
-    };
-    //#endregion
-    /**
-     * MD5
-     */
-    CryptUtil.md5 = function (text) {
-        return crypto_es_1.default.MD5(text).toString();
-    };
-    return CryptUtil;
-}());
-exports.CryptUtil = CryptUtil;