有限状态机

最新推荐文章于 2024-05-15 10:15:11 发布
最新推荐文章于 2024-05-15 10:15:11 发布
阅读量7.8k 收藏 34
点赞数 9
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cooper20/article/details/109380976
版权

文章目录


在实际的软件开发中，状态机并不常用，但是在能够用得到的场景中，可以发挥出很大的作用。状态机常用在游戏、工作流引擎等系统开发中，其实现方式有分支逻辑法、查表法、状态模式等。

1. 概念

1.1 定义

有限状态机（Finite State Machine，FSM）简称状态机。状态机有三个组成部分：状态（State）、事件（Event）、动作（Action），事件（转移条件）触发状态的转移和动作的执行。动作的执行不是必须的，可以只转移状态，不指定任何动作。总体而言，状态机是一种用以表示有限个状态以及这些状态之间的转移和动作的执行等行为的数学模型。

状态机可以用公式 State(S) x Event(E) -> Actions (A), State(S’)表示，即在处于状态S的情况下，接收到了事件E，使得状态转移到了S’，同时伴随着动作A的执行。

1.2 举例

在游戏“超级马里奥”中，马里奥的形态转变就是一个状态机。马里奥有小马里奥、超级马里奥、火焰马里奥、斗篷马里奥等形态，在遇到不同的游戏情节时，会发生形态改变，同时产生积分的增减。比如小马里奥吃了蘑菇之后会变成超级马里奥，同时增加100积分。

在超级马里奥中，马里奥的不同形态就是状态机中的“状态”，游戏情节就是状态机中的“事件”，加减积分就是状态——机中的“动作”。

在这里插入图片描述

其中，事件E1~E4分别表示吃蘑菇、获得斗篷、获得火焰、遇到怪物。

2. 分支逻辑法

分支逻辑法是状态机最简单的实现方式，利用if-else或者switch-case，参照状态转移图，将每一种状态转移直接翻译成代码。

对于简单的状态机，分支逻辑法的实现方式可以接受。对于复杂的状态机，分支逻辑法容易漏写、错写某些状态转移。除此之外，代码中充斥着大量的if-else，可读性、可维护性都很差。

定义状态枚举

public enum State {

    SMALL(0),
    SUPER(1),
    FIRE(2),
    CAPE(3);

    private int value;

