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

using System.Collections.Generic;
using System.Linq;
using Core.Language;
using Excel2Json;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Combat;
using GameLogic.Combat.CombatTool;
using Unity.Plastic.Newtonsoft.Json.Serialization;
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>();

    IDialogueMono dialogueMono;

    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(IDialogueMono dialogueMono)
    {
        eventConfigs = ConfigComponent.Instance.GetAll<EventConfig>().ToList();
        divineSenseConfigs = ConfigComponent.Instance.GetAll<DivineSenseConfig>().ToList();
        this.dialogueMono = dialogueMono;
        StaticUpdater.Instance.AddRenderUpdateCallBack(Update);
    }

    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 = new AccountFileInfo.EventList();
            eventList.eventID = eventConfigs[i].ID;
            eventLists.Add(eventList);
        }

        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 List<EventConfig> DetectEvents(int bigMapId, int eventCount)
    {
        BigMap bigMap = ConfigComponent.Instance.Get<BigMap>(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).ToList();


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

    /// <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})");
        dialogueMono.ChangeComabtState(CombatController.idle);

        DialogueManager.Instance.StartDialogue(evt.EventBeginId, 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.EventBeginId;
        }
        else
        {
            dialogueID = evt.curStep;
        }

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

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


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

        return true;
    }

    /// <summary>
    /// 检查单个触发条件。
    /// </summary>
    private bool CheckCondition(int conditionid, int EventVlaue)
    {
        //>=
        if (EventVlaue == 1)
        {
        }
        //=
        else if (EventVlaue == 2)
        {
        }
        // <=
        else if (EventVlaue == 3)
        {
        }


        return true;
    }

    /// <summary>
    /// 完成事件
    /// </summary>
    /// <param name="eventID">事件ID</param>
    public void CompleteEvent(int eventID)
    {
        isTriggerEvent = false;
        LogTool.Log($"完成事件{eventID}");
        AccountFileInfo.EventData eventData = AccountFileInfo.Instance.playerData.events.FirstOrDefault((e) => e.eventID == eventID);
        if (eventData == null)
        {
            eventData = new AccountFileInfo.EventData();
            eventData.eventID = eventID;
        }

        eventData.completeCount++;
        AccountFileInfo.Instance.playerData.events.Add(eventData);

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


        AccountFileInfo.Instance.SavePlayerData();
        dialogueMono.ChangeComabtState(CombatController.update);

        // EventManager.Instance.Dispatch(CustomEventType.CompleteEvent, null);
    }

    /// <summary>
    /// 完成事件
    /// </summary>
    /// <param name="eventID">事件ID</param>
    public void CompleteEvent(AccountFileInfo.EventList eventList, bool isTriggerEvent = false)
    {
        this.isTriggerEvent = isTriggerEvent;
        LogTool.Log($"完成事件{eventList.eventID}");
        AccountFileInfo.EventData eventData = AccountFileInfo.Instance.playerData.events.FirstOrDefault((e) => e.eventID == eventList.eventID);
        if (eventData == null)
        {
            eventData = new AccountFileInfo.EventData();
            eventData.eventID = eventList.eventID;
        }

        eventData.completeCount++;
        AccountFileInfo.Instance.playerData.events.Add(eventData);

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


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

        EventManager.Instance.Dispatch(CustomEventType.CompleteEvent, null);
        dialogueMono.ChangeComabtState(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);
    }
}