light-h5-core-lib 2.10.10 → 2.11.0

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.MapUtil = exports.CollisionDetectionUtil = exports.SelfDecrypt = exports.GetDecorateUtils = 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.SetterGetterBase = exports.ClassNameUtil = exports.PoolObj = exports.PoolObjPutStatus = void 0;
+exports.MapUtil = exports.CollisionDetectionUtil = exports.SelfDecrypt = exports.GetDecorateUtils = 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.SetterGetterBase = exports.ClassNameUtil = exports.PoolObj = exports.PoolObjPutStatus = exports.BeizerPositionsLerpUtil = void 0;
 const PoolObj_1 = require("./pool/PoolObj");
 Object.defineProperty(exports, "PoolObj", { enumerable: true, get: function () { return PoolObj_1.PoolObj; } });
 const BaseSingleton_1 = require("./common/base/BaseSingleton");
@@ -46,7 +46,10 @@ const MapUtil_1 = require("./common/util/MapUtil");
 Object.defineProperty(exports, "MapUtil", { enumerable: true, get: function () { return MapUtil_1.MapUtil; } });
 const PoolObjPutStatus_1 = require("./pool/PoolObjPutStatus");
 Object.defineProperty(exports, "PoolObjPutStatus", { enumerable: true, get: function () { return PoolObjPutStatus_1.PoolObjPutStatus; } });
+const BeizerPositionsLerpUtil_1 = require("./common/util/BeizerPositionsLerpUtil");
+Object.defineProperty(exports, "BeizerPositionsLerpUtil", { enumerable: true, get: function () { return BeizerPositionsLerpUtil_1.BeizerPositionsLerpUtil; } });
 module.exports = {
+    BeizerPositionsLerpUtil: BeizerPositionsLerpUtil_1.BeizerPositionsLerpUtil,
     PoolObjPutStatus: PoolObjPutStatus_1.PoolObjPutStatus,
     PoolObj: PoolObj_1.PoolObj,
     ClassNameUtil: ClassNameUtil_1.ClassNameUtil,

package/common/util/BeizerPositionsLerpUtil.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeizerPositionsLerpUtil = void 0;
+/**
+ * 贝塞尔曲线坐标点插值算法
+ * @author Aonaufly
+ */
+class BeizerPositionsLerpUtil {
+    /**
+     * 根据开始坐标和结束坐标计算整个贝塞尔曲线的坐标点集合
+     * @param startPosition 开始坐标
+     * @param endPosition 结束坐标
+     * @param addCount 再添加的坐标点数(startPosition + addCount + endPosition) default 1
+     * @param amplitude 幅度（1: 最大为开始坐标与结束坐标的距离的一半）default 0.4
+     * @param distanceMultiple 距离倍数（1=线段内, >1则控制点可向两端外延，如1.5=两端各外延0.25倍线段长度）default 1.0
+     * @returns 控制点集合
+     */
+    static generateControlPoints(startPosition, endPosition, addCount = 1, amplitude = 0.4, distanceMultiple = 1.0) {
+        const result = [{ x: startPosition.x, y: startPosition.y }];
+        if (addCount <= 0) {
+            result.push({ x: endPosition.x, y: endPosition.y });
+            return result;
+        }
+        // 连接线方向向量
+        const dx = endPosition.x - startPosition.x;
+        const dy = endPosition.y - startPosition.y;
+        const len = Math.sqrt(dx * dx + dy * dy);
+        if (len < 0.000001) {
+            // 起点与终点重合，直接返回
+            for (let i = 0; i < addCount; i++) {
+                result.push({ x: startPosition.x, y: startPosition.y });
+            }
+            result.push({ x: endPosition.x, y: endPosition.y });
+            return result;
+        }
+        // 单位方向向量
+        const ux = dx / len;
+        const uy = dy / len;
+        // 垂直方向向量（法向量），旋转90度
+        const nx = -uy;
+        const ny = ux;
+        // 添加点到连接线的最大距离：amplitude * 0.5 * 连接线长度
+        const maxDistance = amplitude * 0.5 * len;
+        // 投影延伸：distanceMultiple=1时投影范围在[0,1]内，>1时向两端外延
+        const extension = (distanceMultiple - 1) * 0.5;
+        // 上一个添加点所在的侧（1 或 -1），用于交替偏向
+        let prevSide = 0;
+        for (let i = 0; i < addCount; i++) {
+            // 在连接线上的投影比例 t ∈ (0, 1)，均匀分布
+            const t = (i + 1) / (addCount + 1);
+            // 映射到实际投影比例：t=0时映射到-extension（起点外侧），t=1时映射到1+extension（终点外侧）
+            const effectiveT = t * distanceMultiple - extension;
+            // 投影点坐标
+            const px = startPosition.x + dx * effectiveT;
+            const py = startPosition.y + dy * effectiveT;
+            // 随机距离 ∈ (0, maxDistance]，确保不在连接线上
+            const randomFactor = 0.1 + Math.random() * 0.9;
+            const distance = randomFactor * maxDistance;
+            // 选择连接线的一侧
+            // 若有上一个点，偏向另一侧的概率为 75%（基础50%增加50%）
+            // 若无上一个点（第一个添加点），各侧50%
+            let side;
+            if (prevSide === 0) {
+                side = Math.random() > 0.5 ? 1 : -1;
+            }
+            else {
+                side = Math.random() < 0.75 ? -prevSide : prevSide;
+            }
+            // 沿法向量偏移得到最终坐标
+            result.push({
+                x: px + nx * distance * side,
+                y: py + ny * distance * side,
+            });
+            prevSide = side;
+        }
+        result.push({ x: endPosition.x, y: endPosition.y });
+        return result;
+    }
+}
+exports.BeizerPositionsLerpUtil = BeizerPositionsLerpUtil;

package/common/util/BeizerUtil.js

@@ -24,6 +24,29 @@ class BeizerUtil {
         }
         return { x, y };
     }
