6086 【前端】【1.5.200】春节红包雨活动

client_linchunjie

2019-01-29 bb98d8ae9ff4d799bd8e2c11ddf3335ab4e0b017

 System/OpenServerActivity/FestivalRedpackWin.cs

@@ -15,6 +15,25 @@
    public class FestivalRedpackWin : Window

    {

        [SerializeField] FestivalRedpackSystemBehaviour m_FestivalSystemBehaviour;

        [SerializeField] Transform m_ContainerAchievement;

        [SerializeField] ScrollerController m_AchievementController;

        [SerializeField] Transform m_ContainerRedEnvelope;

        [SerializeField] ScrollerController m_RedEnvelopeControl;

        [SerializeField] Transform m_ContainerNoEnvelope;

        [SerializeField] Text m_OpenTime;

        [SerializeField] Transform m_ContainerGrab;

        [SerializeField] Text m_GrabCount;

        [SerializeField] Text m_GrabJade;



        FestivalRedpackModel model { get { return ModelCenter.Instance.GetModel<FestivalRedpackModel>(); } }



        AchievementModel achieveModel

        {

            get { return ModelCenter.Instance.GetModel<AchievementModel>(); }

        }



        RedEnvelopeModel envelopeModel { get { return ModelCenter.Instance.GetModel<RedEnvelopeModel>(); } }



        #region Built-in

        protected override void BindController()

        {

@@ -22,10 +41,20 @@


        protected override void AddListeners()

        {

            m_AchievementController.OnRefreshCell += OnRefreshAchievementCell;

            m_RedEnvelopeControl.OnRefreshCell += OnRefreshRedEnvelopeCell;

        }



        protected override void OnPreOpen()

        {

            model.selectTypeRefresh += SelectTypeRefresh;

            model.redpackGrabRefresh += RedpackGrabRefresh;

            WindowCenter.Instance.windowAfterOpenEvent += WindowAfterOpenEvent;

            OperationTimeHepler.Instance.dayResetEvent += DayResetEvent;

            achieveModel.achievementCompletedEvent += FestivalAchievementRefresh;

            achieveModel.achievementProgressUpdateEvent += FestivalAchievementRefresh;

            model.taskRedpackRefresh += TaskRedpackRefresh;

            Display();

        }



        protected override void OnAfterOpen()

@@ -34,6 +63,14 @@


        protected override void OnPreClose()

        {

            model.selectTypeRefresh -= SelectTypeRefresh;

            model.redpackGrabRefresh -= RedpackGrabRefresh;

            WindowCenter.Instance.windowAfterOpenEvent -= WindowAfterOpenEvent;

            OperationTimeHepler.Instance.dayResetEvent -= DayResetEvent;

            achieveModel.achievementCompletedEvent -= FestivalAchievementRefresh;

            achieveModel.achievementProgressUpdateEvent -= FestivalAchievementRefresh;

            model.taskRedpackRefresh -= TaskRedpackRefresh;

            m_FestivalSystemBehaviour.Dispose();

        }



        protected override void OnAfterClose()

@@ -41,6 +78,187 @@
        }

        #endregion



        void Display()

        {

            DisplayType();

            DisplayOpenTime();

        }



        void DisplayType()

        {

            m_FestivalSystemBehaviour.gameObject.SetActive(model.selectType == 1);

            m_ContainerAchievement.gameObject.SetActive(model.selectType == 2);

            m_ContainerRedEnvelope.gameObject.SetActive(model.selectType == 3);

            m_ContainerGrab.gameObject.SetActive(model.selectType != 2);

            switch (model.selectType)

            {

                case 1:

                    m_FestivalSystemBehaviour.Display();

                    break;

                case 2:

                    m_FestivalSystemBehaviour.Dispose();

                    DisplayAchievements();

                    break;

                case 3:

                    m_FestivalSystemBehaviour.Dispose();

                    DisplayRedpacks();

                    break;

            }

        }



        void DisplayAchievements()

        {

            m_AchievementController.Refresh();

            model.displayAchievements.Clear();

            List<FestivalRedpackAchievement> list;

            if (model.TryGetAchievements(model.festivalDay + 1, out list))

            {

                model.displayAchievements.AddRange(list);

                model.displayAchievements.Sort(model.AchievementSort);

            }

            for (int i = 0; i < model.displayAchievements.Count; i++)

            {

                m_AchievementController.AddCell(ScrollerDataType.Header, i);

            }

            m_AchievementController.Restart();

        }



        void DisplayRedpacks()

        {

            m_RedEnvelopeControl.Refresh();

            model.taskDisplayRedpacks.Clear();

            List<int> list;

            if (envelopeModel.TryGetEnvelopes(FestivalRedpackModel.FESTIVALTASKREDPACKTYPE, out list))

            {

                model.taskDisplayRedpacks.AddRange(list);

            }

            model.taskDisplayRedpacks.Sort(model.CompareEnvelope);

            var _line = Mathf.CeilToInt((float)model.taskDisplayRedpacks.Count / 5);

            for (int i = 0; i < _line; i++)

            {

                m_RedEnvelopeControl.AddCell(ScrollerDataType.Header, i);

            }

            m_RedEnvelopeControl.Restart();

            m_ContainerNoEnvelope.gameObject.SetActive(model.taskDisplayRedpacks.Count == 0);

        }



        void DisplayOpenTime()

        {

            OperationFestivalRedpack operation;

            if (OperationTimeHepler.Instance.TryGetOperation(Operation.FestivalRedpack, out operation))

            {

                m_OpenTime.text = StringUtility.Contact(Language.Get("ExpActivity_Text1"), operation.ToDisplayTime());

            }

        }



        void DisplayGrab()

        {

            m_GrabCount.text = Mathf.Max(0, model.grabRedpackLimitTimes - model.grabRedpackTimes).ToString();

            m_GrabJade.text = model.grabTotalJade.ToString();

        }



        private void OnRefreshAchievementCell(ScrollerDataType type, CellView cell)

        {

            var achievementCell = cell as FestivalAchievementCell;

            achievementCell.Display(cell.index);

        }



        private void OnRefreshRedEnvelopeCell(ScrollerDataType type, CellView cell)

        {

            var redpackCell = cell as OSRedEnvelopeCell;

            redpackCell.Display(cell.index);

        }



        private void SelectTypeRefresh()

        {

            DisplayType();

        }



        private void RedpackGrabRefresh()

        {

            DisplayGrab();

        }



        private void WindowAfterOpenEvent(Window win)

        {

            if (win is OpenServerActivityWin)

            {

                AutoOpenRedpack();

            }

        }



        void AutoOpenRedpack()

        {

            if (model.autoOpen && model.selectType == 3)

            {

                for (int i = 0; i < model.taskDisplayRedpacks.Count; i++)

                {

                    RedEnvelopeModel.RedEnvelope envelope;

                    if (envelopeModel.TryGetEnvelope(model.taskDisplayRedpacks[i], out envelope)

                        && envelope.state == 1)

                    {

                        if (PlayerDatas.Instance.PlayerId == envelope.player

                            || model.grabRedpackLimitTimes - model.grabRedpackTimes > 0)

                        {

                            ModelCenter.Instance.GetModel<PlayerRedPacketDatas>().RedBagId = envelope.id;

                            WindowCenter.Instance.Open<RedpackOpenWin>();

                        }

                    }

                }

            }

            model.autoOpen = false;

        }



        private void DayResetEvent(int resetType)

        {

            OperationFestivalRedpack operation;

            if (OperationTimeHepler.Instance.TryGetOperation(Operation.FestivalRedpack, out operation))

            {

                if (resetType == operation.resetType)

                {

                    if (model.selectType == 2)

                    {

                        DisplayAchievements();

                    }

                }

            }

        }



        private void FestivalAchievementRefresh(int id)

        {

            if (model.selectType != 2)

            {

                return;

            }

            Achievement achievement;

            if (model.IsContainsAchievement(model.displayAchievements, id))

            {

                FestivalRedpackAchievement festivalRedpackAchievement = model.displayAchievements.Find((x) =>

                {

                    return x.Contains(id);

                });

                if (festivalRedpackAchievement != null)

                {

                    if (achieveModel.TryGetAchievement(festivalRedpackAchievement.CurrentAchieve, out achievement))

                    {

                        if (Achievement.IsReach(achievement.id, achievement.progress))

                        {

                            DisplayAchievements();

                            return;

                        }

                    }

                }

            }

            m_AchievementController.m_Scorller.RefreshActiveCellViews();

        }



        private void TaskRedpackRefresh()

        {

            if (model.selectType == 3)

            {

                DisplayRedpacks();

            }

        }

    }



}