三消游戏FSM状态机设计图

三消游戏FSM状态机设计图

1) 设计FSM图

2) smc配置文件

///////////////////////////////////////////////////////////////////////
// ColorTable.sm
//   -- ColorTable State Map for C++ classes auto-generation
//
// 1) generate c++ classes:
//   $ java -jar Smc.jar -c++ ColorTable.sm
//
// 2) generate graphviz dot graph:
//   $ java -jar Smc.jar -graph -glevel 1 ColorTable.sm
//
// see also:
//   http://graphviz.org/ //
// Author: cheungmine
// Copyright 2015-?, All rights reserved.
//
///////////////////////////////////////////////////////////////////////
%class ColorTable
%header ColorTable.h
%start ColorTableMap::Vacancy
%map ColorTableMap
%%
/**
* State {
*     Transition [Guard Condition]
*		EndState {
*			Action(s)
*		}
*
*     Transition [context.getOwner().is_valid()]
*		EndState {
*			Action(s)
*		}
*     ...
* }
*/

//==> ColorTableMap::Vacancy
Vacancy
Entry {
enterVacancy();
}
Exit {
leaveVacancy();
}
{
// Expose Transitions to other parts if necessary
shuffle
ShuffleFilled {
shuffle();
}
}

//==> ColorTableMap::ShuffleFilled
// only swappable state
ShuffleFilled
Entry {
enterShuffleFilled();
}
Exit {
leaveShuffleFilled();
}
{
// !!can swap here!!
swap [ context.getOwner().swap_done() ]
Filled {
}
swap
ShuffleFilled {
// set stack top sub sm: SwapMap
}
}

//==> ColorTableMap::FallenOver
FallenOver
Entry {
enterFallenOver();
}
Exit {
leaveFallenOver();
}
{
// Expose Transitions to other parts if necessary
fill [ context.getOwner().is_empty() ]
Vacancy {
}
fill
Filled {
fill();
}
}

//==> ColorTableMap::Filled
Filled
Entry {
enterFilled();
}
Exit {
leaveFilled();
}
{
erase [ context.getOwner().can_erase() ]
Unfilled {
erase();
}
erase
Vacancy {
empty();
}
}

//==> ColorTableMap::Unfilled
Unfilled
Entry {
enterUnfilled();
}
Exit {
leaveUnfilled();
}
{
fall
Fallen {
fall();
}
}

//==> ColorTableMap::Fallen
Fallen
Entry {
enterFallen();
}
Exit {
leaveFallen();
}
{
erase [ context.getOwner().can_erase() ]
Unfilled {
erase();
}

erase
FallenOver {
empty();
}
}
%%

3) ColorTable.h和ColorTable.cpp

/**
* ColorTable.h
* 2015-02-01
* cheungmine, all rights reserved.
*
*        col->
*      +-------+-------+-------+-------+-------+-------+-------+
*  row |00     |01     |02     |03     |04     |05     |06     |
*   |  |       |       |       |       |       |       |       |
*   v  |       |       |       |       |       |       |       |
*      +-------+-------+-------+-------+-------+-------+-------+
*      |10     |11     |12     |13     |14     |15     |16     |
*      |       |       |       |       |       |       |       |
*      |       |       |       |       |       |       |       |
*      +-------+-------+-------+-------+-------+-------+-------+
*      |20     |21     |22     |23     |24     |25     |26     |
*      |       |(xp,yp)|       |       |       |       |       | height
*      |       | .     |       |       |       |       |       |
*      +-------+-------+-------+-------+-------+-------+-------+
*      |30     |31     |32     |33     |34     |35     |36     |
*      |       |       |       |       |       |       |       |
*      |       |       |       |       |       |       |       |
*      +-------+-------+-------+-------+-------+-------+-------+
*  y   |40     |41     |42     |43     |44     |45     |46     |
*  ^   |       |       |       |       |       |       |       |
*  |   |       |       |       |       |       |       |       |
*  |   o-------+-------+-------+-------+-------+-------+-------+
*  |  origin                     width
*  +------------>x
* (0,0)
*
*/
#ifndef __COLORTABLE_H__
#define __COLORTABLE_H__

#include "cocos2d.h"
USING_NS_CC;

#include "ColorTable_sm.h"

class ColorTable : public Node
{
public:

// Global Settings:

static const int ColorTable_NumRows = 5;
static const int ColorTable_NumCols = 7;
static const int ColorTable_NumCells = ColorTable_NumRows*ColorTable_NumCols;
static const int ColorTable_NumColors = 4;
static const int ColorTable_ColorsPal[ColorTable_NumColors+1];    // colors palette

// Construct and Deconstruct

ColorTable() :
swap_done_(false),
_fsm(0),
_DeltaTime(0.1f),
_NumRows(ColorTable_NumCols),
_NumCols(ColorTable_NumRows),
_NumCells(ColorTable_NumCells)
{
}

// Public Types:

enum EnumColor
{
INVALID = 0,
RED     = 1,
GREEN   = 2,
BLUE    = 3,
YELLOW  = 4
};

// Public Inline Methods:

inline int index(int row, int col) const
{
return (col*_NumCols + row);
}

inline int color(int row, int col) const
{
return table_[index(row, col)];
}

inline int result(int row, int col) const
{
return results_[index(row, col)];
}

public:
// Public Methods:
CREATE_FUNC(ColorTable);

virtual bool init();

bool is_empty();

bool can_erase();

bool swap_done();

void shuffle();

void empty();

void erase();

void fall();

void fill();

void print();

public:
// Public Callbacks:
void enterVacancy();
void leaveVacancy();

void enterShuffleFilled();
void leaveShuffleFilled();

void enterFallenOver();
void leaveFallenOver();

void enterFilled();
void leaveFilled();

void enterUnfilled();
void leaveUnfilled();

void enterFallen();
void leaveFallen();

// Public Events:
void onIdleVacancy(float dt);
void onIdleShuffleFilled(float dt);
void onIdleFallenOver(float dt);
void onIdleFilled(float dt);
void onIdleUnfilled(float dt);
void onIdleFallen(float dt);

private:
// Private Methods:

void init_table();

void exit();

private:
// Private Members:

ColorTableContext * _fsm;

const int _NumRows;
const int _NumCols;
const int _NumCells;
const float _DeltaTime;

bool swap_done_;

int table_[ColorTable_NumCells];
int results_[ColorTable_NumCells];
};

