/* asktell.t: ASK/TELL-based conversation system for TADS
* V1.0
* Suzanne Skinner, 1999, Public Domain
* [email protected]
*
* This file implements a topic-based ask/tell system similar to that used
* used by WorldClass. It also implements information sources (i.e. things
* that let you look up information), since they are a simple and obvious
* addition. It requires TADS 2.4 at minimum (since it uses 2.4's new
* disambiguation hook, disambigXobj). Preferably, you should use a patched
* or later version of TADS, since 2.4 has a glitch which will cause
* disambiguation questions to look odd.
*
* To use asktell.t, include it after adv.t in your main source file. See
* the comments in the source below, especially for the superclasses topic,
* ioTopicVerb, and movableActor, to learn how to implement conversations
* using this library.
*
* This file uses #pragma C+, but sets back to #pragma C- at the end.
*
* Features:
*
*   + Full disambiguation: If you "ask so-and-so about tree", and there
*     are two different trees you might be asking about, the game will
*     respond with a disambiguation question: just as with other verbs.
*
*   + Topic-based: Indirect objects for ASK/TELL are scoped to allow
*     topics only. Non-topic objects will never show up in disambiguation
*     questions.
*
*   + Knowledge-based: A topic may be known or unknown at a given time.
*     Unknown topics will also never show up in disambiguation questions.
*
*   + Mimesis-preserving: If the player uses vocabulary that doesn't match
*     any topics, the npc's "disavow" property will be output, instead of
*     a cryptic message such as "something tells you that won't be a very
*     productive topic". disambigXobj allows us to accomplish this.
*
* Tips:
*
*   + Be careful of unknown topics. If you have a topic that can be
*     referred to by a very general noun, e.g. "enchanted tree" (which
*     can be called simply "tree" by the player), it may be best to make
*     it a knownTopic. Or, make sure there is a general known topic that
*     matches that noun from the start (e.g. a "forest"
*     object). Otherwise, the player may get peeved by the seemingly
*     erroneous "you don't know about that" message.
*
*   + WorldClass sets up carryable items to be topics by default. I
*     recommend against this, at least in a large game (in my own game,
*     there are often 3-4 different versions of the same item floating
*     around). Keep the topic system separate to help insure that no
*     impossible disambiguation questions will show up ("Which ball do
*     you mean, the ball, the ball, or the ball?").
*
*   + This library assumes that only topics draw a distinction between
*     known and unknown. But if you prefer a WCish world in which
*     *anything* can be unknown (and therefore, "ask about [unknown
*     non-topic]" should result in "you don't know about that"), the
*     changes shouldn't be hard to make. Just fiddle with disambigIobj.
*
*   + Scenario: You have in your game a red gem and a green sword. But
*     nowhere does there exist a green gem. What happens when the player
*     types "ask so-and-so about green gem"? This:
*
*        I don't see any green gem here.
*
*     This happens in any TADS implementation of ASK/TELL. It is the
*     catchall error message displayed when a non-existent noun/adjective
*     combination is used. This is an artifact of how TADS is set up
*     internally: it favors local-scope verbs, for which that error *does*
*     make sense. You can change the message (#9) using parseError to say
*     something more meaningful (e.g. "I don't know of any such thing"),
*     but there are complications: the same error message is used for
*     other situations of a different nature. Also, there is no practical
*     way (that I know of) to determine what verb was used in this case.
*     It is handled too early in the parsing process.
*
*     It's possible to fix this somewhat, but tricky. I won't go into
*     details here, but if enough people ask, i can add the solution into
*     this source file.
*/

#pragma C+

/*************************** New Superclasses ***************************/

// topic: something which can be asked about, told about, or looked up in
// information sources. The code for scoping and disambiguation with topics
// is largely contained in ioTopicVerb.
//
// Important properties:
//   + known: indicates whether the player currently knows about this
//     topic. If nil, it will never show up in disambiguation questions,
//     and the player cannot get information by asking about it.
//   + unknownMsg: the message printed when the player's vocabulary matches
//     only unknown topic(s).
class topic: thing
 known = nil
 unknownMsg = "You don't know about that."

 location = nil
;

// knownTopic: a topic which is known from the beginning.
//
// Important properties: none
class knownTopic: topic
 known = true
