@kkarum/framework 2.3.17

package/types/FW.d.ts.meta

@@ -0,0 +1,6 @@
+{
+  "ver": "2.0.2",
+  "uuid": "a6ecbab2-9bdf-4b34-a89f-d84013abbcf7",
+  "importer": "text",
+  "subMetas": {}
+}

package/types/Global.d.ts

@@ -0,0 +1,22 @@
+declare namespace globalThis {
+  export var launchScene: string;
+  export function PerformanceMonitor(operationName?: string);
+  export function FWDeprecated(description?: string);
+  export function FWSocketAutoProcessPause();
+  export function FWSocketAutoProcessResume();
+  export function RegisterEvents(events: FW.RegisterEventArgs[]);
+  export function AutoRegisterCCEvent(nodePath: string, eventName?: string);
+  export function AutoRegisterFWEvent(eventName: any);
+  export function searchChild(node: cc.Node, name: string);
+  export function FWPropertyNode($opt?: ParamType): FW.PropertyDecorator;
+  export function FWPropertyNodes(...paths: string[]): FW.PropertyDecorator;
+  export function FWPropertyComponent(
+    $componentClass: FW.Newable<cc.Component>,
+    $childName?: string,
+    $mute = false,
+  ): FW.PropertyDecorator;
+  export function FWPropertyComponents(
+    $componentClass: FW.Newable<cc.Component>,
+    $childName?: string,
+  ): FW.PropertyDecorator;
+}

package/types/Global.d.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "3c019db9-4849-403e-938c-9b8921731119",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/types.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "d7721852-9dd0-4a93-82d4-4752e570c5ac",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}

package/utils/FWLodash.ts

@@ -0,0 +1,105 @@
+import Lodash from 'lodash';
+
+export namespace FWLodash {
+  /**
+   * 通过字符串数组创建一个CC的枚举对象
+   * @param target
+   * @returns
+   */
+  export function CCEnum(target: string[]) {
+    return cc.Enum(
+      Lodash.chain(target)
+        .map((element, index) => {
+          return [`${element}`, index];
+        })
+        .fromPairs()
+        .value(),
+    );
+  }
+  /**
+   * 判断值是否为空
+   * @param value
+   * @returns
+   */
+  export const isEmpty = (value: any) => Lodash.isEmpty(value);
+  /**
+   * 递归克隆
+   * @param value
+   * @returns
+   */
+  export const cloneDeep = <T>(value: T): T => Lodash.cloneDeep(value);
+  /**
+   * 递归地将源对象的自身和继承的可枚举属性合并到目标对象中，
+   * 跳过解析为undefined的源属性。
+   * 数组和普通对象属性递归合并。
+   * 其他对象和值类型被赋值覆盖。
+   * 源对象从左向右应用。
+   * 后续源会覆盖先前源的属性分配。
+   * @param object
+   * @param source
+   * @returns
+   */
+  export const merge = <T, U>(object: T, source: U): T & U => Lodash.merge(object, source);
+  /**
+   * 创建一个 debounced（防抖动）函数，该函数会从上一次被调用后，延迟 wait 毫秒后调用 func 方法。
+   * @param func
+   * @param wait
+   * @returns
+   */
+  export const debounce = <T extends (...args: any[]) => any>(func: T, wait: number) =>
+    Lodash.debounce(func, wait);
+  /**
+   * 创建一个节流函数，在 wait 秒内最多执行 func 一次的函数。
+   * @param func
+   * @param wait
+   * @returns
+   */
+  export const throttle = <T extends (...args: any[]) => any>(func: T, wait: number) =>
+    Lodash.throttle(func, wait);
+  /**
+   * 创建数组的无重复版本，其中只保留每个元素的第一次出现。
+   * @param array
+   * @returns
+   */
+  export const uniq = <T>(array: T[]): T[] => Lodash.uniq(array);
+  /**
+   * 根据 object对象的path路径获取值
+   * @param object
+   * @param path
+   * @param defaultValue
+   * @returns
+   */
+  export const get = <T, R>(object: T, path: Lodash.PropertyPath, defaultValue?: R): R =>
+    Lodash.get(object, path, defaultValue);
+  /**
+   * 根据 object对象的path路径设置值
+   * @param object
+   * @param path
+   * @param defaultValue
+   * @returns
+   */
+  export const set = <T extends object>(object: T, path: Lodash.PropertyPath, value: any): T =>
+    Lodash.set(object, path, value);
+  /**
+   * 创建一个由通过迭代器运行集合的每个元素的结果生成的键组成的对象。每个键的对应值是负责生成键的元素数组
+   * @param array
+   * @param iteratee
+   * @returns
+   */
+  export const groupBy = <T>(array: T[], iteratee: Lodash.ValueIteratee<T>) =>
+    Lodash.groupBy(array, iteratee);
+  /**
+   * 创建一个元素数组，根据通过每个迭代器运行集合中每个元素的结果按升序排序。此方法执行稳定排序，即保留相等元素的原始排序顺序。
+   * @param array
+   * @param iteratee
+   * @returns
+   */
+  export const sortBy = <T>(array: T[], iteratee?: Lodash.Many<Lodash.ListIteratee<T>>) =>
+    Lodash.sortBy(array, iteratee);
+  /**
+   * 创建一个只调用一次的函数
+   * @param func
+   * @returns
+   */
+  export const once = (func: any) => Lodash.once(func);
+}

