@cc-component/cc-core 1.4.2 → 1.4.4

package/assets/core/config/CommonEnum.ts

@@ -30,7 +30,6 @@ export interface IBundleConfig {
     is_load_sub?: boolean;
     /**是否记录-不记录可重复打开窗口 */
     is_record?: boolean;
-
 }
 export enum BundleConfigName {
     home = "home",

package/assets/core/lib/net/net/HttpManager.ts

@@ -5,8 +5,7 @@
  * @LastEditTime: 2022-09-09 18:10:50
  */
 
-import { IExtData } from "../../../config/CommonEnum";
-
+import { IExtData } from "db://assets/start/Interface/base/BaseCommon";
 
 /** HTTP请求返回值 */
 export class HttpReturn<T> {
@@ -64,8 +63,7 @@ export class HttpManager {
     server: string = "http://127.0.0.1/";
     /** 请求超时(毫秒) */
     timeout: number = 10000;
-    /**网络回调 函数 */
-    open: (finish: (isOk: boolean) => void) => void
+
     /**
      * GET请求获取文本格式数据
      * @param name      协议名
@@ -163,12 +161,10 @@ export class HttpManager {
             let url: string = r[0];
             let key: string = r[1];
             let pss: string = r[2];
-            if (method == HttpMethod.POST) {
-                pss = JSON.stringify(params);
-            }
+
             let hrd = urls.get(key);
             if (hrd && hrd.pss == pss) {
-                Logger.warn(`地址【${key}】已正在请求中，不能重复请求`);
+                console.warn(`地址【${key}】已正在请求中，不能重复请求`);
                 return;
             }
 
@@ -176,7 +172,7 @@ export class HttpManager {
 
             // 防重复请求功能
             urls.set(key, { xhr, pss });
-            //Logger.warn(ext && ext.query ? key : url)
+            //console.warn(ext && ext.query ? key : url)
             if (method == HttpMethod.POST)
                 xhr.open(HttpMethod.POST, ext && ext.query ? key : url);
             else
@@ -198,7 +194,7 @@ export class HttpManager {
                 resolve(ret);
             }
             xhr.onloadend = (ev: ProgressEvent) => {
-                if (xhr.status == 500 || xhr.status > 500) {
+                if (xhr.status == 500) {
                     urls.delete(key);
 
                     ret.isSucc = false;

package/assets/core/lib/net/net/HttpManager.ts.meta

@@ -2,7 +2,7 @@
   "ver": "4.0.24",
   "importer": "typescript",
   "imported": true,
-  "uuid": "7a410a72-518e-4a0d-89e2-0a2e33d0eddb",
+  "uuid": "42b714af-f09e-4aba-94f8-0033dd8a1321",
   "files": [],
   "subMetas": {},
   "userData": {}

package/assets/core/lib/net/net/NetInterface.ts

@@ -27,6 +27,8 @@ export interface IRequestProtocol {
     buffer?: NetData,
     /** 等待响应的回调对象 */
     callback: CallbackObject,
+    /**包名 */
+    packageObj?: any
 }
 
 /** 响应协议 */
@@ -67,6 +69,11 @@ export class IProtocolHelper {
     decodeCommon(msg: NetData): IResponseProtocol { return null! };
     /** 解析自定义响应数据 */
     decodeCustom(ireqp: IRequestProtocol, iresp: IResponseProtocol): void { };
+
+    encodeCustomPackage(packageObj: any, ireqp: IRequestProtocol): void { };
+    decodeCustomPackage(packageObj: any, ireqp: IRequestProtocol, iresp: IResponseProtocol): void { };
+
+
     /** 返回一个心跳包 */
     onHearbeat(): void { };
 }

package/assets/core/lib/net/net/NetInterface.ts.meta

@@ -2,7 +2,7 @@
   "ver": "4.0.24",
   "importer": "typescript",
   "imported": true,
-  "uuid": "60e7847d-69e1-42a2-bff4-52bedbb4012b",
+  "uuid": "30df3d0f-b563-43c6-8a8c-59e4fd5652b0",
   "files": [],
   "subMetas": {},
   "userData": {}

package/assets/core/lib/net/net/NetManager.ts.meta

@@ -2,7 +2,7 @@
   "ver": "4.0.24",
   "importer": "typescript",
   "imported": true,
-  "uuid": "634ec195-a543-433e-a365-3fc0184ab964",
+  "uuid": "4e807495-5d3d-4a54-bffb-85196cfa2489",
   "files": [],
   "subMetas": {},
   "userData": {}

package/assets/core/lib/net/net/NetNode.ts

@@ -71,7 +71,7 @@ export class NetNode {
     protected _keepAliveTimer: any = null;                                  // 心跳定时器
     protected _receiveMsgTimer: any = null;                                 // 接收数据定时器
     protected _reconnectTimer: any = null;                                  // 重连定时器
-    protected _heartTime: number = 10000;                                   // 心跳间隔
+    protected _heartTime: number = 20000;                                   // 心跳间隔
     protected _receiveTime: number = 30000;                                 // 多久没收到数据断开
     protected _reconnetTimeOut: number = 5000;                              // 重连间隔
     protected _requests: IRequestProtocol[] = Array<IRequestProtocol>();    // 请求列表
@@ -184,7 +184,7 @@ export class NetNode {
     protected initSocket() {
         if (this._socket) {
             this._socket.onConnected = (event) => { this.onConnected(event) };
-            this._socket.onMessage = (msg) => { this.onMessage(msg) };
+            this._socket.onMessage = (msg) => { this.onMessageCust(msg) };
             this._socket.onError = (event) => { this.onError(event) };
             this._socket.onClosed = (event) => { this.onClosed(event) };
             this._isSocketInit = true;
@@ -327,6 +327,11 @@ export class NetNode {
 
         this.base_request(reqProtocol, showTips, force);
     }
+    requestCust(packageoObj: any, reqProtocol: IRequestProtocol, showTips: boolean = true, force: boolean = false) {
+        this._protocolHelper.encodeCustomPackage(packageoObj, reqProtocol);
+
+        this.base_request(reqProtocol, showTips, force);
+    }
 
     /**
      * 唯一request，确保没有同一响应的请求（避免一个请求重复发送，netTips界面的屏蔽也是一个好的方法）
@@ -355,7 +360,7 @@ export class NetNode {
             this._socket.send(reqProtocol.buffer!);
         }
 
-        Logger.debug(`队列命令为【${reqProtocol.cmd}】的请求，等待请求数据的回调`);
+        //  Logger.debug(`队列命令为【${reqProtocol.cmd}】的请求，等待请求数据的回调`);
 
         // 进入发送缓存列表
         this._requests.push(reqProtocol);
@@ -447,7 +452,7 @@ export class NetNode {
         }
 
         this._keepAliveTimer = setTimeout(() => {
-            Logger.debug("网络节点发送心跳信息");
+            // Logger.logModel("网络节点发送心跳信息");
             if (this._state == NetNodeState.Working) {
                 this._protocolHelper.onHearbeat();
             }
@@ -467,4 +472,97 @@ export class NetNode {
         }
     }
     //#endregion
+
+
+    /** 接收到一个完整的消息包 */
+    protected onMessageCust(msg: NetData): void {
+        // Logger.debug(`接受消息状态为【${NetNodeStateStrs[this._state]}】`);
+
+        var iresp: IResponseProtocol = this._protocolHelper.decodeCommon(msg);
+        const game_resp = message.GameResponse.decode(iresp.data);
+        iresp.data = game_resp
+
+        // 接受到数据，重新定时收数据计时器
+        this.resetReceiveMsgTimer();
+        // 重置心跳包发送器
+        this.resetHearbeatTimer();
+        // 触发消息执行
+        var id = iresp.id = game_resp.id;
+        var cmd = iresp.cmd = game_resp.cmd;
+
+        if (cmd === command.CommandType.CMD_HEARTBEAT) {
+
+        } else {
+            Logger.debug(`接受到命令【${cmd}】的消息`);
+        }
+
+        // 触发请求队列中的回调函数
+        if (this._requests.length > 0) {
+            for (let reqIdx in this._requests) {
+                let ireqp = this._requests[reqIdx];
+                const idd = ireqp.params.id;
+                if (idd == id) {
+                    //Logger.debug(`触发请求命令【${cmd}】的回调`);
+                    // this._protocolHelper.decodeCustomPackage(ireqp.packageObj, ireqp, iresp);
+                    this._callbackExecuter(ireqp.callback, iresp);
+                    this._requests.splice(parseInt(reqIdx), 1);
+                    break;
+                }
+            }
+
+            // 触发请求结束
+            if (this._requests.length == 0) {
+                this.updateNetTips(NetTipsType.Requesting, false);
+            }
+            else {
+                Logger.debug(`请求队列中还有【${this._requests.length}】个请求在等待`);
+            }
+        }
+
+        // 服务器推送回调触发
+        let listeners = this._listener[cmd];
+        if (null != listeners) {
+            for (const ireqp of listeners) {
+                //Logger.debug(`触发监听命令【${cmd}】的回调`);
+                // this._protocolHelper.decodeCustomPackage(ireqp.packageObj, ireqp, iresp);
+                this._callbackExecuter(ireqp.callback, iresp.data);
+            }
+        }
+    }
+
+
+    /**
+ * 监听服务器推送
+ * @param cmd       协议命令号
+ * @param respName  Protobuf返回协议名
+ * @param callback  回调方法
+ * @param target    目标对象
+ */
+    addResponeHandlerCust(reqProtocol: IRequestProtocol): void {
+        var cmd = reqProtocol.cmd;
+        if (null == this._listener[cmd]) {
+            this._listener[cmd] = [reqProtocol];
+        }
+        else {
+            let index = this.getNetListenersIndex(cmd, reqProtocol.callback);
+            if (-1 == index) {
+                this._listener[cmd]!.push(reqProtocol);
+            }
+        }
+    }
+
+    /**
+     * 删除一个监听中指定子回调
+     * @param cmd       命令字串
+     * @param callback  回调方法
+     * @param target    目标对象
+     */
+    removeResponeHandlerCust(cmd: number, callback: NetCallFunc, target?: any) {
+        if (null != this._listener[cmd] && callback != null) {
+            let index = this.getNetListenersIndex(cmd, { target, callback });
+            if (-1 != index) {
+                this._listener[cmd]!.splice(index, 1);
+            }
+        }
+    }
 }

package/assets/core/lib/net/net/NetNode.ts.meta

@@ -2,7 +2,7 @@
   "ver": "4.0.24",
   "importer": "typescript",
   "imported": true,
-  "uuid": "8b63b153-6aa2-402d-ba89-00bd4d6cab8a",
+  "uuid": "e7d169e6-a1fb-4216-a01e-96acda541c6f",
   "files": [],
   "subMetas": {},
   "userData": {}

package/assets/core/lib/net/net/WebSock.ts.meta

@@ -2,7 +2,7 @@
   "ver": "4.0.24",
   "importer": "typescript",
   "imported": true,
-  "uuid": "fd6723cd-96ff-4dde-a559-d1d48b056e5b",
+  "uuid": "cc0b4757-b227-4bbb-8cfe-5df29532f1b7",
   "files": [],
   "subMetas": {},
   "userData": {}

package/assets/core/lib/net/net/protocol/Builder.ts

@@ -0,0 +1,176 @@
+/**
+ * @Builder 装饰器 - 自动为类添加Builder模式支持
+ * @param {Object} options - 配置选项
+ * @param {string} options.prefix - 方法前缀，默认'set'
+ * @param {string} options.suffix - 方法后缀，默认''
+ * @param {Object} options.customMethods - 自定义方法
+ * @param {Array} options.exclude - 排除的属性名
+ * @param {Array} options.include - 包含的属性名(手动指定,优先级高于自动收集)
+ * @param {boolean} options.immutable - 是否不可变，返回新实例
+ * @param {boolean} options.usePropertyNames - 是否使用属性名作为方法名(如 .name() 而不是 .setName())
+ */
+export function Builder(options = {}) {
+    return function (target) {
+        const {
+            prefix = 'set',
+            suffix = '',
+            customMethods = {},
+            exclude = [],
+            include = null,
+            immutable = false,
+            usePropertyNames = false
+        } = options;
+
+        // 收集类的属性
+        const collectProperties = (cls) => {
+            // 如果手动指定了 include,直接使用
+            if (include && include.length > 0) {
+                return include;
+            }
+
+            const props = new Set();
+            let current = cls;
+
+            // 遍历原型链
+            while (current && current !== Function.prototype) {
+                // 方法1: 获取实例自身的属性(已赋值的)
+                try {
+                    const instance = new cls();
+                    Object.getOwnPropertyNames(instance).forEach(prop => {
+                        if (prop !== 'constructor' && !exclude.includes(prop)) {
+                            props.add(prop);
+                        }
+                    });
+                } catch (e) {
+                    // 如果构造函数需要参数,忽略错误
+                }
+
+                // 方法2: 获取原型上的属性描述符
+                const descriptors = Object.getOwnPropertyDescriptors(current.prototype || {});
+                Object.entries(descriptors).forEach(([prop, desc]) => {
+                    // 收集所有非方法属性(包括 getter 和普通属性)
+                    if (prop !== 'constructor' && !exclude.includes(prop)) {
+                        // 排除函数类型的方法
+                        if (typeof desc.value !== 'function' || desc.get) {
+                            props.add(prop);
+                        }
+                    }
+                });
+
+                current = Object.getPrototypeOf(current);
+            }
+
+            return Array.from(props);
+        };
+
+        const properties = collectProperties(target);
+
+        // 创建Builder类
+        class DynamicBuilder {
+            constructor() {
+                this._data = {};
+                this._targetClass = target;
+                this._isImmutable = immutable;
+            }
+
+            build() {
+                const instance = new this._targetClass();
+
+                // 将 _data 中的属性赋值到实例上
+                Object.assign(instance, this._data);
+
+                // 如果是不可变模式，冻结对象
+                if (this._isImmutable) {
+                    Object.freeze(instance);
+                    if (instance.battleInfoList) {
+                        Object.freeze(instance.battleInfoList);
+                    }
+                }
+
+                return instance;
+            }
+
+            // 重置数据
+            reset() {
+                this._data = {};
+                return this;
+            }
+
+            // 批量设置
+            setAll(data) {
+                this._data = {...this._data, ...data};
+                return this;
+            }
+        }
+
+        // 为所有属性创建setter方法
+        properties.forEach(prop => {
+            // 根据 usePropertyNames 决定使用属性名还是带前缀的方法名
+            const methodName = usePropertyNames ? prop : `${prefix}${prop.charAt(0).toUpperCase() + prop.slice(1)}${suffix}`;
+
+            DynamicBuilder.prototype[methodName] = function (value) {
+                this._data[prop] = value;
+                return this;
+            };
+        });
+
+        // 添加特殊方法
+        DynamicBuilder.prototype.addAllBattleInfoList = function (list) {
+            this._data.battleInfoList = Array.isArray(list) ? [...list] : list;
+            return this;
+        };
+
+        DynamicBuilder.prototype.addBattleInfo = function (item) {
+            if (!this._data.battleInfoList) {
+                this._data.battleInfoList = [];
+            }
+            this._data.battleInfoList.push(item);
+            return this;
+        };
+
+        // 添加自定义方法
+        Object.keys(customMethods).forEach(methodName => {
+            DynamicBuilder.prototype[methodName] = customMethods[methodName];
+        });
+
+        // 为原始类添加builder方法
+        target.builder = function () {
+            return new DynamicBuilder();
+        };
+
+        // 添加快速创建方法
+        target.create = function (data) {
+            return target.builder().setAll(data).build();
+        };
+
+        return target;
+    };
+}
+
+/**
+ * @Buildable 装饰器 - 简化版Builder(默认使用 set 前缀)
+ */
+export function Buildable(target) {
+    return Builder()(target);
+}
+
+/**
+ * @ToBuilder 装饰器 - 流式API版Builder(使用属性名,不带 set 前缀)
+ */
+export function ToBuilder(target) {
+    return Builder({...{}, usePropertyNames: true})(target);
+}
+
+/**
+ * @FluentBuilder 装饰器 - 流式API版Builder(使用属性名,不带 set 前缀)
+ */
+export function FluentBuilder(options = {}) {
+    return Builder({...options, usePropertyNames: true});
+}
+
+/**
+ * @ImmutableBuilder 装饰器 - 创建不可变对象
+ */
+export function ImmutableBuilder(target) {
+    return Builder({immutable: true})(target);
+}

package/assets/core/lib/net/net/{custom/NetChannelManager.ts.meta → protocol/Builder.ts.meta}

@@ -2,7 +2,7 @@
   "ver": "4.0.24",
   "importer": "typescript",
   "imported": true,
-  "uuid": "ed715e24-08b4-4a37-b866-ca28e9a85b2f",
+  "uuid": "bece4181-3af2-405f-a0ce-3ffce775cde1",
   "files": [],
   "subMetas": {},
   "userData": {}

package/assets/core/lib/net/net/protocol/MessageWrapper.ts

@@ -0,0 +1,84 @@
+/**
+ * Protobuf Message 包装器
+ *
+ * 为 message.GameRequest 等提供类似 Builder 的链式调用
+ * 完全不修改 protobuf 生成的代码
+ *
+ * 使用示例：
+ * // 在 NetProtocolProtobuf.ts 中使用
+ * data(cmd: number, subCmd: number) {
+ *     return GameRequestWrapper.builder()
+ *         .cmd(cmd)
+ *         .subCmd(subCmd)
+ *         .id(this.getRequestId())
+ *         .timestamp(Date.now())
+ *         .build();
+ * }
+ */
+
+/**
+ * 通用 Builder 类 - 使用 Proxy 自动处理所有字段
+ * 协议字段改动时无需手动更新
+ */
+class AutoBuilder<T extends object> {
+    private message: T;
+
+    constructor(message: T) {
+        this.message = message;
+    }
+
+    /**
+     * 使用 Proxy 拦截所有属性访问,自动生成对应的 setter 方法
+     * 例如: builder.cmd(100) -> 实际调用 builder.set('cmd', 100)
+     */
+    static create<T extends object>(message: T): any {
+        const builder = new AutoBuilder(message);
+
+        const proxyObj = new Proxy(builder, {
+            get(_target, prop) {
+                // 如果是 build 方法,直接返回原始 message 对象
+                if (prop === 'build') {
+                    return () => builder.message;
+                }
+
+                // 如果是 set 方法,允许手动设置
+                if (prop === 'set') {
+                    return <K extends keyof T>(key: K, value: T[K]) => {
+                        builder.message[key] = value;
+                        return proxyObj;
+                    };
+                }
+
+                // 其他所有属性都作为 setter 方法处理
+                return (value: any) => {
+                    // @ts-ignore - 动态设置属性
+                    builder.message[prop] = value;
+                    return proxyObj;
+                };
+            }
+        });
+
+        return proxyObj;
+    }
+}
+
+/**
+ * 通用的 Message 包装器工厂
+ * 适用于任何 Protobuf Message 类型
+ */
+export function createMessageWrapper<T extends object>(
+    messageConstructor: new (...args: any[]) => T
+) {
+    return {
+        /**
+         * 创建 Builder
+         * 支持链式调用,协议字段改动时无需更新
+         */
+        builder: () => AutoBuilder.create(new messageConstructor()),
+
+        /**
+         * 快速创建(带初始值)
+         */
+        create: (data?: Partial<T>) => new messageConstructor(data)
+    };
+}

package/assets/core/lib/net/{libs/proto/output/protobuf_custom.d.ts.meta → net/protocol/MessageWrapper.ts.meta}

@@ -2,7 +2,7 @@
   "ver": "4.0.24",
   "importer": "typescript",
   "imported": true,
-  "uuid": "6fc3137d-408a-4395-99f4-756637ce6ea6",
+  "uuid": "0b11fc13-aada-4341-ba06-e518eb7cb644",
   "files": [],
   "subMetas": {},
   "userData": {}

package/assets/core/lib/net/net/protocol/NetProtocolJson.ts.meta

@@ -2,7 +2,7 @@
   "ver": "4.0.24",
   "importer": "typescript",
   "imported": true,
-  "uuid": "245e7a4f-60f6-4240-b02c-b516af592916",
+  "uuid": "ef0b1e0c-f9a8-40c0-81d0-f64049599bff",
   "files": [],
   "subMetas": {},
   "userData": {}