using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using ActionGameFramework.Health;
using Core.Health;
using Core.Utilities;
using DG.Tweening;
using KTGMGemClient;
using TMPro.Examples;
using TowerDefense.Affectors;
using TowerDefense.Agents.Data;
using TowerDefense.Economy;
using TowerDefense.Level;
using TowerDefense.Nodes;
using UnityEngine;
using UnityEngine.AI;

namespace TowerDefense.Agents
{
    // 预计算移动的方位.
    public enum EAgentMovDir
    {
        Start,
        XPositive,
        XNegative,
        ZPositive,
        ZNegative,
        End
    }


    /// <summary>
    /// 每一个Agent发布到场景内时设置的数据
    /// </summary>
    public struct AgentSetData
    {
        public float speed;
        public float hp;
    }

    /// <summary>
    /// An agent will follow a path of nodes
    /// NavMeshAgent和AttackAffector是必须得加入的EntityNode.
    /// </summary>
    [RequireComponent(typeof(NavMeshAgent)), RequireComponent(typeof(AttackAffector))]
    public abstract class Agent : Targetable
    {
        /// <summary>
        /// A means of keeping track of the agent along its path
        /// </summary>
        public enum State
        {
            /// <summary>
            /// When the agent is on a path that is not blocked
            /// </summary>
            OnCompletePath,

            /// <summary>
            /// When the agent is on a path is blocked
            /// </summary>
            OnPartialPath,

            /// <summary>
            /// When the agent has reached the end of a blocked path
            /// </summary>
            Attacking,

            /// <summary>
            /// For flying agents, when they move over obstacles
            /// </summary>
            PushingThrough,

            /// <summary>
            /// When the agent has completed their path
            /// </summary>
            PathComplete
        }

        /// <summary>
        /// Event fired when agent reached its final node
        /// </summary>
        public event Action<Node> destinationReached;

        /// <summary>
        /// Position offset for an applied affect
        /// 这个主要是用于AgentEffect相关的类，给当前的Agent加相关的效果，移动变慢，加速等等。
        /// </summary>
        public Vector3 appliedEffectOffset = Vector3.zero;

        /// <summary>
        /// Scale adjustment for an applied affect
        /// 加强效果对应的Scale数据
        /// </summary>
        public float appliedEffectScale = 1;

        /// <summary>
        /// 当前的Agent对应的healthBar.
        /// </summary>
        public HealthVisualizer healthBar;

        /// <summary>
        /// 如果不为空，则播放当前的particle.
        /// </summary>
        public ParticleSystem spawnParticle;

        public AgentSetData mAgentData;



        //public Textur


        /// <summary>
        /// The NavMeshAgent component attached to this
        /// 这个，Unity内比较核心的类
        /// </summary>
        protected NavMeshAgent m_NavMeshAgent;

        /// <summary>
        /// The Current node that the agent must navigate to
        /// </summary>
        protected Node m_CurrentNode;

        /// <summary>
        /// 修改当前的NavMeshAgent移动模式，修改为纯手动移动
        /// </summary>
        protected Node m_NextNode;

        /// <summary>
        /// 记录初始化的位置和Node，用于重设当前Agent的位置
        /// </summary>
        protected Node initNode;
        protected Vector3 initPos;

        /// <summary>
        /// Reference to the level manager
        /// </summary>
        protected LevelManager m_LevelManager;

        protected EndlessLevelManager endlessLevelManager;

        /// <summary>
        /// Stores the Destination to the next node so we don't need to get new random positions every time
        /// </summary>
        protected Node m_Destination;
        /// <summary>
        /// 每次移动从SrcPosition到m_Destination.
        /// </summary>
        protected Vector3 m_SrcPosition;
        /// <summary>
        /// 每次切换Node,都会重新计算移动方向，用于中间状态时，更快速的计算移动数据。
        /// </summary>
        protected EAgentMovDir moveDir;

