@kkarum/framework 2.3.17

package/machine/FWStateMachine.ts

@@ -0,0 +1,74 @@
+import { FWState } from '../state/FWState';
+
+export default class FWStateMachine implements FW.StateMachine {
+  private stateMap: Map<number, FWState>;
+  private stateType: number;
+  private paused: boolean;
+
+  public get state() {
+    return this.stateType;
+  }
+  constructor() {
+    this.stateMap = new Map<number, FWState>();
+    this.stateType = 0;
+    this.paused = false;
+  }
+  /** 进入状态 */
+  enter(stateType: number, ...args: any): void {
+    if (this.stateMap.size == 0) {
+      FW.Log.error('stateMachine is not register!');
+      return;
+    }
+
+    if (this.paused) return;
+    if (this.state == stateType) return;
+
+    if (this.stateMap.has(this.stateType)) {
+      this.stateMap?.get(this.stateType)?.onExit();
+    }
+    this.stateType = stateType;
+    if (this.stateMap.has(this.stateType)) {
+      this.stateMap?.get(this.stateType)?.onEnter(args);
+    }
+  }
+  /**
+   * 暂停状态机
+   * */
+  pause() {
+    this.paused = true;
+    FW.Entry.timeMgr.pauseSchedule(this);
+  }
+  /**
+   * 恢复状态机
+   */
+  resume() {
+    this.paused = false;
+    FW.Entry.timeMgr.resumeSchedule(this);
+  }
+  /**
+   * 注册
+   * @param type
+   * @param state
+   */
+  register<T extends FWState>(state: FW.StateMachineRegisterArgs<T>) {
+    const constructor = new state.stateConstructor();
+    constructor.onInit();
+    FW.Entry.timeMgr.update(constructor.onUpdate.bind(state), this);
+    this.stateMap.set(state.stateType, constructor);
+  }
+  /**
+   * 注销
+   * @param type
+   */
+  unRegister(stateType: number) {
+    if (!this.stateMap.has(stateType)) return;
+    const constructor = this.stateMap.get(stateType);
+    constructor.onDestroy();
+    FW.Entry.timeMgr.unSchedule(this);
+    this.stateMap.delete(stateType);
+  }
+  onDestroy() {
+    this.stateMap.clear();
+    this.stateMap = null;
+  }
+}

package/machine/FWStateMachine.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "71dbc901-1182-44eb-9c23-111d7a3e2963",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/machine.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "a2c00ae3-16c2-4bd9-9cc7-e4ad4e9c0c88",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}

package/manager/FWAnimationManager.ts

