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

12. Open and close

In the previous chapter, we used ‘condition’ functions to make objects disappear. But of course, there is a much simpler way to achieve the same: just clear the object’s location attribute!

The cave entrance was a typical example where condition functions work particularly well. This is because the entrance is affected by attributes in other objects (the guard and the silver coin); the functions make it possible to keep all the logic together.

Let’s take a more straightforward example. Suppose the cave has a door leading to a backroom. Just a simple doorway, which the player can open and close. Just like in the previous chapter, we will use two objects for the passage; one to represent the open door, and another for when it is closed.

- backroom description "a backroom" tags "backroom" details "The room is dusty and messy.\n" - openDoorToBackroom description "an open door to the south" tags "south", "door", "doorway" destination backroom details "The door is open.\n" textGo "You walk through the door into the backroom.\n" - closedDoorToBackroom description "a closed door to the south" tags "south", "door", "doorway" location cave prospect backroom details "The door is closed.\n" textGo "The door is closed.\n"

Naturally, the door should be accessible from the other side as well.

- openDoorToCave description "an open door to the north" tags "north", "door", "doorway" destination cave details "The door is open.\n" textGo "You walk through the door into the cave.\n" - closedDoorToCave description "a closed door to the north" tags "north", "door", "doorway" location backroom prospect cave details "The door is closed.\n" textGo "The door is closed.\n"

Notice I only gave the closed doorways a location; the open ones have none. So initially, the door is closed (hence the dashed arrows between cave and backroom in the generated map you see on the right). To open the door, all we have to do is swap the locations.

openDoorToBackroom->location = cave; closedDoorToBackroom->location = NULL; openDoorToCave->location = backroom; closedDoorToCave->location = NULL;

Let’s create a helper function to accommodate this.

void swapLocations(OBJECT *obj1, OBJECT *obj2) { OBJECT *tmp = obj1->location; obj1->location = obj2->location; obj2->location = tmp; }

Now the following statements can be used to open the door; and once it is open, the same statements will close it again.

swapLocations(openDoorToBackroom, closedDoorToBackroom); swapLocations(openDoorToCave, closedDoorToCave);

The helper function is particularly convenient when the object in question is movable. For example, a box can be opened and closed, but it is also an item that can be picked up and moved elsewhere. In other words, its location is not fixed. Function swapLocations does not rely on a fixed location, since it passes the current location back and forth between two objects.

Of course, a box is not a passage; the player is always on the outside, so a single pair of objects will suffice, and so will a single call to swapLocations.

swapLocations(openBox, closedBox);

This is more or less all we need to implement some new commands open and close. Below is a simple implementation of open; the implementation of close is similar.

OBJECT *obj = parseObject(noun); if (obj == closedDoorToBackRoom || obj == closedDoorToCave) { swapLocations(openDoorToBackroom, closedDoorToBackroom); swapLocations(openDoorToCave, closedDoorToCave); printf("OK.\n"); } else if (obj == closedBox) { swapLocations(openBox, closedBox); printf("OK.\n"); } else if (obj == openDoorToBackRoom || obj == openDoorToCave || obj == openBox) { printf("That is already open.\n"); } else { printf("That cannot be opened.\n"); }

To make things slightly more complicated, we can put a lock on the door or on the box. This requires (at least) three mutually exclusive objects; one for each of the possible states: open, closed and locked. But we can still use the same function to swap locations of the objects. For example, here’s how to unlock a locked box; and vice versa.

swapLocations(closedBox, lockedBox);

There is some overhead involved in the other commands. Our implementation of command open must be expanded to handle the new object lockedBox:

... else if (obj == lockedBox) { printf("You can't, it is locked.\n"); } ...

It may be clear that the number of lines of code is proportional to the number of doors in the game (and boxes and other objects that can be opened). So if your game has more than just a handful of doors, then it is a good idea to go for a more generic solution. By the way, this is something that goes for every command: when it concerns a good many objects, try to write generic code; but when you are dealing with one or two special cases, just stick to straightforward, specialized code.

