XiuXianGame/Assets/Scripts/GameLogic/Player/PlayerManager.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Core.Audio;
using Core.Language;
using Core.Utility;
using Excel2Json;
using Fort23.Core;
using Fort23.Mono;
using Fort23.UTool;
using GameLogic.Bag;
using GameLogic.Combat.CombatTool;
using GameLogic.CombatScenesTool;
using GameLogic.Hero;
using GameLogic.Player;
using Mono.Player;
using UnityEngine;
using Utility;
using Random = UnityEngine.Random;


public class PlayerManager : Singleton<PlayerManager>
{
    public GameConstantConfig gameConstantConfig;

    public GongFaControl GongFaControl;
    public FaBaoControl FaBaoControl;
    public BagController BagController;
    public PlayerGuideDataComponent PlayerGuideDataComponent = new PlayerGuideDataComponent();
    public SummonManager SummonManager = new SummonManager();

    // public Map<long, List<AccountFileInfo.DaoYouGuaiJiData>> GuaijiDaoYou = new Map<long, List<AccountFileInfo.DaoYouGuaiJiData>>();

    public bool isTest;

    /// <summary>
    /// 玩家角色属性
    /// </summary>
    public HeroInfo myHero;

    public HeroInfo yindaoHeroData;

    private string playerName;


    public string PlayerName
    {
        get { return AccountFileInfo.Instance.playerData.playerName; }
        set
        {
            playerName = value;
            AccountFileInfo.Instance.playerData.playerName = value;
            AccountFileInfo.Instance.SavePlayerData();
        }
    }

    private CTask _cTask;

    public long serverTime => TimeHelper.ServerNow();
    private AccountFileInfo.SmallPlacesData currentPlaces;

    public AccountFileInfo.SmallPlacesData CurrentsmallPlaces
    {
        get { return currentPlaces; }
        set { currentPlaces = value; }
    }

    public float PlacesBl => GetMapBl(CurrentsmallPlaces.id);

    private TimerEntity _timerEntity;

    public bool isLogin;

    /// <summary>
    /// 当前引导id
    /// </summary>
    public int curGuideGroupId;

    public void Init()
    {
        AccountFileInfo.Instance.LoadPlayerData();
        LogServer.Instance.playerID = AccountFileInfo.Instance.playerData.playerId;
        SetConfigs();

        InitGameData();


        if (string.IsNullOrEmpty(AccountFileInfo.Instance.playerData.playerId))
        {
            AccountFileInfo.Instance.playerData.playerId = Guid.NewGuid().ToString();
        }

        if (AccountFileInfo.Instance.playerData.MusicEffects)
        {
            AudioManager.Instance.SetAudioValue(1);
        }
        else
        {
            AudioManager.Instance.SetAudioValue(0);
        }

        if (AccountFileInfo.Instance.playerData.MusicBg)
        {
            AudioManager.Instance.SetBgmValue(1);
        }
        else
        {
            AudioManager.Instance.SetBgmValue(0);
        }


        // int m = Random.Range(0, 4 * 60 * 1000);
        RandownDaoYou(gameConstantConfig.Daoyoushowuptime + 1000);
        QiankundaiConfig[] qiankundaiConfigs = ConfigComponent.Instance.GetAll<QiankundaiConfig>();
        foreach (var qiankundaiConfig in qiankundaiConfigs)
        {
            if (qiankundaiConfig.dropType == 1)
            {
                AccountFileInfo.QiankundaiData qiankundaiData =
                    AccountFileInfo.Instance.playerData.QiankundaiDatas.FirstOrDefault(q =>
                        q.id == qiankundaiConfig.ID);
                if (qiankundaiData == null)
                {
                    qiankundaiData = new AccountFileInfo.QiankundaiData();
                    qiankundaiData.id = qiankundaiConfig.ID;
                    if (qiankundaiConfig.dropPara1 == 1)
                    {
                        qiankundaiData.refenceTime = TimeHelper.ClientNow() + 60 * 60 * 1000;
                    }
                    else if (qiankundaiConfig.dropPara1 == 2)
                    {
                        qiankundaiData.refenceTime = TimeHelper.GetBaseRefreshTime(TimeHelper.ClientNow());
                    }
                    else if (qiankundaiConfig.dropPara1 == 3)
                    {
                    }

                    AccountFileInfo.Instance.playerData.QiankundaiDatas.Add(qiankundaiData);
                }
            }
        }

        EveryDayRefence();
        CalculateOfflineRewards();
        AccountFileInfo.Instance.SavePlayerData();
        SummonManager.CustomInit();
        isLogin = true;
    }

