游戏逻辑底层，MainLoop&&FSM&&MSG（三）

最新推荐文章于 2022-05-31 13:25:37 发布
最新推荐文章于 2022-05-31 13:25:37 发布
阅读量595 收藏 1
点赞数
分类专栏： AI 文章标签： 游戏 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22984991/article/details/51072202
版权

FSM–有限状态机

今天我们来探讨一下Finite State Machine,有限状态机，简称FSM，有兴趣的同学可以看一下《游戏编程中的人工智能》这本书，写得很经典（无论从代码上来说还是思维上来说），此次的例子基本是在此书的思想结构上来编程的。

FSM的基本思想我不多赘述，我们只关注代码的实现。

首先是State基类
State.h

template<class Type>
class State
{
public:
    virtual ~State(){}
    virtual void enter(Type*) = 0;
    virtual void execute(Type*) = 0;
    virtual void exit(Type*) = 0;
    virtual bool onMsg(Type*, const Telegram&) = 0;
};

State是一个纯虚类，我们通过继承来使用它的子类，而不用State本身。
这里有一个很好的抽象，State将所有的事件状态分为了enter，execute，exit三个基本事件，这样在游戏中的所有事件，无论是持续性的还是瞬时事件都可以用其概括。

接下来我们看一下StateMachine类（！！！重要提示，文件头不要使用#ifndef宏，会出现宏冲突，请使用#pragma once）
StateMachine.h

template<class Type>
class StateMachine
{
private:
    State<Type>* _currentState;
    State<Type>* _previousState;
    State<Type>* _globalState;
    Type* _owner;
public:
    StateMachine(Type*);
    virtual ~StateMachine();
public:
    //ignore getxx & setxx...
    void update() const;

    bool handleMsg(const Telegram&);

    void changeState(State<Type>*);

    bool isStateOn(State<Type>& state)const;

    void revert2PreviousState();
};

template<class Type>
StateMachine<Type>::StateMachine(Type* owner) :_currentState(NULL),
_previousState(NULL),
_globalState(NULL),
_owner(owner)
{

}

template<class Type>
StateMachine<Type>::~StateMachine()
{

}

template<class Type>
void StateMachine<Type>::update()const
{
    if (_globalState)
        _globalState->execute(_owner);
    if (_currentState)
        _currentState->execute(_owner);
}

template<class Type>
bool StateMachine<Type>::handleMsg(const Telegram& tel)
{
    if (_currentState&&_currentState->onMsg(_owner, tel))
        return true;
    if (_globalState&&_globalState->onMsg(_owner, tel))
        return true;

    return false;
}

template<class Type>
void StateMachine<Type>::changeState(State<Type>* newState)
{
    assert(newState&&"a null state,tring to changeState falied");
    _previousState = _currentState;
    _currentState->exit(_owner);
    _currentState = newState;
    _currentState->enter(_owner);
}

template<class Type>
bool StateMachine<Type>::isStateOn(State<Type>& state)const
{
    return typeid(*_currentState) == typeid(state);
}

template<class Type>
void StateMachine<Type>::revert2PreviousState()
{
    changeState(_previousState);
}

我们看一下update函数就可以知道此类的运行方式，每次更新执行globalState，意指随时可能发生的状态，比如你下班回家，突然下雨了，你要找一家咖啡店避雨，这个状态，有别于其他按序或者按规则发生的状态，不受其他状态约束，在避雨状态完了之后，你会revert2PreviousState，返回原本状态（回滚），此处为继续回家。

然后每次更新还要执行currentState，此状态按规则（一般是自身属性规则），接下来描述一个状态切换,一个miner矿工的状态集合

MinerOwnedStates.h

using namespace std;

class Miner;

class EMADFN :public State < Miner >, public Singleton < EMADFN >//enter mine and dig for nugget
{
public:
    EMADFN(){}
    virtual void enter(Miner*);
    virtual void execute(Miner*);
    virtual void exit(Miner*);
    virtual bool onMsg(Miner*, const Telegram&);
};

