The root production to use to parse missing indirect object responses. By default, this is singleNoun, but individual actions can override this as appropriate.

Note that language modules might want to override this to allow for special responses. For example, in English, most verbs will want to override this with a specialized production that allows the appropriate preposition in the response.

Determine which object to call first for action processing. By default, we execute in the same order as we resolve, but this can be overridden if necessary.

current indirect object being executed

the full ResolveInfo associated with iobjCur_

the indirect object list

the predicate grammar must assign the indirect object production tree to iobjMatch

my cached indirect object resolver

For VerbRules: does this verb rule have a prepositional or structural phrasing of the direct and indirect object slots? That is, are the object slots determined by a prepositional marker, or purely by word order? For most English verbs with two objects, the indirect object is marked by a preposition: GIVE BOOK TO BOB, PUT BOOK IN BOX. There are a few English verbs that don't include any prespositional markers for the objects, though, and assign the noun phrase roles purely by the word order: GIVE BOB BOOK, SHOW BOB BOOK, THROW BOB BOOK. We define these phrasings with separate verb rules, which we mark with this property.

We use this in ranking verb matches. Non-prepositional verb structures are especially prone to matching where they shouldn't, because we can often find a way to pick out words to fill the slots in the absence of any marker words. For example, GIVE GREEN BOOK could be interpreted as GIVE BOOK TO GREEN, where GREEN is assumed to be an adjective-ending noun phrase; but the player probably means to give the green book to someone who they assumed would be filled in as a default. So, whenever we find an interpretation that involves a non-prespositional phrasing, we'll use this flag to know we should be suspicious of it and try alternative phrasing first.

Most two-object verbs in English use prepositional markers, so we'll set this as the default. Individual VerbRules that use purely structural phrasing should override this.

The last object list we resolved. We keep track of this so that we can provide it as the anaphoric binding, if an anaphor binding is requested.

Flag: we have been asked for an anaphoric binding, but we don't have a binding available. We'll check this after resolving the first-resolved noun phrase so that we can go back and re-resolve it again after resolving the other noun phrase.

Flag: omit the indirect object in a query for a missing direct object. For many verbs, if we already know the indirect object and we need to ask for the direct object, the query sounds best when it includes the indirect object: "what do you want to put in it?" or "what do you want to take from it?". This is the default phrasing.

However, the corresponding query for some verbs sounds weird: "what do you want to dig in with it?" or "whom do you want to ask about it?". For such actions, this property should be set to true to indicate that the indirect object should be omitted from the queries, which will change the phrasing to "what do you want to dig in", "whom do you want to ask", and so on.

we have a direct and indirect object

Action-remap properties for the indirect object. By convention, the remapper properties are named remapDobjAction and remapIobjAction, for the direct and indirect objects, respectively, where Action is replaced by the root name of the action.

Resolution order - returns DirectObject or IndirectObject to indicate which noun phrase to resolve first in resolveNouns(). By default, we'll resolve the indirect object first, but individual actions can override this to resolve in a non-default order.

Empty phrase resolution order. This is similar to the standard resolution order (resolveFirst), but is used only when both the direct and indirect objects are empty phrases.

When both phrases are empty, we will either use a default or prompt interactively for the missing phrase. In most cases, it is desirable to prompt interactively for a missing direct object first, regardless of the usual resolution order.

The tentative direct and indirect object lists. A tentative list is available for the later-resolved object while resolving the earlier-resolved object.

Verification and action properties for the indirect object. By convention, the verification method for the indirect object of a two-object action is verIobjXxx; the check method is checkIobjXxx; and the action method is actionIobjXxx.

announce all defaulted objects

announce a default object used with this action

Can the indirect object potentially resolve to the given simulation object? This only determines if the object is a *syntactic* match, meaning that it can match at a vocabulary and grammar level. This doesn't test it for logicalness or check that it's an otherwise valid resolution.

Check the command.

For a two-object action, this first calls the catch-all 'check' methods (the dobjFor(Default) and dobjFor(All) methods) on the two objects (indirect object first), then calls the 'check' methods for this specific action (direct object first).

