<title>13. The parser</title>

<link rel="stylesheet" href="htpataic.css" type="text/css" />

<table class="contents"><tr><td>

<h4>Contents</h4>

<div><a href="htpataic01.html">1. Introduction</a></div>

<div><a href="htpataic02.html">2. The main loop</a></div>

<div><a href="htpataic03.html">3. Locations</a></div>

<div><a href="htpataic04.html">4. Objects</a></div>

<div><a href="htpataic05.html">5. Inventory</a></div>

<div><a href="htpataic06.html">6. Passages</a></div>

<div><a href="htpataic07.html">7. Distance</a></div>

<div><a href="htpataic08.html">8. North, east, south, west</a></div>

<div><a href="htpataic09.html">9. Code generation</a></div>

<div><a href="htpataic10.html">10. More attributes</a></div>

<div><a href="htpataic11.html">11. Conditions</a></div>

<div><a href="htpataic12.html">12. Open and close</a></div>

<div><b>13. The parser</b></div>

<div><a href="htpataic14.html">14. Multiple nouns</a></div>

<div><a href="htpataic15.html">15. Light and dark</a></div>

<div><a href="htpataic16.html">16. Savegame</a></div>

<div><a href="htpataic17.html">17. Test automation</a></div>

<div><a href="htpataic18.html">18. Abbreviations</a></div>

<div><a href="htpataic19.html">19. Conversations</a></div>

<div><a href="htpataic20.html">20. Combat</a></div>

<div><a href="htpataic21.html">21. Multi-player</a></div>

<div><a href="htpataic22.html">22. Client-server</a></div>

<div><a href="htpataic23.html">23. Database</a></div>

<div><a href="htpataic24.html">24. Speech</a></div>

<div><a href="htpataic25.html">25. JavaScript</a></div>

<h1>How to program a text adventure in C</h1>

by Ruud Helderman

&lt;<a href="mailto:r.helderman@hccnet.nl">r.helderman@hccnet.nl</a>&gt;

Licensed under

<a href="https://github.com/helderman/htpataic/blob/master/LICENSE">MIT License</a>

<h2>13. The parser</h2>

<p class="intro">

Every text adventure has a

<a href="http://en.wikipedia.org/wiki/Parsing">parser</a>.

But there are parsers and parsers.

A simple &lsquo;verb-noun&rsquo; parser

(like the one we have been using ever since chapter 2)

could be sufficient for a carefully designed adventure game.

However,

<a href="http://en.wikipedia.org/wiki/Infocom">Infocom</a>

has proven that a more advanced parser

really helps to make an enjoyable game.

It does not have to pass the

<a href="http://en.wikipedia.org/wiki/Turing_test">Turing test</a>;

remember, it&rsquo;s only a game.

But the parser should enable the player

to express his intentions in a more or less natural way.

Our current parser mainly consists of two lines of code,

tucked away in <i>parsexec.c</i>:

<td class="snippet">char *verb = strtok(input, " \n");

char *noun = strtok(NULL, "\n");

Alright, plus the sequence of <i>strcmp</i> calls to map verbs to commands,

and the functions in <i>noun.c</i> to map nouns to objects.

But that&rsquo;s it.

This system has served us well for the past 11 chapters,

but it has its flaws.

<li>It only accepts simple commands of the form &lsquo;verb noun&rsquo;;

it does not understand sentences

with both a direct object and an indirect object, like <i>put coin in box</i>.

<li>It does accept multi-word objects (like <i>silver coin</i>),

but the

<a href="http://en.wikipedia.org/wiki/Whitespace_character">whitespace</a>

between the words must be spot-on.

Our game rejects a double space between <i>silver</i> and <i>coin</i>.

<li>It is

<a href="http://en.wikipedia.org/wiki/Case_sensitivity">case-sensitive</a>;

the command &ldquo;Go north&rdquo; is not recognized

because of the capital &lsquo;G&rsquo;.

Writing a good parser is no trivial task,

but here I will give you a relatively simple approach.

We will define a

<a href="http://en.wikipedia.org/wiki/Formal_grammar">grammar</a>

that consists of a list of <b>patterns</b>,

similar to (but much simpler than)

<a href="http://en.wikipedia.org/wiki/Regular_expression">regular expressions</a>.

Examples of patterns:

<table cellpadding="8"><tr>

<td class="snippet">look around</td>

