@kkarum/framework 2.3.17

package/entry/FWEntry.ts

@@ -0,0 +1,219 @@
+import FWUiManager from '../manager/FWUiManager';
+import FWAnimationManager from '../manager/FWAnimationManager';
+import FWAudioManager from '../manager/FWAudioManager';
+import FWComponentManager from '../manager/FWComponentManager';
+import FWEventManager from '../manager/FWEventManager';
+import FWLanguageManager from '../manager/FWLanguageManager';
+import { FWLayerManager } from '../manager/FWLayerManager';
+import FWObjectManager from '../manager/FWObjectManager';
+import { FWResManager } from '../manager/FWResManager';
+import FWSocketManager from '../manager/FWSocketManager';
+import { FWStateManager } from '../manager/FWStateManager';
+import { FWTimeManager } from '../manager/FWTimeManager';
+import { FWSocketAutoProcessPause } from '../expand/FWDecorator';
+import FWTaskManager from '../manager/FWTaskManager';
+import FWEngineManager from '../manager/FWEngineManager';
+import FWHotUpdateManager from '../manager/FWHotUpdateManager';
+import FWPromiseManager from '../manager/FWPromiseManager';
+import { FWPerformanceManager } from '../manager/FWPerformanceManager';
+import FWUtils from '../utils/FWUtils';
+
+/**
+ * 入口脚本
+ */
+export class FWEntry implements FW.Entry {
+  map: Map<string, FW.RegisterBundle> = new Map<string, FW.RegisterBundle>();
+  /**
+   * 事件管理器
+   */
+  timeMgr: FW.TimeManager;
+  /**
+   * 层级管理器
+   */
+  layerMgr: FW.LayerManager;
+  /**
+   * 资源管理器
+   */
+  resMgr: FW.ResManager;
+  /**
+   * 动画管理器
+   */
+  animationMgr: FW.AnimationManager;
+  /**
+   * 状态管理器
+   */
+  stateMgr: FW.StateManager;
+  /**
+   * 音效管理器
+   */
+  audioMgr: FW.AudioManager;
+  /**
+   * socket管理器
+   */
+  socketMgr: FW.SocketManager;
+  /**
+   * 对象管理器
+   */
+  objectMgr: FW.ObjectManager;
+  /**
+   * 事件管理器
+   */
+  evtMgr: FW.EventManager;
+  /**
+   * UI管理器
+   */
+  uiMgr: FW.UiManager;
+  /**
+   * 任务管理器
+   */
+  taskMgr: FW.TaskManager;
+  /**
+   * 组件管理器
+   */
+  componentMgr: FWComponentManager;
+  /**
+   * 多语言管理器
+   */
+  languageMgr: FW.LanguageManager;
+  /**
+   * 引擎管理器
+   */
+  engineMgr: FW.EngineManager;
+  /**
+   * 热更新管理器
+   */
+  hotUpdateMgr: FW.HotUpdateManager;
+  /**
+   * promise管理器
+   */
+  promiseMgr: FW.PromiseManager;
+  /**
+   * 性能管理器
+   */
+  performanceMgr: FW.PerformanceManager;
+
+  utils: FW.Utils;
+  /**
+   * 当前Scene
+   */
+  scene: FW.Scene;
+  /**
+   * bundle名字
+   */
+  bundleName: string;
+  /**
+   * 初始化
+   * */
+  initialize() {
+    this.evtMgr = new FWEventManager();
+    this.timeMgr = new FWTimeManager();
+    this.engineMgr = new FWEngineManager();
+    this.taskMgr = new FWTaskManager();
+    this.resMgr = new FWResManager();
+    this.layerMgr = new FWLayerManager();
+    this.uiMgr = new FWUiManager();
+    this.animationMgr = new FWAnimationManager();
+    this.stateMgr = new FWStateManager();
+    this.audioMgr = new FWAudioManager();
+    this.objectMgr = new FWObjectManager();
+    this.socketMgr = new FWSocketManager();
+    this.componentMgr = new FWComponentManager();
+    this.languageMgr = new FWLanguageManager();
+    this.hotUpdateMgr = new FWHotUpdateManager();
+    this.promiseMgr = new FWPromiseManager();
+    this.performanceMgr = new FWPerformanceManager();
+    this.utils = new FWUtils();
+  }
+
+  /**
+   * 启动场景
+   * @param bundleName bundle名字
+   * @param sceneName 场景名字
+   */
+  @FWSocketAutoProcessPause()
+  launchScene(name: string, forceRelease?: boolean): void {
+    FW.Entry.layerMgr.clear();
+
+    if (forceRelease) {
+      this.releaseBundle(this.bundleName);
+    } else {
+      if (this.bundleAutoRelease(this.bundleName)) {
+        this.releaseBundle(this.bundleName);
+      }
+    }
+
+    if (!this.hasSceneName(name)) {
+      try {
+        cc.director.loadScene(name);
+        this.bundleName = '';
+        return;
+      } catch (e) {
+        FW.Log.error('launchScene failed:', name);
+      }
+    }
+
+    this.bundleName = name;
+
+    cc.director.loadScene(this.getSceneName());
+  }
+
+  restart() {
+    this.engineMgr?.restart();
+  }
+
+  releaseBundle(bundleName: string) {
+    this.resMgr.releaseBundle(bundleName);
+    const depend = this.getDepend(bundleName);
+    for (const d of depend) {
+      this.resMgr.releaseBundle(d);
+    }
+  }
+
+  register(data: FW.RegisterBundle) {
+    this.map.set(data.bundleName, data);
+  }
+
+  unRegister(data: FW.RegisterBundle): void {
+    this.map.has(data?.bundleName) && this.map.delete(data?.bundleName);
+  }
+
+  bundleAutoRelease(bundleName: string) {
+    const autoRelease = this.map.get(bundleName)?.autoRelease;
+    return autoRelease === undefined ? true : autoRelease;
+  }
+
+  getDepend(bundleName: string) {
+    const dependencySet = new Set<string>();
+    const findDependencies = (name: string) => {
+      const directDeps = this.map.get(name)?.depend || [];
+      for (const dep of directDeps) {
+        if (!dependencySet.has(dep)) {
+          dependencySet.add(dep);
+          findDependencies(dep);
+        }
+      }
+    };
+
+    findDependencies(bundleName);
+
+    return Array.from(dependencySet);
+  }
+
+  hasSceneName(sceneName: string) {
+    return this.map.has(sceneName);
+  }
+
+  getSceneName() {
+    return this.map.get(this.bundleName)?.sceneName || undefined;
+  }
+
+  getComponent: <T>(serviceIdentifier: FW.ServiceIdentifier<T>) => T = (serviceIdentifier) =>
+    FW.Framework.getComponent(serviceIdentifier);
+
+  getComponents: <T>(serviceIdentifier?: FW.ServiceIdentifier<T>) => T[] = (serviceIdentifier) =>
+    FW.Framework.getComponents(serviceIdentifier);
+
+  update(dt: number) {
+    this.timeMgr?.onUpdate(dt);
+  }
+}

