# thing.t | documentation

    #charset "us-ascii"
    #include "advlite.h"

    property subLocation;
    property lookAroundShowExits;

    /*
     *   Mentionable is the base class for objects that the player can refer to
     *   in command input.  In order for the parser to recognize an object, the
     *   object must have vocabulary words in the dictionary.  This class's
     *   main function, then, is to set up the dictionary for an object, so
     *   that its words are recognizable to the parser.
     *
     *   This class is based on LMentionable, which is defined in the language
     *   module.  LMentionable provides implementations for certain methods
     *   that we rely upon for functionality that varies by language.
     */
    class Mentionable: LMentionable
        /*
         *   'vocab' is a string that we use to initialize the object's short
         *   name, dictionary words, grammatical gender, and grammatical number
         *   (singular/plural).  This is designed to make it as convenient as
         *   possible to describe the object's name and grammatical behavior
         *   for input and output purposes.
         *
         *   The syntax is language-specific - see initVocab() for details.
         */
        vocab = nil

        /*
         *   The object's short name, for display in lists and announcements.
         *   By default, this is automatically derived from 'vocab', so you
         *   usually don't have to set it directly.  If you define a non-nil
         *   'name' value manually, though, it takes precedence (i.e., the
         *   library won't replace it with the name implied by 'vocab').
         */
        name = nil

        /*
         *   My room title.  This is displayed as the start of the room
         *   headline, which is the first line of the room description when
         *   'self' is the outermost visible container of the point-of-view
         *   actor.  The headline is also conventionally shown on the status
         *   line whenever the player is in the location.
         *
         *   The room title essentially serves as a label for the room on the
         *   player's mental and/or paper map of the game's geography.  It's
         *   usually something short and pithy that sums up the room's essence,
         *   function, or appearance, and is usually written in title case: Ice
         *   Cave, Bank Lobby, Front of House, Transporter Room 3, etc.
         *
         *   The room headline sometimes adds more status information to the
         *   title, such as the point-of-view actor's direct container when the
         *   actor is inside an intermediate container within the room, such as
         *   a chair.
         */
        roomTitle = nil

        /*
         *   The object's disambiguation name.  This is a more detailed version
         *   of the name, for situations where the short name is ambiguous.
         *   For example, the parser displays this name in "Which do you mean"
         *   questions when it would help tell two of the listed objects apart.
         *
         *   By default, this is the same as the short name.  It's uncommon to
         *   override this, since short names are typically already detailed
         *   enough for most purposes.  Every so often, though, you'll want to
         *   keep the short name very terse, so you'll leave out some
         *   distinguishing detail that it *could* have had.  In such cases,
         *   you can add the distinguishing detail here, so that it's displayed
         *   only when it's really needed.
         */
        disambigName = (name)

        /*
         *   Disambiguation prompt grouping.  When the parser generates a
         *   disambiguation question ("Which did you mean, the red book, or the blue
         *   book?"), it'll group the objects in the list by common disambigGroup
         *   values.  The group is just an arbitrary value that keeps like objects
         *   together in the list.  You can use a string, a class, or whatever you
         *   like for this, as long as grouped objects have the same value in
         *   common. We give this property a default value of 0 so that the
         *   disambigOrder will work by default without the need to specify a
         *   disambigGroup.
         */
        disambigGroup = 0

        /*
         *   Disambiguation prompt sorting.  This gives the display order of
         *   this item within its disambiguation group, if it has one.  The
         *   parser sorts objects within each group in ascending order of this
         *   value when generating the object list for a disambiguation
         *   question.  This is simply an integer; the default is 1 for every
         *   object, which makes the ordering arbitrary.
         *
         *   This property is useful for grouped objects with a natural
         *   ordering, such as items with sequential labels of some sort
         *   (numbers, letters, etc).  You can use this property to ensure that
         *   lists of these items will be displayed in the natural order:
         *   "button 1, button 2, or button 3?" or "the door on the left, the
         *   door in the middle, or the door on the right?"
         */
        disambigOrder = (listOrder)

        /*
         *   Is this object's short name a proper name?  A proper name is the
         *   name of a person, place, or other unique entity with its own name.
         *
         *   This property controls how the library shows the object's name in
         *   generated messages.  In English, for example, articles (a, the)
         *   aren't used with a proper name.
         *
         *   The English library tries to infer whether the object has a proper
         *   name based on the 'vocab' string: if all the words in the short
         *   name are capitalized, we'll consider it a proper name.  This rule
         *   of thumb doesn't always apply, though, so you can override it:
         *   simply set 'proper' explicitly in an individual object, and the
         *   setting will take precedence over whatever the name's
         *   capitalization would otherwise imply.  (Other languages might have
         *   different rules for inferring 'proper', and some might not be able
         *   to infer it at all.)
         */
        proper = nil

        /*
         *   The object's name is "qualified" grammatically, meaning that it
         *   can't be combined with articles (a, the) or possessives.  Proper
         *   names are considered to be qualified, but it's possible for a name
         *   to be qualified but not proper, such as a name that incorporates a
         *   possessive.
         */
        qualified = (proper)

        /*
         *   The grammatical person of narration relative to this object.  Use
         *   1 for first person ("I am in a cave"), 2 for second person ("You
         *   are in a cave"), and 3 for third person ("Bob is in a cave").
         *
         *   Usually, every object in the game will be in the third person -
         *   *except* the player character object, which is usually in the
         *   second person.  The library doesn't care which person you use for
         *   the player character, though - you're free to use first or third
         *   person if you prefer.  First-person and third-person IF are
         *   relatively uncommon, but not unheard of.
         *
         *   This property is used for verb agreement when library messages are
         *   generated.  This ensures that library messages adapt to the
         *   correct narrative person of the story automatically.  To write a
         *   first-person game, you don't have to replace all of the default
         *   messages, but simply set person=1 in your PC object.
         */
        person = 3

        /*
         *   The object's grammatical gender(s).  This information is used to
         *   determine which pronouns can match the object as an antecedent,
         *   which pronouns should represent it in output, and (for some
         *   languages) which articles and other gender-agreement words should
         *   be used in conjunction with the object name in output.
         *
         *   The default is neuter.  Use isHim and isHer to give an object
         *   masculine and/or feminine gender.  Use isIt to explicitly give an
         *   object neuter gender.  By default, we infer isIt from isHim and
         *   isHer: we assume the object is neuter if it's not masculine or
         *   feminine.
         *
         *   Languages that have grammatical gender will almost certainly want
         *   to parse articles in the 'vocab' property to make it more
         *   convenient to encode each object's gender.  For example, a French
         *   implementation could parse 'le' or 'la' at the start of a vocab
         *   string and set isHim and isHer accordingly.
         *
         *   The English library sets isHim and isHer if 'him' and 'her'
         *   (respectively) are found in the object's pronoun list.  (This is
         *   the most convenient way to represent gender via the vocab string
         *   in English, since English doesn't have gendered articles.)
         *
         *   Note that we define the genders as three separate properties, so
         *   the genders are NOT mutually exclusive - an object can be a "him",
         *   a "her", and an "it" at the same time.  This is because a single
         *   object can have multiple grammatical genders in some languages.
         *   In English, for example, an animal can be referred to as gendered
         *   (matching its physical gender) or neuter; and a few inanimate
         *   objects have a sort of optional, idiomatic gender, such as
         *   referring to a ship or country as "her".
         *
         *   Some languages might need additional genders.  When needed,
         *   LMentionable should simply define suitable additional properties.
         *
         *   In most gendered languages, the grammatical gender is an attribute
         *   of the noun, not of the object.  In particular, if an object has
         *   two nouns in its vocabulary, the two nouns might be of different
         *   genders.  The language module might therefore limit the use of
         *   isIt et al to the gender of the object's name string as it appears
         *   in output (e.g., for selecting an article when showing the name in
         *   a list, or selecting a pronoun to represent the object), and use a
         *   completely different scheme to tag the gender of individual
         *   vocabulary words.  One approach would be to use separate mNoun and
         *   fNoun token properties (and more if needed) to distinguish the
         *   gender of individual nouns in the dictionary.
         */
        isIt = (!(isHim || isHer))
        isHim = nil
        isHer = nil

        /*
         *   The object's name's grammatical number.  This specifies singular
         *   or plural usage for the object's name when it appears in generated
         *   messages.  By default, an object has singular usage, so it'll
         *   appear as (for example) "an orange".  Some objects have names with
         *   plural usage, either because they're words that always appear in
         *   the plural (such as "scissors"), or because the game object
         *   represents a group of items that are too numerous and unimportant
         *   to the game to actually implement as separate Thing objects.  For
         *   example, the books in a library might be implemented collectively
         *   as a single "books" object.
         *
         *   The English library sets this to true if 'them' is listed as a
         *   pronoun for the object in the 'vocab' property.
         */
        plural = nil

        /*
         *   Some objects, such as a pair of shoes or a flight of stairs could be
         *   regarded as either singular or plural and referred to as either 'it' or
         *   'them'. Set ambiguouslyPlural to true for such objects.
         */
        ambiguouslyPlural = nil

        /*
         *   The object's name is a mass noun.  A mass noun is a word that has
         *   singular form but represents an indeterminate quantity or group of
         *   something, such as "sand" or "furniture".
         *
         *   In English, mass nouns use "some" as the indefinite article rather
         *   than "a" (some sand, not a sand).  Their plural usage tends to
         *   differ from regular nouns, in that they already carry a sense of
         *   plurality; if you have two distinct piles of sand, the two
         *   together are usually still just "sand", not "two sands".
         *
         *   When a mass noun is awkward as an object's name, you can often
         *   make it into a regular noun by naming its overall form.  "Sand" is
         *   a mass noun, but recasting it as "pile of sand" makes it an
         *   ordinary noun.  (The generic way to do this for a homogeneous
         *   substance is to add "quantity of".)
         */
        massNoun = nil

        /*
         *   My nominal contents is the special contents item we can use in
         *   naming the object.  This is useful for containers whose identities
         *   come primarily from their contents, such as a vessel for liquids
         *   or a box of loose files.  Returns an object that qualifies the
         *   name: a "water" object for BOX OF WATER, a "files" object for BOX
         *   OF FILES.  Nil means that the object isn't named by its contents.
         *
         *   Note that this is always a single object (or nil), not the whole
         *   list of contents.  We can only be named by one content object.
         *   (So you can't have a "box of books and papers" by having separate
         *   nominal contents objects for the books and the papers; although
         *   you could fake it by creating a "books and papers" object.)
         */
        nominalContents = nil

        /*
         *   Can I be distinguished in parser messages by my contents?  If so,
         *   we can be distinguished (in parser messages) from similar objects
         *   by our contents, or lack thereof: "bucket of water" vs "empty
         *   bucket".  If this is true, our nominalContents property determines
         *   the contents we display for this.
         */
        distinguishByContents = nil

        /*
         *   Match the object to a noun phrase in the player's input.  If the given
         *   token list is a valid name for this object, we return a combination of
         *   MatchXxx flag values describing the match.  If the token list isn't a
         *   valid name for this object, we return 0.
         *
         *   By default, we call simpleMatchName(), which matches the name if all of
         *   the words in the token list are in the object's vocabulary list,
         *   regardless of word order.
         *
         *   In most cases, an unordered word match works just fine.  The obvious
         *   drawback with this approach is that it's far too generous at matching
         *   nonsense phrases to object names - DUSTY OLD SPELL BOOK and BOOK DUSTY
         *   SPELL OLD are treated the same.  In most cases, users won't enter
         *   nonsense phrases like that anyway, so they'll probably never notice
         *   that we accept them.  If they enter something like that intentionally,
         *   we can plead Garbage In/Garbage Out: a user who willfully types a
         *   nonsense command has only himself to blame for a nonsense reply.
         *
         *   Occasionally, though, there are reasons to be pickier.  When these come
         *   up, you can override matchName() to be as picky as you like.
         *
         *   The most common situation where pickiness is called for is when two
         *   objects happen to share some of the same vocabulary words, but certain
         *   words orderings clearly refer to only one or the other. With the
         *   unordered approach, this can be a nuisance for the player because it
         *   can trigger disambiguation questions that seem unnecessary.  Overriding
         *   matchName() to be picky about word order for those specific objects can
         *   often fix this. In this implementation the matchPhrases property can be
         *   used for this purpose.
         *
         *   Another example is ensuring the user knows the correct full name of an
         *   object as part of a puzzle: you can override matchName() to make sure
         *   the user doesn't accidentally stumble on the object by using one of its
         *   vocabulary words to refer to something else nearby.  Another example is
         *   matching words that aren't in the vocabulary list, such as a game
         *   object that represents a group of apparent objects that have a whole
         *   range of labels ("post office box 123", say).
         */
        matchName(tokens)
        {
            return matchNameCommon(tokens, matchPhrases, matchPhrasesExclude);
        }

        /*
         *   Match a name against a list of tokens entered by the player. phrases is
         *   the list of match phrases defined on the object (either for initial
         *   matching or for disambiguation) and excludes should be true or nil
         *   depending on whether failure to match phrases should exclude a match
         *   overall.
         */
        matchNameCommon(tokens, phrases, excludes)
        {
            /*
             *   If an item is hidden, the player character either shouldn't know of
             *   its existence, or at least shouldn't be able to interact with it,
             *   so it shouldn't match any vocab.
             */
            if(isHidden && !gCommand.action.unhides)
                return 0;

            /*
             *   First try the phrase-match matcher; if this fails return 0 to
             *   indicate that we don't match. If it succeeds in matching a phrase
             *   of more than one word, return MatchPhrase (we found a match).
             */
            local phraseMatch = 0;

            /*
             *   We only need to test for phrase matching if there are any phrases
             *   to match,
             */
            if(phrases != nil)
            {
                /* See if our list of tokens matches any of our phrases. */
                phraseMatch = phraseMatchName(phrases, tokens);

                /*
                 *   If there's a mismatch between our phrases and our tokens,
                 *   return 0 to indicate we don't have a match overall. A mismatch
                 *   only occurs if one or more of our tokens appears in one or more
                 *   of our phrases but there's no match between a phrase and the
                 *   succession of tokens.
                 */
                if(phraseMatch is in (0, nil) && excludes)
                    return 0;

                /*
                 *   A return type of true means there was no overlap between the
                 *   tokens and the matchPhrases, so the matchPhrases should have no
                 *   effect on the match.
                 */
                if(dataType(phraseMatch) != TypeInt)
                    phraseMatch = 0;
            }

            /*
             *   Now compute our simple match score (based on our individual tokens
             *   without regard to their ordering or to their matching any phrases).
             */
            local simpleMatch = simpleMatchName(tokens);

            /*
             *   If the simpleMatchName routine fails to match anything, consider
             *   the match a failure
             */
            if(simpleMatch == 0)
                return 0;

            /*
             *   Otherwise boost the simpleMatch score with the result of the phrase
             *   match.
             */
            return phraseMatch | simpleMatch;
        }

        /*
         *   Match the object to a noun phrase in *disambiguation* input.  This
         *   checks words in the player's reply to a "Which one did you
         *   mean...?" question from the parser.  When the player replies to
         *   this kind of question, they usually don't respond with the full
         *   name, but with just an adjective or two.
         *
         *   Now, you might think we should handle these replies by just
         *   appending them to the original noun phrase in the input.  But we
         *   can't just do that: matchName() *could* care about the order of
         *   the words in the noun phrase, so we can't just assume that we can
         *   stick them in somewhere and still have a valid name for the
         *   object.  So, instead of doing that, we call this routine with the
         *   phrase from the player's answer to the "Which one" question.
         *   Since this routine knows that the new words aren't part of the
         *   original phrase, it can deal with them as it sees fit with respect
         *   to word order.
         *
         *   The default here, of course, is to do the same thing as the
         *   default matchName(): we simply call simpleMatchName() to match the
         *   input to the object vocabulary, ignoring word order.  This will
         *   usually work even when matchName() is overridden to care about
         *   word order, since the added words here are just serving to
         *   distinguish one object from another.
         */
        matchNameDisambig(tokens)
        {

            /*
             *   If disambigMatchPhrases is defined then we must match it
             *   exclusively; i.e. a fail to match any relevant phrase must result
             *   in a failure overall; otherwise we'll just keep getting the same
             *   disambiguation question over and over.
             */
            return matchNameCommon(tokens, disambigMatchPhrases, true);

        }

        /*
         *   Simple implementation of matchName(), which simply checks to see
         *   if all of the tokens are associated with the object.  The "simple"
         *   aspect is that we don't pay any attention to the order of the
         *   words - we simply check that they're all in the object's
         *   vocabulary list, in any order.
         */
        simpleMatchName(tokens)
        {
            /* if the token list is empty, it's no match */
            if (tokens.length() == 0)
                return 0;

            /* we haven't found any strength demerits yet */
            local strength = MatchNoTrunc | MatchNoApprox;

            /* we haven't found any part-of-speech matches yet */
            local partOfSpeech = 0;

            /* remember the vocabulary word list and the string comparator */
            local vw = vocabWords, cmp = Mentionable.dictComp;

            /*
             *   if we're distinguishable by contents, add either the
             *   vocabulary for our contents object, if we have one, or the
             *   special 'empty' vocabulary words
             */
            if (distinguishByContents)
            {
                vw += nominalContents != nil
                    ? nominalContents.vocabWords : emptyVocabWords;
            }

            /* note the number of states we have */
            local stateCnt = states.length();

            /* scan the token list */
            for (local i = 1, local len = tokens.length() ; i <= len ; ++i)
            {
                /* get the word */
                local tok = tokens[i];

                /* match this word */
                local match = matchToken(tok, vw, cmp);

                /*
                 *   if we didn't match it from our own vocabulary, try
                 *   matching it against any states we have
                 */
                if (match == 0)
                {
                    /* try each state until we find a match or run out of states */
                    for (local j = 1 ; j <= stateCnt ; ++j)
                    {
                        /* try this state - stop searching if it matches */
                        local state = states[j];
                        if ((match = state.matchName(
                            tok, self.(state.stateProp), cmp)) != 0)
                            break;
                    }
                }

                /*
                 *   if we didn't find a match for this token, the whole phrase
                 *   fails (even if we've already matched other tokens)
                 */
                if (match == 0)
                    return 0;

                /*
                 *   We found a match for this token, so combine it into the
                 *   running totals for the overall phrase.  The overall phrase
                 *   strength is the WEAKEST of the individual token strengths.
                 *   The overall phrase part-of-speech mix is the union of the
                 *   individual token part-of-speech matches.
                 */
                strength = min(strength, match & MatchStrengthMask);
                partOfSpeech |= match;
            }

            /*
             *   Omit prepositions from the results.  We don't want to reject
             *   prepositions that are in our vocabulary, which is why we've
             *   kept them in the results thus far, but we also don't want to
             *   match the whole phrase on the strength of just a preposition -
             *   "of" just isn't sufficiently specific to match "pile of
             *   paper".  Also mask out the match-strength bits we've
             *   accumulated, so that we can tell specifically which parts of
             *   speech we've matched.
             */
            partOfSpeech &= MatchPartMask & ~MatchPrep;

            /*
             *   we need at least one actual part-of-speech match - if we
             *   didn't find any, we must have had a string of nothing but
             *   prepositions
             */
            if (partOfSpeech == 0)
                return 0;

            /* return the overall results, combined into a single bit vector */
            return strength | partOfSpeech;
        }

        /*
         *   If we have any phraseMatches defined, check whether we fail to match
         *   any of them. This will be the case if we find a phraseMatch containing
         *   one of our tokens but not the rest in the right order.
         */
        phraseMatchName(phrases, tokens)
        {
            /* Start by assuming we won't find a mismatch */
            local ok = true;

            /* Note the number of tokens to check */
            local tokLen = tokens.length;

            /* Note the string comparator to use. */
            local cmp = Mentionable.dictComp;

            /*
             *   Go through each phraseMatch in turn to see if the tokens either
             *   fail to match it or succeed in matching it.
             */
            foreach(local pm in valToList(phrases))
            {
                /* Split the phraseMatch into a list of words */
                local pmList = pm.split(' ');

                /*
                 *   If the list of words from the phraseMatch contains no words in
                 *   common with the token list, there's nothing to test; but if it
                 *   does, we need to test it.
                 */
                if(pmList.overlapsWith(tokens))
                {
                    /*
                     *   See if we can find a list equivalent to the phraseMatch
                     *   list as a sublist of the tokens list.
                     */
                    local pmLength = pmList.length();
                    for(local i in 1 .. tokLen - pmLength + 1)
                    {
                        /*
                         *   If we can we've succeeded in finding a phrase match, so
                         *   we can return true straight away.
                         */
                        if(tokens.sublist(i, pmLength).strComp(pmList, cmp))
                        {
                            return pmLength > 1 ? MatchPhrase : MatchAdj;
                        }
                    }
                    /*
                     *   If we don't find a phrase match, note the failure, but
                     *   there may be other phrases to try matching, so carry on
                     *   looking.
                     */
                    ok = 0;
                }
            }

            /* Return the result */
            return ok;
        }

        /*
         *   A single-quoted string, or a list of single-quoted strings containing
         *   exact phrases (i.e. sequences of words) that must be matched by the
         *   player input if any of the words in the phrase matches appear in the
         *   player input. Note that words defined here should also be defined in
         *   the vocab property; the purpose of the matchPhrases property is to
         *   limit matches. Note also that object will be matched if any of the
         *   phrases in the list is matched.
         */
        matchPhrases = nil

        /*
         *   Do we want to test for phrase matches when disambiguating? We'll assume
         *   that by default we do since the same reasons for wanting the phrase
         *   match are likely to apply when disambiguating, and that we'll use the
         *   same set of phrases. This can be overridden to supply a different set
         *   of phrases or none.
         */
        disambigMatchPhrases = matchPhrases

        /*
         *   If failing to match any of the match phrases (when the player's input
         *   includes at least one word used in any of them) excludes a match, then
         *   return nil
         */
        matchPhrasesExclude = true

        /*
         *   On dynamically creating a new object, do the automatic vocabulary
         *   and short name initialization.
         */
        construct()
        {
            /* do the vocabulary initialization */
            initVocab();

            /* build the list of applicable states */
            foreach (local s in State.all)
            {
                if (s.appliesTo(self))
                    states += s;
            }
        }

        /*
         *   Vocabulary word list.  This is a vector of VocabWord objects that
         *   we build in initVocab(), giving the individual words that this
         *   object uses for its noun phrase vocabulary.
         */
        vocabWords = []

        /* the State objects applying to this object */
        states = []

        /*
         *   The filterResolveList method allows this object to remove itself or
         *   other objects from the list of resolved objects.
         *
         *   np is the noun phrase, so np.matches gives the current list of matches,
         *   and np.matches[i].obj gives the ith object match. To change the list of
         *   matches, manipulate the np.matches list.
         *
         *   cmd is the command object, so that cmd.action gives the action about to
         *   be executed.
         *
         *   mode is the match mode.
         *
         *   By default we do nothing here.
         */
        filterResolveList(np, cmd, mode) { }
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   Match a token from the player's input against a given vocabulary list.
     *   Returns a set of MatchXxx flags for a match, or 0 if there's no match.
     *
     *   'tok' is the token string to match.  'words' is the list of words to
     *   match, as VocabWords objects.  'cmp' is the StringComparator object
     *   that we use to compare the strings.
     */
    matchToken(tok, words, cmp)
    {
        /* we don't have a match for this token yet */
        local strength = 0, partOfSpeech = 0;

        /* try matching this token against our vocabulary list */
        for (local len = words.length(), local i = 1 ; i <= len ; ++i)
        {
            /* get this vocabulary word entry */
            local entry = words[i];

            /* check this token against the dictionary word */
            local match = cmp.matchValues(tok, entry.wordStr);

            /* if there's no match, keep looking */
            if (match == 0)
                continue;

            /*
             *   Figure the result flags for this match.  Note that any
             *   bits in the String Comparator match value above 0x80
             *   are character approximation flags.
             */
            local result =
                (match & StrCompTrunc ? 0 : MatchNoTrunc)
                | (match & ~0xFF ? 0 : MatchNoApprox);

            /*
             *   Check the required match-strength flags to see if this
             *   match is allowed.  If a MatchNoXxx flag is set in the
             *   required flags in the dictionary entry, it means that
             *   the match itself MUST have that flag.  So, if a flag
             *   is set in the dictionary, and it's not set in the
             *   result, reject this match.
             */
            if (entry.strengthFlags & ~result)
                continue;

            /*
             *   Okay, it's a match.  There are three possibilities for how
             *   it relates to other matches we've already found:
             *
             *   - It's stronger, meaning that it's not truncated while the
             *   earlier match was, or not approximated while the earlier
             *   match was.  We only want to keep the strongest matche(es),
             *   so if we have a prior match, forget it.
             *
             *   - It's equally strong.  We might have found another
             *   part-of-speech usage for the word at the same match
             *   strength.  Combine the part-of-speech flags into the
             *   running total.
             *
             *   - It's weaker.  We only want to keep the best matches, so
             *   reject this one.
             */
            if (result > strength)
            {
                /* it's stronger - replace any past match with this one */
                strength = result;
                partOfSpeech = entry.posFlags;
            }
            else if (result == strength)
            {
                /* equally strong - add this entry's part of speech */
                partOfSpeech |= entry.posFlags;
            }
        }

        /* return the combined MatchXxx flags */
        return strength | partOfSpeech;
    }

    /* ------------------------------------------------------------------------ */
    /*
     *   A VocabWord is an entry in a Mentionable object's list of noun phrase
     *   words.
     */
    class VocabWord: object
        construct(w, f)
        {
            /* remember the word string */
            wordStr = w;

            /* separate out the part-of-speech and match-strength flags */
            posFlags = f & MatchPartMask;
            strengthFlags = f & MatchStrengthMask;
        }

        /* the word string (the text of this vocabulary word) */
        wordStr = nil

        /* the part-of-speech flags (MatchNoun, etc) */
        posFlags = 0

        /* the required match strength flags (MatchNoTrunc, MatchNoApprox) */
        strengthFlags = 0
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   A State represents a changeable condition of a Mentionable that can be
     *   used as part of the object's name in command input.  For example, a
     *   state could be used to represent whether a match is lit or unlit: the
     *   words 'lit' and 'unlit' could then be used to describe the object,
     *   according to its current condition.
     *
     *   The actual current condition of a given object is given by a property
     *   of the Mentionable, which we define as part of the State object.  So
     *   testing whether an object is lit or unlit is just a matter of checking
     *   the corresponding property of the object.
     *
     *   The parser considers an object to have the state, for parsing
     *   purposes, if the object defines any value for the state property.
     *
     *   Most of the State object's definition is its vocabulary, which is
     *   obviously language-specific.  We therefore leave it to the language
     *   modules to define the individual State instances.  Games can also add
     *   new states as needed, of course.
     */
    class State: LState
        /*
         *   The Mentionable property that indicates the current condition of
         *   an object that has this State.  The range of values that this
         *   property takes on in the Mentionable is up to the State to define.
         *   For some states, this will be a simple boolean: Lit/Unlit,
         *   Open/Closed, On/Off, etc.  For others, this might be an integer
         *   range or a set of string values.
         */
        stateProp = nil

        /*
         *   Does this state apply to the given object?  By default, we
         *   consider any object that defines the state property to exhibit the
         *   state.
         */
        appliesTo(obj) { return obj.propDefined(stateProp); }

        /*
         *   Match a token from the object name for the given state value.
         *   Mentionable.matchName() calls this to see if a token applies
         *   because of the object's current conditdion.  'tok' is the token
         *   string; 'state' is the object's value for the state property; and
         *   'cmp' is the string comparator to use for the string comparisons.
         *   Returns a combination of MatchXxx flags, or zero if the token
         *   doesn't match the current condition.
         *
         *   For example, a Lit/Unlit state would return MatchAdj for 'lit' if
         *   'state' is true, 0 otherwise.
         */
        matchName(tok, state, cmp)
        {
            /* get the vocabulary for the state; if none, there's no match */
            local v = getVocab(state);
            if (v == nil)
                return 0;

            /* compare the token against the list for the current state */
            return matchToken(tok, v, cmp);
        }

        /*
         *   Get the vocabulary words that apply to the given state.  For
         *   example, a Lit/Unlit object might return 'lit' if state is true
         *   and 'unlit' if state is nil.
         */
        getVocab(state)
        {
            /* return the list for this state */
            return vocabTab[state];
        }

        /* state vocabulary lookup table (built automatically during preinit) */
        vocabTab = nil

        /*
         *   State/adjective initializer list.
         *
         *   States are generally represented in names by adjectives added to
         *   the object name, both in displaying output and in parsing input.
         *   For example, a Lit/Unlit state would add 'lit' in the lit state
         *   and 'unlit' in the unlit state.  So we provide an easy way of
         *   initializing a state object: just list the states and their
         *   corresponding adjectives.
         *
         *   Make one entry in this list for each possible state; the entry is
         *   a list, [stateval, [adjectives]], where 'stateval' is the state
         *   variable value, and [adjectives] is a list of strings giving the
         *   corresponding adjectives.  The first adjective in the list is the
         *   display adjective - this is the one that addToName() will use to
         *   generate an object name for display.  The rest are used to parse
         *   input; they'll all be matched to the state.
         */
        adjectives = []

        /*
         *   *Full* vocabulary initializer list.  If the 'adjectives' list
         *   isn't sufficiently flexible for your needs, you can use this
         *   initializer list instead.  This consists of a list of sublist
         *   entries, [stateval, word, flags].  'stateval' is a state value,
         *   'word' is a string giving a vocabulary word to match, and 'flags'
         *   is a combination of MatchXxx flags for the word.
         *
         *.     [[nil, 'unlit', MatchAdj],
         *.      [true, 'lit', MatchAdj]]
         */
        vocabWords = []

        /* class property: master list of all State objects */
        all = []

        /* construction */
        construct()
        {
            /* create the vocabulary table */
            local tab = vocabTab = new LookupTable(8, 16);

            /* do the inherited work */
            inherited();

            /* load the vocabulary table from the adjectives list, if present */
            foreach (local a in adjectives)
            {
                /* make sure there's a list for this state */
                local st = a[1];
                if (tab[st] == nil)
                    tab[st] = [];

                /* add a VocabWord for each adjective for this state */
                foreach (local adj in a[2])
                {
                    initWord(adj);
                    tab[st] += new VocabWord(adj, MatchAdj);
                }
            }

            /* load the vocabulary table from the vocabWords list, if present */
            foreach (local w in vocabWords)
            {
                /*
                 *   create an empty list for the state if this is the first
                 *   word we've seen for this state
                 */
                local st = w[1];
                if (tab[st] == nil)
                    tab[st] = [];

                /* add a VocabWord for this word to the state list */
                initWord(w[2]);
                tab[st] += new VocabWord(w[2], w[3]);
            }
        }

        /* class initialization */
        classInit()
        {
            /* build the master list of State objects */
            forEachInstance(State, { s: State.all += s });
        }
    ;

    /*
     *   A ReplaceRedirector is a Redirector that uses replaceAction (or its
     *   execNestedAction equivalent) to redirect one action to another.
     */
    class ReplaceRedirector: Redirector

        /*
         *   User code should normally call this method via doInstead rather than
         *   directly. cmd is the current command object, altAction is the action we
         *   want to perform instead of the current action, dobj and iobj are the
         *   direct and indirect objects of the new action, and isReplacement
         *   determines whether the new action replaces the original one (if true)
         *   or merely takes place during the execution of the original one, which
         *   then resumes when the new action is complete (if isReplacement is nil).
         */
        redirect(cmd, altAction, dobj:?, iobj:?, aobj:?, isReplacement: = true)
        {
            if(iobj != nil && dobj != nil && aobj != nil)
                execNestedAction(isReplacement, gActor, altAction, dobj, iobj, aobj);
            else if(iobj != nil && dobj != nil)
                execNestedAction(isReplacement, gActor, altAction, dobj, iobj);
            else if(dobj != nil)
                execNestedAction(isReplacement, gActor, altAction, dobj);
            else
                execNestedAction(isReplacement, gActor, altAction);
        }
    ;

    /*
     *   Thing is the base class for all game objects that represent physical
     *   objects which can be interacted with in the game world. All such physical
     *   objects are either Things or based on a subclass of Thing.
     */
    class Thing:  ReplaceRedirector, Mentionable

        /*
         *   Most of the following properties and methods down to the next dashed
         *   line are usually only relevant on Room, but they have been moved to
         *   Thing in case the player char finds itself in a closed Booth.
         */

        /*
         *   The title of this room to be displayed at the start of a room
         *   description, or in the status line.
         */
        roomHeadline(pov)
        {
            /*
             *   start with the room title; if this room is illuminated use the
             *   standard roomTitle, otherwise use our darkName.
             */
            say(isIlluminated ? roomTitle : darkName);

            /* if the actor is in an intermediate container, add the container */
            if (pov.location not in (self, nil))
                pov.location.roomSubhead(pov);
        }

        /*
         *   Can the player character recognize this room (enough to know its name
         *   and have a rough idea of its location) in the dark? (If so then looking
         *   around in this room in the dark makes it visited and familiar,
         *   otherwise it doesn't).
         */
        recognizableInDark = nil

        /* The name to display at the head of a room description */
        roomTitle = name

        /* The name to display at the head of a room description when it's dark */
        darkName =  BMsg(dark name, 'In the dark')

        /* The description of the room when it's dark */
        darkDesc()
        {
            DMsg(dark desc, 'It{dummy} {is} pitch black; {i} {can\'t} see a thing.
                ');
        }

        /*
         *   The "inside" description.  This is displayed when an actor LOOKS AROUND
         *   from within this object.  Note that this applies not only to top-level
         *   rooms but also to things like chairs, platforms, and booths that can
         *   contain an actor.  By default, we simply show the ordinary EXAMINE
         *   description (or the darkDesc if there's no illumination).  Non-room
         *   containers such as chairs or booths should usually override this to
         *   provide the view from inside the object, which usually differs from the
         *   ordinary EXAMINE description.  For a top-level room, you don't usually
         *   override this, since the only description needed for a room is normally
         *   the LOOK AROUND perspective.
         */
        interiorDesc = (desc)

        /*
         *   If we're a room, are we illuminated (is there enough light for an actor
         *   within us to see by)?
         */
        isIlluminated()
        {
            /*
             *   If the room itself is lit, then it's self-illuminating and we don't
             *   need to check anything else.
             */
            if(isLit)
                return true;

            /*
             *   Otherwise we need to see if there's anything visible in the room's
             *   contents that's lit.
             */
            return isThereALightSourceIn(contents);
        }

        /*
         *   Determine (recursively) whether lst contains a light source; i.e.
         *   whether any of the items within list is lit or whether any of the
         *   visible contents of any of the items in lst it lit.
         */
        isThereALightSourceIn(lst)
        {
            foreach(local obj in lst)
            {
                /* If we find an object that's lit, return true. */
                if(obj.isLit)
                    return true;

                /*
                 *   If we have any contents and our contents are visible from
                 *   outside us, return true if there's a light source among our
                 *   contents.
                 */
                if(obj.contents.length > 0
                   && (obj.isOpen || obj.contType != In || obj.isTransparent)
                   && isThereALightSourceIn(obj.contents))
                    return true;

            }

            /* If we get this far we haven't found a light source. */
            return nil;
        }

        /*
         *   The contents lister to use for listing this room's miscellaneous
         *   contents. By default we use the standard lookLister but this can be
         *   overridden to use a CustomRoomLister (say) to provide just about any
         *   wording we like.
         */
        roomContentsLister = lookLister

        /*
         *   The contents lister to use for listing this room's miscellaneous
         *   subcontents. By default we use the standard lookContentsLister but this
         *   can be overridden.
         */
        roomSubContentsLister = lookContentsLister

        /*
         *   Look around within this Thing (Room or Booth) to provide a full
         *   description of this location as seen from within, including our
         *   headline name, our internal description, and a listing of our visible
         *   contents.
         */
        lookAroundWithin()
        {
             /* Reset everything in the room to not mentioned. */
            unmention(contents);

            /* Reset everything in any remote rooms we're connected to */
            unmentionRemoteContents();

            /* Begin by displaying our name */
            "<.roomname><<roomHeadline(gPlayerChar)>><./roomname>\n";

            /* If we're illuminate show our description and list our contents. */
            if(isIlluminated)
            {
                /* Display our interior description. */
                if(gameMain.verbose || !visited || gActionIs(Look))
                    "<.roomdesc><<interiorDesc>><./roomdesc><.p>";

                /* List our contents. */
                "<.roomcontents>";
                listContents();
                "<./roomcontents>";

                /* Note that we've been seen and visited. */
                setSeen();
                visited = true;
            }

            /*
             *   Otherwise, if there's not enough light to see by, just show our
             *   dark description.
             */
            else
            {
                /* Display the darkDesc */
                "<.roomdesc><<darkDesc>><./roomdesc>";

                /*
                 *   If this location is recognizable to the player character in the
                 *   dark despite the poor lighting (for example, the PC knows it's
                 *   a cellar because s/he's just descended a flight of steps that
                 *   clearly lead to a cellar), note that we've been visited and
                 *   that we're now known about (the pc knows of our existence).
                 */
                if(recognizableInDark)
                {
                    visited = true;
                    setKnown();
                }

            }
            "<.p>";

            /* If the game includes an exit lister, list our exits. */
            if(gExitLister != nil)
                gExitLister.lookAroundShowExits(gActor, self, isIlluminated);
        }

        /* List the contents of this object using lister. */
        listContents(lister = &roomContentsLister)
        {

            /* Don't list the contents if we can't see in */
            if(!canSeeIn())
                return;

            /*
             *   Set up a variable to contain the list of objects with specialDescs
             *   to be shown before the list of miscellaneous contents.
             */
            local firstSpecialList = [];

            /* Set up a variable to contain of list of miscellaneous contents. */
            local miscContentsList = [];

            /*
             *   Set up a variable to contain the list of objects with specialDescs
             *   to be shown after the list of miscellaneous contents.
             */
            local secondSpecialList = [];

            /*
             *   First mention the actor's immediate container, if it isn't the
             *   object we're looking around within. Then list the oontainer's
             *   contents immediately after.
             */
            local loc = gActor.location;

            /*
             *   If we're not the pc's immediate container and we're looking around,
             *   start by describing the pc's immediate container and listing its
             *   contents.
             */
            if(loc != self && lister == &roomContentsLister)
            {
                /*
                 *   If there isn't a current action (e.g. because we're showing a
                 *   room description before the first turn) create a Look Action to
                 *   provide an action context for the gMessageParams() call that
                 *   follows.
                 */
                if(gAction == nil)
                    gAction = Look.createInstance();

                /* Create a message parameter substitution. */
                gMessageParams(loc);

                /* Start by mentioning the PC's immediate container. */
                DMsg(list immediate container, '{I} {am} {in loc}. <.p>');

                /* Note that the pc's immediate container has been mentioned. */
                loc.mentioned = true;

                /*
                 *   If the pc's immediate container is a subcomponent (of a complex
                 *   container object), note that its lexical parent has been
                 *   mentioned.
                 */
                if(loc.ofKind(SubComponent) && loc.lexicalParent != nil)
                    loc.lexicalParent.mentioned = true;

                /* List the contents of the pc's immediate container. */
                listSubcontentsOf([loc]);
            }

            /* List every listable item in our contents. */
            foreach(local obj in contents)
            {
                /* Don't include any hidden items in the listing */
                if(obj.isHidden)
                    continue;

                /*
                 *   If the object has an initSpecialDesc or a specialDesc which is
                 *   currently in use, add it to the appropriate list.
                 */
                if((obj.propType(&initSpecialDesc) != TypeNil &&
                   obj.useInitSpecialDesc()) ||
                   (obj.propType(&specialDesc) != TypeNil && obj.useSpecialDesc()))
                {
                    /*
                     *   If the specialDesc should be shown before the list of
                     *   miscellaneous items, add this object to the first list of
                     *   specials.
                     */
                    if(obj.specialDescBeforeContents)
                        firstSpecialList += obj;

                    /* Otherwise add it to the second list of specials. */
                    else
                        secondSpecialList += obj;
                }
                /*
                 *   Otherwise add it to the list of miscellaneous items, provided
                 *   it should be listed when looking around.
                 */
                else if(obj.lookListed)
                    miscContentsList += obj;

                /* Note that the object has been seen by the pc. */
                obj.noteSeen();
            }

            /* Sort the first list of specials in order of their specialDescOrder */
            firstSpecialList = firstSpecialList.sort(nil, {a, b: a.specialDescOrder -
                                                     b.specialDescOrder});

            /* Sort the second list of specials in order of their specialDescOrder */
            secondSpecialList = secondSpecialList.sort(nil, {a, b: a.specialDescOrder -
                                                     b.specialDescOrder});

            /*
             *   Show the specialDesc (or initSpecialDesc) of all the objects in the
             *   first specials list.
             */
            foreach(local obj in firstSpecialList)
                obj.showSpecialDesc();

            /*
             *   If we're listing the contents of a room, then show the specialDescs
             *   of any items in the other rooms in our SenseRegions, where
             *   specialDescBeforeContents is true
             */
            if(lister == &roomContentsLister)
                showFirstConnectedSpecials(gPlayerChar);

            /*
             *   Remove any items from the miscellaneous list that have already been
             *   mentioned.
             */
            miscContentsList = miscContentsList.subset({o: o.mentioned == nil});

            /*
             *   Display the list of miscellaneous items using the lister passed as
             *   parameter to this method.
             */
            self.(lister).show(miscContentsList, self);

            /*   List the contents of our contents. */
            listSubcontentsOf(contents, &roomSubContentsLister);

             /*
              *   If we're not putting paragraph breaks between each subcontents
              *   listing sentence, insert a paragraph break after the lot before we
              *   list anything else.
              *
              */
                if(!paraBrksBtwnSubcontents)
                    "<.p>";

            /*
             *   If we're listing the contents of a room, then show the
             *   miscellaneous contents of other rooms in our sense regions
             */
            if(lister == &roomContentsLister)
                showConnectedMiscContents(gPlayerChar);

            /*
             *   Show the specialDesc (or initSpecialDesc) of every object in our
             *   second list of specials.
             */
            secondSpecialList = secondSpecialList.subset({o: o.mentioned == nil});

            foreach(local obj in secondSpecialList)
                obj.showSpecialDesc();

            /*
             *   Show the specialDescs of any items in the other rooms in our
             *   SenseRegions, where specialDescBeforeContents is nil
             */
           if(lister == &roomContentsLister)
               showSecondConnectedSpecials(gPlayerChar);
        }

        /*
         *   List the contents of every item in contList, recursively listing the
         *   contents of contents all the way down the containment tree. The
         *   contList parameter can also be passed as a singleton object.
         */
        listSubcontentsOf(contList, lister = &examineLister)
        {

            /*
             *   If contList has been passed as a singleton value, convert it to a
             *   list, otherwise retain the list that's been passed.
             */
            contList = valToList(contList);

            /*
             *   Ensure the contents of any associated remapXX items are included in
             *   the list of items whose contents are to be listed.
             */

            /* Initialize an empty list to collect the remapXXX items. */
            local lst = [];

            /*
             *   Go through every item in the contList to see if it has any remapXXX
             *   objects attached. If so add the remapXXX object to our list.
             */
            foreach(local cur in contList)
            {
                foreach(local prop in remapProps)
                {
                    local obj = cur.(prop);
                    if(obj != nil)
                        lst += obj;
                }
            }

            /*
             *   Append the list of remapXXX objects to the list of items whose
             *   contents are to be listed.
             */
            contList = contList.appendUnique(lst);

            /*
             *   Sort the contList in listOrder. Although we're listing the contents
             *   of each item in the contList, it seems good to mention each item's
             *   contents in the listOrder order of the item. Amongst other things
             *   this helps give a consistent ordering for the listing of
             *   SubComponents.
             */
            contList = contList.sort(nil, {a, b: a.listOrder - b.listOrder});

            foreach(local obj in contList)
            {
                /*
                 *   We don't explicitly list things in actors' inventory, but we
                 *   should note them as seen if the player can see them.
                 */
                if(obj.contType == Carrier && markInventoryAsSeen)
                    obj.allContents.subset({o: gPlayerChar.canSee(o) }).forEach( {o:
                        o.noteSeen() });

                /*
                 *   Don't list the inventory of any actors, or of any items that
                 *   don't want their contents listed, or any items we can't see in,
                 *   or of any items that don't have any contents to list.
                 */
                if(obj.contType == Carrier
                   || obj.(obj.(lister).contentsListedProp) == nil
                   || obj.canSeeIn() == nil
                   || obj.contents.length == 0)
                    continue;

                /*
                 *   Don't list any items that have already been mentioned or which
                 *   are hidden.
                 */
                local objList = obj.contents.subset({x: x.mentioned == nil
                                                    && x.isHidden == nil});

                /*
                 *   Extract the list of items that have active specialDescs or
                 *   initSpecial Descs
                 */
                local firstSpecialList = objList.subset(
                    {o: (o.propType(&specialDesc) != TypeNil && o.useSpecialDesc())
                    || (o.propType(&initSpecialDesc) != TypeNil &&
                        o.useInitSpecialDesc() )
                    }
                    );

                /*
                 *   Remove items with specialDescs or initSpecialDescs from the
                 *   list of miscellaneous items.
                 */
                objList = objList - firstSpecialList;

                /*
                 *   From the list of items with specialDescs, extract those whose
                 *   specialDescs should be listed after any miscellaneous items
                 */
                local secondSpecialList = firstSpecialList.subset(
                    { o: o.specialDescBeforeContents == nil });

                /*
                 *   Remove the items whose specialDescs should be listed after the
                 *   miscellaneous items from the list of all items with
                 *   specialDescs to give the list of items with specialDescs that
                 *   should be listed before the miscellaneous items.
                 */
                firstSpecialList = firstSpecialList - secondSpecialList;

                /*
                 *   Sort the list of items with specialDescs to be displayed before
                 *   miscellaneous items by specialDescOrder
                 */
                firstSpecialList = firstSpecialList.sort(nil, {a, b: a.specialDescOrder -
                    b.specialDescOrder});

                /*
                 *   Sort the list of items with specialDescs to be displayed after
                 *   miscellaneous items by specialDescOrder
                 */
                secondSpecialList = secondSpecialList.sort(nil, {a, b: a.specialDescOrder -
                    b.specialDescOrder});

                /*
                 *   Show the specialDescs of items whose specialDescs should be
                 *   shown before the list of miscellaneous items.
                 */
                firstSpecialList = firstSpecialList.subset({o: o.mentioned == nil});
                foreach(local cur in firstSpecialList)
                    cur.showSpecialDesc();

                objList = objList.subset({o: o.mentioned == nil});
                /*   List the miscellaneous items */
                if(objList.length > 0)
                {
                    obj.(lister).show(objList, obj, paraBrksBtwnSubcontents);
                    objList.forEach({o: o.mentioned = true });
                }

                /*
                 *   If we're not putting paragraph breaks between each subcontents
                 *   listing sentence, insert a space instead.
                 */
                if(!paraBrksBtwnSubcontents)
                    " ";

                /*
                 *   Show the specialDescs of items whose specialDescs should be
                 *   shown after the list of miscellaneous items.
                 */
                secondSpecialList = secondSpecialList.subset({o: o.mentioned == nil});
                foreach(local cur in secondSpecialList)
                    cur.showSpecialDesc();

                /*
                 *   Recursively list the contents of each item in this object's
                 *   contents, if it has any; but don't list recursively for an
                 *   object that's just been opened (for which the lister's
                 *   listRecursively property should be nil) or for which there are
                 *   no listable contents.
                 */
                local lstr = obj.(lister);

                if(obj.contents.length > 0 && lstr.listRecursively
                   && obj.contents.countWhich({x: lstr.listed(x)}) > 0)
                    listSubcontentsOf(obj.contents, lister);

            }

        }

        /*
         *   Do we want paragraph breaks between the listings of subcontents (i.e.
         *   the contents of this item's contents)? By default we take our value
         *   from the global setting on gameMain.
         */
        paraBrksBtwnSubcontents = (gameMain.paraBrksBtwnSubcontents)

        /*
         *   Mark everything item in lst as not mentioned , and carry on down the
         *   containment tree marking the contents of every item in lst as not
         *   mentioned.
         */
        unmention(lst)
        {
            foreach(local obj in lst)
            {
                obj.mentioned = nil;

                /* If obj has any contents, unmention every item in is contents */
                if(obj.contents.length > 0)
                    unmention(obj.contents);
            }
        }

        /*
         *   The next four methods are provided so that listContents() can call
         *   them, but they do nothing in the core library. They are overridden in
         *   senseRegion.t (for use if senseRegion.t is included in the build).
         */
        unmentionRemoteContents() {}
        showFirstConnectedSpecials(pov) {}
        showConnectedMiscContents(pov) {}
        showSecondConnectedSpecials(pov) {}

        /*
         *   Display the "status line" name of the room.  This is normally a
         *   brief, single-line description.
         *
         *   By long-standing convention, each location in a game usually has a
         *   distinctive name that's displayed here.  Players usually find
         *   these names helpful in forming a mental map of the game.
         *
         *   By default, if we have an enclosing location, and the actor can
         *   see the enclosing location, we'll defer to the location.
         *   Otherwise, we'll display our roo interior name.
         */
        statusName(actor)
        {
            /*
             *   use the enclosing location's status name if there is an
             *   enclosing location and its visible; otherwise, show our
             *   interior room name
             */
            if (location != nil && Q.canSee(actor, location))
                location.statusName(actor);
            else
            {
                roomHeadline(actor);
            }
        }

        /*
         *   Get the estimated height, in lines of text, of the exits display's
         *   contribution to the status line.  This is used to calculate the
         *   extra height we need in the status line, if any, to display the
         *   exit list.  If we're not configured to display exits in the status
         *   line, this should return zero.
         */
        getStatuslineExitsHeight()
        {
            if (gExitLister != nil)
                return gExitLister.getStatuslineExitsHeight();
            else
                return 0;
        }

        /* Show our exits in the status line */
        showStatuslineExits()
        {
            location.showStatuslineExits();
        }

        /*
         *   Would this location be lit for actor. By default it would if it's
         *   illuminated.
         */
        wouldBeLitFor(actor)
        {
            return getOutermostRoom.isIlluminated;
        }

    //------------------------------------------------------------------------------
        /*
         *   From here on we have properties and methods relating to Things in
         *   general rather than just Rooms and Booths.
         */

        /*
         *   The description of this Thing that's displayed when it's examined.
         *   Normally this would be defined as a double-quoted string, but in more
         *   complicated cases you could also define it as a method that displays
         *   some text.
         */
        desc = ""

        /*
         *   The state-specific description of this object, which is appended to its
         *   desc when examined. This is defined as a single-quoted string to make
         *   it easy to change at run-time.
         */
        stateDesc = ''

        /*
         *   Additional information to display after our desc in response to an
         *   EXAMINE command.
         */
        examineStatus()
        {
            /* First display our stateDesc (our state-specific information) */
            display(&stateDesc);

            /*
             *   Then display our list of contents, unless we're a Carrier (an actor
             *   carrying our oontents) or our contentsListedInExamine is nil.
             */
            if(contType != Carrier && contentsListedInExamine)
            {
                /*
                 *   Start by marking our contents as not mentioned to ensure that
                 *   they all get listed.
                 */
                unmention(contents);

                /* Then list our contents using our examineLister. */
                listSubcontentsOf(self, &examineLister);
            }
        }

        /* The lister to use to list an item's contents when it's examined. */
        examineLister = descContentsLister

        /*
         *   Attempt to display prop appropriately according to it data type
         *   (single-quoted string, double-quoted string, integer or code). The prop
         *   parameter must be provided as a property pointer.
         */
        display(prop)
        {
            local str;
            switch(propType(prop))
            {
                /*
                 *   If prop is a single-quoted string or an integer, simply display
                 *   it.
                 */
            case TypeSString:
            case TypeInt:
                say(self.(prop));
                break;

                /* If prop is a double-quoted string, display it by executing it. */
            case TypeDString:
                self.(prop);
                break;

                /* if prop is a method, execute it. */
            case TypeCode:
                /*
                 *   In case prop is a method that returns a single-quoted string,
                 *   note the return value from executing prop.
                 */
                str = self.(prop);

                /* If it's a string, display it. */
                if(dataType(str) == TypeSString && str > '')
                    say(str);
                break;
            default:
                /* do nothing */
                break;
            }
        }

        /*
         *   Attempt to display the message defined in the property prop, and return
         *   true if anything is displayed. Otherwise, if the altMsg parameter is
         *   supplied (either as a single-quoted string or as a property pointer)
         *   display it instead, and then in any case return nil to tell the caller
         *   that nothing was displayed by prop.
         *
         *   This method is primarily for use with properties such as smellDesc and
         *   listenDesc for which alternatives may need to be displayed if they
         *   don't display anything.
         */

        displayAlt(prop, altMsg?)
        {
            /*
             *   If attempting to display the prop property results in some output,
             *   return true to inform our caller of the fact.
             */
            if(gOutStream.watchForOutput({: display(prop) }))
                return true;

            /*
             *   If we reach this point, prop failed to produce any output, so if
             *   altMsg has been provided as a single-quoted string, display it.
             */
            if(dataType(altMsg) == TypeSString)
                say(altMsg);

            /*
             *   Otherwise, if altMsg has been provided as a property pointer,
             *   display it using the display() method.
             */
            if(dataType(altMsg) == TypeProp)
                display(altMsg);

            /*
             *   Tell our caller that there was no output from attempting to display
             *   prop.
             */
            return nil;
        }

        /*
         *   Check if displaying prop could possibly produce any output. The only
         *   tests we apply here is that prop is not defined as nil.
         */
        checkDisplay(prop)
        {
            return propType(prop) != TypeNil;
        }

        /*
         *   Has this item been mentioned yet in a room description. Note that this
         *   flag is used internally by the library; it shouldn't normally be
         *   necessary to manipulate it directly from game code.
         */
        mentioned = nil

        /*
         *   Do we want this object to report whether it's open? By default we do if
         *   it's both openable and open.
         */
        openStatusReportable = (isOpenable && isOpen)

        /*
         *   If present, a description of this object shown in a separate paragraph
         *   in the listing of the contents of a Room. If specialDesc is defined
         *   then this paragraph will be displayed regardless of the value of
         *   isListed.
         */
        specialDesc = nil

        /*
         *   Should the specialDesc be used? Normally we use the specialDesc if we
         *   have one, but we may want to override this for particular cases. For
         *   example, if we want an item to have a paragraph to itself until it's
         *   moved we could define useSpecialDesc = (!moved) [making it equivalent
         *   to initSpecialDesc]. Note that the useSpecialDesc property only
         *   has any effect if specialDesc is not nil.
         */
        useSpecialDesc = true

        /* A specialDesc that's shown until this item has been moved */
        initSpecialDesc = nil

        /*
         *   By default we use the initSpecialDesc until the object has been moved,
         *   but this can be overridden with some other condition.
         */
        useInitSpecialDesc = (!moved)

        /*
         *   The specialDescOrder property controls where in a series of specialDesc
         *   paragraphs this item is mentioned: the higher the number, the later it
         *   will come relative to other items. Note that this does not override the
         *   specialDescBeforeContents setting.
         */
        specialDescOrder = 100

        /*
         *   Is this item listed before or after the list of miscellaneous contents
         *   in the room. By default we'll show the specialDesc of items before
         *   miscellaneous items in a room description but afterwards otherwise:
         *   this places specialDescs in a more logical order in relation to the
         *   text of listers used to list the contents of obejcts other than rooms.
         */
        specialDescBeforeContents = (location && location.ofKind(Room))

        /* For possible future use; at the moment this doesn't do anything */
        specialDescListWith = nil

        /* Show our specialDesc or initSpecialDesc, as appropriate */
        showSpecialDesc()
        {
            /*
             *   If we've already been mentioned in the room description, don't show
             *   us again. Otherwise note that we've now been mentioned.
             */
            if(mentioned)
                return;
            else
                mentioned = true;

            /*
             *   If we have an initSpecialDesc and useInitSpecialDesc is true, show
             *   our initSpecialDesc, otherwise show our specialDesc.
             */
            if(propType(&initSpecialDesc) != TypeNil && useInitSpecialDesc)
                initSpecialDesc;
            else
                specialDesc;

            /*  Add a paragraph break. */
            "<.p>";

            /* Note that we've been seen. */
            noteSeen();
        }

        /*
         *   Flag to indicate whether this item is portable (nil) or fixed in place
         *   (true). If it's fixed in place it can't be picked up or moved around
         *   (by player commands).
         */
        isFixed = (isDecoration)

        /*
         *   Is this item listed in room descriptions and the like. We tend to list
         *   portable items but not those fixed in place, so we make this the
         *   default.
         */

        /*
         *   A global isListed property that can be used to set the value of all the
         *   others. By default we're listed if we're not fixed in place.
         */
        isListed = (!isFixed)

        /*
         *   Flag: is this item listed in a room description (when looking around).
         */
        lookListed = (isListed)

        /* Flag: is this item listed in an inventory listing. */
        inventoryListed = (isListed)

        /* Flag: is this item listed when its container is examined. */
        examineListed = (isListed)

        /*
         *   Flag: is this item listed when is container is searched (or looked in).
         */
        searchListed = (isListed)

        /*
         *   Flag: should this item's contents be listed? This can be used to
         *   control both contentsListedInLook and contentsListedInExamine.
         */
        contentsListed = true

        /*
         *   Flag: should this item's contents be listed as part of a room
         *   description (when looking around).
         */
        contentsListedInLook = (contentsListed)

        /*
         *   Flag: should this item's contents be listed when its container is
         *   examined.
         */
        contentsListedInExamine = (contentsListed)

        /*
         *   Flag, should this item's contents be listed when it is searched (by
         *   default this is simply true, since it would be odd to have a container
         *   that failed to reveal its contents when searched).
         */
        contentsListedInSearch = true

        /*
         *   Flag, if our contType is Carrier (i.e. we're an Actor), should our
         *   contents be marked as seen even though it hasn't been listed in a room
         *   description? By default this is set to true, on the basis that the
         *   inventory (and parts) of an actor would normally be in plain sight.
         */
        markInventoryAsSeen = true

        /*
         *   The text we display in response to a READ command. This can be nil
         *   (if we're not readable), a single-quoted string, a double-quoted string
         *   or a routine to display a string.     */

        readDesc = nil

        /* The description displayed in response to a SMELL command */
        smellDesc = nil

        /*
         *   Is the this object's smellDesc displayed in response to an intransitive
         *   SMELL command? (Only relevant if smellDesc is not nil)
         */
        isProminentSmell = true

        /*   The description displayed in response to a FEEL command */
        feelDesc = nil

        /*   The description displayed in response to a LISTEN command */
        listenDesc = nil

        /*
         *   Is the this object's listenDesc displayed in response to an
         *   intransitive LISTEN command? (Only relevant if listenDesc is not nil)
         */
        isProminentNoise = true

        /*   The description displayed in response to a TASTE command */
        tasteDesc = nil

        /*  The subset of our contents that should be listed. */
        listableContents = (contents.subset({x: x.lookListed}))

        /* The subset of the contents of cont that should be listed. */
        listableContentsOf(cont)
        {
            local lst = [];
            foreach(local obj in cont.contents)
            {
                if(obj.isListed)
                    lst += obj;
            }
            return lst;
        }

        /*
         *   Our globalParamName is an arbitrary string value that can be used to
         *   refer to this thing in a message substitution parameter; for code
         *   readability it may be a good idea to make this a string representation
         *   of our programmatic name (where we want to define it at all).
         */
        globalParamName = nil

        /*
         *   Is this object lit, i.e. providing sufficient light to see not only
         *   this object but other objects in the vicinity by.
         */
        isLit = nil

        /* Make this object lit or unlit */
        makeLit(stat) { isLit = stat; }

        /*
         *   Is this object visible in the dark without (necessarily) providing
         *   enough light to see anything else by, e.g. the night sky.
         */
        visibleInDark = nil

        /*
         *   An optional description to be displayed instead of our normal desc and
         *   any status information (such as our contents) if we're examined in a
         *   dark room and visibleInDark is true. Note that if visibleInDark is nil
         *   inDarkDesc will never be used.
         */
        inDarkDesc = nil

        /*
         *   Is this object lightable (via a player command)? Note that setting this
         *   property to true also automatically makes the LitUnlit State applicable
         *   to this object, allowing it to be referred to as 'lit' or 'unlit' as
         *   appropriate.
         */
        isLightable = nil

        /*
         *   The preposition that should be used to describe containment within this
         *   thing (e.g. 'in', 'on' , 'under' or 'behind'). By default we get this
         *   from our contType.
         */
        objInPrep = (contType.prep)

        /*
         *   The preposition that should be used to describe movement to within this
         *   thing (e.g. 'into', 'onto' , 'under' or 'behind'). By default we get
         *   this from our contType.
         */
        objIntoPrep = (contType.intoPrep)

        /*
         *   This object's bulk, in arbitrary units (game authors should devise
         *   their own bulk scale according to the needs of their game).
         */
        bulk = 0

        /*
         *   The maximum bulk that can be contained in this Thing. We set a very
         *   large number by default.
         */
        bulkCapacity = 10000

        /*
         *   The maximum bulk that a single item may have to be inserted into (onto,
         *   under, behind) this object; by default this is the same as the bulk
         *   capacity, but you could set a lower value, e.g. to model a bottle with
         *   a narrow neck.
         */
        maxSingleBulk = (bulkCapacity)

        /*   Calculate the total bulk of the items contained within this object. */
        getBulkWithin()
        {
            local totalBulk = 0;
            foreach(local cur in contents)
                totalBulk += cur.bulk;

            return totalBulk;
        }

        /*
         *   Calculate the total bulk carried by an actor, which excludes the bulk
         *   of any items currently worn or anything fixed in place.
         */
        getCarriedBulk()
        {
            local totalBulk = 0;
            foreach(local cur in directlyHeld)
            {
                totalBulk += cur.bulk;
            }

            return totalBulk;
        }

        /*
         *   Check whether an item can be inserted into this object, or whether
         *   doing so would either exceed the total bulk capacity of the object or
         *   the maximum bulk allowed for a single item.
         */
        checkInsert(obj)
        {
            /* Create a message parameter substitution. */
            gMessageParams(obj);

            /*
             *   If the bulk of obj is greater than the maxSingleBulk this Thing can
             *   take, or greater than its overall bulk capacity then display a
             *   message to say it's too big to fit inside ue.
             */
            if(obj.bulk > maxSingleBulk || obj.bulk > bulkCapacity)
                DMsg(too big, '{The subj obj} {is} too big to fit {1} {2}. ',
                     objInPrep, theName);

            /*
             *   Otherwise if the bulk of obj is greater than the remaining bulk
             *   capacity of this Thing allowing for what it already contains,
             *   display a message saying there's not enough room for obj.
             */
            else if(obj.bulk > bulkCapacity - getBulkWithin())
                DMsg(no room, 'There {dummy} {is} not enough room {1} {2} for {the
                    obj}. ', objInPrep, theName);
        }

        /* The list of possible remap props */
        remapProps = [&remapOn, &remapIn, &remapUnder, &remapBehind]

        /*
         *   If remapIn is not nil, a LOOK IN, PUT IN, OPEN, CLOSE, LOCK or UNLOCK
         *   command performed on this Thing will be redirected to the object
         *   specified on remapIn. In other words, remapIn specifies the object that
         *   acts as our proxy container.
         */
        remapIn = nil

        /*
         *   If non-nil, remapOn speficies the object that acts as our proxy
         *   surface, in other words the object to which PUT ON will be redirected.
         */
        remapOn = nil

        /*
         *   If non-nil, remapUnder specified the object that acts as our proxy
         *   underside, i.e. the object to which any PUT UNDER or LOOK UNDER action
         *   directed at us will be redirected.
         */
        remapUnder = nil

        /*
         *   If non-nil, remapUnder specified the object that acts as our proxy
         *   rear, i.e. the object to which any PUT BEHIND or LOOK BEHIND action
         *   directed at us will be redirected.
         */
        remapBehind = nil

        /*
         *   Our notional total contents is our normal contents plus anything
         *   contained in any of our remapXX objects representing our associated
         *   proxy container, surface, underside and rear, excluding anything in a
         *   closed opaque container (which would not be visible).
         */
        notionalContents()
        {
            local nc = [];

            if(isTransparent || !enclosing)
                nc = contents;
            if(remapIn != nil && (remapIn.isTransparent || !remapIn.enclosing))
                nc = nc + remapIn.contents;
            if(remapOn != nil)
                nc = nc + remapOn.contents;
            if(remapUnder != nil)
                nc = nc + remapUnder.contents;
            if(remapBehind != nil)
                nc = nc + remapBehind.contents;

            return nc;
        }

        /*
         *   A list of objects that are treated as hidden under this one. A LOOK
         *   UNDER command will list them and move them into the enclosing room. It
         *   follows that objects placed in this property should not be given an
         *   initial location. This should deal with the most common reason for
         *   wanting items to be placed under things (i.e. to hide them). Note, the
         *   items in the hiddenUnder property should also be revealed when the
         *   player moves the hiding item.
         */
        hiddenUnder = []

        /*
         *   A list of objects that are treated as hidden behind this one. A LOOK
         *   BEHIND command will list them and move them into the enclosing room. It
         *   follows that objects placed in this property should not be given an
         *   initial location. This should deal with the most common reason for
         *   wanting items to be placed behind things (i.e. to hide them). Note, the
         *   items in the hiddenBehind property should also be revealed when the
         *   player moves the hiding item.
         */
        hiddenBehind = []

        /*
         *   A list of objects that are treated as hidden inside this one. A LOOK IN
         *   command will list them and move them into the enclosing room (or in
         *   this one if we're a container). It follows that objects placed in this
         *   property should not be given an initial location.
         */
        hiddenIn = []

        /*
         *   The maximum bulk that can be hidden under, behind or in this object,
         *   assuming that the player can put anything there at all. Note that this
         *   only affects what the player can place there with PUT IN, PUT UNDER and
         *   PUT BEHIND commands, not what can be defined there initially or moved
         *   there programmatically.
         */
        maxBulkHiddenUnder = 100
        maxBulkHiddenBehind = 100
        maxBulkHiddenIn = 100

        /* The total bulk of items hidden in, under or behind this object */
        getBulkHiddenUnder = (totalBulkIn(hiddenUnder))
        getBulkHiddenIn = (totalBulkIn(hiddenIn))
        getBulkHiddenBehind = (totalBulkIn(hiddenBehind))

        /* Calculate the total bulk of the items in lst */
        totalBulkIn(lst)
        {
            local totBulk = 0;
            for(local item in valToList(lst))
                totBulk += item.bulk;

            return totBulk;
        }

        /*
         *   Flag, do we want to treat this object as hidden from view (so that the
         *   player can't interact with it)?
         */
        isHidden = nil

        /*
         *   Make a hidden item unhidden. If the method is called with the optional
         *   parameter and the parameter is nil, i.e. discover(nil), the method
         *   instead hides the object.
         */
        discover(stat = true)
        {
            isHidden = !stat;

            /*
             *   If the player character can see me when I'm hidden, note that the
             *   player character has now seen me.
             */
            if(stat && Q.canSee(gPlayerChar, self))
                noteSeen();
        }

        /*
         *   The lockability property determines whether this object is lockable and
         *   if so how. The possible values are notLockable, lockableWithoutKey,
         *   lockableWithKey and indirectLockable.
         */
        lockability = keyList == nil ? notLockable : lockableWithKey

        /*
         *   Flag: is this object currently locked. By default we start out locked
         *   if we're lockable.
         */
        isLocked = lockability not in (nil, notLockable)

        /*
         *   Make us locked or ublocked. We define this as a method so that
         *   subclasses such as Door can override to produce side effects (such as
         *   locking or unlocking the other side).
         */
        makeLocked(stat)
        {
            isLocked = stat;
        }

        /*
         *   Can this object be switched on and off?
         */
        isSwitchable = nil

        /* is this item currently switched on? */
        isOn = nil

        /* switch this item on or off */
        makeOn(stat) { isOn = stat; }

        /* is this object something that can be worn */
        isWearable = nil

        /*
         *   If this object is currently being worn by someone, the wornBy property
         *   contains the identity of the person wearing it.
         */
        wornBy = nil

        /*
         *   Make this object worn or not worn. If this object is worn, note who
         *   it's worn by. If stat is nil the object is no longer being worn.
         */
        makeWorn(stat)  { wornBy = stat; }

        /* are we directly held by the given object? */
        isDirectlyHeldBy(obj) { return location == obj && !isFixed && wornBy == nil; }

        /*
         *   Get everything I'm directly holding, which is everything in my
         *   immediate contents which is neither fixed in place nor being worn.
         */
        directlyHeld = (contents.subset({ obj: !obj.isFixed &&
                obj.wornBy == nil }))

        /* are we worn by the given object, directly or indirectly? */
        isWornBy(obj)
        {
            return (location == obj ? wornBy == obj :
                    location != nil && location.isWornBy(obj));
        }

        /* are we directly worn by the given object? */
        isDirectlyWornBy(obj) { return location == obj && wornBy == obj; }

        /* get everything I'm directly wearing */
        directlyWorn = (contents.subset({ obj: obj.wornBy == self }))

        /*
         *   Flag: can under objects be placed under us? By default they can if our
         *   contType is Under. If this is set to true and our contType is not
         *   Under, anything placed under us will be treated as hidden under.
         */
        canPutUnderMe = (contType == Under)

        /*
         *   Flag: can under objects be placed behind us? By default they can if our
         *   contType is Behind. If this is set to true and our contType is not
         *   Behind, anything placed behind us will be treated as hidden behind.
         */
        canPutBehindMe = (contType == Behind)

        /*
         *   Flag: can under objects be placed inside us? By default they can if our
         *   contType is In. If this is set to true and our contType is not
         *   In, anything placed in us will be treated as hidden in.
         */
        canPutInMe = (contType == In)

        /*
         *   Can an actor enter (get in or on) this object. Note that for such an
         *   action to be allowing the contType must also match the proposed action.
         */
        isBoardable = nil

        /* Flag: Can this thing be eaten */

        isEdible = nil

        /*
         *   My nominal contents is the special contents item we can use in
         *   naming the object.  This is useful for containers whose identities
         *   come primarily from their contents, such as a vessel for liquids
         *   or a box of loose files.  Returns an object that qualifies the
         *   name: a "water" object for BOX OF WATER, a "files" object for BOX
         *   OF FILES.  Nil means that the object isn't named by its contents.
         *
         *   Note that this is always a single object (or nil), not the whole
         *   list of contents.  We can only be named by one content object.
         *   (So you can't have a "box of books and papers" by having separate
         *   nominal contents objects for the books and the papers; although
         *   you could fake it by creating a "books and papers" object.)
         */
        nominalContents = nil

        /*
         *   Can I be distinguished in parser messages by my contents?  If so,
         *   we can be distinguished (in parser messages) from similar objects
         *   by our contents, or lack thereof: "bucket of water" vs "empty
         *   bucket".  If this is true, our nominalContents property determines
         *   the contents we display for this.
         */
        distinguishByContents = nil

          /*
           *   This object's containment type - that is, the locType for direct
           *   children.  This is given as one of the spatial relation types (In,
           *   On, Under, Behind etc).
           */
        contType = Outside

        /* The list of things directly contained by this object */
        contents = [ ]

        /*
         *   The location of this object, i.e. this object's immediate container
         *   (which may be another Thing, a Room, or an Actor such as the player
         *   char). Note that while you should specify the initial location of an
         *   object via this property you should never directly alter this property
         *   in game code thereafter; to change the location on object during the
         *   the course of a game use the moveInto(loc) or actionMoveInto(loc)
         *   method.
         */
        location = nil

        /*
         *   Add an item to this object's contents. Normally this method is used
         *   internally in the library than directly by game code. If the vec
         *   parameter is supplied, the object added to our contents is also added
         *   to vec; again this is intended primarily for internal use by the
         *   library.
         */
        addToContents(obj, vec?)
        {
            contents = contents.appendUnique([obj]);
            if(vec != nil)
                vec.appendUnique(self);
        }

        /*
         *   Remove an item to this object's contents. Normally this method is used
         *   internally in the library than directly by game code. If the vec
         *   parameter is supplied, the object removed from our contents is also
         *   removed from vec; again this is intended primarily for internal use by
         *   the library.
         */
        removeFromContents(obj, vec?)
        {
            local idx = contents.indexOf(obj);
            if(idx != nil)
                contents = contents.removeElementAt(idx);

            if(vec != nil)
                vec.removeElement(self);
        }

        /*
         *   Basic moveInto for moving an object from one container to another by
         *   programmatic fiat.
         */
        moveInto(newCont)
        {
            /* If we have a location, remove us from its list of contents. */
            if(location != nil)
                location.removeFromContents(self);

            /* Set our new location. */
            location = newCont;

            /*
             *   Provided our new location isn't nil, add us to our new location's
             *   list of contents.
             */
            if(location != nil)
                location.addToContents(self);
        }

        /* Move into generated by a user action, which includes notifications */
        actionMoveInto(newCont)
        {
            /*
             *   If we have a location, notify our existing location that we're
             *   about to be removed from it.
             */
            if(location != nil)
                location.notifyRemove(self);

            /*
             *   If the location we're about to be moved into is non-nil, notify our
             *   new location that we're about to be moved into it. Note that both
             *   this and the previous notification can veto the move with an exit
             *   command.
             */
            if(newCont != nil)
                newCont.notifyInsert(self);

            /* Carry out the move. */
            moveInto(newCont);

            /* Note that we have been moved. */
            moved = true;

            /* If the player character can now see us, note that we've been seen */
            if(Q.canSee(gPlayerChar, self))
                noteSeen();
        }

        /*
         *   Receive notification that obj is about to be removed from inside us; by
         *   default we do nothing.
         */
        notifyRemove(obj) { }

        /*
         *   Receive notification that obj is about to be inserted into us; by
         *   default we do nothing.
         */
        notifyInsert(obj) { }

        /*
         *   Move a MultiLoc (ml) into this additional Thing or Room, by adding it
         *   to this thing's contents list and adding the Thing to ml's
         *   locationList.
         */
        moveMLIntoAdd(ml)
        {
            if(contents.indexOf(ml) == nil)
                addToContents(ml);

            if(ml.locationList.indexOf(self) == nil)
                ml.locationList += self;
        }

        /*
         *   Move a MultiLoc (ml) out of this object, by removing it from our
         *   contents list and removing us from its locationList.
         */
        moveMLOutOf(ml)
        {
            removeFromContents(ml);

            ml.locationList -= self;
        }

        /* Is obj visible from us? */
        canSee(obj) { return Q.canSee(self, obj); }

        /* Is obj audible from us? */
        canHear(obj) { return Q.canHear(self, obj); }

        /* Is obj smellable from us? */
        canSmell(obj) { return Q.canSmell(self, obj); }

        /* Is obj reachable (by touch) from us? */
        canReach(obj) { return Q.canReach(self, obj); }

         /*
         *   Are we a containment "child" of the given object with the given
         *   location type?  This returns true if our location is the given
         *   object and our locType is the given type, or our location is a
         *   containment child of the given object with the given type.
         *
         *   'typ' is a LocType giving the relationship to test for, or nil.
         *   If it's nil, we'll return true if we have any containment
         *   relationship to 'obj'.
         */
        isChild(obj, typ)
        {
            /*
             *   If the typ we're testing for is neither nil nor the containment
             *   type of obj, return nil.
             */
            if(typ not in (nil, obj.contType))
                return nil;

            /* Otherwise return whether or not we're in obj. */
            return isIn(obj);
        }

        /*
         *   Are we a direct containment child of the given object with the
         *   given containment type?  'typ' is a LocType giving the
         *   relationship to test for, or nil.  If it's nil, we'll return true
         *   if we have any direct containment relationship with 'obj'.
         */
        isDirectChild(obj, typ)
        {
            /*
             *   If the typ we're testing for is neither nil nor the containment
             *   type of obj, return nil.
             */
            if(typ not in (nil, obj.contType))
                return nil;

            /* Otherwise return whether or not we're directly in obj. */
            return isDirectlyIn(obj);
        }

        /*  Are we directly in cont? */
        isDirectlyIn(cont)
        {
            /* If cont is nil then we're in cont if our location is nil. */
            if(cont == nil)
                return location == nil;

            /*
             *   Otherwise we're directly in cont either if our location is cont or
             *   if we're in cont's contents list (the latter test caters for
             *   MultiLocs).
             */
            return location == cont || valToList(cont.contents).indexOf(self) != nil;
        }

        /* Are we in cont? */
        isIn(cont)
        {
            /* If we're directly in cont, then we're certainly in cont. */
            if(isDirectlyIn(cont))
                return true;

            /* Otherwise if out location is nil, we're not in cont */
            if(location == nil)
                return nil;

            /* Otherwise we're in cont if our location is in cont. */
            return location.isIn(cont);
        }

        /* Are either oont or in cont ? */
        isOrIsIn(cont)
        {
            return self == cont || isIn(cont);
        }

         /*
         *   Get my list of enclosed direct contents.  This is the subset of my
         *   direct contents that have interior location types (In).
         */
        intContents = ( contType == In ? contents : [] )

        /*
         *   Get my list of unenclosed direct contents.  This is the subset of
         *   my direct contents that have exterior location types (On, Outside,
         *   Behind, Under).
         */
        extContents = ( contType == In ? [] : contents)

        /* Carry out the preinitialization of a Thing */
        preinitThing()
        {
            /*
             *   If we have both a location and a subLocation (which should be a
             *   property pointer if it's not nil), change our location to the
             *   object defined on the subLocation property of our location; this is
             *   used to place objects in the SubComponents of their parent objects.
             */
            if(subLocation != nil && location != nil)
                location = location.(subLocation);

            /*   If we have a location, add ourselves to its contents list. */
            if(location != nil)
                location.addToContents(self);

            /* if we have a global parameter name, add it to the global table */
            if (globalParamName != nil)
                libGlobal.nameTable_[globalParamName] = self;

            /* If our owner property isn't already a list, convert it to one. */
            owner = valToList(owner);

            /* If we have a keyList, add ourselves to every key in the list */
            if(keyList != nil)
            {
                foreach(local key in valToList(keyList))
                {
                    if(key.ofKind(Key))
                    {
                        key.actualLockList = key.actualLockList.appendUnique([self]);
                        key.plausibleLockList = key.plausibleLockList.appendUnique([self]);
                    }
                }

                foreach(local key in valToList(knownKeyList))
                {
                    if(key.ofKind(Key))
                    {
                        key.knownLockList = key.knownLockList.appendUnique([self]);
                    }
                }

            }

            /*
             *   if we have any remapXXX properties, set those objects to the same
             *   listOrder as our own, since they're effectively representations of
             *   ourself.
             */

            for(local prop in remapProps)
            {
                local obj = self.(prop);
                if(obj)
                    obj.listOrder = listOrder;
            }

            /*
             *   If we're compiling for debug, warn the user if s/he's used the
             *   canSitOn, canLieOn or canStand on properties in an inconsistent
             *   manner.
             */
    #ifdef __DEBUG
            if(isBoardable == nil && contType != On)
            {
                if(canSitOnMe)
                    "WARNING! canSitOnMe is true on <<theName>> when <<theName>>
                    cannot be boarded.\n";
                if(canStandOnMe)
                    "WARNING! canStandOnMe is true on <<theName>> when <<theName>>
                    cannot be boarded.\n";
                if(canLieOnMe)
                    "WARNING! canLieOnMe is true on <<theName>> when <<theName>>
                    cannot be boarded.\n";

                if(canSitOnMe || canStandOnMe || canLieOnMe)
                    "You either need to make <<objToString()>> a Platform or remove
                    your override on its canSit/Stand/LieOnMe properties\b";
            }

    #endif
        }

        /*
         *   Our outermost room, i.e. the top level Room in which we are indirectly
         *   or directly contained.
         */
        getOutermostRoom = (location == nil ? nil : location.getOutermostRoom)

        interiorParent()
        {
            /* if I don't have a location, there's no interior parent */
            if (location == nil)
                return nil;

            /* if my immediate location is interior, it's the interior parent */
            if (location.contType == In || location.ofKind(Room))
                return location;

            /* otherwise, it's my parent's interior parent */
            return location.interiorParent();
        }

        /*
         *   Am I on the inside of the given object?  This returns true if our
         *   relationship to the given object is an interior location type.
         */
        isInterior(obj)
        {
            if(location == nil)
                return nil;

            if(location == obj && obj.contType == In)
                return true;

            if(location.ofKind(SubComponent) && location.contType == In &&
               location.lexicalParent == obj)
                return true;

            return location.isInterior(obj);
        }

        /*
         *   Find the immediate child of 'self' that contains 'other'.  If
         *   'other' is directly in 'self', we return 'other'; otherwise, we
         *   return an object directly within 'self' that contains 'obj',
         *   directly or indirectly.  If 'other' is not within 'self', we
         *   return nil.
         */
        directChildParent(other)
        {
            /* scan other's parent chain until we find a direct child of self */
            for (local o = other ; o != nil ; o = o.location)
            {
                if (o.location == self)
                    return o;
            }

            /* 'other' is not a child */
            return nil;
        }

          /*
         *   Get the containment relationship between 'child' and 'self'.  This
         *   returns the containment type of the immediate child of 'self' that
         *   contains 'child'.
         */
        childLocType(child)
        {
            /* get the direct child of self containing child */
            child = directChildParent(child);

            /*
             *   If we found the direct child container, the containment
             *   relationship is the one between 'self' and the direct child;
             *   otherwise there's no relationship.
             */
            return (child != nil ? child.locType : nil);
        }

        /*
         *   Find the nearest common containing parent of self and other. Unlike
         *   commonInteriorParent this doesn't take account of the type of
         *   containment (it can be In, On, Under, Behind or anything else) just so
         *   long as we find a common parent in the containment hierarchy.
         */
        commonContainingParent(other)
        {
            /* start at each object's nearest direct parent */
            local l1 = location;
            local l2 = other.location;

             /*
              *   if one or the other doesn't have a location, there's no common
              *   parent.
              */

            if(l1 == nil || l2 == nil)
                return nil;

             /* work up the containment tree one parent at a time */
            while (l1 != nil || l2 != nil)
            {
                /* if I'm inside the current other parent, that's the common one */
                if (l2 != nil && isIn(l2))
                    return l2;

                /* if other is in my current parent, that's the nearest one */
                if (l1 != nil && other.isIn(l1))
                    return l1;

                /* move up one level */
                l1 = (l1 != nil ? l1.location : nil);
                l2 = (l2 != nil ? l2.location : nil);
            }

            /* there's no common parent */
            return nil;
        }

       /*
         *   Find the nearest common interior parent of self and other.  This
         *   finds the nearest parent that both self and other are inside of.
         */
        commonInteriorParent(other)
        {
            /* start at each object's nearest interior parent */
            local l1 = interiorParent();
            local l2 = other.interiorParent();

            /*
             *   if one or the other doesn't have an interior parent, there's no
             *   common parent.
             */

            if(l1 == nil || l2 == nil)
                return nil;

            /* work up the containment tree one interior at a time */
            while (l1 != nil || l2 != nil)
            {
                /* if I'm inside the current other parent, that's the common one */
                if (l2 != nil && isInterior(l2))
                    return l2;

                /* if other is in my current parent, that's the nearest one */
                if (l1 != nil && other.isInterior(l1))
                    return l1;

                /* move up one level */
                l1 = (l1 != nil ? l1.interiorParent() : nil);
                l2 = (l2 != nil ? l2.interiorParent() : nil);
            }

            /* there's no common parent */
            return nil;
        }

        /*
         *   Get the interior containment path from 'self' to 'other'.  This
         *   returns a list containing three elements.  The first element is a
         *   sublist giving the interior containers you have to traverse
         *   outwards from self up to the common interior parent.  The second
         *   element is the common container; this will be nil if the two
         *   objects are in separate rooms.  The third element is a sublist
         *   giving the containers you have to traverse inwards from the common
         *   parent to other.
         */
        containerPath(other)
        {
            /* set up vectors for the outward and inward paths */
            local outPath = new Vector(10), inPath = new Vector(10);

            /* set up a variable for the common parent */
            local commonPar = nil;

            /* trace the paths, accumulating the elements in the vectors */
            traceContainerPath(
                other,
                { c: outPath.append(c) },
                { c: commonPar = c },
                { c: inPath.append(c) });

            /* return the lists */
            return [outPath.toList(), commonPar, inPath.toList()];
        }

        /*
         *   Trace the interior containment path from 'self' to 'other'.
         *
         *   We'll start by working up the containment tree from 'self' to the
         *   nearest interior container we have in common with 'other' - that
         *   is, the nearest object that contains both 'self' and 'other' with
         *   an interior location type for each object.  For each container
         *   BELOW the common parent, we call outFunc(container).
         *
         *   Next, we call parentFunc(container) on the common container.  If
         *   there is no common container, we call parentFunc(nil).
         *
         *   Next, we work back down the containment tree from the common
         *   parent to 'other'.  For each container below the common parent, we
         *   call inFunc(container).
         */
        traceContainerPath(other, outFunc, parentFunc, inFunc)
        {
            /* find the nearest common enclosing container */
            local cpar = commonInteriorParent(other);

            /* work up from self to the common parent */
            for (local c = interiorParent() ; c != cpar ; c = c.interiorParent())
                outFunc(c);

            /* call the common parent callback */
            parentFunc(cpar);

            /*
             *   Work back down from the common parent to other.  The easy way
             *   to do this is to build a stack from other up to cpar, then
             *   work back through the stack.
             */
            local stk = new Vector(10);
            for (local c = other.interiorParent() ; c != cpar ;
                 c = c.interiorParent())
                stk.push(c);

            /* work back through the stack */
            while (!stk.isEmpty())
                inFunc(stk.pop());
        }

        /*
         *   Search for a "blockage" along the container path between 'self'
         *   and 'other'.  'outProp' and 'inProp' are "can" properties
         *   (&canSeeOut, &canReachIn, etc) that test a container to see
         *   whether we can see/reach/hear/etc in or out of the container.
         *
         *   We trace the containment path, using traceContainerPath().  For
         *   each outbound container on the path, we evaluate the container's
         *   outProp property: if this is nil, we add that container to the
         *   blockage list.  Next, if there's no common parent, we add the
         *   outermost room containing 'self' to the list.  Next, we trace the
         *   inbound path, evaluating each container's inProp property: if nil,
         *   we add that container to the blockage list.
         *
         *   Finally, we return the blockage list.  This is a vector giving all
         *   of the blockages we found, in the order we encountered them.
         */
        containerPathBlock(other, inProp, outProp)
        {
            /* set up a vector for the blockage list */
            local vec = new Vector(10);

            /* trace the path, noting each blockage */
            traceContainerPath(
                other,
                new function(c) { if (!c.(inProp)) vec.append(c); },
                new function(c) { if (c == nil) vec.append(outermostParent()); },
                new function(c) { if (!c.(outProp)) vec.append(c); });

            /* return the path */
            return vec;
        }

        /*
         *   Get the first blockage in a container path.  This calls
         *   containerPathBlock() and returns the first blockage in the list,
         *   or nil if there's no blockage.
         */
        firstContainerPathBlock(other, inProp, outProp)
        {
            local v = containerPathBlock(other, inProp, outProp);
            return (v.length() != 0 ? v[1] : nil);
        }

        outermostVisibleParent()
        {
            /*
             *   our "eyes" are on our outside, so we can always see our own
             *   parent; find its outermost visible container
             */
            local loc;
            for (loc = location ; loc != nil ; loc = loc.location)
            {
                /* if this is the outermost container, we're done */
                if (loc.location == nil)
                    break;

                /* if we can't see out to our next container, stop here */
                if (loc.contType == In && !loc.canSeeOut)
                    break;
            }

            /* return what we found */
            return loc;

        }

        /*
         *   Our location type with respect to our immediate container; e.g. are we
         *   In, On, Under or Behind it?
         */
        locType()
        {
            /* If we don't have a location we can't have a locType */
            if(location == nil)
                return nil;

            /*
             *   If our location is a Carrier then our locType depends on other
             *   factors.
             */
            if(location.contType == Carrier)
            {
                /* If we're worn by our location then our locType is Worn. */
                if(wornBy == location)
                    return Worn;

                /*
                 *   Otherwise, if we're fixed in place we're a component of our
                 *   location (i.e. a part of the actor that's our location), so our
                 *   locType is Outside (we're attached to but external to our
                 *   location
                 */
                if(isFixed)
                    return Outside;

                /*  Otherwise, if we're a portable object, we're being carried. */
                return Held;
            }

            /* Otherwise our locType is simply our location's contType. */
            else return location.contType;
        }

         /*
         *   Get my outermost parent.  This is simply our ancestor in the
         *   location tree that has no location itself.
         */
        outermostParent()
        {
            return locationWhich({ p: p.location == nil });
        }

        /* are we on the exterior of the given object, directly or indirectly? */
        isOutside(obj)
        {
            return (location == obj ? locType == Outside :
                    location != nil && location.isOutside(obj));
        }

        /* are we held by the given object, directly or indirectly? */
        isHeldBy(obj)
        {
            return (location == obj ? locType == Held :
                    location != nil && location.isHeldBy(obj));
        }

        /*
         *   Flag; is this Thing a vehicle for an actor? If so then issuing a travel
         *   command while in this vehicle will call this vehicle to travel
         */
        isVehicle = nil

        /*
         *   The nested room subhead.  This shows a little addendum to the room
         *   headline when the point-of-view actor is inside an object within
         *   the main room, such as a chair or platform.  This usually shows
         *   something of the form "(in the chair)".  Note that only the
         *   *immediate* container is shown; if the actor is in a chair in a
         *   booth on a stage, we normally only mention the chair.
         *
         *   We leave this to the language library to define, since the exact
         *   syntax varies by language.
         */
        // roomSubhead(pov) { }

        /*
         *   Listing order.  This is an integer giving the relative position of
         *   this item in a miscellaneous item list.  The list is sorted in
         *   ascending order of this value.
         */
        listOrder = 100

        /*
         *   List group.  At the moment this does nothing, but it has been retained
         *   from the Mercury library for possible future use.
         */
        listWith = nil

        /*
         *   Group order.  This gives the relative order of this item within
         *   its list group.
         */
        groupOrder = 100

         /*
          *   CollectiveGroup, or a list of CollectiveGroups, to which this item
          *   belongs.
          */
        collectiveGroups = nil

        /*
         *   The owner or owners of the object.  This is for resolving
         *   possessives in the player's input, such as BOB'S WALLET.  By
         *   default, an object has no explicit owner, so this is an empty
         *   list.
         *
         *   This should only return the *explicit* owner(s), not an implied
         *   locational owner.  For example, if Bob is holding a key, it's
         *   implicitly BOB'S KEY.  However, the key may or may not still be
         *   Bob's after he drops it.  If the key is something that's
         *   understood to belong to Bob, whether it's currently in his
         *   physical possession or not, then this routine would return Bob;
         *   otherwise it would return nil.
         *
         *   An object can have multiple explicit owners, in which case it'll
         *   be recognized with a possessive qualifier for any of the owners.
         *   The first owner in the list is the nominal owner, meaning its the
         *   one we'll use if we're called upon to display the object's name
         *   with a possessive phrase.
         */
        owner = []

        /*
         *   Are we the nominal owner of the objects we contain?  This controls
         *   whether or not we can be chosen as the nominal owner of a contained
         *   object for display purposes.  If a contained object has no explicit
         *   owner, it can still be implicitly owned by an actor carrying it, or by
         *   another suitable container.  (Note that this only applies as a default.
         *   When an item in our contents has an explicit owner, that will override
         *   the implied container ownership for that item.  So, for example, Bob
         *   can be carrying Bill's wallet wallet, and as long as the wallet has its
         *   explicit owner set, we'll still describe it as Bill's despite its
         *   location.)
         *
         *   By default, most objects are not nominal owners.  Actors generally
         *   should set this to true, so that (for example) anything Bob is carrying
         *   can be described as Bob's. Something with contType = Carrier is likely
         *   to be an actor and hence something that can own its contents.
         */
        ownsContents = (contType == Carrier)

        /*
         *   Get my nominal owner.  If we have an explicit owner, we'll return
         *   the first explicit owner.  Otherwise, we'll look for a container
         *   that has ownsContents = true, and return the first such container.
         */
        nominalOwner()
        {
            /* if I have an explicit owner, return the first one */
            if (owner.length() > 0)
                return owner[1];

            /* look for a container with ownsContents = true */
            return locationWhich({loc: loc.ownsContents});
        }

        /*
         *   Does the given object own me, explicitly or implicitly?  This
         *   returns true if 'obj' is in my 'owner' list, but it can also
         *   return true if there's merely an implied ownership relationship.
         *   Location can imply ownership: BOB'S KEY could refer to the key
         *   that Bob is holding, whether or not it would continue to be
         *   considered his key if he were to drop it.
         *
         *   We return true if 'obj' is an explicit owner, OR self is contained
         *   within 'obj', OR self is contained within an object owned by
         *   'obj'.  (The latter case is for things like BOB'S TWENTY DOLLAR
         *   BILL, which is Bob's by virtue of being inside a wallet explicitly
         *   owned by Bob.)
         */
        ownedBy(obj)
        {
            /* if obj is in my explicit owner, we're owned by obj */
            if (owner.indexOf(obj))
                return true;

            /* if we're a child of obj, we're implicitly owned by obj */
            if (isChild(obj, nil))
                return true;

            /* are we inside something owned by obj? */
            if (location != nil && location.ownedBy(obj))
                return true;

            /* we're not owned by obj */
            return nil;
        }

        /*
         *   Return a list of everything that's directly or indirectly contained
         *   within us.
         */
        allContents()
        {
            local vec = new Vector(20);

            addToAllContents(vec, contents);

            return vec.toList;
        }

        addToAllContents(vec, lst)
        {
            vec.appendUnique(lst);
            foreach(local cur in lst)
                addToAllContents(vec, cur.contents);
        }

        /* get everything that's directly in me */
        directlyIn = (contents.subset({ obj: obj.locType == In }))

        /*
         *   Run a check method passed as a property pointer in the prop parameter
         *   and return any string it tried to display
         */
        tryCheck(prop)
        {
            local ret;
            try
            {
                ret = gOutStream.captureOutput({: self.(prop) });
            }
            catch (ExitSignal ex)
            {
                if(ret is in ('', nil))
                    ret = gAction.failCheckMsg;
            }
            finally
            {
                return ret;
            }
        }

        locationWhich(func)
        {
            /*
             *   scan up the location tree until we reach the top, or a
             *   location for which func(loc) returns true
             */
            local loc;
            for (loc = location ; loc != nil && !func(loc) ; loc = loc.location) ;

            /* return what we found */
            return loc;
        }

        /*
         *   Are we transparent to light?  If this is true, then an observer
         *   outside this object can see through it to objects on its interior,
         *   and an observer inside can see through to objects on its exterior.
         *
         *   This property controls transparency symmetrically (looking in from
         *   outside and looking out from within).  The library also lets you
         *   control transparency asymmetrically, using canSeeIn and canSeeOut.
         *   Those values are by default derived from this one, but you can
         *   override them separately to create something like a one-way
         *   mirror.
         */
        isTransparent = nil

        /*
         *   Do we fully enclose our interior contents (true), or only
         *   partially (nil)?  By default, we assume that our contents are
         *   fully enclosed.  This can be set to nil for objects that represent
         *   spaces that are open on one side, such as a nook in a rock or a
         *   create without a lid.
         *
         *   For an object that's sometimes fully enclosing and sometimes not,
         *   such as a cabinet with a door that can be opened and closed, this
         *   should be overridden with a method that figures the current value
         *   based on the open/closed state.
         *
         *   Note that this only applies to our *interior* contents, such as
         *   contents of location type In.  Contents that are atop the object
         *   or otherwise arranged around the exterior aren't affected by this.
         */
        enclosing = (contType == In && isOpen == nil)

        /*
         *   Can we see in from my exterior to my interior?  That is, can an
         *   observer outside of this object see things located within it?  By
         *   default, we can see in from outside if we're transparent or we're
         *   non-enclosing.
         */
        canSeeIn = (isTransparent || !enclosing)

        /*
         *   Can we see out from my interior to my exterior?  That is, can an
         *   observer inside this object see things located outside of it?  By
         *   default, we can see out from inside if we're transparent or we're
         *   non-enclosing.
         */
        canSeeOut = (isTransparent || !enclosing)

         /*
         *   Can we hear in from my exterior to my interior?  That is, can an
         *   observer on the outside of this container hear a sound source on
         *   the inside?
         *
         *   By default, we can hear in for all containers, since most
         *   materials transmit at least some sound even if they're opaque to
         *   light.  For a soundproof material (a glass booth, say), you could
         *   override this to make it (!enclosing) instead.
         */
        canHearIn = true

        /*
         *   Can we hear out from my interior to my exterior?  That is, can an
         *   observer on the inside of this container hear a sound source on
         *   the outside?
         *
         *   By default, we can hear out for all containers, since most
         *   materials transmit at least some sound even if they're opaque to
         *   light.  For a soundproof material (a glass both, say), you could
         *   override this to make it (!enclosing) instead.
         */
        canHearOut = true

        /*
         *   Can we smell in (from an observer on my exterior to an odor source
         *   on my interior)?  By default, we can smell in if we're
         *   non-enclosing, since most solid materials aren't very permeable to
         *   scents (at human sensitivities, at least).
         */
        canSmellIn = (!enclosing)

        /*
         *   Can we smell out (from an observer on my interior to an odor
         *   source on my exterior)?  By default, we can smell out if we're
         *   non-enclosing, since most solid materials aren't very permeable to
         *   scents (at human sensitivities, at least).
         */
        canSmellOut = (!enclosing)

        /*
         *   Can we reach out from my interior to my exterior?  That is, can an
         *   observer inside this object reach something outside of it?  By
         *   default, we can reach out if we're non-enclosing.
         */
        canReachOut = (!enclosing)

        /*
         *   Can we reach in from my exterior to my interior?  That is, can an
         *   observer outside this object reach something inside of it?  By
         *   default, we can reach in if we're non-enclosing.
         */
        canReachIn = (!enclosing)

        /*
         *   Allow this object to add additional checks at the check and verify
         *   stages to stipulate whether it can reach obj (or obj can reach it). We
         *   might use this, for example, to put an object conditionally out of
         *   reach if it's on top of a high cupboard or it's too hot to touch.
         */

        /*
         *   If the verifyReach() method is defined, it should use the
         *   illogical/inaccessible/implausible/logical/logicalRank verify macros
         *   like a verify method. Don't define this method if you don't want it to
         *   block reaching.
         */
    //    verifyReach(obj) { }

        /*
         *   Check whether the actor can reach (touch) this object. If this method
         *   displays anything (which should be the reason this object can't be
         *   touched) then the object can't be reached. Note that this only has any
         *   effect when the touchObj preCondition is defined.
         */
        checkReach(actor) {  }

        /*
         *   Check whether an actor can reach inside this object (for reasons other
         *   that it enclosing its contents; e.g. because it's out of reach). If
         *   this method displays anything (which should be the reason the interior
         *   of this object can't be reached) then disallow reaching inside. Note
         *   that this only has any effect when the touchObj preCondition is defined
         *   on this object. By default we can reach inside if we can reach this
         *   object and not otherwise. If the optional target parameter is supplied,
         *   it's the object that actor is trying to reach.
         */
        checkReachIn(actor, target?)
        {
            checkReach(actor);
        }

        /*
         *   Check whether the actor can reach out of this object to touch obj, if
         *   obj is not in this object.
         */
        allowReachOut(obj) { return true; }

        /*
         *   If an actor within me cannot reach an object from me, should the actor
         *   automatically try to get out of me?
         */
        autoGetOutToReach = true

        /*
         *   Return a message explaining why an object outside me can't reach one
         *   inside (or vice versa); this will normally be triggered by an attempt
         *   to reach an object inside a closed transparent container. The method is
         *   defined here to make it easier to customize the message on the
         *   container that's doing the blocking.
         */
        reachBlockedMsg(target)
        {
            local obj = self;
            gMessageParams(obj, target);
            return  BMsg(cannot reach, '{I} {can\'t} reach {the target} through
                {the obj}. ');
        }

        /*
         *   Return a message (single-quoted string) explaining why we can't be
         *   reached by the actor (typically because we're in a different room).
         */
        tooFarAwayMsg
        {
            local obj = self;
            gMessageParams(obj);
            return BMsg(too far away, '{The subj obj} {is} too far away. ');
        }

        /*
         *   Return a message (single-quoted string) explaining why target can't be
         *   reached from inside this Thing (when this Thing is typically some kind
         *   of nested room such as a Booth or Platform).
         */
        cannotReachOutMsg(target)
        {
            local loc = self;
            gMessageParams(loc, target);
            return BMsg(cannot reach out, '{I} {can\'t} reach {the target} from
                        {the loc}. ');
        }

        /*
         *   Does this object shine light outwards?  This determines if the
         *   object is a light source to objects outside of it.  Light shines
         *   out from an object if the object itself is a light source, or one
         *   of its direct exterior contents shines out, or its contents are
         *   visible from the outside and one of its direct interior contents
         *   shines out.
         */
        shinesOut()
        {
            /* if I'm a light source directly, we shine light outwards */
            if (isLit)
                return true;

            /* check my exterior contents */
            if (contents.indexWhich(
                { c: c.locType.ofKind(ExtLocType) && c.shinesOut() }) != nil)
                return true;

            /* if we can see into this object from outside, check the contents */
            if (canSeeIn
                && contents.indexWhich(
                    { c: c.locType.ofKind(IntLocType) && c.shinesOut() }) != nil)
                return true;

            /* I don't provide light outwards */
            return nil;
        }

        /*
         *   Is this object's interior lit?
         *   an object if the object itself is a light source, or anything
         *   directly inside shines outwards, or we can see out from within and
         *   our location shines inwards.
         */
        litWithin()
        {
            /* if I'm a light source directly, we shine inwards */
            if (isLit)
                return true;

            /* if any interior contents shine outwards, we're lit within */
            if (contents.indexWhich(
                { c: c.locType.ofKind(IntLocType) && c.shinesOut() }) != nil)
                return true;

            /*
             *   if we can see out from within, and my enclosing parent is lit
             *   within, I'm lit within
             */
            if (canSeeOut)
            {
                local p = interiorParent();
                if (p != nil && p.litWithin())
                    return true;
            }

            /* I don't provide light inwards */
            return nil;
        }

        /*
         *   Has this object ever been moved by the player character?  This is
         *   set to true when the PC takes the object or puts it somewhere.
         */
        moved = nil

        /*
         *   Have we been examined?  This is set to true when the player
         *   character examines the object.  For a room, LOOK AROUND counts as
         *   examination, as does triggering a room description by traveling
         *   into the room.
         */
        examined = nil

        /*
         *   Have we been seen?  This is set to true the first time the object
         *   is described or listed in a room description or the description of
         *   another object (such as LOOK IN this object's container).
         */
        seen = nil

        /*
         *   The last location where the player character saw this object.
         *   Whenever the object is described or listed in the description of a
         *   room or another object, we set this to the object's location at
         *   that time.
         */
        lastSeenAt = nil

        /* Note that we've been seen and where we were last seen */
        noteSeen()
        {
            gPlayerChar.setHasSeen(self);
            lastSeenAt = location;
        }

        /*
         *   Whether the player character knows of the existence of this object, if
         *   if it hasn't been seen. Set to true for objects that the player
         *   character should be familiar with at the start of play, or make true
         *   when the PC learns of them.
         */
        familiar = nil

        /*
         *   Properties to set and test whether an object is known about or has been
         *   seen; we define these on Thing to allow the player char to be a Thing.
         *   In what follows 'this Thing' is the object on which the method is
         *   called (which would typically be an Actor, the player character, or
         *   some other object representing an NPC) and obj is the object that is
         *   potentially known about or seen.
         */

        /*  Mark this Thing as knowing about obj. */
        setKnowsAbout(obj) { obj.(knownProp) = true; }

        /*  Mark the player character as knowing about us (i.e. this Thing) */
        setKnown() { gPlayerChar.setKnowsAbout(self); }

        /*  Mark this Thing as having seen obj. */
        setHasSeen(obj) { obj.(seenProp) = true; }

        /*  Mark the player character as having seen this Thing. */
        setSeen() { gPlayerChar.setHasSeen(self); }

        /*  Test whether this Thing has seen obbj. */
        hasSeen(obj) { return obj.(seenProp); }

        /*
         *   Test whether this Thing knows about obj, which it does either if it has
         *   seen this obj or its knownProp (by default, familiar) is true.
         */
        knowsAbout(obj) {return hasSeen(obj) || obj.(knownProp); }

        /*
         *   Test whether this Thing is known to the player character.
         */
        known = (gPlayerChar.knowsAbout(self))

         /*
          *   If we want to track whether characters other than than the player char
          *   know about or have seen this object, we can define knownProp and
          *   seenProp as the properties used by this Thing to track what it knows
          *   about and has seen.
          */
        knownProp = &familiar
        seenProp = &seen

        /*
         *   The currentInterlocutor is the Actor this object is currently in
         *   conversation with. This property is only relevant on gPlayerChar, but
         *   it is defined here rather than on Actor since the player char can be of
         *   kind Thing.
         */
        currentInterlocutor = nil

         /*
          *   Can this Thing (which might be the Player Char for instance) talk to
          *   other?
          */
        canTalkTo(other)
        {
            return Q.canTalkTo(self, other);
        }

        /* The lister to use when listing this object's inventory. */
        myInventoryLister = inventoryLister

        /* The lister to use when listing what this object is wearing. */
        myWornLister = wornLister

        /*
         *   Score this object for disambiguation.  When a noun phrase is
         *   ambiguous (for example, the phrase matches multiple in-scope
         *   objects, and we have to choose just one), the parser calls this
         *   routine on each object it's considering as a match.
         *
         *   Our job here is to read the player's mind.  The question before us
         *   is: did the player mean *this* object when typing this noun
         *   phrase?  Obviously we can't really know what's in the player's
         *   mind, but in many cases we can make an educated guess based on
         *   what ought to make the most sense in context.  The context in this
         *   case is the state of the simulated game world, as it's portrayed
         *   to the player.  That last bit is important: be cognizant of what
         *   the player is *meant* to know at this point.  DON'T base the score
         *   on information that the player isn't supposed to know, though:
         *   that could give away secrets that the player is meant to discover
         *   on her own.
         *
         *   Before this routine is called, the Action has already assigned an
         *   initial score to each object, but this routine can override the
         *   initial score by assigning its own score value.  This routine is
         *   most useful in cases where a particular object has a special
         *   affinity for a verb, or for the verb in combination with
         *   particular other objects involved in the command.
         *
         *   'cmd' is the Command object.  'role' is the noun phrase's role in
         *   the command (DirectObject, IndirectObject, etc).  'lst' is a list
         *   of NPMatch objects identifying the objects that matched the noun
         *   phrase.  'm' is the NPMatch object for self.
         *
         *   To override or adjust the score, simply set m.score to the new
         *   value.  This routine is also free to override the scores of any
         *   other objects in the list, if needed.
         *
         *   By default, we don't make any adjustment - we simply accept the
         *   initial score calculated by the Action, by leaving m.score
         *   unchanged.
         *
         *   See Action.scoreObjects() for full details.
         */
        scoreObject(cmd, role, lst, m)
        {
            m.score += vocabLikelihood;

            /*
             *   If we're the last object written on, boost our score if the player
             *   wants to write something again.
             */
            if(libGlobal.lastWrittenOnObj == self && cmd.action == WriteOn && role
               == IndirectObject)
                m.score += 20;

            /*
             *   If we're the last object typed on, boost our score if the player
             *   wants to type something again.
             */
            if(libGlobal.lastTypedOnObj == self && cmd.action == TypeOn && role
               == IndirectObject)
                m.score += 20;

        }

        /*
         *   A property that can be used to boost this object being chosen by the
         *   parser, other things being equal; it can be used as a tie-breaker
         *   between two objects that otherwise have the same verification scores.
         *   Game code should normally use fairly small values for this property,
         *   say between -20 and +20, to prevent overriding the verification score.
         */
        vocabLikelihood = 0

        /*
         *   A list of objects that are facets of this object, and so can be
         *   referred to with the same pronoun.
         */
        getFacets = []

        /*
         *   Before travel notification. This is called just before traveler
         *   attempts to travel via connector. By default we do nothing
         */
        beforeTravel(traveler, connector) {}

        /*
         *   After travel notification. This is called just after traveler has
         *   traveled via connector.
         */
        afterTravel(traveler, connector) {}

        /*
         *   Cause this Thing to travel via the connector conn. This method is
         *   supplied in case travelVia is called on a Thing which is not an Actor,
         *   although it's Actor that has the full implementation.
         */
        travelVia(conn, announceArrival = true)
        {
            /*
             *   If we've been mixed in with a TravelConnector class, it's almost
             *   certainly the TravelConnector's version of travelVia() that we need
             *   to execute here.
             */
            if(ofKind(TravelConnector))
                inherited TravelConnector(conn);

            else
                /* Move this actor via conn. */
                conn.travelVia(self);
        }

        /*
         *   Handle a command directed to this open (e.g. BALL, GET IN BOX). Since
         *   inanimate objects generally can't respond to commands we simply display
         *   a message announcing the futility of issuing one. This method is
         *   overridden on Actor to allow Actors to respond to commands via
         *   CommandTopics.
         */
        handleCommand(action)
        {
            DMsg(cannot command thing, 'There{dummy}\'s no point trying to give
                orders to {1}. ', aName);
        }

        /*
         *   The before action handling on this Thing if it's the current actor. We
         *   define it here rather than on Actor since the player character can be a
         *   Thing. By default we do nothing.
         */
        actorAction() { }

        /*
         *   Before action notification on this Thing; this is triggered whenever an
         *   action is about to be performed when we're in scope (and could be used
         *   to veto the action with an exit macro). The action we'd test for here
         *   would normally be one that *doesn't* involve this Thing.
         */
        beforeAction() { }

        /*
         *   After action notification on this Thing; this is triggered whenever an
         *   action has just been performed when we're in scope. The action we'd
         *   test for here would normally be one that *doesn't* involve this Thing.
         */
        afterAction() { }

        /* Is this object the player character? */
        isPlayerChar = (gPlayerChar == self)

        /*
         *   To exclude this item from the list of objects to be acted upon when the
         *   player types a command with ALL for action, override this method to
         *   return true for the action or actions concerned. Note that this
         *   exclusion is applied after the action has constructed its own list of
         *   objects that ALL should apply to, and can only be used to make further
         *   exclusions.
         *
         *   It shouldn't be necessary to use this method very often, since the
         *   normal approach will be to override the getAll() method on the
         *   appropriate action. It may be useful to use this method to handle
         *   exceptional cases, however.
         */
        hideFromAll(action) { return nil; }

        /*
         *   ******************************************************************
         *   ACTION HANDLING
         *
         *   Here follows code relating to the handling of specific actions
         */

         /*
          *   If I declare this object to be a decoration (i.e. isDecoration = true)
          *   then its default behaviour will be to display its notImportantMsg for
          *   every action except Examine or GoTo. We can extend the actions it will
          *   respond to by adding them to the list in the decorationActions
          *   property.
          */
        isDecoration = nil

        /*
         *   The list of actions this object will respond to specifically if
         *   isDecoration is true. All other actions will be handled by
         *   dobjFor(Default) and/or iobjFor(Default). Game code can override this
         *   list (usually to expand it) for decorations that are required to handle
         *   additional actions.
         *
         *   If we're compiling for debugging, it will be useful to allow the GONEAR
         *   command with Decorations for testing purposes, but this can't be
         *   included in a release build without causing a compilation error, so we
         *   define the decorationActions property with different lists of actions
         *   depending on whether we're compiling for debugging or release.
         */
    #ifdef __DEBUG
        decorationActions = [Examine, GoTo, GoNear]
    #else
        decorationActions = [Examine, GoTo]
    #endif
        /*
         *   Our handling of any action of which we're the direct or indirect action
         *   that's not in our list of decorationActions when our isDecoration
         *   property is true. By default we just stop the action at the verify
         *   stage and display our notImportantMsg.
         */
        dobjFor(Default)
        {
            verify
            {
                illogical(notImportantMsg);
            }
        }

        iobjFor(Default)
        {
            verify()
            {
                illogical(notImportantMsg);
            }
        }

        notImportantMsg = BMsg(not important, '{The subj cobj} {is} not important.
             ')

        /*
         *   Next deal with what happens if this object is being tested as a
         *   potential actor
         */
        verifyActor()
        {
           /*
            *   If our contType isn't Carrier we're unlikely to be an actor, so
            *   we're a poor choice of object if the parser has to select an actor,
            *   typically when the player has entered a command targeted at an NPC.
            */
            if(contType != Carrier)
                logicalRank(70);
        }

        remapActor = nil

        preCondActor = [objAudible]

        /* Now the handling for specific actions */

        dobjFor(Examine)
        {
            preCond = [objVisible]

            verify()
            {
                if(isDecoration)
                    logicalRank(70);
                else
                    logical;
            }

            check() { }

            action()
            {
                local descDisplayed = nil;

                /*
                 *   If we have a non-nil darkDesc property and we're in a dark
                 *   room, display our darkDesc and stop there. Note this will only
                 *   ever happen if we're visibleInDark.
                 */
                if(propType(&inDarkDesc) != TypeNil
                   && !getOutermostRoom.isIlluminated())
                {
                    /* Display our darkDesc */
                    display(&inDarkDesc);

                    /*
                     *   Stop there, because in a dark room we can only be seen
                     *   partially, and so we don't add any status information or
                     *   record that we've been (properly) examined.
                     */
                    return;
                }

                /*
                 *   Display our description. Normally the desc property will be
                 *   specified as a double-quoted string or a routine that displays
                 *   a string, but by using the display() message we ensure that it
                 *   will still be shown even if desc has been defined a
                 *   single-quoted string.
                 */
                if(gOutStream.watchForOutput({:display(&desc) }))
                   descDisplayed = true;

                /*
                 *   Display any additional information, such as our stateDesc (if
                 *   we have one) and our contents (if we have any).
                 */
                if(gOutStream.watchForOutput({:examineStatus()} ))
                    descDisplayed = true;

                /*
                 *   If nothing has been displayed yet, show the default message
                 *   saying we nothing special about this object.
                 */
                if(!descDisplayed)
                    DMsg(nothing special,  '{I} {see} nothing special about
                    {the 1}. ', self);

                /*   Note that we've now been examined. */
                examined = true;

                /*
                 *   Note that the player character has seen us. 99 times out a
                 *   hundred this probably won't be necessary, but it may catch the
                 *   odd case where something is examined that hasn't yet been set
                 *   as seen.
                 */
                if(gActor == gPlayerChar)
                    noteSeen();

                "\n";
            }
        }

        /* The message to display when it's too dark to see anything */
        tooDarkToSeeMsg = BMsg(too dark to see, 'It{dummy}{\'s} too dark to see
            anything. ')

        /*
         *   By default everything is smellable, but you can override this to nil if
         *   something isn't
         */
        isSmellable = true

        cannotSmellMsg = BMsg(cannot smell, '{I} {can\'t} smell {the dobj}. ')

        dobjFor(SmellSomething)
        {
            preCond = [objSmellable]

            verify()
            {
                if(!isSmellable)
                    illogical(cannotSmellMsg);
            }

            action()
            {
                displayAlt(&smellDesc, &smellNothingMsg);
            }
        }

        smellNothingMsg = BMsg(smell nothing, '{I} {smell} nothing out of the
                        ordinary.<.p>')

        dobjFor(ListenTo)
        {

            preCond = [objAudible]

            action()
            {
                displayAlt(&listenDesc, &hearNothingMsg);
            }
        }

        hearNothingMsg = BMsg(hear nothing listen to, '{I} hear{s/d} nothing out of
            the ordinary.<.p>')

        /*
         *   By default everything is tasteable, but there might well be things the
         *   that it would not be appropriate to taste.
         */
        isTasteable = true

        cannotTasteMsg = BMsg(cannot taste, '{The subj dobj} {is} not suitable for
            tasting. ')

        dobjFor(Taste)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isTasteable)
                    illogical(cannotTasteMsg);
            }

            action()
            {
                if(propType(&tasteDesc) == TypeNil)
                    DMsg(taste nothing, '{I} taste{s/d} nothing unexpected.<.p>');
                else
                    display(&tasteDesc);
            }
        }

        /*
         *   By default we can try feeling most things, but there may be some things
         *   it would be inappropriate to try feeling (like a blazing fire or Aunt
         *   Mable) or somethings that cannot be felt (like a ray of light).
         */
        isFeelable = true

        cannotFeelMsg = BMsg(cannot feel, 'It{\'s} hardly a good idea to try feeling
            {the dobj}. ')

        /*
         *   This property can be defined to display a message at the check stage
         *   (and so stop the FEEL action there). Normally checkFeelMsg would be
         *   defined as a double-quoted string, but it can also be defined as a
         *   double-quoted string or a method that displays some text.
         */
        checkFeelMsg = nil

        dobjFor(Feel)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isFeelable)
                    illogical(cannotFeelMsg);
            }

            check()
            {
                if(dataType(&checkFeelMsg) != TypeNil)
                    display(&checkFeelMsg);

            }

            action()
            {
                if(propType(&feelDesc) == TypeNil)
                    DMsg(feel nothing, '{I} {feel} nothing unexpected.<.p>');
                else
                    display(&feelDesc);
            }
        }

        /* By default a Thing is takeable if it's not fixed in place */
        isTakeable = (!isFixed)

        dobjFor(Take)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isTakeable)
                    illogical(cannotTakeMsg);

                if(isDirectlyIn(gActor))
                    illogicalNow(alreadyHeldMsg);

                if(gActor.isIn(self))
                    illogicalNow(cannotTakeMyContainerMsg);

                if(gActor == self)
                    illogicalSelf(cannotTakeSelfMsg);

                logical;
            }

            check()
            {
                /*
                 *   Check that the actor has room to hold the item s/he's about to
                 *   pick up.
                 */
                checkRoomToHold();
            }

            action()
            {
                /*
                 *   If we have any contents hidden behind us or under us, reveal it
                 *   now
                 */
                revealOnMove();

                /*
                 *   move us into the actor who is taking us, triggering the
                 *   appropriate notifications.
                 */
                actionMoveInto(gActor);
            }

            /*
             *   Report that we've been taken. Note that if the action causes
             *   several items to be taken, this method will only be called on the
             *   final item, and will need to report on all the items taken.
             */
            report()
            {
                DMsg(report take, 'Taken. | {I} {take} {1}. ', gActionListStr);
            }
        }

        cannotTakeMsg = BMsg(cannot take, '{The subj cobj} {is} fixed in place.
            ')

        alreadyHeldMsg = BMsg(already holding, '{I}{\'m} already holding {the dobj}.
            ')

        cannotTakeMyContainerMsg = BMsg(cannot take my container, '{I} {can\'t}
            take {the dobj} while {i}{\'m} {1} {him dobj}. ', objInPrep)

        cannotTakeSelfMsg = BMsg(cannot take self, '{I} {can} hardly take {myself}. ')

        /*
         *   Flag, should any items behind me be left behind when I'm moved; by
         *   default, they should.
         */
        dropItemsBehind = true

        /*
         *   Flag, should any items behind me be left behind when I'm moved; by
         *   default, they should.
         */
        dropItemsUnder = true

        /*
         *   List and move into an appropriate location any item that was hidden
         *   behind or under us. We place this in a separate method so it can be
         *   conveniently called by other actions that move an object, or overridden
         *   by particular objects that want a different handling.
         *
         *   Note that we don't provide any handling for the hiddenIn property here,
         *   on the assumption that items hidden in something may well stay there
         *   when it's moved; but this method can always be overridden to provide
         *   custom behaviour.
         */
        revealOnMove()
        {
            local moveReport = '';
            local underLoc = location;
            local behindLoc = location;

            /*
             *   If I don't want to leave items under me behind when I'm moved, and
             *   I am or have an underside, change the location to move items hidden
             *   under me to accordingly.
             */
            if(contType == Under && dropItemsUnder == nil)
                underLoc = self;
            else if(remapUnder != nil && dropItemsUnder == nil)
                underLoc = remapUnder;

             /*
              *   If I don't want to leave items behind me behind when I'm moved,
              *   and I am or have a RearContainer, change the location to move
              *   items hidden under me to accordingly.
              */
            if(contType == Behind && dropItemsBehind == nil)
                behindLoc = self;
            else if(remapBehind != nil && dropItemsBehind == nil)
                behindLoc = remapBehind;

            /*
             *   If anything is hidden under us, add a report saying that it's just
             *   been revealed moved and then move the previously hidden items to
             *   our location.
             */
            if(hiddenUnder.length > 0)
            {
                moveReport +=
                    BMsg(reveal move under,'Moving {1} {dummy} reveal{s/ed} {2}
                        previously hidden under {3}. ',
                         theName, makeListStr(hiddenUnder), himName);

                moveHidden(&hiddenUnder, underLoc);

            }

            /*
             *   If anything is hidden behind us, add a report saying that's just
             *   been revealed and then move the previously hidden items to our
             *   location.
             */
            if(hiddenBehind.length > 0)
            {
                moveReport +=
                    BMsg(reveal move behind,'Moving {1} {dummy} reveal{s/ed} {2}
                        previously hidden behind {3}. ',
                         theName, makeListStr(hiddenBehind), himName);

                moveHidden(&hiddenBehind, behindLoc);
            }

            /*
             *   Construct a list of anything left behind from under or behind us
             *   when we're moved.
             */
            local lst = [];

            if(dropItemsUnder)
            {
                if(contType == Under)
                    lst = contents;
                else if(remapUnder)
                    lst = remapUnder.contents;
            }

            if(dropItemsBehind)
            {
                if(contType == Behind)
                    lst += contents;
                else if(remapBehind)
                    lst += remapBehind.contents;
            }

            lst = lst.subset({o: !o.isFixed});

            if(lst.length > 0)
            {
                foreach(local cur in lst)
                    cur.moveInto(location);

                moveReport +=
                    BMsg(report left behind, '<<if moveReport == ''>>Moving {1}
                        <<else>>It also <<end>> {dummy} {leaves} {2} behind. ',
                         theName, makeListStr(lst));
            }

            /*
             *   If anything has been reported as being revealed, report the
             *   discovery after reporting the action that caused it.
             */
            if(moveReport != '' )
                reportAfter(moveReport);
        }

        /*
         *   Service method: move everything in the prop property to loc and mark it
         *   as seen.
         */
        moveHidden(prop, loc)
        {
            foreach(local cur in self.(prop))
            {
                cur.moveInto(loc);
                cur.noteSeen();
            }
            self.(prop) = [];

        }

        /*
         *   Check that the actor has enough spare bulkCapacity to add this item to
         *   his/her inventory. Since by default everything has a bulk of zero and a
         *   very large bulkCapacity, by default there will be no effective
         *   restriction on what an actor (and in particular the player char) can
         *   carry, but game authors may often wish to give portable items bulk in
         *   the interests of realism and may wish to impose an inventory limit by
         *   bulk by reducing the bulkCapacity of the player char.
         */
        checkRoomToHold()
        {
            /*
             *   First check whether this item is individually too big for the actor
             *   to carry.
             */
            if(bulk > gActor.maxSingleBulk)
                DMsg(too big to carry, '{The subj dobj} {is} too big for {me} to
                    carry. ');

            /*
             *   If the BagOfHolding class is defined and the actor doesn't have
             *   enough spare bulk capacity, see if the BagOfHolding class can deal
             *   with it by moving something to a BagOfHolding.
             */
            if(defined(BagOfHolding)
               && bulk > gActor.bulkCapacity - gActor.getCarriedBulk
               && BagOfHolding.tryHolding(self));

            /*
             *   otherwise check that the actor has sufficient spare carrying
             *   capacity.
             */
            else if(bulk > gActor.bulkCapacity - gActor.getCarriedBulk())
                DMsg(cannot carry any more, '{I} {can\'t} carry any more than
                    {i}{\'m} already carrying. ');
        }

        /* By default we can drop anything that's held */
        isDroppable = true

        /* The message to display if something can't be dropped. */
        cannotDropMsg = BMsg(cannot drop, '{The subj dobj} {can\'t} be dropped. ')

        /* The location in which something dropped in me should land. */
        dropLocation = self

        dobjFor(Drop)
        {
            preCond = [objNotWorn]

            verify()
            {
                /* I can't drop something I'm not holding */
                if(!isDirectlyIn(gActor))
                    illogicalNow(notHoldingMsg);

                /*
                 *   Even if something is directly in me, I can't drop it if it's
                 *   fixed in place (since it's then presumably a part of me).
                 */
                else if(isFixed)
                    illogical(partOfYouMsg);

                /*
                 *   And I can't drop something that game code has deemed to be not
                 *   droppable for some other reason.
                 */
                else if(!isDroppable)
                    illogical(cannotDropMsg);

                logical;
            }

            action()
            {
                actionMoveInto(gActor.location.dropLocation);
            }

            report()
            {
                DMsg(report drop, 'Dropped. |{I} drop{s/?ed} {1}. ', gActionListStr);
            }
        }

        notHoldingMsg = BMsg(not holding, '{I} {amn\'t} holding {the dobj}. ')
        partOfYouMsg = BMsg(part of me, '{The subj dobj} {is} part of {me}. ')

        /* By default an object is readable if it defines a non-nil readDesc */
        isReadable = (propType(&readDesc) != TypeNil)

        dobjFor(Read)
        {
            preCond = [objVisible]

            verify()
            {
                if(!isReadable)
                    illogical(cannotReadMsg);
            }

            action()
            {
                if(propType(&readDesc) == TypeNil)
                    say(cannotReadMsg);
                else
                    display(&readDesc);
            }
        }

        cannotReadMsg = BMsg(cannot read, 'There {dummy} {is} nothing to read on
            {the dobj}. ')

        /*
         *   Flag: can this object be followed? Most inanimate objects cannot, so
         *   the default value is nil.
         */
        isFollowable = nil

        dobjFor(Follow)
        {
            preCond = [objVisible]

            verify()
            {
                if(!isFollowable)
                    illogical(cannotFollowMsg);

                if(self == gActor)
                    illogicalSelf(cannotFollowSelfMsg);
            }
        }

        cannotFollowMsg = BMsg(cannot follow, '{The subj dobj} {isn\'t} going
            anywhere. ')

        cannotFollowSelfMsg = BMsg(cannot follow self, '{I} {can\'t} follow
            {myself}. ')

        /*
         *   Although in theory we can attack almost anything, in practice there's
         *   seldom reason to do so.
         */
        isAttackable = nil

        dobjFor(Attack)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isAttackable)
                    illogical(cannotAttackMsg);
            }

            check()
            {
                if(dataType(&checkAttackMsg) != TypeNil)
                    display(&checkAttackMsg);
            }

            /*
             *   In case isAttackable is changed to true but no other handling is
             *   added, we need to provide some kind of default report.
             */
            report()
            {
                say(futileToAttackMsg);
            }
        }

        /*
         *   If we want Attack to fail at the check stage we can supply a message
         *   explaining why.
         */
        checkAttackMsg = nil

        cannotAttackMsg = BMsg(cannot attack, 'It{dummy}{\'s} best to avoid
            pointless violence. ')

        dobjFor(AttackWith)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isAttackable)
                    illogical(cannotAttackMsg);
            }

            /*
             *   In case isAttackable is changed to true but no other handling is
             *   added, we need to provide some kind of default report.
             */
            report()
            {
                say(futileToAttackMsg);
            }
        }

        futileToAttackMsg = BMsg(futile attack, 'Attacking {1} prove{s/d} futile. ',
                                 gActionListStr)

        iobjFor(AttackWith)
        {
            preCond = [objHeld]
            verify()
            {
                if(!canAttackWithMe)
                   illogical(cannotAttackWithMsg);

                if(gDobj == self)
                    illogicalSelf(cannotAttackWithSelfMsg);
            }
        }

        /* By default we can't use most things as weapons */
        canAttackWithMe = nil

        cannotAttackWithSelfMsg = BMsg(cannot attack with self, '{I} {can\'t}
            attack anything with itself. ')

        cannotAttackWithMsg = BMsg(cannot attack with, '{I} {can\'t} attack
            anything with {that iobj}. ')

        dobjFor(Strike) asDobjFor(Attack)

        /*
         *   By default treat everything as breakable, but there are somethings that
         *   clearly aren't like sunbeams, sounds and mountains.
         */
        isBreakable = true

        /*   Probably most things shouldn't be broken though. */
        shouldBeBroken = nil

        dobjFor(Break)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isBreakable)
                    illogical(cannotBreakMsg);
                else if(!shouldBeBroken)
                    implausible(shouldNotBreakMsg);
            }
        }

        cannotBreakMsg = BMsg(cannot break, '{The subj dobj} {is} not the sort of
            thing (i) {can} break. ')

        shouldNotBreakMsg = BMsg(dont break, '{I} {see} no point in breaking {that
            dobj}. ')

        /* By default something is throwable unless it's fixed in place. */
        isThrowable = (!isFixed)

        dobjFor(ThrowDir)
        {
            preCond = [objHeld]

            verify()
            {
                if(!isThrowable)
                    illogical(cannotThrowMsg);

            }

            /*
             *   The default result of throwing something in a compass direction is
             *   that it lands in the dropLocation of its outermost room.
             */
            action() { actionMoveInto(getOutermostRoom.dropLocation); }

            report()
            {
                local obj = gActionListObj;

                gMessageParams(obj);

                DMsg(throw dir, '{I} {throw} {the obj} {1} and {he obj}
                    land{s/ed} on the ground. ', gAction.direction.name );
            }
        }

        cannotThrowMsg = BMsg(cannot throw, '{I} {can\'t} throw {the dobj} anywhere.
            ')

        /*
         *   Is this object openable. If this property is set to true then this
         *   object can be open and closed via the OPEN and CLOSE commands. Note
         *   that setting this property to true also automatically makes the
         *   OpenClosed State apply to this object, so that it can be referred to as
         *   'open' or 'closed' accordingly.
         */
        isOpenable = nil

        /*
         *   Is this object open. By default we'll make Things open so that their
         *   interiors (if they have any) are accessible, unless they're openable,
         *   in which case we'll assume they start out closed.
         */
        isOpen = (!isOpenable)

        /*
         *   Make us open or closed. We define this as a method so that subclasses
         *   such as Door can override to produce side effects (such as opening or
         *   closing the other side).
         */
        makeOpen(stat)
        {
            isOpen = stat;
            if(stat)
                opened = true;
        }

        /*
         *   Flag, has this object ever been opened. Note that this is nil for an
         *   object that starts out open but has never been closed and opened again.
         */
        opened = nil

        /*
         *   Flag, do we want to attempt to unlock this item it it's locked when we
         *   try to open it?
         */
        autoUnlock = nil

        dobjFor(Open)
        {

            preCond = autoUnlock ? [touchObj, objUnlocked] : [touchObj]

            /*
             *   If this object is not itself openable, but its remapIn property
             *   points to an associated object that is, remap this action to use
             *   the remapIn object instead of us.
             */
            remap()
            {
                if(!isOpenable && remapIn != nil && remapIn.isOpenable)
                    return remapIn;
                else
                    return self;
            }

            verify()
            {
                if(isOpenable == nil)
                    illogical(cannotOpenMsg);

                if(isOpen)
                    illogicalNow(alreadyOpenMsg);

                logical;
            }

            /*
             *   An object can't be open if it's locked. We test this at check
             *   rather than verify since it may not be obvious that an object's
             *   locked until someone tries to open it.
             */
            check()
            {
                if(isLocked)
                    say(lockedMsg);
            }

            action()
            {
                makeOpen(true);

                /*
                 *   If opening us is not being performed as an implicit action,
                 *   list the contents that are revealed as a result of our being
                 *   opened.
                 */
                if(!gAction.isImplicit)
                {
                    unmention(contents);
                    listSubcontentsOf(self, &myOpeningContentsLister);
                }
            }

            report()
            {
                DMsg(okay open, okayOpenMsg, gActionListStr);
            }
        }

        /*
         *   The lister to use when listing my contents when I'm opened. By default
         *   we use the openingContentsLister.
         */
        myOpeningContentsLister = openingContentsLister

        okayOpenMsg = 'Opened.|{I} open{s/ed} {1}. '

        cannotOpenMsg = BMsg(cannot open, '{The subj dobj} {is} not something {i}
            {can} open. ')
        alreadyOpenMsg = BMsg(already open, '{The subj dobj} {is} already open. ')
        lockedMsg = BMsg(locked, '{The subj dobj} {is} locked. ')

        /* By default something is closeable if it's openable */
        isCloseable = (isOpenable)

        dobjFor(Close)
        {
            preCond = [touchObj]

            remap()
            {
                if(!isCloseable && remapIn != nil && remapIn.isCloseable)
                    return remapIn;
                else
                    return self;
            }

            verify()
            {
                if(!isCloseable)
                    illogical(cannotCloseMsg);
                if(!isOpen)
                    illogicalNow(alreadyClosedMsg);
                logical;
            }

            action()
            {
                makeOpen(nil);
            }

            report()
            {
                DMsg(report close, 'Done. |{I} close{s/d} {1}. ',  gActionListStr);
            }
        }

        cannotCloseMsg = BMsg(not closeable, '{The subj dobj} {is} not something
            that {can} be closed. ')
        alreadyClosedMsg = BMsg(already closed,'{The subj dobj} {isn\'t} open. ')

        /*
         *   By default we make everything turnable, but lots of things clearly
         *   won't be.
         */
        isTurnable = true

        dobjFor(Turn)
        {

            preCond = [touchObj]

            verify()
            {
                if(!isTurnable)
                    illogical(cannotTurnMsg);
                else if(isDirectlyIn(gActor))
                    logical;
                else
                    logicalRank(80);
            }

            report()
            {
                say(turnNoEffectMsg);
            }

        }

        cannotTurnMsg = BMsg(cannot turn, '{The subj dobj} {can\'t} be turned. ')

        turnNoEffectMsg = BMsg(turn useless, 'Turning {1} {dummy} achieve{s/d}
            nothing. ', gActionListStr)

        dobjFor(TurnWith)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isTurnable)
                    illogical(cannotTurnMsg);
                else if(isDirectlyIn(gActor))
                    logical;
                else
                    logicalRank(80);
            }

            report()
            {
                say(turnNoEffectMsg);
            }

        }

        /* By default things can't be used to turn other things with */
        canTurnWithMe = nil

        iobjFor(TurnWith)
        {
            preCond = [objHeld]
            verify()
            {
                if(gDobj == self)
                    illogical(cannotTurnWithSelfMsg);

                if(!canTurnWithMe)
                    illogical(cannotTurnWithMsg);
            }
        }

        cannotTurnWithMsg = BMsg(cannot turn with, '{I} {can\'t} turn anything with
            {that iobj}. ')

        cannotTurnWithSelfMsg = BMsg(turn self, '{I} {cannot} turn anything with
            itself. ')

        /* By default things can't be cut */
        isCuttable = nil

        dobjFor(Cut)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isCuttable)
                   illogical(cannotCutMsg);
            }

            action() { askForIobj(CutWith); }
        }

        dobjFor(CutWith)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isCuttable)
                   illogical(cannotCutMsg);
            }
        }

        /* Most things can't be used to cut other things with */
        canCutWithMe = nil

        iobjFor(CutWith)
        {
            preCond = [objHeld]

            verify()
            {
                if(self == gDobj)
                    illogicalSelf(cannotCutWithSelfMsg);

                if(!canCutWithMe)
                    illogical(cannotCutWithMsg);
            }
        }

        cannotCutMsg = BMsg(cannot cut, '{I} {can\'t} cut {the dobj}. ')
        cannotCutWithMsg = BMsg(cannot cut with, '{I} {can\'t} cut anything with
            {that iobj}. ')
        cannotCutWithSelfMsg = BMsg(cannot cut with self, '{I} {cannot} cut anything
            with itself. ')

        /*
         *   If the actor finds something in a hiddenPrep list and there's nowhere
         *   obvious for it go, should he take it? By default the actor should take
         *   it if the object he's found it in/under/behind is fixed in place.
         */
        autoTakeOnFindHidden = (isFixed)

        /*
         *   Where should an item that's been hidden in/under/behind something be
         *   moved to when its found? If it's taken, move into the actor; otherwise
         *   move it to the location of the object it's just been found
         *   in/under/behind.
         */
        findHiddenDest = (autoTakeOnFindHidden ? gActor : location)

        dobjFor(LookIn)
        {
            preCond = [objVisible, containerOpen]

            remap = remapIn

            verify()
            {
                if(contType == In || remapIn != nil)
                    logicalRank(120);

                logical;
            }

            action()
            {
               /*
                *   If we're actually a container-type object, i.e. if our contType
                *   is In, try to determine what's inside us and display a list of
                *   it; if there's nothing inside us just display a message to that
                *   effect.
                */
                if(contType == In)
                {
                    /*
                     *   If there's anything hidden inside us move it into us before
                     *   doing anything else
                     */
                    if(hiddenIn.length > 0)
                        moveHidden(&hiddenIn, self);

                    /* If there's nothing inside us, simply display our lookInMsg */
                    if(contents.length == 0)
                        display(&lookInMsg);

                    /* Otherwise display a list of our contents */
                    else
                    {
                        /* Start by marking our contents as not mentioned. */
                        unmention(contents);

                        /*
                         *   It's possible that we have contents but nothing in our
                         *   contents is listable, so instead of just displaying a
                         *   list of contents we also watch to see if anything is
                         *   displayed; if nothing was we display our lookInMsg
                         *   instead.
                         */
                        if(gOutStream.watchForOutput(
                            {: listSubcontentsOf(self, &myLookInLister) }) == nil)
                          display(&lookInMsg);

                    }
                }

                /*
                 *   Otherwise, if we're not a container-type object (our contType
                 *   is not In), if there's anything in our hiddenIn list move it
                 *   into scope and display a list of it.
                 */
                else if(hiddenIn.length > 0)
                    findHidden(&hiddenIn, In);

                /*  Otherwise just display our lookInMsg */
                else
                    display(&lookInMsg);
            }

        }

        /*
         *   The lister to use when listing the objects inside me in response to a
         *   LOOK IN command. By default we use the lookInLister.
         */
        myLookInLister = lookInLister

        /*
         *   By default our lookInMsg just says the actor finds nothing of interest
         *   in us; this could be overridden for an objecy with a more interesting
         *   interior.
         */
        lookInMsg = BMsg(look in, '{I} {see} nothing interesting in {the
            dobj}. ')

        /*
         *   If there's something hidden in the dobj but nowhere obvious to move it
         *   to then by default we move everything from the hiddenIn list to the
         *   actor's inventory and announce that the actor has taken it. We call
         *   this out as a separate method to make it easy to override if desired.
         */
        findHidden(prop, prep)
        {
            /* Report what we find */
            sayFindHidden(prop, prep);

            /* Move the hidden items to the appropriate location. */
            moveHidden(prop, findHiddenDest);
        }

        /*
         *   Report what was found hidded in/under/behind us. We make this a
         *   separate method so that it can be easily customized on individual
         *   objects.
         */
        sayFindHidden(prop, prep)
        {
             DMsg(find hidden, '\^{1} {the dobj} {i} {find} {2}<<if findHiddenDest ==
                  gActor>>, which {i} {take}<<end>>. ',
                 prep.prep, makeListStr(self.(prop)));
        }

        /*
         *   We can look under most things, but there are some things (houses, the
         *   ground, sunlight) it might not make much sense to try looking under.
         */
        canLookUnderMe = true

        dobjFor(LookUnder)
        {
            preCond = [objVisible, touchObj]

            remap = remapUnder

            verify()
            {
                if(!canLookUnderMe)
                    illogical(cannotLookUnderMsg);
            }

            action()
            {
                /*
                 *   If we're actually an underside-type object, i.e. if our
                 *   contType is Under, try to determine what's under us and display
                 *   a list of it; if there's nothing under us just display a
                 *   message to that effect.
                 */
                if(contType == Under)
                {

                    /*
                     *   If there's anything hidden under us move it into us before
                     *   doing anything else
                     */
                    if(hiddenUnder.length > 0)
                        moveHidden(&hiddenUnder, self);

                    /* If there's nothing under us, simply display our lookUnerMsg */
                    if(contents.length == 0)
                        display(&lookUnderMsg);

                    /* Otherwise display a list of our contents */
                    else
                    {
                        /* Start by marking our contents as not mentioned. */
                        unmention(contents);

                        /*
                         *   It's possible that we have contents but nothing in our
                         *   contents is listable, so instead of just displaying a
                         *   list of contents we also watch to see if anything is
                         *   displayed; if nothing was we display our lookUnderMsg
                         *   instead.
                         */
                        if(gOutStream.watchForOutput(
                            {: listSubcontentsOf(self, &myLookUnderLister) }) == nil)
                            display(&lookUnderMsg);

                    }
                }

                /*
                 *   Otherwise, if we're not an underside-type object (our contType
                 *   is not Under), if there's anything in our hiddenUnder list move
                 *   it into scope and display a list of it.
                 */
                else if(hiddenUnder.length > 0)
                    findHidden(&hiddenUnder, Under);

                /*  Otherwise just display our lookUnderMsg */
                else
                    display(&lookUnderMsg);

            }
        }

        /*
         *   The lister to use when listing the objects under me in response to a
         *   LOOK UNDER command. By default we use the lookInLister.
         */
        myLookUnderLister = lookInLister

        cannotLookUnderMsg = BMsg(cannot look under, '{I} {can\'t} look under {that
            dobj}. ')

        lookUnderMsg = BMsg(look under, '{I} {find} nothing of interest under
            {the dobj}. ')

        /*
         *   By default we make it possible to look behind things, but there could
         *   be many things it makes no sense to try to look behind.
         */
        canLookBehindMe = true

        dobjFor(LookBehind)
        {
            preCond = [objVisible, touchObj]

            remap = remapBehind

            verify()
            {
                if(!canLookBehindMe)
                    illogical(cannotLookBehindMsg);
            }

            action()
            {
                /*
                 *   If we're actually a rear-type object, i.e. if our contType is
                 *   Behind, try to determine what's behind us and display a list of
                 *   it; if there's nothing behind us just display a message to that
                 *   effect.
                 */
                if(contType == Behind)
                {

                    /*
                     *   If there's anything hidden behind us move it into us before
                     *   doing anything else
                     */
                    if(hiddenBehind.length > 0)
                        moveHidden(&hiddenBehind, self);

                    /*
                     *   If there's nothing behind us, simply display our
                     *   lookBehindMsg
                     */
                    if(contents.length == 0)
                        display(&lookBehindMsg);

                    /* Otherwise display a list of our contents */
                    else
                    {
                        /* Start by marking our contents as not mentioned. */
                        unmention(contents);

                        /*
                         *   It's possible that we have contents but nothing in our
                         *   contents is listable, so instead of just displaying a
                         *   list of contents we also watch to see if anything is
                         *   displayed; if nothing was we display our lookBehindMsg
                         *   instead.
                         */
                        if(gOutStream.watchForOutput(
                            {: listSubcontentsOf(self, &myLookBehindLister) }) == nil)
                            display(&lookBehindMsg);

                    }
                }

                /*
                 *   Otherwise, if we're not a rear-type object (our contType is not
                 *   Behind), if there's anything in our hiddenBehind list move it
                 *   into scope and display a list of it.
                 */
                else if(hiddenBehind.length > 0)
                    findHidden(&hiddenBehind, Behind);

                /*  Otherwise just display our lookBehindMsg */
                else
                    display(&lookBehindMsg);

            }
        }

        /*
         *   The lister to use when listing the objects behind me in response to a
         *   LOOK BEHIND command. By default we use the lookInLister.
         */
        myLookBehindLister = lookInLister

        cannotLookBehindMsg = BMsg(cannot look behind, '{I} {can\'t} look behind
            {that dobj}. ')

        lookBehindMsg = BMsg(look behind, '{I} {find} nothing behind {the
            dobj}. ')

        /*
         *   By default we make it possible to look through things, but there may
         *   well be things you obviously couldn't look through.
         */
        canLookThroughMe = true

        dobjFor(LookThrough)
        {
            preCond = [objVisible]

            verify()
            {
                if(!canLookThroughMe)
                    illogical(cannotLookThroughMsg);
            }

            action() { display(&lookThroughMsg); }
        }

        cannotLookThroughMsg = BMsg(cannot look through, '{I} {can\'t} look through
            {that dobj}. ')

        lookThroughMsg = BMsg(look through, '{I} {see} nothing through {the
            dobj}. ')

        /* Most things cannot be gone through */
        canGoThrougMe = nil

        dobjFor(GoThrough)
        {
            preCond = [touchObj]
            verify()
            {
                if(!canGoThroughMe)
                    illogical(cannotGoThroughMsg);
            }
        }

        cannotGoThroughMsg = BMsg(cannot go through,'{I} {can\'t} go through {that
            dobj}. ')

        /* We can at least try to push most things. */
        isPushable = true

        dobjFor(Push)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isPushable)
                    illogical(cannotPushMsg);
            }

            report() { say(pushNoEffectMsg); }
        }

        cannotPushMsg = BMsg(cannot push, 'There{\'s} no point trying to push
            {that dobj}. ')

        pushNoEffectMsg = BMsg(push no effect, 'Pushing {1} {dummy} {has} no
            effect. ', gActionListStr)

        /* We can at least try to pull most things. */
        isPullable = true

        dobjFor(Pull)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isPullable)
                    illogical(cannotPullMsg);
            }

            report() { say(pullNoEffectMsg); }
        }

        cannotPullMsg = BMsg(cannot pull, 'There{\'s} no point trying to pull
            {that dobj}. ')

        pullNoEffectMsg = BMsg(pull no effect, 'Pulling {1} {dummy} {has} no
            effect. ', gActionListStr)

        /*
         *   The most usual reason why we can't put something somewhere is that we
         *   can't pick it up in the first place, so by default we'll just copy
         *   cannotPutMsg from cannotTakeMsg.
         */
        cannotPutMsg = cannotTakeMsg

        dobjFor(PutOn)
        {
            preCond = [objHeld, objNotWorn]

            verify()
            {
                if(gIobj != nil && self == gIobj)
                    illogicalSelf(cannotPutInSelfMsg);

                if(isFixed)
                    illogical(cannotPutMsg);

                if(gIobj != nil && isDirectlyIn(gIobj))
                    illogicalNow(alreadyInMsg);

                if(gIobj != nil && gIobj.isIn(self))
                    illogicalNow(circularlyInMsg);

                logical;
            }

            action()
            {
                /* Handled on iobj */
            }

            report()
            {
                DMsg(report put on, '{I} {put} {1} on {the iobj}. ', gActionListStr);
            }
        }

        alreadyInMsg = BMsg(already in, '{The subj dobj} {is} already {in iobj}. ')

        circularlyInMsg = BMsg(circularly in, '{I} {can\'t} put {the dobj} {in iobj}
            while {the subj iobj} {is} {in dobj}. ')

        cannotPutInSelfMsg = BMsg(cannot put in self, '{I} {can\'t} put {the dobj}
            {1} {itself dobj}. ', gIobj.objInPrep)

        iobjFor(PutOn)
        {

            preCond = [touchObj]

            remap = remapOn

            verify()
            {
                if(contType != On)
                    illogical(cannotPutOnMsg);

                logical;
            }

            check()
            {
                checkInsert(gDobj);
            }

            action()
            {
                gDobj.actionMoveInto(self);
            }

        }

        cannotPutOnMsg = BMsg(cannot put on,'{I} {can\'t} put anything on {the
            iobj}. '   )

        dobjFor(PutIn)
        {
            preCond = [objHeld, objNotWorn]

            verify()
            {
                if(gIobj != nil && self == gIobj)
                    illogicalSelf(cannotPutInSelfMsg);

                if(isFixed)
                    illogical(cannotPutMsg);

                if(gIobj != nil && isDirectlyIn(gIobj))
                    illogicalNow(alreadyInMsg);

                if(gIobj != nil && gIobj.isIn(self))
                    illogicalNow(circularlyInMsg);

                logical;
            }

            action()
            {
                /* handled on iobj */
            }

            report()
            {
                DMsg(report put in, '{I} {put} {1} in {the iobj}. ', gActionListStr);
            }
        }

        iobjFor(PutIn)
        {
            preCond = [containerOpen, touchObj]

            remap = remapIn

            verify()
            {
                if(!canPutInMe)
                    illogical(cannotPutInMsg);

                logical;
            }

            check()
            {
                /*
                 *   If we're actually a container-like object (our contType is In),
                 *   check whether there's enough room inside us to contain the
                 *   direct object.
                 */
                if(contType == In)
                   checkInsert(gDobj);

                /*
                 *   Otherwise check whether adding the direct object to our
                 *   hiddenIn list would exceed the amount of bulk allowed there.
                 */
                else if(gDobj.bulk > maxBulkHiddenIn - getBulkHiddenIn)
                    DMsg(no room in, 'There {dummy}{isn\'t} enough room for {the
                        dobj} in {the iobj}. ');
            }

            action()
            {
                /*
                 *   If we're actually a container-like object (i.e. if our contType
                 *   is In) then something put in us can be moved inside us.
                 *   Otherwise, all we can do with something put in us is to add it
                 *   to our hiddenIn list and move it off-stage.
                 */
                if(contType == In)
                    gDobj.actionMoveInto(self);
                else
                {
                    hiddenIn += gDobj;
                    gDobj.actionMoveInto(nil);
                }
            }

        }

        cannotPutInMsg = BMsg(cannot put in, '{I} {can\'t} put anything in {the
            iobj}. ')

        dobjFor(PutUnder)
        {
            preCond = [objHeld, objNotWorn]

            verify()
            {
                if(gIobj != nil && self == gIobj)
                    illogicalSelf(cannotPutInSelfMsg);

                if(isFixed)
                    illogical(cannotPutMsg);

                if(gIobj != nil && (isDirectlyIn(gIobj)))
                    illogicalNow(alreadyInMsg);

                if(gIobj != nil && gIobj.isIn(self))
                    illogicalNow(circularlyInMsg);

                logical;
            }

            action()
            {
                /* Handled by iobj */
            }

            report()
            {
                DMsg(report put under, '{I} {put} {1} under {the iobj}. ',
                     gActionListStr);
            }

        }

        iobjFor(PutUnder)
        {
            preCond = [touchObj]

            remap = remapUnder

            verify()
            {
                if(!canPutUnderMe)
                    illogical(cannotPutUnderMsg);
                else
                    logical;
            }

            check()
            {
                /*
                 *   If we're actually an underside-like object (our contType is
                 *   Under), check whether there's enough room under us to contain
                 *   the direct object.
                 */
                if(contType == Under)
                   checkInsert(gDobj);

                /*
                 *   Otherwise check whether adding the direct object to our
                 *   hiddenUnder list would exceed the amount of bulk allowed there.
                 */
                else if(gDobj.bulk > maxBulkHiddenUnder - getBulkHiddenUnder)
                    DMsg(no room under, 'There {dummy}{isn\'t} enough room for {the
                        dobj} under {the iobj}. ');
            }

            action()
            {
                /*
                 *   If we're actually an underside-like object (i.e. if our
                 *   contType is Under) then something put under us can be moved
                 *   inside us. Otherwise, all we can do with something put under us
                 *   is to add it to our hiddenUnder list and move it off-stage.
                 */
                if(contType == Under)
                    gDobj.actionMoveInto(self);
                else
                {
                    hiddenUnder += gDobj;
                    gDobj.actionMoveInto(nil);
                }
            }

        }

        cannotPutUnderMsg = BMsg(cannot put under, '{I} {cannot} put anything under
            {the iobj}. ' )

        dobjFor(PutBehind)
        {
            preCond = [objHeld, objNotWorn]

            verify()
            {
                if(gIobj != nil && self == gIobj)
                    illogicalSelf(cannotPutInSelfMsg);

                if(isFixed)
                    illogical(cannotPutMsg);

                if(gIobj != nil && (isDirectlyIn(gIobj)))
                    illogicalNow(alreadyInMsg);

                if(gIobj != nil && gIobj.isIn(self))
                    illogicalNow(circularlyInMsg);

                logical;
            }

            action()
            {
                /* Handled by iobj */
            }

            report()
            {
                DMsg(report put behind, '{I} {put} {1} behind {the iobj}. ',
                     gActionListStr);
            }

        }

        iobjFor(PutBehind)
        {
            preCond = [touchObj]

            remap = remapBehind

            verify()
            {
                if(!canPutBehindMe)
                    illogical(cannotPutBehindMsg);
                else
                    logical;
            }

            check()
            {
                /*
                 *   If we're actually a rear-like object (our contType is Behind),
                 *   check whether there's enough room behind us to contain the
                 *   direct object.
                 */
                if(contType == Behind)
                    checkInsert(gDobj);

                /*
                 *   Otherwise check whether adding the direct object to our
                 *   hiddenBehind list would exceed the amount of bulk allowed
                 *   there.
                 */
                 else if(gDobj.bulk > maxBulkHiddenBehind - getBulkHiddenBehind)
                    DMsg(no room behind, 'There {dummy}{isn\'t} enough room for {the
                        dobj} behind {the iobj}. ');
            }

            action()
            {
                /*
                 *   If we're actually a rear-like object (i.e. if our contType is
                 *   Behind) then something put behind us can be moved inside us.
                 *   Otherwise, all we can do with something put behind us is to add
                 *   it to our hiddenBehind list and move it off-stage.
                 */
                if(contType == Behind)
                    gDobj.actionMoveInto(self);
                else
                {
                    hiddenBehind += gDobj;
                    gDobj.actionMoveInto(nil);
                }
            }

        }

        cannotPutBehindMsg = BMsg(cannot put behind, '{I} {cannot} put anything
            behind {the iobj}. ')

        /*
         *   A list of Keys that can be used to lock or unlock this Thing. Any Keys
         *   in this list will cause this Thing to be added to the plausible and
         *   actual lock lists of that Key at PreInit. This provides an alternative
         *   way of specifying the relation between locks and keys.
         */
        keyList = nil

        /*
         *   A list of Keys that the player character starts out knowing at the
         *   start of the game can lock our unlock this Thing.
         */
        knownKeyList = nil

        /*
         *   Note: we don't use isLockable, because this is not a binary property;
         *   there are different kings of lockability and defining an isLockable
         *   property in addition would only confuse things and might break the
         *   logic.
         */
        dobjFor(UnlockWith)
        {

            preCond = [touchObj]

            /*
             *   Remap the unlock action to our remapIn object if we're not lockable
             *   but we have a lockable remapIn object (i.e. an associated
             *   container).
             */
            remap()
            {
                if(lockability == notLockable && remapIn != nil &&
                   remapIn.lockability != notLockable)
                    return remapIn;
                else
                    return self;
            }

            verify()
            {
                /*
                 *   If we're not lockable at all, we're a very poor choice of
                 *   direct object for an UnlockWith action.
                 */
                if(lockability == notLockable || lockability == nil)
                    illogical(notLockableMsg);

                /*
                 *   If we're lockable, but not with a key (either because we don't
                 *   need one at all or because we use some other form of locking
                 *   mechanism) then we're still a bad choice of object for an
                 *   UnlockWith action, but not so bad as if we weren't lockable at
                 *   all.
                 */
                if(lockability == lockableWithoutKey)
                    implausible(keyNotNeededMsg);

                if(lockability == indirectLockable)
                    implausible(indirectLockableMsg);

                /*
                 *   If we are lockable with key, then were a good choice of object
                 *   for an UnlockWith action provided we're currently locked.
                 */
                if(lockability == lockableWithKey)
                {
                    if(isLocked)
                        logical;
                    else
                        illogicalNow(notLockedMsg);
                }
            }
        }

        notLockableMsg = BMsg(not lockable, '{The subj dobj} {isn\'t} lockable. ')
        keyNotNeededMsg = BMsg(key not needed,'{I} {don\'t need[ed]} a key to lock
            and unlock {the dobj}. ')
        indirectLockableMsg = BMsg(indirect lockable,'{The dobj} appear{s/ed} to use
            some other kind of locking mechanism. ')
        notLockedMsg = BMsg(not locked, '{The subj dobj} {isn\'t} locked. ')

        /*
         *   Most things can't be used to unlock with. In practice there's probably
         *   little point in overriding this property since if you do want to use
         *   something to unlock other things with, you'd use the Key class.
         */
        canUnlockWithMe = nil

        iobjFor(UnlockWith)
        {
            verify()
            {
                if(!canUnlockWithMe)
                   illogical(cannotUnlockWithMsg);

                if(gDobj == self)
                    illogicalSelf(cannotUnlockWithSelfMsg);
            }
        }

        cannotUnlockWithMsg = BMsg(cannot unlock with, '{I} {can\'t} unlock
            anything with {that dobj}. ' )

        cannotUnlockWithSelfMsg = BMsg(cannot unlock with self, '{I} {can\'t} unlock
            anything with itself. ' )

        dobjFor(LockWith)
        {
            preCond  = [objClosed, touchObj]

             /*
              *   Remap the lock action to our remapIn object if we're not lockable
              *   but we have a lockable remapIn object (i.e. an associated
              *   container).
              */
            remap()
            {
                if(lockability == notLockable && remapIn != nil &&
                   remapIn.lockability != notLockable)
                    return remapIn;
                else
                    return self;
            }

            verify()
            {
                if(lockability == notLockable || lockability == nil)
                    illogical(notLockableMsg);

                if(lockability == lockableWithoutKey)
                    implausible(keyNotNeededMsg);

                if(lockability == indirectLockable)
                    implausible(indirectLockableMsg);

                if(lockability == lockableWithKey)
                {
                    if(isLocked)
                       illogicalNow(alreadyLockedMsg);
                    else
                        logical;
                }
            }

        }

        alreadyLockedMsg = BMsg(already locked, '{The subj dobj} {is} already
            locked. ')

        /*
         *   Usually, if something can be used to unlock things it can also be used
         *   to lock them
         */
        canLockWithMe = (canUnlockWithMe)

        iobjFor(LockWith)
        {
            verify()
            {
                if(!canLockWithMe)
                   illogical(cannotLockWithMsg);

                if(gDobj == self)
                    illogicalSelf(cannotLockWithSelfMsg);
            }
        }

        cannotLockWithMsg = BMsg(cannot lock with, '{I} {can\'t} lock anything with
            {that dobj}. ' )

        cannotLockWithSelfMsg = BMsg(cannot lock with self, '{I} {can\'t} lock
            anything with itself. ' )

        dobjFor(Unlock)
        {
            preCond = [touchObj]

            /*
             *   Remap the unlock action to our remapIn object if we're not lockable
             *   but we have a lockable remapIn object (i.e. an associated
             *   container).
             */
            remap()
            {
                if(lockability == notLockable && remapIn != nil &&
                   remapIn.lockability != notLockable)
                    return remapIn;
                else
                    return self;
            }

            verify()
            {
                if(lockability == notLockable || lockability == nil)
                    illogical(notLockableMsg);

                if(lockability == indirectLockable)
                    implausible(indirectLockableMsg);

                if(!isLocked)
                    illogicalNow(notLockedMsg);
            }

            check()
            {
                /*
                 *   if we need a key to be unlocked with, check whether the player
                 *   is holding a suitable one.
                 */
                if(lockability == lockableWithKey)
                    findPlausibleKey();

            }

            action()
            {
                /*
                 *   The useKey_ property will have been set by the
                 *   findPlausibleKey() method at the check stage. If it's non-nil
                 *   it's the key we're going to use to try to unlock this object
                 *   with, so we display a parenthetical note to the player that
                 *   we're using this key. (Note: the action would have failed at
                 *   the check stage if useKey_ wasn't the right key for the job).
                 */
                if(useKey_ != nil)
                    extraReport(withKeyMsg);

                /*
                 *   Otherwise, if we need a key to unlock this object with, ask the
                 *   player to specify it and then execute an UnlockWith action
                 *   using that key.
                 */
                else if(lockability == lockableWithKey)
                    askForIobj(UnlockWith);

                /*  Make us unlocked. */
                makeLocked(nil);
            }

            report()
            {
                DMsg(report unlock, okayUnlockMsg, gActionListStr);
            }

        }

        okayUnlockMsg = 'Unlocked.|{I} unlock{s/ed} {1}. '

        dobjFor(Lock)
        {
            preCond = [objClosed, touchObj]

             /*
              *   Remap the lock action to our remapIn object if we're not lockable
              *   but we have a lockable remapIn object (i.e. an associated
              *   container).
              */
            remap()
            {
                if(lockability == notLockable && remapIn != nil &&
                   remapIn.lockability != notLockable)
                    return remapIn;
                else
                    return self;
            }

            verify()
            {
                if(lockability == notLockable || lockability == nil)
                    illogical(notLockableMsg);

                if(lockability == indirectLockable)
                    implausible(indirectLockableMsg);

                if(isLocked)
                    illogicalNow(alreadyLockedMsg);

            }

            check()
            {
                /*
                 *   if we need a key to be locked with, check whether the player
                 *   is holding a suitable one.
                 */
                if(lockability == lockableWithKey)
                    findPlausibleKey();

            }

            action()
            {
                /*
                 *   The useKey_ property will have been set by the
                 *   findPlausibleKey() method at the check stage. If it's non-nil
                 *   it's the key we're going to use to try to lock this object
                 *   with, so we display a parenthetical note to the player that
                 *   we're using this key. (Note: the action would have failed at
                 *   the check stage if useKey_ wasn't the right key for the job).
                 */
                if(useKey_ != nil)
                    extraReport(withKeyMsg);

                /*
                 *   Otherwise, if we need a key to unlock this object with, ask the
                 *   player to specify it and then execute a LockWith action
                 *   using that key.
                 */
                else if(lockability == lockableWithKey)
                    askForIobj(LockWith);

                /*  Make us locked. */
                makeLocked(true);
            }

            report()
            {
                DMsg(report lock, okayLockMsg, gActionListStr);
            }
        }

        okayLockMsg = 'Locked.|{I} {lock} {1}. '

        withKeyMsg = BMsg(with key, '(with {1})\n', useKey_.theName)

        /*
         *   Find a key among the actor's possessions that might plausibly lock or
         *   unlock us. If the silent parameter is true, then don't report a failed
         *   attempt.
         */
        findPlausibleKey(silent = nil)
        {

            useKey_ = nil;
            local lockObj = self;

            /*
             *   First see if the actor is holding a key that is known to work on
             *   this object. If so, use it.
             */
            foreach(local obj in gActor.contents)
            {
                if(obj.ofKind(Key)
                   && obj.knownLockList.indexOf(self) !=  nil)
                {
                    useKey_ = obj;
                    return;
                }
            }

            /*
             *   Then see if the actor is holding a key that might plausibly work on
             *   this object; if so, try that.
             */
            foreach(local obj in gActor.contents)
            {
                if(obj.ofKind(Key)
                   && obj.plausibleLockList.indexOf(self) !=  nil)
                {
                    useKey_ = obj;
                    break;
                }
            }

            /*
             *   If we haven't found a suitable key yet, check to see if the actor
             *   is holding one that might fit our lexicalParent, if we have a
             *   lexicalParent whose interior we're representing.
             */
            if(useKey_ == nil)
            {
                if(lexicalParent != nil && lexicalParent.remapIn == self)
                {
                    lexicalParent.findPlausibleKey();
                    useKey_ = lexicalParent.useKey_;
                    lockObj = lexicalParent;
                }
            }

            /*
             *   If we've found a possible key but it doesn't actually work on this
             *   object, report that we're trying this key but it doesn't work.
             */
            if(useKey_ && useKey_.actualLockList.indexOf(lockObj) == nil && !silent)
            {
                say(withKeyMsg);
                say(keyDoesntWorkMsg);
            }

        }

        keyDoesntWorkMsg = BMsg(key doesnt work, 'Unfortunately {1} {dummy}
            {doesn\'t work[ed]} on {the dobj}. ', useKey_.theName)

        useKey_ = nil

        dobjFor(SwitchOn)
        {

            preCond = [touchObj]

            verify()
            {
                if(!isSwitchable)
                    illogical(notSwitchableMsg);
                else if(isOn)
                    illogicalNow(alreadyOnMsg);
            }

            action()
            {
                makeOn(true);
            }

            report()
            {
                DMsg(report turn on, 'Done.|{I} turn{s/ed} on {the dobj}. ');
            }
        }

        notSwitchableMsg = BMsg(not switchable, '{The subj dobj} {can\'t} be
            switched on and off. ')
        alreadyOnMsg = BMsg(already switched on, '{The subj dobj} {is} already
            switched on. ')

        dobjFor(SwitchOff)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isSwitchable)
                    illogical(notSwitchableMsg);
                else if(!isOn)
                    illogicalNow(alreadyOffMsg);
            }

            action()
            {
                makeOn(nil);
            }

            report()
            {
                DMsg(report turn off, 'Done.|{I} turn{s/ed} off {the dobj}. ');
            }
        }

       alreadyOffMsg = BMsg(not switched on, '{The subj dobj} {isn\'t} switched on.
           ')

        dobjFor(SwitchVague)
        {
            verify()
            {
                if(!isSwitchable)
                    illogical(notSwitchableMsg);
            }

            action()
            {
                makeOn(!isOn);
            }

            report()
            {
                DMsg(report switch, 'Okay, {i} turn{s/ed} {1} {2}. ', isOn ?
                     'on' : 'off', gActionListStr);
            }
        }

        /*
         *   Since FLIP X is often synonymous with SWITCH X , by default we make
         *   something flippable if it's switchable.
         */
        isFlippable = (isSwitchable)

        dobjFor(Flip)
        {
            verify()
            {
                if(!isFlippable)
                   illogical(cannotFlipMsg);
            }
        }

        cannotFlipMsg = BMsg(cannot flip, '{I} {can\'t} usefully flip {the dobj}. ')

        /* By default we assume most things aren't burnable */
        isBurnable = nil

        dobjFor(Burn)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isBurnable)
                   illogical(cannotBurnMsg);
            }
        }

        dobjFor(BurnWith)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isBurnable)
                   illogical(cannotBurnMsg);
            }
        }

        /*
         *   By default we assume most things can't be used to burn other things
         *   with.
         */
        canBurnWithMe = nil

        iobjFor(BurnWith)
        {
            preCond = [objHeld]
            verify()
            {
                if(!canBurnWithMe)
                    illogical(cannotBurnWithMsg);
            }
        }

        cannotBurnMsg = BMsg(cannot burn, '{I} {cannot} burn {the dobj}. ')
        cannotBurnWithMsg = BMsg(cannot burn with, '{I} {can\'t} burn {the dobj}
            with {that iobj}. ')

        dobjFor(Wear)
        {
            preCond = [objHeld]

            verify()
            {
                if(!isWearable)
                    illogical(cannotWearMsg);

                if(wornBy == gActor)
                    illogicalNow(alreadyWornMsg);
            }

            action()  {  makeWorn(gActor);  }

            report()
            {
                DMsg(okay wear, 'Okay, {i}{\'m} now wearing {1}. ',
                     gActionListStr);
            }
        }

        cannotWearMsg = BMsg(cannot wear, '{The subj dobj} {can\'t} be worn. ')
        alreadyWornMsg = BMsg(already worn, '{I}{\'m} already wearing {the dobj}. ')

        /* By default we assume that something's doffable if it's wearable */
        isDoffable = (isWearable)

        dobjFor(Doff)
        {

            verify()
            {
                if(wornBy != gActor)
                    illogicalNow(notWornMsg);

                if(!isDoffable)
                    illogical(cannotDoffMsg);
            }

            check()
            {
                checkRoomToHold();
            }

            action()  {   makeWorn(nil);  }

            report()
            {
                DMsg(okay doff, 'Okay, {I}{\'m} no longer wearing {1}. ',
                     gActionListStr);

            }
        }

        cannotDoffMsg = (cannotWearMsg)

        notWornMsg = BMsg(not worn, '{I}{\'m} not wearing {the dobj}. ')

        /* Most things can't be climbed */
        isClimbable = nil

        dobjFor(Climb)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isClimbable)
                   illogical(cannotClimbMsg);
            }
        }

        canClimbUpMe = (isClimbable)

        dobjFor(ClimbUp)
        {
            preCond = [touchObj]
            verify()
            {
                if(!canClimbUpMe)
                   illogical(cannotClimbMsg);
            }
        }

        cannotClimbMsg = BMsg(cannot climb,'{The subj dobj} {is} not something {i}
            {can} climb. ')

        canClimbDownMe = (isClimbable)

        dobjFor(ClimbDown)
        {
            preCond = [touchObj]
            verify()
            {
                if(!canClimbDownMe)
                   illogical(cannotClimbDownMsg);
            }
        }

        cannotClimbDownMsg = BMsg(cannot climb down, '{The subj dobj} {is} not
            something {i} {can} climb down. ')

        dobjFor(Throw)
        {
            preCond = [objHeld]

            verify()
            {
                if(!isThrowable)
                    illogical(cannotThrowMsg);
            }

            action()
            {
                actionMoveInto(getOutermostRoom.dropLocation);
            }

            report()
            {
                local obj = gActionListObj;
                gMessageParams(obj);
                DMsg(throw, '{The subj obj} sail{s/ed} through the air and land{s/ed}
                    on the ground. ' );
            }

        }

        dobjFor(Board)
        {
            preCond = [touchObj, actorInStagingLocation]

            remap = remapOn

            verify()
            {
                if(!isBoardable || contType != On)
                    illogical(cannotBoardMsg);

                if(gActor.isIn(self))
                    illogicalNow(actorAlreadyOnMsg);

                if(isIn(gActor))
                    illogicalNow(cannotGetOnCarriedMsg);
            }

            check() { checkInsert(gActor); }

            action()
            {
                gActor.actionMoveInto(self);
            }

            report()
            {
                DMsg(okay get on, '{I} {get} on {1}. ', gActionListStr);
            }
        }

        cannotBoardMsg = BMsg(cannot board, '{The subj dobj} {is} not something {i}
            {can} get on. ')
        actorAlreadyOnMsg = BMsg(already on, '{I}{\'m} already {in dobj}. ')

        cannotGetOnCarriedMsg = BMsg(cannot board carried, '{I} {can\'t} get on {the
            dobj} while {i}{\'m} carrying {him dobj}. ')

        /*
         *   Since we don't track postures in this library we'll treat STAND ON as
         *   equivalent to BOARD
         */
        dobjFor(StandOn) asDobjWithoutVerifyFor(Board)
        dobjFor(SitOn) asDobjWithoutVerifyFor(Board)
        dobjFor(LieOn) asDobjWithoutVerifyFor(Board)

        /*
         *   Although we don't track postures as such, some objects may be better
         *   choices than other for sitting on (e.g. chairs), lying on (e.g. beds)
         *   and standing on (e.g. rugs), so we allow these to be tested for
         *   individually at the verify stage.
         *
         *   Note that none of these three properties (canSitOnMe, canLieOnMe,
         *   canStandOnMe) should normally be overridden to simply true, since they
         *   cannot make it possible to sit, lie or stand on something for which
         *   isBoardable is not true (or which contType is not On).
         */
        canSitOnMe = isBoardable
        canLieOnMe = isBoardable
        canStandOnMe = isBoardable

        /*
         *   As well as ruling out certain objects for sitting, lying or standing
         *   on, we can also give them a score for each of these postures; e.g. a
         *   bed may be particularly suitable for lying on (although you could lie
         *   on the sofa) while a chair may be particularly suitable for sitting on
         *   (though you could sit on the bed.
         *
         *   By default we'll give each posture a score of 100, the normal logical
         *   verify score. Note that these scores have no effect if the
         *   corresponding can xxxOnMe property is nil.
         */
        sitOnScore = 100
        lieOnScore = 100
        standOnScore = 100

        dobjFor(StandOn)
        {
            verify()
            {
                if(!canStandOnMe)
                    illogical(cannotStandOnMsg);
                else
                    verifyDobjBoard();

                logicalRank(standOnScore);
            }
        }

        dobjFor(SitOn)
        {
            verify()
            {
                if(!canSitOnMe)
                    illogical(cannotSitOnMsg);
                else
                    verifyDobjBoard();

                logicalRank(sitOnScore);
            }
        }

        dobjFor(LieOn)
        {
            verify()
            {
                if(!canLieOnMe)
                    illogical(cannotLieOnMsg);
                else
                    verifyDobjBoard();

                logicalRank(lieOnScore);
            }
        }

        cannotStandOnMsg = BMsg(cannot stand on, '{The subj dobj} {isn\'t}
            something {i} {can} stand on. ')
        cannotSitOnMsg = BMsg(cannot sit on, '{The subj dobj} {isn\'t}
            something {i} {can} sit on. ')
        cannotLieOnMsg = BMsg(cannot lie on, '{The subj dobj} {isn\'t}
            something {i} {can} lie on. ')

        /*
         *   Flag, can we enter (i.e. get inside) this thing? For most objects, we
         *   can't
         */
        isEnterable = nil

        /*   Treat Enter X as equivalent to Get In X */

        dobjFor(Enter)
        {
            preCond = [touchObj, containerOpen, actorInStagingLocation]

            remap = remapIn

            verify()
            {
                if(!isEnterable || contType != In)
                    illogical(cannotEnterMsg);

                if(gActor.isIn(self))
                    illogicalNow(actorAlreadyInMsg);

                if(isIn(gActor))
                    illogicalNow(cannotGetInCarriedMsg);
            }

            check() { checkInsert(gActor); }

            action()
            {
                gActor.actionMoveInto(self);
            }

            report()
            {
                DMsg(okay get in, '{I} {get} in {1}. ', gActionListStr);
            }

        }

        cannotEnterMsg = BMsg(cannot enter, '{The subj dobj} {is} not something {i}
            {can} enter. ')
        actorAlreadyInMsg = BMsg(actor already in, '{I}{\'m} already {in dobj}. ')

        cannotGetInCarriedMsg = BMsg(cannot enter carried, '{I} {can\'t} get in {the
            dobj} while {i}{\'m} carrying {him dobj}. ')

        /*
         *   By default we'll treat standing, sitting or lying IN something as
         *   simply equivalent to entering it.
         */
        dobjFor(StandIn) asDobjFor(Enter)
        dobjFor(SitIn) asDobjFor(Enter)
        dobjFor(LieIn) asDobjFor(Enter)

        /*
         *   Our exitLocation is the location an actor should be moved to when s/he
         *   gets off/out of us.
         */
        exitLocation = (lexicalParent == nil ? location : lexicalParent.location)

        /*   Our staging location is where we need to be to get on/in us */
        stagingLocation = (exitLocation)

        dobjFor(GetOff)
        {

            remap = remapOn

            verify()
            {
                if(!gActor.isIn(self) || contType != On)
                    illogicalNow(actorNotOnMsg);

            }

            action()
            {
                gActor.actionMoveInto(exitLocation);
            }

            report() { say(okayGetOutOfMsg); }
        }

        dobjFor(GetOutOf)
        {
            preCond = [containerOpen]

            remap = remapIn

            verify()
            {
                if(!gActor.isIn(self) || contType != In)
                    illogicalNow(actorNotInMsg);

            }

            action()
            {
                gActor.actionMoveInto(exitLocation);
            }

            report() { say(okayGetOutOfMsg); }
        }

        okayGetOutOfMsg = BMsg(okay get outof, 'Okay, {i} {get} {outof dobj}. ')

        actorNotInMsg = BMsg(actor not in,'{I}{\'m} not in {the dobj}. ')
        actorNotOnMsg = BMsg(actor not on,'{I}{\'m} not on {the dobj}. ')

        /*
         *   We'll take REMOVE to mean DOFF when it's dobj is worn and TAKE
         *   otherwise. This handling will be dealt with by removeDoer insteadof
         *   remap, since this form of remap has now been discontinued. See
         *   english.t for removeDoer (which seems to be a language-specific
         *   construct)
         */
        dobjFor(Remove)
        {
            /*
             *   We still need a verify() routine to help the parser find a suitable
             *   target for the command.
             */

            verify()
            {
                if(!isRemoveable)
                    illogical(cannotRemoveMsg);

                /*
                 *   If we're already holding the object (and not wearing it),
                 *   there's nothing for remove to do.
                 */
                if(isDirectlyIn(gActor) && wornBy != gActor)
                    illogicalNow(alreadyHeldMsg);
            }

        }

        /* By default an object is removeable if it's takeable */

        isRemoveable = (isTakeable)

        /*
         *   Note that this message should never display in an English-language game
         *   since removeDoer will intercept the action before it gets to this
         *   point.
         */
        cannotRemoveMsg = BMsg(cannot remove, '{The subj dobj} {cannot} be removed.
            ')

        /* Treat SEARCH as equivalent to LOOK IN */
        dobjFor(Search) asDobjFor(LookIn)

        /*
         *   By default we assume anything fixed isn't moveable. That's not
         *   necessarily the case since we may be able to move something by pushing
         *   it around (say) even if we can't pick it up.
         */
        isMoveable = (!isFixed)

        /*
         *   Moving an object is generally possible if the object is portable, but
         *   there's no obvious effect, so by default this action does nothing
         *   except say it's done nothing.
         */
        dobjFor(Move)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isMoveable)
                    illogical(cannotMoveMsg);
            }

            action()  {  }

            report()
            {
                say(moveNoEffectMsg);
            }
        }

        cannotMoveMsg = (cannotTakeMsg)

        dobjFor(MoveWith)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isMoveable)
                    illogical(cannotMoveMsg);

            }

            action() {  }

            report()
            {
                say(moveNoEffectMsg);
            }
        }

        moveNoEffectMsg = BMsg(move no effect, 'Moving {1} {dummy} {has} no effect. ',
                     gActionListStr)

        /*
         *   Most things can't be used to move other things with. Note that since
         *   the dobj is resolved first, objects or subclasses could override this
         *   with a method that returns true or nil depending on the identity of the
         *   dobj.
         */
        canMoveWithMe = nil

        iobjFor(MoveWith)
        {
            preCond = [objHeld]

            verify()
            {
                if(!canMoveWithMe)
                   illogical(cannotMoveWithMsg);

                if(gDobj == self)
                    illogicalSelf(cannotMoveWithSelfMsg);
            }
        }

        cannotMoveWithMsg = BMsg(cannot move with, '{I} {can\'t} move {the dobj}
            with {the iobj}. ')

        cannotMoveWithSelfMsg = BMsg(cannot move with self, '{The subj dobj}
            {can\'t} be used to move {itself dobj}. ')

        /*
         *   MoveTo is a more complex case than MOVE or MOVE WITH. In this
         *   implementation we assume that it represents moving the direct object to
         *   the vicinity of the indirect object, and so we track the object it's
         *   been moved to.
         *
         *   This might be useful, say, if you wanted the player to have to MOVE the
         *   chair TO the bookcase before being able to reach the top shelf by
         *   standing on the chair, since you could then check the value of the
         *   chair's movedTo property before deciding whether the top shelf was
         *   accesssible.
         */
        dobjFor(MoveTo)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isMoveable)
                    illogical(cannotMoveMsg);
            }

            action()
            {
                makeMovedTo(gIobj);
            }

            report()
            {
                DMsg(okay move to, '{I} move{s/d} {1} {dummy} to {the iobj}. ',
                     gActionListStr);
            }
        }

        /*
         *   The notional location (other object) this object has been moved to as
         *   the result of a MoveTo command.
         */
        movedTo = nil

        /* Cause this object to be moved to loc */
        makeMovedTo(loc) { movedTo = loc; }

        /* In general there's no reason why most objects can't be moved to. */
        canMoveToMe = true

        iobjFor(MoveTo)
        {
            preCond = [touchObj]

            verify()
            {
                if(!canMoveToMe)
                    illogical(cannotMoveToMsg);

                if(gDobj == self)
                    illogicalSelf(cannotMoveToSelfMsg);

                if(gDobj.movedTo == self)
                    illogicalNow(alreadyMovedToMsg);

            }

        }

        cannotMoveToMsg = BMsg(cannot move to, '{The subj dobj} {can\'t} be moved to
            {the iobj}. ')

        cannotMoveToSelfMsg = BMsg(cannot move to self, '{The subj dobj} {can\'t}
            be moved to {itself dobj}. ')

        alreadyMovedToMsg = BMsg(already moved to, '{The subj dobj} {has} already
            been moved to {the iobj}. ')

        /*
         *   Lighting an object makes it a light source by making its isLit property
         *   true.
         */
        dobjFor(Light)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isLightable)
                    illogical(cannotLightMsg);
                else if(isLit)
                    illogicalNow(alreadyLitMsg);
            }

            action()
            {
                makeLit(true);
            }

            report()
            {
                DMsg(okay lit,'Done.|{I} {light} {1}. ', gActionListStr);
            }
        }

        cannotLightMsg = BMsg(cannot light, '{The subj dobj} {is} not something
            {i} {can} light. ')

        alreadyLitMsg = BMsg(already lit, '{The subj dobj} {is} already lit. ')

        /*
         *   Most things are extinguishable if they're lit, but some things (like
         *   the sun or a nuclear explosion) might conceivably not be. Note that
         *   this property should only be set to nil for things that couldn't be
         *   extinguished even if they were lit (the flames of Hell, for example,
         *   which might be considered undousable for all eternity, if you're bent
         *   on writing an infernal game).
         */
        isExtinguishable = true

        dobjFor(Extinguish)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isLit)
                    illogicalNow(notLitMsg);

                if(!isExtinguishable)
                    illogical(cannotExtinguishMsg);

            }

            action()
            {
                makeLit(nil);
            }

            report()
            {
                DMsg(extinguish, '{I} {put} out {1}. ', gActionListStr);
            }
        }

        notLitMsg = BMsg(not lit, '{The subj dobj} {isn\'t} lit. ')

        cannotExtinguishMsg = BMsg(cannot extinguish, '{The dobj} {cannot} be
            extinguished. ')

        dobjFor(Eat)
        {
            preCond = [objHeld]

            verify()
            {
                if(!isEdible)
                    illogical(cannotEatMsg);
            }

            action()
            {
                moveInto(nil);
            }

            report()
            {
                DMsg(eat, '{I} {eat} {1}. ', gActionListStr);
            }
        }

        cannotEatMsg = BMsg(cannot eat, '{The subj dobj} {is} plainly inedible. ')

        /* Most things aren't drinkable */
        isDrinkable = nil

        dobjFor(Drink)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isDrinkable)
                   illogical(cannotDrinkMsg);

            }

        }

        cannotDrinkMsg = BMsg(not potable, '{I} {can\'t} drink {1}. ', fluidName)

        /*
         *   Most things probably could be cleaned, even if they're not worth
         *   cleaning in practice. Some things like a mountain or the moon probably
         *   can't be cleaned and could reasonably define isCleanable = nil.
         */
        isCleanable = true

        /* Assume most things start out not as clean as they could be */
        isClean = nil

        /* But that most things don't actually need cleaning in the game */
        needsCleaning = nil

        /*
         *   If this is non-nil then this is an object or a list of objects that
         *   must be/can be used to clean this object.
         */
        mustBeCleanedWith = nil

        /*
         *   The handling of the Clean action is possibly more elaborate than it
         *   needs to be by default, and game code may wish to override it with a
         *   different implementation, but the aim is to provide a framework that
         *   covers some common cases.
         *
         *   An object starts out with isClean = nil. Cleaning the object makes
         *   isClean true (at which point it doesn't need cleaning again).
         *
         *   If an object needs another object to be cleaned with (e.g. if in order
         *   to clean the window you need a wet sponge to clean it with), this can
         *   be defined by setting mustBeCleanedWith to an object or a list of
         *   objects that can be used to clean this direct object.
         */
        dobjFor(Clean)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isCleanable)
                    illogical(cannotCleanMsg);

                else if(isClean)
                    illogicalNow(alreadyCleanMsg);

                else if(!needsCleaning)
                    implausible(noNeedToCleanMsg);

            }

            action()
            {
                if(mustBeCleanedWith != nil)
                    askForIobj(CleanWith);

                makeCleaned(true);
            }

            report()
            {
                say(okayCleanMsg);
            }
        }

        /*
         *   Carry out the effects of cleaning. By default we just set the value of
         *   the isClean property, but game code could override this to carry out
         *   any side effects of cleaning, such as revealing the inscription on a
         *   dirty old gravestone.
         */
        makeCleaned(stat) { isClean = stat; }

        cannotCleanMsg = BMsg(cannot clean, '{The subj dobj} {is} not something {i}
            {can} clean. ')

        alreadyCleanMsg = BMsg(already clean, '{The subj dobj} {is} already quite
            clean enough. ')

        noNeedToCleanMsg = BMsg(no clean, '{The subj dobj} {doesn\'t need[ed]}
            cleaning. ')

        dontNeedCleaningObjMsg = BMsg(dont need cleaning obj, '{I} {don\'t need[ed]}
            anything to clean {the dobj} with. ')

        okayCleanMsg = DMsg(okay clean, 'Cleaned|{I} clean{s/ed} {1}. ',
                            gActionListStr)

        dobjFor(CleanWith)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isCleanable)
                    illogical(cannotCleanMsg);

                else if(isClean)
                    illogicalNow(alreadyCleanMsg);

                else if(!needsCleaning)
                    implausible(noNeedToCleanMsg);

                else if(mustBeCleanedWith == nil)
                    implausible(dontNeedCleaningObjMsg);

                else if(valToList(mustBeCleanedWith).indexOf(gIobj) == nil)
                    implausible(cannotCleanWithMsg);
            }

            action() { makeCleaned(true); }

            report()
            {
                say(okayCleanMsg);
            }
        }

        /*
         *   We assume most objects aren't suitable for cleaning other objects with.
         *   Since the dobj is resolved first canCleanWithMe could be a method that
         *   checks whether the proposed iobj is suitable for cleaning gDobj; but a
         *   better way of doing it might be to list suitable objects in the
         *   mustBeCleanedWith property.
         */
        canCleanWithMe = nil

        iobjFor(CleanWith)
        {
            preCond = [objHeld]
            verify()
            {
                if(!canCleanWithMe)
                   illogical(cannotCleanWithMsg);
            }
        }

        cannotCleanWithMsg = BMsg(cannot clean with, '{I} {can\'t} clean {the dobj}
            with {the iobj}. ')

        /* Most things are not suitable for digging in*/
        isDiggable = nil

        dobjFor(Dig)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isDiggable)
                   illogical(cannotDigMsg);
            }

            /*
             *   If digging is allowed, then most likely we need an implement like a
             *   spade to dig with, so our default action is to ask for one. This
             *   can be overridden on objects in which the actors can effectively
             *   dig with their bare hands.
             */
            action() { askForIobj(DigWith); }
        }

        /* Most objects aren't suitable digging instruments */
        canDigWithMe = nil

        /*
         *   For DigWith we merely provide verify handlers that rule out the action
         *   wih the default values of isDiggable and canDigWithMe. The library
         *   cannot model the effect of digging in general, so it's up to game code
         *   to implement this on particular objects as required.
         */
        dobjFor(DigWith)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isDiggable)
                   illogical(cannotDigMsg);
            }
        }

        iobjFor(DigWith)
        {
            preCond = [objHeld]
            verify()
            {
                if(!canDigWithMe)
                   illogical(cannotDigWithMsg);

                if(gDobj == self)
                    illogicalSelf(cannotDigWithSelfMsg);
            }
        }

        cannotDigMsg = BMsg(cannot dig, '{I} {can\'t} dig there. ')
        cannotDigWithMsg = BMsg(cannot dig with, '{I} {can\'t} dig anything with
            {that iobj}. ')
        cannotDigWithSelfMsg = BMsg(cannot dig with self, '{I} {can\'t} dig {the
            dobj} with {itself dobj}. ')

        /*
         *   We treat TAKE FROM as equivalent to TAKE except at the verify stage,
         *   where we first check that the direct object is actually in the indirect
         *   object.
         */
        dobjFor(TakeFrom) asDobjWithoutVerifyFor(Take)

        dobjFor(TakeFrom)
        {
            verify()
            {
                if(!isTakeable)
                    illogical(cannotTakeMsg);

                if(gIobj.notionalContents.indexOf(self) == nil)
                    illogicalNow(notInMsg);
                if(self == gIobj)
                    illogicalSelf(cannotTakeFromSelfMsg);
            }
        }

        iobjFor(TakeFrom)
        {
            preCond = [touchObj]

            verify()
            {
                /*We're a poor choice of indirect object if there's nothing in us */
                if(notionalContents.countWhich({x: !x.isFixed}) == 0)
                    logicalRank(70);

                /*
                 *   We're also a poor choice if none of the tentative direct
                 *   objects is in our list of notional contents
                 */
                if(gTentativeDobj.overlapsWith(notionalContents) == nil)
                    logicalRank(80);

            }
        }

        notInMsg = BMsg(not inside, '{The dobj} {is}n\'t {in iobj}. ')
        cannotTakeFromSelfMsg =  BMsg(cannot take from self, '{I} {can\'t} take
            {the subj dobj} from {the dobj}. ')

        /*
         *   Flag, can we supply more items from us that are currently in scope? By
         *   default we can't; but a DispensingCollective may be able to.
         */
        canSupply = nil

        dobjFor(ThrowAt)
        {
            preCond = [objHeld]

            verify() { verifyDobjThrow(); }

            action()
            {
                /*
                 *   Normally the action handling for the ThrowAt action is dealt
                 *   with on the indirect object - iobjFor(ThrowAt) - but if for
                 *   particular objects you want to handle it on the direct object
                 *   and you don't want the iobj handling as well, then you need to
                 *   end your dobj action method with exitAction to suppress the
                 *   iobj action method.
                 */
            }
        }

        /*
         *   Most objects can the target of a throw, but it's conceivable that some
         *   might be obviously unsuitable
         */
        canThrowAtMe = true

        iobjFor(ThrowAt)
        {
            preCond = [objVisible]

            verify()
            {
                if(!canThrowAtMe)
                    illogical(cannotThrowAtMsg);

                if(gDobj == self)
                    illogical(cannotThrowAtSelfMsg);
            }

            action()
            {
                gDobj.actionMoveInto(getOutermostRoom.dropLocation);
            }

            report()
            {
                local obj = gActionListObj;
                gMessageParams(obj);
                DMsg(throw at, '{The subj obj} {strikes} {the iobj} and land{s/ed}
                    on the ground. ');
            }

        }

        /*
         *   Particular instances will nearly always need to override with a less
         *   generic and more plausible refusal message.
         */
        cannotThrowAtMsg = BMsg(cannot throw at, '{I} {can\'t} throw anything at
            {the iobj}. ')

        cannotThrowAtSelfMsg = BMsg(cannot throw at self, '{The subj dobj} {can\'t}
            be thrown at {itself dobj}. ')

        dobjFor(ThrowTo)
        {
            preCond = [objHeld]

            verify() { verifyDobjThrow(); }
        }

        /*
         *   Most objects cannot have things thrown to then, since this would imply
         *   that they might be able to catch them, which only animate objects can
         *   do.
         */
        canThrowToMe = nil

        iobjFor(ThrowTo)
        {
            preCond = [objVisible]

            verify()
            {
                if(!canThrowToMe)
                    illogical(cannotThrowToMsg);

                if(gDobj == self)
                    illogical(cannotThrowToSelfMsg);
            }

        }

        cannotThrowToMsg = BMsg(cannot throw to, '{The subj dobj} {can\'t} catch
            anything. ')

        cannotThrowToSelfMsg = BMsg(cannot throw to self, '{The subj dobj} {can\'t}
            be thrown to {itself dobj}. ')

        throwFallsShortMsg = BMsg(throw falls short, '{The subj dobj} land{s/ed} far
            short of {the iobj}. ')

        canTurnMeTo = nil

        /*
         *   Turning something To is setting it to a value by rotating it, such as
         *   turning a dial to point to a particular number.
         */
        dobjFor(TurnTo)
        {
            preCond = [touchObj]

            verify()
            {
                if(!canTurnMeTo)
                   illogical(cannotTurnToMsg);
            }

            check()
            {
                checkSetting(gLiteral);
            }

            action()
            {
                makeSetting(gLiteral);
            }

            report()
            {
                DMsg(okay turn to, 'Okay, {I} turn{s/ed} {1} to {2}', gActionListStr,
                     gLiteral);
            }
        }

        /*
         *   If the setting is valid, do nothing. If it's invalid display a message
         *   explaining why. We do nothing here but this is overridden on the
         *   Settable class, which may be easier to use than providing your own
         *   implementation on Thing.
         */
        checkSetting(val) { }

        /* The value we're currently set to. */
        curSetting = ''

        cannotTurnToMsg = BMsg(cannot turn to, '{I} {cannot} turn {that dobj} to
            anything. ')

        canSetMeTo = nil

        dobjFor(SetTo)
        {
            preCond = [touchObj]

            verify()
            {
                if(!canSetMeTo)
                   illogical(cannotSetToMsg);
            }

            check()
            {
                /* This would be a good place to put code to validate the setting */
                checkSetting(gLiteral);
            }

            action()
            {
                makeSetting(gLiteral);
            }

            report()
            {
                DMsg(okay set to, '{I} {set} {1} to {2}. ', gActionListStr,
                     curSetting);
            }
        }

        makeSetting(val) { curSetting = val; }

        cannotSetToMsg = BMsg(cannot set to, '{I} {cannot} set {that dobj} to
            anything. ')

        /*
         *   The GoTo action allows the player character to navigate the map through
         *   the use of commands such as GO TO LOUNGE.
         */
        dobjFor(GoTo)
        {
            verify()
            {
                /*
                 *   If the actor is already in the direct object, there's no need
                 *   to move any further.
                 */
                if(gActor.isIn(self))
                    illogicalNow(alreadyThereMsg);

                /*
                 *   If the direct object is in the actor's location, there's no
                 *   need for the actor to move to get to it.
                 */
                if(isIn(gActor.getOutermostRoom))
                    illogicalNow(alreadyPresentMsg);

                /*
                 *   It's legal to GO TO a decoration object, but given the choice,
                 *   it's probably best to let the parser choose a non-decoration in
                 *   cases of ambiguity, so we'll decorations a slightly lower
                 *   logical rank.
                 */
                if(isDecoration)
                    logicalRank(90);
            }

            /*
             *   The purpose of the GO TO action is to take the player char along
             *   the shortest route to the destination. The action routine
             *   calculates the route and takes the first step.
             */
            action()
            {
                /* Get our destination. */
                local dest = lastSeenAt ? lastSeenAt.getOutermostRoom : nil;

                /*
                 *   Calculate the route from the actor's current room to the
                 *   location where the target object was last seen, using the
                 *   pcRouteFinder to carry out the calculations if it is present.
                 */
                local route = defined(pcRouteFinder) && lastSeenAt != nil
                    ? pcRouteFinder.findPath(
                    gActor.getOutermostRoom, dest) : nil;

                /*
                 *   If we don't find a route, just display a message saying we
                 *   don't know how to get to our destination.
                 */
                if(route == nil)
                    sayDontKnowHowToGetThere();

                /*
                 *   If the route we find has only one element in its list, that
                 *   means that we're where we last saw the target but it's no
                 *   longer there, so we don't know where it's gone. In which case
                 *   we display a message saying we don't know how to reach our
                 *   target.
                 */
                else if(route.length == 1)
                    sayDontKnowHowToReach();

                /*
                 *   If the route we found has at least two elements, then use the
                 *   first element of the second element as the direction in which
                 *   we need to travel, and use the Continue action to take a step
                 *   in that direction.
                 */
                else
                {
                    local idx = 2;
                    local dir = route[2][1];
                    local oldLoc = gPlayerChar.getOutermostRoom();

                    local commonRegions =
                        gPlayerChar.getOutermostRoom.regionsInCommonWith(dest);

                    local regionFastGoTo =
                        commonRegions.indexWhich({r: r.fastGoTo }) != nil;

                    local fastGo = regionFastGoTo || gameMain.fastGoTo;

                    Continue.takeStep(dir, getOutermostRoom, fastGo);

                    /*
                     *   If the fastGoTo option is active, continue moving towards
                     *   the destination until either we reach it our we're
                     *   prevented from going any further.
                     */
                    while((fastGo)
                          && oldLoc != gPlayerChar.getOutermostRoom
                          && idx < route.length)
                    {
                        local dir = route[++idx][1];
                        Continue.takeStep(dir, getOutermostRoom, true);
                    }
                }
            }
        }

        /*
         *   We make these two sayDontKnowHowTo... methods separate methods so that
         *   they can be reused on the Distant class without having to repeat the
         *   DMsg() definitions.
         */
        sayDontKnowHowToGetThere()
            { DMsg(route unknown, '{I} {don\'t know} how to get there. ');}

        sayDontKnowHowToReach()
            {  DMsg(destination unknown, '{I} {don\'t know} how to reach
                {him dobj}.' );}

        alreadyThereMsg = BMsg(already there, '{I}{\'m} already there. ')
        alreadyPresentMsg = BMsg(already present, '{The subj dobj} {is} right
            {here}. ')

        /*
         *   By default most things can't be attached to any things. The base
         *   handling of ATTACH and DETACH on Thing merely rules them out at the
         *   verify stage. The SimpleAttachable and NearbyAttachable classes define
         *   in the optional attachables.t module provide fuller handling.
         */
        isAttachable = nil

        dobjFor(Attach)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isAttachable)
                   illogical(cannotAttachMsg);
            }
            action() { askForIobj(AttachTo); }
        }

        dobjFor(AttachTo)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isAttachable)
                   illogical(cannotAttachMsg);
            }
        }

        canAttachToMe = nil

        iobjFor(AttachTo)
        {
            preCond = [touchObj]
            verify()
            {
                if(!canAttachToMe)
                   illogical(cannotAttachToMsg);

                if(gDobj == self)
                    illogicalSelf(cannotAttachToSelfMsg);
            }
        }

        cannotAttachMsg = BMsg(cannot attach, '{I} {cannot} attach {the dobj} to
            anything. ')
        cannotAttachToMsg = BMsg(cannot attach to, '{I} {cannot} attach anything to
            {the iobj}. ')

        cannotAttachToSelfMsg = BMsg(cannot attach to self, '{I} {cannot} attach
            {the iobj} to {itself iobj}. ')

        isDetachable = nil

        dobjFor(Detach)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isDetachable)
                   illogical(cannotDetachMsg);
            }
        }

        cannotDetachMsg = BMsg(cannot detach, 'There{dummy} {is}n\'t anything from
            which {the subj dobj} could be detached. ')

        dobjFor(DetachFrom)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isDetachable)
                   illogical(cannotDetachMsg);

                if(gIobj == self)
                    illogicalSelf(cannotDetachFromSelfMsg);
            }
        }

        canDetachFromMe = nil

        iobjFor(DetachFrom)
        {
            verify()
            {
                if(!canDetachFromMe)
                    illogical(cannotDetachFromMsg);
            }
        }

        cannotDetachFromMsg = BMsg(cannot detach from, 'There{dummy} {is}n\'t
            anything that could be detached from {the iobj}. ')

        cannotDetachFromSelfMsg = BMsg(cannot detach from self, '{The subj dobj}
            {can\'t} be detached from {itself dobj}. ')

        /*
         *   Fasten by itself presumably refers to objects like seat-belts. There
         *   are not many such fastenable objects so we may things not fastenable by
         *   default.
         */
        isFastenable = nil

        /*   Most things start out unfastened. */
        isFastened = nil

        /*
         *   Make something fastened or unfastened. By default we just change the
         *   value of its isFastened property, but game code could override this to
         *   provide further side-effects on particular objects.
         */
        makeFastened(stat) { isFastened = stat; }

        dobjFor(Fasten)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isFastenable)
                    illogical(cannotFastenMsg);

                if(isFastened)
                    illogicalNow(alreadyFastenedMsg);
            }

            action() { makeFastened(true); }

            report()
            {
                DMsg(okay fasten, 'Done|{I} fasten{s/ed} {1}. ', gActionListStr);
            }
        }

        cannotFastenMsg = BMsg(cannot fasten, '{That subj dobj}{\'s} not something
            {i} {can} fasten. ')

        alreadyFastenedMsg = BMsg(already fastened, '{The subj dobj} {is} already
            fastened. ')

        dobjFor(FastenTo)
        {
            preCond = [objHeld]
            verify()
            {
                if(!isFastenable)
                   illogical(cannotFastenMsg);
            }
        }

        canFastenToMe = nil

        iobjFor(FastenTo)
        {
            preCond = [touchObj]
            verify()
            {
                if(!canFastenToMe)
                    illogical(cannotFastenToMsg);

                if(gDobj == self)
                    illogicalSelf(cannotFastenToSelfMsg);
            }
        }

        cannotFastenToMsg = BMsg(cannot fasten to, '{I} {can\'t} fasten anything to
            {that iobj}. ')

        cannotFastenToSelfMsg = BMsg(cannot fasten to self, '{The subj iobj}
            {can\'t} be fastened to {itself iobj}. ')

        isUnfastenable = nil

        dobjFor(Unfasten)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isUnfastenable)
                   illogical(cannotUnfastenMsg);

                if(!isFastened)
                    illogicalNow(notFastenedMsg);
            }
        }

        dobjFor(UnfastenFrom)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isUnfastenable)
                   illogical(cannotUnfastenMsg);

                if(gIobj == self)
                    illogical(cannotUnfastenFromSelfMsg);
            }
        }

        canUnfastenFromMe = nil

        iobjFor(UnfastenFrom)
        {
            preCond = [touchObj]
            verify()
            {
                if(!canUnfastenFromMe)
                   illogical(cannotUnfastenFromMsg);
            }
        }

        cannotUnfastenMsg = BMsg(cannot unfasten, '{The subj dobj} {cannot} be
            unfastened. ')

        cannotUnfastenFromMsg = BMsg(cannot unfasten from, '{I} {can\'t} unfasten
            anything from {that iobj}. ')

        cannotUnfastenFromSelfMsg = BMsg(cannot unfasten from self, '{I} {can\'t}
            unfasten {the dobj} from {itself dobj}. ')

        notFastenedMsg = BMsg(not fastened, '{The subj dobj} {isn\'t} fastened. ')

        /*
         *   Most things can't be plugged into other things or have other things
         *   plugged into them.
         */
        isPlugable = nil
        canPlugIntoMe = nil

        /*
         *   The base handling of PlugInto on Thing merely rules it out at the
         *   verify stage. A fuller implementation is provided by the PlugAttachable
         *   class in the optional attachables module.
         */
        dobjFor(PlugInto)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isPlugable)
                    illogical(cannotPlugMsg);

                if(self == gIobj)
                    illogicalSelf(cannotPlugIntoSelfMsg);
            }

        }

        iobjFor(PlugInto)
        {
            preCond = [touchObj]
            verify()
            {
                if(!canPlugIntoMe)
                    illogical(cannotPlugIntoMsg);
            }
        }

        cannotPlugMsg = BMsg(cannot plug, '{The subj dobj} {can\'t} be plugged into
            anything. ')
        cannotPlugIntoSelfMsg = BMsg(cannot plug into self, '{I} {can\'t} plug
            {the dobj} into {itself dobj}. ')
        cannotPlugIntoMsg = BMsg(cannot plug into, '{I} {can\'t} plug anything into
            {the iobj}. ')

        isUnplugable = (isPlugable)
        canUnplugFromMe = (canPlugIntoMe)

        dobjFor(UnplugFrom)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isUnplugable)
                    illogical(cannotUnplugMsg);

                if(gIobj == self)
                    illogicalSelf(cannotUnplugFromSelfMsg);
            }
        }

        iobjFor(UnplugFrom)
        {
            preCond = []

            verify()
            {
                if(!canUnplugFromMe)
                    illogical(cannotUnplugFromMsg);

            }
        }

        cannotUnplugMsg = BMsg(cannot unplug, '{The subj dobj} {can\'t} be
            unplugged. ')

        cannotUnplugFromSelfMsg = BMsg(cannot unplug from self, '{I} {can\'t} unplug
            {the dobj} from {itself dobj}. ')

        cannotUnplugFromMsg = BMsg(cannot unplug from, '{I} {can\'t} unplug anything
            from {the iobj}. ')

        dobjFor(PlugIn)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isPlugable)
                    illogical(cannotPlugMsg);
            }
        }

        dobjFor(Unplug)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isUnplugable)
                    illogical(cannotUnplugMsg);
            }
        }

        /* We can try kissing most things, even if it isn't very rewarding */
        isKissable = true

        /*
         *   The logical rank assigned to kissing this object if kissing is allowed.
         *   Kissing an inanimate object is less likely than kissing an Actor.
         */
        kissRank = 80

        dobjFor(Kiss)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isKissable)
                    illogical(cannotKissMsg);

                /*
                 *   It's more logical to kiss actors, so we give the Kiss action a
                 *   lower logical rank on ordinary things.
                 */
                logicalRank(80);
            }

            check()
            {
                if(dataType(&checkKissMsg) != TypeNil)
                    display(&checkKissMsg);
            }

            action()
            {
                if(dataType(&futileToKissMsg) != TypeNil)
                    display(&futileToKissMsg);
            }

            report()
            {
                DMsg(report kiss, 'Kissing {1} {dummy}prove{s/d} remarkably
                    unrewarding. ',  gActionListStr);
            }
        }

        futileToKissMsg = nil

        cannotKissMsg = BMsg(cannot kiss, '{I} really {can\'t} kiss {that dobj}. ')

        /*
         *   If we want Kissing to fail at the check stage we can supply a message
         *   here explaining why. This is most simply given as a single-quoted
         *   string, but a double-quoted string or method will also work.
         */
        checkKissMsg = nil

        /*
         *   Flag, if this is a nested room, should an actor get out of it before
         *   executing an intransitive Jump command. By default it should.
         */
        getOutToJump = true

        /*
         *   It should be possible to jump off something if and only if the actor is
         *   on it in the first place.
         */
        canJumpOffMe = (gActor.location == self && contType == On)

        dobjFor(JumpOff)
        {
            preCond = [touchObj]

            verify()
            {
                if(!canJumpOffMe)
                    illogical(cannotJumpOffMsg);
            }

            action()
            {
                /*
                 *   Jumping off something has much the same effect as getting off
                 *   it, i.e. moving the actor to our exitLocation.
                 */
                gActor.actionMoveInto(exitLocation);
            }

            report()
            {
                DMsg(jump off, '{I} jump{s/ed} off {1} and land{s/ed} on the ground',
                     gActionListStr);
            }
        }

        cannotJumpOffMsg = BMsg(cannot jump off, '{I}{\'m} not on {the dobj}. ')

        /* It usually isn't possible (or at least useful) to jump over things. */
        canJumpOverMe = nil

        /*
         *   The base handling of JumpOver is simply to rule it out at the verify
         *   stage.
         */
        dobjFor(JumpOver)
        {
            preCond = [touchObj]

            verify()
            {
                if(!canJumpOverMe)
                   illogical(cannotJumpOverMsg);
            }
        }

        cannotJumpOverMsg = BMsg(pointless to jump over, 'It {dummy}{is}
            pointless to try to jump over {the dobj}. ')

        /* Most things aren't settable. */
        isSettable = nil

        /*
         *   The Set command by itself doesn't do much. By default we just rule it
         *   out at the verify stage.
         */
        dobjFor(Set)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isSettable)
                   illogical(cannotSetMsg);
            }
        }

        cannotSetMsg = BMsg(cannot set, '{The subj dobj} {is} not something {i}
            {can} set. ')

        /* Most things can't be typed on. */
        canTypeOnMe = nil

        /*
         *   The base handling of both the vague (TYPE ON X) and specific (TYPE FOO
         *   ON X) forms of TypeOn is simply to rule them out at the verify stage.
         *   Game code that needs objects that can be typed on is responsible for
         *   handling these actions in custom code.
         */
        dobjFor(TypeOnVague)
        {
            preCond = [touchObj]
            verify()
            {
                if(!canTypeOnMe)
                   illogical(cannotTypeOnMsg);
            }
        }

        dobjFor(TypeOn)
        {
            preCond = [touchObj]
            verify()
            {
                if(!canTypeOnMe)
                   illogical(cannotTypeOnMsg);
            }
        }

        cannotTypeOnMsg = BMsg(cannot type on, '{I} {can\'t} type anything on {the
            dobj}. ')

        /*
         *   Entering something on means ENTER FOO ON BAR where FOO is a string
         *   literal and BAR is an object such as a computer terminal. Most objects
         *   can't be entered on in this sense.
         */
        canEnterOnMe = nil

        /*
         *   The base handling is simply to rule out EnterOn at verify. There's no
         *   further handling the library can provide for a 'general' case so it's
         *   up to game code to define it for specific cases.
         */
        dobjFor(EnterOn)
        {
            preCond = [touchObj]
            verify()
            {
                if(!canEnterOnMe)
                   illogical(cannotEnterOnMsg);
            }
        }

        cannotEnterOnMsg = BMsg(cannot enter on, '{I} {can\'t} enter anything on
            {the dobj}. ')

        /*  Most things can't be written on. */
        canWriteOnMe = nil

        /*  By default we simply rule out writing on things at the verify stage. */
        dobjFor(WriteOn)
        {
            preCond = [touchObj]
            verify()
            {
                if(!canWriteOnMe)
                   illogical(cannotWriteOnMsg);
            }

        }

        cannotWriteOnMsg = BMsg(cannot write on, '{I} {can\'t} write anything on
            {the dobj}. ')

        /* Most things aren't consultable */
        isConsultable = nil

        /*
         *   The base handling on Thing merely rules out the Consult action at the
         *   verify stage. For a fuller implementation that allows consulting use
         *   the Consultable class.
         */
        dobjFor(ConsultAbout)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isConsultable)
                   illogical(cannotConsultMsg);
            }

        }

        cannotConsultMsg = BMsg(cannot consult, '{The subj dobj} {is} not a
            provider of information. ')

        /*
         *   Most things aren't pourable (they can't be poured into or onto other
         *   things.
         */
        isPourable = nil

        /*
         *   Sometimes we may have a container, such as an oilcan, from which we
         *   want to pour a liquid, such as oil, and we're using the same object to
         *   do duty for both. We can then use the fluidName property to say 'the
         *   oil' rather than 'the oilcan' in messages that refer specifically to
         *   pouring the liquid.
         */
        fluidName = theName

        /*
         *   The base handling of Pour, PourOnto and PourInto is simply to rule out
         *   all three actions at the verify stage. Game code that wants to allow
         *   these actions on specific objects will need to provide further handling
         *   for them.
         */
        dobjFor(Pour)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isPourable)
                   illogical(cannotPourMsg);
            }
        }

        dobjFor(PourOnto)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isPourable)
                   illogical(cannotPourMsg);
            }
        }

        /*
         *   Most things can probably have something poured onto them in principle,
         *   though we might want to prevent it in practice. The canPourOntoMe
         *   property controls whether it's possible to pour onto this thing.
         */

        canPourOntoMe = true

        /*
         *   The allowPourOntoMe property controls whether we want allow anything to
         *   be poured onto this thing (even if it's possible). By default we don't.
         */
        allowPourOntoMe = nil

        iobjFor(PourOnto)
        {
            preCond = [touchObj]

            remap = (remapOn)

            verify()
            {
                if(gDobj == self)
                    illogicalSelf(cannotPourOntoSelfMsg);

                if(!canPourOntoMe)
                    illogical(cannotPourOntoMsg);
                else if(!allowPourOntoMe)
                    implausible(shouldNotPourOntoMsg);

            }
        }

        dobjFor(PourInto)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isPourable)
                   illogical(cannotPourMsg);
            }
        }

        /*
         *   Presumably it's possible by default to pour something into me if I'm a
         *   container; but this could be overridden simply to true for objects like
         *   the sea or a river.
         */
        canPourIntoMe = (contType == In || remapIn != nil)

        /*
         *   While it's possible to pour stuff into any container, we probably don't
         *   want to allow it on most of them
         */
        allowPourIntoMe = nil

        iobjFor(PourInto)
        {
            preCond = [touchObj]

            remap = (remapIn)

            verify()
            {
                if(gDobj == self)
                    illogicalSelf(cannotPourIntoSelfMsg);

                if(!canPourIntoMe)
                    illogical(cannotPourIntoMsg);
                else if(!allowPourIntoMe)
                    implausible(shouldNotPourIntoMsg);
            }
        }

        cannotPourMsg = BMsg(cannot pour, '{I} {can\'t} pour {1} anywhere. ',
                             fluidName)
        cannotPourOntoSelfMsg = BMsg(cannot pour on self, '{I} {can\'t} pour {the
            dobj} onto {itself dobj}. ')
        cannotPourIntoSelfMsg = BMsg(cannot pour in self, '{I} {can\'t} pour {the
            dobj} into {itself dobj}. ')
        cannotPourIntoMsg = BMsg(cannot pour into, '{I} {can\'t} pour {1}
            into {that dobj}. ', gDobj.fluidName)
        cannotPourOntoMsg = BMsg(cannot pour onto, '{I} {can\'t} pour {1}
            into {that dobj}. ', gDobj.fluidName)
        shouldNotPourIntoMsg = BMsg(should not pour into, 'It{dummy}{\'s} better not
            to pour {1} into {the iobj}. ', gDobj.fluidName)

        shouldNotPourOntoMsg = BMsg(should not pour onto, 'It{dummy}{\'s} better not
            to pour {1} onto {the iobj}. ', gDobj.fluidName)

        /* Most things can't be screwed */
        isScrewable = nil

        /* Most things can't be used to screw other things with. */
        canScrewWithMe = nil

        /*
         *   In the base handling we simply rule out Screw and Unscrew actions at
         *   the verify stage. It's up to game code to provide specific handling for
         *   objects that can be screwed and unscrewed.
         */
        dobjFor(Screw)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isScrewable)
                   illogical(cannotScrewMsg);
            }
        }

        dobjFor(ScrewWith)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isScrewable)
                   illogical(cannotScrewMsg);
            }
        }

        iobjFor(ScrewWith)
        {
            preCond = [objHeld]
            verify()
            {
                if(!canScrewWithMe)
                    illogical(cannotScrewWithMsg);

                if(gDobj == self)
                    illogical(cannotScrewWithSelfMsg);
            }
        }

        isUnscrewable = (isScrewable)
        canUnscrewWithMe = (canScrewWithMe)

        dobjFor(Unscrew)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isUnscrewable)
                   illogical(cannotUnscrewMsg);
            }
        }

        dobjFor(UnscrewWith)
        {
            preCond = [touchObj]
            verify()
            {
                if(!isUnscrewable)
                   illogical(cannotUnscrewMsg);
            }
        }

        iobjFor(UnscrewWith)
        {
            preCond = [objHeld]
            verify()
            {
                if(!canUnscrewWithMe)
                    illogical(cannotUnscrewWithMsg);

                if(gDobj == self)
                    illogicalSelf(cannotUnscrewWithSelfMsg);
            }
        }

        cannotScrewMsg = BMsg(cannot screw, '{I} {can\'t} screw {the dobj}. ')
        cannotScrewWithMsg = BMsg(cannot screw with, '{I} {can\'t} screw anything
            with {that iobj}. ')
        cannotScrewWithSelfMsg = BMsg(cannot screw with self, '{I} {can\'t} screw
            {the iobj} with {itself iobj}. ')
        cannotUnscrewMsg = BMsg(cannot unscrew, '{I} {can\'t} unscrew {the dobj}. ')
        cannotUnscrewWithMsg = BMsg(cannot unscrew with, '{I} {can\'t} unscrew
            anything with {that iobj}. ')
        cannotUnscrewWithSelfMsg = BMsg(cannot unscrew with self, '{I} {can\'t}
            unscrew {the iobj} with {itself iobj}. ')

        /*
         *   Common handler for verifying push travel actions. The via parameter may
         *   be a preposition object (such as Through) defining what kind of push
         *   traveling the actor is trying to do (e.g. through a door or up some
         *   stairs).
         */
        verifyPushTravel(via)
        {
            viaMode = via;

            if(!canPushTravel && !canPullTravel)
                illogical(cannotPushTravelMsg);

            if(matchPushOnly && !canPushTravel)
                implausible(cannotPushTravelMsg);

            if(matchPullOnly && !canPullTravel)
                implausible(cannotPushTravelMsg);

            if(gActor.isIn(self))
                illogicalNow(cannotPushOwnContainerMsg);

            if(gIobj == self)
                illogicalSelf(cannotPushViaSelfMsg);

        }

        /*
         *   Check if the player specifically asked to PUSH this object somewhere.
         *   In the main library we assume not, but language-specific code will need
         *   to override to check what that player's command actually said.
         */
        matchPushOnly = nil

        /*
         *   Check if the player specifically asked to PULL this object somewhere.
         *   In the main library we assume not, but language-specific code will need
         *   to override to check what that player's command actually said.
         */
        matchPullOnly = nil

        viaMode = ''

        cannotPushOwnContainerMsg = BMsg(cannot push own container, '{I} {can\'t}
            {1} {the dobj} anywhere while {he actor}{\'s} {2} {him dobj}. ',
                                         gVerbWord, gDobj.objInPrep)

        cannotPushViaSelfMsg = BMsg(cannot push via self, '{I} {can\'t} {1} {the
            dobj} {2} {itself dobj}. ', gVerbWord, viaMode.prep)

        /*
         *   By default we can't push travel most things. Push Travel means pushing
         *   an object from one place to another and traveling with it.
         */
        canPushTravel = nil

        /*
         *   Normally we don't distinguish PushTravel from PullTravel, but if we
         *   want something to be pushable between rooms but not pullable, or vice
         *   versa, we can set these to different values.
         */
        canPullTravel = canPushTravel

        /*
         *   PushTravelDir handles pushing an object in a particular direction, e.g.
         *   PUSH BOX NORTH
         */
        dobjFor(PushTravelDir)
        {
            preCond = [touchObj]

            verify()  {  verifyPushTravel('');  }

            action()
            {
                /*
                 *   Most of the action is carried out by the PushTravel Action. All
                 *   we need to do here is to tell the action that we're allowing
                 *   push travel and reveal any items that come to light as a result
                 *   of moving this object.
                 */
                gAction.travelAllowed = true;

                /*
                 *   Reveal items previously under or behind us that now become
                 *   visible.
                 */
                pushTravelRevealItems();
            }
        }

        pushTravelRevealItems()
        {
            /*
             *   Check whether moving this object revealed any items hidden behind
             *   or beneath it (even if we don't succeed in pushing the object to
             *   another room we can presumably move it far enough across its
             *   current one to reveal any items it was concealing.
             */
            revealOnMove();

            /*
             *   If moving this item did reveal any hidden items, we want to see the
             *   report of them now, before moving to another location.
             */
            gCommand.afterReport();

            /*
             *   We don't want to see these reports again at the end of the action,
             *   so clear the list.
             */
            gCommand.afterReports = [];
        }

        /* Display a message explaining that push travel is not possible */
        cannotPushTravelMsg()
        {
            if(isFixed)
                return cannotTakeMsg;
            return BMsg(cannot push travel, 'There{dummy}{\'s} no point trying to
                {1} {that dobj} anywhere. ', gVerbWord);
        }

        /* Check the travel barriers on the indirect object of the action */
        checkPushTravel()
        {
            checkTravelBarriers(gDobj);
            checkTravelBarriers(gActor);
        }

        /*  Carry out the push travel on the direct object of the action. */
        doPushTravel(via)
        {
            /*
             *   Check whether moving this object revealed any items hidden behind
             *   or beneath it (even if we don't succeed in pushing the object to
             *   another room we can presumably move it far enough across its
             *   current one to reveal any items it was concealing.
             */
            pushTravelRevealItems();

            if(!gIobj.isLocked)
                describePushTravel(via);

            /*
             *   We temporarily make the push traveler item hidden before moving it
             *   to the new location so that it doesn't show up listed in its former
             *   location when actor moves to the new location and there's a sight
             *   path between the two.
             */
            local wasHidden;
            try
            {
                wasHidden = propType(&isHidden) is in (TypeCode, TypeFuncPtr) ?
                        getMethod(&isHidden) : isHidden;

                isHidden = true;

                gIobj.travelVia(gActor);
            }
            finally
            {
                if(dataTypeXlat(wasHidden) is in (TypeCode, TypeFuncPtr))
                    setMethod(&isHidden, wasHidden);
                else
                    isHidden = wasHidden;
            }

            /*
             *   Use the travelVia() method of the iobj to move the iobj to its new
             *   location.
             */

            if(gActor.isIn(gIobj.destination))
            {
                gIobj.travelVia(gDobj);
                gDobj.describeMovePushable(self, gActor.location);
            }
        }

        beforeMovePushable(connector, dir)
        {
            if(connector == nil || connector.ofKind(Room))
                DMsg(before push travel dir, '{I} push{es/ed} {the dobj} {1}. ',
                     dir.departureName);
            else
                describePushTravel(viaMode);

        }

        describeMovePushable (connector, dest)
        {
            local obj = self;
            gMessageParams(obj, dest);
            DMsg(describe move pushable, '{The subj obj} {comes} to a halt. ' );

        }

        /*
         *   This message, called on the direct object of a PushTravel command (i.e.
         *   the object being pushed) is displayed just before travel takes place.
         *   It is used when the PushTravel command also involves an indirect
         *   object, e.g. a Passage, Door or Stairway the direct object is being
         *   pushed through, up or down. The via parameter is the preposition
         *   relevant to the kind of pushing, e.g. Into, Through or Up.
         */
        describePushTravel(via)
        {
            /* If I have a traversalMsg, use it */
            if(gIobj && gIobj.propType(&traversalMsg) != TypeNil)
                DMsg(push travel traversal, '{I} <<if matchPullOnly>> pull{s/ed}
                    <<else>> push{es/ed}<<end>> {the dobj} {1}. ',
                     gIobj.traversalMsg);
            else
                DMsg(push travel somewhere, '{I} <<if matchPullOnly>> pull{s/ed}
                    <<else>> push{es/ed}<<end>> {the dobj} {1} {the iobj}. ',
                     via.prep);
        }

        /*
         *   PushTravelThrough handles pushing something through something, such as
         *   a door or archway. Most of the actual handling is dealt with by the
         *   common routines defined above.
         */
        dobjFor(PushTravelThrough)
        {
            preCond = [touchObj]
            verify()   {   verifyPushTravel(Through);   }

            action() { doPushTravel(Through); }
        }

        iobjFor(PushTravelThrough)
        {
            preCond = [touchObj]
            verify()
            {
                if(!canGoThroughMe || destination == nil)
                    illogical(cannotPushThroughMsg);
            }

            check() { checkPushTravel(); }
        }

        cannotPushThroughMsg = BMsg(cannot push through, '{I} {can\'t} {1}
            anything through {the iobj}. ', gVerbWord)

        /*
         *   PushTravelEnter handles commands like PUSH BOX INTO COFFIN, where the
         *   indirect object is a Booth-like object. The syntactically identical
         *   command for pushing things into an Enterable (e.g. PUSH BOX INTO HOUSE
         *   where HOUSE represents the outside of a separate location) is handled
         *   on the Enterable class.
         */
        dobjFor(PushTravelEnter)
        {
            preCond = [touchObj]
            verify()  {  verifyPushTravel(Into);  }

        }

        okayPushIntoMsg = BMsg(okay push into, '{I} <<if matchPullOnly>> pull{s/ed}
                    <<else>> push{es/ed}<<end>>} {the dobj} into {the iobj}. ')

        iobjFor(PushTravelEnter)
        {
            preCond = [containerOpen]
            verify()
            {
                if(!isEnterable)
                    illogical(cannotPushIntoMsg);
            }

            check()
            {
                checkInsert(gActor);
                checkInsert(gDobj);
            }

            action()
            {
                gDobj.actionMoveInto(self);
                gActor.actionMoveInto(self);

                if(gDobj.isIn(self))
                    say(okayPushIntoMsg);
            }
        }

        cannotPushIntoMsg = BMsg(cannot push into, '{I} {can\'t} {1}
            anything into {the iobj}. ', gVerbWord)

        dobjFor(PushTravelGetOutOf)
        {
            preCond = [touchObj]
            verify()
            {
                verifyPushTravel(OutOf);
                if(!self.isIn(gIobj))
                    illogicalNow(notInMsg);
            }

        }

        iobjFor(PushTravelGetOutOf)
        {
            preCond = [touchObj]

            verify()
            {
                if(!gActor.isIn(self))
                    illogicalNow(actorNotInMsg);

            }

            action()
            {
                gDobj.actionMoveInto(location);
                if(gDobj.location ==  location)
                {
                    say(okayPushOutOfMsg);
                    gActor.actionMoveInto(location);
                }
            }

        }

        okayPushOutOfMsg = BMsg(okay push out of, '{I} <<if matchPullOnly>> pull{s/ed}
                    <<else>> push{es/ed}<<end>> {the dobj} {outof iobj}. ')

        dobjFor(PushTravelClimbUp)
        {
            preCond = [touchObj]
            verify()  {  verifyPushTravel(Up);  }

            action() { doPushTravel(Up); }
        }

        iobjFor(PushTravelClimbUp)
        {
            preCond = [touchObj]

            verify()
            {
                if(!isClimbable || destination == nil)
                    illogical(cannotPushUpMsg);
            }

            check() { checkPushTravel(); }
        }

        cannotPushUpMsg = BMsg(cannot push up, '{I} {can\'t} {1}
            anything up {the iobj}. ', gVerbWord)

        dobjFor(PushTravelClimbDown)
        {
            preCond = [touchObj]
            verify()  { verifyPushTravel(Down);  }

            action() { doPushTravel(Down); }
        }

        iobjFor(PushTravelClimbDown)
        {
            preCond = [touchObj]

            verify()
            {
                if(!canClimbDownMe || destination == nil)
                    illogical(cannotPushDownMsg);
            }

            check() { checkPushTravel(); }
        }

        cannotPushDownMsg = BMsg(cannot push down, '{I} {can\'t} {1}
            anything down {the iobj}. ', gVerbWord)

        /*
         *   We don't bother to define isAskable etc. properties since we assume
         *   that no inanimate object can be conversed with, and that game code will
         *   use the Actor class to allow conversation. In any case since there's
         *   never any difficult in talking about oneself, the various illogicalSelf
         *   checks aren't needed.
         *
         *   Indeed, the handling of conversational commands on Thing is minimal;
         *   they are simply ruled out at the verify stage, since most Things can't
         *   converse. The implementation of these actions that allows conversation
         *   to take place is on the Actor class. We do however define a canTalkToMe
         *   property so that Actor can use the verify handling defined on Thing by
         *   just overriding it.
         *
         *   Things can't be talked to, so game code shouldn't normally override
         *   this property; it's there to be overridden on the Actor class.
         */
        canTalkToMe = nil

        dobjFor(AskAbout)
        {
            preCond = [objAudible]
            verify()
            {
                if(gActor == self)
                    illogicalSelf(cannotTalkToSelfMsg);

                else if(!canTalkToMe)
                  illogical(cannotTalkToMsg);
            }
        }

        dobjFor(AskFor)
        {
            preCond = [objAudible]
            verify()
            {
                if(gActor == self)
                    illogicalSelf(cannotTalkToSelfMsg);

                else if(!canTalkToMe)
                  illogical(cannotTalkToMsg);
            }
        }

        dobjFor(TellAbout)
        {
            preCond = [objAudible]
            verify()
            {
                if(gActor == self)
                    illogicalSelf(cannotTalkToSelfMsg);

                else if(!canTalkToMe)
                  illogical(cannotTalkToMsg);
            }
        }

        dobjFor(SayTo)
        {
            preCond = [objAudible]
            verify()
            {
                if(gActor == self)
                    illogicalSelf(cannotTalkToSelfMsg);

                else if(!canTalkToMe)
                  illogical(cannotTalkToMsg);
            }
        }

        dobjFor(QueryAbout)
        {
            preCond = [objAudible]
            verify()
            {
                if(gActor == self)
                    illogicalSelf(cannotTalkToSelfMsg);

                else if(!canTalkToMe)
                  illogical(cannotTalkToMsg);
            }
        }

        dobjFor(TalkAbout)
        {
            preCond = [objAudible]
            verify()
            {
                if(gActor == self)
                    illogicalSelf(cannotTalkToSelfMsg);

                else if(!canTalkToMe)
                  illogical(cannotTalkToMsg);
            }
        }

        dobjFor(TalkTo)
        {
            preCond = [objAudible]
            verify()
            {
                if(gActor == self)
                    illogicalSelf(cannotTalkToSelfMsg);

                else if(!canTalkToMe)
                  illogical(cannotTalkToMsg);
            }
        }

        cannotTalkToMsg = BMsg(cannot talk, 'There{dummy}{\'s} no point trying to
            talk to {the cobj}. ')

        cannotTalkToSelfMsg = BMsg(cannot talk to self, 'Talking to oneself {dummy}
            {is} generally pointless. ')

        dobjFor(GiveTo)
        {
            preCond = [objHeld]
            verify()
            {
                if(isIn(gIobj))
                    illogical(alreadyHasMsg);
            }

            report()
            {
                if(gAction.summaryReport != nil)
                    dmsg(gAction.summaryReport, gActionListStr);

                if(gAction.summaryProp != nil)
                    gIobj.(gAction.summaryProp);
            }
        }

        alreadyHasMsg = BMsg(already has, '{The subj iobj} already {has}
            {the dobj}.')

        iobjFor(GiveTo)
        {
            preCond = [touchObj]
            verify()
            {
                if(gActor == self)
                    illogicalSelf(cannotGiveToSelfMsg);
                if(!canTalkToMe)
                    illogical(cannotGiveToMsg);
            }

        }

        cannotGiveToMsg = BMsg(cannot give to, '{I} {can\'t} give anything to {that
            iobj}. ')

        cannotGiveToSelfMsg = BMsg(cannot give to self, '{I} {can\'t} give anything
            to {himself actor}. ')

        dobjFor(ShowTo)
        {
            preCond = isFixed ? [objVisible] : [objHeld]
            report()
            {
                if(gAction.summaryReport != nil)
                    dmsg(gAction.summaryReport, gActionListStr);

                if(gAction.summaryProp != nil)
                    gIobj.(gAction.summaryProp);
            }
        }

        iobjFor(ShowTo)
        {
            preCond = [touchObj]
            verify()
            {
                if(gActor == self)
                    illogicalSelf(cannotShowToSelfMsg);
                else if(!canTalkToMe)
                    illogical(cannotShowToMsg);
            }
        }

        cannotShowToMsg = BMsg(cannot show to, '{I} {can\'t} show anything to {that
            iobj}. ')

        cannotShowToSelfMsg = BMsg(cannot show to self, '{I} {can\'t} show anything
            to {himself actor}. ')

        dobjFor(ShowToImplicit)
        {
            preCond = isFixed ? [objVisible] : [objHeld]

            verify()
            {
                if(gActor.currentInterlocutor == nil)
                    illogical(notTalkingToAnyoneMsg);
                else if(!Q.canTalkTo(gActor, gActor.currentInterlocutor))
                    illogicalNow(noLongerTalkingToAnyoneMsg);

            }

            action()
            {
                gActor.currentInterlocutor.handleTopic(&showTopics, [self]);
            }

            report()
            {
                if(gAction.summaryReport != nil)
                    dmsg(gAction.summaryReport, gActionListStr);

                if(gAction.summaryProp != nil)
                    gActor.currentInterlocutor.(gAction.summaryProp);
            }
        }

        dobjFor(GiveToImplicit)
        {
            preCond = [objHeld]

            verify()
            {
                if(gActor.currentInterlocutor == nil)
                    illogical(notTalkingToAnyoneMsg);
                else if(!Q.canTalkTo(gActor, gActor.currentInterlocutor))
                    illogicalNow(noLongerTalkingToAnyoneMsg);

            }

            action()
            {
                 gActor.currentInterlocutor.handleTopic(&giveTopics, [self]);
            }

            report()
            {
                if(gAction.summaryReport != nil)
                    dmsg(gAction.summaryReport, gActionListStr);

                if(gAction.summaryProp != nil)
                    gActor.currentInterlocutor.(gAction.summaryProp);
            }
        }

        notTalkingToAnyoneMsg = BMsg(not talking to anyone, '{I}{\'m} not talking to
            anyone. ')

        noLongerTalkingToAnyoneMsg = BMsg(no longer talking to anyone, '{I}{\'m} no
            longer talking to anyone. ')

     #ifdef __DEBUG
        /* Handling of Debugging actions. */

        /*
         *   PURLOIN allows the player to move any portable object in the game
         *   directly into his/her inventory, wherever it is currently. We don't
         *   allow absolutely anything to be purloined, as this could cause chaos.
         */
        dobjFor(Purloin)
        {
            verify()
            {
                if(isDirectlyIn(gActor))
                    illogicalNow(alreadyHeldMsg);

                if(self == gActor)
                    illogicalSelf(cannotPurloinSelfMsg);

                if(isFixed)
                    illogical(cannotTakeMsg);

                if(ofKind(Room))
                    illogical(cannotPurloinRoomMsg);

                if(gActor.isIn(self))
                    illogicalNow(cannotPurloinContainerMsg);

                logical;
            }

            check() {}

            action()
            {
                /*
                 *   We use moveInto() rather than actionMoveInto() to move the item
                 *   into the player's inventory since this isn't a regular take and
                 *   we don't want the side-effects of movement notifications,
                 *   neither to we want a notifyRemove() routine to veto a Purloin.
                 */
                moveInto(gActor);

                /*
                 *   Make this item unhidden even if it was hidden before, otherwise
                 *   it won't show up in inventory and we can't interact with it.
                 */
                isHidden = nil;

                /*
                 *   Note that the player char has seen the purloined item. Not
                 *   doing this can make it appear that the player character doesn't
                 *   know about an object that's in his/her inventory.
                 */
                if(gPlayerChar.canSee(self))
                    gSetSeen(self);
            }

            report()
            {
                DMsg(purloin, '{I} suddenly {find} {myself} holding {1}. ',
                    gActionListStr );
            }
        }

        cannotPurloinSelfMsg = BMsg(cannot purloin self, '{I} {can\'t} purloin
            {myself}. ')
        cannotPurloinRoomMsg = BMsg(cannot purloin room, '{I} {can\'t} purloin a
            room. ')
        cannotPurloinContainerMsg = BMsg(cannot purloin container, '{I} {can\'t}
            purloin something {i}{\'m} contained within. ')

        /*
         *   The GoNear action allows the player character to teleport around the
         *   map.
         */
        dobjFor(GoNear)
        {
            verify()
            {
                if(getOutermostRoom == nil)
                    illogicalNow(cannotGoNearThereMsg);

                if(ofKind(Room))
                    logicalRank(120);
            }

            action()
            {
                DMsg(gonear, '{I} {am} translated in the twinkling of an
                    eye...<.p>');
                getOutermostRoom.travelVia(gActor);
            }
        }

        cannotGoNearThereMsg = BMsg(cannot go there, '{I} {can\'t} go there right
            {now}. ')

     #endif
    ;

    thingPreinit: PreinitObject
        execute()
        {
            forEachInstance(Thing, {obj: obj.preinitThing });

            /*
             *   The player character presumably knows about the objects s/he's
             *   immediately holding even without explicitly examining them or
             *   taking inventory
             */
            foreach(local cur in gPlayerChar.contents)
                gSetKnown(cur);
        }

        execBeforeMe = [pronounPreinit]
    ;

    /*
     *   A Key is any object that can be used to lock or lock selected items whose
     *   lockabilty is lockableWithKey. We define all the special handling on the
     *   Key class rather than on the items to be locked and/or unlocked.
     */
    class Key: Thing

        /* The list of things this key can actually be used to lock and unlock. */
        actualLockList = []

        /*
         *   The list of things this key plausibly looks like it might lock and
         *   unlock (e.g. if we're a yale key, we might list all the doors in the
         *   game that have yale locks here).
         */
        plausibleLockList = []

        /*
         *   The list of all the things the player character knows this key can lock
         *   and unlock. Items are automatically added to this list when this key is
         *   successfully used to lock or unlock them, but game code can also use
         *   this property to list items the player character starts out knowing,
         *   such as the door locked by his/her own front door key.
         */
        knownLockList = []

        /*
         *   Determine whether we're a possible key for obj (i.e. whether we might
         *   be able to lock or unlock obj).
         */
        isPossibleKeyFor(obj)
        {
            /*
             *   First test if we've been defined as a plausible or known key for
             *   our lexicalParent in the case that we're the remapIn object for our
             *   lexicalParent. If so return true. We do this because game code
             *   might easily define the plausibleKeyList and/or knownKeyList on our
             *   lexicalParent intending to refer to what keys might unlock is
             *   associated container (i.e. ourselves if we're our lexicalParent's
             *   remapIn object).
             */
            if(obj.lexicalParent != nil && obj.lexicalParent.remapIn == obj
               &&(knownLockList.indexOf(obj.lexicalParent) != nil
                  || plausibleLockList.indexOf(obj.lexicalParent) != nil))
                return true;

            /*
             *   Otherwise return true if obj is in either our knownLockList or our
             *   plausibleLockList or nil otherwise.
             */
            return knownLockList.indexOf(obj) != nil ||
                plausibleLockList.indexOf(obj) != nil;
        }

        /* A key is something we can unlock with. */
        canUnlockWithMe = true

        iobjFor(UnlockWith)
        {
            preCond = [objHeld]

            verify()
            {
                inherited;

                /*
                 *   We're a logical choice of key if we're a possible key for the
                 *   direct object.
                 */
                if(isPossibleKeyFor(gDobj))
                    logical;

                /* Otherwise we're not a very good choice. */
                else
                    implausible(notAPlausibleKeyMsg);
            }

            check()
            {
                /*
                 *   Check whether this key *actually* fits the direct object, and
                 *   if not display a message to say it doesn't (which halts the
                 *   action).
                 *
                 *   This is complicated by the fact that if the direct object is a
                 *   SubComponent the game author may have listed the dobj's
                 *   lexicalParent in our actualLockList property instead of the
                 *   actual dobj (e.g. the fridge object itself instead of the
                 *   SubComponent representing the interior of the fridge). So in
                 *   addition to seeing if the dobj is included in our
                 *   actuallockList we need to check whether, if the dobj has a
                 *   lexicalParent of which it's the remapIn object, dobj's
                 *   lexicalParent is in our actualLockList.
                 */

                if(actualLockList.indexOf(gDobj) == nil
                   && (gDobj.lexicalParent == nil
                   || gDobj.lexicalParent.remapIn != gDobj
                   || actualLockList.indexOf(gDobj.lexicalParent) == nil))
                    say(keyDoesntFitMsg);
            }

            action()
            {
                /* Make the dobj unlocked. */
                gDobj.makeLocked(nil);

                /* If the dobj is not already in our knownLockList, add it there. */
                if(knownLockList.indexOf(gDobj) == nil)
                    knownLockList += gDobj;
            }

            report()
            {
                DMsg(okay unlock with, okayUnlockWithMsg, gActionListStr);
            }

        }

        okayUnlockWithMsg = '{I} unlock{s/ed} {the dobj} with {the iobj}. '

        iobjFor(LockWith)
        {
            preCond = [objHeld]

            verify()
            {
                inherited;

                if(isPossibleKeyFor(gDobj))
                    logical;
                else
                    implausible(notAPlausibleKeyMsg);
            }

            check()
            {
                /*
                 *   Check whether this key *actually* fits the direct object, and
                 *   if not display a message to say it doesn't (which halts the
                 *   action).
                 *
                 *   This is complicated by the fact that if the direct object is a
                 *   SubComponent the game author may have listed the dobj's
                 *   lexicalParent in our actualLockList property instead of the
                 *   actual dobj (e.g. the fridge object itself instead of the
                 *   SubComponent representing the interior of the fridge). So in
                 *   addition to seeing if the dobj is included in our
                 *   actuallockList we need to check whether, if the dobj has a
                 *   lexicalParent of which it's the remapIn object, dobj's
                 *   lexicalParent is in our actualLockList.
                 */
                 if(actualLockList.indexOf(gDobj) == nil
                   && (gDobj.lexicalParent == nil
                   || gDobj.lexicalParent.remapIn != gDobj
                   || actualLockList.indexOf(gDobj.lexicalParent) == nil))
                    say(keyDoesntFitMsg);
            }

            action()
            {
                /*Make the dobj locked. */
                gDobj.makeLocked(true);

                /* If the dobj is not already in our knownLockList, add it there. */
                if(knownLockList.indexOf(gDobj) == nil)
                    knownLockList += gDobj;
            }

            report()
            {
                 DMsg(okay lock with, okayLockWithMsg, gActionListStr);
            }
        }

        /* The message to say that the actor has lock the dobj with this key. */
        okayLockWithMsg = '{I} lock{s/ed} {the dobj} with {the iobj}. '

        /*
         *   The message to say that this key clearly won\'t work on the dobj
         *   (because it\'s the wrong sort of key for the lock; e.g. a yale key
         *   clearly won\'t fit the lock on a small jewel box).
         */
        notAPlausibleKeyMsg = '\^<<theName>> clearly won\'t work on <<gDobj.theName>>. '

        /*  The message to say that this key doesn\'t in fact fit the dobj. */
        keyDoesntFitMsg = '\^<<theName>> won\'t fit <<gDobj.theName>>. '

        preinitThing()
        {
            inherited;

            /*
             *   Add the actualLockList to the plausibleLockList if it's not already
             *   there to ensure that this key will work on anything in its
             *   actualLockList.
             */
            plausibleLockList = plausibleLockList.appendUnique(actualLockList);

        }

    ;

    /*
     *   A SubComponent is a Thing that is part of something else and represents the
     *   surface, container, underside or rear of the object to which it's attached.
     *   This allows a Thing to model several types of containment at once, by
     *   having (say) one SubComponent that represents its top (on which things can
     *   be placed) and another to represent its interior (in which things can be
     *   placed.
     *
     *   A SubComponent is normally defined as a nested anonymous object on the
     *   remapOn, remapIn, remapUnder or remapBehind property of a Thing. There's no
     *   need to further specify whether a SubComponent is also a Surface,
     *   Container, Underside or RearContainer, since the library can work this out
     *   from the property on which it is defined.
     */
    class SubComponent: Thing

        /*
         *   A SubComponent is always fixed in place since it represents a fixed
         *   part of its lexicalParent.
         */
        isFixed = true

        /* Preinitialize a SubComponent. */
        preinitThing()
        {
            /*
             *   Carry out the particular initialization of a SubComponent (see next
             *   method); this sets up the proper relation between the SubComponent
             *   and its lexicalParent.
             */
            initializeSubComponent(lexicalParent);

            /*  Note any vocab defined on this SubComponent */
            origVocab = vocab;

            /* Carry out the inherited handling. */
            inherited;
        }

        /*
         *   Initialize this SubComponent. This sets up the necessary relations
         *   between the SubCompononent and the object of which it is a part,
         *   usually its lexicalParent (passed as the parent parameter).
         */
        initializeSubComponent(parent)
        {
            /*
             *   If for any reason we don't have a parent (normally, our
             *   lexicalParent), stop here because there's nothing we can do.
             */
            if(parent == nil)
                return;

            /* A SubComponent is located in its parent. */
            location = parent;

            /*
             *   A SubComponent takes its name from its parent, since it's
             *   effectively an aspect of its parent.
             */
            nameAs(parent);

            /*
             *   Determine the contType of this SubComponent from the property to
             *   which it's attached. The contType must match the remapXX type.
             */
            if(parent.remapIn == self)
                contType = In;

            if(parent.remapOn == self)
                contType = On;

            if(parent.remapUnder == self)
                contType = Under;

            if(parent.remapBehind == self)
                contType = Behind;

            /* If we have a contType, set our listOrder to that of our contType. */
            if(contType != nil)
                listOrder = contType.listOrder;
        }

        /*
         *   Take each of our name-related properties from the corresponding
         *   properties of our lexicalParent. Language-specific modules may need to
         *   override this method to cater for additional properties.
         *
         *   Note that if the lexicalParent is renamed at any point during the game,
         *   this nameAs() method should be called on any openable SubComponent at
         *   the same time to ensure the names stay in sync.
         */
        nameAs(parent)
        {
            name = parent.name;
            proper = parent.proper;
            qualified = parent.qualified;
            person = parent.person;
            plural = parent.plural;
            massNoun = parent.massNoun;
            isHim = parent.isHim;
            isHer = parent.isHer;
            isIt = parent.isIt;
        }

        makeOpen(stat)
        {
            inherited(stat);

            /*
             *   If we close this item when the playerChar is inside it, the player
             *   will need to be able to refer to it with the vocab of its
             *   lexicalParent, since the lexicalParent will no longer be in scope
             */
            if(lexicalParent != nil && gPlayerChar.isIn(self))
            {
                if(stat)
                {
                    /*
                     *   If this object is being opened, replace our vocab with the
                     *   vocab we started out with (which will normally be none),
                     *   since we no longer want the player to be able to refer
                     *   directly* to us using our lexicalParent's vocab once we're
                     *   open.
                     */
                    replaceVocab(origVocab);

                    /*   Restore our name to our lexicalParent's name. */
                    nameAs(lexicalParent);
                }
                else
                {
                    /*
                     *   If this object is being closed, replace our vocab with that
                     *   of our lexicalParent (which is no longer in scope once
                     *   we're closed with the playerChar inside us) so that the PC
                     *   can still refer to us (e.g. to open us again).
                     */
                    addVocab(lexicalParent.vocab);

                }
            }
        }

        /*
         *   Our original vocab. We need to store this in case makrOpen() wants to
         *   restore it.
         */
        origVocab = nil

        matchNameDisambig(tokens)
        {
            local match = inherited(tokens);

            /*
             *   If we're being matched at a disambig prompt and we don't have any
             *   vocabWords of our own, try matching us against our lexicalParent's
             *   vocab instead, provided we have a lexicalParent.
             *
             *   This is necessary because SubComponents don't normally have any
             *   vocab of their own, but a SubComponent may end up as one of the
             *   objects that notionally matched the vocab of its lexicalParent
             *   among which the parser now wishes the player to disambiguate. For
             *   example, if the player types LOOK IN BOX and there's more than one
             *   box in scope, and the red box (say) has a SubComponent defined on
             *   its remapIn property, then since the LOOK IN action will have been
             *   redirected to the SubComponent, the parser will list the
             *   SubComponent as the object corresponding to "red box", but the
             *   SubComponent doesn't have any vocab of its own for the player's
             *   response "red" to match; when disambiguating we therefore need to
             *   try to match against our lexicalParent's vocab.
             */
            if(match == 0 && lexicalParent != nil)
                return lexicalParent.matchNameDisambig(tokens);

            /*
             *   Otherwise just return our normal match
             */
            return match;

        }
    ;

    /*
     *   A MultiLoc is an object that can exist in several locations at once.
     *   MultiLoc is a mix-in class that should be used in conjunction with Thing or
     *   a Thing-derived class.
     */
    class MultiLoc: object

        /*
         *   A list of the locations this object is currently present in. If this
         *   property is defined at the start of the game and initialLocationList
         *   isn't, then this list will be copied to initialLocationList, and so can
         *   be specified by users in exactly the same way.
         */
        locationList = []

        /*
         *   A list of the locations this object is to start out in. Locations may
         *   be specified as Things, Rooms or Regions, or as some mix of all three.
         */
        initialLocationList = []

        /*
         *   A list of locations this object is not to be present in. This is
         *   intended mainly to allow certain rooms to be excepted from a specified
         *   region.
         */
        exceptions = []

        /*
         *   If the initialLocationClass property is defined, then this MultiLoc is
         *   initially located in every instance of this class. Note that this would
         *   be in addition to the locations defined in the locationList class and
         *   would likewise be subject to anything defined in the exceptions
         *   property.
         */
        initialLocationClass = nil

        /*
         *   Test an object for inclusion in our initial location list.  By
         *   default, we'll simply return true to include every object.  We
         *   return true by default so that an instance can merely specify a
         *   value for initialLocationClass in order to place this object in
         *   every instance of the given class.
         */
        isInitiallyIn(obj) { return true; }

        /*
         *   In Preinit, add this MultiLoc into the contents list of every item in
         *   its locationList and every object of class initialLocationClass (if
         *   this is not nil) and then remove it from the contents list of every
         *   item in its exceptions list.
         */
        addToLocations()
        {
            /*
             *   If there's nothing in the initialLocationList, we'll assume the
             *   author used the locationList property to specify the initial
             *   locations of this MultiLoc, since this was correct in earlier
             *   versions and should be maintained for backward compatibility. In
             *   That case copy the locationList to the initialLocationList and then
             *   set the locationList to an empty list before attempting to build
             *   it.
             */
            if(initialLocationList.length == 0)
            {
                initialLocationList = locationList;
                locationList = [];
            }

            /* Create a new Vector to keep track of our list of locations. */
            local locationVec = new Vector(10);

            /*
             *   Add ourselves to the content property of all the items listed in
             *   our initialLocationList. At the same time append each item listed
             *   to our locationVec vector.
             */
            foreach(local loc in valToList(initialLocationList))
            {
                loc.addToContents(self, locationVec);
            }

            /*
             *   If we have an initialLocationClass, add ourselves to the location
             *   list of every object of that class for which our isInitiallyIn(obj)
             *   method returns true; at the last time add all such objects to our
             *   locationVec vector.
             */
            if(initialLocationClass != nil)
            {
                for(local obj = firstObj(initialLocationClass); obj != nil; obj =
                    nextObj(obj, initialLocationClass))
                {
                    if(isInitiallyIn(obj))
                        obj.addToContents(self, locationVec);
                }
            }

            /*
             *   Now remove ourselves from the contents list of all objects listed
             *   as exceptions in our exceptions property, and remove those objects
             *   from our locationVec vector.
             */
            foreach(local loc in valToList(exceptions))
            {
                loc.removeFromContents(self, locationVec);
            }

            /*
             *   Store our resulting list of locations in our locationList property.
             */
            locationList = locationVec.toList();
        }

        /*
         *   Move this MultiLoc into an additional location.
         */
        moveIntoAdd(loc)
        {
            /*
             *   Let the new location handle it, so it will work whether the new
             *   location is a Thing, a Room or a Region.
             */
            loc.moveMLIntoAdd(self);

        }

        /*
         *   Remove this MultiLoc from loc.
         */
        moveOutOf(loc)
        {
            /*
             *   Let the new location handle it, so it will work whether the new
             *   location is a Thing, a Room or a Region.
             */
            loc.moveMLOutOf(self);
        }

        /*
         *   To move a MultiLoc into a single location, first remove it from every
         *   location in its location list, then add it to the single location it's
         *   now in.
         */
        moveInto(loc)
        {
            foreach(local cur in locationList)
                cur.removeFromContents(self);

            locationList = [];

            if(loc != nil)
                moveIntoAdd(loc);
        }

        /*
         *   A MultiLoc is directly in another object if it's listed in that other
         *   object's contents list.
         */
        isDirectlyIn(loc)
        {
            if(loc != nil)
                return valToList(loc.contents).indexOf(self) != nil;

            /*
             *   We only reach this point if loc is nil, in which case we're testing
             *   whether this MultiLoc is in nil, i.e. nowhere at all. This will be
             *   the case if and only if its location list is empty.
             */
            return locationList == [];
        }

        /*
         *   A MultiLoc is in another object either if it's directly in that object
         *   or if one of the items in its location list is in that object.
         */
        isIn(loc)
        {
            return isDirectlyIn(loc)
                || locationList.indexWhich({x: x.isIn(loc)}) != nil;
        }

        /*
         *   For certain purposes, such as sense path calculations, a Multiloc needs
         *   a notional location. We assume the enquiry is made from the perspective
         *   of the current actor, or, failing that, the player char, so we return
         *   the current actor's (or the player char's) current location if the
         *   MultiLoc is present there, or the last place where the MultiLoc was
         *   seen otherwise. The intention is to select the most currently
         *   significant location where we're present.
         */
        location()
        {
            /*
             *   If our locationList is empty, then we aren't anywhere, so our
             *   location is nil.
             */
             if(locationList.length == 0)
                return nil;

            /*
             *   Get the room either of the current actor (if there is one) or else
             *   of the player char.
             */
            local rm = gActor == nil ? gPlayerChar.getOutermostRoom :
            gActor.getOutermostRoom;

            /*
             *   First see if we're directly in the actor's enclosing room. If so,
             *   return that room as our location.
             */
            if(isDirectlyIn(rm))
                return rm;

            /*
             *   If that doesn't work, check if anything in our location list is in
             *   the actor's room; if so, use that.
             */
            local loc = locationList.valWhich({x: x.isIn(rm)});

            if(loc != nil)
                return loc;

            /*
             *   If that doesn't work, return the location we were last seen at,
             *   provided we have one and we're still there.
             */
            if(lastSeenAt != nil && locationList.indexOf(lastSeenAt) != nil)
                return lastSeenAt;

             /*
              *   If all else fails, return the first location from our locationList
              *   (if we've reached this point we know for sure there is one, since
              *   if our locationList were empty this method would have already
              *   returned nil).
              */
            return locationList[1];
        }

        /*
         *   If we're a MultiLoc we don't want to carry out any of the normal
         *   preinitialization related to our location.
         */
        preinitThing()
        {
            /* if we have a global parameter name, add it to the global table */
            if (globalParamName != nil)
                libGlobal.nameTable_[globalParamName] = self;
        }
    ;

    /*
     *   The Floor Class is used to provide a floor or ground object to each room
     *   that wants one (by default, every Room). While this serves the secondary
     *   purpose of allowing the player to refer to the ground/floor of the current
     *   location (which is nearly always implicitly present), it's primary purpose
     *   is to allow the parser to refer to the floor/ground when it wants to
     *   distinguish items directly in a Room (and hence notionally on the ground)
     *   from those in or on some other object.
     */
    class Floor: MultiLoc, Thing
        /*
         *   A Floor is a Decoration, but since the extras.t module is optional we
         *   have to define is as isFixed = true and isDecoration = true.
         */
        isFixed = true

        isDecoration = true

        /* By default, every room has a floor. */
        initialLocationClass = Room

        /* A Floor is something we can put things on. */
        contType = On

        /*
         *   We narrow down our list of locations to those Rooms that actually
         *   define this Floor as their floorObj. Some rooms may wish to define a
         *   custom floorObj, and some (e.g. those representing the top of a mast or
         *   tree) may want to have no floorObj at all.
         */
        isInitiallyIn(obj) { return obj.floorObj == self; }

        /*
         *   The Floor object needs to appear to share the contents of the player
         *   character's room (or other enclosing container) for certain purposes
         *   (such as disambiguating by container or the TakeFrom command), but
         *   nothing is really moved into or out of a Floor).
         */
        contents = (gPlayerChar.outermostVisibleParent().contents - self)

        /*
         *   We can examine a Floor or take something from it, but other actions are
         *   ruled out. A Floor should generally be treated as a Decoration object
         *   rather than something with which any extensive interaction is allowed.
         */
        decorationActions = [Examine, TakeFrom]

        /*
         *   By default we probably want to keep the description of a Floor object
         *   as minimalistic as possible to discourage players from trying to
         *   interact with it, so we won't listed the 'contents' of a Floor when
         *   it's examined. This can of course be overridden if desired.
         */
        contentsListed = nil
    ;

    /*
     *   The defaultGround object is the specific Floor object that's present in
     *   every Room by default.
     */
    defaultGround: Floor
    ;

    /* Preinitilizer for MultiLocs */
    multiLocInitiator: PreinitObject
        execute()
        {
            /*
             *   Add every MultiLoc to the contents list of all its locations. This
             *   also builds each MultiLoc's locationList as it goes.
             */
            for(local cur = firstObj(MultiLoc); cur !=nil ; cur = nextObj(cur,
                MultiLoc))

                cur.addToLocations();
        }

        /*
         *   Make sure we've preinitialized Regions first, so that their roomLists
         *   are ready when we want to use them.
         */
        execBeforeMe = [regionPreinit]
    ;

    /*
     *   A Topic is something that the player character can refer to in the course
     *   of conversation or look up in a book, but which is not implemented as a
     *   physical object in the game. Topics can be used for abstract concepts such
     *   as life, liberty and happiness, or for physical objects that are referred
     *   to but not actually implemented as Things in the game, such as Alfred the
     *   Great or the Great Wall of China.
     */
    class Topic: Mentionable
        construct(name_)
        {
            vocab = name_;
            initVocab();
        }

        /*
         *   Whether the player character knows of the existence of this topic. By
         *   default we assume this is true.
         */
        familiar = true

        /*   Make this topic known to the player character */
        setKnown() { gPlayerChar.setKnowsAbout(self); }

        /* Test whether this topic is known to the player character */
        known = (gPlayerChar.knowsAbout(self))

        /*
         *   Return a textual description of this topic, which will normally be just
         *   its name. We use the vocab as fall-back alternative.
         */
        getTopicText()
        {
            return name == nil ? vocab : name;
        }
    ;
    /* ------------------------------------------------------------------------ */
    /*
     *   LocType objects are used for Thing.locType property values to specify
     *   the relationship between an object and its container.
     *
     *   The language module must set appropriate vocabulary properties for
     *   each LocType object during pre-initialization.  The exact vocabulary
     *   needed is up to the language to define.  For the English module, we
     *   set the 'prep' property to a suitable preposition for constructing
     *   locational phrases ("the book *on* the table", etc).
     */
    class LocType: object

        listOrder = 100
    ;

    /*
     *   An IntLocType is an interior location type.  These represent objects
     *   on the inside of an enclosed space.
     */
    IntLocType: LocType

    ;

    /*
     *   An ExtLocType is an exterior location type.  These represent objects
     *   on the outside of an object, such as atop it or attached to it.
     */
    ExtLocType: LocType
    ;

    /*
     *   "In" location type - specifies that an object is contained within its
     *   location; its location encloses it.
     */
    In: IntLocType
        listOrder = 10
    ;

    /*
     *   "Outside" location type - specifies that an object is situated
     *   somewhere on the exterior of the object.  This can be used for
     *   components, attachments, things stuck to an object, things nailed to
     *   it, messages painted on it, etc.
     */
    Outside: ExtLocType
    ;

    /*
     *   "On" location type - specifies that an object is sitting on the top
     *   surface of its container.
     */
    On: ExtLocType
        listOrder = 20
    ;

    /*
     *   "Under" location type - specifies that an object is situated
     *   underneath its container.
     */
    Under: ExtLocType
        listOrder = 30
    ;

    /*
     *   "Behind" location type - specifies that an object is situated behind
     *   its container.
     */
    Behind: ExtLocType
        listOrder = 40
    ;

    /*
     *   "Held" location type - specifies that an object is being held by its
     *   container, in the sense of a person holding an object in her hands.
     *   An object being held is exterior to the holder, not enclosed.
     */
    Held: ExtLocType
    ;

    /*
     *   "Worn" location type - specifies that an object is being worn by its
     *   container, in the sense of a person wearing a coat.
     */
    Worn: ExtLocType
    ;

    /*
     *   "Attached" location type - specifies that an object is attached to its
     *   container.
     */
    Attached: ExtLocType
    ;

    /*
     *   "PartOf" location type - specifies that an object is part of -- a component
     *   of -- its container.
     */
    PartOf: ExtLocType
    ;

    /*
     *   "Carrier" location type - specifies that the object is being carried by its
     *   container (which will then normally be the actor holding this object). Any
     *   actor-type object should define Carrier as its contType.
     */
    Carrier: ExtLocType
    ;

    /*
     *   A ViaType is an object used to define the preposition to use to describe
     *   various kinds of PushTravel. The language-specific part of the libary needs
     *   to override the various ViaType objects to give the names of the
     *   prepositions in the target language.
     */
    class ViaType: object
        prep = ''
    ;

    Into: ViaType;
    OutOf: ViaType;
    Down: ViaType;
    Up: ViaType;
    Through: ViaType;

    /*
     *   The displayProbe object is used to store the result of capturing text in
     *   Thing.checkDisplay() before undoing the trial display of the string. By
     *   making displayProbe transient we preserve the value of its displayed
     *   property across the undo.
     */
    transient displayProbe: object
        displayed = nil
    ;

Adv3Lite Library Reference Manual
Generated on 28/03/2016 from adv3Lite version 1.5