奖励已经双倍奖励

assets/script/game/common/GameDataSyncManager.ts

@@ -1,3 +1,4 @@
+import { oops } from "db://oops-framework/core/Oops";
 import { WxCloudApi ,UserGameData} from "../wx_clound_client_api/WxCloudApi";
 import { smc } from "./SingletonModuleComp";
 
@@ -47,7 +48,7 @@ export class GameDataSyncManager {
         
         // 直接覆盖道具数据
         if (remoteData.items) {
-            Object.assign(smc.itmes, remoteData.items);
+            Object.assign(smc.items, remoteData.items);
             console.log(`[Initialize]: 道具数据已从${dataSource}覆盖`);
         }
         
@@ -238,183 +239,6 @@ export class GameDataSyncManager {
         }
     }
 
-    /**
-     * 删除指定英雄
-     * @param heroId 英雄ID
-     * @returns 是否成功
-     */
-    async deleteHero(heroId: number): Promise<boolean> {
-        try {
-            console.log(`[GameDataSyncManager]: 删除英雄 ID:${heroId}`);
-            
-            const result = await WxCloudApi.deleteHero(heroId);
-            
-            if (result.result.code === 200) {
-                // 远程修改成功，同步本地数据
-                delete smc.heros[heroId];
-                console.log(`[GameDataSyncManager]: 英雄删除成功，本地数据已同步`);
-                return true;
-            } else {
-                console.warn(`[GameDataSyncManager]: 英雄删除失败: ${result.result.msg}`);
-                return false;
-            }
-        } catch (error) {
-            console.error(`[GameDataSyncManager]: 删除英雄异常:`, error);
-            return false;
-        }
-    }
-
-    // ==================== 库存管理 (items, tals, equips) ====================
-
-    /**
-     * 增加指定物品的数量
-     * @param type 库存类型 ('items', 'tals', 'equips')
-     * @param itemId 物品ID
-     * @param count 添加数量
-     * @returns 是否成功
-     */
-    async addInventoryItem(type: 'items' | 'tals' | 'equips', itemId: number, count: number): Promise<boolean> {
-        try {
-            console.log(`[GameDataSyncManager]: 增加库存物品 类型:${type}, ID:${itemId}, 数量:${count}`);
-            
-            const result = await WxCloudApi.addInventoryItem(type, itemId, count);
-            
-            if (result.result.code === 200) {
-                // 远程修改成功，同步本地数据
-                const targetData = this.getTargetData(type);
-                targetData[itemId] = (targetData[itemId] || 0) + count;
-                console.log(`[GameDataSyncManager]: 库存物品增加成功，本地数据已同步`);
-                return true;
-            } else {
-                console.warn(`[GameDataSyncManager]: 库存物品增加失败: ${result.result.msg}`);
-                return false;
-            }
-        } catch (error) {
-            console.error(`[GameDataSyncManager]: 增加库存物品异常:`, error);
-            return false;
-        }
-    }
-
-    /**
-     * 消耗指定数量的物品
-     * @param type 库存类型 ('items', 'tals', 'equips')
-     * @param itemId 物品ID
-     * @param count 消耗数量
-     * @returns 是否成功
-     */
-    async consumeInventoryItem(type: 'items' | 'tals' | 'equips', itemId: number, count: number): Promise<boolean> {
-        try {
-            console.log(`[GameDataSyncManager]: 消耗库存物品 类型:${type}, ID:${itemId}, 数量:${count}`);
-            
-            const result = await WxCloudApi.consumeInventoryItem(type, itemId, count);
-            
-            if (result.result.code === 200) {
-                // 远程修改成功，同步本地数据
-                const targetData = this.getTargetData(type);
-                targetData[itemId] = Math.max(0, (targetData[itemId] || 0) - count);
-                console.log(`[GameDataSyncManager]: 库存物品消耗成功，本地数据已同步`);
-                return true;
-            } else {
-                console.warn(`[GameDataSyncManager]: 库存物品消耗失败: ${result.result.msg}`);
-                return false;
-            }
-        } catch (error) {
-            console.error(`[GameDataSyncManager]: 消耗库存物品异常:`, error);
-            return false;
-        }
-    }
-
-    /**
-     * 直接设置物品的数量
-     * @param type 库存类型 ('items', 'tals', 'equips')
-     * @param itemId 物品ID
-     * @param count 新的数量
-     * @returns 是否成功
-     */
-    async setInventoryItem(type: 'items' | 'tals' | 'equips', itemId: number, count: number): Promise<boolean> {
-        try {
-            console.log(`[GameDataSyncManager]: 设置库存物品 类型:${type}, ID:${itemId}, 数量:${count}`);
-            
-            const result = await WxCloudApi.setInventoryItem(type, itemId, count);
-            
-            if (result.result.code === 200) {
-                // 远程修改成功，同步本地数据
-                const targetData = this.getTargetData(type);
-                targetData[itemId] = count;
-                console.log(`[GameDataSyncManager]: 库存物品设置成功，本地数据已同步`);
-                return true;
-            } else {
-                console.warn(`[GameDataSyncManager]: 库存物品设置失败: ${result.result.msg}`);
-                return false;
-            }
-        } catch (error) {
-            console.error(`[GameDataSyncManager]: 设置库存物品异常:`, error);
-            return false;
-        }
-    }
-
-    /**
-     * 批量更新多个物品的数量
-     * @param type 库存类型 ('items', 'tals', 'equips')
-     * @param data 更新数据对象
-     * @param merge 是否合并更新（默认true）
-     * @returns 是否成功
-     */
-    async updateInventory(type: 'items' | 'tals' | 'equips', data: any, merge: boolean = true): Promise<boolean> {
-        try {
-            console.log(`[GameDataSyncManager]: 批量更新库存 类型:${type}, 数据:`, data);
-            
-            const result = await WxCloudApi.updateInventory(type, data, merge);
-            
-            if (result.result.code === 200) {
-                // 远程修改成功，同步本地数据
-                const targetData = this.getTargetData(type);
-                if (merge) {
-                    Object.assign(targetData, data);
-                } else {
-                    Object.keys(targetData).forEach(key => delete targetData[key]);
-                    Object.assign(targetData, data);
-                }
-                console.log(`[GameDataSyncManager]: 库存批量更新成功，本地数据已同步`);
-                return true;
-            } else {
-                console.warn(`[GameDataSyncManager]: 库存批量更新失败: ${result.result.msg}`);
-                return false;
-            }
-        } catch (error) {
-            console.error(`[GameDataSyncManager]: 批量更新库存异常:`, error);
-            return false;
-        }
-    }
-
-    /**
-     * 重置指定类型的库存为默认值
-     * @param type 库存类型 ('items', 'tals', 'equips')
-     * @returns 是否成功
-     */
-    async resetInventory(type: 'items' | 'tals' | 'equips'): Promise<boolean> {
-        try {
-            console.log(`[GameDataSyncManager]: 重置库存 类型:${type}`);
-            
-            const result = await WxCloudApi.resetInventory(type);
-            
-            if (result.result.code === 200) {
-                // 远程修改成功，同步本地数据
-                const targetData = this.getTargetData(type);
-                Object.keys(targetData).forEach(key => delete targetData[key]);
-                Object.assign(targetData, result.result.data);
-                console.log(`[GameDataSyncManager]: 库存重置成功，本地数据已同步`);
-                return true;
-            } else {
-                console.warn(`[GameDataSyncManager]: 库存重置失败: ${result.result.msg}`);
-                return false;
-            }
-        } catch (error) {
-            console.error(`[GameDataSyncManager]: 重置库存异常:`, error);
-            return false;
-        }
-    }
-
     // ==================== 便捷方法 ====================
 
     /**
@@ -424,7 +248,22 @@ export class GameDataSyncManager {
      * @returns 是否成功
      */
     async addItem(itemId: number, count: number): Promise<boolean> {
-        return this.addInventoryItem('items', itemId, count);
+        smc.items[itemId] = (smc.items[itemId] || 0) + count;
+        try {
+            console.log(`[GameDataSyncManager]: 增加道具 ID:${itemId}, 数量:${count}`);
+            const result = await WxCloudApi.addInventoryItem('items', itemId, count);
+            if (result.result.code === 200) {
+                // 远程修改成功，同步本地数据
+                console.log(`[GameDataSyncManager]: 道具增加成功`);
+                return true;
+            } else {
+                console.warn(`[GameDataSyncManager]: 道具增加失败: ${result.result.msg}`);
+                return false;
+            }
+        } catch (error) {
+            console.error(`[GameDataSyncManager]: 增加道具异常:`, error);
+            return false;
+        }
     }
 
     /**
@@ -434,9 +273,30 @@ export class GameDataSyncManager {
      * @returns 是否成功
      */
     async consumeItem(itemId: number, count: number): Promise<boolean> {
-        return this.consumeInventoryItem('items', itemId, count);
+        if(!smc.items[itemId]||smc.items[itemId]<count){
+            oops.gui.toast("道具数量不足")
+            return false
+        }
+        try {
+            console.log(`[GameDataSyncManager]: 消耗道具 ID:${itemId}, 数量:${count}`);
+            const result = await WxCloudApi.consumeInventoryItem('items', itemId, count);
+            if (result.result.code === 200) {
+                // 远程修改成功，同步本地数据
+                smc.items[itemId] = Math.max(0, (smc.items[itemId] || 0) - count);
+                console.log(`[GameDataSyncManager]: 道具消耗成功，本地数据已同步`);
+                return true;
+            } else {
+                console.warn(`[GameDataSyncManager]: 道具消耗失败: ${result.result.msg}`);
+                return false;
+            }
+        } catch (error) {
+            console.error(`[GameDataSyncManager]: 消耗道具异常:`, error);
+            return false;
+        }
     }
 
