Contents

1. Introduction
2. The main loop
3. Locations
4. Objects
5. Inventory
6. Passages
7. Distance
8. North, east, south, west
9. Code generation
10. More attributes
11. Conditions
12. Open and close
13. The parser
14. Multiple nouns
15. Light and dark
16. Savegame
17. Test automation
18. Abbreviations
19. Conversations
20. Combat
21. Multi-player
22. Client-server
23. Database
24. Speech
25. JavaScript

How to program a text adventure in C

by Ruud Helderman <r.helderman@hccnet.nl>

Licensed under MIT License

8. North, east, south, west

Traditional text adventures use compass directions to navigate.

Basic map with compass directions

For example, on the map I drew in chapter 6, the player might want to enter go east to move from the field to the cave. We can implement this by giving passage intoCave the tag “east”. However, there are two problems that we need to solve first.

  1. We may still want to refer to the passage as “entrance” as well as “east”. But right now, an object can have one tag only.
  2. On a bigger map, with more locations and passages, the tag “east” will be defined many times. So far, tags were globally unique in our game; there were no duplicates. This will radically change.

These problems apply to other objects as well, not just passages. In our adventure, we have a silver coin and a gold coin. On the one hand, it would be silly not to accept get coin in a location where only one of the coins is present. On the other hand, it should be possible to use get silver coin instead in case both coins are present at the same location.

This immediately brings us to a third problem with our parser:

  1. A tag can only be a single word; “silver coin” would never be recognized.

All three problems will be solved in this chapter, starting with problem #1. It is resolved by giving each object a list of tags, instead of just a single tag.

Sample output
Welcome to Little Cave Adventure.
You are in an open field.
You see:
a silver coin
a burly guard
a cave entrance to the east
dense forest all around

--> get coin
You pick up a silver coin.

--> go west
You can't get much closer than this.

--> go east
OK.
You are in a little cave.
You see:
a gold coin
an exit to the west
solid rock all around

--> go west
OK.
You are in an open field.
You see:
a burly guard
a cave entrance to the east
dense forest all around

--> go entrance
OK.
You are in a little cave.
You see:
a gold coin
an exit to the west
solid rock all around

--> drop coin
You drop a silver coin.

--> get coin
Please be specific about which coin you mean.

--> get gold coin
You pick up a gold coin.

--> quit

Bye!
object.h
  1. typedef struct object {
  2. const char *description;
  3. const char **tags;
  4. struct object *location;
  5. struct object *destination;
  6. } OBJECT;
  8. extern OBJECT objs[];
  10. #define field (objs + 0)
  11. #define cave (objs + 1)
  12. #define silver (objs + 2)
  13. #define gold (objs + 3)
  14. #define guard (objs + 4)
  15. #define player (objs + 5)
  16. #define intoCave (objs + 6)
  17. #define exitCave (objs + 7)
  18. #define wallField (objs + 8)
  19. #define wallCave (objs + 9)
  21. #define endOfObjs (objs + 10)
object.c
  1. #include <stdio.h>
  2. #include "object.h"
  4. static const char *tags0[] = {"field", NULL};
  5. static const char *tags1[] = {"cave", NULL};
  6. static const char *tags2[] = {"silver", "coin", "silver coin", NULL};
  7. static const char *tags3[] = {"gold", "coin", "gold coin", NULL};
  8. static const char *tags4[] = {"guard", "burly guard", NULL};
  9. static const char *tags5[] = {"yourself", NULL};
  10. static const char *tags6[] = {"east", "entrance", NULL};
  11. static const char *tags7[] = {"west", "exit", NULL};
  12. static const char *tags8[] = {"west", "north", "south", "forest", NULL};
  13. static const char *tags9[] = {"east", "north", "south", "rock", NULL};
  15. OBJECT objs[] = {
  16. {"an open field" , tags0, NULL , NULL },
  17. {"a little cave" , tags1, NULL , NULL },
  18. {"a silver coin" , tags2, field, NULL },
  19. {"a gold coin" , tags3, cave , NULL },
  20. {"a burly guard" , tags4, field, NULL },
  21. {"yourself" , tags5, field, NULL },
  22. {"a cave entrance to the east", tags6, field, cave },
  23. {"an exit to the west" , tags7, cave , field },
  24. {"dense forest all around" , tags8, field, NULL },
  25. {"solid rock all around" , tags9, cave , NULL }
  26. };

Explanation:

Of course, for this change to take effect, we also need to adjust function objectHasTag in noun.c.

In the same module, we can also fix problem #2. Partially, this problem was already solved in the previous chapter. The distance check introduced there, already makes it less likely to find more than one matching object. A tag like ‘east’ would always match a passage originating from the current location, and never conflict with eastbound exits in other locations. But the possibility is still there; the silver and gold coin might end up in the same room. So how to choose between them, based on their mutual tag ‘coin’? The answer is, we cannot, and so we should not. So instead of randomly picking either object, we will let functions getVisible and getPossession inform the player he has to be more specific.

