@kkarum/framework 2.3.17

package/manager/FWTimeManager.ts

@@ -0,0 +1,442 @@
+import { FWManager } from './FWManager';
+
+class FWTimer implements FW.Timer {
+  constructor() {
+    this.executeTime = 0;
+    this.id = 0;
+    this.repeat = 0;
+    this.pause = false;
+  }
+  pause: boolean;
+  resolve: Function;
+  executeTime: number;
+  id: number;
+  repeat: number;
+  target: FW.TargetType;
+  tag?: string;
+  internal?: number;
+  cb?: (dt?: number) => void;
+}
+
+/**
+ * 时间管理器
+ */
+export class FWTimeManager extends FWManager implements FW.TimeManager {
+  /**
+   * 时间对象合集
+   */
+  private timerMap: Map<number, FWTimer>;
+  /**
+   * 唯一id
+   */
+  private uniqueId: number;
+  /**
+   * 帧时间
+   */
+  dt: number;
+  /**
+   * 当前游戏总时间
+   */
+  gameTotalDuration: number;
+
+  public initialize(): void {
+    this.timerMap = new Map<number, FWTimer>();
+    this.gameTotalDuration = 0;
+    this.dt = 0;
+    this.uniqueId = 0;
+  }
+
+  public getTime(): string {
+    const date = new Date();
+    const year = date.getFullYear();
+    const month = date.getMonth() + 1;
+    const day = date.getDate();
+    const hours = date.getHours();
+    const minutes = date.getMinutes();
+    const seconds = date.getSeconds();
+    const milliseconds = date.getMilliseconds();
+    return `${year}年${month}月${day}日:${hours}:${minutes}:${seconds}.${milliseconds}`;
+  }
+
+  /**
+   * 调度器
+   * @param cb
+   * @param target
+   */
+
+  schedule(
+    cb: () => void,
+    time?: number,
+    repeat?: number,
+    target?: FW.TargetType,
+    tag?: string,
+  ): FW.TimerSchedule {
+    const timer = new FWTimer();
+
+    timer.internal = time || 0;
+    timer.repeat = repeat || 0;
+    timer.tag = tag || '';
+    timer.target = target || FW.Entry.scene;
+    timer.cb = cb;
+    timer.id = this.uniqueId++;
+    timer.pause = false;
+
+    this.timerMap.set(timer.id, timer);
+
+    return <FW.TimerSchedule>{
+      timer: timer,
+      unSchedule: () => this.unSchedule.bind(this)(timer.id),
+      pauseSchedule: () => this.pauseSchedule.bind(this)(timer.id),
+      resumeSchedule: () => this.resumeSchedule.bind(this)(timer.id),
+    };
+  }
+  /**
+   * 一次性调度器
+   * @param cb
+   * @returns
+   */
+  /**
+   * 一次性调度器
+   */
+  scheduleOnce(cb?: () => void, tag?: string): FW.TimerSchedule;
+  /**
+   * 一次性调度器
+   */
+  scheduleOnce(time?: number, tag?: string): FW.TimerSchedule;
+  /**
+   * 一次性调度器
+   */
+  scheduleOnce(cb?: () => void, target?: any): FW.TimerSchedule;
+  /**
+   * 一次性调度器
+   */
+  scheduleOnce(time?: number, target?: any): FW.TimerSchedule;
+  /**
+   * 一次性调度器
+   */
+  scheduleOnce(cb?: () => void, time?: number, tag?: string): FW.TimerSchedule;
+  /**
+   * 一次性调度器
+   */
+  scheduleOnce(time?: number, cb?: () => void, tag?: string): FW.TimerSchedule;
+  /**
+   * 一次性调度器
+   */
+  scheduleOnce(time?: number, cb?: () => void, target?: any): FW.TimerSchedule;
+  /**
+   * 一次性调度器
+   */
+  scheduleOnce(cb?: () => void, time?: number, target?: any): FW.TimerSchedule;
+  scheduleOnce(): FW.TimerSchedule {
+    let time: number;
+    let cb: () => void;
+    let tag: string;
+    let target: any;
+
+    for (const arg of arguments) {
+      if (typeof arg === 'function') {
+        cb = arg;
+      } else if (typeof arg === 'number') {
+        time = arg;
+      } else if (typeof arg === 'string') {
+        tag = arg;
+      } else if (arg) {
+        target = arg;
+      }
+    }
+
+    const timer = new FWTimer();
+    timer.id = this.uniqueId++;
+    timer.pause = false;
+    timer.cb = cb;
+    timer.repeat = 0;
+    timer.internal = time || 0;
+    timer.target = target || FW.Entry.scene;
+    timer.tag = tag;
+
+    const promise = new Promise<void>((resolve) => {
+      timer.resolve = resolve;
+    });
+
+    this.timerMap.set(timer.id, timer);
+
+    return <FW.TimerSchedule>{
+      timer: timer,
+      promise: promise,
+      unSchedule: () => this.unSchedule.bind(this)(timer.id),
+      pauseSchedule: () => this.pauseSchedule.bind(this)(timer.id),
+      resumeSchedule: () => this.resumeSchedule.bind(this)(timer.id),
+    };
+  }
+
+  /**
+   * 停止调度器
+   * @param tag
+   */
+  unSchedule(tag: string);
+  /**
+   * 停止调度器
+   * @param target: Comment | Object | cc.Node
+   */
+  unSchedule(target: Comment | Object | cc.Node);
+  /**
+   * 停止调度器
+   * @param id: number
+   */
+  unSchedule(id: number);
+  /**
+   * 停止调度器
+   * @returns
+   */
+  unSchedule() {
+    const args = arguments;
+    if (!args || args?.length == 0) return;
+
+    if (typeof args[0] == 'string') {
+      this.removeTimerFromTag(args[0]);
+    } else if (typeof args[0] == 'number') {
+      this.removeTimerFromId(args[0]);
+    } else {
+      this.removeTimerFromTarget(args[0]);
+    }
+  }
+
+  /**
+   * 暂停调度器
+   * @param tag
+   */
+  pauseSchedule(tag: string);
+  /**
+   * 暂停调度器
+   * @param target
+   */
+  pauseSchedule(target: FW.TargetType);
+  /**
+   * 暂停调度器
+   * @param id
+   */
+  pauseSchedule(id: number);
+  /**
+   * 暂停调度器
+   * @returns
+   */
+  pauseSchedule() {
+    const args = arguments;
+    if (!args || args?.length == 0) return;
+    if (typeof args[0] == 'string') {
+      this.pauseTimerFromTag(args[0], true);
+    } else if (typeof args[0] == 'number') {
+      this.pauseTimerFromId(args[0], true);
+    } else {
+      this.pauseTimerFromTarget(args[0], true);
+    }
+  }
+
+  /**
+   * 恢复调度器
+   * @param tag
+   */
+  resumeSchedule(tag: string);
+  /**
+   * 恢复调度器
+   * @param target
+   */
+  resumeSchedule(target: FW.TargetType);
+  /**
+   * 暂停调度器
+   * @param id
+   */
+  resumeSchedule(id: number);
+  /**
+   * 恢复调度器
+   */
+  resumeSchedule() {
+    const args = arguments;
+    if (!args || args?.length == 0) return;
+    if (typeof args[0] == 'string') {
+      this.pauseTimerFromTag(args[0], false);
+    } else if (typeof args[0] == 'number') {
+      this.pauseTimerFromId(args[0], false);
+    } else {
+      this.pauseTimerFromTarget(args[0], false);
+    }
+  }
+
+  /**
+   * 每一帧更新
+   * @param cb
+   * @param tag
+   */
+  update(cb: (dt: number) => void, tag?: string): void;
+  /**
+   * 每一帧更新
+   * @param cb
+   * @param target
+   */
+  update(cb: (dt: number) => void, target?: FW.TargetType): void;
+  /**
+   * 每一帧更新
+   * @param cb
+   * @param tag
+   * @param target
+   */
+  update(cb: (dt: number) => void, tag?: string, target?: FW.TargetType): void;
+  /**
+   * 每一帧更新
+   */
+  update() {
+    const args = arguments;
+
+    if (args?.length == 0) return;
+
+    const timer = new FWTimer();
+
+    const cb = args[0];
+
+    var target: FW.TargetType;
+    var tag: string;
+    if (args.length == 2) {
+      if (typeof args[1] == 'string') {
+        tag = args[1];
+      } else {
+        target = args[1];
+      }
+    } else if (args.length == 3) {
+      tag = args[1];
+      target = args[2];
+    }
+
+    timer.id = this.uniqueId++;
+    timer.cb = cb;
+    timer.executeTime = 0;
+    timer.internal = 0;
+    timer.tag = tag || '';
+    timer.target = target || undefined;
+    timer.pause = false;
+    timer.repeat = cc.macro.REPEAT_FOREVER;
+
+    this.timerMap.set(timer.id, timer);
+  }
+
+  /** 每一帧更新 */
+  onUpdate(dt: number) {
+    this.dt = dt;
+    this.gameTotalDuration += dt;
+    this.timerMap?.forEach((v, k) => {
+      if (v.pause) {
+        return;
+      }
+
+      if (v.executeTime > v.internal) {
+        v.executeTime = 0;
+        v.cb?.call(v.target, dt);
+        v.resolve?.();
+
+        if (v.repeat > 0) {
+          v.repeat--;
+          if (v.repeat < 0) {
+            this.removeTimerFromId(v.id);
+          }
+        } else {
+          this.removeTimerFromId(v.id);
+        }
+      }
+      if (this.timerMap.has(v.id)) {
+        v.executeTime += dt;
+      }
+    });
+  }
+
+  /**
+   * 销毁
+   */
+  onDestroy() {
+    this.timerMap.forEach((v, k) => {
+      this.unSchedule(v.id);
+      this.removeTimerFromId(v.id);
+    });
+    this.timerMap = new Map<number, FWTimer>();
+    this.gameTotalDuration = 0;
+    this.dt = 0;
+    this.uniqueId = 0;
+  }
+
+  /**
+   * 通过id移除调度器
+   * @param id
+   * @returns
+   */
+  private removeTimerFromId(id: number) {
+    if (!this.timerMap.has(id)) return;
+    this.timerMap.delete(id);
+  }
+
+  /**
+   * 通过tag移除调度器
+   * @param id
+   * @returns
+   */
+  private removeTimerFromTag(tag: string) {
+    this.timerMap.forEach((v) => {
+      if (v.tag == tag) {
+        this.removeTimerFromId(v.id);
+      }
+    });
+  }
+
+  /**
+   * 通过target移除调度器
+   * @param id
+   * @returns
+   */
+
+  private removeTimerFromTarget(target: FW.TargetType) {
+    this.timerMap.forEach((v) => {
+      if (v.target == target) {
+        this.removeTimerFromId(v.id);
+      }
+    });
+  }
+
+  /**
+   * 通过id暂停调度器
+   * @param id
+   * @returns
+   */
+
+  private pauseTimerFromId(id: number, pause: boolean) {
+    if (!this.timerMap.has(id)) return;
+    this.timerMap.get(id).pause = pause;
+  }
+
+  /**
+   * 通过tag暂停调度器
+   * @param id
+   * @returns
+   */
+
+  private pauseTimerFromTag(tag: string, pause: boolean) {
+    this.timerMap.forEach((v) => {
+      if (v.tag == tag) {
+        this.pauseTimerFromId(v.id, pause);
+      }
+    });
+  }
+
+  /**
+   * 通过target暂停调度器
+   * @param id
+   * @returns
+   */
+
+  private pauseTimerFromTarget(target: FW.TargetType, pause: boolean) {
+    this.timerMap.forEach((v) => {
+      if (
+        v.target == target ||
+        (v.target?.uuid && target?.uuid && v.target?.uuid == target?.uuid)
+      ) {
+        this.pauseTimerFromId(v.id, pause);
+      }
+    });
+  }
+}

