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

14. Multiple nouns

Time to prove the new parser is really capable of interpreting more complex commands.

So far, our parser only accepted simple verb-noun commands. Let’s try and parse some more complex commands like:

Adding patterns to parsexec.c seems straightforward:

But as explained in the previous chapter, similar commands (like ‘get A from B’ and the already existing ‘get A’) must be placed in the correct order. If ‘get A’ would appear first, then it would consume any command starting with ‘get’, including all those that were supposed to be matched by the new pattern. In short, ‘get A from B’ must come before ‘get A’.

Some commands (for example put) do not have a single-noun variant. Nevertheless, we will add a pattern with a single nonterminal (‘put A’). We need this to correctly capture a misspelled noun. The full pattern ‘put A in B’ will not match a command like ‘put koin in box’. As explained in the previous chapter, only a nonterminal at the end of a pattern is able to capture a misspelled or otherwise unrecognized noun.

The same applies to commands with more than two nouns. With n nouns, you need n patterns to handle all possible mismatches. An example with three parameters:

  1. “paint A on B with C”
  2. “paint A on B”
  3. “paint A”

Again, the order of the patterns is vital: if “paint A” would be on top (meaning it will be tried first), then it would consume every paint command, including those that were meant to be caught by 1 and 2.

For now, we do not need patterns with more than two nonterminals.

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

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

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

--> inventory
You have:
a gold coin
a tiny key

--> put gold in box
You put a gold coin in a wooden box.

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

--> quit

Bye!
parsexec.h
  1. extern bool parseAndExecute(const char *input);
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"
  12. typedef struct
  13. {
  14. const char *pattern;
  15. bool (*function)(void);
  16. } COMMAND;
  18. static bool executeQuit(void)
  19. {
  20. return false;
  21. }
  23. static bool executeNoMatch(void)
  24. {
  25. const char *src = *params;
  26. int len;
  27. for (len = 0; src[len] != '\0' && !isspace(src[len]); len++);
  28. if (len > 0) printf("I don't know how to '%.*s'.\n", len, src);
  29. return true;
  30. }
  32. bool parseAndExecute(const char *input)
  33. {
  34. static const COMMAND commands[] =
  35. {
  36. { "quit" , executeQuit },
  37. { "look" , executeLookAround },
  38. { "look around" , executeLookAround },
  39. { "look at A" , executeLook },
  40. { "look A" , executeLook },
  41. { "examine A" , executeLook },
  42. { "go to A" , executeGo },
  43. { "go A" , executeGo },
  44. { "get A from B" , executeGetFrom },
  45. { "get A" , executeGet },
  46. { "put A in B" , executePutIn },
  47. { "drop A in B" , executePutIn },
  48. { "drop A" , executeDrop },
  49. { "ask A from B" , executeAskFrom },
  50. { "ask A" , executeAsk },
  51. { "give A to B" , executeGiveTo },
  52. { "give A" , executeGive },
  53. { "inventory" , executeInventory },
  54. { "open A" , executeOpen },
  55. { "close A" , executeClose },
  56. { "lock A" , executeLock },
  57. { "unlock A" , executeUnlock },
  58. { "A" , executeNoMatch }
  59. };
  60. const COMMAND *cmd;
  61. for (cmd = commands; !matchCommand(input, cmd->pattern); cmd++);
  62. return (*cmd->function)();
  63. }

In a new module inventory2.c, we implement the new multi-noun commands get, drop/put, ask and give. Now we can finally put the gold coin back in the box!

inventory2.h
  1. extern bool executeGetFrom(void);
  2. extern bool executePutIn(void);
  3. extern bool executeAskFrom(void);
  4. extern bool executeGiveTo(void);
