the amount of time on the game clock that the action consumes - by default, each action consumes one unit, but actions can override this to consume more or less game time

afterActionMainList

action.t[1291]

list of methods to invoke after we’ve completed the action

beforeAfterObjs

action.t[2254]

vector of objects requiring explicit before/after notification

defaultForRecursion

action.t[504]

the defaultForRecursion flag must be explicitly set in subclasses when desired - by default we’ll use any language-specific subclass of an Action for recursive commands

extraMessageParams

action.t[642]

Extra message parameters. If a message processor wants to add special message parameters of its own, we’ll create a lookup table for the extra parameters. Message processors might want to add their own special parameters to allow referring to objects other than the main objects of the command.

implicitMsg

action.t[543]

the libMessage property, if any, to announce the implicit command

includeInUndo

action.t[656]

Flag: this command should be included in the undo records. This is true for almost every command, but a few special commands (undo, save) are not subject to undo.

isImplicit

action.t[512]

Flag: the command is implicit. An implicit command is one that is performed as an implied enabling step of another command - for example, if an actor wants to throw something, the actor must be holding the object, so will implicitly try to take the object.

isRepeatable

action.t[649]

Flag: this command is repeatable with ‘again’. Before executing a command, we’ll save it for use by the ‘again’ command if this flag is true.

iterationCanceled

action.t[204]

internal flag: object iteration has been canceled

originalAction

action.t[540]

the original action - we are effectively part of the original action for reporting purposes

parentAction

action.t[527]

The parent action. If the command is performed programmatically in the course of executing another command, this is set to the enclosing action.

Note that while all implicit commands are nested, not all nested commands are implicit. A nested command may simply be a component of another command, or another command may be handled entirely by running a different command as a nested command. In any case, a nested but non-implicit command does not appear to the player as a separate command; it is simply part of the original command.

preCond

action.t[2403]

Our list of action-level pre-condition objects. These are the conditions that apply to the overall action, not to the individual objects involved. (Object-level pre-conditions are attached to the objects, not to the action.)

predicateNounPhrases

action.t[834]

Get the noun-phrase information for my predicate grammar. This returns a list of the match-tree properties for the noun-phrase sub-productions in our predicate grammar. The properties generally include &dobjMatch, &iobjMatch, &literalMatch, and &topicMatch. The order of the slots isn’t important; they simply tell us which ones we should find in our predicate grammar match.

The base Action is intransitive, so it doesn’t have any noun-phrase slots, hence this is an empty list.

pronounOverride

action.t[1021]

the pronoun override table - this is nil by default, which means that no overrides have been defined yet; we create a LookupTable upon adding the first entry to the table

remappedFrom

action.t[534]

The original action we were remapped from. This is valid when the action was explicitly remapped during the remap() phase to a different action.

showDefaultReports

action.t[550]

Flag: we are to show default reports for this action. In most cases we will do so, but for some types of commands (such as implicit commands), we suppress default reports.

synthParamID

action.t[633]

synthesized message object parameter serial number

verbFlags

en_us.t[8411]

Verb flags - these are used to control certain aspects of verb formatting. By default, we have no special flags.

verifiedOkay

action.t[2968]

List of objects that verified okay on a prior pass. This is a scratch-pad for use by verifier routines, to keep track of work they’ve already done. A few verifiers use this as a way to detect when an implicit action actually finished the entire job, which would in many cases result in a verify failure if not checked (because a command that effects conditions that already hold is normally illogical); by tracking that the verification previously succeeded, the verifier can know that the action should be allowed to proceed and do nothing.

Methods

actionOfKind (cls)

action.t[162]

Are we the given kind of action? By default, this simply returns true if we’re of the given action class.

addBeforeAfterObj (obj)

action.t[2243]

Register an object for explicit inclusion in beforeAction and afterAction notifications. This can be used to register objects that might not be connected by containment or otherwise notifiable by normal means. If this is called after the beforeAction notification loop has already started, then the object will only be sent an afterAction notification.

afterAction ( )

action.t[1812]

Run our action-specific post-processing. By default, we do nothing here.

afterActionMain ( )

action.t[1196]

Perform processing after running the entire action. This is called just once per action, even if the action was iterated for a list of objects.

announceActionObject (info, numberInList, whichObj)

action.t[1600]

Announce the object of an action. This should be used for each iteration of a command that takes objects to announce the objects on this iteration.

We announce an object under several circumstances:

- If we are iterating through multiple objects, we’ll show the current object to show the player the individual step in the command being performed.

- If ‘all’ was used to specify the object, we’ll announce it even if only one object is involved, to make it clear to the player exactly what we chose as a match.

