XiuXianGame/Assets/Scripts/GameUI/GameApplction.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Core.AssetLoadTool.Asset;
using Core.Audio;
using Core.Language;
using Core.Utility;
using Excel2Json;
using Fort23.Core;
using Fort23.Mono;
// using Fort23.Mono.UpdateAsset;
using Fort23.UTool;
using GameLogic.Combat;
using GameLogic.Combat.CombatTool;
using GameLogic.Combat.CombatType;
using GameLogic.CombatScenesTool;
using GameLogic.Hero;
using GameLogic.NetworkClient;
using GameLogic.Player;
using GameUI;
using NetCore.Protocol.MemoryPack;
using ThirdParty;
using ThirdParty.DownloadSystem;
#if UNITY_EDITOR
using UnityEditor;
#endif
using UnityEngine;
using UnityEngine.UI;
using Utility.CTween;
using Utility.UITool;


public class GameApplction : IGameStart, ILogSend
{
    public static GameApplction gameApplction;
    public GameRuntimeConfig gameRuntimeConfig;
    public ShaderVariantCollection ShaderVariantCollection;
    public BundleLoadType BundleLoadType;
    public string h5Url;
    private Entity _root;

    private Entity _scene;

    // public bool isTest;
    public int levelBattleId = 1;

    private GameStartUIPanel gameStartUIPanel;
    private System.Action LoadFinish;

    private static string LogPath =>
        Path.Combine(Application.persistentDataPath, "GameLog.txt");

    private static readonly StringBuilder _cache = new StringBuilder();

    public async void StartGame(LoadType LoadType, string h5Url, GameStartUIPanel gameStartUIPanel,
        System.Action LoadFinish)
    {
        Debug.Log("开始游戏逻辑");
        HotSyncContent.DownloadUI = gameStartUIPanel;
        this.LoadFinish = LoadFinish;
        gameApplction = this;
        Debug.Log("开始游戏逻辑");
        LogTool.LogSend = this;
        Crasheye.SendScriptException("测试错误", "测试错误", "ZH");
        Crasheye.SetRegisterLogFunction(UnityLogic);
        this.gameStartUIPanel = gameStartUIPanel;
        gameStartUIPanel.ShowMassge("开始加载资源");
        gameStartUIPanel.SetSlider(0);
        BundleLoadType = (BundleLoadType)LoadType;
        GameObject gameObject = new GameObject("app");
        gameObject.AddComponent<GameApplctionMono>();
        GameAssetUpdatePanel gameAssetUpdatePanel = new GameAssetUpdatePanel();
        gameAssetUpdatePanel.StartUpdateAsset(AssetUpdateFinish);
    }

    private LoginMainPanel _mainPanel;

    private async void AssetUpdateFinish()
    {
        Debug.Log("finish AssetUpdateFinish");
        await InitGameApplication();
        _mainPanel = await LoginMainPanel.OpenPanel();
        LoadFinish?.Invoke();
        UIManager.Instance.Canvas.gameObject.SetActive(true);
        gameStartUIPanel = _mainPanel.gameStartUIPanel;
        await Login();
        // DBManager.Instance.SetUserID(AccountFileInfo.Instance.playerData.playerId);
        Debug.Log("初始化完成");
    }


