XiuXianGame/Assets/Scripts/GameUI/EventManager/EventSystemManager.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Common.Utility.CombatEvent;
using Core.Language;
using Excel2Json;
using Fort23.Core;
using Fort23.Mono;
using Fort23.UTool;
using GameLogic.Bag;
using GameLogic.Combat;
using GameLogic.Combat.CombatTool;
using UnityEngine;
using Utility;
using EventConfig = Excel2Json.EventConfig;
using Random = UnityEngine.Random;

public class EventSystemManager : Singleton<EventSystemManager>
{
    List<EventConfig> eventConfigs = new List<EventConfig>();


    public AccountFileInfo.EventList CurrentEventList;

    public bool isTriggerEvent;

    List<DivineSenseConfig> divineSenseConfigs = new List<DivineSenseConfig>();

    List<int> qualitys = new List<int>() { 1, 2, 3, 4, 5, 6 };

    public bool isOpenUi;

    Action onCompleteCallback;

    public Map<int, List<EventConfig>> eventConfigsMap = new Map<int, List<EventConfig>>();

    // public Map<int, AccountFileInfo.EventConditionData> EventConditionDataMap = new Map<int, AccountFileInfo.EventConditionData>();

    public void CustomInit()
    {
        eventConfigs = ConfigComponent.Instance.GetAll<EventConfig>().ToList();
        divineSenseConfigs = ConfigComponent.Instance.GetAll<DivineSenseConfig>().ToList();

        foreach (var eventConfig in eventConfigs)
        {
            if (eventConfig.XiantuID != 0)
            {
                if (eventConfigsMap.ContainsKey(eventConfig.XiantuID))
                {
                    eventConfigsMap[eventConfig.XiantuID].Add(eventConfig);
                }
                else
                {
                    eventConfigsMap.Add(eventConfig.XiantuID, new List<EventConfig>() { eventConfig });
                }
            }
        }

        // foreach (var playerDataEventConditionData in AccountFileInfo.Instance.playerData.eventConditionDatas)
        // {
        //     EventConditionDataMap.Add(playerDataEventConditionData.guid, playerDataEventConditionData);
        // }

        StaticUpdater.Instance.AddRenderUpdateCallBack(Update);
        EventManager.Instance.AddEventListener(CustomEventType.DetectRandomEvent, RenfenceRandomEvent);
        EventManager.Instance.AddEventListener(CustomEventType.AddItem, ItemUpdate);
        EventManager.Instance.AddEventListener(CustomEventType.JingJieUpgrade, JingJieUpgrade);
        EventManager.Instance.AddEventListener(CustomEventType.CancelEvent, Cancel);
    }

    private void Cancel(IEventData e)
    {
        CancelEvent();
    }

    private void JingJieUpgrade(IEventData e)
    {
        CeekEventCompletes(3, null);
    }

    private void ItemUpdate(IEventData e)
    {
        ItemUpdateData data = e as ItemUpdateData;
        CeekEventCompletes(1, new[] { data.ItemInfo.itemID });
        CeekEventCompletes(6, new[] { data.ItemInfo.itemID, data.Count });
    }

    private void RenfenceRandomEvent(IEventData e)
    {
        DetectRandomEvents();
    }

    private float timer = 0;

    private void Update()
    {
        timer += Time.deltaTime;
        if (timer > 1)
        {
            timer = 0;
            HeroPowerUpConfig heroPowerUpConfig = PlayerManager.Instance.myHero.powerUpConfig;
            if (AccountFileInfo.Instance.playerData.divineSensePoint < heroPowerUpConfig.ShenshiMax)
            {
                AccountFileInfo.Instance.playerData.divineSensePoint += 3;
                EventManager.Instance.Dispatch(CustomEventType.DivineSensePointChange, null);
                AccountFileInfo.Instance.SavePlayerData();
            }
        }
    }

