advlite.h file | source file

TADS 3 Library - main header

This file provides definitions of macros, properties, and other identifiers used throughout the library and in game source.

Each source code file in the library and in a game should generally #include this header near the top of the source file.

Summary of Classes

(none)

Summary of Global Functions

(none)

Summary of Macros

`_STRINGIZE _STRINGIZE abort abortImplicit accFor accList ADV3LITE_H AHREF_Plain aMood aMoodIn aMoodIs aobjFor aobjList asAccFor asAobjFor asDobjFor asDobjWithoutActionFor asDobjWithoutVerifyFor aSetMood aSetStance asExit asExitListed asIobjFor asIobjWithoutActionFor asIobjWithoutVerifyFor askForAcc askForAccX askForAobj askForAobjX askForDobj askForDobjX askForIobj askForIobjX asObjFor asObjWithoutActionFor asObjWithoutVerifyFor aStance aStanceIn aStanceIs AudioLink BMsg BMsg BV cannotTouchMsg canSwichOffMe canSwichOnMe canSwitchMeOff canSwitchMeOn checkHitMsg checkTouchMsg ConversationLullReason dangerous DCT DefaultTopicReason DefineAction DefineIAction DefineLiteralAction DefineLiteralTAction DefineNumericAction DefineNumericTAction DefineSystemAction DefineTAction DefineTActionSub DefineTIAAction DefineTIAActionSub DefineTIAction DefineTIActionSub DefineTopicAction DefineTopicTAction DefMood DefSignal DefStance DMsg DMsg dobjFor dobjList exit exitAction exitCommandLine feelResponseMsg gAcc gAction gActionIn gActionIs gActionList gActionListObj gActionListStr gActor gActorRoom gAobj gCommand gCommandToks gDobj gExitLister gExtraHintManager gFact gFactDesc gHintManager gInformed gIobj gKnown gLastAction gLastCommand gLastFact gLastTopic gLibMessages gLiteral gLocation gMessageParams gMood gMoodIn gMoodIs gNumber goInstead goNested gOutStream gPlayerChar gReveal gRevealed gRoom gSetKnown gSetMood gSetSeen gSetStance gStance gStanceIn gStanceIs gTentativeDobj gTentativeDobjIn gTentativeIobj gTentativeIobjIn gTopic gTopicMatch gTopicText gTravelActionIs gTurns gUnreveal gVerbPhrase gVerbWord gVerifyDobj gVerifyIobj gVerifyList hitResponseMsg IfDebug IfDebug illogical illogicalAlready illogicalNow illogicalSelf implausible inaccessible INF InitiateConversationReason input iobjFor iobjList isClimbDownable isClimbUpable isCutable isDigable isDropable isEatable isEnterOnable isFlipable isGoAlongable isGoThroughable isGoThruable isJumpOffable isJumpOverable isLieOnable isLooBehindable isLookThroughable isLookThrughable isLookUnderable isPluggable isPotable isPushTravelable isSetable isSetToable isSitOnable isStandOnable isSwitchOffable isSwitchOnable isTouchable isTurnToable isTypeOnable isUnpluggable isWriteOnAble iTag literalAcc literalAobj literalDobj literalIobj logical logicalRank M_DOWN M_PREV M_QUIT M_SEL M_UP mainReport MatchAdj MatchNoApprox MatchNoTrunc MatchNoun MatchPartMask MatchPhrase MatchPlural MatchPrep MatchStrengthMask MatchWeak MMTIAction more Msg multiAcc multiAobj multiDobj multiIobj NCT NEC nextrule nonObvious nostop npcKnows numberDobj numericAcc numericAobj numericDobj numericIobj objFor pcKnows reportAfter reportPostImplicit RNF rnull rTag SelArbitrary SelDefault SelDisambig SelPlural SelProg setPastTense singleAcc singleAobj singleDir singleDobj singleIobj skip sLoc Sta stop STRINGIZE STRINGIZE topicAcc topicAobj topicDobj topicIobj tSel tvo UsePronoun VerbRule VideoLink waitKey withPast withPresent`

Summary of Enums

`ClosedGoal dubious feminine FootnotesFull FootnotesMedium FootnotesOff indirectLockable large likely lockableWithKey lockableWithoutKey manyToMany manyToOne masculine medium neuter normalRelation notLockable null oneToMany oneToOne OpenGoal OtherObject reverseRelation rmcAskLiteral rmcAskObject rmcCommand rmcDisambig rmcOops small UndiscoveredGoal unlikely untrue`

Summary of Templates

`Achievement ActorState ActorTopicEntry AltTopic AltTopic ClockEvent CommandTopic CommandTopic CustomMessages DefaultConsultTopic DefaultThought DefaultTopic Doer Door Door DSCon DSTravelConnector DSTravelConnector Enterable Enterable EventList EventListItem ExtraHint Fact Footnote Goal Hint MenuItem MenuLongTopicItem MenuTopicItem MiscTopic MiscTopic NodeContinuationTopic NodeContinuationTopic ProxyActor QueryTopic QueryTopic QueryTopic QueryTopic QueryTopic QueryTopic Region Relation Room Room Rule Rule SayTopic Scenery SensoryEmanation ShuffledEventList SpecialVerb string string string string string string string string string string string string string string string string string StyleTag SymConnector SymConnector SymPassage SymPassage SymPassage SymPassage Test Test Thing Tip Topic TopicEntry TopicEntry TopicEntry TopicEntry TopicGroup TravelConnector TravelConnector Unthing Unthing`

Global Functions

(none)

Macros

`_STRINGIZE (x)` | `advlite.h[265]`

`#@x`
A couple of utility macros we use internally for turning macro values into strings. STRINGIZE(x) expands any macros in its argument and then turns the result into a single-quoted string, which can then be used in regular program text or in directives that evaluate constant expressions, such as #if. (STRINGIZE is the real macro; _STRINGIZE is needed to force expansion of any macros in the argument, which is required because of the weird ANSI C expansion-order rules, and which works because of same.)

`_STRINGIZE (x)` | `advlite.h[1031]`

`#@x`
A couple of utility macros we use internally for turning macro values into strings. STRINGIZE(x) expands any macros in its argument and then turns the result into a single-quoted string, which can then be used in regular program text or in directives that evaluate constant expressions, such as #if. (STRINGIZE is the real macro; _STRINGIZE is needed to force expansion of any macros in the argument, which is required because of the weird ANSI C expansion-order rules, and which works because of same.)

`abort` | `advlite.h[745]`

`throw new AbortActionSignal()`
a concise macro to throw an Abort signal

`abortImplicit` | `advlite.h[742]`

`throw new AbortImplicitSignal()`
a concise macro to throw an AbortImplicitSignal

`accFor (action)` | `advlite.h[679]`

`objFor(Aobj, action)`
no description available

`accList` | `advlite.h[74]`

`nounList->accMatch`
no description available

`ADV3LITE_H` | `advlite.h[16]`

``
no description available

`AHREF_Plain` | `advlite.h[754]`

`0x0001 /* plain text hyperlink (no underline/color) */`
aHref() flags

`aMood (actor)` | `advlite.h[1533]`

`(actor.mood)`
What mood is actor in?

`aMoodIn (actor, mood_, ...)` | `advlite.h[1543]`

`(actor.mood is in (mood_#foreach: mood_##Mood:, :))`
Is actor in one of these moods?

`aMoodIs (actor, mood_)` | `advlite.h[1536]`

`(actor.mood == mood_ ## Mood)`
Is actor in this mood?

`aobjFor (action)` | `advlite.h[677]`

`objFor(Aobj, action)`
no description available

`aobjList` | `advlite.h[75]`

`nounList->accMatch`
no description available

`asAccFor (action)` | `advlite.h[680]`

`asObjFor(Aobj, action)`
no description available