class VBADG :public State< Miner >, public Singleton < VBADG >//visit bank and deposit gold
{
public:
    VBADG(){}
    virtual void enter(Miner*);
    virtual void execute(Miner*);
    virtual void exit(Miner*);
    virtual bool onMsg(Miner*, const Telegram&);
};

class GHASTR :public State < Miner >, public Singleton < GHASTR >//go home and sleep til rested
{
public:
    GHASTR(){}
    virtual void enter(Miner*);
    virtual void execute(Miner*);
    virtual void exit(Miner*);
    virtual bool onMsg(Miner*, const Telegram&);
};

class QT :public State < Miner >, public Singleton < QT >//quench thirst
{
public:
    QT(){}
    virtual void enter(Miner*);
    virtual void execute(Miner*);
    virtual void exit(Miner*);
    virtual bool onMsg(Miner*, const Telegram&);
};

class ES :public State < Miner >, public Singleton < ES >//eat stew
{
public:
    ES(){}
    virtual void enter(Miner*);
    virtual void execute(Miner*);
    virtual void exit(Miner*);
    virtual bool onMsg(Miner*, const Telegram&);
};

MinerOwnedStates.cpp

#include"MinerStates.h"
#include"Miner.h"

//------------------------------------------------------------------------------------------------------------------------

//enter mine and dig for nugget
void EMADFN::enter(Miner* miner)
{
    if (miner->location() != goldMine)
    {
        cout << "\n" << EntityManenger::instance()->getNameOfEntity(miner->ID()) << ": " << "Walkin' to the goldmine";

        miner->locationChange(goldMine);
    }
}

void EMADFN::execute(Miner* miner)
{
    miner->addToGoldCarried(1);

    miner->increaseFatigue();

    cout << "\n" << EntityManenger::instance()->getNameOfEntity(miner->ID()) << ": " << "Pickin' up a nugget";

    //if enough gold mined, go and put it in the bank
    if (miner->pocketsFull())
    {
        miner->getFSM()->changeState(vbadg);
    }

    if (miner->thirst())
    {
        miner->getFSM()->changeState(qt);
    }
}

void EMADFN::exit(Miner* miner)
{
    cout << "\n" << EntityManenger::instance()->getNameOfEntity(miner->ID()) << ": "
        << "Ah'm leavin' the goldmine with mah pockets full o' sweet gold";
}

bool EMADFN::onMsg(Miner* miner, const Telegram& tel)
{
    return false;
}

//------------------------------------------------------------------------------------------------------------------------

//visit bank and deposit gold

void VBADG::enter(Miner* miner)
{
    if (miner->location() != bank)
    {
        cout << "\n" << EntityManenger::instance()->getNameOfEntity(miner->ID()) << ": " << "Goin' to the bank. Yes siree";

        miner->locationChange(bank);
    }
}

void VBADG::execute(Miner* miner)
{
    miner->addToWealth(miner->goldCarried());

    miner->setGoldCarried(0);

    cout << "\n" << EntityManenger::instance()->getNameOfEntity(miner->ID()) << ": "
        << "Depositing gold. Total savings now: " << miner->moneyInBank();

    //wealthy enough to have a well earned rest?
    if (miner->moneyInBank() >= COMFORT_LEVEL)
    {
        cout << "\n" << EntityManenger::instance()->getNameOfEntity(miner->ID()) << ": "
            << "WooHoo! Rich enough for now. Back home to mah li'lle lady";

        miner->getFSM()->changeState(ghastr);
    }

    //otherwise get more gold
    else
    {
        miner->getFSM()->changeState(emadfn);
    }
}

void VBADG::exit(Miner* miner)
{
    cout << "\n" << EntityManenger::instance()->getNameOfEntity(miner->ID()) << ": " << "Leavin' the bank";
}

bool VBADG::onMsg(Miner* miner, const Telegram& tel)
{
    return false;
}

//------------------------------------------------------------------------------------------------------------------------

//go home and sleep til rested

