XiuXianGame/Assets/Scripts/GameLogic/Combat/Hero/CombatHeroAi.cs

using Common.Utility.CombatEvent;
using Core.State;
using Fort23.Core;
using GameLogic.Combat.CombatTool;
using GameLogic.Combat.Hero.State;
using GameLogic.Combat.Hero.SubStatus;
using UnityEngine;

namespace GameLogic.Combat.Hero
{
    public class CombatHeroAi : CombatAIBasic
    {
        // public NavMeshObstacle NavMeshObstacle;
        protected CombatHeroEntity _combatHeroEntity
        {
            get { return _showBaiscEntity as CombatHeroEntity; }
        }

        protected float _r = 5;
        public bool isAlert;


        /// <summary>
        /// 当前聚焦的目标
        /// </summary>
        public override IHero currFocusTarget
        {
            get { return _currFocusTarget; }
            set
            {
                CombatHeroTargetAlterEventData combatHeroTargetAlterEventData = CombatHeroTargetAlterEventData.Create();
                combatHeroTargetAlterEventData.combatHeroEntity = _combatHeroEntity;
                combatHeroTargetAlterEventData.targetCombatHeroEntity = value;
                combatHeroTargetAlterEventData.lasetCombatHeroEntity = _currFocusTarget;
                CombatEventManager.Instance.Dispatch(CombatEventType.TargetAlter, combatHeroTargetAlterEventData);
                _currFocusTarget = value;
            }
        }


        private BetterList<GameObject> _areaList = new BetterList<GameObject>();
        private BetterList<GameObject> _HindAreaList = new BetterList<GameObject>();
        private float _t;


        public GameObject[] AreaList
        {
            get { return _areaList.ToArray(); }
        }

        protected override void ProInit()
        {
            CombatEventManager.Instance.AddEventListener(CombatEventType.AlertTrigger, AlertTrigger);
        }


        protected void AlertTrigger(IEventData iEventData)
        {
            AlertTriggerEventData alertTriggerEventData = iEventData as AlertTriggerEventData;
            if (alertTriggerEventData.combatHeroEntity == _combatHeroEntity)
            {
                if (alertTriggerEventData.isTrigger && !_areaList.Contains(alertTriggerEventData.triggerObject))
                {
                    _areaList.Add(alertTriggerEventData.triggerObject);
                }
                else if (!alertTriggerEventData.isTrigger)
                {
                    _areaList.Remove(alertTriggerEventData.triggerObject);
                    _HindAreaList.Remove(alertTriggerEventData.triggerObject);
                }
            }
        }

        protected override void ProInitState()
        {
            stateControl.AddState(CombatHeroStateType.idle, new CombatHeroIdleState(_combatHeroEntity));
            stateControl.AddState(CombatHeroStateType.move, new CombatHeroMoveState(_combatHeroEntity));
            stateControl.AddState(CombatHeroStateType.att, new CombatHeroAttState(_combatHeroEntity));
            stateControl.AddState(CombatHeroStateType.dile, new CombatHeroDieState(_combatHeroEntity));
            stateControl.AddState(CombatHeroStateType.rolling, new CombatHeroRollingState(_combatHeroEntity));
            stateControl.AddState(CombatHeroStateType.followMove, new CombatHeroFollowMoveState(_combatHeroEntity));
            stateControl.AddState(CombatHeroStateType.followIdle, new CombatHeroFollowIdleState(_combatHeroEntity));
            stateControl.AddState(CombatHeroStateType.NullState, new CombatHeroNullState(_combatHeroEntity));

            stateControl.AddState(CombatHeroStateType.Active, new CombatHeroActiveState(_combatHeroEntity));
            stateControl.AddState(CombatHeroStateType.XiuMian, new CombatHeroXiuMianState(_combatHeroEntity));
            stateControl.AddState(CombatHeroStateType.Resurrection, new CombatResurrectionState(_combatHeroEntity));
            stateControl.AddState(CombatHeroStateType.PickUp, new CombatHeroPickUpState(_combatHeroEntity));
            stateControl.AddState(CombatHeroStateType.Disappear, new CombatHeroDisappearState(_combatHeroEntity));
        }