Generic code typically comes with a data-driven approach. In other words, we need to add one or more attributes to our object structure. In this particular case, we will be adding a function pointer for each of the commands we wish to support: open, close, lock and unlock.

object.txt
  1. #include <stdbool.h>
  2. #include <stdio.h>
  3. #include "object.h"
  4. #include "toggle.h"
  6. typedef struct object {
  7. bool (*condition)(void);
  8. const char *description;
  9. const char **tags;
  10. struct object *location;
  11. struct object *destination;
  12. struct object *prospect;
  13. const char *details;
  14. const char *contents;
  15. const char *textGo;
  16. int weight;
  17. int capacity;
  18. int health;
  19. void (*open)(void);
  20. void (*close)(void);
  21. void (*lock)(void);
  22. void (*unlock)(void);
  23. } OBJECT;
  25. extern OBJECT objs[];
  27. - field
  28. description "an open field"
  29. tags "field"
  30. details "The field is a nice and quiet place under a clear blue sky."
  31. capacity 9999
  33. - cave
  34. description "a little cave"
  35. tags "cave"
  36. details "The cave is just a cold, damp, rocky chamber."
  37. capacity 9999
  39. - silver
  40. description "a silver coin"
  41. tags "silver", "coin", "silver coin"
  42. location field
  43. details "The coin has an eagle on the obverse."
  44. weight 1
  46. - gold
  47. description "a gold coin"
  48. tags "gold", "coin", "gold coin"
  49. location openBox
  50. details "The shiny coin seems to be a rare and priceless artefact."
  51. weight 1
  53. - guard
  54. description "a burly guard"
  55. tags "guard", "burly guard"
  56. location field
  57. details "The guard is a really big fellow."
  58. contents "He has"
  59. health 100
  60. capacity 20
  62. - player
  63. description "yourself"
  64. tags "yourself"
  65. location field
  66. details "You would need a mirror to look at yourself."
  67. contents "You have"
  68. health 100
  69. capacity 20
  71. - intoCave
  72. condition { return guard->health == 0 || silver->location == guard; }
  73. description "a cave entrance to the east"
  74. tags "east", "entrance"
  75. location field
  76. destination cave
  77. details "The entrance is just a narrow opening in a small outcrop."
  78. textGo "You walk into the cave."
  79. open isAlreadyOpen
  81. - intoCaveBlocked
  82. condition { return guard->health > 0 && silver->location != guard; }
  83. description "a cave entrance to the east"
  84. tags "east", "entrance"
  85. location field
  86. prospect cave
  87. details "The entrance is just a narrow opening in a small outcrop."
  88. textGo "The guard stops you from walking into the cave."
  89. open isAlreadyOpen
  91. - exitCave
  92. description "an exit to the west"
  93. tags "west", "exit"
  94. location cave
  95. destination field
  96. details "Sunlight pours in through an opening in the cave's wall."
  97. textGo "You walk out of the cave."
  98. open isAlreadyOpen
  100. - wallField
  101. description "dense forest all around"
  102. tags "west", "north", "south", "forest"
  103. location field
  104. details "The field is surrounded by trees and undergrowth."
  105. textGo "Dense forest is blocking the way."
  107. - wallCave
  108. description "solid rock all around"
  109. tags "east", "north", "rock"
  110. location cave
  111. details "Carved in stone is a secret password 'abccb'."
  112. textGo "Solid rock is blocking the way."
  114. - backroom
  115. description "a backroom"
  116. tags "backroom"
  117. details "The room is dusty and messy."
  118. capacity 9999
  120. - wallBackroom
  121. description "solid rock all around"
  122. tags "east", "west", "south", "rock"
  123. location backroom
  124. details "Trendy wallpaper covers the rock walls."
  125. textGo "Solid rock is blocking the way."
  127. - openDoorToBackroom
  128. description "an open door to the south"
  129. tags "south", "door", "doorway"
  130. destination backroom
  131. details "The door is open."
  132. textGo "You walk through the door into a backroom."
  133. open isAlreadyOpen
  134. close toggleDoorToBackroom
  136. - closedDoorToBackroom
  137. description "a closed door to the south"
  138. tags "south", "door", "doorway"
  139. location cave
  140. prospect backroom
  141. details "The door is closed."
  142. textGo "The door is closed."
  143. open toggleDoorToBackroom
  144. close isAlreadyClosed
  146. - openDoorToCave
  147. description "an open door to the north"
  148. tags "north", "door", "doorway"
  149. destination cave
  150. details "The door is open."
  151. textGo "You walk through the door into the cave."
  152. open isAlreadyOpen
  153. close toggleDoorToCave
  155. - closedDoorToCave
  156. description "a closed door to the north"
  157. tags "north", "door", "doorway"
  158. location backroom
  159. prospect cave
  160. details "The door is closed."
  161. textGo "The door is closed."
  162. open toggleDoorToCave
  163. close isAlreadyClosed
  165. - openBox
  166. description "a wooden box"
  167. tags "box", "wooden box"
  168. details "The box is open."
  169. weight 5
  170. capacity 10
  171. open isAlreadyOpen
  172. close toggleBox
  173. lock isStillOpen
  174. unlock isAlreadyOpen
  176. - closedBox
  177. description "a wooden box"
  178. tags "box", "wooden box"
  179. details "The box is closed."
  180. weight 5
  181. open toggleBox
  182. close isAlreadyClosed
  183. lock toggleBoxLock
  184. unlock isAlreadyUnlocked
  186. - lockedBox
  187. description "a wooden box"
  188. tags "box", "wooden box"
  189. location backroom
  190. details "The box is closed."
  191. weight 5
  192. open isStillLocked
  193. close isAlreadyClosed
  194. lock isAlreadyLocked
  195. unlock toggleBoxLock
  197. - keyForBox
  198. description "a tiny key"
  199. tags "key", "tiny key"
  200. location cave
  201. details "The key is really small and shiny."
  202. weight 1

