@ives_xxz/framework 1.0.0

package/manager/FWTimeManager.ts

@@ -0,0 +1,473 @@
+import FWLog from '../log/FWLog';
+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?: Comment | Object | cc.Node,
+    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;
+    if (arguments.length == 1) {
+      if (typeof arguments[0] === 'number') time = arguments[0];
+      else if (typeof arguments[0] === 'function') cb = arguments[0];
+    } else if (arguments.length == 2) {
+      if (typeof arguments[0] === 'number') {
+        time = arguments[0];
+        if (typeof arguments[1] === 'string') {
+          tag = arguments[1];
+        } else if (typeof arguments[1] === 'object') {
+          cb = arguments[1];
+        } else {
+          target = arguments[1];
+        }
+      } else if (typeof arguments[0] === 'function') {
+        cb = arguments[0];
+        if (typeof arguments[1] === 'string') {
+          tag = arguments[1];
+        } else if (typeof arguments[1] === 'number') {
+          time = arguments[1];
+        } else {
+          target = arguments[1];
+        }
+      }
+    } else if (arguments.length == 3) {
+      if (typeof arguments[0] === 'number') {
+        time = arguments[0];
+        cb = arguments[1];
+        if (typeof arguments[2] === 'string') {
+          tag = arguments[2];
+        } else {
+          target = arguments[2];
+        }
+      } else if (typeof arguments[0] === 'function') {
+        cb = arguments[0];
+        time = arguments[1];
+        if (typeof arguments[2] === 'string') {
+          tag = arguments[2];
+        } else {
+          target = arguments[2];
+        }
+      }
+    }
+
+    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?.(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,164 @@
+import FWLog from '../log/FWLog';
+import { FWManager } from './FWManager';
+
+export default class FWUiManager extends FWManager implements FW.UiManager {
+  /** 默认点击时间间隔 */
+  private eventMap: Map<string, FW.CCEvent | FW.FWEvent> = new Map<
+    string,
+    FW.CCEvent | FW.FWEvent
+  >();
+  public initialize(): void {}
+  public onDestroy(): void {}
+  registerButtonEvent(args: FW.RegisterEventArgs | FW.RegisterEventArgs[]) {
+    const register: (eventArgs: FW.RegisterEventArgs) => void = (
+      eventArgs: FW.RegisterEventArgs,
+    ) => {
+      if (eventArgs?.CCEvent?.target instanceof cc.Node) {
+        if (cc.isValid(eventArgs.CCEvent.target)) {
+          eventArgs.CCEvent.target.on(
+            eventArgs.eventName || cc.Node.EventType.TOUCH_END,
+            (evt: cc.Event.EventTouch, custom?: string) => {
+              /** 未设置禁用默认为启用状态 */
+              if (eventArgs.enable === undefined) {
+                eventArgs.enable = true;
+              }
+
+              if (!eventArgs.enable) return;
+
+              /** 检测触发间隔 */
+              if (Date.now() - eventArgs.lastResponseTimestamp < eventArgs.responseInterval) {
+                return;
+              }
+
+              const button = (eventArgs.CCEvent.target as cc.Node).getComponent(cc.Button);
+              if (button && !button.interactable) return;
+
+              eventArgs.lastResponseTimestamp = Date.now();
+              eventArgs.CCEvent.cb?.bind(eventArgs.target)?.(evt, custom, eventArgs.data);
+            },
+            eventArgs.CCEvent.target,
+          );
+          this.eventMap.set(
+            `${eventArgs.eventName}_${eventArgs.CCEvent.target.name}`,
+            eventArgs.CCEvent,
+          );
+        } else {
+          FWLog.warn(`register CCEvent is not cc.Node:${eventArgs.CCEvent.target}`);
+          return;
+        }
+      }
+
+      if (eventArgs.FWEvent) {
+        FW.Entry.evtMgr?.register(
+          eventArgs.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() - eventArgs.lastResponseTimestamp < (eventArgs.responseInterval || 0)) {
+              return;
+            }
+            eventArgs.lastResponseTimestamp = Date.now();
+            eventArgs.FWEvent.cb?.bind(eventArgs.FWEvent.target)(
+              args1,
+              args2,
+              args3,
+              args4,
+              args5,
+              args6,
+              args7,
+              args8,
+              args9,
+              args10,
+            );
+          },
+          eventArgs.FWEvent.target,
+        );
+        this.eventMap.set(eventArgs.eventName, eventArgs.FWEvent);
+      }
+    };
+
+    if (Array.isArray(args)) {
+      args.forEach((v) => register(v));
+    } else {
+      register(args);
+    }
+  }
+
+  /** 暂停事件 */
+  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((v) => FW.Entry.evtMgr?.targetPause(v));
+  }
+
+  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((v) => FW.Entry.evtMgr?.targetResume(v));
+  }
+
+  unRegisterEvent(args: FW.RegisterEventArgs) {
+    if (this.eventMap.has(args.eventName)) return;
+    this.eventMap.delete(args.eventName);
+  }
+
+  unRegisterAll() {
+    this.eventMap.clear();
+  }
+
+  unRegisterTarget(target: FW.TargetType) {
+    this.eventMap.forEach((v) => {
+      if (v.target == target) FW.Entry.evtMgr?.targetOff(v.target);
+    });
+  }
+
+  hasRegister(eventName: string, target: FW.TargetType): boolean {
+    let has = false;
+    this.eventMap.forEach((v, key) => {
+      if (v.target == target && key == eventName) has = true;
+    });
+    return has;
+  }
+
+  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;
+        }
+      }
+    });
+  }
+}

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,17 @@
+{
+  "name": "@ives_xxz/framework",
+  "version": "1.0.0",
+  "description": "cocoscreator 2.x mvc framework",
+  "main": "index.js",
+  "config": {
+    "node_modules": "./node_modules" 
+  },
+  "keywords": [
+    "123456"
+  ],
+  "author": "ives",
+  "license": "ISC",
+  "files": [
+    "*"
+  ]
+}

package/package.json.meta

@@ -0,0 +1,6 @@
+{
+  "ver": "1.0.2",
+  "uuid": "819701b1-36a1-4772-b24e-e2b54759ab35",
+  "importer": "json",
+  "subMetas": {}
+}