NLDClient-yudde/ProjectNLD/Assets/Code/Scripts/Gameplay/Level/State/LevelStateBattle.cs

using AOT.PostProcess.BlackArea;
using Code.Scripts.Gameplay.Fight.Evacuate;
using Framework;
using Gameplay.Area;
using Gameplay.Area.Ready;
using Gameplay.Buff;
using Gameplay.Bullet;
using Gameplay.Character;
using Gameplay.Fight.Capture;
using Gameplay.Guide;
using Gameplay.Pause;
using Gameplay.Skill;
using Gameplay.Unit;
using Gameplay.Unit.Data;
using Gameplay.Vehicle.Impl;
using LTGame;
using PhxhSDK;
using TGS;
using UnityEngine;
using Utils.Bounds;

namespace Gameplay.Level
{
    public class LevelStateBattle : BaseLevelState
    {

        public LevelStateBattle(Level level) : base(level, ELevelState.Battle)
        {
        }

        private bool _canUpdate;
        private bool _oldPauseStatus;

        protected override void _OnEnter(NBaseState exitState,
            object param)
        {
            base._OnEnter(exitState, param);

            if (exitState.id == ELevelState.Prepare)
            {
                _SetPlayerControl();

                GameUnitManager.instance.EnterBattle();
                // 这个必须在GameUnitManager.instance.EnterBattle()之后
                // 因为他会给unit增加buff
                BoundsManager.instance.Init();
                _level.LevelTime = 0;
            }

            _level.isInBattle = true;

            EventManager.Instance.Send(EventManager.EventName.LevelBattleBegin);

            EventManager.Instance.Register<GameUnit>(EventManager.EventName.INFIGHT_UI_CLICK_UNIT, _OnUIClickUnit);

            var cameraInfo = _level.Map.MapData.cameraMarginInfo;
            CameraManager.Instance.MainCamera.GetComponent<CameraController>().rightMargin = cameraInfo.rightMarginInFight;
            CameraManager.Instance.MainCamera.GetComponent<CameraController>().leftMargin = cameraInfo.leftMarginInFight;
            CameraManager.Instance.MainCamera.GetComponent<CameraController>().topMargin = cameraInfo.topMarginInFight;
            CameraManager.Instance.MainCamera.GetComponent<CameraController>().bottomMargin = cameraInfo.bottomMarginInFight;

            CameraManager.Instance.MainCamera.GetComponent<CameraController>().AdjustSelf();

            LevelManager.Instance.CurrentLevel.SetSpeed(ELevelSpeed.DEFAULT_SPEED);
            EventManager.Instance.Send(EventManager.EventName.FightStoryHide);

            _WaitBlackOut();
        }

        protected override void _OnRunning()
        {
            base._OnRunning();

            PauseManager.instance.LogicUpdate(deltaTime);
            SkillManager.instance.LogicUpdate(deltaTime);
            if (AreaManager.instance.isInSkillPreview) return;

            _level.LevelTime += deltaTime;
            BulletManager.instance.LogicUpdate(deltaTime);
            GameUnitManager.instance.LogicUpdate(deltaTime);
            BuffManager.instance.LogicUpdate(deltaTime);
            AreaManager.instance.LogicUpdate(deltaTime);
            CaptureManager.instance.LogicUpdate(deltaTime);
            BlackAreaManager.instance.LogicUpdate(deltaTime);
            EvacuateManager.instance.LogicUpdate();
            EventManager.Instance.Send(EventManager.EventName.LevelTimeIncrease, deltaTime);

            _level.fightStoryManager.LogicUpdate(deltaTime);
            if (_level.fightStoryManager.CheckCanTrigger())
            {
                isFinished = true;
                nextState = ELevelState.BattleStory;
            }
        }

        protected override void _OnExit(NBaseState exitState,
            object param)
        {
            base._OnExit(exitState, param);

            _level.isInBattle = false;
            EventManager.Instance.Unregister<GameUnit>(EventManager.EventName.INFIGHT_UI_CLICK_UNIT, _OnUIClickUnit);
        }

        private void _OnUIClickUnit(GameUnit clickUnit)
        {
            if (AreaManager.instance.readyAreaManager.isShow)
            {
                _HandleOnReadyShow(clickUnit);
            }
            else
            {
                _HandleOnReadyNotShow(clickUnit);
            }
            
        }
        private void _HandleOnReadyShow(GameUnit clickUnit)
        {
            if (clickUnit == AreaManager.instance.readyAreaManager.readyUnit)
            {
                return;
            }
            // 关闭准备区域
            AreaManager.instance.readyAreaManager.HideReadyArea();
            _level.SetPause(_oldPauseStatus);
            
            _HandleOnReadyNotShow(clickUnit);
        }
        
