Geisha Studios

Monster Sweeper is controlled only with the keyboard. Here are listed the keys that Monster Sweeper accepts:

The most relevant piece of information in the Game class is the board where the monsters are located and that the player must reveal according to her and the monster’s.

As not every cell in the board has a monster, I need a way to differentiate between the two kind of cells: these with monsters and these without. I also need to know whether the cell has already been revealed or not. The easiest way to put all this is to have a structure with the information about the cell. Each cell has a boolean member that tells if the cell is revealed, whether has monster or not, and either the monster type or the sum of every monster in the surrounding cells.

The last piece of information — either the monster or the sum of levels — is stored in a chtype variable. This is because I want to make easier to show the monster on the screen by storing the actual monster character in the cell. Give that chtype is defined as an unsigned integer, I can use the same data type to store the sum of level. To know how I need to interpret that value (i.e., monster or sum of levels) I need to look at the structure’s is_monster boolean member. This variable’s default value is false.

            
<<Game board cell structure definition>>=
struct Cell
{
    bool is_monster;
    bool is_visible;
    chtype value;

    Cell():
        is_monster(false),
        is_visible(false),
        value(0)
    {
    }
};

          

The board, thus, can be defined as a array of Cell but, since I need to have an arbitrary and dynamic board size, the easiest is to store the board as a vector of Row instead, being Row defined as another vector of Cell, to form a 2D array.

            
<<headers>>=
#include <vector>

          

            
<<Board type definition>>=
typedef std::vector<Cell> Row;
typedef std::vector<Row> Board;

          

            
<<Game private attributes>>=
Board board_;

          

Another key piece of information that I need to store in the Game class is the definition of the different kind of monsters. Each monster has the same attributes: level, the attack points, the experience points, and the number of monster of that kind that remain on the board. Again, all this information is better defined in a structure.

            
<<Monster types definition>>=
struct Monster
{
    size_t level;
    size_t attack_points;
    size_t experience_points;
    size_t remaining;

    Monster(size_t level, size_t attack_points, size_t experience_points,
        size_t remaining):
        level(level),
        attack_points(attack_points),
        experience_points(experience_points),
        remaining(remaining)
    {
    }
};

          