- If we are executing the command on a single object, and the object was chosen through disambiguation of a set of ambiguous choices, and some of the discarded possibilities were logical but less so than the chosen object, we’ll show the assumption we made. In such cases, our assumption is not necessarily correct, so we’ll tell the user about our choice explicitly by way of confirmation - this gives the user a better chance of noticing quickly if our assumption was incorrect.

- If we supplied a default for a missing noun phrase in the player’s command, we’ll show what we chose. Since the player didn’t say what they meant, we’ll make it plain that we’re providing an assumption about what we thought they must have meant.

‘info’ is the ResolveInfo object describing this resolved object, and ‘numberInList’ is the total number of objects we’re iterating over for this object function (direct object, indirect object, etc). ‘whichObj’ is one of the object function constants (DirectObject, IndirectObject, etc) describing which object we’re mentioning; the language-specific message generator might use this in conjunction with the action to include a preposition with the displayed phrase, for example, or choose an appropriate inflection.

announceAllDefaultObjects (allResolved)

en_us.t[8289]

Announce all defaulted objects in the action. By default, we show nothing.

announceDefaultObject (obj, whichObj, resolvedAllObjects)

en_us.t[8276]

Announce a default object used with this action.

‘resolvedAllObjects’ indicates where we are in the command processing: this is true if we’ve already resolved all of the other objects in the command, nil if not. We use this information to get the phrasing right according to the situation.

beforeAction ( )

action.t[1776]

Run our action-specific pre-processing. By default, we do nothing here.

beforeActionMain ( )

action.t[1187]

Perform processing before running the action. This is called just once per action, even if the action will be iterated for a list of objects.

cacheMultiObjectAnnouncements (lst, whichObj)

action.t[1674]

Pre-calculate the multi-object announcement text for each object. This is important because these announcements might choose a form for the name that distinguishes it from the other objects in the iteration, and the basis for distinction might be state-dependent (such as the object’s current owner or location), and the relevant state might change as we iterate over the objects. From the user’s perspective, they’re referring to the objects based on the state at the start of the command, so the user will expect to see names based on the that state.

callAfterActionMain (obj)

action.t[1279]

Register an object for afterActionMain invocation. After we’ve finished with the entire action - including all iterated objects involved in the action - we’ll invoke each registered object’s afterActionMain() method. This registration is only meaningful for the current action instance, and can only be set up before the action has been finished (i.e., before the current gAction invokes its own afterActionMain() method).

Each object is only registered once. If a caller attempts to register the same object repeatedly, we’ll simply ignore the repeated requests.

This is a convenient way to implement a collective follow-up to the parts of an iterated action. Since repeated registrations are ignored, each handler for an iterated object (such as a “dobjFor” action() handler) can register its follow-up handler without worrying about redundant registration. Then, when the overall action is completed for each iterated object involved, the follow-up handler will be invoked, and it can do any final work for the overall action. For example, the follow-up handler could display a message summarizing the iterated parts of the action; or, it could even scan the transcript for particular messages and replace them with a summary.

callCatchAllProp (obj, actionProp, defProp, allProp)

action.t[1946]

Call a catch-all property on the given object.

actionProp is the custom per-object/per-action property that we normally invoke to process the action. For example, if we’re processing verification for the direct object of Take, this would be &verifyDobjTake.

defProp is the default property that corresponds to actionProp. This is the per-object/default-action property that we invoke when the object doesn’t provide a “more specialized” version of actionProp - that is, if the object doesn’t define or inherit actionProp at a point in its class hierarchy that is more specialized than the point at which it defines defProp, we’ll call defProp. If there is a more specialized definition of actionProp for the object, it effectively overrides the default handler, so we do not invoke the default handler.

allProp is the catch-all property corresponding to actionProp. We invoke this property in all cases.

Returns true if there is indeed a Default property that overrides the action, nil if not.

callPreConditions (lst, allowImplicit)

action.t[2338]

Call a method on all of the precondition objects in the precondition list obtained from the given property of the given object.

callVerifyPreCond (resultSoFar)

action.t[1896]

Verify the non-object-related pre-conditions. This runs verification on each of the pre-condition objects defined for the action.

callVerifyProp (obj, verProp, preCondProp, remapProp, resultSoFar, whichObj)

action.t[1984]

Call a verification routine. This creates a results object and makes it active, then invokes the given verification routine on the given object.

We call verification directly on the object, and we also call verification on the object’s preconditions.

If resultSoFar is non-nil, it is a VerifyResultList that has the results so far - this can be used for multi-object verifications to gather all of the verification results for all of the objects into a single result list. If resultSoFar is nil, we’ll create a new result list.

cancelIteration ( )