    private async CTask InitGameApplication()
    {
        _scene = new Scene();
        _root = new Entity();
        _root.Parent = _scene;

        _root.AddComponent<TimerComponent>();
        _root.AddComponent<CoroutineLockComponent>();

        gameStartUIPanel.ClearSlider();
        gameStartUIPanel.ShowMassge("loadBundle");
        gameStartUIPanel.SetSliderMaxValue(1);
        gameStartUIPanel.SetSlider(0.15f);
        AssetBundleLoadManager.Instance.BundleLoadType = BundleLoadType;
        AssetBundleLoadManager.Instance.h5Url = h5Url;
        await AssetBundleLoadManager.Instance.InitAssetsManager(null);
#if !UNITY_EDITOR
        AssetBundleLoadManager.Instance.AddBundleTask("fb010shader", delegate(BundleLoadBasic basic, object o)
        {
            if (basic.currBundle != null)
            {
                basic.currBundle.LoadAllAssets<Shader>();
                Shader.WarmupAllShadersWait();
            }
        }, null);
#endif
        gameStartUIPanel.ShowMassge("loadConfig");
        gameStartUIPanel.SetSlider(0.25f);

        AssetHandle gameRuntimeAssetHandle =
            await AssetBundleLoadManager.Instance.LoadAssetAsyncTask<GameRuntimeConfig>("GameRuntimeConfig.asset");
        gameRuntimeConfig = gameRuntimeAssetHandle.AssetObject<GameRuntimeConfig>();

        await ConfigComponent.Instance.Preload();
        await AnimationCurveManager.Instance.Init();
        UGUIPackLoad uguiPackLoad = new UGUIPackLoad();
        UGUIPackManager.Instance.SetIUGUIPackLoad(uguiPackLoad);
        await uguiPackLoad.InitPack();
        gameStartUIPanel.ShowMassge("loadLanguage");
        gameStartUIPanel.SetSlider(0.45f);
        await LanguageManager.Instance.InitManager();
        _root.AddComponent<StaticUpdater>();
        _root.AddComponent<UIManager, Transform>(null);
        ULockManager.Instance.gameRuntimeConfig = gameRuntimeConfig;
        gameStartUIPanel.ShowMassge("loadUI");
        gameStartUIPanel.SetSlider(0.55f);

        await AudioManager.Instance.InitMainAudio();

        await UIManager.Instance.InitUI();
        CustomTweenManager.Init();
        RedDotManager.Instance.Init();
    }

    private async CTask Login()
    {
#if UNITY_ANDROID && Taptap
        //登录
        CTask<bool> callback = CTask<bool>.Create();
        LoginPanel.OpenPanel(callback);
        await callback;
#else
        AccountFileInfo.Instance.LoadPlayerData();
#endif

        await TimeHelper.InitNetworkTime();
        Dictionary<string, object> dict = new Dictionary<string, object>();
        DBManager.Instance.CustomEvent("StartGame", dict);


        EventManager.Instance.RemoveEventListener(CustomEventType.DialoguePanelOpen, DialoguePanelOpenEvent);
        EventManager.Instance.AddEventListener(CustomEventType.DialoguePanelOpen, DialoguePanelOpenEvent);


        PlayerManager.Instance.Init();
        ShopManger.Instance.CustomInit();
        EventSystemManager.Instance.CustomInit();

        await ShowItemMoveToTargetPanel.OpenShowItemMoveToTargetPanel();
        PlayerManager.Instance.AddSentimentData(1);
        foreach (var playerDataAllSkillData in AccountFileInfo.Instance.playerData.AllSkillDatas)
        {
            SkillInfo skillInfo = new SkillInfo(playerDataAllSkillData);
            skillInfo.index = playerDataAllSkillData.useIndex;
            PlayerManager.Instance.GongFaControl.AddSkillInfo(skillInfo);
        }

        foreach (var playerDataAllSkillData in AccountFileInfo.Instance.playerData.AllFaBaoDatas)
        {
            FaBaoInfo faBaoInfo = new FaBaoInfo(playerDataAllSkillData);
            PlayerManager.Instance.FaBaoControl.AddFaBao(faBaoInfo);
        }

        // for (int i = 1; i < 4; i++)
        // {
        //     PlayerManager.Instance.FaBaoControl.FightFaBao[i] = PlayerManager.Instance.FaBaoControl.myAllFaBao[i];
        // }
        // PlayerManager.Instance.InitTestHero();


        await CombatDrive.Instance.Init();
        StartCombatInfo startCombatInfo = new StartCombatInfo();
        startCombatInfo.CombatType = CombatType.LevelBattle;
#if UNITY_EDITOR
        TestCombatHeroConfig testCombatHeroConfig = GameObject.FindObjectOfType<TestCombatHeroConfig>();
        if (testCombatHeroConfig != null)
        {
            startCombatInfo.CombatType = CombatType.TestCombat;
            TestCombatHeroConfig.TestHeroInfoConfig testHeroInfoConfig = testCombatHeroConfig.myHeroInfo[0];
            PlayerManager.Instance.AddTestHeroInfo(testHeroInfoConfig);
        }
#endif

        // startCombatInfo.levelBattleId = AccountFileInfo.Instance.playerData.levelBattle;
        CombatDrive.Instance.AddCombatController(new CombatController());
        gameStartUIPanel.ShowMassge("loadCombat");
        gameStartUIPanel.SetSlider(0.95f);
        var eventList = EventSystemManager.Instance.AddEvent(10001);

        if (eventList != null)
        {
            AccountFileInfo.Instance.playerData.eventList.Add(eventList);
            AccountFileInfo.Instance.SavePlayerData();
        }

        EventSystemManager.Instance.UpdateZuizhongEventData();


        // if (PlayerGuideManager.Instance.GuideIsCanDo(1))
        // {
        //     await MarskPanel.OpenPanel(255);
        // }

        await CombatDrive.Instance.StartCombat(startCombatInfo);
        PlayerManager.Instance.GongFaControl.SaveUseSkill();
        PlayerManager.Instance.GongFaControl.SetTaoismSkillIndex(AccountFileInfo.Instance.playerData.heroData
            .TaoismSkillId);

        if (startCombatInfo.CombatType != CombatType.TestCombat)
        {
            MainPanel mainPanel = await MainPanel.OpenPanel();
            if (!AccountFileInfo.Instance.playerData.isTiggerPlot && PlayerGuideManager.Instance.GuideIsCanDo(1))
            {
                mainPanel.GObjectPoolInterface.SetActive(false);
                AppBarPanel.ClosePanel();
            }
        }


        gameStartUIPanel.ShowMassge("loadFinish");
        gameStartUIPanel.SetSlider(1f);
        LoginMainPanel.ClsoePanel();

        XinShouCombat();
    }

