三消游戏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
}