<td class="comment">Matches just that;

double spaces, leading spaces, trailing spaces and case differences

are ignored</td>

<td class="snippet">go A</td>

<td class="comment">Matches the word <i>go</i> followed by the tag of an object

(see chapters 4 and 8 for an explanation of &lsquo;tags&rsquo;)</td>

<td class="snippet">put A in B</td>

<td class="comment">Matches the word <i>put</i> followed by

a tag, the word <i>in</i>, and another tag</td>

To parse the user&rsquo;s input,

we will traverse the list of patterns from top to bottom,

trying to match the user&rsquo;s input with each pattern in turn.

We will stop at the first match found.

For the sake of simplicity, we will not make use of

<a href="http://en.wikipedia.org/wiki/Backtracking">backtracking</a>,

though this could be added later.

Uppercase letters are the

<a href="http://en.wikipedia.org/wiki/Nonterminal_symbol">nonterminal symbols</a>

in our grammar;

they match <b>any tag</b> (of any object).

Matching is

<a href="https://en.wikipedia.org/wiki/Greedy_algorithm">greedy</a>;

when the parser has a choice between two different tags

(for example &lsquo;silver coin&rsquo; and &lsquo;silver&rsquo;),

the longer tag will take precedence.

The matching tag can then be passed as parameter <i>noun</i>

to one of the <i>execute</i> functions.

For commands with more than one noun (introduced in the next chapter),

parameter passing becomes a bit unpractical.

For simplicity, I will use a

<a href="http://en.wikipedia.org/wiki/Global_variable">global variable</a>

instead of parameters (despite the bad reputation of global variables).

The variable will be an array of string pointers.

<td class="snippet">const char *params[26];

The array has 26 elements; one for each (uppercase) letter in the alphabet.

That is sufficient for upto 26 different nonterminals in a single pattern.

For every nonterminal in a (matching) pattern,

a matching tag will be &lsquo;captured&rsquo; by filling

the nonterminal&rsquo;s array element with a pointer to that particular tag.

params[0] (the first array element) captures nonterminal &lsquo;A&rsquo;,

params[1] captures &lsquo;B&rsquo;, and so forth.

A simple macro can be used

to find the array element that belongs to a given nonterminal.

<td class="snippet">#define paramByLetter(letter) (params + (letter) - 'A')

Note: you may find the array length of 26 a bit over the top,

but it does save me the trouble of writing some

<a href="http://en.wikipedia.org/wiki/Bounds_checking">bounds checking</a>

code to prevent a

<a href="http://en.wikipedia.org/wiki/Buffer_overflow">buffer overflow</a>

in case of a malformed pattern.

Now we have to think of a way to handle missing or unrecognized nouns.

Suppose the user makes a typo and enters &ldquo;go kave&rdquo;.

Question is, should this command match the pattern &ldquo;go A&rdquo; or not?

If we don&rsquo;t, then the command will fail to match <i>any</i> pattern

and end up in a generic error handler, which will probably reply with

something like &ldquo;I don&rsquo;t know how to <i>go kave</i>&rdquo;.

This takes away every opportunity

to improve these &lsquo;negative responses&rsquo;;

a reply &ldquo;I don&rsquo;t understand where you want to go&rdquo;

already feels a lot more natural.

It would be best to maintain all replies concerning command <i>go</i>

inside function <i>executeGo</i>.

There are a few ways to achieve this, but the easiest one is

to allow nonterminals to match <i>anything</i>;

so not just a valid tag, but also total gibberish, blanks or just nothing.

This &lsquo;invalid&rsquo; input will be captured as an empty string

(&ldquo;&rdquo;).

Having such a &lsquo;loose&rsquo; nonterminal in the middle of a pattern

does complicate the pattern matching process; it would require

<a href="http://en.wikipedia.org/wiki/Backtracking">backtracking</a>

to properly align the word &lsquo;in&rsquo;

when matching input &ldquo;put foo in in box&rdquo;

with pattern &ldquo;put A in B&rdquo;.

To keep things simple, we will <i>only</i> enable this loose matching

for nonterminals that occur at the very end of a pattern.

To be able to properly match the example above, we need two separate patterns:

<li>Pattern &ldquo;put A in B&rdquo; will match

the valid command <i>put coin in box</i>,

as well as the invalid commands

<i>put coin in booox</i> and <i>put coin in</i>.

Note that the nonterminal A only matches valid tags

