奖励已经双倍奖励

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表示失败
 只有在远程修改成功后，本地数据才会被同步修改

assets/script/game/common/SingletonModuleComp.ts

@@ -42,7 +42,7 @@ export class SingletonModuleComp extends ecs.Comp {
         5005:{uuid:5005,lv:1},
         5007:{uuid:5007,lv:1},
     };
-    itmes:any={
+    items:any={
     }
     tals:any={
     }
@@ -151,10 +151,17 @@ export class SingletonModuleComp extends ecs.Comp {
 
 
     // ==================== 统一的数据操作接口 ====================
-
+  
     /**
      * 增加游戏数据属性（统一接口）
      * @param property 属性名
+     * property list:
+     * ***gold:金币
+     * ***diamond:钻石
+     * ***meat:肉
+     * ***exp:经验
+     * ***score:分数
+     * ***mission:关卡
      * @param value 增加的值
      * @param autoSave 是否自动保存 (默认true)
      * @returns 操作结果
@@ -221,6 +228,14 @@ export class SingletonModuleComp extends ecs.Comp {
 
         return true;
     }
+    addItem(item_uuid:number,count:number,autoSave:boolean=true){
+        if(this.isWxClient()){
+            this.gameDataSyncManager.addItem(item_uuid,count);
+        }
+        else{
+            this.items[item_uuid] = (this.items[item_uuid] || 0) + count;
+        }
+    }
 
 }
 

assets/script/game/common/config/GameUIConfig.ts

@@ -19,6 +19,7 @@ export enum UIID {
     HeroInfo,
     Victory,
     HeroSelect,
+    ItemInfo,
     // Shop_Page,
     // Hero_Page,
 }
@@ -32,6 +33,7 @@ export var UIConfigData: { [key: number]: UIConfig } = {
     [UIID.HeroInfo]: { layer: LayerType.UI, prefab: "gui/Hinfo" },
     [UIID.Victory]: { layer: LayerType.UI, prefab: "gui/element/victory" },
     [UIID.HeroSelect]: { layer: LayerType.UI, prefab: "gui/hero_select" },
+    [UIID.ItemInfo]: { layer: LayerType.UI, prefab: "gui/element/item_info" },
     // [UIID.Shop_Page]: { layer: LayerType.UI, prefab: "gui/shop_page" },
     // [UIID.Hero_Page]: { layer: LayerType.UI, prefab: "gui/heros_page" },
     // [UIID.Toast]: { layer: LayerType.PopUp, prefab: "common/prefab/toast" },

assets/script/game/common/config/Items.ts

@@ -1,31 +1,217 @@
-/*
-type:
-     1 普通消耗品，武器升级或技能升级原材料
-     2 可双击打开，如宝箱，
-  ghstone:0, //英雄石 绿色 普通英雄升星
-        bhstone:0, //英雄石 蓝色 稀有英雄升星
-        phlestone:0, //英雄石 紫色 史诗英雄升星
-        rhstone:0, //英雄石 红色 传说英雄升星
-        herocard:0, //英雄卡,抽卡凭证
-        ckey:0, //铜钥匙 解锁稀有英雄 也可以直接兑换金币
-        skey:0, //银钥匙 解锁史诗英雄 也可以直接兑换金币
-        gkey:0, //金钥匙 解锁传说英雄 也可以直接兑换金币
-
-
-*/
-
+import * as exp from "constants";
 import { QualitySet } from "./BoxSet";
 
-
-export const Items={
-     1001:{uuid: 1001,path: "1001",type:1,quality:QualitySet.GREEN,name: "经验药水",info:"增加英雄经验", },
-     1002:{uuid: 1002,path: "1002",type:1,quality:QualitySet.BLUE,name: "绿色英雄石",info:"稀有英雄升星必须材料", },
-     1003:{uuid: 1003,path: "1003",type:1,quality:QualitySet.BLUE,name: "蓝色英雄石",info:"史诗英雄升星必须材料", }, 
-     1004:{uuid: 1004,path: "1004",type:1,quality:QualitySet.PURPLE,name: "紫色英雄石",info:"传说英雄升星必须材料", },
-     1005:{uuid: 1005,path: "1005",type:1,quality:QualitySet.ORANGE,name: "红色英雄石",info:"传说英雄升星必须材料", },
-     1006:{uuid: 1006,path: "1006",type:1,quality:QualitySet.GREEN,name: "招募劵",info:"可以在英雄酒馆招募英雄", },
-     1007:{uuid: 1007,path: "1007",type:1,quality:QualitySet.BLUE,name: "铜钥匙",info:"解锁稀有英雄 也可以直接兑换金币", },
-     1008:{uuid: 1008,path: "1008",type:1,quality:QualitySet.PURPLE,name: "银钥匙",info:"解锁史诗英雄 也可以直接兑换金币", },
-     1009:{uuid: 1009,path: "1009",type:1,quality:QualitySet.ORANGE,name: "金钥匙",info:"解锁传说英雄 也可以直接兑换金币", },
+export enum ItemType{
+     NORMAL=0,//普通
+     SPECIAL=1,//特殊 可双击打开
+     EQUIP=2,//装备
+}
+
+// 掉落物品接口
+export interface DropItem {
+    item_uuid: number;      // 物品ID
+    probability: number; // 掉落概率 (0-1之间)
+    minCount: number;    // 最小掉落数量
+    maxCount: number;    // 最大掉落数量
+    baseCount: number;   // 基础掉落数量
+    growthRate: number;  // 增长参数
+}
+
+// 怪物掉落配置接口
+export interface MonsterDropConfig {
+    monsterId: number;           // 怪物ID
+    quality: QualitySet;         // 怪物品质
+    drops: DropItem[];           // 掉落物品列表
+}
+
+export const Items={
+    1001:{uuid: 1001,path: "1001",type:1,quality:QualitySet.GREEN,name: "绿色英雄石",info:"稀有英雄升星必须材料", },
+    1002:{uuid: 1002,path: "1002",type:1,quality:QualitySet.BLUE,name: "蓝色英雄石",info:"史诗英雄升星必须材料", }, 
+    1003:{uuid: 1003,path: "1003",type:1,quality:QualitySet.PURPLE,name: "紫色英雄石",info:"传说英雄升星必须材料", },
+    1004:{uuid: 1004,path: "1004",type:1,quality:QualitySet.ORANGE,name: "红色英雄石",info:"传说英雄升星必须材料", },
+    1005:{uuid: 1005,path: "1005",type:1,quality:QualitySet.ORANGE,name: "招募劵",info:"可以在英雄酒馆招募英雄", },
+    1006:{uuid: 1006,path: "1006",type:1,quality:QualitySet.BLUE,name: "铜钥匙",info:"解锁稀有英雄 也可以直接兑换金币", },
+    1007:{uuid: 1007,path: "1007",type:1,quality:QualitySet.PURPLE,name: "银钥匙",info:"解锁史诗英雄 也可以直接兑换金币", },
+    1008:{uuid: 1008,path: "1008",type:1,quality:QualitySet.ORANGE,name: "金钥匙",info:"解锁传说英雄 也可以直接兑换金币", },
+}
+
+export enum DropKey{
+    ItemUUId=0,    // 物品ID
+    Pro=1,         // 概率
+    Diff=2,        // 上下限差值
+    Base=3,        // 基础数量
+    GrowthRate=4,  // 增长参数
+}
+
+// 怪物掉落配置表 - 按照DropKey顺序配置
+export const MonsterDropTable: { [monsterId: number]: [number, number, number, number, number][] } = {
+    // 普通怪物 - 绿色品质
+    5201: [ // 兽人战士
+        [Items[1001].uuid, 1.0, 0, 1, 0.2],  // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
+        [Items[1006].uuid, 0.3, 0, 1, 0.1]   // [item_uuid, probability, diff, baseCount, growthRate] - 30%概率掉落铜钥匙
+    ],
+    5202: [ // 兽人刺客
+        [Items[1001].uuid, 1.0, 0, 1, 0.2],  // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
+        [Items[1006].uuid, 0.4, 0, 1, 0.1]   // [item_uuid, probability, diff, baseCount, growthRate] - 40%概率掉落铜钥匙
+    ],
+    5203: [ // 兽人护卫
+        [Items[1001].uuid, 1.0, 0, 1, 0.2],  // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
+        [Items[1006].uuid, 0.3, 0, 1, 0.1]   // [item_uuid, probability, diff, baseCount, growthRate] - 30%概率掉落铜钥匙
+    ],
+    5204: [ // 石卫
+        [Items[1001].uuid, 1.0, 0, 1, 0.2],  // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
+        [Items[1006].uuid, 0.35, 0, 1, 0.1]  // [item_uuid, probability, diff, baseCount, growthRate] - 35%概率掉落铜钥匙
+    ],
+    5205: [ // 土卫
+        [Items[1001].uuid, 1.0, 0, 1, 0.2],  // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
+        [Items[1006].uuid, 0.35, 0, 1, 0.1]  // [item_uuid, probability, diff, baseCount, growthRate] - 35%概率掉落铜钥匙
+    ],
+    5206: [ // 树卫
+        [Items[1001].uuid, 1.0, 0, 1, 0.2],  // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
+        [Items[1006].uuid, 0.35, 0, 1, 0.1]  // [item_uuid, probability, diff, baseCount, growthRate] - 35%概率掉落铜钥匙
+    ],
+    5219: [ // 牛头战士
+        [Items[1001].uuid, 1.0, 1, 1, 0.25], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1-2个绿色英雄石
+        [Items[1006].uuid, 0.4, 0, 1, 0.15]  // [item_uuid, probability, diff, baseCount, growthRate] - 40%概率掉落铜钥匙
+    ],
+    5220: [ // 牛头战士
+        [Items[1001].uuid, 1.0, 0, 1, 0.2],  // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
+        [Items[1006].uuid, 0.3, 0, 1, 0.1]   // [item_uuid, probability, diff, baseCount, growthRate] - 30%概率掉落铜钥匙
+    ],
+    5221: [ // 牛头战士
+        [Items[1001].uuid, 1.0, 0, 1, 0.2],  // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
+        [Items[1006].uuid, 0.4, 0, 1, 0.1]   // [item_uuid, probability, diff, baseCount, growthRate] - 40%概率掉落铜钥匙
+    ],
+    5222: [ // 独眼巨人
+        [Items[1001].uuid, 1.0, 0, 1, 0.2],  // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
+        [Items[1006].uuid, 0.3, 0, 1, 0.1]   // [item_uuid, probability, diff, baseCount, growthRate] - 30%概率掉落铜钥匙
+    ],
+    5223: [ // 独眼巨人
+        [Items[1001].uuid, 1.0, 0, 1, 0.2],  // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
+        [Items[1006].uuid, 0.3, 0, 1, 0.1]   // [item_uuid, probability, diff, baseCount, growthRate] - 30%概率掉落铜钥匙
+    ],
+    5224: [ // 独眼巨人
+        [Items[1001].uuid, 1.0, 0, 1, 0.2],  // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
+        [Items[1006].uuid, 0.4, 0, 1, 0.1]   // [item_uuid, probability, diff, baseCount, growthRate] - 40%概率掉落铜钥匙
+    ],
+
+    // 精英怪物 - 蓝色品质
+    5225: [ // 精英独眼
+        [Items[1001].uuid, 1.0, 1, 2, 0.3],  // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落2-3个绿色英雄石
+        [Items[1002].uuid, 1.0, 0, 1, 0.25], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个蓝色英雄石
+        [Items[1006].uuid, 0.6, 1, 1, 0.2],  // [item_uuid, probability, diff, baseCount, growthRate] - 60%概率掉落铜钥匙
+        [Items[1007].uuid, 0.2, 0, 1, 0.15]  // [item_uuid, probability, diff, baseCount, growthRate] - 20%概率掉落银钥匙
+    ],
+    5226: [ // 精英牛头
+        [Items[1001].uuid, 1.0, 1, 2, 0.3],  // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落2-3个绿色英雄石
+        [Items[1002].uuid, 1.0, 0, 1, 0.25], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个蓝色英雄石
+        [Items[1006].uuid, 0.6, 1, 1, 0.2],  // [item_uuid, probability, diff, baseCount, growthRate] - 60%概率掉落铜钥匙
+        [Items[1007].uuid, 0.2, 0, 1, 0.15]  // [item_uuid, probability, diff, baseCount, growthRate] - 20%概率掉落银钥匙
+    ],
+    5227: [ // 精英兽人
+        [Items[1001].uuid, 1.0, 1, 2, 0.3],  // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落2-3个绿色英雄石
+        [Items[1002].uuid, 1.0, 0, 1, 0.25], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个蓝色英雄石
+        [Items[1006].uuid, 0.6, 1, 1, 0.2],  // [item_uuid, probability, diff, baseCount, growthRate] - 60%概率掉落铜钥匙
+        [Items[1007].uuid, 0.2, 0, 1, 0.15]  // [item_uuid, probability, diff, baseCount, growthRate] - 20%概率掉落银钥匙
+    ]
+};
+
+// 怪物掉落管理器
+export class MonsterDropManager {
+    
+    /**
+     * 根据怪物ID获取掉落配置
+     * @param monsterId 怪物ID
+     * @returns 掉落配置
+     */
+    static getDropConfig(monsterId: number): [number, number, number, number, number][] | null {
+        return MonsterDropTable[monsterId] || null;
+    }
+    
+    /**
+     * 计算指定关卡数的掉落数量
+     * @param baseCount 基础数量
+     * @param growthRate 增长参数
+     * @param stageNumber 关卡数
+     * @param diff 上下限差值
+     * @returns 计算后的掉落数量
+     */
+    static calculateDropCount(baseCount: number, growthRate: number, stageNumber: number, diff: number): number {
+        // 公式：基础数量 * 增长参数 * 关卡数 + (0-差值的随机数)
+        const calculatedCount = baseCount * growthRate * stageNumber;
+        const randomBonus = Math.floor(Math.random() * (diff + 1)); // 0到diff的随机数
+        const finalCount = calculatedCount + randomBonus;
+        
+        // 允许掉落数量为0
+        return Math.max(0, Math.floor(finalCount));
+    }
+    
+    /**
+     * 计算怪物掉落物品
+     * @param monsterId 怪物ID
+     * @param stageNumber 关卡数
+     * @param playerLuck 玩家幸运值加成
+     * @returns 掉落物品数组
+     */
+    static calculateMonsterDrops(monsterId: number, stageNumber: number, playerLuck: number = 0): Array<{item_uuid: number, count: number}> {
+        const dropArray = this.getDropConfig(monsterId);
+        if (!dropArray) {
+            console.warn(`[MonsterDropManager]: No drop config found for monster ${monsterId}`);
+            return [];
+        }
+        
+        const result: Array<{item_uuid: number, count: number}> = [];
+        const luckBonus = 1 + (playerLuck * 0.01); // 幸运值加成
+        
+        // 处理所有掉落物品（统一按概率处理）
+        dropArray.forEach(dropData => {
+            const [item_uuid, probability, diff, baseCount, growthRate] = dropData;
+            
+            if (Math.random() < probability) {
+                // 使用新的计算公式：基础值*关卡数*增长参数+(0-差值的随机数)
+                const finalCount = this.calculateDropCount(baseCount, growthRate, stageNumber, diff);
+                const countWithLuck = Math.floor(finalCount * luckBonus);
+                
+                result.push({
+                    item_uuid: item_uuid,
+                    count: Math.max(1, countWithLuck) // 确保至少掉落1个
+                });
+            }
+        });
+        
+        return result;
+    }
+    
+    /**
+     * 预览指定关卡数的掉落数量（不包含随机因素）
+     * @param monsterId 怪物ID
+     * @param stageNumber 关卡数
+     * @returns 掉落物品预览数组
+     */
+    static previewMonsterDrops(monsterId: number, stageNumber: number): Array<{item_uuid: number, baseCount: number, calculatedCount: number, maxCount: number}> {
+        const dropArray = this.getDropConfig(monsterId);
+        if (!dropArray) {
+            console.warn(`[MonsterDropManager]: No drop config found for monster ${monsterId}`);
+            return [];
+        }
+        
+        const result: Array<{item_uuid: number, baseCount: number, calculatedCount: number, maxCount: number}> = [];
+        
+        // 处理所有掉落物品
+        dropArray.forEach(dropData => {
+            const [item_uuid, probability, diff, baseCount, growthRate] = dropData;
+            const calculatedCount = baseCount * growthRate * stageNumber;
+            const maxCount = calculatedCount + diff;
+            
+            result.push({
+                item_uuid: item_uuid,
+                baseCount: baseCount,
+                calculatedCount: Math.floor(calculatedCount),
+                maxCount: Math.floor(maxCount)
+            });
+        });
+        
+        return result;
+    }
 }
 

assets/script/game/hero/HeroViewComp.ts

@@ -13,6 +13,7 @@ import { EquipSpecialAttr } from "../common/config/Equips";
 import { FightSet, getExpDrops, getStoneDrops, TooltipTypes } from "../common/config/Mission";
 import { RandomManager } from "db://oops-framework/core/common/random/RandomManager";
 import { EnhancementType } from "../common/config/LevelUp";
+import { MonsterDropManager } from "../common/config/Items";
 const { ccclass, property } = _decorator;
 
 
@@ -254,11 +255,16 @@ export class HeroViewComp extends CCComp {
         this.is_count_dead=true
         if(this.fac==FacSet.MON){
             this.scheduleOnce(()=>{
-                oops.message.dispatchEvent(GameEvent.MonDead)
+                let drop_item=this.do_drop()
+                if(drop_item.length>0){
+                    oops.message.dispatchEvent(GameEvent.MonDead,{mon_uuid:this.hero_uuid,drops:drop_item})
+                }   
              },0.1)
         }
         if(this.fac==FacSet.HERO){
-            oops.message.dispatchEvent(GameEvent.HeroDead)
+            this.scheduleOnce(()=>{
+                oops.message.dispatchEvent(GameEvent.HeroDead,{hero_uuid:this.hero_uuid})
+            },0.1)
         }
        
         if(this.fac==FacSet.HERO){
@@ -268,7 +274,11 @@ export class HeroViewComp extends CCComp {
 
        
     }
-
+    do_drop(){
+        let drop_item=MonsterDropManager.calculateMonsterDrops(this.hero_uuid,smc.data.mission,1)
+        console.log("[HeroViewComp]:do_drop",this.hero_uuid,drop_item)
+        return drop_item
+    }
     add_debuff(type:number,deV:number,deC:number,deR:number){
         let n_deR=deR-this.Attrs[BuffAttr.DEBUFF_DOWN]
         let r=RandomManager.instance.getRandomInt(0,100) // 随机数

assets/script/game/hero/SkillConComp.ts

@@ -52,7 +52,7 @@ export class SkillConComp extends CCComp {
             }
             if(skills[1]){
                 if(this.HeroView.fac==FacSet.HERO) {
-                    console.log("[SkillConComp] 角色状态:",this.HeroView.hero_name+"=>能量:"+this.HeroView.power+"/"+this.HeroView.power_max,skills)
+                    // console.log("[SkillConComp] 角色状态:",this.HeroView.hero_name+"=>能量:"+this.HeroView.power+"/"+this.HeroView.power_max,skills)
                 }
                 this.HeroView.power+=(1+this.HeroView.Attrs[BuffAttr.POWER_UP])*dt*SKILL_CONST.POWER_UP
                 let progress=this.HeroView.power/this.HeroView.power_max
@@ -223,7 +223,7 @@ export class SkillConComp extends CCComp {
 
     onDestroy() {
         // 清理所有定时器
-        console.log("[SkillConComp]:onDestroy:",this.node.name)
+        // console.log("[SkillConComp]:onDestroy:",this.node.name)
         Object.values(this._timers).forEach(clearTimeout);
         this._timers = {};
         // 移除事件监听

assets/script/game/map/ItemComp.ts

@@ -0,0 +1,222 @@
+import { _decorator, Component, Node, Label, Sprite, resources, SpriteFrame } from 'cc';
+import { Items } from '../common/config/Items';
+import { QualitySet } from '../common/config/BoxSet';
+import { oops } from 'db://oops-framework/core/Oops';
+import { UIID } from '../common/config/GameUIConfig';
+const { ccclass, property } = _decorator;
+
+@ccclass('ItemComp')
+export class ItemComp extends Component {
+    item_uuid: number = 0;
+    item_count: number = 1;
+    type: number = 0;
+    slot: number = 0;
+    no_show:boolean=false
+
+
+
+    start() {
+        console.log("[ItemComp]:start");
+    }
+
+    update(deltaTime: number) {
+        
+    }
+
+    /**
+     * 更新物品数据
+     * @param hero_uuid 物品ID
+     * @param count 物品数量
+     * @param args 额外参数
+     */
+    update_data(hero_uuid: number, count: number = 1, args: any = {}) {
+        this.item_uuid = hero_uuid;
+        this.item_count = count;
+        this.type = args.type || 0;
+        this.slot = args.slot || 0;
+        this.no_show = args.no_show || false;
+        console.log("[ItemComp]:update_data", hero_uuid, count, this.type, this.slot, args);
+
+        // 获取物品配置
+        const itemData = Items[hero_uuid];
+        if (!itemData) {
+            console.error("[ItemComp]: Item not found", hero_uuid);
+            return;
+        }
+
+        // 设置物品图标
+        this.setItemIcon(itemData.path);
+
+        // 设置品质边框
+        this.setQualityFrame(itemData.quality);
+
+        // 设置数量显示
+        this.setItemCount(count);
+
+        // 设置选中状态
+        if (args.selected) {
+            this.setSelected(true);
+        } else {
+            this.setSelected(false);
+        }
+    }
+
+    /**
+     * 设置物品图标
+     * @param iconPath 图标路径
+     */
+    private setItemIcon(iconPath: string) {
+        let path=`gui/items/${iconPath}`
+        console.log("[ItemComp]: setItemIcon", path);
+        resources.load(path, SpriteFrame, (err, spriteFrame) => {
+            if (err) {
+                console.error("[ItemComp]: Failed to load item icon", iconPath, err);
+                return;
+            }
+            console.log("[ItemComp]: setItemIcon", iconPath, spriteFrame);
+            this.node.getChildByName("icon").getComponent(Sprite)!.spriteFrame = spriteFrame;
+        });
+    }
+
+    /**
+     * 设置品质边框
+     * @param quality 品质类型
+     */
+    private setQualityFrame(quality: QualitySet) {
+        // 隐藏所有品质边框
+        this.hideAllQualityFrames();
+
+        // 根据品质显示对应边框
+        switch (quality) {
+            case QualitySet.GREEN:
+                this.node.getChildByName("q1").active = true;
+                break;
+            case QualitySet.BLUE:
+                this.node.getChildByName("q2").active = true;
+                break;
+            case QualitySet.PURPLE:
+                this.node.getChildByName("q3").active = true;
+                break;
+            case QualitySet.ORANGE:
+                this.node.getChildByName("q4").active = true;
+                break;
+            default:
+                // 默认使用绿色边框
+                this.node.getChildByName("q").active = true;
+                break;
+        }
+    }
+
+    /**
+     * 隐藏所有品质边框
+     */
+    private hideAllQualityFrames() {
+        this.node.getChildByName("q").active = false;
+        this.node.getChildByName("q1").active = false;
+        this.node.getChildByName("q2").active = false;
+        this.node.getChildByName("q3").active = false;
+        this.node.getChildByName("q4").active = false;
+        this.node.getChildByName("focus").active = false;
+    }
+
+    /**
+     * 设置物品数量
+     * @param count 数量
+     */
+    private setItemCount(count: number) {
+        this.node.getChildByName("num").getComponent(Label)!.string = count.toString();
+    }
+
+    /**
+     * 设置选中状态
+     * @param selected 是否选中
+     */
+    private setSelected(selected: boolean) {
+        this.node.getChildByName("focus").active = selected;
+    }
+
+    /**
+     * 物品点击事件
+     */
+    do_click() {
+        console.log("[ItemComp]: Item clicked", this.item_uuid, this.item_count);
+        
+        // 根据类型处理不同逻辑
+        switch (this.type) {
+            case 1: // 普通点击
+                this.onItemClick();
+                break;
+            case 2: // 选择物品
+                this.onItemSelect();
+                break;
+            case 3: // 使用物品
+                this.onItemUse();
+                break;
+            default:
+                this.onItemClick();
+                break;
+        }
+    }
+
+    /**
+     * 普通物品点击
+     */
+    private onItemClick() {
+        // 显示物品信息或执行其他逻辑
+        console.log("[ItemComp]: Show item info", this.item_uuid);
+    }
+
+    /**
+     * 选择物品
+     */
+    private onItemSelect() {
+        // 处理物品选择逻辑
+        console.log("[ItemComp]: Item selected", this.item_uuid);
+    }
+
+    /**
+     * 使用物品
+     */
+    private onItemUse() {
+        // 处理物品使用逻辑
+        console.log("[ItemComp]: Use item", this.item_uuid);
+    }
+    show_item_info(){
+        if(this.no_show){
+            return
+        }
+        oops.gui.open(UIID.ItemInfo, { item_uuid: this.item_uuid ,count:this.item_count});
+    }
+    /**
+     * 获取物品UUID
+     */
+    getItemUUID(): number {
+        return this.item_uuid;
+    }
+
+    /**
+     * 获取物品数量
+     */
+    getItemCount(): number {
+        return this.item_count;
+    }
+    addItemCount(count:number){
+        this.item_count+=count
+        this.setItemCount(this.item_count)
+    }
+    /**
+     * 设置物品类型
+     */
+    setItemType(type: number) {
+        this.type = type;
+    }
+
+    /**
+     * 设置物品槽位
+     */
+    setItemSlot(slot: number) {
+        this.slot = slot;
+    }
+}
+
+

assets/script/game/map/ItemComp.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "691f8376-3937-42db-ae4b-771d4cc67b25",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

assets/script/game/map/ItemInfoComp.ts

@@ -0,0 +1,295 @@
+import { _decorator, Component, Node, Label, Sprite, resources, SpriteFrame, input, Input, EventTouch, EventMouse, Vec3, Vec2, UITransform, Color } from 'cc';
+import { Items } from '../common/config/Items';
+import { QualitySet } from '../common/config/BoxSet';
+import { oops } from 'db://oops-framework/core/Oops';
+const { ccclass, property } = _decorator;
+
+@ccclass('ItemInfoComp')
+export class ItemInfoComp extends Component {
+    item_uuid: number = 0;
+    item_count: number = 1;
+
+    // 触摸监听相关
+    private touchListener: any = null;
+    private isListening: boolean = false;
+
+    start() {
+        console.log("[ItemInfoComp]:start");
+    }
+
+    onAdded(args: any) {
+        console.log("[ItemInfoComp]:onAdded", args);
+        this.setupTouchListener();
+        this.update_data(args);
+    }
+
+    update(deltaTime: number) {
+        
+    }
+
+    onDestroy() {
+        this.removeTouchListener();
+    }
+
+    /**
+     * 设置触摸监听
+     */
+    private setupTouchListener() {
+        if (this.isListening) return;
+        // 监听触摸开始事件
+        this.touchListener = input.on(Input.EventType.TOUCH_START, this.onTouchStart, this);
+        this.isListening = true;
+        
+        console.log("[ItemInfoComp]: Touch listener setup");
+    }
+
+    /**
+     * 移除触摸监听
+     */
+    private removeTouchListener() {
+        if (this.touchListener && this.isListening) {
+            input.off(Input.EventType.TOUCH_START, this.onTouchStart, this);
+            this.isListening = false;
+            this.touchListener = null;
+            
+            console.log("[ItemInfoComp]: Touch listener removed");
+        }
+    }
+
+    /**
+     * 触摸开始事件处理
+     * @param event 触摸事件
+     */
+    private onTouchStart(event: EventTouch) {
+        const touchPos = event.getLocation();
+        const nodePos = this.node.getWorldPosition();
+        
+        // 检查触摸点是否在弹窗范围内
+        if (!this.isTouchInNodeBounds(touchPos, nodePos)) {
+            console.log("[ItemInfoComp]: Touch outside bounds, closing popup");
+            this.closeItemInfo();
+        }
+    }
+
+    /**
+     * 检查触摸点是否在节点范围内
+     * @param touchPos 触摸点世界坐标
+     * @param nodePos 节点世界坐标
+     * @returns 是否在范围内
+     */
+    private isTouchInNodeBounds(touchPos: Vec2, nodePos: Vec3): boolean {
+        const nodeSize = this.node.getComponent(UITransform)?.contentSize;
+        if (!nodeSize) return false;
+
+        // 计算节点的边界
+        const halfWidth = nodeSize.width * 0.5;
+        const halfHeight = nodeSize.height * 0.5;
+        
+        // 检查触摸点是否在节点范围内
+        const inX = Math.abs(touchPos.x - nodePos.x) <= halfWidth;
+        const inY = Math.abs(touchPos.y - nodePos.y) <= halfHeight;
+        
+        return inX && inY;
+    }
+
+    /**
+     * 更新物品数据
+     * @param args 物品参数 {item_uuid: number, count?: number}
+     */
+    update_data(args: any) {
+        console.log("[ItemInfoComp]:update_data", args);
+        
+        if (!args || !args.item_uuid) {
+            console.error("[ItemInfoComp]: Invalid args", args);
+            return;
+        }
+
+        this.item_uuid = args.item_uuid;
+        this.item_count = args.count || 1;
+
+        // 获取物品配置
+        const itemData = Items[this.item_uuid];
+        if (!itemData) {
+            console.error("[ItemInfoComp]: Item not found", this.item_uuid);
+            return;
+        }
+
+        // 设置物品图标
+        this.setItemIcon(itemData.path);
+
+        // 设置品质边框
+        this.setQualityFrame(itemData.quality);
+
+        // 设置品质文字描述
+        this.setQualityText(itemData.quality);
+
+        // 设置数量显示
+        this.setItemCount(this.item_count);
+
+        // 设置物品名称
+        this.setItemName(itemData.name);
+
+        // 设置物品描述
+        this.setItemInfo(itemData.info);
+    }
+
+    /**
+     * 设置物品图标
+     * @param iconPath 图标路径
+     */
+    private setItemIcon(iconPath: string) {
+        let path=`gui/items/${iconPath}`
+        console.log("[ItemComp]: setItemIcon", path);
+        resources.load(path, SpriteFrame, (err, spriteFrame) => {
+            if (err) {
+                console.error("[ItemComp]: Failed to load item icon", iconPath, err);
+                return;
+            }
+            console.log("[ItemComp]: setItemIcon", iconPath, spriteFrame);
+            this.node.getChildByName("item").getChildByName("icon").getComponent(Sprite)!.spriteFrame = spriteFrame;
+        });
+    }
+
+    /**
+     * 设置品质边框
+     * @param quality 品质类型
+     */
+    private setQualityFrame(quality: QualitySet) {
+        // 隐藏所有品质边框
+        this.hideAllQualityFrames();
+
+        // 根据品质显示对应边框
+        switch (quality) {
+            case QualitySet.GREEN:
+                this.node.getChildByName("item").getChildByName("q1").active = true;
+                break;
+            case QualitySet.BLUE:
+                this.node.getChildByName("item").getChildByName("q2").active = true;
+                break;
+            case QualitySet.PURPLE:
+                this.node.getChildByName("item").getChildByName("q3").active = true;
+                break;
+            case QualitySet.ORANGE:
+                this.node.getChildByName("item").getChildByName("q4").active = true;
+                break;
+            default:
+                // 默认使用绿色边框
+                this.node.getChildByName("item").getChildByName("q").active = true;
+                break;
+        }
+    }
+
+    /**
+     * 隐藏所有品质边框
+     */
+    private hideAllQualityFrames() {
+        this.node.getChildByName("item").getChildByName("q").active = false;
+        this.node.getChildByName("item").getChildByName("q1").active = false;
+        this.node.getChildByName("item").getChildByName("q2").active = false;
+        this.node.getChildByName("item").getChildByName("q3").active = false;
+        this.node.getChildByName("item").getChildByName("q4").active = false;
+    }
+
+    /**
+     * 设置物品数量
+     * @param count 数量
+     */
+    private setItemCount(count: number) {
+        if (count > 1) {
+            this.node.getChildByName("item").getChildByName("num").getComponent(Label)!.string = count.toString();
+            this.node.getChildByName("item").getChildByName("num").active = true;
+        } else {
+            this.node.getChildByName("item").getChildByName("num").active = false;
+        }
+    }
+
+    /**
+     * 设置物品名称
+     * @param name 物品名称
+     */
+    private setItemName(name: string) {
+        this.node.getChildByName("name").getComponent(Label)!.string = name;
+    }
+
+    /**
+     * 设置物品描述
+     * @param info 物品描述
+     */
+    private setItemInfo(info: string) {
+        this.node.getChildByName("info").getComponent(Label)!.string = info;
+    }
+
+    /**
+     * 设置品质文字描述
+     * @param quality 品质类型
+     */
+    private setQualityText(quality: QualitySet) {
+    
+            switch (quality) {
+                case QualitySet.GREEN:
+                    this.node.getChildByName("quality").getChildByName("Label").getComponent(Label)!.string = "优秀";
+                    this.node.getChildByName("quality").getChildByName("Label").getComponent(Label)!.color = new Color(76, 175, 80, 255); // 现代绿色
+                    break;
+                case QualitySet.BLUE:
+                    this.node.getChildByName("quality").getChildByName("Label").getComponent(Label)!.string = "精良";
+                    this.node.getChildByName("quality").getChildByName("Label").getComponent(Label)!.color = new Color(33, 150, 243, 255); // 现代蓝色
+                    break;
+                case QualitySet.PURPLE:
+                    this.node.getChildByName("quality").getChildByName("Label").getComponent(Label)!.string = "史诗";
+                    this.node.getChildByName("quality").getChildByName("Label").getComponent(Label)!.color = new Color(156, 39, 176, 255); // 现代紫色
+                    break;
+                case QualitySet.ORANGE:
+                    this.node.getChildByName("quality").getChildByName("Label").getComponent(Label)!.string = "传说";
+                    this.node.getChildByName("quality").getChildByName("Label").getComponent(Label)!.color = new Color(255, 87, 34, 255); // 现代橙色
+                    break;
+                default:
+                    this.node.getChildByName("quality").getChildByName("Label").getComponent(Label)!.string = "普通";
+                    this.node.getChildByName("quality").getChildByName("Label").getComponent(Label)!.color = new Color(158, 158, 158, 255); // 现代灰色
+                    break;
+            }
+        
+    }
+
+    /**
+     * 获取物品UUID
+     */
+    getItemUUID(): number {
+        return this.item_uuid;
+    }
+
+    /**
+     * 获取物品数量
+     */
+    getItemCount(): number {
+        return this.item_count;
+    }
+
+    /**
+     * 关闭物品信息弹窗
+     */
+    closeItemInfo() {
+        console.log("[ItemInfoComp]: Close item info");
+        this.removeTouchListener();
+        oops.gui.removeByNode(this.node)
+    }
+
+    /**
+     * 使用物品
+     */
+    useItem() {
+        console.log("[ItemInfoComp]: Use item", this.item_uuid);
+        // 这里可以添加使用物品的逻辑
+        // 比如消耗物品、触发效果等
+    }
+
+    /**
+     * 丢弃物品
+     */
+    dropItem() {
+        console.log("[ItemInfoComp]: Drop item", this.item_uuid);
+        // 这里可以添加丢弃物品的逻辑
+        // 比如从背包中移除、显示确认对话框等
+    }
+}
+
+

assets/script/game/map/ItemInfoComp.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "627ed4fe-6a6c-4591-96fb-df08a6ebed95",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

assets/script/game/map/MissionComp.ts

@@ -1,4 +1,4 @@
-import { _decorator,Button,EventHandler,EventTouch,Label,NodeEventType,resources,Sprite,SpriteAtlas,tween,UITransform,v3, Vec3,Animation, UI, instantiate, Prefab, screen } from "cc";
+import { _decorator, Vec3,Animation, instantiate, Prefab, Node } from "cc";
 import { ecs } from "../../../../extensions/oops-plugin-framework/assets/libs/ecs/ECS";
 import { CCComp } from "../../../../extensions/oops-plugin-framework/assets/module/common/CCComp";
 import { smc } from "../common/SingletonModuleComp";
@@ -10,6 +10,7 @@ import { HeroViewComp } from "../hero/HeroViewComp";
 import { MonModelComp } from "../hero/MonModelComp";
 import { SkillCom } from "../skills/SkillCom";
 import { UIID } from "../common/config/GameUIConfig";
+import { ItemComp } from "./ItemComp";
 const { ccclass, property } = _decorator;
 
 
@@ -22,7 +23,7 @@ export class MissionComp extends CCComp {
     // VictoryComp:any = null;
     // reward:number = 0;
     // reward_num:number = 0;
- 
+    rewards:any[]=[]
 
     onLoad(){
         this.on(GameEvent.MissionStart,this.mission_start,this)
@@ -45,10 +46,61 @@ export class MissionComp extends CCComp {
     do_reward(){
         // 奖励发放
     }
-    
-    do_mon_dead(){
+    do_drop(drop_item:any[]){
+        console.log("[MissionComp] do_drop",drop_item)
+        let parent=this.node.getChildByName("reward").getChildByName("items")
+        let items=parent.children
+        if(drop_item.length>0){
+            for(let i=0;i<drop_item.length;i++){
+                let d_item=drop_item[i]
+                // 查找是否已存在该物品
+                const existingItem = this.rewards.find(item => item.item_uuid === d_item.item_uuid);
+                if(existingItem){
+                    // 如果已存在该物品，累加数量
+                    existingItem.count += d_item.count;
+                }else{
+                    // 如果不存在该物品，添加新物品
+                    this.rewards.push({item_uuid: d_item.item_uuid, count: d_item.count});
+                }
+            }
+        }
+        for(let i=0;i<items.length;i++){
+            let hitem=items[i].getComponent(ItemComp)
+            for(let j=0;j<drop_item.length;j++){
+                let d_item=drop_item[j]
+                if(d_item.item_uuid==hitem.item_uuid){
+                    hitem.addItemCount(d_item.count)
+                    drop_item.splice(j,1)
+                    smc.addItem(d_item.item_uuid,d_item.count)
+                    break
+                }
+            }
+        }
+        if(drop_item.length>0){
+            console.log("[MissionComp] do_drop 剩余物品",drop_item)
+            for(let i=0;i<drop_item.length;i++){
+                let d_item=drop_item[i]
+                let path="game/gui/item"
+                const prefab = oops.res.get(path, Prefab);
+                if (!prefab) {
+                    console.error("[MissionComp=>do_drop] 预制体加载失败:", path);
+                    return;
+                }
+                const node = instantiate(prefab) as unknown as Node;
+                node.parent=parent
+                node.getComponent(ItemComp)!.update_data(d_item.item_uuid,d_item.count)
+                smc.addItem(d_item.item_uuid,d_item.count)
+            }
+        }
+    }
+    do_mon_dead(event:any,data:any){
+        console.log("[MissionComp] do_mon_dead",event,data)
         smc.vmdata.mission_data.mon_num--
-        console.log("[MissionComp] do_mon_dead",smc.vmdata.mission_data.mon_num)
+        if(data.drops){
+            if(data.drops.length>0){
+                this.do_drop(data.drops)
+            }
+        }
         if(smc.vmdata.mission_data.mon_num<=0) {
             smc.vmdata.mission_data.level++
             if(smc.vmdata.mission_data.level < smc.vmdata.mission_data.max_mission){
@@ -57,15 +109,16 @@ export class MissionComp extends CCComp {
             }
             smc.addGameProperty("mission",1)
             oops.message.dispatchEvent(GameEvent.FightEnd,{victory:true})
-            oops.gui.open(UIID.Victory,{victory:true})
+            oops.gui.open(UIID.Victory,{victory:true,rewards:this.rewards})
         }
     }
-    do_hero_dead(){
+
+    do_hero_dead(event:any,data:any){
+        console.log("[MissionComp] do_hero_dead",event,data)
         smc.vmdata.mission_data.hero_num--
-        console.log("[MissionComp] do_hero_dead",smc.vmdata.mission_data.hero_num)
         if(smc.vmdata.mission_data.hero_num<=0) {
             oops.message.dispatchEvent(GameEvent.FightEnd,{victory:false})
-            oops.gui.open(UIID.Victory,{victory:false})
+            oops.gui.open(UIID.Victory,{victory:false,rewards:this.rewards})
         }
     }
     do_ad(){
@@ -109,7 +162,7 @@ export class MissionComp extends CCComp {
 
     to_end_fight(){
         oops.message.dispatchEvent(GameEvent.FightEnd,{victory:false})
-        oops.gui.open(UIID.Victory,{victory:false})
+        oops.gui.open(UIID.Victory,{victory:false,rewards:this.rewards})
     }
 
 
@@ -135,6 +188,8 @@ export class MissionComp extends CCComp {
         smc.vmdata.mission_data.in_fight=false
         smc.vmdata.mission_data.fight_time=0
         smc.vmdata.mission_data.level=0
+        this.rewards=[]  // 改为数组，用于存储掉落物品列表
+        this.node.getChildByName("reward").getChildByName("items").removeAllChildren()
         console.log("[MissionComp]局内数据初始化",smc.vmdata.mission_data)  
     }
 

assets/script/game/map/MissionHomeComp.ts

@@ -38,8 +38,13 @@ export class MissionHomeComp extends CCComp {
     uodate_data(){
         smc.syncData()
     }
+    isWxClient(){
+        return typeof wx !== 'undefined' && typeof (wx as any).getSystemInfoSync === 'function';
+    }
     btn_func(e:string,data:any){
-        smc.syncDataFromLocal() //调试用,正式环境去掉
+        if(!this.isWxClient()){
+            smc.syncDataFromLocal() //调试用,正式环境去掉
+        }
         // console.log("[MissionHomeComp]:btn_func",e,data)
         let page_heros=this.node.getChildByName("heros_page")
         let page_shop=this.node.getChildByName("shop_page")

assets/script/game/map/VictoryComp.ts

@@ -1,9 +1,10 @@
-import { _decorator, instantiate, Label ,Prefab,resources,Sprite,SpriteAtlas,v3} from "cc";
+import { _decorator, instantiate, Label ,Prefab,Node} from "cc";
 import { ecs } from "../../../../extensions/oops-plugin-framework/assets/libs/ecs/ECS";
 import { CCComp } from "../../../../extensions/oops-plugin-framework/assets/module/common/CCComp";
 import { oops } from "../../../../extensions/oops-plugin-framework/assets/core/Oops";
 import { smc } from "../common/SingletonModuleComp";
 import { GameEvent } from "../common/config/GameEvent";
+import { ItemComp } from "./ItemComp";
 
 const { ccclass, property } = _decorator;
 
@@ -14,13 +15,18 @@ export class VictoryComp extends CCComp {
     
     reward_lv:number=1
     reward_num:number=2
+    rewards:any[]=[]
     /** 视图层逻辑代码分离演示 */
     protected onLoad(): void {
 
     }
 
     onAdded(args: any) {
-        console.log("[VictoryComp] onAdded",args)
+        console.log("[VictoryComp] onAdded",args,smc.items)
+        if(args.rewards){
+            this.add_reward(args.rewards)
+            this.rewards=args.rewards
+        }
         this.node.getChildByName("title").getChildByName("victory").active=args.victory
         this.node.getChildByName("title").getChildByName("defeat").active=!args.victory
         this.node.getChildByName("btns").getChildByName("next").active=false
@@ -29,12 +35,39 @@ export class VictoryComp extends CCComp {
         },0.2)
     }
 
-
+    add_reward(rewards:any[]){  
+        let parent=this.node.getChildByName("box").getChildByName("items")
+        let items=parent.children
+        for(let i=0;i<rewards.length;i++){
+            let d_item=rewards[i]
+            let path="game/gui/item"
+            const prefab = oops.res.get(path, Prefab);
+            if (!prefab) {
+                console.error("[MissionComp=>do_drop] 预制体加载失败:", path);
+                return;
+            }
+            const node = instantiate(prefab) as unknown as Node;
+            node.parent=parent
+            node.getComponent(ItemComp)!.update_data(d_item.item_uuid,d_item.count,{no_show:true})
+        }
+    }
     victory_end(){
         oops.message.dispatchEvent(GameEvent.MissionEnd)
         oops.gui.removeByNode(this.node)
     }
-
+    //看广告双倍
+    watch_ad(){
+        return true
+    }
+    double_reward(){
+        if(this.watch_ad()){
+            this.rewards.forEach(d_item=>{
+               smc.addItem(d_item.item_uuid,d_item.count)
+            })
+            this.node.getChildByName("btns").getChildByName("double").active=false
+        }
+        console.log("[VictoryComp]double_reward",smc.items,this.rewards)
+    }
     restart(){
         oops.message.dispatchEvent(GameEvent.MissionStart)
         oops.gui.removeByNode(this.node)