        /// <summary>
        /// 移动速度,暂时从navMeshAgent中获取.
        /// </summary>
        protected float fMoveSpeed;
        protected float MoveStopTime = 0.0f;
        protected ParticleSystem MoveStopEffect = null;

        /// <summary>
        /// 距离目标的最终距离.
        /// </summary>
        protected float m_DisToDestination;

        /// <summary>
        /// 当前Agent的默认Scale数据
        /// </summary>
        protected Vector3 mDefaultScale;

        /// <summary>
        /// 当前小怪对应的掉落数据
        /// </summary>
        protected LootDrop mLootDrop;

        /// <summary>
        /// 每一个Node加一个超长距离值
        /// </summary>
        protected readonly float NODE_DIS = 1000f;

        /// <summary>
        /// 当前Agent的开始Yval,用于标注层级显示.
        /// </summary>
        protected float mStartYVal;
        protected float mStartZVal;

        /// <summary>
        /// 动画器.
        /// </summary>
        public Animator ActionAnimator;

        protected AnimationClip[] clips;

        protected bool bInDeathAct = false;

        /// <summary>
        /// 原地罚站
        /// </summary>
        /// <param name="can"></param>
        public bool CanMove { get; set; } = true;

        /// <summary>
        /// Gets the attached nav mesh agent velocity
        /// </summary>
        public override Vector3 velocity
        {
            get { return m_NavMeshAgent.velocity; }
        }

        public bool bInDeathState
        {
            get { return this.bInDeathAct; }
            set { bInDeathAct = value; }
        }

        /// <summary>
        /// 是否是可再生的怪物类型
        /// </summary>
        public bool bRespawn { get; set; }

        /// <summary>
        /// The current state of the agent along the path
        /// </summary>
        public State state { get; protected set; }

        /// <summary>
        /// 当前Agent对应到的兵线ID.
        /// </summary>
        public int waveLineID { get; set; }

        public NavMeshAgent navMeshAgent
        {
            get { return this.m_NavMeshAgent; }
        }

        /// <summary>
        /// 是否显示目标位置信息
        /// </summary>
        public bool bShowDebugNode = false;

        /// <summary>
        /// 持续寻路，起到寻路成功
        /// </summary>
        protected bool nodeMoveUpdate = false;

        /// <summary>
        /// 代理的类型
        /// </summary>
        public SpawnAgentType AgentType { get; set; } = SpawnAgentType.Normal;

        /// <summary>
        /// 无尽模式小怪对应 endless_enemy表中数据
        /// </summary>
        public endless_enemy EnemyData { get; set; }

        /// <summary>
        /// Accessor to <see cref="m_NavMeshAgent"/>
        /// </summary>
        public NavMeshAgent navMeshNavMeshAgent
        {
            get { return m_NavMeshAgent; }
            set { m_NavMeshAgent = value; }
        }

        public float distanceToDest
        {
            get { return this.m_DisToDestination; }
        }

        /// <summary>
        /// The area mask of the attached nav mesh agent
        /// </summary>
        public int navMeshMask
        {
            get { return m_NavMeshAgent.areaMask; }
        }

        /// <summary>
        /// Gets this agent's original movement speed
        /// </summary>
        public float originalMovementSpeed { get; protected set; }

        /// <summary>
        /// 小怪的动作状态
        /// </summary>
        public AgentActionState ActionState { get; protected set; }

        private string paramName = "AgentActionState";

        /// <summary>
        /// 更新怪物的移动速度。
        /// </summary>
        /// <param name="fscale"></param>
        public void SetMoveSpeedScale(float fscale)
        {
            fMoveSpeed = fMoveSpeed * fscale;
        }

