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

15. Light and dark

In many adventures, a lamp is a vital object. Without it, you cannot make it through the dark caverns that lie ahead.

The effect of being in the dark differs from game to game. Typically, it makes the command ‘look’ ineffective. In some games (e.g. Zork), darkness is deadly. In others, you can still make progress without a light source, provided you have drawn a detailed map of the dark area.

Our game will stay in between; being in the dark will not get you killed, but you will not be able to follow any passages either. An exception will be made for passages that lead back into the light; it seemed unfair to me to allow the player to run into a dark area, without an opportunity to get back to where he came from.

Alright; so first of all, in darkness you cannot see your surroundings.

location.c
  1. #include <stdbool.h>
  2. #include <stdio.h>
  3. #include "object.h"
  4. #include "misc.h"
  5. #include "match.h"
  6. #include "noun.h"
  8. bool executeLookAround(void)
  9. {
  10. if (isLit(player->location))
  11. {
  12. printf("You are in %s.\n", player->location->description);
  13. }
  14. else
  15. {
  16. printf("It is very dark in here.\n");
  17. }
  18. listObjectsAtLocation(player->location);
  19. return true;
  20. }
  22. bool executeLook(void)
  23. {
  24. OBJECT *obj = getVisible("what you want to look at", params[0]);
  25. switch (getDistance(player, obj))
  26. {
  27. case distHereContained:
  28. printf("Hard to see, try to get it first.\n");
  29. break;
  30. case distOverthere:
  31. printf("Too far away, move closer please.\n");
  32. break;
  33. case distNotHere:
  34. printf("You don't see any %s here.\n", params[0]);
  35. break;
  36. case distUnknownObject:
  37. // already handled by getVisible
  38. break;
  39. default:
  40. printf("%s\n", obj->details);
  41. listObjectsAtLocation(obj);
  42. }
  43. return true;
  44. }
  46. static void movePlayer(OBJECT *passage)
  47. {
  48. printf("%s\n", passage->textGo);
  49. if (passage->destination != NULL)
  50. {
  51. player->location = passage->destination;
  52. printf("\n");
  53. executeLookAround();
  54. }
  55. }
  57. bool executeGo(void)
  58. {
  59. OBJECT *obj = getVisible("where you want to go", params[0]);
  60. switch (getDistance(player, obj))
  61. {
  62. case distOverthere:
  63. movePlayer(getPassage(player->location, obj));
  64. break;
  65. case distNotHere:
  66. printf("You don't see any %s here.\n", params[0]);
  67. break;
  68. case distUnknownObject:
  69. // already handled by getVisible
  70. break;
  71. default:
  72. movePlayer(obj);
  73. }
  74. return true;
  75. }

Secondly, in darkness you cannot see or use nearby objects.

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 if (isLit(player->location))
  45. {
  46. printf("You don't see any %s here.\n", noun);
  47. }
  48. else
  49. {
  50. printf("It's too dark.\n");
  51. }
  52. }
  53. else if (obj == &ambiguousNoun)
  54. {
  55. printf("Please be specific about which %s you mean.\n", noun);
  56. obj = NULL;
  57. }
  58. return obj;
  59. }
  61. OBJECT *getPossession(OBJECT *from, const char *verb, const char *noun)
  62. {
  63. OBJECT *obj = NULL;
  64. if (from == NULL)
  65. {
  66. printf("I don't understand who you want to %s.\n", verb);
  67. }
  68. else if ((obj = getObject(noun, from, distHeldContained)) == NULL)
  69. {
  70. if (getObject(noun, player, distNotHere) == NULL)
  71. {
  72. printf("I don't understand what you want to %s.\n", verb);
  73. }
  74. else if (from == player)
  75. {
  76. printf("You are not holding any %s.\n", noun);
  77. }
  78. else
  79. {
  80. printf("There appears to be no %s you can get from %s.\n",
  81. noun, from->description);
  82. }
  83. }
  84. else if (obj == &ambiguousNoun)
  85. {
  86. printf("Please be specific about which %s you want to %s.\n",
  87. noun, verb);
  88. obj = NULL;
  89. }
  90. else if (obj == from)
  91. {
  92. printf("You should not be doing that to %s.\n", obj->description);
  93. obj = NULL;
  94. }
  95. return obj;
  96. }