The monster identifier — that is, the character that I put in the ‘board` to represent the monster — isn’t stored in the Monster structure itself. Instead, as I have to lookup the monsters’ data when revealing squares later, I have map structure to assign the identifiers to their corresponding structure.

            
<<headers>>=
#include <map>

          

            
<<Monster types definition>>=
typedef std::map<chtype, Monster> MonsterMap;

          

            
<<Game private attributes>>=
MonsterMap monsters_;

          

This map isn’t initialized in the constructor as the others member attributes are. This is because when the board is created, I don’t want to pass all the monsters as parameters to the constructor. Instead, Game provides a member function to add new monster definitions. This function not only adds a new definition to the map, but also places the monsters randomly on the board, so after I added all the monsters definitions, the board game is also ready. As a caveat of having the initialization of the board and the monsters definition outside the constructor, I could end up with a board without any monster whatsoever. However, I see this as a valid board setup, albeit one not very exciting.

The next_level_experience parameter to this function is explained in the next section.

            
<<headers>>=
#include <cassert>

          

            
<<Game public functions>>=
void AddMonster(chtype monster_type, size_t level, size_t attack_points,
    size_t experience_points, size_t monsters_to_add,
    size_t next_level_experience)
{
    assert(monsters_to_add > 0 && "At least add one monster");
    assert(level > 0 && "Invalid monster level");
    assert(free_cells_.size() > monsters_to_add && "Too many monsters");
    assert(monsters_.find(monster_type) == monsters_.end() &&
        "Monster already defined");

    monsters_.insert(MonsterMap::value_type(monster_type,
            Monster(level, attack_points, experience_points, monsters_to_add)));
    <<store level experience>>
    for (; monsters_to_add > 0 ; monsters_to_add--)
    {
        Position pos(free_cells_.back());
        SetMonsterCell(pos.x, pos.y, monster_type);
        free_cells_.pop_back();
    }
}

          

The function SetMonsterCell simply sets the monster type to the specified cell.

            
<<Game public functions>>=
void SetMonsterCell(size_t x, size_t y, chtype monster_type)
{
    Cell &cell(Get(x, y));
    cell.is_monster = true;
    cell.value = monster_type;
}

          

The Get function using by SetMonsterCell returns the reference to the cell at the position passed as parameter. This function also checks that the coordinates are within the board limits, although it only does an assert instead throwing an exception on error; a precondition of this function.

            
<<Game public functions>>=
size_t width() const
{
    return board_[0].size();
}

size_t height() const
{
    return board_.size();
}

Cell &Get(size_t x, size_t y)
{
    assert(y < height());
    assert(x < width());

    return board_[y][x];
}

const Cell &Get(size_t x, size_t y) const
{
    return static_cast<const Cell &>(const_cast<Game &>(*this).Get(x, y));
}

          

Notice how I am using a free_cell_ member vector to get the position where I have to put the monster to. This vector is initialized in the Game constructor with all the board’s possible positions, which are simple structures with an x and and y coordinate, meaning that all the cells are free to put monsters at this point. Then, using the standard random_shuffle function, I randomly shuffle this positions to use later to put the monsters in a random position.

By using random_shuffle the iterator of the structure to shuffle must be random and as a consequence I can’t use a list, that a priori seems to be a better fit, because its iterators are sequential. However, even with the data structure drawback, by shuffling the positions beforehand I don’t have to hunt for a free cell for each monster I need to add, avoiding a possibly long initialization time if there are a lot of monsters.

            
<<Position structure definition>>=
struct Position
{
    size_t x;
    size_t y;

    Position(size_t x, size_t y):
        x(x),
        y(y)
    {
    }
};

          

            
<<Game private attributes>>=
std::vector<Position> free_cells_;
bool reveal_everything_;

          

            
<<headers>>=
#include <algorithm>

          

            
<<Game constructor>>=
Game(size_t width, size_t height, size_t hit_points, bool reveal_everything = true):
    board_(height, Row(width)),
    monsters_(),
    free_cells_(),
    reveal_everything_(reveal_everything),
    <<other Game constructor initializations>>
{
    assert(width > 0 && "Invalid board width");
    assert(height > 0 && "Invalid board height");
    assert(hit_points > 0 && "Invalid initial hit points");

    for(size_t y = 0 ; y < height ; ++y)
    {
        for(size_t x = 0 ; x < width ; ++x)
        {
            free_cells_.push_back(Position(x, y));
        }
    }
    std::random_shuffle(free_cells_.begin(), free_cells_.end());
}

          

Notice also that there is a reveal_everything parameter to Game constructor. This flag tells whether all the cells must be revealed in order to win the game or if it only is necessary to reveal the cells containing no monsters. This is used later when verifying the winning condition.

Revealing the cells is the meat of the game and, in consequence, where most of the game’s logic is. To reveal a cell, I check whether the specified cell is already revealed or not, because for already visible cells I need to do nothing at all. If the cell isn’t yet revealed, I make this cell visible and decrease the number of total remaining cells on the board, which is initialized in the constructor.

            
<<Game private attributes>>=
size_t remaining_cells_;

          

            
<<other Game constructor initializations>>=
remaining_cells_(width * height),

          

            
<<Game public functions>>=
void Reveal(size_t x, size_t y)
{
    Cell &cell(Get(x, y));
    if (!cell.is_visible)
    {
        cell.is_visible = true;
        <<reveal the cell>>
        <<initialize the game timer>>
        --remaining_cells_;
    }
}

          

When revealing the cell, I have two possible cases: cells with monsters and empty cells. When I encounter a monster, the monster attacks the player as many times as the difference between the its level and the player’s. If the player can sustain the attack, the monster is defeated and I have to increase the player’s experience points according to the monster type and check if I must increase the player’s level.

I also make the screen flash a brief moment to warn the player that she has leveled up. However, I found out that the curses flash function doesn’t seem to work when the colors output is enables. Thus, I had to make my own FlashScreen function that shows the whole screen in reverse mode for 50 milliseconds and then restores the window as it were. This function makes the characters to drop any attributes — i.e., colors — but this actually doesn’t matter because once the cell is revealed, everything is redrawn again anyway.

            
<<Flash screen function>>=
void FlashScreen()
{
    struct StripAttributes
    {
        StripAttributes()
        {
            for(int y = 0 ; y < LINES ; ++y)
            {
                for(int x = 0 ; x < COLS ; ++x)
                {
                    mvaddch(y, x, mvinch(y, x) & A_CHARTEXT);
                }
            }
        }
    };

    attron(A_REVERSE);
    StripAttributes reverse;
    refresh();

    napms(50);

    attroff(A_REVERSE);
    StripAttributes restore;
    refresh();
}

          

            
<<reveal the cell>>=
if (cell.is_monster)
{
    MonsterMap::iterator monster_iter = monsters_.find(cell.value);
    assert(monster_iter != monsters_.end() && "Invalid monster");
    Monster &monster(monster_iter->second);
    --monster.remaining;
    if (monster.level > player_level_)
    {
        player_hit_points_ -=
            std::min(monster.attack_points * (monster.level - player_level_),
                    player_hit_points_);
    }
    if (player_hit_points_ > 0)
    {
        player_experience_ += monster.experience_points;
        if (player_experience_ >= next_level_experience_)
        {
            ++player_level_;
            next_level_experience_ = GetLevelExperience(player_level_ + 1);
            FlashScreen();
        }
    }
}

          

The player_hit_points_, player_experience_, player_level_, and next_level_experience_ are private member attributes of Game that are initialized to default values in the constructor, except for player_hit_points_ that the caller passes its value as a parameter to the constructor.

            
<<Game private attributes>>=
size_t next_level_experience_;
size_t player_hit_points_;
size_t player_experience_;
size_t player_level_;

          

            
<<other Game constructor initializations>>=
next_level_experience_(9999),
player_hit_points_(hit_points),
player_experience_(0),
player_level_(1),

          

To get the experience points required to advance to the next level, I use the until now unexplained next_level_experience parameter to the AddMonster function. This parameter is actually the value that I need to know in order to allow the player to level up. I store this value in a map, like I do for the monsters themselves, except that instead of using a structure, I now only save the experience points value.

            
<<Experience types definition>>=
typedef std::map<size_t, size_t> ExperienceMap;

          

            
<<Game private attributes>>=
ExperienceMap levels_experience_;

          

            
<<other Game constructor initializations>>=
levels_experience_(),

          

When the caller passes the required experience points to level up as parameter to the AddMonster function, then I store this parameter mapped to the monster’s next level, not the actual monster’s level. If the monster’s level is the first, then I initialize the next_level_experience_ with this value, as I need to have this variable initialized before playing the game.

            
<<store level experience>>=
levels_experience_[level + 1] = next_level_experience;
if (1 == level)
{
    next_level_experience_ = next_level_experience;
}

          

With this setup, retrieving the next level experience with GetLevelExperience is straightforward.

            
<<Game public functions>>=
size_t GetLevelExperience(size_t level)
{
    assert(levels_experience_.find(level) != levels_experience_.end() &&
        "Level experience not found");
    return levels_experience_[level];
}

          

If the cell that is to be revealed is empty and doesn’t contain a monster, then, instead of juggling with the player’s statistics, I need to compute the cell’s value as the sum of the surrounding monsters' level.

If the resulting value is zero, for convenience, the game also reveals all the neighbour cells, by calling the function recursively and passing the position of the neighbour cells to reveal. Remember that if a cell has been already revealed this function does nothing, that is why is so important to set the is_visible variable to true as soon as possible: to avoid infinite recursion when a neighbour’s cell is also empty and calls this function with the initial cell’s position.

            
<<reveal the cell>>=
else
{
    size_t start_x = x > 0 ? x - 1 : 0;
    size_t end_x = x < width() - 1 ? x + 2 : x + 1;
    size_t start_y = y > 0 ? y - 1 : 0;
    size_t end_y = y < height() - 1 ? y + 2 : y + 1;

    cell.value = 0;
    for (size_t cell_y = start_y ; cell_y < end_y ; ++cell_y)
    {
        for(size_t cell_x = start_x ; cell_x < end_x ; ++cell_x)
        {
            cell.value += GetMonsterLevelAtCell(cell_x, cell_y);
        }
    }

    if (0 == cell.value)
    {
        for(size_t cell_y = start_y ; cell_y < end_y ; ++cell_y)
        {
            for (size_t cell_x = start_x ; cell_x < end_x ; ++cell_x )
            {
                Reveal(cell_x, cell_y);
            }
        }
    }
}

          

The function that I use here to get a monster level in a cell, GetMonsterLevelAtCell, is as simple as it sounds: it gets a cell, checks whether there is a monster in there, and returns its level. If there is no monster, then it always returns 0.

            
<<Game public functions>>=
size_t GetMonsterLevelAtCell(size_t x, size_t y) const
{
    const Cell &cell(Get(x, y));
    if (cell.is_monster)
    {
        MonsterMap::const_iterator monster(monsters_.find(cell.value));
        assert(monster != monsters_.end());
        return monster->second.level;
    }
    return 0;
}

          

The only thing that remains to do when revealing a cell is to start the game timer. The game counts the number of seconds that have elapsed since the first time a cell was revealed. For me, the easiest way to get the number of seconds elapsed is to store the time the first cell was revealed and then, each time I need to know the elapsed time, get the current time and subtract it from this initial time, but not allowing this time to be more than 9999 seconds, mostly to be able to tell beforehand how many digits I need to display the time on the screen. And also, quite blunt, a player that spends 9999 seconds (almost 3 hours) isn’t very good at this game.

            
<<headers>>=
#include <ctime>

          

            
<<Game public functions>>=
time_t GetElapsedTime() const
{
    if (start_time_ > 0)
    {
        return std::min(time_t(9999), std::time(NULL) - start_time_);
    }
    return 0;
}

          

The start_time_ attribute is initialized to zero in the constructor for me to know that the game hasn’t started yet. Thus, when the user reveals a cell, I check this attribute and set the current time if I find that its value is the zero.

            
<<Game private attributes>>=
time_t start_time_;

          

            
<<other Game constructor initializations>>=
start_time_(0)

          

            
<<initialize the game timer>>=
if (0 == start_time_)
{
    start_time_ = std::time(NULL);
}

          

The game ends when the player has revealed, without loosing all her hit points, all the cells that didn’t have monsters or all the cells without losing all her hit points, depending on the reveal_everything_ member attribute.

To know whether the player still has hit points, I simply check whether the variable is zero. For the cells is a little more involved, but not that much. First, knowing that I decrease the number of remaining monsters each time a monster is revealed, I find how many monsters remain to be revealed on the board. Then, I check if the remaining cells and the remaining monsters are the same, but I may require the number of remaining cells to be zero or not, depending on the reveal_everything_ flag. If this flag is set, then there can be no remaining cell, and thus no remaining monsters. Otherwise, there can remain any number of cells as long as they all are cells with monsters inside.

            
<<Game public functions>>=
bool IsDone() const
{
    if (player_hit_points_ == 0)
    {
        return true;
    }

    size_t remainingMonsters = 0;
    for(MonsterMap::const_iterator monster = monsters_.begin() ;
        monster != monsters_.end() ; ++monster)
    {
        remainingMonsters += monster->second.remaining;
    }
    return (!reveal_everything_ || remaining_cells_ == 0) &&
        remaining_cells_ == remainingMonsters;
}

          

Later, to check whether the player won or not, I only check whether the game is done but the player still has some hit points left.

            
<<Game public functions>>=
bool DidPlayerWin() const
{
    return IsDone() && player_hit_points_ > 0;
}

          

Both views show their content inside a curses window that they must manage. However, managing a window means that I have to take care to initialize the proper data structures and release them when are no longer needed.

A common C++ idiom to encapsulate this data initialization and posterior release is to wrap the raw resources in a Resource Acquisition Is Initialization (RAII) class. This class sole responsibility is to hold the window’s pointer, in this case, created in its constructor and release the pointer’s data on its destructor.

            
<<Window class>>=
class Window
{
    public:
        Window(int nlines, int ncols, int begin_y, int begin_x):
            window_(newwin(nlines, ncols, begin_y, begin_x))
        {
            if (0 == window_)
            {
                throw std::runtime_error("couldn't create window");
            }
        }

        ~Window()
        {
            delwin(window_);
        }

        <<Window public functions>>

    <<make Window class uncopiable>>

    private:
        WINDOW *window_;
};

          

Beside the initialization and release of the window’s pointer, I also need to access to this class' pointer to draw on. The cleanest way is to add a new member function that just returns the pointer.

This function can’t be const because the caller could modify the window using the pointer. Although in the eyes of the C++ compiler this is still const in a bitwise sense (i.e., the bits inside the class don’t change), this is not my idea of a const function, which means that the class status doesn’t change. That is why I don’t make this function const.

            
<<Window public functions>>=
WINDOW *Get()
{
    return window_;
}

          

Lastly, to avoid nasty and hard to find bugs, I don’t allow to make copies of the Window class. This way, I won’t call delwin on the same pointer twice just because the pointer got copied from object to object. To disallow copies, I define the copy constructor and the assignment operator as protected, but I leave them undefined. If someone tries, by mistake, to make a copy, the compiler won’t allow them.

            
<<make Window class uncopiable>>=
protected:
    Window(const Window &);
    Window &operator=(const Window &);

          

As I said, the StatusView class is the responsible to show to the player the game’s non-essential, although highly useful, data such as:

            
<<StatusView class>>=
class StatusView
{
    public:
        <<StatusView constructor>>

        <<StatusView public functions>>

    private:
        <<StatusView constants>>

        <<StatusView private attributes>>
};

          

Besides creating the required data structures to allow me to show this data, I have to modify the definition of the model in order to get all the information. Mostly, I have to add getters to the Game class.

The first data I need from ‘Game` is the number of monsters it has. I need this information to know how many lines the status window needs to hace. As I will also need to get the monsters’ data structure later when showing their level, the best way I can think of counting the different kind of monsters is by writing the getter that returns the monster map and then just call its size() member function.

            
<<Game public functions>>=
const MonsterMap &monsters() const
{
    return monsters_;
}

          