(in this case <i>coin</i>).

<li>Pattern &ldquo;put A&rdquo; matches

all remaining invalid commands:

<i>put coin</i>,

<i>put koin</i>,

<i>put koin in box</i>,

<i>put koin in booox</i> and a bare <i>put</i>.

And also the initial example (<i>put foo in in box</i>).

The order of the patterns is vital here:

if &ldquo;put A&rdquo; would be on top (meaning it will be tried first),

then it would consume every <i>put</i> command;

a valid &ldquo;put coin in box&rdquo; would be considered invalid

because there is no tag &ldquo;coin in box.&rdquo;

The same goes for commands that appear in multiple forms, such as <i>look</i>.

<li>&ldquo;look around&rdquo;</li>

<li>&ldquo;look&rdquo; (as an abbreviation of <i>look around</i>)</li>

<li>&ldquo;look A&rdquo;</li>

The first two patterns can be in any order,

but the third one <i>must</i> come last.

Time to put this into action.

We will discard the existing contents of module <i>parsexec.c</i>,

and replace it by a new implementation of function <i>parseAndExecute</i>

using a list of patterns

that should be able to match every command we have implemented so far.

Each pattern is tied to a function that executes the appropriate command.

<table class="code"><tr>

<th>parsexec.h</th>

<li class="new">extern bool parseAndExecute(const char *input);</li>

<th>parsexec.c</th>

<li class="new">#include &lt;ctype.h&gt;</li>

<li class="new">#include &lt;stdbool.h&gt;</li>

<li class="new">#include &lt;stdio.h&gt;</li>

<li class="new">#include "object.h"</li>

<li class="new">#include "misc.h"</li>

<li class="new">#include "match.h"</li>

<li class="new">#include "location.h"</li>

<li class="new">#include "inventory.h"</li>

<li class="new">#include "openclose.h"</li>

<li class="new"></li>

<li class="new">typedef struct</li>

<li class="new">{</li>

<li class="new"> const char *pattern;</li>

<li class="new"> bool (*function)(void);</li>

<li class="new">} COMMAND;</li>

<li class="new"></li>

<li class="new">static bool executeQuit(void)</li>

<li class="new">{</li>

<li class="new"> return false;</li>

<li class="new">}</li>

<li class="new"></li>

<li class="new">static bool executeNoMatch(void)</li>

<li class="new">{</li>

<li class="new"> const char *src = *params;</li>

<li class="new"> int len;</li>

<li class="new"> for (len = 0; src[len] != '\0' &amp;&amp; !isspace(src[len]); len++);</li>

<li class="new"> if (len &gt; 0) printf("I don't know how to '%.*s'.\n", len, src);</li>

<li class="new"> return true;</li>

<li class="new">}</li>

<li class="new"></li>

<li class="new">bool parseAndExecute(const char *input)</li>

<li class="new">{</li>

<li class="new"> static const COMMAND commands[] =</li>

<li class="new"> {</li>

<li class="new"> { "quit" , executeQuit },</li>

<li class="new"> { "look" , executeLookAround },</li>

<li class="new"> { "look around" , executeLookAround },</li>

<li class="new"> { "look at A" , executeLook },</li>

<li class="new"> { "look A" , executeLook },</li>

<li class="new"> { "examine A" , executeLook },</li>

<li class="new"> { "go to A" , executeGo },</li>

<li class="new"> { "go A" , executeGo },</li>

<li class="new"> { "get A" , executeGet },</li>

<li class="new"> { "drop A" , executeDrop },</li>

<li class="new"> { "ask A" , executeAsk },</li>

<li class="new"> { "give A" , executeGive },</li>

<li class="new"> { "inventory" , executeInventory },</li>

<li class="new"> { "open A" , executeOpen },</li>

<li class="new"> { "close A" , executeClose },</li>

<li class="new"> { "lock A" , executeLock },</li>

<li class="new"> { "unlock A" , executeUnlock },</li>

<li class="new"> { "A" , executeNoMatch }</li>

<li class="new"> };</li>

<li class="new"> const COMMAND *cmd;</li>

<li class="new"> for (cmd = commands; !matchCommand(input, cmd-&gt;pattern); cmd++);</li>

<li class="new"> return (*cmd-&gt;function)();</li>

<li class="new">}</li>

<div class="explanation">

Explanation:

<li>Line 1:

