• Unity-2D游戏-打击感与敌人AI

    前言

    最近快搞毕设了，学一些Unity2D游戏开发的知识，发现b站宝藏up主奥飒姆Awesome的两个蛮不错的教程，我想简单记录一下它这个游戏设计的方法。

    我不一点点实现了，就是分析一下大致框架（方便以后套用）

    资源

    打击感

    Red hood pixel character by Legnops

    Pixel Fantasy Caves by Szadi art.

    Pixelated Attack/Hit Animations by Viktor

    成品项目链接：

    GitHub - RedFF0000/AttackSense

    敌人AI

    Animated Pixel Adventurer by rvros

    Skeleton Sprite Pack by Jesse Munguia

    成品项目链接：

    GitHub - RedFF0000/Finite-state-machine

    动作游戏打击感

    玩家配置

    我们来看主角的动画状态：

    其中，对于标准运动定义了很多，比如idle进入run，通过分析浮点型变量Horizontal来设置，因为左右都要有动画，故设置了两个Transition：

     可以看到，除了基本的idle跑跳动作，还有一个Any State，监听了任意时刻的动作，例如我选中的any state到Light Attack1，就是当触发变量LightAttack触发时，ComboStep为1时则进入，应该就是进行轻攻击的第一下：

     这些内容的控制，主要都在代码里，我们看一下人物面板配置：

     截图中的speed调大，参考数据为 moveSpeed：180、lightSpeed：25、heavySpeed：35

    来看一下PlayerController脚本，我已经把大概的注释写好了：

    1. using System.Collections;
    2. using System.Collections.Generic;
    3. using UnityEngine;
    4.  
    5. public class PlayerController : MonoBehaviour
    6. {
    7.     [Header("补偿速度")]
    8.     public float lightSpeed;
    9.     public float heavySpeed;
    10.     [Header("打击感")]
    11.     public float shakeTime;
    12.     public int lightPause;
    13.     public float lightStrength;
    14.     public int heavyPause;
    15.     public float heavyStrength;
    16.  
    17.     [Space]
    18.     public float interval = 2f;
    19.     private float timer;
    20.     private bool isAttack;
    21.     private string attackType; //攻击类型
    22.     private int comboStep; //第几段攻击
    23.  
    24.     public float moveSpeed;
    25.     public float jumpForce;
    26.     new private Rigidbody2D rigidbody;
    27.     private Animator animator;
    28.     private float input;
    29.     private bool isGround;
    30.     [SerializeField] private LayerMask layer;
    31.  
    32.     [SerializeField] private Vector3 check;
    33.  
    34.     void Start()
    35.     {
    36.         //得到刚体
    37.         rigidbody = GetComponent<Rigidbody2D>();
    38.         //得到动画状态机
    39.         animator = GetComponent<Animator>();
    40.     }
    41.     /*
    42.      * 按帧执行，适合来处理GetKeyDown
    43.      */
    44.     void Update()
    45.     {
    46.         //得到水平输入
    47.         input = Input.GetAxisRaw("Horizontal");
    48.         //得到地面检测（layer）
    49.         isGround = Physics2D.OverlapCircle(transform.position + new Vector3(check.x, check.y, 0), check.z, layer);
    50.         //将刚体水平方向速度传给动画机
    51.         animator.SetFloat("Horizontal", rigidbody.velocity.x);
    52.         //将刚体竖直方向速度传给动画机
    53.         animator.SetFloat("Vertical", rigidbody.velocity.y);
    54.         //将是否触碰地面状态传给动画机
    55.         animator.SetBool("isGround", isGround);
    56.         //攻击处理
    57.         Attack();
    58.         Jump();
    59.     }
    60.     void Jump(){
    61.         //进行跳跃
    62.         if (Input.GetButtonDown("Jump") && isGround)
    63.         {
    64.             //给刚体一个y方向的力
    65.             rigidbody.velocity = new Vector2(0, jumpForce);
    66.             //同步动画机
    67.             animator.SetTrigger("Jump");
    68.         }
    69.     }
    70.     /*
    71.      * 按固定时间间隔执行，适合来处理刚体效果
    72.      */
    73.     private void FixedUpdate()
    74.     {
    75.         //移动处理
    76.         Move();
    77.     }
    78.  
    79.  
    80.     /*
    81.      * 攻击处理函数
    82.      */
    83.     void Attack()
    84.     {
    85.         if (Input.GetKeyDown(KeyCode.J) && !isAttack) //轻击
    86.         {
    87.             //进入攻击状态
    88.             isAttack = true;
    89.             //设置攻击类型
    90.             attackType = "Light";
    91.             //攻击段数加一
    92.             comboStep++;
    93.             //还原攻击段数
    94.             if (comboStep > 3)
    95.                 comboStep = 1;
    96.             //设置攻击冷却间隔（负责自动还原攻击段数）
    97.             timer = interval;
    98.             //通知动画机
    99.             animator.SetTrigger("LightAttack");
    100.             animator.SetInteger("ComboStep", comboStep);
    101.         }
    102.         if (Input.GetKeyDown(KeyCode.K) && !isAttack) //重击
    103.         {
    104.             //重击
    105.             isAttack = true;
    106.             attackType = "Heavy";
    107.             comboStep++;
    108.             if (comboStep > 3)
    109.                 comboStep = 1;
    110.             timer = interval;
    111.             animator.SetTrigger("HeavyAttack");
    112.             animator.SetInteger("ComboStep", comboStep);
    113.         }
    114.  
    115.  
    116.         if (timer != 0)
    117.         {
    118.             timer -= Time.deltaTime;
    119.             if (timer <= 0)
    120.             {
    121.                 timer = 0;
    122.                 comboStep = 0;
    123.             }
    124.         }
    125.     }
    126.  
    127.     //攻击结束（此函数被每个攻击动画的快结束处调用）
    128.     public void AttackOver()
    129.     {
    130.         isAttack = false;
    131.     }
    132.  
    133.     /*
    134.     * 移动处理函数
    135.     */
    136.     void Move()
    137.     {
    138.         if (!isAttack)
    139.             //如果不在攻击中，则根据水平输入进行移动
    140.             rigidbody.velocity = new Vector2(input * moveSpeed * Time.fixedDeltaTime, rigidbody.velocity.y);
    141.         else
    142.         {
    143.             //根据攻击类型进行适量的移动（补偿速度）
    144.             if (attackType == "Light")
    145.                 rigidbody.velocity = new Vector2(transform.localScale.x * lightSpeed * Time.fixedDeltaTime, rigidbody.velocity.y);
    146.             else if (attackType == "Heavy")
    147.                 rigidbody.velocity = new Vector2(transform.localScale.x * heavySpeed * Time.fixedDeltaTime, rigidbody.velocity.y);
    148.         }
    149.  
    150.         //根据速度方向调整本地缩放方向（实现转向）
    151.         if (rigidbody.velocity.x < 0)
    152.             transform.localScale = new Vector3(-1, 1, 1);
    153.         else if (rigidbody.velocity.x > 0)
    154.             transform.localScale = new Vector3(1, 1, 1);
    155.     }
    156.  
    157.     /*
    158.      * 触发检测
    159.      * 玩家物体的子物体身上挂载有触发盒子
    160.      * 玩家的攻击动画会动态激活子物体并调整其子物体的区域大小
    161.      * 这里触发检测的就是子物体所触发区域
    162.      */
    163.     private void OnTriggerEnter2D(Collider2D other)
    164.     {
    165.         //触碰敌人
    166.         if (other.CompareTag("Enemy"))
    167.         {
    168.             if (attackType == "Light") //轻击中
    169.             {
    170.                 //通知攻击管理进行轻击中暂停
    171.                 AttackSense.Instance.HitPause(lightPause);
    172.                 //通知攻击管理进行轻击中镜头摇晃
    173.                 AttackSense.Instance.CameraShake(shakeTime, lightStrength); 
    174.             }
    175.             else if (attackType == "Heavy") //重击中
    176.             {
    177.                 AttackSense.Instance.HitPause(heavyPause);
    178.                 AttackSense.Instance.CameraShake(shakeTime, heavyStrength);
    179.             }
    180.  
    181.             //根据自身方向调整敌人的转向
    182.             if (transform.localScale.x > 0)
    183.                 other.GetComponent<Enemy>().GetHit(Vector2.right);
    184.             else if (transform.localScale.x < 0)
    185.                 other.GetComponent<Enemy>().GetHit(Vector2.left);
    186.         }
    187.     }
    188. }

    将移动放在fixedupdate中，跳跃放在update中。
    移动和跳跃都是通过施加力实现的。跳跃有isGround变量限制，必须触地才能跳一次，故按帧执行或者按时间执行都不影响，而按时间执行还可能导致“按键失效”，所以我们放入按帧执行中，即update中；而移动是去持续施加力，在不同帧率的主机上效果不同，所以我们应该放入fixedupdate中，按时间执行

    细看代码不难理解，其中，对攻击的触发检测，触发盒挂在在子物体上，我么可以看一下大概思路：

    可以看到，打击感的核心交给了AttackSense这个单例的类，算是个攻击管理类（攻击意识）；而敌人接收到攻击的响应，则是通过触发器获取敌人对象来设置，这样很好的对Enemy进行了封装，不管什么敌人，统统调用GetHit即可。

    攻击意识

    下面我们来看看攻击管理的单例类，这是一个挂载到相机上的类：

    1. using System.Collections;
    2. using System.Collections.Generic;
    3. using UnityEngine;
    4.  
    5. public class AttackSense : MonoBehaviour
    6. {
    7.     private static AttackSense instance;
    8.     public static AttackSense Instance
    9.     {
    10.         get
    11.         {
    12.             if (instance == null)
    13.                 instance = Transform.FindObjectOfType<AttackSense>();
    14.             return instance;
    15.         }
    16.     }
    17.     private bool isShake;
    18.  
    19.     public void HitPause(int duration)
    20.     {
    21.         StartCoroutine(Pause(duration));
    22.     }
    23.  
    24.     IEnumerator Pause(int duration)
    25.     {
    26.         float pauseTime = duration / 60f;
    27.         Time.timeScale = 0;
    28.         yield return new WaitForSecondsRealtime(pauseTime);
    29.         Time.timeScale = 1;
    30.     }
    31.  
    32.     public void CameraShake(float duration, float strength)
    33.     {
    34.         if (!isShake)
    35.             StartCoroutine(Shake(duration, strength));
    36.     }
    37.  
    38.     IEnumerator Shake(float duration, float strength)
    39.     {
    40.         isShake = true;
    41.         Transform camera = Camera.main.transform;
    42.         Vector3 startPosition = camera.position;
    43.  
    44.         while (duration > 0)
    45.         {
    46.             camera.position = Random.insideUnitSphere * strength + startPosition;
    47.             duration -= Time.deltaTime;
    48.             yield return null;
    49.         }
    50.         camera.position = startPosition;
    51.         isShake = false;
    52.     }
    53. }

    很简单

    敌人配置

    最后我们来看一下Enemy的配置，这里敌人的动画很简单：

     

    代码如下：

    1. using System.Collections;
    2. using System.Collections.Generic;
    3. using UnityEngine;
    4.  
    5. public class Enemy : MonoBehaviour
    6. {
    7.     public float speed;
    8.     private Vector2 direction;
    9.     private bool isHit;
    10.  
    11.     new private Rigidbody2D rigidbody;
    12.  
    13.     private AnimatorStateInfo info;
    14.     private Animator animator;
    15.  
    16.     void Start()
    17.     {
    18.         //得到自身动画机
    19.         animator = transform.GetComponent<Animator>();
    20.         //得到刚体
    21.         rigidbody = transform.GetComponent<Rigidbody2D>();
    22.     }
    23.  
    24.     void Update()
    25.     {
    26.         //得到自身动画机动画状态信息
    27.         info = animator.GetCurrentAnimatorStateInfo(0);
    28.         if (isHit)
    29.         {
    30.             //受到攻击回退
    31.             rigidbody.velocity = direction * speed; 
    32.             if (info.normalizedTime >= .6f)
    33.                 isHit = false;
    34.         }
    35.     }
    36.  
    37.     public void GetHit(Vector2 direction)
    38.     {
    39.         //与受攻击方向同步方向
    40.         transform.localScale = new Vector3(-direction.x, 1, 1); 
    41.         isHit = true;
    42.         //重置方向，便于回退Update中
    43.         this.direction = direction;
    44.         //同步动画状态
    45.         animator.SetTrigger("Hit");
    46.     }
    47. }

    结语

    基本配置完成，打击感满满

     

    敌方AI

    玩家配置

    玩家的配置很简单，就是正常的移动跳跃，需要更高级的配置在后面可以自己添加：

     

    敌人配置

    我们重点来看敌人配置：

    在Enemy下有两个子物体：

    • Area：一个长条的空物体。触发器，模拟敌人的检测视野
    • AttackArea：一个空物体（一个点）。将在脚本中搭配一个半径值来构成一个圆形区域，作为敌人施展攻击的触发区域

    在Enemy上，绑定着脚本FSM（有限状态机），其内容我已注释：

    1. using System;
    2. using System.Collections;
    3. using System.Collections.Generic;
    4. using UnityEngine;
    5.  
    6. //定义枚举类型
    7. public enum StateType
    8. {
    9.     //待机、巡逻、追逐、反应、攻击、被攻击、死亡
    10.     Idle, Patrol, Chase, React, Attack, Hit, Death
    11. }
    12.  
    13. [Serializable] //可序列化-在检视面板可以设置
    14. public class Parameter
    15. {
    16.     //生命值
    17.     public int health;
    18.     //巡逻速度
    19.     public float moveSpeed;
    20.     //追逐速度
    21.     public float chaseSpeed;
    22.     //待机时长（巡逻到头后待机）
    23.     public float idleTime;
    24.     //巡逻范围
    25.     public Transform[] patrolPoints;
    26.     //追逐范围
    27.     public Transform[] chasePoints;
    28.     //目标
    29.     public Transform target;
    30.     //目标所在层
    31.     public LayerMask targetLayer;
    32.     //攻击位置点
    33.     public Transform attackPoint;
    34.     //攻击位置点的半径（结合攻击位置点规划出一个攻击触发区）
    35.     public float attackArea;
    36.     //动画机
    37.     public Animator animator;
    38.     //是否受攻击
    39.     public bool getHit;
    40. }
    41. //定义有限状态机类
    42. public class FSM : MonoBehaviour
    43. {
    44.     //当前状态
    45.     private IState currentState;
    46.     //状态字典
    47.     private Dictionary<StateType, IState> states = new Dictionary<StateType, IState>();
    48.     //实例化一个parameter对象
    49.     public Parameter parameter;
    50.     void Start()
    51.     {
    52.         //给字典添加各个枚举类型对应的各个对象
    53.         states.Add(StateType.Idle, new IdleState(this));
    54.         states.Add(StateType.Patrol, new PatrolState(this));
    55.         states.Add(StateType.Chase, new ChaseState(this));
    56.         states.Add(StateType.React, new ReactState(this));
    57.         states.Add(StateType.Attack, new AttackState(this));
    58.         states.Add(StateType.Hit, new HitState(this));
    59.         states.Add(StateType.Death, new DeathState(this));
    60.  
    61.         //初始化状态为Idle状态（转换为Idle状态）
    62.         TransitionState(StateType.Idle);
    63.  
    64.         //初始化参数中的动画机
    65.         parameter.animator = transform.GetComponent<Animator>();
    66.     }
    67.  
    68.     void Update()
    69.     {
    70.         //当前状态更新
    71.         currentState.OnUpdate();
    72.  
    73.         //模拟受到攻击（按下回车）
    74.         if (Input.GetKeyDown(KeyCode.Return))
    75.         {
    76.             //参数对象设置受到攻击
    77.             parameter.getHit = true;
    78.         }
    79.     }
    80.  
    81.     /* 状态转换
    82.      * 
    83.      */
    84.     public void TransitionState(StateType type)
    85.     {
    86.         //当前已有状态，做退出工作
    87.         if (currentState != null)
    88.             currentState.OnExit();
    89.         //更改当前状态
    90.         currentState = states[type];
    91.         //做进入状态工作
    92.         currentState.OnEnter();
    93.     }
    94.     /* 翻转
    95.      * 根据目标位置转向
    96.      */
    97.     public void FlipTo(Transform target)
    98.     {
    99.         if (target != null)
    100.         {
    101.             if (transform.position.x > target.position.x)
    102.             {
    103.                 transform.localScale = new Vector3(-1, 1, 1);
    104.             }
    105.             else if (transform.position.x < target.position.x)
    106.             {
    107.                 transform.localScale = new Vector3(1, 1, 1);
    108.             }
    109.         }
    110.     }
    111.     //碰到玩家触发（触发器是子物体Area）
    112.     private void OnTriggerEnter2D(Collider2D other)
    113.     {
    114.         if (other.CompareTag("Player"))
    115.         {
    116.             parameter.target = other.transform;
    117.         }
    118.     }
    119.     //退出触发
    120.     private void OnTriggerExit2D(Collider2D other)
    121.     {
    122.         if (other.CompareTag("Player"))
    123.         {
    124.             parameter.target = null;
    125.         }
    126.     }
    127.  
    128.     private void OnDrawGizmos()
    129.     {
    130.         Gizmos.DrawWireSphere(parameter.attackPoint.position, parameter.attackArea);
    131.     }
    132. }

    可以看到，原作者是通过状态机来实现AI的，将各个状态封装成对象，全部继承自接口：

    1. public interface IState
    2. {
    3.     void OnEnter();
    4.  
    5.     void OnUpdate();
    6.  
    7.     void OnExit();
    8. }

    下面我们来一个个看，代码上我就省略头文件的引用了：

    1. using System.Collections;
    2. using System.Collections.Generic;
    3. using UnityEngine;

    待机状态：

    1. /*
    2.  * 待机状态
    3.  */
    4. public class IdleState : IState
    5. {
    6.     //一个有限状态机
    7.     private FSM manager;
    8.     //一个参数汇总对象
    9.     private Parameter parameter;
    10.  
    11.     private float timer;
    12.     //初始化
    13.     public IdleState(FSM manager)
    14.     {
    15.         this.manager = manager;
    16.         this.parameter = manager.parameter;
    17.     }
    18.     public void OnEnter()
    19.     {
    20.         //参数对象的动画机播放待机动画（待机动画是循环的）
    21.         parameter.animator.Play("Idle");
    22.     }
    23.  
    24.     public void OnUpdate()
    25.     {
    26.         //计时器累积（单位秒）
    27.         timer += Time.deltaTime;
    28.  
    29.         //待机状态被打
    30.         if (parameter.getHit)
    31.         {
    32.             //转换状态到Hit
    33.             manager.TransitionState(StateType.Hit);
    34.         }
    35.         //发现目标且目标距离在追捕范围内
    36.         if (parameter.target != null &&
    37.             parameter.target.position.x >= parameter.chasePoints[0].position.x &&
    38.             parameter.target.position.x <= parameter.chasePoints[1].position.x)
    39.         {
    40.             //进入反应状态
    41.             manager.TransitionState(StateType.React);
    42.         }
    43.         //计时器超过待机时间
    44.         if (timer >= parameter.idleTime)
    45.         {
    46.             //转换回巡逻状态
    47.             manager.TransitionState(StateType.Patrol);
    48.         }
    49.     }
    50.  
    51.     public void OnExit()
    52.     {
    53.         //计时器归零
    54.         timer = 0;
    55.     }
    56. }

    巡逻状态：

    1. /*
    2.  * 巡逻状态
    3.  */
    4. public class PatrolState : IState
    5. {
    6.     private FSM manager;
    7.     private Parameter parameter;
    8.  
    9.     private int patrolPosition;
    10.     //初始化
    11.     public PatrolState(FSM manager)
    12.     {
    13.         this.manager = manager;
    14.         this.parameter = manager.parameter;
    15.     }
    16.     public void OnEnter()
    17.     {
    18.         //播放走路动画
    19.         parameter.animator.Play("Walk");
    20.     }
    21.  
    22.     public void OnUpdate()
    23.     {
    24.         //根据巡逻位置转向
    25.         manager.FlipTo(parameter.patrolPoints[patrolPosition]);
    26.         //位移
    27.         manager.transform.position = Vector2.MoveTowards(manager.transform.position,
    28.             parameter.patrolPoints[patrolPosition].position, parameter.moveSpeed * Time.deltaTime);
    29.  
    30.         if (parameter.getHit)
    31.         {
    32.             manager.TransitionState(StateType.Hit);
    33.         }
    34.         if (parameter.target != null &&
    35.             parameter.target.position.x >= parameter.chasePoints[0].position.x &&
    36.             parameter.target.position.x <= parameter.chasePoints[1].position.x)
    37.         {
    38.             manager.TransitionState(StateType.React);
    39.         }
    40.         if (Vector2.Distance(manager.transform.position, parameter.patrolPoints[patrolPosition].position) < .1f)
    41.         {
    42.             manager.TransitionState(StateType.Idle);
    43.         }
    44.     }
    45.  
    46.     public void OnExit()
    47.     {
    48.         //巡逻点下标更新
    49.         patrolPosition++;
    50.  
    51.         if (patrolPosition >= parameter.patrolPoints.Length)
    52.         {
    53.             patrolPosition = 0;
    54.         }
    55.     }
    56. }

    追捕状态：

    1. /*
    2.  * 追捕状态
    3.  */
    4. public class ChaseState : IState
    5. {
    6.     private FSM manager;
    7.     private Parameter parameter;
    8.  
    9.     public ChaseState(FSM manager)
    10.     {
    11.         this.manager = manager;
    12.         this.parameter = manager.parameter;
    13.     }
    14.     public void OnEnter()
    15.     {
    16.         //播放走路动画（Walk动画循环）
    17.         parameter.animator.Play("Walk");
    18.     }
    19.  
    20.     public void OnUpdate()
    21.     {
    22.         //根据目标位置转向
    23.         manager.FlipTo(parameter.target);
    24.         //有目标则一直走
    25.         if (parameter.target)
    26.             manager.transform.position = Vector2.MoveTowards(manager.transform.position,
    27.             parameter.target.position, parameter.chaseSpeed * Time.deltaTime);
    28.  
    29.         if (parameter.getHit)
    30.         {
    31.             manager.TransitionState(StateType.Hit);
    32.         }
    33.         if (parameter.target == null ||
    34.             manager.transform.position.x < parameter.chasePoints[0].position.x ||
    35.             manager.transform.position.x > parameter.chasePoints[1].position.x)
    36.         {
    37.             manager.TransitionState(StateType.Idle);
    38.         }
    39.         if (Physics2D.OverlapCircle(parameter.attackPoint.position, parameter.attackArea, parameter.targetLayer))
    40.         {
    41.             manager.TransitionState(StateType.Attack);
    42.         }
    43.     }
    44.  
    45.     public void OnExit()
    46.     {
    47.  
    48.     }
    49. }

    反应状态：

    1. /*
    2.  * 反应状态
    3.  */
    4. public class ReactState : IState
    5. {
    6.     private FSM manager;
    7.     private Parameter parameter;
    8.  
    9.     //得到动画状态
    10.     private AnimatorStateInfo info;
    11.     public ReactState(FSM manager)
    12.     {
    13.         this.manager = manager;
    14.         this.parameter = manager.parameter;
    15.     }
    16.     public void OnEnter()
    17.     {
    18.         parameter.animator.Play("React");
    19.     }
    20.  
    21.     public void OnUpdate()
    22.     {
    23.         //得到当前动画状态
    24.         info = parameter.animator.GetCurrentAnimatorStateInfo(0);
    25.  
    26.         if (parameter.getHit)
    27.         { 
    28.             manager.TransitionState(StateType.Hit);
    29.         }
    30.         //播放动画快结束，则进入追捕状态
    31.         if (info.normalizedTime >= .95f)
    32.         {
    33.             manager.TransitionState(StateType.Chase);
    34.         }
    35.     }
    36.  
    37.     public void OnExit()
    38.     {
    39.  
    40.     }
    41. }

    攻击状态

    1. /*
    2.  * 攻击状态
    3.  */
    4. public class AttackState : IState
    5. {
    6.     private FSM manager;
    7.     private Parameter parameter;
    8.  
    9.     private AnimatorStateInfo info;
    10.     public AttackState(FSM manager)
    11.     {
    12.         this.manager = manager;
    13.         this.parameter = manager.parameter;
    14.     }
    15.     public void OnEnter()
    16.     {
    17.         //进入攻击动画
    18.         parameter.animator.Play("Attack");
    19.     }
    20.  
    21.     public void OnUpdate()
    22.     {
    23.         info = parameter.animator.GetCurrentAnimatorStateInfo(0);
    24.  
    25.         if (parameter.getHit)
    26.         {
    27.             manager.TransitionState(StateType.Hit);
    28.         }
    29.         if (info.normalizedTime >= .95f)
    30.         {
    31.             manager.TransitionState(StateType.Chase);
    32.         }
    33.     }
    34.  
    35.     public void OnExit()
    36.     {
    37.  
    38.     }
    39. }

    受攻击状态：

    1. /*
    2.  * 受攻击状态
    3.  */
    4. public class HitState : IState
    5. {
    6.     private FSM manager;
    7.     private Parameter parameter;
    8.  
    9.     private AnimatorStateInfo info;
    10.     public HitState(FSM manager)
    11.     {
    12.         this.manager = manager;
    13.         this.parameter = manager.parameter;
    14.     }
    15.     public void OnEnter()
    16.     {
    17.         //播放动画，
    18.         parameter.animator.Play("Hit");
    19.         //掉血
    20.         parameter.health--;
    21.     }
    22.  
    23.     public void OnUpdate()
    24.     {
    25.         info = parameter.animator.GetCurrentAnimatorStateInfo(0);
    26.  
    27.         if (parameter.health <= 0)
    28.         {
    29.             //死亡
    30.             manager.TransitionState(StateType.Death);
    31.         }
    32.         if (info.normalizedTime >= .95f)
    33.         {
    34.             parameter.target = GameObject.FindWithTag("Player").transform;
    35.  
    36.             manager.TransitionState(StateType.Chase);
    37.         }
    38.     }
    39.  
    40.     public void OnExit()
    41.     {
    42.         parameter.getHit = false;
    43.     }
    44. }

    死亡状态：

    1. /*
    2.  * 死亡状态
    3.  */
    4. public class DeathState : IState
    5. {
    6.     private FSM manager;
    7.     private Parameter parameter;
    8.  
    9.     public DeathState(FSM manager)
    10.     {
    11.         this.manager = manager;
    12.         this.parameter = manager.parameter;
    13.     }
    14.     public void OnEnter()
    15.     {
    16.         parameter.animator.Play("Dead");
    17.     }
    18.  
    19.     public void OnExit()
    20.     {
    21.         throw new System.NotImplementedException();
    22.     }
    23.  
    24.     public void OnUpdate()
    25.     {
    26.         throw new System.NotImplementedException();
    27.     }
    28. }

    结语

    功能基本完成。

  • 相关阅读:
    利用Python爬虫 爬取金融期货数据
    释放WebKit潜能：硬件加速的秘诀与实战
    C语言：static，volatile，const，extern，register，auto, 栈stack结构
    一篇让你使用vue-cli搭建SPA项目
    【机器学习5】无监督学习聚类
    Java 加载、编辑和保存WPS表格文件（.et/.ett）
    C语言-数组指针与指针数组
    《吐血整理》高级系列教程-吃透Fiddler抓包教程(29)-Fiddler如何抓取Android7.0以上的Https包-终篇
    vue3 父子组件之间的方法调用
    C++入门
  • 原文地址：https://blog.csdn.net/m0_46378049/article/details/128078913