action.t[201]

Cancel iteration of the action. This can be called during the ‘check’ or ‘action’ phases of executing this action. It tells the action that we want to stop executing the action when we’re finished with the current object.

Note that this doesn’t cause a jump out of the current code, so it’s not like ‘exit’ or the other termination signals. Instead, this simply tells the action to proceed normally for the remainder of the processing for the current object, and then act as though there were no more objects to iterate over, ending the command normally. If you want to cut off the remainder of the execution cycle for the current object, you can use ‘exit’ (for example) immediately after calling this method.

checkAction ( )

action.t[1791]

Check the action. This runs the ‘check’ phase, and must be overridden for each subclass.

Intransitive actions don’t generally have to do anything in the ‘check’ phase, since they can simply do any necessary checks in the ‘execute’ phase that runs immediately after ‘check’. This phase is separated out from ‘execute’ mostly for the benefit of transitive actions, where the ‘check’ phase gives the involved objects a chance to object to the action.

checkPreConditions (allowImplicit)

action.t[2292]

Check any pre-conditions for the action.

This should check all of the conditions that must be met for the action to proceed. If any pre-condition can be met by running an implicit command first, that implicit command should be executed here. If any pre-condition cannot be met, this routine should notify the actor and throw an ExitSignal.

Returns true if any implicit commands are executed, nil if not. Implicit commands can only be attempted if allowImplicit is true; if this is nil, a precondition must simply fail (by displaying an appropriate failure report and using ‘exit’) without attempting an implicit command if its assertion does not hold.

checkRemapping ( )

action.t[1851]

Check for remapping the action. This should check with each resolved object involved in the command to see if the object wants to remap the action to a new action; if it does, the object must replace the current action (using replaceAction or equivalent). Note that replacing the action must use ‘exit’ to terminate the original action, so this will never return if remapping actually does occur.

combineRemappedVerifyResults (lst, role)

action.t[2520]

Combine any remapped verify results in the given verify result list. We will remove any result that was remapped to a different object if and only if the target of the remapping appears in the list and has the same results as the remapped original. When objects are remapped in this fashion, they become effectively equivalent for the purposes of this command, so we don’t have to distinguish between them for disambiguation or defaulting purposes.

createActionFrom (orig)

action.t[275]

Create an instance of this action based on another action. We’ll copy the basic properties of the original action.

createActionInstance ( )

action.t[235]

Create an instance of this action, for use by a recursive or programmatically-generated command.

The generic actions defined in the library are always subclassed by language-specific library modules, because the language modules have to define the grammar rules for the verbs - we can’t define the grammar rules generically because the verbs wouldn’t be reusable for non-English translations if we did. As a result, library code referring to one of the library verbs by name, say TakeAction, doesn’t get a language-specific subclass of the verb, but just gets the language-independent base class.

However, to make full use of an Action object in a recursive command, we do need a final language-specific subclass - without this, we won’t be able to generate text describing the command, for example. This method bridges this gap by finding a suitable language-specific subclass of the given action, then creating an instance of that subclass rather than an instance of the base class.

By default, we’ll take any subclass of this action that is itself a class. However, if any subclass has the property defaultForRecursion set to true, we’ll use that class specifically - this lets the language module designate a particular subclass to use as the default for recursive commands, which might be desirable in cases where the language module defines more than one subclass of an action.

createTopicQualifierResolver (issuingActor, targetActor)

action.t[2951]

Create a topic qualifier resolver. This type of resolver is used for qualifier phrases (e.g., possessives) within topic phrases within objects of this verb. Topics *usually* only apply to TopicActionBase subclasses, but not exclusively: action remappings can sometimes require a topic phrase from one action to be resolved in the context of another action that wouldn’t normally involve a topic phrase. That’s why this is needed on the base Action class.

doAction (issuingActor, targetActor, targetActorPhrase, countsAsIssuerTurn)

action.t[1097]

Perform this action. Throughout execution of the action, the global parser variables that specify the current actor and action are valid.

doActionOnce ( )

action.t[1326]

Execute the action for a single set of objects. This runs the full execution sequence for the current set of objects.

Subclasses generally won’t override this method, but will instead override the methods that implement the individual steps in the execution sequence.

execAction ( )

action.t[1802]

Execute the action. This must be overridden by each subclass.

Intransitive actions must do all of their work in this routine. In most cases, transitive actions will delegate processing to one or more of the objects involved in the command - for example, most single-object commands will call a method in the direct object to carry out the command.

filterAmbiguousWithVerify (lst, requiredNum, verProp, preCondProp, remapProp, whichObj, np)

action.t[2574]