@@ -0,0 +1,89 @@
+import { FWSkeleton } from '../animation/FWSkeleton';
+import { FWTween } from '../animation/FWTween';
+import { FWManager } from './FWManager';
+import { FWAnimationMachine } from '../machine/FWAnimationMachine';
+
+export default class FWAnimationManager extends FWManager {
+  private animationMachineMap: Map<string, FWAnimationMachine>;
+  public initialize(): void {
+    this.animationMachineMap = new Map<string, FWAnimationMachine>();
+
+    this.createAnimationMachine(FW.SystemDefine.FWAnimationMachineType.TWEEN);
+    this.createAnimationMachine(FW.SystemDefine.FWAnimationMachineType.SKELETON);
+    this.createAnimationMachine(FW.SystemDefine.FWAnimationMachineType.ANIMATION);
+  }
+
+  /**
+   * 创建一个tween动画
+   * @param args
+   * @returns
+   */
+  createTween(args?: FW.TweenArgs) {
+    const t = new FWTween();
+    const machine = this.animationMachineMap.get(FW.SystemDefine.FWAnimationMachineType.TWEEN);
+    t.animationName = args?.tag || '';
+    t.animation = cc.tween(args?.target);
+    t.timeScale(args?.timeScale || 1);
+    machine.addAnimation(t);
+    return t;
+  }
+
+  /**
+   * 创建一个skeleton动画
+   * @param skeleton
+   * @returns
+   */
+  createSkeleton(skeleton: sp.Skeleton) {
+    const s = new FWSkeleton();
+    const machine = this.animationMachineMap.get(FW.SystemDefine.FWAnimationMachineType.SKELETON);
+    s.animationName = skeleton.name;
+    s.animation = skeleton;
+    machine.addAnimation(s);
+    return s;
+  }
+
+  /**
+   * 暂停所有动画
+   */
+  pauseAll() {
+    this.animationMachineMap.forEach((v) => v.pause());
+  }
+
+  /** 恢复所有动画 */
+  resumeAll() {
+    this.animationMachineMap.forEach((v) => v.resume());
+  }
+
+  /**
+   * 创建动画机
+   * @param animationMachineName
+   * @returns
+   */
+  private createAnimationMachine(animationMachineName: string) {
+    if (this.animationMachineMap.has(animationMachineName)) {
+      FW.Log.warn(`已创建动画机:${animationMachineName},请勿重复注册!`);
+      return;
+    }
+    const machine = new FWAnimationMachine();
+    this.animationMachineMap.set(animationMachineName, machine);
+    return machine;
+  }
+
+  /**
+   * 移除动画机
+   * @param animationMachineName
+   * @returns
+   */
+  private removeAnimationMachine(animationMachineName: string) {
+    if (!this.animationMachineMap.has(animationMachineName)) {
+      return;
+    }
+    this.animationMachineMap.delete(animationMachineName);
+  }
+
+  onDestroy(): void {
+    this.animationMachineMap.forEach((v, k) => {
+      this.removeAnimationMachine(k);
+    });
+  }
+}

package/manager/FWAnimationManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "c2448e26-e096-4b98-83bc-f54fe3600ac8",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/manager/FWAssetManager.ts

