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

using System;
using System.Collections.Generic;
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);
            }
            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.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();
                    for (int i = 0; i < response.ThemeList.Count; i++)
                    {
                        FightData roleData = GetFightRoleData(response.DressupList[i], roleInfo, i);

                        FightDataManager.Instance.SetItemScoreList(roleData);
                        ScoreSystemData.Instance.SetEquipScoresWithPartId(roleData);
                        ArenaDataManager.Instance.DressupList.Add(roleData);
                    }

                    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);
                        }
                    }
                }
            }
        }
        //刷新竞争对手
        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)
        {

            S2C_ChangeArenaDressup response = null;
            response = (S2C_ChangeArenaDressup)await MessageHelper.SendToServer(new C2S_ChangeArenaDressup() { Index = index, CardId = cardId, EquipIds = itemList });
            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 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("购买成功");
                }
            }
        }


        //挑战
        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.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.headRes = targetData.RoleInfo.headRes;
                    ArenaDataManager.Instance.BonusList = ItemUtil.CreateItemDataList(response.rewards);
                    ArenaDataManager.Instance.LastTargets = new List<ArenaTargetData>(ArenaDataManager.Instance.Targets);

                    //更新新数据
                    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
                {
                    //更新新数据
                    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);

                    return false;
                }

            }
            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 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)
                {
                    for (int i = 0; i < response.data.Count; i++)
                    {
                        list[i].cardScore = response.data[i].CardScore;
                        list[i].itemScoreList = response.data[i].SuitScore;
                        List<PassivitySkillCfg> skillCfgs = PassivitySkillCfgArray.Instance.GetCfgsBycardId(response.data[i].CardId);

                        if (response.data[i].SkillId.Count == skillCfgs.Count)
                        {
                            for (int j = 0; j < skillCfgs.Count; j++)
                            {
                                int index = response.data[i].SkillId.IndexOf(skillCfgs[j].skillId);
                                list[i].skillLvs.Add(response.data[i].SkillLevel[index]);
                            }
                        }
                        FightDataManager.Instance.SetItemScoreList(list[i]);
                        ScoreSystemData.Instance.SetEquipScoresWithPartId(list[i]);
                    }
                }
            }
        }

        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.FightScores = 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.FightScores = arenaTargetProto.FightPower;
            if (arenaTarget.Type == FightTargetType.PLAYER)
            {
                arenaTarget.RoleInfo.roleId = arenaTargetProto.RoleInfo.RoleId;
                arenaTarget.RoleInfo.roleName = arenaTargetProto.RoleInfo.RoleName;
                arenaTarget.RoleInfo.roleLv = arenaTargetProto.RoleInfo.RoleLvl;
                arenaTarget.RoleInfo.headId = arenaTargetProto.RoleInfo.HeadItemId;
            }
            else
            {
                ArenaRobotCfg robotCfg = ArenaRobotCfgArray.Instance.GetCfg(arenaTargetProto.RobotDressupInfo.RobotId);
                arenaTarget.RoleInfo.roleId = 0;
                arenaTarget.RoleInfo.roleName = robotCfg.gradeName;
                arenaTarget.RoleInfo.roleLv = robotCfg.level;
                arenaTarget.RoleInfo.headRes = robotCfg.targetRes;
            }

            arenaTarget.FightDatas.Clear();
            for (int j = 0; j < ArenaDataManager.Instance.ThemeList.Count; j++)
            {
                if (arenaTarget.Type == FightTargetType.PLAYER)
                {
                    FightData roleData = GetFightRoleData(arenaTargetProto.PlayerDressupList[j], arenaTarget.RoleInfo, j);
                    arenaTarget.FightDatas.Add(roleData);
                }
                else if (arenaTarget.Type == FightTargetType.ROBOT)
                {
                    FightData robotData = GetFightRobotData(arenaTargetProto.RobotDressupInfo, j);
                    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 = RoleLevelCfgArray.Instance.GetCfg(roleInfo.roleLv).baseScore;
            fightData.cardId = dressupProto.CardId;
            if (index == 0) fightData.tags = new string[1] { ArenaDataManager.Instance.Tag };

            fightData.type = FightTargetType.PLAYER;
            fightData.headId = roleInfo.headId;
            fightData.itemList = dressupProto.EquipIds;


            return fightData;
        }
        public static FightData GetFightRobotData(ArenaRobotProto robotProto, int index)
        {
            ArenaRobotCfg robotCfg = ArenaRobotCfgArray.Instance.GetCfg(robotProto.RobotId);
            FightData fightData = new FightData();
            fightData.name = robotCfg.gradeName;
            fightData.scoreType = ArenaDataManager.Instance.ThemeList[index];
            fightData.baseScore = RoleLevelCfgArray.Instance.GetCfg(robotCfg.level).baseScore;
            fightData.cardId = robotProto.CardIdList[index];
            if (index == 0)//只有第一个主题才计算标签
            {
                fightData.tags = new string[1] { ArenaDataManager.Instance.Tag };
                fightData.tagAddition = robotCfg.tagAddition;
            }
            fightData.itemScoreList = new List<int>(robotCfg.partsScoreArr);

            fightData.type = FightTargetType.ROBOT;
            fightData.res = robotCfg.targetRes;
            double cardScore = (double)robotCfg.cardScore * (double)robotProto.Random / 10000;
            fightData.cardScore = (int)Math.Ceiling(cardScore);
            fightData.skillLvs.Add(robotCfg.skillLvs);
            fightData.showSuitId = robotProto.SuitList[index];

            return fightData;
        }
    }
}