Based on this data and knowing that I need to show the level, the hit points, the experience, the next level experience, and the game’s time, I can compute the lines required to show all the information. The width is always fixed to 7 characters, to allow enough space to show everything, plus the two characters I need to show the box around the window. The height has a minimum of 8 lines, and then I must add the number of monsters in the game.

            
<<StatusView private attributes>>=
const Game &game_;
Window window_;

          

            
<<StatusView constants>>=
static const int kWindowWidth = 14 + 2;
static const int kWindowMinHeight = 8;

          

            
<<StatusView constructor>>=
StatusView(const Game &game):
    game_(game),
    window_(kWindowMinHeight + game.monsters().size(), kWindowWidth,
        0, COLS - kWindowWidth)
{
}

          

With the window created, showing the information is just a matter of calling the required Game getters and the curses mvwprintw function with the relevant bits. I use the uncommon “left adjustment” (i.e., -width flags) in order to remove any leftover characters when the values shrinks by a digit.

However, I have to use waddch when outputting the monster’s characters because the characters could contain color information that mwprintw — which in turn calls printf — would throw away. Therefore, I have to split the line in multiple calls to mvwprintw, waddch, and wprintw.

            
<<StatusView public functions>>=
void Draw()
{
    box(window_.Get(), ACS_VLINE, ACS_HLINE);

    int line = 1;
    mvwprintw(window_.Get(), line++, 1, "HP: %-4llu",
        static_cast<unsigned long long>(game_.player_hit_points()));
    mvwprintw(window_.Get(), line++, 1, "LV: %-4llu",
        static_cast<unsigned long long>(game_.player_level()));
    mvwprintw(window_.Get(), line++, 1, "EX: %-4llu",
        static_cast<unsigned long long>(game_.player_experience()));
    mvwprintw(window_.Get(), line++, 1, "NE: %-4llu",
        static_cast<unsigned long long>(game_.next_level_experience() -
            game_.player_experience()));
    mvwprintw(window_.Get(), line++, 1, "T : %-4lu",
        static_cast<unsigned long>(game_.GetElapsedTime()));
    line++;

    const Game::MonsterMap &monsters(game_.monsters());
    for(Game::MonsterMap::const_iterator monster = monsters.begin() ;
        monster != monsters.end() ; ++monster)
    {
        mvwprintw(window_.Get(), line, 1, "LV: %llu ",
            static_cast<unsigned long long>(monster->second.level));
        waddch(window_.Get(), monster->first);
        wprintw(window_.Get(), " x %-3llu",
            static_cast<unsigned long long>(monster->second.remaining));
        ++line;
    }

    wrefresh(window_.Get());
}

          

