XiuXianGame/Assets/Scripts/GameLogic/Combat/Hero/State/MagicWeaponMoveState.cs

using Core.State;
using Core.Triiger;
using Fort23.Core;
using GameLogic.Combat.CombatTool;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Logical;
using UnityEngine;

namespace GameLogic.Combat.Hero.State
{
    /// <summary>
    /// 再空中飞来飞去撞的时候
    /// </summary>
    public class MagicWeaponMoveState : CombatHeroStateBasic
    {
        public class MagicWeaponMoveStateData : CObject, IStateEnterData
        {
            public bool trigger;
            public float triggerTime;
            public override void ActiveObj()
            {
            }

            public override void DormancyObj()
            {
            }
        }
        private CombatMagicWeaponEntity myCombatMagicWeaponEntity;

        private float speed = 10;

        private IUnRegister OnTriggerEnterEvent;

        protected Vector3 _lastDir;

        protected bool _trigger;
        private float _triggerTime;

        public MagicWeaponMoveState(CombatHeroEntity combatHeroEntity) : base(combatHeroEntity)
        {
            myCombatMagicWeaponEntity = combatHeroEntity as CombatMagicWeaponEntity;
        }

        protected override void ProEnter()
        {
            MagicWeaponMoveStateData magicWeaponMoveStateData=   iStateEnterData as MagicWeaponMoveStateData;
            if (magicWeaponMoveStateData != null)
            {
                _trigger = magicWeaponMoveStateData.trigger;
                _triggerTime = magicWeaponMoveStateData.triggerTime;
            }

            OnTriggerEnterEvent = myCombatMagicWeaponEntity.GameObject.OnTriggerEnterEvent(OnTriggerEnter);
        }

        public Vector3 GetStartPos()
        {
            Vector3 startPos = myCombatMagicWeaponEntity.MagicWeaponControl.combatHeroEntity.dotPos;
            float y = myCombatMagicWeaponEntity.IsEnemy ? 5 : 3;
            float x = myCombatMagicWeaponEntity.useIndex;


            return startPos + new Vector3(x, y, 0);
        }

        private void OnTriggerEnter(Collider collider)
        {
            HeroEntityMono heroEntityMono = collider.GetComponent<HeroEntityMono>();
            if (heroEntityMono == null || heroEntityMono.combatHeroEntity != myCombatMagicWeaponEntity.CollidingTarget)
            {
                return;
            }

            if (!(myCombatMagicWeaponEntity.CombatAIBasic.CurrState is MagicWeaponMoveState))
            {
                return;
            }

            CombatMagicWeaponEntity combatMagicWeaponEntity =
                heroEntityMono.combatHeroEntity as CombatMagicWeaponEntity;
            if ((combatMagicWeaponEntity.HpBl <= 30 || myCombatMagicWeaponEntity.HpBl < 20) &&
                myCombatMagicWeaponEntity.CombatAIBasic.CurrState is MagicWeaponMoveState)
            {
                CombatController.currActiveCombat.MagicWeaponCombatSence.AddCollisionMagicWeapon(
                    combatMagicWeaponEntity, myCombatMagicWeaponEntity);
            }
            else
            {
                combatMagicWeaponEntity.ReduceHp(40);
                _trigger = true;
                _triggerTime = 0.5f;
                myCombatMagicWeaponEntity.CollidingTarget = null;
            }

            // _trigger = true;
            // _triggerTime = 0.5f;
            //碰到了要撞的敌人
        }

        protected override void ProUpdate(float t)
        {
            if (myCombatMagicWeaponEntity.CollidingTarget == null ||
                myCombatMagicWeaponEntity.CollidingTarget.HpBl <= 0)
            {
                CombatMagicWeaponEntity combatMagicWeaponEntity =
                    CombatController.currActiveCombat.MagicWeaponCombatSence.FindCollidingTarget(
                        myCombatMagicWeaponEntity);


                myCombatMagicWeaponEntity.CollidingTarget = combatMagicWeaponEntity;
            }

            Vector3 targetPos = Vector3.zero;
            CombatMagicWeaponEntity currCollidingTarget = myCombatMagicWeaponEntity.CollidingTarget;
            if (currCollidingTarget == null || !currCollidingTarget.isCombatState) //没有可碰撞的法宝了
            {
                Vector3 startPos = GetStartPos();
                if (Vector3.Distance(startPos, myCombatMagicWeaponEntity.dotPos) < 0.5f)
                {
                    myCombatMagicWeaponEntity.CombatAIBasic.ChangeState(CombatHeroStateType.idle);
                    return;
                }

                targetPos = startPos;
            }
            else
            {
                targetPos = currCollidingTarget.dotPos;
            }


            Quaternion newQuaternion = myCombatMagicWeaponEntity.GameObject.transform.rotation;
            if (_trigger && _triggerTime > 0)
            {
                _triggerTime -= t;
                if (_triggerTime <= 0)
                {
                    _trigger = false;
                    // speed = 1;
                }
            }
            else
            {
                Vector3 newDir = (targetPos - myCombatMagicWeaponEntity.dotPos).normalized;
                float targetAngle = Vector3.Angle(Vector3.forward, newDir);
                // Quaternion.Euler(0, targetAngle, 0) * enemyDirection;
                newQuaternion = Quaternion.LookRotation(newDir);


                newQuaternion = Quaternion.RotateTowards(myCombatMagicWeaponEntity.GameObject.transform.rotation,
                    newQuaternion, 5);

                _lastDir = newDir;
            }

            // speed += t * 3;
            // if (speed > 10)
            // {
            //     speed = 10;
            // }

            Vector3 pos = newQuaternion * new Vector3(0, 0, 1);
            Vector3 movePos = pos * speed * t;

            Vector3 _currPos = myCombatMagicWeaponEntity.dotPos;
            _currPos += movePos;
            myCombatMagicWeaponEntity.combatHeroGameObject.SetPosition(_currPos);
            myCombatMagicWeaponEntity.GameObject.transform.rotation = newQuaternion;
        }


        protected void ActiveHero()
        {
        }


        protected override void ProExit()
        {
            OnTriggerEnterEvent.UnRegister();
        }

        public override bool IsUpdateLockTarget()
        {
            return false;
        }

        protected override void ProDispose()
        {
        }
    }
}