Filter an ambiguous object list using the given verification method. We call the given verification method on each object, noting the result, then find the best (most logical) result in the list. We reduce the set to the objects that all have the same best value - everything else in the list is less logical, so we discard it. This gives us a set of objects that are all of equivalent likelihood and all of the best likelihood of all the objects.

This is the typical way that we disambiguate a list of objects, but this is merely a service routine, so individual actions can choose to use this or other mechanisms as appropriate.

filterFacets (lst)

action.t[2776]

Filter out redundant facets of the same object. The various facets of an object are equivalent to the parser. An object that has multiple facets is meant to appear to be one game world object from the perspective of a character - the multiple facet objects are an internal implementation detail.

filterPluralWithVerify (lst, verProp, preCondProp, remapProp, whichObj, np)

action.t[2738]

Filter a plural list with a verification method. We’ll reduce the list to the subset of objects that verify as logical, if there are any. If there are no logical objects in the list, we’ll simply return the entire original list.

finishResolveList (lst, whichObj, np, requiredNum)

action.t[2411]

Finish the result list for a resolved noun phrase. This is used just before disambiguation. We’ll give each object in the list a chance to filter the list with filterResolveList, and we’ll note the noun phrase we matched in each resolved object.

getAnaphoricBinding (typ)

action.t[960]

Get the list of bindings for an anaphoric pronoun - this is a pronoun that refers back to an earlier noun phrase in the same sentence, such as HIMSELF in ASK BOB ABOUT HIMSELF. These obviously make no sense for verbs that take one (or zero) objects, since there’s no earlier phrase to refer back to; these should return nil to indicate that an anaphoric pronoun is simply nonsensical in such a context. Actions of two or more objects should return a list of objects for the preceding noun phrase.

Actions of two or more objects should set this if possible to the resolved object list for the previous noun phrase, as a ResolveInfo list.

The tricky part is that some actions will resolve noun phrases in a different order than they appear in the actual command grammar; similarly, it’s also possible that some non-English languages use cataphoric pronouns (i.e., pronouns that refer to noun phrases that appear later in the sentence). To allow for these cases, return an empty list here if a binding is grammatically possible but not yet available because of the resolution order, and note internally that the parser asked us for an anaphoric binding. Afterwards, the action’s resolver method must go back and perform *another* resolve pass on the noun phrase production that requested the anaphor binding.

‘typ’ is the PronounType specifier for the corresponding ordinary pronoun. For ‘himself’, for example, typ will be PronounHim.

getCurrentObjects ( )

action.t[2266]

Get the list of all of the objects (direct object, indirect object, and any additional objects for actions with three or more object roles) involved in the current execution. This is valid only during a call to doActionOnce(), since that’s the only time a particular set of objects are selected for the action.

By default, an action has no objects roles at all, so we’ll just return an empty list.

getDefaultWithVerify (resolver, verProp, preCondProp, remapProp, whichObj, np)

action.t[2838]

Get a default object using the given verification method. We’ll start with the ‘all’ list, then use the verification method to reduce the list to the most likely candidates. If we find a unique most likely candidate, we’ll return a ResolveInfo list with that result; otherwise, we’ll return nothing, since there is no suitable default.

getEnteredVerbPhrase ( )

action.t[718]

Get the actual verb phrase the player typed in to generate this Action, expressed in a canonical format. The canonical format consists of the lower-case version of all of the actual text the player typed, but with each noun phrase replaced by a standard placeholder token describing the slot. The placeholder tokens are ‘(dobj)’ for the direct object, ‘(iobj)’ for the indirect object, ‘(literal)’ for a literal text phrase, and ‘(topic)’ for a topic phrase.

For example, if the player typed PUT BOOK AND PENCIL IN BOX, the canonical phrasing we return would be “put (dobj) in (iobj)”.

getImplicitPhrase (ctx)

en_us.t[8303]

Return a phrase describing the action performed implicitly, as a participle phrase. ‘ctx’ is an ImplicitAnnouncementContext object describing the context in which we’re generating the phrase.

This comes in two forms: if the context indicates we’re only attempting the action, we’ll return an infinitive phrase (“open the box”) for use in a larger participle phrase describing the attempt (“trying to…”). Otherwise, we’ll be describing the action as actually having been performed, so we’ll return a present participle phrase (“opening the box”).

getInfPhrase ( )

en_us.t[8320]

Get the infinitive form of the action. We are NOT to include the infinitive complementizer (i.e., “to”) as part of the result, since the complementizer isn’t used in all contexts in which we might want to use the infinitive; for example, we don’t want a “to” in phrases involving an auxiliary verb, such as “he can open the box.”

getMatchForRole (role)

action.t[856]