from <a href="http://en.wikipedia.org/wiki/Ctype.h">ctype.h</a>,

we will be using <i>isspace</i> (line 26),

which provides a more complete

<a href="http://en.wikipedia.org/wiki/Whitespace_(computer_science)">whitespace</a>

test than a simple comparison with

<a href="http://en.wikipedia.org/wiki/Space_character">space</a>

(it also matches

<a href="http://en.wikipedia.org/wiki/Tab_character">tab</a>,

among others).

<li>Line 11-15:

type <i>COMMAND</i> is a structure that combines a pattern with a function.

<li>Line 17-29:

a few generic handlers.

<li>Line 26:

this loop calculates the length of the first word entered by the player;

we assume this is supposed to be the (unrecognized) verb.

<li>Line 27:

we use a special format specifier <code>%.*s</code>

to print only the first <i>len</i> characters of <i>src</i>.

<li>Line 33-53:

the array of patterns.

<li>Line 38-40:

<a href="https://en.wikipedia.org/wiki/Synonym">synonyms</a>

are simple: just map different patterns to the same function.

<li>Line 52:

the last pattern should always be &ldquo;A&rdquo;;

this pattern matches <i>anything</i> and so it will pick up

everything that hasn&rsquo;t been matched by preceding patterns.

<li>Line 55:

this loop scans though all patterns from top to bottom;

it stops at the first pattern that matches.

The &lsquo;sure match&rsquo; on line 52 ensures

the loop will never pass the end of the array.

<li>Line 56:

the function that belongs to the matching pattern is called.

The hardest part is the implementation of function <i>matchCommand</i>.

But as you can see below, that too can be done in less than 100 lines of code.

<table class="code"><tr>

<th>match.h</th>

<li class="new">#define MAX_PARAMS 26</li>

<li class="new"></li>

<li class="new">extern const char *params[];</li>

<li class="new"></li>

<li class="new">#define paramByLetter(letter) (params + (letter) - 'A')</li>

<li class="new"></li>

<li class="new">extern bool matchCommand(const char *src, const char *pattern);</li>

<th>match.c</th>

<li class="new">#include &lt;ctype.h&gt;</li>

<li class="new">#include &lt;stdbool.h&gt;</li>

<li class="new">#include &lt;string.h&gt;</li>

<li class="new">#include "object.h"</li>

<li class="new">#include "misc.h"</li>

<li class="new">#include "match.h"</li>

<li class="new"></li>

<li class="new">const char *params[MAX_PARAMS];</li>

<li class="new"></li>

<li class="new">static const char *skipSpaces(const char *src)</li>

<li class="new">{</li>

<li class="new"> while (isspace(*src)) src++;</li>

<li class="new"> return src;</li>

<li class="new">}</li>

<li class="new"></li>

<li class="new">static const char *matchSpaces(const char *src)</li>

<li class="new">{</li>

<li class="new"> return *src == '\0' || isspace(*src) ? skipSpaces(src) : NULL;</li>

<li class="new">}</li>

<li class="new"></li>

<li class="new">static const char *matchTerminal(const char *src, char terminal)</li>

<li class="new">{</li>

<li class="new"> return terminal == ' ' ? matchSpaces(src) :</li>

<li class="new"> tolower(*src) == tolower(terminal) ? src + 1 : NULL;</li>

<li class="new">}</li>

<li class="new"></li>

<li class="new">static const char *matchTag(const char *src, const char *tag, bool atEnd)</li>

<li class="new">{</li>

<li class="new"> while (src != NULL &amp;&amp; *tag != '\0')</li>

<li class="new"> {</li>

<li class="new"> src = matchTerminal(src, *tag++);</li>

<li class="new"> }</li>

<li class="new"> return atEnd &amp;&amp; src != NULL &amp;&amp; *skipSpaces(src) != '\0' ? NULL : src;</li>

<li class="new">}</li>

<li class="new"></li>

<li class="new">static const char *matchParam(const char *src, const char **par, bool loose)</li>

