Client/GameClient/Assets/Game/HotUpdate/Data/ArenaDataManager.cs

using System;
using System.Collections.Generic;
using ET;
using UnityEngine;
using FairyGUI;

namespace GFGGame
{
    public class ArenaDataManager : SingletonBase<ArenaDataManager>
    {
        public long LastFightTime = 0;//上次战斗时间，时间为0，说明未战斗过，则没有段位奖励
        public List<int> ThemeList = new List<int>() { 1, 2, 3 };//本周主题列表
        public string Tag = "异域";//本周标签
        public int SeasonId = 1;// 赛季id
        public int Grade = 1;//本赛季段位
        public int Rank = 10000;//本赛季段位内排名
        public int HighestGrade = 1;//本赛季最高段位
        public int HighestRank = 10000; //本赛最高季段位内排名
        public List<FightData> DressupList = new List<FightData>();//我的搭配列表
        public List<ArenaTargetData> Targets = new List<ArenaTargetData>();//对手
        public ArenaTargetData SelfData;//自己的排行榜信息
        public ArenaTargetData SelfLastData;//自己的上赛季排行榜信息
        public Dictionary<int, List<ArenaTargetData>> RankDatasDic = new Dictionary<int, List<ArenaTargetData>>();//排行榜数据
        public List<ArenaHistoryData> HistoryDatas = new List<ArenaHistoryData>();//获取竞技场历史记录

        /*************************************************************************************************************************************/
        // public Dictionary<int, Texture2D> TextureDic = new Dictionary<int, Texture2D>();
        public List<int> roundTime = new List<int>();
        public List<int> targetRoundTime = new List<int>();
        //Dictionary<回合下标, Dictionary<partId, Dictionary<战斗节点, List<PassivitySkillLvlCfg>>>>
        public Dictionary<int, Dictionary<int, Dictionary<int, List<PassivitySkillLvlCfg>>>> vaildSkills = new Dictionary<int, Dictionary<int, Dictionary<int, List<PassivitySkillLvlCfg>>>>();
        public Dictionary<int, Dictionary<int, Dictionary<int, List<PassivitySkillLvlCfg>>>> targetVaildSkills = new Dictionary<int, Dictionary<int, Dictionary<int, List<PassivitySkillLvlCfg>>>>();
        public int SelectThemeIndex = 0;//当前选中换装主题（ThemeList）的下标
        public int SelectTargetIndex = -1;//当前选中挑战对象的下标
        public int CurFightIndex = 0;//当前挑战场次下标
        public List<long> myScore = new List<long>();//对战数据，三轮分数
        public List<long> targetScore = new List<long>();//对战数据，三轮分数
        public List<long> myFightScore = new List<long>();//对战数据，竞技场战力，搭配战力,卓越点击战力,卡牌战力
        public List<long> targetFightScore = new List<long>();//对战数据，对手竞技场战力，搭配战力,卓越点击战力,卡牌战力

        /*************************************************************************************************************************************/

        public int LastGrade;//战斗前段位
        public int LastRank;//战斗前排行
        public OtherRoleInfoData LastTargetInfo = new OtherRoleInfoData();//战斗对手角色信息
        public List<ArenaTargetData> LastTargets = new List<ArenaTargetData>();//对手
        public int RewardId;//段位提升奖励
        public List<ItemData> BonusList;//战斗结算奖励

        /*************************************************************************************************************************************/

