Unity中的AI算法和实现2-有限状态机FSM(上)

Posted 2023-04-02 拂面清风三点水

本文分享Unity中的AI算法和实现2-有限状态机FSM(上)

在上一篇文章中, 我们基于Waypoint构建了一个最简单的AI怪物, 这个怪物可以在几个点之间巡逻.

本篇文章会在此基础之上, 添加怪物在巡逻过程中发现玩家并追逐玩家, 并且在距离玩家一定距离之后脱离追逐然后继续进行巡逻.

在添加两个状态之前, 我们先介绍什么是有限状态机(Finite State Machine, FSM).

有限状态机FSM

FSM顾名思义, 是一个"有限的", “状态机”. 状态机说的是, 这是一种管理状态的机器, 有限说的是这些状态是有限的.

也就是说我们可以用一种"机器"来管理有限的一些状态.

而这正好可以满足我们的需求, 因为怪物的AI就是有各种状态, 然后在合适的条件下在状态之间进行转换.

“状态(State)”, “转换(Transition)”, “转换的条件(Condition)”, 再加上一个负责管理各个状态和转换的"管理器(Manager)", 就组成了一个FSM.

Unity中的Animator就是一个典型的FSM, 想必大家已经不陌生了.

为了避免太过抽象, 我们下面借助Animator来介绍FSM的概念, 并添加我们要用到的两个状态.

借助Animator设计状态机

首先我们要知道, 现在怪物有两个状态(巡逻和发现玩家), 并在两个状态之间有切换条件.

新建一个Animator, 添加两个状态, 两个转换和一个条件(条件参数).

其中Animator对应管理器, Patrol和SeeGamer对应两个状态, 两个白色的箭头对应两个转换, 参数SeeGamer为对应条件, 黄色代表是默认状态.

大家可能会对转换和条件有一些迷糊, 这里多说几句.

转换也可以说是"过渡(这个词可能比较好理解一点)", 和状态一样, 也是一个过程, 可以理解为是一个特殊的状态, 而条件是触发转换, 转换的结果是状态: 条件=>转换=>状态.

所以一个转换可以有很多的条件, 当所有的条件都满足时, 会触发转换过程的发生, 转换完成后状态机就进入了一个新的状态.

有一些FSM会将转换设计的复杂一点, 比如Unity的Animator, 她支持多个条件, 多个转换, 支持转换过程等, 如图:

上面说明的是, Patrol到SeeGamer状态的转换, 然后这个这个转换有两个条件, 参数SeeGamer = true且移动速度Speed > 5.

而我们要实现的FSM比较简单, 只有一个条件而且转换立马完成, 但是支持多个条件和转换, 大家理解核心之后可以自由扩展.

设置好Animator之后, 在各自的状态更新的时候, 判断条件满足后设置对应的参数就能完成我们的目标.

这里我们就不演示Animator了, 后面有机会就动画相关的知识写一个专栏再介绍吧.

设计我们自己的FSM

上面借助Unity的Animator对FSM有了简单的理解, 我们知道了我们需要的几个角色:

• 状态机管理器(相当于Animator): FSMMgr
• 状态类: FSMState
• 转换类: FSMTransitionBase
• 转换条件类: FSMTransitionCondition
• 数据管理类: DataMgr, 用于记录一些数据供访问, 比如怪物移动速度等
• 状态机控制器(相当于我们手动在Unity中创建状态, 添加参数等): FSMController

上面四个属于框架层, 最后两个属于业务层, 下我们从简单到复杂依次介绍.

FSMTransitionCondition

状态转换条件类, 用于判断对应的转换是否需要进行.

这里的实现参考了Unity的源码, 一个string Parameter表示参数名, 一个float Threshold表示参数的参考值, 然后通过枚举FSMTransitionConditionMode定义的方式来判断是否满足条件.

完整的代码和使用示例如下(因为可能不太好理解, 所以写了一个简单的使用示例):

public enum FSMTransitionConditionMode

    IfTrue = 0, // Threshold != 0
    IfFalse,

    Greater,
    Less,
    Equal,


public class FSMTransitionCondition

    /// <summary>
    /// 条件参数名
    /// </summary>
    public string Parameter  get; set; 

    /// <summary>
    /// 条件参数值
    /// </summary>
    public float Threshold  get; set; 

    /// <summary>
    /// 条件判断方式
    /// </summary>
    public FSMTransitionConditionMode Mode  get; set; 


public static class Test

    public static void Main()
    
        // Controller中初始化
        var condition = new FSMTransitionCondition()
         Parameter = "Speed", Threshold = 0, Mode = FSMTransitionConditionMode.Greater ;

        // Controller或者状态中设置参数
        var speed = 1f;
        
        // mgr中判断
        var isDone = false;
        if (condition.Parameter == "Speed" && condition.Mode == FSMTransitionConditionMode.Greater)
        
            isDone = speed > condition.Threshold;
        
    

