@lzpenguin/server 1.0.1 → 1.0.3

package/index.js

@@ -1,4 +1,32 @@
-import WebSocket from 'ws';
+// 检测运行环境，浏览器使用原生 WebSocket，Node.js 使用 ws 库
+let WebSocketImpl;
+let isBrowser = false;
+
+if (typeof window !== 'undefined' && window.WebSocket) {
+  // 浏览器环境
+  WebSocketImpl = window.WebSocket;
+  isBrowser = true;
+} else {
+  // Node.js 环境 - 使用动态导入
+  try {
+    // 使用 require 或 import，根据环境选择
+    if (typeof require !== 'undefined') {
+      // CommonJS 环境
+      WebSocketImpl = require('ws');
+    } else {
+      // ES Module 环境 - 在运行时动态导入
+      // 注意：这需要在异步上下文中使用
+      WebSocketImpl = null; // 将在 connect 方法中动态导入
+    }
+  } catch (e) {
+    // 如果无法导入 ws，尝试使用全局 WebSocket（某些打包工具可能会提供）
+    if (typeof WebSocket !== 'undefined') {
+      WebSocketImpl = WebSocket;
+    } else {
+      throw new Error('WebSocket is not available. In Node.js, please install "ws" package.');
+    }
+  }
+}
 
 /**
  * RiffleServer - 游戏服务器 WebSocket 客户端
@@ -79,29 +107,43 @@ export class RiffleServer {
     // 当前服务器数据缓存
     this.currentData = null;
 
-    // 连接状态
-    this.connect();
+    // 连接状态（异步调用，不阻塞构造函数）
+    this.connect().catch(err => {
+      console.error('[RiffleServer] Initial connection failed:', err);
+    });
   }
 
   /**
    * 连接到 WebSocket 服务器
    * @private
    */
