Geisha Studios

This version of The Horde is turn based which means that in each turn the player and the hordlings can make a move. A move can either be an actual movement to an adjacent cell, building a fence, or buying a cow. The player is the only that can make the last two.

Based on the number of turns the player lasts against The Horde, the game sends in a new wave of hordlings or even increases the difficulty. To know the number of turns played, I need a new variable. Using an unsigned integer to make the number of turns practically unlimited.

            
<<main variables>>=
unsigned int current_turn;

          

When the game starts, this variable is set to zero: the first turn.

            
<<initialize level>>=
current_turn = 0;

          

For each game’s loop, I need to increment the turn counter by one.

            
<<update turn counter>>=
++current_turn;

          

As stated, the game’s objective is to reach a minimum of $2000 in gold.

            
<<constants>>=
#define GOLD_GOAL 2000

          

That means that the game must keep account of the current amount of gold. Given the defined upper limit of gold, using a short to store the amount is enough. I can’t use an unsigned because it is possible to reach a negative amount due to attacks from the hordlings, in which case the game ends and the player loses.

            
<<main variables>>=
short gold;

          

This amount needs to be zero at the beginning.

            
<<initialize level>>=
gold = 0;

          

The game reward the player with gold once every new season, which starts after an arbitrary number of turns. Through trial and error, I’ve defined the number of turns to start a season to be 150 that gives enough time to stop the current wave and prepare for the next.

            
<<constants>>=
#define SEASON_TURNS 150

          