package/entry/FWEntry.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "8848bb37-a1fc-43cf-967d-63e757e5d663",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/entry.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "0886dc2c-004b-4b93-9c5e-eae8ac86edee",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}

package/expand/FWCocosExpand.ts

@@ -0,0 +1,73 @@
+/**
+ * 游戏整体速率修改
+ */
+if (CC_DEBUG) {
+  let timeScaler = 1;
+
+  const originCalculateDeltaTime = cc.Director.prototype['calculateDeltaTime'];
+  cc.director['calculateDeltaTime'] = function (now) {
+    originCalculateDeltaTime.call(this, now);
+    this._deltaTime *= timeScaler;
+  };
+
+  /**
+   *  修改时间倍率
+   *
+   * @param {number} scaler 倍率值
+   */
+  FW.timeScale = function (scaler = 1) {
+    timeScaler = scaler;
+    return `当前帧率缩放比=${timeScaler}`;
+  };
+}
+
+/**
+ * 编辑器模式下预览spine动画
+ */
+if (CC_DEBUG && CC_EDITOR) {
+  cc.game.once(cc.game.EVENT_ENGINE_INITED, function () {
+    cc.js.mixin(sp.Skeleton.prototype, {
+      update(dt) {
+        // if (CC_EDITOR) return;
+
+        if (CC_EDITOR) {
+          cc['engine']._animatingInEditMode = 1;
+          cc['engine'].animatingInEditMode = 1;
+        }
+
+        if (this.paused) return;
+
+        dt *= this.timeScale * sp['timeScale'];
+
+        if (this.isAnimationCached()) {
+          // Cache mode and has animation queue.
+          if (this._isAniComplete) {
+            if (this._animationQueue.length === 0 && !this._headAniInfo) {
+              let frameCache = this._frameCache;
+              if (frameCache && frameCache.isInvalid()) {
+                frameCache.updateToFrame();
+                let frames = frameCache.frames;
+                this._curFrame = frames[frames.length - 1];
+              }
+              return;
+            }
+            if (!this._headAniInfo) {
+              this._headAniInfo = this._animationQueue.shift();
+            }
+            this._accTime += dt;
+            if (this._accTime > this._headAniInfo.delay) {
+              let aniInfo = this._headAniInfo;
+              this._headAniInfo = null;
+              this.setAnimation(0, aniInfo.animationName, aniInfo.loop);
+            }
+            return;
+          }
+
+          this._updateCache(dt);
+        } else {
+          this._updateRealtime(dt);
+        }
+      },
+    });
+  });
+}