void GHASTR::enter(Miner* miner)
{
    if (miner->location() != shack)
    {
        cout << "\n" << EntityManenger::instance()->getNameOfEntity(miner->ID()) << ": " << "Walkin' home";

        miner->locationChange(shack);

        //let the wife know I'm home
        MSGDISPATCHER->addMsg(DEFAULT_DELAY, //time delay
            miner->ID(),        //ID of sender
            EntityManenger::ent_Elsa,            //ID of recipient
            Bob_home,   //the message
            NO_EXTRA_INFO);
    }
}

void GHASTR::execute(Miner* miner)
{
    //if miner is not fatigued start to dig for nuggets again.
    if (!miner->fatigued())
    {
        cout << "\n" << EMGR->getNameOfEntity(miner->ID()) << ": "
            << "All mah fatigue has drained away. Time to find more gold!";

        miner->getFSM()->changeState(EMADFN::instance());
    }

    else
    {
        //sleep
        miner->decreaseFatigue();

        cout << "\n" << EMGR->getNameOfEntity(miner->ID()) << ": " << "ZZZZ... ";
    }
}

void GHASTR::exit(Miner* miner)
{
    return;
}

bool GHASTR::onMsg(Miner* miner, const Telegram& tel)
{
    switch (tel.msg_)
    {
    case Stew_cooked:

        cout << "\nMessage handled by " << EMGR->getNameOfEntity(miner->ID())
            << " at time: " << clock();


        cout << "\n" << EMGR->getNameOfEntity(miner->ID())
            << ": Okay Hun, ahm a comin'!";

        miner->getFSM()->changeState(ES::instance());

        return true;
    default:
        return false;
    }//end switch

}

//------------------------------------------------------------------------------------------------------------------------

//quench thirst

void QT::enter(Miner* miner)
{
    if (miner->location() != saloon)
    {
        miner->locationChange(saloon);

        cout << "\n" << EMGR->getNameOfEntity(miner->ID()) << ": " << "Boy, ah sure is thusty! Walking to the saloon";
    }
}

void QT::execute(Miner* miner)
{
    miner->buyAndDrinkAWhiskey();

    cout << "\n" <<EMGR->getNameOfEntity(miner->ID()) << ": " << "That's mighty fine sippin' liquer";

    miner->getFSM()->changeState(EMADFN::instance());
}

void QT::exit(Miner* miner)
{
    cout << "\n" << EMGR->getNameOfEntity(miner->ID()) << ": " << "Leaving the saloon, feelin' good";
}

bool QT::onMsg(Miner* miner, const Telegram& tel)
{
    return false;
}

//------------------------------------------------------------------------------------------------------------------------

//eat stew

void ES::enter(Miner* miner)
{
    cout << "\n" << EMGR->getNameOfEntity(miner->ID()) << ": " << "Smells Reaaal goood Elsa!";
}

void ES::execute(Miner* miner)
{
    cout << "\n" << EMGR->getNameOfEntity(miner->ID()) << ": " << "Tastes real good too!";

    miner->getFSM()->revert2PreviousState();
}

void ES::exit(Miner* miner)
{
    cout << "\n" << EMGR->getNameOfEntity(miner->ID()) << ": " << "Thankya li'lle lady. Ah better get back to whatever ah wuz doin'";
}

bool ES::onMsg(Miner* miner, const Telegram& tel)
{
    return false;
}

此处由于是测试，并未带有完整的消息处理。这个状态集合描述了miner从工作，赚钱，休息，吃饭的完整集合，状态可循环。下次我会放上整个程序给大家看看。

准备写一个有关游戏底层算法，物理算法，以及AI（重点是机器学习在游戏中的应用）的长篇博客，欢迎大家指正交流╰(￣▽￣)╯