    /// <summary>
    /// 获得固定时间乾坤袋表
    /// </summary>
    /// <returns></returns>
    public List<QiankundaiConfig> GetFixedTimeQiankundaiConfigs()
    {
        List<QiankundaiConfig> configs = new List<QiankundaiConfig>();
        QiankundaiConfig[] qiankundaiConfigs = ConfigComponent.Instance.GetAll<QiankundaiConfig>();
        foreach (var qiankundaiConfig in qiankundaiConfigs)
        {
            if (qiankundaiConfig.dropType == 2)
            {
                if (myHero.powerUpConfig.ID >= qiankundaiConfig.dropLevel[0] &&
                    myHero.powerUpConfig.ID <= qiankundaiConfig.dropLevel[1])
                {
                    configs.Add(qiankundaiConfig);
                }
            }
        }

        return configs;
    }

    //添加心境
    public void AddSentimentData(int id)
    {
        AccountFileInfo.SentimentData sentimentData =
            AccountFileInfo.Instance.playerData.SentimentDatas.FirstOrDefault(sd => sd.id == id);
        if (sentimentData != null)
        {
            LogTool.Error("已经用心境 id：" + id);
            return;
        }

        SentimentConfig sentimentConfig = ConfigComponent.Instance.Get<SentimentConfig>(id);

        sentimentData = new AccountFileInfo.SentimentData();
        sentimentData.id = id;
        sentimentData.mainSentiment = new AccountFileInfo.SentimentProperty();
        sentimentData.mainSentiment.groupId = sentimentConfig.mainSentimentEffect;
        foreach (var i in sentimentConfig.sentimentEffect)
        {
            AccountFileInfo.SentimentProperty sentimentProperty = new AccountFileInfo.SentimentProperty();
            sentimentProperty.groupId = i;
            sentimentData.sentimentProperties.Add(sentimentProperty);
        }

        AccountFileInfo.Instance.playerData.SentimentDatas.Add(sentimentData);
        AccountFileInfo.Instance.SavePlayerData();
    }

    List<AccountFileInfo.DaoYouData> removerDaoYou = new List<AccountFileInfo.DaoYouData>();

    public void RandownDaoYou(int m)
    {
        _timerEntity?.Dispose();
        _timerEntity = null;
        _timerEntity = TimerComponent.Instance.AddTimer(m, () =>
        {
            List<AccountFileInfo.DaoYouData> daoYouDatas = AccountFileInfo.Instance.playerData.daoYouDatas.ToList();

            foreach (var daoYouData in daoYouDatas)
            {
                if (daoYouData.favorabilityLv <= 1)
                {
                    removerDaoYou.Add(daoYouData);

                    continue;
                }

                foreach (var keyValuePair in AccountFileInfo.Instance.playerData.daoYouGuaiJiDatas)
                {
                    if (daoYouData.id == keyValuePair.daoyouDataID)
                    {
                        removerDaoYou.Add(daoYouData);
                        break;
                    }
                }
            }

            foreach (var daoYouData in removerDaoYou)
            {
                daoYouDatas.Remove(daoYouData);
            }

            removerDaoYou.Clear();


            int count = Random.Range(0, daoYouDatas.Count + 1);
            count = count > gameConstantConfig.daoyouMaxshowupNum ? gameConstantConfig.daoyouMaxshowupNum : count;
            List<AccountFileInfo.DaoYouGuaiJiData> daoyou = new List<AccountFileInfo.DaoYouGuaiJiData>();
            for (int i = 0; i < count; i++)
            {
                int index = Random.Range(0, daoYouDatas.Count);

                AccountFileInfo.DaoYouGuaiJiData daoYouGuaiJiData = new AccountFileInfo.DaoYouGuaiJiData();
                int time = Random.Range(gameConstantConfig.DaoyouguajiDuration[0],
                    gameConstantConfig.DaoyouguajiDuration[1]) * 1000;
                daoYouGuaiJiData.leaveTime = TimeHelper.ClientNow() + time;
                daoYouGuaiJiData.guajiTime = time;
                daoYouGuaiJiData.daoyouDataID = daoYouDatas[index].id;


                daoyou.Add(daoYouGuaiJiData);

                daoYouDatas.RemoveAt(index);
                _timerEntity?.Dispose();
                _timerEntity = null;
            }

            if (daoyou.Count > 0)
            {
                AccountFileInfo.Instance.playerData.daoYouGuaiJiDatas.AddRange(daoyou);
                EventManager.Instance.Dispatch(CustomEventType.DaoYouCounUpdate, null);
            }

            RandownDaoYou(gameConstantConfig.Daoyoushowuptime * 1000);
        });
    }