        /// <summary>
        /// 是否快速挑战
        /// </summary>
        /// <value></value>
        public bool QuickFight
        {
            get
            {
                return StorageDataManager.Instance.GetStorageValue(ConstStorageId.ARENA_QUICK_FIGHT) == 1 ? true : false;
            }
            set
            {
                StorageSProxy.ReqSetClientValue(ConstStorageId.ARENA_QUICK_FIGHT, value == true ? 1 : 0).Coroutine();
            }
        }
        public void Clear()
        {
            ThemeList.Clear();
            DressupList.Clear();
            Targets.Clear();
            RankDatasDic.Clear();
            HistoryDatas.Clear();
            // TextureDic.Clear();
            myScore.Clear();
            targetScore.Clear();
            myFightScore.Clear();
            targetFightScore.Clear();
            roundTime.Clear();
            targetRoundTime.Clear();
            // LastTargetInfo = null;
            SelfData = null;
            SelfLastData = null;
        }
        /// <summary>
        /// 是否结算中
        /// </summary>
        /// <returns></returns>
        public bool IsArenaClearing
        {
            get
            {
                long curTime = TimeHelper.ServerNow();
                long startTime = TimeUtil.GetCurWeekTime(GlobalCfgArray.globalCfg.clearingStartWeekDay, GlobalCfgArray.globalCfg.clearingStartTime);
                long endTime = TimeUtil.GetCurWeekTime(GlobalCfgArray.globalCfg.clearingEndWeekDay, GlobalCfgArray.globalCfg.clearingEndTime);
                if (GlobalCfgArray.globalCfg.clearingEndWeekDay >= GlobalCfgArray.globalCfg.clearingStartWeekDay)
                {
                    //结算时间开始到结束未跨周(例：本周六开始，本周日结束)
                    return curTime >= startTime && curTime <= endTime;
                }
                else
                {
                    //结算时间开始到结束跨周(例：本周六开始，下周一结束)
                    return curTime <= endTime || curTime >= startTime;
                }
            }
        }
        /// <summary>
        /// 赛季是否开启
        /// </summary>
        /// <value></value>
        public bool IsSeasonOpen
        {
            get 
            {
                ArenaOpenCfg cfg = ArenaOpenCfgArray.Instance.GetCfg(SeasonId);
                if (TimeUtil.IsBeforeCurTime(cfg.openTime) && TimeUtil.IsLaterCurTime(cfg.endTime))
                {
                    return true;
                }
                return false;
            }
        }
        /// <summary>
        /// 试图更新最高段位、排行数据
        /// </summary>
        public void TryUpdateHighest()
        {
            HighestGrade = HighestGrade >= Grade ? HighestGrade : Grade;
            HighestRank = HighestRank >= Rank ? HighestRank : Rank;
        }

        //获取竞技场对手角色战斗数据
        public FightData GetArenaFightData(int index, ArenaTargetData arenaTarget)
        {
            return arenaTarget.FightDatas[index];
        }

