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

using System;
using System.Collections.Generic;
using System.Linq;
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> myFightPower = new List<long>(); //对战数据，竞技场战力，搭配战力,卓越点击战力,词牌战力
        public List<long> targetFightPower = 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();
            myFightPower.Clear();
            targetFightPower.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<int> wearCardIds)
        {
            float dressListAllAcore = FightDataManager.Instance.GetDressListAllScore(itemList, scoreType);
            List<CardData> cardDatas = FightDataManager.Instance.SortCardList(CardDataManager.GetCardListByRarity(0),
                dressListAllAcore, scoreType);
            cardDatas = cardDatas.Where(a => !wearCardIds.Contains(a.id)).ToList();
            if (cardDatas.Count == 0) return 0;
            wearCardIds.Add(cardDatas[0].itemCfg.id);
            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));
            }

            bool isHasLYQ = itemListDic.ContainsKey(ConstDressUpItemType.LIAN_YI_QUN);
            bool isHasSY = itemListDic.ContainsKey(ConstDressUpItemType.SHANG_YI);
            bool isHasXZ = itemListDic.ContainsKey(ConstDressUpItemType.XIA_ZHUANG);
            bool isHasND = itemListDic.ContainsKey(ConstDressUpItemType.NEI_DA);

            int countTagLYQ =
                isHasLYQ && ItemDataManager.CheckItemTagsRight(itemListDic[ConstDressUpItemType.LIAN_YI_QUN][0], tags)
                    ? 1
                    : 0;
            int countTagSY =
                isHasSY && ItemDataManager.CheckItemTagsRight(itemListDic[ConstDressUpItemType.SHANG_YI][0], tags)
                    ? 1
                    : 0;
            int countTagXZ =
                isHasXZ && ItemDataManager.CheckItemTagsRight(itemListDic[ConstDressUpItemType.XIA_ZHUANG][0], tags)
                    ? 1
                    : 0;
            int countTagND =
                isHasND && ItemDataManager.CheckItemTagsRight(itemListDic[ConstDressUpItemType.NEI_DA][0], tags)
                    ? 1
                    : 0;

            if (countTagLYQ > countTagSY + countTagXZ + countTagND)
            {
                itemListDic.Remove(ConstDressUpItemType.NEI_DA);
                itemListDic.Remove(ConstDressUpItemType.SHANG_YI);
                itemListDic.Remove(ConstDressUpItemType.XIA_ZHUANG);
            }
            else if (countTagLYQ < countTagSY + countTagXZ + countTagND)
            {
                itemListDic.Remove(ConstDressUpItemType.LIAN_YI_QUN);
            }
            else
            {
                int scoreLYQ = !isHasLYQ
                    ? 0
                    : ItemDataManager.GetItemAdditionScore(itemListDic[ConstDressUpItemType.LIAN_YI_QUN][0], scoreType,
                        tags);
                int scoreSY = !isHasSY
                    ? 0
                    : ItemDataManager.GetItemAdditionScore(itemListDic[ConstDressUpItemType.SHANG_YI][0], scoreType,
                        tags);
                int scoreXZ = !isHasXZ
                    ? 0
                    : ItemDataManager.GetItemAdditionScore(itemListDic[ConstDressUpItemType.XIA_ZHUANG][0], scoreType,
                        tags);
                int scoreND = !isHasND
                    ? 0
                    : 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:最高点击战力分 = (卓越点击战力+登峰造极额外加分) / 服装部件评分系数2.33 原来:卓越点击战力
        /// index=2:词牌战力/技能战力
        /// </summary>
        /// <param name="fightDatas"></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;
            //登峰造极额外加分
            double maxScore = 0;
            for (int i = 0; i < ThemeList.Count; i++)
            {
                var fightData = fightDatas[i];
                if (fightData.type == FightTargetType.PLAYER)
                {
                    long itemsScore = GetItemScoreSum(fightData.itemScoreList);
                    itemSum += itemsScore;
                    clickScore += GetPerfectClickScore(fightData);
                    skillScore += FightDataManager.Instance.GetSkillFightScore(itemsScore, fightData.baseScore,
                        fightData.leagueSkillScore, fightData.cardId, fightData.cardScore,
                        fightData.skillLvs);
                }
                else
                {
                    long itemsScore = GetItemScoreSum(fightData.itemScoreList);
                    itemSum += itemsScore;
                    clickScore += GetRobotPerfectClickScore(fightData);
                    skillScore += FightDataManager.Instance.GetSkillFightScore(itemsScore, fightData.baseScore,
                        fightData.leagueSkillScore, fightData.cardId, fightData.cardScore,
                        fightData.skillLvs);
                }

                //总主属性分
                double mainScore = ScoreSystemData.Instance.GetMainScore(fightData);
                maxScore += ScoreSystemData.Instance.GetAllCircleAddScore(fightData);
            }
            
            //A:(部件基础评分+(角色等级分数+角色雅集技能分+词牌对应主题的属性分数)*点击完美附加评分系数0.2) * 点击系数2.22
            //A/服装部件评分系数2.33
            clickScore = clickScore / ConstScoreSystem.PART_SCORE;
            fightScoreDatas.Add(itemSum);
            // fightScoreDatas.Add((long)Math.Ceiling(clickScore));
            //最高点击战力分 = (卓越点击战力+登峰造极额外加分) / 服装部件评分系数2.33
            maxScore = maxScore / ConstScoreSystem.PART_SCORE;
            long maxClickScore = (long)Math.Ceiling(clickScore) + (long)Math.Ceiling(maxScore);
            fightScoreDatas.Add(maxClickScore);
            fightScoreDatas.Add(skillScore);
         
            return fightScoreDatas;
        }

        /// <summary>
        /// 所有部件主属性和
        /// </summary>
        /// <returns></returns>
        public long GetItemScoreSum(List<float> 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.partScoreListDic.Keys)
            {
                double partBaseScore = ScoreSystemData.Instance.GetroundBaseScore(roleData, key);
                //start------------------------------------------------------
                //本段注释为上个版本的计算公式，留做备份参考
                //（部件基础分+（人物基础分+雅集技能分数+卡牌属性分数）*卓越点击系数）*点击系数
                //double score =
                //    (partBaseScore + (roleData.baseScore + roleData.leagueSkillScore + roleData.cardScore) *
                //        ConstScoreSystem.PERFECT_SCORE) * ConstScoreSystem.CLICK_SCORE;
                //end--------------------------------------------------------
                //改为 点击评分 =（部件基础分+人物基础分）*点击系数
                double score = (partBaseScore + roleData.baseScore)* ConstScoreSystem.PERFECT_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.GetRobotRoundScore(robotData, i + 1, ClickType.PERFECT_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 async void ReqArenaInfo()
        {
            if (FunctionOpenDataManager.Instance.CheckIsFunOpenById(typeof(ArenaView).Name, false))
            {
                await ArenaSproxy.ReqArenaInfos();
                for (int i = 0; i < ArenaDataManager.Instance.Targets.Count; i++)
                {
                    ArenaTargetData targetData = ArenaDataManager.Instance.Targets[i];
                    if (targetData.Type == FightTargetType.PLAYER)
                    {
                        ArenaSproxy.ReqArenaFightAttr(targetData.RoleInfo.roleId, targetData.FightDatas).Coroutine();
                    }
                }

                ArenaSproxy.ReqArenaHistory().Coroutine();
            }
        }

        private void RemoveCheckSeasonOpenTimer()
        {
            Timers.inst.Remove(OnTimeUpdate);
        }
    }
}