An implementation of ResolveResults for normal noun resolution.

class BasicResolveResults :   ResolveResults

Superclass Tree   (in declaration order)


Subclass Tree  


Global Objects  


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 



allow remapping the action

allow making an arbitrary choice among equivalents

no description available

The target and issuing actors for the command being resolved.


allNotAllowed ( )parser.t[4794]

use the basic noMatch handling

ambiguousNounPhrase (keeper, asker, txt, matchList, fullMatchList, scopeList, requiredNum, resolver)parser.t[4927]
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[5542]
there's nothing to do with a literal at this point, since we're not ranking anything

askMissingObject (asker, resolver, responseProd)parser.t[5511]
ask the resolver to supply an implied default object

beginSingleObjSlot ( )parser.t[5633]
we don't care about these right now

beginTopicSlot ( )parser.t[5636]
no description available

canResolveInteractively (action)parser.t[4895]
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[5568]
return the response

endSingleObjSlot ( )parser.t[5634]
no description available

endTopicSlot ( )parser.t[5637]
no description available

filterWithDistinguisher (lst, dist)parser.t[5448]
filter a match list with a specific Distinguisher

getImpliedObject (np, resolver)parser.t[5505]
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[5639]
no description available

insufficientQuantity (txt, matchList, requiredNum)parser.t[5581]
abort with an error

noMatch (action, txt)parser.t[4781]
indicate that we couldn't match the phrase

noMatchForAll ( )parser.t[4800]
show an error

noMatchForAllBut ( )parser.t[4811]
this isn't an error - ignore it

noMatchForListBut ( )parser.t[4817]
show an error

noMatchForLocation (loc, txt)parser.t[4859]
let the (singular) owner object generate the error

noMatchForPossessive (owner, txt)parser.t[4844]
show an error

noMatchForPronoun (typ, txt)parser.t[4823]
show an error

noMatchPossessive (action, txt)parser.t[4788]
show an error

noteActorSpecified ( )parser.t[5644]
we don't care about how many subcommands there are

noteAdjEnding ( )parser.t[5603]
abort with an error

noteBadPrep ( )parser.t[4871]
let the location object generate the error

noteEmptyBut ( )parser.t[4806]
show an error

noteIndefinite ( )parser.t[5608]
we don't care about adjective-ending noun phrases at this point

noteLiteral (txt)parser.t[5534]
try reading an object response

noteMatches (matchList)parser.t[5623]
we don't care about pronouns right now

noteMiscWordList (txt)parser.t[5613]
we don't care about indefinites at this point

noteNounSlots (cnt)parser.t[5653]
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[5628]
we don't care about the matches just now

notePronoun ( )parser.t[5618]
we don't care about unstructured noun phrases at this point

noteWeakPhrasing (level)parser.t[5661]
we don't care about this during execution; it only matters for the ranking process

nothingInLocation (loc)parser.t[4865]
let the location object generate the error

noVocabMatch (action, txt)parser.t[4774]
Results gatherer methods

reflexiveNotAllowed (typ, txt)parser.t[4830]
show an error

setActors (target, issuer)parser.t[4764]
set up the actor parameters

singleObjectRequired (txt)parser.t[5596]
abort with an error

uniqueObjectRequired (txt, matchList)parser.t[5589]
abort with an error

unknownNounPhrase (match, resolver)parser.t[5475]
handle a noun phrase that doesn't match any legal grammar rules for noun phrases

wrongReflexive (typ, txt)parser.t[4837]
show an error

zeroQuantity (txt)parser.t[5574]
abort with an error

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