In both cases, we used a function isLit. It is defined (and used some more) in misc.c.

misc.h
  1. typedef enum {
  2. distSelf,
  3. distHeld,
  4. distHeldContained,
  5. distLocation,
  6. distHere,
  7. distHereContained,
  8. distOverthere,
  9. distNotHere,
  10. distUnknownObject
  11. } DISTANCE;
  13. extern bool isHolding(OBJECT *container, OBJECT *obj);
  14. extern bool isLit(OBJECT *location);
  15. extern OBJECT *getPassage(OBJECT *from, OBJECT *to);
  16. extern DISTANCE getDistance(OBJECT *from, OBJECT *to);
  17. extern OBJECT *actorHere(void);
  18. extern int listObjectsAtLocation(OBJECT *location);
misc.c
  1. #include <stdbool.h>
  2. #include <stdio.h>
  3. #include "object.h"
  4. #include "misc.h"
  6. bool isHolding(OBJECT *container, OBJECT *obj)
  7. {
  8. return validObject(obj) && obj->location == container;
  9. }
  11. bool isLit(OBJECT *target)
  12. {
  13. OBJECT *obj;
  14. if (validObject(target))
  15. {
  16. if (target->light > 0)
  17. {
  18. return true;
  19. }
  20. for (obj = objs; obj < endOfObjs; obj++)
  21. {
  22. if (validObject(obj) && obj->light > 0 &&
  23. (isHolding(target, obj) || isHolding(target, obj->location)))
  24. {
  25. return true;
  26. }
  27. }
  28. }
  29. return false;
  30. }
  32. static bool isNoticeable(OBJECT *obj)
  33. {
  34. return obj->location == player ||
  35. isLit(obj) || isLit(obj->prospect) || isLit(player->location);
  36. }
  38. OBJECT *getPassage(OBJECT *from, OBJECT *to)
  39. {
  40. if (from != NULL && to != NULL)
  41. {
  42. OBJECT *obj;
  43. for (obj = objs; obj < endOfObjs; obj++)
  44. {
  45. if (isHolding(from, obj) && obj->prospect == to)
  46. {
  47. return obj;
  48. }
  49. }
  50. }
  51. return NULL;
  52. }
  54. DISTANCE getDistance(OBJECT *from, OBJECT *to)
  55. {
  56. return to == NULL ? distUnknownObject :
  57. !validObject(to) ? distNotHere :
  58. to == from ? distSelf :
  59. isHolding(from, to) ? distHeld :
  60. !isNoticeable(to) ? distNotHere :
  61. isHolding(to, from) ? distLocation :
  62. isHolding(from->location, to) ? distHere :
  63. isHolding(from, to->location) ? distHeldContained :
  64. isHolding(from->location, to->location) ? distHereContained :
  65. getPassage(from->location, to) != NULL ? distOverthere :
  66. distNotHere;
  67. }
  69. OBJECT *actorHere(void)
  70. {
  71. OBJECT *obj;
  72. for (obj = objs; obj < endOfObjs; obj++)
  73. {
  74. if (isHolding(player->location, obj) && obj != player &&
  75. isNoticeable(obj) && obj->health > 0)
  76. {
  77. return obj;
  78. }
  79. }
  80. return NULL;
  81. }
  83. int listObjectsAtLocation(OBJECT *location)
  84. {
  85. int count = 0;
  86. OBJECT *obj;
  87. for (obj = objs; obj < endOfObjs; obj++)
  88. {
  89. if (obj != player && isHolding(location, obj) && isNoticeable(obj))
  90. {
  91. if (count++ == 0)
  92. {
  93. printf("%s:\n", location->contents);
  94. }
  95. printf("%s\n", obj->description);
  96. }
  97. }
  98. return count;
  99. }

Explanation:

