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

using System;
using System.Collections.Generic;
using ET;

namespace GFGGame
{

    //通知联盟解散了
    public class NoticeDisbandLeague : AMHandler<L2C_NoticeDisbandLeague>
    {
        protected override async ETTask Run(Session session, L2C_NoticeDisbandLeague message)
        {
            if (message.LeagueId == LeagueDataManager.Instance.LeagueData.LeagueId)
            {
                if (ViewManager.isViewOpen(typeof(LeagueView).FullName))
                {
                    ViewManager.Show<MainUIView>(null, null, true);
                    PromptController.Instance.ShowFloatTextPrompt("您的雅集已解散");
                }
                LeagueDataManager.Instance.Clear();
                LeagueSproxy.ReqGetLeagueInfo().Coroutine();
            }
            await ETTask.CompletedTask;
        }
    }
    //通知联盟值变化
    public class NoticeLeagueNumeric : AMHandler<L2C_NoticeLeagueNumeric>
    {
        protected override async ETTask Run(Session session, L2C_NoticeLeagueNumeric message)
        {
            if (message.LeagueId == LeagueDataManager.Instance.LeagueData.LeagueId)
            {
                LeagueDataManager.Instance.SetNumeric(message.NumericType, message.NewValue);
                EventAgent.DispatchEvent(ConstMessage.LEAGUE_NUMBERIC_CHANGE);
            }
            await ETTask.CompletedTask;
        }
    }

    //通知有人申请加入联盟
    public class NoticeApplyLeague : AMHandler<L2C_NoticeApplyLeague>
    {
        protected override async ETTask Run(Session session, L2C_NoticeApplyLeague message)
        {
            OtherRoleInfoData otherRoleInfo = RoleDataManager.GetOtherRoleInfoData(message.RoleInfo);
            LeagueDataManager.Instance.ListApplyDatas[otherRoleInfo.roleId] = otherRoleInfo;
            await ETTask.CompletedTask;
        }
    }
    //通知有人离开了联盟
    public class NoticeLeaveLeague : AMHandler<L2C_NoticeLeaveLeague>
    {
        protected override async ETTask Run(Session session, L2C_NoticeLeaveLeague message)
        {
            LeagueData leagueData = LeagueDataManager.Instance.LeagueData;
            if (message.LeagueId == leagueData.LeagueId)
            {
                if (message.LeaveRoleId == RoleDataManager.roleId)//自己离开联盟
                {
                    LeagueDataManager.Instance.Clear();
                    LeagueSproxy.ReqGetLeagueInfo().Coroutine();
                    if (ViewManager.isViewOpen(typeof(LeagueView).FullName))
                    {
                        ViewManager.Show<MainUIView>(null, null, true);
                    }
                    PromptController.Instance.ShowFloatTextPrompt("您已离开雅集");
                }
                else
                {


                    if (leagueData.LeagueMemberDatas.ContainsKey(message.LeaveRoleId))
                    {
                        if (leagueData.LeagueMemberDatas[message.LeaveRoleId].Pos == LeaguePos.Flower)
                        {
                            leagueData.FlowerNum--;
                        }
                        leagueData.LeagueMemberDatas.Remove(message.LeaveRoleId);
                    }
                    if (message.LeaveRoleId == leagueData.OwnerId)
                    {
                        leagueData.OwnerId = 0;
                    }
                    else if (message.LeaveRoleId == leagueData.SubOwnerId)
                    {
                        leagueData.SubOwnerId = 0;
                    }
                }
                LeagueDataManager.Instance.LeagueData.Num = LeagueDataManager.Instance.LeagueData.Num - 1;
                EventAgent.DispatchEvent(ConstMessage.LEAGUE_MEMBER_CHANGE);
            }
            await ETTask.CompletedTask;
        }
    }
    //通知有人加入了联盟
    public class NoticeJoinLeague : AMHandler<L2C_NoticeJoinLeague>
    {
        protected override async ETTask Run(Session session, L2C_NoticeJoinLeague message)
        {
            if (LeagueDataManager.Instance.Type == LeagueJoinType.UnJoin)
            {
                bool result = await LeagueSproxy.ReqGetLeagueInfo();
                if (result && ViewManager.isViewOpen(typeof(LeagueJoinView).FullName))
                {
                    ViewManager.Show<LeagueView>(null, new object[] { typeof(MainUIView).FullName, null }, true);
                }
            }
            else
            {
                LeagueMemberData memberData = LeagueSproxy.GetLeagueMemberData(message.RoleInfo);
                LeagueDataManager.Instance.LeagueData.LeagueMemberDatas[memberData.RoleInfo.roleId] = memberData;
                LeagueDataManager.Instance.LeagueData.Num = LeagueDataManager.Instance.LeagueData.Num + 1;
            }
            EventAgent.DispatchEvent(ConstMessage.LEAGUE_MEMBER_CHANGE);
            await ETTask.CompletedTask;
        }
    }
    //通知职位变化
    public class NoticeLeaguePosChange : AMHandler<L2C_NoticeLeaguePosChange>
    {
        protected override async ETTask Run(Session session, L2C_NoticeLeaguePosChange message)
        {
            LeagueData leagueData = LeagueDataManager.Instance.LeagueData;

            if (message.LeagueId == leagueData.LeagueId)
            {
                if (message.RoleId == leagueData.OwnerId) leagueData.OwnerId = 0;
                if (message.RoleId == leagueData.SubOwnerId) leagueData.SubOwnerId = 0;
                if (message.Position == LeaguePos.Owner)
                {
                    leagueData.OwnerId = message.RoleId;
                }
                else if (message.Position == LeaguePos.SubOwner)
                {
                    leagueData.SubOwnerId = message.RoleId;
                }
                if (leagueData.LeagueMemberDatas.ContainsKey(message.RoleId))
                {

                    if (leagueData.LeagueMemberDatas[message.RoleId].Pos == LeaguePos.Flower)
                    {
                        leagueData.FlowerNum--;
                    }
                    else if (message.Position == LeaguePos.Flower)
                    {
                        leagueData.FlowerNum++;
                    }
                    LeagueDataManager.Instance.LeagueData.LeagueMemberDatas[message.RoleId].Pos = message.Position;
                }
                EventAgent.DispatchEvent(ConstMessage.LEAGUE_MEMBER_CHANGE);
            }
            await ETTask.CompletedTask;
        }
    }

