@lzpenguin/server 1.0.2 → 1.0.4

package/index.js

@@ -177,9 +177,39 @@ export class RiffleServer {
               console.log('[RiffleServer] Initialized');
             }
             
-            // 更新缓存并触发数据回调
-            this.currentData = message;
-            this.dataCallbacks.forEach(cb => cb(message));
+            // 合并服务器数据与当前缓存，避免丢失乐观更新的数据
+            // 策略：对于 world 数据，优先保留乐观更新（当前缓存），然后合并服务器数据
+            // 这样可以确保刚画的笔画不会因为服务器推送旧数据而丢失
+            if (this.currentData) {
+              const mergedData = {
+                // world 数据：先使用当前缓存（包含乐观更新），再合并服务器数据
+                // _deepMerge 会先保留 target（当前缓存）的所有数据，然后添加 source（服务器数据）中不存在的项
+                // 对于数组（如 strokes），会合并去重，确保不会丢失任何笔画
+                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);
@@ -240,6 +270,58 @@ 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 字符串比较）
+    // 先保留 target 的所有项，然后添加 source 中不存在的项
+    // 这样可以确保不会丢失任何数据
+    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;
+    }
+    
+    // 处理对象：递归合并
+    // 先复制 target，然后用 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
@@ -256,6 +338,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) {

package/package.json

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