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

10. More attributes

There are many possible reasons for expanding the ‘object’ structure.

When we introduced objects in chapter 4, they had only three attributes. In chapter 6, we added a fourth. This is more or less the absolute minimum. To put more detail into our adventure, we need some more attributes. Here are a few examples.

  1. The command look around gives a global description of the player’s location, including a list of items, actors and other objects present there. Many adventures require the player to examine these objects, either to reveal certain clues that are needed to make progress in the game, or simply to enhance the game’s atmosphere. We will add an attribute details that holds a detailed description of each object, plus an attribute contents that is used with objects that contain other objects.
  2. When the player follows a passage, the response is invariably “OK” followed by a description of the new location. This is a bit dull; it would be so much nicer to give each passage its own custom message. We will add an attribute textGo to hold this message.
  3. Some passages have a ‘twist’; they do not go where the player expects them to go. For example, a forest path may be hiding a pitfall. While the passage appears to be leading from location A to location B, in reality the end point is location C, i.e. the bottom of a pit. More common ‘twists’ are passages that are ‘blocked’: a closed grating, a broken bridge, a narrow crack. Suppose our cave entrance is blocked by the guard. Any attempt to enter the cave will fail; instead the player will stay at his original location, i.e. the field. We could simply change the passage’s destination to field (or NULL), but that would result in an undesirable response to commands like go cave and look cave: “You don’t see any cave here.” We need separate attributes for the actual and the apparent end point of a passage. We will introduce an attribute prospect to represent the latter; the attribute destination, introduced in chapter 6, still holds the actual end point. In most cases, the two will be equal, so we will have object.awk generate an appropriate default; prospect only needs to be specified in object.txt when it differs from destination.
  4. In many adventures, the player, as well as other actors in the game, are limited in how much they can carry. Give each item a weight; the combined weight of all items in an actor’s inventory should not exceed that actor’s capacity. Give an object a very high weight to make it immovable (a tree, a house, a mountain).
  5. RPG-style adventure games will need a whole range of attributes for actors (both player and non-player), for example health. Objects with zero health are either dead, or they are not an actor at all.

We define seven new attributes in object.txt:

object.txt
  1. #include <stdio.h>
  2. #include "object.h"
  4. typedef struct object {
  5. const char *description;
  6. const char **tags;
  7. struct object *location;
  8. struct object *destination;
  9. struct object *prospect;
  10. const char *details;
  11. const char *contents;
  12. const char *textGo;
  13. int weight;
  14. int capacity;
  15. int health;
  16. } OBJECT;
  18. extern OBJECT objs[];
  20. - field
  21. description "an open field"
  22. tags "field"
  23. details "The field is a nice and quiet place under a clear blue sky."
  24. capacity 9999
  26. - cave
  27. description "a little cave"
  28. tags "cave"
  29. details "The cave is just a cold, damp, rocky chamber."
  30. capacity 9999
  32. - silver
  33. description "a silver coin"
  34. tags "silver", "coin", "silver coin"
  35. location field
  36. details "The coin has an eagle on the obverse."
  37. weight 1
  39. - gold
  40. description "a gold coin"
  41. tags "gold", "coin", "gold coin"
  42. location cave
  43. details "The shiny coin seems to be a rare and priceless artefact."
  44. weight 1
  46. - guard
  47. description "a burly guard"
  48. tags "guard", "burly guard"
  49. location field
  50. details "The guard is a really big fellow."
  51. contents "He has"
  52. health 100
  53. capacity 20
  55. - player
  56. description "yourself"
  57. tags "yourself"
  58. location field
  59. details "You would need a mirror to look at yourself."
  60. contents "You have"
  61. health 100
  62. capacity 20
  64. - intoCave
  65. description "a cave entrance to the east"
  66. tags "east", "entrance"
  67. location field
  68. prospect cave
  69. details "The entrance is just a narrow opening in a small outcrop."
  70. textGo "The guard stops you from walking into the cave."
  72. - exitCave
  73. description "an exit to the west"
  74. tags "west", "exit"
  75. location cave
  76. destination field
  77. details "Sunlight pours in through an opening in the cave's wall."
  78. textGo "You walk out of the cave."
  80. - wallField
  81. description "dense forest all around"
  82. tags "west", "north", "south", "forest"
  83. location field
  84. details "The field is surrounded by trees and undergrowth."
  85. textGo "Dense forest is blocking the way."
  87. - wallCave
  88. description "solid rock all around"
  89. tags "east", "north", "south", "rock"
  90. location cave
  91. details "Carved in stone is a secret password 'abccb'."
  92. textGo "Solid rock is blocking the way."