        /// <summary>
        /// 动态设置Agent的血量数据.
        /// </summary>
        /// <param name="health"></param>       设置当前小怪的血量.
        /// <param name="moveSpeed"></param>    设置当前小怪的移动速度
        /// <param name="coinDrop"></param>     设置当前小怪的金币掉落数据
        public void SetAgentData(float health, float moveSpeed = -1, int coinDrop = 0)
        {
            this.configuration.maxHealth = health;
            this.configuration.startingHealth = health;
            this.configuration.SetMaxHealth(health);
            this.configuration.Init();
            this.configuration.SetHealth(health);

            // 只有在速度大于零的情况下才会设置.
            if (moveSpeed > 0)
                fMoveSpeed = moveSpeed;

            // 金币掉落大于零.
            if (coinDrop > 0)
                mLootDrop.lootDropped = coinDrop;

            mAgentData.speed = fMoveSpeed;
            mAgentData.hp = this.configuration.maxHealth;

            //
            mStartYVal = this.transform.position.y;
            mStartZVal = this.transform.position.z;

            // 确保设置成默认白色纹理:
            this.SetTargetableMatColor(Color.white, true);

            speedSlowRate = 0.0f;
            poisonHurt = 0;
            poisonAttid = 0;
            poisonTimes = 0;
            timeToPoisonHurt = 0;
            bShieldBreak = false;
            CanMove = true;

            /*// 如果对应的粒子不为空，则播放
			if( spawnParticle)
            {
				ParticleSystem tpar = Instantiate<ParticleSystem>(spawnParticle);
				tpar.transform.localScale = new Vector3(1.5f, 1.5f, 1.5f);
				tpar.transform.position = this.transform.position;
				tpar.Simulate(0.0f);
				tpar.Play();
			}*/
            // if (healthBar)
            // 	healthBar.bOpponent = opponentAgent;
        }

        /// <summary>
        /// Checks if the path is blocked
        /// </summary>
        /// <value>
        /// The status of the agent's path
        /// </value>
        protected virtual bool isPathBlocked
        {
            get { return m_NavMeshAgent.pathStatus == NavMeshPathStatus.PathPartial; }
        }

        /// <summary>
        /// Is the Agent close enough to its destination?
        /// </summary>
        protected virtual bool isAtDestination
        {
            get { return navMeshNavMeshAgent.remainingDistance <= navMeshNavMeshAgent.stoppingDistance; }
        }

        /// <summary>
        /// 改变m_NextNode，因为要切换基地
        /// </summary>
        /// <param name="node"></param>
        public void ChangeNextNode(Node node)
        {
            m_NextNode = node;
        }

        /// <summary>
        /// Sets the node to navigate to
        /// </summary>
        /// <param name="node">The node that the agent will navigate to</param>
        public virtual void SetNode(Node node, int lineid)
        {
            if (lineid >= 0)
                waveLineID = lineid;

            // 设置为空的时候，是为了不再每一帧更新Agent的位置信息
            if (node == null)
            {
                m_CurrentNode = null;
                m_NextNode = null;
                return;
            }

            if (m_CurrentNode == null)
            {
                initNode = node;
            }

            m_CurrentNode = node;

            // 需要设置移动的目标Node.
            m_NextNode = m_CurrentNode.GetNextNode();


            this.MoveToNode();
        }

        /// <summary>
        /// 处理Agent的锁定Buf,播放特效，设置速度为零,并时间到达后重设数据。
        /// </summary>
        /// <param name="binfo"></param>
        protected virtual void SetAgentStopBuff(buffinfo binfo)
        {
            MoveStopTime = binfo.last / 1000;

            if (!isFrost)
            {
                isFrost = true;

                if (FrostParticle != null)
                    FrostParticle.Play();
            }
        }

        /// <summary>
        /// 设置当前Agent对应的各种技能属性ID.
        /// </summary>
        /// <param name="effid"></param>
        public void SetAgentBuffEffect(int buffid)
        {
            buffinfo bufdata = JsonDataCenter.GetBuffFromId(buffid);
            if (bufdata == null) return;

            if (bufdata.buff_func[0] == 3)
            {
                SetAgentStopBuff(bufdata);
            }
            else
                return;
        }

        public override bool isAgent()
        {
            return true;
        }