The getters for Game are trivial.

            
<<Game public functions>>=
size_t player_hit_points() const
{
    return player_hit_points_;
}

size_t player_level() const
{
    return player_level_;
}

size_t player_experience() const
{
    return player_experience_;
}

size_t next_level_experience() const
{
    return next_level_experience_;
}

          

The only other function I need for this view is its window’s width, used in the function with the main loop to create the other view, as already mentioned. Here, I can cast the const of window_ away because I know that getmaxx doesn’t modify the window at all. Without this cast I couldn’t declare the getter const.

            
<<StatusView public functions>>=
int width() const
{
    return getmaxx(const_cast<Window &>(window_).Get());
}

          

The GameView class is conceptually the same as the StatusView: a window where to draw some data from the model. However, even if both classes follow the same idea and even have some functions named similarly, I don’t think useful to make a base class and derive both from this new class. After all, I am not going to use the two views in a polymorphic way.

            
<<GameView class>>=
class GameView
{
    public:
        <<Cursor type definition>>

        <<GameView constructor>>

        <<GameView public functions>>

    private:
        <<GameView constants>>

        <<GameView private attributes>>
};

          

Like StatusView, GameView has a curses window that is created in its constructor as well as the reference to the Game model. In this case, though, the constructor also receives the maximum number of columns that this view can use. GameView uses this width, as well as the terminal’s height, to compute the maximum number of cells, not characters, that the view can show. Then I can create the window given this number and each cell’s size in characters.