Explanation:

New attributes also require an adjustment in the code generator.

object.awk
  1. BEGIN {
  2. count = 0;
  3. obj = "";
  4. if (pass == "c2") {
  5. print "\nOBJECT objs[] = {";
  6. }
  7. }
  9. /^- / {
  10. outputRecord(",");
  11. obj = $2;
  12. prop["description"] = "NULL";
  13. prop["tags"] = "";
  14. prop["location"] = "NULL";
  15. prop["destination"] = "NULL";
  16. prop["prospect"] = "";
  17. prop["details"] = "\"You see nothing special.\"";
  18. prop["contents"] = "\"You see\"";
  19. prop["textGo"] = "\"You can't get much closer than this.\"";
  20. prop["weight"] = "99";
  21. prop["capacity"] = "0";
  22. prop["health"] = "0";
  23. }
  25. obj && /^[ \t]+[a-z]/ {
  26. name = $1;
  27. $1 = "";
  28. if (name in prop) {
  29. prop[name] = $0;
  30. }
  31. else if (pass == "c2") {
  32. print "#error \"" FILENAME " line " NR ": unknown attribute '" name "'\"";
  33. }
  34. }
  36. !obj && pass == (/^#include/ ? "c1" : "h") {
  37. print;
  38. }
  40. END {
  41. outputRecord("\n};");
  42. if (pass == "h") {
  43. print "\n#define endOfObjs\t(objs + " count ")";
  44. }
  45. }
  47. function outputRecord(separator)
  48. {
  49. if (obj) {
  50. if (pass == "h") {
  51. print "#define " obj "\t(objs + " count ")";
  52. }
  53. else if (pass == "c1") {
  54. print "static const char *tags" count "[] = {" prop["tags"] ", NULL};";
  55. }
  56. else if (pass == "c2") {
  57. print "\t{\t/* " count " = " obj " */";
  58. print "\t\t" prop["description"] ",";
  59. print "\t\ttags" count ",";
  60. print "\t\t" prop["location"] ",";
  61. print "\t\t" prop["destination"] ",";
  62. print "\t\t" prop[prop["prospect"] ? "prospect" : "destination"] ",";
  63. print "\t\t" prop["details"] ",";
  64. print "\t\t" prop["contents"] ",";
  65. print "\t\t" prop["textGo"] ",";
  66. print "\t\t" prop["weight"] ",";
  67. print "\t\t" prop["capacity"] ",";
  68. print "\t\t" prop["health"];
  69. print "\t}" separator;
  70. delete prop;
  71. }
  72. count++;
  73. }
  74. }

Now we’re all set to start using the new attributes! details is used in a newly recognized command look <object>, and textGo replaces the fixed text “OK” in our implementation of command go.

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

--> look guard
The guard is a really big fellow.

--> get guard
That is way too heavy.

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

--> inventory
You have:
a silver coin

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

--> look guard
The guard is a really big fellow.
He has:
a silver coin

--> go cave
The guard stops you from walking into the cave.

--> go north
Dense forest is blocking the way.

--> quit

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

Attributes weight and capacity together become a possible reason for not being able to move certain objects around. And a health check replaces the hard-coded whitelist of actors.

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 (obj->weight > to->capacity)
  50. {
  51. printf("That is way too heavy.\n");
  52. }
  53. else if (obj->weight + weightOfContents(to) > to->capacity)
  54. {
  55. printf("That would become too heavy.\n");
  56. }
  57. else
  58. {
  59. describeMove(obj, to);
  60. obj->location = to;
  61. }
  62. }

Here is one more module that can use health to identify actors.