;

// infoSource: something the player can look things up in.
//
// Important properties:
//   + askTopics(topic, words): This works the same as askTopics in
//     movableActor. "topic" is the topic asked about, and "words" are the
//     vocabulary words that were used to refer to it. The method should
//     output text and return true if the infoSource has an entry for that
//     topic, otherwise return nil. This method will never be called with
//     an unknown topic.
//   + disavow: This method will be printed whenever askTopics returns nil.
class infoSource: thing
 askTopics(topic, words) = {return nil;}
 disavow = "There's no entry for that topic."

 verIoLookupIn(actor) = {
   if (self.location != Me)
     "You're not holding <<self.thedesc>>.";
 }
 ioLookupIn(actor, dobj) = {
   // We have to handle catchallUnknownTopic here, unlike with other
   // verbs:
   if (dobj == catchallUnknownTopic)
     topic.unknownMsg;
   else if (!self.askTopics(dobj, objwords(1)))
     self.disavow;
 }

 verDoConsultOn(actor, io) = {self.verIoLookupIn(actor);}
 doConsultOn(actor, io) = {
   if (!self.askTopics(io, objwords(2)))
     self.disavow;
 }
;

// ioTopicVerb: a verb which uses topics as indirect objects. Non-topics
// will never show up in disambiguation questions. validIo and validIoList
// are not used for scoping, nor are verIoAskAbout and the like used.
// Instead, all disambiguation is done within disambigIobj. If no topics
// match the player's input, that method will return the special catchall
// topic catchallNonTopic. Since no NPC's or infoSources know about this
// topic, it will simply cause a "disavow" to be printed. Similarly, if
// topics match but no *known* topics match, catchallUnknownTopic will be
// returned, which will cause a reply of "you don't know about that" to
// any type of query (ask, tell, consult, look up).
//
// Important properties: none
class ioTopicVerb: deepverb
 validIoList(actor, prep, dobj) = (nil)
 validIo(actor, obj, seqno) = true
 ioDefault(actor, prep) = (nil)

 disambigIobj(actor, prep, dobj, verprop, wordlist, objlist, flaglist,
              numberWanted, isAmbiguous, silent) = {
   local i, len;
   local newlist = [];
   local unknownTopicsFound = nil;

   len = length(objlist);
   for (i=1; i <= len; i++) {
     if (isclass(objlist[i], topic)) {
       if (objlist[i].known)
         newlist += objlist[i];
       else
         unknownTopicsFound = true;
     }
   }
   if (length(newlist) < 1) {
     if (unknownTopicsFound)
       newlist += catchallUnknownTopic;
     else
       newlist += catchallNonTopic;
   }
   return newlist;
 }
;

// doTopicVerb: a verb which uses topics as direct objects. disambigDobj
// simply calls disambigIobj on ioTopicVerb. See ioTopicVerb for more
// details.
//
// Important properties: none
class doTopicVerb: deepverb
 validDoList(actor, prep, io) = (nil)
 validDo(actor, obj, seqno) = true
 doDefault(actor, prep, io) = (nil)

 // Allowing multiple objects can cause erroneous sdescs
 // (e.g. catchallNonTopic.sdesc) to get printed.
 rejectMultiDobj(prep) = {
   "You can't use multiple objects with that verb.";
   return true;
 }

 disambigDobj(actor, prep, io, verprop, wordlist, objlist, flaglist,
              numberWanted, isAmbiguous, silent) = {
   return ioTopicVerb.disambigIobj(actor, prep, io, verprop, wordlist,
          objlist, flaglist, numberWanted, isAmbiguous, silent);
 }
;

/************************** adv.t Modifications **************************/

// Modifications to thing for default responses to ask, tell, consult,
// look up, and redirections of ioConsultOn to doConsultOn, ioAskFor to
// doAskFor.
//
// Important properties: none, unless you want to change default responses.
modify thing
 replace verDoAskAbout(actor, io) = {"There is no response.";}
 verIoAskFor(actor) = {}
 verDoAskFor(actor, io) = {"There is no response.";}
 ioAskFor(actor, dobj) = {dobj.doAskFor(actor, self);}

 replace verDoTellAbout(actor, io)= {"There is no response.";}

 verIoConsultOn(actor) = {}
 verDoConsultOn(actor, io) = {"That's not an information source.";}
 ioConsultOn(actor, dobj) = {dobj.doConsultOn(actor, self);}

 verIoLookupIn(actor) = {"That's not an information source.";}
 verDoLookupIn(actor, io) = {}