        /// <summary>
        /// 获取推荐卡牌
        /// </summary>
        public int GetRecommentCardId(int scoreType, List<int> itemList)
        {
            List<CardData> cardDatas = FightDataManager.Instance.SortCardList(CardDataManager.GetCardListByRarity(0), itemList, scoreType);
            if (cardDatas.Count == 0) return 0;
            return cardDatas[0].itemCfg.id;
        }
        /// <summary>
        /// 获取推荐列表
        /// </summary>
        /// <param name="scoreType"></param>
        /// <param name="tags"></param>
        /// <returns></returns>
        public List<int> GetRecommentItemList(int scoreType, string[] tags)
        {
            Dictionary<int, List<int>> itemListDic = new Dictionary<int, List<int>>();
            Dictionary<int, List<int>> itemDatasDic = DressUpMenuItemDataManager.ItemDatasBySubTypeDic;

            foreach (int subType in itemDatasDic.Keys)
            {
                int key = subType;
                if (itemDatasDic.Count == 0) continue;
                if (DressUpMenuItemCfg1Array.Instance.CheckIsSceneTypeBySubType(subType)) continue;
                List<int> dressList = SortDressList(itemDatasDic[subType], scoreType, tags);
                int max = subType == (int)ConstDressUpItemType.TE_SHU ? 3 : 1;
                max = Math.Min(max, dressList.Count);
                if (DressUpMenuItemCfg1Array.Instance.CheckIsOrnamentsTypeBySubType(subType))
                {
                    key = ConstDressUpItemType.TE_SHU;//饰品全放在一个列表里
                }
                if (!itemListDic.ContainsKey(key))
                {
                    itemListDic[key] = new List<int>();
                }
                itemListDic[key].AddRange(dressList.GetRange(0, max));
            }
            if (itemListDic.ContainsKey(ConstDressUpItemType.LIAN_YI_QUN) &&
            (!itemListDic.ContainsKey(ConstDressUpItemType.SHANG_YI) ||
            !itemListDic.ContainsKey(ConstDressUpItemType.XIA_ZHUANG) ||
            !itemListDic.ContainsKey(ConstDressUpItemType.NEI_DA)))
            {
                itemListDic.Remove(ConstDressUpItemType.SHANG_YI);
                itemListDic.Remove(ConstDressUpItemType.XIA_ZHUANG);
                itemListDic.Remove(ConstDressUpItemType.NEI_DA);
            }
            else if (!itemListDic.ContainsKey(ConstDressUpItemType.LIAN_YI_QUN) &&
            (itemListDic.ContainsKey(ConstDressUpItemType.SHANG_YI) &&
            itemListDic.ContainsKey(ConstDressUpItemType.XIA_ZHUANG) &&
            itemListDic.ContainsKey(ConstDressUpItemType.NEI_DA)))
            {
                itemListDic.Remove(ConstDressUpItemType.LIAN_YI_QUN);
            }
            if (itemListDic.ContainsKey(ConstDressUpItemType.LIAN_YI_QUN) && itemListDic.ContainsKey(ConstDressUpItemType.SHANG_YI) && itemListDic.ContainsKey(ConstDressUpItemType.XIA_ZHUANG) && itemListDic.ContainsKey(ConstDressUpItemType.NEI_DA))
            {
                bool hasTagLYQ = ItemDataManager.CheckItemTagsRight(itemListDic[ConstDressUpItemType.LIAN_YI_QUN][0], tags);
                bool hasTagSY = ItemDataManager.CheckItemTagsRight(itemListDic[ConstDressUpItemType.SHANG_YI][0], tags);
                bool hasTagXZ = ItemDataManager.CheckItemTagsRight(itemListDic[ConstDressUpItemType.XIA_ZHUANG][0], tags);
                bool hasTagND = ItemDataManager.CheckItemTagsRight(itemListDic[ConstDressUpItemType.NEI_DA][0], tags);
                if (hasTagLYQ && !hasTagSY && !hasTagXZ)
                {
                    itemListDic.Remove(ConstDressUpItemType.SHANG_YI);
                    itemListDic.Remove(ConstDressUpItemType.XIA_ZHUANG);
                    itemListDic.Remove(ConstDressUpItemType.NEI_DA);
                }
                else if (!hasTagLYQ && (hasTagSY || hasTagXZ))
                {
                    itemListDic.Remove(ConstDressUpItemType.LIAN_YI_QUN);
                }
                else
                {
                    int scoreLYQ = ItemDataManager.GetItemAdditionScore(itemListDic[ConstDressUpItemType.LIAN_YI_QUN][0], scoreType, tags);
                    int scoreSY = ItemDataManager.GetItemAdditionScore(itemListDic[ConstDressUpItemType.SHANG_YI][0], scoreType, tags);
                    int scoreXZ = ItemDataManager.GetItemAdditionScore(itemListDic[ConstDressUpItemType.XIA_ZHUANG][0], scoreType, tags);
                    int scoreND = ItemDataManager.GetItemAdditionScore(itemListDic[ConstDressUpItemType.NEI_DA][0], scoreType, tags);
                    if (scoreLYQ > scoreSY + scoreXZ + scoreND)
                    {
                        itemListDic.Remove(ConstDressUpItemType.SHANG_YI);
                        itemListDic.Remove(ConstDressUpItemType.XIA_ZHUANG);
                        itemListDic.Remove(ConstDressUpItemType.NEI_DA);
                    }
                    else
                    {
                        itemListDic.Remove(ConstDressUpItemType.LIAN_YI_QUN);
                    }
                }
            }
            List<int> itemList = new List<int>();
            foreach (int subType in itemListDic.Keys)
            {
                DressUpMenuItemDataManager.SortItemListByHighScore(itemListDic[subType]);
                if (subType == ConstDressUpItemType.TE_SHU)
                {
                    int max = Math.Min(itemListDic[subType].Count, 5);
                    itemList.AddRange(itemListDic[subType].GetRange(0, max));
                }
                else
                {
                    itemList.AddRange(itemListDic[subType]);
                }
            }
            return itemList;
        }
        private List<int> SortDressList(List<int> dressList, int scoreType, string[] tags)
        {
            dressList.Sort((int a, int b) =>
            {
                ItemCfg cfgA = ItemCfgArray.Instance.GetCfg(a);
                ItemCfg cfgB = ItemCfgArray.Instance.GetCfg(b);
                bool isTagA = ItemDataManager.CheckItemTagsRight(a, tags);
                bool isTagB = ItemDataManager.CheckItemTagsRight(b, tags);
                if (isTagA && !isTagB) return -1;
                if (isTagB && !isTagA) return 1;
                int scoreA = ItemDataManager.GetItemAdditionScore(a, scoreType, tags);
                int scoreB = ItemDataManager.GetItemAdditionScore(b, scoreType, tags);
                if (scoreA > scoreB) return -1;
                if (scoreA < scoreB) return 1;
                return cfgA.id - cfgB.id;
            });
            return dressList;
        }