    public List<AccountFileInfo.EventList> UseDivinesense()
    {
        //使用神识先移除完成的事件
        List<AccountFileInfo.EventList> removeEvents = new List<AccountFileInfo.EventList>();
        foreach (var eventList in AccountFileInfo.Instance.playerData.eventList)
        {
            if (eventList.isCompleted)
            {
                removeEvents.Add(eventList);
            }
        }

        foreach (var removeEvent in removeEvents)
        {
            AccountFileInfo.Instance.playerData.completeEvents.Add(removeEvent);
            AccountFileInfo.Instance.playerData.eventList.Remove(removeEvent);
        }

        AccountFileInfo.Instance.SavePlayerData();


        HeroPowerUpConfig heroPowerUpConfig = PlayerManager.Instance.myHero.powerUpConfig;
        int count = AccountFileInfo.Instance.playerData.divineSensePoint / PlayerManager.Instance.gameConstantConfig.DetectEventCount;
        if (count <= 0)
        {
            //神识值不够
            return null;
        }

        int maxCount = heroPowerUpConfig.ShenshiMax / PlayerManager.Instance.gameConstantConfig.DetectEventCount;
        count = count + GetShenShiCount() > maxCount ? maxCount - GetShenShiCount() : count;


        EventManager.Instance.Dispatch(CustomEventType.DivineSensePointChange, null);
        // 神识升级逻辑
        UpDivinesense();

        var eventConfigs = DetectEvents(count);
        if (eventConfigs == null || eventConfigs.Count == 0)
            return default;

        CeekEventCompletes(8, new[] { 1 });

        //扣除神识值 增加神识经验
        int xiaoHao = eventConfigs.Count * PlayerManager.Instance.gameConstantConfig.DetectEventCount;
        AccountFileInfo.Instance.playerData.divineSenseexp += xiaoHao;
        AccountFileInfo.Instance.playerData.divineSensePoint -= xiaoHao;


        AccountFileInfo.Instance.playerData.eventList.AddRange(eventConfigs);
        UpdateZuizhongEventData();
        AccountFileInfo.Instance.SavePlayerData();
        return eventConfigs;
    }

    public void UpdateZuizhongEventData()
    {
        if (AccountFileInfo.Instance.playerData.CurrentZuiZhongEventList == null || AccountFileInfo.Instance.playerData.CurrentZuiZhongEventList.guid == 0)
        {
            var mainEventData = GetMainEventDta();
            if (mainEventData != null)
            {
                AccountFileInfo.Instance.playerData.CurrentZuiZhongEventList = mainEventData;
            }
            else if (AccountFileInfo.Instance.playerData.eventList.Count > 0)
            {
                AccountFileInfo.Instance.playerData.CurrentZuiZhongEventList = AccountFileInfo.Instance.playerData.eventList[0];
            }
        }
    }

    private void UpDivinesense()
    {
        for (var i = AccountFileInfo.Instance.playerData.divineSenseLevel - 1; i < divineSenseConfigs.Count; i++)
        {
            if (AccountFileInfo.Instance.playerData.divineSenseexp >= divineSenseConfigs[i].exp)
            {
                AccountFileInfo.Instance.playerData.divineSenseexp -= divineSenseConfigs[i].exp;
                AccountFileInfo.Instance.playerData.divineSenseLevel = divineSenseConfigs[i].ID;
            }
        }

        AccountFileInfo.Instance.SavePlayerData();
    }


    public int GetShenShiCount()
    {
        int count = 0;
        foreach (var eventList in AccountFileInfo.Instance.playerData.eventList)
        {
            EventConfig eventConfig = ConfigComponent.Instance.Get<EventConfig>(eventList.eventID);
            if (eventConfig.EventTriggerType != 5)
            {
                count++;
            }
        }

        return count;
    }


    public bool BagIsEvent(int eventID)
    {
        foreach (var eventList in AccountFileInfo.Instance.playerData.eventList)
        {
            if (eventList.eventID == eventID)
            {
                return true;
            }
        }

        return false;
    }

