Complete roguelike tutorial using C++ and libtcod - part 4: field of view

Complete roguelike tutorial using C++ and libtcod -originally written by Jice Text in this tutorial was released under the Creative Commons Attribution-ShareAlike 3.0 Unported and the GNU Free Documentation License (unversioned, with no invariant sections, front-cover texts, or back-cover texts) on 2015-09-21.

part 1: setting up part 2: map and actors part 3: dungeon building part 4: field of view part 5: preparing for combat part 6: going berserk! part 7: the GUI part 8: items and inventory part 9: spells and ranged combat part 10.1: persistence part 10.2: game menu part 11: dungeon levels and character progression extra 1: about editors and IDE extra 2: debugging extra 3: scent tracking extra 4: makefiles extra 5: more generic items

In this fourth part, we're computing the player field of view to light only the visible part of the dungeon. We also only display the part of the dungeon that the player has explored. We're going to use the libtcod TCODMap object to compute the field of view.

libtcod functions used in this article

TCODMap::TCODMap

TCODMap::isWalkable

TCODMap::isInFov

TCODMap::computeFov

TCODMap::setProperties

Updating the Map class

In Map.hpp we're adding a reference to a TCODMap object and we add a few helper functions along with the FOV compute function :

   bool isInFov(int x, int y) const;
   bool isExplored(int x, int y) const;
   void computeFov();
   void render() const;
protected :
   Tile *tiles;
   TCODMap *map;
   friend class BspListener;

Since TCODMap already contains canWalk / canSeeThrough information, we remove the canWalk field from the Tile object. In fact, we're replacing it with an "explored" field that indicates whether this tile has already been seen by the player.

struct Tile {
   bool explored; // has the player already seen this tile ?
   Tile() : explored(false) {}
};

In Map.cpp, we allocate the TCODMap object in the constructor :

Map::Map(int width, int height) : width(width),height(height) {
   tiles=new Tile[width*height];
   map=new TCODMap(width,height);

and delete it in the destructor :

Map::~Map() {
   delete [] tiles;
   delete map;
}

The new isWall method uses the TCODMap object :

bool Map::isWall(int x, int y) const {
   return !map->isWalkable(x,y);
}

whereas the isExplored function uses our Tile array :

bool Map::isExplored(int x, int y) const {
   return tiles[x+y*width].explored;
}

And now the functions dealing with the field of view :

bool Map::isInFov(int x, int y) const {
   if ( map->isInFov(x,y) ) {
       tiles[x+y*width].explored=true;
       return true;
   }
   return false;
}

void Map::computeFov() {
   map->computeFov(engine.player->x,engine.player->y,
       engine.fovRadius);
}

We're using a fovRadius field on the engine class, this way we'll be able to dynamically change the radius.

The isInFov function does not only returns the computed value from the TCODMap object, it also updates the explored flags when a cell enters the field of view.

The dig function must also be updated to use the TCODMap object :

for (int tilex=x1; tilex <= x2; tilex++) {
   for (int tiley=y1; tiley <= y2; tiley++) {
       map->setProperties(tilex,tiley,true,true);
   }
}

In Map::render(), we define two new constants for the light colors :

static const TCODColor lightWall(130,110,50);
static const TCODColor lightGround(200,180,50);

During the map drawing phase, we use the light color for tiles in FOV and the dark color for explored tiles not in fov. Other tiles are not drawn.

for (int x=0; x < width; x++) {
   for (int y=0; y < height; y++) {
       if ( isInFov(x,y) ) {
           TCODConsole::root->setCharBackground(x,y,
               isWall(x,y) ? lightWall :lightGround );
       } else if ( isExplored(x,y) ) {
           TCODConsole::root->setCharBackground(x,y,
               isWall(x,y) ? darkWall : darkGround );
       }
   }
}