        private void _HandleOnReadyNotShow(GameUnit clickUnit)
        {
            if (clickUnit.statusData.isOnVehicle)
            {
                _level.UnSelectUnit();
                _HandleOnVehicle(clickUnit);
            }
            else
            {
                _HandleNotOnVehicle(clickUnit);
            }
        }

        private void _HandleOnVehicle(GameUnit clickUnit)
        {
            if (clickUnit is Character.Character unitCharacter)
            {
                var belongVehicle = unitCharacter.runtimeData.belongVehicle;
                if (belongVehicle == null)
                {
                    DebugUtil.LogError("单位没有载具");
                    return;
                }
                
                // 居中镜头
                CameraManager.Instance.MainCamera.GetComponent<CameraController>().KeepCenter(belongVehicle.transform.position);
                AreaManager.instance.readyAreaManager.ShowReadyArea(EReadyAreaStatus.AroundVehicle, clickUnit);

                _oldPauseStatus = _level.IsPause();
                _level.SetPause(true);
            }
            else
            {
                DebugUtil.LogError("在载具上的单位必须是角色");
            }
        }

        private void _HandleNotOnVehicle(GameUnit clickUnit)
        {
            // 居中镜头
            CameraManager.Instance.MainCamera.GetComponent<CameraController>().KeepCenter(clickUnit.transform.position);

            if (_level.selectUnit == clickUnit)
            {
                _TryEnterSkillPreRelease(clickUnit);
            }
            else
            {
                _level.SelectUnit(clickUnit);
            }
        }

        private void _TryEnterSkillPreRelease(GameUnit unit)
        {
            if (unit.statusData.isRetreat)
            {
                UITipsManager.ShowTips("单位处于撤退状态,无法释放技能");
                return;
            }
            if (unit.statusData.isDead)
            {
                UITipsManager.ShowTips("单位已死亡,无法释放技能");
                return;
            }

            var unitSkillManager = SkillManager.instance.GetUnitSkillManager(unit);
            if (unitSkillManager == null)
            {
                UITipsManager.ShowTips("单位无技能管理器");
                return;
            }

            var positiveSkill = unitSkillManager.positiveSkill;
            if (positiveSkill == null)
            {
                UITipsManager.ShowTips("单位无主动技能");
                return;
            }

            if (positiveSkill.canRelease)
            {
                DebugUtil.LogG("进入技能释放状态");
                AreaManager.instance.skillAreaSelector2.EnterPreview(positiveSkill);
            }
            else
            {
                UITipsManager.ShowTips("技能未准备好");
            }
        }

        private void _SetPlayerControl()
        {
            if (_level.fightStoryManager.hasStory
                && _level.fightStoryManager.fightStoryData.forceUserTeam)
            {
                var teamData = _level.fightStoryManager.fightStoryData.playerTeamData;
                if (teamData == null)
                {
                    return;
                }

                for (int i = 0; i < teamData.memberList.Count; i++)
                {
                    var memberInfo = teamData.memberList[i];
                    if (memberInfo == null)
                    {
                        continue;
                    }
                    if (memberInfo.unitLocalId == 0)
                    {
                        continue;
                    }
                    var unit = GameUnitManager.instance.infightUnits.SearchByLocalId(memberInfo.unitLocalId);
                    if (unit == null)
                    {
                        continue;
                    }
                    unit.commonData.canControl = true;
                }
            }
        }

        protected override void _OnClick(Vector2 screenPosition)
        {

            var clickCellIndex = GroundHitHelper.CalcHitCellIndex(screenPosition, _level.Map.TerrainGridSystem);
            if (clickCellIndex < 0)
            {
                if (GuideManager.Instance.IsGuiding && GuideManager.Instance.IsControlFloor)
                    return;

                return;
            }

            if (AreaManager.instance.isInSkillPreview)
            {
                EventManager.Instance.Send(EventManager.EventName.INFIGHT_UI_SKILL_CLICK_SCREEN, clickCellIndex);
                return;
            }

            CheckCellClick(_level.Map.TerrainGridSystem, clickCellIndex, 0);
        }