        /// <summary>
        /// 获取符合标签的服装总个数
        /// </summary>
        /// <param name="itemList">服装列表</param>
        /// <param name="tags">标签</param>
        /// <returns></returns>
        public int GetTagsCount(List<int> itemList, string[] tags)
        {
            int count = 0;
            for (int i = 0; i < itemList.Count; i++)
            {
                if (ItemDataManager.CheckItemTagsRight(itemList[i], tags))
                {
                    if (ItemUtilCS.GetItemSubType(itemList[i]) == ConstDressUpItemType.LIAN_YI_QUN)
                    {
                        count += 3;
                    }
                    {
                        count++;
                    }
                }

            }
            return count;
        }

        /*********************************************************************************************************************/
        public void SetMineFightAttrs()
        {
            for (int i = 0; i < DressupList.Count; i++)
            {
                SetMineFightAttr(DressupList[i], ThemeList[i]);
            }
        }

        public void SetMineFightAttr(FightData fightData, int theme)
        {
            fightData.cardScore = ItemDataManager.GetItemAdditionScore(fightData.cardId, theme, fightData.tags);
            fightData.skillLvs = SkillDataManager.Instance.GetCardSkillLvs(fightData.cardId);
            FightDataManager.Instance.SetItemScoreList(fightData);
        }
        /// <summary>
        /// 获取三套服装总战力
        /// </summary>
        /// <param name="roleType"></param>
        /// <param name="roleDatas"></param>
        /// <param name="robotDatas"></param>
        /// <returns></returns>
        public long GetAllFightScore(List<long> fightScores)
        {
            long fightScore = 0;

            for (int i = 0; i < fightScores.Count; i++)
            {
                fightScore += fightScores[i];
            }
            return fightScore;
        }
        public long GetAllFightScore(List<FightData> roleDatas)
        {
            long fightScore = 0;
            List<long> fightScoreDatas = GetFightScoreList(roleDatas);
            for (int i = 0; i < fightScoreDatas.Count; i++)
            {
                fightScore += fightScoreDatas[i];
            }
            return fightScore;
        }
        /// <summary>
        /// index=0:搭配战力
        /// index=1:卓越点击战力
        /// index=2:卡牌战力/技能战力
        /// </summary>
        /// <param name="roleType"></param>
        /// <param name="fightDatas"></param>
        /// <param name="robotDatas"></param>
        /// <returns></returns>
        public List<long> GetFightScoreList(List<FightData> fightDatas)
        {
            List<long> fightScoreDatas = new List<long>();
            long itemSum = 0;
            double clickScore = 0;
            long skillScore = 0;
            for (int i = 0; i < ThemeList.Count; i++)
            {
                if (fightDatas[i].type == FightTargetType.PLAYER)
                {
                    long itemsScore = GetItemScoreSum(fightDatas[i].itemScoreList);
                    itemSum += itemsScore;
                    clickScore += GetPerfectClickScore(fightDatas[i]);
                    skillScore += FightDataManager.Instance.GetSkillFightScore(itemsScore, fightDatas[i].baseScore, fightDatas[i].cardId, fightDatas[i].cardScore, fightDatas[i].skillLvs);
                }
                else
                {
                    long itemsScore = GetItemScoreSum(fightDatas[i].itemScoreList);
                    itemSum += itemsScore;
                    clickScore += GetRobotPerfectClickScore(fightDatas[i]);
                    skillScore += FightDataManager.Instance.GetSkillFightScore(itemsScore, fightDatas[i].baseScore, fightDatas[i].cardId, fightDatas[i].cardScore, fightDatas[i].skillLvs);
                }
            }
            clickScore = clickScore / ConstScoreSystem.PART_SCORE;
            fightScoreDatas.Add(itemSum);
            fightScoreDatas.Add((long)Math.Ceiling(clickScore));
            fightScoreDatas.Add(skillScore);
            return fightScoreDatas;
        }

