简介

有限状态机是unity游戏开发中经常用到的一个概念，能制作敌人AI，玩家控制器等。

有限状态机允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类

实现：将一个个具体的状态类抽象出来

经典案例：玩家行动器

案例中玩家行动包括：待机、移动、跳跃、冲刺、爬墙等

而这么多状态我们再进一步将其分为：

【在墙上的状态】

【在地面的状态】

【玩家能力状态】

比较特殊的是玩家在空中的状态，我们需要做很多判断，所以不将其抽象，同样的还有冲刺状态。

新的输入系统（Input System）

在开始制作状态机前，我们需要将输入系统也更新一下：在包管理器中找到Input System 然后引入

然后在创建中找到 Input Actions 将其命名为Player

双击进入编辑窗口

设置Movement的输入

录入键盘时点击Listen然后再按你想监听的键

记得设置你的方向

然后在玩家对象上创建Player Input组件，将刚刚创建好的Input System文件挂载上去

创建C# 脚本 PlayerInputManage

public class PlayerInputManage : MonoBehaviour
{
    //新输入系统文件
    private PlayerInput playerInput;

    //初始移动输入
    public Vector2 RawMovementInput { get; private set; }

    //X：横轴输入值 Y：纵轴输入值
    public int NormInputX { get; private set; }
    public int NormInputY { get; private set; }

    private void Start()
    {
        playerInput = GetComponent<PlayerInput>();
    }

    public void OnMoveInput(InputAction.CallbackContext context) 
    {
        RawMovementInput = context.ReadValue<Vector2>();

        NormInputX = Mathf.Abs(RawMovementInput.x) > 0.5f ? (int)(RawMovementInput * Vector2.right).normalized.x : 0;
        NormInputY = Mathf.Abs(RawMovementInput.y) > 0.5f ? (int)(RawMovementInput * Vector2.up).normalized.y : 0;
    }
}

创建好后回到我们的Player Input文件，点开GamePlayer

将Player脚本挂载上去

然后在PlayerInputManage中找到刚刚写好的OnMoveInput方法

玩家数据设计

[CreateAssetMenu(fileName ="newPlayerData",menuName ="Data/Player Data/Base Data")]
public class PlayerData : ScriptableObject
{
    [Header("移动相关")]//移动速度
    public float movementVelocity = 10f;
}

创建完PlayerData脚本后，我们右键 -> 数据 ->

玩家状态设计

public class PlayerState
{
    protected Player player;
    protected PlayerStateMachine stateMachine;
    protected PlayerData playerData;

    protected float startTime;//通用计时器

    protected bool isAnimtionFinished;//动画是否完成
    protected bool isExitingState;//是否已经切换完状态

    private string animBoolName;//动画器条件切换

    //初始化
    public PlayerState(Player player, PlayerStateMachine stateMachine, PlayerData playerData,string animBoolName)
    {
        this.player = player;
        this.stateMachine = stateMachine;
        this.playerData = playerData;
        this.animBoolName = animBoolName;
    }

    // 状态开始
    public virtual void Enter()
    {
        Dochecks();
        player.Anim.SetBool(animBoolName,true);
        startTime = Time.time;
        Debug.Log(animBoolName);
        isAnimtionFinished = false;
        isExitingState = false;
    }

    // 状态结束
    public virtual void Exit()
    {
        player.Anim.SetBool(animBoolName,false);
        isExitingState = true;
    }

    // 逻辑更新
    public virtual void LogicUpdate(){ }

    // 物理更新
    public virtual void PhysicsUpdate() => Dochecks();

    // 图层检测
    public virtual void Dochecks() { }

    // 开始动画触发
    public virtual void AnimationTrigger() { }

    // 结束动画触发
    public virtual void AnimtionFinishTrigger() => isAnimtionFinished = true;
}

玩家实体设计

public class Player : MonoBehaviour
{
    //状态变量
    public PlayerStateMachine StateMachine{ get; private set;}//状态管理器

    public PlayerIdleState IdleState { get; private set; }//待机
    public PlayerMoveState MoveState { get; private set; }//移动

    //玩家数据
    [SerializeField]
    private PlayerData playerData;

    //组件变量
    public Animator Anim { get; private set;}//动画器
    public PlayerInputManage InputManage{ get; private set;}//玩家输入管理
    pubilc Rigidbody2D RB { get; private set;}//刚体