    public int GetBagEventCount(int eventID)
    {
        int count = 0;
        foreach (var eventList in AccountFileInfo.Instance.playerData.eventList)
        {
            if (eventList.eventID == eventID)
            {
                count++;
            }
        }

        return count;
    }

    // public bool IsRefenceEvent(int eventID)
    // {
    //     EventConfig eventConfig = ConfigComponent.Instance.Get<EventConfig>(eventID);
    // }


    public bool IsEventTrigger(int eventID)
    {
        foreach (var eventList in AccountFileInfo.Instance.playerData.completeEvents)
        {
            if (eventList.eventID == eventID)
            {
                return true;
            }
        }

        return false;
    }

    private List<AccountFileInfo.EventList> DetectEvents(int eventCount)
    {
        PlacesConfig bigMap = ConfigComponent.Instance.Get<PlacesConfig>(PlayerManager.Instance.CurrentPlaces.id);
        DivineSenseConfig divineSenseConfig = ConfigComponent.Instance.Get<DivineSenseConfig>(AccountFileInfo.Instance.playerData.divineSenseLevel);


        LogTool.Log($"使用神识，神识等级:{AccountFileInfo.Instance.playerData.divineSenseLevel}");


        List<AccountFileInfo.EventList> eventLists = new List<AccountFileInfo.EventList>();

        //找出可以刷新的支线任务
        if (bigMap.ZhixianActivatedPercentage != null)
        {
            List<EventConfig> zhiXianEvents = new List<EventConfig>();
            for (var i = 0; i < bigMap.ZhixianActivatedPercentage.Length; i++)
            {
                if (PlayerManager.Instance.PlacesBl >= bigMap.ZhixianActivatedPercentage[i])
                {
                    if (!BagIsEvent(bigMap.ZhixianID[i]) && !IsEventTrigger(bigMap.ZhixianID[i]) && CanTriggerEvent(bigMap.ZhixianID[i]))
                    {
                        zhiXianEvents.Add(ConfigComponent.Instance.Get<EventConfig>(bigMap.ZhixianID[i]));
                    }
                }
            }

            foreach (var c in zhiXianEvents)
            {
                AccountFileInfo.EventList eventList = AddEvent(c.ID);
                if (eventList != null)
                {
                    eventLists.Add(eventList);
                    eventCount--;

                    if (eventCount == 0)
                    {
                        return eventLists;
                    }
                }
            }
        }


        for (int i = 0; i < eventCount; i++)
        {
            int randomValue3 = Random.Range(0, 101);

            //先刷事件关联的事件
            if (randomValue3 <= PlayerManager.Instance.gameConstantConfig.RefreshRelevanceEventProbability)
            {
                bool isRefence = false;
                foreach (var eventList in AccountFileInfo.Instance.playerData.eventList)
                {
                    foreach (var eventListEventLink in eventList.eventLinks)
                    {
                        foreach (var eventConditionData in eventListEventLink.eventConditions)
                        {
                            if (IsEvenkLinkComplete(eventConditionData))
                                continue;
                            EventConditionConfig eventConditionConfig = ConfigComponent.Instance.Get<EventConditionConfig>(eventConditionData.eventCondition);
                            for (var i1 = 0; i1 < eventConditionConfig.RelatedEvents?.Length; i1++)
                            {
                                EventConfig eventConfig1 = ConfigComponent.Instance.Get<EventConfig>(eventConditionConfig.RelatedEvents[i1]);
                                int count = 0;
                                foreach (var list in eventLists)
                                {
                                    if (list.eventID == eventConfig1.ID)
                                    {
                                        count++;
                                    }
                                }

                                if (GetBagEventCount(eventConfig1.ID) + count >= eventConfig1.RefreshCount)
                                {
                                    continue;
                                }

                                int randomValue4 = Random.Range(0, 101);
                                if (randomValue4 <= eventConfig1.RefreshProbability)
                                {
                                    var eventList1 = AddEvent(eventConfig1.ID);
                                    if (eventList1 != null)
                                    {
                                        eventLists.Add(AddEvent(eventConfig1.ID));
                                        isRefence = true;
                                    }
                                    else
                                    {
                                        LogTool.Error("管理事件没有刷新出来 id:" + eventConfig1.ID);
                                    }

                                    break;
                                }
                            }
                        }
                    }
                }

                if (isRefence)
                    continue;
            }


            //先掉落出品质
            int quality = UtilTools.GetRandomByWeight(qualitys, divineSenseConfig.QualityBonusChance);


            // // 获取通用事件
            // List<EventConfig> globalEvents = eventConfigs.Where(e => e.EventTriggerType == 1 && CanTriggerEvent(e.ID) && e.EventQuality == quality && !BagIsEvent(e.ID) && eventLists.FirstOrDefault(el => el.eventID == e.ID) == null).ToList();
            //
            //
            // //场景特定事件
            // List<EventConfig> candidateEvents = eventConfigs.Where(e => bigMap.SpecialTaskID.Contains(e.ID) && CanTriggerEvent(e.ID) && e.EventQuality == quality && !BagIsEvent(e.ID) && eventLists.FirstOrDefault(el => el.eventID == e.ID) == null).ToList();

            // 获取通用事件
            List<EventConfig> globalEvents = eventConfigs.Where(e => e.EventTriggerType == 1 && e.EventQuality == quality && eventLists.FirstOrDefault(el => el.eventID == e.ID) == null && CanTriggerEvent(e.ID)).ToList();


            //场景特定事件
            List<EventConfig> candidateEvents = eventConfigs.Where(e => bigMap.SpecialTaskID.Contains(e.ID) && e.EventQuality == quality && eventLists.FirstOrDefault(el => el.eventID == e.ID) == null && CanTriggerEvent(e.ID)).ToList();

            if (candidateEvents.Count == 0 && globalEvents.Count == 0)
            {
                continue;
            }


            int randomValue1 = Random.Range(0, 101);
            // 达到怪率刷新场景特定事件
            //不然刷新通用事件（每个地图都可以刷的）
            if (randomValue1 >= bigMap.DivineSenseGeneralProbability && candidateEvents.Count > 0)
            {
                int randomValue2 = Random.Range(0, candidateEvents.Count);

                var eventList = AddEvent(candidateEvents[randomValue2].ID);
                if (eventList != null)
                {
                    eventLists.Add(eventList);
                }
                else
                {
                    LogTool.Error("场景没有刷新出来 id:" + candidateEvents[randomValue2].ID);
                }
            }
            else if (globalEvents.Count > 0)
            {
                int randomValue2 = Random.Range(0, globalEvents.Count);
                var eventList = AddEvent(globalEvents[randomValue2].ID);

                if (eventList != null)
                {
                    eventLists.Add(eventList);
                }
                else
                {
                    LogTool.Error("通用事件没有刷新出来 id:" + globalEvents[randomValue2].ID);
                }
            }
        }

        if (eventLists.Count == 0)
        {
            LogTool.Error("没有可以触发的事件");
            return null;
        }

        return eventLists;
    }