        /// <summary>
        /// 所有部件主属性和
        /// </summary>
        /// <returns></returns>
        public long GetItemScoreSum(List<int> itemScoreList)
        {
            long scoreSum = 0;
            for (int i = 0; i < itemScoreList.Count; i++)
            {
                scoreSum += (long)itemScoreList[i];
            }
            return scoreSum;

        }
        //玩家卓越点击战力
        private long GetPerfectClickScore(FightData roleData)
        {
            double clickScore = 0;
            foreach (int key in roleData.pardScoreListDic.Keys)
            {
                double partBaseScore = ScoreSystemData.Instance.GetPartBaseScore(roleData, key);
                double score = (partBaseScore + (roleData.baseScore + roleData.cardScore) * ConstScoreSystem.PERFECT_SCORE) * ConstScoreSystem.CLICK_SCORE;
                clickScore += score;
            }
            return (long)Math.Ceiling(clickScore);
        }
        //机器人卓越点击战力
        private long GetRobotPerfectClickScore(FightData robotData)
        {
            long clickScore = 0;
            FightScoreCfg[] scoreCfg = FightScoreCfgArray.Instance.dataArray;
            for (int i = 0; i < scoreCfg.Length; i++)
            {
                clickScore += (long)ScoreSystemData.Instance.GetRobotPartScore(robotData, i + 1, ClickType.PREFACT_CLICK, 0);
            }
            return clickScore;
        }

        /************************************************************************************************************/

        public void AddCheckSeasonOpenTimer()
        {
            RemoveCheckSeasonOpenTimer();
            Timers.inst.Add(1, 0, OnTimeUpdate);
        }
        private void OnTimeUpdate(object param)
        {
            if (!IsSeasonOpen) return;
            if (ThemeList.Count == 0)
            {
                ReqArenaInfo();
            }
            RemoveCheckSeasonOpenTimer();
        }
        public void ReqArenaInfo()
        {
            if (FunctionOpenDataManager.Instance.CheckIsFunOpenById(typeof(ArenaView).Name, false))
            {
                ArenaSproxy.ReqArenaInfos().Coroutine();
                ArenaSproxy.ReqArenaHistory().Coroutine();
            }
        }
        private void RemoveCheckSeasonOpenTimer()
        {
            Timers.inst.Remove(OnTimeUpdate);
        }
    }
}