XiuXianProject/GameClient/Assets/Game/HotUpdate/Data/CardDataManager.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using cfg.GfgCfg;
using ET;
using UnityEngine;

namespace GFGGame
{
    public class CardDataManager
    {
        private static Dictionary<int, Dictionary<int, CardData>> _cardDicByType =
            new Dictionary<int, Dictionary<int, CardData>>();

        public static int CardResInitWidth = 1440;
        public static int CardResInitHight = 1920;

        public static Dictionary<int, Dictionary<int, int>> _selectList = new Dictionary<int, Dictionary<int, int>>();
        public static List<int> _selectRoleList = new List<int>();
        public static List<int> _selectRarityList = new List<int>();
        public static List<int> _selectFosterList = new List<int>();
        public static bool isFilter = false; //是否筛选中

        private static Dictionary<int, List<CardStoryCfg>> _cardStoryCfgDic = new Dictionary<int, List<CardStoryCfg>>();


        public static void Clear()
        {
            _cardDicByType.Clear();
            _cardStoryCfgDic.Clear();
        }


        public static void Add(CardInfoProto cardInfoProto, bool fromeList = false)
        {
            CardData cardData = new CardData();

            cardData.id = cardInfoProto.CardId;
            cardData.lv = cardInfoProto.Lvl;
            cardData.exp = cardInfoProto.Exp;
            cardData.star = cardInfoProto.Star;
            cardData.mainScore = cardInfoProto.MainScore;
            cardData.resIndex = cardInfoProto.ResIndex;
            for (int i = 0; i < cardInfoProto.KsStarBonus.Count; i++)
            {
                cardData.starRewardsState[cardInfoProto.KsStarBonus[i]] = cardInfoProto.VsStarBonus[i];
            }

            cardData.scores = new Dictionary<int, int>();

            for (int j = 0; j < cardInfoProto.KsAttribute.Count; j++)
            {
                cardData.scores.Add(cardInfoProto.KsAttribute[j], cardInfoProto.VsAttribute[j]);
            }


            if (_cardDicByType.ContainsKey(0) == false)
            {
                _cardDicByType[0] = new Dictionary<int, CardData>();
            }

            if (_cardDicByType.ContainsKey(cardData.mainScore) == false)
            {
                _cardDicByType[cardData.mainScore] = new Dictionary<int, CardData>();
            }

            _cardDicByType[0][cardData.id] = cardData;
            _cardDicByType[cardData.mainScore][cardData.id] = cardData;
            if (GameGlobal.AfterDataInited && !fromeList)
            {
                PreDownloadManager.Instance.PreDownloadCardAnimationRes(cardData.id);
            }
        }

        public static List<string> GetCardResources(ItemCfg itemCfg)
        {
            List<string> resources = new List<string>();
            resources.Add(itemCfg.Res);
            if (itemCfg.CardRes != "")
            {
                resources.Add(itemCfg.CardRes);
            }

            return resources;
        }

        //默认词牌排序规则 ：稀有度>星级>等级>种类（风>花>雪>月）
        public static List<CardData> SortItemList(List<CardData> arrayList)
        {
            arrayList.Sort((CardData a, CardData b) =>
            {
                int rarityA = a.itemCfg.Rarity;
                int rarityB = b.itemCfg.Rarity;
                if (rarityA < rarityB)
                {
                    return 1;
                }
                else if (rarityA > rarityB)
                {
                    return -1;
                }
                else
                {
                    if (a.star < b.star)
                    {
                        return 1;
                    }
                    else if (a.star > b.star)
                    {
                        return -1;
                    }
                    else
                    {
                        if (a.lv < b.lv)
                            return 1;
                        else if (a.lv > b.lv)
                            return -1;
                        else
                        {
                            if (a.mainScore > b.mainScore)
                                return 1;
                            else if (a.mainScore < b.mainScore)
                                return -1;
                        }
                    }
                }

                return string.Compare(a.itemCfg.Res, b.itemCfg.Res);
            });
            return arrayList;
        }


        /// <summary>
        /// 根据词牌Id获取词牌升级升星数据，无数据返回null
        /// </summary>
        /// <param name="cardId"></param>
        /// <returns></returns>
        public static CardData GetCardDataById(int cardId)
        {
            if (_cardDicByType.Count == 0 || !_cardDicByType.ContainsKey(0) || !_cardDicByType[0].ContainsKey(cardId))
            {
                return null;
            }

            return _cardDicByType[0][cardId];
        }