inventory2.c
  1. #include <stdbool.h>
  2. #include <stdio.h>
  3. #include "object.h"
  4. #include "match.h"
  5. #include "noun.h"
  6. #include "move.h"
  7. #include "reach.h"
  9. bool executeGetFrom(void)
  10. {
  11. OBJECT *from = reachableObject("where to get that from", params[1]);
  12. if (from != NULL && getVisible("what you want to get", params[0]) != NULL)
  13. {
  14. if (from->health > 0)
  15. {
  16. printf("You should ask %s nicely.\n", from->description);
  17. }
  18. else
  19. {
  20. moveObject(getPossession(from, "get", params[0]), player);
  21. }
  22. }
  23. return true;
  24. }
  26. bool executePutIn(void)
  27. {
  28. OBJECT *obj = getPossession(player, "put", params[0]);
  29. if (obj != NULL)
  30. {
  31. OBJECT *to = reachableObject("where to put that in", params[1]);
  32. if (to != NULL)
  33. {
  34. if (to->health > 0)
  35. {
  36. printf("You should offer that nicely to %s.\n", to->description);
  37. }
  38. else
  39. {
  40. moveObject(obj, to);
  41. }
  42. }
  43. }
  44. return true;
  45. }
  47. bool executeAskFrom(void)
  48. {
  49. OBJECT *from = reachableObject("who to ask that", params[1]);
  50. if (from != NULL)
  51. {
  52. if (from->health > 0)
  53. {
  54. if (getVisible("what you want to ask", params[0]) != NULL)
  55. {
  56. moveObject(getPossession(from, "ask", params[0]), player);
  57. }
  58. }
  59. else
  60. {
  61. printf("There is no response from %s.\n", from->description);
  62. }
  63. }
  64. return true;
  65. }
  67. bool executeGiveTo(void)
  68. {
  69. OBJECT *obj = getPossession(player, "give", params[0]);
  70. if (obj != NULL)
  71. {
  72. OBJECT *to = reachableObject("who to give that to", params[1]);
  73. if (to != NULL)
  74. {
  75. if (to->health > 0)
  76. {
  77. moveObject(obj, to);
  78. }
  79. else
  80. {
  81. printf("No eagerness is shown by %s.\n", to->description);
  82. }
  83. }
  84. }
  85. return true;
  86. }

You may notice that commands like ‘put coin in forest’ and ‘put coin in box’ (when the box is closed) get the following strange reply: “That is way too heavy.” That is because most objects (including the closed box, and scenary like the forest) have zero capacity to hold other objects. Rightfully so, but the message is quite inappropriate. To avoid that, we will introduce a separate message for objects that have zero capacity: “It doesn’t seem to fit in.”

However, that particular message is totally misleading when it comes as a response to ‘put key in box’. So we will make a special exception for that particular combination of objects.

move.c
  1. #include <stdbool.h>
  2. #include <stdio.h>
  3. #include "object.h"
  4. #include "misc.h"
  6. static int weightOfContents(OBJECT *container)
  7. {
  8. int sum = 0;
  9. OBJECT *obj;
  10. for (obj = objs; obj < endOfObjs; obj++)
  11. {
  12. if (isHolding(container, obj)) sum += obj->weight;
  13. }
  14. return sum;
  15. }
  17. static void describeMove(OBJECT *obj, OBJECT *to)
  18. {
  19. if (to == player->location)
  20. {
  21. printf("You drop %s.\n", obj->description);
  22. }
  23. else if (to != player)
  24. {
  25. printf(to->health > 0 ? "You give %s to %s.\n" : "You put %s in %s.\n",
  26. obj->description, to->description);
  27. }
  28. else if (obj->location == player->location)
  29. {
  30. printf("You pick up %s.\n", obj->description);
  31. }
  32. else
  33. {
  34. printf("You get %s from %s.\n",
  35. obj->description, obj->location->description);
  36. }
  37. }
  39. void moveObject(OBJECT *obj, OBJECT *to)
  40. {
  41. if (obj == NULL)
  42. {
  43. // already handled by getVisible or getPossession
  44. }
  45. else if (to == NULL)
  46. {
  47. printf("There is nobody here to give that to.\n");
  48. }
  49. else if (to->capacity == 0)
  50. {
  51. printf(obj == keyForBox && (to == closedBox || to == lockedBox) ?
  52. "The key seems to fit the lock.\n" :
  53. "It doesn't seem to fit in.\n");
  54. }
  55. else if (obj->weight > to->capacity)
  56. {
  57. printf("That is way too heavy.\n");
  58. }
  59. else if (obj->weight + weightOfContents(to) > to->capacity)
  60. {
  61. printf("That would become too heavy.\n");
  62. }
  63. else
  64. {
  65. describeMove(obj, to);
  66. obj->location = to;
  67. }
  68. }

I guess the more complex the commands we accept, the more effort we need to put into making convincing replies.

⭳   Download source code 🌀   Run on Repl.it

Next chapter: 15. Light and dark