XiuXianGame/Assets/Scripts/GameUI/UI/Task/TaskInfoPanel.cs

using System.Collections.Generic;
using System.Linq;
using Core.Language;
using Excel2Json;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Bag;
using GameLogic.Player;

namespace Fort23.Mono
{
    [UIBinding(prefab = "TaskInfoPanel")]
    public partial class TaskInfoPanel : UIPanel
    {
        List<WidgetItem> widgetItems = new List<WidgetItem>();

        private int type;

        private void Init()
        {
            isAddStack = false;
        }

        protected override void AddEvent()
        {
        }

        protected override void DelEvent()
        {
        }

        public override void AddButtonEvent()
        {
            Btn_Close.onClick.AddListener(() =>
            {
                if (type == 2)
                {
                    return;
                }

                UIManager.Instance.HideUIUIPanel(this);
            });
            Btn_Bag.onClick.AddListener(() => { TipMessagePanel.OpenTipMessagePanel("事件的选择会影响获得的道具！"); });
            Btn_Ok.onClick.AddListener(() => { UIManager.Instance.HideUIUIPanel(this); });
        }

        public async void CustomInit(AccountFileInfo.EventList eventList, int type)
        {
            if (PlayerGuideManager.Instance.GuideIsCanDo(2, 6))
            {
                PlayerGuideManager.Instance.NextGuide();
            }

            this.type = type;
            Btn_Ok.gameObject.SetActive(type == 2);
            EventConfig taskConfig = ConfigComponent.Instance.Get<EventConfig>(eventList.eventID);
            Text_Name.text = LanguageManager.Instance.Text(taskConfig.EventName);
            Text_desc.text = LanguageManager.Instance.Text(taskConfig.Description);
            EventLinkConfig evenkConfig = ConfigComponent.Instance.Get<EventLinkConfig>(eventList.curStep);
            AccountFileInfo.EventLinkData eventLinkData =
                eventList.eventLinks.FirstOrDefault(el => el.eventLinkId == eventList.curStep);
            if (eventLinkData == null || eventLinkData.eventConditions == null ||
                eventLinkData.eventConditions.Count == 0)
            {
                if (evenkConfig.EventConditionMessage != 0)
                {
                    Text_Condition.text = LanguageManager.Instance.Text(evenkConfig.EventConditionMessage);
                }
                else
                {
                    Text_Condition.text ="";
                }
                
             
            }
            else
            {
                string desc = "";
                foreach (var eventConditionData in eventLinkData.eventConditions)
                {
                    desc += EventHelper.GetTaskMessage(eventConditionData) + "\n";
                }

                Text_Condition.text = desc;
            }

            Btn_Bag.gameObject.SetActive(false);
            foreach (var eventListEventLink in eventList.eventLinks)
            {
                EventLinkConfig eventLinkConfig =
                    ConfigComponent.Instance.Get<EventLinkConfig>(eventListEventLink.eventLinkId);
                if (eventLinkConfig.optionType == 3)
                {
                    Btn_Bag.gameObject.SetActive(true);
                    break;
                }
            }

            if (taskConfig.PrizeIDs != null)
            {
                List<ItemInfo> itemInfos = new List<ItemInfo>();
                for (var i = 0; i < taskConfig.PrizeIDs.Length; i++)
                {
                    DropConfig dropConfig = ConfigComponent.Instance.Get<DropConfig>(taskConfig.PrizeIDs[i]);
                    if (dropConfig.dropType == 3)
                    {
                        ItemInfo itemInfo = new ItemInfo(dropConfig.dropGroupID[0], taskConfig.PrizeNums[i]);
                        itemInfos.Add(itemInfo);
                    }
                    else
                    {
                        List<ItemInfo> items = DropManager.Instance.DropItem(taskConfig.PrizeNums[i]);
                        if (items != null)
                            itemInfos.AddRange(items);
                    }
                }

                foreach (var itemInfo in itemInfos)
                {
                    WidgetItem widgetItem = await UIManager.Instance.CreateGComponent<WidgetItem>(null, root: ItemRoot);
                    widgetItem.InitWidget(itemInfo);
                    widgetItems.Add(widgetItem);
                }

                foreach (var eventListItemInfo in eventList.itemInfos)
                {
                    WidgetItem widgetItem = await UIManager.Instance.CreateGComponent<WidgetItem>(null, ItemRoot);
                    widgetItem.InitWidget(new ItemInfo(eventListItemInfo));
                    widgetItems.Add(widgetItem);
                }
            }
        }

        public async static CTask<TaskInfoPanel> OpenPanel(AccountFileInfo.EventList eventList, int type)
        {
            TaskInfoPanel taskInfoPanel =
                await UIManager.Instance.LoadAndOpenPanel<TaskInfoPanel>(null, UILayer.Top, isShowBG: true);
            taskInfoPanel.CustomInit(eventList, type);
            return taskInfoPanel;
        }

        public async override CTask Close()
        {
            if (PlayerGuideManager.Instance.GuideIsCanDo(2, 7))
            {
                PlayerGuideManager.Instance.NextGuide();
            }

            foreach (var widgetItem in widgetItems)
            {
                UIManager.Instance.DormancyGComponent(widgetItem);
            }

            widgetItems.Clear();

            await base.Close();
        }
    }
}