Explanation:

To avoid duplicate code, I deliberately did not use anonymous functions this time. Instead, we will implement the necessary logic in a separate module. Function swapLocations is in there too, but in a slightly extended version, which will also output feedback to the user.

toggle.h
  1. extern void cannotBeOpened(void);
  2. extern void cannotBeClosed(void);
  3. extern void cannotBeLocked(void);
  4. extern void cannotBeUnlocked(void);
  6. extern void isAlreadyOpen(void);
  7. extern void isAlreadyClosed(void);
  8. extern void isAlreadyLocked(void);
  9. extern void isAlreadyUnlocked(void);
  11. extern void isStillOpen(void);
  12. extern void isStillLocked(void);
  14. extern void toggleDoorToBackroom(void);
  15. extern void toggleDoorToCave(void);
  16. extern void toggleBox(void);
  17. extern void toggleBoxLock(void);
toggle.c
  1. #include <stdbool.h>
  2. #include <stdio.h>
  3. #include "object.h"
  5. static void swapLocations(const char *verb1, OBJECT *obj1,
  6. const char *verb2, OBJECT *obj2)
  7. {
  8. OBJECT *tmp = obj1->location;
  9. OBJECT *obj = tmp != NULL ? obj1 : obj2;
  10. const char *verb = tmp != NULL ? verb1 : verb2;
  11. obj1->location = obj2->location;
  12. obj2->location = tmp;
  13. if (verb != NULL) printf("You %s %s.\n", verb, obj->description);
  14. }
  16. void cannotBeOpened(void) { printf("That cannot be opened.\n"); }
  17. void cannotBeClosed(void) { printf("That cannot be closed.\n"); }
  18. void cannotBeLocked(void) { printf("That cannot be locked.\n"); }
  19. void cannotBeUnlocked(void) { printf("That cannot be unlocked.\n"); }
  21. void isAlreadyOpen(void) { printf("That is already open.\n"); }
  22. void isAlreadyClosed(void) { printf("That is already closed.\n"); }
  23. void isAlreadyLocked(void) { printf("That is already locked.\n"); }
  24. void isAlreadyUnlocked(void) { printf("That is already unlocked.\n"); }
  26. void isStillOpen(void) { printf("That is still open.\n"); }
  27. void isStillLocked(void) { printf("That is locked.\n"); }
  29. void toggleDoorToBackroom(void)
  30. {
  31. swapLocations(NULL, openDoorToCave, NULL, closedDoorToCave);
  32. swapLocations("close", openDoorToBackroom, "open", closedDoorToBackroom);
  33. }
  35. void toggleDoorToCave(void)
  36. {
  37. swapLocations(NULL, openDoorToBackroom, NULL, closedDoorToBackroom);
  38. swapLocations("close", openDoorToCave, "open", closedDoorToCave);
  39. }
  41. void toggleBox(void)
  42. {
  43. swapLocations("close", openBox, "open", closedBox);
  44. }
  46. void toggleBoxLock(void)
  47. {
  48. if (keyForBox->location == player)
  49. {
  50. swapLocations("lock", closedBox, "unlock", lockedBox);
  51. }
  52. else
  53. {
  54. printf("You don't have a key.\n");
  55. }
  56. }