<li class="new">{</li>

<li class="new"> const char *restOfSrc = loose ? src + strlen(src) : NULL;</li>

<li class="new"> OBJECT *obj;</li>

<li class="new"> for (obj = objs; obj &lt; endOfObjs; obj++)</li>

<li class="new"> {</li>

<li class="new"> const char **tag;</li>

<li class="new"> for (tag = obj-&gt;tags; *tag != NULL; tag++)</li>

<li class="new"> {</li>

<li class="new"> const char *behindMatch = matchTag(src, *tag, loose);</li>

<li class="new"> if (behindMatch != NULL &amp;&amp; strlen(*tag) &gt; strlen(*par))</li>

<li class="new"> {</li>

<li class="new"> *par = *tag;</li>

<li class="new"> restOfSrc = behindMatch;</li>

<li class="new"> }</li>

<li class="new"> }</li>

<li class="new"> }</li>

<li class="new"> if (**par == '\0')</li>

<li class="new"> {</li>

<li class="new"> *par = src;</li>

<li class="new"> }</li>

<li class="new"> return restOfSrc;</li>

<li class="new">}</li>

<li class="new"></li>

<li class="new">bool matchCommand(const char *src, const char *pattern)</li>

<li class="new">{</li>

<li class="new"> const char **par;</li>

<li class="new"> for (par = params; par &lt; params + MAX_PARAMS; par++)</li>

<li class="new"> {</li>

<li class="new"> *par = "";</li>

<li class="new"> }</li>

<li class="new"> for (src = skipSpaces(src); src != NULL &amp;&amp; *pattern != '\0'; pattern++)</li>

<li class="new"> {</li>

<li class="new"> src = isupper(*pattern)</li>

<li class="new"> ? matchParam(src, paramByLetter(*pattern), pattern[1] == '\0')</li>

<li class="new"> : matchTerminal(src, *pattern);</li>

<li class="new"> }</li>

<li class="new"> return src != NULL &amp;&amp; *skipSpaces(src) == '\0';</li>

<li class="new">}</li>

<div class="explanation">

Explanation:

<li>Line 16-19:

function <i>matchSpaces</i>

tries to match a stretch of whitespace, either between two words,

or (possibly zero-width) at the end of the input string.

As with most of the functions in this module,

parsing starts at the character pointed to by parameter <i>src</i>;

the return value is either a pointer to the position in the input string

that immediately follows the match

(in this case, to the first non-whitespace character encountered;

this <i>may</i> be the NUL character denoting end-of-string),

or NULL, meaning no match was found

(in this case, if there was a non-whitespace character at the start position).

<li>Line 21-25:

function <i>matchTerminal</i> matches a particular character,

case-insensitively.

If the required character (parameter <i>terminal</i>) is a space,

the match is a stretch of (whitespace) characters, as explained above.

<li>Line 27-34:

function <i>matchTag</i> matches a particular word, case-insensitively.

If parameter <i>atEnd</i> is true,

then matching will only succeed if the word is last in the input string.

<li>Line 36-58:

function <i>matchParam</i> matches and captures a nonterminal.

All tags of all objects will be scanned to find the longest matching tag.

The array element pointed to by <i>par</i>

will be filled with a pointer to the matching tag (if any).

Set parameter <i>loose</i> to match a &lsquo;loose&rsquo; nonterminal;

this will always consume the entire input string

(i.e. return a pointer to the end-of-string character),

regardless of whether there is a tag to satisfy this match.

<li>Line 53-56:

if no matching tag is found, then the remaining input is captured.

This can be used to included the non-matching input in an error message;

we do this in function <i>executeNoMatch</i>, defined in <i>parsexec.c</i>.

<li>Line 60-74:

function <i>matchCommand</i> matches an entire pattern,

capturing nonterminals into array <i>params</i>.

We adjust the implementations of the various commands

to make use of the new array <i>params</i>.

<table class="demo">

<tr><th>Sample output</th></tr>

Welcome to Little Cave Adventure.<br />

You are in an open field.<br />

You see:<br />

a silver coin<br />

a burly guard<br />

a cave entrance to the east<br />

dense forest all around<br />

<br />

--&gt; get coin<br />

You pick up a silver coin.<br />

<br />

--&gt; give coin<br />

You give a silver coin to a burly guard.<br />

<br />

--&gt; go cave<br />

You walk into the cave.<br />

<br />

You are in a little cave.<br />

You see:<br />

an exit to the west<br />

solid rock all around<br />

a closed door to the south<br />

a tiny key<br />

<br />

--&gt; get key<br />

You pick up a tiny key.<br />

<br />

--&gt; go south<br />

The door is closed.<br />

<br />

--&gt; open door<br />

You open a closed door to the south.<br />

<br />

--&gt; go south<br />

