@ives_xxz/framework 1.0.0

package/scene/FWScene.ts

@@ -0,0 +1,25 @@
+import { FWSocketAutoProcessResume } from '../expand/FWDecorator';
+
+const { ccclass, property } = cc._decorator;
+
+@ccclass
+export default abstract class FWScene extends cc.Component {
+  readonly entry: FW.Entry = FW.Entry;
+
+  @FWSocketAutoProcessResume()
+  protected onLoad(): void {
+    this.entry.scene = this;
+  }
+
+  protected update(dt: number): void {
+    this.entry?.update?.(dt);
+  }
+
+  protected onDestroy(): void {
+    this.entry?.evtMgr.targetOff(this);
+    this.entry?.timeMgr.unSchedule(this);
+    this.entry?.uiMgr.unRegisterTarget(this);
+    this?.unscheduleAllCallbacks?.();
+    this?.node?.stopAllActions?.();
+  }
+}

package/scene/FWScene.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "9d78ed88-e34f-455b-9d0f-73978b74107a",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/scene.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "f8d1e84d-5adb-468b-9dcf-c84901b90bce",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}

package/service/FWService.ts

@@ -0,0 +1,7 @@
+export default abstract class FWService {
+  constructor() {
+    this.initialize();
+  }
+  public abstract initialize(): void;
+  public abstract destroy(): void;
+}

package/service/FWService.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "02e35f42-98e4-45c5-8139-e90f226d3782",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/service/http/FWHttp.ts

@@ -0,0 +1,70 @@
+import { FWSystemDefine } from "../../define/FWSystemDefine";
+import FWLog from "../../log/FWLog";
+import FWService from "../FWService";
+
+export default class FWHttp extends FWService {
+  public initialize(): void {}
+  public destroy(): void {}
+
+  protected async getMessage(
+    url: string,
+    params?: string,
+    cb?: (response: string) => void
+  ): Promise<string> {
+    return this.dataProcessing(
+      url,
+      params,
+      cb,
+      FWSystemDefine.FWHttpRequestType.GET
+    );
+  }
+
+  protected async postMessage(
+    url: string,
+    params?: string,
+    cb?: (response: string) => void
+  ): Promise<string> {
+    return this.dataProcessing(
+      url,
+      params,
+      cb,
+      FWSystemDefine.FWHttpRequestType.POST
+    );
+  }
+
+  private dataProcessing(
+    url: string,
+    params: string,
+    cb: (response: any) => void,
+    type: FWSystemDefine.FWHttpRequestType
+  ): Promise<string> {
+    return new Promise(
+      (resolve: (msg: string) => void, reject: (error: string) => void) => {
+        const xhr = new XMLHttpRequest();
+        xhr.onreadystatechange = () => {
+          if (xhr.readyState == 4 && xhr.status === 200) {
+            cb?.(xhr.response);
+            resolve(xhr.response);
+          }
+        };
+
+        xhr.onerror = (err: any) => {
+          FWLog.error(err);
+          this.onError(err);
+          reject(`http request error:${err}`);
+        };
+
+        xhr.ontimeout = () => {
+          this.onTimeout();
+          reject(`http request timeout!`);
+        };
+
+        xhr.open(type, url, true);
+        xhr.send(params);
+      }
+    );
+  }
+
+  onError(err: any) {}
+  onTimeout() {}
+}

package/service/http/FWHttp.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "f0ad42b9-3784-4643-9175-bffd9d96570a",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/service/http.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "8af24859-b6c3-4ead-8cf8-386570d860a8",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}

package/service/socket/FWSocket.ts