When computing the number of cells from the maximum columns, I have to reserve enough space for the view’s border. Also, the view’s usable area on the screen can be bigger or smaller than the board, so I always have to use the lowest of the usable screen’s are or the board’s size as the view size.

            
<<GameView constants>>=
static const int kCellWidth = 3; // characters
static const int kCellHeight = 1; // characters

          

            
<<GameView private attributes>>=
const Game &game_;
int view_height_;
int view_width_;
Window window_;

          

            
<<GameView constructor>>=
GameView(const Game &game, int maximum_width):
    game_(game),
    view_height_(std::min((LINES - 2) / kCellHeight, static_cast<int>(game.height()))),
    view_width_(std::min((maximum_width - 2) / kCellWidth, static_cast<int>(game.width()))),
    window_(view_height_ * kCellHeight + 2, view_width_ * kCellWidth + 2, 0, 0),
    <<other GameView initialization>>
{
}

          

As hinted before, GameView is able to handle boards that are bigger than what can be seen on the screen by scrolling the board. To scroll, I need a couple of variables that tell to the view which is the board’s first column and first row that are visible on the screen, which by default are column 0 and row 0.

            
<<GameView private attributes>>=
size_t scroll_x_;
size_t scroll_y_;

          

            
<<other GameView initialization>>=
scroll_x_(0),
scroll_y_(0),

          