The implementation of isLit uses a new attribute light.

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["light"] = "0";
  26. prop["open"] = "cannotBeOpened";
  27. prop["close"] = "cannotBeClosed";
  28. prop["lock"] = "cannotBeLocked";
  29. prop["unlock"] = "cannotBeUnlocked";
  30. }
  32. obj && /^[ \t]+[a-z]/ {
  33. name = $1;
  34. $1 = "";
  35. if (name in prop) {
  36. prop[name] = $0;
  37. if (/^[ \t]*\{/) {
  38. prop[name] = name count;
  39. if (pass == "c1") print "static bool " prop[name] "(void) " $0;
  40. }
  41. }
  42. else if (pass == "c2") {
  43. print "#error \"" FILENAME " line " NR ": unknown attribute '" name "'\"";
  44. }
  45. }
  47. !obj && pass == (/^#include/ ? "c1" : "h") {
  48. print;
  49. }
  51. END {
  52. outputRecord("\n};");
  53. if (pass == "h") {
  54. print "\n#define endOfObjs\t(objs + " count ")";
  55. print "\n#define validObject(obj)\t" \
  56. "((obj) != NULL && (*(obj)->condition)())";
  57. }
  58. }
  60. function outputRecord(separator)
  61. {
  62. if (obj) {
  63. if (pass == "h") {
  64. print "#define " obj "\t(objs + " count ")";
  65. }
  66. else if (pass == "c1") {
  67. print "static const char *tags" count "[] = {" prop["tags"] ", NULL};";
  68. }
  69. else if (pass == "c2") {
  70. print "\t{\t/* " count " = " obj " */";
  71. print "\t\t" prop["condition"] ",";
  72. print "\t\t" prop["description"] ",";
  73. print "\t\ttags" count ",";
  74. print "\t\t" prop["location"] ",";
  75. print "\t\t" prop["destination"] ",";
  76. print "\t\t" prop[prop["prospect"] ? "prospect" : "destination"] ",";
  77. print "\t\t" prop["details"] ",";
  78. print "\t\t" prop["contents"] ",";
  79. print "\t\t" prop["textGo"] ",";
  80. print "\t\t" prop["weight"] ",";
  81. print "\t\t" prop["capacity"] ",";
  82. print "\t\t" prop["health"] ",";
  83. print "\t\t" prop["light"] ",";
  84. print "\t\t" prop["open"] ",";
  85. print "\t\t" prop["close"] ",";
  86. print "\t\t" prop["lock"] ",";
  87. print "\t\t" prop["unlock"];
  88. print "\t}" separator;
  89. delete prop;
  90. }
  91. count++;
  92. }
  93. }

By default, light is zero, meaning an object does not emit light. Every location in broad daylight (typically all but the underground ones) will be given a positive light value. It doesn’t really matter what value that is; as long as it’s not zero. We will also add a lamp the player can carry to traverse dark areas.

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. int light;
  20. void (*open)(void);
  21. void (*close)(void);
  22. void (*lock)(void);
  23. void (*unlock)(void);
  24. } OBJECT;
  26. extern OBJECT objs[];
  28. - field
  29. description "an open field"
  30. tags "field"
  31. details "The field is a nice and quiet place under a clear blue sky."
  32. capacity 9999
  33. light 100
  35. - cave
  36. description "a little cave"
  37. tags "cave"
  38. details "The cave is just a cold, damp, rocky chamber."
  39. capacity 9999
  41. - silver
  42. description "a silver coin"
  43. tags "silver", "coin", "silver coin"
  44. location field
  45. details "The coin has an eagle on the obverse."
  46. weight 1
  48. - gold
  49. description "a gold coin"
  50. tags "gold", "coin", "gold coin"
  51. location openBox
  52. details "The shiny coin seems to be a rare and priceless artefact."
  53. weight 1
  55. - guard
  56. description "a burly guard"
  57. tags "guard", "burly guard"
  58. location field
  59. details "The guard is a really big fellow."
  60. contents "He has"
  61. health 100
  62. capacity 20
  64. - player
  65. description "yourself"
  66. tags "yourself"
  67. location field
  68. details "You would need a mirror to look at yourself."
  69. contents "You have"
  70. health 100
  71. capacity 20
  73. - intoCave
  74. condition { return guard->health == 0 || silver->location == guard; }
  75. description "a cave entrance to the east"
  76. tags "east", "entrance"
  77. location field
  78. destination cave
  79. details "The entrance is just a narrow opening in a small outcrop."
  80. textGo "You walk into the cave."
  81. open isAlreadyOpen
  83. - intoCaveBlocked
  84. condition { return guard->health > 0 && silver->location != guard; }
  85. description "a cave entrance to the east"
  86. tags "east", "entrance"
  87. location field
  88. prospect cave
  89. details "The entrance is just a narrow opening in a small outcrop."
  90. textGo "The guard stops you from walking into the cave."
  91. open isAlreadyOpen
  93. - exitCave
  94. description "an exit to the west"
  95. tags "west", "exit"
  96. location cave
  97. destination field
  98. details "Sunlight pours in through an opening in the cave's wall."
  99. textGo "You walk out of the cave."
  100. open isAlreadyOpen
  102. - wallField
  103. description "dense forest all around"
  104. tags "west", "north", "south", "forest"
  105. location field
  106. details "The field is surrounded by trees and undergrowth."
  107. textGo "Dense forest is blocking the way."
  109. - wallCave
  110. description "solid rock all around"
  111. tags "east", "north", "rock"
  112. location cave
  113. details "Carved in stone is a secret password 'abccb'."
  114. textGo "Solid rock is blocking the way."
  116. - backroom
  117. description "a backroom"
  118. tags "backroom"
  119. details "The room is dusty and messy."
  120. capacity 9999
  122. - wallBackroom
  123. description "solid rock all around"
  124. tags "east", "west", "south", "rock"
  125. location backroom
  126. details "Trendy wallpaper covers the rock walls."
  127. textGo "Solid rock is blocking the way."
  129. - openDoorToBackroom
  130. description "an open door to the south"
  131. tags "south", "door", "doorway"
  132. destination backroom
  133. details "The door is open."
  134. textGo "You walk through the door into a backroom."
  135. open isAlreadyOpen
  136. close toggleDoorToBackroom
  138. - closedDoorToBackroom
  139. description "a closed door to the south"
  140. tags "south", "door", "doorway"
  141. location cave
  142. prospect backroom
  143. details "The door is closed."
  144. textGo "The door is closed."
  145. open toggleDoorToBackroom
  146. close isAlreadyClosed
  148. - openDoorToCave
  149. description "an open door to the north"
  150. tags "north", "door", "doorway"
  151. destination cave
  152. details "The door is open."
  153. textGo "You walk through the door into the cave."
  154. open isAlreadyOpen
  155. close toggleDoorToCave
  157. - closedDoorToCave
  158. description "a closed door to the north"
  159. tags "north", "door", "doorway"
  160. location backroom
  161. prospect cave
  162. details "The door is closed."
  163. textGo "The door is closed."
  164. open toggleDoorToCave
  165. close isAlreadyClosed
  167. - openBox
  168. description "a wooden box"
  169. tags "box", "wooden box"
  170. details "The box is open."
  171. weight 5
  172. capacity 10
  173. open isAlreadyOpen
  174. close toggleBox
  175. lock isStillOpen
  176. unlock isAlreadyOpen
  178. - closedBox
  179. description "a wooden box"
  180. tags "box", "wooden box"
  181. details "The box is closed."
  182. weight 5
  183. open toggleBox
  184. close isAlreadyClosed
  185. lock toggleBoxLock
  186. unlock isAlreadyUnlocked
  188. - lockedBox
  189. description "a wooden box"
  190. tags "box", "wooden box"
  191. location backroom
  192. details "The box is closed."
  193. weight 5
  194. open isStillLocked
  195. close isAlreadyClosed
  196. lock isAlreadyLocked
  197. unlock toggleBoxLock
  199. - keyForBox
  200. description "a tiny key"
  201. tags "key", "tiny key"
  202. location cave
  203. details "The key is really small and shiny."
  204. weight 1
  206. - lampOff
  207. description "a lamp"
  208. tags "lamp"
  209. location field
  210. details "The lamp is off."
  211. weight 5
  213. - lampOn
  214. description "a lamp"
  215. tags "lamp"
  216. details "The lamp is on."
  217. weight 5
  218. light 100