    private void DialoguePanelOpenEvent(IEventData e)
    {
        LoginMainPanel.ClsoePanel();
    }

    public async void XinShouCombat()
    {
        if (PlayerGuideManager.Instance.GuideIsCanDo(1))
        {
            AccountFileInfo.EventList eventList2 = EventSystemManager.Instance.AddEvent(9999);
            await EventSystemManager.Instance.TriggerEvent(eventList2,
                uiOpenOverCallBack: () => { });

            CTask cTask = CTask.Create();
            await CombatDrive.Instance.LoadLevelBattleCombat(10001, false, -1,
                delegate(bool isWin)
                {
                    LogTool.Log("战斗完成" + isWin);
                    cTask.SetResult();
                });

            await cTask;

            AccountFileInfo.EventList eventList1 = EventSystemManager.Instance.AddEvent(10000);
            MainPanel mainPanel = UIManager.Instance.GetComponent<MainPanel>();
            mainPanel.GObjectPoolInterface.SetActive(true);
            await EventSystemManager.Instance.TriggerEvent(eventList1);

            AccountFileInfo.Instance.SavePlayerData();


            AccountFileInfo.Instance.playerData.isTiggerPlot = true;

            // AlterNamePanel.OpenPanel();
            // PlayerGuideManager.Instance.NextGuide();
            mainPanel.GetFocus();
        }
        else
        {
            LoginMainPanel.ClsoePanel();
        }
    }

    public void SendError(string massge)
    {
        string line = $"[{DateTime.Now:yyyy-MM-dd HH:mm:ss}] [{LogType.Error}] {massge}\n";

        line += massge + "\n";

        _cache.Append(line);

        // 每 50 条或 100KB 刷一次盘
        if (_cache.Length > 100 * 1024 || GetLineCount(_cache.ToString()) > 50)
            Flush();
        Crasheye.SendScriptException(massge, massge, "");
        // CrashSightAgent.ReportException(LogType.Error.ToString(), massge, massge);
    }

    private void Flush()
    {
        if (_cache.Length == 0) return;
        try
        {
            File.AppendAllText(LogPath, _cache.ToString());
            _cache.Clear();
        }
        catch
        {
            /* 磁盘满/权限问题直接丢弃 */
        }
    }

    public void OnApplicationQuit() => Flush();

    public void SendException(Exception e)
    {
        _cache.AppendLine($"{e.Message} {e.StackTrace}");
        Flush();
        Crasheye.SendScriptException(e);
    }

    public void UnityLogic(string logString, string stackTrace, LogType type)
    {
        if (type == LogType.Error || type == LogType.Exception)
        {
            Crasheye.SendScriptException(logString, stackTrace, "");
        }
    }

    private int GetLineCount(string s) => s.Length - s.Replace("\n", "").Length;
}