To know whether the view needs to scroll or not, I must allow the player to move around the view. This is what is termed a cursor, which is a 2D position on the view.

            
<<Cursor type definition>>=
struct Cursor
{
    size_t x;
    size_t y;

    Cursor():
        x(0),
        y(0)
    {
    }

    Cursor(size_t x, size_t y):
        x(x),
        y(y)
    {
    }
};

          

            
<<GameView private attributes>>=
Cursor view_cursor_;

          

            
<<other GameView initialization>>=
view_cursor_()

          

However, this view has two cursors: one is the actual cursor visible on the screen and the other is the position over the game board where the view cursor is on. This cursor isn’t stored; is computed from the visible cursor and the current scroll.

            
<<GameView public functions>>=
Cursor BoardCursor() const
{
    return Cursor(view_cursor_.x + scroll_x_, view_cursor_.y + scroll_y_);
}

          

But a static cursor if of no use whatsoever, so I have to add functions that move the cursor around the screen and that also update the scroll variables when the player tries to move outside the view’s limits, if possible. These scroll variable can’t have a value that allows the view to draw outside the board’s limits.

            
<<GameView public functions>>=
size_t Height() const
{
    return view_height_;
}

size_t Width() const
{
    return view_width_;
}

void MoveDown()
{
    if (view_cursor_.y < Height() - 1)
    {
        ++view_cursor_.y;
    }
    else if (scroll_y_ + Height() < game_.height())
    {
        ++scroll_y_;
    }
}