`asAobjFor (action)` | `advlite.h[678]`

`asObjFor(Aobj, action)`
no description available

`asDobjFor (action)` | `advlite.h[461]`

`asObjFor(Dobj, action)`
no description available

`asDobjWithoutActionFor (action)` | `advlite.h[481]`

`asObjWithoutActionFor(Dobj, action)`
no description available

`asDobjWithoutVerifyFor (action)` | `advlite.h[493]`

`asObjWithoutVerifyFor(Dobj, action)`
no description available

`aSetMood (actor, mood_)` | `advlite.h[1552]`

`(actor.setMood(mood_ ## Mood))`
no description available

`aSetStance (actor, st_)` | `advlite.h[1548]`

`(actor.setStanceToward(gPlayerChar, st_ ## Stance))`
no description available

`asExit (dir)` | `advlite.h[514]`

`: UnlistedProxyConnector { direction = dir##Dir }`
no description available

`asExitListed (dir)` | `advlite.h[515]`

`: UnlistedProxyConnector { direction = dir##Dir isConnectorListed = true}`
no description available

`asIobjFor (action)` | `advlite.h[462]`

`asObjFor(Iobj, action)`
no description available

`asIobjWithoutActionFor (action)` | `advlite.h[482]`

`asObjWithoutActionFor(Iobj, action)`
no description available

`asIobjWithoutVerifyFor (action)` | `advlite.h[494]`

`asObjWithoutVerifyFor(Iobj, action)`
no description available

`askForAcc (action)` | `advlite.h[499]`

`askMissingObject(action, AccessoryObject)`
no description available

`askForAccX (action)` | `advlite.h[504]`

`askMissingObject(action, AccessoryObject, nil)`
no description available

`askForAobj (action)` | `advlite.h[498]`

`askMissingObject(action, AccessoryObject)`
no description available

`askForAobjX (action)` | `advlite.h[503]`

`askMissingObject(action, AccessoryObject, nil)`
no description available

`askForDobj (action)` | `advlite.h[496]`

`askMissingObject(action, DirectObject)`
no description available

`askForDobjX (action)` | `advlite.h[501]`

`askMissingObject(action, DirectObject, nil)`
no description available

`askForIobj (action)` | `advlite.h[497]`

`askMissingObject(action, IndirectObject)`
no description available

`askForIobjX (action)` | `advlite.h[502]`

`askMissingObject(action, IndirectObject, nil)`
no description available

`asObjFor (obj, Action)` | `advlite.h[451]`

`{ \
preCond { return preCond##obj##Action; } \
verify() { verify##obj##Action; } \
remap() { return remap##obj##Action; } \
check() { check##obj##Action; } \
action() { action##obj##Action; } \
report() { report##obj##Action; } \
}`
Treat an object definition as equivalent to another object definition. These can be used immediately after a dobjFor() or iobjFor() to treat the first action as though it were the second. So, if the player types "search box", and we want to treat the direct object the same as for "look in box", we could make this definition for the box:

dobjFor(Search) asDobjFor(LookIn)

Note that no semicolon is needed after this definition, and that this definition is completely in lieu of a regular property set for the object action.

In general, a mapping should NOT change the role of an object: dobjFor(X) should not usually be mapped using asIobjFor(Y), and iobjFor(X) shouldn't be mapped using asDobjFor(Y). The problem with changing the role is that the handler routines often assume that the object is actually in the role for which the handler was written; a verify handler might refer to '{dobj}' in generating a message, for example, so reversing the roles would give the wrong object in the role.

Role reversals should always be avoided, but can be used if necessary under conditions where all of the code involved in the TARGET of the mapping can be carefully controlled to ensure that it doesn't make assumptions about object roles, but only references 'self'. Reversing roles in a mapping should never be attempted in general-purpose library code, because code based on the library could override the target of the role-reversing mapping, and the override could fail to observe the restrictions on object role references.

Note that role reversals can almost always be handled with other mechanisms that handle reversals cleanly. Always consider Doer.doInstead() first when confronted with a situation that seems to call for a role-reversing asObjFor() mapping, as doInstead() specifically allows for object role changes.

`asObjWithoutActionFor (obj, Action)` | `advlite.h[472]`

`{ \
preCond { return preCond##obj##Action; } \
verify() { verify##obj##Action; } \
remap() { return remap##obj##Action(); } \
check() { check##obj##Action; } \
action() { } \
}`
Define mappings of everything except the action. This can be used in cases where we want to pick up the verification, preconditions, and check routines from another handler, but not the action. This is often useful for two-object verbs where the action processing is entirely provided by one or the other object, so applying it to both would be redundant.

`asObjWithoutVerifyFor (obj, Action)` | `advlite.h[484]`

`{ \
preCond { return preCond##obj##Action; } \
remap() { return remap##obj##Action(); } \
check() { check##obj##Action; } \
action() { action##obj##Action(); } \
report() { report##obj##Action(); } \
}`
no description available

`aStance (actor)` | `advlite.h[1513]`

`(actor.stance)`
What stance is this actor in?

`aStanceIn (actor, st_, ...)` | `advlite.h[1522]`

`(actor.stance is in (st_#foreach: st_##Stance:, ))`
no description available

`aStanceIs (actor, st_)` | `advlite.h[1516]`

`(actor.stance == st_ ## Stance)`
Is actor in this stance ?

`AudioLink` | `advlite.h[1350]`

`1`
Communication Link Types

AudioLink means audio communication only is available VideoLink means both audio and visual links are available.

`BMsg (id, txt, args, ...)` | `advlite.h[1103]`

`buildMessage(#@id, txt, ##args)`
no description available

`BMsg (id, txt, args, ...)` | `advlite.h[1106]`

`buildMessage(#@id, nil, ##args)`
no description available

`BV (x)` | `advlite.h[1394]`

`(defined(beliefManager) ? beliefManager.bvTab[x] : x)`
Macros to deal with knowledge enums and their associated objects

`cannotTouchMsg` | `advlite.h[1408]`

`cannotFeelMsg`
no description available

`canSwichOffMe` | `advlite.h[1231]`

`isSwitchable`
no description available

`canSwichOnMe` | `advlite.h[1228]`

`isSwitchable`
no description available

`canSwitchMeOff` | `advlite.h[1230]`

`isSwitchable`
no description available

`canSwitchMeOn` | `advlite.h[1227]`

`isSwitchable`
no description available

`checkHitMsg` | `advlite.h[1410]`

`checkAttackMsg`
no description available

`checkTouchMsg` | `advlite.h[1405]`

`checkFeelMsg`
Define some synonyms for potentially confusing property names

`ConversationLullReason` | `advlite.h[909]`

`2`
no description available

`dangerous` | `advlite.h[726]`

`gAction.addVerifyResult(new VerifyResult(90, '', true, verobj, nil))`
no description available

`DCT` | `advlite.h[904]`

`DefaultConvstayTopic`
no description available

`DefaultTopicReason` | `advlite.h[910]`

`3`
no description available

`DefineAction (name, baseClass, ...)` | `advlite.h[534]`

`name: ##baseClass \
baseActionClass = name`
Define an action OBJECT with the given name inheriting from the given base class, for use with the Mercury parser.

`DefineIAction (name)` | `advlite.h[550]`

`DefineAction(name, IAction)`
Define a concrete IAction, given the root name for the action. We'll automatically generate a class with name XxxAction.

`DefineLiteralAction (name)` | `advlite.h[577]`

`DefineAction(name, LiteralAction)`
no description available

`DefineLiteralTAction (name)` | `advlite.h[574]`

`DefineTActionSub(name, LiteralTAction)`
no description available

`DefineNumericAction (name)` | `advlite.h[589]`

`DefineAction(name, NumericAction)`
no description available