        /// <summary>
        /// Stops the navMeshAgent and attempts to return to pool
        /// </summary>
        public override void Remove()
        {
            // 统一管理器内删除当前的Agent:
            AgentInsManager.instance.removeAgent(this);
            EventCenter.Ins.BroadCast((int)KTGMGemClient.EventType.EndlessAgentDead, this);
            base.Remove();

            if (m_LevelManager) m_LevelManager.DecrementNumberOfEnemies();
            else endlessLevelManager.DecrementNumberOfEnemies();
            if (m_NavMeshAgent.enabled)
            {
                m_NavMeshAgent.isStopped = true;
            }
            m_NavMeshAgent.enabled = false;

            // 必须要重置数据，不然会有一系列的小Bug.
            this.m_CurrentNode = null;
            m_NextNode = null;

            this.liveID = this.liveID + 1;

            speedSlowRate = 0.0f;
            poisonHurt = 0;
            poisonAttid = 0;
            poisonTimes = 0;
            timeToPoisonHurt = 0;
            isFrost = false;
            bShieldBreak = false;
            bInDeathAct = false;
            ChangeState(AgentActionState.Move);
            configuration.ClearShieldWall();

            StopFrostParticle();
            //this.SetTargetableMatColor(Color.white);

            // 删除当前停止特效和状态.
            if (MoveStopTime > 0)
                MoveStopTime = 0.0f;


            // 停止DoTween动画.
            this.transform.DOKill();

            Poolable.TryPool(gameObject);
        }

        private void StopFrostParticle()
        {
            if (FrostParticle != null)
                FrostParticle.Stop();
        }

        /// <summary>	
        /// Setup all the necessary parameters for this agent from configuration data
        /// </summary>
        public virtual void Initialize()
        {
            ResetPositionData();
            LazyLoad();
            configuration.SetHealth(configuration.maxHealth);
            state = isPathBlocked ? State.OnPartialPath : State.OnCompletePath;

            // River TEST CODE TO DELETE: 测试成功之后，是需要删除navMeshAgent组件的，根本不需要
            m_NavMeshAgent.enabled = false;

            if (m_LevelManager) m_LevelManager.IncrementNumberOfEnemies();
            else endlessLevelManager.IncrementNumberOfEnemies();


            // 
            // 设置一个DOTween队列，让场景内刷出来的Agent有一个变大淡出的效果,此时是无敌效果加持.
            this.configuration.bInvincible = true;
            mDefaultScale = this.transform.localScale;
            Sequence agentTweenSeq = DOTween.Sequence();
            var ss = mDefaultScale * 0.3f;
            this.transform.localScale = this.transform.localScale * 0.3f;
            Tweener agScale = this.transform.DOScale(mDefaultScale, 0.3f);
            agentTweenSeq.Append(agScale);
            agentTweenSeq.AppendCallback(beDamageStart);

            this.nodeMoveUpdate = false;

            // 获取移动速度
            fMoveSpeed = this.m_NavMeshAgent.speed / 2.0f;
        }

        protected void beDamageStart()
        {
            this.configuration.bInvincible = false;
        }

        /// <summary>
        /// 把当前的Agent拉到起始位置
        /// </summary>
        public void ResetAgentToInitialPos()
        {
            if (!this.initNode) return;

            Vector3 initPos = this.initNode.GetRandomPointInNodeArea();
            transform.position = initPos;
            ResetPositionData();

            this.SetNode(initNode, -1);

            // 更新AgentMgr，确保不再攻击回到原点的Agent.
            AgentInsManager.instance.updateInsMgrPos(this.opponentAgent);

        }

        /// <summary>
        /// 执行重设到开始位置的Agent特效，需要执行一系列的动作.
        /// </summary>
        public void execAgentPosResetAction()
        {
            // 无敌状态不增加当前的效果:
            if (configuration.bInvincible) return;

            // 只有处于非PosEffect状态才可以有这个状态.
            var posResetEff = this.GetComponent<AgentResetPosEffect>();
            if (posResetEff == null)
            {
                posResetEff = this.gameObject.AddComponent<AgentResetPosEffect>();

                // 初始化当前的PosResetEffect
                posResetEff.Initialize(3, AgentInsManager.instance.posResetFx);
            }
        }