    private State(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

状态机实现


public class MarioStateMachine {
    // 积分
    private int score;
    // 状态
    private State currentState;

    public MarioStateMachine() {
        this.score = 0;
        this.currentState = State.SMALL;
    }

    // 事件处理：在不同状态下事件所触发的状态转移、动作执行
    public void obtainMushRoom() {
        if (currentState.equals(State.SMALL)) {
            this.currentState = State.SUPER;
            this.score += 100;
        }
    }
    public void meetMonster() {
        if (currentState.equals(State.SUPER)) {
            this.currentState = State.SMALL;
            this.score -= 100;
            return;
        }
        if (currentState.equals(State.CAPE)) {
            this.currentState = State.SMALL;
            this.score -= 200;
            return;
        }
        if (currentState.equals(State.FIRE)) {
            this.currentState = State.SMALL;
            this.score -= 300;
            return;
        }
    }
}

3. 查表法

查表法适用于实现状态、事件类型很多、状态转移比较复杂的状态机，利用二维数组表示状态转移图，能极大的提高代码的可读性和可维护性。当把数组存在配置文件中，在状态机变更时甚至不需要修改代码。

在二维数组的表示形式中，用数组transitionTable和actionTable分别表示状态转移和动作执行。在这两个数组中，横坐标都表示当前状态，纵坐标都表示发生的事件，值则分别表示转移后的新状态和需要执行的动作。

在这里插入图片描述

查表法的actionTable有一定的局限性，表示数值操作比较容易，表示复杂的业务逻辑会比较困难，此时，用状态模式会更加合适。当然，也可以将动作的类型用枚举表示，这样就可以用放入数组之中。

定义事件

public enum Event {

    GOT_MUSHROOM(0),
    GOT_CAPE(1),
    GOT_FIRE(2),
    MET_MONSTER(3);
  
    private int value;

    private Event(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

状态机实现

public class MarioStateMachine {
    private int score;
    private State currentState;

    private static final State[][] TRANSITION_TABLE = {
            {SUPER, CAPE, FIRE, SMALL},
            {SUPER, CAPE, FIRE, SMALL},
            {CAPE, CAPE, CAPE, SMALL},
            {FIRE, FIRE, FIRE, SMALL}
    };

    private static final int[][] ACTION_TABLE = {
            {+100, +200, +300, +0},
            {+0, +200, +300, -100},
            {+0, +0, +0, -200},
            {+0, +0, +0, -300}
    };

    public MarioStateMachine() {
        this.score = 0;
        this.currentState = State.SMALL;
    }

    // 事件处理：根据当前状态和事件，查询TRANSITION_TABLE和ACTION_TABLE表，获得转移后的新状态和需要执行的动作
    public void executeEvent(Event event) {
        int stateValue = currentState.getValue();
        int eventValue = event.getValue();
        this.currentState = TRANSITION_TABLE[stateValue][eventValue];
        this.score = ACTION_TABLE[stateValue][eventValue];
    }
}

4. 状态模式

状态模式用以实现状态不多、状态转移简单，但是事件触发动作所包含的业务逻辑比较复杂的状态机。将不同状态下事件所触发的状态转移和动作执行，拆分到不同的状态类中，来避免分支判断逻辑。

当状态模式会引入较多的状态类，对于状态比较多的推荐使用查表法；而对于状态比较少，但是动作复杂的，状态模式更加适合。

状态接口

IMario是状态的接口，定义了所有事件的响应方法。

public interface IMario {

    State getName();

    //以下是定义的事件
    void obtainMushRoom();
    void obtainCape();
    void obtainFireFlower();
    void meetMonster();
}

状态类实现

SmallMario、SuperMario等是状态的具体实现类，分别对应状态机中的4个状态。具体实现了在当前状态下，每个事件的状态转移和动作执行，这些原本在MarioStateMachine中，现在分散到具体的状态类中了。

public class SmallMario implements IMario {

    // 状态类也依赖于状态机，用于修改其状态。
    private MarioStateMachine stateMachine;

    public SmallMario(MarioStateMachine stateMachine) {
        this.stateMachine = stateMachine;
    }

    // 实现事件的具体逻辑：状态转移、动作执行
    @Override
    public void obtainMushRoom() {
        stateMachine.setCurrentState(new SuperMario(stateMachine));
        stateMachine.setScore(stateMachine.getScore() + 100);
    }
    @Override
    public void obtainCape() {
        stateMachine.setCurrentState(new CapeMario(stateMachine));
        stateMachine.setScore(stateMachine.getScore() + 200);
    }
    @Override
    public void obtainFireFlower() {
        stateMachine.setCurrentState(new FireMario(stateMachine));
        stateMachine.setScore(stateMachine.getScore() + 300);
    }
    @Override
    public void meetMonster() {
        // do nothing...
    }

    @Override
    public State getName() {
        return State.SMALL;
    }

}

状态机

状态机持有状态，响应事件并调用具体状态类的实现来执行具体的逻辑。状态机和状态类之间是双向依赖，状态机持有状态，状态类需要反向修改状态机的状态。

public class MarioStateMachine {
    private int score;

    // 使用状态类而不是状态枚举表示当前状态
    private IMario currentState;

    public MarioStateMachine() {
        this.score = 0;
        this.currentState = new SmallMario(this);
    }

    // 调用具体状态类的事件方法
    public void obtainMushRoom() {
        this.currentState.obtainMushRoom();
    }
    public void obtainCape() {
        this.currentState.obtainCape();
    }
    public void obtainFireFlower() {
        this.currentState.obtainFireFlower();
    }
    public void meetMonster() {
        this.currentState.meetMonster();
    }

    // getter、setter
    public int getScore() {
        return this.score;
    }
    public State getCurrentState() {
        return this.currentState.getName();
    }
    public void setScore(int score) {
        this.score = score;
    }
    public void setCurrentState(IMario currentState) {
        this.currentState = currentState;
    }

}

实现优化

可以将状态类设计成单例，对于状态类依赖于状态机，可以通过方法传参将状态机传入状态类。

public interface IMario {
    State getName();

    void obtainMushRoom(MarioStateMachine stateMachine);

    void obtainCape(MarioStateMachine stateMachine);

    void obtainFireFlower(MarioStateMachine stateMachine);

    void meetMonster(MarioStateMachine stateMachine);
}

public class SmallMario implements IMario {
    private static final SmallMario instance = new SmallMario();

    private SmallMario() {
    }

    public static SmallMario getInstance() {
        return instance;
    }

    @Override
    public State getName() {
        return State.SMALL;
    }

    @Override
    public void obtainMushRoom(MarioStateMachine stateMachine) {
        stateMachine.setCurrentState(SuperMario.getInstance());
        stateMachine.setScore(stateMachine.getScore() + 100);
    }

    @Override
    public void obtainCape(MarioStateMachine stateMachine) {
        stateMachine.setCurrentState(CapeMario.getInstance());
        stateMachine.setScore(stateMachine.getScore() + 200);
    }

    @Override
    public void obtainFireFlower(MarioStateMachine stateMachine) {
        stateMachine.setCurrentState(FireMario.getInstance());
        stateMachine.setScore(stateMachine.getScore() + 300);
    }

    @Override
    public void meetMonster(MarioStateMachine stateMachine) {
        // do nothing...
    }
}

public class MarioStateMachine {
    private int score;
    private IMario currentState;

    public MarioStateMachine() {
        this.score = 0;
        this.currentState = SmallMario.getInstance();
    }

    public void obtainMushRoom() {
        this.currentState.obtainMushRoom(this);
    }

    public void obtainCape() {
        this.currentState.obtainCape(this);
    }

    public void obtainFireFlower() {
        this.currentState.obtainFireFlower(this);
    }

    public void meetMonster() {
        this.currentState.meetMonster(this);
    }

    public int getScore() {
        return this.score;
    }

    public State getCurrentState() {
        return this.currentState.getName();
    }

    public State getCurrentState() {
        return this.currentState.getName();
    }

    public void setScore(int score) {
        this.score = score;
    }

    public void setCurrentState(IMario currentState) {
        this.currentState = currentState;
    }
}

参考

有限状态机——维基百科

《设计模式之美》——极客时间

萝卜头柯克船长
关注
  • 9
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
RTOS之UCOS（一）--- 有限状态机
流云
05-30 4501
一、什么是有限状态机 有限状态机（FSM: Finite-state machine）是一种用来进行对象行为建模的工具，其作用主要是描述对象在它的生命周期内所经历的状态序列，以及如何响应来自外界的各种事件。它把复杂的控制逻辑分解成有限个稳定状态，在每个状态上判断事件，变连续处理为离散数字处理，符合计算机的工作特点。同时，因为有限状态机具有有限个状态，所以可以在实际的工程上实现。但这并不意味着其只能进行有限次的处理，相反，有限状态机是闭环系统，有限无穷，可以用有限的状态，处理无穷的事务。在计算机科学中，有限
【自动驾驶决策算法之有限状态机】
weixin_65089713的博客
06-14 3010
1 有限状态机的介绍 （1）在硬件角度看，状态机由状态寄存器和组合逻辑电路构成，能够根据控制信号按照预先设定的状态进行状态转移。 （2）因为状态机是基于有限的离散状态，所以状态机也称为有限状态机，简写为FSM（Finite State Machine） （3）有限状态机是一个简单的抽象反应系统，它只针对特定的外界激励产生数量有限的响应 其核心思想是，通过有限的状态描述定义，组合产生大量的复杂的逻辑行为.........
有限状态机（Finite State Machine，简称FSM）
最新发布
探索未知，成就非凡
05-15 198
首先，需要定义状态机的所有可能状态。这些状态通常用枚举类型来表示，以便于代码的可读性和维护性。} state_t;接下来，需要定义一个寄存器来保存当前状态。
有限状态机FSM
05-22 1045
FSM可以把模型的多状态、多状态间的转换条件解耦。可以使维护变得容易，代码也更加具有可读性，也更加艺术。
有限状态机详解（转载）
热门推荐
baixiaoshi的专栏
08-23 3万+
以前总觉得有限状态机和无限状态机非常的难理解，原来也就是自己一直没有一个直观的认识，今天看到一篇博客，总算对有限状态机入门了。一看就懂。转载地址：http://blog.csdn.net/zqixiao_09/article/details/50239337我们知道，一般编写程序时都要画出流程图，按照流程图结构来编程，如果编写一个比较繁琐，容易思维混乱的程序时，我们可以利用有限状态机模型画出一个状态
JavaScript有限状态机
11-30
JavaScript有限状态机是一种在编程中用于管理对象状态的模式，尤其在处理复杂逻辑流程时非常有用。它将一个系统划分为一系列预定义的状态，并规定了这些状态之间的转换规则。有限状态机（Finite State Machine，FSM...
有限状态机编程
12-21
有限状态机（Finite State Machine, FSM）是一种数学模型，用于描述和设计具有固定数量状态的系统，这些系统根据外部输入或内部变化在不同状态之间转换。在计算机科学中，有限状态机广泛应用于编译器、协议解析、...
vhdl有限状态机设计
09-23
有限状态机（Finite State Machine, FSM）是VHDL中的一个重要概念，它能够描述和实现复杂逻辑功能，常用于控制单元的设计。 有限状态机由几个关键部分组成：状态、状态转换、输入和输出。状态是FSM的核心，每个状态...
Lua有限状态机
08-08
《Lua有限状态机在Unity3D中的应用与实现》 Lua是一种轻量级的脚本语言，因其简洁、高效的特点，常被用作游戏开发中的脚本工具，尤其是在Unity3D引擎中。有限状态机（Finite State Machine, FSM）是编程中一种常见...
FSM有限状态机模拟例程
01-04
有限状态机（Finite State Machine, FSM）是一种数学模型，用于描述和设计具有固定数量的状态以及在这些状态之间转换的系统。在计算机科学和IT领域，FSM被广泛应用于硬件设计、软件工程、编译器构造、协议解析、游戏...
C语言实现有限状态机
12-22
有限状态机是一种数学概念，运用到程序中，可用于有限数量的状态的变化，每个子程序进行一些处理并选择下一种状态。 　基本的实现思路是用一张表保存所有可能的状态，并列出进入每个状态时可能执行的所有动作，...
Python有限状态机——transitions
05-06
有限状态机（Finite State Machine, FSM）是一种数学模型，用于描述一个系统随时间可能经历的各种状态以及状态之间的转换。在Python中，`transitions`库提供了对这种模型的抽象，简化了状态管理和转换的实现。要安装...
Java如何通过枚举实现有限状态机
08-18
Java如何通过枚举实现有限状态机 Java中的枚举类型是一种特殊的类类型，它可以实现有限状态机。有限状态机是一种数学模型，用于描述一个系统在不同的状态下可以执行的动作和切换规则。 Java中的枚举类型可以很好地...
有限状态机(FSM)设计原理
OpenFPGA的博客
07-26 2万+
1.1 概述　　有限状态机是由寄存器组和组合逻辑构成的硬件时序电路。有限状态机的状态(即由寄存器组的1和0的组合状态所构成的有限个状态)只可能在同一时钟跳变沿的情况下才能从一个状态转向另一个状态。 　　有限状态机的下一个状态不但取决于各个输入值，还取决于当前所在状态。这里指的是米里Mealy型有限状态机，而莫尔Moore型有限状态机的下一个状态只决于当前状态。 　 图 1　　Mealy型
有限状态机是什么？
天心天地生的博客
06-16 6562
1.背景介绍 有限状态机，（英语：Finite-state machine, FSM），又称有限状态自动机，简称状态机， 是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。 其作用主要是描述对象在它的生命周期内所经历的状态序列，以及如何响应来自外界的各种事件。在计算机科学中， 有限状态机被广泛用于建模应用行为、硬件电路系统设计、软件工程，编译器、网络协议、和计算与语言的研究...
有限状态机（FSM）的分类
流云
03-04 4985
转自:http://book.51cto.com/art/200911/162899.htm 有限状态机有两种基本类型：米利（Mealy）机和摩尔（Moore）机，米利机的下一状态和输出取决于当前状态和当前输入；摩尔机的下一状态取决于当前状态和当前输入，但其输出仅取决于当前状态。这两类有限状态机的下一状态和输出都是由组合逻辑电路形成的。 1. 米利（Mealy）机 米利（...
unity 有限状态机
10-17
Unity中的有限状态机（Finite State Machine，FSM）是一种常用的游戏编程模式，它可以帮助我们管理游戏对象的状态和行为。在Unity中，我们可以使用Animator组件来创建有限状态机。 有限状态机由状态和转换组成。状态表示游戏对象的某种行为或状态，转换表示游戏对象从一个状态转换到另一个状态的条件。 在Unity中，我们可以使用Animator Controller来创建有限状态机。Animator Controller是一个可视化的编辑器，它允许我们创建状态和转换，并将它们组合成一个有限状态机。 在创建Animator Controller时，我们需要定义状态和转换。状态可以是任何游戏对象的行为或状态，例如“待机”、“行走”、“攻击”等。转换表示游戏对象从一个状态转换到另一个状态的条件，例如“当玩家进入攻击范围时，从待机状态转换到攻击状态”。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值