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.Combat;
using GameLogic.Combat.CombatTool;
using UnityEngine;
using Utility;
using Random = UnityEngine.Random;

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

    List<AccountFileInfo.EventData> eventDatas = new List<AccountFileInfo.EventData>();


    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 void CustomInit()
    {
        eventConfigs = ConfigComponent.Instance.GetAll<EventConfig>().ToList();
        divineSenseConfigs = ConfigComponent.Instance.GetAll<DivineSenseConfig>().ToList();

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

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

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

    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(int bigMapId)
    {
        DivineSenseConfig divineSenseConfig = ConfigComponent.Instance.Get<DivineSenseConfig>(AccountFileInfo.Instance.playerData.divineSenseLevel);
        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 + AccountFileInfo.Instance.playerData.eventList.Count > maxCount ? maxCount - AccountFileInfo.Instance.playerData.eventList.Count : count;

        int xiaoHao = count * PlayerManager.Instance.gameConstantConfig.DetectEventCount;

        AccountFileInfo.Instance.playerData.divineSenseexp += xiaoHao;
        AccountFileInfo.Instance.playerData.divineSensePoint -= xiaoHao;
        EventManager.Instance.Dispatch(CustomEventType.DivineSensePointChange, null);
        // 神识升级逻辑
        UpDivinesense();
        // AccountFileInfo.Instance.SavePlayerData();

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

        List<AccountFileInfo.EventList> eventLists = new List<AccountFileInfo.EventList>();
        for (var i = 0; i < eventConfigs.Count; i++)
        {
            AccountFileInfo.EventList eventList = AddEvent(eventConfigs[i].ID);
            if (eventList == null)
                continue;

            eventLists.Add(eventList);
        }

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

    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();
    }


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

        return false;
    }

    private List<EventConfig> DetectEvents(int bigMapId, int eventCount)
    {
        PlacesConfig bigMap = ConfigComponent.Instance.Get<PlacesConfig>(bigMapId);
        DivineSenseConfig divineSenseConfig = ConfigComponent.Instance.Get<DivineSenseConfig>(AccountFileInfo.Instance.playerData.divineSenseLevel);


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


        var triggeredEvents = new List<EventConfig>();
        for (int i = 0; i < eventCount; i++)
        {
            //先掉落出品质
            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)).ToList();


            //神识场景事件
            List<EventConfig> candidateEvents = eventConfigs.Where(e => bigMap.ZhixianID.Contains(e.ID) && CanTriggerEvent(e.ID) && e.EventQuality == quality && !BagIsEvent(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);

                triggeredEvents.Add(candidateEvents[randomValue2]);
                candidateEvents.RemoveAll(ew => ew.ID == candidateEvents[randomValue2].ID);
            }
            else if (globalEvents.Count > 0)
            {
                int randomValue2 = Random.Range(0, globalEvents.Count);

                triggeredEvents.Add(globalEvents[randomValue2]);
                globalEvents.RemoveAll(ew => ew.ID == globalEvents[randomValue2].ID);
            }
        }

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

        return triggeredEvents;
    }


    //添加事件
    public AccountFileInfo.EventList AddEvent(int eventID)
    {
        EventConfig eventConfig = ConfigComponent.Instance.Get<EventConfig>(eventID);
        AccountFileInfo.EventList eventList = null;
        AccountFileInfo.EventList e = AccountFileInfo.Instance.playerData.eventList.FirstOrDefault(e => e.eventID == eventID);
        if (e == null)
        {
            //主线任务只能刷一次
            if (eventConfig.EventTriggerType == 4)
            {
                e = AccountFileInfo.Instance.playerData.completeEvents.FirstOrDefault(e => e.eventID == eventID);
                if (e == null)
                {
                    eventList = new AccountFileInfo.EventList();
                    eventList.eventID = eventID;


                    // return eventList;
                }
            }
            else
            {
                eventList = new AccountFileInfo.EventList();
                eventList.eventID = eventID;
            }
        }

        if (eventList != null && eventConfig.EventType != 2)
        {
            foreach (var i in eventConfig.EventLinksId)
            {
                AccountFileInfo.EventLinkData eventLinkData = AccountFileInfo.Instance.playerData.eventLinkDatas.FirstOrDefault(el => el.eventLinkId == i);

                if (eventLinkData == null)
                {
                    eventLinkData = new AccountFileInfo.EventLinkData();
                    eventLinkData.eventId = eventList.eventID;
                    eventLinkData.eventLinkId = i;
                    AccountFileInfo.Instance.playerData.eventLinkDatas.Add(eventLinkData);
                }

                eventLinkData.fishCount = 0;
                EventSystemManager.Instance.CeekTaskComplete(eventLinkData.eventLinkId, 1, 0);
                EventSystemManager.Instance.CeekTaskComplete(eventLinkData.eventLinkId, 3, 0);
            }
        }


        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.Description} (ID: {evt.ID}, 品质: {evt.EventQuality})");
        CombatDrive.Instance.CombatController.ChangeState(CombatController.idle);

        DialogueManager.Instance.StartDialogue(evt.EventLinksId[0], evt.ID, () => { CompleteEvent(evt.ID); });
    }

    /// <summary>
    /// 触发事件
    /// </summary>
    public async CTask TriggerEvent(AccountFileInfo.EventList evt, Action oncompleteCallBack = null)
    {
        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.Description)} (ID: {eventConfig.ID}, 品质: {eventConfig.EventQuality})");

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


            // AccountFileInfo.Instance.SavePlayerData();
        }
        else
        {
            dialogueID = evt.curStep;
        }


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


    //任务是否完成
    public bool IsEvenkLinkComplete(int eventLinkId)
    {
        EventLinkConfig eventLinkConfig = ConfigComponent.Instance.Get<EventLinkConfig>(eventLinkId);
        if (eventLinkConfig.ConditionType == 0)
            return true;

        AccountFileInfo.EventLinkData eventLinkData = AccountFileInfo.Instance.playerData.eventLinkDatas.FirstOrDefault(el => el.eventLinkId == eventLinkId);

        if (eventLinkData != null)
        {
            return eventLinkData.fishCount >= eventLinkConfig.finishCount;
        }

        return false;
    }

    public void CeekEventCompletes(int type, int value)
    {
        foreach (var playerDataEventLinkData in AccountFileInfo.Instance.playerData.eventLinkDatas)
        {
            CeekTaskComplete(playerDataEventLinkData.eventLinkId, type, value);
        }
    }

    public void CeekTaskComplete(int eventLiknId, int type, int value)
    {
        //任务完成了跳过检测
        if (IsEvenkLinkComplete(eventLiknId))
            return;
        AccountFileInfo.EventLinkData eventLinkData = AccountFileInfo.Instance.playerData.eventLinkDatas.FirstOrDefault(el => el.eventLinkId == eventLiknId);

        EventLinkConfig eventLinkConfig = ConfigComponent.Instance.Get<EventLinkConfig>(eventLiknId);
        switch (type)
        {
            //检测背包道具
            case 1:
                if (eventLinkConfig.ConditionType == 1)
                {
                    eventLinkData.fishCount += (int)PlayerManager.Instance.BagController.GetItemCount(eventLinkConfig.ConditionPara[0]);

                    if (IsEvenkLinkComplete(eventLiknId))
                    {
                        CompleteTask(eventLiknId);
                    }
                }

                break;

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

                    if (IsEvenkLinkComplete(eventLiknId))
                    {
                        CompleteTask(eventLiknId);
                    }
                }

                break;

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

                    if (IsEvenkLinkComplete(eventLiknId))
                    {
                        CompleteEvent(eventLiknId);
                    }
                }

                break;

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

                    if (IsEvenkLinkComplete(eventLiknId))
                    {
                        CompleteEvent(eventLinkData);
                    }
                }

                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;

        if (!CheckCondition(evt.EventConditionId[0], evt.EventValue,evt.EventCount))
            return false;
        // for (var i = 0; i < evt.EventConditionId?.Length; i++)
        // {
        //     
        // }

        return true;
    }

    /// <summary>
    /// 检查单个触发条件。
    /// </summary>
    public bool CheckCondition(int conditionid, int[] EventVlaue,int value)
    {
        if (conditionid == 0)
            return true;


        //道具id判断
        // if (conditionid == 1)
        // {
        //     return PlayerManager.Instance.BagController.IsEnough(EventVlaue[0], EventVlaue[1]);
        // }
        // else if (conditionid == 3)
        // {
        //     return PlayerManager.Instance.myHero.powerUpConfig.ID >= EventVlaue[0];
        // }


        return true;
    }

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


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

        if (AccountFileInfo.Instance.playerData.senceExplorationProgress < 100)
            AccountFileInfo.Instance.playerData.senceExplorationProgress += 1;


        AccountFileInfo.Instance.SavePlayerData();
        CombatDrive.Instance.CombatController.ChangeState(CombatController.update);
    }

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

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

        AccountFileInfo.Instance.playerData.completeEvents.Add(eventList);

        if (AccountFileInfo.Instance.playerData.senceExplorationProgress < 100)
            AccountFileInfo.Instance.playerData.senceExplorationProgress += 1;


        AccountFileInfo.Instance.playerData.eventList.Remove(eventList);
        AccountFileInfo.Instance.SavePlayerData();

        if (eventConfig.EventTriggerType == 4)
        {
            TaskInfoPanel.OpenPanel(eventList.eventID, "任务完成");
        }

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

    /// <summary>
    /// 完成事件
    /// </summary>
    /// <param name="eventID">事件ID</param>
    public void CompleteEvent(AccountFileInfo.EventLinkData eventLinkData)
    {
        // AccountFileInfo.EventList eventList = new AccountFileInfo.EventList();
        // eventList.eventID = eventLinkData.eventId;
        // AccountFileInfo.Instance.playerData.completeEvents.Add(eventList);
        //
        // if (AccountFileInfo.Instance.playerData.senceExplorationProgress < 100)
        //     AccountFileInfo.Instance.playerData.senceExplorationProgress += 1;
        //
        //
        // AccountFileInfo.Instance.playerData.eventList.Remove(eventList);
        //
        // EventLinkConfig eventLinkConfig = ConfigComponent.Instance.Get<EventLinkConfig>(eventLinkData.eventLinkId);
        // if (eventLinkConfig.ResultType == 3)
        // {
        //     //触发新事件
        //     //弹出任务完成ui
        // }
        //
        // AccountFileInfo.Instance.SavePlayerData();
        //
        // EventManager.Instance.Dispatch(CustomEventType.CompleteEvent, null);
        // CombatDrive.Instance.CombatController.ChangeState(CombatController.update);
    }

    /// <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);
    }

    public AccountFileInfo.EventList GetMainEventDta()
    {
        foreach (var eventList in AccountFileInfo.Instance.playerData.eventList)
        {
            EventConfig eventConfig = ConfigComponent.Instance.Get<EventConfig>(eventList.eventID);
            if (eventConfig.EventType == 4)
            {
                return eventList;
            }
        }

        return null;
    }
}