DEV Community: Ignacio Oyarzabal

The C Roguelike Tutorial - Part 4: Field of View

Ignacio Oyarzabal — Thu, 09 Sep 2021 14:17:26 +0000

It's not much of an adventure if you can't get surprised by hidden goblins and sudden encounters with big angry trolls. Right now the player can see everything in the dungeon. In this part of the tutorial we'll add an algorithm which will give the player a limited field of view, so that he has to walk around in order to discover the dungeon around him. Before we go ahead with that, however, we will add color to our game so that we can differentiate what we are currently seeing from what we have seen in the past.

Adding color

When we use ncurses, color is not enabled by default, it only uses black and white. In order to use color we need to use a function from ncurses which initializes the color scheme mode. Before we do that, we will use another function that verifies whether the current terminal that is running the application actually supports colors. If it returns true we will proceed to initialize the color mode, if it returns false, we will give the player an appropriate message informing him that his terminal does not support colors and we will close the game.

Once color is initialized, ncurses provides 8 different predefined colors which we can use. Colors are not used individually in ncurses, they must be used in pairs. A background color and a foreground color go together to make up a color pair that you can give to the different parts in your game. I will show you how to initialize a color pair with the default colors provided by ncurses. Ncurses also allows you to define your own colors in case you need more than the eight default ones, but we will stick to the basic eight colors for this tutorial. If you want more colors you will have to look into the ncurses documentation. Be aware that if you decide to use more than the eight basic colors not all terminals will be able to display them. While the linux terminal emulators usually support 256 colors, I've found that the windows Command Line only supports 8.

To initialize color pairs, ncurses takes an int which defines each pair. In order to use more appropriate names for each color first we will define a set of constants in our header file. Add the following lines to our rogue.h:

#include <ncurses.h>
#include <stdlib.h>
#include <time.h>
+
+// color pairs
+#define VISIBLE_COLOR 1
+#define SEEN_COLOR 2

typedef struct
...

Here we are defining a constant for each of the color pairs we will use in this part of the tutorial. We will use these constants when we initialize our color pairs to avoid having to use non-descriptive numbers every time we want to use the color pairs.

Next we will add the initialization code to our engine.c file, making our cursesSetup() function look like this:

void cursesSetup(void)
{ 
  initscr();
  noecho();
  curs_set(0);

  if (has_colors())
  {
    start_color();

    init_pair(VISIBLE_COLOR, COLOR_WHITE, COLOR_BLACK);
    init_pair(SEEN_COLOR, COLOR_BLUE, COLOR_BLACK);
  }
}

In the first new line if (has_colors()) checks whether the terminal supports colors. If it does, we initialize ncurse's color system with start_color(). Finally, we initialize two color pairs:

    init_pair(VISIBLE_COLOR, COLOR_WHITE, COLOR_BLACK);
    init_pair(SEEN_COLOR, COLOR_BLUE, COLOR_BLACK);

The ncurses init_pair() function takes an int as a first parameter to identify the new color pair. The second parameter is the foreground color and the third is the background color. The uppercase constants that we have passed for these parameters are some of the color constants defined by ncurses. We have now established that our VISIBLE_COLOR will have a white font color on a black background and our SEEN_COLOR will have a blue font color on a black background. Since we don't have gray in our predefined ncurses colors we'll use blue, which will substitute nicely to make up the parts of the dungeon which we have already seen but which are plunged into shadow once the player moves on.

Now that the colors are initialized we can use them with a function called COLOR_PAIR() which takes as argument one of our predefined color numbers such as VISIBLE_COLOR and returns an int that we can use to modify ASCII characters when we print them to the ncurses screen. In order to assign each map tile and each entity a color, we'll add an int color variable to our Tile and Entity structs in our rogue.h file, like so:

typedef struct
{
  char ch;
+  int color;
  bool walkable;
} Tile;

typedef struct
{
  ...
} Room;

typedef struct
{
  Position pos;
  char ch;
+  int color;
} Entity;

Now that our structs are set up to include a color variable, we need to modify a few functions. Open map.c and add the following line to our createMapTiles() function:

Tile** createMapTiles(void)
{
  Tile** tiles = calloc(MAP_HEIGHT, sizeof(Tile*));

  for (int y = 0; y < MAP_HEIGHT; y++)
  {
    tiles[y] = calloc(MAP_WIDTH, sizeof(Tile));
    for (int x = 0; x < MAP_WIDTH; x++)
    {
      tiles[y][x].ch = '#';
+      tiles[y][x].color = COLOR_PAIR(VISIBLE_COLOR);
      tiles[y][x].walkable = false;
    }
  }

  return tiles;
}

And open the player.c file and modify the createPlayer() function with the following:

Entity* createPlayer(Position start_pos)
{
  Entity* newPlayer = calloc(1, sizeof(Entity));

  newPlayer->pos.y = start_pos.y;
  newPlayer->pos.x = start_pos.x;
  newPlayer->ch = '@';
+  newPlayer->color = COLOR_PAIR(VISIBLE_COLOR);

  return newPlayer;
}

Now that our struct variables have a color assigned we have to modify some code to use their colors when we draw them on the screen. In order to use the color pairs, we will use the bitwise OR operator | to modify each struct's char variable. Open our draw.c file and change the lines like this:

void drawMap(void)
{
  for (int y = 0; y < MAP_HEIGHT; y++)
  {
    for (int x = 0; x < MAP_WIDTH; x++)
    {
-      mvaddch(y, x, map[y][x].ch);
+      mvaddch(y, x, map[y][x].ch | map[y][x].color);
    }
  }
}

void drawEntity(Entity* entity)
{   
-  mvaddch(entity->pos.y, entity->pos.x, entity->ch);
+  mvaddch(entity->pos.y, entity->pos.x, entity->ch | entity->color);
}

What we are adding to the ch variables is a bitwise OR operation. The bitwise OR is an operation that compares the binary of each side of the operation and returns a binary that will retain 1s whenever one or both of those sides have a 1, or will return a 0 otherwise. In this case the OR operation is returning an int that represents the same character as before but with a modified color scheme.

If we run our code now, it should do exactly the same as it did before, with no change. And now we can move on to implementing a field of vision for our player where we will use our SEEN_COLOR and actually put our color scheme to use.

Field of Vision

We will now create a new file where we will write all of the code needed to use a field of vision for our player that will only allow us to see up to a certain range. We will code two functions that will be used by other c modules in our game, those will be makeFOV() and clearFOV(). makeFOV() will make the appropriate calculations and modify the Tiles around the player accordingly so that the game shows them on the screen. 'clearFOV()' will make sure that every time we move we clear all of the tiles which we had previously seen, so that the next time makeFOV() is called everything is cleared and we don't get a trail of light left behind us as we move. makeFOV() will make use of several other functions in this file, the most complicated of which is lineOfSight() which is the function that will make sure that our player can't see through walls. This function is used by implementing the simplest algorithm for line of sight I could find. It is a just an adaptation of this algorithm by Steve Register.

Before we start programming the algorithms for field of view we need to add three new boolean variables to our Tile struct in our rogue.h file, like so:

...
typedef struct
{
  char ch;
  int color;
  bool walkable;
+  bool transparent;
+  bool visible;
+  bool seen;
} Tile;
...

The transparent boolean will be used by our lineOfSight() function to determine which parts of the map the player can see through, while the visible and seen will be used by makeFOV() and clearFOV() as they go about modifying the map to fit what the player can actually see.

Go ahead and create a file called fov.c and add the following code to it:

#include "rogue.h"

void makeFOV(Entity* player)
{ 
  int y, x, distance;
  int RADIUS = 15;
  Position target;

  map[player->pos.y][player->pos.x].visible = true;
  map[player->pos.y][player->pos.x].seen = true;

  for (y = player->pos.y - RADIUS; y < player->pos.y + RADIUS; y++)
  { 
    for (x = player->pos.x - RADIUS; x < player->pos.x + RADIUS; x++)
    { 
      target.y = y;
      target.x = x;
      distance = getDistance(player->pos, target);

      if (distance < RADIUS)
      { 
        if (isInMap(y, x) && lineOfSight(player->pos, target))
        { 
          map[y][x].visible = true;
          map[y][x].seen = true;
        } 
      } 
    } 
  } 
}

