\minorsection itemcnt\par
{\tt itemcnt: function({\it  list })}:
Returns a count of the ``listable'' objects in {\it list}.  An
object is listable (that is, it shows up in a room's description)
if its {\tt isListed} property is {\tt true}.  This function is
useful for determining how many objects (if any) will be listed
in a room's description.


\minorsection listcont\par
{\tt listcont: function({\it  obj })}:
This function displays the contents of an object, separated by
commas.  The {\tt thedesc} properties of the contents are used.
It is up to the caller to provide the introduction to the list
(usually something to the effect of ``The box contains'' is
displayed before calling {\tt listcont}) and finishing the
sentence (usually by displaying a period).  An object is listed
only if its {\tt isListed} property is {\tt true}.


\minorsection listfixedcontcont\par
{\tt listfixedcontcont: function({\it  obj })}:
List the contents of the contents of any {\tt fixeditem} objects
in the {\tt contents} list of the object {\it obj}.  This routine
makes sure that all objects that can be taken are listed somewhere
in a room's description.  This routine recurses down the contents
tree, following each branch until either something has been listed
or the branch ends without anything being listable.  This routine
displays a complete sentence, so no introductory or closing text
is needed.


\minorsection listcontcont\par
{\tt listcontcont: function({\it  obj })}:
This function lists the contents of the contents of an object.
It displays full sentences, so no introductory or closing text
is required.  Any item in the {\tt contents} list of the object
{\it obj} whose {\tt contentsVisible} property is {\tt true} has
its contents listed.  An Object whose {\tt isqcontainer} or
{\tt isqsurface} property is {\tt true} will not have its
contents listed.


\minorsection turncount\par
{\tt turncount: function({\it  parm })}:
This function can be used as a daemon (normally set up in the {\tt init}
function) to update the turn counter after each turn.  This routine
increments {\tt global.turnsofar}, and then calls {\tt setscore} to
update the status line with the new turn count.


\minorsection addweight\par
{\tt addweight: function({\it  list })}:
Adds the weights of the objects in {\it list} and returns the sum.
The weight of an object is given by its {\tt weight} property.  This
routine includes the weights of all of the contents of each object,
and the weights of their contents, and so forth.


\minorsection addbulk\par
{\tt addbulk: function({\it  list })}:
This function returns the sum of the bulks (given by the {\tt bulk}
property) of each object in {\it list}.  The value returned includes
only the bulk of each object in the list, and {\it not} of the contents
of the objects, as it is assumed that an object does not change in
size when something is put inside it.  You can easily change this
assumption for special objects (such as a bag that stretches as
things are put inside) by writing an appropriate {\tt bulk} method
for that object.


\minorsection incscore\par
{\tt incscore: function({\it  amount })}:
Adds {\it amount} to the total score, and updates the status line
to reflect the new score.  The total score is kept in {\tt global.score}.
Always use this routine rather than changing {\tt global.score}
directly, since this routine ensures that the status line is
updated with the new value.


\minorsection initSearch\par
{\tt initSearch:  function}.
Initializes the containers of objects with a {\tt searchLoc}, {\tt underLoc},
and {\tt behindLoc} by setting up {\tt searchCont}, {\tt underCont}, and
{\tt behindCont} lists, respectively.  You should call this function once in
your {\tt preinit} (or {\tt init}, if you prefer) function to ensure that
the underable, behindable, and searchable objects are set up correctly.


\minorsection nestedroom\par
{\tt nestedroom:  room}.
A special kind of room that is inside another room; chairs and
some types of vehicles, such as inflatable rafts, fall into this
category.  Note that a room can be within another room without
being a {\tt nestedroom}, simply by setting its {\tt location} property
to another room.  The {\tt nestedroom} is different from an ordinary
room, though, in that it's an ``open'' room; that is, when inside it,
the actor is still really inside the enclosing room for purposes of
descriptions.  Hence, the player sees ``Laboratory, in the chair."
In addition, a {\tt nestedroom} is an object in its own right,
visible to the player; for example, a chair is an object in a
room in addition to being a room itself.


\minorsection chairitem\par
{\tt chairitem:  fixeditem, nestedroom, surface}.
Acts like a chair:  actors can sit on the object.  While sitting
on the object, an actor can't go anywhere until standing up, and
can only reach objects that are on the chair and in the chair's
{\tt reachable} list.  By default, nothing is in the {\tt reachable}
list.  Note that there is no real distinction made between chairs
and beds, so you can sit or lie on either; the only difference is
the message displayed describing the situation.


\minorsection beditem\par
{\tt beditem:  chairitem}.
This object is the same as a {\tt chairitem}, except that the player
is described as lying on, rather than sitting in, the object.


\minorsection thing\par
{\tt thing:  object}.
The basic class for objects in a game.  The property {\tt contents}
is a list that specifies what is in the object; this property is
automatically set up by the system after the game is compiled to
contain a list of all objects that have this object as their
{\tt location} property.  The {\tt contents} property is kept
consistent with the {\tt location} properties of referenced objects
by the {\tt moveInto} method; always use {\tt moveInto} rather than
directly setting a {\tt location} property for this reason.  The
{\tt adesc} method displays the name of the object with an indefinite
article; the default is to display ``a'' followed by the {\tt sdesc},
but objects that need a different indefinite article (such as ``an''
or ``some'') should override this method.  Likewise, {\tt thedesc}
displays the name with a definite article; by default, {\tt thedesc}
displays ``the'' followed by the object's {\tt sdesc}.  The {\tt sdesc}
simply displays the object's name (``short description'') without
any articles.  The {\tt ldesc} is the long description, normally
displayed when the object is examined by the player; by default,
the {\tt ldesc} displays ``It looks like an ordinary {\tt sdesc}.''
The {\tt isIn({\it object})} method returns {\tt true} if the
object's location is the specified {\it object} or the object's
{\tt location} is an object whose {\tt contentsVisible} property is
{\tt true} and that object's {\tt isIn({\it object})} method is
{\tt true}.  Note that if {\tt isIn} is {\tt true}, it doesn't
necessarily mean the object is reachable, because {\tt isIn} is
{\tt true} if the object is merely visible within the location.
The {\tt thrudesc} method displays a message for when the
player looks through the object (objects such as windows would
use this property).  The {\tt moveInto({\it object})} method
moves the object to be inside the specified {\it object}.
To make an object disappear, move it into {\tt nil}.


\minorsection item\par
{\tt item:  thing}.
A basic item which can be picked up by the player.  It has no weight
(0) and minimal bulk (1).  The {\tt weight} property should be set
to a non-zero value for heavy objects.  The {\tt bulk} property
should be set to a value greater than 1 for bulky objects, and to
zero for objects that are very small and take essentially no effort
to hold---or, more precisely, don't detract at all from the player's
ability to hold other objects (for example, a piece of paper).


\minorsection lightsource\par
{\tt lightsource:  item}.
A portable lamp, candle, match, or other source of light.  The
light source can be turned on and off with the {\tt islit} property.
If {\tt islit} is {\tt true}, the object provides light, otherwise it's
just an ordinary object.


\minorsection hiddenItem\par
{\tt hiddenItem:  object}.
This is an object that is hidden with one of the {\tt hider} classes. 
A {\tt hiddenItem} object doesn't have any special properties in its
own right, but all objects hidden with one of the {\tt hider} classes
must be of class {\tt hiddenItem} so that {\tt initSearch} can find
them.


\minorsection hider\par
{\tt hider:  item}.
This is a basic class of object that can hide other objects in various
ways.  The {\tt underHider}, {\tt behindHider}, and {\tt searchHider} classes
are examples of {\tt hider} subclasses.  The class defines
the method {\tt searchObj({\it actor, list})}, which is given the list
of hidden items contained in the object (for example, this would be the
{\tt underCont} property, in the case of an {\tt underHider}), and ``finds''
the object or objects. Its action is dependent upon a couple of other
properties of the {\tt hider} object.  The {\tt serialSearch} property,
if {\tt true}, indicates that items in the list are to be found one at
a time; if {\tt nil} (the default), the entire list is found on the
first try.  The {\tt autoTake} property, if {\tt true}, indicates that
the actor automatically takes the item or items found; if {\tt nil}, the
item or items are moved to the actor's location.  The {\tt searchObj} method
returns the {\it list} with the found object or objects removed; the
caller should assign this returned value back to the appropriate
property (for example, {\tt underHider} will assign the return value
to {\tt underCont}).

Note that because the {\tt hider} is hiding something, this class
overrides the normal {\tt verDoSearch} method to display the
message, ``You'll have to be more specific about how you want
to search that.''  The reason is that the normal {\tt verDoSearch}
message (``You find nothing of interest'') leads players to believe
that the object was exhaustively searched, and we want to avoid
misleading the player.  On the other hand, we don't want a general
search to be exhaustive for most {\tt hider} objects.  So, we just
display a message letting the player know that the search was not
enough, but we don't give away what they have to do instead.

The objects hidden with one of the {\tt hider} classes must be
of class {\tt hiddenItem}.


\minorsection underHider\par
{\tt underHider:  hider}.
This is an object that can have other objects placed under it.  The
objects placed under it can only be found by looking under the object;
see the description of {\tt hider} for more information.   You
should set the {\tt underLoc} property of each hidden object to point
to the {\tt underHider}.

Note that an {\tt underHider} doesn't allow the {\it player} to put anything
under the object during the game.  Instead, it's to make it easy for the
game writer to set up hidden objects while implementing the game.  All you
need to do to place an object under another object is declare the top
object as an {\tt underHider}, then declare the hidden object normally,
except use {\tt underLoc} rather than {\tt location} to specify the
location of the hidden object.  The {\tt behindHider} and {\tt searchHider}
objects work similarly.

The objects hidden with {\tt underHider} must be of class {\tt hiddenItem}.


\minorsection behindHider\par
{\tt behindHider:  hider}.
This is just like an {\tt underHider}, except that objects are hidden
behind this object.  Objects to be behind this object should have their
{\tt behindLoc} property set to point to this object.

The objects hidden with {\tt behindHider} must be of class {\tt hiddenItem}.


\minorsection searchHider\par
{\tt searchHider:  hider}.
This is just like an {\tt underHider}, except that objects are hidden
within this object in such a way that the object must be looked in
or searched.  Objects to be hidden in this object should have their
{\tt searchLoc} property set to point to this object.  Note that this
is different from a normal container, in that the objects hidden within
this object will not show up until the object is explicitly looked in
or searched.

The items hidden with {\tt searchHider} must be of class {\tt hiddenItem}.


\minorsection fixeditem\par
{\tt fixeditem:  thing}.
An object that cannot be taken or otherwise moved from its location.
Note that a {\tt fixeditem} is sometimes part of a movable object;
this can be done to make one object part of another, ensuring that
they cannot be separated.  By default, the functions that list a room's
contents do not automatically describe {\tt fixeditem} objects (because
the {\tt isListed} property is set to {\tt nil}).  Instead, the game author
will generally describe the {\tt fixeditem} objects separately as part of
the room's {\tt ldesc}.  


\minorsection readable\par
{\tt readable:  item}.
An item that can be read.  The {\tt readdesc} property is displayed
when the item is read.  By default, the {\tt readdesc} is the same
as the {\tt ldesc}, but the {\tt readdesc} can be overridden to give
a different message.


\minorsection fooditem\par
{\tt fooditem:  item}.
An object that can be eaten.  When eaten, the object is removed from
the game, and {\tt global.lastMealTime} is decremented by the
{\tt foodvalue} property.  By default, the {\tt foodvalue} property
is {\tt global.eatTime}, which is the time between meals.  So, the
default {\tt fooditem} will last for one ``nourishment interval.''


\minorsection dialItem\par
{\tt dialItem:  fixeditem}.
This class is used for making ``dials,'' which are controls in
your game that can be turned to a range of numbers.  You must
define the property {\tt maxsetting} as a number specifying the
highest number to which the dial can be turned; the lowest number
on the dial is always 1.  The {\tt setting} property is the dial's
current setting, and can be changed by the player by typing the
command ``turn dial to {\it number}.''  By default, the {\tt ldesc}
method displays the current setting.


\minorsection switchItem\par
{\tt switchItem:  fixeditem}.
This is a class for things that can be turned on and off by the
player.  The only special property is {\tt isActive}, which is {\tt nil}
if the switch is turned off and {\tt true} when turned on.  The object
accepts the commands ``turn it on'' and ``turn it off,'' as well as
synonymous constructions, and updates {\tt isActive} accordingly.


\minorsection room\par
{\tt room:  thing}.
A location in the game.  By default, the {\tt islit} property is
{\tt true}, which means that the room is lit (no light source is
needed while in the room).  You should create a {\tt darkroom}
object rather than a {\tt room} with {\tt islit} set to {\tt nil} if you
want a dark room, because other methods are affected as well.
The {\tt isseen} property records whether the player has entered
the room before; initially it's {\tt nil}, and is set to {\tt true}
the first time the player enters.  The {\tt roomAction({\it actor,
verb, directObject, preposition, indirectObject})} method is
activated for each player command; by default, all it does is
call the room's location's {\tt roomAction} method if the room
is inside another room.  The {\tt lookAround({\it verbosity})}
method displays the room's description for a given verbosity
level; {\tt true} means a full description, {\tt nil} means only
the short description (just the room name plus a list of the
objects present).  {\tt roomDrop({\it object})} is called when
an object is dropped within the room; normally, it just moves
the object to the room and displays ``Dropped.''  The {\tt firstseen}
method is called when {\tt isseen} is about to be set {\tt true}
for the first time (i.e., when the player first sees the room);
by default, this routine does nothing, but it's a convenient
place to put any special code you want to execute when a room
is first entered.  The {\tt firstseen} method is called {\it after}
the room's description is displayed.


\minorsection darkroom\par
{\tt darkroom:  room}.
A dark room.  The player must have some object that can act as a
light source in order to move about and perform most operations
while in this room.  Note that the room's lights can be turned
on by setting the room's {\tt lightsOn} property to {\tt true};
do this instead of setting {\tt islit}, because {\tt islit} is
a method which checks for the presence of a light source.


\minorsection Actor\par
{\tt Actor:  fixeditem, movableActor}.
A character in the game.  The {\tt maxweight} property specifies
the maximum weight that the character can carry, and the {\tt maxbulk}
property specifies the maximum bulk the character can carry.  The
{\tt actorAction({\it verb, directObject, preposition, indirectObject})}
method specifies what happens when the actor is given a command by
the player; by default, the actor ignores the command and displays
a message to this effect.  The {\tt isCarrying({\it object})}
method returns {\tt true} if the {\it object} is being carried by
the actor.  The {\tt actorDesc} method displays a message when the
actor is in the current room; this message is displayed along with
a room's description when the room is entered or examined.  The
{\tt verGrab({\it object})} method is called when someone tries to
take an object the actor is carrying; by default, an actor won't
let other characters take its possessions.

If you want the player to be able to follow the actor when it
leaves the room, you should define a {\tt follower} object to shadow
the character, and set the actor's {\tt myfollower} property to
the {\tt follower} object.  The {\tt follower} is then automatically
moved around just behind the actor by the actor's {\tt moveInto}
method.

The {\tt isHim} property should return {\tt true} if the actor can
be referred to by the player as ``him,'' and likewise {\tt isHer}
should be set to {\tt true} if the actor can be referred to as ``her.''
Note that both or neither can be set; if neither is set, the actor
can only be referred to as ``it,'' and if both are set, any of ``him,''
``her,'' or ``it'' will be accepted.


\minorsection movableActor\par
{\tt movableActor:  qcontainer}.
Just like an {\tt Actor} object, except that the player can
manipulate the actor like an ordinary item.  Useful for certain
types of actors, such as small animals.


\minorsection follower\par
{\tt follower:  Actor}.
This is a special object that can ``shadow'' the movements of a
character as it moves from room to room.  The purpose of a {\tt follower}
is to allow the player to follow an actor as it leaves a room by
typing a ``follow'' command.  Each actor that is to be followed must
have its own {\tt follower} object.  The {\tt follower} object should
define all of the same vocabulary words (nouns and adjectives) as the
actual actor to which it refers.  The {\tt follower} must also
define the {\tt myactor} property to be the {\tt Actor} object that
the {\tt follower} follows.  The {\tt follower} will always stay
one room behind the character it follows; no commands are effective
with a {\tt follower} except for ``follow.''


\minorsection basicMe\par
{\tt basicMe:  Actor}.
A default implementation of the {\tt Me} object, which is the
player character.  {\tt adv.t} defines {\tt basicMe} instead of
{\tt Me} to allow your game to override parts of the default
implementation while still using the rest, and without changing
{\tt adv.t} itself.  To use {\tt basicMe} unchanged as your player
character, include this in your game:  ``{\tt Me: basicMe;}''.

The {\tt basicMe} object defines all of the methods and properties
required for an actor, with appropriate values for the player
character.  The nouns ``me'' and ``myself'' are defined (``I''
is not defined, because it conflicts with the ``inventory''
command's minimal abbreviation of ``i'' in certain circumstances,
and is generally not compatible with the syntax of most player
commands anyway).  The {\tt sdesc} is ``you''; the {\tt thedesc}
and {\tt adesc} are ``yourself,'' which is appropriate for most
contexts.  The {\tt maxbulk} and {\tt maxweight} properties are
set to 10 each; a more sophisticated {\tt Me} might include the
player's state of health in determining the {\tt maxweight} and
{\tt maxbulk} properties.


\minorsection decoration\par
{\tt decoration:  fixeditem}.
An item that doesn't have any function in the game, apart from
having been mentioned in the room description.  These items
are immovable and can't be manipulated in any way, but can be
referred to and inspected.  Liberal use of {\tt decoration} items
can improve a game's playability by helping the parser recognize
all the words the game uses in its descriptions of rooms.


\minorsection buttonitem\par
{\tt buttonitem:  fixeditem}.
A button (the type you push).  The individual button's action method
{\tt doPush({\it actor})}, which must be specified in
the button, carries out the function of the button.  Note that
all buttons have the noun ``button'' defined.


\minorsection clothingItem\par
{\tt clothingItem:  item}.
Something that can be worn.  By default, the only thing that
happens when the item is worn is that its {\tt isworn} property
is set to {\tt true}.  If you want more to happen, override the
{\tt doWear({\it actor})} property.  Note that, when a {\tt clothingItem}
is being worn, certain operations will cause it to be removed (for
example, dropping it causes it to be removed).  If you want
something else to happen, override the {\tt checkDrop} method;
if you want to disallow such actions while the object is worn,
use an {\tt exit} statement in the {\tt checkDrop} method.


\minorsection obstacle\par
{\tt obstacle:  object}.
An {\tt obstacle} is used in place of a room for a direction
property.  The {\tt destination} property specifies the room that
is reached if the obstacle is successfully negotiated; when the
obstacle is not successfully negotiated, {\tt destination} should
display an appropriate message and return {\tt nil}.


\minorsection doorway\par
{\tt doorway:  fixeditem, obstacle}.
A {\tt doorway} is an obstacle that impedes progress when it is closed.
When the door is open ({\tt isopen} is {\tt true}), the user ends up in
the room specified in the {\tt doordest} property upon going through
the door.  Since a doorway is an obstacle, use the door object for
a direction property of the room containing the door.

If {\tt noAutoOpen} is not set to {\tt true}, the door will automatically
be opened when the player tries to walk through the door, unless the
door is locked ({\tt islocked} = {\tt true}).  If the door is locked,
it can be unlocked simply by typing ``unlock door'', unless the
{\tt mykey} property is set, in which case the object specified in
{\tt mykey} must be used to unlock the door.  Note that the door can
only be relocked by the player under the circumstances that allow
unlocking, plus the property {\tt islockable} must be set to {\tt true}.
By default, the door is closed; set {\tt isopen} to {\tt true} if the door
is to start out open (and be sure to open the other side as well).

{\tt otherside} specifies the corresponding doorway object in the
destination room ({\tt doordest}), if any.  If {\tt otherside} is
specified, its {\tt isopen} and {\tt islocked} properties will be
kept in sync automatically.


\minorsection lockableDoorway\par
{\tt lockableDoorway:  doorway}.
This is just a normal doorway with the {\tt islockable} and
{\tt islocked} properties set to {\tt true}.  Fill in the other
properties ({\tt otherside} and {\tt doordest}) as usual.  If
the door has a key, set property {\tt mykey} to the key object.


\minorsection vehicle\par
{\tt vehicle:  item, nestedroom}.
This is an object that an actor can board.  An actor cannot go
anywhere while on board a vehicle (except where the vehicle goes);
the actor must get out first.


\minorsection surface\par
{\tt surface:  item}.
Objects can be placed on a surface.  Apart from using the
preposition ``on'' rather than ``in'' to refer to objects
contained by the object, a {\tt surface} is identical to a
{\tt container}.  Note: an object cannot be both a
{\tt surface} and a {\tt container}, because there is no
distinction between the two internally.


\minorsection container\par
{\tt container:  item}.
This object can contain other objects.  The {\tt iscontainer} property
is set to {\tt true}.  The default {\tt ldesc} displays a list of the
objects inside the container, if any.  The {\tt maxbulk} property
specifies the maximum amount of bulk the container can contain.


\minorsection openable\par
{\tt openable:  container}.
A container that can be opened and closed.  The {\tt isopenable}
property is set to {\tt true}.  The default {\tt ldesc} displays
the contents of the container if the container is open, otherwise
a message saying that the object is closed.


\minorsection qcontainer\par
{\tt qcontainer:  container}.
A ``quiet'' container:  its contents are not listed when it shows
up in a room description or inventory list.  The {\tt isqcontainer}
property is set to {\tt true}.


\minorsection lockable\par
{\tt lockable:  openable}.
A container that can be locked and unlocked.  The {\tt islocked}
property specifies whether the object can be opened or not.  The
object can be locked and unlocked without the need for any other
object; if you want a key to be involved, use a {\tt keyedLockable}.


\minorsection keyedLockable\par
{\tt keyedLockable:  lockable}.
This subclass of {\tt lockable} allows you to create an object
that can only be locked and unlocked with a corresponding key.
Set the property {\tt mykey} to the {\tt keyItem} object that can
lock and unlock the object.


\minorsection keyItem\par
{\tt keyItem:  item}.
This is an object that can be used as a key for a {\tt keyedLockable}
or {\tt lockableDoorway} object.  It otherwise behaves as an ordinary item.


\minorsection transparentItem\par
{\tt transparentItem:  item}.
An object whose contents are visible, even when the object is
closed.  Whether the contents are reachable is decided in the
normal fashion.  This class is useful for items such as glass
bottles, whose contents can be seen when the bottle is closed
but cannot be reached.


\minorsection basicNumObj\par
{\tt basicNumObj:  object}.
This object provides a default implementation for {\tt numObj}.
To use this default unchanged in your game, include in your
game this line:  ``{\tt numObj: basicNumObj}''.


\minorsection basicStrObj\par
{\tt basicStrObj:  object}.
This object provides a default implementation for {\tt strObj}.
To use this default unchanged in your game, include in your
game this line:  ``{\tt strObj: basicStrObj}''.


\minorsection deepverb\par
{\tt deepverb:  object}.
A ``verb object'' that is referenced by the parser when the player
uses an associated vocabulary word.  A {\tt deepverb} contains both
the vocabulary of the verb and a description of available syntax.
The {\tt verb} property lists the verb vocabulary words;
one word (such as {\tt 'take'}) or a pair (such as {\tt 'pick up'})
can be used.  In the latter case, the second word must be a
preposition, and may move to the end of the sentence in a player's
command, as in ``pick it up.''  The {\tt action({\it actor})}
method specifies what happens when the verb is used without any
objects; its absence specifies that the verb cannot be used without
an object.  The {\tt doAction} specifies the root of the message
names (in single quotes) sent to the direct object when the verb
is used with a direct object; its absence means that a single object
is not allowed.  Likewise, the {\tt ioAction({\it preposition})}
specifies the root of the message name sent to the direct and
indirect objects when the verb is used with both a direct and
indirect object; its absence means that this syntax is illegal.
Several {\tt ioAction} properties may be present:  one for each
preposition that can be used with an indirect object with the verb.

The {\tt validDo({\it actor, object, seqno})} method returns {\tt true}
if the indicated object is valid as a direct object for this actor.
The {\tt validIo({\it actor, object, seqno})} method does likewise
for indirect objects.  The {\it seqno} parameter is a ``sequence
number,'' starting with 1 for the first object tried for a given
verb, 2 for the second, and so forth; this parameter is normally
ignored, but can be used for some special purposes.  For example,
{\tt askVerb} does not distinguish between objects matching vocabulary
words, and therefore accepts only the first from a set of ambiguous
objects.  These methods do not normally need to be changed; by
default, they return {\tt true} if the object is accessible to the
actor.

The {\tt doDefault({\it actor, prep, indirectObject})} and
{\tt ioDefault({\it actor, prep})} methods return a list of the
default direct and indirect objects, respectively.  These lists
are used for determining which objects are meant by ``all'' and which
should be used when the player command is missing an object.  These
normally return a list of all objects that are applicable to the
current command.


\minorsection Prep\par
{\tt Prep:  object}.
A preposition.  The {\tt preposition} property specifies the
vocabulary word.