`DefineNumericTAction (name)` | `advlite.h[586]`

`DefineTActionSub(name, NumericTAction)`
no description available

`DefineSystemAction (name)` | `advlite.h[543]`

`DefineAction(name, SystemAction)`
Define a "system" action. System actions are meta-game commands, such as SAVE and QUIT, that generally operate the user interface and are not part of the game world.

`DefineTAction (name)` | `advlite.h[559]`

`DefineTActionSub(name, TAction)`
Define a concrete TAction, given the root name for the action. We'll automatically generate a class with name XxxAction, a verProp with name verXxx, a checkProp with name checkXxx, and an actionProp with name actionDobjXxx.

`DefineTActionSub (name, cls)` | `advlite.h[565]`

`DefineAction(name, cls) \
verDobjProp = &verifyDobj##name \
remapDobjProp = &remapDobj##name \
preCondDobjProp = &preCondDobj##name \
checkDobjProp = &checkDobj##name \
actionDobjProp = &actionDobj##name \
reportDobjProp = &reportDobj##name \
`
Define a concrete TAction with a specific base class.

`DefineTIAAction (name)` | `advlite.h[649]`

`DefineTIAActionSub(name, TIAAction)`
The following macros relating to the TIAAction class are only relevant when the TIAAction extension is used. The macros are nevertheless included here for convenience when using the TIAAction extension.

Define a concrete TIAAction, given the root name for the action. We'll automatically generate a class with name XxxAction, a verDobjProp with name verDobjXxx, a verIobjProp with name verIobjxxx, a checkDobjProp with name checkDobjXxx, a checkIobjProp with name checkIobjXxx, an actionDobjProp with name actionDobjXxx, and an actionIobjProp with name actionIobjXxx.

`DefineTIAActionSub (name, cls)` | `advlite.h[655]`

`DefineAction(name, cls) \
verDobjProp = &verifyDobj##name \
verIobjProp = &verifyIobj##name \
verAobjProp = &verifyAobj##name \
remapDobjProp = &remapDobj##name \
remapIobjProp = &remapIobj##name \
remapAobjProp = &remapAobj##name \
preCondDobjProp = &preCondDobj##name \
preCondIobjProp = &preCondIobj##name \
preCondAobjProp = &preCondAobj##name \
checkDobjProp = &checkDobj##name \
checkIobjProp = &checkIobj##name \
checkAobjProp = &checkAobj##name \
actionDobjProp = &actionDobj##name \
actionIobjProp = &actionIobj##name \
actionAobjProp = &actionAobj##name \
reportDobjProp = &reportDobj##name \
reportIobjProp = &reportIobj##name \
reportAobjProp = &reportAobj##name \
`
Define a concrete TIAction with a specific base class.

`DefineTIAction (name)` | `advlite.h[601]`

`DefineTIActionSub(name, TIAction)`
Define a concrete TIAction, given the root name for the action. We'll automatically generate a class with name XxxAction, a verDobjProp with name verDobjXxx, a verIobjProp with name verIobjxxx, a checkDobjProp with name checkDobjXxx, a checkIobjProp with name checkIobjXxx, an actionDobjProp with name actionDobjXxx, and an actionIobjProp with name actionIobjXxx.

`DefineTIActionSub (name, cls)` | `advlite.h[607]`

`DefineAction(name, cls) \
verDobjProp = &verifyDobj##name \
verIobjProp = &verifyIobj##name \
remapDobjProp = &remapDobj##name \
remapIobjProp = &remapIobj##name \
preCondDobjProp = &preCondDobj##name \
preCondIobjProp = &preCondIobj##name \
checkDobjProp = &checkDobj##name \
checkIobjProp = &checkIobj##name \
actionDobjProp = &actionDobj##name \
actionIobjProp = &actionIobj##name \
reportDobjProp = &reportDobj##name \
reportIobjProp = &reportIobj##name \
`
Define a concrete TIAction with a specific base class.

`DefineTopicAction (name)` | `advlite.h[583]`

`DefineAction(name, TopicAction)`
no description available

`DefineTopicTAction (name)` | `advlite.h[580]`

`DefineTActionSub(name, TopicTAction)`
no description available

`DefMood (name_)` | `advlite.h[1504]`

`name_ ## Mood: Mood \
name = #@name_`
Define a new Mood

`DefSignal (sig, nam)` | `advlite.h[1461]`

`sig##Signal: Signal \
name = #@nam\
handleProp = &handle_##sig`
Definitions for the Signals Extension

`DefStance (name_, score_)` | `advlite.h[1498]`

`name_ ## Stance: Stance \
name = #@name_ \
score = score_`
Define a new Stance

`DMsg (id, txt, args, ...)` | `advlite.h[1102]`

`message(#@id, txt, ##args)`
DMsg() - default English library message cover macro.

Whenever the library displays a message, it uses the DMsg() macro. The arguments are a message ID, and the default English message text to display. The message ID is a string that identifies the message; this is used to look for overriding customizations of the message. Refer to the CustomMessages class for information on customizing the standard library messages.

In our approach, the library defines the default English text of the messages in-line, directly in the code. On the surface, this is contrary to standard practices in most modern programming projects, which strive to make translations easier by separating the message text from the program code, gathering all of the text into a central message file that can be replaced for each language. Despite appearances, we're accomplishing the same thing - but in our system, we have the advantage that we *also* define the default English message text in-line as part of the code it applies to. This makes it easier to read the code by keeping a message and its full context in one place; this way you don't have to shuttle between the code and message file.

Here's how we accomplish the message separation required for translations, and also for games that wish to customize the library defaults. The DMsg() macro requires both the default English message text *and* an ID key for the message. The message display function receives both. The display function proceeds to look up the ID key in a translation table; if it finds an entry, it uses the version of the message in the translation table instead of the English default passed in via DMsg(). A language module can provide a message table that defines the language translations, and a game can provide a table that further customizes the library messages to fit its narrative style.

There's one additional element. Translators and game authors need to be able to see all of the messages in one place, so they can create their tables. We would seem to lack that central list of English messages. Fortunately, by using a standard macro for each message, we can extract a comprehensive English message list automatically via a special tool. We use this as part of the library release process to create the English message file for reference.

Note that the macro expansion includes the default English text only in English builds. It omits the text in non-English builds. This is to save space - we assume that the English messages will all be overridden anyway by each translated library version, so there's no point in including their text in the final compiled program.

`DMsg (id, txt, args, ...)` | `advlite.h[1105]`

`message(#@id, nil, ##args)`
no description available

`dobjFor (action)` | `advlite.h[394]`

`objFor(Dobj, action)`
no description available

`dobjList` | `advlite.h[94]`

`nounList->dobjMatch`
Also add a couple of synonyms familiar froma adv3

`exit` | `advlite.h[736]`

`throw new ExitSignal()`
a concise macro to throw an ExitSignal

`exitAction` | `advlite.h[739]`

`throw new ExitActionSignal()`
a concise macro to throw an ExitActionSignal

`exitCommandLine` | `advlite.h[924]`

`throw new ExitCommandLineSignal()`
Terminate execution of the command line. This aborts the current command, including any remaining object iterations for the current action, and discards anything else on the command line.

`feelResponseMsg` | `advlite.h[1406]`

`touchResponseMsg`
no description available

`gAcc` | `advlite.h[682]`

`gAction.curAobj`
no description available

`gAction` | `advlite.h[294]`

`(libGlobal.curAction)`
the Action object of the command being executed

`gActionIn (action, ...)` | `advlite.h[334]`

`(gAction != nil \
&& (action#foreach/gAction.ofKind(action)/||/))`
is the current global action ANY of the specified actions?

`gActionIs (action)` | `advlite.h[330]`