The makeFOV() function returns void and takes a single Entity* as an argument.

  int y, x, distance;
  int RADIUS = 15;
  Position target;

Here we define the variables that we will use for this function. y and x will be iterated according to the RADIUS variable in order to get a square field that extends as many tiles as the RADIUS function to all sides of the player. We are hardcoding a RADIUS for now but we will later add a radius variable to the player and take the radius from there. The Position target will be used to send the y and x coordinates to our getDistance() function.

  map[player->pos.y][player->pos.x].visible = true;
  map[player->pos.y][player->pos.x].seen = true;

Here we are simply assigning true to the position in the map that the player is standing on, since he will always be able to see at least where he stands. Making a tile visible will allow our drawMap() function to draw the tile and anything on it, but we also set seen to true, so that when we move away from that position we can switch the visible variable to false, and our drawMap() function will then check if the position is seen and draw it in blue so that the player remembers where he's been, even if he can't see it at the moment.

Next, we enter the loop:

  for (y = player->pos.y - RADIUS; y < player->pos.y + RADIUS; y++)
  { 
    for (x = player->pos.x - RADIUS; x < player->pos.x + RADIUS; x++)
    {

As I mentioned previously, the loop iterates y and x to go through all of the coordinates around the player by as much as the RADIUS variable.

      target.y = y;
      target.x = x;
      distance = getDistance(player->pos, target);

Inside the loop first we assign the y and x variables to the target variable and use that to call the getDistance() function, which we will code shortly, and assign it's return value to distance. getDistance() will return the distance from the player's position to the target position coordinate that the loop is iterating through at the moment.

      if (distance < RADIUS)
      { 
        if (isInMap(y, x) && lineOfSight(player->pos, target))
        { 
          map[y][x].visible = true;
          map[y][x].seen = true;
        }

Finally, we check whether the distance from the player to the target is shorter than the RADIUS. Performing this check allows us to make the FOV of the player a pseudo-circular area around him, instead of a sharp square. If the distance is shorter than the RADIUS, then we proceed with the final check to verify if the player can actually see the given location.

In the final if statement, we first verify if the y-x coordinate is inside our map with the isInMap() function, this will prevent us from crashing the game by going out of bounds in the map array. If, and only if, this function returns true, then the call to lineOfSight(player->pos, target) is made, and, if that also returns true, we switch the appropriate map Tile's visible and seen variables to true.

Now add the following function to the same fov.c file:

...
void clearFOV(Entity* player)
{ 
  int y, x;
  int RADIUS = 15;

  for (y = player->pos.y - RADIUS; y < player->pos.y + RADIUS; y++)
  { 
    for (x = player->pos.x - RADIUS; x < player->pos.x + RADIUS; x++)
    {
      if (isInMap(y, x))
        map[y][x].visible = false;
    }
  } 
}

In this function we are again iterating through the section of map around the player just like in the makeFOV() function, except in this case we are simply turning every single Tile's visible variable to false, in order to clear the map and allow for a fresh run of the makeFOV() function. We use the isInMap() function again to avoid going out of bounds of the map array.

Next, we will start adding our helper functions that we used in these functions. Append the following code below the clearFOV() function:

...
int getDistance(Position origin, Position target)
{ 
  double dy, dx;
  int distance;
  dx = target.x - origin.x;
  dy = target.y - origin.y;
  distance = floor(sqrt((dx * dx) + (dy * dy)));

  return distance;
}

bool isInMap(int y, int x)
{ 
  if ((0 < y && y < MAP_HEIGHT - 1) && (0 < x && x < MAP_WIDTH - 1))
  { 
    return true;
  }

  return false;
}

The getDistance() function simply calculates the distance between two points using the hypotenuse formula. It uses floor() and sqrt() functions which are defined in the math.h header. We will have to add this header to our rogue.h file before compiling.

The isInMap() function checks whether the y and x parameters are in the correct range, keeping a padding of 1 both at the beginning and end of the range. It returns true if the respective ints are within the range of the map array or false otherwise.

Next we will add the most complicated of the helper functions, this function will do the brunt of the calculations. The algorithm is not entirely efficient and if you were making a more complicated game with higher graphical requirements this algorithm would likely slow your game down. As it is, our game will be perfectly fine with this algorithm and due to its relative simplicity it serves the purpose of this tutorial nicely.

Add the following code to the bottom of our fov.c file:

...
bool lineOfSight(Position origin, Position target)
{
  int t, x, y, abs_delta_x, abs_delta_y, sign_x, sign_y, delta_x, delta_y;

  delta_x = origin.x - target.x;
  delta_y = origin.y - target.y;

  abs_delta_x = abs(delta_x);
  abs_delta_y = abs(delta_y);

  sign_x = getSign(delta_x);
  sign_y = getSign(delta_y);

  x = target.x;
  y = target.y;

  if (abs_delta_x > abs_delta_y)
  {
    t = abs_delta_y * 2 - abs_delta_x;

    do
    {
      if (t >= 0)
      {
        y += sign_y;
        t -= abs_delta_x * 2;
      }

      x += sign_x;
      t += abs_delta_y * 2;

      if (x == origin.x && y == origin.y)
      {
        return true;
      }
    }
    while (map[y][x].transparent);

    return false;
  }
  else
  {
    t = abs_delta_x * 2 - abs_delta_y;

    do
    {
      if (t >= 0)
      {
        x += sign_x;
        t -= abs_delta_y * 2;
      }

      y += sign_y;
      t += abs_delta_x * 2;

      if (x == origin.x && y == origin.y)
      {
        return true;
      }
    }
    while (map[y][x].transparent);

    return false;
  }
}

int getSign(int a)
{
  return (a < 0) ? -1 : 1;
}

The lineOfSight() function takes two Position arguments, an origin and a target and returns a boolean. It will return true if the origin is in line of sight of the target. Using the transparent variable of the Tiles in our map, the function goes through all of the Tiles that make the shortest line from the origin to the target, if it can go through the whole line without encountering a Tile that has a transparent value of false, it returns true, and it returns false otherwise. I won't analyze this function line per line as it is quite long and complex, but you can take a look at the original documented code by Steve Register here if you want to get a better explanation of how the algorithm works.

The getSign() function simply returns a 1 or a -1 depending on the sign of the int provided. This function is used in lineOfSight() as a helper function.

Now all we need to do to use our new field of view functions is make a few small changes in our code. First, we need to initialize all of the new boolean variables we added to our tiles. Open our map.c file and add the following lines to the createMapTiles() function:

Tile** createMapTiles(void)
{
  Tile** tiles = calloc(MAP_HEIGHT, sizeof(Tile*));

  for (int y = 0; y < MAP_HEIGHT; y++)
  {
    tiles[y] = calloc(MAP_WIDTH, sizeof(Tile));
    for (int x = 0; x < MAP_WIDTH; x++)
    {
      tiles[y][x].ch = '#';
      tiles[y][x].color = COLOR_PAIR(VISIBLE_COLOR);
      tiles[y][x].walkable = false;
+      tiles[y][x].transparent = false;
+      tiles[y][x].visible = false;
+      tiles[y][x].seen = false;
    }
  }

  return tiles;
}

Since we initialize all of our Tiles to be walls, we assign their transparent variable to be false, as well as the other two.

Now open the room.c file and modify the addRoomToMap() and the connectRoomCenters() functions to use the new transparent variable:

void addRoomToMap(Room room)
{
  for (int y = room.pos.y; y < room.pos.y + room.height; y++)
  {
    for (int x = room.pos.x; x < room.pos.x + room.width; x++)
    {
      map[y][x].ch = '.';
      map[y][x].walkable = true;
+      map[y][x].transparent = true;
    }
  }
}

void connectRoomCenters(Position centerOne, Position centerTwo)
{
  Position temp;
  temp.x = centerOne.x;
  temp.y = centerOne.y;

  while (true)
  {
    if (abs((temp.x - 1) - centerTwo.x) < abs(temp.x - centerTwo.x))
      temp.x--;
    else if (abs((temp.x + 1) - centerTwo.x) < abs(temp.x - centerTwo.x))
      temp.x++;
    else if (abs((temp.y + 1) - centerTwo.y) < abs(temp.y - centerTwo.y))
      temp.y++;
    else if (abs((temp.y - 1) - centerTwo.y) < abs(temp.y - centerTwo.y))
      temp.y--;
    else
      break;

    map[temp.y][temp.x].ch = '.';
    map[temp.y][temp.x].walkable = true;
+    map[temp.y][temp.x].transparent = true;
  }
}

With these simple additions our map is ready to use the field of vision functions. Let's add our functions to our rogue.h file and also add a new include for the math functions:

#ifndef ROGUE_H
#define ROGUE_H

#include <ncurses.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

...

// room.c functions
Room createRoom(int y, int x, int height, int width);
void addRoomToMap(Room room);
void connectRoomCenters(Position centerOne, Position centerTwo);
+
+// fov.c functions
+void makeFOV(Entity* player);
+void clearFOV(Entity* player);
+int getDistance(Position origin, Position target);
+bool isInMap(int y, int x);
+bool lineOfSight(Position origin, Position target);
+int getSign(int a);

...

Now we just need to use our makeFOV() and clearFOV() functions in the right place for it to work. First, we will add a call to makeFOV() at the start of the game, right before the loop begins. Open engine.c and add the following line:

...
void gameLoop(void)
{
  int ch;
+    
+  makeFOV(player);
  drawEverything();

  while(ch = getch())
  {
    if (ch == 'q')
    {
      break;
    }

    handleInput(ch);
    drawEverything();
  }
}

...

This line will create the field of view for the first time right before the map is drawn.

Now open the player.c file and modify the movePlayer() function like this:

...
void movePlayer(Position newPos)
{
  if (map[newPos.y][newPos.x].walkable)
  {   
+    clearFOV(player);
    player->pos.y = newPos.y;
    player->pos.x = newPos.x;
+    makeFOV(player);
  }
}

In this way, we are clearing the field of view before we actually make a move, and then we are remaking the field of view once we have performed the player's move.

Finally, we need to modify our draw function. Open draw.c file and modify our drawMap() function like this:

...

void drawMap(void)
{
  for (int y = 0; y < MAP_HEIGHT; y++)
  {
    for (int x = 0; x < MAP_WIDTH; x++)
    {
-      mvaddch(y, x, map[y][x].ch | map[y][x].color);
+      if (map[y][x].visible)
+      {
+        mvaddch(y, x, map[y][x].ch | map[y][x].color);
+      }
+      else if (map[y][x].seen)
+      {
+        mvaddch(y, x, map[y][x].ch | COLOR_PAIR(SEEN_COLOR));
+      }
+      else
+      {
+        mvaddch(y, x, ' ');
+      }
    }
  }
}

...

In the first if block, we check if the position is visible to the player and draw the Tile using it's own color if it is. If the position is not visible, but it has been seen, the second block will draw the Tile using the darker SEEN_COLOR. Finally, if the position is neither visible nor seen, the last block will draw an empty space. If we did not do this, the previous drawings would remain.

Now all of the source code is ready, but before we try to compile the program again, we need to add a new flag in our makefile so that the compiler knows to link the math.h header file properly when compiling. Open the makefile and add the following:

CC = gcc
-CFLAGS = -lncurses -I./include/
+CFLAGS = -lncurses -lm -I./include/
SOURCES = ./src/*.c

...

Now we can finally compile our game again. It should now show you only the nearest parts of the dungeon to the player. If you move around you will see how the shadows move around with the player and the light is stopped by the walls of the dungeon.

Congratulations! We now have a game where we can discover things instead of being shown everything at once!

The only issue now is that if you run the game in a terminal which doesn't support colors, the game will crash when it tries to use colors. Therefore we need to add some logic to our code that will prevent the game from running if it doesn't find color support and inform the user that he should try running the game in a color-compatible terminal.

First we'll modify our cursesSetup() function to return a boolean. It will return true if it managed to initialize colors, and false otherwise. Open engine.c and make the following modifications:

...
-void cursesSetup(void)
+bool cursesSetup(void)
{
  initscr();
  noecho();
  curs_set(0);

  if (has_colors())
  {
    start_color();

    init_pair(VISIBLE_COLOR, COLOR_WHITE, COLOR_BLACK);
    init_pair(SEEN_COLOR, COLOR_BLUE, COLOR_BLACK);
+
+    return true;
  }
+  else
+  {
+    mvprintw(20, 50, "Your system doesn't support color. Can't start game!");
+    getch();
+    return false;
+  }
}

...

This new code will return true if the colors are initialized. If they are not, it will print a message to the user informing him of the issue, wait for the user to press any key and then return false.

Modify the function declaration in our rogue.h file:

...
//engine.c functions
-void cursesSetup(void);
+bool cursesSetup(void);
void gameLoop(void);
void closeGame(void);
...

Now we need to modify our main.c file to use the boolean value returned by cursesSetup(). Modify the main() function to look like this:

...
int main(void)
{
  Position start_pos;
  bool compatibleTerminal;

  compatibleTerminal = cursesSetup();

  if (compatibleTerminal)
  {
    srand(time(NULL));

    map = createMapTiles();
    start_pos = setupMap();
    player = createPlayer(start_pos);

    gameLoop();

    closeGame();
  }
  else
  {
    endwin();
  }

  return 0;
}

With this in place any errors due to color compatibility will be dealt with smoothly, warning the player of the issue.

That's all for this part of the tutorial. If you want to look at the full code up to this part, you can download it here!

In the next part of this tutorial we'll be looking into adding monsters to our dungeon!

The C Roguelike Tutorial - Part 3: The Dungeon

Ignacio Oyarzabal — Wed, 18 Aug 2021 14:24:05 +0000

In this part of the tutorial we're going to setup the randomized generation of our dungeon rooms and their hallways. Let's get right to it!

The Room Struct

First off, we're going to create a new struct for our rooms which will allow us to easily go about our dungeon generation process. Open your rogue.h file and add the following struct below your Tile struct:

...
} Tile;

typedef struct
{
  int height; 
  int width;
  Position pos;
  Position center;
} Room;

typedef struct
{
...

The Room struct contains height and width members, pos, which defines the upper-left corner of the room, and center, which we will use to connect each room to the next. We'll need a function to create each individual room and another to add the room to our map array. Open a new file in src/ called room.c and add the following code:

#include <rogue.h>

Room createRoom(int y, int x, int height, int width)
{
  Room newRoom;

  newRoom.pos.y = y;
  newRoom.pos.x = x;
  newRoom.height = height;
  newRoom.width = width;
  newRoom.center.y = y + (int)(height / 2);
  newRoom.center.x = x + (int)(width / 2);

  return newRoom;
}

void addRoomToMap(Room room)
{
  for (int y = room.pos.y; y < room.pos.y + room.height; y++)
  {
    for (int x = room.pos.x; x < room.pos.x + room.width; x++)
    {
      map[y][x].ch = '.';
      map[y][x].walkable = true;
    }
  }
}

The function createRoom() takes the y and x coordinates to assign to the room's pos member and also its height and width. It calculates the room's center variable from a simple calculation with the parameters given. When we divide the height and width by 2 to get the center point of the room we are casting the result of that division to an int type, so that we can add it to either y or x and get an int variable to represent the coordinates of our center variable, otherwise, the division would give us a float number. After newRoom is properly created, we return it to the calling function.

In addRoomToMap() we are looping through the space of the room and setting the corresponding tiles in our map array to be floors. The start position for the loop will be the pos variable's y and x members and for the loop condition we add each of these to the room's height and width respectively to get a loop through the dimensions of the room. Notice that at the moment, we could call this function with parameters that create a room with dimensions that exceed or are entirely outside of the space of our map array. If we do that, the function will try to iterate through indices which do not exist in our map array and this will cause our game to crash. Later on we'll add a check to avoid this behaviour, but for now, we'll have to be mindful of the parameters we pass the function.

Let's add these functions to our rogue.h file:

...
// player.c functions
...
+
+// room.c functions
+Room createRoom(int y, int x, int height, int width);
+void addRoomToMap(Room room);

// externs
...

Now we'll try using these functions with the rand() function in order to get random parameters and have different rooms every time we start the game.

Randomization

The rand() function is defined in the stdlib.h header file, which we already have included. It takes no arguments and returns an int ranging from 0 to RAND_MAX, which is a predefined constant that is at least 32767. In order to get the random numbers we want we'll use the modulus operand % to get the remainder from dividing the number returned by rand(). For example, if we wanted to get random numbers between 0 and 9, we would write rand() % 10. If we wanted a number from 5 to 9, we would have to add a minimum so that the smallest number returned from rand() would be 5 instead of 0, and then we would need to reduce the divisor in order to avoid overshooting and getting numbers from 5 to 14. The modified code would look like (rand() % 5) + 5.

One issue with the rand() function is that it is merely a pseudo-random generator, which means that it is in fact deterministic and it will always return the same sequence of numbers unless we provide a different 'seed' number every time we start the game. To provide the 'seed' number we use the srand() function, to which we will pass the result of the time() function. The time() function is defined in the time.h header file.

First let's add the time.h header file to our rogue.h:

#ifndef ROGUE_H
#define ROGUE_H

#include <ncurses.h>
#include <stdlib.h>
+#include <time.h>

typedef struct
...

We only need to use the srand() function to seed the generator once, so we will place our function call at the beginning of our main function. Add the following to main.c:

...
int main(void)
{
  Position start_pos;

  cursesSetup();
+  srand(time(NULL));

  map = createMapTiles();
...

Now we're ready to use rand() to generate random rooms. Open the map.c file and modify the setupMap() function to look like the following:

#include <rogue.h>

Tile** createMapTiles(void)
{
...
}

Position setupMap(void)
{
  int y, x, height, width, n_rooms;
  n_rooms =  (rand() % 11) + 5;
  Room* rooms = calloc(n_rooms, sizeof(Room));
  Position start_pos;

  for (int i = 0; i < n_rooms; i++)
  {
    y = (rand() % (MAP_HEIGHT - 10)) + 1;
    x = (rand() % (MAP_WIDTH - 20)) + 1;
    height = (rand() % 7) + 3;
    width = (rand() % 15) + 5;
    rooms[i] = createRoom(y, x, height, width);
    addRoomToMap(rooms[i]);
  }

  start_pos.y = rooms[0].center.y;
  start_pos.x = rooms[0].center.x;

  free(rooms);

  return start_pos;
}

void freeMap(void)
{
...
}

Let's take a look at what we're doing here.

  int y, x, height, width, n_rooms;
  n_rooms =  (rand() % 11) + 5;
  Room* rooms = calloc(n_rooms, sizeof(Room));
  Position start_pos;

First we declare a few int variables we'll need. y, x, height and width will be reassigned throughout the loop to hold the parameters of each room we create. n_rooms is assigned a random number between 5 and 15 in the next line of code. Then we use that number to define a one-dimensional array of Rooms called rooms. And finally we declare the start_pos that we will use at the end to return an appropriate starting location for the player.

With respect to the rooms array, we could choose to change the definition to be a variable-length-array, using something like:

Room rooms[n_rooms];

This would save us the use of calloc() and also the use of free() for this array. However, this form of variable-length-arrays is implementation dependent and doesn't necessarily work on all compilers. Therefore, I think it's better if we choose to use dynamic allocation of memory to create this array, so that the code is portable across different C compiler implementations.

After those four lines of setup, we have the for loop:

  for (int i = 0; i < n_rooms; i++)
  {
    y = (rand() % (MAP_HEIGHT - 10)) + 1;
    x = (rand() % (MAP_WIDTH - 20)) + 1;
    height = (rand() % 7) + 3;
    width = (rand() % 15) + 5;
    rooms[i] = createRoom(y, x, height, width);
    addRoomToMap(rooms[i]);
  }

The first two lines of the loop define the y and x of the upper-left corner of our room. The y will be an int between 1 and 15 and the x will be an int between 1 and 80. We're not using the entire dimensions of the map so that we don't get a position that is close to the edges of the map, otherwise the room would overflow from our map once we add the height and width.

The next two lines define the height to be a random number between 3 and 9 and the width to be between 5 and 19. These dimension will allow our rooms to stay within the parameters of our map.

Attention
Keep in mind that if you changed the parameters of the MAP_HEIGHT or MAP_WIDTH to your liking, you need to also modify the parameters we are using to create our rooms so that they are within the dimensions of the map. Otherwise, the game will crash when it tries to allocate a room outside of the map.

The next line calls the createRoom() function with the parameters we've randomly determined and assigns the return value to the appropriate location of the rooms array. And finally we call the addRoomToMap() function with the same index of the array as we've just created.

After the for loop we assign the values of the center of the first room in the array to our start_pos variable. Since this is the last thing we needed to use the array for, we free the rooms array. Finally we return the start_pos so that the calling function can position the player in the center of the first room created.

Try to compile the game now. You should get something like this:

As you can see, the rooms frequently overlap each other, generating rooms of different sizes rather than just simple rectangles. I personally find this result to be more appealing as it generates more organic-looking spaces, while also having the advantage of being simpler to code. If you were looking for something like the classic 'Rogue' where each room is distinctly separate from the rest, you can try implementing a check for each room to verify whether it overlaps with other rooms and then skip the creation of that room. Since skipping a room would leave empty index spaces in our rooms array, you would need to use a separate counter to keep track of how many rooms you've added to the array. A possible solution for that would look like this (DON'T ADD THE FOLLOWING CODE IF YOU WANT TO FOLLOW ALONG WITH THE TUTORIAL, THIS IS JUST A SUGGESTION IN CASE YOU WANT TO AVOID OVERLAPPING ROOMS IN YOUR GAME):

Position setupMap(void)
{
  int y, x, height, width, n_rooms;
  n_rooms =  (rand() % 11) + 5;
  Room* rooms = calloc(n_rooms, sizeof(Room));
  Position start_pos;

  int rooms_counter = 0;

  for (int i = 0; i < n_rooms; i++)
  {
    y = (rand() % (MAP_HEIGHT - 10)) + 1;
    x = (rand() % (MAP_WIDTH - 20)) + 1;
    height = (rand() % 7) + 3;
    width = (rand() % 15) + 5;

    if (!roomOverlaps(rooms, rooms_counter, y, x, height, width))
    {
      rooms[rooms_counter] = createRoom(y, x, height, width);
      addRoomToMap(rooms[rooms_counter]);
      rooms_counter++;
    }
  }

  start_pos.y = rooms[0].center.y;
  start_pos.x = rooms[0].center.x;

  free(rooms);

  return start_pos;
}

bool roomOverlaps(Room* rooms, int rooms_counter, int y, int x, int height, int width)
{
  for (int i = 0; i < rooms_counter; i++)
  {
    if (x >= rooms[i].pos.x + rooms[i].width || rooms[i].pos.x >= x + width)
    {
      continue;
    }
    if (y + height <= rooms[i].pos.y || rooms[i].pos.y + rooms[i].height <= y)
    {
      continue;
    }

    return true;
  }

  return false;
}

We will continue without these changes for this tutorial, so if you decide to add this anti-overlap logic to your code you will have to change a few things of what I present in the tutorial.

Connecting Rooms

Even though sometimes our rooms overlap and connect, we still get many rooms that appear disconnected from where the player is located. Let's create a function that will generate hallways between the centers of two rooms. Open our room.c file and append the following function at the bottom:

...
void drawRoom(Room* room)
{
...
}

void connectRoomCenters(Position centerOne, Position centerTwo)
{ 
  Position temp;
  temp.x = centerOne.x;
  temp.y = centerOne.y;

  while (true)
  { 
    if (abs((temp.x - 1) - centerTwo.x) < abs(temp.x - centerTwo.x))
      temp.x--;
    else if (abs((temp.x + 1) - centerTwo.x) < abs(temp.x - centerTwo.x))
      temp.x++;
    else if (abs((temp.y + 1) - centerTwo.y) < abs(temp.y - centerTwo.y))
      temp.y++;
    else if (abs((temp.y - 1) - centerTwo.y) < abs(temp.y - centerTwo.y))
      temp.y--;
    else
      break;

    map[temp.y][temp.x].ch = '.';
    map[temp.y][temp.x].walkable = true;
  }
}

Let's take a look at what this function does. connectRoomCenters() takes two Position arguments which will be the centers of the two rooms we want to connect.

  Position temp;
  temp.x = centerOne.x;
  temp.y = centerOne.y;

This section will create a Position variable called temp which we will modify at each step and use to draw the hallways that connect our rooms. It starts in the same position as the center of the first room.

Then we open a while loop with its condition set to true. We will code a break statement into the loop in order to prevent an infinite loop.

Inside the while loop we have a series of if statements, each of which, if true, will modify either the x or the y of our temp variable by adding or subtracting one.

The first if statement,

  if (abs((temp.x - 1) - centerTwo.x) < abs(temp.x - centerTwo.x))

checks to see whether subtracting 1 to the x of our temp variable creates a position which is closer to our second room center. It does this by subtracting 1 from temp.x, getting the difference between this new x position and the x position of the second room, centerTwo.x and then comparing this number with the difference between the current temp.x and centerTwo.x, using the abs() function on both sides to get a positive integer since we are measuring distances. If the left side of the equation gives a smaller number than the right side, that means that by decreasing the x value of the first room's center, we are getting closer to the center of the second room. If that is the case, then the if statement condition is true and it runs

       temp.x--;

which will modify our temp variable. All the other if statements are then skipped and the code jumps directly to the last two lines of our while loop:

    map[temp.y][temp.x].ch = '.';
    map[temp.y][temp.x].walkable = true;

In this part we simply use the modified temp variable in order to access the appropriate tile in our map array and change that tile to become floor space. The while loop will then restart.

As long as decreasing the x value of the temp variable gets us closer to the second room, it will continue to decrease it and change the appropriate tiles to be floors. Eventually the condition will be false, and the other if statements will be tested.

The other if statements are analogous to the first one but they test whether increasing x, increasing y or decreasing y respectively will produce a position that is closer to the second room. The algorithm will continue to make modifications to the temp variable in a way that reduces the distance between it and the center of the second room.

Eventually temp will have the same y and x positions as the center of the second room. When that happens, no possible modification to either y or x will provide a position that is closer to the second room center than the position which is already represented by temp. In this case, all if conditions will fail and the last else clause will be executed closing the while loop with break.

Add the function to our rogue.h file:

// room.c functions
Room createRoom(int y, int x, int height, int width);
void addRoomToMap(Room room);
+void connectRoomCenters(Position centerOne, Position centerTwo);

// externs

Now we can use it in our map.c file. Modify the setupMap() function with the following lines:

Position setupMap(void)
{
  int y, x, height, width, n_rooms;
  n_rooms =  (rand() % 11) + 5;
  Room* rooms = calloc(n_rooms, sizeof(Room));
  Position start_pos;

  for (int i = 0; i < n_rooms; i++)
  {
    y = (rand() % (MAP_HEIGHT - 10)) + 1;
    x = (rand() % (MAP_WIDTH - 20)) + 1;
    height = (rand() % 7) + 3;
    width = (rand() % 15) + 5;
    rooms[i] = createRoom(y, x, height, width);
    addRoomToMap(rooms[i]);
+
+    if (i > 0)
+    {
+      connectRoomCenters(rooms[i-1].center, rooms[i].center);
+    }
  }

  start_pos.y = rooms[0].center.y;
  start_pos.x = rooms[0].center.x;

  free(rooms);

  return start_pos;
}

Here we are simply adding

    if (i > 0)
    {
      connectRoomCenters(rooms[i-1].center, rooms[i].center);
    }

to the room creation loop.

First we check if the i loop counter is greater than 0, so that the code inside the loop doesn't run for the first room created. When the i is greater than 0, we know that we have already created at least one other room and therefore we can access rooms[i-1] confidently, knowing that we are not going out of bounds of our rooms array.

The loop code simply calls the connectRoomCenters() function with the previously created room as the first argument and the current room as the second argument. By the end of the loop that creates rooms, all rooms will be connected to each other.

Now try compiling and verifying that all of your rooms are now reachable through hallways.

And that's all we had to do in order to get a randomly generated dungeon! Hope to see you in the next part of this tutorial, where we'll be looking into generating a field of view, in order to add a little darkness and mystery to our dungeon.

You can check out the full code for this part of the tutorial here!

The C Roguelike Tutorial - Part 2: The Map

Ignacio Oyarzabal — Wed, 11 Aug 2021 07:39:39 +0000

In this part of the tutorial we will set up the tile system we will use for the map, set all of the tiles in our map to be walls, and then start carving a room for our player to move around in. Before we get into defining our map tiles, let's take some time to refactor our main.c code to separate the setup code and the game loop code into their own functions.

Create a new file in src/ called engine.c and add the following code into it:

#include <rogue.h>

void cursesSetup(void)
{ 
  initscr();
  noecho();
  curs_set(0);
}

void gameLoop(void)
{ 
  int ch;

  mvaddch(player->pos.y, player->pos.x, player->ch);

  while(ch = getch())
  { 
    if (ch == 'q')
    { 
      break;
    } 

    handleInput(ch);
    clear();
    mvaddch(player->pos.y, player->pos.x, player->ch);
  } 
}

This is the same as the setup and loop code found in main.c but separated into individual functions.

In Part 1 we used the calloc() function to dynamically assign memory needed for our Entity* player variable. Whenever you dynamically assign memory to pointers in this way, it is good practice to free this memory when you don't need it anymore, since C does not do this automatically. We can use the free() function defined in the stdlib.h header file to do so. Since the player pointer should be freed when the game closes, let's take this opportunity to make a function we can run to process all the code needed at the end of the program.

Still on engine.c, append the following code beneath the gameLoop() function:

...

void closeGame(void)
{ 
  endwin();
  free(player);
}

The free() function takes a pointer argument and releases the memory allocated to it so that the program can reuse that memory later. If you continuously allocate memory for pointers and you don't free them when no longer in use, your program will incur memory leaks which can eventually lead your program to terminate unexpectedly due to a lack of available memory. You can read more about free() here.

Before we can use these functions in our main.c, we need to add their declarations in our rogue.h file, like so:

...
} Entity;
+
+//engine.c functions
+void cursesSetup(void);
+void gameLoop(void);
+void closeGame(void);

// player.c functions
...

Now we can use these functions in our main.c to simplify it. By removing all the now duplicate code and replacing it with the appropriate calls main.c now looks like this:

#include <rogue.h>

Entity* player;

int main(void)
{
  cursesSetup();

  Position start_pos = { 10, 20 };
  player = createPlayer(start_pos);

  gameLoop();

  closeGame();

  return 0;
}

That looks a lot nicer! Compile the game again to verify that it works the same as before. Now we're ready to start defining our map tiles.

The Tile Struct

Tile structs will contain the information of each individual map tile. These tiles will represent our floors, walls and staircases. Open your rogue.h file and add the following struct definition in between your Position and Entity structs:

...
} Position;

typedef struct
{
  char ch;
  bool walkable;
} Tile;

typedef struct
...

For now our Tile structs will only have a ch member to represent how to draw them and a walkable member to allow the player to walk on floors but not through walls. We'll add a few more features later on in the tutorial. We don't give our Tile structs a Position member because we are going to use them in a 2-d array which will intuitively manage the positions of our tiles through its indices.

In order to create our 2-d map array we should define the dimensions of our map with two constants. Add the following to our main.c file:

#include <rogue.h>
+
+const int MAP_HEIGHT = 25;
+const int MAP_WIDTH = 100;

Entity* player;
...

And now add these constants as externs in rogue.h:

...
// externs
+extern const int MAP_HEIGHT;
+extern const int MAP_WIDTH;
extern Entity* player;
...

We also want to add an extern for an array of tiles we'll use to draw our map:

...
// externs
extern const int MAP_HEIGHT;
extern const int MAP_WIDTH;
extern Entity* player;
+extern Tile** map;
...

And of course, let's add this variable to main.c as well:

...
Entity* player;
+Tile** map;

int main(void)
...

The map variable is a pointer to pointers to Tile structs. In other words, the first pointer will point to an array of pointers, each of which will point to an array of tiles. In this way, we get a two dimensional array of tiles which we will be able to use with the notation map[y][x] to access the individual tiles. We'll need a function that allocates the memory for all the rows of tiles. Create a new file in src/ called map.c and add the following code to it:

#include <rogue.h>

Tile** createMapTiles(void)
{ 
  Tile** tiles = calloc(MAP_HEIGHT, sizeof(Tile*));

  for (int y = 0; y < MAP_HEIGHT; y++)
  { 
    tiles[y] = calloc(MAP_WIDTH, sizeof(Tile));
    for (int x = 0; x < MAP_WIDTH; x++)
    { 
      tiles[y][x].ch = '#';
      tiles[y][x].walkable = false;
    }
  } 

  return tiles;
} 

void freeMap(void)
{ 
  for (int y = 0; y < MAP_HEIGHT; y++)
  { 
    free(map[y]);
  } 
  free(map);
}

Let's go over these two functions. createMapTiles() takes no arguments and returns a two dimensional array in the form of a pointer to pointers to Tiles.

  Tile** tiles = calloc(MAP_HEIGHT, sizeof(Tile*));

Here we declare the variable called tiles, named like that to avoid confusion with the global variable map, and then allocate memory for an amount of Tile* (pointers to Tile) equal to MAP_HEIGHT. In other words, we allocate as many pointers to Tile as the length of our map's y axis.

  for (int y = 0; y < MAP_HEIGHT; y++)
  { 
    tiles[y] = calloc(MAP_WIDTH, sizeof(Tile));

With this for loop we iterate through all of the pointers we have just allocated, and we allocate for each of them an amount of Tiles equal to MAP_WIDTH. In this way, each pointer to Tile in our y axis now points to an array of tiles of the same length as our x axis.

    for (int x = 0; x < MAP_WIDTH; x++)
    { 
      tiles[y][x].ch = '#';
      tiles[y][x].walkable = false;
    }

And finally we loop through the newly allocated x axis and access each of our tiles in order to initialize their member variables. We are using '#' to represent our walls and setting walkable to false in order to keep the player from moving through walls. We will soon have to code some movement logic that uses this boolean.

At the end of this function we simply return the tiles pointer, which is now a map filled entirely with walls.

The freeMap() function is a simple cleanup function that iterates throught the array of pointers in order to free each row of tiles before finally freeing the map pointer itself.

Again, we need to add these functions to rogue.h:

...
void closeGame(void);
+
+//map.c functions
+Tile** createMapTiles(void);
+void freeMap(void);

// player.c functions
...

Let's use createMapTiles() in our main.c file to initialize the map variable:

...
  player = createPlayer(start_pos);
+  map = createMapTiles();

  gameLoop();
...

Now we need a way to draw the map and the player every turn. Let's create a new file called draw.c to keep all of our drawing logic. Add the following code to it:

#include <rogue.h>

void drawMap(void)
{ 
  for (int y = 0; y < MAP_HEIGHT; y++)
  { 
    for (int x = 0; x < MAP_WIDTH; x++)
    { 
      mvaddch(y, x, map[y][x].ch);
    } 
  } 
} 

void drawEntity(Entity* entity)
{ 
  mvaddch(entity->pos.y, entity->pos.x, entity->ch);
} 

void drawEverything(void)
{
  clear();
  drawMap();
  drawEntity(player);
}

These functions are fairly self-explanatory. drawMap() iterates through the map array and adds the ch symbol to the screen, drawEntity() is just a generic function to simplify drawing any entity on the screen, and drawEverything() simply runs all of the drawing steps needed to fully render the scene.

Add these functions to our rogue.h file:

...
} Entity;
+
+//draw.c functions
+void drawMap(void);
+void drawEntity(Entity* entity);
+void drawEverything(void);

//engine.c functions
...

Now we can replace our draw step in the gameLoop() function with drawEverything(). Open engine.c and make the following changes:

void gameLoop(void)
{ 
  int ch;
+
+  drawEverything();
-  mvaddch(player->pos.y, player->pos.x, player->ch);

  while(ch = getch())
  { 
    if (ch == 'q')
    { 
      break;
    } 

    handleInput(ch);
+    drawEverything();
-    clear();
-    mvaddch(player->pos.y, player->pos.x, player->ch);
  } 
}

Try compiling your file now. You should now see the screen is filled with # through out the dimensions specified in our MAP_HEIGHT and MAP_WIDTH. You may need to enlarge your terminal in order to see the entire rectangle.

The issue we have now is that the player is just flying over the walls. We need to add the logic to check whether we're moving into a wall or not. Open our player.c file and make the following changes to the handleInput() function:

void handleInput(int input)
{
+
+  Position newPos = { player->pos.y, player->pos.x };
+
  switch(input)
  {
    //move up
    case 'k':
-      player->pos.y--;
+      newPos.y--;
      break;
    //move down
    case 'j':
-      player->pos.y++;
+      newPos.y++;
      break;
    //move left
    case 'h':
-      player->pos.x--;
+      newPos.x--;
      break;
    //move right
    case 'l':
-      player->pos.x++;
+      newPos.x++;
      break;
    default:
      break;
  }
+  
+  movePlayer(newPos);
}

And now add a new function called movePlayer() below the handleInput() function:

...
void handleInput(int input)
{
...
}

void movePlayer(Position newPos)
{ 
  if (map[newPos.y][newPos.x].walkable)
  {
    player->pos.y = newPos.y;
    player->pos.x = newPos.x;
  }
}

We've changed handleInput() to create a newPos variable which will start off the same as the player's current position, and then it will be modified according to the user's input. Whether newPos is modified or not, it will then be passed to the function movePlayer(), which will take care of actually determining whether the player can actually move to the location required by the user's input. We do this by simply checking for the boolean value of map[newPos.y][newPos.x].walkable. If it's true, then we change the player's position to be the same as newPos.

Add the new function to rogue.h:

// player.c functions
Entity* createPlayer(Position start_pos);
void handleInput(int input);
+void movePlayer(Position newPos);

And that's all we have to do to get the logic working. Try the game out now. The player should not be able to move through walls. The problem of course is that the player can't move at all because we didn't create any floor space in our dungeon.

Add the following function in our map.c file in between the createMapTiles() and the freeMap() function:

...
  return tiles;
}

Position setupMap(void)
{
  Position start_pos = { 10, 50 };

  for (int y = 5; y < 15; y++)
  {
    for (int x = 40; x < 60; x++)
    {
      map[y][x].ch = '.';
      map[y][x].walkable = true;
    }
  }

  return start_pos;
}

void freeMap(void)
{
...

In this function we are simply hard coding a double for loop to iterate through a 10x20 sized section of our map matrix and replacing that space with floors. We represent the floors with the . character and assign true to their walkable member. We are also hard coding a starting position which we will pass to the calling function so that they can use that to place the player in an appropriate location. In the next part of this tutorial we will be generating the rooms and the player starting position randomly.

Add this function to our rogue.h:

//map.c functions
Tile** createMapTiles(void);
+Position setupMap(void);
void freeMap(void);

Now open main.c and make the following modifications:

int main(void)
{
+
+  Position start_pos;
+
  cursesSetup();
-
-  Position start_pos = { 10, 20 };
-  player = createPlayer(start_pos);
  map = createMapTiles();
+  start_pos = setupMap();
+  player = createPlayer(start_pos);

  gameLoop();

  closeGame();

  return 0;
}

Compile and run the game now. You should be able to move the player around a square of dots, but he'll stop at the walls. Perfect! Now we're ready to move on to the next part, where we'll look into procedurally generating our dungeon.

You can take a look at the entire source code for Part 2 here.

The C Roguelike Tutorial - Part 1: The Player

Ignacio Oyarzabal — Thu, 05 Aug 2021 06:14:36 +0000

In this part we will be drawing the player character onto the screen and moving him around. If you haven't set up your environment with GCC and Ncurses yet, go check out the setup instructions at Part 0: The Setup.

Getting Started

Let's first create a src folder inside our game folder to keep all of our .c files. Place your main.c file in that folder and replace the code in it to be the following:

#include <ncurses.h> // replace 'ncurses.h' with 'curses.h' if using Windows

int main(void)
{
  initscr();
  noecho();
  curs_set(0);


  while(getch() != 'q')
  {
    mvaddch(10, 20, '@');
  }

  endwin();

  return 0;
}

The first function we call, initscr() starts up the ncurses system and allows us to call all the other functions on our terminal. noecho() will prevent ncurses from immediately drawing on the screen when we press any keys, try commenting it out to see what happens. And finally curs_set(0) will make our cursor invisible, otherwise we would see the flashing cursor on our screen, which is not part of our game.

After this setup of ncurses we can actually start using it to draw on the screen. getch() is a function that takes a single character input from your keyboard and returns that character to the calling function. In this case, we are running a while loop that will constantly ask the user for an input and will keep printing the @ symbol until the user presses the q key, at which time the while loop will exit and our program will end.

The function mvaddch(10, 20, '@'); is a function which takes three parameters, a y index, an x index and a character to print to screen at the (y, x) coordinates. Notice how ncurses uses coordinates with the y axis first and the x axis second. This is consistent across all ncurses functions. mvaddch() function just moves the cursor to the indicated position, then adds the given character to where the cursor is.

To get out of the loop just press the q key. After the while loop we run endwin() which is the ncurses function that closes ncurses in our terminal, this will always be the last function we run before closing our program.

Automating Compilation

Before trying out this program, let's simplify our compilation task, which we will be repeating many times, by creating a makefile. Create a new file in your top level game folder (outside of src) called makefile and add the following code to it:

In Linux

CC = gcc
CFLAGS = -lncurses
SOURCES = ./src/*.c

all: rogue run clean

rogue: 
        $(CC) $(SOURCES) $(CFLAGS) -o rogue

run:
        ./rogue

clean:
        rm rogue

Now all you need to do in order to compile and run the program is type the following command:

$ make

This will first run the section titled rogue, which will be the same as gcc ./src/*.c -lncurses -o rogue after replacing all the variables. If it manages to compile correctly and without errors, it will then proceed to run the section titled run, running the compiled program. If the program itself finishes without an error, the makefile will run the clean section, removing the compiled program so that next time you run make you get a fresh compilation.

In Windows

You can try to install make in Windows to have the above makefile work for you, but I have not been able to try that out. The solution I can offer is to write a simple .bat file with the following code which will allow you to automate compilation in a similar manner:

gcc .\src\*.c -lpdcurses -o -rogue
rogue.exe
Del rogue.exe

Attention!

If you don't remove the compiled file, next time you run make, it will see that there is already a compiled version and will skip the compilation phase altogether, even if you've made changes to the source files. This is especially prone to happen whenever you get bugs in your code which make your program crash during runtime. Since the makefile will stop for any errors, the bugged compilation will not be removed. If you forget to delete the file and start debugging and running make again, it will simply run the old compilation again and you won't actually be seeing the modifications you've made to your source code.

Try running the program with either your makefile or your .bat file and see if it works properly.

Note: this game should be run directly on the Command Line or Command Prompt as Ncurses is a library meant to create programs for terminals.

Right now it simply draws an @ sign on the screen. Not much, but that's our main character. The @ sign is traditionally used in ASCII-based roguelikes to represent the player avatar.

Now let's try getting it to move.

Movement

To start moving around we'll need some way to change the player's y and x position. In order to give the player a (y, x) position let's create some structs. First, go ahead and create a new directory called include in your base directory and add a file into that folder called rogue.h. You should now have a directory tree as follows:

tutorial_folder/
    -include/
        -rogue.h
    -src/
        -main.c
    -makefile

From now on, all of our .c files will go into src/ and all of our .h files will go into include/.

Add the following code into rogue.h:

#ifndef ROGUE_H
#define ROGUE_H

#include <ncurses.h>
#include <stdlib.h>

typedef struct
{
  int y;
  int x;
} Position;

typedef struct
{
  Position pos;
  char ch;
} Entity;

#endif

Here we're creating two simple structs, one called Position which contains (y, x) coordinates in the form of two int variables, and another called Entity which for now will only contain a Position variable and a char variable where we will keep how the player is represented on the screen. We include <stdlib.h> because we will be using a function that is defined in it. We also added #include <ncurses.h> at the top because we're going to include this file in main.c and we'll just keep all of our includes in our .h files.

The first two statements and the last line,

#ifndef ROGUE_H
#define ROGUE_H

...

#endif

are used to keep the compiler from compiling the rogue.h file multiple times. Since we will include it in several different .c files, we have the compiler check if the variable ROGUE_H has been previously defined and, if not, define ROGUE_H and proceed with compiling the rest of the file. In this way, rogue.h will only get compiled the first time it is included, after which, it will simply detect that ROGUE_H has already been defined and skip the rest of the file.

Now to include our rogue.h file change the following code in main.c:

-#include <ncurses.h>
+#include <rogue.h>

Now that we've connected main.c with rogue.h let's create another file in which we will make a function that creates our player using the structs and another that takes an input and modifies the player position. Create a new file in src called player.c and add the following:

#include <rogue.h>


Entity* createPlayer(Position start_pos)
{
  Entity* newPlayer = calloc(1, sizeof(Entity));

  newPlayer->pos.y = start_pos.y;
  newPlayer->pos.x = start_pos.x;
  newPlayer->ch = '@';

  return newPlayer;
}

void handleInput(int input)
{
  switch(input)
  {
    //move up
    case 'k':
      player->pos.y--;
      break;
    //move down
    case 'j':
      player->pos.y++;
      break;
    //move left
    case 'h':
      player->pos.x--;
      break;
    //move right
    case 'l':
      player->pos.x++;
      break;
    default:
      break;
  }
}

We include rogue.h because we're using both structs defined in that file. The first function Entity* createPlayer(Position start_pos) takes a Position argument and returns a pointer to an Entity. We create the player as a pointer to Entity in order to be able to modify his component variables in function calls. We will use pointers extensively in this tutorial.
Entity* newPlayer = calloc(1, sizeof(Entity)); declares the newPlayer variable and dynamically allocates the appropriate memory for that pointer. We are using calloc() in this tutorial instead of its counterpart malloc() beacause calloc not only allocates the memory, it also initializes all of the bytes in that memory block to 0, erasing any garbage data which might have been stored previously and allowing us to use the memory safely. You can find more information about the calloc() function here. calloc() is defined in stdlib.h which we've already included in rogue.h.

After allocating the memory we assign the appropriate values to the newPlayer position and character. Note that when using pointers to structs you need to use -> in order to reference its member variables. If it is just a struct variable, like the Position struct inside of the Entity struct, then you just use . in order to reference its member variables. That is why we use newPlayer->pos.y: newPlayer is a pointer so we use -> to access its pos member, and since pos is not a pointer but a struct variable, we simply use . to access its y and x members.

After setting up the player, we return the newPlayer pointer to the calling function.

void handleInput(int input) is a simple function where we use a switch() statement in order to increase or decrease the y or x variable of the player's position depending on the input provided. Here we are using a pointer variable called player which we will declare as an extern in our rogue.h file below. I used the vim-like hjkl keyset because it's the classic retro style, but you can change it to use the standard wasd keys or any other keyset you prefer.

Open rogue.h and append the following code before the #endif line:

// player.c functions
Entity* createPlayer(Position start_pos);
void handleInput(int input);

// externs
extern Entity* player;

#endif

Here we are simply adding the declarations of the functions we defined in player.c. This is so any file which includes rogue.h can use these functions properly. We also add an extern Entity* player; variable which we will declare in our main.c file. We will add several externs throughout the tutorial whenever we want to create a variable that is shared between any files that include rogue.h.

Open main.c and make the following changes:

#include <rogue.h>
+ 
+Entity* player;
+
int main(void)
{
+  int ch;
+  Position start_pos = { 10, 20 };
+
  initscr();
  noecho();
  curs_set(0);
+ 
+  player = createPlayer(start_pos);
+  mvaddch(player->pos.y, player->pos.x, player->ch);
+ 
-  while(getch() != 'q')
+  while(ch = getch())
  {
-    mvaddch(10, 20, '@');
+    if (ch == 'q')
+    {
+      break;
+    }
+
+      handleInput(ch);
+      clear();
+      mvaddch(player->pos.y, player->pos.x, player->ch);
  }

  endwin();

Your main.c file should now look like this:

#include <rogue.h>

Entity* player;

int main(void)
{
  int ch;
  Position start_pos = { 10, 20 };

  initscr();
  noecho();
  curs_set(0);

  player = createPlayer(start_pos);
  mvaddch(player->pos.y, player->pos.x, player->ch);

  while(ch = getch())
  {
    if (ch == 'q')
    {
      break;
    }

    handleInput(ch);
    clear();
    mvaddch(player->pos.y, player->pos.x, player->ch);
  }

  endwin();

  return 0;
}

Entity* player; declares a variable which we will use to point to our player object. We have already added it as an extern in our rogue.h file so that it can be used by functions outside of main.c without us having to pass the player object as an argument. This will help reduce our function signatures.

int ch; declares an int which we will use to store the input from the user and Position start_pos = { 10, 20 }; creates a Position struct which we use to give the createPlayer() function a starting position. We hard code it for now, but we will soon be getting that position depending on the randomized creation of the rooms in the dungeon.

player = createPlayer(start_pos); calls the createPlayer() function and assigns the returned Entity pointer to our player variable.

mvaddch(player->pos.y, player->pos.x, player->ch); uses the player struct's members to call mvaddch() and draw the player's character on the screen at his position. We call this once before the while loop to avoid just having an initial black screen before the user presses any keys.

while(ch = getch()) starts a while loop that waits for the user to press a key and assigns that key to our ch variable declared above.

if (ch == 'q')
    {
      break;
    }

This verifies if the key pressed is q and exits the while loop if it is.

If the input isn't a q then we proceed with the rest of the while loop, calling first handleInput(ch);, which will modify the player's position depending on the key. Then we use clear();, which is an ncurses function that erases the screen. And finally we call mvaddch(player->pos.y, player->pos.x, player->ch); again to draw the character at his new position. If we didn't use clear() before drawing the player on his new position, the old positions of the player would still be drawn and you would see a trail of previous @ symbols.

Before we try compiling it, we need to modify our makefile to compile our include file. Make the following changes to it:

-CFLAGS = -lncurses
+CFLAGS = -lncurses -I./include/

If you're using the windows batch file change the first line to the following:

gcc .\src\*.c -lpdcurses -I.\include\ -o -rogue

Try compiling it using the .bat file or with make:

$ make

You should be able to move your @ character around the screen by pressing the appropriate keys. Press q to exit. Congratulations, you now have a moving player!

That's the end of this part. We'll have Part 2 coming out soon.

The C Roguelike Tutorial - Part 0: The Setup

Ignacio Oyarzabal — Wed, 04 Aug 2021 09:29:31 +0000

Intro

This tutorial will teach you the basics of how to make a classic retro roguelike game entirely in C using the Ncurses library. By the end of the tutorial you will have built a simple ASCII roguelike that will feature procedurally generated dungeons, increasing enemy difficulty, leveling up, equipment, spells, and a final boss at level 10 to give you a sense of closure.

I was inspired to make this tutorial by the Coding a Rogue/Nethack RPG in C Youtube series, which is a great 26-video tutorial which taught me the basics of how to use Ncurses and gave me ideas to build a small roguelike in C. I even adapted some of the algorithms shown in that series for this tutorial. If you are more engaged by video tutorials, you should definitely check that one out, though keep in mind that it seems to be incomplete as the videos end when the author was starting to implement equipment. But if you prefer reading then stick around for my tutorial series where we are going to program a game with a lot more features.

Requirements

The tutorial assumes a basic knowledge of C or similar languages. If you've never programmed before you might be able to follow along with the code, but it will be difficult for you to actually understand what you're doing. If that is the case I would recommend choosing a book from The Definitive C Book Guide over at StackOverflow to read up on the basics of C programming. I will be explaining some of the logic and decisions behind the code presented, but I won't go into the very basics of coding in C.

In order to follow along with the code you will need to have a C compiler such as GCC(Linux) or MinGW(Windows), and the ncurses library. Let's take a brief look at those now.

C Compiler and Ncurses

- Linux

If you are working on a Linux machine chances are you already have GCC installed, which is the GNU Compiler Collection. Use the following command in your terminal to verify it:

$ gcc --version

If you get something like bash: gcc: command not found, you will have to install it yourself. If you are using Ubuntu or one of its derivatives the following commands will install GCC and a few other necessary programs:

$ sudo apt update
$ sudo apt install build-essential

After this, try again the first command to verify that you have gcc installed.

Now that gcc is installed, use the following command to install ncurses:

$ sudo apt install libncurses5-dev libncursesw5-dev

Now you should be setup with GCC and Ncurses. At the bottom of the chapter we'll go through a small program to verify that everything's working properly.

- Windows

Ncurses is a Unix/Linux-based library meant for use in unix-like terminals, but for Windows you can use the alternative PDcurses, which is the Public Domain curses port.

Windows doesn't come preinstalled with a C compiler so you will have to install your own. I suggest installing MinGW, which is the Windows port of GCC, as it has a simple installer that allows you to install the PDcurses library at the same time. The easiest way to do it is by downloading the MinGW installer from SourceForge.

Choose the default folder location for the installation. In the installation manager you will reach a step where you can choose which packages to install; mark the boxes on all of the options from the 'Basic Setup' tab, there should be seven of them. Then go to the 'All Packages' tab and mark all of the following for installation:

mingw32-libncurses (dll)
mingw32-libncurses (dev)
mingw32-libpdcurses (dll)
mingw32-libpdcurses (dev)

After these are selected go to 'Installation'-> 'Apply Changes' and click Apply to continue with the installation.

Once the installation is finished you need to add the path to MinGW\bin to your PATH environment variable. In the Windows start bar search for Edit environment variables for your account. Edit the PATH variable and click on 'New' to add a new path. If you installed it in the default location, the folder path should be C:\MinGW\bin.

You should now have MinGW installed in your system. To verify it, open the Windows Command Prompt and type:

$ gcc --version

- MacOS

Unfortunately I don't have a Mac system to try this on, so I can only provide what I've read online without personal validation of its effectiveness. From what I've read, you should be able to use Homebrew to install both GCC and Ncurses on Mac:

$ brew install gcc
$ brew install ncurses

Hope that works for you or at least gets you started. This is the only mention I will do in this tutorial about how to do things in MacOS. I think you can still follow along with most of what I do here since MacOS is a UNIX-family OS and its command line works fairly similar to the Linux command line.

Testing GCC and Ncurses

In order to verify that everything is working we'll make a short program to validate our setup. Create a folder where you want to start your project and open a new file in your editor of choice. Call the file main.c and put the following code in it:

#include <ncurses.h>

int main(void)
{
  initscr();
  endwin();

  return 0;
}

If you are using Windows, you will have to replace the first line to include the curses.h file instead of the ncurses.h file, like so:

-#include <ncurses.h>
+#include <curses.h>

This change and a similarly small replacement in our makefile will be the only differences in the code for Windows. Apart from this minor change in the include statement, everything else in the code will be the same on any machine.

I will explain initscr() and endwin() in the next part of this tutorial. For now, simply compile the file to verify that the compiler is able to include the header correctly.

On Linux

$ gcc main.c -lncurses

On Windows

$ gcc main.c -lpdcurses

If you do not get any error messages you should now have either an a.out file in Linux or an a.exe file in Windows. The -lncurses and -lpdcurses options used above ask the compiler to link the ncurses or the pdcurses libraries respectively. You can try running the program, which will close immediately after starting.

Other Resources

If you want to learn more about Ncurses you can click here or check out this Programming How-To If you ever need help with anything roguelike related you can go to the Roguelike Dev Subreddit which is a very welcoming community exclusively for roguelike developers!

Now you're all set to start coding! See you on Part 1!