@@ -0,0 +1,451 @@
+import { FWSystemConfig } from "../config/FWSystemConfig";
+import { FWManager } from "./FWManager";
+
+/**
+ * 资源数据
+ */
+class FWAssetData implements FW.AssetData {
+  asset: cc.Asset;
+  uuid: string;
+  user: string;
+  depend: string[];
+  reference: string[];
+  type: typeof cc.Asset;
+  dependentBundle: string;
+  loaded: boolean;
+  autoRelease: boolean;
+  assetProperty: FW.AssetProperty;
+}
+
+export class FWAssetManager extends FWManager implements FW.AssetManager {
+  assetsMap: Map<string, FWAssetData>;
+
+  constructor(protected readonly resMgr: FW.ResManager) {
+    super();
+  }
+
+  public async initialize(): Promise<void> {
+    this.assetsMap = new Map<string, FWAssetData>();
+  }
+
+  /**
+   * 从远程加载spine动画
+   * @param data
+   * @returns
+   */
+  async loadSpineDataFromRemote(data: {
+    img: string;
+    ske: string;
+    atlas: string;
+    bin?: boolean;
+  }): Promise<sp.SkeletonData> {
+    try {
+      return await this.invoke(
+        FW.Entry.promiseMgr.execute((resolve, reject, signal) => {
+          const bin = data.bin === undefined ? false : data.bin;
+          const img = data.img;
+          const ske = data.ske;
+          const atlas = data.atlas;
+          const type = bin ? ".bin" : ".txt";
+          cc.assetManager.loadAny(
+            [
+              { url: atlas, ext: type },
+              { url: ske, ext: type },
+            ],
+            async (error, assets) => {
+              if (error != null) {
+                reject(error);
+                return;
+              }
+              const fileName = FW.Entry.utils.getFileName(img);
+              const texture: cc.Texture2D = await this.loadRemote(img, {
+                ext: ".png",
+              });
+              var asset = new sp.SkeletonData();
+              asset.atlasText = assets[0];
+              asset.skeletonJson = assets[1];
+              asset.textures.push(texture);
+              asset["textureNames"] = [`${fileName}`];
+              asset["_uuid"] = ske;
+              resolve(asset);
+            },
+          );
+        }, FWSystemConfig.PromiseConfig.loadAsset).promise,
+      );
+    } catch (e) {
+      FW.Log.error("从远程加载spine动画资源失败!");
+      throw e;
+    }
+  }
+
+  /** 加载远程资源 */
+  async loadRemote<T extends cc.Asset = cc.Asset>(
+    url?: string,
+    options?: {
+      ext?: string;
+      enableCache?: boolean;
+      maxRetryCount?: number;
+      cb?: (asset: T) => void;
+    },
+  ): Promise<T> {
+    return await this.invoke(
+      FW.Entry.promiseMgr.execute((resolve, reject, signal) => {
+        cc.assetManager.loadRemote(
+          options?.enableCache === undefined || !options?.enableCache
+            ? `${url}?t=${new Date().getTime()}`
+            : `${url}`,
+          {
+            ext: options?.ext,
+            cacheEnabled: options?.enableCache || false,
+            maxRetryCount: options?.maxRetryCount || 0,
+          },
+          (err, asset) => {
+            if (err || !asset) {
+              reject(err);
+            }
+            options?.cb?.(asset as T);
+            resolve(asset as T);
+          },
+        );
+      }, FWSystemConfig.PromiseConfig.loadAsset).promise,
+      `loadAssets -> ${url}`,
+    );
+  }
+
+  async preLoad(assetProperty: FW.AssetProperty | FW.AssetProperty[]) {
+    if (!assetProperty) {
+      FW.Log.error(`加载资源失败,请检查参数列表:${assetProperty}!`);
+      return undefined;
+    }
+
+    const propertys = Array.isArray(assetProperty)
+      ? assetProperty
+      : [assetProperty];
+
+    await Promise.all(
+      propertys.map(async (property) => {
+        const bundleName = property.bundle || FW.Entry.bundleName;
+        const type = property.type;
+        const path = property.path;
+        const progress = property.progress;
+
+        if (!bundleName || bundleName === "") {
+          FW.Log.error(`找不到bundle${bundleName},或者bundle未加载!`);
+          return undefined;
+        }
+
+        if (!path || path === "") {
+          FW.Log.error(`找不到资源路径${path},请检查!`);
+          return undefined;
+        }
+
+        let bundle: cc.AssetManager.Bundle =
+          await this.resMgr.loadBundle(bundleName);
+
+        if (!bundle) {
+          FW.Log.error(`加载bundle失败,请检查!`);
+          return undefined;
+        }
+
+        return await this.invoke(
+          FW.Entry.promiseMgr.execute((resolve, reject, signal) => {
+            bundle.preload(
+              path,
+              type,
+              (
+                finish: number,
+                total: number,
+                item: cc.AssetManager.RequestItem,
+              ) => {
+                progress?.(finish, total, item);
+              },
+              (err: Error, item: cc.AssetManager.RequestItem[]) => {
+                if (err || !item || item?.length == 0) {
+                  reject(err || "preload failed!");
+                }
+                resolve(item);
+              },
+            );
+          }, FWSystemConfig.PromiseConfig.loadAsset).promise,
+          `preLoadAssets -> ${property.path}`,
+        );
+      }),
+    );
+  }
+
+  /**
+   * 加载资源
+   * @param assetProperty
+   * @returns
+   */
+  async load(assetProperty: FW.AssetProperty): Promise<FW.AssetData> {
+    if (!assetProperty) {
+      FW.Log.error(`加载资源失败,请检查参数列表:${assetProperty}!`);
+      return undefined;
+    }
+    const bundleName = assetProperty.bundle || FW.Entry.bundleName;
+    const type = assetProperty.type;
+    const path = assetProperty.path;
+    const cb = assetProperty.cb;
+    const progress = assetProperty.progress;
+    const autoRelease = assetProperty.autoRelease;
+
+    if (!bundleName || bundleName === "") {
+      FW.Log.error(`找不到bundle${bundleName},或者bundle未加载!`);
+      return undefined;
+    }
+
+    if (!path || path === "") {
+      FW.Log.error(`找不到资源路径${path},请检查!`);
+      return undefined;
+    }
+
+    let bundle: cc.AssetManager.Bundle =
+      await this.resMgr.loadBundle(bundleName);
+
+    if (!bundle) {
+      FW.Log.error(`加载bundle失败,请检查!`);
+      return undefined;
+    }
+    const key = this.createAssetMapKey(assetProperty);
+
+    if (this.assetsMap.has(key)) {
+      const assetData = this.assetsMap.get(key);
+
+      if (!assetData.loaded || !cc.isValid(assetData.asset)) {
+        this.assetsMap.delete(key);
+      } else {
+        return assetData;
+      }
+    }
+
+    const assetData = new FWAssetData();
+
+    assetData.loaded = false;
+
+    return this.invoke(
+      FW.Entry.promiseMgr.execute((resolve, reject, signal) => {
+        const self = this;
+        bundle.load(
+          path,
+          type,
+          (
+            finish: number,
+            total: number,
+            item: cc.AssetManager.RequestItem,
+          ) => {
+            progress?.(finish, total, item);
+          },
+          (err: Error, asset: cc.Asset) => {
+            if (err || !asset) {
+              reject(err);
+              return;
+            }
+            assetData.loaded = true;
+            assetData.dependentBundle = bundleName;
+            assetData.uuid = asset["_uuid"];
+            assetData.autoRelease = autoRelease;
+            assetData.asset = asset;
+            assetData.user = assetProperty.user;
+            assetData.assetProperty = assetProperty;
+
+            self.assetsMap.set(key, assetData);
+
+            cb?.(assetData);
+            resolve(assetData);
+          },
+        );
+      }, FWSystemConfig.PromiseConfig.loadAsset).promise,
+      `loadAssets -> ${assetProperty.path}`,
+    );
+  }
+  /**
+   * 加载文件夹
+   * @param assetProperty
+   * @returns
+   */
+  async loadDir(assetProperty: FW.AssetProperty): Promise<FW.AssetData[]> {
+    if (!assetProperty) {
+      FW.Log.error(`加载资源失败,请检查参数列表:${assetProperty}!`);
+      return undefined;
+    }
+    const bundleName = assetProperty.bundle || FW.Entry.bundleName;
+    const type = assetProperty.type;
+    const path = assetProperty.path;
+    const cb = assetProperty.cb;
+    const autoRelease = assetProperty.autoRelease;
+
+    if (!bundleName || bundleName === "") {
+      FW.Log.error(`找不到bundle${bundleName},或者bundle未加载!`);
+      return undefined;
+    }
+
+    if (!path || path === "") {
+      FW.Log.error(`找不到资源路径${path},请检查!`);
+      return undefined;
+    }
+
+    const bundle: cc.AssetManager.Bundle =
+      await this.resMgr.loadBundle(bundleName);
+
+    if (!bundle) {
+      FW.Log.error(`加载bundle失败,请检查!`);
+      return undefined;
+    }
+
+    return this.invoke(
+      FW.Entry.promiseMgr.execute((resolve, reject) => {
+        bundle.loadDir(path, type, (err: Error, assets: cc.Asset[]) => {
+          if (err || assets.length === 0) {
+            FW.Log.error(`加载资源失败:${path},请检查!`, err);
+            reject(err);
+            return;
+          }
+          const assetDataList = [];
+          for (const asset of assets) {
+            const assetData = new FWAssetData();
+            assetData.loaded = true;
+            assetData.dependentBundle = bundleName;
+            assetData.uuid = asset["_uuid"];
+            assetData.autoRelease = autoRelease;
+            assetData.asset = asset;
+            assetData.type = type;
+            assetData.assetProperty = assetProperty;
+
+            const key = `${this.createAssetMapKey({
+              bundle: bundleName,
+              path: path,
+            })}/${asset.name}${type ? `_${type?.name}` : ""}`;
+
+            this.assetsMap.set(key, assetData);
+            assetDataList.push(assetData);
+          }
+          cb?.(assetDataList);
+          resolve(assetDataList);
+        });
+      }, FWSystemConfig.PromiseConfig.loadAsset).promise,
+      `loadDir -> ${path}`,
+    );
+  }
+
+  /**
+   * 获取资源
+   * @param assetProperty
+   * @returns
+   */
+  get(assetProperty: FW.AssetProperty): FW.AssetData {
+    if (!assetProperty) {
+      FW.Log.error(`加载资源失败,请检查参数列表:${assetProperty}!`);
+      return undefined;
+    }
+    const bundleName = assetProperty.bundle || FW.Entry.bundleName;
+    const path = assetProperty.path;
+
+    if (!bundleName || bundleName === "") {
+      FW.Log.error(`找不到bundle${bundleName},或者bundle未加载!`);
+      return undefined;
+    }
+
+    if (!path || path === "") {
+      FW.Log.error(`找不到资源路径${path},请检查!`);
+      return undefined;
+    }
+
+    if (!this.has(assetProperty)) {
+      FW.Log.error("获取资源失败,请先加载!", assetProperty);
+      return undefined;
+    }
+
+    const key = this.createAssetMapKey(assetProperty);
+    const assetsData = this.assetsMap.get(key);
+    return assetsData;
+  }
+
+  /**
+   * 释放资源
+   * @param assetProperty
+   * @returns
+   */
+  release(assetProperty: FW.AssetProperty): void {
+    if (!assetProperty) {
+      FW.Log.error(`加载资源失败,请检查参数列表:${assetProperty}!`);
+      return undefined;
+    }
+    const bundleName = assetProperty.bundle || FW.Entry.bundleName;
+    const path = assetProperty.path;
+    const autoRelease = assetProperty.autoRelease;
+
+    if (!bundleName || bundleName === "") {
+      FW.Log.error(`找不到bundle${bundleName},或者bundle未加载!`);
+      return undefined;
+    }
+
+    if (!path || path === "") {
+      FW.Log.error(`找不到资源路径${path},请检查!`);
+      return undefined;
+    }
+
+    if (!this.has(assetProperty)) {
+      return undefined;
+    }
+
+    const key = this.createAssetMapKey(assetProperty);
+    const assetData = this.assetsMap.get(key);
+
+    if (!assetData || !assetData.asset) {
+      this.assetsMap.delete(key);
+      return;
+    }
+
+    if (assetData.asset.refCount <= 0 && autoRelease) {
+      this.resMgr.getBundle(bundleName)?.release(path);
+      this.assetsMap.delete(key);
+    }
+  }
+
+  /**
+   * 获取资源引用计数
+   * @param assetProperty
+   * @returns
+   */
+  public getReferenceCount(assetProperty: FW.AssetProperty): number {
+    const key = this.createAssetMapKey(assetProperty);
+    return this.assetsMap.get(key)?.asset?.refCount || 0;
+  }
+
+  /**
+   * 资源是否存在
+   * @param uid
+   * @returns
+   */
+  has(assetProperty: FW.AssetProperty) {
+    if (!assetProperty) {
+      FW.Log.error(`判断资源是否存在失败,请检查参数列表:${assetProperty}!`);
+      return;
+    }
+
+    return this.assetsMap.has(this.createAssetMapKey(assetProperty));
+  }
+
+  private createAssetMapKey(assetProperty: FW.AssetProperty) {
+    const bundleName = assetProperty.bundle || FW.Entry.bundleName;
+    const path = assetProperty.path;
+    const type = assetProperty.type;
+
+    let typeKey: string | undefined;
+    if (typeof type === "string") {
+      typeKey = type;
+    } else if (type) {
+      typeKey = (type as any).name;
+    }
+
+    if (!typeKey) {
+      return `${bundleName}_${path}`;
+    }
+    return `${bundleName}_${path}_${typeKey}`;
+  }
+
+  public onDestroy(): void {
+    this.assetsMap.clear();
+  }
+}

package/manager/FWAssetManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "eb4a5a74-0281-4aba-af9b-ae616f1d94f2",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}