package/utils/FWLodash.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "167711e4-ace5-44f9-8ad3-2689277b6e7c",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/utils/FWMask.ts

@@ -0,0 +1,222 @@
+export enum FWMaskType {
+  /**
+   * !#en Rect mask.
+   * !#zh 使用矩形作为遮罩
+   * @property {Number} RECT
+   */
+  RECT = 0,
+  /**
+   * !#en Ellipse Mask.
+   * !#zh 使用椭圆作为遮罩
+   * @property {Number} ELLIPSE
+   */
+  ELLIPSE = 1,
+  /**
+   * !#en Image Stencil Mask.
+   * !#zh 使用图像模版作为遮罩
+   * @property {Number} IMAGE_STENCIL
+   */
+  IMAGE_STENCIL = 2,
+
+  /**
+   * 多边形遮罩
+   */
+  POLYGON = 3,
+}
+
+let _vec2_temp = new cc.Vec2();
+let _mat4_temp = new cc.Mat4();
+
+let _circlepoints = [];
+function _calculateCircle(center, radius, segements) {
+  _circlepoints.length = 0;
+  let anglePerStep = (Math.PI * 2) / segements;
+  for (let step = 0; step < segements; ++step) {
+    _circlepoints.push(
+      cc.v2(
+        radius.x * Math.cos(anglePerStep * step) + center.x,
+        radius.y * Math.sin(anglePerStep * step) + center.y,
+      ),
+    );
+  }
+
+  return _circlepoints;
+}
+
+class EllipseConfig {
+  center: cc.Vec2;
+  r: cc.Vec2;
+  segments: number;
+}
+
+/**
+ * 遮罩扩展
+ * 自定义多边形遮罩
+ */
+const { ccclass, property, executeInEditMode, menu, help, inspector } = cc._decorator;
+@ccclass
+@executeInEditMode
+@inspector('packages://maskplus/inspector.js')
+@menu('CustomComponent/FWMask')
+export default class FWMask extends cc.Mask {
+  static Type = FWMaskType;
+
+  @property({ type: cc.Enum(FWMaskType), override: true })
+  _type: FWMaskType = 0;
+  @property({ type: cc.Enum(FWMaskType), override: true })
+  // @ts-ignore
+  get type() {
+    return this._type;
+  }
+  // @ts-ignore
+  set type(value) {
+    if (this._type !== value) {
+      this['_resetAssembler']();
+    }
+
+    this._type = value;
+
+    if (this._type === FWMaskType.POLYGON) {
+      if (this._polygon.length === 0) {
+        let [x, y, width, height] = this.getNodeRect();
+        this._polygon.push(
+          cc.v2(x, y),
+          cc.v2(x + width, y),
+          cc.v2(x + width, y + height),
+          cc.v2(x, y + height),
+        );
+      }
+    }
+
+    if (this._type !== FWMaskType.IMAGE_STENCIL) {
+      this.spriteFrame = null;
+      this.alphaThreshold = 0;
+      this._updateGraphics();
+    }
+    this['_activateMaterial']();
+  }
+
+  @property({ type: [cc.Vec2], serializable: true })
+  _polygon: cc.Vec2[] = [];
+  @property({ type: [cc.Vec2], serializable: true })
+  public get polygon() {
+    return this._polygon;
+  }
+  public set polygon(points: cc.Vec2[]) {
+    this._polygon = points;
+    this._updateGraphics();
+  }
+
+  private ellipse: EllipseConfig = new EllipseConfig();
+  public setEllipse(center?: cc.Vec2, r?: cc.Vec2, segments?: number) {
+    this.ellipse.center = center;
+    this.ellipse.r = r;
+    this.ellipse.segments = segments || this.segements;
+  }
+
+  _updateGraphics() {
+    let node = this.node;
+    let graphics = this['_graphics'];
+    // Share render data with graphics content
+    graphics.clear(false);
+    let [x, y, width, height] = this.getNodeRect();
+    if (this['_type'] === FWMaskType.RECT) {
+      graphics.rect(x, y, width, height);
+    } else if (this['_type'] === FWMaskType.ELLIPSE) {
+      let center = this.ellipse.center || cc.v2(x + width / 2, y + height / 2);
+      let radius = this.ellipse.r || { x: width / 2, y: height / 2 };
+      let segments = this.ellipse.segments || this['_segments'];
+      let points = _calculateCircle(center, radius, segments);
+      for (let i = 0; i < points.length; ++i) {
+        let point = points[i];
+        if (i === 0) {
+          graphics.moveTo(point.x, point.y);
+        } else {
+          graphics.lineTo(point.x, point.y);
+        }
+      }
+      graphics.close();
+    } else if (this['_type'] === FWMaskType.POLYGON) {
+      if (this._polygon.length === 0) this._polygon.push(cc.v2(0, 0));
+      graphics.moveTo(this._polygon[0].x, this._polygon[0].y);
+      for (let i = 1; i < this._polygon.length; i++) {
+        graphics.lineTo(this._polygon[i].x, this._polygon[i].y);
+      }
+      graphics.lineTo(this._polygon[0].x, this._polygon[0].y);
+    }
+
+    if (cc.game.renderType === cc.game.RENDER_TYPE_CANVAS) {
+      graphics.stroke();
+    } else {
+      graphics.fill();
+    }
+  }
+
+  _hitTest(cameraPt: cc.Vec2) {
+    let node = this.node;
+    let size = node.getContentSize(),
+      w = size.width,
+      h = size.height,
+      testPt = _vec2_temp;
+
+    node['_updateWorldMatrix']();
+    if (!cc.Mat4.invert(_mat4_temp, node['_worldMatrix'])) {
+      return false;
+    }
+    let point = cc.v2(0, 0);
+    cc.Vec2.transformMat4(point, cameraPt, _mat4_temp);
+    testPt.x = point.x + node['_anchorPoint'].x * w;
+    testPt.y = point.y + node['_anchorPoint'].y * h;
+
+    let result = false;
+    if (this.type === FWMaskType.RECT || this.type === FWMaskType.IMAGE_STENCIL) {
+      result = testPt.x >= 0 && testPt.y >= 0 && testPt.x <= w && testPt.y <= h;
+    } else if (this.type === FWMaskType.ELLIPSE) {
+      let rx = w / 2,
+        ry = h / 2;
+      let px = testPt.x - 0.5 * w,
+        py = testPt.y - 0.5 * h;
+      result = (px * px) / (rx * rx) + (py * py) / (ry * ry) < 1;
+    } else if (this.type === FWMaskType.POLYGON) {
+      result = this.isInPolygon(point, this.polygon);
+    }
+    if (this.inverted) {
+      result = !result;
+    }
+    return result;
+  }
+
+  private getNodeRect() {
+    let width = this.node['_contentSize'].width;
+    let height = this.node['_contentSize'].height;
+    let x = -width * this.node['_anchorPoint'].x;
+    let y = -height * this.node['_anchorPoint'].y;
+    return [x, y, width, height];
+  }
+
+  public isInPolygon(checkPoint: cc.Vec2, polygonPoints: cc.Vec2[]) {
+    let counter = 0,
+      i: number,
+      xinters: number;
+    let p1: cc.Vec2, p2: cc.Vec2;
+    let pointCount = polygonPoints.length;
+    p1 = polygonPoints[0];
+
+    for (i = 1; i <= pointCount; i++) {
+      p2 = polygonPoints[i % pointCount];
+      if (checkPoint.x > Math.min(p1.x, p2.x) && checkPoint.x <= Math.max(p1.x, p2.x)) {
+        if (checkPoint.y <= Math.max(p1.y, p2.y)) {
+          if (p1.x != p2.x) {
+            xinters = ((checkPoint.x - p1.x) * (p2.y - p1.y)) / (p2.x - p1.x) + p1.y;
+            if (p1.y == p2.y || checkPoint.y <= xinters) {
+              counter++;
+            }
+          }
+        }
+      }
+      p1 = p2;
+    }
+    return (counter & 1) !== 0;
+  }
+}
+cc['FWMask'] = FWMask;