        /// <summary>
        /// 根据男主类型获取词牌列表
        /// </summary>
        public static List<CardData> GetCardListByRoleType(int mainScore)
        {
            if (_cardDicByType.ContainsKey(mainScore))
            {
                return _cardDicByType[mainScore].Values.ToList();
            }

            return new List<CardData>();
        }

        public static bool isFullLv(int cardId, int lv, bool showTips = true)
        {
            CardData cardData = _cardDicByType[0][cardId];
            int rarity = cardData.itemCfg.Rarity;
            int maxLv = CommonDataManager.Tables.TblCardRarityCfg.GetOrDefault(rarity).MaxCardLvl;
            if (lv >= maxLv && cardData.exp >= CommonDataManager.Tables.TblCardLvlCfg.Get(rarity, maxLv).NeedExp)
            {
                if (showTips == true)
                {
                    PromptController.Instance.ShowFloatTextPrompt("已达到最大等级");
                }

                return true;
            }
            else
            {
                return false;
            }
        }

        public static bool isFullStar(int cardId, int star, bool showTips = true)
        {
            CardData cardData = _cardDicByType[0][cardId];
            if (CommonDataManager.Tables.TblCardStarCfg.Get(cardData.id, star + 1) == null)
            {
                if (showTips == true)
                {
                    PromptController.Instance.ShowFloatTextPrompt("已达到最大星级");
                }

                return true;
            }
            else
            {
                return false;
            }
        }

        public static void GetPreViewLvAndExp(int cardId, int curLv, int curExp, int hasExp, out int showLv,
            out int showExp)
        {
            showLv = curLv;
            showExp = curExp + hasExp;
            CardData cardData = _cardDicByType[0][cardId];
            int rarity = cardData.itemCfg.Rarity;
            int maxLv = CommonDataManager.Tables.TblCardRarityCfg.GetOrDefault(rarity).MaxCardLvl;
            CardLvlCfg tCurCfg = CommonDataManager.Tables.TblCardLvlCfg.Get(rarity, showLv);
            while (showExp >= tCurCfg.NeedExp && showLv <= maxLv)
            {
                showExp -= tCurCfg.NeedExp;
                if (showLv + 1 > maxLv)
                {
                    //满级
                    showExp = tCurCfg.NeedExp;
                    break;
                }

                showLv++;
                tCurCfg = CommonDataManager.Tables.TblCardLvlCfg.Get(rarity, showLv);
            }
        }

        public static List<CardData> FilterCardList(List<CardData> cardList)
        {
            List<CardData> _cardList = new List<CardData>();
            for (int i = 0; i < cardList.Count; i++)
            {
                CardData cardData = cardList[i];
                bool isRole = _selectRoleList.Count == 0 || _selectRoleList.IndexOf(cardData.itemCfg.SubType) >= 0;
                bool isRarity = _selectRarityList.Count == 0 || _selectRarityList.IndexOf(cardData.itemCfg.Rarity) >= 0;
                int maxLv = CommonDataManager.Tables.TblCardRarityCfg.GetOrDefault(cardData.itemCfg.Rarity).MaxCardLvl;
                bool isFoster = _selectFosterList.Count == 0 ||
                                _selectFosterList.IndexOf(ConstCardState.STATE_FULL_LV) >= 0 &&
                                cardList[i].lv == maxLv ||
                                _selectFosterList.IndexOf(ConstCardState.STATE_LV) >= 0 && cardList[i].lv < maxLv ||
                                _selectFosterList.IndexOf(ConstCardState.STATE_FULL_STAR) >= 0 &&
                                isFullStar(cardList[i].id, cardList[i].star, false) ||
                                _selectFosterList.IndexOf(ConstCardState.STATE_STAR) >= 0 &&
                                !isFullStar(cardList[i].id, cardList[i].star, false);
                if (isRole && isRarity && isFoster)
                {
                    _cardList.Add(cardData);
                }
            }

            return _cardList;
        }


        public static List<CardStoryCfg> GetStoryCfgsById(int cardId)
        {
            if (_cardStoryCfgDic.Keys.Count == 0)
            {
                List<CardStoryCfg> cardStoryCfgs = CommonDataManager.Tables.TblCardStoryCfg.DataList;

                for (int i = 0; i < cardStoryCfgs.Count; i++)
                {
                    int _cardId = cardStoryCfgs[i].CardId;
                    if (_cardStoryCfgDic.ContainsKey(_cardId) == false)
                    {
                        _cardStoryCfgDic.Add(_cardId, new List<CardStoryCfg>());
                    }

                    _cardStoryCfgDic[_cardId].Add(cardStoryCfgs[i]);
                }
            }

            return _cardStoryCfgDic.ContainsKey(cardId) ? _cardStoryCfgDic[cardId] : new List<CardStoryCfg>();
        }