+    /**
+     * 获得当前时间的切线（运动方向）(慎用: 耗性能)
+     * @param timer 时间[0,1]
+     * @returns 切线
+     */
+    static getTangent(points, timer) {
+        if (points.length < 2) {
+            return { x: 0, y: 0 };
+        }
+        // 导数控制点: Q_i = P_{i+1} - P_i
+        const derivativePoints = [];
+        for (let i = 0; i < points.length - 1; i++) {
+            derivativePoints.push({
+                x: points[i + 1].x - points[i].x,
+                y: points[i + 1].y - points[i].y,
+            });
+        }
+        // 在导数控制点上计算 n-2 阶贝塞尔值
+        const pos = BeizerUtil.getPosition(derivativePoints, timer);
+        // 乘以 (n-1) 得到最终切线
+        const n = points.length;
+        return { x: pos.x * (n - 1), y: pos.y * (n - 1) };
+    }
     //#endregion
     //region 获得路线的长度
     static distance(p1, p2) {

package/common/util/MapUtil.js

@@ -24,5 +24,57 @@ class MapUtil {
             keyItems = keys.next();
         }
     }
+    /**
+     * 通过Value寻找Key值
+     * @param targetMap 目标Map
+     * @param value 目标值
+     */
+    static getKeyByValue(targetMap, value) {
+        if (!targetMap || targetMap.size <= 0) {
+            return null;
+        }
+        if (!value)
+            return null;
+        const keys = targetMap.keys();
+        let keyItems = keys.next();
+        while (!keyItems.done) {
+            if (targetMap.get(keyItems.value) === value) {
+                return keyItems.value;
+            }
+            keyItems = keys.next();
+        }
+        return null;
+    }
+    /**
+     * 清理字典中的空Value
+     * @param targetMap 目标Map
+     * @param isNeedClearCallback 判断一个值是不是需要被删除 默认：null
+     */
+    static clearEmptyValue(targetMap, isNeedClearCallback = null) {
+        if (!targetMap || targetMap.size <= 0) {
+            return;
+        }
+        const keys = targetMap.keys();
+        let keyItems = keys.next();
+        const deleteKeys = [];
+        let item;
+        while (!keyItems.done) {
+            item = targetMap.get(keyItems.value);
+            if (!item) {
+                deleteKeys.push(keyItems.value);
+            }
+            else if (isNeedClearCallback) {
+                if (isNeedClearCallback(item)) {
+                    deleteKeys.push(keyItems.value);
+                }
+            }
+            keyItems = keys.next();
+        }
+        if (deleteKeys.length <= 0)
+            return;
+        for (let i = 0; i < deleteKeys.length; i++) {
+            targetMap.delete(deleteKeys[i]);
+        }
+    }
 }
 exports.MapUtil = MapUtil;