`(gAction != nil && gAction.ofKind(action))`
Determine if the current global action is the specified action. Only the action prefix is needed - so use "Take" rather than "TakeAction" here.

This tests to see if the current global action is an instance of the given action class - we test that it's an instance rather than the action class itself because the parser creates an instance of the action when it matches the action's syntax.

`gActionList` | `advlite.h[343]`

`(nilToList(gCommand.action.actionList))`
the list of objects involved in the action just completed

`gActionListObj` | `advlite.h[354]`

`(object: Thing \
{ \
plural = (gAction.reportList.length > 1 || \
gAction.reportList[1].plural); \
isIt = (gAction.reportList.length == 1 ? \
gAction.reportList[1].isIt : nil);\
isHim = (gAction.reportList.length == 1 ? \
gAction.reportList[1].isHim : nil);\
isHer = (gAction.reportList.length == 1 ? \
gAction.reportList[1].isHer : nil);\
name = gActionListStr; \
qualified = true; \
} )`
an object that is singular or plural according to whether gActionList represents a single object of a plurality of objects, and which picks up the correct gender if there is only a single object.

`gActionListStr` | `advlite.h[346]`

`makeListStr(gCommand.action.reportList, &theName)`
a displaying string version of the above

`gActor` | `advlite.h[279]`

`(libGlobal.curActor)`
the actor performing the current command

`gActorRoom` | `advlite.h[390]`

`(gActor.getOutermostRoom)`
Get the current actor's curren room (which may not be the same as its location)

`gAobj` | `advlite.h[681]`

`gAction.curAobj`
no description available

`gCommand` | `advlite.h[295]`

`(libGlobal.curCommand)`
no description available

`gCommandToks` | `advlite.h[1283]`

`(gCommand == nil || gCommand.verbProd == nil ? [] \
: gCommand.verbProd.tokenList.mapAll({t: getTokVal(t)}))`
Get the command tokens for the current command.

`gDobj` | `advlite.h[287]`

`(gAction.curDobj)`
For convenience, define some macros that return the current direct and indirect objects from the current action. The library only uses direct and indirect objects, so games that define additional command objects will have to add their own similar macros for those.

`gExitLister` | `advlite.h[959]`

`(libGlobal.exitListerObj)`
the exit lister object - if the exits module isn't included in the game, this will be nil

`gExtraHintManager` | `advlite.h[972]`

`(libGlobal.extraHintManagerObj)`
the extra hint manager object - if the hints module isn't included in the game, this will be nil

`gFact (tag)` | `advlite.h[1193]`

`(factManager.getFact(tag))`
no description available

`gFactDesc (tag)` | `advlite.h[1194]`

`(factManager.getFactDesc(tag))`
no description available

`gHintManager` | `advlite.h[965]`

`(libGlobal.hintManagerObj)`
the hint manager object - if the hints module isn't included in the game, this will be nil

`gInformed (key)` | `advlite.h[1377]`

`(getActor.informedAbout(key))`
has a topic key been revealed to an NPC through <.inform>?

`gIobj` | `advlite.h[288]`

`(gAction.curIobj)`
no description available

`gKnown (obj)` | `advlite.h[1373]`

`(gPlayerChar.knowsAbout(obj))`
does the player character know about obj?

`gLastAction` | `advlite.h[317]`

`(libGlobal.lastAction)`
The previous action and command

`gLastCommand` | `advlite.h[318]`

`(libGlobal.lastCommand)`
no description available

`gLastFact` | `advlite.h[1386]`

`(libGlobal.lastFactMentioned)`
the last fact mentioned in the course of the current conversation

`gLastTopic` | `advlite.h[1383]`

`(libGlobal.lastTopicMentioned)`
the last topic mentioned in the course of the current conversation

`gLibMessages` | `advlite.h[953]`

`(libGlobal.libMessageObj)`
The current library messages object. This is the source object for messages that don't logically relate to the actor carrying out the comamand. It's mostly used for meta-command replies, and for text fragments that are used to construct descriptions.

This message object isn't generally used for parser messages or action replies - most of those come from the objects given by the current actor's getParserMessageObj() or getActionMessageObj(), respectively.

By default, this is set to libMessages. The library never changes this itself, but a game can change this if it wants to switch to a new set of messages during a game. (If you don't need to change messages during a game, but simply want to customize some of the default messages, you don't need to set this variable - you can simply use 'modify libMessages' instead. This variable is designed for cases where you want to *dynamically* change the standard messages during the game.)

`gLiteral` | `advlite.h[289]`

`(gAction.literal)`
no description available

`gLocation` | `advlite.h[378]`

`(getPlayerChar().location)`
get the player character's location

`gMessageParams (var, ...)` | `advlite.h[1146]`

`(gAction.setMessageParams(var#foreach/#@var, var/,/))`
Some message processors add their own special parameters to messages, because they want to use expansion parameters (in the "{the dobj/him}" format) outside of the set of objects directly involved in the command.

The Action method setMessageParam() lets you define such a parameter, but for convenience, we define this macro for setting one or more parameters whose names exactly match their local variable names. In other words, if you call this macro like this:

gMessageParams(obj, cont)

then you'll get one parameter with the text name 'obj' whose expansion will be the value of the local variable obj, and another with text name 'cont' whose expansion is the value of the local variable cont.

`gMood` | `advlite.h[1526]`

`(getActor().mood)`
What mood is getActor in?

`gMoodIn (mood_, ...)` | `advlite.h[1539]`

`(gMood is in (mood_#foreach: mood_ ## Mood:, :))`
Is getActor in one of these moods?

`gMoodIs (mood_)` | `advlite.h[1529]`

`(getActor().mood == mood_ ## Mood)`
Is getActor in one of these moods?

`gNumber` | `advlite.h[290]`

`(gAction.num)`
no description available

`goInstead (dirn)` | `advlite.h[508]`

`doInstead(Go, dirn##Dir)`
Convenience macros for synthesizing travel in a given compass direction

`goNested (dirn)` | `advlite.h[509]`

`doNested(Go, dirn##Dir)`
no description available

`gOutStream` | `advlite.h[1124]`

`(outputManager.curOutputStream)`
no description available

`gPlayerChar` | `advlite.h[375]`

`(libGlobal.playerChar)`
get the current player character Actor object

`gReveal (key, args, ...)` | `advlite.h[1363]`

`(libGlobal.setRevealed(key, ## args))`
reveal a topic key, as though through <.reveal>

`gRevealed (key)` | `advlite.h[1360]`

`(libGlobal.getRevealed(key))`
has a topic key been revealed through <.reveal>?

`gRoom` | `advlite.h[387]`

`(getPlayerChar().getOutermostRoom)`
get the player character's current room (which may or may not be the same as his/her location)

`gSetKnown (obj)` | `advlite.h[1369]`

`(gPlayerChar.setKnowsAbout(obj))`
mark a Topic/Thing as known/seen by the player character

`gSetMood (mood_)` | `advlite.h[1551]`

`(getActor.setMood(mood_ ## Mood))`
Set moods

`gSetSeen (obj)` | `advlite.h[1370]`

`(gPlayerChar.setHasSeen(obj))`
no description available

`gSetStance (st_)` | `advlite.h[1547]`

`(getActor.setStanceToward(gPlayerChar, st_ ## Stance))`
Set stances towards the player character

`gStance` | `advlite.h[1509]`

`(getActor().stance)`
Is the actor whose agenda item, topic entry or whatever we're looking from in this stance?

`gStanceIn (st_, ...)` | `advlite.h[1519]`

`(gStance is in (st_#foreach: st_##Stance:, :))`
Is actor in one of these stances?

`gStanceIs (st_)` | `advlite.h[1510]`

`(getActor().stance == st_ ## Stance)`
no description available

`gTentativeDobj` | `advlite.h[297]`