    public int GetDaoYouLevel(AccountFileInfo.DaoYouData daoYouData)
    {
        HeroPowerUpConfig[] heroPowerUpConfigs = ConfigComponent.Instance.GetAll<HeroPowerUpConfig>();
        DaoyouModelConfig daoyouModelConfig = ConfigComponent.Instance.Get<DaoyouModelConfig>(daoYouData.id);
        int level = (int)(myHero.level.Value * daoyouModelConfig.growupRate * 0.01f);
        if (level < 1) level = 1;
        if (level > heroPowerUpConfigs.Length) level = heroPowerUpConfigs.Length;
        return level;
    }

    public int GetBl(AccountFileInfo.DaoYouData daoYouData, int guajibuffId)
    {
        DaoyouLevelupConfig daoyouLevelupConfig =
            ConfigComponent.Instance.Get<DaoyouLevelupConfig>(daoYouData.favorabilityLv);
        int level = GetDaoYouLevel(daoYouData);
        DaoyouguajiResourcLevel daoyouguajiResourcLevel = ConfigComponent.Instance.Get<DaoyouguajiResourcLevel>(level);
        guajibuff guajibuff = ConfigComponent.Instance.Get<guajibuff>(guajibuffId);

        int levelBl = 0;
        int bl = 0;
        switch (guajibuff.paraValue)
        {
            case 1:
                levelBl = daoyouguajiResourcLevel.para1;
                bl = (int)(guajibuff.GivingRate * levelBl * daoyouLevelupConfig.guajiGrowup * 0.01f * 0.01f);
                return bl;

                break;
            case 2:
                levelBl = daoyouguajiResourcLevel.para2;
                bl = (int)(guajibuff.GivingRate * levelBl * daoyouLevelupConfig.guajiGrowup * 0.01f * 0.01f);
                return bl;
                break;
            case 3:
                levelBl = daoyouguajiResourcLevel.para3;
                bl = (int)(guajibuff.GivingRate * levelBl * daoyouLevelupConfig.guajiGrowup * 0.01f * 0.01f);
                return bl;
                break;
            case 4:
                levelBl = daoyouguajiResourcLevel.para4;
                bl = (int)(guajibuff.GivingRate * levelBl * daoyouLevelupConfig.guajiGrowup * 0.01f * 0.01f);
                return bl;
                break;
            case 5:
                levelBl = daoyouguajiResourcLevel.para5;
                bl = (int)(guajibuff.GivingRate * levelBl * daoyouLevelupConfig.guajiGrowup * 0.01f * 0.001f);
                return bl;
                break;
            default:
                return 0;
        }
    }

    private void SetConfigs()
    {
        gameConstantConfig = ConfigComponent.Instance.Get<GameConstantConfig>(1);
    }


    private void InitGameData()
    {
        GongFaControl = new GongFaControl();
        FaBaoControl = new FaBaoControl();
        BagController = new BagController();

        HeroInfo heroInfo = new HeroInfo();
        AccountFileInfo.Instance.playerData.heroData.TaoismSkillId = 601011;
        heroInfo.InitHero(AccountFileInfo.Instance.playerData.heroData);
        myHero = heroInfo;
        myHero.TaoismSkillId = 601011;


        yindaoHeroData = new HeroInfo();
        yindaoHeroData.InitMonster(102, 200);
        yindaoHeroData.isMonster = false;
        // yindaoHeroData = heroInfo;
        yindaoHeroData.TaoismSkillId = 601011;
        // myHero= yindaoHeroData;
        BagController.Init();

        //初始化关卡
        CurrentsmallPlaces = GetSmallPlacesData(GetMaxSmallPlacesId());

        StaticUpdater.Instance.RemoveRenderUpdateCallBack(Update);
        StaticUpdater.Instance.AddRenderUpdateCallBack(Update);

        EventManager.Instance.AddEventListener(CustomEventType.CloseLoadingUI, CloseLoadingUI);
    }

