XiuXianGame/Assets/Scripts/GameLogic/Paritcle/ParitcleLogic/FxNavigationLogic.cs

using System.Collections;
using System.Collections.Generic;
using Common.Combat.FxAILogic;
using Core.Audio;
using Core.Triiger;
using GameLogic.Combat.CombatTool;
using GameLogic.Combat.Hero;
using UnityEngine;
using UTool.CustomizeTimeLogic.FxLogic.TimeLineEventinterface;

[AddComponentMenu("特效脚本/弹道/导航型子弹")]
public class FxNavigationLogic : FxAILogicBasic
{
    public float speed;
    [Header("多少秒后开始导航")] public float delayNavigation;
    [Header("最长持续时间")] public float continuedTime=10;
    public int PenetrateCount=1;
    private IUnRegister UnRegister = null;

    private Vector3 endPos;
    private Vector3 dir;

    private float currTime;
    private bool NavigationState;
    private float _currNavigationStateTime;
    private int _currPenetrateCount;
    // private float _NavigationInterval;

    protected CombatHeroEntity _currNavigationTargetHero;

    protected override void ProInit()
    {
        UnRegister = gameObject.OnTriggerEnterEvent(this,OnTriggerEnterEvent);
        if (isUseCustomTargetEndPos)
        {
            endPos = TimeLineEventParticleLogicBasic.customizePos[
                customTargetEndPosIndex];
        }
        else
        {
            endPos = AttTarget.GetSpecialDotInfo("hitpos").GetWorlPos();
        }

        _currNavigationTargetHero = null;
        endPos = new Vector3(endPos.x, CurrPos.y, endPos.z);
        dir = (endPos - CurrPos).normalized;
        gameObject.transform.rotation = Quaternion.LookRotation(dir);
        NavigationState = false;
        currTime = 0;
        _currNavigationStateTime = 0;
        _currPenetrateCount = 0;
    }

    protected void OnTriggerEnterEvent(Collider collision,ITriggerEntity triggerEntity)
    {
        HeroEntityMono heroEntityMono = collision.gameObject.GetComponent<HeroEntityMono>();
        if (heroEntityMono == null)
        {
            return;
        }

        CombatHeroEntity target = heroEntityMono.combatHeroEntity;
        if (target.IsEnemy == CombatHeroEntity.IsEnemy)
        {
            return;
        }

        if (target.isDie || target.GetMainHotPoin<ILifetCycleHitPoint>() == null)
        {
            return;
        }

        ITimeLineTriggerEvent timeLineTriggerEvent =
            TimeLineEventParticleLogicBasic.ITimeLineTriggerEntity as ITimeLineTriggerEvent;
        if (timeLineTriggerEvent != null)
        {
            timeLineTriggerEvent.TimeLineTrigger(TimeLineEventParticleLogicBasic.TimeLineEventLogicGroup.groupName,
                target.GetMainHotPoin<ILifetCycleHitPoint>(), this, triggerData);
            if (!string.IsNullOrEmpty(hitFxName))
            {
                CombatController.currActiveCombat.GameTimeLineParticleFactory.CreateParticle(hitFxName,
                    collision.ClosestPoint(gameObject.transform.position), null, false, null, null);
            }

            _currPenetrateCount++;
            AudioManager.Instance.PlayAudio(hitAudioName, false);
            NavigationState = false;
            _currNavigationStateTime = delayNavigation-0.1f;
            if (!isPenetrate||_currPenetrateCount>=PenetrateCount)
            {
                Dispose();
            }
        }
    }

    protected override void ProCombatUpdate(float time)
    {
        currTime += time;
        if (!NavigationState)
        {
            _currNavigationStateTime += time;
            // if (Vector3.SqrMagnitude(_currPos - startPos) > 200)
            // {
            //     Dispose();
            // }
            if (_currNavigationStateTime > delayNavigation)
            {
                NavigationState = true;
            }
        }
        else
        {

            if (_currNavigationTargetHero == null || _currNavigationTargetHero.isDie)
            {
                FindNavigationTarget();
            }

            if (_currNavigationTargetHero != null)
            {
                // Vector3 dotPos= _currNavigationTargetHero.dotPos + new Vector3(0, 0.5f, 0);
                // _currPos=
                Vector3 newDir = (_currNavigationTargetHero.dotPos - _currPos).normalized;
                dir = Vector3.Lerp(dir, newDir, 0.1f);
                dir.y = 0;
                dir.Normalize();
            }
        }

        Vector3 lastPos = _currPos;
        Vector3 movePos = dir * speed * time;


        _currPos += movePos;
        gameObject.transform.position = _currPos;
        gameObject.transform.rotation = Quaternion.LookRotation(dir);
        if (currTime > continuedTime)
        {
            Dispose();
            return;
        }
    }


    private void FindNavigationTarget()
    {
        _currNavigationTargetHero = null;
        CombatHeroEntity[] allHero =
            CombatController.currActiveCombat.CombatHeroController.GetHero(!CombatHeroEntity.IsEnemy);
        if (allHero == null || allHero.Length <= 0)
        {
            return;
        }

        int index = CombatCalculateTool.Instance.GetOdd(0, allHero.Length);
        _currNavigationTargetHero = allHero[index];
        // for (int i = 0; i < allHero.Length; i++)
        // {
        //     
        // }
    }

    protected override void ProDispose()
    {
        if (UnRegister != null)
        {
            UnRegister.UnRegister();
        }

        UnRegister = null;
        _currNavigationTargetHero = null;
    }
}