Thingclassthing.t[979], senseRegion.t[510], english.t[2121]

Thing is the base class for all game objects that represent physical objects which can be interacted with in the game world. All such physical objects are either Things or based on a subclass of Thing.

Modified in senseRegion.t[510]:
Modifications to Thing to support the other mods required for use with SenseRegion.

Modified in english.t[2121]:
English modifications for Thing. This adds some methods that vary by language, so they can't be defined in the generic Thing class.

class Thing :   ReplaceRedirector   Mentionable

Superclass Tree   (in declaration order)

Thing
        ReplaceRedirector
                Redirector
                        object
        Mentionable
                LMentionable
                        object

Subclass Tree  

Thing
        Actor
        Button
        Consultable
        Container
                Booth
                OpenableContainer
                        KeyedContainer
                        LockableContainer
        Door
                SecretDoor
        Fixture
                CollectiveGroup
                Component
                ContainerDoor
                Decoration
                        Distant
                        SensoryEmanation
                                Noise
                                Odor
                        Unthing
                Enterable
                Heavy
        Floor
        Food
        Immovable
        Key
        Lever
        Passage
                PathPassage
        RearContainer
        Room
        Settable
                Dial
                        NumberedDial
        SimpleAttachable
                AttachableComponent
                NearbyAttachable
                        Attachable
        StairwayDown
        StairwayUp
        SubComponent
        Surface
                Platform
        Switch
                Flashlight
        Underside
        Wearable

Global Objects  

dummy_  pluralDummy_  scopeProbe_ 

Summary of Properties  

actorAlreadyInMsg  actorAlreadyOnMsg  actorNotInMsg  actorNotOnMsg  allowPourIntoMe  allowPourOntoMe  alreadyCleanMsg  alreadyClosedMsg  alreadyFastenedMsg  alreadyHasMsg  alreadyHeldMsg  alreadyInMsg  alreadyLitMsg  alreadyLockedMsg  alreadyMovedToMsg  alreadyOnMsg  alreadyOpenMsg  alreadyPresentMsg  alreadyThereMsg  alreadyWornMsg  autoGetOutToReach  autoTakeOnFindHidden  autoUnlock  bulk  bulkCapacity  canAttachToMe  canAttackWithMe  canBurnWithMe  canCleanWithMe  canClimbDownMe  canClimbUpMe  canCutWithMe  canDetachFromMe  canDigWithMe  canEnterOnMe  canFastenToMe  canGoThrougMe  canHearIn  canHearOut  canJumpOffMe  canJumpOverMe  canLieOnMe  canLockWithMe  canLookBehindMe  canLookThroughMe  canLookUnderMe  canMoveToMe  canMoveWithMe  cannotAttachMsg  cannotAttachToMsg  cannotAttachToSelfMsg  cannotAttackMsg  cannotAttackWithMsg  cannotAttackWithSelfMsg  cannotBoardMsg  cannotBreakMsg  cannotBurnMsg  cannotBurnWithMsg  cannotCleanMsg  cannotCleanWithMsg  cannotClimbDownMsg  cannotClimbMsg  cannotCloseMsg  cannotConsultMsg  cannotCutMsg  cannotCutWithMsg  cannotCutWithSelfMsg  cannotDetachFromMsg  cannotDetachFromSelfMsg  cannotDetachMsg  cannotDigMsg  cannotDigWithMsg  cannotDigWithSelfMsg  cannotDoffMsg  cannotDrinkMsg  cannotDropMsg  cannotEatMsg  cannotEnterMsg  cannotEnterOnMsg  cannotExtinguishMsg  cannotFastenMsg  cannotFastenToMsg  cannotFastenToSelfMsg  cannotFeelMsg  cannotFlipMsg  cannotFollowMsg  cannotFollowSelfMsg  cannotGetInCarriedMsg  cannotGetOnCarriedMsg  cannotGiveToMsg  cannotGiveToSelfMsg  cannotGoNearThereMsg  cannotGoThroughMsg  cannotJumpOffMsg  cannotJumpOverMsg  cannotKissMsg  cannotLieOnMsg  cannotLightMsg  cannotLockWithMsg  cannotLockWithSelfMsg  cannotLookBehindMsg  cannotLookThroughMsg  cannotLookUnderMsg  cannotMoveMsg  cannotMoveToMsg  cannotMoveToSelfMsg  cannotMoveWithMsg  cannotMoveWithSelfMsg  cannotOpenMsg  cannotPlugIntoMsg  cannotPlugIntoSelfMsg  cannotPlugMsg  cannotPourIntoMsg  cannotPourIntoSelfMsg  cannotPourMsg  cannotPourOntoMsg  cannotPourOntoSelfMsg  cannotPullMsg  cannotPurloinContainerMsg  cannotPurloinRoomMsg  cannotPurloinSelfMsg  cannotPushDownMsg  cannotPushIntoMsg  cannotPushMsg  cannotPushOwnContainerMsg  cannotPushThroughMsg  cannotPushUpMsg  cannotPushViaSelfMsg  cannotPutBehindMsg  cannotPutInMsg  cannotPutInSelfMsg  cannotPutMsg  cannotPutOnMsg  cannotPutUnderMsg  cannotReadMsg  cannotRemoveMsg  cannotScrewMsg  cannotScrewWithMsg  cannotScrewWithSelfMsg  cannotSetMsg  cannotSetToMsg  cannotShowToMsg  cannotShowToSelfMsg  cannotSitOnMsg  cannotSmellMsg  cannotStandOnMsg  cannotTakeFromSelfMsg  cannotTakeMsg  cannotTakeMyContainerMsg  cannotTakeSelfMsg  cannotTalkToMsg  cannotTalkToSelfMsg  cannotTasteMsg  cannotThrowAtMsg  cannotThrowAtSelfMsg  cannotThrowMsg  cannotThrowToMsg  cannotThrowToSelfMsg  cannotTurnMsg  cannotTurnToMsg  cannotTurnWithMsg  cannotTurnWithSelfMsg  cannotTypeOnMsg  cannotUnfastenFromMsg  cannotUnfastenFromSelfMsg  cannotUnfastenMsg  cannotUnlockWithMsg  cannotUnlockWithSelfMsg  cannotUnplugFromMsg  cannotUnplugFromSelfMsg  cannotUnplugMsg  cannotUnscrewMsg  cannotUnscrewWithMsg  cannotUnscrewWithSelfMsg  cannotWearMsg  cannotWriteOnMsg  canPlugIntoMe  canPourIntoMe  canPourOntoMe  canPullTravel  canPushTravel  canPutBehindMe  canPutInMe  canPutUnderMe  canReachIn  canReachOut  canScrewWithMe  canSeeIn  canSeeOut  canSetMeTo  canSitOnMe  canSmellIn  canSmellOut  canStandOnMe  canSupply  canTalkToMe  canThrowAtMe  canThrowToMe  canTurnMeTo  canTurnWithMe  canTypeOnMe  canUnfastenFromMe  canUnlockWithMe  canUnplugFromMe  canUnscrewWithMe  canWriteOnMe  checkAttackMsg  checkFeelMsg  checkKissMsg  circularlyInMsg  collectiveGroups  contents  contentsListed  contentsListedInExamine  contentsListedInLook  contentsListedInSearch  contType  currentInterlocutor  curSetting  darkName  decorationActions  decorationActions  desc  directlyHeld  directlyIn  directlyWorn  distinguishByContents  dontNeedCleaningObjMsg  dropItemsBehind  dropItemsUnder  dropLocation  enclosing  examined  examineListed  examineLister  exitLocation  extContents  familiar  feelDesc  findHiddenDest  fluidName  futileToAttackMsg  futileToKissMsg  getBulkHiddenBehind  getBulkHiddenIn  getBulkHiddenUnder  getFacets  getOutermostRoom  getOutToJump  globalParamName  groupOrder  hearNothingMsg  hiddenBehind  hiddenIn  hiddenUnder  inDarkDesc  indirectLockableMsg  initSpecialDesc  intContents  interiorDesc  inventoryListed  isAttachable  isAttackable  isBoardable  isBreakable  isBurnable  isClean  isCleanable  isClimbable  isCloseable  isConsultable  isCuttable  isDecoration  isDetachable  isDiggable  isDoffable  isDrinkable  isDroppable  isEdible  isEnterable  isExtinguishable  isFastenable  isFastened  isFeelable  isFixed  isFlippable  isFollowable  isHidden  isKissable  isLightable  isListed  isLit  isLocked  isMoveable  isOn  isOpen  isOpenable  isPlayerChar  isPlugable  isPourable  isProminentNoise  isProminentSmell  isPullable  isPushable  isReadable  isRemoveable  isScrewable  isSettable  isSmellable  isSwitchable  isTakeable  isTasteable  isThrowable  isTransparent  isTurnable  isUnfastenable  isUnplugable  isUnscrewable  isVehicle  isWearable  keyDoesntWorkMsg  keyList  keyNotNeededMsg  kissRank  known  knownKeyList  knownProp  lastSeenAt  lieOnScore  listableContents  listenDesc  listOrder  listWith  location  lockability  lockedMsg  lookBehindMsg  lookInMsg  lookListed  lookThroughMsg  lookUnderMsg  markInventoryAsSeen  matchPullOnly  matchPushOnly  maxBulkHiddenBehind  maxBulkHiddenIn  maxBulkHiddenUnder  maxSingleBulk  mentioned  moved  movedTo  moveNoEffectMsg  mustBeCleanedWith  myInventoryLister  myLookBehindLister  myLookInLister  myLookUnderLister  myOpeningContentsLister  myWornLister  needsCleaning  noLongerTalkingToAnyoneMsg  nominalContents  noNeedToCleanMsg  notFastenedMsg  notHoldingMsg  notImportantMsg  notInMsg  notLitMsg  notLockableMsg  notLockedMsg  notSwitchableMsg  notTalkingToAnyoneMsg  notWornMsg  objInPrep  objIntoPrep  okayCleanMsg  okayGetOutOfMsg  okayLockMsg  okayOpenMsg  okayPushIntoMsg  okayPushOutOfMsg  okayUnlockMsg  opened  openStatusReportable  owner  ownsContents  paraBrksBtwnSubcontents  partOfYouMsg  preCondActor  pullNoEffectMsg  pushNoEffectMsg  readDesc  recognizableInDark  remapActor  remapBehind  remapIn  remapOn  remapProps  remapUnder  roomContentsLister  roomSubContentsLister  roomTitle  searchListed  seen  seenProp  shouldBeBroken  shouldNotBreakMsg  shouldNotPourIntoMsg  shouldNotPourOntoMsg  sightSize  sitOnScore  smellDesc  smellNothingMsg  smellSize  soundSize  specialDesc  specialDescBeforeContents  specialDescListWith  specialDescOrder  stagingLocation  standOnScore  stateDesc  tasteDesc  throwFallsShortMsg  tooDarkToSeeMsg  tooFarAwayToHearMsg  tooFarAwayToReadMsg  tooFarAwayToSeeDetailMsg  tooFarAwayToSmellMsg  turnNoEffectMsg  useInitSpecialDesc  useKey_  useSpecialDesc  viaMode  visibleInDark  vocabLikelihood  withKeyMsg  wornBy 

Inherited from Mentionable :
ambiguouslyPlural  disambigGroup  disambigMatchPhrases  disambigName  disambigOrder  isHer  isHim  isIt  massNoun  matchPhrases  matchPhrasesExclude  name  person  plural  proper  qualified  states  vocab  vocabWords 

Inherited from LMentionable :
acronymPluralPat  alphaCharPat  aName  apostPluralPat  apostSPat  deannotatePat  dictComp  dummyName  elevenEighteenPat  emptyVocabWords  esPluralPat  firstWordPat  heName  herName  hersName  himName  iesPluralPat  irregularPlurals  lastWordPat  leadingTagOrQuotePat  menPluralPat  objInName  objIntoName  objName  objOutOfName  oneLetterAnWordPat  oneLetterWordPat  ownerNamed  pluralPat  posPat  possAdj  possNoun  prepList  prepPhrasePat  prepWordPat  pronounMap  properNamePat  properPat  reflexiveName  specialAOrAn  tagOrQuotePat  thatName  thatObjName  theName  theObjName  trimPat  truncationLength  weakWordPat 

Summary of Methods  