    //通知联盟信息变化
    public class NoticeLeagueInfoChange : AMHandler<L2C_NoticeLeagueInfoChange>
    {
        protected override async ETTask Run(Session session, L2C_NoticeLeagueInfoChange message)
        {
            if (message.LeagueId == LeagueDataManager.Instance.LeagueData.LeagueId)
            {
                if (message.Type == 1)//1为名字
                {
                    LeagueDataManager.Instance.LeagueData.Name = message.Changed;
                }
                else if (message.Type == 2) //2为徽章
                {
                    LeagueDataManager.Instance.LeagueData.Icon = message.Changed;
                }
                else if (message.Type == 3)//3为公告
                {
                    LeagueDataManager.Instance.LeagueData.Notice = message.Changed;
                }

                EventAgent.DispatchEvent(ConstMessage.LEAGUE_INFO_CHANGE);
            }

            await ETTask.CompletedTask;
        }
    }
    //获取加入退出日志
    public class NoticeLeagueJoinQuitLog : AMHandler<S2C_LeagueJoinQuitLog>
    {
        protected override async ETTask Run(Session session, S2C_LeagueJoinQuitLog message)
        {
            LeagueLogData logData = LeagueSproxy.GetLeagueLogData(message.Logs);
            LeagueDataManager.Instance.ListLogDatas.Insert(0, logData);
            EventAgent.DispatchEvent(ConstMessage.LEAGUE_LOG_CHANGE);
            await ETTask.CompletedTask;
        }
    }
    //同步玩家联盟贡献统计
    public class NoticeLeagueContribution : AMHandler<S2C_LeagueContribution>
    {
        protected override async ETTask Run(Session session, S2C_LeagueContribution message)
        {
            LeagueData leagueData = LeagueDataManager.Instance.LeagueData;
            if (leagueData.LeagueMemberDatas.ContainsKey(message.RoleId))
            {
                leagueData.LeagueMemberDatas[message.RoleId].WeekContribution = message.WeekContribution;
                leagueData.LeagueMemberDatas[message.RoleId].AllContribution = message.AllContribution;
            }

            await ETTask.CompletedTask;
        }
    }