Thus, when a new season starts the game counts how many cows still remain on the level and increment the amount of gold by $10 for each still alive.

            
<<constants>>=
#define COW_PROFIT 10

          

            
<<new season>>=
if (current_turn % SEASON_TURNS == 0) {
    for (y = 0 ; y < LEVEL_HEIGHT ; ++y) {
        for (x = 0 ; x < LEVEL_WIDTH ; ++x) {
            if (COW_CHAR == level[y][x]) {
                gold += COW_PROFIT;
            }
        }
    }

          

Notice how the first turn being zero forces to start a new season to start right at the beginning therefore allowing the player to start with some money to spend coming from the cows placed randomly. Unfortunately, for the player, it also means that the first wave of hordlings starts to attack immediately.

As with real life, spending or losing money can happen any time, not only at a new season’s start. The player can build a fence or buy a cow any turn. Also, when a hordling attacks a player instead of going after the cattle, the player loses some of the money. The game, thus, needs to check each turn if the player lost all her money. I also check if the player reached the goal at the same time, because either way the logic to quit the game is almost the same, and I want to avoid repetition.

            
<<check gold>>=
if (gold < 0 || gold >= GOLD_GOAL) {
    mvprintw(LEVEL_HEIGHT / 2, LEVEL_WIDTH + 1, (gold < 0) ? "LOSE" : "WIN");
    getch();
    quit = TRUE;
}

          

When the game is over, either because the player won or lost, I print out the outcome on the level’s right side and then way for a key before quiting the game.

Besides the position of all entities, the player needs to see other information such as the amount of gold remaining, to be know whether has the possibly to build a fence or buy a cow; and the current turn, to know when a new season starts.

I print the this extra status at the first row next the level.

            
<<draw level>>=
mvprintw(0, LEVEL_WIDTH + 1, "$%i T%i ", gold, SEASON_TURNS - (current_turn % SEASON_TURNS));

          

Instead of the actual current turn I print the number of turns remaining until the next season. With this is easier to know when a new season starts than with the actual turn number, which gives no extra information to the player.

The additional space written after the turn is there to erase any digit left over when the number of turns gets smaller and uses a digit less (i.e., it goes down from 100 to 99, and from 10 to 9.)

To move the player around the level, I am going to use the same keys as used by NetHack, which has two sets of keys.

The first set use the numeric pad, where 4, 2, 8, and 6 move the player to the adjacent cell west, south, north, or east respectively. 1, 3, 7, and 9 move the player diagonally.

The second is similar to the set used by vi to move the cursor around, with keys h, j, k, and l to move the character to the adjacent cell west, south, north, or east respectively. The y, u, b, and n keys move the player diagonally.

As the player moves around the screen, the game needs to check whether the player is going to step in a cell within the level’s limit, if is going to attack a hordling, and other similar cases. To avoid repeating all this checks throughout the code that received the input, I am going to have a pair of variables that tell the position the player should move given the input.

            
<<main variables>>=
int new_playerx;
int new_playery;

          

Thus, I need to set these variables based on the current player’s position as well as the character received from the keyboard. If the key is not a movement command, the new player’s position is set outside the level on purpose.

            
<<handle keyboard input>>=
new_playerx = -1; /* set outside the level to know whether the key was */
new_playery = -1; /* a movement command or any other command. */
switch (getch()) {
    /* west */
    case 'h':
    case '4':
        new_playerx = playerx - 1;
        new_playery = playery;
        break;

    /* south */
    case 'j':
    case '2':
        new_playerx = playerx;
        new_playery = playery + 1;
        break;

    /* north */
    case 'k':
    case '8':
        new_playerx = playerx;
        new_playery = playery - 1;
        break;

    /* east */
    case 'l':
    case '6':
        new_playerx = playerx + 1;
        new_playery = playery;
        break;

    /* north-west */
    case 'y':
    case '7':
        new_playerx = playerx - 1;
        new_playery = playery - 1;
        break;

    /* north-east */
    case 'u':
    case '9':
        new_playerx = playerx + 1;
        new_playery = playery - 1;
        break;

    /* south-west */
    case 'b':
    case '1':
        new_playerx = playerx - 1;
        new_playery = playery + 1;
        break;

    /* south-east */
    case 'n':
    case '3':
        new_playerx = playerx + 1;
        new_playery = playery + 1;
        break;

          

With these variables correctly set, I can now check whether the new position is within the level’s limits and if the cell in which the player is going to move is empty. If so, the movement is permitted.

            
<<update player position>>=
if (new_playerx > 0 && new_playerx < LEVEL_WIDTH - 1 &&
    new_playery > 0 && new_playery < LEVEL_HEIGHT - 1 ) {

    <<check collision with hordlings>>

    if (EMPTY_CHAR == level[new_playery][new_playerx]) {
        playerx = new_playerx;
        playery = new_playery;
    }

          

To buy a cow and place at the player’s position, the game needs to check whether there are enough gold to buy a new cow based on their cost.

            
<<constants>>=
#define COW_PRICE 20

          

It must also check if the player’s position is actually empty. Remember that the player could be on top of a cow or fence.

            
<<buy and place cow>>=
if (gold >= COW_PRICE && EMPTY_CHAR == level[playery][playerx]) {
    gold -= COW_PRICE;
    level[playery][playerx] = COW_CHAR;
}

          

To place a new cow the user must enter the c key. This sets a new cow character at the player’s position and also decrease the amount of gold.

            
<<handle keyboard input>>=
    case 'c':
        <<buy and place cow>>
        break;

          

The fences the player can put on can have different strength, from the weakest to the stronger. Both building a new fence and upgrading a fence to be stronger has the same cost of $1.

            
<<constants>>=
#define FENCE_COST 1

          

To make easier upgrading and downgrading the fences' strength, the different strengths have consecutive characters on screen. Thus, with simple increments and decrements I can change a fence’s strength. Therefore, the difference between a fence’s character and the weakest fence character is the fence’s strength.

            
<<constants>>=
#define FENCE_WEAKEST_CHAR 176
#define FENCE_STRONGEST_CHAR 180

          

The characters that I’ve selected for the fences are from the extended ASCII table, also known as code page 437. The intended output for these characters is only correct when running in a terminal set to this code page; all other configurations will show different characters for the fences. This is a known issue that won’t be fixed, because there is no characters in the regular ASCII set that looks as a fence to me, and using a suitable character for different configurations isn’t worth it.

Building a new fence, then, is a matter of placing the weakest fence on the position where the player is located at, if that position is empty and there is enough gold. This is done when the user presses the f key.

            
<<handle keyboard input>>=
    case 'f':
        if (gold >= FENCE_COST && EMPTY_CHAR == level[playery][playerx]) {
            gold -= FENCE_COST;
            level[playery][playerx] = FENCE_WEAKEST_CHAR;
        }
        break;

          

To upgrade an existing fence I have to come up with another way, because the player can’t pass over a fence, forcing the user to think better fence placement strategies. Instead, the I will upgrade the fences when the player tries to move to a cell already occupied by a fence. That is, instead of passing over she will upgrade the fence, if there is enough money and the fence is not at the strongest already. Remember how the different fences' strengths have consecutive values and thus a simple increment upgrades a fence.

            
<<update player position>>=
    else if (level[new_playery][new_playerx] >= FENCE_WEAKEST_CHAR &&
        level[new_playery][new_playerx] < FENCE_STRONGEST_CHAR &&
        gold >= FENCE_COST) {
        gold -= FENCE_COST;
        ++level[new_playery][new_playerx];
    }
}

          

At each turn, every hordling on the screen will move a step closer to its nearer cow. But first, the game needs to know which hordling to update by looping over the level and looking for hordlings in it. If there is no hordling to move, then we can continue with the turn.

            
<<update hordlings position>>=
while (TRUE) {
    int hordlingx = -1;
    int hordlingy = -1;
    <<other hordling position variables>>

    for (y = 0 ; y < LEVEL_HEIGHT ; ++y) {
        for (x = 0 ; x < LEVEL_WIDTH ; ++x) {
            if (level[y][x] >= HORDLING_WEAKEST_CHAR &&
                level[y][x] <= HORDLING_STRONGEST_CHAR) {
                hordlingx = x;
                hordlingy = y;
            }
        }
    }

    if (hordlingx < 0) {
        /* No more hordlings. */
        break;
    }

          

With the hordling position, I need to find the nearest cow to move toward. Also, if the player is nearer to the hordling than any cow, the hordling instead will move towards the player to steal a piece of gold. I do this by comparing the distance in the X and Y coordinates between each cow and the hordling, and the distance between the hordling and the player. Whichever is the shorter distance, becomes the hordling’s target.

            
<<other hordling position variables>>=
int distance;
int targetx;
int targety;

          

            
<<update hordlings position>>=
    /* find nearest cow, or use the player if nearer. */
    targetx = playerx;
    targety = playery;
    distance = abs(hordlingx - playerx) + abs(hordlingy - playery);
    for (y = 0 ; y < LEVEL_HEIGHT ; ++y) {
        for (x = 0 ; x < LEVEL_WIDTH ; ++x) {
            if (COW_CHAR == level[y][x]) {
                int new_distance = abs(hordlingx - x) + abs(hordlingy - y);
                if (new_distance < distance) {
                    targetx = x;
                    targety = y;
                    distance = new_distance;
                }
            }
        }
    }

          

Here I am using the abs function declared in math.h.

            
<<headers>>=
#include <math.h>

          

With the target’s position in the targetx and targety variables, now I can compute the new position for the hordling in order to move in. Like the player, the hordlings only can move a cell per turn.

            
<<other hordling position variables>>=
int new_hordlingx;
int new_hordlingy;

          

            
<<update hordlings position>>=
    new_hordlingx = hordlingx + (hordlingx == targetx ? 0 : (hordlingx < targetx ? 1 : -1));
    new_hordlingy = hordlingy + (hordlingy == targety ? 0 : (hordlingy < targety ? 1 : -1));

          

Before I can move the hordling I need to check whether there is any impediment on its way. For the case of a hordling, either a fence or the player.

When there is a fence in front of the hordling, the hordling will hit the fence and will weaken it. If the fence was of the weakest strength, then it will vanish.

            
<<update hordlings position>>=
    if (level[new_hordlingy][new_hordlingx] >= FENCE_WEAKEST_CHAR &&
        level[new_hordlingy][new_hordlingx] <= FENCE_STRONGEST_CHAR) {
        --level[new_hordlingy][new_hordlingx];
        if (level[new_hordlingy][new_hordlingx] < FENCE_WEAKEST_CHAR) {
            level[new_hordlingy][new_hordlingx] = EMPTY_CHAR;
        }

          

Otherwise, if the fence wasn’t crushed and it is still a bit stronger than just the bare bone fence, is the hordling who will also take a hit. Like the fence, if the hordling was of the lowest strength, it will perish.

            
<<update hordlings position>>=
        else if (level[new_hordlingy][new_hordlingx] > FENCE_WEAKEST_CHAR) {
           --level[hordlingy][hordlingx];
           if (level[hordlingy][hordlingx] < HORDLING_WEAKEST_CHAR) {
               level[hordlingy][hordlingx] = EMPTY_CHAR;
               /* next monster */
               continue;
           }
        }
    }

          

If instead of a fence, the hordling hits the player, it will steal a piece of gold from her. Remember that the player’s position is not in the level array but kept by two separate variables.

            
<<update hordlings position>>=
    else if (new_hordlingy == playery && new_hordlingx == playerx) {
        --gold;
    }

          

If it is not any of these cases, check whether the cell to move is either empty or has a cow. In both cases, the hordling moves to the new position. If the cell has a cow, then the hordling replaces — or eats — the cow as if it were an empty cell.

            
<<update hordlings position>>=
    else if (level[new_hordlingy][new_hordlingx] == EMPTY_CHAR ||
        level[new_hordlingy][new_hordlingx] == COW_CHAR) {
        level[new_hordlingy][new_hordlingx] = level[hordlingy][hordlingx];
        level[hordlingy][hordlingx] = EMPTY_CHAR;
        /* update the position. */
        hordlingx = new_hordlingx;
        hordlingy = new_hordlingy;
    }

          

Finally, to mark that the hordling has already moved and thus no need to update it again until the next turn, I’ll convert its character to lower case. Since the hordlings characters are all uppercase (from A to Z), converting it to lowercase the previous loop that looks for hordling will skip all already moved hordlings and stop when all of them have moved.

            
<<update hordlings position>>=
    level[hordlingy][hordlingx] = tolower(level[hordlingy][hordlingx]);
}

          

The tolower function is declared in the ctype.h header that I need to include.

            
<<headers>>=
#include <ctype.h>

          

After all the hordlings have moved, I must change all them back to uppercase to make them ready for the next turn. I’ll use the fact that only hordlings are lowercase letters to my advantage and use the islower function, also declared in the ctype.h header, to find the hordlings and the toupper function to convert them back to capitals.

            
<<update hordlings position>>=
for (y = 0 ; y < LEVEL_HEIGHT ; ++y) {
    for (x = 0 ; x < LEVEL_WIDTH ; ++x) {
        if (islower(level[y][x])) {
            level[y][x] = toupper(level[y][x]);
        }
    }
}

          

I am aware that all this looping around the level has a complexity of O(n²), but given the size of the grid (24x24 cells) this is hardly an issue. If the level was any bigger, a I would advise a different approach, such as keeping a list of hordlings and cows.

Killing hordlings is done in the same way as upgrading fences, and reciprocally how hordlings steal from the player: when the player is adjacent to a hordling and moves towards it, the hordling receives a hit and lowers its strength.

            
<<check collision with hordlings>>=
if (level[new_playery][new_playerx] >= HORDLING_WEAKEST_CHAR &&
    level[new_playery][new_playerx] <= HORDLING_STRONGEST_CHAR) {
    --level[new_playery][new_playerx];

          

If the hordling was of the weakest strength, then it dies and leaves its cell empty, in which case the player now can move in it. That is why checking for collision with hordlings is done before trying to actually update the player’s position.

            
<<check collision with hordlings>>=
    if (level[new_playery][new_playerx] < HORDLING_WEAKEST_CHAR) {
        level[new_playery][new_playerx] = EMPTY_CHAR;
    }
}