package/utils/FWMask.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "d23e2be0-c6e3-43f3-a7f3-fc08342960ac",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/utils/FWObject.ts

@@ -0,0 +1,27 @@
+export abstract class FWObject extends cc.Component {
+  /** 是否已经初始化 */
+  public initialize: boolean;
+  /** 对象唯一id */
+  public uniqueId: number;
+  /** 对象是否启用 */
+  public enable: boolean;
+
+  public readonly entry: FW.Entry = FW.Entry;
+
+  constructor() {
+    super();
+    this.initialize = false;
+    this.uniqueId = 0;
+    this.enable = false;
+  }
+
+  abstract onGet(args: any);
+  abstract onPut();
+  abstract onInit();
+  onDestroy() {
+    FW.Entry.timeMgr?.unSchedule(this);
+    FW.Entry.evtMgr?.targetOff(this);
+    this?.unscheduleAllCallbacks();
+    this?.node?.stopAllActions();
+  }
+}

package/utils/FWObject.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "9385d55e-5267-434f-b54c-6a98368a5985",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/utils/FWObjectPool.ts

@@ -0,0 +1,177 @@
+const POOL_DISABLE_POSITION: cc.Vec3 = cc.v3(50000, 50000);
+
+export class FWObjectPool<T extends FW.Object = FW.Object>
+  implements FW.ObjectPool
+{
+  private uniqueId: number;
+  private type: FW.SystemDefine.FWObjectType;
+  private enablePoolMap: Map<number, FW.ObjectProperty>;
+  private disablePoolMap: Map<number, FW.ObjectProperty>;
+
+  constructor(
+    protected node: cc.Node,
+    protected parent: cc.Node,
+    type?: FW.SystemDefine.FWObjectType,
+  ) {
+    this.uniqueId = 0;
+    this.type =
+      type !== undefined ? type : FW.SystemDefine.FWObjectType.OPACITY;
+    this.enablePoolMap = new Map<number, FW.ObjectProperty>();
+    this.disablePoolMap = new Map<number, FW.ObjectProperty>();
+  }
+
+  /**
+   * 获取所有已经启用对象
+   */
+  public getEnableObjectMap() {
+    return this.enablePoolMap;
+  }
+  /**
+   * 获取未启用对象
+   * @returns
+   */
+  public getDisableObjectMap() {
+    return this.disablePoolMap;
+  }
+  /**
+   * 获取所有已经创建对象
+   */
+  public getAllObjectMap() {
+    return [...this.enablePoolMap, ...this.disablePoolMap];
+  }
+
+  findObjectProperty(node: cc.Node);
+  findObjectProperty(component: FW.Object);
+  findObjectProperty(uniqueId: number);
+  findObjectProperty() {
+    const map = new Map([...this.enablePoolMap, ...this.disablePoolMap]);
+
+    for (const [uniqueId, property] of map) {
+      if (arguments[0] instanceof cc.Node) {
+        const uuid = arguments[0].uuid;
+        if (property.node.uuid == uuid) {
+          return property;
+        }
+      } else if (arguments[0] instanceof FW.Object) {
+        if (uniqueId == arguments[0]?.uniqueId) {
+          return property;
+        }
+      } else {
+        if (property?.uniqueId == arguments[0]) {
+          return property;
+        }
+      }
+    }
+    return undefined;
+  }
+
+  /** 是否禁用缓存池中存在剩余对象 */
+  public isEmpty() {
+    return this.disablePoolMap.size == 0;
+  }
+
+  get(...args: any): FW.ObjectProperty {
+    let node: cc.Node;
+    let element: T;
+    let ObjectProperty: FW.ObjectProperty = {
+      uniqueId: -1,
+    };
+    if (this.isEmpty()) {
+      node = cc.instantiate(this.node);
+      element = (node.getComponent(FW.Object) as T) || undefined;
+      ObjectProperty.uniqueId = ++this.uniqueId;
+      ObjectProperty.node = node;
+      ObjectProperty.component = element;
+      if (ObjectProperty.component) {
+        ObjectProperty.component.uniqueId = ObjectProperty.uniqueId;
+      }
+    } else {
+      const entry = this.disablePoolMap.entries().next().value;
+      const key = entry[0];
+      ObjectProperty = entry[1] as FW.ObjectProperty;
+      node = ObjectProperty.node;
+      element = ObjectProperty.component as T;
+      this.disablePoolMap.delete(key);
+    }
+
+    if (!cc.isValid(node)) {
+      return;
+    }
+
+    ObjectProperty.enable = true;
+
+    this.enablePoolMap.set(ObjectProperty.uniqueId, ObjectProperty);
+    if (this.type == FW.SystemDefine.FWObjectType.OPACITY) {
+      node.opacity = 255;
+    } else {
+      node.active = true;
+      node.setParent(this.parent);
+    }
+
+    if (element) {
+      if (!element.initialize) {
+        element.initialize = true;
+        element.onInit();
+      }
+      element.enable = true;
+      node.setParent(this.parent);
+      element.onGet(args);
+      FW.Entry.evtMgr?.targetResume(element);
+    } else {
+      node.setParent(this.parent);
+    }
+
+    node.resumeSystemEvents(true);
+
+    return ObjectProperty;
+  }
+
+  puts(nodes: cc.Node[]);
+  puts(components: cc.Component[]);
+  puts(uniqueId: number[]);
+  puts() {
+    const arr = (arguments[0] as any[]).concat();
+    for (let i = 0; i < arr.length; i++) {
+      this.put(arr[i]);
+    }
+  }
+
+  put(node: cc.Node);
+  put(component: FW.Object);
+  put(uniqueId: number);
+  put() {
+    let property: FW.ObjectProperty = this.findObjectProperty(arguments[0]);
+
+    const node: cc.Node = property.node;
+    const element = (node.getComponent(FW.Object) as T) || undefined;
+
+    if (!cc.isValid(node)) {
+      return;
+    }
+
+    if (this.type == FW.SystemDefine.FWObjectType.OPACITY) {
+      node.opacity = 0;
+    } else {
+      node.active = false;
+      node.removeFromParent(false);
+    }
+    node.pauseSystemEvents(true);
+    node.setPosition(POOL_DISABLE_POSITION);
+    this.disablePoolMap.set(property.uniqueId, property);
+    if (element) {
+      FW.Entry.evtMgr?.targetPause(element);
+      element.onPut();
+      element.enable = false;
+    }
+  }
+
+  onDestroy() {
+    const map = new Map([...this.enablePoolMap, ...this.disablePoolMap]);
+
+    for (const [uniqueId, property] of map) {
+      property.component?.onDestroy?.();
+    }
+    this.enablePoolMap.clear();
+    this.disablePoolMap.clear();
+  }
+}