Check for remapping

Copy one tentative object list to the other. This is useful when an object's verifier for one TIAction wants to forward the call to the other object verifier for a different TIAction.

Create an instance of this action for retrying a given single-object action with a missing indirect object.

Create our indirect object resolver. By default, we'll use a basic indirect object resolver.

Execute the action. We'll run through the execution sequence once for each resolved object in our direct or indirect object list, depending on which one is the list and which one is the singleton.

Execute the command.

filter an ambiguous indirect object noun phrase

filter a plural phrase

Resolve 'all' for the indirect object. By default, we'll return everything in the scope list.

Get the anaphoric binding for the noun phrase we're currently resolving.

Get the list of active objects. We have a direct and indirect object.

get the default indirect object

get the current indirect object being executed

get the number of direct objects

get the object resolution flags for the indirect object

get the full ResolveInfo associated with the current indirect object

get our indirect object resolver, or create one if we haven't already cached one

get the original token list of the current indirect object phrase

get the original words (as a list of strings) of the current iobj

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

Get a message parameter object for the action. We define 'dobj' as the direct object and 'iobj' as the indirect object, in addition to any inherited targets.

get the resolved object in a given role

get the missing object response production for a given role

Get the pronoun for the message object in the given role.

get the OtherObject role for the given role

get the precondition descriptor list for the action

get the 'preCond' property for a given object role

show the verb's basic infinitive form for an interrogative

get the 'remap' property for a given object role

get the list of resolved indirect objects

get the list of resolved objects in the given role

get the ResolveInfo for the given resolved object

get an object role

Get the tentative direct/indirect object resolution lists. A tentative list is available for the later-resolved object while resolving the earlier-resolved object.

get the verb phrase in infinitive or participle form

Get the verb phrase for a two-object (dobj + iobj) phrasing. This is a class method, so that it can be reused by unrelated (i.e., non-TIAction) classes that also use two-object syntax but with other internal structures. This is the two-object equivalent of TAction.getVerbPhrase1().

get the 'verify' property for a given object role

Initialize the action for retrying with a missing direct object.

If we're trying a TIAction, we can only be coming from a TAction (since that's the only kind of original action that can turn into a two-object, at least in the base library). That means the original action already has a direct object. Now, since we're asking for a MISSING direct object, the only possibility is that the original action's direct object is our INDIRECT object. For example: SWEEP WITH BROOM is turning into SWEEP <what> WITH BROOM.

Initialize the action for retrying with a missing indirect object.

We can only be coming from a TAction, so the TAction will have a direct object already. Simply copy that as our own direct object. For example: UNLOCK DOOR is turning into UNLOCK DOOR WITH <what>.

initialize tentative resolutions for other noun phrases

Determine if we need to announce this action when the action was remapped, based on the resolution information for one of our objects. We need to announce a remapped action when either object had unclear disambiguation or was defaulted.

check that the resolved objects are in scope

resolve our noun phrases to objects

Modified in en_us.t[8649]:
resolve noun phrases

Retry an action as a two-object action with an ambiguous indirect object. We'll ask which of the given possible objects is intended.

Retry a single-object action as a two-object action. We'll treat the original action's direct object list as our direct object list, and obtain an indirect object using the normal means (first looking for a default, then prompting the player if we can't find a suitable default). 'orig' is the original single-object action.

This routine terminates with 'exit' if it doesn't throw some other error.

set the current objects

manually set the unresolved object noun phrase match trees

Set the pronoun according to the pronoun type actually used in the input. For example, if we said PUT BOX ON IT, we want IT to continue referring to whatever IT referred to before this command - we specifically do NOT want IT to refer to the BOX in this case.

set a resolved iobj

Manually set the resolved objects. We'll set our direct and indirect objects.

Test to see if askForIobj() would find a default indirect object. Returns true if there's a default, nil if not. If this returns true, then askForIobj() will simply take the default and proceed; otherwise, it will have to actually ask the user for the missing information.

Verify the action.

get the interrogative for one of our objects