FSMTransitionBase

状态转换类, 负责记录转换条件, 转换目标, 也可以维护转换过程(本文未实现).

public class FSMTransitionBase

    /// <summary>
    /// 用于标识转换, 唯一
    /// </summary>
    public int TransitionName  get; protected set; 

    /// <summary>
    /// 转换条件列表
    /// </summary>
    public List<FSMTransitionCondition> Conditions = new List<FSMTransitionCondition>();

    /// <summary>
    /// 源状态
    /// </summary>
    public FSMStateBase SourceState  get; private set; 

    /// <summary>
    /// 目标状态
    /// </summary>
    public FSMStateBase TargetState  get; private set; 

    public FSMTransitionBase(FSMStateBase sourceState, FSMStateBase targetState)
    
        TargetState = targetState;
        SourceState = sourceState;
    

    public void AddCondition(string parameter, FSMTransitionConditionMode mode, float threshold = 0f)
    
        Conditions.Add(new FSMTransitionCondition()
        
            Parameter = parameter,
            Threshold = threshold,
            Mode = mode
        );
    

FSMStateBase

状态类, FSM主要的部分, 用于标识整个状态机当前的状态, 同时负责维护所有相关的转换类, 并拥有相应的生命周期.

/// <summary>
/// 状态机类型
/// </summary>
public enum FSMStateType

    None,


/// <summary>
/// 状态机状态基类
/// </summary>
public abstract class FSMStateBase

    /// <summary>
    /// 状态类型, FSMStateType
    /// </summary>
    public int StateType  get; protected set; 

    /// <summary>
    /// 所有的转换
    /// </summary>
    public Dictionary<int, FSMTransitionBase> Transitions  get; private set;  = new Dictionary<int, FSMTransitionBase>();

    /// <summary>
    /// 状态机管理器, 进入状态时从外部传入
    /// </summary>
    public FSMMgr StateMgr  get; protected set; 

    /// <summary>
    /// 状态拥有者, 一般是Mono对象
    /// </summary>
    public object StateOwner  get; protected set; 

    protected FSMStateBase(int stateType, object owner)
    
        StateType = stateType;
        StateOwner = owner;
    

    public void RegisterTransition(FSMTransitionBase transition)
    
        var transitionType = transition.TransitionName;
        if (Transitions.ContainsKey(transition.TransitionName))
        
            Debug.LogError($"重复注册: transition.TransitionName:transition.TargetState.StateType.");
            return;
        

        Transitions.Add(transitionType, transition);
    

    /// <summary>
    /// 进入状态
    /// </summary>
    public virtual void OnEnter(FSMMgr mgr)
    
        if (mgr == null)
        
            Debug.LogError("状态切换必须添加管理器!");
            return;
        

        Debug.Log($"切换到this.");

        StateMgr = mgr;
    

    /// <summary>
    /// 进入状态之后
    /// </summary>
    public virtual void OnExit()
    
        StateMgr = null;
    

    /// <summary>
    /// 状态更新
    /// </summary>
    public abstract void OnRunning();

    public override string ToString()
    
        return $"(FSMStateType)StateType状态";
    

FSMMgr

状态机管理器, 用于管理所有状态的注册, 判断, 切换等.

