#charset "us-ascii"
#include "advlite.h"
/*
* ***************************************************************************
* extras.t
*
* This module forms part of the adv3Lite library (c) 2012-13 Eric Eve
*
*
*
*
* This file contains a number of (in principle) optional classes that can be
* used in addition to Thing. A game does not need to use any of these classes
* since authors can always just set the appropriate properties on thing, but
* some authors may find them a convenience, or may find that using them
* improves the clarity of their code.
*/
property tooFarAwayToHearMsg;
property tooFarAwayToSmellMsg;
property smellSize;
property soundSize;
/*
* We define SensoryEmanation to be the base class for Odor and Noise. It
* doesn't add any functionality here, but makes it possible for the sensory.t
* extension to add functionality to this class.
*/
class SensoryEmanation: Decoration
/*
* There's no point in including a SensoryEmanation in any command applying to ALL unless the
* command is one of our decoration actions.
*/
hideFromAll(action) { return decorationActions.indexOf(action) == nil; }
;
/*
* An Odor is an object representing a smell (as opposed to the object that
* might be emitting that smell). The desc property of an Odor is displayed in
* response to EXAMINE or SMELL; any other action is responded to with the
* notImportantMsg.
*/
class Odor: SensoryEmanation
/* An Odor responds to EXAMINE SOMETHING or SMELL SOMETHING */
decorationActions = [Examine, SmellSomething]
/*
* The message to display when any other action is attempted with an Odor
*/
notImportantMsg = BMsg(only smell, '{I} {can\'t} do that to a smell. ')
/* Treat Smelling an Odor as equivalent to Examining it. */
dobjFor(SmellSomething) asDobjFor(Examine)
dobjFor(Examine) { preCond = [objSmellable] }
/*
* Since we turn SMELL into EXAMINE we want our sightSize to be our
* smellSize.
*/
sightSize = smellSize
/*
* For the same reason we want to use our tooFarAwayToSmellMsg for our
* tooFarWayToSeeDetailMsg.
*/
tooFarAwayToSeeDetailMsg = tooFarAwayToSmellMsg
isOdor = true
;
/*
* A Noise is an object representing a sound (as opposed to the object that
* might be emitting that sound). The desc property of a Noise is displayed in
* response to EXAMINE or LISTEN TO; any other action is responded to with the
* notImportantMsg.
*/
class Noise: SensoryEmanation
/* A Noise responds to EXAMINE SOMETHING or LISTEN TO SOMETHING */
decorationActions = [Examine, ListenTo]
/*
* The message to display when any other action is attempted with a Noise
*/
notImportantMsg = BMsg(only listen, '{I} {can\'t} do that to a sound. ')
/* Treat Listening to a Noise as equivalent to Examining it. */
dobjFor(ListenTo) asDobjFor(Examine)
dobjFor(Examine) { preCond = [objAudible] }
/*
* Since we turn LISTEN TO into EXAMINE we want our sightSize to be our
* soundSize.
*/
sightSize = soundSize
/*
* For the same reason we want to use our tooFarAwayToHearlMsg for our
* tooFarWayToSeeDetailMsg.
*/
tooFarAwayToSeeDetailMsg = tooFarAwayToHearMsg
isNoise = true
;
/* A Container is a Thing that other things can be put inside */
class Container: Thing
/* Containers are open by default */
isOpen = true
/*
* The containment type of a container is In; i.e. things located in a
* Container are considered to be in it.
*/
contType = In
;
/* An OpenableContainer is a Container that can be opened and closed. */
class OpenableContainer: Container
/* Most OpenableContainers start out closed. */
isOpen = nil
/* An OpenableContainer is openable */
isOpenable = true
;
/*
* A LockableContainer is an OpenableContainer that can be locked and unlocked
* without the aid of a key.
*/
class LockableContainer: OpenableContainer
lockability = lockableWithoutKey
/* We usually want a LockableContainer to start out locked. */
isLocked = true
;
/*
* A KeyedContainer is an OpenableContainer that can be locked and unlocked
* only with the aid of a key.
*/
class KeyedContainer: OpenableContainer
lockability = lockableWithKey
/* We usually want a KeyedContainer to start out locked. */
isLocked = true
;
/* A Surface is a Thing that other things can be placed on top of */
class Surface: Thing
/* The contents of a Surface are considered to be on the Surface */
contType = On
/*
* Searching a Surface may involve look for what's on it as well as what's
* in it.
*
* We put this code here rather than checking for contType == On on a
* Thing to avoid burdening Thing with overcomplicated code for a rather
* special case.
*/
dobjFor(Search)
{
preCond = [objVisible, touchObj]
verify() {}
check() {}
action()
{
if(hiddenIn.length == 0
&& contents.countWhich({x: x.searchListed}) == 0)
{
say(nothingOnMsg);
return;
}
local onList = contents.subset({x: x.searchListed});
if(onList.length > 0)
listContentsOn(onList);
if(hiddenIn.length > 0)
findHidden(&hiddenIn, In);
}
}
nothingOnMsg = BMsg(nothing on, '{I} {find} nothing of interest on
{the dobj}. ')
/*
* List what's on me. We put this in a separate method to make it easier
* to customise on a per object basis.
*/
listContentsOn(lst)
{
lookInLister.show(lst, self, true);
}
;
/*
* A Plaftorm is a Surface that the player character (and other actors) can
* get on.
*/
class Platform: Surface
isBoardable = true
;
/*
* A Booth is a Container that the player character (and other actors) can get
* in.
*/
class Booth: Container
isEnterable= true
;
/* An Underside is a Thing that other things can be put under */
class Underside: Thing
/* The contents of an Underside are considered to be under it. */
contType = Under
;
/* An RearContainer is a Thing that other things can be put behind */
class RearContainer: Thing
/* The contents of an RearContainer are considered to be behind it. */
contType = Behind
;
/* A Wearable is a Thing that can be worn */
class Wearable: Thing
isWearable = true
;
/* A Food is a Thing that can be eaten */
class Food: Thing
isEdible = true
;
/*
* A Fixture is a Thing that can't be picked up and carried around (and so
* can't be put anywhere either).
*/
class Fixture: Thing
isFixed = true
;
/*
* A Decoration is a Fixture that can only be EXAMINEd. Any other action
* results in the display of its notImportantMsg. It's normally used for
* objects that are purely scenery.
*/
class Decoration: Fixture
isDecoration = true
/*
* Game code may wish to hide decorations from all commands applied to ALL. Tbis can be
* achieved by overriding hideFromAll() as shown below. This is not done in the library since
* making this change at version 1.61 would compromise backward compatibility.
*/
// hideFromAll(action) { return true; }
;
/*
* A Component is an object that's (usually permanently) part of something
* else, like the handle of a suitcase or a dial on a safe.
*/
class Component: Fixture
cannotTakeMsg = BMsg(cannot take component, '{I} {can\'t} have {that cobj},
{he dobj}{\'s} part of {1}. ', location.theName)
locType = PartOf
;
/*
* A Distant is a Decoration that's considered too far away to be interacted
* with by any command other than EXAMINE
*/
class Distant: ProxyDest, Decoration
/* Message to say that this object is too far away. */
notImportantMsg = BMsg(distant, '{The subj cobj} {is} too far away. ')
/*
* The base Decoration class includes GoTo as a decorationAction. For a
* Distant object (e.g. the sun or moon or a distanct mountain) this will
* often be inappropriate. Where an object is 'locally distant' as it
* were, i.e. a sign mounted high up on a wall, you can override the
* destination property to give the location that a GO TO action should
* take the player character to; decorationActions will then include GoTo,
* since GO TO SIGN would then be a reasonable way for the player to get
* to the location of the sign.
*/
decorationActions = destination ? [Examine, GoTo] : [Examine]
/*
* If this Distant represents an object that's notionally in another
* location, setting destination to that location will allow the GO TO
* command to take the actor to that location. If destination is specified
* it should normally be a room (usually one adjacent to that this Distant
* object is located in. For an object like the sky, the sun or a distant
* mountain this should be left as nil.
*/
destination = nil
/*
* Going To a Distant object is unlike a normal GoTo, since if the object
* is meant to be Distant, going to its location (the normal response to a
* GO TO command) is precisely what we don't want to happen. We therefore
* need to provide custom GoTo handling on a Distant object.
*/
dobjFor(GoTo)
{
verify()
{
/*
* Unless the actor is in our location and we have a destination,
* we don't want to field a GoTo command, so we make it as
* illogical as possible. If we don't have a destination we
* shouldn't reach this point anyway since GoTo shouldn't be one
* of our decorationActions, but writing the test this way will
* make this verify routine prevent the action even if
* decorationActions is overridden, if there's a nil destination.
*/
if(!gActor.isIn(getOutermostRoom) || destination == nil)
inaccessible(notImportantMsg);
}
action()
{
/*
* Calculate the route from the actor's current room to the
* location where the target object was last seen, using the
* routeFinder to carry out the calculations if it is present. In
* this case we use routeFinder rather than pcRouteFinder since
* the PC can presumably see the way s/he needs to go even if s/he
* hasn't gone that way before.
*/
local route = defined(routeFinder)? routeFinder.findPath(
gActor.getOutermostRoom, destination.getOutermostRoom) : nil;
/*
* If we don't find a route, just display a message saying we
* don't know how to get to our destination.
*/
if(route == nil)
sayDontKnowHowToGetThere();
/*
* If the route we find has only one element in its list, that
* means that we're where we last saw the target but it's no
* longer there, so we don't know where it's gone. In which case
* we display a message saying we don't know how to reach our
* target.
*/
else if(route.length == 1)
sayDontKnowHowToReach();
/*
* If the route we found has at least two elements, then use the
* first element of the second element as the direction in which
* we need to travel, and use the Continue action to take a step
* in that direction.
*/
else
{
local dir = route[2][1];
Continue.takeStep(dir, destination.getOutermostRoom);
};
}
}
;
/* An Unthing is an object that represents the absence of a thing */
class Unthing: Decoration
/* An Unthing can't respond to any actions, as it isn't there */
decorationActions = []
/*
* The message to display when the player character tries to interact with
* this object; by default we just say it isn't there, but game code will
* normally want to override this message to explain the reason for the
* absence.
*/
notImportantMsg = BMsg(unthing absent, '{The subj cobj} {isn\'t} {here}. ')
/*
* Users coming from adv3 may be used to Unthings having a notHereMsg, so
* we'll define this to be the same as the notImportantMsg
*/
notHereMsg = notImportantMsg
/* An Unthing should never be included in ALL */
hideFromAll(action) { return true; }
/*
* A player is more likely to be trying to refer to something that is
* present than something that isn't, so we give Unthings a substantially
* reduced vocabLikelihood
*/
vocabLikelihood = -100
/*
* If there's anything else in the match list, remove myself from the
* matches
*/
filterResolveList(np, cmd, mode)
{
if(np.matches.length > 1)
np.matches = np.matches.subset({m: m.obj != self});
}
/* Make Unthings verify with the lowest possible score */
dobjFor(Default)
{
verify()
{
inaccessible(notHereMsg);
}
}
iobjFor(Default)
{
verify()
{
inaccessible(notHereMsg);
}
}
/*
* Giving an order to an Unthing should give the same response as any
* other command involving an Unthing.
*/
handleCommand(action)
{
say(notHereMsg);
}
;
/*
* A CollectiveGroup is a an object that can represent a set of other objects
* for particular actions. For any of the objects in the myObjects list the
* CollectiveGroup will handle any of the actions in the myActions list; all
* the other actions will be handled by the individual objects.
*/
class CollectiveGroup: Fixture
/*
* The list of actions this CollectiveGroup will handle; all the rest will
* be handled by the individual objects.
*/
collectiveActions = [Examine]
/*
* Is action to be treated as a collective action by this group (i.e.
* handled by this CollectiveGroup object); by default it is if it's one
* of the actions listed in our collectiveActions property.
*/
isCollectiveAction(action)
{
return collectiveActions.indexWhich({a: action.ofKind(a)}) != nil;
}
/*
* If the current action is one of the collective Actions, then filter all
* myObjects from the resolve list; otherwise filter myself out from the
* resolve list.
*/
filterResolveList(np, cmd, mode)
{
/* If there are fewer than two matches, don't do any filtering */
if(np.matches.length < 2)
return;
if(isCollectiveAction(cmd.action))
np.matches = np.matches.subset(
{m: valToList(m.obj.collectiveGroups).indexOf(self) == nil});
else
np.matches = np.matches.subset({m: m.obj != self });
}
/* Obtain the list of the objects belonging to me that are in scope. */
myScopeObjects()
{
return Q.scopeList(gActor).toList.subset(
{o: valToList(o.collectiveGroups).indexOf(self) != nil});
}
/*
* The default descriptions of a CollectiveGroup: By default we just list
* those of our members that are in scope.
*/
desc()
{
/*
* Get a list of all the objects in scope that belong to this
* Collective Group.
*/
local lst = myScopeObjects();
/*
* Obtain the sublist of these that are currently held by the player
* character
*/
local heldLst = lst.subset({o: o.isIn(gPlayerChar)});
/*
* Subtract the list of held items from the list of in-scope items to
* obtain a list of other items in scope.
*/
lst -= heldLst;
/* If none of our items are in scope, say so */
if(nilToList(lst).length == 0 && nilToList(heldLst).length == 0)
DMsg(collective group empty, 'There{\'s} no {1} {here}. ', name);
/*
* Otherwise display lists of which of my members the player character
* is carrying and which others are also present.
*/
else
{
if(heldLst.length > 0)
DMsg(carrying collective group, '{I} {am} carrying {1}. ',
makeListStr(heldLst));
if(lst.length > 0)
DMsg(collective group members, 'There{\'s} {1} {here}. ',
makeListStr(lst));
}
}
/* A CollectiveGroup isn't normally listed as an item in its own right. */
isListed = nil
;
/*
* A Heavy is a Fixture that's too heavy to be picked up. We make Heavy a
* Fixture rather than an Immovable since it should normally be obvious that
* something is too heavy to be moved.
*/
class Heavy: Fixture
cannotTakeMsg = BMsg(too heavy, '{The subj cobj} {is} too heavy to move. ')
;
/*
* An Immovable is something that can't be picked up, although it may not be
* immediately obvious that it can't be moved. For that reason we rule out
* taking an Immovable at the check stage rather than the verify stage (this
* is what distinquished an Immovable from a Fixture).
*/
class Immovable: Thing
/* Respond to an attempt to TAKE by ruling it out at the check stage. */
dobjFor(Take)
{
check() { say(cannotTakeMsg); }
}
/* The message to display to explain why this object can't be taken. */
cannotTakeMsg = BMsg(cannot take immovable, '{I} {cannot} take {the cobj}.
')
;
/*
* A StairwayUp is Thing the player character can climb up. It might represent
* an upward staircase, but it could also represent a tree, mast or hillside,
* for example. A StairwayUp is also a TravelConnector so it can be defined on
* the appropriate direction property of its enclosing room.
*/
class StairwayUp: TravelConnector, Thing
/* Climbing a StairwayUp is equivalent to travelling via it. */
dobjFor(Climb)
{
action() { travelVia(gActor); }
}
/* Climbing up a Stairway up is the same as Climbing it. */
dobjFor(ClimbUp) asDobjFor(Climb)
/* A StairwayUp is usually something fixed in place. */
isFixed = true
/* A StairwayUp is climbable */
isClimbable = true
/*
* The appropriate PushTravelAction for pushing something something up a
* StairwayUp.
*/
PushTravelVia = PushTravelClimbUp
/*
* Display message announcing that traveler (typically an NPC whose
* departure is witnessed by the player character) has left via this
* staircase.
*/
sayDeparting(traveler)
{
gMessageParams(traveler);
DMsg(say departing up stairs, '{The subj traveler} {goes} up
{1}. ', theName);
}
/*
* Display message announcing that follower is following leader up
* this staircase.
*/
sayActorFollowing(follower, leader)
{
/* Create message parameter substitutions for the follower and leader */
gMessageParams(follower, leader);
DMsg(say following up staircase, '{The subj follower} follow{s/ed} {the
leader} up {1}. ', theName);
}
traversalMsg = BMsg(traverse stairway up, 'up {1}', theName)
;
/*
* A StairwayDown is Thing the player character can climb down. It might
* represent an downward staircase, but it could also represent a tree, mast
* or hillside, for example. A StairwayDown is also a TravelConnector so it
* can be defined on the appropriate direction property of its enclosing room.
*/
class StairwayDown: TravelConnector, Thing
/* Climbing down a StairwayDown is equivalent to travelling via it. */
dobjFor(ClimbDown)
{
action { travelVia(gActor); }
}
/* A StairwayDown is usually something fixed in place. */
isFixed = true
/* A StairwayDown is something one can climb down */
canClimbDownMe = true
/*
* The appropriate PushTravelAction for pushing something something down a
* StairwayDown.
*/
PushTravelVia = PushTravelClimbDown
/*
* Display message announcing that traveler (typically an NPC whose
* departure is witnessed by the player character)has left via this
* staircase.
*/
sayDeparting(traveler)
{
gMessageParams(traveler);
DMsg(say departing down stairs, '{The subj traveler} {goes} down
{1}. ', theName);
}
/*
* Display message announcing that follower is following leader down
* this staircase.
*/
sayActorFollowing(follower, leader)
{
/* Create message parameter substitutions for the follower and leader */
gMessageParams(follower, leader);
DMsg(say following down staircase, '{The subj follower} follow{s/ed}
{the leader} down {1}. ', theName);
}
traversalMsg = BMsg(traverse stairway down, 'down {1}', theName)
cannotClimbMsg = BMsg(cannot climb stairway down, '{I} {can\'t} climb {the
dobj}, but {i} could go down {him dobj}. ')
;
/* A Passage represents a physical object an actor can travel through, like a
passage or portal. A Passage is also a TravelConnector so it
* can be defined on the appropriate direction property of its enclosing room.
*/
class Passage: TravelConnector, Thing
/* Going through a Passage is equivalent to travelling via it. */
dobjFor(GoThrough)
{
preCond = [travelPermitted, touchObj]
action() { travelVia(gActor); }
}
iobjFor(PushTravelThrough)
{
preCond = [travelPermitted, touchObj]
}
/* Entering a Passage is the same as going through it */
dobjFor(Enter) asDobjFor(GoThrough)
/* Going along a Passage is the same as going through it */
dobjFor(GoAlong) asDobjFor(GoThrough)
/* A Passage is usually something fixed in place. */
isFixed = true
/* A Passage is something one can go through */
canGoThroughMe = true
/*
* The appropriate PushTravelAction for pushing something something
* through a Passage.
*/
PushTravelVia = PushTravelThrough
;
/*
* A PathPassage is a Passage that represents a path, so that following it or
* going down it is equivalent to going through it.
*/
class PathPassage: Passage
/* Make following a path the same as going through it. */
dobjFor(Follow) asDobjFor(GoThrough)
/* Make going down a path the same as going through it. */
dobjFor(ClimbDown) asDobjFor(GoThrough)
/* Make going up a path the same as going through it. */
dobjFor(ClimbUp) asDobjFor(GoThrough)
/* One most naturally talks of going 'down' a path */
traversalMsg = BMsg(traverse path passage, 'down {1}', theName)
;
/*
* ProxyDest is a mix-in class for use with an object that represents the
* exterior of a room, such as a hut in a field. Its purpose is to remove such
* an object as the possible target of a GO TO command provided there's
* another alternative. This prevents a GO TO command from taking the player
* character from the appropriate room to an inappropriate destination.
*/
class ProxyDest: object
filterResolveList(np, cmd, mode)
{
/* Carry out the inherited handling. */
inherited(np, cmd, mode);
/*
* If we're the potential target of a GO TO command and there are
* other possible matches, remove ourselves from the list of matches.
*/
if(cmd.action == GoTo && np.matches.length > 1)
np.matches = np.matches.subset({m: m.obj != self});
}
;
/*
* An Enterable is a Thing one can go inside. It is usually used to represent
* the exterior of an object like a building, so that going inside will take
* the actor to a new location representing the interior.
*/
class Enterable: ProxyDest, Fixture
/* To enter an Enterable the actor must travel via its connector. */
dobjFor(Enter)
{
verify() {}
action() { connector.travelVia(gActor); }
}
/* The handling of an attempt to push something inside this object */
iobjFor(PushTravelEnter)
{
/*
* To push something inside this object we must be able to touch this
* object.
*/
preCond = [touchObj]
/* Check whether our connector allows push travel through it */
check() { connector.checkPushTravel(); }
/* Carry out the attempt to push something inside us. */
action()
{
/*
* If our connector defines a PushTravelVia action, use that
* action to push the direct object via our connector. The use of
* replaceAction means that the handling will end there.
*/
if(connector.PushTravelVia)
replaceAction(connector.PushTravelVia, gDobj, connector);
/* Otherwise, make our direct object travel vis our connector */
connector.travelVia(gDobj);
/*
* If the push travel attempt was successful, which we assume it
* was if the direct object ended up in our connector's
* destination, display a message to say the push travel succeeded
* and make the actor travel via our connector.
*/
if(gDobj.isIn(connector.destination))
{
say(okayPushIntoMsg);
connector.travelVia(gActor);
}
}
}
/*
* Our connector is the TravelConnector via which an actor travels on
* entering this object. This may be a Room, or some other TravelConnector
* object such as a Door on our outside through which the actor must pass
* to get inside.
*
* We set connector = destination since on occasion it may seem more
* natural to authors to set the destination property (when it leads
* straight to a room) and sometimes more natural to set the connector
* property (when it's a door, say). With connector = (destination) by
* default, it should work either way.
*/
connector = (destination)
/*
* If entering this object leads straight to another room, it may seem
* more natural to define a destination property; provided we don't
* override connector as well, this has the same effect as pointing
* connector directly to the room.
*/
destination = nil
/* An Enterable is usually enterable */
isEnterable = true
;
/*
* A SecretDoor is a Door that doesn't appear to be a door when it's closed,
* and which must be opened by some external mechanism (other than by an OPEN
* command)
*/
class SecretDoor: Door
/* You can only go through a SecretDoor when it's open */
canGoThroughMe = isOpen
/* A SecretDoor only functions as a TravelConnector when it's open */
isConnectorApparent = isOpen
/*
* We can't use an OPEN command to open a SecretDoor, but by default we'll
* allow a CLOSE command to close it. To disallow this override isOpenable
* to nil
*/
isOpenable = isOpen
/*
* The vocab string (including the name) that applies to this SecretDoor
* when it's open. This might be somewhat different from that which
* applies when it's closed. For example, opening a bookcase might turn it
* into a passage or an opening. If you don't want to the vocab to change
* when this SecretDoor is opened and closed, leave vocabWhenOpen as nil.
*/
vocabWhenOpen = nil
/*
* The vocab string (including the name) that applies to this SecretDoor
* when it's closed. If the SecretDoor starts out closed there's no need
* to define this explicitly as it will be copied from the vocab property
* at preInit.
*
* To define a SecretDoor that's effectively invisible when closed, give
* it a vocab property comprising an empty string (i.e. '', not nil); this
* will make it impossible for the player to refer to it when it's closed.
*/
vocabWhenClosed = nil
/* Preinitialize a SecretDoor */
preinitThing()
{
/* Carry out the inherited handling */
inherited();
/*
* If the door starts out open, copy its initial vocab to its
* vocabWhenOpen property.
*/
if(isOpen)
vocabWhenOpen = vocab;
/*
* If the door starts out closed, copy its initial vocab to its
* vocabWhenClosed property.
*/
else
vocabWhenClosed = vocab;
}
/* Carry out opening or closing a SecretDoor */
makeOpen(stat)
{
/* Perform the inherited handling */
inherited(stat);
/*
* If we're opening the SecretDoor and it has a non-nil vocabWhenOpen
* property and its vocabWhenOpen property is different from its
* current vocab, then reinitialize its vocab from the vocabWhenOpen
* property.
*/
if(stat && vocabWhenOpen && vocab != vocabWhenOpen)
replaceVocab(vocabWhenOpen);
/*
* If we're closing the SecretDoor and it has a non-nil
* vocabWhenClosed property and its vocabWhenClosed property is
* different from its current vocab, then reinitialize its vocab from
* the vocabWhenClosed property.
*/
if(!stat && vocabWhenClosed && vocab != vocabWhenClosed)
replaceVocab(vocabWhenClosed);
}
;
/* A Switch is a Thing than can be turned on and off */
class Switch: Thing
/* A Switch is switchable */
isSwitchable = true
/* FLIP SWITCH is equivalent to SWITCH SWITCH */
dobjFor(Flip) asDobjFor(SwitchVague)
;
/*
* A Flashlight is a light source that can be turned on and off; in other
* words it's a Switch that's lit when on.
*/
class Flashlight: Switch
/* Turning a Flashlight on and off makes it lit or unlit */
makeOn(stat)
{
inherited(stat);
makeLit(stat);
}
/* Lighting a Flashlight is equivalent to switching it on */
dobjFor(Light) asDobjFor(SwitchOn)
/* Extinguishing a Flashlight is equivalent to switching it off */
dobjFor(Extinguish) asDobjFor(SwitchOff)
;
/*
* A ContainerDoor can be used as part of a multiply-containing object to
* represent the door of the container-like object defined on its remapIn
* property. A ContainerDoor is open or closed if the underlying container is
* open or closed, and remaps all container-appropriate actions to the remapIn
* object of its location.
*/
class ContainerDoor: Fixture
/* We're open if our location's container is open */
isOpen = (location.remapIn.isOpen)
/*
* Redirect all container-appropriate actions to the remapIn object of our
* location, so that opening, closing, locking and unlocking this door
* will perform the equivalent action on our container object.
*/
remapIn = location.remapIn
cannotTakeMsg = BMsg(cannot take container door, '{I} {can\'t} have {the
cobj}; {he dobj}{\'s} part of {1}. ', location.theName)
;
/*
* A MinorItem is an unobtrusive and possibly unimportant portable object that's worth
* implementing in the game but sufficiently minor as to be not worth mentioning (in response to X
* or FOO ALL) unless it's either directly held by the player character or directly in the
* enclosing room. (Based on Joey Cramsey's Trinket class).
*/
class MinorItem: Thing
/*
* We're listed in response to a LOOK command only if we're not fixed in place and we can't be
* ignored for the current action or our current location.
*/
lookListed = (!canBeIgnored(gAction) && !isFixed)
/* We're excluded from a FOO ALL action if we can be ignored for FOO. */
hideFromAll(action)
{
return canBeIgnored(action);
}
/*
* We can be ignored for action unless we're directly in our enclosing room or directly in the
* player character's location or carried by the player character or, if desired, the action
* is TAKEFROM or PutXX
*/
canBeIgnored(action)
{
/*
* If we are exposed, in the middle of the room or the actor's location (e.g. a
* platform or booth), then we cannot be ignored.
*/
if (location is in (getOutermostRoom(), gActor.location))
return nil;
/* Allow actions like DROP ALL if we are being directly carried. */
if (isDirectlyHeldBy(gActor))
return nil;
/* Allow an explicit TAKE FROM or PUT somewhere if our allowTakeFromPut flag allows it. */
if(action is in (TakeFrom, PutIn, PutOn, PutBehind, PutUnder))
return !includeTakeFromPutAll;
// Otherwise, pay us no mind in X ALL.
return true;
}
/*
* Flag: do we want to be included in TAKE ALL FROM X, and PUT ALL IN/ON/UNDER/BEHIND X? by
* default we do.
*/
includeTakeFromPutAll = true
;
Adv3Lite Library Reference Manual
Generated on 01/03/2024 from adv3Lite version 1.6.2