abcName  actionMoveInto  actorAction  addToAllContents  addToContents  afterAction  afterTravel  allContents  allowReachOut  beforeAction  beforeMovePushable  beforeTravel  canHear  cannotPushTravelMsg  cannotReachOutMsg  canReach  canSee  canSmell  canTalkTo  checkDisplay  checkInsert  checkPushTravel  checkReach  checkReachIn  checkRoomToHold  checkSetting  childLocType  commonContainingParent  commonInteriorParent  containerPath  containerPathBlock  darkDesc  describeMovePushable  describePushTravel  directChildParent  discover  display  displayAlt  dobjFor(AskAbout)  dobjFor(AskFor)  dobjFor(Attach)  dobjFor(AttachTo)  dobjFor(Attack)  dobjFor(AttackWith)  dobjFor(Board)  dobjFor(Break)  dobjFor(Burn)  dobjFor(BurnWith)  dobjFor(Clean)  dobjFor(CleanWith)  dobjFor(Climb)  dobjFor(ClimbDown)  dobjFor(ClimbUp)  dobjFor(Close)  dobjFor(ConsultAbout)  dobjFor(Cut)  dobjFor(CutWith)  dobjFor(Default)  dobjFor(Detach)  dobjFor(DetachFrom)  dobjFor(Dig)  dobjFor(DigWith)  dobjFor(Doff)  dobjFor(Drink)  dobjFor(Drop)  dobjFor(Eat)  dobjFor(Enter)  dobjFor(EnterOn)  dobjFor(Examine)  dobjFor(Extinguish)  dobjFor(Fasten)  dobjFor(FastenTo)  dobjFor(Feel)  dobjFor(Flip)  dobjFor(Follow)  dobjFor(GetOff)  dobjFor(GetOutOf)  dobjFor(GiveTo)  dobjFor(GiveToImplicit)  dobjFor(GoNear)  dobjFor(GoThrough)  dobjFor(GoTo)  dobjFor(JumpOff)  dobjFor(JumpOver)  dobjFor(Kiss)  dobjFor(LieIn)  dobjFor(LieOn)  dobjFor(LieOn)  dobjFor(Light)  dobjFor(ListenTo)  dobjFor(Lock)  dobjFor(LockWith)  dobjFor(LookBehind)  dobjFor(LookIn)  dobjFor(LookThrough)  dobjFor(LookUnder)  dobjFor(Move)  dobjFor(MoveTo)  dobjFor(MoveWith)  dobjFor(Open)  dobjFor(PlugIn)  dobjFor(PlugInto)  dobjFor(Pour)  dobjFor(PourInto)  dobjFor(PourOnto)  dobjFor(Pull)  dobjFor(Purloin)  dobjFor(Push)  dobjFor(PushTravelClimbDown)  dobjFor(PushTravelClimbUp)  dobjFor(PushTravelDir)  dobjFor(PushTravelEnter)  dobjFor(PushTravelGetOutOf)  dobjFor(PushTravelThrough)  dobjFor(PutBehind)  dobjFor(PutIn)  dobjFor(PutOn)  dobjFor(PutUnder)  dobjFor(QueryAbout)  dobjFor(Read)  dobjFor(Remove)  dobjFor(SayTo)  dobjFor(Screw)  dobjFor(ScrewWith)  dobjFor(Search)  dobjFor(Set)  dobjFor(SetTo)  dobjFor(ShowTo)  dobjFor(ShowToImplicit)  dobjFor(SitIn)  dobjFor(SitOn)  dobjFor(SitOn)  dobjFor(SmellSomething)  dobjFor(StandIn)  dobjFor(StandOn)  dobjFor(StandOn)  dobjFor(Strike)  dobjFor(SwitchOff)  dobjFor(SwitchOn)  dobjFor(SwitchVague)  dobjFor(Take)  dobjFor(TakeFrom)  dobjFor(TakeFrom)  dobjFor(TalkAbout)  dobjFor(TalkTo)  dobjFor(Taste)  dobjFor(TellAbout)  dobjFor(Throw)  dobjFor(ThrowAt)  dobjFor(ThrowDir)  dobjFor(ThrowTo)  dobjFor(Turn)  dobjFor(TurnTo)  dobjFor(TurnWith)  dobjFor(TypeOn)  dobjFor(TypeOnVague)  dobjFor(Unfasten)  dobjFor(UnfastenFrom)  dobjFor(Unlock)  dobjFor(UnlockWith)  dobjFor(Unplug)  dobjFor(UnplugFrom)  dobjFor(Unscrew)  dobjFor(UnscrewWith)  dobjFor(Wear)  dobjFor(WriteOn)  doPushTravel  examineStatus  filterResolveList  findHidden  findPlausibleKey  firstContainerPathBlock  getBulkWithin  getCarriedBulk  getStatuslineExitsHeight  handleCommand  hasSeen  hideFromAll  interiorParent  iobjFor(AttachTo)  iobjFor(AttackWith)  iobjFor(BurnWith)  iobjFor(CleanWith)  iobjFor(CutWith)  iobjFor(Default)  iobjFor(DetachFrom)  iobjFor(DigWith)  iobjFor(FastenTo)  iobjFor(GiveTo)  iobjFor(LockWith)  iobjFor(MoveTo)  iobjFor(MoveWith)  iobjFor(PlugInto)  iobjFor(PourInto)  iobjFor(PourOnto)  iobjFor(PushTravelClimbDown)  iobjFor(PushTravelClimbUp)  iobjFor(PushTravelEnter)  iobjFor(PushTravelGetOutOf)  iobjFor(PushTravelThrough)  iobjFor(PutBehind)  iobjFor(PutIn)  iobjFor(PutOn)  iobjFor(PutUnder)  iobjFor(ScrewWith)  iobjFor(ShowTo)  iobjFor(TakeFrom)  iobjFor(ThrowAt)  iobjFor(ThrowTo)  iobjFor(TurnWith)  iobjFor(UnfastenFrom)  iobjFor(UnlockWith)  iobjFor(UnplugFrom)  iobjFor(UnscrewWith)  isAudibleFrom  isChild  isDirectChild  isDirectlyHeldBy  isDirectlyIn  isDirectlyWornBy  isHeldBy  isIlluminated  isIn  isInterior  isOrIsIn  isOutside  isReadableFrom  isSmellableFrom  isThereALightSourceIn  isVisibleFrom  isWornBy  knowsAbout  listableContentsOf  listContents  listRemoteContents  listSubcontentsOf  litWithin  locationWhich  locType  lookAroundWithin  makeCleaned  makeFastened  makeLit  makeLocked  makeMovedTo  makeOn  makeOpen  makeSetting  makeWorn  moveHidden  moveInto  moveMLIntoAdd  moveMLOutOf  nominalOwner  noteSeen  notifyInsert  notifyRemove  notionalContents  outermostParent  outermostVisibleParent  ownedBy  preinitThing  pushTravelRevealItems  reachBlockedMsg  remoteInitSpecialDesc  remoteObjInName  remoteSpecialDesc  removeFromContents  revealOnMove  roomHeadline  roomSubhead  sayDontKnowHowToGetThere  sayDontKnowHowToReach  sayFindHidden  scoreObject  setHasSeen  setKnown  setKnowsAbout  setSeen  shinesOut  showConnectedMiscContents  showFirstConnectedSpecials  showRemoteSpecialDesc  showSecondConnectedSpecials  showSpecialDesc  showStatuslineExits  statusName  totalBulkIn  traceContainerPath  travelVia  tryCheck  unmention  unmentionRemoteContents  verifyActor  verifyPushTravel  wouldBeLitFor 

Inherited from ReplaceRedirector :
redirect 

Inherited from Redirector :
doInstead  doNested  doOtherAction 

Inherited from Mentionable :
construct  matchName  matchNameCommon  matchNameDisambig  phraseMatchName  simpleMatchName 

Inherited from LMentionable :
addDictWord  addVocab  addVocabWord  aNameFrom  aNameFromPoss  classInit  contify  distinguishedName  ifPronoun  inheritVocab  initVocab  initVocabWord  locify  matchPronoun  pluralNameFrom  pluralWordFrom  possessify  pronoun  removeVocabWord  replaceVocab  theNameFrom  theNameIs 

Properties  

actorAlreadyInMsgthing.t[6496]

no description available

actorAlreadyOnMsgthing.t[6363]
no description available

actorNotInMsgthing.t[6563]
no description available

actorNotOnMsgthing.t[6564]
no description available

allowPourIntoMething.t[8129]
While it's possible to pour stuff into any container, we probably don't want to allow it on most of them