;

// Modifications to movableActor (parent class for all actors)
//
// Important properties:
//   + askTopics(topic, words): This method should output text and return
//     true for a valid topic, otherwise return nil, in which case disavow
//     will be printed by doAskAbout. The specific vocabulary words used to
//     refer to the topic are passed in the "words" parameter.
//   + tellTopics(topic, words): works almost identically to askTopics.
//   + doAskFor(actor, io): You should override this method if you want to
//     allow the player to ask this NPC *for* something. Like "ask about",
//     it takes topics only. By default, it simply outputs self.disavow.
//   + disavow: default changed to "There is no response.". This method will
//     be called if askTopics returns nil.
//   + tellDisavow: calls disavow by default. This method will be called if
//     tellTopics returns nil.
modify movableActor
 askTopics(topic, words) = {return nil;}
 tellTopics(topic, words) = {return nil;}
 doAskFor(actor, io) = {self.disavow;}
 replace disavow = "There is no response."
 tellDisavow = {self.disavow;}

 replace doAskAbout(actor, io) = {
   if (!self.askTopics(io, objwords(2)))
     self.disavow;
 }

 verDoTellAbout(actor, io) = {}
 doTellAbout(actor, io) = {
   if (!self.tellTopics(io, objwords(2)))
     self.tellDisavow;
 }

 verDoAskFor(actor, io) = {}
;

/**************************** Special Objects ****************************/

// catchallNonTopic: If the game is expecting a topic, and the player
// enters vocabulary that does not match any objects of the topic class
// (known or unknown), then the disambiguation function on ioTopicVerb or
// doTopicVerb will return a single-item list consisting of
// catchallNonTopic. Since no NPC or infoSource will have a response/entry
// for this topic, it will simply cause a "disavow" statement to be
// printed.
//
// Important properties: none
catchallNonTopic: knownTopic
 sdesc = "non-topic (you should never see this)"
;

// catchallUnknownTopic: Similar to catchallNonTopic, this topic will be
// returned by disambiguation functions if the player's vocabulary matches
// no *known* topics, but at least one unknowntopic. Default messages are
// set here so that ask, tell, and consult will all output topic.unknownMsg
// in response. The default message for "look up" must be handled in
// infoSource itself, in ioLookupIn.
//
// Important properties: none
catchallUnknownTopic: knownTopic
 sdesc = "unknown topic (you should never see this)"
 ioAskAbout(actor, dobj) = {topic.unknownMsg;}
 ioAskFor(actor, dobj) = {topic.unknownMsg;}
 ioTellAbout(actor, dobj) = {topic.unknownMsg;}
 ioConsultOn(actor, dobj) = {topic.unknownMsg;}
;

/*************************** New Prepositions ***************************/

forPrep: Prep
 preposition = 'for'
 sdesc = "for"
;

/************************ New and Replaced Verbs ************************/

replace askVerb: ioTopicVerb, darkVerb
 verb = 'ask'
 sdesc = "ask"
 prepDefault = aboutPrep
 ioAction(aboutPrep) = 'AskAbout'
 ioAction(forPrep) = 'AskFor'
;

replace tellVerb: ioTopicVerb, darkVerb
 verb = 'tell'
 sdesc = "tell"
 prepDefault = aboutPrep
 ioAction(aboutPrep) = 'TellAbout'
;

consultVerb: ioTopicVerb
 verb = 'consult'
 sdesc = "consult"
 prepDefault = onPrep
 ioAction(onPrep) = 'ConsultOn'
 ioAction(aboutPrep) = 'ConsultOn'
;

lookupVerb: doTopicVerb
 verb = 'look up' 'read about'
 sdesc = "look up"
 prepDefault = inPrep
 ioAction(inPrep) = 'LookupIn'
;

#pragma C-

You are viewing proxied material from mercury.661.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.