    //添加事件
    public AccountFileInfo.EventList AddEvent(int eventID)
    {
        EventConfig eventConfig = ConfigComponent.Instance.Get<EventConfig>(eventID);
        AccountFileInfo.EventList eventList = null;
        if (eventConfig.ID == 0)
        {
            return null;
        }


        //主线任务只能刷一次
        if (eventConfig.EventTriggerType == 4 || eventConfig.EventTriggerType == 6)
        {
            AccountFileInfo.EventList e = AccountFileInfo.Instance.playerData.eventList.FirstOrDefault(e => e.eventID == eventID);
            if (e == null)
            {
                e = AccountFileInfo.Instance.playerData.completeEvents.FirstOrDefault(e => e.eventID == eventID);
                if (e == null)
                {
                    eventList = new AccountFileInfo.EventList();
                    eventList.eventID = eventID;
                }
                else
                {
                    return null;
                }

                eventList.guid = IdGenerater.GenerateIdInt();
                eventList.curStep = eventConfig.EventLinksId[0];
                eventList.selectEventLinkIds.Add(eventConfig.EventLinksId[0]);
            }
        }
        else
        {
            eventList = new AccountFileInfo.EventList();
            eventList.eventID = eventID;

            eventList.guid = IdGenerater.GenerateIdInt();
            eventList.curStep = eventConfig.EventLinksId[0];
            eventList.selectEventLinkIds.Add(eventConfig.EventLinksId[0]);
        }


        //初始化神识链条，用于监听条件是否完成
        if (eventList != null && eventConfig.EventType != 2)
        {
            foreach (var i in eventConfig.EventLinksId)
            {
                EventLinkConfig eventLinkConfig = ConfigComponent.Instance.Get<EventLinkConfig>(i);

                AccountFileInfo.EventLinkData eventLinkData = new AccountFileInfo.EventLinkData();
                eventLinkData.eventId = eventID;
                eventLinkData.eventLinkId = i;
                if (eventLinkConfig.ConditionId != null)
                {
                    foreach (var i1 in eventLinkConfig.ConditionId)
                    {
                        AccountFileInfo.EventConditionData eventConditionData = new AccountFileInfo.EventConditionData();
                        eventConditionData.eventId = eventList.eventID;
                        eventConditionData.eventCondition = i1;
                        eventLinkData.eventConditions.Add(eventConditionData);

                        //初始化先检测一些条件
                        CeekTaskComplete(eventConditionData, 1, null);
                        CeekTaskComplete(eventConditionData, 3, null);
                    }
                }

                eventList.eventLinks.Add(eventLinkData);
            }
        }


        return eventList;
    }