        protected override void _OnCellClick(TerrainGridSystem tgs,
            int cellIndex,
            int buttonIndex)
        {
            if (InputManager.Instance.HandledThisFrame())
            {
                return;
            }

            if (AreaManager.instance.readyAreaManager.isShow)
            {
                // 上阵模式
                _HandleUpUnit(cellIndex);
                return;
            }

            var selectUnit = _level.selectUnit;
            if (selectUnit == null)
            {
                // 没有选中单位,进行选中操作
                _TrySelect(cellIndex);
            }
            else
            {
                // 有选中单位,进行移动操作
                _TryMove(cellIndex);
            }
        }

        private void _HandleUpUnit(int cellIndex)
        {
            // 不是准备区域
            _GetOutVehicle(cellIndex);
        }

        private void _TryMove(int cellIndex)
        {
            var selectUnit = _level.selectUnit;
            if (selectUnit == null)
            {
                DebugUtil.LogError("没有选中单位");
                return;
            }

            if (selectUnit.statusData.isRetreat
                && selectUnit.transData.cellIndex == cellIndex)
            {
                // 取消选中
                _level.UnSelectUnit();
                return;
            }

            if (!AreaManager.instance.moveAreaView.CheckIsInArea(cellIndex))
            {
                // 不在区域内,提示操作无效
                UITipsManager.ShowTips("无法移动到该位置");
                return;
            }

            selectUnit.MoveTo(cellIndex, true);
            _CheckAfterMove(cellIndex);

            _level.UnSelectUnit();
        }

        private void _CheckAfterMove(int cellIndex)
        {
            var selectUnit = _level.selectUnit;
            if (selectUnit.gameunitType != EGameUnitType.Character
                && selectUnit.gameunitType != EGameUnitType.Vehicle) return;
            selectUnit.controlData.markVehicle = null;
            selectUnit.controlData.markEnemy = null;

            if (selectUnit.transData.cellIndex == cellIndex) return;

            var units = AreaManager.instance.GetUnitsByCellIndex(cellIndex);
            for (int i = 0; i < units.Count; i++)
            {
                var unit = units[i];
                if (unit.commonData.troopId == selectUnit.commonData.troopId
                    && unit.gameunitType == EGameUnitType.Vehicle)
                {
                    if (selectUnit.gameunitType == EGameUnitType.Vehicle)
                    {
                        // 载具不能上载具
                        return;
                    }
                    // 点击的己方单位, 这里必然是载具
                    var vehicle = unit as NormalVehicle;
                    if (vehicle == null)
                    {
                        DebugUtil.LogError("不是载具");
                        return;
                    }
                    if (vehicle.CheckCanUp(selectUnit))
                    {
                        selectUnit.controlData.markVehicle = vehicle;
                    }
                    return;
                }
                // 如果是敌人, 则设置敌人目标
                if (unit.statusData.CheckCanBeTarget(selectUnit, -1))
                {
                    selectUnit.controlData.markEnemy = unit;
                    selectUnit.controlData.forceUpdateTarget = true;
                    return;
                }
            }

        }

        private void _TrySelect(int cellIndex)
        {
            var unitList = AreaManager.instance.GetUnitsByCellIndex(cellIndex);
            if (unitList.Count <= 0)
            {
                // 没有单位,不做任何操作
                return;
            }
            for (int i = 0; i < unitList.Count; i++)
            {
                var unit = unitList[i];
                if (unit.commonData.canSelect)
                {
                    // 只选中可控制单位
                    _level.SelectUnit(unit);
                    if (unit.debugShowInfo.cacheConfigId != 0)
                    {
                        EventManager.Instance.Send(EventManager.EventName.INFIGHT_AUDIO_SELECT_UNIT, unit.debugShowInfo.cacheConfigId);
                    }
                    return;
                }
            }
        }

        private void _GetOutVehicle(int cellIndex)
        {
            var character = AreaManager.instance.readyAreaManager.readyUnit as Character.Character;
            if (character == null)
            {
                DebugUtil.LogError("不是角色");
                return;
            }
            if (character.fullFSM.currentState.id != EFullState.OnVehicle)
            {
                DebugUtil.LogError("不在载具上");
                return;
            }
            if (AreaManager.instance.readyAreaManager.CheckIsInReadyArea(cellIndex))
            {
                DebugUtil.Log("在准备区域内, 下车");
                character.transData.disableEvent = true;
                character.transData.pos =
                    LevelManager.Instance.CurrentLevel.Map.TGSCellIndex2WorldPosition(cellIndex);
                character.transData.disableEvent = false;
                character.DownVehicle();
            }
            else
            {
                DebugUtil.Log("不在准备区域内, 关闭准备区域");
                AreaManager.instance.readyAreaManager.HideReadyArea();
            }
            
            _level.SetPause(_oldPauseStatus);
        }
        
    }
}