noun.h
  1. extern OBJECT *getVisible(const char *intention, const char *noun);
  2. extern OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun);
noun.c
  1. #include <stdbool.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include "object.h"
  5. #include "misc.h"
  7. static bool objectHasTag(OBJECT *obj, const char *noun)
  8. {
  9. if (noun != NULL && *noun != '\0')
  10. {
  11. const char **tag;
  12. for (tag = obj->tags; *tag != NULL; tag++)
  13. {
  14. if (strcmp(*tag, noun) == 0) return true;
  15. }
  16. }
  17. return false;
  18. }
  20. static OBJECT ambiguousNoun;
  22. static OBJECT *getObject(const char *noun, OBJECT *from, DISTANCE maxDistance)
  23. {
  24. OBJECT *obj, *res = NULL;
  25. for (obj = objs; obj < endOfObjs; obj++)
  26. {
  27. if (objectHasTag(obj, noun) && getDistance(from, obj) <= maxDistance)
  28. {
  29. res = res == NULL ? obj : &ambiguousNoun;
  30. }
  31. }
  32. return res;
  33. }
  35. OBJECT *getVisible(const char *intention, const char *noun)
  36. {
  37. OBJECT *obj = getObject(noun, player, distOverthere);
  38. if (obj == NULL)
  39. {
  40. if (getObject(noun, player, distNotHere) == NULL)
  41. {
  42. printf("I don't understand %s.\n", intention);
  43. }
  44. else
  45. {
  46. printf("You don't see any %s here.\n", noun);
  47. }
  48. }
  49. else if (obj == &ambiguousNoun)
  50. {
  51. printf("Please be specific about which %s you mean.\n", noun);
  52. obj = NULL;
  53. }
  54. return obj;
  55. }
  57. OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun)
  58. {
  59. OBJECT *obj = NULL;
  60. if (from == NULL)
  61. {
  62. printf("I don't understand who you want to %s.\n", verb);
  63. }
  64. else if ((obj = getObject(noun, from, distHeldContained)) == NULL)
  65. {
  66. if (getObject(noun, player, distNotHere) == NULL)
  67. {
  68. printf("I don't understand what you want to %s.\n", verb);
  69. }
  70. else if (from == player)
  71. {
  72. printf("You are not holding any %s.\n", noun);
  73. }
  74. else
  75. {
  76. printf("There appears to be no %s you can get from %s.\n",
  77. noun, from->description);
  78. }
  79. }
  80. else if (obj == &ambiguousNoun)
  81. {
  82. printf("Please be specific about which %s you want to %s.\n",
  83. noun, verb);
  84. obj = NULL;
  85. }
  86. else if (obj == from)
  87. {
  88. printf("You should not be doing that to %s.\n", obj->description);
  89. obj = NULL;
  90. }
  91. return obj;
  92. }

Explanation:

Problem #3 can be fixed by simply removing a single space character from function parseAndExecute (line 10 below). This solution is far from perfect (a double space between ‘silver’ and ‘coin’ is not accepted), but it will do until we make ourselves a better parser in chapter 13.

parsexec.c
  1. #include <stdbool.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include "location.h"
  5. #include "inventory.h"
  7. bool parseAndExecute(char *input)
  8. {
  9. char *verb = strtok(input, " \n");
  10. char *noun = strtok(NULL, "\n");
  11. if (verb != NULL)
  12. {
  13. if (strcmp(verb, "quit") == 0)
  14. {
  15. return false;
  16. }
  17. else if (strcmp(verb, "look") == 0)
  18. {
  19. executeLook(noun);
  20. }
  21. else if (strcmp(verb, "go") == 0)
  22. {
  23. executeGo(noun);
  24. }
  25. else if (strcmp(verb, "get") == 0)
  26. {
  27. executeGet(noun);
  28. }
  29. else if (strcmp(verb, "drop") == 0)
  30. {
  31. executeDrop(noun);
  32. }
  33. else if (strcmp(verb, "give") == 0)
  34. {
  35. executeGive(noun);
  36. }
  37. else if (strcmp(verb, "ask") == 0)
  38. {
  39. executeAsk(noun);
  40. }
  41. else if (strcmp(verb, "inventory") == 0)
  42. {
  43. executeInventory();
  44. }
  45. else
  46. {
  47. printf("I don't know how to '%s'.\n", verb);
  48. }
  49. }
  50. return true;
  51. }

Modules main.c, inventory.c, location.c, move.c and misc.c remain unchanged, you can see them in the previous chapters.

Now that the array of objects (object.c) starts to grow in multiple dimensions (in particular with the introduction of multiple tags), we need a way to make it more maintainable. We will do so in the next chapter.

⭳   Download source code 🌀   Run on Repl.it

Next chapter: 9. Code generation