XiuXianGame/Assets/Scripts/GameLogic/Player/SummonManager.cs

using System.Collections.Generic;
using System.Linq;
using Excel2Json;
using Fort23.Core;
using Fort23.Mono;
using Fort23.UTool;
using GameLogic.Bag;
using UnityEngine;
using UnityEngine.UIElements;
using Utility;

namespace GameLogic.Player
{
    public class SummonManager
    {
        public Map<int, AccountFileInfo.SummonData> summonDataMap = new Map<int, AccountFileInfo.SummonData>();

        //积分规则
        public Map<int, List<OpenBoxScoreRule>> openBoxScoreRuleMap = new Map<int, List<OpenBoxScoreRule>>();

        private static readonly System.Random random = new System.Random();

        public void CustomInit()
        {
            OpenBoxConfig[] openBoxConfigs = ConfigComponent.Instance.GetAll<OpenBoxConfig>();

            //每次进游戏检查是否有新的抽卡
            foreach (var openBoxConfig in openBoxConfigs)
            {
                if (AccountFileInfo.Instance.playerData.SummonDatas.FirstOrDefault(s => s.id == openBoxConfig.ID) ==
                    null)
                {
                    AccountFileInfo.SummonData summonData = new AccountFileInfo.SummonData();
                    summonData.id = openBoxConfig.ID;
                    AccountFileInfo.Instance.playerData.SummonDatas.Add(summonData);
                }
            }

            OpenBoxScoreRule[] openBoxScoreRules = ConfigComponent.Instance.GetAll<OpenBoxScoreRule>();
            foreach (var openBoxScoreRule in openBoxScoreRules)
            {
                List<OpenBoxScoreRule> openBoxScoreRuleList;
                if (!openBoxScoreRuleMap.ContainsKey(openBoxScoreRule.openBoxID))
                {
                    openBoxScoreRuleList = new List<OpenBoxScoreRule>();
                    openBoxScoreRuleMap[openBoxScoreRule.openBoxID] = openBoxScoreRuleList;
                }

                openBoxScoreRuleList = openBoxScoreRuleMap[openBoxScoreRule.openBoxID];
                openBoxScoreRuleList.Add(openBoxScoreRule);
            }


            foreach (var playerDataSummonData in AccountFileInfo.Instance.playerData.SummonDatas)
            {
                if (!summonDataMap.ContainsKey(playerDataSummonData.id))
                {
                    summonDataMap.Add(playerDataSummonData.id, playerDataSummonData);
                }
            }

            AccountFileInfo.Instance.SavePlayerData();
        }