You walk through the door into a backroom.<br />

<br />

You are in a backroom.<br />

You see:<br />

solid rock all around<br />

an open door to the north<br />

a wooden box<br />

<br />

--&gt; unlock box<br />

You unlock a wooden box.<br />

<br />

--&gt; open box<br />

You open a wooden box.<br />

<br />

--&gt; examine box<br />

The box is open.<br />

You see:<br />

a gold coin<br />

<br />

--&gt; get gold<br />

You get a gold coin from a wooden box.<br />

<br />

--&gt; quit<br />

<br />

Bye!<br />

<table class="code"><tr>

<th>inventory.h</th>

<li class="new">extern bool executeGet(void);</li>

<li class="new">extern bool executeDrop(void);</li>

<li class="new">extern bool executeAsk(void);</li>

<li class="new">extern bool executeGive(void);</li>

<li class="new">extern bool executeInventory(void);</li>

<th>inventory.c</th>

<li class="old">#include &lt;stdbool.h&gt;</li>

<li class="old">#include &lt;stdio.h&gt;</li>

<li class="old">#include "object.h"</li>

<li class="old">#include "misc.h"</li>

<li class="new"><span class="old">#include </span>"match.h"</li>

<li class="new">#include<span class="old"> "noun.h"</span></li>

<li class="old">#include "move.h"</li>

<li class="old"></li>

<li class="new">bool executeGet(void)</li>

<li class="old">{</li>

<li class="new"><span class="old"> OBJECT *obj = getVisible("what you want to get", </span>params[0]);</li>

<li class="old"> switch (getDistance(player, obj))</li>

<li class="old"> {</li>

<li class="old"> case distSelf:</li>

<li class="old"> printf("You should not be doing that to yourself.\n");</li>

<li class="old"> break;</li>

<li class="old"> case distHeld:</li>

<li class="old"> printf("You already have %s.\n", obj-&gt;description);</li>

<li class="old"> break;</li>

<li class="old"> case distOverthere:</li>

<li class="old"> printf("Too far away, move closer please.\n");</li>

<li class="old"> break;</li>

<li class="old"> case distUnknownObject:</li>

<li class="old"> // already handled by getVisible</li>

<li class="old"> break;</li>

<li class="old"> default:</li>

<li class="old"> if (obj-&gt;location != NULL &amp;&amp; obj-&gt;location-&gt;health &gt; 0)</li>

<li class="old"> {</li>

<li class="old"> printf("You should ask %s nicely.\n", obj-&gt;location-&gt;description);</li>

<li class="old"> }</li>

<li class="old"> else</li>

<li class="old"> {</li>

<li class="old"> moveObject(obj, player);</li>

<li class="old"> }</li>

<li class="old"> }</li>

<li class="new"><span class="old"> </span>return true;</li>

<li class="old">}</li>

<li class="old"></li>

<li class="new">bool executeDrop(void)</li>

<li class="old">{</li>

<li class="new"><span class="old"> moveObject(getPossession(player, "drop", </span>params[0]),<span class="old"> player-&gt;location);</span></li>

<li class="new"><span class="old"> </span>return true;</li>

<li class="old">}</li>

<li class="old"></li>

<li class="new">bool executeAsk(void)</li>

<li class="old">{</li>

<li class="new"><span class="old"> moveObject(getPossession(actorHere(), "ask", </span>params[0]),<span class="old"> player);</span></li>

<li class="new"><span class="old"> </span>return true;</li>

<li class="old">}</li>

<li class="old"></li>

<li class="new">bool executeGive(void)</li>

<li class="old">{</li>

<li class="new"><span class="old"> moveObject(getPossession(player, "give", </span>params[0]),<span class="old"> actorHere());</span></li>

<li class="new"><span class="old"> </span>return true;</li>

<li class="old">}</li>

<li class="old"></li>

<li class="new">bool<span class="old"> executeInventory(void)</span></li>

<li class="old">{</li>

<li class="old"> if (listObjectsAtLocation(player) == 0)</li>

<li class="old"> {</li>

<li class="old"> printf("You are empty-handed.\n");</li>

<li class="old"> }</li>

<li class="new"><span class="old"> </span>return true;</li>

<li class="old">}</li>

Same thing for the module we added in the previous chapter.

<table class="code"><tr>

<th>openclose.h</th>

<li class="new">extern bool executeOpen(void);</li>

