XiuXianProject/GameClient/Assets/Game/HotUpdate/ServerProxy/ArenaSproxy.cs

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

namespace GFGGame
{
    public class NoticeArebaRankChange : AMHandler<SC_RankChange>
    {
        protected override async ETTask Run(Session session, SC_RankChange message)
        {
            ArenaDataManager.Instance.Grade = message.Grade;
            ArenaDataManager.Instance.Rank = message.RankInGrade;
            ArenaDataManager.Instance.TryUpdateHighest();
            await ETTask.CompletedTask;
        }
    }

    public class NoticeArenaHistoryChange : AMHandler<SC_ArenaHistoryAdd>
    {
        protected override async ETTask Run(Session session, SC_ArenaHistoryAdd message)
        {
            ArenaHistoryData historyData = ArenaSproxy.GetArenaHistoryData(message.history);
            ArenaDataManager.Instance.HistoryDatas.Insert(0, historyData);
            if (ArenaDataManager.Instance.HistoryDatas.Count > 20)
            {
                ArenaDataManager.Instance.HistoryDatas.RemoveAt(ArenaDataManager.Instance.HistoryDatas.Count - 1);
            }

            // if (ViewManager.isViewOpen(typeof(ArenaView).FullName))
            // {
            //     ViewManager.Show<ArenaView>();
            // }
            await ETTask.CompletedTask;
        }
    }

    public class NoticeArenaWeekClear : AMHandler<SC_ArenaWeekClear>
    {
        protected override async ETTask Run(Session session, SC_ArenaWeekClear message)
        {
            ArenaDataManager.Instance.Tag = message.Tag;
            ArenaDataManager.Instance.ThemeList = message.Themes;
            if (ViewManager.isViewOpen(typeof(ArenaView).FullName))
            {
                ViewManager.Show<ArenaView>();
                PromptController.Instance.ShowFloatTextPrompt("周结算已更新");
            }

            await ETTask.CompletedTask;
        }
    }

    public class NoticeArenaSeasonEnd : AMHandler<SC_ArenaSeasonEnd>
    {
        protected override async ETTask Run(Session session, SC_ArenaSeasonEnd message)
        {
            if (ViewManager.isViewOpen(typeof(ArenaView).FullName))
            {
                ViewManager.GoBackFrom(typeof(ArenaView).FullName);
                PromptController.Instance.ShowFloatTextPrompt("赛季已结束");
            }

            ArenaDataManager.Instance.Clear();
            ArenaDataManager.Instance.SeasonId = message.seasonId;
            ArenaDataManager.Instance.AddCheckSeasonOpenTimer();
            await ETTask.CompletedTask;
        }
    }