        public async CTask<List<ItemInfo>> Summon(int id, int count)
        {
            AccountFileInfo.SummonData summonData = summonDataMap[id];
            OpenBoxConfig openBoxConfig = ConfigComponent.Instance.Get<OpenBoxConfig>(summonData.id);
            List<ItemInfo> allIitem = new List<ItemInfo>();
            //单抽
            if (count == 1)
            {
                //有免费次数，并且让到时间了就免费抽
                if (summonData.oneFreeCount < openBoxConfig.oneConsumeFreePara[1] &&
                    PlayerManager.Instance.serverTime >= summonData.nextOneFreeTime)
                {
                    allIitem = Summon(summonData, 1);

                    summonData.oneFreeCount++;
                    summonData.nextOneFreeTime =
                        PlayerManager.Instance.serverTime + openBoxConfig.oneConsumeFreePara[0] * 1000;
                }
                else
                {
                    //验证道具是否足够
                    if (openBoxConfig.CostItemID == 1007)
                    {
#if UNITY_ANDROID && !UNITY_EDITOR&& Taptap
                        if (TakuSDKManager.Instance.IsReady())
                        {
                            bool isOK = await TakuSDKManager.Instance.ShowAutoAd();
                            if (!isOK)
                            {
                                return null;
                            }
                            await TimerComponent.Instance.WaitAsync(1000);
                        }
                        else
                        {
                            return null;
                        }


#endif
                    }
                    else
                    {
                        //验证道具是否足够
                        if (PlayerManager.Instance.BagController.IsEnough(openBoxConfig.CostItemID,
                                openBoxConfig.oneConsume) || openBoxConfig.CostItemID == 1007)
                        {
                            //TODO 消耗：抽功法 (count 1/10)
                            PlayerManager.Instance.BagController.DeductItem(openBoxConfig.CostItemID,
                                openBoxConfig.oneConsume);
                        }
                        else
                        {
                            return null;
                        }
                    }


                    allIitem = Summon(summonData, 1);

                    summonData.onePayCount++;
                }
            }
            //十连抽
            else if (count == 10)
            {
                //有免费次数，并且让到时间了就免费抽
                if (summonData.tenFreeCount < openBoxConfig.oneConsumeFreePara_1[1] &&
                    PlayerManager.Instance.serverTime >= summonData.nextTenFreeTime)
                {
                    allIitem = Summon(summonData, 10);
                    if (summonData.isSummonSocre)
                    {
                        //记录抽卡道具 用于成就检测
                        List<int> drawHistory = new List<int>();
                        foreach (var itemInfo in allIitem)
                        {
                            drawHistory.Add(itemInfo.itemID);
                        }

                        AccountFileInfo.IntList intList = new AccountFileInfo.IntList();
                        intList.list = drawHistory;
                        summonData.drawHistory.Add(intList);
                        CheckAchievements(summonData);
                    }


                    summonData.tenFreeCount++;
                    summonData.nextTenFreeTime =
                        PlayerManager.Instance.serverTime + openBoxConfig.oneConsumeFreePara_1[0] * 1000;
                }
                else
                {
                    //验证道具是否足够
                    if (openBoxConfig.CostItemID == 1007)
                    {
#if UNITY_ANDROID && !UNITY_EDITOR&& Ads
                        if (TakuSDKManager.Instance.IsReady())
                        {
                            bool isOK = await TakuSDKManager.Instance.ShowAutoAd();
                            if (!isOK)
                            {
                                return null;
                            }

                            await TimerComponent.Instance.WaitAsync(1000);
                        }
                        else
                        {
                            return null;
                        }
#endif
                    }
                    else
                    {
                        if (PlayerManager.Instance.BagController.IsEnough(openBoxConfig.CostItemID,
                                openBoxConfig.tenConsume) || openBoxConfig.CostItemID == 1007)
                        {
                            //TODO 消耗：抽功法 (count = 1 / 10)
                            PlayerManager.Instance.BagController.DeductItem(openBoxConfig.CostItemID,
                                openBoxConfig.tenConsume);
                        }
                        else
                        {
                            return null;
                        }
                    }

                    allIitem = Summon(summonData, 10);
                    if (summonData.isSummonSocre)
                    {
                        //记录抽卡道具 用于成就检测
                        List<int> drawHistory = new List<int>();
                        foreach (var itemInfo in allIitem)
                        {
                            drawHistory.Add(itemInfo.itemID);
                        }

                        AccountFileInfo.IntList intList = new AccountFileInfo.IntList();
                        intList.list = drawHistory;
                        summonData.drawHistory.Add(intList);


                        CheckAchievements(summonData);
                    }

                    summonData.tenPayCount++;
                }
            }

            AccountFileInfo.Instance.SavePlayerData();
            return allIitem;
        }