        /// <summary>
        /// 预处理当前的Agent最大或最小可以到达的ZValue.
        /// </summary>
        protected void PreProcessZValue()
        {
            if (!m_CurrentNode) return;
            Node nextNode = m_CurrentNode.GetNextNode();
            if (!nextNode) return;

            /*			if (m_CurrentNode.transform.position.z > nextNode.transform.position.z)
                            this.m_PositiveZ = false;
                        else
                            this.m_PositiveZ = true;
                        m_ZMaxValue = nextNode.transform.position.z;

                        Node thirdNode = nextNode.GetNextNode();
                        if (!thirdNode) return;
                        if (thirdNode.transform.position.x > nextNode.transform.position.x)
                            this.m_PositiveX = true;
                        else
                        {
                            this.m_PositiveX = false;
                        }
                        m_XMaxValue = thirdNode.transform.position.x;*/
        }

        /// <summary>
        /// Finds the next node in the path
        /// </summary>
        public virtual void MoveToNextNode(Node currentlyEnteredNode)
        {
            // Don't do anything if the calling node is the same as the m_CurrentNode
            if (m_NextNode != currentlyEnteredNode)
            {
                return;
            }
            if (m_NextNode == null)
            {
                Debug.LogError("Cannot find current node");
                return;
            }

            Node nextNode = m_NextNode.GetNextNode();
            if (nextNode == null)
            {
                if (m_NavMeshAgent.enabled)
                {
                    m_NavMeshAgent.isStopped = true;
                }

                // 清空当前的Node和NextNode.
                m_CurrentNode = null;
                HandleDestinationReached();
                m_NextNode = null;

                return;
            }

            Debug.Assert(nextNode != m_CurrentNode);

            SetNode(m_NextNode, -1);
        }

        /// <summary>
        /// Moves the agent to a position in the <see cref="Agent.m_NextNode" />
        /// 预计算开始位置，结束位置，以及移动方向。
        /// </summary>
        public virtual void MoveToNode()
        {
            if ((!m_CurrentNode) || (!m_NextNode))
            {
                if (!m_CurrentNode)
                    Debug.Log("当前的Node值为空.");
                else
                    Debug.Log("NextNode的值为空.");

                return;
            }

            m_Destination = m_NextNode;
            m_SrcPosition = m_CurrentNode.transform.position;

            // 
            // 预处理，确定移动方向.
            if (m_Destination.transform.position.x == m_SrcPosition.x)
            {
                if (m_Destination.transform.position.z > m_SrcPosition.z)
                    moveDir = EAgentMovDir.ZPositive;
                else
                    moveDir = EAgentMovDir.ZNegative;
            }
            else
            {
                if (m_Destination.transform.position.z != m_SrcPosition.z)
                {
                    Debug.Log("目标位置和开始位置的Z值不相等:" + m_Destination.transform.position.x + "," + m_Destination.transform.position.z + "," +
                        m_SrcPosition.x + "," + m_SrcPosition.z);
                }
                if (m_Destination.transform.position.x > m_SrcPosition.x)
                    moveDir = EAgentMovDir.XPositive;
                else
                    moveDir = EAgentMovDir.XNegative;
            }
        }

        /// <summary>
        /// The logic for what happens when the destination is reached
        /// </summary>
        public virtual void HandleDestinationReached()
        {
            state = State.PathComplete;
            if (destinationReached != null)
            {
                destinationReached(m_NextNode);
            }
        }

        /// <summary>
        /// Lazy Load, if necesaary and ensure the NavMeshAgent is disabled
        /// </summary>
        protected override void Awake()
        {
            //Debug.Log("哪里生成的?");
            base.Awake();
            LazyLoad();
            m_NavMeshAgent.enabled = false;
            MoveStopTime = 0.0f;
        }