package/expand/FWCocosExpand.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "a17028d0-eb34-48e2-846a-ce7bbd25a8f4",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/expand/FWDecorator.ts

@@ -0,0 +1,366 @@
+import 'reflect-metadata';
+
+export function searchChild(node: cc.Node, name: string) {
+  let ret = node.getChildByName(name);
+  if (ret) return ret;
+  for (let i = 0; i < node.children.length; i++) {
+    let child = node.children[i];
+    if (!child.isValid) continue;
+    ret = searchChild(child, name);
+    if (ret) return ret;
+  }
+  return null;
+}
+
+const CookDecoratorKey = ($desc: string) => `__ccc_decorator_${$desc}__`;
+
+const KeyChild = CookDecoratorKey('child_cache');
+
+type ParamType = {
+  path?: string;
+};
+
+export function FWPropertyNode($opt?: ParamType): FW.PropertyDecorator {
+  return ($target, $propertyKey: string, $descriptorOrInitializer) => {
+    if (!$target.hasOwnProperty(KeyChild)) {
+      $target[KeyChild] = [];
+
+      const oldOnLoad: () => void = $target.onLoad || undefined;
+      $target.onLoad = function () {
+        const cache = $target[KeyChild];
+        cache.forEach(($vo) => {
+          const node = searchChild(this.node, $vo.childName);
+          this[$vo.propertyKey] = node;
+        });
+        oldOnLoad && oldOnLoad.apply(this);
+      };
+    }
+
+    const cache: { propertyKey: string; childName: string }[] = $target[KeyChild];
+
+    if (!cache.some(($vo) => $vo.propertyKey === $propertyKey)) {
+      cache.push({
+        propertyKey: $propertyKey,
+        childName: $opt?.path || $propertyKey,
+      });
+    } else {
+      throw new Error(`child 装饰器重复绑定属性：${$propertyKey},class：${$target?.name}`);
+    }
+  };
+}
+
+const KeyChildMulti = CookDecoratorKey('child_cache_multi');
+
+export function FWPropertyNodes(...paths: string[]): FW.PropertyDecorator {
+  return ($target: any, $propertyKey: string) => {
+    if (!$target.hasOwnProperty(KeyChildMulti)) {
+      $target[KeyChildMulti] = [];
+
+      const oldOnLoad = $target.onLoad;
+      $target.onLoad = function () {
+        const cache = $target[KeyChildMulti];
+        if (!this.node) {
+          console.error(`this.node 为空，无法查找子节点`, this);
+          return;
+        }
+        cache.forEach(($vo) => {
+          const nodes: cc.Node[] = [];
+          $vo.childNames.forEach((childName) => {
+            const childNode = searchChild(this.node, childName);
+            if (!childNode) {
+              console.warn(`未找到子节点：${childName}`);
+            } else {
+              nodes.push(childNode);
+            }
+          });
+          this[$vo.propertyKey] = nodes;
+        });
+        if (oldOnLoad) {
+          oldOnLoad.apply(this);
+        }
+      };
+    }
+
+    const cache: { propertyKey: string; childNames: string[] }[] = $target[KeyChildMulti];
+    const existingEntry = cache.find(($vo) => $vo.propertyKey === $propertyKey);
+
+    if (!existingEntry) {
+      cache.push({
+        propertyKey: $propertyKey,
+        childNames: paths,
+      });
+    } else {
+      throw new Error(
+        `child 装饰器重复绑定属性：${$propertyKey}, class：${$target.constructor.name}`,
+      );
+    }
+  };
+}
+
+interface INewable<T = any> extends Function {
+  new (...args: any[]): T;
+}
+
+const KeyComp = CookDecoratorKey('comp_cache');
+
+export function FWPropertyComponent(
+  $componentClass: INewable<cc.Component>,
+  $childName?: string,
+  $mute = false,
+): FW.PropertyDecorator {
+  return ($target, $propertyKey: string, $descriptorOrInitializer) => {
+    if (!$target.hasOwnProperty(KeyComp)) {
+      $target[KeyComp] = [];
+
+      const oldOnLoad: () => void = $target.onLoad || undefined;
+      $target.onLoad = function () {
+        const cache = $target[KeyComp];
+        cache.forEach(($vo) => {
+          const node = $vo.childName ? searchChild(this.node, $vo.childName) : this.node;
+          if (!node) {
+            if (!$mute) {
+              throw new Error(
+                `component装饰器没有找到适合的node节点:class：${$target?.name}，组件：${$componentClass?.name}，childName：${$childName}`,
+              );
+            } else {
+              return;
+            }
+          }
+          this[$vo.propertyKey] =
+            node.getComponent($vo.compClass) || node.addComponent($vo.compClass);
+        });
+        oldOnLoad && oldOnLoad.apply(this);
+      };
+    }
+
+    const cache: {
+      propertyKey: string;
+      compClass: INewable<cc.Component>;
+      childName: string;
+    }[] = $target[KeyComp];
+
+    if (!cache.some(($vo) => $vo.propertyKey === $propertyKey)) {
+      cache.push({
+        propertyKey: $propertyKey,
+        compClass: $componentClass,
+        childName: $childName || $propertyKey,
+      });
+    } else {
+      if (!$mute) {
+        throw new Error(`component装饰器重复绑定属性：${$propertyKey},class：${$target.name}`);
+      }
+      return;
+    }
+  };
+}
+
+export function FWPropertyComponents(
+  $componentClass: INewable<cc.Component>,
+  $childName?: string,
+): FW.PropertyDecorator {
+  return ($target, $propertyKey: string, $descriptorOrInitializer) => {
+    const componentName = $childName || $propertyKey;
+    const oldOnLoad: () => void = $target.onLoad || undefined;
+    $target.onLoad = function () {
+      const components = this.node.getComponentsInChildren($componentClass);
+      if (components.length == 0) return;
+      this[$propertyKey] = components.filter((v) => {
+        return v.node.name == componentName;
+      });
+      oldOnLoad && oldOnLoad.apply(this);
+    };
+  };
+}
+
+export function isNull(message?: string) {
+  return function (target: any, propertyKey: string) {
+    let value: any;
+
+    const getter = function () {
+      return value;
+    };
+
+    const setter = function (newVal: any) {
+      if (newVal === null || newVal === undefined) {
+        const errorMsg = message || `${propertyKey} 不能为 null 或 undefined`;
+        console.error(errorMsg);
+        throw new Error(errorMsg);
+      }
+      value = newVal;
+    };
+
+    Object.defineProperty(target, propertyKey, {
+      get: getter,
+      set: setter,
+      enumerable: true,
+      configurable: true,
+    });
+  };
+}
+
+export function FWSocketAutoProcessPause() {
+  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    const originalMethod = descriptor.value;
+
+    descriptor.value = async function (...args: any[]) {
+      try {
+        const result = await originalMethod.apply(this, args);
+        return result;
+      } finally {
+        FW.Log.debug('暂停socket消息处理');
+        FW.Entry.socketMgr.resumeMessageHandle();
+      }
+    };
+
+    return descriptor;
+  };
+}
+
+export function FWDeprecated(description?: string) {
+  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function (...args: any[]) {
+      FW.Log.warn(`${propertyKey}方法已弃用!${description || ''}`);
+      originalMethod.apply(this, args);
+    };
+    return descriptor;
+  };
+}
+
+export function FWSocketAutoProcessResume() {
+  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    const originalMethod = descriptor.value;
+
+    descriptor.value = async function (...args: any[]) {
+      try {
+        const result = await originalMethod.apply(this, args);
+        return result;
+      } finally {
+        FW.Log.debug('恢复socket消息处理');
+        FW.Entry.socketMgr.resumeMessageHandle();
+      }
+    };
+
+    return descriptor;
+  };
+}
+
+export function RegisterEvents(events: FW.RegisterEventArgs[]) {
+  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    const originalMethod = descriptor.value;
+
+    descriptor.value = function (...args: any[]) {
+      if (this.registerEvent) {
+        this.registerEvent(events);
+      }
+      return originalMethod.apply(this, args);
+    };
+
+    return descriptor;
+  };
+}
+
+export function AutoRegisterCCEvent(nodePath: string, eventName?: string) {
+  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    const originalMethod = descriptor.value;
+    const originalOnInit = target.onInit;
+    const evt = eventName || cc.Node.EventType.TOUCH_END;
+
+    target.onInit = function () {
+      originalOnInit?.call(this);
+
+      let targetNode: cc.Node | null = null;
+
+      const cachedNodes = this[KeyChild] || [];
+      const cachedNode = cachedNodes.find((vo: any) => vo.childName === nodePath);
+
+      if (cachedNode && this[cachedNode.propertyKey]) {
+        targetNode = this[cachedNode.propertyKey];
+      } else {
+        targetNode = searchChild(this.layer?.node || this.node, nodePath);
+
+        if (targetNode && !cachedNode) {
+          const cacheKey = `_cached_${nodePath.replace(/\//g, '_')}`;
+          this[cacheKey] = targetNode;
+          if (!this[KeyChild]) this[KeyChild] = [];
+          this[KeyChild].push({
+            propertyKey: cacheKey,
+            childName: nodePath,
+          });
+        }
+      }
+
+      if (targetNode) {
+        this.registerEvent({
+          CCEvent: [
+            {
+              eventName: evt,
+              cb: originalMethod.bind(this),
+              target: targetNode,
+            },
+          ],
+        });
+        FW.Log.debug(`自动注册事件: ${nodePath} -> ${propertyKey}`);
+      } else {
+        FW.Log.warn(`自动注册事件失败: 未找到节点 ${nodePath}`);
+      }
+    };
+  };
+}
+
+export function AutoRegisterFWEvent(eventName: any) {
+  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    const originalMethod = descriptor.value;
+    const originalOnInit = target.onInit;
+
+    target.onInit = function (...args) {
+      originalOnInit?.call(this, args);
+      this.registerEvent({
+        CCEvent: [
+          {
+            eventName: eventName,
+            cb: originalMethod.bind(this),
+            target: this,
+          },
+        ],
+      });
+    };
+  };
+}
+
+export function PerformanceMonitor(operationName?: string) {
+  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    const originalMethod = descriptor.value;
+
+    descriptor.value = async function (...args: any[]) {
+      const startTime = Date.now();
+      const moduleName = target.constructor.name;
+      let methodName = propertyKey;
+
+      if (args && args[0].type) {
+        methodName = `${methodName}->${args[0]?.type?.name}`;
+      } else {
+        methodName = operationName || propertyKey;
+      }
+
+      try {
+        const result = await originalMethod.apply(this, args);
+        const duration = Date.now() - startTime;
+
+        FW.Entry.performanceMgr?.recordOperationMetric(moduleName, methodName, duration);
+
+        if (duration > 100) {
+          FW.Log.warn(`[${moduleName}] ${methodName} took ${duration}ms`);
+        }
+
+        return result;
+      } catch (error) {
+        const duration = Date.now() - startTime;
+        FW.Entry.performanceMgr?.recordOperationMetric(moduleName, `${methodName}_error`, duration);
+        throw error;
+      }
+    };
+
+    return descriptor;
+  };
+}

package/expand/FWDecorator.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "96d84c32-0f47-4743-bf8f-9a72adda6f7f",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}