Explanation:

We will add some commands we can use to turn the lamp on and off.

parsexec.c
  1. #include <ctype.h>
  2. #include <stdbool.h>
  3. #include <stdio.h>
  4. #include "object.h"
  5. #include "misc.h"
  6. #include "match.h"
  7. #include "location.h"
  8. #include "inventory.h"
  9. #include "inventory2.h"
  10. #include "openclose.h"
  11. #include "onoff.h"
  13. typedef struct
  14. {
  15. const char *pattern;
  16. bool (*function)(void);
  17. } COMMAND;
  19. static bool executeQuit(void)
  20. {
  21. return false;
  22. }
  24. static bool executeNoMatch(void)
  25. {
  26. const char *src = *params;
  27. int len;
  28. for (len = 0; src[len] != '\0' && !isspace(src[len]); len++);
  29. if (len > 0) printf("I don't know how to '%.*s'.\n", len, src);
  30. return true;
  31. }
  33. bool parseAndExecute(const char *input)
  34. {
  35. static const COMMAND commands[] =
  36. {
  37. { "quit" , executeQuit },
  38. { "look" , executeLookAround },
  39. { "look around" , executeLookAround },
  40. { "look at A" , executeLook },
  41. { "look A" , executeLook },
  42. { "examine A" , executeLook },
  43. { "go to A" , executeGo },
  44. { "go A" , executeGo },
  45. { "get A from B" , executeGetFrom },
  46. { "get A" , executeGet },
  47. { "put A in B" , executePutIn },
  48. { "drop A in B" , executePutIn },
  49. { "drop A" , executeDrop },
  50. { "ask A from B" , executeAskFrom },
  51. { "ask A" , executeAsk },
  52. { "give A to B" , executeGiveTo },
  53. { "give A" , executeGive },
  54. { "inventory" , executeInventory },
  55. { "open A" , executeOpen },
  56. { "close A" , executeClose },
  57. { "lock A" , executeLock },
  58. { "unlock A" , executeUnlock },
  59. { "turn on A" , executeTurnOn },
  60. { "turn off A" , executeTurnOff },
  61. { "turn A on" , executeTurnOn },
  62. { "turn A off" , executeTurnOff },
  63. { "A" , executeNoMatch }
  64. };
  65. const COMMAND *cmd;
  66. for (cmd = commands; !matchCommand(input, cmd->pattern); cmd++);
  67. return (*cmd->function)();
  68. }