get the match tree for the noun phrase in the given role

getMessageParam (objName)

action.t[558]

Get a message parameter object for the action. Each action subclass defines this to return its objects according to its own classifications. The default action has no objects, but recognizes ‘actor’ as the current command’s actor.

getNotifyTable ( )

action.t[2175]

Get the list of objects to notify before or after the action has been performed.

getObjectForRole (role)

action.t[853]

get the resolved object in a given role

getObjPreCondDescList (obj, preCondProp, checkArg, whichObj)

action.t[2314]

Get a precondition descriptor list for the given object. This returns a list of PreCondDesc objects that wrap the preconditions for the given object in the given role for this action.

getObjPreConditions (obj, preCondProp, whichObj)

action.t[2060]

Get the precondition list for an object. whichObj is the object role of the object whose preconditions we’re retrieving; this is nil if we’re looking for action-level preconditions.

getObjResponseProd (resolver)

action.t[2975]

Get the missing object response production for a given resolver role. (The base action doesn’t have any objects, so there’s no such thing as a missing object query.)

getOriginalAction ( )

action.t[391]

Get the “original” action. If I’m a replacement or nested action, this returns the original main action of which I’m a part, for reporting pruposes.

It’s important to note that an implied action does NOT count as a nested or replacement action for the purposes of this method. That is, if a command A triggers an implied action B, which triggers a nested action C, and then after that command A itself triggers a nested action D, then

A.getOriginalAction -> A
B.getOriginalAction -> B (B is implied, not nested)
C.getOriginalAction -> C (C is nested within B)
D.getOriginalAction -> A (D is nested within A)

The purpose of the original action is to tell us, mainly for reporting purposes, what we’re really trying to do with the action. This allows reports to hide the internal details of how the action is carried out, and instead say what the action was meant to do from the player’s perspective.

getOrigTokenList ( )OVERRIDDEN

action.t[2924]

A synthesized Action (one that’s generated by something other than parsing a command line, such as an event action or nested action) won’t have a parser token list attached to it. If we’re asked to get the token list, we need to check for this possibility. If we don’t have a token list, but we do have a parent action, we’ll defer to the parent action. Otherwise, we’ll simply return nil.

getOtherObjectRole (role)

action.t[850]

Get the “other object” role - this is the complement of the given object role for a two-object action, and is used to determine the real role of the special OtherObject placeholder in a remapTo(). This is only meaningful with actions of exactly two objects.

getParticiplePhrase ( )

en_us.t[8359]

Get a string describing the full action in present participle form, using the current command objects: “taking the watch”, “putting the book on the shelf”

getPreCondDescList ( )

action.t[2303]

Get the precondition descriptor list for the action. For the base intransitive action type, this simply returns the list of conditions for the action itself.

getPreCondPropForRole (role)

action.t[865]

get the ‘preCond’ property for a given object role

getPredicate ( )

action.t[811]

Get the grammar match tree object for the predicate that was used to enter this command. By default, if we have an original action, we return the original action; otherwise we just return ‘self’.

Language libraries must override this to return the original match tree object if Actions are separate from predicate match trees.

(The ‘predicate’ is simply the grammar match tree object for the entire verb phrase from the player’s actual command entry text that matched this Action. For example, in “BOB, TAKE BOX”, the predicate is the match tree for the “TAKE BOX” part. In “BOB, TAKE BOX AND GO NORTH”, the predicate for the Take action is still the “TAKE BOX” part. For “BOB, TAKE BOX AND BOOK AND GO NORTH”, the predicate for the Take action is “TAKE BOX AND BOOK” - the full verb phrase includes any multiple-object lists in the original command.)

getPronounOverride (typ)

action.t[992]

Get any special pronoun override in effect for the action, as set via setPronounOverride(). This looks in our own override table for a definition; then, if we have no override of our own, we ask our parent action if we have one, then our original action.

getQuestionInf (which)

en_us.t[8345]

Get the root infinitive form of our verb phrase as part of a question in which one of the verb’s objects is the “unknown” of the interrogative. ‘which’ is one of the role markers (DirectObject, IndirectObject, etc), indicating which object is the subject of the interrogative.

For example, for the verb UNLOCK <dobj> WITH <iobj>, if the unknown is the direct object, the phrase we’d return would be “unlock”: this would plug into contexts such as “what do you want to unlock.” If the indirect object is the unknown for the same verb, the phrase would be “unlock it with”, which would plug in as “what do you want to unlock it with”.

Note that we are NOT to include the infinitive complementizer (i.e., “to”) as part of the phrase we generate, since the complementizer isn’t used in some contexts where the infinitive conjugation is needed (for example, “what should I <infinitive>”).

