• Unity3d 商业工程中的 FSM 有限状态机 实现代码

    一、有限状态机介绍

    有限状态机（Finite State Machine, FSM），又称有限状态自动机，简称状态机，是指在有限个状态之间按照一定规律转换的逻辑状态。

    状态机有 3 个组成部分：状态、事件、动作。

    状态：所有可能存在的状态。包括当前状态和条件满足后要迁移的状态。
    事件：也称为转移条件，当一个条件被满足，将会触发一个动作，或者执行一次状态的迁移。
    动作：条件满足后执行的动作。动作执行完毕后，可以迁移到新的状态，也可以仍旧保持原状态。动作不是* 必需的，当条件满足后，也可以不执行任何动作，直接迁移到新状态。

    FSM有限状态机在游戏中的作用主要是做场景的流程管理，进入场景状态后 加载资源初始化，更新状态时执行更新逻辑，离开场景状态时销毁场景资源，数据清理、角色动作状态切换，进入时播放动作，离开时播放下一个当作等。

    二、有限状态机的设计

    设计的时候考虑了可能同时存在多个状态机，所以把状态机单独的分成了一个类；状态机里面有具体的状态，负责具体状态的生命周期；状态机多了之后就需要有一个管理者去管理状态机的整个生命周期：创建、删除、释放内存；

    主要分成了4个类文件：

    1.状态机基类 FsmBase.cs

    包含状态机所需要的通用数据，所有的基类其实都是设计模式中的模板方法模式，因为基类里面的所有方法对于子类来说，都是一样的，所以叫做模板方法。

    FsmBase.cs 代码

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6.  
    7. namespace Myh
    8. {
    9.     /// 
    10.     /// 状态机基类
    11.     /// 
    12.     public abstract class FsmBase
    13.     {
    14.         //状态机编号
    15.         public int FsmId { private set; get; }
    16.  
    17.         //当前状态的类型
    18.         public sbyte CurrStateType;
    19.  
    20.         public FsmBase(int fsmId)
    21.         {
    22.             FsmId = fsmId;
    23.         }
    24.  
    25.         //关闭状态机
    26.         public abstract void ShutDown();
    27.  
    28.     }
    29. }

    2.状态机类 Fsm.cs

    状态机的具体类，继承了FsmBase类；内部实现了所有具体状态的管理、添加、更新、切换等。

    Fsm.cs实现代码

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6.  
    7. namespace Myh
    8. {
    9.     //拥有者，拥有这个状态的类型
    10.     public class Fsm<T> : FsmBase where T : class
    11.     {
    12.         //拥有者
    13.         public T Owner { private set; get; }
    14.  
    15.         //当前状态
    16.         private FsmState m_CurrState;
    17.  
    18.         //状态字典
    19.         private Dictionary<sbyte, FsmState> m_dicState;
    20.  
    21.         //参数字典(??切换状态的时候还传参数??)
    22.         private Dictionary<string, VariableBase> m_dicParam;
    23.  
    24.  
    25.  
    26.         /* 
    27.          * 构造函数  需要以下参数
    28.          * fsmId:状态机的id
    29.          * owner:拥有者
    30.          * states:状态机里的所有状态
    31.          */
    32.         public Fsm(int fsmId, T owner, FsmState[] states) : base(fsmId)
    33.         {
    34.             m_dicState = new Dictionary<sbyte, FsmState>();
    35.             m_dicParam = new Dictionary<string, VariableBase>();
    36.  
    37.             Owner = owner;
    38.  
    39.             //把状态放入字典
    40.             int len = states.Length;
    41.             for (int i = 0; i < len; ++i)
    42.             {
    43.                 FsmState state = states[i];
    44.                 if (null != state)
    45.                 {
    46.                     state.CurrFsm = this;
    47.                 }
    48.                 m_dicState[(sbyte)i] = state;
    49.             }
    50.  
    51.             CurrStateType = -1;
    52.         }
    53.  
    54.         //获取状态 by 状态类型
    55.         public FsmState GetState(sbyte stateType)
    56.         {
    57.             FsmState state = null;
    58.             m_dicState.TryGetValue(stateType,out state);
    59.             return state;
    60.         }
    61.  
    62.         //状态机更新
    63.         public void OnUpdate()
    64.         {
    65.             if (null != m_CurrState)
    66.             {
    67.                 m_CurrState.OnUpdate();
    68.             }
    69.         }
    70.  
    71.         //状态机切换 by newStateType
    72.         public void ChangeState(sbyte newState)
    73.         {
    74.             //如果两个状态一致，不再进入
    75.             if (CurrStateType == newState)
    76.                 return;
    77.  
    78.             //先让当前状态执行OnLeave流程，执行上一个状态离开的逻辑
    79.             if (null != m_CurrState)
    80.                 m_CurrState.OnLeave();
    81.  
    82.             CurrStateType = newState;
    83.             m_CurrState = m_dicState[CurrStateType];
    84.  
    85.             //然后再让新状态执行OnEnter流程，执行新状态的进入逻辑
    86.             m_CurrState.OnEnter();
    87.         }
    88.  
    89.         //设置参数值
    90.         public void SetData<TData>(string key, TData value)
    91.         {
    92.             VariableBase itemBase = null;
    93.             if (m_dicParam.TryGetValue(key, out itemBase))
    94.             {
    95.                 //参数原来存在，更新值
    96.                 Variable item = itemBase as Variable;
    97.                 item.Value = value;
    98.                 //其实这里不重新写入也行，itemBase本来就是个class，拿到的本来就是引用
    99.                 //m_dicParam[key] = item;
    100.             }
    101.             else
    102.             {
    103.                 //参数原来不存在,插入
    104.                 Variable item = new Variable();
    105.                 item.Value = value;
    106.                 m_dicParam[key] = item;
    107.             }
    108.         }
    109.  
    110.         //获取参数值
    111.         public TData GetData<TData>(string key)
    112.         {
    113.             VariableBase itemBase = null;
    114.             if (m_dicParam.TryGetValue(key, out itemBase))
    115.             {
    116.                 Variable item = itemBase as Variable;
    117.                 if (null == item)
    118.                     return default(TData);
    119.                 
    120.                 return item.Value;
    121.             }
    122.             
    123.             //返回该结构的实例？
    124.             return default(TData);
    125.         }
    126.  
    127.  
    128.         public override void ShutDown()
    129.         {
    130.             if (null != m_CurrState)
    131.                 m_CurrState.OnLeave();
    132.  
    133.             //循环遍历，执行所有状态的OnDestroy函数，执行销毁逻辑，销毁所有的状态
    134.             foreach (KeyValuePair<sbyte, FsmState> kvPair in m_dicState)
    135.             {
    136.                 if (null != kvPair.Value)
    137.                 {
    138.                     kvPair.Value.OnDestroy();
    139.                 }
    140.             }
    141.  
    142.             m_dicState.Clear();
    143.             m_dicParam.Clear();
    144.         }
    145.     }
    146. }

    3.状态机 状态抽象类 FsmState.cs

    状态抽象类不可以直接使用，在实际的开发中使用一个具体的状态来继承 状态抽象类FsmState ，具体的例子可以看测试代码中的实现。abstract改成接口也行，但是后来感觉没啥必要，有些派生类未必一定需要实现所有虚函数，所以就写成了抽象类，4个事件都写成了虚函数。派生类实现不实现都可。

    FsmState.cs 代码实现

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6.  
    7. namespace Myh
    8. {
    9.     //状态机的状态
    10.     public abstract class FsmState<T> where T : class
    11.     {
    12.         //状态对应的状态机
    13.         public Fsm CurrFsm;
    14.  
    15.         //进入状态
    16.         public virtual void OnEnter() { }
    17.  
    18.         //更新状态
    19.         public virtual void OnUpdate() { }
    20.  
    21.         //离开状态
    22.         public virtual void OnLeave() { }
    23.  
    24.         //状态机销毁时调用（销毁状态）
    25.         public virtual void OnDestroy() { }
    26.  
    27.     }
    28. }

    4.状态机管理器 FsmManager.cs

    状态机管理器内缓存下来来了所有的,状态机；主要负责创建、销毁，有点像是一个模型类，大部分的职责都是增删状态机。

    FsmManager.cs代码实现

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6.  
    7. namespace Myh
    8. {
    9.     //状态机管理器
    10.     public class FsmManager : ManagerBase, IDisposable
    11.     {
    12.         //状态机字典
    13.         private Dictionary<int, FsmBase> m_dicFsm;
    14.  
    15.         //状态机的临时编号
    16.         private int m_TemFsmId = 0;
    17.  
    18.         public FsmManager()
    19.         {
    20.             m_dicFsm = new Dictionary<int, FsmBase>();
    21.         }
    22.  
    23.         //初始化
    24.         public override void Init()
    25.         {
    26.             
    27.         }
    28.  
    29.         #region Create
    30.         /*
    31.          * 创建状态机实例
    32.          * T：拥有者类型
    33.          * fsmId：状态机Id
    34.          * owner：拥有者实例
    35.          * states：状态数组
    36.          */
    37.         public Fsm<T> Create<T>(int fsmId, T owner, FsmState[] states) where T : class 
    38.         {
    39.             Fsm fsm = new Fsm(fsmId, owner, states);
    40.             m_dicFsm[fsmId] = fsm;
    41.             return fsm;
    42.         }
    43.  
    44.         public Fsm<T> Create<T>(T owner, FsmState[] states) where T : class
    45.         {
    46.             return Create(++m_TemFsmId, owner, states);
    47.         }
    48.  
    49.         #endregion
    50.  
    51.  
    52.         #region 销毁状态机
    53.         //销毁状态机
    54.         public void DestroyFsm(int fsmId)
    55.         {
    56.             FsmBase fsm = null;
    57.             if (m_dicFsm.TryGetValue(fsmId, out fsm))
    58.             {
    59.                 fsm.ShutDown();
    60.                 m_dicFsm.Remove(fsmId);
    61.             }
    62.         }
    63.         #endregion
    64.  
    65.         public void Dispose()
    66.         {
    67.             IEnumeratorint, FsmBase>> iter= m_dicFsm.GetEnumerator();
    68.             for (; iter.MoveNext();)
    69.             {
    70.                 iter.Current.Value.ShutDown();
    71.             }
    72.             m_dicFsm.Clear();
    73.         }
    74.     }
    75. }

    三、测试与总结

    因为刚开始写，还没办法在实际的工程中去做测试，所以主要通过按下按键就切换状态，测了一下状态切换是否符合预期，结果很好，符合预期。

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6. using Myh;
    7. using YouYou;
    8. using UnityEngine;
    9.  
    10. public class FmsTest : ITest
    11. {
    12.     static private void PrintStateLog(int id, string strEvent)
    13.     {
    14.         Debug.Log("状态机：" + id + " 触发了：" + strEvent + " 事件");
    15.     }
    16.  
    17.     #region 测试状态类
    18.  
    19.     enum EnumTestClassType
    20.     {
    21.         eTest1,
    22.         eTest2,
    23.         eTest3,
    24.         eTest4,
    25.     }
    26.     
    27.     class FsmTestState1 : FsmState<FmsTest>
    28.     {
    29.         public override void OnEnter()
    30.         {
    31.             base.OnEnter();
    32.             PrintStateLog(1, "OnEnter");
    33.         }
    34.         
    35.         public override void OnUpdate()
    36.         {
    37.             base.OnUpdate();
    38.             PrintStateLog(1, "OnUpdate");
    39.         }
    40.  
    41.         public override void OnLeave()
    42.         {
    43.             base.OnLeave();
    44.             PrintStateLog(1, "OnLeave");
    45.         }
    46.  
    47.         public override void OnDestroy()
    48.         {
    49.             base.OnDestroy();
    50.             PrintStateLog(1, "OnDestroy");
    51.         }
    52.     }
    53.  
    54.     class FsmTestState2 : FsmState<FmsTest>
    55.     {
    56.         public override void OnEnter()
    57.         {
    58.             base.OnEnter();
    59.             PrintStateLog(2, "OnEnter");
    60.         }
    61.  
    62.         public override void OnUpdate()
    63.         {
    64.             base.OnUpdate();
    65.             PrintStateLog(2, "OnUpdate");
    66.         }
    67.  
    68.         public override void OnLeave()
    69.         {
    70.             base.OnLeave();
    71.             PrintStateLog(2, "OnLeave");
    72.         }
    73.  
    74.         public override void OnDestroy()
    75.         {
    76.             base.OnDestroy();
    77.             PrintStateLog(2, "OnDestroy");
    78.         }
    79.     }
    80.  
    81.  
    82.     class FsmTestState3 : FsmState<FmsTest>
    83.     {
    84.         public override void OnEnter()
    85.         {
    86.             base.OnEnter();
    87.             PrintStateLog(3, "OnEnter");
    88.         }
    89.  
    90.         public override void OnUpdate()
    91.         {
    92.             base.OnUpdate();
    93.             PrintStateLog(3, "OnUpdate");
    94.         }
    95.  
    96.         public override void OnLeave()
    97.         {
    98.             base.OnLeave();
    99.             PrintStateLog(3, "OnLeave");
    100.         }
    101.  
    102.         public override void OnDestroy()
    103.         {
    104.             base.OnDestroy();
    105.             PrintStateLog(3, "OnDestroy");
    106.         }
    107.     }
    108.  
    109.     class FsmTestState4 : FsmState<FmsTest>
    110.     {
    111.         public override void OnEnter()
    112.         {
    113.             base.OnEnter();
    114.             PrintStateLog(4, "OnEnter");
    115.         }
    116.  
    117.         public override void OnUpdate()
    118.         {
    119.             base.OnUpdate();
    120.             PrintStateLog(4, "OnUpdate");
    121.         }
    122.  
    123.         public override void OnLeave()
    124.         {
    125.             base.OnLeave();
    126.             PrintStateLog(4, "OnLeave");
    127.         }
    128.  
    129.         public override void OnDestroy()
    130.         {
    131.             base.OnDestroy();
    132.             PrintStateLog(4, "OnDestroy");
    133.         }
    134.     }
    135.  
    136.     #endregion
    137.  
    138.  
    139.     private Fsm m_fsm=null;
    140.     
    141.     public void OnTestStart()
    142.     {
    143.         FsmState[] arrStates = new FsmState[4];
    144.         arrStates[(int)EnumTestClassType.eTest1] = new FsmTestState1();
    145.         arrStates[(int)EnumTestClassType.eTest2] = new FsmTestState2();
    146.         arrStates[(int)EnumTestClassType.eTest3] = new FsmTestState3();
    147.         arrStates[(int)EnumTestClassType.eTest4] = new FsmTestState4();
    148.  
    149.         m_fsm = GameEntry.FSM.Create(this, arrStates);
    150.     }
    151.  
    152.     public void OnTestUpdate()
    153.     {
    154.         if (null == m_fsm)
    155.             return;
    156.  
    157.         //m_fsm.OnUpdate();
    158.  
    159.         if (Input.GetKeyDown(KeyCode.Keypad1))
    160.         {
    161.             m_fsm.ChangeState((int)EnumTestClassType.eTest1);
    162.         }
    163.         else if (Input.GetKeyDown(KeyCode.Keypad2))
    164.         {
    165.             m_fsm.ChangeState((int)EnumTestClassType.eTest2);
    166.         }
    167.         else if (Input.GetKeyDown(KeyCode.Keypad3))
    168.         {
    169.             m_fsm.ChangeState((int)EnumTestClassType.eTest3);
    170.         }
    171.         else if (Input.GetKeyDown(KeyCode.Keypad4))
    172.         {
    173.             m_fsm.ChangeState((int)EnumTestClassType.eTest4);
    174.         }
    175.  
    176.     }
    177. }

  • 相关阅读:
    卧槽，Log4j2 再爆雷，Log4j v2.17.0 横空出世。。。
    SpringCloud 05 Eureka集群环境配置和CAP
    scannet v2 数据集下载
    Redis缓存初探
    ＜SQL编程工具MySQL、SQLyog安装及环境配置教程＞——《SQL》
    LeetCode50天刷题计划第二季（Day 31 — 两数之和 II - 输入有序数组（11.10-11.20）分数到小数（11.30-12.30）
    计算机毕业设计 基于thinphp 的校园论坛交流网站(源码+系统+mysql数据库+Lw文档）
    Ubuntu18.04 CoppeliaSim Edu 安装教程 (2022年11月)
    spring-data-mongodb的Aggregation详解
    【MAPBOX基础功能】11、mapbox绘制symbol icon图层并进行添加、删除、更新、显隐等操作
  • 原文地址：https://blog.csdn.net/qq_33531923/article/details/127742063