Below is the implementation of these commands.

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
a lamp

--> get lamp
You pick up a lamp.

--> 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.

It is very dark in here.
You see:
an exit to the west

--> get key
It's too dark.

--> open door
It's too dark.

--> go south
It's too dark.

--> turn lamp on
You turn on a lamp.

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

--> look around
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.

--> 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

--> quit

Bye!
onoff.h
  1. extern bool executeTurnOn(void);
  2. extern bool executeTurnOff(void);
onoff.c
  1. #include <stdbool.h>
  2. #include <stdio.h>
  3. #include "object.h"
  4. #include "match.h"
  5. #include "reach.h"
  6. #include "toggle.h"
  8. bool executeTurnOn(void)
  9. {
  10. OBJECT *obj = reachableObject("what you want to turn on", params[0]);
  11. if (obj != NULL)
  12. {
  13. if (obj == lampOff)
  14. {
  15. toggleLamp();
  16. }
  17. else
  18. {
  19. printf(obj == lampOn ? "The lamp is already on.\n"
  20. : "You cannot turn that on.\n");
  21. }
  22. }
  23. return true;
  24. }
  26. bool executeTurnOff(void)
  27. {
  28. OBJECT *obj = reachableObject("what you want to turn off", params[0]);
  29. if (obj != NULL)
  30. {
  31. if (obj == lampOn)
  32. {
  33. toggleLamp();
  34. }
  35. else
  36. {
  37. printf(obj == lampOff ? "The lamp is already off.\n"
  38. : "You cannot turn that off.\n");
  39. }
  40. }
  41. return true;
  42. }