`(gCommand.dobjs.mapAll({x: x.obj}).toList)`
no description available

`gTentativeDobjIn (lst)` | `advlite.h[313]`

`(gTentativeDobj.overlapsWith(lst))`
An alternative way of dealing with the potential object not yet resolved problem, by testing whether any of the objects in lst are in the Tentative Object List.

`gTentativeIobj` | `advlite.h[298]`

`(gCommand.iobjs.mapAll({x: x.obj}).toList)`
no description available

`gTentativeIobjIn (lst)` | `advlite.h[314]`

`(gTentativeIobj.overlapsWith(lst))`
no description available

`gTopic` | `advlite.h[396]`

`(gAction.curTopic)`
no description available

`gTopicMatch` | `advlite.h[398]`

`(gTopic.getBestMatch)`
no description available

`gTopicText` | `advlite.h[397]`

`(gTopic.getTopicText)`
no description available

`gTravelActionIs (dirn)` | `advlite.h[339]`

`(gAction != nil && gAction.ofKind(Travel) && gAction.direction == dirn ## Dir)`
is the current action a Travel action going dirn

`gTurns` | `advlite.h[381]`

`(libGlobal.totalTurns)`
get the current turn count

`gUnreveal (key)` | `advlite.h[1366]`

`(libGlobal.setUnrevealed(key))`
remove a topic key, as though through <.unreveal>

`gVerbPhrase` | `advlite.h[1287]`

`(gCommand.getCommandPhrase())`
Get the command phrase for the current command.

`gVerbWord` | `advlite.h[1279]`

`(gCommand == nil || gCommand.verbProd == nil ? '' \
: getTokVal(gCommand.verbProd.tokenList[1]))`
Get the first word the player entered for the current command.

`gVerifyDobj` | `advlite.h[306]`

`(gDobj ?? (gTentativeDobj.length > 0 ? gTentativeDobj[1] : failVerifyObj))`
the probable Action objects of the command being executed for use in verify routines when resolution of both objects may not be complete. If the gDobj or gIobj is non-nil, use that, otherwise use the first object in the tentative resolution list if the list has any items, otherwisse evaluate to failVerifyObj.

`gVerifyIobj` | `advlite.h[307]`

`(gIobj ?? (gTentativeIobj.length > 0 ? gTentativeIobj[1] : failVerifyObj))`
no description available

`gVerifyList` | `advlite.h[690]`

`gAction.verifyList`
Macros for use in verify routines, returning various kinds of verify results

`hitResponseMsg` | `advlite.h[1411]`

`attackResponseMsg`
no description available

`IfDebug (key, code)` | `advlite.h[1118]`

`if (DebugCtl.enabled[#@key]) { code; } else { }`
Debugging. When we compile in development mode, we'll include a number of functions and methods that display information for debugging purposes. We omit these in release builds to keep the compiled file size smaller, and to avoid making it too easy for end users to snoop around in the program internals.

`IfDebug (key, code)` | `advlite.h[1121]`

``
no description available

`illogical (msg)` | `advlite.h[694]`

`gAction.addVerifyResult(new VerifyResult(30, msg, nil, verobj))`
no description available

`illogicalAlready (msg)` | `advlite.h[708]`

`gAction.addVerifyResult(new VerifyResult(45, msg, nil, verobj))`
IllogicalAlready doesn't do anything mush different from IllogicalNow in adv3Lite, but is supplied so that game authors familiar with adv3 can use it without getting a compilation error. It may also be slightly useful for documentary purposes to clarify why a verify routine in game code is ruling out an action. We now give it a slightly higher logical rank than illogicalNow().

`illogicalNow (msg)` | `advlite.h[697]`

`gAction.addVerifyResult(new VerifyResult(40, msg, nil, verobj))`
no description available

`illogicalSelf (msg)` | `advlite.h[711]`

`gAction.addVerifyResult(new VerifyResult(20, msg, nil, verobj))`
no description available

`implausible (msg)` | `advlite.h[720]`

`gAction.addVerifyResult(new VerifyResult(35, msg, nil, verobj))`
no description available

`inaccessible (msg)` | `advlite.h[717]`

`gAction.addVerifyResult(new VerifyResult(10, msg, nil, verobj))`
no description available

`INF (name_, desc, args, ...)` | `advlite.h[1397]`

`informNewFact(name_, desc, ## args)`
no description available

`InitiateConversationReason` | `advlite.h[908]`

`1`
Define convenient named constants for use with ConvAgendaItem

`input (x, ...)` | `advlite.h[1419]`

`inputManager.getInputLine(x)`
no description available

`iobjFor (action)` | `advlite.h[395]`

`objFor(Iobj, action)`
no description available

`iobjList` | `advlite.h[95]`

`nounList->iobjMatch`
no description available

`isClimbDownable` | `advlite.h[1234]`

`canClimbDownMe`
no description available

`isClimbUpable` | `advlite.h[1233]`

`canClimbUpMe`
no description available

`isCutable` | `advlite.h[1214]`

`isCuttable`
Further macros for various isXable properties game author may spell wrong.

`isDigable` | `advlite.h[1238]`

`isDiggable`
no description available

`isDropable` | `advlite.h[1216]`

`isDroppable`
no description available

`isEatable` | `advlite.h[1211]`

`isEdible`
The library uses isEdible rather than isEatable, since edible is the more natural word to use, but strict consistency might have dictated isEatable, so we make it an effective synonym in case some game authors use it.

`isEnterOnable` | `advlite.h[1247]`

`canEnterOnMe`
no description available

`isFlipable` | `advlite.h[1232]`

`isFlippable`
no description available

`isGoAlongable` | `advlite.h[1224]`

`canGoAlongMe`
no description available

`isGoThroughable` | `advlite.h[1222]`

`canGoThroughMe`
no description available

`isGoThruable` | `advlite.h[1223]`

`canGoThroughMe`
no description available

`isJumpOffable` | `advlite.h[1243]`

`canJumpOffMe`
no description available

`isJumpOverable` | `advlite.h[1244]`

`camJumpOverMe`
no description available

`isLieOnable` | `advlite.h[1237]`

`canLieOnMe`
no description available

`isLooBehindable` | `advlite.h[1218]`

`canLookBehindMe`
no description available

`isLookThroughable` | `advlite.h[1220]`

`canLookThroughMe`
no description available

`isLookThrughable` | `advlite.h[1221]`

`canLookThroughMe`
no description available

`isLookUnderable` | `advlite.h[1217]`

`canLookUnderMe`
no description available

`isPluggable` | `advlite.h[1241]`

`isPlugable`
no description available

`isPotable` | `advlite.h[1257]`

`isDrinkable`
Conversely, authors alive to the Latin root of edible might try the latinate isPotable instead of isDrinkable.

`isPushTravelable` | `advlite.h[1249]`

`canPushTravel`
no description available

`isSetable` | `advlite.h[1245]`

`isSettable`
no description available

`isSetToable` | `advlite.h[1240]`

`canSetToMe`
no description available

`isSitOnable` | `advlite.h[1236]`

`canSitOnMe`
no description available

`isStandOnable` | `advlite.h[1235]`

`canStandOnMe`
no description available

`isSwitchOffable` | `advlite.h[1229]`

`isSwitchable`
no description available

`isSwitchOnable` | `advlite.h[1226]`

`isSwitchable`
no description available

`isTouchable` | `advlite.h[1215]`

`isFeelable`
no description available

`isTurnToable` | `advlite.h[1239]`

`canTurnToMe`
no description available

`isTypeOnable` | `advlite.h[1246]`

`canTypeOnMe`
no description available

`isUnpluggable` | `advlite.h[1242]`

`isUnplugable`
no description available

`isWriteOnAble` | `advlite.h[1248]`

`canWriteOnMe`
no description available

`iTag` | `advlite.h[1198]`