+
+    
     /**
      * 增加天赋点
      * @param talId 天赋ID
@@ -444,7 +304,24 @@ export class GameDataSyncManager {
      * @returns 是否成功
      */
     async addTalent(talId: number, count: number): Promise<boolean> {
-        return this.addInventoryItem('tals', talId, count);
+        try {
+            console.log(`[GameDataSyncManager]: 增加天赋点 ID:${talId}, 数量:${count}`);
+            
+            const result = await WxCloudApi.addInventoryItem('tals', talId, count);
+            
+            if (result.result.code === 200) {
+                // 远程修改成功，同步本地数据
+                smc.tals[talId] = (smc.tals[talId] || 0) + count;
+                console.log(`[GameDataSyncManager]: 天赋点增加成功，本地数据已同步`);
+                return true;
+            } else {
+                console.warn(`[GameDataSyncManager]: 天赋点增加失败: ${result.result.msg}`);
+                return false;
+            }
+        } catch (error) {
+            console.error(`[GameDataSyncManager]: 增加天赋点异常:`, error);
+            return false;
+        }
     }
 
     /**
@@ -454,7 +331,51 @@ export class GameDataSyncManager {
      * @returns 是否成功
      */
     async consumeTalent(talId: number, count: number): Promise<boolean> {
-        return this.consumeInventoryItem('tals', talId, count);
+        try {
+            console.log(`[GameDataSyncManager]: 消耗天赋点 ID:${talId}, 数量:${count}`);
+            
+            const result = await WxCloudApi.consumeInventoryItem('tals', talId, count);
+            
+            if (result.result.code === 200) {
+                // 远程修改成功，同步本地数据
+                smc.tals[talId] = Math.max(0, (smc.tals[talId] || 0) - count);
+                console.log(`[GameDataSyncManager]: 天赋点消耗成功，本地数据已同步`);
+                return true;
+            } else {
+                console.warn(`[GameDataSyncManager]: 天赋点消耗失败: ${result.result.msg}`);
+                return false;
+            }
+        } catch (error) {
+            console.error(`[GameDataSyncManager]: 消耗天赋点异常:`, error);
+            return false;
+        }
+    }
+
+    /**
+     * 设置天赋点数量
+     * @param talId 天赋ID
+     * @param count 数量
+     * @returns 是否成功
+     */
+    async setTalent(talId: number, count: number): Promise<boolean> {
+        try {
+            console.log(`[GameDataSyncManager]: 设置天赋点数量 ID:${talId}, 数量:${count}`);
+            
+            const result = await WxCloudApi.setInventoryItem('tals', talId, count);
+            
+            if (result.result.code === 200) {
+                // 远程修改成功，同步本地数据
+                smc.tals[talId] = count;
+                console.log(`[GameDataSyncManager]: 天赋点数量设置成功，本地数据已同步`);
+                return true;
+            } else {
+                console.warn(`[GameDataSyncManager]: 天赋点数量设置失败: ${result.result.msg}`);
+                return false;
+            }
+        } catch (error) {
+            console.error(`[GameDataSyncManager]: 设置天赋点数量异常:`, error);
+            return false;
+        }
     }
 
     /**
@@ -464,7 +385,24 @@ export class GameDataSyncManager {
      * @returns 是否成功
      */
     async addEquipment(equipId: number, count: number): Promise<boolean> {
-        return this.addInventoryItem('equips', equipId, count);
+        try {
+            console.log(`[GameDataSyncManager]: 增加装备 ID:${equipId}, 数量:${count}`);
+            
+            const result = await WxCloudApi.addInventoryItem('equips', equipId, count);
+            
+            if (result.result.code === 200) {
+                // 远程修改成功，同步本地数据
+                smc.equips[equipId] = (smc.equips[equipId] || 0) + count;
+                console.log(`[GameDataSyncManager]: 装备增加成功，本地数据已同步`);
+                return true;
+            } else {
+                console.warn(`[GameDataSyncManager]: 装备增加失败: ${result.result.msg}`);
+                return false;
+            }
+        } catch (error) {
+            console.error(`[GameDataSyncManager]: 增加装备异常:`, error);
+            return false;
+        }
     }
 
     /**
@@ -474,29 +412,55 @@ export class GameDataSyncManager {
      * @returns 是否成功
      */
     async consumeEquipment(equipId: number, count: number): Promise<boolean> {
-        return this.consumeInventoryItem('equips', equipId, count);
-    }
-
-    // ==================== 私有辅助方法 ====================
-
-    /**
-     * 根据类型获取对应的目标数据对象
-     * @param type 库存类型
-     * @returns 对应的数据对象
-     */
-    private getTargetData(type: 'items' | 'tals' | 'equips'): any {
-        switch (type) {
-            case 'items':
-                return smc.itmes;
-            case 'tals':
-                return smc.tals;
-            case 'equips':
-                return smc.equips;
-            default:
-                throw new Error(`未知的库存类型: ${type}`);
+        try {
+            console.log(`[GameDataSyncManager]: 消耗装备 ID:${equipId}, 数量:${count}`);
+            
+            const result = await WxCloudApi.consumeInventoryItem('equips', equipId, count);
+            
+            if (result.result.code === 200) {
+                // 远程修改成功，同步本地数据
+                smc.equips[equipId] = Math.max(0, (smc.equips[equipId] || 0) - count);
+                console.log(`[GameDataSyncManager]: 装备消耗成功，本地数据已同步`);
+                return true;
+            } else {
+                console.warn(`[GameDataSyncManager]: 装备消耗失败: ${result.result.msg}`);
+                return false;
+            }
+        } catch (error) {
+            console.error(`[GameDataSyncManager]: 消耗装备异常:`, error);
+            return false;
         }
     }
 
+    /**
+     * 设置装备数量
+     * @param equipId 装备ID
+     * @param count 数量
+     * @returns 是否成功
+     */
+    async setEquipment(equipId: number, count: number): Promise<boolean> {
+        try {
+            console.log(`[GameDataSyncManager]: 设置装备数量 ID:${equipId}, 数量:${count}`);
+            
+            const result = await WxCloudApi.setInventoryItem('equips', equipId, count);
+            
+            if (result.result.code === 200) {
+                // 远程修改成功，同步本地数据
+                smc.equips[equipId] = count;
+                console.log(`[GameDataSyncManager]: 装备数量设置成功，本地数据已同步`);
+                return true;
+            } else {
+                console.warn(`[GameDataSyncManager]: 装备数量设置失败: ${result.result.msg}`);
+                return false;
+            }
+        } catch (error) {
+            console.error(`[GameDataSyncManager]: 设置装备数量异常:`, error);
+            return false;
+        }
+    }
+
+
+
     /**
      * 从云端加载所有游戏数据并同步到本地
      * @returns 是否成功
@@ -513,7 +477,7 @@ export class GameDataSyncManager {
                 smc.data = cloudData.data;
                 smc.fight_heros = cloudData.fight_heros;
                 smc.heros = cloudData.heros;
-                smc.itmes = cloudData.items;
+                smc.items = cloudData.items;
                 smc.tals = cloudData.tals;
                 smc.equips = cloudData.equips;
                 
@@ -545,23 +509,31 @@ export const gameDataSyncManager = GameDataSyncManager.getInstance();
 使用示例：
 
 // 1. 出战英雄管理
-await gameDataSyncManager.setFightHero(0, 5001);           // 设置位置0的英雄
-await gameDataSyncManager.swapFightHeros(0, 1);            // 交换位置0和1的英雄
 await gameDataSyncManager.updateFightHeros({0: 5001, 1: 5005}); // 批量更新
+await gameDataSyncManager.resetFightHeros();                     // 重置为默认配置
 
 // 2. 英雄管理
-await gameDataSyncManager.addHero(5008, {uuid: 5008, lv: 1}); // 添加新英雄
-await gameDataSyncManager.levelUpHero(5001, 5);                // 英雄升级5级
-await gameDataSyncManager.setHeroProperty(5001, "exp", 1000);  // 设置英雄经验
+await gameDataSyncManager.addHero(5008, {uuid: 5008, lv: 1});  // 添加新英雄
+await gameDataSyncManager.levelUpHero(5001, 100, 50, 5);       // 英雄升级5级
+await gameDataSyncManager.setHeroProperty(5001, "exp", 1000);   // 设置英雄经验
 
-// 3. 库存管理
+// 3. 道具管理 (items)
 await gameDataSyncManager.addItem(1001, 10);                    // 增加道具
-await gameDataSyncManager.consumeItem(1001, 2);                // 消耗道具
-await gameDataSyncManager.addTalent(2001, 5);                  // 增加天赋点
-await gameDataSyncManager.addEquipment(3001, 2);               // 增加装备
+await gameDataSyncManager.consumeItem(1001, 2);                 // 消耗道具
+await gameDataSyncManager.setItem(1001, 5);                     // 设置道具数量
 
-// 4. 数据加载
-await gameDataSyncManager.loadAllGameData();                    // 从云端加载所有数据
+// 4. 天赋点管理 (tals)
+await gameDataSyncManager.addTalent(2001, 5);                   // 增加天赋点
+await gameDataSyncManager.consumeTalent(2001, 2);               // 消耗天赋点
+await gameDataSyncManager.setTalent(2001, 10);                  // 设置天赋点数量
+
+// 5. 装备管理 (equips)
+await gameDataSyncManager.addEquipment(3001, 2);                // 增加装备
+await gameDataSyncManager.consumeEquipment(3001, 1);            // 消耗装备
+await gameDataSyncManager.setEquipment(3001, 3);                // 设置装备数量
+
+// 6. 数据加载
+await gameDataSyncManager.loadAllGameData();                     // 从云端加载所有数据
 
 注意：所有方法都返回 Promise<boolean>，true表示成功，false表示失败
 只有在远程修改成功后，本地数据才会被同步修改