    //通知有玩家加入答题
    public class NoticeJoinAnswer : AMHandler<L2C_NoticeJoinAnswer>
    {
        protected override async ETTask Run(Session session, L2C_NoticeJoinAnswer message)
        {
            LeagueDataManager.Instance.ListAnsweringDatas[message.RoleId] = 0;
            EventAgent.DispatchEvent(ConstMessage.LEAGUE_ANSWER_MEMBER_CHANGE);
            await ETTask.CompletedTask;
        }
    }
    //通知有玩家退出答题
    public class NoticeQuitAnswer : AMHandler<L2C_NoticeQuitAnswer>
    {
        protected override async ETTask Run(Session session, L2C_NoticeQuitAnswer message)
        {
            LeagueDataManager.Instance.ListAnsweringDatas.Remove(message.RoleId);
            EventAgent.DispatchEvent(ConstMessage.LEAGUE_ANSWER_MEMBER_CHANGE);
            await ETTask.CompletedTask;
        }
    }
    //同步玩家答题数量
    public class NoticeAnswerNum : AMHandler<S2C_SyncAnswerNum>
    {
        protected override async ETTask Run(Session session, S2C_SyncAnswerNum message)
        {
            LeagueDataManager.Instance.ListAnsweringDatas[message.RoleId] = message.Num;
            LeagueDataManager.Instance.LastAnswerRoleData.RightRoleId = message.RoleId;
            List<ItemData> rewards = ItemUtil.CreateItemDataList(message.Rewards);
            if (rewards.Count > 0)
            {
                BonusController.TryShowBonusList(rewards);
            }
            EventAgent.DispatchEvent(ConstMessage.LEAGUE_ANSWER_RESULT_CHANGE);
            await ETTask.CompletedTask;
        }
    }
    //同步答题开始
    public class NoticeAnswerStart : AMHandler<S2C_SyncAnswerStart>
    {
        protected override async ETTask Run(Session session, S2C_SyncAnswerStart message)
        {
            LeagueDataManager.Instance.SetNumeric(LeagueNumericType.LeagueQuestionId, message.QuestionId);
            LeagueDataManager.Instance.SetNumeric(LeagueNumericType.LeagueQuestionStatusEndTime, message.Time);
            EventAgent.DispatchEvent(ConstMessage.LEAGUE_ANSWER_START);
            await ETTask.CompletedTask;
        }
    }
    //通知答题暂停
    public class NoticeAnswerPause : AMHandler<L2C_NoticeAnswerPause>
    {
        protected override async ETTask Run(Session session, L2C_NoticeAnswerPause message)
        {
            if (message.Type == LastQuestionResult.Ending)
            {
                LeagueDataManager.Instance.SetNumeric(LeagueNumericType.LeagueQuestionStatus, LeagueQuestionStatus.AnswerEnd);
                //弹窗
                var rewards = ItemUtil.CreateItemDataList(message.Rewards);
                if (rewards.Count > 0)
                {
                    BonusController.TryShowBonusList(rewards);
                }
            }
            else
            {
                LeagueDataManager.Instance.SetNumeric(LeagueNumericType.LeagueQuestionStatus, LeagueQuestionStatus.WaitNext);
                LeagueDataManager.Instance.SetNumeric(LeagueNumericType.LeagueQuestionStatusEndTime, message.Time);
            }
            LeagueDataManager.Instance.LastAnswerRoleData.LastQuestionResult = message.Type;
            LeagueDataManager.Instance.LastAnswerRoleData.MyAnswer = "";
            EventAgent.DispatchEvent(ConstMessage.LEAGUE_ANSWER_END, message.Type);
            await ETTask.CompletedTask;
        }
    }
    /*****************************************************************************************************************************************/