`tTag`
no description available

`literalAcc` | `advlite.h[85]`

`literalPhrase->accMatch`
no description available

`literalAobj` | `advlite.h[86]`

`literalPhrase->accMatch`
no description available

`literalDobj` | `advlite.h[83]`

`literalPhrase->dobjMatch`
no description available

`literalIobj` | `advlite.h[84]`

`literalPhrase->iobjMatch`
no description available

`logical` | `advlite.h[692]`

`gAction.addVerifyResult (new VerifyResult(100, '', true, verobj))`
no description available

`logicalRank (score)` | `advlite.h[714]`

`gAction.addVerifyResult(new VerifyResult(score, '', true, verobj))`
no description available

`M_DOWN` | `advlite.h[1161]`

`4`
no description available

`M_PREV` | `advlite.h[1159]`

`2`
no description available

`M_QUIT` | `advlite.h[1158]`

`1`
The indices for the key values used to navigate menus, which are held in the keyList array of MenuItems.

`M_SEL` | `advlite.h[1162]`

`5`
no description available

`M_UP` | `advlite.h[1160]`

`3`
no description available

`mainReport (msg, args, ...)` | `advlite.h[407]`

`actionReport(msg, ##args)`
Defined for the sake of adv3 users moving to adv3Lite, who may be more used to using mainReport() in a similar context.

`MatchAdj` | `advlite.h[134]`

`0x0002`
matched an adjective (the phrase contains at least one adjective)

`MatchNoApprox` | `advlite.h[153]`

`0x1000`
all words were matched WITHOUT character approximations (such as matching 'a' to 'a-umlaut')

`MatchNoTrunc` | `advlite.h[156]`

`0x2000`
all words were matched WITHOUT truncation

`MatchNoun` | `advlite.h[137]`

`0x0004`
matched a noun (the phrase contains at least one noun word)

`MatchPartMask` | `advlite.h[146]`

`0x0FFF`
mask to select only the part-of-speech flags

`MatchPhrase` | `advlite.h[143]`

`0x0010`
matched a phrase

`MatchPlural` | `advlite.h[140]`

`0x0008`
matched a plural (the phrase contains at least one plural word)

`MatchPrep` | `advlite.h[125]`

`0x0001`
matched a preposition (the phrase contains at least one preposition)

`MatchStrengthMask` | `advlite.h[159]`

`0xF000`
mask to select only the match-strength flags

`MatchWeak` | `advlite.h[131]`