package/utils/FWObjectPool.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "570aed3c-115a-4f80-91e7-7c26e4f8f1f4",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/utils/FWQueue.ts

@@ -0,0 +1,55 @@
+export class FWQueue<T> {
+  private queue: T[];
+  constructor() {
+    this.queue = [];
+  }
+
+  /**
+   * 添加元素进入队列末尾
+   * @param element
+   */
+  public add(element: T) {
+    this.queue.push(element);
+  }
+
+  /**
+   * 删除并返回元素第一个元素
+   * */
+  public shift() {
+    return this.queue.shift();
+  }
+
+  /**
+   * 查看并返回元素第一个元素
+   * */
+  public peek() {
+    if (!this.isEmpty()) {
+      return undefined;
+    }
+    return this.queue[0];
+  }
+
+  /**
+   * 队列是否为空
+   * @returns
+   */
+  public isEmpty() {
+    return this.size() == 0;
+  }
+
+  /**
+   * 队列剩余数量
+   * @returns
+   */
+  public size() {
+    return this.queue.length;
+  }
+
+  public clear() {
+    this.queue = [];
+  }
+
+  public getQueue() {
+    return this.queue;
+  }
+}

package/utils/FWQueue.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "8739c994-9649-44c8-87f3-1d766fff1f54",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}