    private void CloseLoadingUI(IEventData e)
    {
        _cTask?.SetResult();
    }

    private float timer;

    public int GetMaxSmallPlacesId()
    {
        int placesId = AccountFileInfo.Instance.playerData.smallPlacesDatas.Max(p => p.id);
        return placesId;
    }

    public AccountFileInfo.PlacesData GetPlacesData(int placesId)
    {
        return AccountFileInfo.Instance.playerData.placesDatas.FirstOrDefault(p => p.id == placesId);
    }

    public AccountFileInfo.SmallPlacesData GetSmallPlacesData(int smallPlacesId)
    {
        return AccountFileInfo.Instance.playerData.smallPlacesDatas.FirstOrDefault(p => p.id == smallPlacesId);
    }

    public float GetMapBl(int map)
    {
        SmallPlacesConfig smallPlacesConfig = ConfigComponent.Instance.Get<SmallPlacesConfig>(map);
        AccountFileInfo.PlacesData placesData = GetPlacesData(smallPlacesConfig.PlacesId);
        if (placesData == null)
            return 0;
        PlacesConfig placesConfig = ConfigComponent.Instance.Get<PlacesConfig>(smallPlacesConfig.PlacesId);
        if (placesConfig.TotalScore == 0)
        {
            return 0;
        }

        return (float)Math.Round(((float)placesData.progress / placesConfig.TotalScore) * 100, 1);
    }


    private bool isUpdate = false;

    private void Update()
    {
        if (!TimeHelper.IsNetworkTimeReady)
        {
            LogTool.Error($"获取网络时间失败，挂机奖励停止计算");
            return;
        }

        timer += Time.deltaTime;
        if (timer > 1)
        {
            timer = 0;
            if (AccountFileInfo.Instance.playerData.QiankundaiDropTimer <= gameConstantConfig.qiankundaiMaxTime)
            {
                AccountFileInfo.Instance.playerData.QiankundaiDropTimer++;
                QianKunDaiAward();
                AccountFileInfo.Instance.SavePlayerData();
            }
        }

        //每天刷新
        EveryDayRefence();


        foreach (var keyValuePair in AccountFileInfo.Instance.playerData.daoYouGuaiJiDatas)
        {
            if (!keyValuePair.isLeave && TimeHelper.ClientNow() > keyValuePair.leaveTime)
            {
                //判断概率给奖励
                isUpdate = true;
                keyValuePair.isLeave = true;

                AccountFileInfo.DaoYouData daoYouData =
                    AccountFileInfo.Instance.playerData.daoYouDatas.FirstOrDefault(d =>
                        d.id == keyValuePair.daoyouDataID);

                DaoyouModelConfig daoyouModelConfig =
                    ConfigComponent.Instance.Get<DaoyouModelConfig>(daoYouData.id);
                int bl = GetBl(daoYouData, daoyouModelConfig.guajiBuffID[0]);

                int randomValue1 = Random.Range(0, 101);
                LogTool.Log("道友随机怪率：" + randomValue1 + " 比例:" + bl);
                List<AccountFileInfo.ItemData> itemDatas = new List<AccountFileInfo.ItemData>();
                if (randomValue1 < bl)
                {
                    for (var i = 1; i < daoyouModelConfig.guajiBuffID.Length; i++)
                    {
                        int count = GetBl(daoYouData, daoyouModelConfig.guajiBuffID[i]);
                        guajibuff guajibuff =
                            ConfigComponent.Instance.Get<guajibuff>(daoyouModelConfig.guajiBuffID[i]);
                        switch (guajibuff.paraValue)
                        {
                            case 1:
                                itemDatas.Add(new AccountFileInfo.ItemData(1003, count));
                                LogTool.Log("道友获得道具id：" + 1003 + " 数量:" + count);
                                break;
                            case 2:
                                itemDatas.Add(new AccountFileInfo.ItemData(1001, count));
                                LogTool.Log("道友获得道具id：" + 1001 + " 数量:" + count);
                                break;
                            case 3:
                                itemDatas.Add(new AccountFileInfo.ItemData(1005, count));
                                LogTool.Log("道友获得道具id：" + 1005 + " 数量:" + count);
                                break;
                            case 4:
                                itemDatas.Add(new AccountFileInfo.ItemData(1006, count));
                                LogTool.Log("道友获得道具id：" + 1006 + " 数量:" + count);
                                break;
                        }
                    }
                }

                keyValuePair.items.AddRange(itemDatas);
            }
        }


        if (isUpdate)
        {
            AccountFileInfo.Instance.SavePlayerData();
            EventManager.Instance.Dispatch(CustomEventType.DaoYouCounUpdate, null);
            isUpdate = false;
        }
    }