<li class="new">extern bool executeClose(void);</li>

<li class="new">extern bool executeLock(void);</li>

<li class="new">extern bool executeUnlock(void);</li>

<th>openclose.c</th>

<li class="old">#include &lt;stdbool.h&gt;</li>

<li class="old">#include &lt;stdio.h&gt;</li>

<li class="old">#include "object.h"</li>

<li class="new"><span class="old">#include </span>"match.h"</li>

<li class="new">#include<span class="old"> "reach.h"</span></li>

<li class="old"></li>

<li class="new">bool executeOpen(void)</li>

<li class="old">{</li>

<li class="new"><span class="old"> OBJECT *obj = reachableObject("what you want to open", </span>params[0]);</li>

<li class="old"> if (obj != NULL) (*obj-&gt;open)();</li>

<li class="new"><span class="old"> </span>return true;</li>

<li class="old">}</li>

<li class="old"></li>

<li class="new">bool executeClose(void)</li>

<li class="old">{</li>

<li class="new"><span class="old"> OBJECT *obj = reachableObject("what you want to close", </span>params[0]);</li>

<li class="old"> if (obj != NULL) (*obj-&gt;close)();</li>

<li class="new"><span class="old"> </span>return true;</li>

<li class="old">}</li>

<li class="old"></li>

<li class="new">bool executeLock(void)</li>

<li class="old">{</li>

<li class="new"><span class="old"> OBJECT *obj = reachableObject("what you want to lock", </span>params[0]);</li>

<li class="old"> if (obj != NULL) (*obj-&gt;lock)();</li>

<li class="new"><span class="old"> </span>return true;</li>

<li class="old">}</li>

<li class="old"></li>

<li class="new">bool executeUnlock(void)</li>

<li class="old">{</li>

<li class="new"><span class="old"> OBJECT *obj = reachableObject("what you want to unlock", </span>params[0]);</li>

<li class="old"> if (obj != NULL) (*obj-&gt;unlock)();</li>

<li class="new"><span class="old"> </span>return true;</li>

<li class="old">}</li>

In <i>location.c</i>, the command <i>look around</i> is given its own function,

separate from the <i>look</i> command to inspect specific objects

(see lines 7-12).

<table class="code"><tr>

<th>location.h</th>

<li class="new"><span class="old">extern </span>bool executeLookAround(void);</li>

<li class="new"><span class="old">extern </span>bool executeLook(void);</li>

<li class="new">extern bool executeGo(void);</li>

<th>location.c</th>

<li class="old">#include &lt;stdbool.h&gt;</li>

<li class="old">#include &lt;stdio.h&gt;</li>

<li class="old">#include "object.h"</li>

<li class="old">#include "misc.h"</li>

<li class="new"><span class="old">#include </span>"match.h"</li>

<li class="new">#include<span class="old"> "noun.h"</span></li>

<li class="old"></li>

<li class="new">bool executeLookAround(void)</li>

<li class="old">{</li>

<li class="old"> printf("You are in %s.\n", player-&gt;location-&gt;description);</li>

<li class="old"> listObjectsAtLocation(player-&gt;location);</li>

<li class="new"><span class="old"> </span>return true;</li>

<li class="old">}</li>

<li class="old"></li>

<li class="new">bool executeLook(void)</li>

<li class="old">{</li>

<li class="new"><span class="old"> OBJECT *obj = getVisible("what you want to look at", </span>params[0]);</li>

<li class="old"> switch (getDistance(player, obj))</li>

<li class="old"> {</li>

<li class="old"> case distHereContained:</li>

<li class="old"> printf("Hard to see, try to get it first.\n");</li>

<li class="old"> break;</li>

<li class="old"> case distOverthere:</li>

<li class="old"> printf("Too far away, move closer please.\n");</li>

<li class="old"> break;</li>

<li class="old"> case distNotHere:</li>

<li class="new"><span class="old"> printf("You don't see any %s here.\n", </span>params[0]);</li>

<li class="old"> break;</li>

<li class="old"> case distUnknownObject:</li>

<li class="old"> // already handled by getVisible</li>

<li class="old"> break;</li>

<li class="old"> default:</li>

<li class="old"> printf("%s\n", obj-&gt;details);</li>

<li class="old"> listObjectsAtLocation(obj);</li>

<li class="old"> }</li>

<li class="new"><span class="old"> </span>return true;</li>