Udemy-Unity制作类暗黑破坏神游戏记录-P60

admin

设置AI自动巡逻，追逐玩家时，分别为不同的移动速度，由于我们使用的自动寻路，所以在脚本中通过一个变量来设置navMeshAgent的速度，这样我们可以通过变量来自定义玩家和AI的速度，在移动逻辑部分，设置一个浮点值。通过浮点值来设置AI在巡逻时为行走状态，追逐玩家时为跑步状态。
移动部分因为动画资源和教程不同，所以使用了寻路时的速度/10，然后把这个速度传给动画状态机做动画的更新

Mover:

using RPG.Combat;
using RPG.Core;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.UI;

//角色的移动
namespace RPG.Movement
{

    public class Mover : MonoBehaviour,IAction
    {
        
        [SerializeField] float maxSpeed = 6f;//最大速度

        private NavMeshAgent navMeshAgent;
        
        Animator animator;
        Health health;
        CapsuleCollider capsuleCollider;

        private void Start()
        {
            animator = GetComponent<Animator>();
            navMeshAgent = GetComponent<NavMeshAgent>();
            health = GetComponent<Health>();
            capsuleCollider = GetComponent<CapsuleCollider>();
        }

        private void Update()
        {
            if (health.IsDead())
            {
                capsuleCollider.enabled = false;//关闭碰撞
                navMeshAgent.enabled = false;//关闭寻路
            }
            
            UpdateAnimator();
        }

        /// <summary>
        /// 开始移动行为
        /// </summary>
        /// <param name="destination">移动的位置</param>
        public void StartMoveAction(Vector3 destination,float speedFraction)
        {
            GetComponent<ActionScheduler>().StartAction(this);
            
            MoveTo(destination,speedFraction);
        }

        /// <summary>
        /// 寻路移动到射线检测点
        /// </summary>
        /// <param name="hit"></param>
        public void MoveTo(Vector3 destination,float speedFraction)
        {
            navMeshAgent.destination = destination;//获取寻路目的地 = 射线碰撞的点
            navMeshAgent.speed = maxSpeed * Mathf.Clamp01(speedFraction);//设置速度的浮动值
            navMeshAgent.isStopped = false;
        }

        /// <summary>
        /// 停止寻路
        /// </summary>
        public void Cancel()
        {
            navMeshAgent.isStopped = true;
        }

        

        /// <summary>
        /// 动画更新
        /// </summary>
        private void UpdateAnimator()
        {
            Vector3 velocity = navMeshAgent.velocity;//创建寻路速度
            Vector3 localVelocity = transform.InverseTransformDirection(velocity);// 将世界向前变换到本地空间：
            float speed = localVelocity.z;
            //print("AI"+speed);

             animator.SetFloat("forwardSpeed", speed/10);
           
        }

        
    }
}
复制代码

AIController:

using RPG.Combat;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using RPG.Movement;
using RPG.Core;
using System;


namespace RPG.Control
{
    //AI的控制
    public class AIController : MonoBehaviour
    {
        [SerializeField] float chaseDistance = 5f;// 设定追逐范围的距离
        [SerializeField] float suspicionTime = 4f;//丢失目标后原地等待时间
        [SerializeField] float waypointDwellTime = 3f;//倒地巡逻点之后等待时间
        [SerializeField] PatrolPath patrolPath;//巡逻点
        [SerializeField] float waypointTolerance = 1f;//到达巡逻点允许的误差范围
        [Range(0f, 1f)]
        [SerializeField] float patrolSpeedFraction = 0.5f;//设置巡逻时的移动速度百分比
       

        float timeSinceLastSawPlayer = Mathf.Infinity;//最后一次看见玩家的时间 时间计时器 设置无限大
        float timeSinceArrivedAtWaypoint = Mathf.Infinity;//到达巡逻点后 时间计时器 设置无限大
        int currentWaypointIndex = 0;//当前巡逻点数量

        Vector3 guardPosition;//默认位置

        //组件
        Fighter fighter;
        Health health;
        Mover mover;
        GameObject player;
        

        

        private void Start()
        {
            fighter = GetComponent<Fighter>();
            health = GetComponent<Health>();
            player = GameObject.FindWithTag("Player");// 找到标签为“Player”的游戏对象
            mover = GetComponent<Mover>();
            guardPosition = transform.position;
        }

        private void Update()
        {
            if (health.IsDead()) return;//如果角色已经死亡，则跳出


            // 如果和玩家的距离小于追逐范围 并且可以攻击玩家
            if (InAttackRangeOfPlayer() && fighter.CanAttack(player))
            {
                AttackBehaviour();//开始攻击
            }
            else if (timeSinceLastSawPlayer < suspicionTime )//失去对玩家的视线后,怀疑时间
            {
                SuspicionBehaviour();//原地待机
            }
            else
            {
                PatrolBehaviour();//进入巡逻
            }

            UpdateTimes();
        }

        private void UpdateTimes()//计时器更新
        {
            timeSinceLastSawPlayer += Time.deltaTime;
            timeSinceArrivedAtWaypoint += Time.deltaTime;
        }