    private void EveryDayRefence()
    {
        if (TimeHelper.ClientNow() > AccountFileInfo.Instance.playerData.nextRefence)
        {
            //每天删一次日志
            if (File.Exists(Path.Combine(Application.persistentDataPath, "GameLog.txt")))
            {
                File.Delete(Path.Combine(Application.persistentDataPath, "GameLog.txt"));
            }

            AccountFileInfo.Instance.playerData.todayTotalAds = 0;
            AccountFileInfo.Instance.playerData.nextRefence =
                TimeHelper.GetBaseRefreshTime(TimeHelper.ClientNow());
            AccountFileInfo.Instance.playerData.todayUseExpElixrPanelCount = 0;
            AccountFileInfo.Instance.playerData.todayDivineSensePoint = 0;

            foreach (var playerDataSummonData in AccountFileInfo.Instance.playerData.SummonDatas)
            {
                playerDataSummonData.onePayCount = 0;
                playerDataSummonData.tenPayCount = 0;
                playerDataSummonData.oneFreeCount = 0;
                playerDataSummonData.nextOneFreeTime = 0;
                playerDataSummonData.tenFreeCount = 0;
                playerDataSummonData.nextTenFreeTime = 0;
            }

            AccountFileInfo.Instance.SavePlayerData();
        }
    }

    public async CTask ChangeMap(int mapId, bool isShowUI = true)
    {
        SmallPlacesConfig currentSmallPlacesConfig =
            ConfigComponent.Instance.Get<SmallPlacesConfig>(PlayerManager.Instance.CurrentsmallPlaces.id);
        SmallPlacesConfig smallPlacesConfig = ConfigComponent.Instance.Get<SmallPlacesConfig>(mapId);
        if (smallPlacesConfig.ID == 0)
            return;
        AccountFileInfo.SmallPlacesData lastSmallPlacesData =
            PlayerManager.Instance.GetSmallPlacesData(smallPlacesConfig.ID - 1);
        SmallPlacesConfig lastSmallPlacesConfig =
            ConfigComponent.Instance.Get<SmallPlacesConfig>(smallPlacesConfig.ID - 1);
        if (smallPlacesConfig.ID > 1 && (lastSmallPlacesData == null ||
                                         lastSmallPlacesData.completionEventCount <
                                         lastSmallPlacesConfig.CompletionEventCount))
        {
            return;
        }

        if (lastSmallPlacesConfig.UnlockEnvetid != 0)
        {
            AccountFileInfo.EventList eventList =
                AccountFileInfo.Instance.playerData.completeEvents.FirstOrDefault(ce =>
                    ce.eventID == lastSmallPlacesConfig.UnlockEnvetid);
            if (eventList == null || !eventList.isCompleted)
            {
                return;
            }
        }

        UIManager.Instance.HindCurrAllShowPanel();
        _cTask = CTask.Create();

        AccountFileInfo.SmallPlacesData smallPlacesData =
            PlayerManager.Instance.GetSmallPlacesData(smallPlacesConfig.ID);

        if (smallPlacesData == null)
        {
            smallPlacesData = new AccountFileInfo.SmallPlacesData();
            smallPlacesData.id = smallPlacesConfig.ID;
            AccountFileInfo.Instance.playerData.smallPlacesDatas.Add(smallPlacesData);
        }


        AccountFileInfo.PlacesData currentPlacesData = PlayerManager.Instance.GetPlacesData(smallPlacesConfig.ID);
        if (currentPlacesData == null)
        {
            currentPlacesData = new AccountFileInfo.PlacesData();
            currentPlacesData.id = smallPlacesConfig.PlacesId;
            AccountFileInfo.Instance.playerData.placesDatas.Add(currentPlacesData);
        }

        PlayerManager.Instance.CurrentsmallPlaces = smallPlacesData;

        if (currentSmallPlacesConfig.PlacesId == smallPlacesConfig.PlacesId)
        {
            CombatController.currActiveCombat.ChangeState(CombatController.miniSceneSwitch);
        }
        else
        {
            CombatController.currActiveCombat.ChangeState(CombatController.sceneSwitch);
        }


        await _cTask;
        if (isShowUI)
            UIManager.Instance.ShowLastHindAllShowPanel();
        EventManager.Instance.Dispatch(CustomEventType.ChangeMap, null);
    }

