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.UpdateNumeric(LeagueDataManager.Instance.LeagueData, 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 = LeagueSproxy.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;
                    }
                }
                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 == 2)
            {
                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;
            }
            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.Position == LeaguePosPower.Owner)
                {
                    leagueData.OwnerId = message.RoleId;
                }
                else if (message.Position == LeaguePosPower.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 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 (response.Type == 1)//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 (response.Type == 2)//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);
                    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] = 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.LeagueData.NeedAudit = response.IsNeed;
                    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);
                }
                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)
                {
                    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)
                {
                    // if (type == 1)
                    // {
                    //     LeagueDataManager.Instance.LeagueData.Name = changed;
                    // }
                    // else
                    // {
                    //     LeagueDataManager.Instance.LeagueData.Icon = changed;
                    // }
                    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.LeagueData.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;
        }


        private static LeagueData GetLeagueData(LeagueDetailInfoProto leagueDetailInfo)
        {
            LeagueData leagueData = new 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.AdEndTime = leagueDetailInfo.AdEndTime;
            leagueData.OwnerId = leagueDetailInfo.OwnerId;
            leagueData.SubOwnerId = leagueDetailInfo.SubOwnerId;

            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.UpdateNumeric(leagueData, leagueDetailInfo.NumberKeys[i], leagueDetailInfo.Values[i]);
            }
            return leagueData;
        }

        public static LeagueMemberData GetLeagueMemberData(LeagueMemberDetailInfoProto memberDetailInfoProto)
        {
            LeagueMemberData memberData = new LeagueMemberData();
            memberData.RoleInfo = 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 = GetOtherRoleInfoData(logProto.RoleInfo);
            logData.Time = logProto.Time;
            logData.OldPos = logProto.OldPos;
            logData.NewPos = logProto.NewPos;
            return logData;
        }
        public static OtherRoleInfoData GetOtherRoleInfoData(OtherRoleInfoProto otherRoleInfo)
        {
            OtherRoleInfoData otherRoleInfoData = new OtherRoleInfoData();
            otherRoleInfoData.roleId = otherRoleInfo.RoleId;
            otherRoleInfoData.headId = otherRoleInfo.HeadItemId;
            otherRoleInfoData.headBorderId = otherRoleInfo.HeadBorderItemId;
            otherRoleInfoData.roleName = otherRoleInfo.RoleName;
            otherRoleInfoData.roleLv = otherRoleInfo.RoleLvl;
            otherRoleInfoData.offlineTimeSec = otherRoleInfo.OfflineTimeSec;
            return otherRoleInfoData;
        }
    }
}