        public override void Update(float t)
        {
            if (CombatController.currActiveCombat.isStopAi)
            {
                if (stateControl.CurrStateName.Equals(CombatHeroStateType.move))
                {
                    stateControl.ChangeState(CombatHeroStateType.idle);
                }

                return;
            }

            for (int i = 0; i < _areaList.Count; i++)
            {
                if (!_areaList[i].activeSelf)
                {
                    _HindAreaList.Remove(_areaList[i]);
                    _areaList.RemoveAt(i);

                    i--;
                }
            }

            for (int i = 0; i < _subStatusList.Count; i++)
            {
                SubStatusBasic subStatusBasic = _subStatusList[i];
                string s = subStatusBasic.IsGetStateName();
                if (!string.IsNullOrEmpty(s))
                {
                    stateControl.ChangeState(s);
                }

                _subStatusList[i].Update(t);
            }

            if (currFocusTarget == null || currFocusTarget.isDie ||
                (currFocusTarget is BannerHero && !_combatHeroEntity.IsEnemy) ||
                !_combatHeroEntity.IsAttDis(currFocusTarget.dotPos))
            {
                CombatHeroEntity[] allHero =
                    CombatController.currActiveCombat.CombatHeroController.GetHero(!_combatHeroEntity.IsEnemy);
                IHero minDistanceHero = FindMinDixtance(allHero);
                currFocusTarget = minDistanceHero;
                if (!_combatHeroEntity.IsEnemy && currFocusTarget == null)
                {
                    currFocusTarget = CombatController.currActiveCombat.CombatTypeBasic.currBannerHero;
                }
            }


            stateControl.Update(t);
            if (currFocusTarget != null && CurrState != null && CurrState.IsUpdateLockTarget() &&
                !_combatHeroEntity.isDie && !isAlert)
            {
                Vector3 nextPos = currFocusTarget.dotPos;
                Vector3 p = nextPos - _combatHeroEntity.dotPos;
                if (p.sqrMagnitude > 0.00001)
                {
                    _combatHeroEntity.combatHeroGameObject.rotation = Quaternion.Lerp(
                        _combatHeroEntity.combatHeroGameObject.rotation, Quaternion.LookRotation(p.normalized), 0.5f);
                }
            }

            AreaUpdate();
            ProUpdate();
            if (currFocusTarget != null)
            {
                _combatHeroEntity.GameObject.transform.rotation = Quaternion.LookRotation(currFocusTarget.dotPos-_combatHeroEntity.dotPos);
            }
            // float add = 0.1f;
            // Vector3 pos = Vector3.zero;
            // Vector3 dir = Vector3.zero;
            // float fx = 1;
            // if (_combatHeroEntity.IsEnemy)
            // {
            //     add = 0.15f;
            //     float lt = CombatController.currActiveCombat.CombatSenceController.currTime + add;
            //     pos = CombatController.currActiveCombat.CombatSenceController.GetTarget(lt);
            //     Vector3 p = CombatController.currActiveCombat.CombatSenceController.GetTarget(lt - 0.01f);
            //     dir = (pos - p).normalized;
            //     fx = -1;
            // }
            // else
            // {
            //     pos = CombatController.currActiveCombat.CombatSenceController.Move(t * 0.1f);
            //     float lt = CombatController.currActiveCombat.CombatSenceController.currTime - 0.01f;
            //     Vector3 p = CombatController.currActiveCombat.CombatSenceController.GetTarget(lt);
            //     dir = (pos - p).normalized;
            // }
            //
            //
            // _combatHeroEntity.combatHeroGameObject.SetPosition(pos);
            // _combatHeroEntity.GameObject.transform.rotation = Quaternion.LookRotation(dir * fx);
        }

        private void AreaUpdate()
        {
            GameObject[] b = AreaList;
            if (b == null)
            {
                return;
            }

            BetterList<GameObject> currArea = new BetterList<GameObject>();
            for (int i = 0; i < b.Length; i++)
            {
                if (!_HindAreaList.Contains(AreaList[i]))
                {
                    currArea.Add(AreaList[i]);
                    _HindAreaList.Add(AreaList[i]);
                }
            }

            if (currArea != null && currArea.Count > 0)
            {
                float dodge = _combatHeroEntity.CurrCombatHeroInfo.dodge;
                int odds = CombatCalculateTool.Instance.GetOdd();
                if (odds < dodge)
                {
                    CombatHeroRollingState.RollingStateData rollingStateData =
                        CObjectPool.Instance.Fetch<CombatHeroRollingState.RollingStateData>();
                    Vector3 pos = Vector3.zero;
                    for (int i = 0; i < b.Length; i++)
                    {
                        pos += b[i].transform.position;
                    }

                    pos /= b.Length;
                    Vector3 dir = pos - _combatHeroEntity.combatHeroGameObject.position;
                    rollingStateData.dir = new Vector3(dir.x, _combatHeroEntity.dotPos.y, dir.z).normalized;
                    _combatHeroEntity.CombatAIBasic.ChangeState(CombatHeroStateType.rolling, rollingStateData);
                }
            }
        }


        protected IHero FindMinDixtance(CombatHeroEntity[] allHero)
        {
            IHero minDistanceHero = null;
            if (allHero == null)
            {
                return null;
            }

            float minDistance = float.MaxValue;
            for (int i = 0; i < allHero.Length; i++)
            {
                CombatHeroEntity hero = allHero[i];
                if (hero.GetMainHotPoin<CombatHeroHitPoint>() == null)
                {
                    continue;
                }

                float distance = Vector3.SqrMagnitude(hero.combatHeroGameObject.position -
                                                      _combatHeroEntity.combatHeroGameObject.position);
                if (distance < minDistance)
                {
                    // if (!_combatHeroEntity.IsEnemy || distance < _combatHeroEntity.CurrCombatHeroInfo.maxDisTo + 100)
                    {
                        minDistance = distance;
                        minDistanceHero = hero;
                    }
                }
            }

            return minDistanceHero;
        }


        protected override void ProDispose()
        {
            CombatEventManager.Instance.RemoveEventListener(CombatEventType.AlertTrigger, AlertTrigger);
        }
    }
}