    public void QianKunDaiAward()
    {
        foreach (var playerDataQiankundaiData in AccountFileInfo.Instance.playerData.QiankundaiDatas)
        {
            //重置掉落次数
            QiankundaiConfig qiankundaiConfig =
                ConfigComponent.Instance.Get<QiankundaiConfig>(playerDataQiankundaiData.id);
            if (qiankundaiConfig.dropType != 2 &&
                TimeHelper.ClientNow() >= playerDataQiankundaiData.refenceTime)
            {
                if (qiankundaiConfig.dropPara1 == 1)
                {
                    playerDataQiankundaiData.refenceTime = TimeHelper.ClientNow() + 60 * 60 * 1000;
                }
                else if (qiankundaiConfig.dropPara1 == 2)
                {
                    playerDataQiankundaiData.refenceTime =
                        TimeHelper.GetBaseRefreshTime(TimeHelper.ClientNow());
                }
                else if (qiankundaiConfig.dropPara1 == 3)
                {
                }

                playerDataQiankundaiData.dropCount = 0;
            }


            if (myHero.powerUpConfig.ID >= qiankundaiConfig.dropLevel[0] &&
                myHero.powerUpConfig.ID <= qiankundaiConfig.dropLevel[1])
            {
                if (playerDataQiankundaiData.dropCount < qiankundaiConfig.dropPara2 ||
                    qiankundaiConfig.dropPara2 == -1)
                {
                    playerDataQiankundaiData.dropTime++;
                    if (playerDataQiankundaiData.dropTime >= qiankundaiConfig.dropTypePara)
                    {
                        //发放奖励
                        for (var i = 0; i < qiankundaiConfig.ChoukaID.Length; i++)
                        {
                            List<ItemInfo> itemInfos = DropManager.Instance.Drop(qiankundaiConfig.ChoukaID[i],
                                qiankundaiConfig.DropCount[i]);
                            foreach (var itemInfo in itemInfos)
                            {
                                AccountFileInfo.ItemData itemData =
                                    AccountFileInfo.Instance.playerData.QiankundaiItemDatas.FirstOrDefault(i =>
                                        i.itemId == itemInfo.itemID);
                                if (itemData != null)
                                {
                                    itemData.itemCount += itemInfo.count.Value;
                                }
                                else
                                {
                                    itemData = itemInfo.ToItemData();
                                    AccountFileInfo.Instance.playerData.QiankundaiItemDatas.Add(itemData);
                                }
                            }
                        }

                        playerDataQiankundaiData.dropCount = 0;
                        playerDataQiankundaiData.dropTime = 0;
                    }
                }
            }

            // AccountFileInfo.Instance.SavePlayerData();
        }
    }