    public Vector2 CurrentVelocity { get; private set; }//当前速度
    public int FacingDirection { get; private set; }//面朝方向

    private Vector2 workspace;//工作空间

    private void Awake()
    {
        //AWake在Start前执行，且只执行一次。可用来初始化玩家状态控制器，以及玩家状态
        StateMachine = new PlayerStateMachine();

        IdleState = new PlayerIdleState(this,StateMachine,playerData,"idle");
        MoveState = new PlayerMOveState(this,StateMachine,playerData,"move");
    }

    private void Start()
    {
        //Start也只执行一次，但在AWake之后。通常是为组件赋值以及执行初始化方法
        Anim = GetComponent<Animator>();
        InputManage = GetComponent<PlayerInputManage>();
        RB = GetComponent<Rigidbody2D>();

        FacingDirection = 1;

        StateMachine.Initialize(IdleState);
    }

    private void Update()
    {
        //在每一帧执行：确定当前速度，执行当前状态的任务方法
        CurrentVelocity = RB.velocity;
        StateMachine.CurrentState.LogicUpdate();
    }

    private void FixedUpdate()
    {
        //在Update后执行但并不是每一帧都执行：常用于物理检测
        StateMachine.CurrentState.PhysicsUpdate();
    }
}

玩家状态管理类

public class PlayerStateMachine
{
    //当前状态
    public PlayerState CurrentState { get; private set; }

    //初始化状态
    public void Initialize(PlayerState startingState) 
    {
        CurrentState = startingState;
        CurrentState.Enter();
    }

    //切换状态
    public void ChangesState(PlayerState newState)
    {
        CurrentState.Exit();
        CurrentState = newState;
        CurrentState.Enter();
    }
}

玩家待机/移动

当准备好 Player(实体类)、PlayerState(状态父类)、PlayerStateMachine(状态管理类)后，就可以开始写第一个状态类来体验有限状态机的魅力。

通过设计书发现还有3个超级类：
Grounded（在地面）、TouchingWall(在墙上)、Ability(玩家能力) 它们继承于玩家状态类。

public class PlayerGroundedState : PlayerState
{
    protected int xInput;
    protected int yInput;

    public PlayerGroundedState(Player player, PlayerStateMachine stateMachine, PlayerData playerData, string animBoolName) : base(player, stateMachine, playerData, animBoolName)
    {
    }

    public override void Dochecks()
    {
        base.Dochecks();
    }

    public override void Enter()
    {
        base.Enter();
    }

    public override void Exit()
    {
        base.Exit();
    }

    public override void LogicUpdate()
    {
        base.LogicUpdate();

        xInput = player.InputManage.NormInputX;
        yInput = player.InputManage.NormInputY;
    }

    public override void PhysicsUpdate()
    {
        base.PhysicsUpdate();
    }
}

因为玩家执行待机以及移动状态时是在地上的，所以需要继承 PlayerGroundedState 这个状态。我们可以先思考一下：在待机状态需要检测什么，以及如何从待机状态切换出去？你可能会想做一个随机的待机动作，也只需要在LogicUpdate中创建随机数，然后根据随机数切换待机动画。

在视觉上我们想要玩家从移动到待机灵敏一点，也就是放开移动，玩家就立马进入待机状态。
回到Player文件中，需要设置一下玩家在X轴上的速度

public class Player : MonoBehaviour
{
    /*状态变量
    ......略
   */

    //玩家数据
    [SerializeField]
    private PlayerData playerData;

    /*组件变量
    ......略
    */

    public Vector2 CurrentVelocity { get; private set; }//当前速度
    public int FacingDirection { get; private set; }//面朝方向

    private Vector2 workspace;//工作空间

    /* Unity 默认方法
    ......略
    */

    //设置X轴的速度
    public void SetVelocityX(float velocity)
    {
        workspace.Set(velocity, CurrentVelocity.y);
        RB.velocity = workspace;
        CurrentVelocity = workspace;
    }
}

这样就可以在待机状态开始时设置玩家在X轴上的速度，你可以注释掉该行代码试一下两者的手感
因为在待机状态我们并不需要做更多物理检测，所以只需要注重逻辑执行就好。

public class PlayerIdleState : PlayerGroundedState
{
    public PlayerIdleState(Player player, PlayerStateMachine stateMachine, PlayerData playerData, string animBoolName) : base(player, stateMachine, playerData, animBoolName)
    {
    }