getRemappedFrom ( )

action.t[430]

no description available

getRemapPropForRole (role)

action.t[871]

get the ‘remap’ property for a given object role

getResolvedObjList (which)

action.t[1686]

get the list of resolved objects in the given role

getResolveInfo (obj, oldRole)

action.t[883]

Get the ResolveInfo for the given object in the current command. Since we don’t have any objects at all, we’ll simply return a new ResolveInfo wrapping the given object. ‘cur’ is the object we’re looking for, and ‘oldRole’ is the role the object previously played in the action.

getRoleFromIndex (idx)

action.t[842]

Get the object “role” identifier for the given index. This returns the identifier (DirectObject, IndirectObject, etc.) for the object at the given slot index, as used in setResolvedObjects(). The first object is at index 1.

getSimpleSynonymRemap (obj, role, remapProp)

action.t[451]

Get the “simple synonym” remapping for one of our objects, if any. ‘obj’ is the resolved object to remap, and ‘role’ is the object role identifier (DirectObject, IndirectObject, etc). ‘remapProp’ is the remapping property for the role; this is simply the result of our getRemapPropForRole(role), but we ask the caller to pass this in so that it can be pre-computed in cases where we’ll called in a loop.

A simple synonym remapping is a remapTo that applies the same verb to a new object in the same role. For example, if we remap OPEN DESK to OPEN DRAWER, then the drawer is the simple synonym remapping for the desk in an OPEN command. A remapping is considered a simple synonym remapping only if we’re remapping to the same action, AND the new object is in the same action role as the original object was.

If there’s no simple synonym remapping, we’ll return nil.

getSortedVerifyResults (lst, verProp, preCondProp, remapProp, whichObj, np, requiredNum)

action.t[2432]

Get a list of verification results for the given ResolveInfo objects, sorted from best to worst. Each entry in the returned list will be a VerifyResultList object whose obj_ property is set to the ResolveInfo object for which it was generated.

getVerbPhrase (inf, ctx)

en_us.t[8375]

Get the full verb phrase in either infinitive or participle format. This is a common handler for getInfinitivePhrase() and getParticiplePhrase().

‘ctx’ is a GetVerbPhraseContext object, which lets us keep track of antecedents when we’re stringing together multiple verb phrases. ‘ctx’ can be nil if the verb phrase is being used in isolation.

getVerifyPropForRole (role)

action.t[859]

get the ‘verify’ property for a given object role

initTentative (issuingActor, targetActor, whichObj)

action.t[1837]

Initialize tentative resolutions for other noun phrases besides the one indicated.

isConversational (issuingActor)

action.t[703]

Flag: this is a “conversational” command, as opposed to an order. When this type of command is addressed to another character, it doesn’t ask the other character to do anything, but rather engages the other character in conversation. Examples:

Bob, hello
Bob, goodbye
Bob, tell me about the planet
Bob, yes
Bob, no

(“Tell me about…” is a little different from the others. We treat it as conversational because it means the same thing as “ask Bob about…”, which we consider conversational because it would be rendered in real life as a question. In other words, the action involves the issuing actor stating the question, which means that issuing actor is the one doing the physical work of the action. “Tell me about…” could be seen as an order, but it seems more appropriate to view it as simply an alternative way of phrasing a question.)

The issuing actor is passed as a parameter because some actions are conversational only in some cases; “tell me about the planet” is conversational, but “tell Bill about the planet” isn’t, since the latter doesn’t ask Bob a question but orders Bob to talk to Bill.

When the issuing actor and target actor are the same, this is irrelevant. The purpose of this is to distinguish orders given to another character from conversational overtures directed to the other character, so if the command is coming from the player and bound for the player character, there’s obviously no conversation going on.

Note also that, contrary to what one might think at first glance, a command like ASK ABOUT is NOT conversational; it’s a command to ask someone about something, and isn’t itself a conversational overture. The act of asking is itself a conversational overture, but the asking is the *result* of the command, not the command itself. An action is only conversational if the action itself is a conversational overture. So, “BOB, HELLO” is conversational; “BOB, ASK BILL ABOUT COMPUTER” is not, because it orders Bob to do something.

isNestedIn (action)

action.t[337]

Determine if I’m nested within the given action. Returns true if the given action is my parent action, or if my parent action is nested within the given action.

isPartOf (action)

action.t[407]

Determine if this action is “part of” the given action. I’m part of the given action if I am the given action, or the given action is my “original” action, or my original action is part of the given action.

isRemapped ( )

action.t[429]

determine if I’m remapped, and get the original action if so

makeResolveInfo (val)

action.t[1024]

wrap an object with a ResolveInfo