    /// <summary>
    /// 触发随机事件
    /// </summary>
    public void DetectRandomEvents()
    {
        if (isTriggerEvent)
            return;

        if (isOpenUi)
            return;
        // 获取随机事件
        List<EventConfig> randomEvents = eventConfigs.Where(e => e.EventTriggerType == 2 && CanTriggerEvent(e.ID)).ToList();


        if (randomEvents.Count == 0)
        {
            LogTool.Warning("没有可以刷新的事件");
            return;
        }


        int idex = Random.Range(0, randomEvents.Count);
        TriggerEvent(randomEvents[idex]);
    }


    /// <summary>
    /// 挂机事件触发
    /// </summary>
    public void TriggerEvent(EventConfig evt)
    {
        if (isTriggerEvent)
            return;
        isTriggerEvent = true;
        LogTool.Log($"触发事件: {evt.EventName} (ID: {evt.ID}, 品质: {evt.EventQuality})");
        CombatDrive.Instance.CombatController.ChangeState(CombatController.idle);

        AccountFileInfo.EventList eventList = AddEvent(evt.ID);
        CurrentEventList = eventList;
        DialogueManager.Instance.StartDialogue(eventList, evt.EventLinksId[0], evt.ID, () => { CompleteEvent(evt.ID); });
    }

    /// <summary>
    /// 其他类型事件触发
    /// </summary>
    public async CTask TriggerEvent(AccountFileInfo.EventList evt, Action oncompleteCallBack = null)
    {
        // ChancleEvent();
        if (isTriggerEvent)
            return;
        CTask cTask = CTask.Create();
        this.onCompleteCallback = oncompleteCallBack;
        isTriggerEvent = true;
        EventConfig eventConfig = ConfigComponent.Instance.Get<EventConfig>(evt.eventID);
        LogTool.Log($"触发事件: {LanguageManager.Instance.Text(eventConfig.EventName)} (ID: {eventConfig.ID}, 品质: {eventConfig.EventQuality})");

        int dialogueID = 0;
        if (evt.curStep == 0)
        {
            dialogueID = eventConfig.EventLinksId[0];
        }
        else
        {
            dialogueID = evt.curStep;
        }


        CurrentEventList = evt;
        CombatDrive.Instance.CombatController.ChangeState(CombatController.idle);
        DialogueManager.Instance.StartDialogue(CurrentEventList, dialogueID, eventConfig.ID, () =>
        {
            CompleteEvent(CurrentEventList);
            cTask.SetResult();
        }, () =>
        {
            CancelEvent(CurrentEventList);
            cTask.SetResult();
        });
        await cTask;
    }