void MoveLeft()
{
    if (view_cursor_.x > 0)
    {
        --view_cursor_.x;
    }
    else if (scroll_x_ > 0)
    {
        --scroll_x_;
    }
}

void MoveRight()
{
    if (view_cursor_.x < Width() - 1)
    {
        ++view_cursor_.x;
    }
    else if (scroll_x_ + Width() < game_.width())
    {
        ++scroll_x_;
    }
}

void MoveUp()
{
    if (view_cursor_.y > 0)
    {
        --view_cursor_.y;
    }
    else if (scroll_y_ > 0)
    {
        --scroll_y_;
    }
}

          

GameView also has convenient functions to move to the first column, the first row, the last column, and the last row.

            
<<GameView public functions>>=
void GoToFirstCol()
{
    view_cursor_.x = 0;
    scroll_x_ = 0;
}

void GoToLastCol()
{
    view_cursor_.x = Width() - 1;
    scroll_x_ = game_.width() - Width();
}

void GoToFirstRow()
{
    view_cursor_.y = 0;
    scroll_y_ = 0;
}

void GoToLastRow()
{
    view_cursor_.y = Height() - 1;
    scroll_y_ = game_.height() - Height();
}

          

Another convenient function allows to move to the next yet unrevealed cell. Here I don’t need to check if there is any remaining unrevealed cell , because if the game has called this function, as a result of a key press, I can assume that there is at least one invisible cell, otherwise the game would have ended already.

            
<<GameView public functions>>=
void GoToNextInvisibleCell()
{
    do
    {
        if (view_cursor_.x < Width() - 1 || scroll_x_ + Width() < game_.width())
        {
            MoveRight();
        }
        else
        {
            GoToFirstCol();
            if (view_cursor_.y < Height() - 1 || scroll_y_ + Height() < game_.height())
            {
                MoveDown();
            }
            else
            {
                GoToFirstRow();
            }
        }
    }
    while (game_.Get(
        scroll_x_ + view_cursor_.x,
        scroll_y_ + view_cursor_.y).is_visible);
}

          