`0x0001`
matched a weak token (which we'll treat as equivalent to matchimg a preposition).

`MMTIAction (name)` | `advlite.h[627]`

`verify ## name (Object dobj, Object iobj, Thing verobj) {} \
check ## name (Object dobj, Object iobj) {} \
action ## name (Object dobj, Object iobj) {} \
modify name \
mmVerify(dobj, iobj, verobj) { verify ## name (dobj, iobj, verobj); } \
mmCheck(dobj, iobj) { check ## name (dobj, iobj); } \
mmAction(dobj, iobj) { action ## name (dobj, iobj); }`
Modify a concrete TIAction to work with multimethods. This creates the base version of the three multimethods needed then sets the relevant methods of the TIAction to call the relevant multimethod.

`more` | `advlite.h[1418]`

`inputManager.pauseForMore()`
Define some macros to give abbreviated synonyms to inputManager method

`Msg (id, txt)` | `advlite.h[1046]`

`#@id, txt`
Msg() - define a custom message to override a library message. 'id' is the message ID, which is the same ID used for the DMsg() message that you wish to override. Do NOT use quotes around the ID - just enter it as though it were a variable name. 'txt' is the message text, as a single-quoted string.

This is used in CustomMessages objects to define message overrides. See CustomMessages for full details.

`multiAcc` | `advlite.h[76]`

`nounList->accMatch`
no description available

`multiAobj` | `advlite.h[77]`

`nounList->accMatch`
no description available

`multiDobj` | `advlite.h[72]`

`nounList->dobjMatch`
no description available

`multiIobj` | `advlite.h[73]`

`nounList->iobjMatch`
no description available

`NCT` | `advlite.h[903]`

`NodeContinuationTopic`
no description available

`NEC` | `advlite.h[902]`

`NodeEndCheck`
Define some convenient abbreviations for ConvNode related objects

`nextrule` | `advlite.h[1440]`

`return (rulebook.contValue)`
no description available

`nonObvious` | `advlite.h[723]`

`gAction.addVerifyResult(new VerifyResult(30, '', true, verobj, nil))`
no description available

`nostop` | `advlite.h[1441]`

`return (rulebook.contValue)`
no description available

`npcKnows (obj)` | `advlite.h[1380]`

`(getActor.knowsAbout(obj))`
is the topic key or object known to the NPC we're in conversaation with?

`numberDobj` | `advlite.h[78]`

`numberPhrase->dobjMatch`
no description available

`numericAcc` | `advlite.h[90]`

`numberPhrase -> accMatch`
no description available

`numericAobj` | `advlite.h[91]`

`numberPhrase -> accMatch`
no description available

`numericDobj` | `advlite.h[88]`

`numberPhrase -> dobjMatch`
no description available

`numericIobj` | `advlite.h[89]`

`numberPhrase -> iobjMatch`
no description available

`objFor (which, action)` | `advlite.h[392]`

`propertyset '*' ## #@which ## #@action`
no description available

`pcKnows (obj)` | `advlite.h[1374]`

`(gPlayerChar.knowsAbout(obj))`
no description available

`reportAfter (msg)` | `advlite.h[400]`

`gCommand.afterReports += msg`
no description available

`reportPostImplicit (msg)` | `advlite.h[401]`

`gCommand.postImplicitReports += msg`
no description available

`RNF (name_, desc, args, ...)` | `advlite.h[1396]`

`revealNewFact(name_, desc, ## args)`
no description available

`rnull` | `advlite.h[1439]`

`return null`
Convenient abbreviations for rules that want to allow their RuleBook to continue processing more rules.

`rTag` | `advlite.h[1197]`

`aTag`
Convenient synonyms for two ActorTopicEntry properties used in conjunction with Facts.

`SelArbitrary` | `advlite.h[196]`

`0x0002`
This object was chosen arbitrarily from a larger set, because the noun phrase construction says we should do so. This flag is set when the noun phrase is something TAKE A BOOK or TAKE ANY OF THE BOOKS.

`SelDefault` | `advlite.h[210]`

`0x0008`
We selected an object as a default. This is set when the player leaves out a noun phrase, but we can guess what was probably meant based on context: e.g., ASK ABOUT THE HOUSE is probably directed to Bob if Bob is the only person nearby.

`SelDisambig` | `advlite.h[189]`

`0x0001`
The noun phrase required disambiguation, because more than one object was in scope that matched the noun phrase. We were able to figure out which one(s) the player meant from context, without having to ask the player for help.

For example, there are two doors in the room, one open and one closed. The player types OPEN DOOR. It's fairly obvious that they must be talking about the closed door. So, we choose that object and set the Disambig flag.

(Note that this flag specifically does NOT mean that we had to ask the user for help with the dreaded "Which do you mean..." question. It's kind of the opposite: it means that we had a noun phrase that was initially ambiguous, but that we managed to disambiguate it on our own. When we get the user involved, there's ambiguity *before* we ask the question, but the user's response removes the ambiguity by telling us exactly which alternative they intended. This flag indicates that we made an educated guess about what the user must have intended, without asking. The flag lets the parser tell the player about the guess, which is desirable because the guess is sometimes wrong.

`SelPlural` | `advlite.h[202]`

`0x0004`
The noun phrase that we matched was a manifestly plural construction, such as TAKE ALL or TAKE THE BOOKS.

`SelProg` | `advlite.h[218]`

`0x1000`
This object was set internally by the program; it did not come from parsing any player input. This generally means that the whole command was constructed by the program, to handle an event or other internal processing, rather than by parsing player input.

`setPastTense (val)` | `advlite.h[984]`

`(gameMain.usePastTense = (val))`
Set the current narrative tense. Use val = true for past and val = nil for present.

`singleAcc` | `advlite.h[70]`

`singleNoun->accMatch`
no description available

`singleAobj` | `advlite.h[71]`

`singleNoun->accMatch`
no description available

`singleDir` | `advlite.h[87]`

`directionName->dirMatch`
no description available

`singleDobj` | `advlite.h[68]`

`singleNoun->dobjMatch`
Verb rule noun phrase macros. These are convenience macros for specifying the most common noun phrase slots in the grammar templates for verb rules.

`singleIobj` | `advlite.h[69]`

`singleNoun->iobjMatch`
no description available

`skip` | `advlite.h[748]`

`throw new SkipSignal()`
a concise macro to throw a Skip signal

`sLoc (which)` | `advlite.h[409]`

`subLocation = &remap##which`
no description available

`Sta (a, b, c)` | `advlite.h[1554]`

`[a, b ## Stance, c]`
no description available

`stop` | `advlite.h[1427]`

`return stopValue;`
Definitions for the rules.t extension

`STRINGIZE (x)` | `advlite.h[266]`

`_STRINGIZE(x)`
no description available

`STRINGIZE (x)` | `advlite.h[1032]`

`_STRINGIZE(x)`
no description available

`topicAcc` | `advlite.h[81]`

`topicPhrase->accMatch`
no description available

`topicAobj` | `advlite.h[82]`

`topicPhrase->accMatch`
no description available

`topicDobj` | `advlite.h[79]`

`topicPhrase->dobjMatch`
no description available

`topicIobj` | `advlite.h[80]`

`topicPhrase->iobjMatch`
no description available

`tSel (presVal, pastVal)` | `advlite.h[990]`

`(gameMain.usePastTense ? (pastVal) : (presVal))`
Shorthand macro for selecting one of two values depending on the current narrative tense.

`tvo` | `advlite.h[636]`

`Thing verobj`
no description available

`UsePronoun` | `advlite.h[411]`

`1`
no description available

`VerbRule (tag)` | `advlite.h[61]`

`grammar predicate(tag):`
The VerbRule macro starts the definition of a verb grammar rule. The tag is just an identifying name for the rule, so that you can refer to it with 'replace' or 'modify'.

`VideoLink` | `advlite.h[1351]`

`2`
no description available

`waitKey (x, ...)` | `advlite.h[1420]`

`inputManager.getKey(x)`
no description available

`withPast (callback)` | `advlite.h[998]`

`(withTense(true, (callback)))`
no description available

`withPresent (callback)` | `advlite.h[997]`

`(withTense(nil, (callback)))`
Temporarily override the current narrative tense and invoke a callback function.

Enums

`ClosedGoal OpenGoal UndiscoveredGoal` | `advlite.h[1320]`

Enums for Goals in the Hint system

`dubious likely unlikely untrue` | `advlite.h[1390]`

Associated knowledge enums

`feminine masculine neuter` | `advlite.h[932]`

no description available

`FootnotesFull FootnotesMedium FootnotesOff` | `advlite.h[1323]`

Enums for Footnotes

`indirectLockable lockableWithKey lockableWithoutKey notLockable` | `advlite.h[930]`

enums for different types of lock:

`large` | `advlite.h[1304]`

Large - the object is large enough that its details can be sensed from a distance or through an obscuring medium.

`manyToMany manyToOne oneToMany oneToOne` | `advlite.h[1451]`

Definitions for the relations.t extension

`medium` | `advlite.h[1311]`

Medium - the object can be sensed at a distance or when obscured, but not in any detail. Most objects fall into this category. Note that things that are parts of large objects should normally be medium.

`normalRelation reverseRelation` | `advlite.h[1454]`

no description available

`null` | `advlite.h[1433]`

Null value to return from Rules that don't stop a RuleBook from continuing to consider rules.

`OtherObject` | `advlite.h[1017]`

A special role for the "other" object of a two-object command. This can be used in certain contexts (such as remapTo) where a particular object role is implied by the context, and where the action involved has exactly two objects; OtherObject in such contexts means DirectObject when the implied role is IndirectObject, and vice versa.

`rmcAskLiteral` | `advlite.h[248]`

reading a response to a prompt for a missing literal phrase

`rmcAskObject` | `advlite.h[245]`

reading a response to a prompt for a missing object phrase

`rmcCommand` | `advlite.h[239]`

reading a normal command line

`rmcDisambig` | `advlite.h[251]`

reading a response to an interactive disambiguation prompt

`rmcOops` | `advlite.h[242]`

reading an unknown word response, to check for an "oops" command

`small` | `advlite.h[1317]`

Small - the object cannot be sensed at a distance at all. This is appropriate for detailed parts of medium-class objects.

Templates

`Achievement` | `advlite.h[763]`

`+points? "desc";`
An achievement defines its descriptive text. It can also optionally define the number of points it awards.

`ActorState` | `advlite.h[800]`

`"specialDesc" 'stateDesc' | "stateDesc" ?;`
no description available

`ActorTopicEntry` | `advlite.h[831]`

`+matchScore? "topicResponse" | [eventList];`
Version ActorTopicEntry template for use with Facts and kTag

`AltTopic` | `advlite.h[889]`

`"topicResponse" | [eventList];`
AltTopics just specify the response text or list

`AltTopic` | `advlite.h[890]`

`[firstEvents] [eventList];`
no description available

`ClockEvent` | `advlite.h[1329]`

`[eventTime];`
Template for ClockEvent

`CommandTopic` | `advlite.h[871]`

`+matchScore? @matchObj | [matchObj] @matchDobj @matchIobj? "topicResponse" | [eventList]? ;`
no description available

`CommandTopic` | `advlite.h[875]`

`+matchScore? @matchObj | [matchObj] [matchDobj] @matchIobj "topicResponse" | [eventList]? ;`
no description available

`CustomMessages` | `advlite.h[1049]`

`[messages] +priority?;`
Template for CustomMessages objects

`DefaultConsultTopic` | `advlite.h[879]`

`"topicResponse" | [eventList];`
no description available

`DefaultThought` | `advlite.h[880]`

`"topicResponse" | [eventList];`
no description available

`DefaultTopic` | `advlite.h[878]`

`"topicResponse" | [eventList];`
no description available

`Doer` | `advlite.h[895]`

`'cmd';`
no description available

`Door` | `advlite.h[786]`

`'vocab' @location? "desc"? ->otherSide;`
no description available

`Door` | `advlite.h[787]`

`->otherSide 'vocab' @location? "desc"?;`
no description available

`DSCon` | `advlite.h[1480]`

`'vocab' @room1 @room2 "desc"?;`
Equivalent template for DSCon objects in main linrary.

`DSTravelConnector` | `advlite.h[1482]`

`@room1 @room2;`
no description available

`DSTravelConnector` | `advlite.h[1483]`

`->room1 ->room2;`
no description available

`Enterable` | `advlite.h[792]`

`inherited ->connector;`
no description available

`Enterable` | `advlite.h[793]`

`->connector inherited;`
no description available

`EventList` | `advlite.h[1184]`

`[eventList];`
templates for EventLists

`EventListItem` | `advlite.h[1490]`

`@myListObj? ~isReady? +minInterval? *maxFireCt? "invokeItem"? ;`
Definitions for the eventListItem Extension

`ExtraHint` | `advlite.h[1178]`

`+hintDelay? "hintText" | [eventList];`
A Template to facilitate the definition of ExtraHints. We can define it here and not in a header file since ExtraHints are only defined in this

`Fact` | `advlite.h[1191]`

`'name' [topics]? 'desc' [initiallyKnownBy]?;`
template and macros for Facts module

`Footnote` | `advlite.h[1326]`

`"desc";`
Template for Footnotes

`Goal` | `advlite.h[1170]`

`->closeWhenAchieved? 'title' 'heading'? [menuContents];`
templates for hint system objects

`Hint` | `advlite.h[1171]`

`'hintText' [referencedGoals]?;`
no description available

`MenuItem` | `advlite.h[1165]`

`'title' 'heading'?;`
some templates for defining menu items

`MenuLongTopicItem` | `advlite.h[1167]`

`'title' 'heading'? 'menuContents' | "menuContents";`
no description available

`MenuTopicItem` | `advlite.h[1166]`

`'title' 'heading'? [menuContents];`
no description available

`MiscTopic` | `advlite.h[883]`

`"topicResponse" | [eventList];`
miscellanous topics just specify the response text or list

`MiscTopic` | `advlite.h[884]`

`[firstEvents] [eventList];`
no description available

`NodeContinuationTopic` | `advlite.h[885]`

`"topicResponse" | [eventList];`
no description available

`NodeContinuationTopic` | `advlite.h[886]`

`[firstEvents] [eventList];`
no description available

`ProxyActor` | `advlite.h[893]`

`@location;`
The ProxyActor template just specifies the location (i.e. the base Actor)

`QueryTopic` | `advlite.h[833]`

`+matchScore? 'matchPattern' "topicResponse" | [eventList] ?;`
no description available

`QueryTopic` | `advlite.h[837]`

`+matchScore? 'matchPattern' [firstEvents] [eventList];`
no description available

`QueryTopic` | `advlite.h[841]`

`+matchScore? 'qtype' @matchObj | [matchObj] | 'matchPattern' "topicResponse" | [eventList] ?;`
no description available

`QueryTopic` | `advlite.h[847]`

`+matchScore? 'qtype' @matchObj | [matchObj] | 'matchPattern' [firstEvents] [eventList];`
a ShuffledEventList version of the above

`QueryTopic` | `advlite.h[853]`

`+matchScore? 'qtype' @matchObj | [matchObj] 'matchPattern' "topicResponse" | [eventList] ?;`
we can also include *both* the match object/list *and* pattern

`QueryTopic` | `advlite.h[860]`

`+matchScore? 'qtype' @matchObj | [matchObj] 'matchPattern' [firstEvents] [eventList];`
a ShuffledEventList version of the above

`Region` | `advlite.h[784]`

`[rooms];`
no description available

`Relation` | `advlite.h[1452]`

`'name' 'reverseName'? @relationType? +reciprocal?;`
no description available

`Room` | `advlite.h[781]`

`'roomTitle' 'vocab' "desc"?;`
no description available

`Room` | `advlite.h[782]`

`'roomTitle' "desc"?;`
no description available

`Rule` | `advlite.h[1443]`

`@location? &action | [action]?;`
no description available

`Rule` | `advlite.h[1444]`

`@location? "follow";`
no description available

`SayTopic` | `advlite.h[866]`

`+matchScore? 'tTag' 'extraVocab' "topicResponse" | [eventList] ?;`
no description available

`Scenery` | `advlite.h[1188]`

`@location? [scenList];`
template for Scenery Class

`SensoryEmanation` | `advlite.h[798]`

`inherited [eventList]?;`
no description available

`ShuffledEventList` | `advlite.h[1185]`

`[firstEvents] [eventList];`
no description available

`SpecialVerb` | `advlite.h[1557]`

`'specVerb' 'stdVerb' @matchObjs | [matchObjs];`
Template for SpecialVerbs

`string` | `advlite.h[1264]`

`<> mentionA;`
String templates for room descriptions etc.

`string` | `advlite.h[1265]`

`<> mentionA;`
no description available

`string` | `advlite.h[1266]`

`<> mentionThe;`
no description available

`string` | `advlite.h[1267]`

`<< list of * is >> listStrIs;`
no description available

`string` | `advlite.h[1268]`

`<< list of * >> makeListInStr;`
no description available

`string` | `advlite.h[1269]`

`<< the list of * >> makeTheListStr;`
no description available

`string` | `advlite.h[1270]`

`<< is list of * >> isListStr;`
no description available

`string` | `advlite.h[1271]`

`<< exclude * >> makeMentioned;`
no description available

`string` | `advlite.h[1332]`

`<> takeTime;`
String Templates for Objective Time module

`string` | `advlite.h[1333]`

`<> takeTime;`
no description available

`string` | `advlite.h[1334]`

`<> takeTime;`
no description available

`string` | `advlite.h[1335]`

`<> takeTime;`
no description available

`string` | `advlite.h[1337]`

`<> addTime;`
no description available

`string` | `advlite.h[1338]`

`<> addTime;`
no description available

`string` | `advlite.h[1339]`

`<> addTime;`
no description available

`string` | `advlite.h[1340]`

`<> addTime;`
no description available

`string` | `advlite.h[1477]`

`<<* by room>> byRoomFunc;`
no description available

`StyleTag` | `advlite.h[771]`

`'tagName' 'openText'? 'closeText'?;`
Templates for style tags

`SymConnector` | `advlite.h[1469]`

`->destination;`
Definitions for the SymConn Extension

`SymConnector` | `advlite.h[1470]`

`@room1 @room2;`
no description available

`SymPassage` | `advlite.h[1472]`

`->destination 'vocab' "desc"?;`
no description available

`SymPassage` | `advlite.h[1473]`

`'vocab' ->destination "desc"?;`
no description available

`SymPassage` | `advlite.h[1474]`

`'vocab' @room1 @room2 "desc"?;`
no description available

`SymPassage` | `advlite.h[1475]`

`'vocab' [rooms] "desc"?;`
no description available

`Test` | `advlite.h[898]`

`'testName' [testList] @location? [testHolding]?;`
Templates for use with test sequences

`Test` | `advlite.h[899]`

`'testName' [testList] [testHolding]? @location?;`
no description available

`Thing` | `advlite.h[778]`

`'vocab' @location? "desc"?;`
Object definition templates

`Tip` | `advlite.h[1180]`

`"desc" | 'desc';`
no description available

`Topic` | `advlite.h[779]`

`'vocab' @familiar?;`
no description available

`TopicEntry` | `advlite.h[805]`

`+matchScore? @matchObj | [matchObj] | 'matchPattern' "topicResponse" | [eventList] ?;`
no description available

`TopicEntry` | `advlite.h[811]`

`+matchScore? @matchObj | [matchObj] | 'matchPattern' [firstEvents] [eventList];`
a ShuffledEventList version of the above

`TopicEntry` | `advlite.h[817]`

`+matchScore? @matchObj | [matchObj] 'matchPattern' "topicResponse" | [eventList] ?;`
we can also include *both* the match object/list *and* pattern

`TopicEntry` | `advlite.h[824]`

`+matchScore? @matchObj | [matchObj] 'matchPattern' [firstEvents] [eventList];`
a ShuffledEventList version of the above

`TopicGroup` | `advlite.h[802]`

`+scoreBoost? 'convKeys' | [convKeys] ? ;`
no description available

`TravelConnector` | `advlite.h[789]`

`'vocab'? @location? "desc"? ->destination;`
no description available

`TravelConnector` | `advlite.h[790]`

`->destination "travelDesc";`
no description available

`Unthing` | `advlite.h[795]`

`'vocab' @location? 'notHereMsg'?;`
no description available

`Unthing` | `advlite.h[796]`

`@unObject @location? 'notHereMsg'?;`
no description available

Adv3Lite Library Reference Manual
Generated on 13/06/2025 from adv3Lite version 2.2.1