欧美视频中文字幕在线,欧美日韩专区在线,欧美黄色视屏

肥仔 — Wed, 24 Dec 2008 07:18:00 GMT

从今天开始我把我前一�D�|��间用到的状态机工具Ragel的��用方法做一些�ȝ��,希望大家斧正!

(如果大家对状态机概念有模�p�的�?span lang="EN-US">,请参�?span lang="EN-US"><<�~�译原理>>一�?span lang="EN-US">,基本上有详尽的介�l?span lang="EN-US">)

好闲�a��叙,�a�归正�?span lang="EN-US">

Ragel可以从正规表辑ּ�生成可执行有限状态机,它可以生�?span lang="EN-US">C,C++,Object-C,D,Java�?span lang="EN-US">Ruby可执行代�?span lang="EN-US">

官方�|�站:http://www.cs.queensu.ca/home/thurston/ragel/

�W�一�?span lang="EN-US">

Ragel是一个可以生成协议处理代码的工具.　

先�D个例子，��单单的几行代�?span lang="EN-US">,实现的功能�ؓ��一个数字字�W�串转换成整敎ͼ�

[Copy to clipboard] [ - ]

CODE:

int atoi( char *str )
{
char *p = str;
int cs, val = 0;
bool neg = false;

%%{       //Ragel 的关键字,用于声明状态机代码�D늚�开�?span lang="EN-US">
action see_neg {
   neg = true;
}

action add_digit {
   val = val * 10 + (fc - '0');
}

main :=
   ( '-'@see_neg | '+' )? ( digit @add_digit )+
   '\n' @{ fbreak; };

# Initialize and execute.
write init;                                  //状态机关键�?span lang="EN-US">,�q�个会再接下来的内容中介�l?span lang="EN-US">
write exec noend;                     //同上
}%%                                        //状态机代码�D늻�束标�?span lang="EN-US">

if ( neg )
val = -1 * val;

if ( cs < atoi_first_final )
cerr << "atoi: there was an error" << endl;

return val;
};

�?span lang="EN-US">c里面�?span lang="EN-US">500多行实现�?span lang="EN-US">atoi函数更加高效

上面�q�段代码�Q�生成的C语言代码如下:

[Copy to clipboard] [ - ]

CODE:

int atoi( char *str )
{
char *p = str;
int cs, val = 0;
bool neg = false;

#line 27 "atoi.c"
{
cs = atoi_start;
}

#line 31 "atoi.c"
{
switch ( cs )
{
case 1:
switch( (*p) ) {
case 43: goto st2;
case 45: goto tr2;
}
if ( 48 <= (*p) && (*p) <= 57 )
goto tr3;
goto st0;
st0:
goto _out0;
tr2:
#line 23 "atoi.rl"
{
neg = true;
}
goto st2;
st2:
p += 1;
case 2:
#line 52 "atoi.c"
if ( 48 <= (*p) && (*p) <= 57 )
goto tr3;
goto st0;
tr3:
#line 27 "atoi.rl"
{
val = val * 10 + ((*p) - '0');
}
goto st3;
st3:
p += 1;
case 3:
#line 63 "atoi.c"
if ( (*p) == 10 )
goto tr4;
if ( 48 <= (*p) && (*p) <= 57 )
goto tr3;
goto st0;
tr4:
#line 33 "atoi.rl"
{ goto _out4; }
goto st4;
st4:
p += 1;
case 4:
#line 74 "atoi.c"
goto st0;
}
_out0: cs = 0; goto _out;
_out4: cs = 4; goto _out;

_out: {}
}
#line 38 "atoi.rl"

if ( neg )
val = -1 * val;

if ( cs < atoi_first_final )
cerr << "atoi: there was an error" << endl;

return val;
};

对应的状态图如下图所�C?span lang="EN-US">:

正则表达式广泛应用于解析器中。它们通常被用来作�?span lang="EN-US">�?/span>黑盒�?/span>与程序逻辑联系在一赗��对正则表达式引擎在执行某些解析工作之后�Q�调用用戯��定义行�ؓ。加入新的自定义行�ؓ�Q�需要重新定义原来的格局�Q�然后粘贴到�E�序逻辑中。自定义行�ؓ��多�Q�正规表辑ּ�的优势越��?span lang="EN-US">

Ragel是一个可以根据用户定义的正则表达式或是由正则表达式生成的状态图来生成健壮的�Q�无依赖的可执行代码�Q�包�?span lang="EN-US">C�Q?span lang="EN-US">C++�Q?span lang="EN-US">Object-C, Java, Ruby �{�等. 可以灉|��控制已经生成状态机的变动，利用已经嵌入自定义行为的模式重构扫描�?span lang="EN-US">

Ragel��Z��M��正规语言能被转化为有限状态自动机的原�?span lang="EN-US">

基本的��用步骤如�?span lang="EN-US">:

首先,�Ҏ��你的业务��程逻辑与需�?span lang="EN-US">,按照ragel提供的语法与关键字编�?span lang="EN-US">.rl文�g

1�Q?span lang="EN-US"> �~�写.rl文�g, 如下所�C�：

[Copy to clipboard] [ - ]

CODE:

/*
* to parse a string started with “table�?or “div�?br>*/

#include
#include
#include

%%{
                #状态机的名�?span lang="EN-US">(必须有一个名字而且必须�W�合命名规则,和变通的变量声明一�?span lang="EN-US">)
        machine par_str;
        write data;
}%%
//函数声明,用于在用戯��定义行�ؓ中调�?span lang="EN-US">,用到了参数的传�?span lang="EN-US">,此函��C��可以是类成员函数
void printtable(int len)
{
   printf("there is a table,length is:%d\n",len);
}

//另外一个函�?span lang="EN-US">,功能同上,只是参数传递用的是引用传�?span lang="EN-US">
void printdiv(char *p)
{
printf("%s\n",(*p));
}
//��d��理函�?span lang="EN-US">
void par_str( char *str,int len )
{
        char *p = str, *pe = str + strlen( str );
        int cs;        //状态机关键�?span lang="EN-US">,用于说明当明状�?span lang="EN-US">,以整型值标�?span lang="EN-US">(current status的羃�?span lang="EN-US">)
                //状态机自定义行为块
        %%{
                        #调用自定义函�?span lang="EN-US">
                        action see_table {
                                 printtable(len);
                }
               #invoke prindiv function to show the table information, as same as above
               action see_div {
                                  printdiv(p);
               }
               #正则表达式声�?span lang="EN-US">,用于在状态机初始化时,按照此规则匹配目�?span lang="EN-US">
               main :=
                                ([t][a][b][l][e]@see_table) ([d][i][v]@see_div)+'\n';
               # 初始�?span lang="EN-US">
               write init;
               write exec;
        }%%

                if ( cs < par_str_first_final )
                fprintf( stderr, "par_str: there was an error\n" );
};

#define BUFSIZE 1024
//��d��?span lang="EN-US">,用于��试生成的状态机
int main()
{
        char buf[BUFSIZE];
        while ( fgets( buf, sizeof(buf), stdin ) != 0 )
{
par_str(buf,10);
}
                return 0;
}

接下�?span lang="EN-US">,�?span lang="EN-US">ragel命��o生成目的语言文�g

CODE:

ragel -o test.cpp test.rl

用代码生成工�?span lang="EN-US">,直接生成可执行代�?span lang="EN-US">

CODE:

rlcodegen -o hello.cpp test.cpp

最后编写对此代码的Makefile,make........

肥仔 2008-12-24 15:18 发表评论

肥仔 — Sun, 14 Dec 2008 11:33:00 GMT

看看��时候玩�?span lang="EN-US">5块钱那种最��单的电子表。只�?span lang="EN-US">2个按钮就能操�?暂且�U�Cؓ按钮A和按�?span lang="EN-US">B)�?br> 现给��Z��个完整的功能文字描述�Q?span lang="EN-US">
     在显�C�时间时�?span lang="EN-US">A�Q�屏�q�显�C�变成日�?span lang="EN-US">
     在显�C�日期时�?span lang="EN-US">A�Q�屏�q�显�C�变成秒�?span lang="EN-US">
     在显�C�秒钟时�?span lang="EN-US">A�Q�屏�q�显�C�变成时�?span lang="EN-US">
     在显�C�秒钟时�?span lang="EN-US">B�Q�秒钟归0
     在显�C�时间时�?span lang="EN-US">B�Q�屏�q?旉��、日期交替显�C��?span lang="EN-US">
     在时间、日期交替显�C�时�?span lang="EN-US">B�Q�屏�q?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>闪烁
     �?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>闪烁时按B�Q�屏�q?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>�?span lang="EN-US">1�Q�超�q?span lang="EN-US">23�?span lang="EN-US">0
     �?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>闪烁时按A�Q�屏�q?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>闪烁
     �?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>闪烁时按B�Q�屏�q?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>�?span lang="EN-US">1�Q�超�q?span lang="EN-US">59�?span lang="EN-US">0
     �?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>闪烁时按A�Q�屏�q?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>闪烁
     �?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>闪烁时按B�Q�屏�q?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>�?span lang="EN-US">1�Q�超�q?span lang="EN-US">12�?span lang="EN-US">0
     �?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>闪烁时按A�Q�屏�q?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>闪烁
     �?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>闪烁时按B�Q�屏�q?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>�?span lang="EN-US">1�Q�超�q?span lang="EN-US">31�?span lang="EN-US">0
     �?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>闪烁时按A�Q�屏�q�回到时间显�C?span lang="EN-US">

    如果按照新手的思�\�Q�尝试去��L��E�图�Q�很快就会陷入一头雾��_��你会发现实现�q�个功能的程序根本就没有�?/span>��定的流�E?span lang="EN-US">�?/span>。因为程序实际流�E�是�Ҏ��人的操作而变化的。程序运行到什么地方，完全取决于两个键的次序，有无数种�ơ序�l�合�Q�根本不可能��d��程图来�?span lang="EN-US">
    但是我们会发玎ͼ��q�个电子表功能的�?/span>语言描述�?/span>在语法上��g��有某�U�规律，��是�Q?span lang="EN-US">
    当系�l�处于某状态（S1�Q�时�Q�如果发生了什么事�?span lang="EN-US">(E)�Q�就执行某功�?span lang="EN-US">(F)�Q�然后系�l�变成新状态（S2�Q?span lang="EN-US">
    只要能用上面�q�句话描�q�的�pȝ��Q�都可以用一�U�状态蟩转机制很方便的实�?span lang="EN-US">