PureDesigner
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
游戏逻辑底层，MainLoop&&FSM&&MSG（一）
PureDesigner的博客
04-06 870
MainLoop–游戏主循环简单的程序主要分为两个线程，一个线程负责处理界面刷新（一般需要较高FPS），另一个线程负责处理程序逻辑（刷新频率较低），此篇文章主要介绍游戏的逻辑线程，我称之为GameMainLoop（以下简称ML）。 基本的ML很简单，定义逻辑刷新频率，定义刷新执行事件，我们直接来看代码MainLoop.h//headers...typedef std::function<void(
游戏主循环基础例子 GameLoop
hunter_wyh
04-08 735
游戏主循环基础例子 GameLoop 这里比较简单，直接发代码好了 import time from loguru import logger from core import GetDeltaTime, SetLastFrameTime FPS = 60 # 帧 g_IsRunning = False g_IsPause = False def init(*args, **kw...
MainLoop 类
游戏开发
12-22 601
MainLoop Inherits: Object Inherited By: SceneTree Abstract base class for the game’s main loop. 游戏主循环的抽象基类。 Description MainLoop is the abstract base class for a Godot project’s game loop. It is inherited by SceneTree, which is the default game loop implem
游戏逻辑编程和游戏引擎编程
小橙子的博客
10-18 977
既然要开始游戏编程，首先要选择语言工具，C和C++是开发游戏引擎的首选。 游戏编程广义上讲可以分成游戏逻辑编程和游戏引擎编程。然而，它们两者之间的边界往往又没有那么泾渭分明。 游戏逻辑开发是指集中力量开发游戏中的剧情和玩法，要决定的是什么时候显示什么内容，什么时候播放什么声音，什么时候通过网络传输什么数据，什么时候这个物体或者人物做某个动作。至于图像如何显示，声音如何处理，数据如何传输，物体动作如何实现，游戏逻辑开发者其实并不用关心，这些归游戏引擎来处理。 所以说游戏逻辑负责游戏核心玩法方面的内容，游戏引擎
FSM有限状态机
qq_33875256的博客
11-26 1085
FSM是finite state machine的缩写，有限状态机，是ChaincodeSupport服务使用到的一个第三方库，在github.com/looplab/fsm可以下载。FSM将一个事物从状态A向状态B的转化看作一个事件，并可以设置在进入/离开某个状态时自动调用的时机函数。每个状态事件、状态、时机函数都用字符串关键字表示。在此简单介绍一下用法： //创建一个状态机 //三个参数：1...
wxPython Demo & installation
11-28
Python GUI 库如 wxPython 提供了一种简单且高效的方法，让程序员能够专注于应用程序的逻辑，而不是底层的图形细节。wxPython 支持多种操作系统，包括 Windows、macOS 和 Linux，这使得开发者可以编写一次代码，到处...
python2.7&wxPython
10-26
15. **第三方库**：除了标准库，Python 2.7还可以使用丰富的第三方库，如NumPy、Pandas、Matplotlib等，进一步扩展其功能。 学习和掌握这些知识点，你就能利用Python 2.7和wxPython开发出功能完备、跨平台的GUI应用...
图形用户界面和游戏开发.md
最新发布
04-20
Pygame让开发者可以从复杂的底层细节中解脱出来，更加专注于游戏的逻辑和功能实现。 ##### 制作游戏窗口 下面是一个使用Pygame创建游戏窗口的基础示例： ```python import pygame def main(): # 初始化导入的...
基于Tkinter实现五子棋小游戏.7z
05-17
总结，基于Tkinter实现五子棋小游戏需要掌握Tkinter的基本组件和事件处理机制，理解棋盘和棋子的表示，编写游戏逻辑，以及优化用户界面。通过这个项目，开发者不仅可以提升Tkinter编程技能，还能锻炼到问题解决和...
tkinter猜数游戏代码以及报告
10-14
总之，tkinter猜数游戏是一个很好的学习tkinter和Python基础编程的实践项目，通过它，你可以深入理解GUI编程的基本概念，同时锻炼逻辑思维和问题解决能力。对于初学者来说，这是一个非常有价值的练习。
FSM(有限状态机)golang基本状态操作
weixin_54433389的博客
05-31 1145
golang中fsm（状态机）使用和简单状态转换
Akka FSM 源码分析
萧猛的技术博客
06-18 2809
Akka FSM 源码分析 萧猛 &lt;simonxiao@qq.com&gt; 啰嗦几句 有限状态机本身不是啥新鲜东西，在GoF的设计模式一书中就有状态模式， 也给出了实现的建议。各种语言对状态机模式都有很多种实现的方式。我自己曾经用C++和java实现过，也曾经把 apache mina 源码中的一个状态机实现抠出来单独使用。但Akka的状态机是我见过的最简洁漂亮实现，充分利用了Sc...
模拟insert，update和delete造成阻塞的示例
还不算晕的专栏
10-28 2744
会话1SID BYS@dg2>select distinct sid from v$mystat;        SID ----------         17 会话2SID BYS@dg2>select distinct sid from v$mystat;        SID ----------         49 insert造成阻塞的示例
有限状态机(FSM)
bbhe_work的博客
11-17 1625
Finite State Machine(FSM)是一种人工智能的实现方式,对象在不同的状态间转换,且某一时刻只能处于一个状态;FSM中对象的行为是由我们自己设置的流程, 在加入消息功能后, 不同对象之间可以通过消息通信的方式来完成互动, 因此会显然非常只能; 案例 参考<<游戏人工只能编程案例精粹>>,这里写了一个类似的渔夫与妻子的一天的简单生活案例;
FSM-Golang
Abel's Blog
11-19 656
这里写自定义目录标题概念游戏中常用的状态机阅读 looplab/fsm 实现参考 使用FSM（Finite State Machine）来制作怪物的AI，比较轻量级； 概念 状态机分为两大类： 名称 说明 Moore machine 输出只和状态有关而与输入无关 Mealy machine 输出不仅和状态有关而且和输入有关系（使用这种状态机通常可以减少状态的数量。） 状态机可归纳为4个要素，即现态、条件、动作、次态。这样的归纳，主要是出于对状态机的内在因果关系的考虑。“现态”和“条件
游戏主循环(Game Loop)的详细解析
Zzz的专栏
03-10 9841
译自：https://dewitters.com/dewitters-gameloop/ 1. 引言 　　游戏主循环是每个游戏的心跳，输送着整个游戏需要的养分。不幸的是没有任何一篇好的文章来指导一个菜鸟游戏程序员如何为自己的程序供养。不过不用担心，因为你刚好不小心看到了这篇，也是唯一一篇给予这个话题足够重视的文章。 　　由于我身为游戏程序员，我见过许许多多的手机小游戏的代码。这些代码给我展示...
main_loop()函数
热门推荐
每天进步一点点
09-23 1万+
main_loop()函数做的都是与具体平台无关的工作，主要包括初始化启动次数限制机制、设置软件版本号、打印启动信息、解析命令等。 （1）设置启动次数有关参数。在进入main_loop()函数后，首先是根据配置加载已经保留的启动次数，并且根据配置判断是否超过启动次数。代码如下：
游戏底层逻辑，运动&&寻路（三）
PureDesigner的博客
04-16 4364
上篇文章我们解释了几种基本的控制力，今天我们会讨论几种较为复杂的行为，涉及了碰撞，以及辅助图形进行运动控制。7、Wander徘徊（巡逻）徘徊（四处巡逻）是一种很常见的行为，但是要得到smoothly平滑的转向行为，并不是特别容易，这里有一种借用辅助圆实现的平滑移动。如图，我们在物体前面构造了一个辅助圆，我们控制目标点，从而用seek方法控制运动行为，如果我们让目标点在圆周上运动，就可以产生一个力，他
游戏底层逻辑，空间划分
PureDesigner的博客
05-07 2792
前言 不知道大家注意到之前有一个寻找相邻个体的方法叫做getNeighbors没有，该方法的实现如下： - 遍历所有个体，计算距离是否小于一定范围，确定邻居 我们可以预知，该方法在个体总数较小的时候效率较高，一旦个体数突破上百个，就很容易造成极大的cpu开销，所以此处我们需要研究出另外的索引方案来得到邻居。 空间划分的方案主流的有很多，例如四叉树，八叉树，bsp树，四叉树主要用于
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值