#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