makeResolveInfoList (val)

action.t[1039]

Convert an object or list of objects to a ResolveInfo list

maybeAnnounceDefaultObject (lst, which, allResolved)

action.t[1700]

Announce a defaulted object list, if appropriate. We’ll announce the object if we have a single object in the given resolution list, it was defaulted, and it hasn’t yet been announced.

maybeAnnounceImplicit ( )

action.t[1540]

Maybe announce the action as an implied action.

maybeAnnounceMultiObject (info, numberInList, whichObj)

action.t[1643]

announce a multi-action object, if appropriate

noMatch (msgObj, actor, txt)

en_us.t[8405]

Show the “noMatch” library message. For most verbs, we use the basic “you can’t see that here”. Verbs that are mostly used with intangible objects, such as LISTEN TO and SMELL, might want to override this to use a less visually-oriented message.

notifyBeforeAfter (prop)

action.t[2160]

Call the beforeAction or afterAction method for each object in the notification list.

objListPronoun (objList)

en_us.t[8183]

Return a string with the appropriate pronoun (objective form) for a list of object matches, with the given resolved cardinality. This list is a list of ResolveInfo objects.

preAnnounceActionObject (info, mainList, whichObj)

action.t[1744]

“Pre-announce” a common object for a command that might involve iteration over other objects. For example, in “put all in box”, the box is common to all iterations of the command, so we would want to preannounce it, if it needs to be announced at all, before the iterations of the command.

We’ll announce the object only if it’s marked as defaulted or unclearly disambiguated, and then only if the other list will be announcing its objects as multi-action objects. However, we do not pre-announce anything for a remapped action, because we’ll show the full action description for each individually announced object, so we don’t need or want a separate announcement for the group.

Returns true if we did any pre-announcing, nil otherwise. If we return true, the caller should not re-announce this object during the iteration, since our pre-announcement is common to all iterations.

recalcSenseContext ( )

action.t[1531]

Reset the message generation context for a sense change. This can be called when something substantial happens in the midst of a command, and we might need different message generation rules before and after the change. For example, this is used when a non-player character moves from one location to another, because the NPC might want to generate leaving and arriving messages differently in the two locations.

repeatAction (lastTargetActor, lastTargetActorPhrase, lastIssuingActor, countsAsIssuerTurn)

action.t[178]

Repeat the action, for an AGAIN command.

resetAction ( )

action.t[169]

Reset the action in preparation for re-execution. This should discard any scoped context from any past execution of the command, such as cached scope information.

resolveAction (issuingActor, targetActor)

en_us.t[8149]

In the English grammar, all ‘predicate’ grammar definitions (which are usually made via the VerbRule macro) are associated with Action match tree objects; in fact, each ‘predicate’ grammar match tree is the specific Action subclass associated with the grammar for the predicate. This means that the Action associated with a grammar match is simply the grammar match object itself. Hence, we can resolve the action for a ‘predicate’ match simply by returning the match itself: it is the Action as well as the grammar match.

This approach (‘grammar predicate’ matches are based on Action subclasses) works well for languages like English that encode the role of each phrase in the word order of the sentence.

Languages that encode phrase roles using case markers or other devices tend to be freer with word order. As a result, ‘predicate’ grammars for such languages should generally not attempt to capture all possible word orderings for a given action, but should instead take the complementary approach of capturing the possible overall sentence structures independently of verb phrases, and plug in a verb phrase as a component, just like noun phrases plug into the English grammar. In these cases, the match objects will NOT be Action subclasses; the Action objects will instead be buried down deeper in the match tree. Hence, resolveAction() must be defined on whatever class is used to construct ‘predicate’ grammar matches, instead of on Action, since Action will not be a ‘predicate’ match.

resolvedObjectsInScope ( )

action.t[925]

Check that the resolved objects are all in scope. Returns true if so, nil if not.

This routine is meant for use only for actions built programmatically using setResolvedObjects(). In particular, we assume that we have only one object in each slot. For normal parser-built actions, this check isn’t necessary, because the parser only resolves objects that are in scope in the first place.

runBeforeNotifiers ( )

action.t[1507]

Run the “before” notifiers: this calls beforeAction on everything in scope, and calls roomBeforeAction on the actor’s containers.

saveActionForAgain (issuingActor, countsAsIssuerTurn, targetActor, targetActorPhrase)

action.t[1065]

If the command is repeatable, save it for use by ‘again’.

setCurrentObjects (lst)

action.t[2275]

Set the current objects. This takes a list of the same form returned by getCurrentObjects().

setImplicit (msgProp)

action.t[299]

Mark the command as implicit. ‘msgProp’ is the property (of gLibMessages) to use to announce the implicit command.