    public void CalculateOfflineRewards()
    {
        int exitMiao = (int)((TimeHelper.ClientNow() - AccountFileInfo.Instance.playerData.ExitTime) / 1000);
        if (exitMiao <= 0)
            return;
        if (AccountFileInfo.Instance.playerData.QiankundaiDropTimer <=
            gameConstantConfig.qiankundaiMaxTime &&
            exitMiao > 0)
        {
            int miao = AccountFileInfo.Instance.playerData.QiankundaiDropTimer + exitMiao;
            miao = miao >= gameConstantConfig.qiankundaiMaxTime
                ? gameConstantConfig.qiankundaiMaxTime - AccountFileInfo.Instance.playerData.QiankundaiDropTimer
                : exitMiao;
            AccountFileInfo.Instance.playerData.QiankundaiDropTimer += miao;
            for (int i = 0; i < miao; i++)
            {
                QianKunDaiAward();
            }
        }


        HeroPowerUpConfig heroPowerUpConfig = myHero.powerUpConfig;

        if (AccountFileInfo.Instance.playerData.divineSensePoint < heroPowerUpConfig.ShenshiMax)
        {
            int miao = 0;
            if (AccountFileInfo.Instance.playerData.todayDivineSensePoint <
                gameConstantConfig.shenshiPointRecSPD[0])
            {
                float todayResidueShenShi = gameConstantConfig.shenshiPointRecSPD[0] -
                                            AccountFileInfo.Instance.playerData.todayDivineSensePoint;
                todayResidueShenShi =
                    AccountFileInfo.Instance.playerData.divineSensePoint + todayResidueShenShi >
                    heroPowerUpConfig.ShenshiMax
                        ? heroPowerUpConfig.ShenshiMax - AccountFileInfo.Instance.playerData.divineSensePoint
                        : todayResidueShenShi;

                miao = (int)(todayResidueShenShi / gameConstantConfig.shenshiPointRecSPD[1]);

                miao = miao > exitMiao ? exitMiao : miao;

                float todayResidue = gameConstantConfig.shenshiPointRecSPD[1] * miao;
                todayResidue = todayResidue + AccountFileInfo.Instance.playerData.divineSensePoint >
                               heroPowerUpConfig.ShenshiMax
                    ? heroPowerUpConfig.ShenshiMax - AccountFileInfo.Instance.playerData.divineSensePoint
                    : todayResidue;
                if (todayResidue < 0)
                    todayResidue = 0;
                AccountFileInfo.Instance.playerData.todayDivineSensePoint += todayResidue;
                AccountFileInfo.Instance.playerData.divineSensePoint += todayResidue;
            }

            int residueExitMiao = exitMiao - miao;
            if (residueExitMiao > 0)
            {
                float todaySs2 = gameConstantConfig.shenshiPointRecSPD[2] * residueExitMiao;
                float allShenshi = todaySs2 + AccountFileInfo.Instance.playerData.divineSensePoint;
                todaySs2 = allShenshi > heroPowerUpConfig.ShenshiMax
                    ? heroPowerUpConfig.ShenshiMax - AccountFileInfo.Instance.playerData.divineSensePoint
                    : todaySs2;
                if (todaySs2 < 0)
                    todaySs2 = 0;
                AccountFileInfo.Instance.playerData.divineSensePoint += todaySs2;
            }
        }


        EventManager.Instance.Dispatch(CustomEventType.DivineSensePointChange, null);
        AccountFileInfo.Instance.playerData.ExitTime = 0;
        AccountFileInfo.Instance.SavePlayerData();
    }