        /// <summary>
        /// 根据帧间的时间，来更新Agent的位置信息，其它信息直接删除.
        /// 1: 
        /// </summary>
        /// <param name="deltaTime"></param>
        protected void updateAgentPos(float deltaTime)
        {
            if ((!m_CurrentNode) || (!m_NextNode))
                return;

            // 是否处于停止状态.
            if (MoveStopTime > 0)
            {
                MoveStopTime -= Time.deltaTime;
                if (MoveStopTime <= 0)
                {
                    StopFrostParticle();
                    MoveStopTime = 0;
                }
                else
                    return;
            }

            if (this.fMoveSpeed == 0)
            {
                Debug.Log("当前的移动为零:" + fMoveSpeed);
                return;
            }

            float finalSpeed = fMoveSpeed * (1 - speedSlowRate);

            if (speedSlowRate > 0 && !isSlowDown)
            {
                isSlowDown = true;

                if (SlowDownParticle != null)
                    SlowDownParticle.Play();
            }
            else if (speedSlowRate == 0 && isSlowDown)
            {
                isSlowDown = false;

                if (SlowDownParticle != null)
                {
                    SlowDownParticle.Stop();
                    SlowDownParticle.Clear();
                }
            }

            Vector3 curPos = m_NavMeshAgent.transform.position;
            bool swithNode = false;

            switch (moveDir)
            {
                case EAgentMovDir.ZPositive:
                    {
                        curPos.z += (deltaTime * finalSpeed);
                        if (curPos.z >= m_Destination.transform.position.z)
                        {
                            curPos.z = m_Destination.transform.position.z;
                            swithNode = true;
                        }
                        break;
                    }
                case EAgentMovDir.ZNegative:
                    {
                        curPos.z -= (deltaTime * finalSpeed);
                        if (curPos.z <= m_Destination.transform.position.z)
                        {
                            curPos.z = m_Destination.transform.position.z;
                            swithNode = true;
                        }
                        break;
                    }
                case EAgentMovDir.XPositive:
                    {
                        curPos.x += (deltaTime * finalSpeed);
                        if (curPos.x >= m_Destination.transform.position.x)
                        {
                            curPos.x = m_Destination.transform.position.x;
                            swithNode = true;
                        }
                        break;
                    }
                case EAgentMovDir.XNegative:
                    {
                        curPos.x -= (deltaTime * finalSpeed);
                        if (curPos.x <= m_Destination.transform.position.x)
                        {
                            curPos.x = m_Destination.transform.position.x;
                            swithNode = true;
                        }
                        break;
                    }
            }

            // 根据是否到达一个结点来进行不同的处理
            if (swithNode)
            {
                this.MoveToNextNode(m_NextNode);
            }
            else
            {
                // Y值插值.
                float lerpVal = (curPos.z - mStartZVal) / (m_Destination.transform.position.z - mStartZVal);
                if (!this.opponentAgent)
                    // curPos.y = mStartYVal + lerpVal * 60f;
                    curPos.y = mStartYVal;
                m_NavMeshAgent.transform.position = curPos;
            }

            return;
        }

        /// <summary>
        /// 更新动作信息.
        /// </summary>
        /// <returns></returns>
        protected void UpdateAction()
        {
            if (ActionAnimator == null) return;

            AnimatorStateInfo stateInfo = ActionAnimator.GetCurrentAnimatorStateInfo(0);

            switch (ActionState)
            {
                case AgentActionState.Move:
                    break;
                case AgentActionState.GetHit:
                    if (stateInfo.normalizedTime >= 1f)
                        ChangeState(AgentActionState.Move);
                    break;
                case AgentActionState.Attack:
                    if (stateInfo.normalizedTime >= 1f)
                    {
                        if (isDead)
                        {
                            AgentInsManager.instance.removeAgent(this);
                            Remove();
                        }
                    }
                    break;
                case AgentActionState.Death:
                    if (stateInfo.normalizedTime >= 1f)
                        Remove();
                    break;
            }
        }