    //任务是否完成
    public bool IsEvenkLinkComplete(AccountFileInfo.EventConditionData eventCondition)
    {
        EventConditionConfig eventConditionConfig = ConfigComponent.Instance.Get<EventConditionConfig>(eventCondition.eventCondition);

        if (eventCondition != null)
        {
            return eventCondition.fishCount >= eventConditionConfig.finishCount;
        }

        return false;
    }

    public bool CeekEventGroupComplete(List<AccountFileInfo.EventConditionData> eventConditions)
    {
        Map<int, List<AccountFileInfo.EventConditionData>> eventConditionDataGroup = new Map<int, List<AccountFileInfo.EventConditionData>>();

        foreach (var eventConditionData in eventConditions)
        {
            EventConditionConfig eventConditionConfig = ConfigComponent.Instance.Get<EventConditionConfig>(eventConditionData.eventCondition);
            if (!eventConditionDataGroup.ContainsKey(eventConditionConfig.Operation))
            {
                eventConditionDataGroup.Add(eventConditionConfig.Operation, new List<AccountFileInfo.EventConditionData>());
            }

            eventConditionDataGroup[eventConditionConfig.Operation].Add(eventConditionData);
        }


        bool isUlock = true;
        //分组检测 其中一个组绑定成功就可以执行
        foreach (var keyValuePair in eventConditionDataGroup)
        {
            isUlock = true;
            foreach (var eventConditionData in keyValuePair.Value)
            {
                if (!IsEvenkLinkComplete(eventConditionData))
                {
                    isUlock = false;
                }
            }

            if (isUlock)
            {
                return isUlock;
            }
        }

        return isUlock;
    }

    public void CeekEventCompletes(int type, int[] value)
    {
        foreach (var playerDataEventLinkData in AccountFileInfo.Instance.playerData.eventList)
        {
            foreach (var eventLinkData in playerDataEventLinkData.eventLinks)
            {
                foreach (var eventConditionData in eventLinkData.eventConditions)
                {
                    CeekTaskComplete(eventConditionData, type, value);
                }
            }
        }

        EventManager.Instance.Dispatch(CustomEventType.RemoveEvent, null);
    }

    public void CeekTaskComplete(AccountFileInfo.EventConditionData conditionData, int type, int[] value)
    {
        EventConditionConfig eventConditionConfig = ConfigComponent.Instance.Get<EventConditionConfig>(conditionData.eventCondition);


        if (IsEvenkLinkComplete(conditionData))
            return;

        switch (type)
        {
            //检测背包道具
            case 1:
                if (eventConditionConfig.ConditionType == 1)
                {
                    conditionData.fishCount += (int)PlayerManager.Instance.BagController.GetItemCount(eventConditionConfig.ConditionPara[0]);

                    if (IsEvenkLinkComplete(conditionData))
                    {
                        // CompleteTask(conditionData.guid);
                    }
                }

                break;

            //境界检测
            case 3:
                if (eventConditionConfig.ConditionType == 3 && PlayerManager.Instance.myHero.powerUpConfig.ID >= eventConditionConfig.ConditionPara[0])
                {
                    conditionData.fishCount++;

                    if (IsEvenkLinkComplete(conditionData))
                    {
                        // CompleteTask(conditionData.guid);
                    }
                }

                break;

            //战斗胜利
            case 5:
                if (eventConditionConfig.ConditionType == 5 && eventConditionConfig.ConditionPara[0] == value[0])
                {
                    conditionData.fishCount++;

                    if (IsEvenkLinkComplete(conditionData))
                    {
                        // CompleteEvent(conditionData.guid);
                    }
                }

                break;


            //获得道具
            case 6:
                if (eventConditionConfig.ConditionType == 6 && eventConditionConfig.ConditionPara[0] == value[0])
                {
                    conditionData.fishCount += value[1];

                    if (IsEvenkLinkComplete(conditionData))
                    {
                        // CompleteEvent(conditionData.guid);
                    }
                }

                break;

            //使用神识
            case 8:
                if (eventConditionConfig.ConditionType == 8)
                {
                    conditionData.fishCount += value[0];

                    if (IsEvenkLinkComplete(conditionData))
                    {
                    }
                }

                break;
        }


        AccountFileInfo.Instance.SavePlayerData();
    }