    public override void Dochecks()
    {
        base.Dochecks();
    }

    public override void Enter()
    {
        base.Enter();
        player.SetVelocityX(0f);
    }

    public override void Exit()
    {
        base.Exit();
    }

    public override void LogicUpdate()
    {
        base.LogicUpdate();
        if(!isExitingState)
        {//没有结束状态
            if (xInput != 0)
            {//且有X轴上的输入
                stateMachine.ChangesState(player.MoveState);
            }
            else if(yInput == -1)
           {//或有Y轴上的向下的输入
                //TODO:切换到下蹲状态
           }
        }
    }

    public override void PhysicsUpdate()
    {
        base.PhysicsUpdate();
    }
}

接着写玩家的移动状态，由于要写的是2D项目，所以需要检测玩家做左右移动旋转玩家方向，回到Playe实体类中

public class Player : MonoBehaviour
{
    /// <summary>
    /// 检测是否转向
    /// </summary>
    /// <param name="xInput">玩家x轴的输入</param>
    public void CheckIfShouldFilp(int xInput)
    {
        if (xInput != 0 && xInput != FacingDirection)
        {//当玩家输入时，输入值（1，-1）与当前面朝方向不一致时，执行转向
            Filp();
        }
    }

    private void Filp()
    {
        FacingDirection *= -1;//设置面朝方向
        RB.transform.Rotate(0.0f, 180.0f, 0.0f);
    }
}

然后继续写MoveState，同样的移动我们是在地面上，所以要继承PlayerGroundedState

public class PlayerMoveState : PlayerGroundedState
{
    public PlayerMoveState(Player player, PlayerStateMachine stateMachine, PlayerData playerData, string animBoolName) : base(player, stateMachine, playerData, animBoolName)
    {
    }

    public override void Dochecks()
    {
        base.Dochecks();
    }

    public override void Enter()
    {
        base.Enter();
    }

    public override void Exit()
    {
        base.Exit();
    }

    public override void LogicUpdate()
    {
        base.LogicUpdate();

        player.CheckIfShouldFilp(xInput);
        player.SetVelocityX(playerData.movementVelocity * xInput);

        if (!isExitingState)
        {
            if (xInput == 0)
            {
                stateMachine.ChangesState(player.IdleState);
            }
            else if (yInput == -1)
            {
                //TODO：切换到下蹲移动状态
            }
        }
    }

    public override void PhysicsUpdate()
    {
        base.PhysicsUpdate();
    }
}

做完这些就可以在动画器中创建idle、move的动画了

动画器设计

除了xVelocity、yVelocity是单独设置，其他的均为Bool在角色进入状态时执行，可以查看上面 PlayerStateMachine 中的代码

动画退出条件为animBoolName == false ,退出时间与过度时间为0是为了让状态动画间的切换更加丝滑

本栏目推荐文章
• 微软企业库Unity学习笔记(一)
• 微软企业库Unity学习笔记(二)
• NUS CS1101S：SICP JavaScript 描述：三、模块化、对象和状态
• 如何让Visual Studio Tools for Unity插件用于调试你自己的Mono嵌入应用程序
• Spring事务状态处理
• Unity 获取当前系统时间并在UI界面中显示
• 2024-01-13 antd的tabel组件业务问题之勾选了table中的一项，然后弹出弹窗，接着关闭弹窗，刷新table，但是table选中的一项还是显示被勾选中的状态 ==》你没有改变所选中的数据（selectedRowKeys）
• Windows 10 中，可以使用 PowerShell 添加打印和文件服务的角色功能组件，包括 Internet 打印客户端、LPD 打印服务和 LPR 端口监视器 PowerShell 添加打印机并创建新的 LPR 端口。以下是添加打印机和创建新端口的 PowerShell 命令在 Windows 10 中，可以使用 PowerShell 添加 LPR 兼容打印机。
• 【Unity】用Graphics.DrawMeshNow在场景中画个三角形
• 设计模式—行为型模式之状态模式

角色 状态 Unity 有限角色 状态unity有限 unity-fsm状态unity有限 状态unity有限fsm 状态 引擎unity有限 机库 状态 有限134 状态 系统 技术 有限 状态 国际 有限 状态 有限fsm 游戏角色 角色unity 射线 角色unity3d unity3