�Q��ƈ且一句话其实��是一�?span lang="EN-US">if(...)�Q�无论有多少多复杂的功能�Q�只要能用上面这句话描述�Q�都可以通过状态机�~�程实现�?span lang="EN-US">

我们��它们抽象。整个系�l�中�?span lang="EN-US">2个事件分别是�Q?span lang="EN-US">A按下�Q?span lang="EN-US">B按下

    A按下(可以是中�?span lang="EN-US">)时执行：
{
     if(Status==TIME) //当显�C�时间时按下A�?span lang="EN-US">
     {
        Status=DATE    //变成昄��日期
     }
     if(Status==DATE) //当显�C�日期时按下A�?span lang="EN-US">
     {
        Status=SEC     //变成昄��U�钟
     }
     if(Status==SEC) //当显�C�秒钟时按下A�?span lang="EN-US">
     {
        Status=TIME     //变成昄��旉��
     }
     if(Status==SET_HOUR) //当设�|?span lang="EN-US">�?/span>��时�?/span>时按�?span lang="EN-US">A�?span lang="EN-US">
     {
        Status=SET_MINUT        //变成讄��?/span>分钟�?br>     }
     if(Status==SET_MINUT) //当设�|?span lang="EN-US">�?/span>分钟�?/span>时按�?span lang="EN-US">A�?span lang="EN-US">
     {
        Status=SET_MONTH        //变成讄��?/span>�?span lang="EN-US">�?br>     }
     .....
     .....
}

    B按下(可以是中�?span lang="EN-US">)时执行：
{
      if(Status==SEC) //当显�C�秒钟时按下B�?span lang="EN-US">
     {
        Secound=0     //�U�归0
     }
     if(Status==TIME) //当显�C�时间时按下B�?span lang="EN-US">
     {
        Status=TIMEDATE    //变成旉��日期交替昄��
     }
     if(Status==TIMEDATE) //当日期交替显�C�时按下B�?span lang="EN-US">
     {
        Status=SET_HOUR    //变成讄��?/span>�?span lang="EN-US">�?/span>�Q�时闪烁�Q?span lang="EN-US">
     }
     if(Status==SET_HOUR) //当设�|?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>时按�?span lang="EN-US">B�?span lang="EN-US">
     {
        Status=Hour++      //时加1
        if(Hour>23) Hour="0";
     }

     .....
     .....
}

     和语�a�描述完全一��_��很快��p��写完�E�序。这��是最��单的状态机思想�?span lang="EN-US">
     当然�Q�上�q�C��大堆if可以�?span lang="EN-US">switch case来实�?span lang="EN-US">
     实际中，大量的�ƈ发过�E�都可以表述为状态蟩转关�p�，从而将CPU从过�E�中解放出来�Q�只需处理状态关�p�，因�ؓ真正需�?span lang="EN-US">CPU的是状态变化的时刻�Q�而不是过�E�中大量的等待，�q�样大量的�ƈ发过�E�都可以�q�行处理�?span lang="EN-US">

肥仔 2008-12-14 19:33 发表评论

什么是有限状态机FSM

肥仔 — Sun, 14 Dec 2008 10:54:00 GMT

��?span lang="EN-US">

有限状态机�Q�以下用FSM指代�Q�是一�U�算法思想�Q�简单而言�Q�有限状态机�׃��l�状态、一个初始状态、输入和�Ҏ��输入及现有状态�{换�ؓ下一个状态的转换函数�l�成。在Gof�?span lang="EN-US">23�U�设计模式里�?span lang="EN-US">state模式是一�U�面向对象的状态机思想�Q�可以适应非常复杂的状态管理�?span lang="EN-US">
�?在，FSM被普遍用于搜索引擎的分词、编译器实现和我们普遍关注的游戏开发中。游戏开发中�Q�通常�?span lang="EN-US">FSM实现NPC控制�Q�如�?span lang="EN-US">NPC受到��d��时根据健店��力量等选择逃跑�q�是反攻的行为，一般是�?span lang="EN-US">FSM实现的�?span lang="EN-US">FSM的实现方法有很多�U�，不能��单地说孰优孰劣，但现代开发中�Q�一般都比较推荐面向对象的实现方式：因�ؓ可重用性和健壮性更高，而且当需求变更的时候，也有很好的适应性�?span lang="EN-US">
实践
�?��Z��实践中来�Q�也要回到实践中厅R��我们现在通过实例来探索一�?span lang="EN-US">FSM的实现吧。首先假设有�q�样一个世界（World�Q�，世界里只有一台永不缺乏动力的汽�R �Q?span lang="EN-US">Car�Q�，汽�R是次世代的，没有沚w��方向盘之�cȝ��落后讑֤��Q�只有两个互斥的按钮—�?/span>停止�Q?span lang="EN-US">Stop�Q�和行进�Q?span lang="EN-US">Run�Q�，随着旉��的流逝，汽�R�Ҏ��N��员的操作走走停停。下面的代码可以实现�q�种功能�Q?span lang="EN-US">
       while True:
       key = get_key() # 按下什么键
       if key == "stop":
              stop(car)
       elif key == "run":
              go(car)
       keep(car) # 保持原�?span lang="EN-US">

�?成了功能而且直观、简�z�的�E�序员万岁！但这时候客��P��{�划或者玩�Ӟ��觉得走走停停太没意思了�Q�他们想要掉头、左转和双��{的功能，我们��p��?span lang="EN-US">while循环里增加更多的if...else分支�Q�他们想要更多的车，我们��p��要在每一个分枝里增加循环�Q�他们不仅仅惌��Car了，他们�q�要要玩Truck�Q�这时我�?��需要在分枝的��@环里判断当前的�R是否支持�q�个操作�Q�如Truck的装卸货�?span lang="EN-US">Car��׃��支持�Q�；他们…�?
�q�个while循环�l�于无限地庞大�v来，我们认识到这��L��设计的确是有炚w��题的�Q�所以我们尝试用另一�U�方法去实现FSM。首先我们来实现汽�R�Q?span lang="EN-US">Car�Q�：
       class Car(object):
       def stop(self):
              print "Stop!!!"
       def go(self):
              print "Goooooo!!!"

只有两个�Ҏ��stop�?span lang="EN-US">go�Q�分别执�?span lang="EN-US">Stop�?span lang="EN-US">Run两个按钮功能。接下来我们�~�写两个状态管理的�c�，用以处理当按钮被按下、弹起和保持旉��要工作的��程�Q?span lang="EN-US">
class stop_fsm(base_fsm):
       def enter_state(self, obj):
              print "Car%s enter stop state!"%(id(obj))

       def exec_state(self, obj):
              print "Car%s in stop state!"%(id(obj))
              obj.stop()

       def exit_state(self, obj):
              print "Car%s exit stop state!"%(id(obj))
class run_fsm(base_fsm):
       def enter_state(self, obj):
              print "Car%s enter run state!"%(id(obj))

       def exec_state(self, obj):
              print "Car%s in run state!"%(id(obj))
              obj.go()

       def exit_state(self, obj):
              print "Car%s exit run state!"%(id(obj))

stop_fsm�?span lang="EN-US">run_fsm都��承自base_fsm�Q?span lang="EN-US">base_fsm是一个纯虚的接口�c�：
class base_fsm(object):
       def enter_state(self, obj):
              raise NotImplementedError()

       def exec_state(self, obj):
              raise NotImplementedError()

       def exit_state(self, obj):
              raise NotImplementedError()

enter_state �?span lang="EN-US">obj�q�入某状态的时候调�?span lang="EN-US">—�?/span>通常用来做一些初始化工作�Q?span lang="EN-US">exit_state也离开某状态的时候调�?span lang="EN-US">—�?/span>通常做一些清理工作；�?span lang="EN-US"> exec_state则在每一帧的时候都会被调用�Q�通常做一些必要的工作�Q�如��自��q��消息队列�q�处理消息等。在stop_fsm�?span lang="EN-US">run_fsm两个�c?�?span lang="EN-US">exec_state函数中，��p��用了对象�?span lang="EN-US">stop�?span lang="EN-US">go函数�Q�让汽�R保持原有的状态�?span lang="EN-US">
至现在�ؓ止，Car�q�没有接触到FSM�Q�所以我们需要提供一个接口，可以让它拥有一�?span lang="EN-US">FSM�Q?span lang="EN-US">
       def attach_fsm(self, state, fsm):
              self.fsm = fsm
              self.curr_state = state

我们�q�需要�ؓCar提供一个状态�{换函敎ͼ�
       def change_state(self, new_state, new_fsm):
              self.curr_state = new_state
              self.fsm.exit_state(self)
              self.fsm = new_fsm
              self.fsm.enter_state(self)
              self.fsm.exec_state(self)

�?span lang="EN-US">Car提供一个保持状态的函数�Q?span lang="EN-US">
def keep_state(self):
self.fsm.exec_state(self)

现在只有两个状态，但我们知道需求随时会改动�Q�所以我们最好弄一个状态机��理器来��理�q�些状态：
class fsm_mgr(object):
       def __init__(self):
              self._fsms = {}
              self._fsms[0] = stop_fsm()
              self._fsms[1] = run_fsm()

       def get_fsm(self, state):
              return self._fsms[state]

       def frame(self, objs, state):
              for obj in objs:
                     if state == obj.curr_state:
                            obj.keep_state()
                     else:
                            obj.change_state(state, self._fsms[state])

fsm_mgr最重要的函数就�?span lang="EN-US">frame�Q�在每一帧都被调用。在�q�里�Q?span lang="EN-US">frame�Ҏ��对象现在的状态和当前的输入决定让对象保持状态或者改变状态�?span lang="EN-US">
�q�时候，我们的实例基本上完成了。但我们�q�要做一件事�Q�就是徏立一个世界（World�Q�来驱动状态机�Q?span lang="EN-US">
class World(object):
       def init(self):
              self._cars = []
              self._fsm_mgr = fsm_mgr()
              self.__init_car()

       def __init_car(self):
              for i in xrange(1):   # 生��汽�R
                     tmp = Car()
                     tmp.attach_fsm(0, self._fsm_mgr.get_fsm(0))
                     self._cars.append(tmp)

       def __frame(self):
              self._fsm_mgr.frame(self._cars, state_factory())

       def run(self):
              while True:
                     self.__frame()
                     sleep(0.5)

�?代码可见�Q?span lang="EN-US">World里有Car对象�Q?span lang="EN-US">fsm_mgr对象�Q�在run函数里，�?span lang="EN-US">0.5s执行一��?span lang="EN-US">__frame函数�Q?span lang="EN-US">FPS = 2�Q�，�?span lang="EN-US">__frame函数只是驱动�?span lang="EN-US">fsm_mgr来刷新对象，新的命��o是从state_factory函数里取出来的，�q�个函数用以模拟��N��员的操作�Q�按�?span lang="EN-US">Stop或�?span lang="EN-US">Run按钮之一�Q�：
def state_factory():
return random.randint(0, 1)

现在我们��p��初始化世界（World�Q�可以跑��h��们的FSM了！
if __name__ == "__main__":
       world = World()
       world.init()
       world.run()

�?span lang="EN-US">python解释器执行上面的代码�Q�我们可以看到程序不停地输出Car的状态：
......
Car8453392 exit run state!
Car8453392 enter stop state!
Car8453392 in stop state!
Stop!!!
Car8453392 in stop state!
Stop!!!
Car8453392 exit stop state!
Car8453392 enter run state!
Car8453392 in run state!
Goooooo!!!
Car8453392 exit run state!
Car8453392 enter stop state!
Car8453392 in stop state!
Stop!!!
Car8453392 exit stop state!
Car8453392 enter run state!
Car8453392 in run state!
Goooooo!!!
Car8453392 in run state!
Goooooo!!!
Car8453392 exit run state!
Car8453392 enter stop state!
Car8453392 in stop state!
Stop!!!
Car8453392 in stop state!
Stop!!!
Car8453392 exit stop state!
Car8453392 enter run state!
Car8453392 in run state!
Goooooo!!!
......

�l�论
�q�时再回头来看看我们之前的问题：
1、玩家想要功能更多的Car�Q�比如掉头�?span lang="EN-US">
�?们可以通过�?span lang="EN-US">Car增加一个调��_��back�Q�的�Ҏ��来执行掉��_��然后�?span lang="EN-US">base_fsm中��承一�?span lang="EN-US">back_fsm来处理调头。之后在fsm_mgr里增加一�?span lang="EN-US">back_fsm实例�Q�及�?span lang="EN-US">state_factory产生调头指��o。听��h��g��比之�?span lang="EN-US">while+if的方式还要麻烦不��，其实不然�Q�这里只�?span lang="EN-US"> back_fsm和�ؓfsm_mgr增加back_fsm实例才是�Ҏ��的，其它步骤两种�Ҏ��都要执行�?span lang="EN-US">
2、玩家要更多�?span lang="EN-US">Car�?span lang="EN-US">
�q�对于面向对象的FSM实现��太��单了�Q�我们只要把World.__init_car里的生��数量修改一下就行了�Q�要多少有多��?span lang="EN-US">
3、玩家要更多型号的�R�Q�如Truck�?span lang="EN-US">
�?span lang="EN-US">Car�z��一�?span lang="EN-US">Truck�Q�然后增加装货、卸货的接口。最大的改动在于Truck状态�{换的时候需要一些判断，如不能直接从装货状态�{换到开动状态，而是装货、停止再开动�?span lang="EN-US">
�?�q�这几个��单的问题分析�Q�我们可以看刎ͼ�使用面向对象的方式来设计FSM�Q�在需求变更的时候，一般都只增删代码，而仍��需要改动已有代码，�E�序的扩展性、适应性和健壮性都得很大的提高�Q�因此，在世界庞大、物�U�烦多、状态复杂且条�g交错的游戏开发中应用面向对象�?span lang="EN-US">FSM实在是明��Z��选。还有一点，面向对象�?span lang="EN-US"> FSM可以非常�Ҏ��地模拟消息机�Ӟ��q�有利于模块清晰化，更容易设计出正交的程序�?

肥仔 2008-12-14 18:54 发表评论

为Linux应用构造有限状态机�Ҏ��

肥仔 — Sun, 14 Dec 2008 10:40:00 GMT

摘要: 有限自动机（Finite Automata Machine�Q�是计算机科学的重要基石�Q�它在��Y件开发领域内通常被称作有限状态机�Q�Finite State Machine�Q�，是一�U�应用非常广泛的软�g设计模式�Q�Design Pattern�Q�。本文介�l�如何构建基于状态机的��Y件系�l�，以及如何利用Linux下的工具来自动生成实用的状态机框架�?　　一、什么是状态机　　有限状态机是一�U�用来进行对象行为徏模的工具... 阅读全文

肥仔 2008-12-14 18:40 发表评论

游戏中的有限状态机

肥仔 — Sun, 14 Dec 2008 09:56:00 GMT

�q�是GAMEGEMS中的�W�三章的�W�一部分�Q�番的不好。你可以直接阅读原文。原本以��是�h工智能的部分�Q�看��C��半才发现只是一个简单的框架。如果你惛_��人工��Q�这里没有，��׃��要浪�Ҏ��间了。由于本人水�q�x��限，其中隑օ�会出现原则性的错误�Q�希望指正�?span lang="EN-US">

关键字：有限状态机、状态、输入、状态�{换、输出状态当前状�?span lang="EN-US">

一个有限状态机�c?span lang="EN-US">
在这��文章中�Q�我们创��Z��一个通用的有限状态机�Q?span lang="EN-US">FSM�Q�的C++�c�R��有限状态机是计��机�U�学和数学理论的抽象�Q�它在许多的斚w��是很有用处的。这里我们不去讲解有限状态机的理��Z��的知识。而是讲如何实��C��?span lang="EN-US">�?/span>有限状态机�?/span>�Q?span lang="EN-US">�?/span>有限状态机�?/span>在游戏的人工��斚w��是很有用处的�?span lang="EN-US">

�?/span>有限状态机�?/span>是由有限的状态组成的一个机制。一�?span lang="EN-US">�?/span>状�?span lang="EN-US">�?/span>��是一个状��c��你考虑一下门�Q�它�?span lang="EN-US">�?/span>状�?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>开�?/span>�?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>以及�?/span>�?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>未锁�?/span>�?span lang="EN-US">

对于一�?span lang="EN-US">�?/span>有限状态机�?/span>�Q�它应该有一�?span lang="EN-US">�?/span>输入�?/span>。这�?span lang="EN-US">�?/span>输入�?/span>可以影响�?/span>状态�{�?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>有限状态机�?/span>应该有一个简单（或复杂）的状态�{换函敎ͼ��q�个函数可以军_��什么状态可以变�?span lang="EN-US">�?/span>当前状�?span lang="EN-US">�?/span>�?span lang="EN-US">

�q�个当前的新状态被�U�Cؓ�?/span>有限状态机�?/span>�?span lang="EN-US">�?/span>状态�{�?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>输出状�?span lang="EN-US">�?/span>。如果你对这个概忉|��些迷惑，��把�?/span>�?span lang="EN-US">�?/span>做�ؓ理解�?/span>有限状态机�?/span>的例子。当一�?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>处于�?/span>关闭�?/span>状态和�?/span>�?span lang="EN-US">�?/span>状态，当你输入�?span lang="EN-US">�?/span>使用钥匙�?/span>�Ӟ��门的状态可以变�?span lang="EN-US">�?/span>未锁�?/span>状态（�?span lang="EN-US">�?/span>状态�{�?span lang="EN-US">�?/span>的输出状态，也就是门的当前状态）。当你输入了�?/span>使用�?span lang="EN-US">�?/span>�Ӟ��门的状态可以�{换成�?/span>开�?/span>的状态。当门处�?span lang="EN-US">�?/span>开�?/span>的状态时�Q�我们输�?span lang="EN-US">�?/span>使用�?span lang="EN-US">�?/span>�Ӟ��会��门的状态重新回�?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>的状态。当�?/span>�?span lang="EN-US">�?/span>处于�?/span>�?span lang="EN-US">�?/span>的状态时�Q�我们输�?span lang="EN-US">�?/span>使用钥匙�?/span>�Ӟ��q�将会��门重新回�?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>的状态。当门处�?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>的状态，我们输入�?/span>使用�?span lang="EN-US">�?/span>�Q�就不能把门的状态�{换到�?/span>开�?/span>的状态，门仍然会保持�?/span>�?span lang="EN-US">�?/span>的状态。还有，当门处于�?/span>开�?/span>的状态时�Q�我们输�?span lang="EN-US">�?/span>使用钥匙�?/span>是不能把门的状态�{换成�?/span>�?span lang="EN-US">�?/span>的状态的�?span lang="EN-US">

��M��Q?span lang="EN-US">�?/span>有限状态机�?/span>是一个有限的状态组成的�Q�其中的一个状态是�?/span>当前状�?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>有限状态机�?/span>可以接受一�?span lang="EN-US">�?/span>输入�?/span>�Q�这�?span lang="EN-US">�?/span>输入�?/span>的结果将��D��一�?span lang="EN-US">�?/span>状态�{�?span lang="EN-US">�?/span>的发生（即从�?/span>当前状�?span lang="EN-US">�?/span>转换�?span lang="EN-US">�?/span>输出�?/span>状态）。这�?span lang="EN-US">�?/span>状态�{�?span lang="EN-US">�?/span>是基�?span lang="EN-US">�?/span>状态�{换函�?span lang="EN-US">�?/span>的。状态�{换完成之后，�?/span>输出状�?span lang="EN-US">�?/span>卛_��成了�?/span>当前状�?span lang="EN-US">�?/span>�?span lang="EN-US">

输入状态�{换函�?span lang="EN-US">
当前状�?span lang="EN-US">-----》状态�{�?span lang="EN-US">-------------》输出状态（当前状态）

那么�Q��h们是如何��这个概念应用到游戏�?span lang="EN-US">AI�pȝ��中的呢？有限状态机的功能很多：��理游戏世界、模�?span lang="EN-US">NPC的思维、维护游戏状态、分析玩游戏的�h的输入，或者管理一个对象的状态�?span lang="EN-US">

假如在一个冒险游戏中有一�?span lang="EN-US">NPC�Q�名字可以叫MONSTER。我们可以先假设�q�个MONSTER在游戏中有如下的状态：BERSERK�?span lang="EN-US">RAGE�?span lang="EN-US">MAD�?span lang="EN-US">ANNOYED以及UNCARING。（前几个状态不好分别）。假设，MONSTER对于不同的状态可以执行不同的操作�Q��ƈ且假设你已经有了�q�些不同操作的代码。我们这时可以��?span lang="EN-US">�?/span>有限状态机�?/span>来模拟这�?span lang="EN-US">MONSTER的行��Z��。只要我们给��Z��同的�?/span>输入�?/span>�Q?span lang="EN-US">MONSTER��׃��做出不同的反应。我们再来指��?span lang="EN-US">�?/span>输入�?/span>是什么：PLAYER SEEN�?span lang="EN-US">PLAYER ATTACKS�?span lang="EN-US">PLAYERGONE�?span lang="EN-US">MONSTER HURT�?span lang="EN-US">MONSTER HEALED。这��h��们可以得��C��个状态�{换的表格�Q�如下：游戏状态�{换表�Q?span lang="EN-US">

当前状�?输入输出状�?span lang="EN-US">
UNCARING PLAYER SEEN ANNOYED
UNCARING PLAYER ATTACKS MAD
MAD MONSTER HURT RAGE
MAD MONSTER HEALED UNCARING
RAGE MONSTER HURT BERSERK
RAGE MONSTER HEALED ANNOYED
BERSERK MONSTER HURT BERSERK
BERSERK MONSTER HEALED RAGE
ANNOYED PLAYER GONE UNCARING
ANNOYED PLAYER ATTACKS RAGE
ANNOYED MONSTER HEALED UNCARING

�Ҏ��上面的这个表��|��我们可以很容易的��d��一�?span lang="EN-US">MONSTER�?span lang="EN-US">�?/span>状态�{换图�?/span>�Q?span lang="EN-US">MONSTER的每一个状态就是图中的��点�?span lang="EN-US">
因此�Q�根据当前状态和�?span lang="EN-US">FSM的输入，MONSTER的状态将被改变。这时根�?span lang="EN-US">MONSTER的状态执行相应操作的代码�Q�假讑ַ��l�实玎ͼ��被执行�Q�这�?span lang="EN-US">MONSTER好像是具备了人工��。显�Ӟ��我们可以定义更多�?span lang="EN-US">�?/span>状�?span lang="EN-US">�?/span>�Q�写出更多的�?/span>输入�?/span>�Q�写出更多的�?/span>状态�{�?span lang="EN-US">�?/span>�Q�这��P��MONSTER可以表现的更真实�Q�生动，当然�Q�这些游戏的规则问题应该是策划制定的�?span lang="EN-US">

FSMclass以及FSMstate

现在�Q�我们如何把�q�些�Ҏ��变成现实�Q��?span lang="EN-US">FSMclass和它的组成部�?span lang="EN-US">FSMstate可以实现�q�些��x��?span lang="EN-US">

定义FSMstate
class FSMstate
{
    unsigned m_usNumberOfTransition; //状态的最大数
    int* m_piInputs; //��Z��转换而��用的输入数组
    int* m_piOutputState; //输出状态数�l?span lang="EN-US">
    int m_iStateID; //�q�个状态的唯一标识�W?span lang="EN-US">
public:
    //一个构造函敎ͼ�可以接受�q�个状态的ID和它支持的�{换数�?span lang="EN-US">
    FSMstate(int iStateID,unsigned usTransitions);
    //析构函数�Q�清除分配的数组
    ~FSMstate();
    //取这个状态的ID
    int GetID(){return m_iStateID;}
    //向数�l�中增加状态�{�?span lang="EN-US">
    void AddTransition(int iInput,int iOutputID);
    //从数�l�中删除一个状态�{�?span lang="EN-US">
    void DeleteTransition(int iOutputID);
    //�q�行状态�{换�ƈ得到输出状�?span lang="EN-US">
    int GetOutput(int iInput);
};

对这个类的分析：
功能�Q�主要是实现与一个状态相关的各种操作。我们前面假设了MONSTER的各�U�状态：
#define STATE_ID_UNCARING 1
#define STATE_ID_MAD 2
#define STATE_ID_RAGE 3
#define STATE_ID_BERSERK 4
#define STATE_ID_ANNOYED 5

状态�{换所需的输入有�Q?span lang="EN-US">
#define INPUT_ID_PLAYER_SEEN 1
#define INPUT_ID_PLAYER_ATTACK 2
#define INPUT_ID_PLAYER_GONE 3
#define INPUT_ID_MONSTER_HURT 4
#define INPUT_ID_MONSTER_HEALED 5

以上是五个状态的标识�W��?span lang="EN-US">
我们��p��声明5�?span lang="EN-US">FSMstate的实例，每一个实例代表一个状态和与之有关的操作。假设我们先处理状�?span lang="EN-US">STATE_ID_MAD
�c�L��员变�?span lang="EN-US">m_iStateID��q��?span lang="EN-US">STATE_ID_MAD�c�L��员变�?span lang="EN-US">m_usNumberOfTransition��是可由�q�个状态�{换成的状态的个数�Q�前面有一个表�Q�其中有两个状态可以由�q�个状态��生，它们分别�?span lang="EN-US">STATE_ID_UNCARING�?span lang="EN-US">STATE_ID_RAGE�?span lang="EN-US">
�q�时�Q?span lang="EN-US">m_usNumberOfTransition�{�于2�?span lang="EN-US">

m_piInputs是一个指针变量，它保存与�q�个状态相关的输入�Q�在前面的表中我们知道与STATE_ID_MAD相关的输入�ؓ
INPUT_ID_MONSTER_HURT�?span lang="EN-US">INPUT_ID_MONSTER_HEALED�Q�因�?span lang="EN-US">m_piInputs中存攄��是这两个数据�?span lang="EN-US">
�?span lang="EN-US">m_piOutputState存放的是�?span lang="EN-US">STATE_ID_MAD相关的状态，�?span lang="EN-US">STATE_ID_RAGE�?span lang="EN-US">STATE_ID_UNCARING�Q�这��P��m_piOutputState中存攄��数据便是�q�两个倹{�?span lang="EN-US">

以上是对成员变量的解释，下面解释成员函数�Q?span lang="EN-US">
构造函�?span lang="EN-US">
FSMstate::FSMstate(int iStateID,unsigned usTransitions)
{
    if(!usTransitions) //如果�l�出的�{换数量�ؓ0�Q�就��ؓ1
        m_usNumberOfTransitions=1;
    else
        m_usNumberOfTransitions=usTransitions;

    //��状态的ID保存��h��
    m_iStateID=iStateID;

    //分配内存�I�间
    try
    {
        m_piInputs=new int[m_usNumberOfTransitions];
        for(int i=0;i            m_piInputs[i]=0;
    }
    catch(...)
    {
        throw;
    }
    try
    {
        m_piOutputState=new int[m_usNumberOfTransition];
        for(int i=0;i            m_piOutputState[i]=0;
    }
    catch(...)
    {
        delete [] m_piInputs;
        throw;
    }
}

�q�就是构造函敎ͼ��?span lang="EN-US">FSMstate�c�M��共有四个成员变量�Q�在�q�个函数中全部被初始化了�?span lang="EN-US">FSMstate是一个类�Q�是否还记得MONSTER的状态（�?span lang="EN-US">MAD�?span lang="EN-US">UNCARING�Q�。这个类��是实现�?span lang="EN-US">MONSTER的一个状态的��理的。假如这个状态是STATE_ID_MAD�Q�与�q�个状态相关的状态有两个�Q�上面已�l�讲�q�了。这时我们给成员变量赋��|��在这个具体例子中它们的值如下：

m_usNumberOfTransition=2
m_piInput[0]=0;
m_piInput[1]=0;
m_piOutputState[0]=0;
m_piOutputState[1]=0;
m_iStateID=STATE_ID_MAD;

析构函数�Q?span lang="EN-US">
FSMState::~FSMState()
{
    delete [] m_piInputs;
    delete [] m_piOutputState;
}
析构函数��动态分配的存储�I�间释放了�?span lang="EN-US">

void FSMstate::AddTransition(int iInput,int iOutputID)
{
    for(int i=0;i        if(!m_piOutputState[i]) break;
            if(i            {
                m_piOutputState[i]=iOutputID;
                m_piInputs[i]=iInput;
            }
}

�q�个函数�l�两个前面构造函数动态分配的�I�间加入数据�Q�首先要扑ֈ�两个数组中找到适当的位�|�，之后�Q�如果位�|�是合法�?span lang="EN-US">
我们��可以把数据加入�q�两个数�l�中。因�?span lang="EN-US">STATE_ID_MAD与两个状态有养I��因此�Q�我们可以调用两�ơ这个函敎ͼ�把这两个状态加入到�c�M��Q?span lang="EN-US">

AddTransition(INPUT_ID_MONSTER_HURT,STATE_ID_RAGE);
AddTransition(INPUT_ID_MONSTER_HEALED,STATE_ID_UNCARING)
�q�样�Q�与状�?span lang="EN-US">STATE_ID_MAD相关�?span lang="EN-US">�?/span>状�?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>输入�?/span>也加入了�?span lang="EN-US">

void FSMstate::DeleteTransition(int iOutputID)
{
    // 遍历每一个输出状�?span lang="EN-US">
    for(int i=0;i    {
        //如果扑ֈ�输出状态，退出��@�?span lang="EN-US">
        if(m_piOutputState[i]==iOutputID)
            break;
    }
    //如果没有扑ֈ�输出状态，�q�回
    if(i>=m_usNumberOfTransitions)
        return;
    //��输出状态的内容�|?span lang="EN-US">0
    m_piInputs[i]=0;
    m_piOutputState[i]=0;

    //被删除的输出状态的后面的输出状态前�U?span lang="EN-US">
    for(;i<(m_usNumberOfTransition-1);++i)
    {
        if(!m_piOUtputState[i])
            break;
        m_piInputs[i]=m_piInputs[i+1];
        m_piOutputState[i]=m_piOutputState[i+1];
    }
    //最后面的输出状态置0
    m_piInputs[i]=0;
    m_piOutputState[i]=0;
}

�q�个函数是要删除与一个状态相关的输出状态。设一个状�?span lang="EN-US">STATE_ID_MAD�Q�与之相关的状态有两个STATE_ID_RAGE,STATE_ID_UNCARING�Q�当然这是经�q�初始化以及前面的添加状态函��C��后，产生了这两个相关的状态。你惛_��除哪一个？如果你想删除相关的输出状态，只要在删除函��C��指出那个状态即可，例如�Q?span lang="EN-US">

DeleteTransition(STATE_ID_RAGE);
你就可以删除输出状�?span lang="EN-US">STATE_ID_RAGE了�?span lang="EN-US">

int FSMstate::GetOutput(int iInput)
{
    //先给输出状态赋��|��如果未找��C��输入对应的输出状态时�Q�返回这个��|��
    int iOutputID=m_iStateID;

    //遍历输出状�?span lang="EN-US">
    for(int i=0;i    {
        //如果没找刎ͼ�退出��@�?span lang="EN-US">
        if(!m_piOutputState[i])
            break;
        //如果扑ֈ�了与�?/span>输入�?/span>相对应的�?/span>输出状�?span lang="EN-US">�?/span>�Q�进行赋倹{�?span lang="EN-US">
        if(iInput==m_piInputs[i])
        {
            iOutputID=m_piOutputState[i];
            break;
        }
    }
    //�q�回�?/span>输出状�?span lang="EN-US">�?br>    return(iOutputID);
}

�q�个函数功能是返回与�?/span>输入�?/span>相对应的�?/span>输出状�?span lang="EN-US">�?/span>的标识。如果没有与�?/span>输入�?/span>相对应的�?/span>输出状�?span lang="EN-US">�?/span>�Q�返回原来的状态，如果有与之对应的�?/span>输出状�?span lang="EN-US">�?/span>�Q�返回这个状态的ID�?span lang="EN-US">

下面定义的是FSMclass�Q�这个类用于�l�护FSMstate对象集合�?span lang="EN-US">
class FSMclass
{
    State_Map m_map; //包括了状态机的所有状�?span lang="EN-US">
    int m_iCurrentState; //当前状态的ID
public:
    FSMclass(int iStateID); //初始化状�?span lang="EN-US">
    ~FSMclass()
    //�q�回当前状�?span lang="EN-US">ID
    int GetCurrentState() {return m_iCurrentState;}
    //讄��当前状�?span lang="EN-US">ID
    void SetCurrentState(int iStateID) {m_iCurrentState=iStateID;}
    //�q�回FSMstate对象指针
    FSMstate* GetState(int iStateID);
    //增加状态对象指�?span lang="EN-US">
    void AddState(FSMstate* pState);
    //删除状态对象指�?span lang="EN-US">
    void DeleteState(int iStateID);
    //�Ҏ��?/span>当前状�?span lang="EN-US">�?/span>�?span lang="EN-US">�?/span>输入�?/span>完成�?/span>状�?span lang="EN-US">�?/span>的�{换�?span lang="EN-US">
    int StateTransition(int iInput);
};

FSMclass::m_map�?span lang="EN-US">FSMstate对象的集合，是从STL中实现的�?span lang="EN-US">
FSMclass::m_iCurrentState�?span lang="EN-US">FSMstate对象的状态标识，�?span lang="EN-US">�?/span>有限状态机�?/span>的当前状态�?span lang="EN-US">

FSMclass::GetCurrentState()可以用之讉K��当前�?span lang="EN-US">FSMstate对象的状态的标识�W��?span lang="EN-US">
FSMclass::SetCurrentState()可以讄��当前FSMstate对象的状态的标识�W��?span lang="EN-US">
FSMclass::GetState()可以取得有限状态机中的��M��FSMstate对象的指针�?span lang="EN-US">
FSMclass::AddState()增加有限状态机中的FSMstate对象�?span lang="EN-US">
FSMclass::DeleteState()删除有限状态机中的FSMstate对象
FSMclass::StateTransition()初始化状态�{换，�Ҏ��输入�q�回输出状态�?span lang="EN-US">

�q�个�c�M��用了STL�Q�我不知道它怎么用：�Q�。听说是高�h才��用它�Q�高��v码要写过上万行的代码。因此不能详�l�介�l�这个类�?span lang="EN-US">

��M��Q�可以这么理解这两个�c?span lang="EN-US">FSMstate,FSMclass.FSMstate代表了一个状态以及和状态相关的数据和操作。如�?span lang="EN-US">MONSTER中有五个状态，我们��p��声明五个�cȝ��对象�Q�每个对象中包括了与�q�个状态相关的状态，输入和各�U��{换函数。可以说FSMstate是对每一个状态的��装�Q�包括相��x��据和操作�Q�，游戏中的对象有多��状态，��p��声明多少�?span lang="EN-US">FSMstate对象。�?span lang="EN-US">FSMclass则是对这若干�?span lang="EN-US">FSMstate对象�Q�这个例子中MONSTER有五个状态）�q�行的封装。在FSMclass中指明了若干�?span lang="EN-US">FSMstate中哪一个是当前�?span lang="EN-US">MONSTER拥有的状态�ƈ且可以设�|�，得到以及删除状态，�q�且可以�q�行状态间的�{换�?span lang="EN-US">

��M��Q�游戏中�?span lang="EN-US">MONSTER有多��状态，游戏中就要声明多��的FSMstate对象�Q�每一�?span lang="EN-US">FSMstate对象包括了与特定的状态相关的数据和操作。�?span lang="EN-US">FSMclass只有一个，它用于协调若�q�个FSMstate之间的关�p�d��操作�?span lang="EN-US">

下面是如何在游戏中��用两个类的例子：

首先是创�?span lang="EN-US">FSMstate对象�Q�若�q�个�Q�，有多��状态就要��@环多��次�Q�下面是增加STATE_ID_UNCARING状态的例子�Q?span lang="EN-US">
FSMstate* pFSMstate=NULL;
//创徏状�?span lang="EN-US">
try
{
    //�W�一个参数是增加状态的标识�Q�第二个参数指明了与�q�个
    //状态相关的状态的个数�?span lang="EN-US">
    pFSMstate=new FSMstate(STATE_ID_UNCARING,2);
}
catch(...)
{
    throw;
}

//之后�l�这个状态加入相关的�?/span>输入�?/span>�?span lang="EN-US">�?/span>输出状�?span lang="EN-US">�?/span>
pFSMstate->AddTransition(INPUT_ID_PLAYER_SEEN,STATE_ID_ANNOYED);
pFSMstate->AddTransition(INPUT_ID_PLAYER_ATTACKS,STATE_ID_MAD);

�q�个函数指明了与特定状态相关的�?/span>输入�?/span>�?span lang="EN-US">�?/span>输出状�?span lang="EN-US">�?br>比如�W�一个函敎ͼ�它表明如果我要输入一�?span lang="EN-US">INPUT_ID_PLAYER_SEEN�Q�这时就会��生一个输出状态，STATE_ID_ANNOYED�?span lang="EN-US">
我们应该为每一个状态做上面的事情，�q�里��q��q�了。之后我们要声明一�?span lang="EN-US">FSMclass对象�Q�用于协调上面的FSMstate对象之间的关�p�R�?span lang="EN-US">

try
{
    m_pFSMclass=new FSMclass(STATE_ID_UNCARING);
}
catch(...)
{
    throw;
}

上面指明�?span lang="EN-US">MONSTER的当前状态是STATE_ID_UNCARING最后将FSMstate对象分别加入�?span lang="EN-US">FSMclass中�?span lang="EN-US">

下面介绍如何使用FSMclass
使用十分��单，只要我们�l�出一�?span lang="EN-US">�?/span>输入�?/span>�Q�之后，我们便可以得��C��?span lang="EN-US">�?/span>输出状�?span lang="EN-US">�?/span>�Q�根据这�?span lang="EN-US">�?/span>输出状�?span lang="EN-US">�?/span>我们执行相应的操作，最后，把这�?span lang="EN-US">�?/span>输出状�?span lang="EN-US">�?/span>变成MONSTER的当前状态�?span lang="EN-US">

在游戏中发生了一些事情，如玩游戏的�h指出他控制的��?span lang="EN-US">MONSTER�Q�用鼠标点击�?span lang="EN-US">MONSTER�Q�，�q�时会��生一�?span lang="EN-US">�?/span>输入”iInputID=INPUT_ID_PLAYER_ATTACK;

�q�时�Q�我们调用状态�{换函敎ͼ�
m_iOutputState=m_pFSMclass->StateTransition(iInputID);

�q�时�Q�我们的�?/span>输入�?/span>�?span lang="EN-US">MONSTER产生了刺�Ȁ�Q��生了一�?span lang="EN-US">�?/span>输出状�?span lang="EN-US">�?/span>。这时我们根据这个输出状态调用相应的代码执行��可以了�Q�这时的MONSTER好像有应反了�Q�我们说它有了简单的��?span lang="EN-US">

if(m_iOutputState==STATE_ID_MAD)
{
    //some code for the monster to act mad
}

当然�Q�我们也应该把其它状态执行的操作也写出来�Q�但只写一个就可以了。��用这个状态机��是�q�么��单。��M��Q?span lang="EN-US">FSMclass不是全部的�h工智能，相反�Q�它只是一个框�Ӟ��一个开始智能需要的�q�很多。只要你可以分出�?/span>状�?span lang="EN-US">�?/span>�Q��ƈ且知道什�?span lang="EN-US">�?/span>输入�?/span>产生什�?span lang="EN-US">�?/span>输出状�?span lang="EN-US">�?/span>��可以了�Q�当然这是一个游戏的规则�Q�策划应当完成这个部分？

肥仔 2008-12-14 17:56 发表评论

肥仔 — Sun, 14 Dec 2008 09:54:00 GMT

有限状态机�Q?span lang="EN-US">Finite State Machine或�?span lang="EN-US">Finite State Automata)是��Y仉��域中一�U�重要的工具�Q�很多东西的模型实际上就是有限状态机�?span lang="EN-US">

最�q�看了一些游戏编�E?span lang="EN-US">AI的材料，感觉游戏中的AI�Q�第一要说的就是有限状态机来实现精�늚�AI�Q�然后才�?span lang="EN-US">A*寻�\�Q�其他学术界讨论比较多的��经�|�络、模�p�控制等问题�q�不是很热�?span lang="EN-US">

FSM的实现方式：
1�Q?span lang="EN-US"> switch/case或�?span lang="EN-US">if/else
�q�无意是最直观的方式，使用一堆条件判断，会编�E�的人都可以做到�Q�对��单小巧的状态机来说最合适，但是毫无疑问�Q�这��L��方式比较原始�Q�对庞大的状态机难以�l�护�?span lang="EN-US">

2�Q?状态表
�l�护一个二�l�状态表�Q�横坐标表示当前状态，�U�坐标表�C��入，表中一个元素存储下一个状态和对应的操作。这一招易于维护，但是�q�行旉��和存储空间的代�h较大�?/font>

3�Q?使用State Pattern
使用State Pattern使得代码的维护比switch/case方式�E�好�Q�性能上也不会有很多的影响�Q�但是也不是100�Q�完��。不�q?span lang="EN-US">Robert C. Martin做了两个自动产生FSM代码的工��P��for java�?span lang="EN-US">for C++各一个，�?span lang="EN-US">http://www.objectmentor.com/resources/index上有免费下蝲�Q�这个工��L��输入是纯文本的状态机描述�Q�自动��生符�?span lang="EN-US">State Pattern的代码，�q�样developer的工作只需要维护状态机的文本描�q�ͼ�每必要冒引入bug的风险去�l�护code�?span lang="EN-US">

4�Q?使用宏定义描�q�状态机
一般来��_��C++�~�程中应该避免��?span lang="EN-US">#define�Q�但是这主要是因为如果用宏来定义函数的话�Q�很�Ҏ��产生�q�样那样的问题，但是巧妙的��?span lang="EN-US">,�q�是能够产生奇妙的效果�?span lang="EN-US">MFC��是使用宏定义来实现大的架构的�?span lang="EN-US">
在实�?span lang="EN-US">FSM的时候，可以把一些繁琐无比的if/else�q�有花括��L��l�合攑֜�宏中�Q�这��P��在代码中可以3�Q�中状态机描述文本一样写�Q�通过�~�译器的预编译处理��?span lang="EN-US">1�Q�一��L��效果�Q�我见过产生C代码的宏�Q�如果要产生C++代码�Q�己�?span lang="EN-US">MFC可以�Q�那么理��Z��也是可行的�?

肥仔 2008-12-14 17:54 发表评论

状态机

肥仔 — Sun, 14 Dec 2008 09:53:00 GMT

关于状态机的一个极度确切的描述是它是一个有向图形，�׃��l�节点和一�l�相应的转移函数�l�成。状态机通过响应一�p�d��事�g�?span lang="EN-US">�?/span>�q�行�?/span>。每个事仉��在属�?span lang="EN-US">�?/span>当前�?节点的�{�U�d��数的控制范围内，其中函数的范围是节点的一个子集。函数返�?span lang="EN-US">�?/span>下一�?span lang="EN-US">�?/span>�Q�也许是同一个）节点。这些节点中臛_��有一个必��L��l�态。当到达�l�态，状态机停止�?/font>

包含一�l�状态集�Q?span lang="EN-US">states�Q�、一个�v始状态（start state�Q�、一�l�输入符号集�Q?span lang="EN-US">alphabet�Q�、一个映��输入符号和当前状态到下一状态的转换函数�Q?span lang="EN-US">transition function�Q�的计算模型。当输入�W�号�Ԍ��模型随即�q�入起始状态。它要改变到新的状态，依赖于�{换函数。在有限状态机中，会有有许多变量，例如�Q�状态机有很多与动作�Q?span lang="EN-US">actions�Q��{�?span lang="EN-US">(Mealy�?span lang="EN-US">)或状态（摩尔机）兌��的动作，多重起始状态，��Z��没有输入�W�号的�{换，或者指定符号和状态（非定�?限状态机�Q�的多个转换�Q�指�z��接收状态（识别者）的一个或多个状态，�{�等�?span lang="EN-US">

　　传统应用�E�序的控制流�E�基本是��序的：遵��@事先讑֮�的逻辑�Q�从头到��֜�执行。很��有事�g能改变标准执行流�E?/font>�Q�而且�q�些事�g主要涉及异常情况�?span lang="EN-US">�?/span>命��o行实用程�?span lang="EN-US">�?/span>是这�U�传�l�应用程序的典型例子�?

另一�c�d��用程序由外部发生的事件来驱动—�?/span>换言之，事�g在应用程序之外生成，无法由应用程序或�E�序员来控制�?/font>具体需要执行的代码取决于接收到的事�Ӟ��或者它相对于其他事件的抵达旉��。所以，控制��程既不能是��序的，也不能是事先讑֮�好的�Q�因为它要依赖于外部事�g。事仉��动的GUI应用�E�序是这�U�应用程序的典型例子�Q�它们由命��o和选择�Q�也��是用户造成的事�Ӟ��来驱动�?

Web应用�E�序由提交的表单和用戯��求的�|�页来驱动，它们也可划归��C��q�类别。但是，GUI应用�E�序对于接收到的事�g仍有一定程度的控制�Q�因��些事件要依赖于向用户昄��的窗口和控�g�Q�而窗口和控�g是由�E�序员控制的�?span lang="EN-US">Web应用 �E�序则不�Ӟ��因�ؓ一旦用户采取不在预料之中的操作�Q�比如��用浏览器的历史记录、手工输入链接以及模拟一�ơ表单提交等�{�）�Q�就很容易打��p��计好的应用程序逻辑�?

昄��Q�必��采取不同的技术来处理�q�些情况。它能处理�Q何顺序的事�g�Q��ƈ能提供有意义的响�?span lang="EN-US">—�?/span>即�ɘq�些事�g发生的顺序和预计的不同。有限状态机正是��Z��满��q�方面的要求而设计的�?

　　有限状态机是一�U�概忉|��机器，它能采取某种操作来响应一个外部事件。具体采取的操作不仅能取决于接收到的事�g�Q�还能取决于各个事�g的相对发生顺序。之所以能做到�q�一点，是因为机器能跟踪一个内部状态，它会在收��C��件后�q�行更新�?font color="#ff0000">��Z��个事件而响应的行动不仅取决于事件本�w�，�q�取决于机器的内部状态。另外，采取的行动还会决定�ƈ更新机器的状态。这样一来，��M��逻辑都可建模成一�p�d��事�g/状态组合�?/font>

肥仔 2008-12-14 17:53 发表评论

有限状态自动机

肥仔 — Sun, 14 Dec 2008 09:30:00 GMT

有限状态自动机是具有离散输入和输出的系�l�的一�U�数学模型�?

　　其主要特�Ҏ��以下几个斚w��Q?

�?(1)�pȝ��h��有限个状态，不同的状态代表不同的意义。按照实际的需要，�pȝ��可以在不同的状态下完成规定的�Q务�?

�?(2)我们可以��输入字�W�串中出现的字符汇集在一��h��成一个字母表。系�l�处理的所有字�W�串都是�q�个字母表上的字�W�串�?

�?(3)�pȝ��在�Q何一个状态下�Q�从输入字符串中��d��一个字�W�，�Ҏ��当前状态和��d��的这个字�W��{到新的状态�?

�?(4)�pȝ��中有一个状态，它是�pȝ��的开始状态�?

�?(5)�pȝ��中还有一些状态表�C�它到目前�ؓ止所��d��的字�W�构成的字符串是语言的一个句子�?

�?

　　形式定义

�?定义�Q�有限状态自动机(FA—finite automaton)是一个五元组�Q?

�?M=(Q, Σ, δ, q0, F)

�?其中�Q?

�?Q——状态的非空有穷集合。∀q∈Q�Q?font color="#ff0000">q�U�CؓM的一个状�?/font>�?

�?Σ——输入字母表�?

�?δ——状态�{�U�d��敎ͼ�有时又叫作状态�{换函数或者移动函敎ͼ�δ�Q�Q×Σ→Q�Q��?q,a)=p�?/font>

�?q0——M的开始状态，也可叫作初始状态或启动状�?font color="#ff0000">。q0∈Q�?/font>

�?F——M的终止状态集合。F被Q包含。�Q�l�q∈F�Q�q�U�CؓM的终止状态�?/p>

肥仔 2008-12-14 17:30 发表评论

NFA转DFA

肥仔 — Sat, 13 Dec 2008 07:21:00 GMT

一�?span style="background: white; color: red">非确定自动机( NFA) 在读入符号串之后�Q��ƈ不确切地知道自动机处于哪个状态。但可以肯定一定处于状态集中的某一状态。该状态集记做 {q1,q2,…qk} 。而一个等��L��定自动�?/span>( DFA) ��d��同样�?span lang="EN-US"> w 一定处于某个确定的状态上。这��P��都是��d��同样�?span lang="EN-US"> w �Q?span lang="EN-US"> DFA 到达某一个状态，�?span lang="EN-US"> NFA 到达某一个状态集。由 w 的�Q意性，可将 NFA 的所有的状态集�?span lang="EN-US"> DFA 的状态一一对应��h��。这�U�对应的前提��是能识别同��L��输入丌Ӏ�即 L(M1)=L(M2) �?span lang="EN-US">

昄��Q�后一个状态集是依赖于前一个状态集的，是在前一个状态集的基��上，�Q�其内�Q意结点）�l�过同一条�\径到辄��。下面是一个简单的例子�Q?span lang="EN-US">

可以看出�Q�其核心是将 NFA 状态集归�ƈ�?span lang="EN-US"> DFA 中的状态。在 NFA 中，无论是从 1 �?span lang="EN-US"> 4 �Q�还�?span lang="EN-US"> 1 �?span lang="EN-US"> 5 �Q�作为集合来讲都是集�?span lang="EN-US"> 1 到集�?span lang="EN-US"> 2 �Q�最为重要得是经�q�的条�g都是 a 。因而从识别语言的效果是一��L��。这使得�q�些弧合�q�成为可能�?span lang="EN-US">

考虑集合覆盖的情��c�?span lang="EN-US">

一个结点属于第一个集合又同时属于�W�二个集合。这�U�情况不一定好理解。但如果从�\径的历史的角度进一步区分，即不同的旉��l�过同一个结点，��其看成是不同的状态。按照这�U�时�I�的角度�q�一步区分，得到叛_��。这和图 1 是类似的�?span lang="EN-US">

再来看看带有�l�态结点的情况�Q?span lang="EN-US">

ab �Q?span lang="EN-US"> abb 均�ؓ�?span lang="EN-US"> NFA 识别的句子，其�{换如下：

	I _a	I_b
A{1,2}	{3}	Φ
B{3}	Φ	{3,4}
C{3,4}	Φ	{3,4}

从某�U�意义上说�?span lang="EN-US"> NFA 中的状�?span lang="EN-US"> 3 �?span lang="EN-US"> DFA 中被分离成两部分�Q�当首次到达 3 时应该是状�?span lang="EN-US"> B �Q�而第二次以后再到�?span lang="EN-US"> 3 则应该属于状�?span lang="EN-US"> C �?span lang="EN-US">

�Ҏ��规则�Q?span lang="EN-US"> C{3,4} �?span lang="EN-US"> DFA 的终态，但在 NFA 中，只有 4 为终态， C 中仍然有 3 为非�l�态，若有路径 1 à 3 à 3 映射�?span lang="EN-US"> DFA 中也�?span lang="EN-US"> A à B à C �Q�何解？

�q�里面最关键的是�Q�对��L��一个句子，��d��以在两个图中分别扑ֈ�一条�\径，形成对应关系。�ƈ不是�?span lang="EN-US"> NFA 中的每条路径都要�?span lang="EN-US"> DFA 中的每条路径一一对应�?span lang="EN-US">

当识别句�?span lang="EN-US"> ab �Ӟ��选择�?span lang="EN-US"> 3 直接到达 4 的�\径。当识别句子 abb �Ӟ��则在状�?span lang="EN-US"> 3 循环一�ơ再到达 4 �?span lang="EN-US">

现在设想�Q�通过 1 à 3 à 3 �l�过的�\径也�?span lang="EN-US"> ab 。但此时�q�未到达�l�态。可以说�Q�在到达 C 中的 3 �Ӟ��必然选择了两�?span lang="EN-US"> b 以上的句子�?span lang="EN-US">

而这��L��路径与选择句子有关�p�R�?span lang="EN-US">

对于 NFA 能识别的句子�Q�在 DFA 中也能识别�?span lang="EN-US">

对于 NFA 不能识别的句子，�?span lang="EN-US"> DFA 中也不能识别�?span lang="EN-US">

肥仔 2008-12-13 15:21 发表评论