-  connect() {
-    if (this.isConnecting || (this.isConnected && this.ws?.readyState === WebSocket.OPEN)) {
+  async connect() {
+    if (this.isConnecting || (this.isConnected && this.ws?.readyState === (WebSocketImpl?.OPEN ?? 1))) {
       return;
     }
 
     this.isConnecting = true;
 
+    // 如果在 Node.js 环境且 WebSocketImpl 未初始化，动态导入
+    if (!isBrowser && !WebSocketImpl) {
+      try {
+        const wsModule = await import('ws');
+        WebSocketImpl = wsModule.default;
+      } catch (e) {
+        this.isConnecting = false;
+        console.error('[RiffleServer] Failed to import ws module:', e);
+        throw new Error('WebSocket is not available. In Node.js, please install "ws" package.');
+      }
+    }
+
     // 构建 WebSocket URL（包含 post_id 和 token）
     let wsUrl = `${this.url}?post_id=${this.postId}&token=${this.token}`;
 
-
     try {
-      this.ws = new WebSocket(wsUrl);
+      this.ws = new WebSocketImpl(wsUrl);
 
-      this.ws.on('open', () => {
+      // 统一事件处理：浏览器用 addEventListener，Node.js 用 .on()
+      const handleOpen = () => {
         this.isConnected = true;
         this.isConnecting = false;
         this.isInitialized = false;  // 连接后重置初始化状态
@@ -113,11 +155,13 @@ export class RiffleServer {
           this.pendingInit = null;
           this._doInit(initData);
         }
-      });
+      };
 
-      this.ws.on('message', (data) => {
+      const handleMessage = (event) => {
         try {
-          const message = JSON.parse(data.toString());
+          // 浏览器: event.data, Node.js: event (Buffer 或 string)
+          const data = event.data || event;
+          const message = JSON.parse(typeof data === 'string' ? data : data.toString());
           
           // 检查是否是错误消息
           if (message.error) {
@@ -133,20 +177,48 @@ export class RiffleServer {
               console.log('[RiffleServer] Initialized');
             }
             
-            // 更新缓存并触发数据回调
-            this.currentData = message;
-            this.dataCallbacks.forEach(cb => cb(message));
+            // 合并服务器数据与当前缓存，避免丢失乐观更新的数据
+            // 策略：服务器数据是权威数据，但需要智能合并以避免丢失本地更新
+            if (this.currentData) {
+              // 对于 self 数据：优先使用服务器数据（因为服务器会合并所有更新）
+              // 但对于 world 数据：需要合并，因为可能有其他玩家的更新
+              const mergedData = {
+                // world 数据：合并服务器数据和本地缓存，确保不丢失任何更新
+                world: this._deepMerge(this.currentData.world || {}, message.world),
+                // self 数据：服务器数据是权威的（已包含所有更新），但合并确保不丢失字段
+                self: {
+                  public: this._deepMerge(
+                    message.self?.public || {},
+                    this.currentData.self?.public || {}
+                  ),
+                  private: this._deepMerge(
+                    message.self?.private || {},
+                    this.currentData.self?.private || {}
+                  )
+                },
+                // players 列表使用服务器数据（其他玩家的数据）
+                players: message.players
+              };
+              
+              // 使用合并后的数据
+              this.currentData = mergedData;
+              this.dataCallbacks.forEach(cb => cb(mergedData));
+            } else {
+              // 如果没有缓存数据，直接使用服务器数据
+              this.currentData = message;
+              this.dataCallbacks.forEach(cb => cb(message));
+            }
           }
         } catch (error) {
           console.error('[RiffleServer] Failed to parse message:', error);
         }
-      });
+      };
 
-      this.ws.on('error', (error) => {
+      const handleError = (error) => {
         console.error('[RiffleServer] WebSocket error:', error);
-      });
+      };
 
-      this.ws.on('close', () => {
+      const handleClose = () => {
         this.isConnected = false;
         this.isConnecting = false;
         this.isInitialized = false;  // 断开连接后重置初始化状态
@@ -159,7 +231,20 @@ export class RiffleServer {
             this.connect();
           }, this.reconnectInterval);
         }
-      });
+      };
+
+      // 根据环境使用不同的事件绑定方式
+      if (isBrowser) {
+        this.ws.addEventListener('open', handleOpen);
+        this.ws.addEventListener('message', handleMessage);
+        this.ws.addEventListener('error', handleError);
+        this.ws.addEventListener('close', handleClose);
+      } else {
+        this.ws.on('open', handleOpen);
+        this.ws.on('message', handleMessage);
+        this.ws.on('error', handleError);
+        this.ws.on('close', handleClose);
+      }
     } catch (error) {
       this.isConnecting = false;
       console.error('[RiffleServer] Connection error:', error);
@@ -183,13 +268,62 @@ export class RiffleServer {
     this.isConnected = false;
   }
 
+  /**
+   * 深度合并对象
+   * @private
+   * @param {Object} target - 目标对象（保留原有数据）
+   * @param {Object} source - 源对象（新数据，优先使用）
+   * @returns {Object} 合并后的对象
+   */
+  _deepMerge(target, source) {
+    if (!target) return source ? (Array.isArray(source) ? [...source] : { ...source }) : {};
+    if (!source) return target;
+    
+    // 处理数组：如果都是数组，合并去重（基于 JSON 字符串比较）
+    if (Array.isArray(target) && Array.isArray(source)) {
+      const merged = [...target];
+      const targetStrings = new Set(target.map(item => JSON.stringify(item)));
+      for (const item of source) {
+        const itemStr = JSON.stringify(item);
+        if (!targetStrings.has(itemStr)) {
+          merged.push(item);
+          targetStrings.add(itemStr);
+        }
+      }
+      return merged;
+    }
+    
+    // 如果类型不匹配，使用源数据
+    if (Array.isArray(target) || Array.isArray(source)) {
+      return Array.isArray(source) ? [...source] : source;
+    }
+    
+    // 处理对象：递归合并
+    const result = { ...target };
+    for (const key in source) {
+      if (source.hasOwnProperty(key)) {
+        const sourceValue = source[key];
+        const targetValue = target[key];
+        
+        // 如果源值是对象且不是数组，递归合并
+        if (sourceValue && typeof sourceValue === 'object' && !Array.isArray(sourceValue)) {
+          result[key] = this._deepMerge(targetValue, sourceValue);
+        } else {
+          // 否则使用源值（优先使用新数据）
+          result[key] = sourceValue;
+        }
+      }
+    }
+    return result;
+  }
+
   /**
    * 发送更新请求
    * @private
    * @param {Object} updateData - 更新数据
    */
   sendUpdate(updateData) {
-    if (!this.isConnected || this.ws?.readyState !== WebSocket.OPEN) {
+    if (!this.isConnected || this.ws?.readyState !== WebSocketImpl.OPEN) {
       console.warn('[RiffleServer] Not connected, cannot send update');
       return;
     }
@@ -199,6 +333,38 @@ export class RiffleServer {
       return;
     }
 
+    // 乐观更新：立即更新本地缓存并触发回调
+    if (this.currentData) {
+      const optimisticData = { ...this.currentData };
+      
+      // 合并 world 数据
+      if (updateData.world) {
+        optimisticData.world = this._deepMerge(this.currentData.world || {}, updateData.world);
+      }
+      
+      // 合并 self 数据
+      if (updateData.self) {
+        optimisticData.self = { ...this.currentData.self };
+        if (updateData.self.public) {
+          optimisticData.self.public = this._deepMerge(
+            this.currentData.self?.public || {},
+            updateData.self.public
+          );
+        }
+        if (updateData.self.private) {
+          optimisticData.self.private = this._deepMerge(
+            this.currentData.self?.private || {},
+            updateData.self.private
+          );
+        }
+      }
+      
+      // 更新缓存并立即触发回调（乐观更新）
+      this.currentData = optimisticData;
+      this.dataCallbacks.forEach(cb => cb(optimisticData));
+    }
+
+    // 发送更新请求到服务器
     try {
       this.ws.send(JSON.stringify(updateData));
     } catch (error) {
@@ -231,7 +397,7 @@ export class RiffleServer {
     }
 
     // 如果还未连接，保存 init 请求，连接建立后自动执行
-    if (!this.isConnected || this.ws?.readyState !== WebSocket.OPEN) {
+    if (!this.isConnected || this.ws?.readyState !== WebSocketImpl.OPEN) {
       console.log('[RiffleServer] Not connected yet, will init after connection');
       this.pendingInit = initData;
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lzpenguin/server",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Riffle 游戏服务器 WebSocket 客户端 SDK",
   "license": "ISC",
   "author": "lzpenguin",