inventory.c
  1. #include <stdbool.h>
  2. #include <stdio.h>
  3. #include "object.h"
  4. #include "misc.h"
  5. #include "noun.h"
  6. #include "move.h"
  8. void executeGet(const char *noun)
  9. {
  10. OBJECT *obj = getVisible("what you want to get", noun);
  11. switch (getDistance(player, obj))
  12. {
  13. case distSelf:
  14. printf("You should not be doing that to yourself.\n");
  15. break;
  16. case distHeld:
  17. printf("You already have %s.\n", obj->description);
  18. break;
  19. case distOverthere:
  20. printf("Too far away, move closer please.\n");
  21. break;
  22. case distUnknownObject:
  23. // already handled by getVisible
  24. break;
  25. default:
  26. if (obj->location != NULL && obj->location->health > 0)
  27. {
  28. printf("You should ask %s nicely.\n", obj->location->description);
  29. }
  30. else
  31. {
  32. moveObject(obj, player);
  33. }
  34. }
  35. }
  37. void executeDrop(const char *noun)
  38. {
  39. moveObject(getPossession(player, "drop", noun), player->location);
  40. }
  42. void executeAsk(const char *noun)
  43. {
  44. moveObject(getPossession(actorHere(), "ask", noun), player);
  45. }
  47. void executeGive(const char *noun)
  48. {
  49. moveObject(getPossession(player, "give", noun), actorHere());
  50. }
  52. void executeInventory(void)
  53. {
  54. if (listObjectsAtLocation(player) == 0)
  55. {
  56. printf("You are empty-handed.\n");
  57. }
  58. }

The weight check makes use of a new function weightOfContents; it will be implemented in misc.c. In the same module, we also make modifications to some of the existing functions, to support the last few attributes.

Attribute contents replaces the fixed text “You see”. The original text was already a bit odd when listing the player’s inventory, but now that function listObjectsAtLocation is used to display contents of any possible object (see function executeLook above), we really need something more flexible.

By replacing attribute destination by prospect in function getPassage, we are improving responses to all commands (not just go and look) applied to a location that is seen lying on the other end of a ‘passage with a twist.’

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 OBJECT *getPassage(OBJECT *from, OBJECT *to);
  15. extern DISTANCE getDistance(OBJECT *from, OBJECT *to);
  16. extern OBJECT *actorHere(void);
  17. 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 obj != NULL && obj->location == container;
  9. }
  11. OBJECT *getPassage(OBJECT *from, OBJECT *to)
  12. {
  13. if (from != NULL && to != NULL)
  14. {
  15. OBJECT *obj;
  16. for (obj = objs; obj < endOfObjs; obj++)
  17. {
  18. if (isHolding(from, obj) && obj->prospect == to)
  19. {
  20. return obj;
  21. }
  22. }
  23. }
  24. return NULL;
  25. }
  27. DISTANCE getDistance(OBJECT *from, OBJECT *to)
  28. {
  29. return to == NULL ? distUnknownObject :
  30. to == from ? distSelf :
  31. isHolding(from, to) ? distHeld :
  32. isHolding(to, from) ? distLocation :
  33. isHolding(from->location, to) ? distHere :
  34. isHolding(from, to->location) ? distHeldContained :
  35. isHolding(from->location, to->location) ? distHereContained :
  36. getPassage(from->location, to) != NULL ? distOverthere :
  37. distNotHere;
  38. }
  40. OBJECT *actorHere(void)
  41. {
  42. OBJECT *obj;
  43. for (obj = objs; obj < endOfObjs; obj++)
  44. {
  45. if (isHolding(player->location, obj) && obj != player &&
  46. obj->health > 0)
  47. {
  48. return obj;
  49. }
  50. }
  51. return NULL;
  52. }
  54. int listObjectsAtLocation(OBJECT *location)
  55. {
  56. int count = 0;
  57. OBJECT *obj;
  58. for (obj = objs; obj < endOfObjs; obj++)
  59. {
  60. if (obj != player && isHolding(location, obj))
  61. {
  62. if (count++ == 0)
  63. {
  64. printf("%s:\n", location->contents);
  65. }
  66. printf("%s\n", obj->description);
  67. }
  68. }
  69. return count;
  70. }

To make the whole picture complete, it would be nice to expand the generated map from the previous chapter with dashed lines for the ‘apparent’ passages (leading towards a prospect).

map.awk
  1. BEGIN { print "digraph map {"; }
  2. /^- / { outputEdges(); delete a; }
  3. /^[ \t]/ { a[$1] = $2; }
  4. END { outputEdges(); print "}"; }
  6. function outputEdges()
  7. {
  8. outputEdge(a["location"], a["destination"], "");
  9. outputEdge(a["location"], a["prospect"], " [style=dashed]");
  10. }
  12. function outputEdge(from, to, style)
  13. {
  14. if (from && to) print "\t" from " -> " to style;
  15. }

Notes:

⭳   Download source code 🌀   Run on Repl.it

Next chapter: 11. Conditions