        public List<ItemInfo> Summon(AccountFileInfo.SummonData summonData, int count)
        {
            List<ItemInfo> allItem = new List<ItemInfo>();
            OpenBoxConfig openBoxConfig = ConfigComponent.Instance.Get<OpenBoxConfig>(summonData.id);

            // 预计算保底物品集合（性能优化）
            HashSet<int> baodiItemSet = CalculateBaodiItems(openBoxConfig.reward2);

            int index = 0;

            for (int i = 0; i < count; i++)
            {
                // 十连保底2
                if (summonData.baodiCount2 >= openBoxConfig.reward2para1)
                {
                    var addItem = ProcessBaodi2(summonData, openBoxConfig);
                    allItem.AddRange(addItem);
                    continue;
                }


                // 十连保底1
                if (summonData.baodiCount1 >= 9)
                {
                    var addItem = ProcessBaodi1(summonData, openBoxConfig, baodiItemSet);
                    allItem.AddRange(addItem);
                    continue;
                }

                // 正常抽卡
                var normalItems = ProcessNormalSummon(summonData, openBoxConfig, count, ref index);
                allItem.AddRange(normalItems);

                // 检查是否触发保底2重置
                CheckBaodi2Reset(summonData, normalItems, baodiItemSet);
            }
//TODO 抽卡：通过openBoxConfig判断来源
            PlayerManager.Instance.BagController.AddItem(allItem);


            AccountFileInfo.Instance.SavePlayerData();
            Shuffle(allItem);
            return allItem;
        }


        public static void Shuffle<T>(IList<T> list)
        {
            int n = list.Count;
            while (n > 1)
            {
                n--;
                int k = random.Next(n + 1);
                T value = list[k];
                list[k] = list[n];
                list[n] = value;
            }
        }

        // 计算保底物品集合
        private HashSet<int> CalculateBaodiItems(int rewardId)
        {
            HashSet<int> baodiSet = new HashSet<int>();
            DropConfig dropConfig = ConfigComponent.Instance.Get<DropConfig>(rewardId);

            foreach (int groupId in dropConfig.dropGroupID)
            {
                DropGroupConfig dropGroupConfig = ConfigComponent.Instance.Get<DropGroupConfig>(groupId);
                foreach (int itemId in dropGroupConfig.dropItemID)
                {
                    DropItemConfig dropItemConfig = ConfigComponent.Instance.Get<DropItemConfig>(itemId);
                    foreach (int item in dropItemConfig.itemID)
                    {
                        baodiSet.Add(item);
                    }
                }
            }

            return baodiSet;
        }

        // 处理十连保底1
        private List<ItemInfo> ProcessBaodi1(AccountFileInfo.SummonData summonData, OpenBoxConfig config,
            HashSet<int> baodiSet)
        {
            var addItem = DropManager.Instance.DropItem(config.reward1);

            // AccountFileInfo.Instance.SavePlayerData();
            summonData.baodiCount1 = 0;
            summonData.baodiCount2++;

            // 检查保底2重置
            if (addItem.Any(i => baodiSet.Contains(i.itemID)))
            {
                summonData.baodiCount2 = 0;
            }

            return addItem;
        }

        //处理十连保底2
        private List<ItemInfo> ProcessBaodi2(AccountFileInfo.SummonData summonData, OpenBoxConfig config)
        {
            var addItem = DropManager.Instance.DropItem(config.reward2);
            // PlayerManager.Instance.BagController.AddItem(addItem);
            summonData.baodiCount2 = 0;
            summonData.baodiCount1 = 0;
            AccountFileInfo.Instance.SavePlayerData();
            return addItem;
        }

        // 处理正常抽卡
        private List<ItemInfo> ProcessNormalSummon(AccountFileInfo.SummonData summonData, OpenBoxConfig config,
            int count, ref int index)
        {
            List<ItemInfo> addItem;

            if (count == 1)
            {
                int randomIndex = Random.Range(0, config.reward.Length);
                addItem = DropManager.Instance.DropItem(config.reward[randomIndex]);
            }
            else
            {
                int poolIndex = index % config.reward.Length;
                addItem = DropManager.Instance.DropItem(config.reward[poolIndex]);
                // summonData.baodiCount2++;
                index++;
            }

            // AccountFileInfo.Instance.SavePlayerData();
            // PlayerManager.Instance.BagController.AddItem(addItem);
            summonData.baodiCount1++;


            return addItem;
        }

