游戏中分层状态机的实现(转)

关注

原创最新推荐文章于 2026-08-10 15:22:02 发布 2.4k 阅读 AI 写同款· GEO 优化 ›

分层状态机学习转载：原创作者参考：参考作者日志： 21.8.24：组内同事分享了一个多状态的项目，其中用到了分层状态机的概念，蛮有兴趣的，前来学习一下决策方法：有限状态机（Finite-State Machines）分层状态机（Hierarchical Finite-State Machines）行为树（Behavior Trees）效用系统（Utility Systems）目标导向型行动计划（Goal-Oriented Action Planners）分层任务网络（Hierarchical Task 阅读详情

游戏中最复杂的逻辑部分就是战斗部分。之前一直没有对状态机进行理论学习，以及于在设计游戏战斗逻辑的时候总是没有安全感。下边是一个写的不错的文章。

转自： http://blog.youkuaiyun.com/xtxy/article/details/9668221

状态机的实现方式有很多种，一般都使用比较简单的switch case方式来实现对事件的处理和状态的转移，如下所示：

[html]view plaincopy
      
     
void ProcessEvent(Event event)  
{  
    switch(state)  
    {  
        case StateA:  
            StateAProcess(event);  
            break;  
  
        case StateB:  
            StateBProcess(event);  
            break;  
    }  
}  

也有利用数组实现的行列式状态机，这样方便开发人员查看，如下所示：

[csharp]view plaincopy
      
     
EventHandler stateHandler[] =  
{  
    StateA_Event1, StateA_Event2,  
    StateB_Event1, StateB_Event2,  
};  
  
void ProcessEvent(Event event)  
{  
    int index = state * EVENT_NUM + event;  
    stateHandler[index]();  
}  

但是这些状态机都有一个共同点，就是状态之间的转移需要在状态内部显示得指明目标状态。

----------------------------------------------------------------------------------------------

在游戏中，遇到一些复杂的情况时，如果使用普通的状态机，那需要写大量的状态，举一个星际争霸中一个机枪兵的例子：

1. 机枪兵在平时站立时，处于空闲状态；

2. 机枪兵发现敌人，并且敌人在射程范围内，机枪兵开始攻击敌人；此时，机枪兵进入攻击状态；

3. 敌人死亡，机枪兵停止攻击；此时，机枪兵回到空闲状态；

4. 此时玩家发出进攻命令，此进攻命令是用A键点了远处的一个地面 place1 ，也就是没有具体目标的进攻；此时，机枪兵进入移动进攻状态；

5. 在移动过程中，机枪兵发现了敌人，所以他要脱离原来的路径，走向发现的敌人；此时，机枪兵进入追击状态；

6. 机枪兵和敌人的距离小于了自己的射程之后，机枪兵停下来，并且攻击敌人；此时，机枪兵进入了攻击状态；

7. 敌人死亡后，机枪兵重新寻路到place1，继续前进；此时机枪兵回到步骤4，回到了移动进攻状态。

在上面这个过程中，从步骤2到步骤3，攻击状态转移到空闲状态；从步骤6到步骤7，攻击状态转移到移动进攻状态；源状态都是攻击状态，触发事件都是敌人死亡，但是目标状态却不相同；

也就是说，步骤2的攻击状态和步骤6的攻击状态严格意义上是不同的两个状态，一般来说有两个解决方案来满足这种情况：

1. 做攻击A 状态和攻击B 状态；

2. 在攻击状态内保存一个变量，来实现状态结束后跳转到不同的状态；

其实这两种方法本质上都是一样的，而且都存在同样的缺点：如果在某种情况下如果攻击状态收到敌人死亡事件之后需要跳转到其他状态，（比如机枪兵在巡逻时发现敌人的情况），那就需要增加状态或者代码分支。

如何才能将上面的攻击状态合并为一个，而且可以支持以后的扩展呢？这个就是需要解决的问题。

仔细分析一下，可以发现攻击状态之所以需要跳转到不同的目标状态，是因为在其前，机枪兵进入了不同的状态；换句话说，机枪兵退出攻击状态的时候，实际上是回到了之前的某个阶段的状态。（步骤2是回到前一个状态，步骤7是回到了前两个状态）

----------------------------------------------------------------------------------------------

堆栈的特性为我们很好地解决了这个问题：压人变量A，栈顶的变量就是变量A；压入变量B，栈顶的变量变为变量B；弹出变量B，栈顶的变量变回到变量A。

所以根据这个特性，可以开发一个融合堆栈的状态机，其基础构造参照了《大型多人在线游戏开发》（《Massively Multiplayer Game Development》）里面的状态机实现，代码（c sharp格式）参考如下：

[csharp]view plaincopy
      
     
public enum StateChange  
{  
    None,  
    Switch,  
    Enter,  
    Exit,  
}  
  
public class UnitSMBase  
{  
    public UnitState state;  
    public StateChange change;  
      
    float _deltaTime;  
    protected float _checkTime;  
    protected Unit _unit;  
      
    public UnitSMBase(Unit unit)  
    {  
        _unit = unit;  
        _deltaTime = 0;  
    }  
      
    public virtual void Enter()  
    {  
        _checkTime = 1;  
    }  
      
    public virtual void Exit()  
    {  
    }  
      
    public void ProcessEvent(UnitEvent evt)  
    {  
        state = UnitState.None;  
        change = StateChange.None;  
          
        if(evt == UnitEvent.Update)  
        {  
            if(_deltaTime >= _checkTime)  
            {  
                _deltaTime = 0;  
                evt = UnitEvent.UpdateFixTime;  
            }  
            else  
            {  
                _deltaTime += Time.deltaTime;  
            }  
        }  
          
        DoProcess(evt);  
    }  
      
    protected virtual void DoProcess(UnitEvent evt)  
    {  
    }  
      
    public virtual bool CanGo(UnitState unitState)  
    {  
        return true;  
    }  
}  
  
  
public class UnitSmMgr  
{  
    List<UnitSMBase> _smList;  
    Dictionary<UnitState, UnitSMBase> _smStateDict;  
  
    public UnitSmMgr(UnitSMBase initSM, UnitState initState)  
    {  
        _smList = new List<UnitSMBase>();  
        _smList.Add(initSM);  
          
        _smStateDict = new Dictionary<UnitState, UnitSMBase>();  
        _smStateDict[initState] = initSM;  
  
                initSM.Enter();  
    }  
  
    public void RegisterSM(UnitSMBase sm, UnitState state)  
    {  
        _smStateDict[state] = sm;  
    }  
  
    public void ProcessEvent(UnitEvent evt)  
    {  
        _smList[0].ProcessEvent(evt);  
          
        switch(_smList[0].change)  
        {  
        case StateChange.Enter:  
            _smList.Insert(0, _smStateDict[_smList[0].state]);  
            _smList[0].Enter();  
            break;  
              
        case StateChange.Switch:  
             _smList[0].Exit();  
            _smList[0] = _smStateDict[_smList[0].state];  
            _smList[0].Enter();  
            break;  
              
        case StateChange.Exit:  
            _smList[0].Exit();  
            _smList.RemoveAt(0);  
            break;  
        }  
          
        if(0 == _smList.Count)  
        {  
            Debug.LogError("state machine is empty");  
        }  
    }  
}  