        private void ChangeState(AgentActionState state)
        {
            if (state == ActionState) return;

            ActionState = state;
            if (ActionAnimator != null)
                ActionAnimator.SetInteger(paramName, (int)state);
        }

        /// <summary>
        /// 检查自身血量
        /// </summary>
        private void CheckHealth()
        {
            if (this.healthVal <= 0.1)
            {
                Die();

                //Debug.Log("删除多余的攻击Agent.");
            }
        }

        private void Die()
        {
            // 统一管理器内删除当前的Agent:
            AgentInsManager.instance.removeAgent(this);
            this.Remove();
        }

        /// <summary>
        /// Updates the agent in its different states, 
        /// Reset destination when path is stale
        /// River: 更新的时候，加入离最终目标的距离数据.
        /// </summary>
        protected virtual void LateUpdate()
        {
            this.UpdateAction();
            HandleShieldWall();

            // 处理死亡状态了，不必再移动:
            if (bInDeathAct || !CanMove) return;

            m_Destination = initNode.GetNextNode();
            updateAgentPos(Time.deltaTime);

            // 计算离目标的距离，非最终距离，只用于比较大小
            this.m_DisToDestination = this.GetDisToDestination();

            // 计算中毒相关.
            if ((poisonTimes > 0) && (poisonHurt > 0))
                updatePoison(Time.deltaTime);
        }

        protected virtual void Update()
        {

        }

        /// <summary>
        /// 处理魔法护盾血量值
        /// </summary>
        protected void HandleShieldWall()
        {
            if (configuration.IsExistShieldWall)
            {
                if (configuration.ShieldWallCurrentHealth <= 0.00001f)
                    configuration.IsExistShieldWall = false;
                else if (configuration.ShieldWallEffectiveTime > 0.00001f)
                {
                    if (configuration.ShieldWallRemainTime <= 0.00001f)
                        configuration.IsExistShieldWall = false;
                    else
                        configuration.ShieldWallRemainTime -= Time.deltaTime;
                }
            }
        }

        /// <summary>
        /// 限制当前Agent的移动位置，让Agent的移动看起来更帅一些
        /// </summary>
        protected void restrictAgentPos()
        {
            /*			// 设置最大的Z值，确保按路线移动
                        Vector3 pos = m_NavMeshAgent.transform.position;
                        if (this.m_PositiveZ)
                        {
                            if (pos.z > m_ZMaxValue)
                            {
                                pos.z = m_ZMaxValue;
                                m_NavMeshAgent.transform.position = pos;
                            }
                        }
                        else
                        {
                            if (pos.z < m_ZMaxValue)
                            {
                                pos.z = m_ZMaxValue;
                                m_NavMeshAgent.transform.position = pos;
                            }
                        }
                        // 设置X值的限制，确保按路线移动
                        if(this.m_PositiveX)
                        {
                            if( pos.x > m_XMaxValue)
                            {
                                pos.x = m_XMaxValue;
                                m_NavMeshAgent.transform.position = pos;
                            }
                        }
                        else
                        {
                            if( pos.x < m_XMaxValue)
                            {
                                pos.x = m_XMaxValue;
                                m_NavMeshAgent.transform.position = pos;
                            }
                        }*/
        }

        /// <summary>
        /// Set the NavMeshAgent's destination
        /// </summary>
        /// <param name="nextPoint">The position to navigate to</param>
        protected virtual bool NavigateTo(Vector3 nextPoint)
        {
            // River mod: 完全自己控制移动 ，不需要navMeshAgent.
            return true;
            /*
			LazyLoad();
			bool res = false;
			if (m_NavMeshAgent.isOnNavMesh)
			{
				nextPoint.y += 0.1f;
				res = m_NavMeshAgent.SetDestination(nextPoint);
			}
			return res;*/
        }