/// <summary>
/// 状态机管理器
/// </summary>
public class FSMMgr

    /// <summary>
    /// 所有注册的状态
    /// </summary>
    private Dictionary<int, FSMStateBase> m_AllState = new Dictionary<int, FSMStateBase>();

    private FSMStateBase m_CurrentState;

    /// <summary>
    /// boolean类型的参数, 这里为了简单, 只维护一个类型
    /// </summary>
    private Dictionary<string, bool> m_BooleanParameters = new Dictionary<string, bool>();

    // 同理, 只实现了布尔类型
    public void SetBool(string parameter, bool value)
    
        if (m_BooleanParameters.ContainsKey(parameter))
            m_BooleanParameters[parameter] = value;
        else
        
            m_BooleanParameters.Add(parameter, value);
        
    

    public void RegisterState(FSMStateBase state)
    
        if (m_AllState.ContainsKey(state.StateType))
        
            Debug.LogError($"重复注册: state.StateType.");
            return;
        

        m_AllState.Add(state.StateType, state);
    

    public void ChangeState(FSMStateBase state)
    
        if (!m_AllState.TryGetValue(state.StateType, out var newState))
        
            Debug.LogWarning($"错误的状态切换: current: m_CurrentState?.StateType, next: state.StateType");
            return;
        

        m_CurrentState?.OnExit();
        m_CurrentState = newState;

        newState.OnEnter(this);
    

    public void OnRunning()
    
        if (m_CurrentState == null) return;

        m_CurrentState.OnRunning();

        FSMTransitionBase satisfiedTransition = null;
        var transitions = m_CurrentState.Transitions;
        foreach (var transition in transitions)
        
            var transitionSatisfied = true; // 无条件则直接满足
            var conditions = transition.Value.Conditions;
            foreach (var condition in conditions)
            
                var oneConditionSatisfied = false;
                if (condition.Mode == FSMTransitionConditionMode.IfTrue ||
                    condition.Mode == FSMTransitionConditionMode.IfFalse)
                 // 这里只处理了布尔类型的参数
                    if (!m_BooleanParameters.TryGetValue(condition.Parameter, out var pair))
                    
                        Debug.LogError($"条件参数不存在condition.Parameter!");
                        return;
                    

                    if (pair && condition.Mode == FSMTransitionConditionMode.IfTrue)
                    
                        oneConditionSatisfied = true;
                    
                    else if (!pair && condition.Mode == FSMTransitionConditionMode.IfFalse)
                    
                        oneConditionSatisfied = true;
                    
                

                if (!oneConditionSatisfied)
                 // 只有要一个条件不满足则中断
                    transitionSatisfied = false;
                    break;
                
            

            if (transitionSatisfied)
             // 满足条件, 转换开始
                satisfiedTransition = transition.Value;
                break;
            
        

        if (satisfiedTransition == null) return;

        // 满足条件, 转换开始. 这里只是简单的直接转换, 实际项目里也可以做转换的过程
        ChangeState(satisfiedTransition.TargetState);
    

总结

今天介绍了状态机的基本知识, 并且借助Unity的Animator来理解和设计我们自己的状态机.

因为内容比较多, 所以分成了上下两篇, 这篇文字主要介绍理论知识和实现框架层的部分.

下篇文章将继续介绍业务层部分: Controller和DataMgr, 并且在Unity中构建简单的场景来完整的运行我们的状态机.

好了, 今天就是这些, 希望对大家有所帮助.

Unity中的有限状态机FSM

一：什么是有限状态机？

在游戏的战斗系统开发中，角色都会有很多的状态，我们需要对这些状态进行处理以及状态之间的转换，最简单的方式是在一个Switch中进行判断，在每一个case分支中进行相应的状态处理和转换条件的判断，但是这种方式不利于扩展，每当添加新的状态都需要修改Switch-case中的代码，违背了对修改关闭对扩展开放的开闭原则，而使用有限状态机可以更好的扩展，后期加入新状态时，只需编写继承状态基类的状态类并添加实现

---

二：使用方法

——声明若干个继承BaseState的状态类并实现OnEnter、OnStay、OnExit方法
——使用AddState将每个状态添加到状态字典中
——在Update中调用OnStay

---

三：代码实现

using System;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 状态基类
/// </summary>
public abstract class BaseState
{
    public abstract void OnEnter(FSMSystem fsm);
    public abstract void OnStay(FSMSystem fsm, GameObject obj);
    public abstract void OnExit(FSMSystem fsm);
}

/// <summary>
/// 有限状态机
/// </summary>
public class FSMSystem
{
    private Dictionary<Type, BaseState> stateCache = new Dictionary<Type, BaseState>();//所有状态

    //当前状态
    private BaseState curState;
    public BaseState CurState { get { return curState; } }

    /// <summary>
    /// 添加状态
    /// </summary>
    public void AddState(BaseState state)
    {
        if (stateCache.ContainsKey(state.GetType()))
        {
            Debug.LogError("已经存在此状态：" + state.GetType());
            return;
        }
        if (curState == null)
        {
            curState = state;
        }
        stateCache.Add(state.GetType(), state);
    }

    /// <summary>
    /// 删除状态
    /// </summary>
    public void DeleteState(BaseState state)
    {
        if (!stateCache.ContainsKey(state.GetType()))
        {
            Debug.LogError("不存在此状态：" + state.GetType());
            return;
        }
        stateCache.Remove(state.GetType());
    }

    /// <summary>
    /// 切换状态
    /// </summary>
    public void SwitchState<T>()
        where T : BaseState
    {
        Type type = typeof(T);
        if (!stateCache.ContainsKey(type))
        {
            Debug.LogError("不存在此状态：" + type);
            return;
        }
        if (curState != null)
        {
            curState.OnExit(this);
        }
        BaseState state = stateCache[type];
        state.OnEnter(this);
        curState = state;
    }
}