    public void AddTestHeroInfo(TestCombatHeroConfig.TestHeroInfoConfig testHeroInfoConfig)
    {
        isTest = true;
        GongFaControl.allSkill.Clear();
        SkillConfig[] allSkillConfig = ConfigComponent.Instance.GetAll<SkillConfig>();
        for (int i = 0; i < allSkillConfig.Length; i++)
        {
            SkillConfig skillConfig = allSkillConfig[i];
            if (skillConfig.level == testHeroInfoConfig.skillStart)
            {
                SkillInfo skillInfo = new SkillInfo(skillConfig.ID, testHeroInfoConfig.skillLevel);
                skillInfo.index = -1;
                GongFaControl.AddSkillInfo(skillInfo);
            }
        }

        AccountFileInfo.HeroData heroData = new AccountFileInfo.HeroData();
        heroData.heroModelId = testHeroInfoConfig.heroID;
        heroData.heroPowerId = testHeroInfoConfig.level;
        myHero = new HeroInfo();
        myHero.InitHero(heroData);
        if (testHeroInfoConfig.skill.Count > 0)
        {
            GongFaControl.allSkill.Clear();
            for (int i = 0; i < testHeroInfoConfig.skill.Count; i++)
            {
                SkillInfo skillInfo = new SkillInfo(testHeroInfoConfig.skill[i], testHeroInfoConfig.skillLevel,
                    testHeroInfoConfig.skillStart);
                skillInfo.index = i;
                GongFaControl.AddSkillInfo(skillInfo);
            }
        }
        else
        {
            SkillInfo[] skillInfos = GongFaControl.allUseSkill;
            for (int i = 0; i < skillInfos.Length; i++)
            {
                if (skillInfos[i] != null)
                {
                    SkillInfo skillInfo = new SkillInfo(skillInfos[i].skillConfig.IDGroup,
                        testHeroInfoConfig.skillLevel,
                        testHeroInfoConfig.skillStart);
                    skillInfo.index = i;
                    GongFaControl.allUseSkill[i] = skillInfo;
                }
            }
        }

        if (testHeroInfoConfig.magicWeaponId.Count > 0)
        {
            int fbLevel = ((testHeroInfoConfig.level - 1) / 10) + 1;
            if (fbLevel <= 0)
            {
                fbLevel = 1;
            }

            for (int i = 0; i < testHeroInfoConfig.magicWeaponId.Count; i++)
            {
                FaBaoInfo faBaoInfo = new FaBaoInfo(testHeroInfoConfig.magicWeaponId[i], fbLevel);
                faBaoInfo.FaBaoData.useIndex = i;
                FaBaoControl.FightFaBao[i] = faBaoInfo;
                FaBaoControl.AddFaBao(faBaoInfo);
            }
        }

        float[] qiangDu = new float[] { 0, 35.7f, 98f, 138.7f, 199.3f, 216f };

        int qiangDuLevelId = Mathf.CeilToInt(testHeroInfoConfig.level / 5f);
        HeroQiangDuAddConfig heroQiangDuAddConfig = ConfigComponent.Instance.Get<HeroQiangDuAddConfig>(qiangDuLevelId);
        int index = Mathf.RoundToInt(heroQiangDuAddConfig.qiangDuZhi) - 1;
        myHero.hp = (EncryptionLong)(myHero.hp.Value * (qiangDu[index] / 100f + 1));
        myHero.attack = (EncryptionLong)(myHero.attack.Value * (qiangDu[index] / 100f + 1));
        myHero.defense = (EncryptionLong)(myHero.defense.Value * (qiangDu[index] / 100f + 1));
        // for (int i = 0; i < 4; i++)
        // {
        //     FaBaoControl.FightFaBao[i] = FaBaoControl.myAllFaBao[i];
        // }
        myHero.hp += testHeroInfoConfig.hp;
        myHero.attack += testHeroInfoConfig.att;
        myHero.defense += testHeroInfoConfig.def;
        myHero.Metal += testHeroInfoConfig.jing;
        myHero.Wood += testHeroInfoConfig.mu;
        myHero.Water += testHeroInfoConfig.shui;
        myHero.Fire += testHeroInfoConfig.huo;
        myHero.Earth += testHeroInfoConfig.tu;
        myHero.TaoismSkillId = 601011;
        myHero.MagicWeaponID.Clear();
        myHero.MagicWeaponID.AddRange(FaBaoControl.FightFaBao);
        // for (int i = 0; i < FaBaoControl.FightFaBao.Length; i++)
        // {
        //     FaBaoInfo faBaoInfo = FaBaoControl.FightFaBao[i];
        //     if (faBaoInfo != null)
        //     {
        //         foreach (var VARIABLE in faBaoInfo.attriButedIC)
        //         {
        //             switch (VARIABLE.Key)
        //             {
        //                 case 1:
        //                     myHero.hp += VARIABLE.Value;
        //                     break;
        //                 case 2:
        //                     myHero.defense += VARIABLE.Value;
        //                     break;
        //                 case 3:
        //                     myHero.attack += VARIABLE.Value;
        //                     break;
        //             }
        //         }
        //     }
        // }
    }


    /// <summary>
    /// 保存英雄数据
    /// </summary>
    /// <param name="heroInfo"></param>
    public void SaveHeroData(HeroInfo heroInfo)
    {
        AccountFileInfo.Instance.playerData.heroData = heroInfo.heroData;
        AccountFileInfo.Instance.SavePlayerData();
    }

    /// <summary>
    /// 时间（秒）转换位小时分钟秒
    /// </summary>
    /// <param name="miao"></param>
    /// <returns></returns>
    public static string TimeToHSM(long miao)
    {
        long fen = miao / 60;
        miao = miao % 60;
        long xiaoShi = fen / 60;
        long tian = xiaoShi / 24;
        xiaoShi = xiaoShi % 24;
        fen = fen % 60;
        if (tian > 0)
        {
            return $"{tian}天{xiaoShi}小時";
        }
        else
        {
            if (xiaoShi <= 0 && fen <= 59)
            {
                return $"{fen}分{miao}秒";
            }
            else
            {
                return $"{xiaoShi}小時{fen}分";
            }
        }
    }
}