As announced earlier, the implementations of the four commands open, close, lock and unlock are totally generic.

openclose.h
  1. extern void executeOpen(const char *noun);
  2. extern void executeClose(const char *noun);
  3. extern void executeLock(const char *noun);
  4. extern void executeUnlock(const char *noun);
openclose.c
  1. #include <stdbool.h>
  2. #include <stdio.h>
  3. #include "object.h"
  4. #include "reach.h"
  6. void executeOpen(const char *noun)
  7. {
  8. OBJECT *obj = reachableObject("what you want to open", noun);
  9. if (obj != NULL) (*obj->open)();
  10. }
  12. void executeClose(const char *noun)
  13. {
  14. OBJECT *obj = reachableObject("what you want to close", noun);
  15. if (obj != NULL) (*obj->close)();
  16. }
  18. void executeLock(const char *noun)
  19. {
  20. OBJECT *obj = reachableObject("what you want to lock", noun);
  21. if (obj != NULL) (*obj->lock)();
  22. }
  24. void executeUnlock(const char *noun)
  25. {
  26. OBJECT *obj = reachableObject("what you want to unlock", noun);
  27. if (obj != NULL) (*obj->unlock)();
  28. }

Above, I used a generic function reachableObject to handle objects that are not here; see below for its implementation. This way, we don’t have to write the same code four times (once for every execute function). More commands will be added in chapter 15; these will benefit from the same function.

reach.h
  1. extern OBJECT *reachableObject(const char *intention, const char *noun);
reach.c
  1. #include <stdbool.h>
  2. #include <stdio.h>
  3. #include "object.h"
  4. #include "misc.h"
  5. #include "noun.h"
  7. OBJECT *reachableObject(const char *intention, const char *noun)
  8. {
  9. OBJECT *obj = getVisible(intention, noun);
  10. switch (getDistance(player, obj))
  11. {
  12. case distSelf:
  13. printf("You should not be doing that to yourself.\n");
  14. break;
  15. case distHeldContained:
  16. case distHereContained:
  17. printf("You would have to get it from %s first.\n",
  18. obj->location->description);
  19. break;
  20. case distOverthere:
  21. printf("Too far away, move closer please.\n");
  22. break;
  23. case distNotHere:
  24. case distUnknownObject:
  25. // already handled by getVisible
  26. break;
  27. default:
  28. return obj;
  29. }
  30. return NULL;
  31. }

The necessary modifications to object.awk are very straightforward:

