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);
            ArenaDataManager.Instance.HistoryDatas.RemoveAt(ArenaDataManager.Instance.HistoryDatas.Count - 1);
            await ETTask.CompletedTask;
        }
    }
    public static class ArenaSproxy
    {
        //获取竞技场信息
        public static async ETTask GetArenaInfos()
        {
            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;

                    ArenaDataManager.Instance.Clear();
                    for (int i = 0; i < response.ThemeList.Count; i++)
                    {
                        FightRoleData roleData = new FightRoleData();
                        roleData.cardId = response.DressupList.Count > i ? response.DressupList[i].CardId : 0;
                        roleData.itemList = response.DressupList.Count > i ? response.DressupList[i].EquipIds : new List<int>();

                        ArenaDataManager.Instance.DressupList.Add(roleData);
                    }

                    for (int i = 0; i < response.targets.Count; i++)
                    {
                        ArenaDataManager.Instance.Targets.Add(GetArenaTargetData(response.targets[i]));
                    }
                }
            }
        }
        //刷新竞争对手
        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++)
                    {
                        ArenaDataManager.Instance.Targets.Add(GetArenaTargetData(response.targets[i]));
                    }
                    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;
                    PromptController.Instance.ShowFloatTextPrompt("保存成功");

                    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> ReqCheckArenaFight()
        {
            S2C_ArenaFight response = null;
            response = (S2C_ArenaFight)await MessageHelper.SendToServer(new C2S_ArenaFight() { });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    return true;
                }
                else
                {
                    ArenaDataManager.Instance.Targets.Clear();
                    for (int i = 0; i < response.targets.Count; i++)
                    {
                        ArenaDataManager.Instance.Targets.Add(GetArenaTargetData(response.targets[i]));
                    }
                    PromptController.Instance.ShowFloatTextPrompt("该玩家排名已经发生变化，请重新选择");
                }
            }
            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,
            });
            if (response != null)
            {
                if (response.Error != ErrorCode.ERR_Success)
                {
                    int lastGrade = ArenaDataManager.Instance.Grade;
                    int lastRank = ArenaDataManager.Instance.Rank;
                    string targetName = targetData.RoleInfo.roleName;
                    int targetHeadId = targetData.RoleInfo.headId;
                    string headRes = targetData.RoleInfo.headRes;

                    ArenaDataManager.Instance.Targets.Clear();
                    for (int i = 0; i < response.targets.Count; i++)
                    {
                        ArenaDataManager.Instance.Targets.Add(GetArenaTargetData(response.targets[i]));
                    }

                    ArenaDataManager.Instance.Grade = response.Grade;
                    ArenaDataManager.Instance.Rank = response.RankInGrade;
                    ArenaDataManager.Instance.TryUpdateHighest();
                    List<ItemData> bonusList = ItemUtil.CreateItemDataList(response.rewards);

                    if (response.Grade > ArenaDataManager.Instance.Grade)
                    {
                        BonusController.TryShowBonusList(bonusList, () =>
                        {
                            ViewManager.Show<ArenaDanUpView>(new object[] { lastGrade, ArenaDataManager.Instance.Grade, response.RewardId });
                        });
                    }
                    else if (response.RankInGrade > ArenaDataManager.Instance.Rank)
                    {
                        BonusController.TryShowBonusList(bonusList, () =>
                        {
                            ViewManager.Show<ArenaRankUpView>(new object[] { lastGrade, lastRank, targetHeadId, headRes, targetName });
                        });
                    }
                    else
                    {
                        BonusController.TryShowBonusList(bonusList);
                    }
                    EventAgent.DispatchEvent(ConstMessage.ARENA_FIGHT_RESULT);

                    return true;
                }
            }
            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]));
                    }
                    ArenaDataManager.Instance.SelfData = GetArenaTargetData(response.self);
                    return true;
                }
            }
            return false;
        }

        //获取竞技场历史记录
        public static async ETTask ReqArenaHistory(int rankType, int startIndex, int endIndex)
        {
            S2C_ArenaHistory response = null;
            response = (S2C_ArenaHistory)await MessageHelper.SendToServer(new C2S_ArenaHistory() { });
            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<FightRoleData> 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].skillLvs = response.data[i].SkillLevel;
                        list[i].itemScoreList = response.data[i].SuitScore;
                    }
                }
            }
        }

        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.GradeChangeType = arenaHistoryProto.GradeChangeType;
            arenaHistory.MyScores = arenaHistoryProto.SelfRandScore;
            arenaHistory.TargetScores = arenaHistoryProto.TargetRandScore;
            arenaHistory.FightScores = arenaHistoryProto.SelfFightPower;
            return arenaHistory;
        }

        private static ArenaTargetData GetArenaTargetData(ArenaTargetProto arenaTargetProto)
        {
            ArenaTargetData arenaTarget = new ArenaTargetData();
            arenaTarget.Grade = arenaTargetProto.Grade;
            arenaTarget.RankInGrade = arenaTargetProto.RankInGrade;
            arenaTarget.Type = arenaTargetProto.Type;
            if (arenaTarget.Type == ArenaFightTargetType.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.RoleDressupList.Clear();
            arenaTarget.RobotDressupList.Clear();

            for (int j = 0; j < ArenaDataManager.Instance.ThemeList.Count; j++)
            {
                if (arenaTarget.Type == ArenaFightTargetType.PLAYER)
                {
                    FightRoleData roleData = GetFightRoleData(arenaTargetProto.PlayerDressupList[j], arenaTarget.RoleInfo, j);
                    arenaTarget.RoleDressupList.Add(roleData);
                }
                else if (arenaTarget.Type == ArenaFightTargetType.ROBOT)
                {
                    FightRobotData robotData = GetFightRobotData(arenaTargetProto.RobotDressupInfo, j);
                    arenaTarget.RobotDressupList.Add(robotData);
                }
            }
            return arenaTarget;
        }

        private static FightRoleData GetFightRoleData(ArenaDressupProto dressupProto, OtherRoleInfoData roleInfo, int index)
        {
            FightRoleData roleData = new FightRoleData();
            roleData.name = roleInfo.roleName;
            roleData.headId = roleInfo.headId;

            roleData.baseScore = RoleLevelCfgArray.Instance.GetCfg(roleInfo.roleLv).baseScore;
            roleData.cardId = dressupProto.CardId;
            roleData.itemList = dressupProto.EquipIds;
            if (index == 0) roleData.tags = new string[1] { ArenaDataManager.Instance.Tag };

            return roleData;
        }
        private static FightRobotData GetFightRobotData(ArenaRobotProto robotProto, int index)
        {
            ArenaRobotCfg robotCfg = ArenaRobotCfgArray.Instance.GetCfg(robotProto.RobotId);
            FightRobotData robotData = new FightRobotData();
            robotData.name = robotCfg.gradeName;
            robotData.res = robotCfg.targetRes;
            robotData.itemScoreList = new List<int>(robotCfg.partsScoreArr);
            robotData.baseScore = robotCfg.baseScore;
            robotData.cardId = robotProto.CardIdList[index];
            double cardScore = (double)robotCfg.cardScore * (double)robotProto.Random / 10000 * 100;
            robotData.cardScore = (int)Math.Ceiling(cardScore);
            robotData.skillLvs.Add(robotCfg.skillLvs);
            robotData.showSuitId = robotProto.SuitList[index];
            if (index == 0)//只有第一个主题才计算标签
            {
                robotData.tags = new string[1] { ArenaDataManager.Instance.Tag };
                robotData.tagAddition = robotCfg.tagAddition;
            }
            return robotData;
        }
    }
}