        private void PatrolBehaviour()//巡逻行为
        {
            Vector3 nectPoition = guardPosition; // 默认巡逻点设为守卫的起始位置

            if (patrolPath != null)// 如果存在巡逻路径
            {
                if(AtWaypoint())// 如果到达当前巡逻点
                {
                    timeSinceArrivedAtWaypoint = 0f;//重置巡逻计时器为0
                    CycleWaypoint();// 切换到下一个巡逻点
                   
                }
                nectPoition = GetCurrentWaypoint();// 获取当前巡逻点的位置
            }
            
            if(timeSinceArrivedAtWaypoint >waypointDwellTime)//如果计时器大于巡逻的待机时间
            {
                mover.StartMoveAction(nectPoition,patrolSpeedFraction);// 开始移动到当前巡逻点，设定巡逻时的移动速度，默认设定为0.5
            }
            
           
        }

      
        private bool AtWaypoint()// 检查是否到达巡逻点
        {
            // 计算当前位置与当前巡逻点之间的距离
            float distanceToWaypoint = Vector3.Distance(transform.position,GetCurrentWaypoint());
            return distanceToWaypoint <waypointTolerance; // 判断是否小于允许的误差范围
        }

        private void CycleWaypoint()// 切换到下一个巡逻点
        {
            // 更新当前巡逻点的索引
            currentWaypointIndex = patrolPath.GetNextIndex(currentWaypointIndex);
        }

        private Vector3 GetCurrentWaypoint()// 获取当前巡逻点的位置
        {
            // 从巡逻路径中获取当前巡逻点的位置
            return patrolPath.GetWaypoint(currentWaypointIndex);
        }


        private void SuspicionBehaviour()//丢失目标后，取消当前任何行为
        {
            GetComponent<ActionScheduler>().CancelCurrentAction();
        }

        private void AttackBehaviour()//攻击行为
        {
            timeSinceLastSawPlayer = 0;//重置为0
            fighter.Attack(player);//对玩家进行攻击
        }

        private bool InAttackRangeOfPlayer() // 检测是否在攻击范围内
        {
            float distanceToPlayer = Vector3.Distance(player.transform.position,transform.position); // 计算并返回玩家和当前对象之间的距离
            return distanceToPlayer < chaseDistance;//返回两者之间距离是否小于追逐距离
        }

        private void OnDrawGizmosSelected()//绘制线框球体
        {
            Gizmos.color = Color.yellow;
            Gizmos.DrawWireSphere(transform.position, chaseDistance);
        }
    }
}

复制代码

Fighter:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using RPG.Movement;
using RPG.Core;


namespace RPG.Combat
{
    //攻击
    public class Fighter : MonoBehaviour, IAction
    {
        [SerializeField] float weaponRange = 2f;// 武器范围，表示武器可以攻击的最大距离
        [SerializeField] float timeBetweenAttacks = 1f;//攻击间隔时间
        [SerializeField] float weaponDamage = 5f;//武器伤害

        Health target;// 当前攻击的目标
        float timeSinceLastAttack = Mathf.Infinity;//上次攻击的时间为 为无穷大

        private Mover mover;// 用于移动角色的 Mover 组件
        private bool isInRange;// 标记目标是否在攻击范围内

        private Animator animator;

        private void Start()
        {
            mover = GetComponent<Mover>();// 获取 Mover 组件
            animator = GetComponent<Animator>();//获取动画组件
           
        }

        private void Update()
        {

            timeSinceLastAttack += Time.deltaTime;//设置攻击后的时间统计累加

           

            if (target == null) return;// 如果目标为空，则不进行任何操作

            if (target.IsDead()) return;//如果目标已经死亡，直接return

            if (!GetIsInRange()) // 如果目标不在攻击范围内，则移动到目标位置
            {
                mover.MoveTo(target.transform.position,1f);//设置战斗时百分比为1
                
            }
            else
            {
                mover.Cancel(); // 目标在攻击范围内，取消移动，并触发攻击动画

                AttackBehaviour();
            }
        }

        private void AttackBehaviour()//攻击行为
        {
            transform.LookAt(target.transform.position);//攻击时面向敌人
            if (timeSinceLastAttack > timeBetweenAttacks)//任何时候都大于攻击间隔
            {
                TriggerAttack();
                timeSinceLastAttack = 0;//重置攻击后的时间为0


            }
        }

        
        private void TriggerAttack()//动画状态机 攻击触发
        {
            animator.ResetTrigger("stopAttack");
            animator.SetTrigger("attack");
        }

        // 动画事件：攻击时触发的事件
        private void Hit()
        {
           if (target == null) return;
            target.TakeDamage(weaponDamage);//造成伤害
        }


        private bool GetIsInRange()// 检查目标是否在攻击范围内
        {
            return Vector3.Distance(transform.position, target.transform.position) < weaponRange;
        }

        public bool CanAttack(GameObject combatTarget)//检测是否可以攻击
        {
            if(combatTarget == null) //如果攻击目标为空 跳出
            {
                return false;
            }
            Health targetToTest = combatTarget.GetComponent<Health>();//获取目标的生命组件
            return targetToTest != null && !targetToTest.IsDead();//目标不为空，并且没有死亡
        }

        public void Attack(GameObject combatTarget)//攻击
        {
            
            GetComponent<ActionScheduler>().StartAction(this); // 启动当前动作并设置目标
            target = combatTarget.GetComponent<Health>();//获取目标的生命组件

        }

        public void Cancel()//取消
        {
            StopAttack();//调用停止攻击
            target = null;//清除目标
        }

        private void StopAttack()//动画状态机 停止攻击
        {
            animator.ResetTrigger("attack");//重置攻击
            animator.SetTrigger("stopAttack");//播放暂停攻击
        }
    }
}
复制代码