    public static class LeagueSproxy
    {
        //获取联盟信息
        public static async ETTask<bool> ReqGetLeagueInfo()
        {
            S2C_GetLeagueInfo response = null;
            response = (S2C_GetLeagueInfo)await MessageHelper.SendToServer(new C2S_GetLeagueInfo() { RoleId = RoleDataManager.roleId });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    LeagueDataManager.Instance.Type = response.Type;

                    if (LeagueDataManager.Instance.Type == LeagueJoinType.Join)//1:已经加入军团
                    {
                        LeagueDataManager.Instance.LeagueData = GetLeagueData(response.LeagueDetailInfo);
                        int myPos = LeagueDataManager.Instance.LeagueData.LeagueMemberDatas[RoleDataManager.roleId].Pos;
                        if (myPos == LeaguePos.Owner || myPos == LeaguePos.SubOwner)
                        {
                            ReqGetApplyJoinLeagueList().Coroutine();
                            ReqLeagueJoinQuitLog().Coroutine();
                        }
                    }
                    else if (LeagueDataManager.Instance.Type == LeagueJoinType.UnJoin)//2:未加入军团
                    {
                        LeagueDataManager.Instance.ListDatas.Clear();
                        for (int i = 0; i < response.list.Count; i++)
                        {
                            LeagueListData leagueListData = GetLeagueListData(response.list[i]);
                            LeagueDataManager.Instance.ListDatas[leagueListData.LeagueId] = leagueListData;
                        }
                    }


                    return true;
                }
            }
            return false;
        }
        // 搜索联盟信息,leagueName为空则刷新
        public static async ETTask<bool> ReqSearchLeagueInfo(string leagueName)
        {
            S2C_SearchLeagueInfo response = null;
            response = (S2C_SearchLeagueInfo)await MessageHelper.SendToServer(new C2S_SearchLeagueInfo() { RoleId = RoleDataManager.roleId, Name = leagueName });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    LeagueDataManager.Instance.ListDatas.Clear();
                    for (int i = 0; i < response.list.Count; i++)
                    {
                        LeagueListData leagueListData = GetLeagueListData(response.list[i]);
                        LeagueDataManager.Instance.ListDatas[leagueListData.LeagueId] = leagueListData;
                    }
                    return true;
                }
            }
            return false;
        }
        //创建联盟
        public static async ETTask<bool> ReqCreateLeague(string leagueName, string icon)
        {
            S2C_CreateLeague response = null;
            response = (S2C_CreateLeague)await MessageHelper.SendToServer(new C2S_CreateLeague() { Name = leagueName, IconName = icon });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    LeagueDataManager.Instance.LeagueData = GetLeagueData(response.LeagueDetailInfo);
                    LeagueDataManager.Instance.Type = LeagueJoinType.Join;
                    return true;
                }
            }
            return false;
        }
        //申请加入联盟
        public static async ETTask<bool> ReqJoinLeague(long leagueId)
        {
            S2C_ApplyJoinLeague response = null;
            response = (S2C_ApplyJoinLeague)await MessageHelper.SendToServer(new C2S_ApplyJoinLeague() { RoleId = RoleDataManager.roleId, LeagueId = leagueId });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    if (response.Type == 2)//加入成功
                    {
                        LeagueDataManager.Instance.LeagueData = GetLeagueData(response.LeagueDetailInfo);
                    }
                    else if (response.Type == 1)//等待审核
                    {
                        LeagueDataManager.Instance.ListDatas[leagueId].ApplyStatus = LeagueApplyStatus.Applying;
                    }
                    return true;
                }
            }
            return false;
        }
        //获取申请加入联盟列表
        public static async ETTask<bool> ReqGetApplyJoinLeagueList()
        {
            S2C_GetApplyJoinLeagueList response = null;
            response = (S2C_GetApplyJoinLeagueList)await MessageHelper.SendToServer(new C2S_GetApplyJoinLeagueList() { RoleId = RoleDataManager.roleId });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    for (int i = 0; i < response.RoleInfo.Count; i++)
                    {
                        LeagueDataManager.Instance.ListApplyDatas[response.RoleInfo[i].RoleId] = RoleDataManager.GetOtherRoleInfoData(response.RoleInfo[i]);
                    }
                    return true;
                }
            }
            return false;
        }
        //设置是否需要审批
        public static async ETTask<bool> ReqSetLeagueApply(bool isNeed)
        {
            S2C_SetLeagueApply response = null;
            response = (S2C_SetLeagueApply)await MessageHelper.SendToServer(new C2S_SetLeagueApply() { IsNeed = isNeed });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    LeagueDataManager.Instance.SetNumeric(LeagueNumericType.NeedAudit, response.IsNeed ? 1 : 0);
                    return true;
                }
            }
            return false;
        }
        //审核是否同意加入
        public static async ETTask<bool> ReqAuditJoinLeague(long targetRoleId, bool IsAgreed)
        {
            S2C_AuditJoinLeague response = null;
            response = (S2C_AuditJoinLeague)await MessageHelper.SendToServer(new C2S_AuditJoinLeague() { TargetRoleId = targetRoleId, IsAgreed = IsAgreed });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    LeagueDataManager.Instance.ListApplyDatas.Remove(targetRoleId);
                }
                else if (response.Error == ErrorCode.ERR_LeagueRoleHad)
                {
                    LeagueDataManager.Instance.ListApplyDatas.Remove(targetRoleId);
                }
                EventAgent.DispatchEvent(ConstMessage.RED_CHANGE);
                return true;
            }
            return false;
        }
        //修改职位
        public static async ETTask<bool> ReqChangeLeaguePos(long targetRoleId, int pos)
        {
            S2C_ChangeLeaguePos response = null;
            response = (S2C_ChangeLeaguePos)await MessageHelper.SendToServer(new C2S_ChangeLeaguePos() { TargetRoleId = targetRoleId, Position = pos });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    // if(targetRoleId==LeagueDataManager.in)
                    return true;
                }
            }
            return false;
        }
        //踢出联盟
        public static async ETTask<bool> ReqKickLeague(long targetRoleId)
        {
            S2C_KickLeague response = null;
            response = (S2C_KickLeague)await MessageHelper.SendToServer(new C2S_KickLeague() { TargetRoleId = targetRoleId });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    return true;
                }
            }
            return false;
        }
        //退出联盟
        public static async ETTask<bool> ReqQuitLeague()
        {
            S2C_QuitLeague response = null;
            response = (S2C_QuitLeague)await MessageHelper.SendToServer(new C2S_QuitLeague() { RoleId = RoleDataManager.roleId });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    LeagueDataManager.Instance.Clear();
                    return true;
                }
            }
            return false;
        }
        //修改联盟名字和联盟徽章
        //type: 1为名字，2为徽章
        public static async ETTask<bool> ReqChangeLeagueNameOrIcon(int type, string changed)
        {
            S2C_ChangeLeagueNameOrIcon response = null;
            response = (S2C_ChangeLeagueNameOrIcon)await MessageHelper.SendToServer(new C2S_ChangeLeagueNameOrIcon() { Type = type, Changed = changed });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    PromptController.Instance.ShowFloatTextPrompt("修改成功");
                    return true;
                }
            }
            return false;
        }
        //修改公告
        public static async ETTask<bool> ReqChangeLeagueNotice(string changed)
        {
            S2C_ChangeLeagueNotice response = null;
            response = (S2C_ChangeLeagueNotice)await MessageHelper.SendToServer(new C2S_ChangeLeagueNotice() { RoleId = RoleDataManager.roleId, Notice = changed });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    LeagueDataManager.Instance.LeagueData.Notice = changed;
                    return true;
                }
            }
            return false;
        }
        //发广告
        public static async ETTask<bool> ReqSendLeagueAD()
        {
            S2C_SendLeagueAD response = null;
            response = (S2C_SendLeagueAD)await MessageHelper.SendToServer(new C2S_SendLeagueAD() { });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    LeagueDataManager.Instance.SetNumeric(LeagueNumericType.AdEndTime, response.AdEndTime);
                    return true;
                }
            }
            return false;
        }
        //获取加入退出日志
        public static async ETTask<bool> ReqLeagueJoinQuitLog()
        {
            S2C_GetLeagueJoinQuitLog response = null;
            response = (S2C_GetLeagueJoinQuitLog)await MessageHelper.SendToServer(new C2S_GetLeagueJoinQuitLog() { RoleId = RoleDataManager.roleId });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    LeagueDataManager.Instance.ListLogDatas.Clear();
                    for (int i = 0; i < response.Logs.Count; i++)
                    {
                        LeagueLogData logData = GetLeagueLogData(response.Logs[i]);
                        LeagueDataManager.Instance.ListLogDatas.Add(logData);
                    }
                    return true;
                }
            }
            return false;
        }
        //建设联盟
        //buildingType:由LeagueBuildingType定义
        public static async ETTask<bool> ReqUpLeagueBuilding(int buildingType)
        {
            S2C_UpLeagueBuilding response = null;
            response = (S2C_UpLeagueBuilding)await MessageHelper.SendToServer(new C2S_UpLeagueBuilding() { RoleId = RoleDataManager.roleId, BuildingType = buildingType });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {

                    return true;
                }
            }
            return false;
        }
        //联盟祈福
        public static async ETTask<bool> ReqPrayLeague(int type)
        {
            S2C_PrayLeague response = null;
            response = (S2C_PrayLeague)await MessageHelper.SendToServer(new C2S_PrayLeague() { Type = type });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    PromptController.Instance.ShowFloatTextPrompt("祈福完成");
                    return true;
                }
            }
            return false;
        }
        //购买联盟福利//LeagueWelfareType
        public static async ETTask<bool> ReqBuyLeagueWelfare(int type)
        {
            S2C_BuyLeagueWelfare response = null;
            response = (S2C_BuyLeagueWelfare)await MessageHelper.SendToServer(new C2S_BuyLeagueWelfare() { Type = type });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    PromptController.Instance.ShowFloatTextPrompt("购买成功");
                    return true;
                }
            }
            return false;
        }
        //领取联盟福利//LeagueWelfareType
        public static async ETTask<bool> ReqGetLeagueWelfare(int type)
        {
            S2C_GetLeagueWelfare response = null;
            response = (S2C_GetLeagueWelfare)await MessageHelper.SendToServer(new C2S_GetLeagueWelfare() { LeagueWelfareType = type });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    List<ItemData> itemDatas = ItemUtil.CreateItemDataList(response.Bonus);
                    BonusController.TryShowBonusList(itemDatas);
                    return true;
                }
            }
            return false;
        }

        //获取答题排行
        public static async ETTask<bool> ReqGetAnswerRank(int type)
        {
            S2C_GetAnswerRank response = null;
            response = (S2C_GetAnswerRank)await MessageHelper.SendToServer(new C2S_GetAnswerRank() { RoleId = RoleDataManager.roleId, Type = type });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    if (!LeagueDataManager.Instance.ListAnswerRankDatas.ContainsKey(type))
                    {
                        LeagueDataManager.Instance.ListAnswerRankDatas[type] = new List<LeagueAnswerData>();
                    }
                    List<LeagueAnswerData> answerDatas = LeagueDataManager.Instance.ListAnswerRankDatas[type];
                    answerDatas.Clear();
                    for (int i = 0; i < response.RoleInfos.Count; i++)
                    {
                        LeagueAnswerData answerData = new LeagueAnswerData();
                        answerData.RoleId = response.RoleInfos[i].RoleId;
                        answerData.Num = response.RoleInfos[i].Num;
                        answerDatas.Add(answerData);
                    }
                    return true;
                }
            }
            return false;
        }
        //回答题目
        public static async ETTask<bool> ReqAnswerQuestion(int questionId, string answer)
        {
            S2C_AnswerQuestion response = null;
            response = (S2C_AnswerQuestion)await MessageHelper.SendToServer(new C2S_AnswerQuestion() { RoleId = RoleDataManager.roleId, QuestionId = questionId, Answer = answer });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    LeagueDataManager.Instance.LastAnswerRoleData.LastQuestionId = questionId;
                    LeagueDataManager.Instance.LastAnswerRoleData.MyAnswer = answer;
                    return true;
                }
            }
            return false;
        }
        //加入答题
        public static async ETTask<bool> ReqJoinAnswer()
        {
            S2C_JoinAnswer response = null;
            response = (S2C_JoinAnswer)await MessageHelper.SendToServer(new C2S_JoinAnswer() { RoleId = RoleDataManager.roleId });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    for (int i = 0; i < response.RoleInfos.Count; i++)
                    {
                        LeagueDataManager.Instance.ListAnsweringDatas[response.RoleInfos[i].RoleId] = response.RoleInfos[i].Num;
                    }
                    LeagueDataManager.Instance.LastAnswerRoleData.RightRoleId = response.LastRightRoleId;
                    LeagueDataManager.Instance.LastAnswerRoleData.LastQuestionId = response.QuestionId;
                    LeagueDataManager.Instance.LastAnswerRoleData.MyAnswer = response.Ans;
                    return true;
                }
            }
            return false;
        }
        //退出答题
        public static async ETTask<bool> ReqQuitAnswer()
        {
            S2C_QuitAnswer response = null;
            response = (S2C_QuitAnswer)await MessageHelper.SendToServer(new C2S_QuitAnswer() { RoleId = RoleDataManager.roleId });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    return true;
                }
            }
            return false;
        }


        //获取技能列表
        public static async ETTask<bool> ReqGetSkillList(int sKillType)
        {
            S2C_GetSkillList response = null;
            response = (S2C_GetSkillList)await MessageHelper.SendToServer(new C2S_GetSkillList() { SKillType = sKillType });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    // PromptController.Instance.ShowFloatTextPrompt("购买成功");
                    return true;
                }
            }
            return false;
        }
        //激活技能
        public static async ETTask<bool> ReqActiveSkill(int sKillType, int SkillId)
        {
            S2C_GetSkillList response = null;
            response = (S2C_GetSkillList)await MessageHelper.SendToServer(new C2S_GetSkillList() { SKillType = sKillType });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    // PromptController.Instance.ShowFloatTextPrompt("购买成功");
                    return true;
                }
            }
            return false;
        }


        //发送聊天消息
        public static async ETTask<bool> ReqSendChatMsg()
        {
            S2C_SendChatMsg response = null;
            response = (S2C_SendChatMsg)await MessageHelper.SendToServer(new C2S_SendChatMsg() { });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    // PromptController.Instance.ShowFloatTextPrompt("购买成功");
                    return true;
                }
            }
            return false;
        }

        private static LeagueData GetLeagueData(LeagueDetailInfoProto leagueDetailInfo)
        {
            LeagueData leagueData = LeagueDataManager.Instance.LeagueData == null ? new LeagueData() : LeagueDataManager.Instance.LeagueData;
            leagueData.LeagueId = leagueDetailInfo.LeagueId;
            leagueData.Name = leagueDetailInfo.Name;
            leagueData.Icon = leagueDetailInfo.Icon;
            leagueData.Notice = leagueDetailInfo.Notice;
            leagueData.Num = leagueDetailInfo.Num;
            leagueData.FlowerNum = 0;
            leagueData.OwnerId = leagueDetailInfo.OwnerId;
            leagueData.SubOwnerId = leagueDetailInfo.SubOwnerId;
            leagueData.LastWeekAnswerNO1Id = leagueDetailInfo.LastQuestionNo1RoleId;

            LeagueDataManager.Instance.SetNumeric(LeagueNumericType.AdEndTime, leagueDetailInfo.AdEndTime);

            leagueData.LeagueMemberDatas.Clear();
            for (int i = 0; i < leagueDetailInfo.LeagueMemberDetailInfo.Count; i++)
            {
                LeagueMemberData memberData = GetLeagueMemberData(leagueDetailInfo.LeagueMemberDetailInfo[i]);
                leagueData.LeagueMemberDatas[memberData.RoleInfo.roleId] = memberData;
                if (memberData.Pos == LeaguePos.Flower) leagueData.FlowerNum++;
            }
            for (int i = 0; i < leagueDetailInfo.NumberKeys.Count; i++)
            {
                LeagueDataManager.Instance.SetNumeric(leagueDetailInfo.NumberKeys[i], leagueDetailInfo.Values[i]);
            }
            return leagueData;
        }

        public static LeagueMemberData GetLeagueMemberData(LeagueMemberDetailInfoProto memberDetailInfoProto)
        {
            LeagueMemberData memberData = new LeagueMemberData();
            memberData.RoleInfo = RoleDataManager.GetOtherRoleInfoData(memberDetailInfoProto.RoleInfo);
            memberData.Pos = memberDetailInfoProto.Pos;
            memberData.WeekContribution = memberDetailInfoProto.WeekContribution;
            memberData.AllContribution = memberDetailInfoProto.AllContribution;
            memberData.JoinLeagueTime = memberDetailInfoProto.JoinLeagueTime;
            return memberData;
        }

        private static LeagueListData GetLeagueListData(LeagueListInfoProto listInfoProto)
        {
            LeagueListData listData = new LeagueListData();

            listData.LeagueId = listInfoProto.LeagueId;
            listData.Level = listInfoProto.Level;
            listData.Name = listInfoProto.Name;
            listData.Icon = listInfoProto.Icon;
            listData.Num = listInfoProto.Num;
            listData.MaxNum = listInfoProto.MaxNum;
            listData.NeedAudit = listInfoProto.NeedAudit;
            listData.IsAd = listInfoProto.IsAd;
            listData.ApplyStatus = listInfoProto.ApplyStatus;
            return listData;
        }
        public static LeagueLogData GetLeagueLogData(LeagueJoinQuitLogProto logProto)
        {
            LeagueLogData logData = new LeagueLogData();
            logData.RoleInfo = RoleDataManager.GetOtherRoleInfoData(logProto.RoleInfo);
            logData.Type = logProto.Type;
            logData.Time = logProto.Time;
            logData.OldPos = logProto.OldPos;
            logData.NewPos = logProto.NewPos;
            return logData;
        }

    }
}