The last remaining bit for GameView to do is to draw itself. Using the scroll_x_ and scroll_y_ variables I can know the position in the game’s board to start reading cells. If the cell is visible, then I draw the cell’s value either as a character, if is a monster, or as an integer, except for empty cells with a value of 0, that I show as blank spaces. For unrevealed cells, I draw two hyphens.

To show where the cursor is, when I am going to draw the cell where the cursor is over, I’ll reverse the character colors and make that cell distinguishable.

When the game is completed, either because the player lost all the hit points or because has revealed all the cells, I also draw all monsters, regardless of whether is revealed or not.

Here again the monster character can have color attributes. However, I also need the space in front of the monster character to be of the same color as the monster, otherwise when I draw the cursor in reverse mode, it has two colors and looks weird. As here the whole string needs to have the same color, I can extract the color information from the monster’s character, if it has any, with a bitwise-and of the character and A_COLOR and apply the result attribute to the curses window with wattron and wattroff before and after printing the string, respectively. In this case, there is no need to split the output of the two characters in two different calls as it was with StatusView.

            
<<GameView public functions>>=
void Draw()
{
    bool show_monsters = game_.IsDone();
    for(size_t y = 0, board_y = scroll_y_, cell_y = 1 ;
        y < Height() ;
        ++y, ++board_y, cell_y += kCellHeight)
    {
        for(size_t x = 0, board_x = scroll_x_, cell_x = 1 ;
            x < Width() ;
            ++x, ++board_x, cell_x += kCellWidth)
        {
            bool show_cursor = y == view_cursor_.y && x == view_cursor_.x;
            if (show_cursor)
            {
                wattron(window_.Get(), A_REVERSE);
            }

            const Game::Cell &cell(game_.Get(board_x, board_y));
            if (cell.is_visible || (cell.is_monster && show_monsters))
            {
                if (cell.is_monster)
                {
                    wattron(window_.Get(), cell.value & A_COLOR);
                    mvwprintw(window_.Get(), cell_y, cell_x, " %c", cell.value);
                    wattroff(window_.Get(), cell.value & A_COLOR);
                }
                else if (cell.value > 0)
                {
                    mvwprintw(window_.Get(), cell_y, cell_x, "%2d", cell.value);
                }
                else
                {
                    mvwprintw(window_.Get(), cell_y, cell_x, "  ");
                }
            }
            else
            {
                mvwprintw(window_.Get(), cell_y, cell_x, "--");
            }

            if (show_cursor)
            {
                wattroff(window_.Get(), A_REVERSE);
            }
        }
    }

          

I also want to draw a box around the GameView view, but this time I can’t use box function and have to use border, because I want to display a different border if the board can be scrolled in any of the four directions. When a side can be scrolled, instead of vertical or horizontal lines, I show arrows pointing to the direction that can be scrolled.

            
<<GameView public functions>>=
    wborder(window_.Get(),
        (scroll_x_ > 0) ? ACS_LARROW : ACS_VLINE, // Left side,
        (scroll_x_ < game_.width() - Width()) ? ACS_RARROW : ACS_VLINE, // Right side
        (scroll_y_ > 0) ? ACS_UARROW : ACS_HLINE, // Top side
        (scroll_y_ < game_.height() - Height()) ? ACS_DARROW : ACS_HLINE, // Bottom side
        ACS_ULCORNER, ACS_URCORNER, ACS_LLCORNER, ACS_LRCORNER);

    wrefresh(window_.Get());
}