        /// <summary>
        /// 计算当前的Agent距离目标的最终距离，不是真实距离，是比较大小的数值.
        /// </summary>
        /// <returns></returns>
        protected float GetDisToDestination()
        {
            if (!m_CurrentNode) return 0;

            float tmpDis = 0;
            Node tmpNode = m_CurrentNode.GetNextNode();
            while (tmpNode.GetNextNode() != null)
            {
                tmpDis += NODE_DIS;
                tmpNode = tmpNode.GetNextNode();
            }
            Vector3 tpos = this.position;
            tpos.y = mStartYVal;
            tmpDis += Vector3.Distance(tpos, this.m_Destination.transform.position);

            return tmpDis;
        }

        protected ChangeMat changeMat;
        /// <summary>
        /// This is a lazy way of caching several components utilised by the Agent
        /// </summary>
        protected virtual void LazyLoad()
        {
            if (m_NavMeshAgent == null)
            {
                m_NavMeshAgent = GetComponent<NavMeshAgent>();
                mLootDrop = GetComponent<LootDrop>();
                originalMovementSpeed = m_NavMeshAgent.speed;
            }
            if (m_LevelManager == null)
            {
                m_LevelManager = LevelManager.instance;
            }
            if (!endlessLevelManager)
                endlessLevelManager = EndlessLevelManager.instance;
        }

        /// <summary>
        /// 播放受击动画.
        /// </summary>
        public void PlayOnHit()
        {
            ChangeState(AgentActionState.GetHit);
        }

        /// <summary>
        /// 播放受击动画，直接从头开始播放
        /// </summary>
        public void PlayOnHitImmediately()
        {
            ChangeState(AgentActionState.GetHit);
            if (ActionAnimator)
            {
                ActionAnimator.Play("GetHit", 0, 0);
                ActionAnimator.Update(0);
            }
        }

        /// <summary>
        /// 播放火技能打击动画
        /// </summary>
        public void PlayFireSkillHit()
        {
            if (FireSkillParticle != null)
                FireSkillParticle.Play();
        }

        public void PlayAttack()
        {
            AudioSourceManager.Ins.Play(AudioEnum.AttackTower);
            ChangeState(AgentActionState.Attack);
        }

        public override void PlayDeath()
        {
            if (isPoison)
            {
                isPoison = false;
                // 移除Agent身上的中毒特效，并播放一个中毒效果消失的特效
                if (PoisonParticle != null)
                {
                    PoisonParticle.Stop();
                    PoisonParticle.Clear();
                    if (PoisonEndParticle != null)
                        PoisonEndParticle.Play();
                }
            }

            if (isSlowDown)
            {
                isSlowDown = false;

                if (SlowDownParticle != null)
                {
                    SlowDownParticle.Stop();
                    SlowDownParticle.Clear();
                }
            }

            ChangeState(AgentActionState.Death);
            // 统一管理器内删除当前的Agent:
            AgentInsManager.instance.removeAgent(this);
            bInDeathAct = true;
        }

        /// <summary>
        /// Move along the path, change to <see cref="Agent.State.OnPartialPath" />
        /// </summary>
        protected virtual void OnCompletePathUpdate()
        {
            if (isPathBlocked)
            {
                state = State.OnPartialPath;
            }
        }

        /// <summary>
        /// Peforms the relevant path update
        /// </summary>
        protected abstract void PathUpdate();

        /// <summary>
        /// The behaviour for when the agent has been blocked
        /// </summary>
        protected abstract void OnPartialPathUpdate();


#if UNITY_EDITOR
        /// <summary>
        /// Draw the agent's path
        /// </summary>
        protected virtual void OnDrawGizmosSelected()
        {
            if (m_NavMeshAgent != null)
            {
                Vector3[] pathPoints = m_NavMeshAgent.path.corners;
                int count = pathPoints.Length;
                for (int i = 0; i < count - 1; i++)
                {
                    Vector3 from = pathPoints[i];
                    Vector3 to = pathPoints[i + 1];
                    Gizmos.DrawLine(from, to);
                }
                Gizmos.DrawWireSphere(m_NavMeshAgent.destination, 0.2f);
            }
        }
#endif
    }
}