#endif // __COLORTABLE_H__

/**
* ColorTable.cpp
* 2015-02-01
* cheungmine, all rights reserved.
*
*/
#include "ColorTable.h"

const int ColorTable::ColorTable_ColorsPal[ColorTable_NumColors+1] = {'O', 'R', 'G', 'B', 'Y'};

/////////////////////////// Private Methods ////////////////////////////

void ColorTable::init_table()
{
int fixed[] = {
1,1,3,1,2,
3,2,1,1,4,
2,2,4,3,3,
1,3,3,4,1,
3,4,4,2,4,
2,2,4,1,1,
2,1,1,2,4
};

int at = 0;
int * p = table_;

while (p - table_ < _NumCells) {
*p++ = fixed[at++];
}
}

/////////////////////////// Public Callbacks ///////////////////////////

void ColorTable::enterVacancy()
{
empty();

this->schedule(schedule_selector(ColorTable::onIdleVacancy), _DeltaTime);
}

void ColorTable::leaveVacancy()
{
exit();
}

void ColorTable::enterShuffleFilled()
{
this->schedule(schedule_selector(ColorTable::onIdleShuffleFilled), _DeltaTime);
}

void ColorTable::leaveShuffleFilled()
{
exit();
}

void ColorTable::enterFallenOver()
{
this->schedule(schedule_selector(ColorTable::onIdleFallenOver), _DeltaTime);
}

void ColorTable::leaveFallenOver()
{
exit();
}

void ColorTable::enterFilled()
{
this->schedule(schedule_selector(ColorTable::onIdleFilled), _DeltaTime);
}

void ColorTable::leaveFilled()
{
exit();
}

void ColorTable::enterUnfilled()
{
this->schedule(schedule_selector(ColorTable::onIdleUnfilled), _DeltaTime);
}

void ColorTable::leaveUnfilled()
{
exit();
}

void ColorTable::enterFallen()
{
this->schedule(schedule_selector(ColorTable::onIdleFallen), _DeltaTime);
}

void ColorTable::leaveFallen()
{
exit();
}

//////////////////////////// Public Events ////////////////////////////

void ColorTable::onIdleVacancy(float dt)
{
_fsm->shuffle();
}

void ColorTable::onIdleShuffleFilled(float dt)
{
}

void ColorTable::onIdleFallenOver(float dt)
{
}

void ColorTable::onIdleFilled(float dt)
{
}

void ColorTable::onIdleUnfilled(float dt)
{
}

void ColorTable::onIdleFallen(float dt)
{
}

/////////////////////////// Public Methods ////////////////////////////

bool ColorTable::init()
{
_fsm = new ColorTableContext(*this);
_fsm->setDebugFlag(true);
_fsm->enterStartState();

return true;
}

void ColorTable::exit()
{
this->unscheduleAllCallbacks();
}

bool ColorTable::is_empty()
{
for (int index = 0; index < _NumCells; ++index) {
if (table_[index] != INVALID) {
return false;
}
}
return true;
}

bool ColorTable::can_erase()
{
return false;
}

bool ColorTable::swap_done()
{
return swap_done_;
}

void ColorTable::shuffle()
{
init_table();
}

void ColorTable::empty()
{
for (int cell = 0; cell < _NumCells; ++cell) {
table_[cell] = INVALID;
results_[cell] = 0;
}
}

void ColorTable::erase()
{
}

void ColorTable::fall()
{
}

void ColorTable::fill()
{
}

void ColorTable::print()
{
#if defined(COCOS2D_DEBUG) && defined(WIN32)
FILE * fp = fopen("c:/temp/color-table.prt", "a+");
if (fp) {
fprintf(fp, "\n>>>> %s {", _fsm->getState().getName());
fprintf(fp, "\n---- TABLE ----\n");
for (int row = 0; row < ColorTable_NumRows; ++row) {
for (int col = 0; col < ColorTable_NumCols; ++col) {
int v = color(row, col);
fprintf(fp, " %c", ColorTable_ColorsPal[v]);
}
fprintf(fp, "\n");
}
fprintf(fp, "\n---- RESULTS ----\n");
for (int row = 0; row < ColorTable_NumRows; ++row) {
for (int col = 0; col < ColorTable_NumCols; ++col) {
int v = result(row, col);
fprintf(fp, " %d", v);
}
fprintf(fp, "\n");
}
fprintf(fp, "}\n");
fclose(fp);
}
#endif
}