XiuXianGame/Assets/Scripts/GameLogic/Combat/CombatTool/CombatController.cs

using System;
using Common.Utility.CombatEvent;
using Common.Utility.CombatTimer;
using Core.Audio;
using Core.Event.Event;
using Core.State;
using Core.Utility;
using Excel2Json;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Combat.CombatGuide;
using GameLogic.Combat.CombatState;
using GameLogic.Combat.CombatTool.CombatReport;
using GameLogic.Combat.CombatType;
using GameLogic.Combat.Hero;
using GameLogic.Combat.Hero.HeroGPU;
using GameLogic.CombatScenesTool;
using UnityEngine;
using Utility.CustomizeTimeLogic.FxLogic.TimeLineEvent;
using Utility.UITool;
using UTool.CustomizeTimeLogic.FxLogic.TimeLineEventinterface;
using UTool.CustomizeTimeLogic.FxLogic.TimeLineEventLogic;

namespace GameLogic.Combat.CombatTool
{
    public class CombatController : ITimeLineAudio, IDisposable
    {
        public static string idle = "idle";
        public static string update = "update";
        public static string fight = "fight";
        public static string sceneSwitch = "sceneSwitch";

        public static CombatController currActiveCombat;
        public CombatHeroController CombatHeroController;
        public CombatCameraControllder CombatCameraControllder;
        public CombatTypeBasic CombatTypeBasic;
        protected StateControl stateControl;
        public CombatSenceController CombatSenceController;

        public CombatDataController CombatDataController;
        public GameTimeLineParticleFactory GameTimeLineParticleFactory;
        public MagicWeaponCombatSence MagicWeaponCombatSence;
        // public RandomEventController RandomEventController;

        public bool isUpdate;

        /// <summary>
        /// 涨停游戏英雄AI行为
        /// </summary>
        public bool isStopAi;

        public float speed = 1;

        private bool _isFullUIShow;

        public bool IsGameOver;
        public bool IsFightState;

        public System.Action<bool> combatFinish;
        public float combatTime;

        public CombatHeroEntity playerHeroEntity;
        public bool isWin;
     
        public CombatStateBasic CurrState
        {
            get { return stateControl.CurrIState as CombatStateBasic; }
        }


        public async CTask InitCombat(StartCombatInfo startCombatInfo)
        {
            combatTime = 0;
            isWin = false;
            IsGameOver = false;
            CombatReportManager.Instance.Clear();
            // CombatGuideManager.Instance.Init();
            TimeLineSingletonEventManager.Instance.AddTimeLineBasic(this);
            GameTimeLineParticleFactory = new GameTimeLineParticleFactory();
            TimeLineFxParticleTool.Instance.Init(GameTimeLineParticleFactory);
            // RandomEventController = new RandomEventController();
            currActiveCombat = this;
            if (stateControl == null)
            {
                stateControl = new StateControl();
                stateControl.AddState("idle", new CombatIdleState(this));
                stateControl.AddState("update", new CombatUpdateState(this));
                stateControl.AddState("fight", new CombatFightState(this));
                stateControl.AddState("combatfinish", new CombatFinishState(this));
                stateControl.AddState(sceneSwitch, new CombatSceneSwitchState(this));

             
                if (CombatSenceController == null)
                {
                    CombatSenceController = new CombatSenceController();
                    await CombatSenceController.InitScenes("LevelBattle02");
                }

                if (CombatDataController == null)
                {
                    CombatDataController = new CombatDataController();
                    await CombatDataController.Init();
                }
            }
            MagicWeaponCombatSence = new MagicWeaponCombatSence();
            MagicWeaponCombatSence.Init();
            Camera camera = Camera.main;
            CombatCameraControllder = new CombatCameraControllder();
            CombatCameraControllder.Init(this, camera);
            CombatHeroController = new CombatHeroController();
            await CombatHeroController.Init(this);
            switch (startCombatInfo.CombatType)
            {
                case CombatType.CombatType.TestCombat:
                    CombatTypeBasic = new TestCombatType();
                    break;
                case CombatType.CombatType.LevelBattle:
                    CombatTypeBasic = new LevelBattleCombatType();
                    break;
            }

            CombatTypeBasic.Init(this, startCombatInfo);
            await CombatTypeBasic.StartGame();

            ChangeState("idle");
            isUpdate = true; 
            EventManager.Instance.AddEventListener(CustomEventType.RefreshFull, RefreshFull);
            CombatEventManager.Instance.Dispatch(CombatEventType.GameStart, null);
        }

    

        private void RefreshFull(IEventData eventData)
        {
            RefreshFullEventData data = (RefreshFullEventData)eventData;
            _isFullUIShow = data.isFullShow;
        }


        public void ChangeState(string name)
        {
            stateControl.ChangeState(name);
        }
      
        public void Update(float t)
        {
            CombatGestureController.Instance.Update();
            if (!isUpdate || _isFullUIShow)
            {
                return;
            }

            
            if (Input.GetKeyDown(KeyCode.A))
            {
               ChangeState("sceneSwitch");
            }
            if (Input.GetKeyDown(KeyCode.D))
            {
               CombatSenceController.Flight(2, -90, 10);
            }
         
            
            t *= speed;
            if (!IsGameOver)
            {
                combatTime += t;
            }

            stateControl.Update(t);
            CombatTypeBasic?.Update(t);
            MagicWeaponCombatSence?.Update(t);
            CombatSenceController?.Update(t);
            CombatTimerManager.Instance.ComabtUpdate(t);
            CombatGuideManager.Instance.Update();

            LateUpdate(t);
            if (playerHeroEntity != null)
            {
                if (Input.GetMouseButtonUp(0))
                {
                    Vector3 pos = Input.mousePosition;
                    Ray ray = CombatCameraControllder.Camera.ScreenPointToRay(pos);
                    bool isOk = Physics.Raycast(ray, out RaycastHit hit, 30, LayerMask.GetMask("hero"));
                    if (isOk)
                    {
                        HeroEntityMono heroEntityMono=  hit.transform.gameObject.GetComponent<HeroEntityMono>();
                        if (heroEntityMono != null &&
                            heroEntityMono.combatHeroEntity.IsEnemy != playerHeroEntity.IsEnemy)
                        {
                            playerHeroEntity.CombatAIBasic.currFocusTarget=heroEntityMono.combatHeroEntity;
                        }
                    }
                }
            }
          
           
        }

        private void TriggerCombat()
        {
        }

        public void LateUpdate(float t)
        {
            CombatHeroController.LateUpdate(t);
            CombatReportManager.Instance.Update();
        }

        public async CTask<AudioSourcePool> PlayAudio(string audioName, bool isLoop)
        {
            return await AudioManager.Instance.PlayAudio(audioName, isLoop);
        }

        public void GameOver(bool isWin)
        {
            this.isWin = isWin;
            IsGameOver = true;
            ChangeState("combatfinish");
            combatFinish?.Invoke(isWin);
        }

        public void DisposeOneCombatInfo()
        {
            CombatReportManager.Instance.Clear();
            MagicWeaponCombatSence.CloseSecene();
            CombatEventManager.Instance.Dispose();
        }

        
        public void Dispose()
        {
            TimeLineSingletonEventManager.Instance.RemoveTimeLineBasic(this);
            CombatTypeBasic?.Dispose();
            CombatHeroController?.Dispose();
            CombatCameraControllder?.Dispose();
            CombatSenceController?.Dispose();
            GameTimeLineParticleFactory?.Dispose();
            EventManager.Instance.RemoveAllEventListener(CustomEventType.RefreshFull);
        }
    }
}