@@ -0,0 +1,236 @@
+import Framework from '../../Framework';
+import FWLog from '../../log/FWLog';
+import FWSocketHandle from './FWSocketHandle';
+import FWSocketSender from './FWSocketSender';
+
+/**
+ * TODO 犹豫socket没有改版暂时已老的cmd字符串映射方式做,后期优化
+ */
+export default class FWSocket implements FW.Socket {
+  /** 发送心跳时间抽 */
+  private sendHeartTimestamp: number;
+  /** 接收心跳时间戳 */
+  private receiveTimeStamp: number;
+  /** socket */
+  socket: WebSocket = null;
+  /** 消息发送者 */
+  protected sender: FWSocketSender;
+  /** 消息处理者 */
+  protected handle: FWSocketHandle;
+  /** 重连次数 */
+  protected reconnectTimes: number;
+  /** 心跳间隔时间 */
+  protected heartInternal: number;
+  /** 心跳超时时间 */
+  protected heartTimeout: number;
+  /** 心跳弱网时间 */
+  protected heartWeakTime: number;
+  /** 最大重连次数 */
+  protected maxReconnectTimes: number;
+  /** 重连间隔 */
+  protected reconnectInternal: number;
+  /** 地址 */
+  protected address: string;
+  /** 标签 */
+  protected tag: string;
+  /** 是否暂停消息处理 */
+  protected isPausedMessageHandle: boolean = false;
+  /** 是否正在重连 */
+  private isReconnect: boolean = false;
+
+  private promiseProxy: FW.SocketPromiseProxy;
+  /**
+   *  消息事件列表
+   * TODO 目前没有消息协议号,暂时无用
+   */
+  protected messageEvents: { [key: string]: (msg: any) => void };
+
+  constructor() {
+    this.initialize();
+  }
+
+  public initialize(): void {
+    this.messageEvents = cc.js.createMap();
+  }
+
+  createSocket(
+    address: string,
+    tag: string,
+    sender: FWSocketSender,
+    handle: FWSocketHandle,
+    config: {
+      heartInternal: number;
+      heartTimeout: number;
+      heartWeakTime: number;
+      maxReconnectTimes: number;
+      reconnectInternal: number;
+    },
+  ): FW.SocketPromiseProxy {
+    FW.Entry.timeMgr.unSchedule(this);
+    this.tag = tag;
+    this.address = address;
+    this.socket = new WebSocket(address);
+    this.socket.onopen = this.onSocketOpen.bind(this);
+    this.socket.onclose = this.onSocketClose.bind(this);
+    this.socket.onerror = this.onSocketError.bind(this);
+    this.socket.onmessage = this.onSocketMessage.bind(this);
+
+    this.sender = sender;
+    this.handle = handle;
+
+    this.heartInternal = config?.heartInternal;
+    this.heartTimeout = config?.heartTimeout;
+    this.heartWeakTime = config?.heartWeakTime;
+    this.maxReconnectTimes = config?.maxReconnectTimes;
+
+    this.promiseProxy = {
+      promise: undefined,
+      socket: this,
+    };
+    new Promise<FWSocket>((resolve) => {
+      this.promiseProxy.promise = resolve;
+    });
+    return this.promiseProxy;
+  }
+  /**
+   * 注册消息事件
+   * @param msgId
+   * @param cb
+   */
+  registerMessage(msgId: string, cb: (msg: any) => void) {
+    this.messageEvents[msgId] = cb;
+  }
+
+  public onDestroy(): void {
+    this.messageEvents = cc.js.createMap();
+    this.socket = null;
+  }
+
+  public getTag() {
+    return this.tag;
+  }
+
+  /**
+   * 获取地址
+   * @returns
+   */
+  public getAddress() {
+    return this.address;
+  }
+
+  /**
+   * 获取socket状态
+   * @returns
+   */
+  public getReadyState() {
+    return this.socket.readyState;
+  }
+  /**
+   * 关闭连接
+   */
+  public close() {
+    FW.Entry.socketMgr.closeSocket(this);
+  }
+
+  public pauseMessageHandle() {
+    this.isPausedMessageHandle = true;
+  }
+
+  public resumeMessageHandle() {
+    this.isPausedMessageHandle = false;
+  }
+
+  private reconnect() {
+    FWLog.debug(
+      `socket reconnect : reconnectTimes->${this.reconnectTimes},maxReconnectTimes->${this.maxReconnectTimes}`,
+    );
+    if (++this.reconnectTimes >= this.maxReconnectTimes) {
+      this.handle?.onTimeout?.();
+      return;
+    }
+    FW.Entry.timeMgr.unSchedule(this);
+    this.isReconnect = true;
+    this.sendHeartTimestamp = 0;
+    this.receiveTimeStamp = 0;
+    this.socket.close();
+    this.socket = null;
+
+    this.createSocket(this.address, this.tag, this.sender, this.handle, {
+      heartInternal: this.heartInternal,
+      heartTimeout: this.heartTimeout,
+      heartWeakTime: this.heartWeakTime,
+      maxReconnectTimes: this.maxReconnectTimes,
+      reconnectInternal: this.reconnectInternal,
+    });
+  }
+
+  /** 连接打开 */
+  private onSocketOpen() {
+    FWLog.debug('on open!');
+    FW.Entry.timeMgr.unSchedule(this);
+    this.reconnectTimes = 0;
+    this.sendHeartTimestamp = 0;
+    this.receiveTimeStamp = 0;
+    this.isReconnect = false;
+    this.handle?.onOpen?.();
+    this.heartHandle();
+    this.promiseProxy?.promise(this);
+  }
+
+  private heartHandle() {
+    FW.Entry?.timeMgr?.schedule(
+      () => {
+        const interval = this.sendHeartTimestamp - this.receiveTimeStamp;
+        if (interval >= this.heartWeakTime) {
+          this.handle.onWeakNetWork?.();
+          if (interval >= this.heartTimeout) {
+            this.reconnect();
+            return;
+          }
+        }
+        this.sendHeart();
+      },
+      this.heartInternal / 1000,
+      cc.macro.REPEAT_FOREVER,
+      this,
+    );
+  }
+
+  private sendHeart() {
+    this.sendHeartTimestamp = new Date().getTime();
+    this.sender?.sendHeart?.();
+  }
+
+  send(msg: any) {
+    if (this.getReadyState() != WebSocket.OPEN) return;
+    if (this.isPausedMessageHandle) return;
+    this.socket?.send(msg);
+  }
+
+  /** socket关闭 */
+  private onSocketClose() {
+    this.handle?.onClose?.();
+    FW.Entry.timeMgr.scheduleOnce(
+      () => {
+        if (!this.isReconnect) return;
+        FWLog.debug('on close!');
+        this.reconnect();
+      },
+      3,
+      this,
+    );
+  }
+  /** 消息处理 */
+  private async onSocketMessage(msg: any) {
+    if (await this.handle?.onHeart?.(msg)) {
+      this.receiveTimeStamp = new Date().getTime();
+    } else {
+      if (this.isPausedMessageHandle) return;
+      this.handle?.onMessage?.(msg);
+    }
+  }
+  /** 错误处理 */
+  private onSocketError(msg: any) {
+    this.handle?.onError?.(msg);
+  }
+}