        //检查保底2重置
        private void CheckBaodi2Reset(AccountFileInfo.SummonData summonData, List<ItemInfo> items,
            HashSet<int> baodiSet)
        {
            if (items.Any(i => baodiSet.Contains(i.itemID)))
            {
                summonData.baodiCount2 = 0;
            }
            else
            {
                summonData.baodiCount2++;
            }
        }


        // 检查成就匹配
        private void CheckAchievements(AccountFileInfo.SummonData summonData)
        {
            List<OpenBoxScoreRule> openBoxScoreRuleList = openBoxScoreRuleMap[summonData.id];

            List<OpenBoxScoreRule> daChengOpenBoxScoreRuleList = new List<OpenBoxScoreRule>();
            foreach (var openBoxScoreRule in openBoxScoreRuleList)
            {
                // 检查连续 Para0 次十连
                if (summonData.drawHistory.Count < openBoxScoreRule.para0) continue;

                bool allDrawsSatisfy = true;
                // 检查最近 Para0 次十连是否都满足条件
                for (int i = summonData.drawHistory.Count - openBoxScoreRule.para0;
                     i < summonData.drawHistory.Count;
                     i++)
                {
                    if (!CheckSingleDraw(openBoxScoreRule, summonData.drawHistory[i].list))
                    {
                        allDrawsSatisfy = false;
                        break;
                    }
                }

                if (allDrawsSatisfy)
                {
                    daChengOpenBoxScoreRuleList.Add(openBoxScoreRule);
                }
            }

            if (daChengOpenBoxScoreRuleList.Count > 0)
            {
                int id = daChengOpenBoxScoreRuleList.Max(obsr => obsr.ID);
                OpenBoxScoreRule openBoxScoreRule = ConfigComponent.Instance.Get<OpenBoxScoreRule>(id);
                summonData.score += openBoxScoreRule.score;

                AccountFileInfo.SummonSocreData summonSocreData =
                    summonData.summonSocreData.FirstOrDefault(ss => ss.id == openBoxScoreRule.ID);
                if (summonSocreData == null)
                {
                    summonSocreData = new AccountFileInfo.SummonSocreData();
                    summonSocreData.id = id;
                    summonData.summonSocreData.Add(summonSocreData);
                }

                summonSocreData.count++;
                summonSocreData.currentCount++;
                LogTool.Log(
                    $"达成成就 ID: {openBoxScoreRule.ID}, 分数: {openBoxScoreRule.score}, 描述: 连续{openBoxScoreRule.para0}次十连获得{openBoxScoreRule.para1}个品质{openBoxScoreRule.para3}的道具");
            }
        }


        // 检查单次十连是否满足成就条件
        public bool CheckSingleDraw(OpenBoxScoreRule openBoxScoreRule, List<int> drawResult)
        {
            // 统计符合条件的道具数量
            int validItemCount = 0;
            foreach (var item in drawResult)
            {
                ItemConfig itemConfig = ConfigComponent.Instance.Get<ItemConfig>(item);
                // 检查道具标签
                if (!openBoxScoreRule.para4.Contains(itemConfig.itemTag)) continue;

                // 检查品质是否符合
                bool qualityMatch = false;
                switch (openBoxScoreRule.para2)
                {
                    case 1: // 等于
                        qualityMatch = itemConfig.quality == openBoxScoreRule.para3;
                        break;
                    case 2: // 大于等于
                        qualityMatch = itemConfig.quality >= openBoxScoreRule.para3;
                        break;
                    case 3: // 小于等于
                        qualityMatch = itemConfig.quality <= openBoxScoreRule.para3;
                        break;
                }

                if (qualityMatch) validItemCount++;
            }

            // 根据 Para1 判断是否满足数量要求
            return validItemCount >= openBoxScoreRule.para1;
        }
    }
}