Hugging Face's logo

Buckets:
bl791
/
IFDB

Files
xet
bl791/IFDB / programming /tads3 /library /contributions /msg_custom.t
bl791's picture
bl791
download
raw
96.4 kB
#charset "us-ascii"
#include "adv3.h"
#include "en_us.h"
//---------------------------------------------------------------
// MSG_CUSTOM.T
// by Greg Boettcher
// Version 2.2 released 18 May 2019
// First version released 18 November 2007
//
// Version 2.2 Verification of compatibility with TADS 3.1.3
// Slight changes for 3.1.3. Removal of unnecessary
// code that added an unnecessary slight risk of
// compatibility problems. 2019-05-18
// Version 2.1 (very slight bug fix) released 23 Jun 2010
//
// Copyright 2006-2007 Greg Boettcher.
//
// This file is freeware. You may use it for any purpose without
// permission, but please credit me appropriately.
//
// My email address:
// <paradoxgregXatXgmailXdotXcom>
//---------------------------------------------------------------
ModuleID
name = 'Msg_custom.t'
byLine = 'by Greg Boettcher'
htmlByLine = 'by Greg Boettcher'
version = '2.2'
//showCredit { "<<name>> <<htmlByLine>>"; }
;
/*
--------------------
ABOUT THIS EXTENSION
--------------------
With this file, you can change the standard TADS 3 messages in
any or all of the following ways:
1. You can deal with "smart quotes" as follows:
- sometimes use smart quotes (TADS 3.0.9 default)
- always use smart quotes (TADS 3.0.10+ default)
- never use smart quotes
2. You can deal with contractions as follows:
- sometimes use contractions (TADS 3 default)
- usually use contractions
- always use contractions
- or you can use contractions even less often than the
standard library does. Not recommended unless your
game's narrator and/or its NPCs are supposed to speak
like Lieutenant Commander Data of Star Trek.
3. You can, if you want, make the standard messages less formal
and more casual. If you do, then "appears" is replaced with
"seems"; "you see no" is replaced with "you don't see any"; etc.
4. You can make it so that when your TADS 3 project refers to
itself as "the story," this phrase is changed to any of the
following:
- "the story"
- "this story"
- "the game"
- "this game"
5. You can adjust the phrasing in cases where TADS 3 tells you
something "you must" do. You can do this in any of five ways,
exemplified as follows:
- "You must stand up before you can do that." (TADS 3 default)
- "You'll have to stand up before you can do that."
- "You'd have to stand up before you could do that."
- "You'll need to stand up before you can do that."
- "You'd need to stand up before you could do that."
These changes should work correctly even if you are doing
something unusual, such as putting your game in the past tense
or if your game is in the first person or third person.
Msg_custom.t should produce the exact same output as msg_neu.t
until you adjust its settings to suit your taste. Also, just to
be clear, all of its settings are independent of each other.
So you can certainly use it even if only one of its features
interests you.
Although I tested this extension quite thoroughly and it seems
relatively bug-free, it is very complicated, so I'm sure there
could be some bugs lurking in it. As such, I will need people's
help in reporting any and all bugs they may may find. While I
can't make any promises for the future, I at least *intend* to
maintain this file as needed.
-------------------------
HOW TO USE THIS EXTENSION
-------------------------
Put msg_custom.t into your project after the standard library
files, but before your own files. (And you do need to include
the standard library files. Msg_custom.t is not meant to
replace msg_neu.t or en_us.t.)
Then put something into your project that looks like this:
modify libGlobal
thisStoryNotTheStory = sometimes
gameNotStory = nil
youMustPref = youMust
useContractions = sometimes
preferCasual = true
useSmartQuotes = always
;
The above example sets each of the variables to their
default settings, and as such accomplishes nothing. But
you can adjust the values of each of those variables, as
described below in the "message variables" comments.
The TADS 3 library should respond accordingly.
For more details on how to do this for each of the individual
variables, see directly below in my "message variables"
comments.
Have fun! And by all means email me with any bugs you may
find.
Greg
*/
///////////////////////////////////////////////////////////
// MESSAGE VARIABLES
///////////////////////////////////////////////////////////
modify libGlobal
// thisStoryNotTheStory:
// = sometimes "*The* story has never referred (T3 default)
// to any such footnote."
// "*This* story has no ABOUT
// information."
// = always "*This* story has never referred (my preference)
// to any such footnote."
// "*This* story has no ABOUT
// information."
// = never "*The* story has never referred
// to any such footnote."
// "*The* story has no ABOUT
// information."
thisStoryNotTheStory = sometimes
// gameNotStory:
// = nil "This story has no ABOUT information." (T3 default)
// = true "This game has no ABOUT information." (my preference)
gameNotStory = nil
// youMustPref: (when the game is in present tense)
// = youMust "You must stand up before (T3 default)
// you can do that."
// = youllHaveTo "You'll have to stand up before (my preference)
// you can do that."
// = youdHaveTo "You'd have to stand up before
// you could do that."
// = youllNeedTo "You'll need to stand up before
// you can do that."
// = youdNeedTo "You'd need to stand up before
// you could do that."
// youMustPref: (when the game is in past tense)
// = youMust "You had to stand up before (T3 default)
// you could do that."
// = youllHaveTo "You would have had to stand (my preference)
// OR youdHaveTo up before you can do that."
// = youllNeedTo "You needed to stand up before
// you could do that.
// = youdNeedTo "You would have needed to stand
// up before you could do that."
youMustPref = youMust
// useContractions:
// = always (always use contractions, even "YOU'VE DIED," etc.)
// = usually (my preference)
// = sometimes (T3 default)
// = seldom (narrator talks like Lt. Cmdr. Data)
// = never (narrator and all NPCs talk like Lt. Cmdr. Data)
useContractions = sometimes
// preferCasual:
// = nil "You *see no* box here." (T3 default)
// "Bob does not *appear* interested."
// [give a "must" example?]
// = true "You *don't see any* box here." (my preference)
// "Bob does not *seem* interested."
// [give a "must" example?]
preferCasual = nil
// useSmartQuotes:
// = always Replace: (my preference,
// (1) all double quotes, and TADS 3.0.10+
// (2) all single quotes, and default)
// (3) all apostrophes
// with
// (1) '<q>', '</q>',
// (2) '&rsquo;', '&lsquo;', and
// (3) '&rsquo;'.
// = sometimes (Default TADS 3.0.9 (TADS 3.0.9
// usage, using smart default)
// quotes only sometimes.)
// = never (Never use any smart
// quotes.)
useSmartQuotes = always
;
///////////////////////////////////////////////////////////
// ENUMS
///////////////////////////////////////////////////////////
#ifndef never
enum never;
#endif
#ifndef seldom
enum seldom;
#endif
#ifndef sometimes
enum sometimes;
#endif
#ifndef usually
enum usually;
#endif
#ifndef always
enum always;
#endif
#ifndef youMust
enum youMust;
#endif
#ifndef youllHaveTo
enum youllHaveTo;
#endif
#ifndef youdHaveTo
enum youdHaveTo;
#endif
#ifndef youllNeedTo
enum youllNeedTo;
#endif
#ifndef youdNeedTo
enum youdNeedTo;
#endif
///////////////////////////////////////////////////////////
// MISC. MODIFICATIONS FOR TADS 3.0.8
///////////////////////////////////////////////////////////
// 2019-05-17 GWB: This section was included to make this extension work equally well
// with both TADS 3.0.8 as with 3.0.9+. This section never did any harm for games written
// in recent versions of TADS 3, although I'm not sure if my previous comments in this
// section truly made that clear (sigh). Either way, this section, allowing the use
// of this extension with TADS 3.0.8 is now absurdly unnecessary.
//// This extension was originally designed to run on games
//// compiled with TADS 3.0.9+. With some modifications, however,
//// we can make sure it works with 3.0.8 as well.
//
//modify GameMainDef
// usePastTense = nil
//;
//
//// In TADS 3.0.9, tSel() is defined as a macro rather than
//// a function. I don't know why, but I can't help thinking
//// that a function would work too, and would also provide
//// a better across-the-board solution for all the files
//// in a project.
//#ifndef tSel
////#define tSel(presVal, pastVal) \
//// (gameMain.usePastTense ? (pastVal) : (presVal))
//tSel(presVal, pastVal) {
// return (gameMain.usePastTense ? pastVal : presVal);
//}
//#endif
//
//modify langMessageBuilder
// pastEnding_ = nil
//;
//
//modify Thing
// verbEndingSD = (tSel(verbEndingS, 'd'))
// verbEndingSEd = (tSel(verbEndingS, 'ed'))
// verbEndingSMessageBuilder_ =
// (tSel(verbEndingS, langMessageBuilder.pastEnding_))
// verbToDo = (tSel('do' + verbEndingEs, 'did'))
// nameDoes = (theName + ' ' + verbToDo)
// verbToGo = (tSel('go' + verbEndingEs, 'went'))
// verbToCome = (tSel('come' + verbEndingS, 'came'))
// verbToLeave = (tSel('leave' + verbEndingS, 'left'))
// verbToSee = (tSel('see' + verbEndingS, 'saw'))
// nameSees = (theName + ' ' + verbToSee)
// verbToSay = (tSel('say' + verbEndingS, 'said'))
// nameSays = (theName + ' ' + verbToSay)
// verbMust = (tSel('must', 'had to'))
// verbCan = (tSel('can', 'could'))
// verbCannot = (tSel('cannot', 'could not'))
// verbCant = (tSel('can&rsquo;t', 'couldn&rsquo;t'))
// verbWill = (tSel('will', 'would'))
// verbWont = (tSel('won&rsquo;t', 'wouldn&rsquo;t'))
//;
//
//modify NameAsOther
// verbEndingSD = (targetObj.verbEndingSD)
// verbEndingSEd = (targetObj.verbEndingSEd)
// verbToDo = (targetObj.verbToDo)
// nameDoes = (targetObj.nameDoes)
// verbToGo = (targetObj.verbToGo)
// verbToCome = (targetObj.verbToCome)
// verbToLeave = (targetObj.verbToLeave)
// verbToSee = (targetObj.verbToSee)
// nameSees = (targetObj.nameSees)
// verbToSay = (targetObj.verbToSay)
// nameSays = (targetObj.nameSays)
// verbMust = (targetObj.verbMust)
// verbCan = (targetObj.verbCan)
// verbCannot = (targetObj.verbCannot)
// verbCant = (targetObj.verbCant)
// verbWill = (targetObj.verbWill)
// verbWont = (targetObj.verbWont)
//;
///////////////////////////////////////////////////////////
// CUSTOM MESSAGE OBJECT
///////////////////////////////////////////////////////////
custMsgObj: object
// Used only when "you" means the player; not when "you" means
// the player character.
youllStr() {
if (libGlobal.useContractions == seldom ||
libGlobal.useContractions == never)
return 'you will';
else
return 'you' + custMsgObj.rsquoPlainStr + 'll';
}
youWillStr() {
if (libGlobal.useContractions == usually ||
libGlobal.useContractions == always)
return 'you' + custMsgObj.rsquoPlainStr + 'll';
else
return 'you will';
}
youveStr() {
if (libGlobal.useContractions == seldom ||
libGlobal.useContractions == never)
return 'you have';
else
return 'you' + custMsgObj.rsquoPlainStr + 've';
}
youreStr() {
if (libGlobal.useContractions == seldom ||
libGlobal.useContractions == never)
return 'you are';
else
return 'you' + custMsgObj.rsquoPlainStr + 're';
}
youdStr() {
if (libGlobal.useContractions == seldom ||
libGlobal.useContractions == never)
return 'you would';
else
return 'you' + custMsgObj.rsquoPlainStr + 'd';
}
cantStr() {
if (libGlobal.useContractions == seldom ||
libGlobal.useContractions == never)
return 'cannot';
else
return 'can' + custMsgObj.rsquoPlainStr + 't';
}
storyStr() {
//return 'storyStr';
if (libGlobal.gameNotStory) return 'game';
else return 'story';
}
theStoryStrFunc(caps, theNotThis) {
local str;
// str = 'story' or 'game'
str = storyStr();
switch (libGlobal.thisStoryNotTheStory) {
// Add 'he ' or 'his ' depending on whether it's
// 'the' or 'this'
case never:
str = 'he ' + str;
break;
case always:
str = 'his ' + str;
break;
default:
if (theNotThis) str = 'he ' + str;
else str = 'his ' + str;
break;
}
if (caps) str = 'T' + str;
else str = 't' + str;
return str;
}
theStoryStr() { return theStoryStrFunc(nil , true); }
thisStoryStr() { return theStoryStrFunc(nil , nil ); }
TheStoryStr() { return theStoryStrFunc(true, true); }
ThisStoryStr() { return theStoryStrFunc(true, nil ); }
// Use this when saying something that will never be in the
// past tense, e.g. "You, the player, cannot do something."
// Do not use for PCs or NPCs, where the verb "cannot"
// would change depending on whether the game is in the
// past tense.
cannotStr() {
if (libGlobal.useContractions != usually &&
libGlobal.useContractions != always) return 'cannot';
else if (libGlobal.useSmartQuotes == always) return 'can&rsquo;t';
else return 'can\'t';
}
// For use only when a given clause is always in the
// past tense.
wereNotStr() {
if (libGlobal.useContractions != usually &&
libGlobal.useContractions != always) return 'were not';
else if (libGlobal.useSmartQuotes == always) return 'weren&rsquo;t';
else return 'weren\'t';
}
appearStr() {
if (libGlobal.preferCasual) return 'seem';
else return 'appear';
}
lsquoStr() {
if (libGlobal.useSmartQuotes == never)
return '\'';
else
return '&lsquo;';
}
rsquoStr() {
if (libGlobal.useSmartQuotes == never)
return '\'';
else
return '&rsquo;';
}
lsquoPlainStr() {
if (libGlobal.useSmartQuotes == always)
return '&lsquo;';
else
return '\'';
}
rsquoPlainStr() {
if (libGlobal.useSmartQuotes == always)
return '&rsquo;';
else
return '\'';
}
ldquoStr() {
if (libGlobal.useSmartQuotes == never)
return '\"'; //return '\"';
else
return '&ldquo;'; //return '&ldquo;';
}
rdquoStr() {
if (libGlobal.useSmartQuotes == never)
return '\"'; //return '\"';
else
return '&rdquo;'; //return '&rdquo;';
}
ldquoPlainStr() {
if (libGlobal.useSmartQuotes == always)
return '&ldquo;'; //return '&ldquo;';
else
return '\"'; //return '\"';
}
rdquoPlainStr() {
if (libGlobal.useSmartQuotes == always)
return '&rdquo;'; //return '&rdquo;';
else
return '\"'; //return '\"';
}
sOrWasStr() {
if (gameMain.usePastTense)
return ' was';
else if (libGlobal.useContractions == seldom ||
libGlobal.useContractions == never)
return ' is';
else
return rsquoPlainStr + 's';
}
_not() {
if (libGlobal.useContractions == usually
|| libGlobal.useContractions == always)
return 'n' + rsquoPlainStr + 't';
else
return ' not';
}
ntAbbr() {
if (libGlobal.useContractions == seldom ||
libGlobal.useContractions == never)
return ' not';
else
return 'n' + rsquoPlainStr + 't';
}
;
///////////////////////////////////////////////////////////
// LANGMESSAGEBUILDER MODIFICATIONS
///////////////////////////////////////////////////////////
// I tried to append to langMessageBuilder.paramList_, but
// I found it more difficult than I expected. So I had to
// replace the list, rather than modify it.
modify langMessageBuilder
// 2019-05-17 GWB: I've verified that the version of the list below
// is still the correct modification as per TADS 3.1.3.
//
// I was wanted to append to this list, but I failed to
// find a way to make this happen before the list is
// processed. Therefore, I had to replace the entire list.
paramList_ =
[
// parameters that imply the actor as the target object
['you/he', &theName, 'actor', nil, true],
['you/she', &theName, 'actor', nil, true],
['you\'re/he\'s', &itIsContraction, 'actor', nil, true],
['you\'re/she\'s', &itIsContraction, 'actor', nil, true],
['you\'re', &itIsContraction, 'actor', nil, true],
['you/him', &theNameObj, 'actor', &itReflexive, nil],
['you/her', &theNameObj, 'actor', &itReflexive, nil],
['your/her', &theNamePossAdj, 'actor', nil, nil],
['your/his', &theNamePossAdj, 'actor', nil, nil],
['your', &theNamePossAdj, 'actor', nil, nil],
['yours/hers', &theNamePossNoun, 'actor', nil, nil],
['yours/his', &theNamePossNoun, 'actor', nil, nil],
['yours', &theNamePossNoun, 'actor', nil, nil],
['yourself/himself', &itReflexive, 'actor', nil, nil],
['yourself/herself', &itReflexive, 'actor', nil, nil],
['yourself', &itReflexive, 'actor', nil, nil],
// parameters that don't imply any target object
['the/he', &theName, nil, nil, true],
['the/she', &theName, nil, nil, true],
['the/him', &theNameObj, nil, &itReflexive, nil],
['the/her', &theNameObj, nil, &itReflexive, nil],
['the\'s/her', &theNamePossAdj, nil, &itPossAdj, nil],
['the\'s/hers', &theNamePossNoun, nil, &itPossNoun, nil],
// Verb 's' endings. In most cases, you should use 's/d', 's/ed',
// or 's/?ed' rather than 's', except in places where you know you
// will never need the past tense form, because 's' doesn't handle
// the past tense. Don't use 's/?ed' with a literal question
// mark; put a consonant in place of the question mark instead.
['s', &verbEndingS, nil, nil, true],
['s/d', &verbEndingSD, nil, nil, true],
['s/ed', &verbEndingSEd, nil, nil, true],
['s/?ed', &verbEndingSMessageBuilder_, nil, nil, true],
['es', &verbEndingEs, nil, nil, true],
['es/ed', &verbEndingEs, nil, nil, true],
['ies', &verbEndingIes, nil, nil, true],
['ies/ied', &verbEndingIes, nil, nil, true],
['is', &verbToBe, nil, nil, true],
['are', &verbToBe, nil, nil, true],
['was', &verbWas, nil, nil, true],
['were', &verbWas, nil, nil, true],
['has', &verbToHave, nil, nil, true],
['have', &verbToHave, nil, nil, true],
['does', &verbToDo, nil, nil, true],
['do', &verbToDo, nil, nil, true],
['goes', &verbToGo, nil, nil, true],
['go', &verbToGo, nil, nil, true],
['comes', &verbToCome, nil, nil, true],
['come', &verbToCome, nil, nil, true],
['leaves', &verbToLeave, nil, nil, true],
['leave', &verbToLeave, nil, nil, true],
['sees', &verbToSee, nil, nil, true],
['see', &verbToSee, nil, nil, true],
['says', &verbToSay, nil, nil, true],
['say', &verbToSay, nil, nil, true],
['must', &verbMust, nil, nil, true],
['can', &verbCan, nil, nil, true],
['cannot', &verbCannot, nil, nil, true],
['can\'t', &verbCant, nil, nil, true],
['will', &verbWill, nil, nil, true],
['won\'t', &verbWont, nil, nil, true],
['a/he', &aName, nil, nil, true],
['an/he', &aName, nil, nil, true],
['a/she', &aName, nil, nil, true],
['an/she', &aName, nil, nil, true],
['a/him', &aNameObj, nil, &itReflexive, nil],
['an/him', &aNameObj, nil, &itReflexive, nil],
['a/her', &aNameObj, nil, &itReflexive, nil],
['an/her', &aNameObj, nil, &itReflexive, nil],
['it/he', &itNom, nil, nil, true],
['it/she', &itNom, nil, nil, true],
['it/him', &itObj, nil, &itReflexive, nil],
['it/her', &itObj, nil, &itReflexive, nil],
// note that we don't have its/his, because that leaves
// ambiguous whether we want an adjective or noun form - so we
// only use the feminine pronouns with these, to make the
// meaning unambiguous
['its/her', &itPossAdj, nil, nil, nil],
['its/hers', &itPossNoun, nil, nil, nil],
['it\'s/he\'s', &itIsContraction, nil, nil, true],
['it\'s/she\'s', &itIsContraction, nil, nil, true],
['it\'s', &itIsContraction, nil, nil, true],
['that/he', &thatNom, nil, nil, true],
['that/she', &thatNom, nil, nil, true],
['that/him', &thatObj, nil, &itReflexive, nil],
['that/her', &thatObj, nil, &itReflexive, nil],
['that\'s', &thatIsContraction, nil, nil, true],
['itself', &itReflexive, nil, nil, nil],
['itself/himself', &itReflexive, nil, nil, nil],
['itself/herself', &itReflexive, nil, nil, nil],
// default preposition for standing in/on something
['on', &actorInName, nil, nil, nil],
['in', &actorInName, nil, nil, nil],
['outof', &actorOutOfName, nil, nil, nil],
['offof', &actorOutOfName, nil, nil, nil],
['onto', &actorIntoName, nil, nil, nil],
['into', &actorIntoName, nil, nil, nil],
// The special invisible subject marker - this can be used to
// mark the subject in sentences that vary from the
// subject-verb-object structure that most English sentences
// take. The usual SVO structure allows the message builder to
// see the subject first in most sentences naturally, but in
// unusual sentence forms it is sometimes useful to be able to
// mark the subject explicitly. This doesn't actually result in
// any output; it's purely for marking the subject for our
// internal book-keeping.
//
// (The main reason the message builder wants to know the subject
// in the first place is so that it can use a reflexive pronoun
// if the same object ends up being used as a direct or indirect
// object: "you can't open yourself" rather than "you can't open
// you.")
['subj', &dummyName, nil, nil, true]
//MSG_CUSTOM ADDITIONS
,['n\'t', &ntAbbr, nil, nil, nil]
,['_not', &_not, nil, nil, nil]
,['that_isn\'t', &thatIsnt, nil, nil, true]
,['that_is_not', &thatIsNot, nil, nil, true]
,['you_would_have_to', &nameWouldHaveTo, 'actor', nil, true]
//,['you_will_have_to', &nameWillHaveTo, 'actor', nil, true]
,['you_could', &itCould, 'actor', nil, true]
,['you_see_no', &nameSeesNo, 'actor', nil, true]
,['you_are', &nameIs, 'actor', nil, true]
]
;
// The following just didn't work, so I resorted to replacing
// the entire set of values for langMessageBuilder.paramList_
//custMsgPreinit: PreinitObject
// execute() {
// langMessageBuilder.paramList_.append(
// ['n\'t', &ntAbbr, nil, nil, true],
// ['_not', &_not, nil, nil, true]
// );
// }
// execAfterMe = [adv3LibPreinit]
//;
///////////////////////////////////////////////////////////
// THING MODIFICATIONS
///////////////////////////////////////////////////////////
modify Thing
thatIsContraction {
if (gameMain.usePastTense)
return thatNom + ' ' + verbToBe;
// From now on, we assume present tense.
else if (libGlobal.useContractions == seldom ||
libGlobal.useContractions == never) // Lt. Cmdr. Data scenario
return thatNom + ' ' + verbToBe;
else if (isPlural)
return thatNom + ' are';
else
return thatNom + custMsgObj.rsquoPlainStr + 's';
}
itIsContraction {
if (gameMain.usePastTense)
return itNom + ' ' + verbToBe; // "it was"/"they were"
// From now on, we assume present tense.
else if (libGlobal.useContractions == seldom ||
libGlobal.useContractions == never) // Lt. Cmdr. Data scenario
return itNom + ' ' + verbToBe; // "it is"/"they are"
else if (isPlural)
return itNom + custMsgObj.rsquoPlainStr + 're'; // "they're"
else
return itNom + custMsgObj.rsquoPlainStr + 's'; // "it's"
}
theNamePossAdj {
return theName +
(isPlural && theName.endsWith('s')
? custMsgObj.rsquoPlainStr
: custMsgObj.rsquoPlainStr + 's');
}
pluralNameFrom(str) {
local len;
local lastChar;
local lastPair;
if (isPlural)
return str;
//// The following will become part of TADS 3 in the version
//// that follows 3.0.9.
//if (rexMatch(patOfPhrase, str) != nil) {
// local ofSuffix;
// str = rexGroup(1)[3];
// ofSuffix = rexGroup(2)[3];
// return pluralNameFrom(str) + ofSuffix;
//}
len = str.length();
if (len == 0)
return '';
if (len == 1) {
if (rexMatch(patSingleApostropheS, str) != nil)
return str + custMsgObj.rsquoPlainStr + 's';
else
return str + 's';
}
lastChar = str.substr(len, 1);
lastPair = (len == 1 ? lastChar : str.substr(len - 1, 2));
if (rexMatch(patUpperOrDigit, lastChar) != nil)
return str + 's';
if (lastChar == '.')
return str + custMsgObj.rsquoPlainStr + 's';
if (rexMatch(patVowelY, lastPair) != nil)
return str.substr(1, len - 1) + 'ies';
if ('sxzh'.find(lastChar) != nil)
return str + 'es';
return str + 's';
}
nameIsnt {
if (libGlobal.useContractions == seldom ||
libGlobal.useContractions == never) // Lt. Cmdr. Data scenario
return nameIs + ' not';
else
return nameIs + 'n' + custMsgObj.rsquoPlainStr + 't';
}
nameIsNot {
if (libGlobal.useContractions == usually ||
libGlobal.useContractions == always)
return theName + ' ' + verbToBe + custMsgObj.ntAbbr;
else
return theName + ' ' + verbToBe + ' not';
}
verbCant() {
if (gameMain.usePastTense) {
if (libGlobal.useContractions != never &&
libGlobal.useContractions != seldom)
return 'couldn' + custMsgObj.rsquoPlainStr + 't';
else
return 'could not';
}
else { // use present tense
if (libGlobal.useContractions != never &&
libGlobal.useContractions != seldom)
return 'can' + custMsgObj.rsquoPlainStr + 't';
else
return 'cannot';
}
}
verbWont() {
if(gameMain.usePastTense) {
if (libGlobal.useContractions != never &&
libGlobal.useContractions != seldom)
return 'wouldn' + custMsgObj.rsquoPlainStr + 't';
else
return 'would not';
}
else { // use present tense
if (libGlobal.useContractions != never &&
libGlobal.useContractions != seldom)
return 'won' + custMsgObj.rsquoPlainStr + 't';
else
return 'will not';
}
}
verbCannot() {
if (gameMain.usePastTense) {
if (libGlobal.useContractions == usually ||
libGlobal.useContractions == always)
return 'couldn' + custMsgObj.rsquoPlainStr + 't';
else
return 'could not';
}
else { // use present tense
if (libGlobal.useContractions == usually ||
libGlobal.useContractions == always)
return 'can' + custMsgObj.rsquoPlainStr + 't';
else
return 'cannot';
}
}
// Presumably in all relevant cases
// Thing.nameWouldHaveTo is overridden by
// Actor.nameWouldHaveTo. But just in case...
nameWouldHaveTo {
if (libGlobal.youMustPref == youMust)
return theName + ' ' + verbMust;
else if (gameMain.usePastTense) {
if (libGlobal.youMustPref == youllNeedTo)
return theName + ' needed to';
if (libGlobal.youMustPref == youdNeedTo)
return theName + ' would have needed to';
else
return theName + ' would have had to';
}
else { // present tense
switch (libGlobal.youMustPref) {
case youllHaveTo: return theName + ' will have to';
case youdHaveTo: return theName + ' would have to';
case youllNeedTo: return theName + ' will need to';
case youdNeedTo: return theName + ' would need to';
default: return theName + ' ' + verbMust; // should never happen; covered above
}
}
}
// Use this when it makes no sense to use the subjective,
// so you want to, e.g., substitute "would" with "will".
nameWillHaveTo {
if (gameMain.usePastTense) {
switch (libGlobal.youMustPref) {
case youllHaveTo:
case youdHaveTo: return theName + ' had to';
case youllNeedTo:
case youdNeedTo: return theName + ' needed to';
default: return theName + ' had to';
}
}
// present tense
switch (libGlobal.youMustPref) {
case youllHaveTo:
case youdHaveTo: return theName + ' will have to';
case youllNeedTo:
case youdNeedTo: return theName + ' will need to';
default: return theName + ' must';
}
}
itCould {
if (gameMain.usePastTense
|| libGlobal.youMustPref == youdHaveTo
|| libGlobal.youMustPref == youdNeedTo)
return itNom + ' could';
else
return itNom + ' can';
}
nameSeesNo {
if (!libGlobal.preferCasual)
return theName + ' ' + verbToSee + ' no';
else
return nameDoes + custMsgObj.ntAbbr + ' see any';
}
hasNo {
if (!libGlobal.preferCasual)
return verbToHave + ' no';
else
return verbToDo + custMsgObj.ntAbbr + ' have any';
}
thatIsNot {
if (libGlobal.useContractions == usually ||
libGlobal.useContractions == always)
return thatIsnt;
else
return thatNom + ' ' + verbToBe + ' not';
}
thatIsnt {
if (libGlobal.useContractions == seldom ||
libGlobal.useContractions == never) {
return thatNom + ' ' + verbToBe + ' not';
}
// I prefer "That's not" to "That isn't." Therefore, do
// it that way whenever possible if libGlobal.useContractions
// is usually or always.
else if (libGlobal.useContractions == usually ||
libGlobal.useContractions == always) {
if (!isPlural && !gameMain.usePastTense)
return thatIsContraction + ' not'; // "that's not"
else
// "those aren't", "that wasn't", "those weren't"
return thatNom + ' ' + verbToBe + custMsgObj.ntAbbr;
}
else { // libGlobal.useContractions == sometimes (default)
return thatNom + ' ' + verbToBe + custMsgObj.ntAbbr;
}
}
_not() {
if (libGlobal.useContractions == usually ||
libGlobal.useContractions == always)
return 'n' + custMsgObj.rsquoPlainStr + 't';
else
return ' not';
}
ntAbbr() {
if (libGlobal.useContractions == seldom ||
libGlobal.useContractions == never)
return ' not';
else
return 'n' + custMsgObj.rsquoPlainStr + 't';
}
;
//This function proved unnecessary.
//function ltCmdrData(str1, str2) {
// if (libGlobal.useContractions == seldom ||
// libGlobal.useContractions == never)
// return str2;
// else
// return str1;
//}
//Unused portions of code which for some reason I don't want
//to throw away:
//modify Thing
// verbCannotCant() {
// if (!libGlobal.preferContractions)
// return tSel('cannot', 'could not');
// else if (libGlobal.useSmartQuotes == always)
// return tSel('can&rsquo;t', 'couldn&rsquo;t');
// else
// return tSel('can\'t', 'couldn\'t');
// }
// verbDoesNot() {
// if (!libGlobal.preferContractions)
// return tSel('do' + verbEndingEs + ' not', 'did not');
// else if (libGlobal.useSmartQuotes == always)
// return tSel('do' + verbEndingEs + 'n&rsquo;t', 'didn&rsquo;t');
// else
// return tSel('do' + verbEndingEs + 'n\'t', 'didn\'t');
// }
// verbIsNot() {
// if (!libGlobal.preferContractions)
// return tSel(isPlural ? 'are not' : 'is not',
// isPlural ? 'were not' : 'was not');
// else if (libGlobal.useSmartQuotes == always)
// return tSel(isPlural ? 'aren&rsquo;t' : 'isn&rsquo;t',
// isPlural ? 'weren&rsquo;t' : 'wasn&rsquo;t');
// else
// return tSel(isPlural ? 'aren\'t' : 'isn\'t',
// isPlural ? 'weren\'t' : 'wasn\'t');
// }
// verbSeesNo() {
// if (!libGlobal.preferCasual)
// return verbToSee + ' no';
// else
// return verbToDo + custMsgObj.ntAbbr + ' see any';
// }
//;
///////////////////////////////////////////////////////////
// ACTOR MODIFICATIONS
///////////////////////////////////////////////////////////
modify Actor
thatIsContraction {
if (libGlobal.useContractions == seldom ||
libGlobal.useContractions == never) // Lt. Cmdr. Data scenario
return thatNom + ' ' + verbToBe;
else
return thatNom +
tSel([custMsgObj.rsquoPlainStr + 'm',
custMsgObj.rsquoPlainStr + 're',
custMsgObj.rsquoPlainStr + 's',
custMsgObj.rsquoPlainStr + 're',
custMsgObj.rsquoPlainStr + 're',
' are'][conjugationSelector], ' ' + verbToBe);
}
itIsContraction {
if (libGlobal.useContractions == seldom ||
libGlobal.useContractions == never) // Lt. Cmdr. Data scenario
return itNom + ' ' + verbToBe;
else
return itNom +
tSel(custMsgObj.rsquoPlainStr +
['m',
're',
's',
're',
're',
're'][conjugationSelector], ' ' + verbToBe);
}
nameIs {
if (referralPerson == ThirdPerson)
return theName + ' ' + verbToBe;
else if (libGlobal.useContractions == usually ||
libGlobal.useContractions == always)
// Do thatIsContraction in order to get the proper contractions
// whenever appropriate.
return thatIsContraction;
else
return theName + ' ' + verbToBe;
}
nameIsnt {
if (libGlobal.useContractions == seldom ||
libGlobal.useContractions == never) // Lt. Cmdr. Data scenario
return nameIs + ' not';
// I think, e.g., "you're not" sounds more natural than "you aren't",
// so if the author picks my settings -- namely, if they set it so
// libGlobal.useContractions == usually -- then change this appropriately.
else if (libGlobal.useContractions == usually ||
libGlobal.useContractions == always)
return tSel(['I' + custMsgObj.rsquoPlainStr + 'm not',
'you' + custMsgObj.rsquoPlainStr + 're not',
nameIs + 'n' + custMsgObj.rsquoPlainStr + 't',
'we' + custMsgObj.rsquoPlainStr + 're not',
'you' + custMsgObj.rsquoPlainStr + 're not',
nameIs + 'n' + custMsgObj.rsquoPlainStr + 't'][conjugationSelector],
nameIs + 'n' + custMsgObj.rsquoPlainStr + 't');
else
return (conjugationSelector == 1 && !gameMain.usePastTense
? 'I' + custMsgObj.rsquoPlainStr + 'm not' : inherited);
}
nameIsNot {
if (libGlobal.useContractions == usually ||
libGlobal.useContractions == always)
return nameIsnt;
else
return theName + ' ' + verbToBe + ' not';
}
thatIsnt {
// This is complicated, but fortunately, whenever
// referralPerson is FirstPerson or SecondPerson,
// what we want is identical with nameIsnt, so that
// makes it easier.
if (referralPerson == FirstPerson ||
referralPerson == SecondPerson)
return nameIsnt;
// All remaining stuff is ThirdPerson.
else if (libGlobal.useContractions == seldom ||
libGlobal.useContractions == never)
return thatNom + ' ' + verbToBe + ' not';
// All remaining cases will do the contraction
// (and are in ThirdPerson).
else if (!isPlural && !gameMain.usePastTense)
// "that's not", "he's not", "she's not"
return thatNom + custMsgObj.sOrWasStr + ' not';
else
// "those aren't", "those weren't",
// "that wasn't", "he wasn't", "she wasn't"
return thatNom + ' ' + verbToBe + custMsgObj.ntAbbr;
}
// Commented out because this should be the same as Thing.thatIsNot
//thatIsNot {
// if (libGlobal.useContractions == usually ||
// libGlobal.useContractions == always)
// return thatIsnt;
// else
// return thatNom + ' ' + verbToBe + ' not';
//}
nameWouldHaveTo {
// Actor.nameWouldHaveTo is in large measure similar to
// Thing.nameWouldHaveTo...
if (libGlobal.youMustPref == youMust)
return theName + ' ' + verbMust;
else if (gameMain.usePastTense) {
if (libGlobal.youMustPref == youllNeedTo ||
libGlobal.youMustPref == youdNeedTo)
return theName + ' would have needed to';
else
return theName + ' would have had to';
}
// ... butActor.nameWouldHaveTo differs from
// Thing.nameWouldHaveTo in its use of contractions.
// The following are all present tense.
else if (referralPerson == 3) {
switch (libGlobal.youMustPref) {
case youllHaveTo: return theName + ' will have to';
case youdHaveTo: return theName + ' would have to';
case youllNeedTo: return theName + ' will need to';
case youdNeedTo: return theName + ' would need to';
default: return theName + ' ' + verbMust; // should never happen; covered above
}
}
// All other cases involve the use of a pronoun followed
// by a contraction.
else {
switch (libGlobal.youMustPref) {
case youllHaveTo: return theName + custMsgObj.rsquoStr + 'll have to';
case youdHaveTo: return theName + custMsgObj.rsquoStr + 'd have to';
case youllNeedTo: return theName + custMsgObj.rsquoStr + 'll need to';
case youdNeedTo: return theName + custMsgObj.rsquoStr + 'd need to';
default: return theName + ' ' + verbMust; // should never happen; covered above
}
}
}
// Use this when it makes no sense to use the subjective,
// so you want to, e.g., substitute "would" with "will".
nameWillHaveTo {
if (gameMain.usePastTense) {
switch (libGlobal.youMustPref) {
case youllHaveTo:
case youdHaveTo: return theName + ' had to';
case youllNeedTo:
case youdNeedTo: return theName + ' needed to';
default: return theName + ' had to';
}
}
// present tense
switch (libGlobal.youMustPref) {
case youllHaveTo:
case youdHaveTo:
if (referralPerson == 3)
return theName + ' will have to';
else
return theName + custMsgObj.rsquoStr + 'll have to';
case youllNeedTo:
case youdNeedTo:
if (referralPerson == 3)
return theName + ' will need to';
else
return theName + custMsgObj.rsquoStr + 'll need to';
default:
return theName + ' must';
}
}
// The following Actor modifications are to correct an inconsistency
// (a bug?) in the TADS 3.0.9 library, whereby 1st person plural
// comes out as "I" instead of "we" in some cases (even though
// 1st person plural does work in other cases). As of right now
// (the morning of April 8, 2006), I don't know whether this will
// be corrected in the T3 library, but I am correcting it here.
theName {
return (referralPerson == ThirdPerson
? inherited : itNom);
}
theNameObj {
return (referralPerson == ThirdPerson
? inherited : itObj);
}
theNamePossAdj {
return (referralPerson == ThirdPerson
? inherited : itPossAdj);
}
theNamePossNoun {
return (referralPerson == ThirdPerson
? inherited : itPossNoun);
}
aName {
return (referralPerson == ThirdPerson
? inherited : itNom);
}
aNameObj {
return (referralPerson == ThirdPerson
? inherited : itObj);
}
;
///////////////////////////////////////////////////////////
// MSG_NEU.T MODIFICATIONS
///////////////////////////////////////////////////////////
//buildParam(typeString, nm) {
// return '{' + typeString + ' ' + nm + '}';
//}
//buildSynthParam(typeString, obj) {
// return '{' + typeString + ' ' + gSynthMessageParam(obj) + '}';
//}
modify libMessages //superclass is MessageHelper
noAboutInfo
{
"<.parser><<custMsgObj.ThisStoryStr>> has no
ABOUT information.<./parser> ";
// I was going to do it the following way, but decided I actually
// prefer a version that more closely resembles the original.
//"<.parser><<custMsgObj.ThisStoryStr>> ";
//if (!libGlobal.preferCasual)
// "has no";
//else
// "does<<custMsgObj.ntAbbr>> have any";
//" ABOUT information.<./parser> ";
}
thingFeelDesc(obj)
{
"{You/he} ";
if (!libGlobal.preferCasual)
"{feel[s actor]|felt} no";
else
"<<gActor.verbToDo>><<custMsgObj.ntAbbr>> feel any";
"thing out of the ordinary. ";
}
dimReadDesc(obj)
{
gMessageParams(obj);
"There<<custMsgObj.sOrWasStr>>
not enough light to read {that obj/him}. ";
}
showScoreMessage(points, maxPoints, turns)
{
"In <<turns>> move<<turns == 1 ? '' : 's'>>,
<<libGlobal.useContractions == always
? 'you' + custMsgObj.rsquoPlainStr + 've' : 'you have'>>
scored <<points>> of a possible <<maxPoints>> point<<
maxPoints == 1 ? '' : 's'>>. ";
}
showScoreNoMaxMessage(points, turns)
{
"In <<turns>> move<<turns == 1 ? '' : 's'>>,
<<libGlobal.useContractions == always
? 'you' + custMsgObj.rsquoPlainStr + 've' : 'you have'>>
scored <<points>> point<<points == 1 ? '' : 's'>>. ";
}
//// Changed down below now in the "modify tips" section:
//firstScoreChange(delta)
//{
// "<.commandsep><.notification><<
// basicScoreChange(delta)>><./notification>
// \n<.notification>If <<custMsgObj.youdStr>>
// prefer not to be notified about
// score changes in the future, type <<
// aHref('notify off', 'NOTIFY OFF', 'Turn off score notifications')
// >>.<./notification> ";
//}
noSuchFootnote(num)
{
"<.parser><<custMsgObj.TheStoryStr>> has never referred to any such
footnote.<./parser> ";
}
showFootnoteStatus(stat)
{
"The current setting is FOOTNOTES ";
switch(stat)
{
case FootnotesOff:
"OFF, which hides all footnote references.
Type <<aHref('footnotes medium', 'FOOTNOTES MEDIUM',
'Set footnotes to Medium')>> to
show references to footnotes except those
<<custMsgObj.youveStr>>
already seen, or <<aHref('footnotes full', 'FOOTNOTES FULL',
'Set footnotes to Full')>>
to show all footnote references. ";
break;
case FootnotesMedium:
"MEDIUM, which shows references to unread footnotes, but
hides references to those <<custMsgObj.youveStr>>
already read. Type
<<aHref('footnotes off', 'FOOTNOTES OFF',
'Turn off footnotes')>> to hide
footnote references entirely, or <<aHref(
'footnotes full', 'FOOTNOTES FULL',
'Set footnotes to Full')>> to show every reference, even to
notes <<custMsgObj.youveStr>> already read. ";
break;
case FootnotesFull:
"FULL, which shows every footnote reference, even to
notes <<custMsgObj.youveStr>>
already read. Type <<aHref('footnotes medium',
'FOOTNOTES MEDIUM', 'Set footnotes to Medium')>> to show
only references to notes you
have<<custMsgObj.ntAbbr>> yet read, or
<<aHref('footnotes off', 'FOOTNOTES OFF', 'Turn off footnotes')>>
to hide footnote references entirely. ";
break;
}
}
invalidCommandToken(ch)
{
"<.parser><<custMsgObj.TheStoryStr>>
does<<custMsgObj.ntAbbr>> know how to use the character
<<custMsgObj.lsquoStr>><<ch>><<custMsgObj.rsquoStr>>
in a command.<./parser> ";
}
oopsOutOfContext = "<.parser>You can only use OOPS to correct
a misspelling immediately after the <<custMsgObj.storyStr>>
points out a word
it does<<custMsgObj.ntAbbr>> know.<./parser> "
announceDefaultObject(obj, whichObj, action, resolvedAllObjects)
{
return '<.assume>'
+ action.announceDefaultObject(obj, whichObj, resolvedAllObjects)
+ '<./assume>\n';
}
noCommandForAgain()
{
"<.parser>There<<(libGlobal.useContractions == seldom ||
libGlobal.useContractions == never) ? ' is'
: custMsgObj.rsquoPlainStr + 's' >>
nothing to repeat.<./parser> ";
}
againCannotChangeActor()
{
"<.parser>To repeat a command like
<<custMsgObj.ldquoStr>>turtle, go north,<<custMsgObj.rdquoStr>>
just say <<custMsgObj.ldquoStr>>again,<<custMsgObj.rdquoStr>> not
<<custMsgObj.ldquoStr>>turtle, again.<<custMsgObj.rdquoStr>><./parser> ";
}
againNotPossible(issuer)
{
"That command <<issuer.verbCannot>> be repeated now. ";
}
systemActionToNPC()
{
"<.parser>This command cannot be directed to another
character in <<custMsgObj.theStoryStr>>.<./parser> ";
}
notTerminating()
{
"<.parser>Continuing the <<custMsgObj.storyStr>>.<./parser> ";
}
notRestarting() { "<.parser>Continuing the <<custMsgObj.storyStr>>.<./parser> "; }
//finishDeathMsg = ('YOU'
// + tSel((libGlobal.useContractions == always
// ? custMsgObj.rsquoPlainStr + 'VE' : ' HAVE'), '')
// + ' DIED')
finishDeathMsg =
(gPlayerChar.theName.toUpper
+ tSel(
(libGlobal.useContractions == always
? (gPlayerChar.referralPerson != ThirdPerson ? '&rsquo;VE' : ' HAVE')
: ' HAVE' )
, '')
+ ' DIED')
finishVictoryMsg = ('YOU'
+ tSel((libGlobal.useContractions == always
? custMsgObj.rsquoPlainStr + 'VE' : ' HAVE'), '')
+ ' WON')
finishFailureMsg = ('YOU'
+ tSel((libGlobal.useContractions == always
? custMsgObj.rsquoPlainStr + 'VE' : ' HAVE'), '')
+ ' FAILED')
saveOkay() { "<.parser>Saved.<./parser> "; }
saveCanceled() { "<.parser>Canceled.<./parser> "; }
saveFailed(exc)
{
"<.parser>Failed; your computer might be running low
on disk space, or you might not have the necessary permissions
to write this file.<./parser> ";
}
restoreInvalidMatch()
{
"<.parser>Failed: the file was not saved by
<<custMsgObj.thisStoryStr>>
(or was saved by an incompatible version of
<<custMsgObj.theStoryStr>>).<./parser> ";
}
pausePrompt()
{
"<.parser><<custMsgObj.TheStoryStr>> is now paused. Please press
the space bar when you are ready to resume the
<<custMsgObj.storyStr>>, or
press the <<custMsgObj.lsquoPlainStr>>S<<custMsgObj.rsquoPlainStr>>
key to save the current position.<./parser><.p>";
}
pauseSaving()
{
"<.parser>Saving the <<custMsgObj.storyStr>>...<./parser><.p>";
}
pauseEnded()
{
"<.parser>Resuming the <<custMsgObj.storyStr>>.<./parser> ";
}
inputScriptOkay(fname)
{
"<.parser>Reading commands from
<<custMsgObj.ldquoStr>><<fname.htmlify()
>><<custMsgObj.rdquoStr>>...<./parser>\n ";
}
scriptingOkay()
{
"<.parser>Text will now be saved to the script file.
Type <<aHref('script off', 'SCRIPT OFF', 'Turn off scripting')>> to
discontinue scripting.<./parser> ";
}
undoOkay(actor, cmd)
{
"<.parser>Taking back one turn: <<custMsgObj.ldquoStr>>";
if (actor != nil)
"<<actor>>, ";
"<<cmd>><<custMsgObj.rdquoStr>>.<./parser><.p>";
}
undoFailed()
{
"<.parser>No more undo information is
available.<./parser> ";
}
noteWithScript = "<.parser>Comment recorded.<./parser> "
noteWithoutScript = "<.parser>Comment <b>not</b> recorded.<./parser> "
noteWithoutScriptWarning = "<.parser>Comment <b>not</b> recorded.
Use <<aHref('script', 'SCRIPT', 'Begin saving the transcript')
>> if you want to start recording the transcript.<./parser> "
invalidFinishOption(resp)
{
"\bThat is<<custMsgObj.ntAbbr>> one of the options. ";
}
exitsOnOffOkay(stat, look)
{
if (stat && look)
"<.parser>The list of exits will now be shown in both
the status line and in each room description.<./parser> ";
else if (!stat && !look)
"<.parser>The list of exits will no longer be shown in
either the status line or room description.<./parser> ";
else
"<.parser>The list of exits <<stat ? 'will' : 'will not'>> be
shown in the status line, and
<<look ? 'will' : 'wo' + custMsgObj.ntAbbr>>
be included in room descriptions.<./parser> ";
}
sorryHintsDisabled()
{
return '<.parser>Sorry, but hints have been disabled
for this session, as you requested. If '
+ custMsgObj.youveStr + ' changed your mind, '
+ custMsgObj.youllStr + ' have to save your
current position, exit the TADS interpreter,
and start a new interpreter session.<./parser> ';
}
hintsNotPresent = '<.parser>Sorry, ' + custMsgObj.thisStoryStr
+ ' does' + custMsgObj.ntAbbr
+ ' have any built-in hints.<./parser> '
showHintWarning =
"<.notification>Warning: Some people do<<custMsgObj.ntAbbr>>
like built-in hints, since the temptation to ask for help
prematurely can become overwhelming when hints are so close
at hand. If <<custMsgObj.youreStr>> worried that your willpower
<<(libGlobal.useContractions == seldom
|| libGlobal.useContractions == never)
? 'will not' : 'won' + custMsgObj.rsquoPlainStr + 't' >>
hold up, you can disable hints for the
rest of this session by typing <<aHref('hints off', 'HINTS OFF')
>>. If you still want to see the hints now, type
<<aHref('hint', 'HINT')>>.<./notification> "
commandNotPresent = "<.parser>That command is<<custMsgObj.ntAbbr>>
needed in <<custMsgObj.thisStoryStr>>.<./parser> "
scoreNotPresent = "<.parser><<custMsgObj.ThisStoryStr>>
does<<custMsgObj.ntAbbr>> use scoring.<./parser> "
defaultsFileNotSupported = "<.parser>Sorry, but the version of the
TADS interpreter <<custMsgObj.youreStr>> using
does<<custMsgObj.ntAbbr>> support saving or
restoring defaults. You must install a more recent version
in order to use this feature.<./parser> "
textMenuMainPrompt(keylist)
{
"\bSelect a topic number, or press
<<custMsgObj.lsquoStr>><<
keylist[M_PREV][1]>><<custMsgObj.rsquoStr>>
for the previous menu or
<<custMsgObj.lsquoStr>><<
keylist[M_QUIT][1]>><<custMsgObj.rsquoStr>>
to quit:\ ";
}
textMenuTopicPrompt()
{
"\bPress the space bar to display the next line,
<<custMsgObj.lsquoStr>><b>P</b><<custMsgObj.rsquoStr>>
to go to the previous menu, or
<<custMsgObj.lsquoStr>><b>Q</b><<custMsgObj.rsquoStr>>
to quit.\b";
}
menuNextChapter(keylist, title, hrefNext, hrefUp)
{
"Next: <a href='<<hrefNext>>'><<title>></a>;
<b>\^<<keylist[M_PREV][1]>></b>=<a href='<<hrefUp>>'>Menu</a>";
}
soundIsFromWithin(obj, loc)
{
"\^<<obj.theName>>
<<custMsgObj.appearStr>><<obj.verbEndingSEd>> to be
coming from inside <<loc.theNameObj>>. ";
}
soundIsFromWithout(obj, loc)
{
"\^<<obj.theName>>
<<custMsgObj.appearStr>><<obj.verbEndingSEd>> to be
coming from outside <<loc.theNameObj>>. ";
}
smellIsFromWithin(obj, loc)
{
"\^<<obj.theName>>
<<custMsgObj.appearStr>><<obj.verbEndingSEd>> to be
coming from inside <<loc.theNameObj>>. ";
}
smellIsFromWithout(obj, loc)
{
"\^<<obj.theName>>
<<custMsgObj.appearStr>><<obj.verbEndingSEd>> to be
coming from outside <<loc.theNameObj>>. ";
}
roomDarkDesc = "It<<custMsgObj.sOrWasStr>> pitch black. "
notOnboardShip = "That direction {is|was}<<custMsgObj.ntAbbr>>
meaningful {|t}here. "
;
modify playerMessages // superclass = libMessages
commandNotUnderstood(actor)
{
"<.parser><<custMsgObj.TheStoryStr>> does<<custMsgObj.ntAbbr>>
understand that command.<./parser> ";
}
specialTopicInactive(actor)
{
"<.parser>That command <<custMsgObj.cantStr>> be used
right now.<./parser> ";
}
noMatchCannotSee(actor, txt)
{ "\^<<gActor.nameSeesNo>> <<txt>> {|t}here. "; }
noMatchNotAware(actor, txt)
{
"\^<<gActor.nameIsNot>> aware of any <<txt>> {|t}here. ";
}
//"cannot" is permitted here, because it feels right to me
//in this case.
allNotAllowed(actor)
{
//"<.parser><q>All</q> <<custMsgObj.cannotStr>> be used with that verb.<./parser> ";
"<.parser><<custMsgObj.ldquoStr>>All<<custMsgObj.rdquoStr>>
<<(libGlobal.useContractions == usually ||
libGlobal.useContractions == always)
? 'can' + custMsgObj.rsquoPlainStr + 't'
: 'cannot'>>
be used with that verb.<./parser> ";
}
noMatchForAll(actor)
{
"<.parser>\^<<gActor.nameSeesNo>>thing suitable {|t}here.<./parser> ";
}
noMatchForAllBut(actor)
{
"<.parser>\^<<gActor.nameSeesNo>>thing else
{|t}here.<./parser> ";
}
noMatchForPronoun(actor, typ, pronounWord)
{
"<.parser>The word
<<custMsgObj.ldquoStr>><<pronounWord>><<custMsgObj.rdquoStr>>
does<<custMsgObj.ntAbbr>> refer to anything right now.<./parser> ";
}
missingObject(actor, action, which)
{
"<.parser>";
switch (libGlobal.youMustPref) {
case youllHaveTo:
case youdHaveTo: "You<<custMsgObj.rsquoPlainStr>>ll have"; break;
case youllNeedTo:
case youdNeedTo: "You<<custMsgObj.rsquoPlainStr>>ll need"; break;
default: "You need"; break;
}
" to be more specific
about <<action.whatObj(which)>> you want
<<actor.referralPerson == ThirdPerson ? actor.theName : ''>>
to <<action.getQuestionInf(which)>>.<./parser> ";
}
missingLiteral(actor, action, which)
{
"<.parser>Please be more specific
about <<action.whatObj(which)>> to
<<action.getQuestionInf(which)>>. Try, for example,
<<action.getQuestionInf(which)>>
<<custMsgObj.ldquoStr>>something<<custMsgObj.rdquoStr>>.<./parser> ";
}
reflexiveNotAllowed(actor, typ, pronounWord)
{
"<.parser><<custMsgObj.TheStoryStr>>
does<<custMsgObj.ntAbbr>> understand how to use the word
<<custMsgObj.ldquoStr>><<pronounWord>><<custMsgObj.rdquoStr>>
like that.<./parser> ";
}
wrongReflexive(actor, typ, pronounWord)
{
"<.parser><<custMsgObj.TheStoryStr>>
does<<custMsgObj.ntAbbr>> understand what the word
<<custMsgObj.ldquoStr>><<pronounWord>><<custMsgObj.rdquoStr>>
refers to.<./parser> ";
}
noMatchForPossessive(actor, owner, txt)
{
"<.parser>\^<<owner.nameDoes>>
not <<custMsgObj.appearStr>> to have any such thing.<./parser> ";
}
noMatchForPluralPossessive(actor, txt)
{
"<.parser>\^They <<tSel('do', 'did')>> not
<<custMsgObj.appearStr>> to have any such
thing.<./parser> ";
}
noMatchForLocation(actor, loc, txt)
{
"<.parser>\^<<actor.nameSeesNo>>
<<loc.childInName(txt)>>.<./parser> ";
}
noMatchDisambig(actor, origPhrase, disambigResponse)
{
"<.parser>That
was not
one of the choices. ";
}
insufficientQuantity(actor, txt, matchList, requiredNum)
{
"<.parser>\^<<actor.nameDoes>><<custMsgObj.ntAbbr>> see that many
<<txt>> <<tSel('here', 'there')>>.<./parser> ";
}
uniqueObjectRequired(actor, txt, matchList)
{
"<.parser>You <<custMsgObj.cantStr>> use multiple
objects there.<./parser> ";
}
singleObjectRequired(actor, txt)
{
"<.parser>Multiple objects are<<custMsgObj.ntAbbr>> allowed with that
command.<./parser> ";
}
disambigOrdinalOutOfRange(actor, ordinalWord, originalText)
{
"<.parser>There <<custMsgObj.wereNotStr>> that many choices. ";
}
ambiguousNounPhrase(actor, originalText, matchList, fullMatchList)
{
"<.parser><<custMsgObj.TheStoryStr>> does<<custMsgObj.ntAbbr>> know which
<<originalText>> you mean.<./parser> ";
}
cannotChangeActor()
{
"<.parser>You <<custMsgObj.cannotStr>> address more than one
character on a single command line in
<<custMsgObj.thisStoryStr>>.<./parser> ";
}
askUnknownWord(actor, txt)
{
"<.parser>The word
<<custMsgObj.ldquoStr>><<txt>><<custMsgObj.rdquoStr>>
is<<custMsgObj._not>> necessary in
<<custMsgObj.thisStoryStr>>.<./parser> ";
oopsNote();
}
wordIsUnknown(actor, txt)
{
"<.parser><<custMsgObj.TheStoryStr>> does<<custMsgObj.ntAbbr>> understand that
command.<./parser> ";
}
cannotAddressMultiple(actor)
{
"<.parser>\^<<actor.theName>> <<actor.verbCannot>> address
multiple people at once.<./parser> ";
}
;
modify npcMessages // superclass = playerMessages
commandNotHeard(actor)
{
"\^<<actor.nameDoes>><<custMsgObj._not>> respond. ";
}
noMatchCannotSee(actor, txt)
{
"\^<<actor.nameSeesNo>> <<txt>>. ";
}
noMatchNotAware(actor, txt)
{ "\^<<actor.nameIsNot>> aware of any <<txt>>. "; }
noMatchForAll(actor)
{
"<.parser>\^<<actor.nameDoes>><<custMsgObj.ntAbbr>> see anything
suitable.<./parser> ";
}
noMatchForAllBut(actor)
{
"<.parser>\^<<actor.nameSeesNo>>thing
else.<./parser> ";
}
insufficientQuantity(actor, txt, matchList, requiredNum)
{
"<.parser>\^<<actor.nameDoes>><<custMsgObj.ntAbbr>> see that many
<<txt>>.<./parser> ";
}
ambiguousNounPhrase(actor, originalText, matchList, fullMatchList)
{
"<.parser>\^<<actor.nameDoes>><<custMsgObj.ntAbbr>> know which
<<originalText>> you mean<<tSel('', 't')>>.<./parser> ";
}
missingLiteral(actor, action, which)
{
"<.parser>You must be more specific about <<action.whatObj(which)>>
you want <<actor.theNameObj>> to <<action.getQuestionInf(which)>>.
For example: <<actor.theName>>, <<action.getQuestionInf(which)>>
<<custMsgObj.ldquoStr>>something<<custMsgObj.rdquoStr>>.<./parser> ";
}
;
// This default implementation simply doesn't report deferred errors at
// all.
modify npcDeferredMessages // superclass = object
;
modify npcMessagesDirect // superclass = npcMessages
noMatchCannotSee(actor, txt)
{
"\^<<actor.nameVerb('look')>> around.
<<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'do not'
: 'don' + custMsgObj.rsquoPlainStr + 't'>>
see any <<txt>>.<<custMsgObj.rdquoStr>> ";
}
noMatchNotAware(actor, txt)
{
"<<custMsgObj.ldquoStr>><<libGlobal.useContractions == never ?
'I am' : 'I' + custMsgObj.rsquoPlainStr + 'm'>> not aware of any
<<txt>>,<<custMsgObj.rdquoStr>> <<actor.nameSays>>. ";
}
noMatchForAll(actor)
{
"\^<<actor.nameSays>>, <<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'do not'
: 'don' + custMsgObj.rsquoPlainStr + 't'>>
see anything suitable.<<custMsgObj.rdquoStr>> ";
}
noMatchForAllBut(actor)
{
"\^<<actor.nameSays>>, <<custMsgObj.ldquoStr>>I ";
if (!libGlobal.preferCasual)
"see no";
else
"<<libGlobal.useContractions == never ? 'do not'
: 'don' + custMsgObj.rsquoPlainStr + 't'>> see any";
"thing else here.<<custMsgObj.rdquoStr>> ";
}
zeroQuantity(actor, txt)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'cannot'
: 'can' + custMsgObj.rsquoPlainStr + 't'>>
do that to zero of
something.<<custMsgObj.rdquoStr>> ";
}
insufficientQuantity(actor, txt, matchList, requiredNum)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'do not'
: 'don' + custMsgObj.rsquoPlainStr + 't'>>
see that many <<txt>> here.<<custMsgObj.rdquoStr>> ";
}
uniqueObjectRequired(actor, txt, matchList)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'cannot'
: 'can' + custMsgObj.rsquoPlainStr + 't'>>
use multiple objects like that.<<custMsgObj.rdquoStr>> ";
}
singleObjectRequired(actor, txt)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'cannot'
: 'can' + custMsgObj.rsquoPlainStr + 't'>>
use multiple objects like that.<<custMsgObj.rdquoStr>> ";
}
noMatchDisambig(actor, origPhrase, disambigResponse)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>That was<<custMsgObj._not>>
one of the choices. ";
}
disambigOrdinalOutOfRange(actor, ordinalWord, originalText)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>There
<<libGlobal.useContractions == never ? 'were not'
: 'weren' + custMsgObj.rsquoPlainStr + 't'>>
that many choices. ";
}
askDisambig(actor, originalText, matchList, fullMatchList,
requiredNum, askingAgain, dist)
{
reportQuestion('');
if (requiredNum == 1) {
if (!askingAgain)
"\^<<actor.nameVerb('ask')>>, <<custMsgObj.ldquoStr>>";
"Which <<originalText>> do you mean, <<
askDisambigList(matchList, fullMatchList, nil, dist)>>?<<custMsgObj.rdquoStr>> ";
}
else {
if (!askingAgain)
"\^<<actor.nameVerb('ask')>>, <<custMsgObj.ldquoStr>>";
"Which <<spellInt(requiredNum)>> (of <<
askDisambigList(matchList, fullMatchList, true, dist)>>)
do you mean?<<custMsgObj.rdquoStr>> ";
}
}
ambiguousNounPhrase(actor, originalText, matchList, fullMatchList)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'do not'
: 'don' + custMsgObj.rsquoPlainStr + 't'>>
know which
<<originalText>> you mean.<<custMsgObj.rdquoStr>> ";
}
askMissingObject(actor, action, which)
{
reportQuestion('\^' + actor.nameSays
+ ', ' + custMsgObj.ldquoStr + '\^'
+ action.whatObj(which)
+ ' do you want me to '
+ action.getQuestionInf(which)
+ '?' + custMsgObj.rdquoStr + ' ');
}
missingObject(actor, action, which)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'do not'
: 'don' + custMsgObj.rsquoPlainStr + 't'>>
know <<action.whatObj(which)>> you want me to
<<action.getQuestionInf(which)>>.<<custMsgObj.rdquoStr>> ";
}
missingLiteral(actor, action, which)
{
missingObject(actor, action, which);
}
askUnknownWord(actor, txt)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'do not'
: 'don' + custMsgObj.rsquoPlainStr + 't'>>
know the word
<<custMsgObj.lsquoPlainStr>><<txt>><<custMsgObj.rsquoPlainStr
>>.<<custMsgObj.rdquoStr>> ";
}
wordIsUnknown(actor, txt)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>You used a word I
<<libGlobal.useContractions == never ? 'do not'
: 'don' + custMsgObj.rsquoPlainStr + 't'>>
know.<<custMsgObj.rdquoStr>> ";
}
;
modify npcDeferredMessagesDirect// superclass = npcDeferredMessages
commandNotUnderstood(actor)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'did not'
: 'didn' + custMsgObj.rsquoPlainStr + 't'>>
understand what you
meant.<<custMsgObj.rdquoStr>> ";
}
noMatchCannotSee(actor, txt)
{
"\^<<actor.nameSays>>, <<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'did not'
: 'didn' + custMsgObj.rsquoPlainStr + 't'>>
see any <<txt>>.<<custMsgObj.rdquoStr>> ";
}
noMatchNotAware(actor, txt)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>><<libGlobal.useContractions == never
? 'I am' : 'I' + custMsgObj.rsquoPlainStr + 'm'>>
not aware of any <<txt>>.<<custMsgObj.rdquoStr>> ";
}
noMatchForAll(actor)
{
"\^<<actor.nameSays>>, <<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'did not'
: 'didn' + custMsgObj.rsquoPlainStr + 't'>>
see anything suitable.<<custMsgObj.rdquoStr>> ";
}
noMatchForAllBut(actor)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'did not'
: 'didn' + custMsgObj.rsquoPlainStr + 't'>>
see what you
meant.<<custMsgObj.rdquoStr>> ";
}
emptyNounPhrase(actor)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>You left some words
out.<<custMsgObj.rdquoStr>> ";
}
zeroQuantity(actor, txt)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'did not'
: 'didn' + custMsgObj.rsquoPlainStr + 't'>>
understand what you
meant.<<custMsgObj.rdquoStr>> ";
}
insufficientQuantity(actor, txt, matchList, requiredNum)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'did not'
: 'didn' + custMsgObj.rsquoPlainStr + 't'>>
see enough
<<txt>>.<<custMsgObj.rdquoStr>> ";
}
uniqueObjectRequired(actor, txt, matchList)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'did not'
: 'didn' + custMsgObj.rsquoPlainStr + 't'>>
understand what you
meant.<<custMsgObj.rdquoStr>> ";
}
singleObjectRequired(actor, txt)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'did not'
: 'didn' + custMsgObj.rsquoPlainStr + 't'>>
understand what you
meant.<<custMsgObj.rdquoStr>> ";
}
ambiguousNounPhrase(actor, originalText, matchList, fullMatchList)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>I
<<libGlobal.useContractions == never ? 'could not'
: 'couldn' + custMsgObj.rsquoPlainStr + 't'>>
tell which <<originalText>>
you meant.<<custMsgObj.rdquoStr>> ";
}
askMissingObject(actor, action, which)
{
local didntStr;
if (libGlobal.useContractions == never)
didntStr = 'did not';
else
didntStr = 'didn' + custMsgObj.rsquoPlainStr + 't';
reportQuestion('\^' + actor.nameSays
+ ', ' + custMsgObj.ldquoStr
+ 'I ' + didntStr + ' know '
+ action.whatObj(which) + ' you wanted me to '
+ action.getQuestionInf(which)
+ '.' + custMsgObj.rdquoStr + ' ');
}
wordIsUnknown(actor, txt)
{
"\^<<actor.nameSays>>,
<<custMsgObj.ldquoStr>>You used a word I
<<libGlobal.useContractions == never ? 'do not'
: 'don' + custMsgObj.rsquoPlainStr + 't'>>
know.<<custMsgObj.rdquoStr>> ";
}
;
// 2019-05-18: This one's done
modify playerActionMessages // superclass = MessageHelper
mustBeHoldingMsg(obj)
{
gMessageParams(obj);
return '{You_would_have_to} be holding {the obj/him}
to do that. ';
}
tooDarkMsg = 'It' + custMsgObj.sOrWasStr + ' too dark to do that. '
cannotBeWearingMsg(obj)
{
gMessageParams(obj);
return '{You_would_have_to} take off {the obj/him} before
{you_could} do that. ';
}
mustBeEmptyMsg(obj)
{
gMessageParams(obj);
return '{You_would_have_to} take everything out of
{the obj/him} before {you_could} do that. ';
}
mustBeOpenMsg(obj)
{
gMessageParams(obj);
return '{You_would_have_to} open {the obj/him} before
{you_could} do that. ';
}
mustBeClosedMsg(obj)
{
gMessageParams(obj);
return '{You_would_have_to} close {the obj/him} before
{you_could} do that. ';
}
mustBeUnlockedMsg(obj)
{
gMessageParams(obj);
return '{You_would_have_to} unlock {the obj/him} before
{you_could} do that. ';
}
noKeyNeededMsg = '{The dobj/he} {does}{_not} ' +
custMsgObj.appearStr + ' to take a key. '
mustBeStandingMsg =
'{You_would_have_to} stand up before
{you_could} do that. '
mustSitOnMsg(obj)
{
gMessageParams(obj);
return '{You_would_have_to} sit {in obj} first. ';
}
mustLieOnMsg(obj)
{
gMessageParams(obj);
return '{You_would_have_to} lie {in obj} first. ';
}
mustGetOnMsg(obj)
{
gMessageParams(obj);
return '{You_would_have_to} get {in obj} first. ';
}
mustBeInMsg(obj, loc)
{
gMessageParams(obj, loc);
return '{You_would_have_to} be {in loc} before
{you_could} do that. ';
}
mustBeCarryingMsg(obj, actor)
{
// Note that gActor.itCould actually fixes a bug in TADS 3.0.9
// whereby a third-person Actor's name could be mentioned in both
// the subject and predicate.
gMessageParams(obj, actor);
return '{You_would_have_to} be holding {the obj/him} before
{you_could} do that. ';
}
decorationNotImportantMsg(obj)
{
gMessageParams(obj);
return '{The obj/he} {is}{n\'t} important. ';
}
unthingNotHereMsg(obj)
{
gMessageParams(obj);
return '{You/he} {does}{n\'t} see {that obj/him} {|t}here. ';
}
thingDescMsg(obj)
{
gMessageParams(obj);
return '{You_see_no}thing unusual about '
+ '{it obj/him}. ';
}
thingSoundDescMsg(obj)
{
local hearNo;
// As a fail-safe, if gActor is nil, return an empty string.
// This will prevent the game from crashing in this unlikely
// scenario.
if (!gActor)
return '';
if (!libGlobal.preferCasual)
hearNo = 'hear' + gActor.verbEndingSD + ' no';
else
hearNo = gActor.verbToDo + custMsgObj.ntAbbr + ' hear any';
return '{You/he} ' + hearNo + 'thing out of the ordinary. ';
}
thingSmellDescMsg(obj)
{
local smellNo;
// As a fail-safe, if gActor is nil, return an empty string.
// This will prevent the game from crashing in this unlikely
// scenario.
if (!gActor)
return '';
if (!libGlobal.preferCasual)
smellNo = 'smell' + gActor.verbEndingSEd + ' no';
else
smellNo = gActor.verbToDo + custMsgObj.ntAbbr + ' smell any';
return '{You/he} ' + smellNo + 'thing out of the ordinary. ';
}
npcDescMsg(npc)
{
gMessageParams(npc);
return '{You_see_no}thing unusual about '
+ '{the npc/him}. ';
}
nothingInsideMsg =
'There' + custMsgObj.sOrWasStr + ' nothing unusual in {the dobj/him}. '
nothingUnderMsg =
'{You_see_no}thing unusual under {the dobj/him}. '
nothingBehindMsg =
'{You_see_no}thing unusual behind {the dobj/him}. '
nothingThroughMsg
{
if (!libGlobal.preferCasual)
return '{You/he} {can} see nothing through {the dobj/him}. ';
else
return '{You/he} {can\'t} see anything through {the dobj/him}. ';
}
nothingToSmellMsg
{
local smellNo;
// As a fail-safe, if gActor is nil, return an empty string.
// This will prevent the game from crashing in this unlikely
// scenario.
if (!gActor)
return '';
if (!libGlobal.preferCasual)
smellNo = 'smell' + gActor.verbEndingSEd + ' no';
else
smellNo = gActor.verbToDo + custMsgObj.ntAbbr + ' smell any';
return '{You/he} ' + smellNo + 'thing out of the ordinary. ';
}
nothingToHearMsg
{
local hearNo;
// As a fail-safe, if gActor is nil, return an empty string.
// This will prevent the game from crashing in this unlikely
// scenario.
if (!gActor)
return '';
if (!libGlobal.preferCasual)
hearNo = 'hear' + gActor.verbEndingSD + ' no';
else
hearNo = gActor.verbToDo + custMsgObj.ntAbbr + ' hear any';
return '{You/he} ' + hearNo + 'thing out of the ordinary. ';
}
notWearableMsg
{
return '{That_isn\'t dobj} something {you/he} {can} wear. ';
}
notDoffableMsg
{
return '{That_isn\'t dobj} something {you/he} {can} remove. ';
}
cannotDigWithMsg =
'{You_see_no} way to use {that iobj/him} as a shovel. '
alreadyHoldingMsg()
{
return '{You_are} already carrying {the dobj/him}. ';
}
cannotMovePushableMsg = 'It would'
+ custMsgObj.ntAbbr + ' {|have} accomplish{|ed} anything
to move {the dobj/him} around aimlessly, but {it actor/he}
might {be|have been} able to push {it dobj/him} in a specific
direction. '
cannotTakeActorMsg = '{The dobj/he} {won\'t} let {you/him} do that. '
cannotMoveActorMsg = '{The dobj/he} {won\'t} let {you/him} do that. '
cannotPutActorMsg = '{The dobj/he} {won\'t} let {you/him} do that. '
cannotTasteActorMsg = '{The dobj/he} {won\'t} let {you/him} do that. '
cannotTakePersonMsg =
'{The dobj/he} probably would{n\'t} {|have} like{|d} that. '
cannotMovePersonMsg =
'{The dobj/he} probably would{n\'t} {|have} like{|d} that. '
cannotPutPersonMsg =
'{The dobj/he} probably would{n\'t} {|have} like{|d} that. '
cannotTastePersonMsg =
'{The dobj/he} probably would{n\'t} {|have} like{|d} that. '
totalTooHeavyForMsg(obj)
{
local youWill;
// As a fail-safe, if gActor is nil, return an empty string.
// This will prevent the game from crashing in this unlikely
// scenario.
if (!gActor)
return '';
gMessageParams(obj);
if ( (libGlobal.useContractions == usually ||
libGlobal.useContractions == always)
&& gActor.referralPerson != ThirdPerson) {
// "I'll", "you'll", "we'll"
youWill = gActor.theName + custMsgObj.rsquoPlainStr + 'll';
}
else
youWill = gActor.theName + ' ' + gActor.verbWill;
return '{The obj/he} {is} too heavy; ' + youWill + ' have to put
something else down first. ';
}
surfaceTooFullMsg(obj, cont)
{
gMessageParams(obj, cont);
return 'There' + custMsgObj.sOrWasStr + ' no room for {the obj/him} on '
+ '{the cont/him}. ';
}
undersideTooFullMsg(obj, cont)
{
gMessageParams(obj, cont);
return 'There' + custMsgObj.sOrWasStr + ' no room for {the obj/him} under '
+ '{the cont/him}. ';
}
rearTooFullMsg(obj, cont)
{
gMessageParams(obj, cont);
return 'There' + custMsgObj.sOrWasStr + ' no room for {the obj/him} behind '
+ '{the cont/him}. ';
}
notASurfaceMsg = 'There' + custMsgObj.sOrWasStr + ' no good surface on {the iobj/him}. '
objNotForKeyringMsg = '{The dobj/he} {does}{n\'t} fit on {the iobj/him}. '
keyNotOnKeyringMsg = '{The dobj/he} {is}{_not} attached to {the iobj/him}. '
keyNotDetachableMsg = '{The dobj/he} {is}{n\'t} attached to anything. '
takeFromNotInMsg = '{The dobj/he} {is}{n\'t} in {that iobj/him}. '
takeFromNotOnMsg = '{The dobj/he} {is}{n\'t} on {that iobj/him}. '
takeFromNotUnderMsg = '{The dobj/he} {is}{n\'t} under {that iobj/him}. '
takeFromNotBehindMsg = '{The dobj/he} {is}{n\'t} behind {that iobj/him}. '
takeFromNotInActorMsg = '{The iobj/he} {does}{n\'t} have {that dobj/him}. '
whereToGoMsg ()
{
return '\^' + custMsgObj.youllStr + ' have to say which way to go. ';
}
cannotGoThatWayInDarkMsg = 'It' + custMsgObj.sOrWasStr + ' too dark; {you/he} {can\'t} see
where {you\'re} going. '
cannotGoBackMsg = '{You/he} {does}{n\'t} know how to return from {|t}here. '
nestedRoomTooHighToExitMsg(obj)
{
return 'It' + custMsgObj.sOrWasStr + ' too long a drop to do that from {|t}here. ';
}
mustOpenDoorMsg(obj)
{
gMessageParams(obj);
return '{You_would_have_to} open {the obj/him} first. ';
}
addressingNoOneMsg
{
return '\^' + custMsgObj.youWillStr + ' have to be more specific about '
+ libMessages.whomPronoun + ' {it actor/he} want{s/ed} to talk to. ';
}
cannotJumpOffHereMsg = 'There' + custMsgObj.sOrWasStr + ' nowhere to jump from {|t}here. '
refuseCommand(targetActor, issuingActor)
{
gMessageParams(targetActor, issuingActor);
return '{The targetActor/he} refuse{s/ed} {your/his} request. ';
}
noResponseFromMsg(other)
{
gMessageParams(other);
return '{The other/he} {does}{_not} respond. ';
}
cannotTalkToSelf = 'Talking to {yourself/himself}
{won\'t} accomplish anything. '
cannotTalkToSelfMsg = 'Talking to {yourself/himself}
{won\'t} accomplish anything. '
cannotAskSelfMsg = 'Talking to {yourself/himself}
{won\'t} accomplish anything. '
cannotAskSelfForMsg = 'Talking to {yourself/himself}
{won\'t} accomplish anything. '
cannotTellSelfMsg = 'Talking to {yourself/himself}
{won\'t} accomplish anything. '
cannotGiveToSelfMsg = 'Giving {the dobj/him} to {yourself/himself}
{won\'t} accomplish anything. '
cannotGiveToItselfMsg = 'Giving {the dobj/him} to {itself}
{won\'t} accomplish anything. '
cannotShowToSelfMsg = 'Showing {the dobj/him} to {yourself/himself}
{won\'t} accomplish anything. '
cannotShowToItselfMsg = 'Showing {the dobj/him} to {itself}
{won\'t} accomplish anything. '
notInterestedMsg(actor)
{
return '\^' + actor.nameDoes + custMsgObj._not + ' '
+ custMsgObj.appearStr + ' interested. ';
}
askVagueMsg = '<.parser>The story doesn' + custMsgObj.rsquoStr + 't
understand that command. Please use ASK ACTOR ABOUT TOPIC
(or just A TOPIC).<./parser> '
tellVagueMsg = '<.parser>The story doesn' + custMsgObj.rsquoStr + 't
understand that command. Please use TELL ACTOR ABOUT TOPIC
(or just T TOPIC).<./parser> '
objCannotHearActorMsg(obj)
{
return '\^' + obj.nameDoes
+ custMsgObj._not + ' ' + custMsgObj.appearStr
+ ' to hear {you/him}. ';
}
actorCannotSeeMsg(actor, obj)
{
return '\^' + actor.nameDoes + custMsgObj._not
+ ' ' + custMsgObj.appearStr
+ ' to be able to see ' + obj.theNameObj + '. ';
}
setToInvalidMsg
{
return '{The dobj/he} {has} no such setting. ';
// I was going to do the following, but I think I prefer the
// message as it originally stood.
//return '{The dobj/he} ' + gDobj.hasNo + ' such setting. ';
}
mustSpecifyTurnToMsg()
{
return '\^' + custMsgObj.youWillStr + ' have to specify the setting to
turn {it dobj/him} to. ';
}
turnToInvalidMsg
{
return '{The dobj/he} {has} no such setting. ';
// I was going to do the following, but I think I prefer the
// message as it originally stood.
//return '{The dobj/he} ' + gDobj.hasNo + ' such setting. ';
}
mustBeBurningMsg(obj)
{
return '{You_would_have_to} light ' + obj.theNameObj
+ ' before {you_could} do that. ';
}
matchNotLitMsg = '{The dobj/he} {is}{n\'t} lit. '
candleNotLitMsg = '{The dobj/he} {is}{_not} lit. '
cannotConsultMsg
{
return '{That_is_not dobj} something {you/he} {can} consult. ';
}
cannotTurnOnMsg
{
return '{That_isn\'t dobj} something {you/he} {can} turn on. ';
}
cannotTurnOffMsg
{
return '{That_isn\'t dobj} something {you/he} {can} turn off. ';
}
cannotBurnMsg
{
return '{That_is_not dobj} something {you/he} {can} burn. ';
}
cannotPourMsg
{
return '{That_is_not dobj} something {you/he} {can} pour. ';
}
mustDetachMsg(obj)
{
// Note that gActor.itCould actually fixes a bug in TADS 3.0.9
// whereby a third-person Actor's name could be mentioned in both
// the subject and predicate.
gMessageParams(obj);
return '{You_would_have_to} detach {the obj/him} before
{you_could} do that. ';
}
cannotDetachPermanentMsg =
'There' + custMsgObj.sOrWasStr + ' no obvious way to detach {that dobj/him}. '
notAttachedToMsg = '{The dobj/he} {is}{n\'t} attached to {that iobj/him}. '
shouldNotBreakMsg =
'Breaking {that dobj/him} would {|have} serve{|ed} no purpose. '
cannotClimbMsg
{
return '{That_is_not dobj} something {you/he} {can} climb. ';
}
cannotOpenMsg
{
return '{That_is_not dobj} something {you/he} {can} open. ';
}
cannotCloseMsg
{
return '{That_is_not dobj} something {you/he} {can} close. ';
}
cannotLockMsg
{
return '{That_is_not dobj} something {you/he} {can} lock. ';
}
cannotUnlockMsg
{
return '{That_is_not dobj} something {you/he} {can} unlock. ';
}
cannotLockWithMsg =
'{The iobj/he} {does}{n\'t} look suitable for locking that. '
cannotUnlockWithMsg =
'{The iobj/he} {does}{n\'t} look suitable for unlocking that. '
unknownHowToLockMsg =
'It' + custMsgObj.sOrWasStr + ' not clear how to lock {the dobj/him}. '
unknownHowToUnlockMsg =
'It' + custMsgObj.sOrWasStr + ' not clear how to unlock {the dobj/him}. '
keyDoesNotFitLockMsg = '{The iobj/he} {does}{n\'t} fit the lock. '
cannotEatMsg = '{The dobj/he} {does}{_not} ' + custMsgObj.appearStr +
' to be edible. '
cannotDrinkMsg = '{That dobj/he} {does}{_not} ' + custMsgObj.appearStr +
' to be something
{you/he} {can} drink. '
cannotCleanMsg =
'{You/he} would{n\'t} {|have} know{|n} how to clean {that dobj/him}. '
cannotSleepMsg = '{You/he} {does}{n\'t} need to sleep right now. '
cannotSitOnMsg
{
return '{That_isn\'t dobj} something {you/he} {can} sit on. ';
}
cannotLieOnMsg
{
return '{That_isn\'t dobj} something {you/he} {can} lie on. ';
}
noRoomToStandMsg =
'There' + custMsgObj.sOrWasStr + ' no room for {you/him} to stand {on dobj}. '
noRoomToSitMsg =
'There' + custMsgObj.sOrWasStr + ' no room for {you/him} to sit {on dobj}. '
noRoomToLieMsg =
'There' + custMsgObj.sOrWasStr + ' no room for {you/him} to lie {on dobj}. '
okayPostureChangeMsg(posture)
{ return 'Okay, {you\'re} now ' + posture.participle + '. '; }
cannotPlugInMsg = '{You_see_no} way to plug in {the dobj/him}. '
cannotPlugInToMsg =
'{You_see_no} way to plug anything into {the iobj/him}. '
cannotUnplugMsg = '{You_see_no} way to unplug {the dobj/him}. '
cannotUnplugFromMsg =
'{You_see_no} way to unplug anything from {the iobj/him}. '
cannotScrewMsg = '{You_see_no} way to screw {the dobj/him}. '
cannotUnscrewMsg = '{You_see_no} way to unscrew {the dobj/him}. '
cannotUnscrewWithMsg =
'{You/he} {cannot} unscrew anything with {the iobj/him}. '
cannotEnterMsg
{
return '{That_is_not dobj} something {you/he} {can} enter. ';
}
cannotGoThroughMsg
{
return '{That_is_not dobj} something {you/he} {can} go through. ';
}
cannotThrowAtSelfMsg =
'{You/he} {can\'t} throw {that dobj/him} at {itself}. '
cannotThrowAtContentsMsg()
{
return '{You_would_have_to} remove {the iobj/him}
from {the dobj/him} before {you_could} do that. ';
}
willNotCatchMsg(catcher)
{
return '\^' + catcher.nameDoes + custMsgObj.ntAbbr
+ ' look like ' + catcher.itNom + ' want'
+ catcher.verbEndingSEd + ' to catch anything. ';
}
cannotKissActorMsg
= '{The dobj/he} probably would{n\'t} {|have} like{|d} that. '
newlyDarkMsg()
{
local isOrWas;
if (gameMain.usePastTense)
isOrWas = ' was';
else if (libGlobal.useContractions == usually ||
libGlobal.useContractions == always)
isOrWas = custMsgObj.rsquoPlainStr + 's';
else
isOrWas = ' is';
return 'It' + isOrWas + ' now pitch black. ';
}
;
modify npcActionMessages // superclass = playerActionMessages
cannotRemoveHeldMsg = 'There' + custMsgObj.sOrWasStr
+ ' nothing to remove {the dobj/him} from. '
whereToGoMsg()
{
return '\^' + custMsgObj.youllStr
+ ' have to say which way {you/he} should {|have} go{|ne}. ';
}
surfaceTooFullMsg(obj, cont)
{
gMessageParams(obj, cont);
return '{You/he} {cannot} do that because there' + custMsgObj.sOrWasStr + '
no room for {the obj/him} on {the cont/him}. ';
}
objNotForKeyringMsg = '{You/he} {cannot} do that because
{that dobj/he} {does}{n\'t} fit on {the iobj/him}. '
takeFromNotInMsg = '{You/he} {cannot} do that because
{the dobj/he} {is}{n\'t} in {that iobj/him}. '
takeFromNotOnMsg = '{You/he} {cannot} do that because
{the dobj/he} {is}{n\'t} on {that iobj/him}. '
takeFromNotUnderMsg = '{You/he} {cannot} do that because
{the dobj/he} {is}{n\'t} under {that iobj/him}. '
takeFromNotBehindMsg = '{You/he} {cannot} do that because
{the dobj/he} {is}{n\'t} behind {that iobj/him}. '
cannotJumpOffHereMsg = 'There' + custMsgObj.sOrWasStr + ' nowhere for {you/him} to jump. '
shouldNotBreakMsg = '{You/he} {does}{n\'t} want to break {that dobj/him}. '
keyDoesNotFitLockMsg = '{You/he} tr{ies/ied} {the iobj/he}, but
{it iobj/he} {does}{n\'t} fit the lock. '
okayFollowModeMsg()
{
local iWill;
if (libGlobal.useContractions == usually ||
libGlobal.useContractions == always)
iWill = 'I' + custMsgObj.rsquoPlainStr + 'll';
else
iWill = 'I will';
return custMsgObj.ldquoPlainStr + 'Okay, ' + iWill
+ ' follow {the dobj/him}.'
+ custMsgObj.rdquoPlainStr + ' ';
}
alreadyFollowModeMsg = custMsgObj.ldquoStr
+ 'I' + custMsgObj.rsquoPlainStr + 'm already following
{the dobj/him}.' + custMsgObj.rdquoStr + ' '
;
// Tip modifications:
modify scoreChangeTip
desc =
"If <<custMsgObj.youdStr>>
prefer not to be notified about
score changes in the future, type <<
aHref('notify off', 'NOTIFY OFF', 'Turn off score notifications')
>>."
;
modify footnotesTip
desc =
"A number in [square brackets] like the one above refers to a footnote,
which you can read by typing FOOTNOTE followed by the number:
<<aHref('footnote 1', 'FOOTNOTE 1', 'Show footnote [1]')>>, for example.
Footnotes usually contain added background information that might be
interesting but is<<custMsgObj.ntAbbr>> essential to the story.
If <<custMsgObj.youdStr>> prefer not to see footnotes at all,
you can control their appearance by typing
<<aHref('footnotes', 'FOOTNOTES',
'Control footnote appearance')>>.<./notification> "
;
// no need to modify oopsTip
// no need to modify fullScoreTip
// no need to modify exitsTip
modify undoTip
desc() {
local didntStr;
if (libGlobal.useContractions == never)
didntStr = 'did not';
else
didntStr = 'didn' + custMsgObj.rsquoPlainStr + 't';
"If this <<didntStr>> turn out quite the way you expected, note that you
can always take back a turn by typing <<aHref('undo', 'UNDO',
'Take back the most recent command')>>. You can even use
UNDO repeatedly to take back several turns in a row. ";
}
;
// Only a few of msg_neu.t's listers had to be modified.
modify actorInventoryLister // superclass = DividedInventoryLister
showInventoryWearingOnly(parent, wearing)
{
//if (libGlobal.preferCasual)
// "\^<<parent.nameIsnt>> carrying anything,
// and <<parent.verbToBe>> wearing <<wearing>>. ";
//else
// "<<buildSynthParam('The/he', parent)>> {is} carrying
// nothing, and {is} wearing <<wearing>>. ";
if (libGlobal.preferCasual)
"\^<<parent.nameIsnt>> carrying anything, and ";
else
"\^<<parent.nameIs>> carrying nothing, and ";
// "You're carrying nothing, and you're wearing a hat", rather than
// "You're carrying nothing, and are wearing a hat."
if ((libGlobal.useContractions == usually ||
libGlobal.useContractions == always)
&& (parent.referralPerson == FirstPerson ||
parent.referralPerson == SecondPerson))
"<<parent.itIsContraction>> ";
else
"<<parent.verbToBe>> ";
"wearing <<wearing>>. ";
}
;
modify thingLookInLister // superclass = DescContentsLister, BaseThingContentsLister
showListEmpty(pov, parent)
{
gMessageParams(parent);
defaultDescReport('\^' + gActor.nameSeesNo
+ 'thing unusual in {the parent/him}. ');
}
;
modify surfaceLookInLister // superclass = DescContentsLister, BaseSurfaceContentsLister
showListEmpty(pov, parent)
{
gMessageParams(parent);
defaultDescReport('\^' + gActor.nameSeesNo
+ 'thing on {the parent/him}. ');
}
;
modify undersideLookUnderLister // superclass = DescContentsLister, BaseUndersideContentsLister
showListEmpty(pov, parent)
{
gMessageParams(parent);
defaultDescReport('\^' + gActor.nameSeesNo
+ 'thing under {the parent/him}. ');
}
;
modify rearLookBehindLister // superclass = DescContentsLister, BaseRearContentsLister
showListEmpty(pov, parent)
{
gMessageParams(parent);
defaultDescReport('\^' + gActor.nameSeesNo
+ 'thing behind {the parent/him}. ');
}
;
modify SuggestedTopicLister
showListEmpty(pov, parent)
{
if (isExplicit)
{
gMessageParams(askingActor, targetActor);
"<<isExplicit ? '' : '('>>\^<<libGlobal.preferCasual
? askingActor.theName + ' ' + askingActor.verbToDo
+ custMsgObj.ntAbbr + ' have any'
: askingActor.theName + ' ' + askingActor.verbToHave + ' no'
>>thing
specific in mind right now to discuss with
{the targetActor/him}.<<isExplicit ? '' : ')'>> ";
}
}
;

Xet Storage Details

Size:
96.4 kB
·
Xet hash:
16b8fd31dd5e5f4bb3218810757c8890f441bc3005243e641d3d7da0f7748406

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.