package/service/socket/FWSocket.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "6bff4169-033b-4745-842d-fdb124b9ac6c",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/service/socket/FWSocketHandle.ts

@@ -0,0 +1,17 @@
+import { injectable } from 'inversify';
+@injectable()
+export default abstract class FWSocketHandle implements FW.Handle {
+  constructor() {
+    this.initialize?.();
+  }
+  public readonly entry: FW.Entry = FW.Entry;
+  initialize?();
+  onDestroy?();
+  onHeart?(msg: any): Promise<boolean>;
+  onWeakNetWork?(): void;
+  abstract onClose(): void;
+  abstract onOpen(): void;
+  abstract onMessage(msg: any): void;
+  abstract onError(msg: any): void;
+  abstract onTimeout(): void;
+}

package/service/socket/FWSocketHandle.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "2e34eee4-ca3e-4ffd-9ff5-3fab23ea4f76",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/service/socket/FWSocketSender.ts

@@ -0,0 +1,16 @@
+import { injectable } from 'inversify';
+import FWLog from '../../log/FWLog';
+@injectable()
+export default class FWSocketSender implements FW.Sender {
+  constructor() {
+    this.initialize?.();
+  }
+  public readonly entry: FW.Entry = FW.Entry;
+  initialize?();
+  onDestroy?();
+  sendHeart?();
+
+  send(msg: any) {
+    FW.Entry.socketMgr.getSocket()?.send(msg);
+  }
+}

package/service/socket/FWSocketSender.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "5ef12e31-ee4f-443b-9de1-9075ecdde103",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/service/socket.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "a7f0af4f-9f10-4654-824d-3bad8f83fe02",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}

package/service.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "c2964b62-8f96-4c31-99a6-dbb9ab128665",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}

package/state/FWState.ts

@@ -0,0 +1,8 @@
+export abstract class FWState implements FW.State {
+  constructor() {}
+  abstract onEnter(args: any): void;
+  abstract onExit(): void;
+  abstract onInit(): void;
+  abstract onDestroy(): void;
+  abstract onUpdate(dt?: number): void;
+}

package/state/FWState.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "28581272-c60a-4687-8d91-0a3140b8c8a7",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/state.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "91d50211-1204-4d3b-a7cb-6ae92e8fb6ca",
+  "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": {}
+}