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

using System;
using System.Collections.Generic;
using ET;
using GFGGame;
using Hutool;


namespace GFGGame
{
    public class NoticeTimeLimitLuckyBoxDropOutCount : AMHandler<S2C_NoticeTimeLimitLuckyBoxDropOutCount>
    {
        protected override async ETTask Run(Session session, S2C_NoticeTimeLimitLuckyBoxDropOutCount message)
        {
            var activityOpenCfg = CommonDataManager.Tables.TblActivityOpenCfg.GetOrDefault(message.ActivityId);

            if (activityOpenCfg.Type == ConstLimitTimeActivityType.ActLimitLuckyBox)
            {
                ActivityDataManager.Instance.allPlayTimes = message.AllPlayTimes;
                ActivityDataManager.Instance.lastDrawCount = message.Count;
            }
            else if (activityOpenCfg.Type == ConstLimitTimeActivityType.ActLimitTsy)
            {
                ActivityDataManager.Instance.allTsyPlayTimes = message.AllPlayTimes;
                ActivityDataManager.Instance.lastTsyDrawCount = message.Count;
            }
            else if (activityOpenCfg.Type == ConstLimitTimeActivityType.ActLimitStlyc)
            {
                ActivityDataManager.Instance.allLimitStlycTimes = message.AllPlayTimes;
                ActivityDataManager.Instance.lastStlycDrawCount = message.Count;
            }

            EventAgent.DispatchEvent(ConstMessage.ACTIVITY_LUCKY_BOX);
            await ETTask.CompletedTask;
        }
    }

    /**********************************************************七日登录*************************************************/
    public static class ActivitySProxy
    {
        public static async ETTask<bool> ReqSevenDayLoginInfos()
        {
            M2C_GetDailySignInBonusInfoList response = null;
            response =
                (M2C_GetDailySignInBonusInfoList)await MessageHelper.SendToServer(
                    new C2M_GetDailySignInBonusInfoList());
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ActivityDataManager.Instance.sevenDayLoginLoginIdList = response.KsBonusId;
                    ActivityDataManager.Instance.sevenDayLoginBonusStatusList = response.VsBonusStatus;
                    return true;
                }
            }