    private void CompleteTask(object taskID)
    {
    }


    /// <summary>
    /// 检查事件是否满足触发条件。
    /// </summary>
    private bool CanTriggerEvent(int eventID)
    {
        var evt = eventConfigs.Find(e => e.ID == eventID);
        if (evt.ID == 0)
            return false;

        switch (evt.EventConditionId)
        {
            //背包道具检测
            case 1:
                return PlayerManager.Instance.BagController.GetItemCount(evt.EventValue[0]) >= evt.EventCount;
            //境界判断
            case 2:
                return PlayerManager.Instance.myHero.level >= evt.EventCount;
            //概率判断
            case 3:
                int randomValue1 = Random.Range(0, 1001);

                return randomValue1 <= evt.EventCount;
            //完成事件判断
            case 10:
                AccountFileInfo.EventList eventList = AccountFileInfo.Instance.playerData.completeEvents.FirstOrDefault(ce => ce.eventID == evt.EventValue[0]);
                return eventList != null;
        }

        return true;
    }


    /// <summary>
    /// 完成事件
    /// </summary>
    /// <param name="eventID">事件ID</param>
    public void CompleteEvent(int evtId)
    {
        isTriggerEvent = false;
        LogTool.Log($"完成挂机事件{evtId}");

        EventConfig eventConfig = ConfigComponent.Instance.Get<EventConfig>(evtId);

        AccountFileInfo.EventList eventList = new AccountFileInfo.EventList();
        eventList.eventID = evtId;
        AccountFileInfo.Instance.playerData.completeEvents.Add(eventList);

        if (PlayerManager.Instance.CurrentPlaces.progress < 100)
            PlayerManager.Instance.CurrentPlaces.progress += eventConfig.Score;


        AccountFileInfo.Instance.SavePlayerData();
        CombatDrive.Instance.CombatController.ChangeState(CombatController.update);
        EventManager.Instance.Dispatch(CustomEventType.CompleteEvent, null);
    }