allowPourOntoMething.t[8081]
The allowPourOntoMe property controls whether we want allow anything to be poured onto this thing (even if it's possible). By default we don't.

alreadyCleanMsgthing.t[6961]
no description available

alreadyClosedMsgthing.t[4764]
no description available

alreadyFastenedMsgthing.t[7591]
no description available

alreadyHasMsgthing.t[8788]
no description available

alreadyHeldMsgthing.t[4162]
no description available

alreadyInMsgthing.t[5340]
Handled on iobj

alreadyLitMsgthing.t[6798]
no description available

alreadyLockedMsgthing.t[5803]
Remap the lock action to our remapIn object if we're not lockable but we have a lockable remapIn object (i.e. an associated container).

alreadyMovedToMsgthing.t[6766]
no description available

alreadyOnMsgthing.t[6090]
no description available

alreadyOpenMsgthing.t[4721]
no description available

alreadyPresentMsgthing.t[7447]
no description available

alreadyThereMsgthing.t[7445]
no description available

alreadyWornMsgthing.t[6223]
no description available

autoGetOutToReachthing.t[3431]
If an actor within me cannot reach an object from me, should the actor automatically try to get out of me?

autoTakeOnFindHiddenthing.t[4900]
If the actor finds something in a hiddenPrep list and there's nowhere obvious for it go, should he take it? By default the actor should take it if the object he's found it in/under/behind is fixed in place.

autoUnlockthing.t[4646]
Flag, do we want to attempt to unlock this item it it's locked when we try to open it?

bulkthing.t[2042]
This object's bulk, in arbitrary units (game authors should devise their own bulk scale according to the needs of their game).

bulkCapacitything.t[2048]
The maximum bulk that can be contained in this Thing. We set a very large number by default.

canAttachToMething.t[7478]
no description available

canAttackWithMething.t[4535]
By default we can't use most things as weapons

canBurnWithMething.t[6184]
By default we assume most things can't be used to burn other things with.

canCleanWithMething.t[7011]
We assume most objects aren't suitable for cleaning other objects with. Since the dobj is resolved first canCleanWithMe could be a method that checks whether the proposed iobj is suitable for cleaning gDobj; but a better way of doing it might be to list suitable objects in the mustBeCleanedWith property.

canClimbDownMething.t[6289]
no description available

canClimbUpMething.t[6274]
no description available

canCutWithMething.t[4872]
Most things can't be used to cut other things with

canDetachFromMething.t[7532]
no description available

canDigWithMething.t[7048]
Most objects aren't suitable digging instruments

canEnterOnMething.t[7964]
Entering something on means ENTER FOO ON BAR where FOO is a string literal and BAR is an object such as a computer terminal. Most objects can't be entered on in this sense.

canFastenToMething.t[7605]
no description available

canGoThrougMething.t[5239]
Most things cannot be gone through

canHearInthing.t[3333]
Can we hear in from my exterior to my interior? That is, can an observer on the outside of this container hear a sound source on the inside?

By default, we can hear in for all containers, since most materials transmit at least some sound even if they're opaque to light. For a soundproof material (a glass booth, say), you could override this to make it (!enclosing) instead.

canHearOutthing.t[3345]
Can we hear out from my interior to my exterior? That is, can an observer on the inside of this container hear a sound source on the outside?

By default, we can hear out for all containers, since most materials transmit at least some sound even if they're opaque to light. For a soundproof material (a glass both, say), you could override this to make it (!enclosing) instead.

canJumpOffMething.t[7854]
It should be possible to jump off something if and only if the actor is on it in the first place.

canJumpOverMething.t[7885]
It usually isn't possible (or at least useful) to jump over things.

canLieOnMething.t[6388]
no description available

canLockWithMething.t[5810]
Usually, if something can be used to unlock things it can also be used to lock them

canLookBehindMething.t[5120]
By default we make it possible to look behind things, but there could be many things it makes no sense to try to look behind.

canLookThroughMething.t[5216]
By default we make it possible to look through things, but there may well be things you obviously couldn't look through.

canLookUnderMething.t[5029]
We can look under most things, but there are some things (houses, the ground, sunlight) it might not make much sense to try looking under.

canMoveToMething.t[6738]
In general there's no reason why most objects can't be moved to.

canMoveWithMething.t[6671]
Most things can't be used to move other things with. Note that since the dobj is resolved first, objects or subclasses could override this with a method that returns true or nil depending on the identity of the dobj.

cannotAttachMsgthing.t[7494]
no description available

cannotAttachToMsgthing.t[7496]
no description available

cannotAttachToSelfMsgthing.t[7499]
no description available

cannotAttackMsgthing.t[4494]
no description available

cannotAttackWithMsgthing.t[4541]
no description available

cannotAttackWithSelfMsgthing.t[4538]
no description available

cannotBoardMsgthing.t[6362]
no description available

cannotBreakMsgthing.t[4568]
no description available

cannotBurnMsgthing.t[6196]
no description available

cannotBurnWithMsgthing.t[6198]
no description available

cannotCleanMsgthing.t[6958]
no description available

cannotCleanWithMsgthing.t[7024]
no description available

cannotClimbDownMsgthing.t[6302]
no description available

cannotClimbMsgthing.t[6287]
no description available

cannotCloseMsgthing.t[4763]
no description available

cannotConsultMsgthing.t[8024]
no description available

cannotCutMsgthing.t[4888]
no description available

cannotCutWithMsgthing.t[4890]
no description available

cannotCutWithSelfMsgthing.t[4892]
no description available

cannotDetachFromMsgthing.t[7544]
no description available

cannotDetachFromSelfMsgthing.t[7547]
no description available

cannotDetachMsgthing.t[7515]
no description available

cannotDigMsgthing.t[7079]
no description available

cannotDigWithMsgthing.t[7081]
no description available

cannotDigWithSelfMsgthing.t[7083]
no description available

cannotDoffMsgthing.t[6257]
no description available

cannotDrinkMsgthing.t[6880]
no description available

cannotDropMsgthing.t[4353]
The message to display if something can't be dropped.

cannotEatMsgthing.t[6862]
no description available

cannotEnterMsgthing.t[6495]
no description available

cannotEnterOnMsgthing.t[7983]
no description available

cannotExtinguishMsgthing.t[6838]
no description available

cannotFastenMsgthing.t[7588]
no description available

cannotFastenToMsgthing.t[7621]
no description available

cannotFastenToSelfMsgthing.t[7624]
no description available

cannotFeelMsgthing.t[4063]
no description available

cannotFlipMsgthing.t[6154]
no description available

cannotFollowMsgthing.t[4448]
no description available

cannotFollowSelfMsgthing.t[4451]
no description available

cannotGetInCarriedMsgthing.t[6499]
no description available

cannotGetOnCarriedMsgthing.t[6366]
no description available

cannotGiveToMsgthing.t[8804]
no description available

cannotGiveToSelfMsgthing.t[8807]
no description available

cannotGoNearThereMsgthing.t[9002]
no description available

cannotGoThroughMsgthing.t[5252]
no description available

cannotJumpOffMsgthing.t[7882]
Jumping off something has much the same effect as getting off it, i.e. moving the actor to our exitLocation.

cannotJumpOverMsgthing.t[7903]
no description available

cannotKissMsgthing.t[7835]
no description available

cannotLieOnMsgthing.t[6451]
no description available

cannotLightMsgthing.t[6796]
no description available

cannotLockWithMsgthing.t[5825]
no description available

cannotLockWithSelfMsgthing.t[5828]
no description available

cannotLookBehindMsgthing.t[5205]
no description available

cannotLookThroughMsgthing.t[5232]
no description available

cannotLookUnderMsgthing.t[5109]
no description available

cannotMoveMsgthing.t[6641]
no description available

cannotMoveToMsgthing.t[6760]
no description available

cannotMoveToSelfMsgthing.t[6763]
no description available

cannotMoveWithMsgthing.t[6688]
no description available

cannotMoveWithSelfMsgthing.t[6691]
no description available

cannotOpenMsgthing.t[4720]
no description available

cannotPlugIntoMsgthing.t[7724]
no description available

cannotPlugIntoSelfMsgthing.t[7722]
no description available

cannotPlugMsgthing.t[7720]
no description available

cannotPourIntoMsgthing.t[8156]
no description available

cannotPourIntoSelfMsgthing.t[8154]
no description available

cannotPourMsgthing.t[8150]
no description available

cannotPourOntoMsgthing.t[8158]
no description available

cannotPourOntoSelfMsgthing.t[8152]
no description available

cannotPullMsgthing.t[5293]
no description available

cannotPurloinContainerMsgthing.t[8973]
no description available

cannotPurloinRoomMsgthing.t[8971]
no description available

cannotPurloinSelfMsgthing.t[8969]
Note that the player char has seen the purloined item. Not doing this can make it appear that the player character doesn't know about an object that's in his/her inventory.

cannotPushDownMsgthing.t[8646]
no description available

cannotPushIntoMsgthing.t[8558]
no description available

cannotPushMsgthing.t[5271]
no description available

cannotPushOwnContainerMsgthing.t[8306]
no description available

cannotPushThroughMsgthing.t[8512]
no description available

cannotPushUpMsgthing.t[8622]
no description available

cannotPushViaSelfMsgthing.t[8309]
no description available

cannotPutBehindMsgthing.t[5653]
If we're actually a rear-like object (i.e. if our contType is Behind) then something put behind us can be moved inside us. Otherwise, all we can do with something put behind us is to add it to our hiddenBehind list and move it off-stage.

cannotPutInMsgthing.t[5467]
If we're actually a container-like object (i.e. if our contType is In) then something put in us can be moved inside us. Otherwise, all we can do with something put in us is to add it to our hiddenIn list and move it off-stage.

cannotPutInSelfMsgthing.t[5346]
no description available

cannotPutMsgthing.t[5303]
The most usual reason why we can't put something somewhere is that we can't pick it up in the first place, so by default we'll just copy cannotPutMsg from cannotTakeMsg.

cannotPutOnMsgthing.t[5376]
no description available

cannotPutUnderMsgthing.t[5560]
If we're actually an underside-like object (i.e. if our contType is Under) then something put under us can be moved inside us. Otherwise, all we can do with something put under us is to add it to our hiddenUnder list and move it off-stage.

cannotReadMsgthing.t[4423]
no description available

cannotRemoveMsgthing.t[6606]
Note that this message should never display in an English-language game since removeDoer will intercept the action before it gets to this point.

cannotScrewMsgthing.t[8246]
no description available

cannotScrewWithMsgthing.t[8248]
no description available

cannotScrewWithSelfMsgthing.t[8250]
no description available

cannotSetMsgthing.t[7924]
no description available

cannotSetToMsgthing.t[7322]
no description available

cannotShowToMsgthing.t[8835]
no description available

cannotShowToSelfMsgthing.t[8838]
no description available

cannotSitOnMsgthing.t[6449]
no description available

cannotSmellMsgthing.t[3990]
no description available

cannotStandOnMsgthing.t[6447]
no description available

cannotTakeFromSelfMsgthing.t[7129]
no description available

cannotTakeMsgthing.t[4159]
Report that we've been taken. Note that if the action causes several items to be taken, this method will only be called on the final item, and will need to report on all the items taken.

cannotTakeMyContainerMsgthing.t[4165]
no description available

cannotTakeSelfMsgthing.t[4167]
no description available

cannotTalkToMsgthing.t[8762]
no description available

cannotTalkToSelfMsgthing.t[8765]
no description available

cannotTasteMsgthing.t[4033]
no description available

cannotThrowAtMsgthing.t[7197]
Particular instances will nearly always need to override with a less generic and more plausible refusal message.

cannotThrowAtSelfMsgthing.t[7200]
no description available

cannotThrowMsgthing.t[4605]
The default result of throwing something in a compass direction is that it lands in the dropLocation of its outermost room.

cannotThrowToMsgthing.t[7232]
no description available

cannotThrowToSelfMsgthing.t[7235]
no description available

cannotTurnMsgthing.t[4797]
no description available

cannotTurnToMsgthing.t[7286]
no description available

cannotTurnWithMsgthing.t[4841]
no description available

cannotTurnWithSelfMsgthing.t[4844]
no description available

cannotTypeOnMsgthing.t[7956]
no description available

cannotUnfastenFromMsgthing.t[7673]
no description available

cannotUnfastenFromSelfMsgthing.t[7676]
no description available

cannotUnfastenMsgthing.t[7670]
no description available

cannotUnlockWithMsgthing.t[5757]
no description available

cannotUnlockWithSelfMsgthing.t[5760]
no description available

cannotUnplugFromMsgthing.t[7763]
no description available

cannotUnplugFromSelfMsgthing.t[7760]
no description available

cannotUnplugMsgthing.t[7757]
no description available

cannotUnscrewMsgthing.t[8251]
no description available

cannotUnscrewWithMsgthing.t[8253]
no description available

cannotUnscrewWithSelfMsgthing.t[8255]
no description available

cannotWearMsgthing.t[6222]
no description available

cannotWriteOnMsgthing.t[8002]
no description available

canPlugIntoMething.t[7685]
no description available

canPourIntoMething.t[8122]
Presumably it's possible by default to pour something into me if I'm a container; but this could be overridden simply to true for objects like the sea or a river.

canPourOntoMething.t[8075]
Most things can probably have something poured onto them in principle, though we might want to prevent it in practice. The canPourOntoMe property controls whether it's possible to pour onto this thing.

canPullTravelthing.t[8322]
Normally we don't distinguish PushTravel from PullTravel, but if we want something to be pushable between rooms but not pullable, or vice versa, we can set these to different values.

canPushTravelthing.t[8315]
By default we can't push travel most things. Push Travel means pushing an object from one place to another and traveling with it.

canPutBehindMething.t[2337]
Flag: can under objects be placed behind us? By default they can if our contType is Behind. If this is set to true and our contType is not Behind, anything placed behind us will be treated as hidden behind.

canPutInMething.t[2344]
Flag: can under objects be placed inside us? By default they can if our contType is In. If this is set to true and our contType is not In, anything placed in us will be treated as hidden in.

canPutUnderMething.t[2330]
Flag: can under objects be placed under us? By default they can if our contType is Under. If this is set to true and our contType is not Under, anything placed under us will be treated as hidden under.

canReachInthing.t[3375]
Can we reach in from my exterior to my interior? That is, can an observer outside this object reach something inside of it? By default, we can reach in if we're non-enclosing.

canReachOutthing.t[3368]
Can we reach out from my interior to my exterior? That is, can an observer inside this object reach something outside of it? By default, we can reach out if we're non-enclosing.

canScrewWithMething.t[8170]
Most things can't be used to screw other things with.

canSeeInthing.t[3313]
Can we see in from my exterior to my interior? That is, can an observer outside of this object see things located within it? By default, we can see in from outside if we're transparent or we're non-enclosing.

canSeeOutthing.t[3321]
Can we see out from my interior to my exterior? That is, can an observer inside this object see things located outside of it? By default, we can see out from inside if we're transparent or we're non-enclosing.

canSetMeTothing.t[7289]
no description available

canSitOnMething.t[6387]
Although we don't track postures as such, some objects may be better choices than other for sitting on (e.g. chairs), lying on (e.g. beds) and standing on (e.g. rugs), so we allow these to be tested for individually at the verify stage.

Note that none of these three properties (canSitOnMe, canLieOnMe, canStandOnMe) should normally be overridden to simply true, since they cannot make it possible to sit, lie or stand on something for which isBoardable is not true (or which contType is not On).

canSmellInthing.t[3353]
Can we smell in (from an observer on my exterior to an odor source on my interior)? By default, we can smell in if we're non-enclosing, since most solid materials aren't very permeable to scents (at human sensitivities, at least).

canSmellOutthing.t[3361]
Can we smell out (from an observer on my interior to an odor source on my exterior)? By default, we can smell out if we're non-enclosing, since most solid materials aren't very permeable to scents (at human sensitivities, at least).

canStandOnMething.t[6389]
no description available

canSupplything.t[7135]
Flag, can we supply more items from us that are currently in scope? By default we can't; but a DispensingCollective may be able to.

canTalkToMething.t[8665]
We don't bother to define isAskable etc. properties since we assume that no inanimate object can be conversed with, and that game code will use the Actor class to allow conversation. In any case since there's never any difficult in talking about oneself, the various illogicalSelf checks aren't needed.

Indeed, the handling of conversational commands on Thing is minimal; they are simply ruled out at the verify stage, since most Things can't converse. The implementation of these actions that allows conversation to take place is on the Actor class. We do however define a canTalkToMe property so that Actor can use the verify handling defined on Thing by just overriding it.

Things can't be talked to, so game code shouldn't normally override this property; it's there to be overridden on the Actor class.

canThrowAtMething.t[7161]
Most objects can the target of a throw, but it's conceivable that some might be obviously unsuitable

canThrowToMething.t[7214]
Most objects cannot have things thrown to then, since this would imply that they might be able to catch them, which only animate objects can do.

canTurnMeTothing.t[7240]
no description available

canTurnWithMething.t[4824]
By default things can't be used to turn other things with

canTypeOnMething.t[7927]
Most things can't be typed on.

canUnfastenFromMething.t[7657]
no description available

canUnlockWithMething.t[5742]
Most things can't be used to unlock with. In practice there's probably little point in overriding this property since if you do want to use something to unlock other things with, you'd use the Key class.

canUnplugFromMething.t[7727]
no description available

canUnscrewWithMething.t[8211]
no description available

canWriteOnMething.t[7987]
Most things can't be written on.

checkAttackMsgthing.t[4491]
If we want Attack to fail at the check stage we can supply a message explaining why.

checkFeelMsgthing.t[4071]
This property can be defined to display a message at the check stage (and so stop the FEEL action there). Normally checkFeelMsg would be defined as a double-quoted string, but it can also be defined as a double-quoted string or a method that displays some text.

checkKissMsgthing.t[7842]
If we want Kissing to fail at the check stage we can supply a message here explaining why. This is most simply given as a single-quoted string, but a double-quoted string or method will also work.

circularlyInMsgthing.t[5343]
no description available

collectiveGroupsthing.t[3125]
CollectiveGroup, or a list of CollectiveGroups, to which this item belongs.

contentsthing.t[2393]
The list of things directly contained by this object

contentsListedthing.t[1907]
Flag: should this item's contents be listed? This can be used to control both contentsListedInLook and contentsListedInExamine.

contentsListedInExaminething.t[1919]
Flag: should this item's contents be listed when its container is examined.

contentsListedInLookthing.t[1913]
Flag: should this item's contents be listed as part of a room description (when looking around).

contentsListedInSearchthing.t[1926]
Flag, should this item's contents be listed when it is searched (by default this is simply true, since it would be odd to have a container that failed to reveal its contents when searched).

contTypething.t[2389]
This object's containment type - that is, the locType for direct children. This is given as one of the spatial relation types (In, On, Under, Behind etc).

currentInterlocutorthing.t[3632]
The currentInterlocutor is the Actor this object is currently in conversation with. This property is only relevant on gPlayerChar, but it is defined here rather than on Actor since the player char can be of kind Thing.

curSettingthing.t[7283]
The value we're currently set to.

darkNamething.t[1017]
The name to display at the head of a room description when it's dark

decorationActionsthing.t[3847]
The list of actions this object will respond to specifically if isDecoration is true. All other actions will be handled by dobjFor(Default) and/or iobjFor(Default). Game code can override this list (usually to expand it) for decorations that are required to handle additional actions.

If we're compiling for debugging, it will be useful to allow the GONEAR command with Decorations for testing purposes, but this can't be included in a release build without causing a compilation error, so we define the decorationActions property with different lists of actions depending on whether we're compiling for debugging or release.

decorationActionsthing.t[3849]
no description available

descthing.t[1636]
The description of this Thing that's displayed when it's examined. Normally this would be defined as a double-quoted string, but in more complicated cases you could also define it as a method that displays some text.

directlyHeldthing.t[2307]
Get everything I'm directly holding, which is everything in my immediate contents which is neither fixed in place nor being worn.

directlyInthing.t[3237]
get everything that's directly in me

directlyWornthing.t[2321]
get everything I'm directly wearing

distinguishByContentsOVERRIDDENthing.t[2381]
Can I be distinguished in parser messages by my contents? If so, we can be distinguished (in parser messages) from similar objects by our contents, or lack thereof: "bucket of water" vs "empty bucket". If this is true, our nominalContents property determines the contents we display for this.

dontNeedCleaningObjMsgthing.t[6968]
no description available

dropItemsBehindthing.t[4173]
Flag, should any items behind me be left behind when I'm moved; by default, they should.

dropItemsUnderthing.t[4179]
Flag, should any items behind me be left behind when I'm moved; by default, they should.

dropLocationthing.t[4356]
The location in which something dropped in me should land.

enclosingthing.t[3305]
Do we fully enclose our interior contents (true), or only partially (nil)? By default, we assume that our contents are fully enclosed. This can be set to nil for objects that represent spaces that are open on one side, such as a nook in a rock or a create without a lid.

For an object that's sometimes fully enclosing and sometimes not, such as a cabinet with a door that can be opened and closed, this should be overridden with a method that figures the current value based on the open/closed state.

Note that this only applies to our *interior* contents, such as contents of location type In. Contents that are atop the object or otherwise arranged around the exterior aren't affected by this.

examinedthing.t[3548]
Have we been examined? This is set to true when the player character examines the object. For a room, LOOK AROUND counts as examination, as does triggering a room description by traveling into the room.

examineListedthing.t[1896]
Flag: is this item listed when its container is examined.

examineListerthing.t[1672]
The lister to use to list an item's contents when it's examined.

exitLocationthing.t[6514]
Our exitLocation is the location an actor should be moved to when s/he gets off/out of us.

extContentsthing.t[2632]
Get my list of unenclosed direct contents. This is the subset of my direct contents that have exterior location types (On, Outside, Behind, Under).

familiarthing.t[3579]
Whether the player character knows of the existence of this object, if if it hasn't been seen. Set to true for objects that the player character should be familiar with at the start of play, or make true when the PC learns of them.

feelDescthing.t[1953]
The description displayed in response to a FEEL command

findHiddenDestthing.t[4908]
Where should an item that's been hidden in/under/behind something be moved to when its found? If it's taken, move into the actor; otherwise move it to the location of the object it's just been found in/under/behind.

fluidNamething.t[8040]
Sometimes we may have a container, such as an oilcan, from which we want to pour a liquid, such as oil, and we're using the same object to do duty for both. We can then use the fluidName property to say 'the oil' rather than 'the oilcan' in messages that refer specifically to pouring the liquid.

futileToAttackMsgthing.t[4518]
In case isAttackable is changed to true but no other handling is added, we need to provide some kind of default report.

futileToKissMsgthing.t[7833]
It's more logical to kiss actors, so we give the Kiss action a lower logical rank on ordinary things.

getBulkHiddenBehindthing.t[2216]
no description available

getBulkHiddenInthing.t[2215]
no description available

getBulkHiddenUnderthing.t[2214]
The total bulk of items hidden in, under or behind this object

getFacetsthing.t[3726]
A list of objects that are facets of this object, and so can be referred to with the same pronoun.

getOutermostRoomthing.t[2725]
Our outermost room, i.e. the top level Room in which we are indirectly or directly contained.

getOutToJumpthing.t[7848]
Flag, if this is a nested room, should an actor get out of it before executing an intransitive Jump command. By default it should.

globalParamNamething.t[1990]
Our globalParamName is an arbitrary string value that can be used to refer to this thing in a message substitution parameter; for code readability it may be a good idea to make this a string representation of our programmatic name (where we want to define it at all).

groupOrderthing.t[3119]
Group order. This gives the relative order of this item within its list group.

hearNothingMsgthing.t[4023]
no description available

hiddenBehindthing.t[2191]
A list of objects that are treated as hidden behind this one. A LOOK BEHIND command will list them and move them into the enclosing room. It follows that objects placed in this property should not be given an initial location. This should deal with the most common reason for wanting items to be placed behind things (i.e. to hide them). Note, the items in the hiddenBehind property should also be revealed when the player moves the hiding item.

hiddenInthing.t[2199]
A list of objects that are treated as hidden inside this one. A LOOK IN command will list them and move them into the enclosing room (or in this one if we're a container). It follows that objects placed in this property should not be given an initial location.

hiddenUnderthing.t[2180]
A list of objects that are treated as hidden under this one. A LOOK UNDER command will list them and move them into the enclosing room. It follows that objects placed in this property should not be given an initial location. This should deal with the most common reason for wanting items to be placed under things (i.e. to hide them). Note, the items in the hiddenUnder property should also be revealed when the player moves the hiding item.

inDarkDescthing.t[2014]
An optional description to be displayed instead of our normal desc and any status information (such as our contents) if we're examined in a dark room and visibleInDark is true. Note that if visibleInDark is nil inDarkDesc will never be used.

indirectLockableMsgthing.t[5734]
no description available

initSpecialDescthing.t[1807]
A specialDesc that's shown until this item has been moved

intContentsthing.t[2625]
Get my list of enclosed direct contents. This is the subset of my direct contents that have interior location types (In).

interiorDescthing.t[1038]
The "inside" description. This is displayed when an actor LOOKS AROUND from within this object. Note that this applies not only to top-level rooms but also to things like chairs, platforms, and booths that can contain an actor. By default, we simply show the ordinary EXAMINE description (or the darkDesc if there's no illumination). Non-room containers such as chairs or booths should usually override this to provide the view from inside the object, which usually differs from the ordinary EXAMINE description. For a top-level room, you don't usually override this, since the only description needed for a room is normally the LOOK AROUND perspective.

inventoryListedthing.t[1893]
Flag: is this item listed in an inventory listing.

isAttachablething.t[7455]
By default most things can't be attached to any things. The base handling of ATTACH and DETACH on Thing merely rules them out at the verify stage. The SimpleAttachable and NearbyAttachable classes define in the optional attachables.t module provide fuller handling.

isAttackablething.t[4459]
Although in theory we can attack almost anything, in practice there's seldom reason to do so.

isBoardablething.t[2351]
Can an actor enter (get in or on) this object. Note that for such an action to be allowing the contType must also match the proposed action.

isBreakablething.t[4549]
By default treat everything as breakable, but there are somethings that clearly aren't like sunbeams, sounds and mountains.

isBurnablething.t[6158]
By default we assume most things aren't burnable

isCleanthing.t[6891]
Assume most things start out not as clean as they could be

isCleanablething.t[6888]
Most things probably could be cleaned, even if they're not worth cleaning in practice. Some things like a mountain or the moon probably can't be cleaned and could reasonably define isCleanable = nil.

isClimbablething.t[6262]
Most things can't be climbed

isCloseablething.t[4726]
By default something is closeable if it's openable

isConsultablething.t[8005]
Most things aren't consultable

isCuttablething.t[4847]
By default things can't be cut

isDecorationthing.t[3831]
If I declare this object to be a decoration (i.e. isDecoration = true) then its default behaviour will be to display its notImportantMsg for every action except Examine or GoTo. We can extend the actions it will respond to by adding them to the list in the decorationActions property.

isDetachablething.t[7502]
no description available

isDiggablething.t[7027]
Most things are not suitable for digging in

isDoffablething.t[6227]
By default we assume that something's doffable if it's wearable

isDrinkablething.t[6865]
Most things aren't drinkable

isDroppablething.t[4350]
By default we can drop anything that's held

isEdiblething.t[2355]
Flag: Can this thing be eaten

isEnterablething.t[6458]
Flag, can we enter (i.e. get inside) this thing? For most objects, we can't

isExtinguishablething.t[6808]
Most things are extinguishable if they're lit, but some things (like the sun or a nuclear explosion) might conceivably not be. Note that this property should only be set to nil for things that couldn't be extinguished even if they were lit (the flames of Hell, for example, which might be considered undousable for all eternity, if you're bent on writing an infernal game).

isFastenablething.t[7555]
Fasten by itself presumably refers to objects like seat-belts. There are not many such fastenable objects so we may things not fastenable by default.

isFastenedthing.t[7558]
Most things start out unfastened.

isFeelablething.t[4060]
By default we can try feeling most things, but there may be some things it would be inappropriate to try feeling (like a blazing fire or Aunt Mable) or somethings that cannot be felt (like a ray of light).

isFixedthing.t[1873]
Flag to indicate whether this item is portable (nil) or fixed in place (true). If it's fixed in place it can't be picked up or moved around (by player commands).

isFlippablething.t[6143]
Since FLIP X is often synonymous with SWITCH X , by default we make something flippable if it's switchable.

isFollowablething.t[4430]
Flag: can this object be followed? Most inanimate objects cannot, so the default value is nil.

isHiddenthing.t[2232]
Flag, do we want to treat this object as hidden from view (so that the player can't interact with it)?

isKissablething.t[7788]
We can try kissing most things, even if it isn't very rewarding

isLightablething.t[2022]
Is this object lightable (via a player command)? Note that setting this property to true also automatically makes the LitUnlit State applicable to this object, allowing it to be referred to as 'lit' or 'unlit' as appropriate.

isListedthing.t[1885]
A global isListed property that can be used to set the value of all the others. By default we're listed if we're not fixed in place.

isLitthing.t[1997]
Is this object lit, i.e. providing sufficient light to see not only this object but other objects in the vicinity by.

isLockedthing.t[2262]
Flag: is this object currently locked. By default we start out locked if we're lockable.

isMoveablething.t[6616]
By default we assume anything fixed isn't moveable. That's not necessarily the case since we may be able to move something by pushing it around (say) even if we can't pick it up.

isOnthing.t[2280]
is this item currently switched on?

isOpenthing.t[4622]
Is this object open. By default we'll make Things open so that their interiors (if they have any) are accessible, unless they're openable, in which case we'll assume they start out closed.

isOpenablething.t[4615]
Is this object openable. If this property is set to true then this object can be open and closed via the OPEN and CLOSE commands. Note that setting this property to true also automatically makes the OpenClosed State apply to this object, so that it can be referred to as 'open' or 'closed' accordingly.

isPlayerCharthing.t[3799]
Is this object the player character?

isPlugablething.t[7684]
Most things can't be plugged into other things or have other things plugged into them.

isPourablething.t[8030]
Most things aren't pourable (they can't be poured into or onto other things.

isProminentNoisething.t[1962]
Is the this object's listenDesc displayed in response to an intransitive LISTEN command? (Only relevant if listenDesc is not nil)

isProminentSmellthing.t[1950]
Is the this object's smellDesc displayed in response to an intransitive SMELL command? (Only relevant if smellDesc is not nil)

isPullablething.t[5277]
We can at least try to pull most things.

isPushablething.t[5256]
We can at least try to push most things.

isReadablething.t[4401]
By default an object is readable if it defines a non-nil readDesc

isRemoveablething.t[6598]
By default an object is removeable if it's takeable

isScrewablething.t[8167]
Most things can't be screwed

isSettablething.t[7907]
Most things aren't settable.

isSmellablething.t[3987]
By default everything is smellable, but you can override this to nil if something isn't

isSwitchablething.t[2277]
Can this object be switched on and off?

isTakeablething.t[4100]
By default a Thing is takeable if it's not fixed in place

isTasteablething.t[4029]
By default everything is tasteable, but there might well be things the that it would not be appropriate to taste.

isThrowablething.t[4574]
By default something is throwable unless it's fixed in place.

isTransparentthing.t[3287]
Are we transparent to light? If this is true, then an observer outside this object can see through it to objects on its interior, and an observer inside can see through to objects on its exterior.

This property controls transparency symmetrically (looking in from outside and looking out from within). The library also lets you control transparency asymmetrically, using canSeeIn and canSeeOut. Those values are by default derived from this one, but you can override them separately to create something like a one-way mirror.

isTurnablething.t[4772]
By default we make everything turnable, but lots of things clearly won't be.

isUnfastenablething.t[7626]
no description available

isUnplugablething.t[7726]
no description available

isUnscrewablething.t[8210]
no description available

isVehiclething.t[3086]
Flag; is this Thing a vehicle for an actor? If so then issuing a travel command while in this vehicle will call this vehicle to travel

isWearablething.t[2286]
is this object something that can be worn

keyDoesntWorkMsgthing.t[6057]
If we've found a possible key but it doesn't actually work on this object, report that we're trying this key but it doesn't work.

keyListthing.t[5661]
A list of Keys that can be used to lock or unlock this Thing. Any Keys in this list will cause this Thing to be added to the plausible and actual lock lists of that Key at PreInit. This provides an alternative way of specifying the relation between locks and keys.

keyNotNeededMsgthing.t[5732]
no description available

kissRankthing.t[7794]
The logical rank assigned to kissing this object if kissing is allowed. Kissing an inanimate object is less likely than kissing an Actor.

knownthing.t[3614]
Test whether this Thing is known to the player character.

knownKeyListthing.t[5667]
A list of Keys that the player character starts out knowing at the start of the game can lock our unlock this Thing.

knownPropthing.t[3623]
If we want to track whether characters other than than the player char know about or have seen this object, we can define knownProp and seenProp as the properties used by this Thing to track what it knows about and has seen.

lastSeenAtthing.t[3564]
The last location where the player character saw this object. Whenever the object is described or listed in the description of a room or another object, we set this to the object's location at that time.

lieOnScorething.t[6404]
no description available

listableContentsthing.t[1970]
The subset of our contents that should be listed.

listenDescthing.t[1956]
The description displayed in response to a LISTEN command

listOrderthing.t[3107]
Listing order. This is an integer giving the relative position of this item in a miscellaneous item list. The list is sorted in ascending order of this value.

listWiththing.t[3113]
List group. At the moment this does nothing, but it has been retained from the Mercury library for possible future use.

locationthing.t[2404]
The location of this object, i.e. this object's immediate container (which may be another Thing, a Room, or an Actor such as the player char). Note that while you should specify the initial location of an object via this property you should never directly alter this property in game code thereafter; to change the location on object during the the course of a game use the moveInto(loc) or actionMoveInto(loc) method.

lockabilitything.t[2256]
The lockability property determines whether this object is lockable and if so how. The possible values are notLockable, lockableWithoutKey, lockableWithKey and indirectLockable.

lockedMsgthing.t[4722]
no description available

lookBehindMsgthing.t[5208]
no description available

lookInMsgthing.t[4995]
By default our lookInMsg just says the actor finds nothing of interest in us; this could be overridden for an objecy with a more interesting interior.

lookListedthing.t[1890]
Flag: is this item listed in a room description (when looking around).

lookThroughMsgthing.t[5235]
no description available

lookUnderMsgthing.t[5112]
no description available

markInventoryAsSeenthing.t[1934]
Flag, if our contType is Carrier (i.e. we're an Actor), should our contents be marked as seen even though it hasn't been listed in a room description? By default this is set to true, on the basis that the inventory (and parts) of an actor would normally be in plain sight.

matchPullOnlything.t[8299]
Check if the player specifically asked to PULL this object somewhere. In the main library we assume not, but language-specific code will need to override to check what that player's command actually said.

matchPushOnlything.t[8291]
Check if the player specifically asked to PUSH this object somewhere. In the main library we assume not, but language-specific code will need to override to check what that player's command actually said.

maxBulkHiddenBehindthing.t[2210]
no description available

maxBulkHiddenInthing.t[2211]
no description available

maxBulkHiddenUnderthing.t[2209]
The maximum bulk that can be hidden under, behind or in this object, assuming that the player can put anything there at all. Note that this only affects what the player can place there with PUT IN, PUT UNDER and PUT BEHIND commands, not what can be defined there initially or moved there programmatically.

maxSingleBulkthing.t[2056]
The maximum bulk that a single item may have to be inserted into (onto, under, behind) this object; by default this is the same as the bulk capacity, but you could set a lower value, e.g. to model a bottle with a narrow neck.

mentionedthing.t[1776]
Has this item been mentioned yet in a room description. Note that this flag is used internally by the library; it shouldn't normally be necessary to manipulate it directly from game code.

movedthing.t[3540]
Has this object ever been moved by the player character? This is set to true when the PC takes the object or puts it somewhere.

movedTothing.t[6732]
The notional location (other object) this object has been moved to as the result of a MoveTo command.

moveNoEffectMsgthing.t[6663]
no description available

mustBeCleanedWiththing.t[6900]
If this is non-nil then this is an object or a list of objects that must be/can be used to clean this object.

myInventoryListerthing.t[3645]
The lister to use when listing this object's inventory.

myLookBehindListerthing.t[5201]
The lister to use when listing the objects behind me in response to a LOOK BEHIND command. By default we use the lookInLister.

myLookInListerthing.t[4986]
The lister to use when listing the objects inside me in response to a LOOK IN command. By default we use the lookInLister.

myLookUnderListerthing.t[5106]
The lister to use when listing the objects under me in response to a LOOK UNDER command. By default we use the lookInLister.

myOpeningContentsListerthing.t[4715]
The lister to use when listing my contents when I'm opened. By default we use the openingContentsLister.

myWornListerthing.t[3648]
The lister to use when listing what this object is wearing.

needsCleaningthing.t[6894]
But that most things don't actually need cleaning in the game

noLongerTalkingToAnyoneMsgthing.t[8901]
no description available

nominalContentsOVERRIDDENthing.t[2372]
My nominal contents is the special contents item we can use in naming the object. This is useful for containers whose identities come primarily from their contents, such as a vessel for liquids or a box of loose files. Returns an object that qualifies the name: a "water" object for BOX OF WATER, a "files" object for BOX OF FILES. Nil means that the object isn't named by its contents.

Note that this is always a single object (or nil), not the whole list of contents. We can only be named by one content object. (So you can't have a "box of books and papers" by having separate nominal contents objects for the books and the papers; although you could fake it by creating a "books and papers" object.)

noNeedToCleanMsgthing.t[6964]
no description available

notFastenedMsgthing.t[7678]
no description available

notHoldingMsgthing.t[4397]
And I can't drop something that game code has deemed to be not droppable for some other reason.

notImportantMsgthing.t[3874]
no description available

notInMsgthing.t[7127]
We're also a poor choice if none of the tentative direct objects is in our list of notional contents

notLitMsgthing.t[6835]
no description available

notLockableMsgthing.t[5730]
If we are lockable with key, then were a good choice of object for an UnlockWith action provided we're currently locked.

notLockedMsgthing.t[5735]
no description available

notSwitchableMsgthing.t[6088]
no description available

notTalkingToAnyoneMsgthing.t[8898]
no description available

notWornMsgthing.t[6259]
no description available

objInPrepthing.t[2029]
The preposition that should be used to describe containment within this thing (e.g. 'in', 'on' , 'under' or 'behind'). By default we get this from our contType.

objIntoPrepthing.t[2036]
The preposition that should be used to describe movement to within this thing (e.g. 'into', 'onto' , 'under' or 'behind'). By default we get this from our contType.

okayCleanMsgthing.t[6971]
no description available

okayGetOutOfMsgthing.t[6561]
no description available

okayLockMsgthing.t[5984]
Make us locked.

okayOpenMsgthing.t[4717]
no description available

okayPushIntoMsgthing.t[8530]
no description available

okayPushOutOfMsgthing.t[8598]
no description available

okayUnlockMsgthing.t[5905]
Make us unlocked.

openedthing.t[4640]
Flag, has this object ever been opened. Note that this is nil for an object that starts out open but has never been closed and opened again.

openStatusReportablething.t[1784]
Do we want this object to report whether it's open? By default we do if it's both openable and open.

ownerthing.t[3147]
The owner or owners of the object. This is for resolving possessives in the player's input, such as BOB'S WALLET. By default, an object has no explicit owner, so this is an empty list.

This should only return the *explicit* owner(s), not an implied locational owner. For example, if Bob is holding a key, it's implicitly BOB'S KEY. However, the key may or may not still be Bob's after he drops it. If the key is something that's understood to belong to Bob, whether it's currently in his physical possession or not, then this routine would return Bob; otherwise it would return nil.

An object can have multiple explicit owners, in which case it'll be recognized with a possessive qualifier for any of the owners. The first owner in the list is the nominal owner, meaning its the one we'll use if we're called upon to display the object's name with a possessive phrase.

ownsContentsthing.t[3166]
Are we the nominal owner of the objects we contain? This controls whether or not we can be chosen as the nominal owner of a contained object for display purposes. If a contained object has no explicit owner, it can still be implicitly owned by an actor carrying it, or by another suitable container. (Note that this only applies as a default. When an item in our contents has an explicit owner, that will override the implied container ownership for that item. So, for example, Bob can be carrying Bill's wallet wallet, and as long as the wallet has its explicit owner set, we'll still describe it as Bill's despite its location.)

By default, most objects are not nominal owners. Actors generally should set this to true, so that (for example) anything Bob is carrying can be described as Bob's. Something with contType = Carrier is likely to be an actor and hence something that can own its contents.

paraBrksBtwnSubcontentsthing.t[1538]
Do we want paragraph breaks between the listings of subcontents (i.e. the contents of this item's contents)? By default we take our value from the global setting on gameMain.

partOfYouMsgthing.t[4398]
no description available

preCondActorthing.t[3894]
no description available

pullNoEffectMsgthing.t[5296]
no description available

pushNoEffectMsgthing.t[5274]
no description available

readDescthing.t[1941]
The text we display in response to a READ command. This can be nil (if we're not readable), a single-quoted string, a double-quoted string

recognizableInDarkthing.t[1011]
Can the player character recognize this room (enough to know its name and have a rough idea of its location) in the dark? (If so then looking around in this room in the dark makes it visited and familiar, otherwise it doesn't).

remapActorthing.t[3892]
If our contType isn't Carrier we're unlikely to be an actor, so we're a poor choice of object if the parser has to select an actor, typically when the player has entered a command targeted at an NPC.

remapBehindthing.t[2144]
If non-nil, remapUnder specified the object that acts as our proxy rear, i.e. the object to which any PUT BEHIND or LOOK BEHIND action directed at us will be redirected.

remapInthing.t[2124]
If remapIn is not nil, a LOOK IN, PUT IN, OPEN, CLOSE, LOCK or UNLOCK command performed on this Thing will be redirected to the object specified on remapIn. In other words, remapIn specifies the object that acts as our proxy container.

remapOnthing.t[2130]
If non-nil, remapOn speficies the object that acts as our proxy surface, in other words the object to which PUT ON will be redirected.

remapPropsthing.t[2115]
The list of possible remap props

remapUnderthing.t[2137]
If non-nil, remapUnder specified the object that acts as our proxy underside, i.e. the object to which any PUT UNDER or LOOK UNDER action directed at us will be redirected.

roomContentsListerthing.t[1095]
The contents lister to use for listing this room's miscellaneous contents. By default we use the standard lookLister but this can be overridden to use a CustomRoomLister (say) to provide just about any wording we like.

roomSubContentsListerthing.t[1102]
The contents lister to use for listing this room's miscellaneous subcontents. By default we use the standard lookContentsLister but this can be overridden.

roomTitleOVERRIDDENthing.t[1014]
The name to display at the head of a room description

searchListedthing.t[1901]
Flag: is this item listed when is container is searched (or looked in).

seenthing.t[3556]
Have we been seen? This is set to true the first time the object is described or listed in a room description or the description of another object (such as LOOK IN this object's container).

seenPropthing.t[3624]
no description available

shouldBeBrokenthing.t[4552]
Probably most things shouldn't be broken though.

shouldNotBreakMsgthing.t[4571]
no description available

shouldNotPourIntoMsgthing.t[8160]
no description available

shouldNotPourOntoMsgthing.t[8163]
no description available

sightSizesenseRegion.t[744]
The sightSize can be small, medium or large and controls how visible this object is from a remote location. If it's small, it can't be seen from a remote location at all. It it's medium, the object can be seen, but it's not possible to discern any detail. If it's large, it can be seen and described. Note that this behaviour is only the default, however, since it can be changed by overriding the isVisibleFrom() and remoteDesc() methods. Note also that sightSize is not related to the bulk property (unless you override sightSize to make it so).

sitOnScorething.t[6403]
As well as ruling out certain objects for sitting, lying or standing on, we can also give them a score for each of these postures; e.g. a bed may be particularly suitable for lying on (although you could lie on the sofa) while a chair may be particularly suitable for sitting on (though you could sit on the bed.

By default we'll give each posture a score of 100, the normal logical verify score. Note that these scores have no effect if the corresponding can xxxOnMe property is nil.

smellDescthing.t[1944]
The description displayed in response to a SMELL command

smellNothingMsgthing.t[4009]
no description available

smellSizesenseRegion.t[760]
The smellSize can be small, medium or large. By default something is smellable from a remote location either if its smellSize is large or if it smellSize is not small and its remoteSmellDesc() method has been defined. Overriding isSmellableFrom(pov) may change these rules.

soundSizesenseRegion.t[752]
The soundSize can be small, medium or large. By default something is audible from a remote location either if its soundSize is large or if it soundSize is not small and its remoteListenDesc() method has been defined. Overriding isAudibleFrom(pov) may change these rules.

specialDescthing.t[1793]
If present, a description of this object shown in a separate paragraph in the listing of the contents of a Room. If specialDesc is defined then this paragraph will be displayed regardless of the value of isListed.

specialDescBeforeContentsthing.t[1831]
Is this item listed before or after the list of miscellaneous contents in the room. By default we'll show the specialDesc of items before miscellaneous items in a room description but afterwards otherwise: this places specialDescs in a more logical order in relation to the text of listers used to list the contents of obejcts other than rooms.

specialDescListWiththing.t[1834]
For possible future use; at the moment this doesn't do anything

specialDescOrderthing.t[1822]
The specialDescOrder property controls where in a series of specialDesc paragraphs this item is mentioned: the higher the number, the later it will come relative to other items. Note that this does not override the specialDescBeforeContents setting.

stagingLocationthing.t[6517]
Our staging location is where we need to be to get on/in us

standOnScorething.t[6405]
no description available

stateDescthing.t[1643]
The state-specific description of this object, which is appended to its desc when examined. This is defined as a single-quoted string to make it easy to change at run-time.

tasteDescthing.t[1965]
The description displayed in response to a TASTE command

throwFallsShortMsgthing.t[7238]
no description available

tooDarkToSeeMsgthing.t[3981]
The message to display when it's too dark to see anything

tooFarAwayToHearMsgsenseRegion.t[912]
Otherwise say this object is too far away for the actor to hear.

tooFarAwayToReadMsgsenseRegion.t[931]
no description available

tooFarAwayToSeeDetailMsgsenseRegion.t[857]
Otherwise say this object is too far away for the actor to see any detail.

tooFarAwayToSmellMsgsenseRegion.t[986]
Otherwise say this object is too far away for the actor to smell.

turnNoEffectMsgthing.t[4800]
no description available

useInitSpecialDescthing.t[1814]
By default we use the initSpecialDesc until the object has been moved, but this can be overridden with some other condition.

useKey_thing.t[6059]
no description available

useSpecialDescthing.t[1803]
Should the specialDesc be used? Normally we use the specialDesc if we have one, but we may want to override this for particular cases. For example, if we want an item to have a paragraph to itself until it's moved we could define useSpecialDesc = (!moved) [making it equivalent to initSpecialDesc]. Note that the useSpecialDesc property only has any effect if specialDesc is not nil.

viaModething.t[8302]
no description available

visibleInDarkthing.t[2006]
Is this object visible in the dark without (necessarily) providing enough light to see anything else by, e.g. the night sky.

vocabLikelihoodthing.t[3719]
A property that can be used to boost this object being chosen by the parser, other things being equal; it can be used as a tie-breaker between two objects that otherwise have the same verification scores. Game code should normally use fairly small values for this property, say between -20 and +20, to prevent overriding the verification score.

withKeyMsgthing.t[5986]
no description available

wornBything.t[2292]
If this object is currently being worn by someone, the wornBy property contains the identity of the person wearing it.

Methods  

abcName (action, role)english.t[2165]

Announce Best Choice name. This can be used in those rare cases where you want to override the name the parser uses to describe an object when announcing its best choice of object. For example, if you have a bottle of wine from which you can fill a glass, you might prefer '(with wine from the bottle)' to '(with the bottle of wine)' following FILL GLASS; action is the action being carried out for which the object has been chosen and role(DirectObject or IndirectObject) is the role the chosen object is playing in the action. By default this method just returns theName.

actionMoveInto (newCont)thing.t[2459]
Move into generated by a user action, which includes notifications

actorAction ( )thing.t[3781]
The before action handling on this Thing if it's the current actor. We define it here rather than on Actor since the player character can be a Thing. By default we do nothing.

addToAllContents (vec, lst)thing.t[3228]
no description available

addToContents (obj, vec?)thing.t[2413]
Add an item to this object's contents. Normally this method is used internally in the library than directly by game code. If the vec parameter is supplied, the object added to our contents is also added to vec; again this is intended primarily for internal use by the library.

afterAction ( )thing.t[3796]
After action notification on this Thing; this is triggered whenever an action has just been performed when we're in scope. The action we'd test for here would normally be one that *doesn't* involve this Thing.

afterTravel (traveler, connector)thing.t[3740]
After travel notification. This is called just after traveler has traveled via connector.

allContents ( )thing.t[3219]
Return a list of everything that's directly or indirectly contained within us.

allowReachOut (obj)thing.t[3423]
Check whether the actor can reach out of this object to touch obj, if obj is not in this object.

beforeAction ( )thing.t[3789]
Before action notification on this Thing; this is triggered whenever an action is about to be performed when we're in scope (and could be used to veto the action with an exit macro). The action we'd test for here would normally be one that *doesn't* involve this Thing.

beforeMovePushable (connector, dir)thing.t[8445]
Use the travelVia() method of the iobj to move the iobj to its new location.

beforeTravel (traveler, connector)thing.t[3733]
Before travel notification. This is called just before traveler attempts to travel via connector. By default we do nothing

canHear (obj)thing.t[2533]
Is obj audible from us?

cannotPushTravelMsg ( )thing.t[8378]
Display a message explaining that push travel is not possible

cannotReachOutMsg (target)thing.t[3464]
Return a message (single-quoted string) explaining why target can't be reached from inside this Thing (when this Thing is typically some kind of nested room such as a Booth or Platform).

canReach (obj)thing.t[2539]
Is obj reachable (by touch) from us?

canSee (obj)thing.t[2530]
Is obj visible from us?

canSmell (obj)thing.t[2536]
Is obj smellable from us?

canTalkTo (other)thing.t[3639]
Can this Thing (which might be the Player Char for instance) talk to other?

checkDisplay (prop)thing.t[1764]
Check if displaying prop could possibly produce any output. The only tests we apply here is that prop is not defined as nil.

checkInsert (obj)thing.t[2089]
Check whether an item can be inserted into this object, or whether doing so would either exceed the total bulk capacity of the object or the maximum bulk allowed for a single item.

checkPushTravel ( )thing.t[8388]
Check the travel barriers on the indirect object of the action

checkReach (actor)thing.t[3399]
Check whether the actor can reach (touch) this object. If this method displays anything (which should be the reason this object can't be touched) then the object can't be reached. Note that this only has any effect when the touchObj preCondition is defined.

checkReachIn (actor, target?)thing.t[3413]
Check whether an actor can reach inside this object (for reasons other that it enclosing its contents; e.g. because it's out of reach). If this method displays anything (which should be the reason the interior of this object can't be reached) then disallow reaching inside. Note that this only has any effect when the touchObj preCondition is defined on this object. By default we can reach inside if we can reach this object and not otherwise. If the optional target parameter is supplied, it's the object that actor is trying to reach.

checkRoomToHold ( )thing.t[4320]
Check that the actor has enough spare bulkCapacity to add this item to his/her inventory. Since by default everything has a bulk of zero and a very large bulkCapacity, by default there will be no effective restriction on what an actor (and in particular the player char) can carry, but game authors may often wish to give portable items bulk in the interests of realism and may wish to impose an inventory limit by bulk by reducing the bulkCapacity of the player char.

checkSetting (val)thing.t[7280]
If the setting is valid, do nothing. If it's invalid display a message explaining why. We do nothing here but this is overridden on the Settable class, which may be easier to use than providing your own implementation on Thing.

childLocType (child)thing.t[2786]
Get the containment relationship between 'child' and 'self'. This returns the containment type of the immediate child of 'self' that contains 'child'.

commonContainingParent (other)thing.t[2805]
Find the nearest common containing parent of self and other. Unlike commonInteriorParent this doesn't take account of the type of containment (it can be In, On, Under, Behind or anything else) just so long as we find a common parent in the containment hierarchy.

commonInteriorParent (other)thing.t[2844]
Find the nearest common interior parent of self and other. This finds the nearest parent that both self and other are inside of.

containerPath (other)thing.t[2889]
Get the interior containment path from 'self' to 'other'. This returns a list containing three elements. The first element is a sublist giving the interior containers you have to traverse outwards from self up to the common interior parent. The second element is the common container; this will be nil if the two objects are in separate rooms. The third element is a sublist giving the containers you have to traverse inwards from the common parent to other.

containerPathBlock (other, inProp, outProp)thing.t[2968]
Search for a "blockage" along the container path between 'self' and 'other'. 'outProp' and 'inProp' are "can" properties (&canSeeOut, &canReachIn, etc) that test a container to see whether we can see/reach/hear/etc in or out of the container.

We trace the containment path, using traceContainerPath(). For each outbound container on the path, we evaluate the container's outProp property: if this is nil, we add that container to the blockage list. Next, if there's no common parent, we add the outermost room containing 'self' to the list. Next, we trace the inbound path, evaluating each container's inProp property: if nil, we add that container to the blockage list.

Finally, we return the blockage list. This is a vector giving all of the blockages we found, in the order we encountered them.

darkDesc ( )thing.t[1020]
The description of the room when it's dark

describeMovePushable (connector, dest)thing.t[8455]
no description available

describePushTravel (via)thing.t[8471]
This message, called on the direct object of a PushTravel command (i.e. the object being pushed) is displayed just before travel takes place. It is used when the PushTravel command also involves an indirect object, e.g. a Passage, Door or Stairway the direct object is being pushed through, up or down. The via parameter is the preposition relevant to the kind of pushing, e.g. Into, Through or Up.

directChildParent (other)thing.t[2768]
Find the immediate child of 'self' that contains 'other'. If 'other' is directly in 'self', we return 'other'; otherwise, we return an object directly within 'self' that contains 'obj', directly or indirectly. If 'other' is not within 'self', we return nil.

discover (stat, =, true)thing.t[2239]
Make a hidden item unhidden. If the method is called with the optional parameter and the parameter is nil, i.e. discover(nil), the method instead hides the object.

display (prop)thing.t[1680]
Attempt to display prop appropriately according to it data type (single-quoted string, double-quoted string, integer or code). The prop parameter must be provided as a property pointer.

displayAlt (prop, altMsg?)thing.t[1729]
Attempt to display the message defined in the property prop, and return true if anything is displayed. Otherwise, if the altMsg parameter is supplied (either as a single-quoted string or as a property pointer) display it instead, and then in any case return nil to tell the caller that nothing was displayed by prop.

This method is primarily for use with properties such as smellDesc and listenDesc for which alternatives may need to be displayed if they don't display anything.

dobjFor(AskAbout)thing.t[8668]
no description available

dobjFor(AskFor)thing.t[8681]
no description available

dobjFor(Attach)thing.t[7457]
no description available

dobjFor(AttachTo)thing.t[7468]
no description available

dobjFor(Attack)thing.t[4461]
no description available

dobjFor(AttackWith)thing.t[4496]
no description available

dobjFor(Board)thing.t[6330]
no description available

dobjFor(Break)thing.t[4554]
no description available

dobjFor(Burn)thing.t[6160]
no description available

dobjFor(BurnWith)thing.t[6170]
no description available

dobjFor(Clean)thing.t[6917]
The handling of the Clean action is possibly more elaborate than it needs to be by default, and game code may wish to override it with a different implementation, but the aim is to provide a framework that covers some common cases.

An object starts out with isClean = nil. Cleaning the object makes isClean true (at which point it doesn't need cleaning again).

If an object needs another object to be cleaned with (e.g. if in order to clean the window you need a wet sponge to clean it with), this can be defined by setting mustBeCleanedWith to an object or a list of objects that can be used to clean this direct object.

dobjFor(CleanWith)thing.t[6973]
no description available

dobjFor(Climb)thing.t[6264]
no description available

dobjFor(ClimbDown)thing.t[6291]
no description available

dobjFor(ClimbUp)thing.t[6276]
no description available

dobjFor(Close)thing.t[4728]
no description available

dobjFor(ConsultAbout)thing.t[8012]
The base handling on Thing merely rules out the Consult action at the verify stage. For a fuller implementation that allows consulting use the Consultable class.

dobjFor(Cut)thing.t[4849]
no description available

dobjFor(CutWith)thing.t[4861]
no description available

dobjFor(Default)thing.t[3857]
Our handling of any action of which we're the direct or indirect action that's not in our list of decorationActions when our isDecoration property is true. By default we just stop the action at the verify stage and display our notImportantMsg.

dobjFor(Detach)thing.t[7504]
no description available

dobjFor(DetachFrom)thing.t[7518]
no description available

dobjFor(Dig)thing.t[7029]
no description available

dobjFor(DigWith)thing.t[7056]
For DigWith we merely provide verify handlers that rule out the action wih the default values of isDiggable and canDigWithMe. The library cannot model the effect of digging in general, so it's up to game code to implement this on particular objects as required.

dobjFor(Doff)thing.t[6229]
no description available

dobjFor(Drink)thing.t[6867]
no description available

dobjFor(Drop)thing.t[4358]
no description available

dobjFor(Eat)thing.t[6841]
no description available

dobjFor(Enter)thing.t[6462]
Treat Enter X as equivalent to Get In X

dobjFor(EnterOn)thing.t[7972]
The base handling is simply to rule out EnterOn at verify. There's no further handling the library can provide for a 'general' case so it's up to game code to define it for specific cases.

dobjFor(Examine)thing.t[3899], senseRegion.t[812]
Now the handling for specific actions

Modified in senseRegion.t[812]:
Modify the effect of Examine to show the remoteDesc if appropriate, or else our regular desc if our sightSize is large, or else a message to say we're too far away to see any detail. If we're in the same room as the actor, simply carry out the regular (inherited) method.

dobjFor(Extinguish)thing.t[6810]
no description available

dobjFor(Fasten)thing.t[7567]
no description available

dobjFor(FastenTo)thing.t[7595]
no description available

dobjFor(Feel)thing.t[4073]
no description available

dobjFor(Flip)thing.t[6145]
no description available

dobjFor(Follow)thing.t[4432]
no description available

dobjFor(GetOff)thing.t[6519]
no description available

dobjFor(GetOutOf)thing.t[6539]
no description available

dobjFor(GiveTo)thing.t[8768]
no description available

dobjFor(GiveToImplicit)thing.t[8869]
no description available

dobjFor(GoNear)thing.t[8980]
The GoNear action allows the player character to teleport around the map.

dobjFor(GoThrough)thing.t[5241]
no description available

dobjFor(GoTo)thing.t[7329]
The GoTo action allows the player character to navigate the map through the use of commands such as GO TO LOUNGE.

dobjFor(JumpOff)thing.t[7856]
no description available

dobjFor(JumpOver)thing.t[7891]
The base handling of JumpOver is simply to rule it out at the verify stage.

dobjFor(Kiss)thing.t[7796]
no description available

dobjFor(LieIn)thing.t[6508]
no description available

dobjFor(LieOn)thing.t[6374]
no description available

dobjFor(LieOn)thing.t[6433]
no description available

dobjFor(Light)thing.t[6772]
Lighting an object makes it a light source by making its isLit property true.

dobjFor(ListenTo)thing.t[4011], senseRegion.t[866]
no description available

Modified in senseRegion.t[866]:
Modify the effect of ListenTo to show the remoteListenDesc if appropriate, or else our regular listenDesc if our soundSize is large, or else a message to say we're too far away to hear. If we're in the same room as the actor, simply carry out the regular (inherited) method.

dobjFor(Lock)thing.t[5907]
no description available

dobjFor(LockWith)thing.t[5762]
no description available

dobjFor(LookBehind)thing.t[5122]
no description available

dobjFor(LookIn)thing.t[4910]
no description available

dobjFor(LookThrough)thing.t[5218]
no description available

dobjFor(LookUnder)thing.t[5032]
no description available

dobjFor(Move)thing.t[6623]
Moving an object is generally possible if the object is portable, but there's no obvious effect, so by default this action does nothing except say it's done nothing.

dobjFor(MoveTo)thing.t[6706]
MoveTo is a more complex case than MOVE or MOVE WITH. In this implementation we assume that it represents moving the direct object to the vicinity of the indirect object, and so we track the object it's been moved to.

This might be useful, say, if you wanted the player to have to MOVE the chair TO the bookcase before being able to reach the top shelf by standing on the chair, since you could then check the value of the chair's movedTo property before deciding whether the top shelf was accesssible.

dobjFor(MoveWith)thing.t[6643]
no description available

dobjFor(Open)thing.t[4649]
no description available

dobjFor(PlugIn)thing.t[7765]
no description available

dobjFor(PlugInto)thing.t[7693]
The base handling of PlugInto on Thing merely rules it out at the verify stage. A fuller implementation is provided by the PlugAttachable class in the optional attachables module.

dobjFor(Pour)thing.t[8048]
The base handling of Pour, PourOnto and PourInto is simply to rule out all three actions at the verify stage. Game code that wants to allow these actions on specific objects will need to provide further handling for them.

dobjFor(PourInto)thing.t[8107]
no description available

dobjFor(PourOnto)thing.t[8058]
no description available

dobjFor(Pull)thing.t[5279]
no description available

dobjFor(Purloin)thing.t[8912]
PURLOIN allows the player to move any portable object in the game directly into his/her inventory, wherever it is currently. We don't allow absolutely anything to be purloined, as this could cause chaos.

dobjFor(Push)thing.t[5258]
no description available

dobjFor(PushTravelClimbDown)thing.t[8624]
no description available

dobjFor(PushTravelClimbUp)thing.t[8600]
no description available

dobjFor(PushTravelDir)thing.t[8328]
PushTravelDir handles pushing an object in a particular direction, e.g. PUSH BOX NORTH

dobjFor(PushTravelEnter)thing.t[8522]
PushTravelEnter handles commands like PUSH BOX INTO COFFIN, where the indirect object is a Booth-like object. The syntactically identical command for pushing things into an Enterable (e.g. PUSH BOX INTO HOUSE where HOUSE represents the outside of a separate location) is handled on the Enterable class.

dobjFor(PushTravelGetOutOf)thing.t[8560]
no description available

dobjFor(PushTravelThrough)thing.t[8491]
PushTravelThrough handles pushing something through something, such as a door or archway. Most of the actual handling is dealt with by the common routines defined above.

dobjFor(PutBehind)thing.t[5562]
no description available

dobjFor(PutIn)thing.t[5378]
no description available

dobjFor(PutOn)thing.t[5305]
no description available

dobjFor(PutUnder)thing.t[5469]
no description available

dobjFor(QueryAbout)thing.t[8722]
no description available

dobjFor(Read)thing.t[4403], senseRegion.t[919]
no description available

Modified in senseRegion.t[919]:
Modify the effect of a Read action to prevent this item being read from a remote location unless isReadableFrom(gActor) is true.

dobjFor(Remove)thing.t[6573]
We'll take REMOVE to mean DOFF when it's dobj is worn and TAKE otherwise. This handling will be dealt with by removeDoer insteadof remap, since this form of remap has now been discontinued. See english.t for removeDoer (which seems to be a language-specific construct)

dobjFor(SayTo)thing.t[8709]
no description available

dobjFor(Screw)thing.t[8177]
In the base handling we simply rule out Screw and Unscrew actions at the verify stage. It's up to game code to provide specific handling for objects that can be screwed and unscrewed.

dobjFor(ScrewWith)thing.t[8187]
no description available

dobjFor(Search)thing.t[6609]
Treat SEARCH as equivalent to LOOK IN

dobjFor(Set)thing.t[7913]
The Set command by itself doesn't do much. By default we just rule it out at the verify stage.

dobjFor(SetTo)thing.t[7291]
no description available

dobjFor(ShowTo)thing.t[8809]
no description available

dobjFor(ShowToImplicit)thing.t[8841]
no description available

dobjFor(SitIn)thing.t[6507]
no description available

dobjFor(SitOn)thing.t[6373]
no description available

dobjFor(SitOn)thing.t[6420]
no description available

dobjFor(SmellSomething)thing.t[3992], senseRegion.t[940]
no description available

Modified in senseRegion.t[940]:
Modify the effect of SmellSomething to show the remoteSmellDesc if appropriate, or else our regular smellDesc if our smellSize is large, or else a message to say we're too far away to smell. If we're in the same room as the actor, simply carry out the regular (inherited) method.

dobjFor(StandIn)thing.t[6506]
By default we'll treat standing, sitting or lying IN something as simply equivalent to entering it.

dobjFor(StandOn)thing.t[6372]
Since we don't track postures in this library we'll treat STAND ON as equivalent to BOARD

dobjFor(StandOn)thing.t[6407]
no description available

dobjFor(Strike)thing.t[4543]
no description available

dobjFor(SwitchOff)thing.t[6092]
no description available

dobjFor(SwitchOn)thing.t[6063]
no description available

dobjFor(SwitchVague)thing.t[6119]
no description available

dobjFor(Take)thing.t[4102]
no description available

dobjFor(TakeFrom)thing.t[7091]
We treat TAKE FROM as equivalent to TAKE except at the verify stage, where we first check that the direct object is actually in the indirect object.

dobjFor(TakeFrom)thing.t[7093]
no description available

dobjFor(TalkAbout)thing.t[8735]
no description available

dobjFor(TalkTo)thing.t[8748]
no description available

dobjFor(Taste)thing.t[4035]
no description available

dobjFor(TellAbout)thing.t[8695]
no description available

dobjFor(Throw)thing.t[6304]
no description available

dobjFor(ThrowAt)thing.t[7137]
no description available

dobjFor(ThrowDir)thing.t[4576]
no description available

dobjFor(ThrowTo)thing.t[7202]
no description available

dobjFor(Turn)thing.t[4775]
no description available

dobjFor(TurnTo)thing.t[7247]
Turning something To is setting it to a value by rotating it, such as turning a dial to point to a particular number.

dobjFor(TurnWith)thing.t[4802]
no description available

dobjFor(TypeOn)thing.t[7945]
no description available

dobjFor(TypeOnVague)thing.t[7935]
The base handling of both the vague (TYPE ON X) and specific (TYPE FOO ON X) forms of TypeOn is simply to rule them out at the verify stage. Game code that needs objects that can be typed on is responsible for handling these actions in custom code.

dobjFor(Unfasten)thing.t[7628]
no description available

dobjFor(UnfastenFrom)thing.t[7644]
no description available

dobjFor(Unlock)thing.t[5831]
no description available

dobjFor(UnlockWith)thing.t[5675]
Note: we don't use isLockable, because this is not a binary property; there are different kings of lockability and defining an isLockable property in addition would only confuse things and might break the logic.

dobjFor(Unplug)thing.t[7776]
no description available

dobjFor(UnplugFrom)thing.t[7729]
no description available

dobjFor(Unscrew)thing.t[8213]
no description available

dobjFor(UnscrewWith)thing.t[8223]
no description available

dobjFor(Wear)thing.t[6200]
no description available

dobjFor(WriteOn)thing.t[7990]
By default we simply rule out writing on things at the verify stage.

doPushTravel (via)thing.t[8395]
Carry out the push travel on the direct object of the action.

examineStatus ( )thing.t[1649]
Additional information to display after our desc in response to an EXAMINE command.

filterResolveList (np, cmd, mode)OVERRIDDENsenseRegion.t[1017]
For certain actions like EXAMINE there's no point trying to carry them out on something that can't be seen (remotely) if there are other things that can be seen that matched the player's command.

findHidden (prop, prep)thing.t[5004]
If there's something hidden in the dobj but nowhere obvious to move it to then by default we move everything from the hiddenIn list to the actor's inventory and announce that the actor has taken it. We call this out as a separate method to make it easy to override if desired.

findPlausibleKey (silent, =, nil)thing.t[5993]
Find a key among the actor's possessions that might plausibly lock or unlock us. If the silent parameter is true, then don't report a failed attempt.

firstContainerPathBlock (other, inProp, outProp)thing.t[2989]
Get the first blockage in a container path. This calls containerPathBlock() and returns the first blockage in the list, or nil if there's no blockage.

getBulkWithin ( )thing.t[2060]
Calculate the total bulk of the items contained within this object.

getCarriedBulk ( )thing.t[2073]
Calculate the total bulk carried by an actor, which excludes the bulk of any items currently worn or anything fixed in place.

getStatuslineExitsHeight ( )thing.t[1601]
Get the estimated height, in lines of text, of the exits display's contribution to the status line. This is used to calculate the extra height we need in the status line, if any, to display the exit list. If we're not configured to display exits in the status line, this should return zero.

handleCommand (action)thing.t[3769]
Handle a command directed to this open (e.g. BALL, GET IN BOX). Since inanimate objects generally can't respond to commands we simply display a message announcing the futility of issuing one. This method is overridden on Actor to allow Actors to respond to commands via CommandTopics.

hasSeen (obj)thing.t[3603]
Test whether this Thing has seen obbj.

hideFromAll (action)thing.t[3814]
To exclude this item from the list of objects to be acted upon when the player types a command with ALL for action, override this method to return true for the action or actions concerned. Note that this exclusion is applied after the action has constructed its own list of objects that ALL should apply to, and can only be used to make further exclusions.

It shouldn't be necessary to use this method very often, since the normal approach will be to override the getAll() method on the appropriate action. It may be useful to use this method to handle exceptional cases, however.

interiorParent ( )thing.t[2728]
no description available

iobjFor(AttachTo)thing.t[7480]
no description available

iobjFor(AttackWith)thing.t[4520]
no description available

iobjFor(BurnWith)thing.t[6186]
no description available

iobjFor(CleanWith)thing.t[7013]
no description available

iobjFor(CutWith)thing.t[4874]
no description available

iobjFor(Default)thing.t[3865]
no description available

iobjFor(DetachFrom)thing.t[7534]
no description available

iobjFor(DigWith)thing.t[7066]
no description available

iobjFor(FastenTo)thing.t[7607]
no description available

iobjFor(GiveTo)thing.t[8790]
no description available

iobjFor(LockWith)thing.t[5812]
no description available

iobjFor(MoveTo)thing.t[6740]
no description available

iobjFor(MoveWith)thing.t[6673]
no description available

iobjFor(PlugInto)thing.t[7708]
no description available

iobjFor(PourInto)thing.t[8131]
no description available

iobjFor(PourOnto)thing.t[8085]
no description available

iobjFor(PushTravelClimbDown)thing.t[8632]
no description available

iobjFor(PushTravelClimbUp)thing.t[8608]
no description available

iobjFor(PushTravelEnter)thing.t[8532]
no description available

iobjFor(PushTravelGetOutOf)thing.t[8574]
no description available

iobjFor(PushTravelThrough)thing.t[8499]
no description available

iobjFor(PutBehind)thing.t[5598]
Handled by iobj

iobjFor(PutIn)thing.t[5414]
handled on iobj

iobjFor(PutOn)thing.t[5348]
no description available

iobjFor(PutUnder)thing.t[5506]
Handled by iobj

iobjFor(ScrewWith)thing.t[8197]
no description available

iobjFor(ShowTo)thing.t[8822]
no description available

iobjFor(TakeFrom)thing.t[7107]
no description available

iobjFor(ThrowAt)thing.t[7163], senseRegion.t[989]
no description available

Modified in senseRegion.t[989]:
Modify the effects of throwing something at this object

iobjFor(ThrowTo)thing.t[7216]
no description available

iobjFor(TurnWith)thing.t[4826]
no description available

iobjFor(UnfastenFrom)thing.t[7659]
no description available

iobjFor(UnlockWith)thing.t[5744]
no description available

iobjFor(UnplugFrom)thing.t[7743]
no description available

iobjFor(UnscrewWith)thing.t[8233]
no description available

isAudibleFrom (pov)senseRegion.t[716]
Is this item audible from the remote location containing pov? By default it is if it's soundSize is not small, but this can be overridden, for example to vary with the pov.

isChild (obj, typ)thing.t[2552]
Are we a containment "child" of the given object with the given location type? This returns true if our location is the given object and our locType is the given type, or our location is a containment child of the given object with the given type.

'typ' is a LocType giving the relationship to test for, or nil. If it's nil, we'll return true if we have any containment relationship to 'obj'.

isDirectChild (obj, typ)thing.t[2571]
Are we a direct containment child of the given object with the given containment type? 'typ' is a LocType giving the relationship to test for, or nil. If it's nil, we'll return true if we have any direct containment relationship with 'obj'.

isDirectlyHeldBy (obj)thing.t[2301]
are we directly held by the given object?

isDirectlyIn (cont)thing.t[2586]
Are we directly in cont?

isDirectlyWornBy (obj)thing.t[2318]
are we directly worn by the given object?

isHeldBy (obj)thing.t[3075]
are we held by the given object, directly or indirectly?

isIlluminated ( )thing.t[1044]
If we're a room, are we illuminated (is there enough light for an actor within us to see by)?

isIn (cont)thing.t[2601]
Are we in cont?

isInterior (obj)thing.t[2746]
Am I on the inside of the given object? This returns true if our relationship to the given object is an interior location type.

isOrIsIn (cont)thing.t[2616]
Are either oont or in cont ?

isOutside (obj)thing.t[3067]
are we on the exterior of the given object, directly or indirectly?

isReadableFrom (pov)senseRegion.t[732]
Assuming this item is readable at all, is it readable from the remote location containing pov? By default we assume this is the case if and only if the item's sightSize is large, but this can be overridden, for example for a large item with small lettering.

isSmellableFrom (pov)senseRegion.t[723]
Is this item smellable from the remote location containing pov? By default it is if it's smellSize is not small, but this can be overridden, for example to vary with the pov.

isThereALightSourceIn (lst)thing.t[1065]
Determine (recursively) whether lst contains a light source; i.e. whether any of the items within list is lit or whether any of the visible contents of any of the items in lst it lit.

isVisibleFrom (pov)senseRegion.t[708]
Is this item visible from the remote location containing pov? By default it is if it's sightSize is not small, but this can be overridden, for example to vary with the pov.

isWornBy (obj)thing.t[2311]
are we worn by the given object, directly or indirectly?

knowsAbout (obj)thing.t[3609]
Test whether this Thing knows about obj, which it does either if it has seen this obj or its knownProp (by default, familiar) is true.

listableContentsOf (cont)thing.t[1973]
The subset of the contents of cont that should be listed.

listContents (lister, =, &, roomContentsLister)thing.t[1169]
List the contents of this object using lister.

listRemoteContents (lst, lister, pov)senseRegion.t[548]
List contents as seen from a remote location

listSubcontentsOf (contList, lister, =, &, examineLister)thing.t[1350]
List the contents of every item in contList, recursively listing the contents of contents all the way down the containment tree. The contList parameter can also be passed as a singleton object.

litWithin ( )thing.t[3508]
Is this object's interior lit? an object if the object itself is a light source, or anything directly inside shines outwards, or we can see out from within and our location shines inwards.

locationWhich (func)thing.t[3262]
no description available

locType ( )thing.t[3024]
Our location type with respect to our immediate container; e.g. are we In, On, Under or Behind it?

lookAroundWithin ( )thing.t[1110]
Look around within this Thing (Room or Booth) to provide a full description of this location as seen from within, including our headline name, our internal description, and a listing of our visible contents.

makeCleaned (stat)thing.t[6955]
Carry out the effects of cleaning. By default we just set the value of the isClean property, but game code could override this to carry out any side effects of cleaning, such as revealing the inscription on a dirty old gravestone.

makeFastened (stat)thing.t[7565]
Make something fastened or unfastened. By default we just change the value of its isFastened property, but game code could override this to provide further side-effects on particular objects.

makeLit (stat)thing.t[2000], english.t[2144]
Make this object lit or unlit

Modified in english.t[2144]:
Check whether we need to add or remove the LitUnlit State from our list of states.

makeLocked (stat)thing.t[2269]
Make us locked or ublocked. We define this as a method so that subclasses such as Door can override to produce side effects (such as locking or unlocking the other side).

makeMovedTo (loc)thing.t[6735]
Cause this object to be moved to loc

makeOn (stat)thing.t[2283]
switch this item on or off

makeOpen (stat)thing.t[4629]
Make us open or closed. We define this as a method so that subclasses such as Door can override to produce side effects (such as opening or closing the other side).

makeSetting (val)thing.t[7319]
This would be a good place to put code to validate the setting

makeWorn (stat)thing.t[2298]
Make this object worn or not worn. If this object is worn, note who it's worn by. If stat is nil the object is no longer being worn.

moveHidden (prop, loc)thing.t[4300]
Service method: move everything in the prop property to loc and mark it as seen.

moveInto (newCont)thing.t[2441]
Basic moveInto for moving an object from one container to another by programmatic fiat.

moveMLIntoAdd (ml)thing.t[2506]
Move a MultiLoc (ml) into this additional Thing or Room, by adding it to this thing's contents list and adding the Thing to ml's locationList.

moveMLOutOf (ml)thing.t[2520]
Move a MultiLoc (ml) out of this object, by removing it from our contents list and removing us from its locationList.

nominalOwner ( )thing.t[3173]
Get my nominal owner. If we have an explicit owner, we'll return the first explicit owner. Otherwise, we'll look for a container that has ownsContents = true, and return the first such container.

noteSeen ( )thing.t[3567]
Note that we've been seen and where we were last seen

notifyInsert (obj)thing.t[2498]
Receive notification that obj is about to be inserted into us; by default we do nothing.

notifyRemove (obj)thing.t[2492]
Receive notification that obj is about to be removed from inside us; by default we do nothing.

notionalContents ( )thing.t[2153]
Our notional total contents is our normal contents plus anything contained in any of our remapXX objects representing our associated proxy container, surface, underside and rear, excluding anything in a closed opaque container (which would not be visible).

outermostParent ( )thing.t[3061]
Get my outermost parent. This is simply our ancestor in the location tree that has no location itself.

outermostVisibleParent ( )thing.t[2996]
no description available

ownedBy (obj)thing.t[3197]
Does the given object own me, explicitly or implicitly? This returns true if 'obj' is in my 'owner' list, but it can also return true if there's merely an implied ownership relationship. Location can imply ownership: BOB'S KEY could refer to the key that Bob is holding, whether or not it would continue to be considered his key if he were to drop it.

We return true if 'obj' is an explicit owner, OR self is contained within 'obj', OR self is contained within an object owned by 'obj'. (The latter case is for things like BOB'S TWENTY DOLLAR BILL, which is Bob's by virtue of being inside a wallet explicitly owned by Bob.)

preinitThing ( )thing.t[2635]
Carry out the preinitialization of a Thing

pushTravelRevealItems ( )thing.t[8353]
Reveal items previously under or behind us that now become visible.

reachBlockedMsg (target)thing.t[3440]
Return a message explaining why an object outside me can't reach one inside (or vice versa); this will normally be triggered by an attempt to reach an object inside a closed transparent container. The method is defined here to make it easier to customize the message on the container that's doing the blocking.

remoteInitSpecialDesc (pov)senseRegion.t[701]
Our remoteInitSpecialDesc, used when viewing this item from a remote location.By default we just show our ordinary initSpecialDesc, but in practice we'll normally want to override this.

remoteObjInName (pov)senseRegion.t[803]
The name given to this object when it's the container for another object viewed remotely, e.g. 'in the distant bucket' as opposed to just 'in the bucket'. By default we just use the objInName.

remoteSpecialDesc (pov)senseRegion.t[694]
Our remoteSpecialDesc is the paragraph describing this item in a room description when viewed from a remote location containing the pov object. By default we just show our ordinary specialDesc, but in practice we'll normally want to override this.

removeFromContents (obj, vec?)thing.t[2427]
Remove an item to this object's contents. Normally this method is used internally in the library than directly by game code. If the vec parameter is supplied, the object removed from our contents is also removed from vec; again this is intended primarily for internal use by the library.

revealOnMove ( )thing.t[4193]
List and move into an appropriate location any item that was hidden behind or under us. We place this in a separate method so it can be conveniently called by other actions that move an object, or overridden by particular objects that want a different handling.

Note that we don't provide any handling for the hiddenIn property here, on the assumption that items hidden in something may well stay there when it's moved; but this method can always be overridden to provide custom behaviour.

roomHeadline (pov)thing.t[992]
The title of this room to be displayed at the start of a room description, or in the status line.

// roomSubhead (pov)Interface description onlything.t[3099], english.t[2129]
The nested room subhead. This shows a little addendum to the room headline when the point-of-view actor is inside an object within the main room, such as a chair or platform. This usually shows something of the form "(in the chair)". Note that only the *immediate* container is shown; if the actor is in a chair in a booth on a stage, we normally only mention the chair.

We leave this to the language library to define, since the exact syntax varies by language.

Modified in english.t[2129]:
Show the nested room subhead. This shows the actor's immediate container as an addendum to the room name in the room description headline.

[Required]

sayDontKnowHowToGetThere ( )thing.t[7437]
We make these two sayDontKnowHowTo... methods separate methods so that they can be reused on the Distant class without having to repeat the DMsg() definitions.

sayDontKnowHowToReach ( )thing.t[7440]
no description available

sayFindHidden (prop, prep)thing.t[5018]
Report what was found hidded in/under/behind us. We make this a separate method so that it can be easily customized on individual objects.

scoreObject (cmd, role, lst, m)thing.t[3690]
Score this object for disambiguation. When a noun phrase is ambiguous (for example, the phrase matches multiple in-scope objects, and we have to choose just one), the parser calls this routine on each object it's considering as a match.

Our job here is to read the player's mind. The question before us is: did the player mean *this* object when typing this noun phrase? Obviously we can't really know what's in the player's mind, but in many cases we can make an educated guess based on what ought to make the most sense in context. The context in this case is the state of the simulated game world, as it's portrayed to the player. That last bit is important: be cognizant of what the player is *meant* to know at this point. DON'T base the score on information that the player isn't supposed to know, though: that could give away secrets that the player is meant to discover on her own.

Before this routine is called, the Action has already assigned an initial score to each object, but this routine can override the initial score by assigning its own score value. This routine is most useful in cases where a particular object has a special affinity for a verb, or for the verb in combination with particular other objects involved in the command.

'cmd' is the Command object. 'role' is the noun phrase's role in the command (DirectObject, IndirectObject, etc). 'lst' is a list of NPMatch objects identifying the objects that matched the noun phrase. 'm' is the NPMatch object for self.

To override or adjust the score, simply set m.score to the new value. This routine is also free to override the scores of any other objects in the list, if needed.

By default, we don't make any adjustment - we simply accept the initial score calculated by the Action, by leaving m.score unchanged.

See Action.scoreObjects() for full details.

setHasSeen (obj)thing.t[3597]
Mark this Thing as having seen obj.

setKnown ( )thing.t[3594]
Mark the player character as knowing about us (i.e. this Thing)

setKnowsAbout (obj)thing.t[3591]
Mark this Thing as knowing about obj.

setSeen ( )thing.t[3600]
Mark the player character as having seen this Thing.

shinesOut ( )thing.t[3481]
Does this object shine light outwards? This determines if the object is a light source to objects outside of it. Light shines out from an object if the object itself is a light source, or one of its direct exterior contents shines out, or its contents are visible from the outside and one of its direct interior contents shines out.

showConnectedMiscContents (pov)thing.t[1564]
no description available

showFirstConnectedSpecials (pov)thing.t[1563]
no description available

showRemoteSpecialDesc (pov)senseRegion.t[516]
Show our remoteSpecialDesc, i.e. the version of our specialDesc that should be seen when this item is viewed from a remote location.

showSecondConnectedSpecials (pov)thing.t[1565]
no description available

showSpecialDesc ( )thing.t[1838]
Show our specialDesc or initSpecialDesc, as appropriate

showStatuslineExits ( )thing.t[1610]
Show our exits in the status line

statusName (actor)thing.t[1579]
Display the "status line" name of the room. This is normally a brief, single-line description.

By long-standing convention, each location in a game usually has a distinctive name that's displayed here. Players usually find these names helpful in forming a mental map of the game.

By default, if we have an enclosing location, and the actor can see the enclosing location, we'll defer to the location. Otherwise, we'll display our roo interior name.

totalBulkIn (lst)thing.t[2219]
Calculate the total bulk of the items in lst

traceContainerPath (other, outFunc, parentFunc, inFunc)thing.t[2924]
Trace the interior containment path from 'self' to 'other'.

We'll start by working up the containment tree from 'self' to the nearest interior container we have in common with 'other' - that is, the nearest object that contains both 'self' and 'other' with an interior location type for each object. For each container BELOW the common parent, we call outFunc(container).

Next, we call parentFunc(container) on the common container. If there is no common container, we call parentFunc(nil).

Next, we work back down the containment tree from the common parent to 'other'. For each container below the common parent, we call inFunc(container).

travelVia (conn, announceArrival, =, true)thing.t[3747]
Cause this Thing to travel via the connector conn. This method is supplied in case travelVia is called on a Thing which is not an Actor, although it's Actor that has the full implementation.

tryCheck (prop)thing.t[3244]
Run a check method passed as a property pointer in the prop parameter and return any string it tried to display

unmention (lst)thing.t[1545]
Mark everything item in lst as not mentioned , and carry on down the containment tree marking the contents of every item in lst as not mentioned.

unmentionRemoteContents ( )thing.t[1562]
The next four methods are provided so that listContents() can call them, but they do nothing in the core library. They are overridden in senseRegion.t (for use if senseRegion.t is included in the build).

verifyActor ( )thing.t[3881]
Next deal with what happens if this object is being tested as a potential actor

verifyPushTravel (via)thing.t[8264]
Common handler for verifying push travel actions. The via parameter may be a preposition object (such as Through) defining what kind of push traveling the actor is trying to do (e.g. through a door or up some stairs).

wouldBeLitFor (actor)thing.t[1619]
Would this location be lit for actor. By default it would if it's illuminated.

Adv3Lite Library Reference Manual
Generated on 28/03/2016 from adv3Lite version 1.5