通行证添加红点功能

assets/Script/JiaZai.ts

@@ -2393,6 +2393,39 @@ export default class JiaZai extends cc.Component {
 
                                 cc.fx.GameConfig.GM_INFO.getProgressLevel = (passCheckLvObj && passCheckLvObj.progressLevel) || 1;
                                 cc.fx.GameConfig.GM_INFO.getProgress = (passCheckLvObj && passCheckLvObj.progress) || 1;
+
+                                // 检查是否有未领取的奖励并显示红点
+                                let hasUnclaimedReward = false;
+                                if (parsedData) {
+                                    // 检查当前和下一阶段是否有未领取的奖励
+                                    for (let key in parsedData) {
+                                        let stage = parsedData[key];
+                                        if (stage && stage.free) {
+                                            // 检查免费奖励是否已领取（值为1表示未领取）
+                                            const maxLength = Math.max(stage.free.length, stage.passCheck.length);
+                                            for (let i = 0; i < maxLength; i++) {
+                                                console.log("检查玩家的奖励领取", stage.free[i], stage.activate, stage.passCheck[i])
+                                                if (i < stage.free.length && stage.free[i] == 1) {
+                                                    hasUnclaimedReward = true;
+                                                    break;
+                                                }
+                                                // 检查付费奖励（仅在激活状态下）
+                                                if (stage.activate && i < stage.passCheck.length && stage.passCheck[i] == 1) {
+                                                    hasUnclaimedReward = true;
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                        if (hasUnclaimedReward) break;
+                                    }
+                                }
+
+                                // 显示或隐藏红点
+                                let redNode = top.getChildByName("passBtn").getChildByName("red");
+                                if (redNode) {
+                                    redNode.active = hasUnclaimedReward;
+                                }
+
                             }
                         }
 

assets/shop/script/passCheck.ts

@@ -753,6 +753,11 @@ export default class passCheck extends cc.Component {
         }
     }
 
+    allGetReward() {
+        // 一键领取
+        // this.passCheckMgr.allGetReward();
+    }
+
     onDestroy() {
         // 组件销毁时清除定时器
         if (this.countdownTimer) {

assets/shop/script/passCheckItem.ts

@@ -297,8 +297,6 @@ export default class PassCheckItem extends cc.Component {
                 this.setNodeGray(num_x)
             }
             num1.scale = 0.8;
-            // num_x.scale = 2;
-            // console.log("num1:", num_x, num1);
             if (num_x && num1) {
                 // 计算数值的位数
                 const digitCount = itemNum.toString().length;
@@ -317,7 +315,6 @@ export default class PassCheckItem extends cc.Component {
 
     updateItem(data: any, index: number) {
         // 在这里处理数据更新
-        // 你的数据更新逻辑
         this.data = data;
         this.itemIndex = index;
         this.initUI();
@@ -351,54 +348,18 @@ export default class PassCheckItem extends cc.Component {
     }
 
     private claimReward(itemId: number, itemNum: number, isLeftReward: boolean) {
-        // 根据物品ID处理不同类型的奖励
+        let passCheckMgr = this.node.parent.parent.parent.parent.getComponent('passCheckMgr');
-
+        if (passCheckMgr && typeof passCheckMgr.claimReward === 'function') {
-        cc.fx.GameTool.getPassCheckPorp(itemId, itemNum, false)
+            console.log("更新奖励状态到服务器:", itemId, itemNum, isLeftReward);
-
+            passCheckMgr.claimReward(this.itemIndex, itemId, itemNum, isLeftReward);
-        // 更新UI显示
-        this.updateRewardUIAfterClaim(isLeftReward);
-
-
-        // 发送统计事件
-        // this.sendClaimEvent(itemId, itemNum);
-        const canvasTemp = cc.find("Canvas"); // 假设 Canvas 节点
-        if (canvasTemp) {
-            const JiaZai = canvasTemp.getComponent("JiaZai");
-            if (JiaZai) {
-                console.log("更新主界面数据")
-
-                switch (itemId) {
-                    case 1001: // 金币
-                        // this.claimCoins(itemNum);
-                        JiaZai.updateCoin();
-                        break;
-                    case 2001: // 冰冻道具
-                        // this.claimFreezeProp(itemNum);
-                        break;
-                    case 2002: // 锤子道具
-                        // this.claimHammerProp(itemNum);
-                        break;
-                    case 2003: // 魔棒道具
-                        // this.claimMagicProp(itemNum);
-                        break;
-                    default:
-                        // console.warn("未知的物品ID:", itemId);
-                        // this.claimInfiniteHealth(itemNum, itemId);
-                        JiaZai.updatePower();
-                        break;
-                }
-            }
-
         }
-
     }
 
     private claimInfiniteHealth(amount: number, itemId: number) {
-        // cc.fx.GameTool.setUserPowerTime(amount);// 900 15分钟 1800 30分钟 3600 60分钟
 
     }
 
-    private updateRewardUIAfterClaim(isLeftReward: boolean) {
+    public updateRewardUIAfterClaim(isLeftReward: boolean) {
         let targetNode = isLeftReward ?
             this.node.getChildByName("leftNode") :
             this.node.getChildByName("rightNode");
@@ -417,18 +378,9 @@ export default class PassCheckItem extends cc.Component {
                 this.setNodeGray(num1);
             }
         }
-        this.updateRewardStateOnServer(isLeftReward);
     }
 
-    private updateRewardStateOnServer(isLeftReward: boolean) {
-        // 通知父组件更新服务器数据
 
-        let passCheckMgr = this.node.parent.parent.parent.parent.getComponent('passCheckMgr');
-        if (passCheckMgr && typeof passCheckMgr.updateRewardStatus === 'function') {
-            console.log("更新奖励状态到服务器:", this.itemIndex, isLeftReward);
-            passCheckMgr.updatePassCheckStatus(this.itemIndex, isLeftReward);
-        }
-    }
 
     private setNodeGray(node: cc.Node, color?: cc.Color) {
         let setColor = color || cc.color(190, 190, 190, 255);

assets/shop/script/passCheckMgr.ts

@@ -19,12 +19,7 @@ export default class passCheckMgr extends cc.Component {
     private endTime: any;
 
     private rewardUpdateTimeout: any = null;
-    private lastUpdateTime: number = 0;
-    private readonly UPDATE_DELAY: number = 200;
-    private isRewardTime: number = 0;
-    // private isLeftReward: boolean = false;
     onLoad() {
-        cc.systemEvent.on('passcheck-reward-claimed', this.updateRewardStatus, this);
     }
 
     start() {
@@ -73,6 +68,7 @@ export default class passCheckMgr extends cc.Component {
 
         // 设置数据
         this.listData = data;
+        console.log("列表数据", data);
         this.list.setData(data);
 
         // 创建进度条
@@ -207,20 +203,22 @@ export default class passCheckMgr extends cc.Component {
         cc.fx.StorageMessage.setStorage("ProgressIndex", this.progressLevel);
     }
 
-    public updatePassCheckStatus(itemIndex?: number, isLeftReward?: boolean) {
+    public updatePassCheckStatus(updates?: Array<{ itemIndex: number, isLeftReward: boolean }>) {
-        // 如果提供了itemIndex和isLeftReward，则更新对应的奖励状态
+        // 如果提供了updates数组，则批量更新对应的奖励状态
-        if (itemIndex !== undefined && isLeftReward !== undefined) {
+        if (updates && Array.isArray(updates) && updates.length > 0) {
-            // 更新本地数据状态
+            // 批量更新本地数据状态
-            if (this.listData[itemIndex]) {
+            for (const update of updates) {
-                if (isLeftReward) {
+                const { itemIndex, isLeftReward } = update;
-                    this.listData[itemIndex].free = 0; // 标记为已领取
+                if (this.listData[itemIndex]) {
-                } else {
+                    if (isLeftReward) {
-                    this.listData[itemIndex].passCheck = 0; // 标记为已领取
+                        this.listData[itemIndex].free = 0; // 标记为已领取
+                    } else {
+                        this.listData[itemIndex].passCheck = 0; // 标记为已领取
+                    }
                 }
             }
         }
-
+        console.log("给服务器发的值", updates);
-
         // 构造要发送到服务器的数据
         let now = this.endTime;
 
@@ -256,12 +254,60 @@ export default class passCheckMgr extends cc.Component {
         Utils.setPassCheckInfo((res) => {
             if (res.code === 1) {
                 console.log("通行证状态保存成功");
+                console.log("服务器返回的成功响应:", res);
+
+                this.checkAllRewardsClaimed();
                 // this.refreshPassCheckItems();
             } else {
                 console.log("通行证状态保存失败");
             }
         }, passCheck);
     }
+    // 检查所有奖励是否领取完毕
+    private checkAllRewardsClaimed() {
+        let allClaimed = true;
+
+        for (let i = 0; i < this.listData.length; i++) {
+            // 检查免费奖励是否已领取 (0表示已领取，1表示未领取)
+            if (this.listData[i].free === 1) {
+                allClaimed = false;
+                break;
+            }
+
+            // 如果已激活通行证，检查通行证奖励是否已领取
+            if (cc.fx.GameConfig.GM_INFO.passCheckActivate && this.listData[i].passCheck === 1) {
+                allClaimed = false;
+                break;
+            }
+        }
+
+        // 如果所有奖励都已领取，可以在这里触发相应逻辑
+        if (allClaimed) {
+            console.log("所有奖励都已领取完毕");
+            // 隐藏通行证按钮上的红点
+            this.hidePassCheckRedDot();
+        } else {
+            console.log("还有未领取的奖励");
+        }
+
+        return allClaimed;
+    }
+    // 隐藏通行证按钮上的红点
+    private hidePassCheckRedDot() {
+        const canvas = cc.find("Canvas");
+        if (canvas) {
+            const jiaZai = canvas.getComponent("JiaZai");
+            if (jiaZai) {
+                const top = jiaZai.node.getChildByName("Load")?.getChildByName("Top");
+                const passBtn = top?.getChildByName("passBtn");
+                const redNode = passBtn?.getChildByName("red");
+                if (redNode) {
+                    redNode.active = false;
+                }
+            }
+        }
+    }
+
     public refreshPassCheckItems() {
         this.updatePassCheckStatus();
         // 通知所有 passCheckItem 组件更新界面
@@ -286,26 +332,17 @@ export default class passCheckMgr extends cc.Component {
         }
     }
 
-    public updateRewardStatus(itemIndex: number, isLeftReward: boolean) {
+    public updateRewardStatus(updates: Array<{ itemIndex: number, isLeftReward: boolean }>) {
-        // this.updatePassCheckStatus(itemIndex, isLeftReward);
         const currentTime = Date.now();
 
-        // 防止短时间内重复触发
-        if (currentTime - this.lastUpdateTime < this.UPDATE_DELAY) {
-            console.log("阻止短时间内重复更新:", currentTime - this.lastUpdateTime, "ms");
-            return;
-        }
-        this.isRewardTime = currentTime;
-        // 更新最后调用时间
-        this.lastUpdateTime = currentTime;
-
         // 使用防抖机制，延迟处理奖励更新
         if (this.rewardUpdateTimeout) {
             clearTimeout(this.rewardUpdateTimeout);
         }
-
+        console.log("传给服务器", updates)
         this.rewardUpdateTimeout = setTimeout(() => {
-            this.updatePassCheckStatus(itemIndex, isLeftReward);
+            // 修改为传入数组
+            this.updatePassCheckStatus(updates);
             this.rewardUpdateTimeout = null;
         }, 50);
     }
@@ -313,9 +350,238 @@ export default class passCheckMgr extends cc.Component {
         this.updatePassCheckStatus();
     }
 
+    // 奖励队列和处理状态
+    private rewardQueue: Array<{ itemIndex: number, itemId: number, itemNum: number, isLeftReward: boolean }> = [];
+    private isProcessingRewards: boolean = false;
+    private rewardProcessTimeout: any = null;
+
+    // 整合自passCheckItem.ts的claimReward方法，支持处理可能的循环调用
+    public claimReward(itemIndex: number, itemId: number, itemNum: number, isLeftReward: boolean) {
+        // 将奖励请求添加到队列中
+        console.log("领取奖励ID", itemIndex, "物品ID", itemId, "数量", itemNum)
+        this.rewardQueue.push({ itemIndex, itemId, itemNum, isLeftReward });
+
+        // 清除之前的定时器
+        if (this.rewardProcessTimeout) {
+            clearTimeout(this.rewardProcessTimeout);
+        }
+
+        // 设置延迟处理，合并短时间内多次调用
+        this.rewardProcessTimeout = setTimeout(() => {
+            this.processRewardQueue();
+        }, 50); // 50ms延迟，合并短时间内多次调用
+    }
+    // 处理奖励队列
+    private processRewardQueue() {
+        // 如果正在处理中，则等待下次处理
+        if (this.isProcessingRewards) {
+            // 重新设置定时器，稍后再次尝试
+            if (this.rewardProcessTimeout) {
+                clearTimeout(this.rewardProcessTimeout);
+            }
+            this.rewardProcessTimeout = setTimeout(() => {
+                this.processRewardQueue();
+            }, 100);
+            return;
+        }
+
+        // 如果队列为空，直接返回
+        if (this.rewardQueue.length === 0) {
+            return;
+        }
+
+        // 标记为正在处理
+        this.isProcessingRewards = true;
+
+        // 处理队列中的所有奖励
+        this.processRewardsInternal([...this.rewardQueue]);
+
+        // 清空队列
+        this.rewardQueue = [];
+
+        // 处理完成
+        this.isProcessingRewards = false;
+    }
+
+    // 内部处理奖励方法
+    private processRewardsInternal(rewards: Array<{ itemIndex: number, itemId: number, itemNum: number, isLeftReward: boolean }>) {
+        // 处理所有奖励的逻辑（道具增加等）
+        const rewardData = [];
+        const canvasTemp = cc.find("Canvas");
+        let JiaZai = null;
+
+        if (canvasTemp) {
+            JiaZai = canvasTemp.getComponent("JiaZai");
+        }
+
+        // 处理每个奖励
+        for (const reward of rewards) {
+            cc.fx.GameTool.getPassCheckPorp(reward.itemId, reward.itemNum, false);
+
+            if (JiaZai) {
+                switch (reward.itemId) {
+                    case 1001: // 金币
+                        JiaZai.updateCoin();
+                        break;
+                    case 2001: // 冰冻道具
+                    case 2002: // 锤子道具
+                    case 2003: // 魔棒道具
+                        break;
+                    default:
+                        JiaZai.updatePower();
+                        break;
+                }
+            }
+            console.log("领取奖励", reward.itemId, reward.itemNum);
+            // 通知对应的passCheckItem组件更新UI
+            this.updateRewardUIAfterClaim(reward.itemIndex, reward.isLeftReward);
+
+            // 收集奖励数据
+            rewardData.push({ itemId: reward.itemId, itemNum: reward.itemNum });
+        }
+
+        // 合并相同类型的奖励
+        const mergedRewards = this.processRewardData(rewardData);
+
+        // 显示奖励弹窗（只显示一次）
+        if (JiaZai && mergedRewards.length > 0) {
+            JiaZai.openRewardWindow(mergedRewards);
+        }
+
+        // 更新服务器状态
+        console.log("更新奖励状态到服务器:", rewards.length);
+        if (rewards.length > 0) {
+            const rewardUpdates = rewards.map(reward => ({
+                itemIndex: reward.itemIndex,
+                isLeftReward: reward.isLeftReward
+            }));
+            this.updateRewardStatus(rewardUpdates);
+
+        }
+    }
+    // 封装奖励数据处理方法，处理循环调用并合并相同类型奖励
+    private processRewardData(rewards: Array<{ itemId: number, itemNum: number }>): Array<{ type: string, count: number }> {
+        // 创建一个映射来存储每种类型的奖励总和
+        const rewardMap = new Map<string, number>();
+
+        // 处理每个奖励项
+        for (const reward of rewards) {
+            let type: string = "";
+
+            switch (reward.itemId) {
+                case 1001: // 金币
+                    type = "coin";
+                    break;
+                case 2001: // 冰冻道具
+                    type = "freeze";
+                    break;
+                case 2002: // 锤子道具
+                    type = "hammer";
+                    break;
+                case 2003: // 魔棒道具
+                    type = "magic";
+                    break;
+                case 3001: // 无限体力 900秒
+                    type = "infinite_health";
+                    reward.itemNum = 900;
+                    break;
+                case 3002: // 无限体力 1800秒
+                    type = "infinite_health";
+                    reward.itemNum = 1800;
+                    break;
+                case 3003: // 无限体力 3600秒
+                    type = "infinite_health";
+                    reward.itemNum = 3600;
+                    break;
+                default:
+                    // 默认处理为无限体力，使用传入的数量
+                    type = "infinite_health";
+                    break;
+            }
+            console.log("处理奖励数据", reward.itemId, reward.itemNum);
+            // 如果该类型已存在，累加数量；否则设置新值
+            if (rewardMap.has(type)) {
+                rewardMap.set(type, rewardMap.get(type)! + reward.itemNum);
+            } else {
+                rewardMap.set(type, reward.itemNum);
+            }
+        }
+
+        // 转换为数组格式
+        const result: Array<{ type: string, count: number }> = [];
+        rewardMap.forEach((count, type) => {
+            result.push({ type, count });
+        });
+
+        return result;
+    }
+
+    // 整合自passCheckItem.ts的updateRewardUIAfterClaim方法
+    private updateRewardUIAfterClaim(itemIndex: number, isLeftReward: boolean) {
+        // 通知对应的passCheckItem组件更新UI
+        if (this.list && this.list.node) {
+            // 通过ScrollView组件获取content节点
+            const scrollViewComponent = this.list.node.getComponent(cc.ScrollView);
+            if (scrollViewComponent && scrollViewComponent.content) {
+                const content = scrollViewComponent.content;
+                // 遍历所有子节点，查找对应索引的 passCheckItem 组件并更新UI
+                for (let i = 0; i < content.childrenCount; i++) {
+                    const child = content.children[i];
+                    // 查找 passCheckItem 节点
+                    if (child.name === "passCheckItem") {
+                        const passCheckItem = child.getComponent("passCheckItem");
+                        if (passCheckItem && passCheckItem.itemIndex === itemIndex) {
+                            // 调用passCheckItem的updateRewardUIAfterClaim方法
+                            if (passCheckItem.updateRewardUIAfterClaim) {
+                                passCheckItem.updateRewardUIAfterClaim(isLeftReward);
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    allGetReward() {
+        const allRewardsToClaim = [];
+
+        for (let i = 0; i < this.listData.length; i++) {
+            // 检查免费奖励是否可以领取
+            if (this.listData[i].free === 1) {
+                allRewardsToClaim.push({
+                    itemIndex: i,
+                    itemId: this.listData[i].ItemID1,
+                    itemNum: this.listData[i].ItemNum1,
+                    isLeftReward: true
+                });
+            }
+            if (cc.fx.GameConfig.GM_INFO.passCheckActivate) {
+                // 检查通行证奖励是否可以领取
+                if (this.listData[i].passCheck === 1) {
+                    allRewardsToClaim.push({
+                        itemIndex: i,
+                        itemId: this.listData[i].ItemID2,
+                        itemNum: this.listData[i].ItemNum2,
+                        isLeftReward: false
+                    });
+                }
+            }
+        }
+
+        console.log("批量领取所有物品:", allRewardsToClaim);
+        // 批量处理所有奖励
+        for (const reward of allRewardsToClaim) {
+            this.claimReward(
+                reward.itemIndex,
+                reward.itemId,
+                reward.itemNum,
+                reward.isLeftReward
+            );
+        }
+    }
     protected onDestroy(): void {
         console.log("销毁passCheckMgr");
-        cc.systemEvent.off('passcheck-reward-claimed', this.updateRewardStatus, this);
 
         // 清理可能存在的列表数据
         if (this.listData) {