    public static class ArenaSproxy
    {
        //获取竞技场信息
        public static async ETTask ReqArenaInfos()
        {
            S2C_GetArenaInfos response = null;
            response = (S2C_GetArenaInfos)await MessageHelper.SendToServer(new C2S_GetArenaInfos());
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ArenaDataManager.Instance.LastFightTime = response.LastFightTime;
                    ArenaDataManager.Instance.ThemeList = response.ThemeList;
                    ArenaDataManager.Instance.Tag = response.Tag;
                    ArenaDataManager.Instance.SeasonId = response.SeasonId;
                    ArenaDataManager.Instance.Grade = response.Grade;
                    ArenaDataManager.Instance.Rank = response.RankInGrade;
                    ArenaDataManager.Instance.HighestGrade = response.HighestGradeOfSeason;
                    ArenaDataManager.Instance.HighestRank = response.HighestRankInGradeOfSeason;
                    OtherRoleInfoData roleInfo = new OtherRoleInfoData();

                    roleInfo.roleName = RoleDataManager.roleName;
                    roleInfo.roleLv = RoleDataManager.lvl;
                    roleInfo.headId = RoleDataManager.headId;

                    // ArenaDataManager.Instance.Clear();
                    ArenaDataManager.Instance.DressupList.Clear();
                    for (int i = 0; i < response.ThemeList.Count; i++)
                    {
                        FightData roleData =
                            GetFightRoleData(response.DressupList.Count <= i ? null : response.DressupList[i], roleInfo,
                                i);
                        roleData.leagueSkillScore = LeagueDataManager.Instance.GetAllSkillScore(response.ThemeList[i]);
                        FightDataManager.Instance.SetItemScoreList(roleData);
                        ScoreSystemData.Instance.SetEquipScoresWithPartId(roleData);
                        ArenaDataManager.Instance.DressupList.Add(roleData);
                    }

                    ArenaDataManager.Instance.Targets.Clear();
                    for (int i = 0; i < response.targets.Count; i++)
                    {
                        ArenaTargetData targetData = GetArenaTargetData(response.targets[i]);
                        ArenaDataManager.Instance.Targets.Add(targetData);
                        if (targetData.Type == FightTargetType.PLAYER)
                        {
                            await ArenaSproxy.ReqArenaFightAttr(targetData.RoleInfo.roleId, targetData.FightDatas);
                        }
                    }

                    ArenaDataManager.Instance.AddCheckSeasonOpenTimer();

                    if (ViewManager.isViewOpen(typeof(ArenaView).FullName))
                    {
                        ViewManager.Show<ArenaView>();
                    }
                }
            }
        }

        //刷新竞争对手
        public static async ETTask<bool> ReqRefreshArenaTargets()
        {
            S2C_RefreshArenaTargets response = null;
            response = (S2C_RefreshArenaTargets)await MessageHelper.SendToServer(new C2S_RefreshArenaTargets());
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ArenaDataManager.Instance.Targets.Clear();
                    for (int i = 0; i < response.targets.Count; i++)
                    {
                        ArenaTargetData targetData = GetArenaTargetData(response.targets[i]);
                        ArenaDataManager.Instance.Targets.Add(targetData);
                        if (targetData.Type == FightTargetType.PLAYER)
                        {
                            await ArenaSproxy.ReqArenaFightAttr(targetData.RoleInfo.roleId, targetData.FightDatas);
                        }
                    }

                    PromptController.Instance.ShowFloatTextPrompt("刷新成功");
                    return true;
                }
            }

            return false;
        }

        //更换搭配
        public static async ETTask<bool> ReqChangeArenaDressup(int index, int cardId, List<int> itemList,
            List<long> scoreList = null)
        {
            S2C_ChangeArenaDressup response = null;
            response = (S2C_ChangeArenaDressup)await MessageHelper.SendToServer(new C2S_ChangeArenaDressup()
                { Index = index, CardId = cardId, EquipIds = itemList, SelfFightPower = scoreList });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ArenaDataManager.Instance.DressupList[index].cardId = cardId;
                    ArenaDataManager.Instance.DressupList[index].itemList = itemList;
                    return true;
                }
            }

            return false;
        }

        //购买挑战次数
        public static async ETTask<bool> ReqBuyArenaFightTimes()
        {
            S2C_BuyArenaFightTimes response = null;
            response = (S2C_BuyArenaFightTimes)await MessageHelper.SendToServer(new C2S_BuyArenaFightTimes() { });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    PromptController.Instance.ShowFloatTextPrompt("购买成功");
                    return true;
                }
            }

            return false;
        }


        //挑战
        public static async ETTask<bool> ReqArenaFight(bool isWin, ArenaTargetData targetData,
            List<long> selfFightPower, List<long> targetFightPower, List<long> myScore, List<long> targetScore)
        {
            S2C_ArenaFight response = null;
            response = (S2C_ArenaFight)await MessageHelper.SendToServer(new C2S_ArenaFight()
            {
                RoleId = RoleDataManager.roleId,
                Grade = targetData.Grade,
                RankInGrade = targetData.RankInGrade,
                Type = targetData.Type,
                TargetRoleId = targetData.RoleInfo.roleId,
                IsWin = isWin,
                SelfFightPower = selfFightPower,
                TargetFightPower = targetFightPower,
                SelfRandScore = myScore,
                TargetRandScore = targetScore,
            }, false);
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    //记录老数据，用于结算展示
                    ArenaDataManager.Instance.LastFightTime = response.LastFightTime;
                    ArenaDataManager.Instance.LastGrade = ArenaDataManager.Instance.Grade;
                    ArenaDataManager.Instance.LastRank = ArenaDataManager.Instance.Rank;
                    ArenaDataManager.Instance.LastTargetInfo.roleName = targetData.RoleInfo.roleName;
                    ArenaDataManager.Instance.LastTargetInfo.headId = targetData.RoleInfo.headId;
                    ArenaDataManager.Instance.LastTargetInfo.headBorderId = targetData.RoleInfo.headBorderId;
                    ArenaDataManager.Instance.LastTargetInfo.headRes = targetData.RoleInfo.headRes;
                    ArenaDataManager.Instance.BonusList = ItemUtil.CreateItemDataList(response.rewards);
                    ArenaDataManager.Instance.LastTargets =
                        new List<ArenaTargetData>(ArenaDataManager.Instance.Targets);
                    ArenaDataManager.Instance.RewardId = response.RewardId;

                    //更新新数据
                    ArenaDataManager.Instance.Targets.Clear();
                    for (int i = 0; i < response.targets.Count; i++)
                    {
                        ArenaTargetData _targetData = GetArenaTargetData(response.targets[i]);
                        ArenaDataManager.Instance.Targets.Add(_targetData);
                        if (_targetData.Type == FightTargetType.PLAYER)
                        {
                            await ArenaSproxy.ReqArenaFightAttr(_targetData.RoleInfo.roleId, _targetData.FightDatas);
                        }
                    }

                    ArenaDataManager.Instance.Grade = response.Grade;
                    ArenaDataManager.Instance.Rank = response.RankInGrade;
                    ArenaDataManager.Instance.TryUpdateHighest();
                    EventAgent.DispatchEvent(ConstMessage.ARENA_FIGHT_RESULT);

                    return true;
                }
                else if (response.Error == ErrorCode.ERR_ArenaFightFail)
                {
                    //更新新数据
                    ArenaDataManager.Instance.Targets.Clear();
                    for (int i = 0; i < response.targets.Count; i++)
                    {
                        // ArenaDataManager.Instance.Targets.Add(GetArenaTargetData(response.targets[i]));
                        ArenaTargetData _targetData = GetArenaTargetData(response.targets[i]);
                        ArenaDataManager.Instance.Targets.Add(_targetData);
                        if (_targetData.Type == FightTargetType.PLAYER)
                        {
                            await ArenaSproxy.ReqArenaFightAttr(_targetData.RoleInfo.roleId, _targetData.FightDatas);
                        }
                    }

                    EventAgent.DispatchEvent(ConstMessage.ARENA_FIGHT_RESULT);
                    //PromptController.Instance.ShowFloatTextPrompt("对方排名已发生变化");
                    ErrorCodeController.Handler(response.Error);
                    return false;
                }
                else
                {
                    ErrorCodeController.Handler(response.Error);
                }
            }

            return false;
        }

        //获取排行榜
        public static async ETTask<bool> ReqArenaRank(int rankType, int startIndex, int endIndex)
        {
            S2C_ArenaRank response = null;
            response = (S2C_ArenaRank)await MessageHelper.SendToServer(new C2S_ArenaRank()
                { RankType = rankType, StartIndex = startIndex, EndIndex = endIndex });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    if (!ArenaDataManager.Instance.RankDatasDic.ContainsKey(rankType))
                    {
                        ArenaDataManager.Instance.RankDatasDic[rankType] = new List<ArenaTargetData>();
                    }

                    List<ArenaTargetData> rankDatas = ArenaDataManager.Instance.RankDatasDic[rankType];
                    for (int i = 0; i < response.ranks.Count; i++)
                    {
                        rankDatas.Add(GetArenaTargetData(response.ranks[i]));
                    }

                    if (response.self != null)
                    {
                        if (rankType == ArenaRankType.LAST_SEASON)
                        {
                            ArenaDataManager.Instance.SelfLastData = GetArenaTargetData(response.self);
                        }
                        else
                        {
                            ArenaDataManager.Instance.SelfData = GetArenaTargetData(response.self);
                        }
                    }

                    return true;
                }
            }

            return false;
        }

        //获取竞技场历史记录
        public static async ETTask ReqArenaHistory()
        {
            S2C_ArenaHistory response = null;
            response = (S2C_ArenaHistory)await MessageHelper.SendToServer(new C2S_ArenaHistory()
                { RoleId = RoleDataManager.roleId });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ArenaDataManager.Instance.HistoryDatas.Clear();
                    for (int i = 0; i < response.history.Count; i++)
                    {
                        ArenaDataManager.Instance.HistoryDatas.Add(GetArenaHistoryData(response.history[i]));
                    }
                }
            }
        }

        //获取对手服装属性
        public static async ETTask<bool> ReqArenaFightAttr(long roleId, List<FightData> list)
        {
            S2C_ArenaFightAttr response = null;
            response = (S2C_ArenaFightAttr)await MessageHelper.SendToServer(new C2S_ArenaFightAttr()
                { TargetRoleId = roleId });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    // if (list.Count < response.data.Count) return false;
                    for (int i = 0; i < response.data.Count; i++)
                    {
                        ArenaDressupAttrProto attrProto = response.data[i];
                        list[i].cardScore = attrProto.CardScore;
                        for (int j = 0; j < attrProto.SuitScore.Count; j++)
                        {
                            list[i].itemScoreList.Add(attrProto.SuitScore[j]);
                        }

                        list[i].itemList = response.DressupList[i].EquipIds;
                        list[i].cardId = response.DressupList[i].CardId;
                        for (int j = 0; j < response.SkillAttrs.Count; j++)
                        {
                            if (response.SkillAttrs[j].Score == list[i].scoreType)
                            {
                                list[i].leagueSkillScore = response.SkillAttrs[j].Value;
                            }
                        }

                        List<PassivitySkillCfg> skillCfgs =
                            CommonDataManager.Tables.TblPassivitySkillCfg.DataList
                                .Where(a => a.CardId == attrProto.CardId).ToList();

                        if (skillCfgs != null)
                        {
                            for (int j = 0; j < skillCfgs.Count; j++)
                            {
                                int skillId = skillCfgs[j].SkillId;
                                int index = attrProto.SkillId.IndexOf(skillId);
                                if (index < 0)
                                {
                                    list[i].skillLvs.Add(1);
                                }
                                else
                                {
                                    list[i].skillLvs.Add(attrProto.SkillLevel[index]);
                                }
                            }
                        }

                        ArenaDataManager.Instance.SetItemScoreList(list[i], attrProto);
                        ScoreSystemData.Instance.SetEquipScoresWithPartId(list[i]);
                    }

                    return true;
                }
            }

            return false;
        }

        public static ArenaHistoryData GetArenaHistoryData(ArenaHistoryProto arenaHistoryProto)
        {
            ArenaHistoryData arenaHistory = new ArenaHistoryData();
            arenaHistory.isWin = arenaHistoryProto.IsWin;
            arenaHistory.IsChallenge = arenaHistoryProto.IsChallenge;
            arenaHistory.FightTime = arenaHistoryProto.FightTime;
            arenaHistory.Grade = arenaHistoryProto.Grade;
            arenaHistory.Rank = arenaHistoryProto.Rank;
            arenaHistory.targetData = GetArenaTargetData(arenaHistoryProto.target);
            arenaHistory.FightPower = arenaHistoryProto.SelfFightPower;
            arenaHistory.GradeChangeType = arenaHistoryProto.GradeChangeType;
            arenaHistory.MyScores = arenaHistoryProto.SelfRandScore;
            arenaHistory.TargetScores = arenaHistoryProto.TargetRandScore;
            // arenaHistory.FightScores = arenaHistoryProto.SelfFightPower;
            return arenaHistory;
        }

        public static ArenaTargetData GetArenaTargetData(ArenaTargetProto arenaTargetProto)
        {
            ArenaTargetData arenaTarget = new ArenaTargetData();
            arenaTarget.Grade = arenaTargetProto.Grade;
            arenaTarget.RankInGrade = arenaTargetProto.RankInGrade;
            arenaTarget.Type = arenaTargetProto.Type;
            arenaTarget.FightPower = arenaTargetProto.FightPower;
            if (arenaTarget.Type == FightTargetType.PLAYER)
            {
                arenaTarget.RoleInfo = RoleDataManager.GetOtherRoleInfoData(arenaTargetProto.RoleInfo);
            }
            else
            {
                ArenaRobotCfg robotCfg =
                    CommonDataManager.Tables.TblArenaRobotCfg.GetOrDefault(arenaTargetProto.RobotDressupInfo.RobotId);

                arenaTarget.RoleInfo.roleId = 0;
                arenaTarget.RoleInfo.roleName = arenaTargetProto.RobotDressupInfo.Name;
                arenaTarget.RoleInfo.roleLv = robotCfg.Level;
                arenaTarget.RoleInfo.headRes = string.IsNullOrEmpty(arenaTargetProto.RobotDressupInfo.RobotHead)
                    ? "self"
                    : arenaTargetProto.RobotDressupInfo.RobotHead;
            }

            arenaTarget.FightDatas.Clear();
            for (int i = 0; i < ArenaDataManager.Instance.ThemeList.Count; i++)
            {
                if (arenaTarget.Type == FightTargetType.PLAYER)
                {
                    FightData roleData =
                        GetFightRoleData(
                            arenaTargetProto.PlayerDressupList.Count <= i
                                ? null
                                : arenaTargetProto.PlayerDressupList[i], arenaTarget.RoleInfo, i);
                    arenaTarget.FightDatas.Add(roleData);
                }
                else if (arenaTarget.Type == FightTargetType.ROBOT)
                {
                    FightData robotData = GetFightRobotData(arenaTargetProto.RobotDressupInfo, i);
                    arenaTarget.FightDatas.Add(robotData);
                }
            }

            return arenaTarget;
        }

        private static FightData GetFightRoleData(ArenaDressupProto dressupProto, OtherRoleInfoData roleInfo, int index)
        {
            FightData fightData = new FightData();
            fightData.name = roleInfo.roleName;
            fightData.scoreType = ArenaDataManager.Instance.ThemeList[index];
            fightData.baseScore = CommonDataManager.Tables.TblRoleLevelCfg.GetOrDefault(roleInfo.roleLv).BaseScore;

            if (index == 0)
            {
                fightData.tags = new List<string> { ArenaDataManager.Instance.Tag };
            }

            fightData.type = FightTargetType.PLAYER;
            fightData.headId = roleInfo.headId;
            fightData.cardId = dressupProto == null ? 0 : dressupProto.CardId;
            fightData.itemList = dressupProto == null ? fightData.itemList : dressupProto.EquipIds; //上赛季没有穿戴数据


            return fightData;
        }

        public static FightData GetFightRobotData(ArenaRobotProto robotProto, int index)
        {
            ArenaRobotCfg robotCfg = CommonDataManager.Tables.TblArenaRobotCfg.GetOrDefault(robotProto.RobotId);

            FightData fightData = new FightData();
            fightData.name = robotProto.Name;
            fightData.scoreType = ArenaDataManager.Instance.ThemeList[index];
            fightData.baseScore = CommonDataManager.Tables.TblRoleLevelCfg.GetOrDefault(robotCfg.Level).BaseScore;

            fightData.leagueSkillScore = 0;
            fightData.cardId = robotProto.CardIdList.Count <= index ? 0 : robotProto.CardIdList[index]; //上赛季没有穿戴数据
            if (index == 0) //只有第一个主题才计算标签
            {
                fightData.tags = new List<string>() { ArenaDataManager.Instance.Tag };
                fightData.tagAddition = robotCfg.TagAddition;
            }

            fightData.itemScoreList.Clear();
            float randoms = robotProto.Randoms.Count >= index ? robotProto.Randoms[index] / 10000f : 1f;

            for (int i = 0; i < robotCfg.PartsScore.Count; i++)
            {
                float score = robotCfg.PartsScore[i] * randoms;
                fightData.itemScoreList.Add(score);
            }

            fightData.type = FightTargetType.ROBOT;
            fightData.res = string.IsNullOrEmpty(robotProto.RobotHead) ? "self" : robotProto.RobotHead;
            double cardScore = (double)robotCfg.CardScore * randoms;
            fightData.cardScore = (int)Math.Ceiling(cardScore);

            List<PassivitySkillCfg> skillCfgs =
                CommonDataManager.Tables.TblPassivitySkillCfg.DataList.Where(a => a.CardId == fightData.cardId)
                    .ToList();

            fightData.skillLvs.Clear();
            if (skillCfgs != null)
            {
                for (int i = 0; i < skillCfgs.Count; i++)
                {
                    fightData.skillLvs.Add(robotCfg.SkillLvs);
                }
            }
            
            fightData.showSuitId = robotProto.SuitList.Count <= index ? 0 : robotProto.SuitList[index]; //上赛季没有穿戴数据

            return fightData;
        }

        //获取对手战力
        public static async ETTask<bool> ReqArenaTargetPowerScore(long targetId, List<long> targetPawerList,
            int targetIndex)
        {
            var response = (S2C_GetTargetNewFightPower)await MessageHelper.SendToServer(new C2S_GetTargetNewFightPower()
                { RoleId = RoleDataManager.roleId, TargetRoleId = targetId });
            if (!(response is { Error: ErrorCode.ERR_Success })) return false;
            for (int i = 0; i < targetPawerList.Count; i++)
            {
                if (targetPawerList[i] != response.TargetFightPower[i])
                {
                    ArenaDataManager.Instance.Targets[targetIndex].FightPower = response.TargetFightPower;
                    return false;
                }
            }

            return true;
        }

        //获取段位奖励状态
        public static async ETTask<bool> ReqGetSeasonGradeRewardStatus()
        {
            var response =
                (S2C_GetSeasonGradeRewardStatus)await MessageHelper.SendToServer(new C2S_GetSeasonGradeRewardStatus()
                    { RoleId = RoleDataManager.roleId });
            if (!(response is { Error: ErrorCode.ERR_Success })) return false;
            for (int i = 0; i < response.RewardStatusKs.Count; i++)
            {
                if (ArenaDataManager.Instance.GradeRewardStateDic.ContainsKey(response.RewardStatusKs[i]))
                {
                    ArenaDataManager.Instance.GradeRewardStateDic[response.RewardStatusKs[i]] =
                        response.RewardStatusVs[i];
                }
                else
                {
                    ArenaDataManager.Instance.GradeRewardStateDic.Add(response.RewardStatusKs[i],
                        response.RewardStatusVs[i]);
                }
            }

            return true;
        }

        //获取段位奖励
        public static async ETTask<bool> ReqGetSeasonGradeReward(int grade)
        {
            var response = (S2C_GetSeasonGradeReward)await MessageHelper.SendToServer(new C2S_GetSeasonGradeReward()
                { RoleId = RoleDataManager.roleId, Grade = grade });
            if (!(response is { Error: ErrorCode.ERR_Success })) return false;
            for (int i = 0; i < response.RewardStatusKs.Count; i++)
            {
                if (ArenaDataManager.Instance.GradeRewardStateDic.ContainsKey(response.RewardStatusKs[i]))
                {
                    ArenaDataManager.Instance.GradeRewardStateDic[response.RewardStatusKs[i]] =
                        response.RewardStatusVs[i];
                }
                else
                {
                    ArenaDataManager.Instance.GradeRewardStateDic.Add(response.RewardStatusKs[i],
                        response.RewardStatusVs[i]);
                }
            }

            BonusController.TryShowBonusList(ItemUtil.CreateItemDataList(response.BonusList));
            return true;
        }
    }
}