12.7. Mahjong Tiles: Outlining A Polymorphic Solution

The difficulty of establishing and using polymorphism is on par with other C++ and object-oriented concepts. However, polymorphism is rarely beneficial in small or simple programs, making it challenging to demonstrate its value in an introductory programming text. We can better appreciate its benefits by describing an authentic problem and its solution. To accomplish this, the tile example excerpts and simplifies a small part of a Mahjong solitaire program.

"Mahjong is a tile-based game that was developed in the 19th century in China and has spread throughout the world." Originally a three- or four-person game, it has become a popular computer solitaire game with numerous variations (see, https://www.free-play-mahjong.com for one example). The following UML class diagram, code fragments, and descriptions are adapted and simplified from a Mahjong solitaire program.

The Mahjong Tile Classes

Mahjong consists of 144 tile objects saved in a custom data structure reflecting each tile's position on a three-dimensional game board. The implementation described here instantiates the tiles from ten related classes representing seven different kinds of tiles - one class represents three kinds of tiles, and three classes support inheritance and polymorphism, but the program never instantiates them. However, each tile's position in the data structure and on the game board is independent of their type. Therefore, it's easiest to upcast and represent them collectively in the data structure and program functions as Tile pointers.

In this simplified example, polymorphism enables two essential operations. First, the program must draw each tile separately. The Tile draw function draws a blank tile, and the subclass draw functions add tile-specific detail, making the relative execution order of these functions significant. Second, to play the game, the player selects the tiles two at a time, and if they "match," the program removes them from the board. What it means to "match" depends on the tile's type and, sometimes, on saved member data. Polymorphism allows the program to test for a match with a single, simple function call. We can solve both problems without polymorphism, but solutions based on branching statements (such as switches or if-else ladders) are larger, more cumbersome, and more complex than polymorphic solutions.

Partial MahJong Tile Implementations

The draw functions use the host operating system's or implementing language's native drawing functions, making the functions non-portable and placing them beyond the scope of an introductory text. Nevertheless, even the partial implementations presented here authentically illustrate numerous polymorphic concepts introduced in the current chapter. The tile classes outlined here include abridged draw functions to demonstrate C++'s polymorphic syntax and function-calling sequences. Conversely, the matches functions are complete.

class Tile
{
    public:
        virtual bool matches(Tile* t)
        {
            if (this == t)			// (a)
                return false;

            if (t == nullptr)			// (b)
                return false;

            return typeid(*this) == typeid(*t);	// (c)
        }


        virtual void draw()
        {
            // draw a blank tile
        }
};

Tile* t1 = first selected tile;
Tile* t2 = second selected tile;

if (t1->matches(t2))
{
    remove(t1);
    remove(t2);
}

void draw_board()
{
    for (Tile t : board)
        t->draw();
}

class RankTile : public Tile
{
    private:
        int rank;

    public:
        RankTile(int r) : rank(r) {}

        virtual bool matches(Tile* t)
        {
            return Tile::matches(t) && rank == ((RankTile *)t)->rank;
        }
};

class CircleTile : public RankTile
{
    public:
        CircleTile(int rank) : RankTile(rank) {}

        virtual void draw()
        {
            Tile::draw();	// draw a blank tile
            // draw "rank" circles on the tile
        }
};

class BambooTile : public RankTile
{
    public:
        BambooTile(int rank) : RankTile(rank) {}

        virtual void draw()
        {
            Tile::draw();	// draw a blank tile
            // draw "rank" bamboo sticks on the tile
        }
};

class CharacterTile : public Tile
{
    private:
        char symbol;

    public:
        CharacterTile(char c) : symbol(c) {}

        virtual bool matches(Tile* t)
        {
            return Tile::matches(t) && symbol == ((CharacterTile *)t)->symbol;
        }

        virtual void draw()
        {
            Tile::draw();	// draw a blank tile
            // draw "symbol" on the tile
        }
};

class WhiteDragonTile : public Tile
{
    public:
        virtual void draw()
        {
            Tile::draw();	// draw a blank tile
            // White dragon decoration on the tile
        }
};

class PictureTile : public Tile
{
    private:
        string name;
        Image picture;

    public:
        PictureTile(string s) : name(s)
        {
            picture = load(name);
        }

        virtual void draw()
        {
            Tile::draw();	// draw a blank tile
            // draw "picture" on the tile
        }
};
 
 

class SeasonTile : public PictureTile
{
    public:
        SeasonTile(string s) : PictureTile(s) {}
};

class FlowerTile : public PictureTile
{
    public:
        FlowerTile(string s) : PictureTile(s) {}
};

class Bamboo1Tile : public PictureTile
{
    public:
        Bamboo1Tile() : PictureTile("Sparrow") {}
};

Downloadable Mahjong Tile Classes

tiles.cpp includes a main function, making the example compilable and runnable. It demonstrates the C++ syntax for creating various tile object, upcasting them to Tile pointers, and calling the virtual functions.