            return false;
        }

        public static async ETTask<bool> ReqSevenDayLoginRewards(int id)
        {
            M2C_GetDailySinInBonus response = null;
            response = (M2C_GetDailySinInBonus)await MessageHelper.SendToServer(new C2M_GetDailySinInBonus()
                { BonusId = id });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ActivityDataManager.Instance.sevenDayLoginBonusStatusList[response.BonusId - 1] =
                        response.BonusStatus;
                    var rewards = CommonDataManager.Tables.TblDailyLoginCfg.GetOrDefault(response.BonusId).Rewards;

                    BonusController.TryShowBonusList(rewards.ToGfgGameItemParam());

                    EventAgent.DispatchEvent(ConstMessage.RED_CHANGE);
                    return true;
                }
            }

            return false;
        }
        /*************************************************************首冲奖励*****************************************************/

        //领取首冲奖励
        public static async ETTask<bool> ReqFirstChargeBonusRewards()
        {
            S2C_GetFirstRechargeBonus response = null;
            response = (S2C_GetFirstRechargeBonus)await MessageHelper.SendToServer(new C2S_GetFirstRechargeBonus() { });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    BonusController.TryShowBonusList(CommonDataManager.Tables.TblGlobalCfg.FirstChargeBonus
                        .ToGfgGameItemParam());

                    return true;
                }
            }

            return false;
        }
        /*************************************************************限时抽奖活动*****************************************************/

        //请求限时抽奖活动信息
        public static async ETTask<bool> ReqGetTimeLimitLuckyBoxInfo(int activityId)
        {
            S2C_GetTimeLimitLuckyBoxInfo response = null;
            response = (S2C_GetTimeLimitLuckyBoxInfo)await MessageHelper.SendToServer(new C2S_GetTimeLimitLuckyBoxInfo()
                { ActivityId = activityId });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    var activityCfg = CommonDataManager.Tables.TblActivityOpenCfg.GetOrDefault(response.ActivityId);

                    if (activityCfg.Type == ConstLimitTimeActivityType.ActLimitLuckyBox)
                    {
                        if (ActivityDataManager.Instance.actLuckyBoxId != response.ActivityId)
                        {
                            ActivityDataManager.Instance.luckyBoxActBonusState.Clear();
                        }

                        ActivityDataManager.Instance.actLuckyBoxId = response.ActivityId;
                        ActivityDataManager.Instance.allPlayTimes = response.AllPlayTimes;
                        ActivityDataManager.Instance.lastDrawCount = response.Count;
                        for (int i = 0; i < response.KsBonusState.Count; i++)
                        {
                            ActivityDataManager.Instance.luckyBoxActBonusState[response.KsBonusState[i]] =
                                response.VsBonusState[i];
                        }
                    }
                    else if (activityCfg.Type == ConstLimitTimeActivityType.ActLimitTsy)
                    {
                        if (ActivityDataManager.Instance.actLimitTsyId != response.ActivityId)
                        {
                            ActivityDataManager.Instance.luckyActTsyBonusState.Clear();
                        }

                        ActivityDataManager.Instance.actLimitTsyId = response.ActivityId;
                        ActivityDataManager.Instance.allTsyPlayTimes = response.AllPlayTimes;
                        ActivityDataManager.Instance.lastTsyDrawCount = response.Count;
                        for (int i = 0; i < response.KsBonusState.Count; i++)
                        {
                            ActivityDataManager.Instance.luckyActTsyBonusState[response.KsBonusState[i]] =
                                response.VsBonusState[i];
                        }
                    }
                    else if (activityCfg.Type == ConstLimitTimeActivityType.ActLimitStlyc)
                    {
                        if (ActivityDataManager.Instance.actLimitStlycId != response.ActivityId)
                        {
                            ActivityDataManager.Instance.limitStlycActBonusState.Clear();
                        }

                        ActivityDataManager.Instance.actLimitStlycId = response.ActivityId;
                        ActivityDataManager.Instance.allLimitStlycTimes = response.AllPlayTimes;
                        ActivityDataManager.Instance.lastStlycDrawCount = response.Count;
                        for (int i = 0; i < response.KsBonusState.Count; i++)
                        {
                            ActivityDataManager.Instance.limitStlycActBonusState[response.KsBonusState[i]] =
                                response.VsBonusState[i];
                        }
                    }

                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// 领取抽奖奖励
        /// </summary>
        /// <param name="activityId"></param>
        /// <param name="bonusKey">奖励key，这里对应抽奖次数</param>
        /// <returns></returns>
        public static async ETTask<bool> ReqGetTimeLimitLuckyBoxBonus(int activityId, int bonusKey)
        {
            S2C_GetTimeLimitLuckyBoxBonus response = null;
            response = (S2C_GetTimeLimitLuckyBoxBonus)await MessageHelper.SendToServer(
                new C2S_GetTimeLimitLuckyBoxBonus() { ActivityId = activityId, BonusKey = bonusKey });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    var activityCfg = CommonDataManager.Tables.TblActivityOpenCfg.GetOrDefault(response.ActivityId);

                    if (activityCfg.Type == ConstLimitTimeActivityType.ActLimitLuckyBox)
                    {
                        if (ActivityDataManager.Instance.actLuckyBoxId != response.ActivityId)
                        {
                            return false;
                        }

                        ActivityDataManager.Instance.luckyBoxActBonusState[response.BonusKey] = response.BonusStatus;
                    }
                    else if (activityCfg.Type == ConstLimitTimeActivityType.ActLimitTsy)
                    {
                        if (ActivityDataManager.Instance.actLimitTsyId != response.ActivityId)
                        {
                            return false;
                        }

                        ActivityDataManager.Instance.luckyActTsyBonusState[response.BonusKey] = response.BonusStatus;
                    }
                    else if (activityCfg.Type == ConstLimitTimeActivityType.ActLimitStlyc)
                    {
                        if (ActivityDataManager.Instance.actLimitStlycId != response.ActivityId)
                        {
                            return false;
                        }

                        ActivityDataManager.Instance.limitStlycActBonusState[response.BonusKey] = response.BonusStatus;
                    }

                    // int[][] bonus = ActivityLuckybonusCfgArray.Instance.GetCfgByidAndnum(response.ActivityId, response.BonusKey).bonusArr;
                    BonusController.TryShowBonusList(ItemUtil.CreateItemDataList(response.BonusList));
                    EventAgent.DispatchEvent(ConstMessage.RED_CHANGE);
                    EventAgent.DispatchEvent(ConstMessage.LUCKY_BOX_ACTIVITY_REWARD);
                    return true;
                }
            }

            return false;
        }

        /*************************************************************限时累充*****************************************************/
        // /// <summary>
        // /// 领取累充奖励
        // /// </summary>
        // /// <param name="activityId"></param>
        // /// <param name="bonusKey">奖励key，这里对应抽奖次数</param>
        // /// <returns></returns>
        // public static async ETTask<bool> ReqGetLimitChargeBonus(int activityId, int bonusKey)
        // {
        //     S2C_GetTimeLimitLuckyBoxBonus response = null;
        //     response = (S2C_GetTimeLimitLuckyBoxBonus)await MessageHelper.SendToServer(new C2S_GetTimeLimitLuckyBoxBonus() { ActivityId = activityId, BonusKey = bonusKey });
        //     if (response != null)
        //     {
        //         if (response.Error == ErrorCode.ERR_Success)
        //         {
        //             if (ActivityDataManager.Instance.actLuckyBoxId != response.ActivityId)
        //             {
        //                 return false;
        //             }
        //             ActivityDataManager.Instance.luckyBoxActBonusState[response.BonusKey] = response.BonusStatus;

        //             int[][] bonus = ActivityLuckybonusCfgArray.Instance.GetCfgByidAndnum(response.ActivityId, response.BonusKey).bonusArr;
        //             BonusController.TryShowBonusList(bonus);

        //             return true;
        //         }
        //     }
        //     return false;
        // }

        /*************************************************************活动弹窗*****************************************************/
        public static async ETTask<bool> ReqActivityTips(int type, int val)
        {
            S2C_UpLimitNumericValue response = null;
            response = (S2C_UpLimitNumericValue)await MessageHelper.SendToServer(new C2S_UpLimitNumericValue()
                { NumericType = type, NumericVal = val });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    GameGlobal.myNumericComponent.Set(response.NumericType, response.NumericVal);
                    return true;
                }
            }

            return false;
        }

        //招财进宝活动
        public static async ETTask<bool> ReqActivityZCJBInfo(int id = 5006)
        {
            int activityID = ActivityDataManager.Instance.GetCurOpenActiveByType(17);
            if (activityID != 0)
            {
                ActivityDataManager.Instance.activityZCJBId =
                    CommonDataManager.Tables.TblActivityOpenCfg.GetOrDefault(activityID).Params1[0];
            }

            S2C_GetDressRewrdStatusList response = null;
            response = (S2C_GetDressRewrdStatusList)await MessageHelper.SendToServer(new C2S_GetDressRewrdStatusList()
                { ActivityId = activityID });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ActivityDataManager.Instance.ActivityZCJBList = response.RewrdIds;
                    return true;
                }
            }

            return false;
        }

        public static async ETTask<bool> ReqActivityZCJBReward(int id, int rewardId)
        {
            S2C_GetDressRewrd response = null;
            response = (S2C_GetDressRewrd)await MessageHelper.SendToServer(new C2S_GetDressRewrd()
                { ActivityId = id, RewrdId = rewardId });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ActivityDataManager.Instance.ActivityZCJBList = response.RewrdIds;
                    BonusController.TryShowBonusList(ItemUtil.CreateItemDataList(response.BonusList));
                    return true;
                }
            }

            return false;
        }

        public static async ETTask SetOnceStatus(int k, long id, int type)
        {
            S2C_UpdateDataRecord response =
                (S2C_UpdateDataRecord)await MessageHelper.SendToServer(new C2S_UpdateDataRecord()
                    { K = k, V = id, ResetType = type });
        }

        public static async ETTask<bool> GetOnceStatus(long k)
        {
            S2C_GetDataRecord response =
                (S2C_GetDataRecord)await MessageHelper.SendToServer(new C2S_GetDataRecord() { });
            for (int i = 0; i < response.AllKs.Count; i++)
            {
                if (response.AllKs[i] == k)
                {
                    if (response.AllVs[i] == 1)
                    {
                        GameGlobal.AutoZCJBTips = false;
                        return true;
                    }
                    else
                    {
                        GameGlobal.AutoZCJBTips = true;
                        return true;
                    }
                }
            }

            GameGlobal.AutoZCJBTips = true;
            return true;
        }
        /**********************************************************新年签到*************************************************/

        public static async ETTask<bool> ReqGetActivitySignInfos()
        {
            int activityId = ActivityDataManager.Instance.GetCurOpenActiveByType(ActivityType.ShenDuChenYou);
            if (activityId < 0 || CommonDataManager.Tables.TblActivitySignCfg.GetGroup1ByActivityId(activityId).Count <=
                0)
                return false;

            S2C_GetActivitySignInfos response = null;
            response = (S2C_GetActivitySignInfos)await MessageHelper.SendToServer(new C2S_GetActivitySignInfos()
                { ActivityId = activityId });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ActivityDataManager.Instance.NewYearLoginInfoDic.Clear();

                    for (int i = 0; i < response.ksDay.Count; i++)
                    {
                        ActivityDataManager.Instance.NewYearLoginInfoDic.Add(response.ksDay[i], response.vsStatus[i]);
                    }

                    return true;
                }
            }

            return false;
        }

        public static async ETTask<bool> ReqGetAcitivitySignBonus(int activityId, int day)
        {
            S2C_ReqGetAcitivitySignBonus response = null;
            response = (S2C_ReqGetAcitivitySignBonus)await MessageHelper.SendToServer(new C2S_ReqGetAcitivitySignBonus()
                { ActivityId = activityId, Day = day });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ActivityDataManager.Instance.NewYearLoginInfoDic[response.Day] = ConstBonusStatus.GOT;
                    var rewards = CommonDataManager.Tables.TblActivitySignCfg.Get(activityId, response.Day)
                        .Bonus;
                    BonusController.TryShowBonusList(rewards.ToGfgGameItemParam());
                    EventAgent.DispatchEvent(ConstMessage.RED_CHANGE);
                    return true;
                }
            }

            return false;
        }

        //**************************新人礼包领取
        public static async ETTask<bool> ReqGetNewPlayerBonus()
        {
            S2C_GetNewcomerRewards response = null;
            response = (S2C_GetNewcomerRewards)await MessageHelper.SendToServer(new C2S_GetNewcomerRewards() { });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ActivityDataManager.Instance.IsGetNewPlayerReward = response.Status;
                    BonusController.TryShowBonusList(ItemUtil.CreateItemDataList(response.BonusList));
                    return true;
                }
            }

            return false;
        }

        //获取新人礼包状态
        public static async ETTask<bool> ReqGetNewPlayerBonusStatus()
        {
            S2C_GetNewcomerRewardStatus response = null;
            response = (S2C_GetNewcomerRewardStatus)await MessageHelper.SendToServer(new C2S_GetNewcomerRewardStatus()
                { });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ActivityDataManager.Instance.IsGetNewPlayerReward = response.Status;
                    GameGlobal.AutoNewPlayersTips = response.OpenStatus;
                    return true;
                }
            }

            return false;
        }

        public static async ETTask SetNewPlayerOnceStatus(long id)
        {
            S2C_UpdateDataRecord response =
                (S2C_UpdateDataRecord)await MessageHelper.SendToServer(
                    new C2S_UpdateDataRecord() { K = 100001, V = id });
        }

        public static async ETTask<bool> GetNewPlayerOnceStatus()
        {
            S2C_GetDataRecord response =
                (S2C_GetDataRecord)await MessageHelper.SendToServer(new C2S_GetDataRecord() { });
            for (int i = 0; i < response.AllKs.Count; i++)
            {
                if (response.AllKs[i] == 100001)
                {
                    if (response.AllVs[i] == 0)
                    {
                        GameGlobal.NewPlayerOnceTips = false;
                        return true;
                    }
                    else
                    {
                        GameGlobal.NewPlayerOnceTips = true;
                        return true;
                    }
                }
            }

            GameGlobal.NewPlayerOnceTips = true;
            return true;
        }

        //弹窗状态设置
        public static async ETTask SetTipsStatus(long tips, long value, int type = 1)
        {
            S2C_UpdateDataRecord response =
                (S2C_UpdateDataRecord)await MessageHelper.SendToServer(new C2S_UpdateDataRecord()
                    { K = tips, V = value, ResetType = type });
        }

        public static async ETTask GetTipsStatus()
        {
            S2C_GetDataRecord response =
                (S2C_GetDataRecord)await MessageHelper.SendToServer(new C2S_GetDataRecord() { });
            for (int i = 0; i < response.AllKs.Count; i++)
            {
                if (ActivityDataManager.Instance.TipsStatusDic.ContainsKey(response.AllKs[i]))
                {
                    ActivityDataManager.Instance.TipsStatusDic[response.AllKs[i]] = response.AllVs[i];
                }
                else
                {
                    ActivityDataManager.Instance.TipsStatusDic.Add(response.AllKs[i], response.AllVs[i]);
                }
                //
            }
        }

        //获取转盘活动信息
        public static async ETTask<bool> ReqGetTurnTableInfo()
        {
            S2C_GetWishingActivityInfo response = null;
            int id = ActivityDataManager.Instance.GetCurOpenActiveByType(ActivityDataManager.Instance
                .TurnTableActivityType);
            if (id == 0)
            {
                return false;
            }

            response = (S2C_GetWishingActivityInfo)await MessageHelper.SendToServer(new C2S_GetWishingActivityInfo()
                { AcitvityId = id });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ActivityDataManager.Instance.TurnRewardStateDic.Clear();
                    ActivityDataManager.Instance.TurnTableTimes = response.SpecialTotalNum;
                    ActivityDataManager.Instance.StartDropId = response.ExtraIdDropId;
                    ActivityDataManager.Instance.TipsDropId = response.ExtraIdDropId;
                    ActivityDataManager.Instance.GiftBagIdList = response.WishingBags;
                    for (int i = 0; i < response.RewardIds.Count; i++)
                    {
                        ActivityDataManager.Instance.TurnRewardStateDic.Add(response.RewardIds[i],
                            response.RewardStatus[i]);
                    }

                    return true;
                }
            }

            return false;
        }

        public static async ETTask<bool> ReqTurnTableWish(int wishType)
        {
            S2C_WishingLuckyBox response = null;
            int id = ActivityDataManager.Instance.GetCurOpenActiveByType(ActivityDataManager.Instance
                .TurnTableActivityType);
            response = (S2C_WishingLuckyBox)await MessageHelper.SendToServer(new C2S_WishingLuckyBox()
                { AcitvityId = id, WishingType = wishType });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ActivityDataManager.Instance.TurnRewardStateDic.Clear();
                    ActivityDataManager.Instance.threeTurnResult.Clear();
                    ActivityDataManager.Instance.TurnTableTimes = response.SpecialTotalNum;
                    ActivityDataManager.Instance.TipsDropId = response.ExtraIdDropId;
                    ActivityDataManager.Instance.GiftBagIdList = response.WishingBags;
                    for (int i = 0; i < response.RewardIds.Count; i++)
                    {
                        ActivityDataManager.Instance.TurnRewardStateDic.Add(response.RewardIds[i],
                            response.RewardStatus[i]);
                    }

                    if (response.RewardList.Count == 3)
                    {
                        ActivityDataManager.Instance.threeTurnResult.Add(0, response.RewardList);
                    }
                    else if (response.RewardList.Count == 9)
                    {
                        List<ItemInfoProto> infoOneList = new List<ItemInfoProto>();
                        List<ItemInfoProto> infoTwoList = new List<ItemInfoProto>();
                        List<ItemInfoProto> infoThreeList = new List<ItemInfoProto>();
                        for (int i = 0; i < response.RewardList.Count; i++)
                        {
                            if (i < 3)
                            {
                                infoOneList.Add(response.RewardList[i]);
                            }
                            else if (i >= 3 && i < 6)
                            {
                                infoTwoList.Add(response.RewardList[i]);
                            }
                            else if (i >= 6)
                            {
                                infoThreeList.Add(response.RewardList[i]);
                            }
                        }

                        ActivityDataManager.Instance.threeTurnResult.Add(0, infoOneList);
                        ActivityDataManager.Instance.threeTurnResult.Add(1, infoTwoList);
                        ActivityDataManager.Instance.threeTurnResult.Add(2, infoThreeList);
                    }

                    ActivityDataManager.Instance.TurnRewardList = response.RewardList;
                    ActivityDataManager.Instance.TurnSpecialRewardList = response.SpecialRewardList;
                    return true;
                }
            }

            return false;
        }

        //获取领取转盘奖励
        public static async ETTask<bool> ReqGetTurnTableReward(int rewardId)
        {
            S2C_GetWishingRewards response = null;
            response = (S2C_GetWishingRewards)await MessageHelper.SendToServer(new C2S_GetWishingRewards()
                { RewardId = rewardId });
            if (response != null)
            {
                if (response.Error == ErrorCode.ERR_Success)
                {
                    ActivityDataManager.Instance.TurnRewardStateDic.Clear();
                    for (int i = 0; i < response.RewardIds.Count; i++)
                    {
                        ActivityDataManager.Instance.TurnRewardStateDic.Add(response.RewardIds[i],
                            response.RewardStatus[i]);
                    }

                    BonusController.TryShowBonusList(ItemUtil.CreateItemDataList(response.RewardList));
                    EventAgent.DispatchEvent(ConstMessage.TurnTable_DateCHANGE);
                    return true;
                }
            }

            return false;
        }
    }


    //新人活动开启状态推送
    public class NewPlayerOpenStatus : AMHandler<S2C_PushNewcomerRewardStatus>
    {
        protected override async ETTask Run(Session session, S2C_PushNewcomerRewardStatus message)
        {
            ActivityDataManager.Instance.IsGetNewPlayerReward = message.Status;
            GameGlobal.AutoNewPlayersTips = message.OpenStatus;
            await ETTask.CompletedTask;
        }
    }
}