    /// <summary>
    /// 完成事件
    /// </summary>
    /// <param name="eventID">事件ID</param>
    public async void CompleteEvent(AccountFileInfo.EventList eventList, bool isTriggerEvent = false)
    {
        this.isTriggerEvent = isTriggerEvent;
        LogTool.Log($"完成事件{eventList.eventID}");

        EventConfig eventConfig = ConfigComponent.Instance.Get<EventConfig>(eventList.eventID);
        AccountFileInfo.EventList ceventList = AccountFileInfo.Instance.playerData.completeEvents.FirstOrDefault(ce => ce.eventID == eventList.eventID);

        if (ceventList == null)
        {
            PlacesConfig[] placesConfigs = ConfigComponent.Instance.GetAll<PlacesConfig>();
            int pId = 0;
            for (var i = 0; i < placesConfigs.Length; i++)
            {
                if (placesConfigs[i].MainTaskID == null || placesConfigs[i].ZhixianID == null)
                    continue;
                if (placesConfigs[i].MainTaskID.Contains(eventConfig.ID) ||
                    placesConfigs[i].ZhixianID.Contains(eventConfig.ID))
                {
                    pId = placesConfigs[i].ID;
                    break;
                }
            }

            if (pId == 0)
            {
                PlayerManager.Instance.CurrentPlaces.progress += eventConfig.Score;
            }
            else
            {
                PlayerManager.Instance.GetPlacesData(pId).progress += eventConfig.Score;
            }
        }


        List<ItemInfo> itemInfos = new List<ItemInfo>();
        if (eventConfig.PrizeIDs != null)
        {
            for (var i = 0; i < eventConfig.PrizeIDs.Length; i++)
            {
                itemInfos.Add(new ItemInfo(eventConfig.PrizeIDs[i], eventConfig.PrizeNums[i]));
            }
        }

        foreach (var eventListItemInfo in eventList.itemInfos)
        {
            itemInfos.Add(new ItemInfo(eventListItemInfo));
        }


        PlayerManager.Instance.BagController.AddItem(itemInfos);
        RewardsPanel rewardsPanel = await RewardsPanel.OpenPanel(itemInfos);
        await rewardsPanel.UIClosed();


        if (eventConfig.EventTriggerType == 4)
        {
            AccountFileInfo.Instance.playerData.completeEvents.Add(eventList);
            AccountFileInfo.Instance.playerData.eventList.Remove(eventList);
            TaskInfoPanel.OpenPanel(eventList);
        }
        else
        {
            //先不移除 下次探索神识移除
            eventList.isCompleted = true;
        }

        if (AccountFileInfo.Instance.playerData.CurrentZuiZhongEventList.guid == eventList.guid)
        {
            AccountFileInfo.Instance.playerData.CurrentZuiZhongEventList = null;
            UpdateZuizhongEventData();
        }


        AccountFileInfo.Instance.SavePlayerData();


        CombatDrive.Instance.CombatController.ChangeState(CombatController.update);
        EventManager.Instance.Dispatch(CustomEventType.CompleteEvent, null);
        onCompleteCallback?.Invoke();
        onCompleteCallback = null;
    }

    /// <summary>
    /// 完成事件
    /// </summary>
    /// <param name="eventID">事件ID</param>
    public void CompleteEvent(AccountFileInfo.EventLinkData eventLinkData)
    {
    }

    /// <summary>
    /// 取消事件
    /// </summary>
    /// <param name="eventID">事件ID</param>
    public void CancelEvent(AccountFileInfo.EventList eventList)
    {
        LogTool.Log($"取消事件{eventList.eventID}");
        isTriggerEvent = false;
        EventManager.Instance.Dispatch(CustomEventType.CompleteEvent, null);
        CombatDrive.Instance.CombatController.ChangeState(CombatController.update);
        onCompleteCallback?.Invoke();
        onCompleteCallback = null;
    }

    public void RemoveEvent(AccountFileInfo.EventList eventList)
    {
        AccountFileInfo.Instance.playerData.eventList.Remove(eventList);
        AccountFileInfo.Instance.SavePlayerData();
        EventManager.Instance.Dispatch(CustomEventType.RemoveEvent, null);
    }

    /// <summary>
    /// 获得主线事件
    /// </summary>
    /// <returns></returns>
    public AccountFileInfo.EventList GetMainEventDta()
    {
        foreach (var eventList in AccountFileInfo.Instance.playerData.eventList)
        {
            EventConfig eventConfig = ConfigComponent.Instance.Get<EventConfig>(eventList.eventID);
            if (eventConfig.EventTriggerType == 4)
            {
                return eventList;
            }
        }

        return null;
    }


    public void CancelEvent()
    {
        CombatDrive.Instance.CombatController.ChangeState(CombatController.update);
        DialogueManager.Instance.ChancleEvent();
        CurrentEventList = null;
        isTriggerEvent = false;
    }
}