object.awk
  1. BEGIN {
  2. count = 0;
  3. obj = "";
  4. if (pass == "c2") {
  5. print "\nstatic bool alwaysTrue(void) { return true; }";
  6. print "\nOBJECT objs[] = {";
  7. }
  8. }
  10. /^- / {
  11. outputRecord(",");
  12. obj = $2;
  13. prop["condition"] = "alwaysTrue";
  14. prop["description"] = "NULL";
  15. prop["tags"] = "";
  16. prop["location"] = "NULL";
  17. prop["destination"] = "NULL";
  18. prop["prospect"] = "";
  19. prop["details"] = "\"You see nothing special.\"";
  20. prop["contents"] = "\"You see\"";
  21. prop["textGo"] = "\"You can't get much closer than this.\"";
  22. prop["weight"] = "99";
  23. prop["capacity"] = "0";
  24. prop["health"] = "0";
  25. prop["open"] = "cannotBeOpened";
  26. prop["close"] = "cannotBeClosed";
  27. prop["lock"] = "cannotBeLocked";
  28. prop["unlock"] = "cannotBeUnlocked";
  29. }
  31. obj && /^[ \t]+[a-z]/ {
  32. name = $1;
  33. $1 = "";
  34. if (name in prop) {
  35. prop[name] = $0;
  36. if (/^[ \t]*\{/) {
  37. prop[name] = name count;
  38. if (pass == "c1") print "static bool " prop[name] "(void) " $0;
  39. }
  40. }
  41. else if (pass == "c2") {
  42. print "#error \"" FILENAME " line " NR ": unknown attribute '" name "'\"";
  43. }
  44. }
  46. !obj && pass == (/^#include/ ? "c1" : "h") {
  47. print;
  48. }
  50. END {
  51. outputRecord("\n};");
  52. if (pass == "h") {
  53. print "\n#define endOfObjs\t(objs + " count ")";
  54. print "\n#define validObject(obj)\t" \
  55. "((obj) != NULL && (*(obj)->condition)())";
  56. }
  57. }
  59. function outputRecord(separator)
  60. {
  61. if (obj) {
  62. if (pass == "h") {
  63. print "#define " obj "\t(objs + " count ")";
  64. }
  65. else if (pass == "c1") {
  66. print "static const char *tags" count "[] = {" prop["tags"] ", NULL};";
  67. }
  68. else if (pass == "c2") {
  69. print "\t{\t/* " count " = " obj " */";
  70. print "\t\t" prop["condition"] ",";
  71. print "\t\t" prop["description"] ",";
  72. print "\t\ttags" count ",";
  73. print "\t\t" prop["location"] ",";
  74. print "\t\t" prop["destination"] ",";
  75. print "\t\t" prop[prop["prospect"] ? "prospect" : "destination"] ",";
  76. print "\t\t" prop["details"] ",";
  77. print "\t\t" prop["contents"] ",";
  78. print "\t\t" prop["textGo"] ",";
  79. print "\t\t" prop["weight"] ",";
  80. print "\t\t" prop["capacity"] ",";
  81. print "\t\t" prop["health"] ",";
  82. print "\t\t" prop["open"] ",";
  83. print "\t\t" prop["close"] ",";
  84. print "\t\t" prop["lock"] ",";
  85. print "\t\t" prop["unlock"];
  86. print "\t}" separator;
  87. delete prop;
  88. }
  89. count++;
  90. }
  91. }
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.

--> give coin
You give a silver coin to a burly guard.

--> go cave
You walk into the cave.

You are in a little cave.
You see:
an exit to the west
solid rock all around
a closed door to the south
a tiny key

--> get key
You pick up a tiny key.

--> go south
The door is closed.

--> open door
You open a closed door to the south.

--> go south
You walk through the door into a backroom.

You are in a backroom.
You see:
solid rock all around
an open door to the north
a wooden box

--> unlock box
You unlock a wooden box.

--> open box
You open a wooden box.

--> look box
The box is open.
You see:
a gold coin

--> get gold
You get a gold coin from a wooden box.

--> quit

Bye!

The additions to parsexec.c are equally straightforward.

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

Notes:

⭳   Download source code 🌀   Run on Repl.it

Next chapter: 13. The parser