setMessageParam (objName, obj)

action.t[590]

Define an extra message-specific parameter. Message processors can use this to add their own special parameters, so that they can refer to parameters that aren’t involved directly in the command. For example, a message for “take <dobj>” might want to refer to the object containing the direct object.

setMessageParams ([lst])

action.t[607]

For convenience, this method allows setting any number of name/value pairs for message parameters.

setNested ( )

action.t[326]

Mark the command as nested, noting the parent action (which we take as the global current action).

setObjectMatches ( )

action.t[913]

Explicitly set the object match trees. This sets the pre-resolved production match trees. The arguments are given in the order of their roles in the action, using the same order that setResolvedObjects() uses.

The arguments to this routine can either be match tree objects, which we’ll plug into our grammar tree in the respective roles exactly as given; or they can be ResolveInfo objects giving the desired resolutions, in which case we’ll build the appropriate kind of PreResolvedProd for each one. The types can be freely mixed.

setOriginalAction (action)

action.t[363]

Set the “original” action. An action with an original action is effectively part of the original action for the purposes of its reported results.

An action has an original action if it’s a nested or replacement action for an action.

setPronounOverride (typ, val)

action.t[976]

Set a special pronoun override. This creates a temporary pronoun definition, which lasts as long as this action (and any nested actions). The temporary definition overrides the normal meaning of the pronoun.

One example of where this is useful is in global action remapping cases where the target actor changes in the course of the remapping. For example, if we remap BOB, GIVE ME YOUR BOOK to ASK BOB FOR YOUR BOOK, the YOUR qualifier should still refer to Bob even though the command is no longer addressing Bob directly. This routine can be used in this case to override the meaning of ‘you’ so that it refers to Bob.

setRemapped (orig)

action.t[426]

Mark the action as “remapped.” This indicates that the action was explicitly remapped to a different action during the remap() phase.

setResolvedObjects ( )

action.t[898]

Explicitly set the resolved objects. This should be overridden in each subclass for the number of objects specific to the action (a simple transitive action takes one argument, an action with both a direct and indirect object takes two arguments, and so on). The base action doesn’t have any objects at all, so this takes no arguments.

This method is used to set up an action to be performed programmatically, rather than based on parsed input. Since there’s no parsed input in such cases, the objects are specified directly by the programmatic caller.

spPrefix (str)

en_us.t[8414]

add a space prefix/suffix to a string if the string is non-empty

spSuffix (str)

en_us.t[8415]

no description available

synthMessageParam (obj)

action.t[618]

Synthesize a global message parameter name for the given object. We’ll store the association and return the synthesized name.

verifyAction ( )

action.t[1824]

Verify the action. Action subclasses with one or more objects should call object verification routines here. Returns a VerifyResultList with the results, or nil if there are no verification results at all. A nil return should be taken as success, not failure, because it means that we found no objection to the command.

verifyHandlersExist (objList, propList, result)

action.t[2120]

Verify that some sort of handling for this action is defined on at least one of the given objects. If we have no handlers at all definfed, we’ll add an “illogical” status to the verification results to indicate that the action is not defined on this object. This check provides a last resort for verbs with no handling at all defined on the involved objects, to ensure that the verb won’t go completely unprocessed.

Each entry in objList is an object involved in the action. For each entry in objList, there must be *THREE* entries in propList: a verify property, a check property, and an action property. If any of these three properties is defined on the corresponding object, we’ll allow the command to proceed. If we can find none of the given handler properties on any of our objects, we’ll add an “illogical” verify result.

whatObj (which)

en_us.t[8158]

Return the interrogative pronoun for a missing object in one of our object roles. In most cases, this is simply “what”, but for some actions, “whom” is more appropriate (for example, the direct object of “ask” is implicitly a person, so “whom” is most appropriate for this role).

whatTranslate (txt)

en_us.t[8169]

Translate an interrogative word for whatObj. If the word is ‘whom’, translate to the library message for ‘whom’; this allows authors to use ‘who’ rather than ‘whom’ as the objective form of ‘who’, which sounds less stuffy to many people.

withVerifyResults (resultsSoFar, obj, func)

action.t[1861]

Invoke a callback with a verify results list in gVerifyResults, using the existing results list or creating a new one if there is no existing one. Returns the results list used.

zeroActionTime ( )

action.t[1308]

Zero the action time in this action and any parent actions. This should be used when a nested replacement action is to completely take over the time-keeping responsibility for the entire turn; all containing actions in this case are to take zero time, since the nested action is the only part of the turn that will count for timing.

TADS 3 Library Manual
Generated on 5/16/2013 from TADS version 3.1.3