package/package.json

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

package/pool/PoolObj.js

@@ -9,17 +9,20 @@ const PoolObjPutStatus_1 = require("./PoolObjPutStatus");
  */
 class PoolObj {
     /**
-     * @param cap 容量(容积) <b style="color:red">小于等于0：无限容量，慎用</b>
-     * @param initCreateNum 初始化创建数量 <b style="color:red">（createCallback != null 有效）</b>
-     * @param createCallback Item创建函数
-     * @param clearCallback Item清理函数
-     * @param destroyCallback Item销毁函数
+     * @param cap 容量(容积) <b style="color:red">小于等于0：无限容量，慎用</b> 默认：5
+     * @param initCreateNum 初始化创建数量 <b style="color:red">（createCallback != null 有效）</b> 默认： 0
+     * @param createCallback Item创建函数 默认: null
+     * @param clearCallback Item清理函数 默认: null
+     * @param destroyCallback Item销毁函数 默认: null
+     * @param isCanPutCallback Item是否可以被放入到对象池 默认: null
+     * @param isForceRefTypeChecking 如果放入的对象是引用对象，是否要检测重复放入的问题 默认: true
      */
-    constructor(cap = 5, initCreateNum = 0, createCallback = null, clearCallback = null, destroyCallback = null, isForceRefTypeChecking = true) {
+    constructor(cap = 5, initCreateNum = 0, createCallback = null, clearCallback = null, destroyCallback = null, isCanPutCallback = null, isForceRefTypeChecking = true) {
         this._cap = cap == null ? 5 : cap;
         this._createCallback = createCallback;
         this._clearCallback = clearCallback;
         this._destroyCallback = destroyCallback;
+        this._isCanPutCallback = isCanPutCallback;
         this._isForceRefTypeChecking = isForceRefTypeChecking;
         this._pool = [];
         this.initCreate(initCreateNum == null ? 0 : initCreateNum);
@@ -66,6 +69,13 @@ class PoolObj {
                 }
             }
         }
+        if (this._isCanPutCallback) {
+            if (!this._isCanPutCallback(obj)) {
+                //client阻止了放入，进行销毁处理
+                this._destroyCallback && this._destroyCallback(obj);
+                return PoolObjPutStatus_1.PoolObjPutStatus.FAILED_CLIENT_PREVENT;
+            }
+        }
         this._clearCallback && this._clearCallback(obj);
         this._pool.push(obj);
         return PoolObjPutStatus_1.PoolObjPutStatus.SUCCESS;

package/pool/PoolObjPutStatus.js

@@ -13,6 +13,8 @@ var PoolObjPutStatus;
     PoolObjPutStatus[PoolObjPutStatus["FAILED_NULL"] = 1] = "FAILED_NULL";
     /**失败的(超过了容量)*/
     PoolObjPutStatus[PoolObjPutStatus["FAILED_EXCEEDS_CAPACITY"] = 2] = "FAILED_EXCEEDS_CAPACITY";
-    /**⚠：引用对象重复放置*/
+    /**⚠️：引用对象重复放入*/
     PoolObjPutStatus[PoolObjPutStatus["WARNING_DUPLICATE"] = 2] = "WARNING_DUPLICATE";
+    /**⚠️: 客户端阻止了放入*/
+    PoolObjPutStatus[PoolObjPutStatus["FAILED_CLIENT_PREVENT"] = 3] = "FAILED_CLIENT_PREVENT";
 })(PoolObjPutStatus || (exports.PoolObjPutStatus = PoolObjPutStatus = {}));

