BasicResolveResults class | parser.t[4743]

An implementation of ResolveResults for normal noun resolution.

`class BasicResolveResults : ResolveResults`

Superclass Tree (in declaration order)

`BasicResolveResults`
`ResolveResults`
`object`

Subclass Tree

`BasicResolveResults`
`ActorResolveResults`
`DisambigResults`

Global Objects

(none)

Summary of Properties

`allowActionRemapping allowEquivalentFiltering issuingActor_ targetActor_`

``

Summary of Methods

`allNotAllowed ambiguousNounPhrase askMissingLiteral askMissingObject beginSingleObjSlot beginTopicSlot canResolveInteractively emptyNounPhrase endSingleObjSlot endTopicSlot filterWithDistinguisher getImpliedObject incCommandCount insufficientQuantity noMatch noMatchForAll noMatchForAllBut noMatchForListBut noMatchForLocation noMatchForPossessive noMatchForPronoun noMatchPossessive noteActorSpecified noteAdjEnding noteBadPrep noteEmptyBut noteIndefinite noteLiteral noteMatches noteMiscWordList noteNounSlots notePlural notePronoun noteWeakPhrasing nothingInLocation noVocabMatch reflexiveNotAllowed setActors singleObjectRequired uniqueObjectRequired unknownNounPhrase wrongReflexive zeroQuantity`

``

Properties

`allowActionRemapping` | `parser.t[5654]`

allow remapping the action

`allowEquivalentFiltering` | `parser.t[5657]`

allow making an arbitrary choice among equivalents

`issuingActor_` | `parser.t[4748]`

no description available

`targetActor_` | `parser.t[4747]`

The target and issuing actors for the command being resolved.

Methods

`allNotAllowed ( )` | `parser.t[4781]`

use the basic noMatch handling

`ambiguousNounPhrase (keeper, asker, txt, matchList, fullMatchList, scopeList, requiredNum, resolver)` | `parser.t[4914]`

Handle an ambiguous noun phrase. We'll first check to see if we can find a Distinguisher that can tell at least some of the matches apart; if we fail to do that, we'll just pick the required number of objects arbitrarily, since we have no way to distinguish any of them. Once we've chosen a Distinguisher, we'll ask the user for help interactively if possible.

`askMissingLiteral (action, which)` | `parser.t[5529]`

there's nothing to do with a literal at this point, since we're not ranking anything

`askMissingObject (asker, resolver, responseProd)` | `parser.t[5498]`

ask the resolver to supply an implied default object

`beginSingleObjSlot ( )` | `parser.t[5620]`

we don't care about these right now

`beginTopicSlot ( )` | `parser.t[5623]`

no description available

`canResolveInteractively (action)` | `parser.t[4882]`

Service routine - determine if we can interactively resolve a need for more information. If the issuer is the player, and the target actor can talk to the player, then we can resolve a question interactively; otherwise, we cannot.

We can't interactively resolve a question if the issuer isn't the player, because there's no interactive user to prompt for more information.

We can't interactively resolve a question if the target actor can't talk to the player, because the question to the player would be coming out of thin air.

`emptyNounPhrase (resolver)` | `parser.t[5555]`

return the response

`endSingleObjSlot ( )` | `parser.t[5621]`

no description available

`endTopicSlot ( )` | `parser.t[5624]`

no description available

`filterWithDistinguisher (lst, dist)` | `parser.t[5435]`

filter a match list with a specific Distinguisher

`getImpliedObject (np, resolver)` | `parser.t[5492]`

If we didn't find any unknown words, it means that they used a word that's in the dictionary in a way that makes no sense to us. Simply return an empty list and let the resolver proceed with its normal handling for unmatched noun phrases.

`incCommandCount ( )` | `parser.t[5626]`

no description available

`insufficientQuantity (txt, matchList, requiredNum)` | `parser.t[5568]`

abort with an error

`noMatch (action, txt)` | `parser.t[4768]`

indicate that we couldn't match the phrase

`noMatchForAll ( )` | `parser.t[4787]`

show an error

`noMatchForAllBut ( )` | `parser.t[4798]`

this isn't an error - ignore it

`noMatchForListBut ( )` | `parser.t[4804]`

show an error

`noMatchForLocation (loc, txt)` | `parser.t[4846]`

let the (singular) owner object generate the error

`noMatchForPossessive (owner, txt)` | `parser.t[4831]`

show an error

`noMatchForPronoun (typ, txt)` | `parser.t[4810]`

show an error

`noMatchPossessive (action, txt)` | `parser.t[4775]`

show an error

`noteActorSpecified ( )` | `parser.t[5631]`

we don't care about how many subcommands there are

`noteAdjEnding ( )` | `parser.t[5590]`

abort with an error

`noteBadPrep ( )` | `parser.t[4858]`

let the location object generate the error

`noteEmptyBut ( )` | `parser.t[4793]`

show an error

`noteIndefinite ( )` | `parser.t[5595]`

we don't care about adjective-ending noun phrases at this point

`noteLiteral (txt)` | `parser.t[5521]`

try reading an object response

`noteMatches (matchList)` | `parser.t[5610]`

we don't care about pronouns right now

`noteMiscWordList (txt)` | `parser.t[5600]`

we don't care about indefinites at this point

`noteNounSlots (cnt)` | `parser.t[5640]`

we don't care about this during execution - it only matters for determining the strength of the command during the ranking process

`notePlural ( )` | `parser.t[5615]`

we don't care about the matches just now

`notePronoun ( )` | `parser.t[5605]`

we don't care about unstructured noun phrases at this point

`noteWeakPhrasing (level)` | `parser.t[5648]`

we don't care about this during execution; it only matters for the ranking process

`nothingInLocation (loc)` | `parser.t[4852]`

let the location object generate the error

`noVocabMatch (action, txt)` | `parser.t[4761]`

Results gatherer methods

`reflexiveNotAllowed (typ, txt)` | `parser.t[4817]`

show an error

`setActors (target, issuer)` | `parser.t[4751]`

set up the actor parameters

`singleObjectRequired (txt)` | `parser.t[5583]`

abort with an error

`uniqueObjectRequired (txt, matchList)` | `parser.t[5576]`

abort with an error

`unknownNounPhrase (match, resolver)` | `parser.t[5462]`

handle a noun phrase that doesn't match any legal grammar rules for noun phrases

`wrongReflexive (typ, txt)` | `parser.t[4824]`

show an error

`zeroQuantity (txt)` | `parser.t[5561]`

abort with an error

TADS 3 Library Manual
Generated on 8/21/2012 from TADS version 3.1.2