        //升星是否满足材料消耗
        public static bool GetUpStarEnoughMaterial(int cardId)
        {
            CardData cardData = CardDataManager.GetCardDataById(cardId);
            CardStarCfg starCfg = CommonDataManager.Tables.TblCardStarCfg.Get(cardId, cardData.star);
            for (int i = 0; i < starCfg.Materiars.Count; i++)
            {
                if (GameGlobal.myNumericComponent.GetAsInt(NumericType.IsAutoSelect) == 0 &&
                    ItemDataManager.GetItemNum(starCfg.Materiars[i].ItemId) < starCfg.Materiars[i].Count)
                    return false;
                else if (GameGlobal.myNumericComponent.GetAsInt(NumericType.IsAutoSelect) == 1 &&
                         (i == 0 && (ItemDataManager.GetItemNum(6003001) +
                                     ItemDataManager.GetItemNum(starCfg.Materiars[i].ItemId)) <
                             starCfg.Materiars[i].Count) || (i == 1 &&
                                                             (ItemDataManager.GetItemNum(6003002) +
                                                              ItemDataManager.GetItemNum(starCfg.Materiars[i].ItemId)) <
                                                             starCfg.Materiars[i].Count))
                    return false;
            }

            return true;
        }

        /// <summary>
        /// 根据主属性获取有序牌ID列表（排序规则： 已获得词牌按稀有度从高到低 > 未获得词牌按稀有度从高到低 > 按词牌名字拼音）
        /// </summary>
        /// <param name="mainScore">
        /// 0 - 全部
        /// </param>
        /// <returns></returns>
        public static List<int> GetAllCardIdListByRoleType(int mainScore)
        {
            List<int> result = new List<int>();

            List<ItemCfg> itemCfgs = CommonDataManager.Tables.TblItemCfg.DataList
                .Where(a => a.ItemType == ConstItemType.CARD).ToList();

            itemCfgs.Sort((a, b) =>
            {
                bool haveA = GetCardDataById(a.Id) != null;
                bool haveB = GetCardDataById(b.Id) != null;

                if (haveB && !haveA)
                {
                    return 1;
                }
                else if (!haveB && haveA)
                {
                    return -1;
                }

                if (a.Rarity != b.Rarity)
                {
                    return a.Rarity > b.Rarity ? -1 : 1;
                }

                return a.Res.CompareTo(b.Res);
            });

            for (int i = 0; i < itemCfgs.Count; i++)
            {
                if (itemCfgs[i].IsHide > 0)
                {
                    continue;
                }

                if (mainScore == 0 || itemCfgs[i].MainScore == mainScore)
                {
                    result.Add(itemCfgs[i].Id);
                }
            }

            return result;
        }

        public static void GetTotalProgress(out int haveCount, out int totalCount, int mainScore = 0)
        {
            totalCount = CommonDataManager.Tables.TblItemCfg.DataList.Count(a => a.ItemType == ConstItemType.CARD);

            if (mainScore != 0)
            {
                List<ItemCfg> itemCfgs = CommonDataManager.Tables.TblItemCfg.DataList
                    .Where(a => a.ItemType == ConstItemType.CARD).ToList();

                totalCount = 0;
                for (int i = 0; i < itemCfgs.Count; i++)
                {
                    if (itemCfgs[i].IsHide > 0)
                    {
                        continue;
                    }

                    if (itemCfgs[i].MainScore == mainScore)
                    {
                        ++totalCount;
                    }
                }
            }

            haveCount = _cardDicByType.ContainsKey(mainScore) ? _cardDicByType[mainScore].Count : 0;
        }

        public static int GetNextUpCardNeedRoleLv(int cardLv)
        {
            int roleLv = RoleDataManager.lvl;
            for (int i = roleLv + 1; i < CommonDataManager.Tables.TblRoleLevelCfg.DataList.Count; i++)
            {
                int limit = CommonDataManager.Tables.TblRoleLevelCfg.GetOrDefault(i).CardLeverLimit;
                if (cardLv < limit)
                {
                    roleLv = i;
                    break;
                }
            }

            return roleLv;
        }
    }
}