package/type/index.d.ts

@@ -17,8 +17,10 @@ export declare enum PoolObjPutStatus {
 	FAILED_NULL = 1,
 	/**失败的(超过了容量)*/
 	FAILED_EXCEEDS_CAPACITY = 2,
-	/**⚠：引用对象重复放置*/
-	WARNING_DUPLICATE = 2
+	/**⚠️：引用对象重复放入*/
+	WARNING_DUPLICATE = 2,
+	/**⚠️: 客户端阻止了放入*/
+	FAILED_CLIENT_PREVENT = 3
 }
 /**
  * 对象池（泛型）</br>
@@ -31,15 +33,18 @@ export declare class PoolObj<T> implements IClear {
 	private _createCallback;
 	private _clearCallback;
 	private _destroyCallback;
+	private _isCanPutCallback;
 	private _isForceRefTypeChecking;
 	/**
-	 * @param cap 容量(容积) <b style="color:red">小于等于0：无限容量，慎用</b>
-	 * @param initCreateNum 初始化创建数量 <b style="color:red">（createCallback != null 有效）</b>
-	 * @param createCallback Item创建函数
-	 * @param clearCallback Item清理函数
-	 * @param destroyCallback Item销毁函数
+	 * @param cap 容量(容积) <b style="color:red">小于等于0：无限容量，慎用</b> 默认：5
+	 * @param initCreateNum 初始化创建数量 <b style="color:red">（createCallback != null 有效）</b> 默认： 0
+	 * @param createCallback Item创建函数 默认: null
+	 * @param clearCallback Item清理函数 默认: null
+	 * @param destroyCallback Item销毁函数 默认: null
+	 * @param isCanPutCallback Item是否可以被放入到对象池 默认: null
+	 * @param isForceRefTypeChecking 如果放入的对象是引用对象，是否要检测重复放入的问题 默认: true
 	 */
-	constructor(cap?: number, initCreateNum?: number, createCallback?: () => T, clearCallback?: (item: T) => void, destroyCallback?: (item: T) => void, isForceRefTypeChecking?: boolean);
+	constructor(cap?: number, initCreateNum?: number, createCallback?: () => T, clearCallback?: (item: T) => void, destroyCallback?: (item: T) => void, isCanPutCallback?: (item: T) => boolean, isForceRefTypeChecking?: boolean);
 	/**
 	 * 初始化一些数量的item
 	 */
@@ -304,6 +309,18 @@ export declare class BeizerUtil {
 		x: number;
 		y: number;
 	};
+	/**
+	 * 获得当前时间的切线（运动方向）(慎用: 耗性能)
+	 * @param timer 时间[0,1]
+	 * @returns 切线
+	 */
+	static getTangent(points: {
+		x: number;
+		y: number;
+	}[], timer: number): {
+		x: number;
+		y: number;
+	};
 	private static calculationC;
 	private static factorial;
 	private static distance;