package/manager/FWTimeManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "ef42e04a-1f21-4d92-ac3c-916af646e1f8",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/manager/FWUiManager.ts

@@ -0,0 +1,217 @@
+import { searchChild } from "../expand/FWDecorator";
+import { FWManager } from "./FWManager";
+
+export default class FWUiManager extends FWManager implements FW.UiManager {
+  private eventMap: Map<
+    number,
+    {
+      uniqueId: number;
+      target: FW.TargetType;
+      event: FW.CCEvent | FW.FWEvent;
+    }
+  > = new Map();
+  private uniqueId: number = 0;
+  public initialize(): void {}
+  public onDestroy(): void {}
+
+  /** 暂停事件 */
+  pauseEvent(target: FW.TargetType) {
+    if (target instanceof cc.Component) {
+      target.node.pauseSystemEvents(true);
+    } else if (target instanceof cc.Node) {
+      target.pauseSystemEvents(true);
+    }
+
+    this.eventMap.forEach((evt) => {
+      if (evt.target === target) {
+        FW.Entry.evtMgr?.targetPause(evt.target);
+      }
+    });
+  }
+
+  resumeEvent(target: FW.TargetType) {
+    if (target instanceof cc.Component) {
+      target.node.resumeSystemEvents(true);
+    } else if (target instanceof cc.Node) {
+      target.resumeSystemEvents(true);
+    }
+
+    this.eventMap.forEach((evt) => {
+      if (evt.target === target) {
+        FW.Entry.evtMgr?.targetResume(evt.target);
+      }
+    });
+  }
+
+  unRegisterEvent(args: FW.RegisterArgs) {
+    this.eventMap.forEach((evt) => {
+      if (args.target === evt.target) {
+        if (this.eventMap.has(evt.uniqueId)) {
+          this.eventMap.delete(evt.uniqueId);
+          FW.Entry.evtMgr.unRegister(evt.event.eventName, evt.target);
+        }
+      }
+    });
+  }
+
+  unRegisterAll() {
+    this.eventMap.forEach((evt) => this.unRegisterTarget(evt.target));
+    this.eventMap.clear();
+  }
+
+  unRegisterTarget(target: FW.TargetType) {
+    this.eventMap.forEach((evt) => {
+      if (evt.target == target) {
+        FW.Entry.evtMgr?.targetOff(evt.target);
+        this.eventMap.delete(evt.uniqueId);
+      }
+    });
+  }
+
+  hasRegister(eventName: string, target: FW.TargetType): boolean {
+    let has = false;
+    this.eventMap.forEach((v, key) => {
+      if (v.target == target && v.event.eventName == eventName) has = true;
+    });
+    return has;
+  }
+
+  find(path: string, rootNode: cc.Node): cc.Node | null {
+    if (!cc.isValid(rootNode)) {
+      FW.Log.error(`查找节点失败: ${path}, 根节点无效`);
+      return null;
+    }
+
+    const node = searchChild(rootNode, path);
+
+    if (!cc.isValid(node)) {
+      FW.Log.warn(`未找到节点: ${path}`);
+      return null;
+    }
+
+    return node;
+  }
+
+  buttonEnable(target: FW.TargetType) {
+    this.eventMap.forEach((v) => {
+      const node = v.target as cc.Node;
+      if (node == target) {
+        node.resumeSystemEvents(true);
+        if (node.getComponent(cc.Button)) {
+          node.getComponent(cc.Button).enableAutoGrayEffect = true;
+          node.getComponent(cc.Button).interactable = true;
+        }
+      }
+    });
+  }
+
+  buttonDisable(target: FW.TargetType) {
+    this.eventMap.forEach((v) => {
+      const node = v.target as cc.Node;
+      if (node == target) {
+        node.pauseSystemEvents(true);
+        if (node.getComponent(cc.Button)) {
+          node.getComponent(cc.Button).enableAutoGrayEffect = true;
+          node.getComponent(cc.Button).interactable = false;
+        }
+      }
+    });
+  }
+
+  register(args: FW.RegisterArgs) {
+    if (!args.target) {
+      FW.Log.error("注册事件失败,目标为空!");
+      return;
+    }
+
+    this.uniqueId++;
+
+    if (args.CCEvent) {
+      args.CCEvent.forEach((evt) => {
+        if (evt.target instanceof cc.Node && cc.isValid(evt.target)) {
+          evt.target.on(
+            evt.eventName || cc.Node.EventType.TOUCH_END,
+            (e: cc.Event.EventTouch, c?: string) => {
+              if (evt.enable === undefined) {
+                evt.enable = true;
+              }
+
+              if (!evt.enable) return;
+
+              if (
+                Date.now() - evt.lastResponseTimestamp <
+                evt.responseInterval
+              ) {
+                return;
+              }
+
+              const button = evt.target.getComponent(cc.Button);
+              if (button && !button.interactable) return;
+
+              evt.lastResponseTimestamp = Date.now();
+
+              FW.Entry.evtMgr.dispatch(
+                FW.EventDefine.SystemEvent.SYSTEM_EVENT_TIRGGER,
+                evt.target,
+              );
+
+              evt.cb?.bind(args.target)?.(e, c, evt.data);
+            },
+            args.target,
+          );
+          this.eventMap.set(this.uniqueId, {
+            uniqueId: this.uniqueId,
+            target: args.target,
+            event: evt,
+          });
+        }
+      });
+    }
+    if (args.FWEvent) {
+      args.FWEvent.forEach((evt) => {
+        FW.Entry.evtMgr?.register(
+          evt.eventName,
+          (
+            args1?: FW.EventManagerArgs,
+            args2?: FW.EventManagerArgs,
+            args3?: FW.EventManagerArgs,
+            args4?: FW.EventManagerArgs,
+            args5?: FW.EventManagerArgs,
+            args6?: FW.EventManagerArgs,
+            args7?: FW.EventManagerArgs,
+            args8?: FW.EventManagerArgs,
+            args9?: FW.EventManagerArgs,
+            args10?: FW.EventManagerArgs,
+          ) => {
+            if (
+              Date.now() - evt.lastResponseTimestamp <
+              (evt.responseInterval || 0)
+            ) {
+              return;
+            }
+            evt.lastResponseTimestamp = Date.now();
+            evt.cb?.bind(args.target)(
+              args1,
+              args2,
+              args3,
+              args4,
+              args5,
+              args6,
+              args7,
+              args8,
+              args9,
+              args10,
+            );
+          },
+          args.target,
+        );
+
+        this.eventMap.set(this.uniqueId, {
+          uniqueId: this.uniqueId,
+          target: args.target,
+          event: evt,
+        });
+      });
+    }
+  }
+}

package/manager/FWUiManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "d33acc3d-71a7-4fe4-86fb-a939985a4d1f",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/manager.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "d591f127-6089-4134-a3fd-24c263480211",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@kkarum/framework",
+  "version": "2.3.17",
+  "description": "cocoscreator 2.x mvc framework",
+  "main": "index.js",
+  "keywords": [
+    "123456"
+  ],
+  "author": "kkarum",
+  "license": "ISC"
+}

package/package.json.meta

@@ -0,0 +1,6 @@
+{
+  "ver": "1.0.2",
+  "uuid": "beb7dd18-de47-4e37-8a42-7798786baba5",
+  "importer": "json",
+  "subMetas": {}
+}