To turn the lamp on and off, we will use the same trick we used to open and close the door and the box (see chapter 12).

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);
  19. extern void toggleLamp(void);
toggle.c
  1. #include <stdbool.h>
  2. #include <stdio.h>
  3. #include "object.h"
  4. #include "misc.h"
  5. #include "location.h"
  7. static void swapLocations(const char *verb1, OBJECT *obj1,
  8. const char *verb2, OBJECT *obj2)
  9. {
  10. OBJECT *tmp = obj1->location;
  11. OBJECT *obj = tmp != NULL ? obj1 : obj2;
  12. const char *verb = tmp != NULL ? verb1 : verb2;
  13. obj1->location = obj2->location;
  14. obj2->location = tmp;
  15. if (verb != NULL) printf("You %s %s.\n", verb, obj->description);
  16. }
  18. void cannotBeOpened(void) { printf("That cannot be opened.\n"); }
  19. void cannotBeClosed(void) { printf("That cannot be closed.\n"); }
  20. void cannotBeLocked(void) { printf("That cannot be locked.\n"); }
  21. void cannotBeUnlocked(void) { printf("That cannot be unlocked.\n"); }
  23. void isAlreadyOpen(void) { printf("That is already open.\n"); }
  24. void isAlreadyClosed(void) { printf("That is already closed.\n"); }
  25. void isAlreadyLocked(void) { printf("That is already locked.\n"); }
  26. void isAlreadyUnlocked(void) { printf("That is already unlocked.\n"); }
  28. void isStillOpen(void) { printf("That is still open.\n"); }
  29. void isStillLocked(void) { printf("That is locked.\n"); }
  31. void toggleDoorToBackroom(void)
  32. {
  33. swapLocations(NULL, openDoorToCave, NULL, closedDoorToCave);
  34. swapLocations("close", openDoorToBackroom, "open", closedDoorToBackroom);
  35. }
  37. void toggleDoorToCave(void)
  38. {
  39. swapLocations(NULL, openDoorToBackroom, NULL, closedDoorToBackroom);
  40. swapLocations("close", openDoorToCave, "open", closedDoorToCave);
  41. }
  43. void toggleBox(void)
  44. {
  45. swapLocations("close", openBox, "open", closedBox);
  46. }
  48. void toggleBoxLock(void)
  49. {
  50. if (keyForBox->location == player)
  51. {
  52. swapLocations("lock", closedBox, "unlock", lockedBox);
  53. }
  54. else
  55. {
  56. printf("You don't have a key.\n");
  57. }
  58. }
  60. void toggleLamp(void)
  61. {
  62. bool oldLit = isLit(player->location);
  63. swapLocations("turn off", lampOn, "turn on", lampOff);
  64. if (oldLit != isLit(player->location))
  65. {
  66. printf("\n");
  67. executeLookAround();
  68. }
  69. }

Explanation:

Finally, we will mark the dark locations in our generated map.

map.awk
  1. BEGIN { print "digraph map {\n\tnode [style=filled]"; }
  2. /^- / { outputEdges(); obj = $2; delete a; }
  3. /^[ \t]/ { a[$1] = $2; }
  4. END { outputEdges(); outputNodes(); print "}"; }
  6. function outputEdges()
  7. {
  8. color[obj] = a["light"] ? "white" : "grey";
  9. outputEdge(a["location"], a["destination"], "");
  10. outputEdge(a["location"], a["prospect"], " [style=dashed]");
  11. }
  13. function outputEdge(from, to, style)
  14. {
  15. if (to)
  16. {
  17. nodes[to] = 1;
  18. if (from)
  19. {
  20. nodes[from] = 1;
  21. print "\t" from " -> " to style;
  22. }
  23. }
  24. }
  26. function outputNodes()
  27. {
  28. for (n in nodes) print "\t" n " [fillcolor=" color[n] "]";
  29. }

Players, please be careful not to turn off the lamp and drop it. In the dark, you will never be able to find it back. You will be stuck! Fortunately, the next chapter will provide a way to undo clumsy actions.

⭳   Download source code 🌀   Run on Repl.it

Next chapter: 16. Savegame