@@ -437,7 +454,7 @@ export declare class CollisionDetectionUtil {
 	 * @param aBox
 	 * @param bBox
 	 */
-	static aABB(aAnchor: Vec2, bAnchor: Vec2, aBox: IBoxInfo, bBox: IBoxInfo): boolean;
+	static aABB(aAnchor: CoreVec2, bAnchor: CoreVec2, aBox: IBoxInfo, bBox: IBoxInfo): boolean;
 	/**
 	 * OBB检测
 	 * @param aCenter A的中心位置
@@ -445,13 +462,13 @@ export declare class CollisionDetectionUtil {
 	 * @param aOBB
 	 * @param bOBB
 	 */
-	static oBB(aCenter: Vec2, bCenter: Vec2, aOBB: IOBBInfo, bOBB: IOBBInfo): boolean;
+	static oBB(aCenter: CoreVec2, bCenter: CoreVec2, aOBB: IOBBInfo, bOBB: IOBBInfo): boolean;
 	/**
 	 * 多边形检测
 	 * @param aVertices A的每个点的位置
 	 * @param bVertices B的每个点的位置
 	 */
-	static polygon(aVertices: Vec2[], bVertices: Vec2[]): boolean;
+	static polygon(aVertices: CoreVec2[], bVertices: CoreVec2[]): boolean;
 	/**
 	 * 检测旋转矩形和圆形是否相交<br>
 	 * <div style="color: #FF0000;">锚点都为0.5</div>
@@ -459,10 +476,10 @@ export declare class CollisionDetectionUtil {
 	 * @param rect 矩形
 	 */
 	static circle2Rect(circle: {
-		position: Vec2;
+		position: CoreVec2;
 		radius: number;
 	}, rect: {
-		position: Vec2;
+		position: CoreVec2;
 		width: number;
 		height: number;
 		angle: number;
@@ -471,10 +488,10 @@ export declare class CollisionDetectionUtil {
 	 * 2个圆形是否碰撞
 	 */
 	static circle2Circle(aCircle: {
-		position: Vec2;
+		position: CoreVec2;
 		radius: number;
 	}, bCircle: {
-		position: Vec2;
+		position: CoreVec2;
 		radius: number;
 	}): boolean;
 	/**
@@ -484,7 +501,7 @@ export declare class CollisionDetectionUtil {
 	 * @param ellipseAxis 椭圆轴
 	 * @returns
 	 */
-	static IsInEllipse(pos: Vec2, centerPos: Vec2, ellipseAxis: Vec2): boolean;
+	static IsInEllipse(pos: CoreVec2, centerPos: CoreVec2, ellipseAxis: CoreVec2): boolean;
 }
 export interface IBoxInfo {
 	x: number;
@@ -492,7 +509,7 @@ export interface IBoxInfo {
 	width: number;
 	height: number;
 }
-export interface Vec2 {
+export interface CoreVec2 {
 	x: number;
 	y: number;
 }
@@ -575,7 +592,35 @@ export declare class MapUtil {
 	 * @param targetMap 目标Map
 	 * @param everyCallback 每次的回调
 	 */
-	static all(targetMap: Map<any, any>, everyCallback: (key: any, item: any) => void): void;
+	static all<KEY, VALUE>(targetMap: Map<KEY, VALUE>, everyCallback: (key: KEY, item: VALUE) => void): void;
+	/**
+	 * 通过Value寻找Key值
+	 * @param targetMap 目标Map
+	 * @param value 目标值
+	 */
+	static getKeyByValue<KEY, VALUE>(targetMap: Map<KEY, VALUE>, value: VALUE): KEY;
+	/**
+	 * 清理字典中的空Value
+	 * @param targetMap 目标Map
+	 * @param isNeedClearCallback 判断一个值是不是需要被删除 默认：null
+	 */
+	static clearEmptyValue<KEY, VALUE>(targetMap: Map<KEY, VALUE>, isNeedClearCallback?: (item: VALUE) => boolean): void;
+}
+/**
+ * 贝塞尔曲线坐标点插值算法
+ * @author Aonaufly
+ */
+export declare class BeizerPositionsLerpUtil {
+	/**
+	 * 根据开始坐标和结束坐标计算整个贝塞尔曲线的坐标点集合
+	 * @param startPosition 开始坐标
+	 * @param endPosition 结束坐标
+	 * @param addCount 再添加的坐标点数(startPosition + addCount + endPosition) default 1
+	 * @param amplitude 幅度（1: 最大为开始坐标与结束坐标的距离的一半）default 0.4
+	 * @param distanceMultiple 距离倍数（1=线段内, >1则控制点可向两端外延，如1.5=两端各外延0.25倍线段长度）default 1.0
+	 * @returns 控制点集合
+	 */
+	static generateControlPoints(startPosition: CoreVec2, endPosition: CoreVec2, addCount?: number, amplitude?: number, distanceMultiple?: number): CoreVec2[];
 }
 
 export {};