@ives_xxz/framework 2.0.13 → 2.0.14

package/FrameworkInitialize.ts

@@ -56,6 +56,7 @@ export function initializeFramework() {
   FW.Log = new (require('./log/FWLog').FWLog)();
   FW.Layer = require('./layer/FWLayer').FWLayer;
   FW.LayerController = require('./controller/FWLayerController').FWLayerController;
+  FW.SocketMock = new (require('./service/socket/mock/FWSocketMock').FWSocketMock)();
   FW.Framework.initialize();
   FW.Entry.initialize();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ives_xxz/framework",
-  "version": "2.0.13",
+  "version": "2.0.14",
   "description": "cocoscreator 2.x mvc framework",
   "main": "index.js",
   "keywords": ["123456"],

package/service/socket/FWSocket.ts

@@ -94,7 +94,6 @@ export default class FWSocket extends FW.Service implements FW.Socket {
           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);
@@ -303,7 +302,7 @@ export default class FWSocket extends FW.Service implements FW.Socket {
   private async onSocketMessage(originalMsg: any) {
     const msg = await this.socketHandle.onBeforeReceivingMessage(originalMsg);
 
-    if (msg.error) {
+    if (!msg || msg?.error) {
       this.onSocketError(msg);
       return;
     }

package/service/socket/mock/FWSocketMock.ts

@@ -0,0 +1,203 @@
+class MockWebSocket {
+  public url: string;
+  public readyState: number;
+  public binaryType: BinaryType = 'blob';
+
+  static readonly CONNECTING = 0;
+  static readonly OPEN = 1;
+  static readonly CLOSING = 2;
+  static readonly CLOSED = 3;
+
+  public onopen: ((event: Event) => void) | null = null;
+  public onmessage: ((event: MessageEvent) => void) | null = null;
+  public onerror: ((event: Event) => void) | null = null;
+  public onclose: ((event: CloseEvent) => void) | null = null;
+
+  private messageQueue: any[] = [];
+
+  constructor(url: string | URL, protocols?: string | string[]) {
+    this.url = url.toString();
+    this.readyState = MockWebSocket.CONNECTING;
+
+    FW.Entry.timeMgr.scheduleOnce(() => {
+      this.readyState = MockWebSocket.OPEN;
+
+      this.onopen?.(new Event('open'));
+
+      WebSocketMockServer.getInstance().addClient(this);
+
+      this.processMessageQueue();
+    });
+  }
+
+  send(data: string | ArrayBuffer | Blob | ArrayBufferView): void {
+    if (this.readyState !== MockWebSocket.OPEN) {
+      this.messageQueue.push(data);
+      return;
+    }
+
+    WebSocketMockServer.getInstance().handleMessage(this, data);
+  }
+
+  close(code?: number, reason?: string): void {
+    if (this.readyState === MockWebSocket.CLOSED) return;
+
+    this.readyState = MockWebSocket.CLOSED;
+    WebSocketMockServer.getInstance().removeClient(this);
+
+    const closeEvent = new CloseEvent('close', {
+      code: code || 1000,
+      reason: reason || 'Normal closure',
+      wasClean: true,
+    });
+
+    if (this.onclose) {
+      this.onclose(closeEvent);
+    }
+  }
+
+  private processMessageQueue(): void {
+    while (this.messageQueue.length > 0) {
+      const data = this.messageQueue.shift();
+      this.send(data);
+    }
+  }
+
+  mockServerSend(data: any): void {
+    if (this.readyState === MockWebSocket.OPEN) {
+      const messageData = typeof data === 'string' ? data : JSON.stringify(data);
+      const messageEvent = new MessageEvent('message', {
+        data: messageData,
+      });
+
+      this.onmessage?.(messageEvent);
+    }
+  }
+
+  mockServerError(error: any): void {
+    const errorEvent = new Event('error');
+
+    this.onerror?.(errorEvent);
+  }
+}
+
+class WebSocketMockServer {
+  private clients: Set<MockWebSocket> = new Set();
+  private broadcastIntervals: any[] = [];
+  private static instance: WebSocketMockServer;
+
+  public mockResponses = {};
+
+  public static getInstance(): WebSocketMockServer {
+    if (!WebSocketMockServer.instance) {
+      WebSocketMockServer.instance = new WebSocketMockServer();
+    }
+    return WebSocketMockServer.instance;
+  }
+
+  private constructor() {
+    FW.Log.system('🎮 WebSocket 模拟服务器已启动');
+  }
+
+  addClient(client: MockWebSocket): void {
+    this.clients.add(client);
+
+    FW.Log.system(`客户端连接，当前连接数: ${this.clients.size}`);
+
+    this.sendToClient(client, {
+      code: 0,
+      message: '连接到模拟游戏服务器成功',
+      serverTime: FW.Entry.timeMgr.getTime(),
+    });
+  }
+
+  removeClient(client: MockWebSocket): void {
+    this.clients.delete(client);
+    FW.Log.system(`客户端断开，当前连接数: ${this.clients.size}`);
+  }
+
+  handleClient(client: MockWebSocket, data: any): void {
+    try {
+      const message = typeof data === 'string' ? JSON.parse(data) : data;
+
+      const response = this.generateMockResponse(message);
+      this.sendToClient(client, response);
+    } catch (error) {
+      this.sendToClient(client, {
+        type: 'error',
+        message: '消息格式错误',
+        timestamp: new Date().toISOString(),
+      });
+    }
+  }
+
+  handleMessage(client: MockWebSocket, data: string | ArrayBuffer | Blob | ArrayBufferView): void {
+    if (typeof data === 'string') {
+      this.handleClient(client, data);
+    } else {
+      console.warn('二进制消息暂不支持');
+    }
+  }
+
+  private generateMockResponse(message: any): any {
+    return (
+      this.mockResponses[message.type as keyof typeof this.mockResponses] || {
+        type: 'unknown',
+        success: false,
+        message: { error: 'unknown message' },
+      }
+    );
+  }
+
+  private sendToClient(client: MockWebSocket, data: any): void {
+    client.mockServerSend(data);
+  }
+
+  public broadcast(data: any): void {
+    const message = typeof data === 'string' ? data : JSON.stringify(data);
+    this.clients.forEach((client) => {
+      this.sendToClient(client, message);
+    });
+  }
+
+  public stop(): void {
+    this.broadcastIntervals.forEach((interval) => clearInterval(interval));
+    this.broadcastIntervals = [];
+    this.clients.clear();
+    FW.Log.system('🛑 WebSocket 模拟服务器已停止');
+  }
+}
+
+export class FWSocketMock {
+  private isInitialized = false;
+
+  start(mockResponses: {}): void {
+    if (this.isInitialized) return;
+
+    WebSocketMockServer.getInstance().mockResponses = mockResponses;
+
+    const OriginalWebSocket = window.WebSocket;
+
+    (window as any).WebSocket = MockWebSocket;
+    (window as any).OriginalWebSocket = OriginalWebSocket;
+
+    this.isInitialized = true;
+    FW.Log.system('🎮 WebSocket 模拟已启动 - 所有 WebSocket 连接将被模拟');
+  }
+
+  stop(): void {
+    if (!this.isInitialized) return;
+
+    if ((window as any).OriginalWebSocket) {
+      window.WebSocket = (window as any).OriginalWebSocket;
+    }
+
+    WebSocketMockServer.getInstance().stop();
+    this.isInitialized = false;
+    FW.Log.system('🛑 WebSocket 模拟已停止 - 恢复原生 WebSocket');
+  }
+
+  getServer(): WebSocketMockServer {
+    return WebSocketMockServer.getInstance();
+  }
+}

package/service/socket/mock/FWSocketMock.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "a8d930bd-0449-4481-8ebd-e0664d7cd09f",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/service/socket/mock.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "755d7ddd-de7b-4f43-9a7a-1fbd31b2a0b9",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}

package/types/FW.d.ts

@@ -2339,3 +2339,11 @@ declare namespace FW {
     onTimeout?();
   }
 }
+
+declare namespace FW {
+  export class SocketMock {
+    static createMockData<T>(msgId: string, data: T);
+    public static start(mockResponses: {}): void;
+    public static stop(): void;
+  }
+}