travel.t | documentation |
#charset "us-ascii"
/*
* Copyright (c) 2000, 2006 Michael J. Roberts. All Rights Reserved.
*
* TADS 3 Library - travel
*
* This module defines the parts of the simulation model related to
* travel: rooms and other locations, directions, passages.
*/
/* include the library header */
#include "adv3.h"
infiniteLoop()
{
for (local i = 1 ; i < 100 ; ) ;
}
/* ------------------------------------------------------------------------ */
/*
* Directions. Each direction is represented by an instance of
* Direction.
*
* A Direction object encapsulates information about a travel direction.
* By using an object to represent each possible travel direction, we
* make it possible for a game or library extension to add new custom
* directions without having to change the basic library.
*/
class Direction: object
/*
* The link property for the direction. This is a property pointer
* that we use to ask an actor's location for a TravelConnector when
* the actor attempts to travel in this direction.
*/
dirProp = nil
/*
* The default TravelConnector when an actor attempts travel in this
* direction, but the actor's location does not define the dirProp
* property for this direction. This is almost always a connector
* that goes nowhere, such as noTravel, since this is used only when
* a location doesn't have a link for travel in this direction.
*/
defaultConnector(loc) { return noTravel; }
/*
* Initialize. We'll use this routine to add each Direction
* instance to the master direction list (Direction.allDirections)
* during pre-initialization.
*/
initializeDirection()
{
/* add myself to the master direction list */
Direction.allDirections.append(self);
}
/*
* Class initialization - this is called once on the class object.
* We'll build our master list of all of the Direction objects in
* the game, and then sort the list using the sorting order.
*/
initializeDirectionClass()
{
/* initialize each individual Direction object */
forEachInstance(Direction, { dir: dir.initializeDirection() });
/*
* sort the direction list according to the individual Directin
* objects' defined sorting orders
*/
allDirections.sort(SortAsc, {a, b: a.sortingOrder - b.sortingOrder});
}
/*
* Our sorting order in the master list. We use this to present
* directions in a consistent, aesthetically pleasing order in
* listings involving multiple directions. The sorting order is
* simply an integer that gives the relative position in the list;
* the list of directions is sorted from lowest sorting order to
* highest. Sorting order numbers don't have to be contiguous,
* since we simply put the directions in an order that makes the
* sortingOrder values ascend through the list.
*/
sortingOrder = 1
/*
* A master list of the defined directions. We build this
* automatically during initialization to include each Direction
* instance. Any operation that wants to iterate over all possible
* directions can run through this list.
*
* By using this master list to enumerate all possible directions
* rather than a hard-coded set of pre-defined directions, we can
* ensure that any new directions that a game or library extension
* adds will be incorporated automatically into the library simply
* by virtue of the existence Direction instances to represent the
* new directions.
*/
allDirections = static new Vector(10)
;
/*
* The base class for compass directions (north, south, etc). We don't
* add anything to the basic Direction class, but we use a separate
* class for compass directions to allow language-specific
* customizations for all of the directions and to allow travel commands
* to treat these specially when needed.
*/
class CompassDirection: Direction
;
/*
* The base class for shipboard directions (port, aft, etc).
*/
class ShipboardDirection: Direction
defaultConnector(loc)
{
/*
* If 'loc' is aboard a ship, use noTravel as the default
* connector, since we simply can't go this direction. If we're
* not aboard ship, use the special connector noShipTravel,
* which is meant to convey that shipboard directions make no
* sense when not aboard a ship.
*/
return (loc.isShipboard ? noTravel : noShipTravel);
}
;
/*
* The base class for vertical directions (up, down)
*/
class VerticalDirection: Direction
;
/*
* The base class for "relative" directions (in, out)
*/
class RelativeDirection: Direction
;
/*
* Individual compass directions.
*
* Our macro defines a direction object with a name based on the
* direction's room travel link property and the base class. So,
* DefineDirection(north, Compass) defines a direction object called
* 'northDirection' based on the CompassDirection class, with the link
* property 'north' and default travel connector 'noTravel'.
*
* Note that we define a sorting order among the default directions as
* follows. First, we define several groups of related directions,
* which we put in a relative order: the compass directions, then the
* vertical directions, then the "relative" (in/out) directions, and
* finally the shipboard directions. Then, we order the directions
* within these groups. For the sortingOrder values, we use arbitrary
* integers with fairly wide separations, to leave plenty of room for
* custom game-specific directions to be added before, between, after,
* or within these pre-defined groups.
*/
#define DefineDirection(prop, base, order) \
prop##Direction: base##Direction \
dirProp = &prop \
sortingOrder = order
DefineDirection(north, Compass, 1000);
DefineDirection(south, Compass, 1100);
DefineDirection(east, Compass, 1200);
DefineDirection(west, Compass, 1300);
DefineDirection(northeast, Compass, 1400);
DefineDirection(northwest, Compass, 1500);
DefineDirection(southeast, Compass, 1600);
DefineDirection(southwest, Compass, 1700);
DefineDirection(up, Vertical, 3000);
DefineDirection(down, Vertical, 3100);
DefineDirection(in, Relative, 5000)
defaultConnector(loc) { return noTravelIn; }
;
DefineDirection(out, Relative, 5100)
defaultConnector(loc) { return noTravelOut; }
;
DefineDirection(fore, Shipboard, 7000);
DefineDirection(aft, Shipboard, 7100);
DefineDirection(port, Shipboard, 7200);
DefineDirection(starboard, Shipboard, 7300);
/* ------------------------------------------------------------------------ */
/*
* Travel Message Handler. This contains a set of messages that are
* specific to different types of TravelConnector objects, to describe
* NPC arrivals and departures via these connectors when the NPC's are in
* view of the player character.
*
* This base class implements the methods simply by calling the
* corresponding gLibMessages message methods.
*
* The purpose of providing this variety of connector-specific handlers
* is to make it easy for individual travelers to customize the
* arrival/departure messages for specific connector subclasses. These
* messages sometimes benefit from customization for specific
* traveler/connector combinations; the easiest way to enable such
* granular customization is to make it possible to override a message
* per connector type on the traveler object.
*/
class TravelMessageHandler: object
/*
* Get the traveler for the purposes of arrival/departure messages.
* Implementations that aren't themselves the travelers should
* override this to supply the correct nominal traveler.
*/
getNominalTraveler() { return self; }
/* generic arrival/departure - for the base TravelConnector class */
sayArriving(conn) { gLibMessages.sayArriving(getNominalTraveler()); }
sayDeparting(conn) { gLibMessages.sayDeparting(getNominalTraveler()); }
/* generic local arrival and departure messages */
sayArrivingLocally(dest, conn)
{ gLibMessages.sayArrivingLocally(getNominalTraveler(), dest); }
sayDepartingLocally(dest, conn)
{ gLibMessages.sayDepartingLocally(getNominalTraveler(), dest); }
/* generic remote travel message */
sayTravelingRemotely(dest, conn)
{ gLibMessages.sayTravelingRemotely(getNominalTraveler(), dest); }
/* directional arrival/departure - for RoomConnector */
sayArrivingDir(dir, conn) { dir.sayArriving(getNominalTraveler()); }
sayDepartingDir(dir, conn) { dir.sayDeparting(getNominalTraveler()); }
/* arrival/departure via a ThroughPassage */
sayArrivingThroughPassage(conn)
{
gLibMessages.sayArrivingThroughPassage(getNominalTraveler(), conn);
}
sayDepartingThroughPassage(conn)
{
gLibMessages.sayDepartingThroughPassage(getNominalTraveler(), conn);
}
/* arrival/departure via a PathPassage */
sayArrivingViaPath(conn)
{ gLibMessages.sayArrivingViaPath(getNominalTraveler(), conn); }
sayDepartingViaPath(conn)
{ gLibMessages.sayDepartingViaPath(getNominalTraveler(), conn); }
/* arrival/departure up/down stairs */
sayArrivingUpStairs(conn)
{ gLibMessages.sayArrivingUpStairs(getNominalTraveler(), conn); }
sayArrivingDownStairs(conn)
{ gLibMessages.sayArrivingDownStairs(getNominalTraveler(), conn); }
sayDepartingUpStairs(conn)
{ gLibMessages.sayDepartingUpStairs(getNominalTraveler(), conn); }
sayDepartingDownStairs(conn)
{ gLibMessages.sayDepartingDownStairs(getNominalTraveler(), conn); }
;
/* ------------------------------------------------------------------------ */
/*
* A Traveler is an object that can travel. The two main kinds of
* travelers are Actors and Vehicles. A vehicle can contain multiple
* actors, so a single vehicle travel operation could move several
* actors.
*
* This class is intended to be multiply inherited, since it is not based
* on any simulation object class.
*/
class Traveler: TravelMessageHandler
/*
* Check, using pre-condition rules, that the traveler is directly
* in the given room. We'll attempt to implicitly remove the actor
* from any nested rooms within the given room.
*/
checkDirectlyInRoom(dest, allowImplicit)
{
/* ask the destination to ensure the traveler is in it directly */
return dest.checkTravelerDirectlyInRoom(self, allowImplicit);
}
/*
* Check, using pre-condition rules, that the traveler is in the
* given room, moving the traveler to the room if possible.
*/
checkMovingTravelerInto(room, allowImplicit)
{
/* subclasses must override */
}
/*
* Get the travel preconditions specific to the traveler, for the
* given connector. By default, we return no extra conditions.
*/
travelerPreCond(conn) { return []; }
/*
* Can the traveler travel via the given connector to the given
* destination? Returns true if the travel is permitted, nil if not.
*
* By default, this simply returns true to indicate that the travel
* is allowed. Individual instances can override this to enforce
* limitations on what kind of travel the traveler can perform.
*/
canTravelVia(connector, dest) { return true; }
/*
* Explain why the given travel is not possible. This is called when
* canTravelVia() returns nil, to display a report to the player
* explaining why the travel was disallowed.
*
* By default, we do nothing, since our default canTravelVia() never
* disallows any travel. If canTravelVia() is overridden to disallow
* travel under some conditions, this must be overridden to generate
* an appropriate explanatory report.
*/
explainNoTravelVia(connector, dest) { }
/*
* Show my departure message - this is shown when I'm leaving a room
* where the player character can see me for another room where the
* player character cannot see me.
*/
describeDeparture(dest, connector)
{
/*
* If we're visible to the player character, describe the
* departure. Ask the connector to describe the travel, since
* it knows the direction of travel and can describe special
* things like climbing stairs.
*
* Don't bother to describe the departure if the traveler is the
* player character, or the player character is inside the
* traveler. The PC obviously can't leave the presence of
* itself.
*/
if (!isActorTraveling(gPlayerChar))
{
/*
* invoke the departure with a visual sense context for the
* traveler
*/
callWithSenseContext(self, sight,
{: describeNpcDeparture(dest, connector)});
}
}
/*
* Describe the departure of a non-player character, or any traveler
* not involving the player character.
*/
describeNpcDeparture(dest, connector)
{
/*
* If the PC can see our destination, we're doing "local travel"
* - we're traveling from one top-level location to another, but
* entirely in view of the PC. In this case, the PC was already
* aware of our presence, so we don't want to describe the
* departure as though we're actually leaving; we're just moving
* around. If the destination isn't in sight, then we're truly
* departing.
*/
if (gPlayerChar.canSee(dest))
{
/*
* We're moving from somewhere within the PC's sight to
* another location within the PC's sight, so we're not
* actually departing, from the PC's point of view: we're
* just moving around a bit.
*
* - If we're moving further away from the PC - that is, if
* we're moving out of the PC's own top-level location and
* into a different top-level location, describe this as a
* "local departure."
*
* - If we're moving closer to the PC - moving from a top
* level location that doesn't contain the PC to the PC's
* current top-level location - say nothing. We'll leave it
* to the "local arrival" message to mention it, because
* that's the more relevant aspect of the travel from the
* PC's POV: we're approaching the PC.
*
* - If we're moving from one top-level location to another,
* say nothing. We'll leave this to arrival time as well.
* Whether we describe remote-to-remote travel as arrival or
* departure is just arbitrary; we only want to generate one
* message, but there's no general reason to prefer
* generating the message at departure vs arrival.
*/
if (gPlayerChar.isIn(getOutermostRoom()))
{
/*
* we're moving further away from the player - describe
* this as a local departure
*/
connector.describeLocalDeparture(self, location, dest);
}
}
else
{
/* we're really departing - let the connector describe it */
connector.describeDeparture(self, location, dest);
}
}
/*
* Show my arrival message - this is shown when I'm entering a room
* in view of the player character from a location where the player
* character could not see me. 'backConnector' is the connector in
* the destination location from which we appear to be emerging.
*/
describeArrival(origin, backConnector)
{
/*
* If the player character is participating in the travel,
* describe the arrival from the point of view of the player
* character by showing the "look around" description of the new
* location.
*
* Otherwise, describe the NPC traveler's arrival. Only
* describe the arrival if the PC can see the traveler, for
* obvious reasons.
*/
if (isActorTraveling(gPlayerChar))
{
/*
* Add an intra-report separator, to visually separate the
* description of the arrival from any result text that came
* before. (For example, if we performed an implied command
* before we could begin travel, this will visually separate
* the results of the implied command from the arrival
* message.)
*/
say(gLibMessages.intraCommandSeparator);
/*
* The player character is traveling - show the travel from
* the PC's perspective.
*/
gPlayerChar.lookAround(gameMain.verboseMode.isOn);
}
else if (travelerSeenBy(gPlayerChar))
{
/*
* The player character isn't traveling, but the PC can see
* me now that I'm in my new location, so describe the
* arrival of the traveler. Do this within a visual sense
* context for the traveler.
*/
callWithSenseContext(
self, sight, {: describeNpcArrival(origin, backConnector)});
}
}
/*
* Describe the arrival of a non-player character or any other
* traveler that doesn't involve the player character.
*/
describeNpcArrival(origin, backConnector)
{
/*
* If we know the connector back, use its arrival message;
* otherwise, use a generic arrival message.
*/
if (backConnector != nil)
{
/*
* If the PC can see the origin, we're not actually arriving
* anew; instead, we're simply moving around within the PC's
* field of view. In these cases, we don't want to use the
* normal arrival message, because we're not truly arriving;
* we could be moving closer to the player, further away from
* the player, or moving laterally from one remote location
* to another. If the PC can't see the origin, we're truly
* arriving.
*/
if (gPlayerChar.canSee(origin))
{
/*
* We're not arriving anew, but just moving around within
* the PC's field of view.
*
* - If we're moving closer to the PC - moving from a
* top-level location that doesn't contain the PC to one
* that does - describe this as a "local arrival."
*
* - If we're moving further away from the PC - from
* within the PC's top-level location to a different
* top-level location - don't say anything. We will have
* already described this as a "local departure" during
* the departure message phase, and from the PC's point
* of view, that fully covers it.
*
* - If we're moving laterally - from one remote
* top-level location to another ("remote" means "does
* not contain the PC") - it's arbitrary whether this
* should be described at arrival or departure time. We
* arbitrarily pick arrival, so describe the lateral
* local travel now.
*/
if (gPlayerChar.isIn(getOutermostRoom()))
{
/*
* We're now in the same top-level location as the
* PC, so we've moved closer to the PC, so describe
* this as a "local arrival."
*/
backConnector.describeLocalArrival(
self, origin, location);
}
else if (!gPlayerChar.isIn(origin))
{
/*
* We're *not* in the same top-level location as the
* PC, and we weren't on departure either, so this is
* a lateral move - a move from one remote location
* to another. Describe it as such now.
*/
backConnector.describeRemoteTravel(
self, origin, location);
}
}
else
{
/* we're arriving anew - let the connector describe it */
backConnector.describeArrival(self, origin, location);
}
}
else
{
/* there's no back-connector, so use a generic arrival message */
gLibMessages.sayArriving(self);
}
}
/*
* Travel to a new location. Moves the traveler to a new location
* via the given connector, triggering any side effects of the
* travel.
*
* Note that this routine is not normally called directly; in most
* cases, the actor's travelTo is called, and it in turn invokes
* this method in the appropriate traveler.
*
* 'dest' is the new location to which we're traveling. 'connector'
* is the TravelConnector we're traversing from the source location
* to reach the new destination; the connector is normally the
* invoker of this routine. 'backConnector' is the connector in the
* destination from which the actor will appear to emerge on the
* other end of the travel.
*/
travelerTravelTo(dest, connector, backConnector)
{
local origin;
local isDescribed;
local actors;
/*
* Remember my departure original location - this is the
* location where the traveler was before we moved.
*/
origin = location;
/*
* Determine if we're describing the travel. We'll describe it
* if we're actually changing locations, or if the connector is
* explicitly a "circular" passage, which means that it connects
* back to the same location but involves a non-trivial passage,
* as sometimes happens in settings like caves.
*/
isDescribed = (dest != origin || connector.isCircularPassage);
/*
* Send a before-departure notification to everyone connected to
* by containment to the traveler.
*/
getNotifyTable().forEachAssoc(
{obj, val: obj.beforeTravel(self, connector)});
/* notify the actor initiating the travel */
if (gActor != nil)
gActor.actorTravel(self, connector);
/* tell the old room we're leaving, if we changed locations */
if (origin != nil && isDescribed)
origin.travelerLeaving(self, dest, connector);
/* notify the connector that we're traversing it */
connector.noteTraversal(self);
/* get the list of traveling actors */
actors = getTravelerActors();
/* move to the destination */
moveIntoForTravel(dest);
/*
* We've successfully completed the travel, so remember it for
* each actor involved in the travel. Do this only if we
* actually went somewhere, or if the connector is circular - if
* we didn't end up going anywhere, and the connector isn't
* circular, we must have turned back halfway without completing
* the travel.
*/
if (dest != origin || connector.rememberCircularPassage)
{
foreach (local cur in actors)
{
/* ask the actor to remember the travel */
cur.rememberTravel(origin, dest, backConnector);
/* remember the destination of the connector for this actor */
connector.rememberTravel(origin, cur, dest);
/*
* If there's a back-connector, also remember travel in
* the other direction. The actor can reasonably be
* expected to assume that the connector through which
* it's arriving connects back to the source location, so
* remember the association.
*/
if (backConnector != nil)
backConnector.rememberTravel(dest, cur, origin);
}
}
/*
* Recalculate the global sense context for message generation
* purposes, since we've moved to a new location. It's possible
* that we've arrived at the player character's location, in
* which case we might have been suppressing messages (due to
* our being in a different room) but should now show messages
* (because we're now near the player character).
*/
if (gAction != nil)
gAction.recalcSenseContext();
/* tell the new room we're arriving, if we changed locations */
if (location != nil && isDescribed)
location.travelerArriving(self, origin, connector, backConnector);
/* notify objects now connected by containment of the arrival */
getNotifyTable().forEachAssoc(
{obj, val: obj.afterTravel(self, connector)});
}
/*
* Perform "local" travel - that is, travel between nested rooms
* within a single top-level location. By default, we simply defer
* to the actor to let it perform the local travel.
*/
travelerTravelWithin(actor, dest)
{
actor.travelerTravelWithin(actor, dest);
}
/*
* Get a lookup table giving the set of objects to be notified of a
* beforeTravel/afterTravel event. By default, we return a table
* including every object connected to the traveler by containment.
*/
getNotifyTable()
{
/* return the table of objects connected by containment */
return connectionTable();
}
/*
* Determine if the given actor can see this traveler. By default,
* we'll simply check to see if the actor can see 'self'.
*/
travelerSeenBy(actor) { return actor.canSee(self); }
/*
* Is the given actor traveling with this traveler? Returns true if
* the actor is in my getTravelerActors list.
*/
isActorTraveling(actor)
{
/* check to see if the given actor is in my actor list */
return getTravelerActors.indexOf(actor) != nil;
}
/*
* Is the given object being carried by the traveler? Returns true
* if the object is inside the traveler itself, or is inside any of
* the actors traveling.
*/
isTravelerCarrying(obj)
{
/* if the object is inside the traveler, it's being carried */
if (obj.isIn(self))
return true;
/* if the object is inside any traveling actor, it's being carried */
foreach (local cur in getTravelerActors)
{
if (obj.isIn(cur))
return true;
}
/* the object isn't being carried */
return nil;
}
/* invoke a callback function for each traveling actor */
forEachTravelingActor(func)
{
/* by default, get the list, and invoke the callback per item */
getTravelerActors.forEach(func);
}
/*
* Get the list of actors taking part in the travel. When an actor
* is the traveler, this list simply contains the actor itself; for
* a vehicle or other composite traveler that moves more than one
* actor at a time, this should return the list of all of the actors
* involved in the travel.
*/
getTravelerActors = []
/*
* Get the list of actors traveling undo their own power. In the
* case of an actor traveling directly, this is just the actor; in
* the case of an actor pushing something, this is likewise the
* actor; in the case of a group of actors traveling together, this
* is the list of traveling actors; in the case of a vehicle, this
* is an empty list, since anyone traveling with the vehicle is
* traveling under the vehicle's power.
*/
getTravelerMotiveActors = []
;
/* ------------------------------------------------------------------------ */
/*
* A Travel Connector is a special connection interface that allows for
* travel from one location to another. Most actor movement, except for
* movement between locations related by containment (such as from a room
* to sitting in a chair within the room) are handled through travel
* connector objects.
*
* Travel connectors are used in the directional link properties in rooms
* - north, south, east, west, in, out, etc. A room direction link
* property is always set to a travel connector - but note that a room is
* itself a travel connector, so a travel link in one room can simply be
* set to point directly to another room. In many cases, rooms
* themselves serve as travel connectors, so that one room can point a
* direction link property directly to another room.
*
* Some travel connectors are physical objects in the simulation, such as
* doors or stairways; other connectors are just abstract objects that
* represent connections, but don't appear as manipulable objects in the
* game.
*
* A travel connector provides several types of information about travel
* through its connection:
*
* - For actors actually traveling, the connector provides a method that
* moves an actor through the connector. This method can trigger any
* side effects of the travel.
*
* - For automatic map builders, actor scripts, and other callers who
* want to learn what can be known about the link without actually
* traversing it, the connector provides an "apparent destination"
* method. This method returns the destination of travel through the
* connector that a given actor would expect just by looking at the
* connector. The important thing about this routine is that it doesn't
* trigger any side effects, but simply indicates whether travel is
* apparently possible, and if so what the destination of the travel
* would be.
*/
class TravelConnector: Thing
/*
* Get any connector-specific pre-conditions for travel via this
* connector.
*/
connectorTravelPreCond()
{
local lst;
/* start with no conditions */
lst = [];
/* if we have a staging location, require that we're in it */
if (connectorStagingLocation != nil)
lst = [new TravelerDirectlyInRoom(gActor, self,
connectorStagingLocation)];
/*
* If we're a physical Thing with a non-nil location, require
* that we be touchable. Only physical objects need to be
* touchable; connectors are sometimes abstract objects, which
* obviously can't be touched.
*/
if (ofKind(Thing) && location != nil)
{
/* require that the traveler can touch the connector */
local cond = new TouchObjCondition(gActor.getTraveler(self));
lst += new ObjectPreCondition(self, cond);
}
/* return the result */
return lst;
}
/*
* The "staging location" for travel through this connector. By
* default, if we have a location, that's our staging location; if
* we don't have a location (in which case we probably an outermost
* room), we don't have a staging location.
*/
connectorStagingLocation = (location)
/*
* Get the travel preconditions that this connector requires for
* travel by the given actor. In most cases, this won't depend on
* the actor, but it's provided as a parameter anyway; in most cases,
* this will just apply the conditions that are relevant to actors as
* travelers.
*
* By default, we require actors to be "travel ready" before
* traversing a connector. The exact meaning of "travel ready" is
* provided by the actor's immediate location, but it usually simply
* means that the actor is standing. This ensures that the actor
* isn't sitting in a chair or lying down or something like that.
* Some connectors might not require this, so this routine can be
* overridden per connector.
*
* Note that this will only be called when an actor is the traveler.
* When a vehicle or other kind of traveler is doing the travel, this
* will not be invoked.
*/
actorTravelPreCond(actor)
{
/*
* create an object precondition ensuring that the actor is
* "travel ready"; the object of this precondition is the
* connector itself
*/
return [new ObjectPreCondition(self, actorTravelReady)];
}
/*
* Barrier or barriers to travel. This property can be set to a
* single TravelBarrier object or to a list of TravelBarrier
* objects. checkTravelBarriers() checks each barrier specified
* here.
*/
travelBarrier = []
/*
* Check barriers. The TravelVia check() routine must call this to
* enforce barriers.
*/
checkTravelBarriers(dest)
{
local traveler;
local lst;
/* get the traveler */
traveler = gActor.getTraveler(self);
/* ask the traveler what it thinks of travel through this connector */
if (!traveler.canTravelVia(self, dest))
{
/* explain why the traveler can't pass */
traveler.explainNoTravelVia(self, dest);
/* terminate the command */
exit;
}
/* check any travel conditions we apply directly */
if (!canTravelerPass(traveler))
{
/* explain why the traveler can't pass */
explainTravelBarrier(traveler);
/* terminate the command */
exit;
}
/* get the barrier list */
lst = travelBarrier;
/* if it's just a single object, make it a list of one element */
if (!lst.ofKind(Collection))
lst = [lst];
/* check each item in our barrier list */
foreach (local cur in lst)
{
/* if this barrier doesn't allow travel, we cannot travel */
if (!cur.canTravelerPass(traveler))
{
/* ask the barrier to explain why travel isn't possible */
cur.explainTravelBarrier(traveler);
/* terminate the command */
exit;
}
}
}
/*
* Check to see if the Traveler object is allowed to travel through
* this connector. Returns true if travel is allowed, nil if not.
*
* This is called from checkTravelBarriers() to check any conditions
* coded directly into the TravelConnector. By default, we simply
* return true; subclasses can override this to apply special
* conditions.
*
* If an override wants to disallow travel, it should return nil
* here, and then provide an override for explainTravelBarrier() to
* provide a descriptive message explaining why the travel isn't
* allowed.
*
* Conditions here serve essentially the same purpose as barrier
* conditions. The purpose of providing this additional place for
* the same type of conditions is simply to improve the convenience
* of defining travel conditions for cases where barriers are
* unnecessary. The main benefit of using a barrier is that the same
* barrier object can be re-used with multiple connectors, so if the
* same set of travel conditions apply to several different
* connectors, barriers allow the logic to be defined once in a
* single barrier object and then re-used easily in each place it's
* needed. However, when a particular condition is needed in only
* one place, creating a barrier to represent the condition is a bit
* verbose; in such cases, the condition can be placed in this method
* more conveniently.
*/
canTravelerPass(traveler) { return true; }
/*
* Explain why canTravelerPass() returned nil. This is called to
* display an explanation of why travel is not allowed by
* self.canTravelerPass().
*
* Since the default canTravelerPass() always allows travel, the
* default implementation of this method does nothing. Whenever
* canTravelerPass() is overridden to return nil, this should also be
* overridden to provide an appropriate explanation.
*/
explainTravelBarrier(traveler) { }
/*
* Is this connector listed? This indicates whether or not the exit
* is allowed to be displayed in lists of exits, such as in the
* status line or in "you can't go that way" messages. By default,
* all exits are allowed to appear in listings.
*
* Note that this indicates if listing is ALLOWED - it doesn't
* guarantee that listing actually occurs. A connector can be
* listed only if this is true, AND the point-of-view actor for the
* listing can perceive the exit (which means that
* isConnectorApparent must return true, and there must be
* sufficient light to see the exit).
*/
isConnectorListed = true
/*
* Get an unlisted proxy for this connector. This is normally
* called from the asExit() macro to set up one room exit direction
* as an unlisted synonym for another.
*/
createUnlistedProxy() { return new UnlistedProxyConnector(self); }
/*
* Determine if the travel connection is apparent - as a travel
* connector - to the actor in the given origin location. This
* doesn't indicate whether or not travel is possible, or where
* travel goes, or that the actor can tell where the passage goes;
* this merely indicates whether or not the actor should realize
* that the passage exists at all.
*
* A closed door, for example, would return true, because even a
* closed door makes it clear that travel is possible in the
* direction, even if it's not possible currently. A secret door,
* on the other hand, would return nil while closed, because it
* would not be apparent to the actor that the object is a door at
* all.
*/
isConnectorApparent(origin, actor)
{
/* by default, passages are apparent */
return true;
}
/*
* Determine if the travel connection is passable by the given
* traveler in the current state. For example, a door would return
* true when open, nil when closed.
*
* This information is intended to help game code probing the
* structure of the map. This information is NOT used in actor
* travel; for actor travel, we rely on custom checks in the
* connector's TravelVia handler to enforce the conditions of travel.
* Actor travel uses TravelVia customizations rather than this method
* because that allows better specificity in reporting failures.
* This method lets game code get at the same information, but in a
* more coarse-grained fashion.
*/
isConnectorPassable(origin, traveler)
{
/* by default, we're passable */
return true;
}
/*
* Get the apparent destination of travel by the actor to the given
* origin. This returns the location to which the connector
* travels, AS FAR AS THE ACTOR KNOWS. If the actor does not know
* and cannot tell where the connector leads, this should return nil.
*
* Note that this method does NOT necessarily return the actual
* destination, because we obviously can't know the destination for
* certain until we traverse the connection. Rather, the point of
* this routine is to return as much information as the actor is
* supposed to have. This can be used for purposes like
* auto-mapping, where we'd want to show what the player character
* knows of the map, and NPC goal-seeking, where an NPC tries to
* figure out how to get from one point to another based on the
* NPC's knowledge of the map. In these sorts of applications, it's
* important to use only knowledge that the actor is supposed to
* have within the parameters of the simulation.
*
* Callers should always test isConnectorApparent() before calling
* this routine. This routine does not check to ensure that the
* connector is apparent, so it could return misleading information
* if used independently of isConnectorApparent(); for example, if
* the connector *formerly* worked but has now disappeared, and the
* actor has a memory of the former destination, we'll return the
* remembered destination.
*
* The actor can know the destination by a number of means:
*
* 1. The location is familiar to the character. For example, if
* the setting is the character's own house, the character would
* obviously know the house well, so would know where you'd end up
* going east from the living room or south from the kitchen. We
* use the origin method actorKnowsDestination() to determine this.
*
* 2. The destination is readily visible from the origin location,
* or is clearly marked. For example, in an outdoor setting, it
* might be clear that going east from the field takes you to the
* hilltop. In an indoor setting, an open passage might make it
* clear that going east from the living room takes you to the
* dining room. We use the origin method actorKnowsDestination() to
* determine this.
*
* 3. The actor has been through the connector already in the course
* of the game, and so remembers the connection by virtue of recent
* experience. If our travelMemory class property is set to a
* non-nil lookup table object, then we'll automatically use the
* lookup table to remember the destination each time an actor
* travels via a connector, and use this information by default to
* provide apparent destination information.
*/
getApparentDestination(origin, actor)
{
local dest;
/*
* Ask the origin if the actor knows the destination for the
* given connector. If so, and we can determine our
* destination, then return the destination.
*/
if (origin.actorKnowsDestination(actor, self)
&& (dest = getDestination(origin,
actor.getTraveler(self))) != nil)
return dest;
/*
* If we have a travelMemory table, look to see if the traversal
* of this actor via this connector from this origin is recorded
* in the table, and if so, assume that the destination is the
* same as it was last time.
*
* Note that we ignore our memory of travel if we never saw the
* destination of the travel (which would be the case if the
* destination was dark every time we've been there, so we've
* never seen any details about the location).
*/
if (travelMemory != nil
&& (dest = travelMemory[[actor, origin, self]]) != nil
&& actor.hasSeen(dest))
{
/* we know the destination from past experience */
return dest;
}
/* we don't know the destination */
return nil;
}
/*
* Get our destination, given the traveler and the origin location.
*
* This method is required to return the current destination for the
* travel. If the connector doesn't go anywhere, this should return
* nil. The results of this method must be stable for the extent of
* a turn, up until the time travel actually occurs; in other words,
* it must be possible to call this routine simply for information
* purposes, to determine where the travel will end up.
*
* This method should not trigger any side effects, since it's
* necessary to be able to call this method more than once in the
* course of a given travel command. If it's necessary to trigger
* side effects when the connector is actually traversed, apply the
* side effects in noteTraversal().
*
* For auto-mapping and the like, note that getApparentDestination()
* is a better choice, since this method has internal information
* that might not be apparent to the characters in the game and thus
* shouldn't be revealed through something like an auto-map. This
* method is intended for internal use in the course of processing a
* travel action, since it knows the true destination of the travel.
*/
getDestination(origin, traveler) { return nil; }
/*
* Get the travel connector leading to the given destination from the
* given origin and for the given travel. Return nil if we don't
* know a connector leading there.
*
* By default, we simply return 'self' if our destination is the
* given destination, or nil if not.
*
* Some subclasses might encapsulate one or more "secondary"
* connectors - that is, the main connector might choose among
* multiple other connectors. In these cases, the secondary
* connectors typically won't be linked to directions on their own,
* so the room can't see them directly - it can only find them
* through us, since we're effectively a wrapper for the secondary
* connectors. In these cases, we won't have any single destination
* ourself, so getDestination() will have to return nil. But we
* *can* work backwards: given a destination, we can find the
* secondary connector that points to that destination. That's what
* this routine is for.
*/
connectorGetConnectorTo(origin, traveler, dest)
{
/* if we go there, return 'self', else return nil */
return (getDestination(origin, traveler) == dest ? self : nil);
}
/*
* Note that the connector is being traversed. This is invoked just
* before the traveler is moved; this notification is fired after the
* other travel-related notifications (beforeTravel, actorTravel,
* travelerLeaving). This is a good place to display any special
* messages describing what happens during the travel, because any
* messages displayed here will come after any messages related to
* reactions from other objects.
*/
noteTraversal(traveler)
{
/* do nothing by default */
}
/*
* Service routine: add a memory of a successful traversal of a
* travel connector. If we have a travel memory table, we'll add
* the traversal to the table, so that we can find it later.
*
* This is called from Traveler.travelerTravelTo() on successful
* travel. We're called for each actor participating in the travel.
*/
rememberTravel(origin, actor, dest)
{
/*
* If we have a travelMemory table, add this traversal. Store
* the destination, keyed by the combination of the actor,
* origin, and connector object (i.e., self) - this will allow
* us to remember the destination we reached last time if we
* want to know where the same route goes in the future.
*/
if (TravelConnector.travelMemory != nil)
TravelConnector.travelMemory[[actor, origin, self]] = dest;
}
/*
* Our "travel memory" table. If this contains a non-nil lookup
* table object, we'll store a record of each successful traversal
* of a travel connector here - we'll record the destination keyed
* by the combination of actor, origin, and connector, so that we
* can later check to see if the actor has any memory of where a
* given connector goes from a given origin.
*
* We keep this information by default, which is why we statically
* create the table here. Keeping this information does involve
* some overhead, so some authors might want to get rid of this
* table (by setting the property to nil) if the game doesn't make
* any use of the information. Note that this table is stored just
* once, in the TravelConnector class itself - there's not a
* separate table per connector.
*/
travelMemory = static new LookupTable(256, 512)
/*
* Is this a "circular" passage? A circular passage is one that
* explicitly connects back to its origin, so that traveling through
* the connector leaves us where we started. When a passage is
* marked as circular, we'll describe travel through the passage
* exactly as though we had actually gone somewhere. By default, if
* traveling through a passage leaves us where we started, we assume
* that nothing happened, so we don't describe any travel.
*
* Circular passages don't often occur in ordinary settings; these
* are mostly useful in disorienting environments, such as twisty
* cave networks, where a passage between locations can change
* direction and even loop back on itself.
*/
isCircularPassage = nil
/*
* Should we remember a circular trip through this passage? By
* default, we remember the destination of a passage that takes us
* back to our origin only if we're explicitly marked as a circular
* passage; in other cases, we assume that the travel was blocked
* somehow instead.
*/
rememberCircularPassage = (isCircularPassage)
/*
* Describe an actor's departure through the connector from the
* given origin to the given destination. This description is from
* the point of view of another actor in the origin location.
*/
describeDeparture(traveler, origin, dest)
{
local dir;
/*
* See if we can find a direction linked to this connector from
* the origin location. If so, describe the departure using the
* direction; otherwise, describe it using the generic departure
* message.
*
* Find the connector from the player character's perspective,
* because the description we're generating is for the player's
* benefit and thus should be from the PC's perspective.
*/
if ((dir = origin.directionForConnector(self, gPlayerChar)) != nil)
{
/*
* We found a direction linked to the connector, so this
* must have been the way they traveled. Describe the
* departure as being in that direction.
*
* Note that it's possible that more than one direction is
* linked to the same connector. In such cases, we'll just
* take the first link we find, because it's equally
* accurate to say that the actor went in any of the
* directions linked to the same connector.
*/
traveler.sayDepartingDir(dir, self);
}
else
{
/*
* We didn't find any direction out of the origin linking to
* this connector, so we don't know how what direction they
* went. Show the generic departure message.
*/
traveler.sayDeparting(self);
}
}
/*
* Describe an actor's arrival through the connector from the given
* origin into the given destination. This description is from the
* point of view of another actor in the destination.
*
* Note that this is called on the connector that reverses the
* travel, NOT on the connector the actor is actually traversing -
* that is, 'self' is the backwards connector, leading from the
* destination back to the origin location. So, if we have two
* sides to a door, and the actor traverses the first side, this
* will be called on the second side - the one that links the
* destination back to the origin.
*/
describeArrival(traveler, origin, dest)
{
local dir;
/*
* See if we can find a direction linked to this connector in
* the destination location. If so, describe the arrival using
* the direction; otherwise, describe it using a generic arrival
* message.
*
* Find the connector from the player character's perspective,
* because the description we're generating is for the player's
* benefit and thus should be from the PC's perspective.
*/
if ((dir = dest.directionForConnector(self, gPlayerChar)) != nil)
{
/*
* we found a direction linked to this back connector, so
* describe the arrival as coming from the direction we
* found
*/
traveler.sayArrivingDir(dir, self);
}
else
{
/*
* we didn't find any direction links, so use a generic
* arrival message
*/
traveler.sayArriving(self);
}
}
/*
* Describe a "local departure" via this connector. This is called
* when a traveler moves around entirely within the field of view of
* the player character, and move *further away* from the PC - that
* is, the traveler's destination is visible to the PC when we're
* leaving our origin, AND the origin's top-level location contains
* the PC. We'll describe the travel not in terms of truly
* departing, but simply in terms of moving away.
*/
describeLocalDeparture(traveler, origin, dest)
{
/* say that we're departing locally */
traveler.sayDepartingLocally(dest, self);
}
/*
* Describe a "local arrival" via this connector. This is called
* when the traveler moves around entirely within the field of view
* of the player character, and comes *closer* to the PC - that is,
* the traveler's origin is visible to the player character when we
* arrive in our destination, AND the destination's top-level
* location contains the PC. We'll describe the travel not in terms
* of truly arriving, since the traveler was already here to start
* with, but rather as entering the destination, but just in terms of
* moving closer.
*/
describeLocalArrival(traveler, origin, dest)
{
/* say that we're arriving locally */
traveler.sayArrivingLocally(dest, self);
}
/*
* Describe "remote travel" via this connector. This is called when
* the traveler moves around entirely within the field of view of the
* PC, but between two "remote" top-level locations - "remote" means
* "does not contain the PC." In this case, the traveler isn't
* arriving or departing, exactly; it's just moving laterally from
* one top-level location to another.
*/
describeRemoteTravel(traveler, origin, dest)
{
/* say that we're traveling laterally */
traveler.sayTravelingRemotely(dest, self);
}
/*
* Find a connector in the destination location that connects back as
* the source of travel from the given connector when traversed from
* the source location. Returns nil if there is no such connector.
* This must be called while the traveler is still in the source
* location; we'll attempt to find the connector back to the
* traveler's current location.
*
* The purpose of this routine is to identify the connector by which
* the traveler arrives in the new location. This can be used, for
* example, to generate a connector-specific message describing the
* traveler's emergence from the connector (so we can say one thing
* if the traveler arrives via a door, and another if the traveler
* arrives by climing up a ladder).
*
* By default, we'll try to find a travel link in the destination
* that links us back to this same connector, in which case we'll
* return 'self' as the connector from which the traveler emerges in
* the new location. Failing that, we'll look for a travel link
* whose apparent source is the origin location.
*
* This should be overridden for any connector with an explicit
* complementary connector. For example, it is common to implement a
* door using a pair of objects, one representing each side of the
* door; in such cases, each door object would simply return its twin
* here. Note that a complementary connector doesn't actually have
* to go anywhere, since it's still useful to have a connector back
* simply for describing travelers arriving on the connector.
*
* This *must* be overridden when the destination location doesn't
* have a simple connector whose apparent source is this connector,
* because in such cases we won't be able to find the reverse
* connector with our direction search.
*/
connectorBack(traveler, dest)
{
local origin;
/* if there's no destination, there's obviously no connector */
if (dest == nil)
return nil;
/*
* get the origin location - this the traveler's current
* immediate container
*/
origin = traveler.location;
/*
* First, try to find a link back to this same connector - this
* will handle simple symmetrical links with the same connector
* object shared between two rooms.
*
* We try to find the actual connector before looking for a
* connector back to the origin - it's possible that there are
* several ways back to the starting point, and we want to make
* sure we pick the one that was actually traversed if possible.
*/
foreach (local dir in Direction.allDirections)
{
/*
* If this direction link from the destination is linked back
* to this same connector, we have a symmetrical connection,
* so we're the connector back. Note that we're interested
* only in map structure here, so we don't pass an actor; the
* actor isn't actually in the new location, so what the
* actor can see is irrelevant to us here.
*/
if (dest.getTravelConnector(dir, nil) == self)
{
/* the same connector goes in both directions */
return self;
}
}
/*
* we didn't find a link back to the same connector, so try to
* find a link from the destination whose apparent source is the
* origin
*/
foreach (local dir in Direction.allDirections)
{
local conn;
/*
* if this link from the destination has an apparent source
* of our origin, the traveler appears to be arriving from
* this link
*/
if ((conn = dest.getTravelConnector(dir, nil)) != nil
&& conn.fixedSource(dest, traveler) == origin)
{
/*
* this direction has an apparent source of the origin
* room - it's not necessarily the same link they
* traversed, but at least it appears to come from the
* same place they came from, so it'll have to do
*/
return conn;
}
}
/* we couldn't find any link back to the origin */
return nil;
}
/*
* Get the "fixed" source for travelers emerging from this connector,
* if possible. This can return nil if the connector does not have a
* fixed relationship with another connector.
*
* The purpose of this routine is to find complementary connectors
* for simple static map connections. This is especially useful for
* direct room-to-room connections.
*
* When a connector relationship other than a simple static mapping
* exists, the connectors must generally override connectorBack(), in
* which case this routine will not be needed (at least, this routine
* won't be needed as long as the overridden connectorBack() doesn't
* call it). Whenever it is not clear how to implement this routine,
* don't - implement connectorBack() instead.
*/
fixedSource(dest, traveler)
{
/* by default, return nothing */
return nil;
}
/*
* Can the given actor see this connector in the dark, looking from
* the given origin? Returns true if so, nil if not.
*
* This is used to determine if the actor can travel from the given
* origin via this connector when the actor (in the origin location)
* is in darkness.
*
* By default, we implement the usual convention, which is that
* travel from a dark room is possible only when the destination is
* lit. If we can't determine our destination, we will assume that
* the connector is not visible.
*/
isConnectorVisibleInDark(origin, actor)
{
local dest;
/*
* Get my destination - if we can't determine our destination,
* then assume we're not visible.
*/
if ((dest = getDestination(origin, actor.getTraveler(self))) == nil)
return nil;
/*
* Check the ambient illumination level in the destination. If
* it's 2 or higher, then it's lit; otherwise, it's dark. If
* the destination is lit, consider the connector to be visible,
* on the theory that the connector lets a little bit of the
* light from the destination leak into the origin room - just
* enough to make the connection itself visible without making
* anything else in the origin room visible.
*/
return (dest.wouldBeLitFor(actor));
}
/*
* Handle travel in the dark. Specifically, this is called when an
* actor attempts travel from one dark location to another dark
* location. (We don't invoke this in any other case:
* light-to-light, light-to-dark, and dark-to-light travel are all
* allowed without any special checks.)
*
* By default, we will prohibit dark-to-dark travel by calling the
* location's darkTravel handler. Individual connectors can
* override this to allow such travel or apply different handling.
*/
darkTravel(actor, dest)
{
/*
* by default, simply call the actor's location's darkTravel
* handler
*/
actor.location.roomDarkTravel(actor);
}
/*
* Action handler for the internal "TravelVia" action. This is not a
* real action, but is instead a pseudo-action that we implement
* generically for travel via the connector. Subclasses that want to
* handle real actions by traveling via the connector can use
* remapTo(TravelVia) to implement the real action handlers. Note
* that remapTo should be used (rather than, say, asDobjFor), since
* this will ensure that every type of travel through the connector
* actually looks like a TravelVia action, which is useful for
* intercepting travel actions generically in other code.
*/
dobjFor(TravelVia)
{
preCond()
{
/*
* For our preconditions, use the traveler's preconditions,
* plus the location's preconditions, plus any special
* connector-specific preconditions we supply.
*/
return gActor.getTraveler(self).travelerPreCond(self)
+ gActor.location.roomTravelPreCond()
+ connectorTravelPreCond();
}
verify()
{
/*
* Verify travel for the current command's actor through this
* connector. This performs normal action verify processing.
*
* The main purpose of this routine is to allow the connector
* to flag obviously dangerous travel to allow a caller to
* avoid such travel as an implicit or scripted action. In
* most cases, there's no need to make travel illogical
* because there's generally no potential ambiguity involved
* in analyzing a travel verb.
*
* Note that this routine must check with the actor to
* determine if the actor or a vehicle will actually be
* performing the travel, by calling gActor.getTraveler(), if
* the routine cares about the difference.
*/
}
check()
{
local t = gActor.getTraveler(self);
local dest;
/*
* Check the travel.
*
* This routine should take into account the light levels at
* the source and destination locations, if travel between
* dark rooms is to be disallowed.
*/
/* get my destination */
dest = getDestination(t.location, t);
/* check dark-to-dark travel */
gActor.checkDarkTravel(dest, self);
/* enforce barriers */
checkTravelBarriers(dest);
}
action()
{
local t = gActor.getTraveler(self);
local dest;
/*
* Execute the travel, moving the command's actor through the
* travel connection: we carry out any side effects of the
* travel and deliver the actor (if appropriate) to the
* destination of the connector.
*
* Note that this routine must check with the actor to
* determine if the actor or a vehicle will actually be
* performing the travel, by calling gActor.getTraveler(), if
* the routine cares about the difference. In most cases,
* the routine won't care: most implementations of this
* routine will (if they effect any travel at all) eventually
* call gActor.travelTo() to carry out the travel, and that
* routine will always route the actual movement to the
* vehicle if necessary.
*/
/* get my destination */
dest = getDestination(t.location, t);
/* travel to my destination */
gActor.travelTo(dest, self, connectorBack(t, dest));
}
}
;
/*
* A "probe" object, for testing light levels in rooms. This is a dummy
* object that we use for what-if testing - it's not actually part of
* the simulation.
*/
lightProbe: Thing;
/*
* A TravelBarrier can be attached to a TravelConnector, via the
* travelBarrier property, to form a conditional barrier to travel.
*/
class TravelBarrier: object
/*
* Determine if this barrier blocks the given traveler. By default,
* we don't block anyone. This doesn't make us much of a barrier, so
* subclasses should override this with a more specific condition.
*/
canTravelerPass(traveler) { return true; }
/*
* Explain why travel isn't allowed. This should generate an
* appropriate failure report explaining the problem. This is
* invoked when travel is attempted and canTravelerPass returns nil.
* Subclasses must override this.
*/
explainTravelBarrier(traveler) { }
;
/*
* An "unlisted proxy" connector acts as a proxy for another connector.
* We act exactly like the underlying connector, except that we suppress
* the connector from automatic exit lists. This can be used for cases
* where an otherwise normal connector is needed but the connector is
* not to appear in automatic exit lists (such as the status line).
*
* The most common situation where this kind of connector is useful is
* where multiple directions in a given room all go to the same
* destination. In these cases, it's often desirable for some of the
* directions to be unlisted alternatives. The asExit() macro can be
* used for convenience to set up these direction synonyms.
*/
class UnlistedProxyConnector: object
construct(pri)
{
/* remember my underlying primary connector */
primaryConn = pri;
}
/*
* Our underlying connector. Start out with a default TadsObject
* rather than nil in case anyone wants to call a property or test
* inheritance before we're finished with our constructor - this will
* produce reasonable default behavior without having to test for nil
* everywhere.
*/
primaryConn = TadsObject
/* we're not listed */
isConnectorListed = nil
/* map any TravelVia action to our underlying connector */
dobjFor(TravelVia) remapTo(TravelVia, primaryConn)
/* redirect everything we don't handle to the underlying connector */
propNotDefined(prop, [args]) { return primaryConn.(prop)(args...); }
/*
* As a proxy, we don't want to disguise the fact that we're a proxy,
* if someone specifically asks, so admist to being of our own true
* kind; but we also act mostly like our underlying connector, so if
* someone wants to know if we're one of those, say yes to that as
* well. So, return true if the inherited version returns true, and
* also return true if our primary connector would return true.
*/
ofKind(cls) { return inherited(cls) || primaryConn.ofKind(cls); }
;
/*
* A travel connector that doesn't allow any travel - if travel is
* attempted, we simply use the origin's cannotTravel method to display
* an appropriate message.
*/
noTravel: TravelConnector
/* it is obvious that is no passage this way */
isConnectorApparent(origin, actor) { return nil; }
/* this is not a passable connector */
isConnectorPassable(origin, traveler) { return nil; }
dobjFor(TravelVia)
{
/*
* we know that no travel will occur, so we don't need to satisfy
* any preconditions
*/
preCond = []
action()
{
/* we can't go this way - use the origin's default message */
gActor.location.cannotTravel();
}
}
;
/*
* An "ask which" travel connector. Rather than just traversing a
* connector, we ask for a direct object for a specified travel verb; if
* the player supplies the missing indirect object (or if the parser can
* automatically choose a default), we'll perform the travel verb using
* that direct object.
*
* This type of connector has two uses.
*
* First, the library various instances, with appropriate specified
* travel verbs, as the default connector for certain directions that
* frequently end up mapping to in-scenario objects. Specifically,
* noTravelIn, noTravelDown, and noTravelOut are used as the default in,
* down, and out connectors. If the player types DOWN, for example, and
* there's no override for 'down' in a given room, then we'll invoke
* noTravelDown; this will in turn ask for a missing direct object for
* the GetOffOf action, since DOWN can mean getting off of a platform or
* other nested room when on such a thing. When there's an obvious
* thing to get down from, the parser will provide the default
* automatically, which will make DOWN into a simple synonym for GET OFF
* OF <whatever>.
*
* Second, games can use this kind of connector for a given direction
* when the direction is ambiguous. For example, you can use this as
* the 'north' connector when there are two doors leading north from the
* location. When the player types NORTH, the parser will ask which
* door the player wants to go through.
*/
class AskConnector: TravelConnector, ResolveAsker
/*
* The specific travel action to attempt. This must be a TAction -
* an action that takes a direct object (and only a direct object).
* The default is TravelVia, but this should usually be customized
* in each instance to the type of travel appropriate for the
* possible connectors.
*/
travelAction = TravelViaAction
/*
* The list of possible direct objects for the travel action. If
* this is nil, we'll simply treat the direct object of the
* travelAction as completely missing, forcing the parser to either
* find a default or ask the player for the missing object. If the
* travel is limited to a specific set of objects (for example, if
* there are two doors leading north, and we want to ask which one
* to use), this should be set to the list of possible objects; the
* parser will then use the ambiguous noun phrase rules instead of
* the missing noun phrase rules to ask the player for more
* information.
*/
travelObjs = nil
/*
* The phrase to use in the disambiguation question to ask which of
* the travelObjs entries is to be used. The language-specific
* module provides a suitable default, but this should usually be
* overridden if travelObjs is overridden.
*/
travelObjsPhrase = nil
/*
* An extra prompt message to show before the normal parser prompt
* for a missing or ambiguous object. We'll show this just before
* the normal parser message, if it's specified.
*
* If you want to customize the messages more completely, you can
* override askDisambig() or askMissingObject(). The parser will
* invoke these to generate the prompt, so you can customize the
* entire messages by overriding these.
*/
promptMessage = nil
/*
* For each of the ResolveAsker methods that might be invoked, add
* the promptMessage text before the normal parser question.
*/
askDisambig(targetActor, promptTxt, curMatchList, fullMatchList,
requiredNum, askingAgain, dist)
{
promptMessage;
inherited(targetActor, promptTxt, curMatchList, fullMatchList,
requiredNum, askingAgain, dist);
}
askMissingObject(targetActor, action, which)
{
promptMessage;
inherited(targetActor, action, which);
}
/* handle travel via this connector */
dobjFor(TravelVia)
{
/*
* No preconditions or checks are necessary, since we don't
* actually perform any travel on our own; we simply recast the
* command as a new action, hence we want to delegate the
* preconditions and check() handling to the replacement action.
* Note that this means that you can't put a travel barrier
* directly on an AskConnector - you have to put any barriers on
* the underlying real connectors instead.
*/
preCond = []
check() { }
/*
* Recast the travel into our specified action, asking for the
* direct object we need for that action.
*/
action()
{
/*
* if we have a set of possible direct objects, retry this
* with the ambiguous object set; otherwise, retry with a
* completely missing direct object
*/
if (travelObjs != nil)
travelAction.retryWithAmbiguousDobj(
gAction, travelObjs, self, travelObjsPhrase);
else
travelAction.retryWithMissingDobj(gAction, self);
}
}
/*
* Get a connector leading to the given destination. We'll scan our
* travel objects; for each one that's a TravelConnector, we'll ask
* it to find the connector, and return the result if we get one.
*/
connectorGetConnectorTo(origin, traveler, dest)
{
/* if we have no travel objects, there's nothing to check */
if (travelObjs == nil)
return nil;
/* scan our secondary connectors */
foreach (local cur in travelObjs)
{
/* if this is a travel connector, ask it what it thinks */
if (cur.ofKind(TravelConnector))
{
local conn;
/*
* if this secondary connector can give us a connector to
* the destination, use that connector
*/
conn = cur.connectorGetConnectorTo(origin, traveler, dest);
if (conn != nil)
return conn;
}
}
/* didn't find a match */
return nil;
}
;
/*
* A "default ask connector" is an AskConnector that we use for certain
* directions (down, in, out) as the library default connector for the
* directions.
*/
class DefaultAskConnector: AskConnector
/*
* since this is a default connector for all locations, indicate that
* no travel is apparently possible in this direction
*/
isConnectorApparent(origin, actor) { return nil; }
/* this is not a passable connector */
isConnectorPassable(origin, traveler) { return nil; }
;
/*
* A default travel connector for going in. When travel in the relative
* direction "in" isn't allowed, we'll try recasting the command as an
* "enter" command with an unknown direct object.
*/
noTravelIn: DefaultAskConnector
/* when we go 'in', we'll try to ENTER something */
travelAction = EnterAction
;
/*
* A default travel connector for going out. When travel in the
* relative direction "out" isn't allowed, we'll try recasting the
* command as an "get out of" command with an unknown direct object.
*/
noTravelOut: DefaultAskConnector
/* when we go 'out', we'll try to GET OUT OF something */
travelAction = GetOutOfAction
;
/*
* A default travel connector for going out from a nested room. This
* works the same way as noTravelOut, except that we'll show OUT as a
* listed exit.
*/
nestedRoomOut: noTravelOut
isConnectorApparent(origin, actor) { return true; }
;
/*
* A special travel connector for 'down' that recasts the command as a
* "get off of" command. This can be used for platforms and the like,
* where a 'down' command should usually be taken to mean "get off
* platform" rather than "down from enclosing room".
*/
noTravelDown: DefaultAskConnector
/* when we go 'down', we'll try to GET OFF OF something */
travelAction = GetOffOfAction
;
/*
* A travel connector for going in that explicitly redirects the command
* to "enter" and asks for the missing direct object. This behaves the
* same way as noTravelIn, but explicitly makes the inward travel
* apparent; this can be used to override the noTravelIn default for
* locations where travel in is explicitly allowed.
*/
askTravelIn: AskConnector
travelAction = EnterAction
;
/* explicitly redirect travel out to "get out of" */
askTravelOut: AskConnector
travelAction = GetOutOfAction
;
/* explicitly redirect travel down to "get off of" */
askTravelDown: AskConnector
travelAction = GetOffOfAction
;
/*
* "No Shipboard Directions" travel connector. This is used as the
* default connector for the shipboard directions for the base Room
* class. This connector displays a special message indicating that the
* room is not a boat hence the shipboard directions don't work here.
*/
noShipTravel: noTravel
dobjFor(TravelVia)
{
action()
{
/* simply indicate that this direction isn't applicable here */
gLibMessages.notOnboardShip();
}
}
;
/* ------------------------------------------------------------------------ */
/*
* A mix-in class that can be added to objects that also inherit from
* TravelConnector to add a message as the connector is traversed.
*
* Note that this isn't itself a travel connector; it's just a class
* that should be combined with TravelConnector or one of its
* subclasses. This class should be in the superclass list before the
* TravelConnector-derived superclass.
*/
class TravelWithMessage: object
/*
* My message to display when the player character traverses the
* connector. This should be overridden with the custom message for
* the connector. By default, if we're a Script, we'll invoke the
* script to show the next message.
*/
travelDesc()
{
if (ofKind(Script))
doScript();
}
/*
* My message to display when any non-player character traverses the
* connector. If this is not overridden, no message will be
* displayed when an NPC travels through the connector.
*/
npcTravelDesc = ""
/*
* Display my message. By default, we show one message for the
* player character and another message for NPC's.
*/
showTravelDesc()
{
if (gActor.isPlayerChar())
travelDesc;
else
npcTravelDesc;
}
/* on traversing the connector, show our message */
noteTraversal(traveler)
{
/* display my message */
showTravelDesc();
/* inherit any other superclass handling as well */
inherited(traveler);
}
;
/*
* A simple connector that displays a message when the connector is
* traversed.
*/
class TravelMessage: TravelWithMessage, TravelConnector
/* my destination location */
destination = nil
/* get my destination */
getDestination(origin, traveler) { return destination; }
/* our source is the same as our destination */
fixedSource(dest, traveler) { return destination; }
;
/*
* A travel connector that can't be traversed, and which shows a custom
* failure message when traversal is attempted. Instances should define
* travelDesc to the message to display when travel is attempted.
*
* Travel is not apparently possible in this direction, so this type of
* connector will not show up in automatic exit lists or maps. This
* class is designed for connections that are essentially the same as no
* connection at all, but where it's desirable to use a special message
* to describe why travel can't be accomplished.
*/
class NoTravelMessage: TravelMessage
dobjFor(TravelVia)
{
/* as in noTravel, we need no preconditions or checks */
preCond = []
action()
{
/* simply show my message - that's all we do */
showTravelDesc();
}
}
/*
* Because no travel is possible, we want a non-empty message for
* NPC's as well as for the PC; by default, use the same message for
* all actors by using travelDesc for NPC's.
*/
npcTravelDesc = (travelDesc)
/* travel is not apparently possible in this direction */
isConnectorApparent(origin, actor) { return nil; }
isConnectorPassable(origin, traveler) { return nil; }
;
/*
* A "fake" connector. This is a connector that doesn't actually allow
* travel, but acts like it *could*. We simply show a special message
* when travel is attempted, but we don't move the actor.
*
* This is a subclass of NoTravelMessage, so instances should customize
* travelDes with the special failure message when travel is attempted.
*
* Note that this type of connector is by default *apparently* an exit,
* even though it doesn't actually go anywhere. This is useful for "soft
* boundaries," where the game's map is meant to appear to the player to
* continue but beyond which no more locations actually exist in the map.
* This is an oft-used device meant to create an illusion that the game's
* map exists in a larger world even though the larger world is not
* modeled. The message we display should in such cases attribute the
* actor's inability to traverse the connector to a suitable constraint
* within the context of the game world; for example, the actor could be
* said to be unwilling to go beyond this point because the actor knows
* or suspects there's nothing for a long way in this direction, or
* because the actor's goals require staying within the modeled map, or
* because the actor is afraid of what lies beyond.
*
* Note that FakeConnector should only be used when the reason for
* blocking the travel is apparent before we even try travel. In
* particular, FakeConnector is good for motivational reasons not to
* travel, where the actor decides for reasons of its own not to even
* attempt the travel. It's especially important not to use
* FakeConnector in cases where the travel is described as attempted but
* aborted halfway in - things like encountering a blocked tunnel. This
* is important because FakeConnector aborts the travel immediately,
* before sending out any of the notifications that would accompany
* ordinary travel, which means that physical barriers (trolls blocking
* the way, being tied to a chair) that would otherwise block ordinary
* travel will be bypassed. For cases where travel is attempted, but
* something turns you back halfway in, use DeadEndConnector.
*/
class FakeConnector: NoTravelMessage
/*
* travel is *apparently* possible in this direction (even though
* it's not *actually* possible)
*/
isConnectorApparent(origin, actor) { return true; }
isConnectorPassable(origin, traveler) { return nil; }
;
/* ------------------------------------------------------------------------ */
/*
* A Dead End Connector is a connector that appears to lead somewhere,
* but which turns out to be impassable for reasons that aren't apparent
* until we get some distance into the passage.
*
* The Dead End Connector might look a lot like the Fake Connector, but
* there's an important difference. A Fake Connector is a connector that
* can't even be physically attempted: the reason not to take a fake
* connector is something that shows up before we even start moving,
* usually a motivational reason ("You really can't leave town until you
* find your missing brother"). A Dead End Connector, on the other hand,
* is meant to model a physical attempt to travel that's blocked by some
* problem halfway along, such as travel down a tunnel that turns out to
* have caved in.
*/
class DeadEndConnector: TravelMessage
/*
* The apparent destination name. If the actor is meant to know the
* apparent destination from the outset, or if traversing the
* connector gives the actor an idea of where the connector
* supposedly goes, this can be used to give the name of that
* destination. This name will show up in exit listings, for
* example, once the PC knows where the connector supposedly goes.
*
* Note that this isn't the actual destination of the connector,
* since the actual destination is simply back to the origin (that's
* the whole point of the dead end, after all). This is simply where
* the connector *appears* to go. If an attempted traversal doesn't
* even reveal that much, then you should just leave this nil, since
* the destination will never become apparent to the PC.
*/
apparentDestName = nil
/*
* Our apparent destination. By default, we create a FakeDestination
* object to represent our apparent destination if we have a non-nil
* name for the apparent destination.
*
* If the supposed-but-unreachable destination of the connector is in
* fact a real location in the game, you can override this to point
* directly to that actual location. This default is for the typical
* case where the supposed destination doesn't actually exist on the
* game map as a real room.
*/
apparentDest()
{
/*
* if we have an apparent destination name, create a
* FakeDestination to represent the apparent destination, and
* plug that in as our apparent destination for future reference
*/
if (apparentDestName != nil)
{
local fake;
/* create a fake destination */
fake = new FakeDestination(self);
/* plug it in as our new apparentDest for future calls */
apparentDest = fake;
/* return the new object as the result */
return fake;
}
/* our apparent destination is unknown */
return nil;
}
/* get our apparent destination */
getApparentDestination(origin, actor)
{
/*
* If the actor knows the destination for the given connector (as
* determined by the origin room), or we have a memory of this
* traversal, return our fake destination object to represent the
* destination. We can only return our fake destination if we
* have an explicit apparent destination, since it's only in this
* case that our apparent destination ever actually becomes
* known, even after an attempted traversal.
*
* Our actual destination is always just the origin, but we
* *appear* to have some other destination. Even though we can
* never actually reach that other, apparent destination, we at
* least want to give the appearance of going there, which we
* provide through our fake destination object.
*/
if (apparentDest != nil
&& (origin.actorKnowsDestination(actor, self)
|| travelMemory[[actor, origin, self]] != nil))
return apparentDest;
/* our unreachable destination is not apparent */
return nil;
}
/* there's no corresponding connector back for a dead end */
connectorBack(traveler, dest) { return nil; }
/* our actual destination is always our origin */
getDestination(origin, traveler) { return origin; }
/* do remember circular trips, since that's the only kind we make */
rememberCircularPassage = true
;
/*
* A fake apparent destination, for dead-end connectors. The dead-end
* connector will create an object of this class to represent its
* apparent but actually unreachable destination, if it has an apparent
* destination name.
*/
class FakeDestination: object
/* construct - remember our associated connector */
construct(conn) { connector = conn; }
/* get our destination name - this is the name from our connector */
getDestName(actor, origin) { return connector.apparentDestName; }
/* our underlying connector (usually a DeadEndConnector) */
connector = nil
;
/* ------------------------------------------------------------------------ */
/*
* A direct room-to-room connector. In most cases, it is not necessary
* to create one of these objects, because rooms can serve as their own
* connectors. These objects are needed in certain cases, though, such
* as when a room-to-room connection requires a travel barrier.
*/
class RoomConnector: TravelConnector
/* the two rooms we link */
room1 = nil
room2 = nil
/*
* get the destination, given the origin: this is the one of the two
* rooms we link that we're not in now
*/
getDestination(origin, traveler)
{
if (origin == room1)
return room2;
else if (origin == room2)
return room1;
else
return nil;
}
fixedSource(origin, traveler)
{
/*
* we're a symmetrical two-way connector, so our source from the
* perspective of one room is the same as the destination from
* that same perspective
*/
return getDestination(origin, traveler);
}
/*
* Get the precondition for this connector. The normal
* TravelConnector rule that the traveler must be in the outbound
* connector's location is not meaningful for an abstract room
* connector, because this type of connection itself isn't
* represented as a physical game object with a location; it's just
* an abstract data structure. This means that we must have a
* directional property in the *source* location that points directly
* to the destination (i.e., self).
*
* So, the appropriate starting point for room connectors is the
* object that contains the connection. In other words, we must
* search for the nearest object enclosing the *traveler* that has a
* direction property directly linked to 'self'; that enclosing
* container is the required starting location for the travel.
*/
connectorTravelPreCond()
{
/*
* Scan upwards from the traveler's location, looking for an
* object that has a directional property linked to self. Only
* scan into locations that the actor can see.
*/
for (local loc = gActor.getTraveler(self).location ;
loc != nil && gActor.canSee(loc) ; loc = loc.location)
{
/* look for a directional connector directly from 'loc' to us */
if (loc.localDirectionLinkForConnector(self) != nil)
{
/*
* we're linked from this enclosing location, so this is
* where we have to be before travel
*/
return [new TravelerDirectlyInRoom(gActor, self, loc)];
}
}
/* we couldn't find a link, so apply no condition */
return [];
}
;
/*
* A one-way room connector. This works like an ordinary room
* connector, but connects only in one direction. To use this class,
* simply define the 'destination' property to point to the room we
* connect to.
*/
class OneWayRoomConnector: RoomConnector
/* my destination - instances must define this */
destination = nil
/* we always have a fixed destination */
getDestination(origin, traveler) { return destination; }
;
/*
* A room "auto-connector". This is a special subclass of RoomConnector
* that can be mixed in to any BasicLocation subclass to make the room
* usable as the direct target of a directional property in another room
* - so you could say "east = myRoom", for example, without creating any
* intermediate connector.
*/
class RoomAutoConnector: RoomConnector
/*
* Suppose that roomA.north = roomB. This means that if an actor is
* in roomA, and executes a "north" command, we'll execute a
* TravelVia action on room B, because the "connector" will be
* roomB. In these cases, the destination of the travel and the
* travel connector are one and the same. So, when the connector is
* roomB, the destination of travel is also simply roomB.
*/
getDestination(origin, traveler)
{
/* we are our own destination */
return self;
}
;
/* ------------------------------------------------------------------------ */
/*
* Base class for passages between rooms. This can be used for a
* passage that not only connects the rooms but also exists as an object
* in its own right within the rooms it connects.
*
* In most cases, two passage objects will exist - one on each side of
* the passage, so one object in each room connected. One of the
* objects should be designated as the "master"; the other is the
* "slave." The master object is the one which should implement all
* special behavior involving state changes (such as opening or closing
* a door).
*
* This basic passage is not designed to be opened and closed; use Door
* for a passage that can be opened and closed.
*/
class Passage: Linkable, Fixture, TravelConnector
/*
* Our destination - this is where the actor ends up when traveling
* through the passage (assuming the passage is open). By default,
* we return the "room location" of our other side's container; in
* cases where our other side is not directly in our destination
* room (for example, the other side is part of some larger object
* structure), this property should be overridden to specify the
* actual destination.
*
* If our otherSide is nil, the passage doesn't go anywhere. This
* can be useful to create things that look and act like passages,
* but which don't actually go anywhere - in other words,
* passage-like decorations.
*/
destination = (otherSide != nil ? otherSide.location.roomLocation : nil)
/* get my destination - just return my 'destination' property */
getDestination(origin, traveler) { return destination; }
/* get our open/closed status */
isOpen()
{
/*
* if we have a separate master object, defer to it; otherwise,
* use our own status
*/
return (masterObject == self ? isOpen_ : masterObject.isOpen);
}
/* internal open/closed status - open by default */
isOpen_ = true
/*
* We're not visible in the dark if we're closed. If we're open,
* the normal rules apply.
*
* Normally, a passage is visible in the dark if there's light in
* the adjoining location: our model is that enough light is leaking
* in through the passage to make the passage itself visible, but
* not enough to light anything else in the current room. In the
* case of a closed passage, though, we assume that it completely
* blocks any light from the other room, eliminating any indication
* of a passage.
*
* If you do want an openable passage to be visible in the dark even
* when it's closed, it's probably better to make the passage
* self-illuminating (i.e., with brightness 1), because this will
* put the passage in scope and thus allow it to be manipulated.
*/
isConnectorVisibleInDark(origin, actor)
{ return isOpen() && inherited(origin, actor); }
/* a passage is passable when it's open */
isConnectorPassable(origin, traveler) { return isOpen(); }
/*
* Initialize. If we're a slave, we'll set up the otherSide
* relationship between this passage and our master passage.
*/
initializeThing()
{
/* inherit default handling */
inherited();
/*
* if we have a master side, initialize our relationship with
* the master side
*/
if (masterObject != self)
{
/* set our otherSide to point to the master */
otherSide = masterObject;
/* set the master's otherSide to point to us */
masterObject.initMasterObject(self);
}
}
/*
* Initialize the master object. The other side of a two-sided door
* will call this on the master object to let the master object know
* about the other side. 'other' is the other-side object. By
* default, we'll simply remember the other object in our own
* 'otherSide' property.
*/
initMasterObject(other) { otherSide = other; }
/*
* Our corresponding passage object on the other side of the
* passage. This will be set automatically during initialization
* based on the masterObject property of the slave - it is not
* generally necessary to set this manually.
*/
otherSide = nil
/* our other side is the other facet of the passage */
getFacets() { return otherSide != nil ? [otherSide] : inherited(); }
/*
* our source is always our destination, since we have a one-to-one
* relationship with our comlementary passage in the destination
* location (we point to it, it points to us)
*/
fixedSource(origin, traveler) { return destination; }
/* the connector back is our complementary side, if we have one */
connectorBack(traveler, dest)
{
/* if we have a complementary side, it's the connector back */
if (otherSide != nil)
return otherSide;
/* we don't have a complementary side, so use the default handling */
return inherited(traveler, dest);
}
/* can the given actor travel through this passage? */
canActorTravel(actor)
{
/*
* by default, the actor can travel through the passage if and
* only if the passage is open
*/
return isOpen;
}
/*
* Display our message when we don't allow the actor to travel
* through the passage because the passage is closed. By default,
* we'll simply display the default cannotTravel message for the
* actor's location, but this can be overridden to provide a more
* specific report of the problem.
*/
cannotTravel()
{
/* use the actor's location's cannotTravel handling */
gActor.location.cannotTravel();
}
/* carry out travel via this connector */
dobjFor(TravelVia)
{
/* check travel */
check()
{
/*
* Move the actor only if we're open; if we're not, use the
* standard no-travel handling for the actor's location.
* Note that we don't try to implicitly open the passage,
* because the basic passage is not openable; if we're
* closed, it means we're impassable for some reason that
* presumably cannot be remedied by a simple "open" command.
*/
if (!canActorTravel(gActor))
{
/* we're closed, so use our no-travel handling */
cannotTravel();
exit;
}
else
{
/* inherit the default checks */
inherited();
}
}
}
dobjFor(LookThrough)
{
action()
{
/*
* if we're open, we simply "can't see much from here";
* otherwise, we can't see through it at all
*/
if (isOpen)
mainReport(¬hingThroughPassageMsg);
else
inherited();
}
}
;
/*
* A passage that an actor can travel through (with a "go through" or
* "enter" command). A "go through" command applied to the passage
* simply makes the actor travel through the passage as though using the
* appropriate directional command.
*
* We describe actors arriving or departing via the passage using
* "through" descriptions ("Bob arrives through the door," etc).
*/
class ThroughPassage: Passage
describeDeparture(traveler, origin, dest)
{
/* describe the traveler departing through this passage */
traveler.sayDepartingThroughPassage(self);
}
describeArrival(traveler, origin, dest)
{
/* describe the traveler arriving through this passage */
traveler.sayArrivingThroughPassage(self);
}
/* treat "go through self" as travel through the passage */
dobjFor(GoThrough) remapTo(TravelVia, self)
/* "enter" is the same as "go through" for this type of passage */
dobjFor(Enter) asDobjFor(GoThrough)
/*
* Explicitly map the indirect object 'verify' handlers for the
* push-travel commands corresponding to the regular travel commands
* we provide. This isn't strictly necessary except when we're mixed
* in to something like a Decoration, in which case explicitly
* defining the mapping here is important because it will give the
* mapping higher precedence than a catch-all handlers overriding the
* same mapping we inherit from Thing. We use the same mapping that
* Thing provides by default.
*/
mapPushTravelIobj(PushTravelThrough, TravelVia)
mapPushTravelIobj(PushTravelEnter, TravelVia)
;
/*
* A Path Passage is a specialization of through passage that's more
* suitable for outdoor locations. This type of passage is good for
* things like outdoor walkways, paths, and streets, where travelers walk
* along the connector but aren't enclosed by it. The main practical
* difference is how we describe departures and arrivals; in English, we
* describe these as being "via" the path rather than "through" the path,
* since there's no enclosure involved in these connections.
*/
class PathPassage: ThroughPassage
describeDeparture(traveler, origin, dest)
{
traveler.sayDepartingViaPath(self);
}
describeArrival(traveler, origin, dest)
{
/* describe the traveler arriving through this passage */
traveler.sayArrivingViaPath(self);
}
/* putting something on a path is the same as dropping it */
iobjFor(PutOn) remapTo(Drop, DirectObject)
/* use a special message for standing on a path */
cannotStandOnMsg = &cannotStandOnPathMsg
/* FOLLOW PATH -> travel via the path */
dobjFor(Follow) remapTo(TravelVia, DirectObject)
;
/* ------------------------------------------------------------------------ */
/*
* The exit portal of a one-way passage. This isn't a fully functional
* passage, but rather an object that acts as the receiving end of a
* passage that can only be traversed in one direction.
*
* This can be used for various purposes: the underside of a trap door,
* the bottom of a chute, the exit of a wormhole.
*/
class ExitOnlyPassage: ThroughPassage
dobjFor(TravelVia)
{
action()
{
/*
* Show our default failure message. This can be overridden
* to provide a more customized description of why the
* passage cannot be entered from this side.
*/
reportFailure(&cannotEnterExitOnlyMsg, self);
}
}
;
/* ------------------------------------------------------------------------ */
/*
* Stairway - this is a special kind of passage that is used for
* vertical connections, such as stairways and ladders. This type of
* passage doesn't allow "enter" or "go through," but does allow "climb".
*
* The basic Stairway should generally not be used, as it doesn't know
* where it is relative to connected stairs. Instead, the more specific
* StairwayUp and StairwayDown should be used in most cases.
*
* Note that at midpoints along long stairways (landings, for example),
* separate stairway objects should normally be used: one going up and
* one going down.
*/
class Stairway: Passage
/*
* Treat "climb self" as travel through the passage
*/
dobjFor(Climb) remapTo(TravelVia, self)
;
/*
* A stairway going up from here.
*/
class StairwayUp: Stairway
describeArrival(traveler, origin, dest)
{
/*
* describe the actor arriving by coming down these stairs (they
* leave up, so they arrive down)
*/
traveler.sayArrivingDownStairs(self);
}
describeDeparture(traveler, origin, dest)
{
/* describe the actor leaving up these stairs */
traveler.sayDepartingUpStairs(self);
}
/* "climb up" is the specific direction for "climb" here */
dobjFor(ClimbUp) asDobjFor(Climb)
/* cannot climb down from here */
dobjFor(ClimbDown)
{
verify() { illogical(&stairwayNotDownMsg); }
}
;
/*
* A stairway going down from here.
*/
class StairwayDown: Stairway
/* "climb down" is the specific direction for "climb" here */
dobjFor(ClimbDown) asDobjFor(Climb)
describeArrival(traveler, origin, dest)
{
/*
* describe the actor arriving by coming up these stairs (they
* leave down, so they arrive up)
*/
traveler.sayArrivingUpStairs(self);
}
describeDeparture(traveler, origin, dest)
{
/* describe the actor traveling down these stairs */
traveler.sayDepartingDownStairs(self);
}
/* cannot climb up from here */
dobjFor(ClimbUp)
{
verify() { illogical(&stairwayNotUpMsg); }
}
;
/* ------------------------------------------------------------------------ */
/*
* Basic Door class. This is the base class for door-like objects: a
* travel connector with two sides, and which can be opened and closed.
* Each side of the door is linked to the other, so that opening or
* closing one side makes the same change to the other side.
*
* A basic door has the internal functionality of a door, but doesn't
* provide handling for player commands that manipulate the open/closed
* status.
*/
class BasicDoor: BasicOpenable, ThroughPassage
/*
* Open/close the door. If we have a complementary door object
* representing the other side, we'll remark in the sensory context
* of its location that it's also opening or closing.
*/
makeOpen(stat)
{
/* inherit the default behavior */
inherited(stat);
/*
* if our new status is in effect, notify the other side so that
* it can generate a message in its location
*/
if (isOpen == stat && otherSide != nil)
otherSide.noteRemoteOpen(stat);
}
/*
* Note a "remote" change to our open/close status. This is an
* open/close operation performed on our complementary object
* representing the other side of the door. We'll remark on the
* change in the sensory context of this side, but only if we're
* suppressing output in the current context - if we're not, then
* the player will see the message generated by the side that we
* directly acted upon, so we don't need a separate report for the
* other side.
*/
noteRemoteOpen(stat)
{
/*
* If I'm not visible to the player character in the current
* sense context, where the action is actually taking place,
* switch to my own sensory context and display a report. This
* way, if the player can see this door but not the other side,
* and the action is taking place on the other side, we'll still
* see a note about the change. We only need to do this if
* we're not already visible to the player, because if we are,
* we'll generate an ordinary report of the door opening in the
* action's context.
*/
if (senseContext.isBlocking)
{
/* show a message in my own sensory context */
callWithSenseContext(self, sight, {: describeRemoteOpen(stat) });
}
}
/*
* Describe the door being opened remotely (that is, by someone on
* the other side). This is called from noteRemoteOpen to actually
* display the message.
*/
describeRemoteOpen(stat)
{
/* show the default library message for opening the door remotely */
gLibMessages.sayOpenDoorRemotely(self, stat);
}
/* carry out travel through the door */
dobjFor(TravelVia)
{
action()
{
/* move the actor to our destination */
inherited();
/* remember that this is the last door the actor traversed */
gActor.rememberLastDoor(self);
}
}
/*
* Boost the likelihood that a command is referring to us if we just
* traveled through the door; this is meant to be called from
* verify() routines. For a few commands (close, lock), the most
* likely door being referred to is the door just traversed.
*/
boostLikelihoodOnTravel()
{
/*
* if this (or our other side) is the last door the actor
* traversed, boost the likelihood that they're referring to us
*/
if (gActor.lastDoorTraversed == self
|| (otherSide != nil && gActor.lastDoorTraversed == otherSide))
logicalRank(120, 'last door traversed');
}
;
/* ------------------------------------------------------------------------ */
/*
* Door. This is a travel connector that can be opened and closed with
* player commands. This is a simple subclass of BasicDoor that adds
* support for player commands to manipulate the door.
*/
class Door: Openable, BasicDoor
/* make us initially closed */
initiallyOpen = nil
/* if we can't travel because the door is closed, say so */
cannotTravel()
{
if (gActor.canSee(self) && !isOpen)
reportFailure(&cannotGoThroughClosedDoorMsg, self);
else
inherited();
}
/*
* get the 'door open' precondition - by default, we create a
* standard doorOpen precondition for this object, but this can be
* overridden if desired to create custom doorOpen variations
*/
getDoorOpenPreCond() { return new ObjectPreCondition(self, doorOpen); }
/* the door must be open before we can travel this way */
connectorTravelPreCond()
{
local ret;
local doorCond;
/* start with the inherited conditions */
ret = inherited();
/* if there's a door-open condition, add it as well */
if ((doorCond = getDoorOpenPreCond()) != nil)
ret += doorCond;
/* return the result */
return ret;
}
dobjFor(Close)
{
verify()
{
/* inherit default handling */
inherited();
/* boost the likelihood if they just traveled through us */
boostLikelihoodOnTravel();
}
}
dobjFor(Lock)
{
verify()
{
/* inherit default handling */
inherited();
/* boost the likelihood if they just traveled through us */
boostLikelihoodOnTravel();
}
}
/*
* looking behind a door implies opening it to see what's on the
* other side
*/
dobjFor(LookBehind)
{
preCond = (inherited + objOpen)
action()
{
/*
* If the door is open, AND we implicitly opened the door to
* carry out this action, use a special report that takes
* into account that we were specifically looking to see what
* was on the other side of the door; otherwise, use the
* default behavior
*/
if (isOpen
&& gTranscript.currentActionHasReport(
{x: (x.action_.ofKind(OpenAction)
&& x.isActionImplicit())}))
mainReport(¬hingBeyondDoorMsg);
else
inherited();
}
}
/* looking through a door requires it to be open */
dobjFor(LookThrough)
{
preCond = (nilToList(inherited) + objOpen)
}
;
/* ------------------------------------------------------------------------ */
/*
* Secret Door. This is a special kind of door that gives no hint of
* its being a door when it's closed. This can be used for objects that
* serve as a secret passage but are otherwise normal objects, such as a
* bookcase that conceals a passage.
*/
class SecretDoor: BasicDoor
/* a secret passage usually starts off secret (i.e., closed) */
initiallyOpen = nil
isConnectorApparent(origin, actor)
{
/*
* A secret passage is not apparent as a pasage unless it's
* open.
*/
if (isOpen)
{
/* the passage is open - use the inherited handling */
return inherited(origin, actor);
}
else
{
/*
* the passage is closed, so it's not apparently a passage
* at all
*/
return nil;
}
}
;
/*
* Hidden Door. This is a secret door that is invisible when closed.
* This can be used when the passage isn't even visible when it's
* closed, such as a door that seamlessly melds into the wall.
*/
class HiddenDoor: SecretDoor
/*
* When we're closed, we're completely invisible, so we have no
* sight presence. When we're open, we have our normal visual
* presence.
*/
sightPresence = (isOpen)
;
/* ------------------------------------------------------------------------ */
/*
* Automatically closing door. This type of door closes behind an actor
* as the actor traverses the connector.
*/
class AutoClosingDoor: Door
dobjFor(TravelVia)
{
action()
{
/* inherit the default handling */
inherited();
/*
* Only close the door if the actor performing the travel
* isn't accompanying another actor. If the actor is
* accompanying someone, we essentially want them to hold the
* door for the other actor - at the very least, we don't
* want to slam it in the other actor's face!
*/
if (!gActor.curState.ofKind(AccompanyingInTravelState))
{
/* close the door */
makeOpen(nil);
/* mention that the automatic closing */
reportAutoClose();
}
}
}
/*
* Report the automatic closure. The TravelVia action() calls this
* after closing the door to generate a message mentioning that the
* door was closed. By default, we just show the standard
* doorClosesBehindMsg library message.
*/
reportAutoClose() { mainReport(&doorClosesBehindMsg, self); }
;
/* ------------------------------------------------------------------------ */
/*
* The base class for Enterables and Exitables. These are physical
* objects associated with travel connectors. For example, the object
* representing the exterior of a building in the location containing
* the building could be an Enterable, so that typing ENTER BUILDING
* takes us into the building via the travel connector that leads inside.
*
* Enterables and Exitables are physical covers for travel connectors.
* These objects aren't travel connectors themselves, and they don't
* specify the destination; instead, these just point to travel
* connectors.
*/
class TravelConnectorLink: object
/* the underlying travel connector */
connector = nil
/*
* The internal "TravelVia" action just maps to travel via the
* underlying connector. However, we want to apply our own
* preconditions, so we don't directly remap to the underlying
* connector. Instead, we provide our own full TravelVia
* implementation, and then we perform the travel on the underlying
* connector via a replacement action in our own action() handler.
*/
dobjFor(TravelVia)
{
/* the physical link object has to be touchable */
preCond = [touchObj]
verify() { }
action()
{
/* carry out the action by traveling via our connector */
replaceAction(TravelVia, connector);
}
}
/*
* These objects are generally things like buildings (exterior or
* interior), which tend to be large enough that their details can be
* seen at a distance.
*/
sightSize = large
;
/*
* An Enterable is an object that exists in one location, and which can
* be entered to take an actor to another location. Enterables are used
* for things such as the outsides of buildings, so that the building
* can have a presence on its outside and can be entered via a command
* like "go into building".
*
* An Enterable isn't a connector, but points to a connector. This type
* of object is most useful when there's already a connector that exists
* as a separate object, such as the door to a house: the house object
* can be made an Enterable that simply points to the door object.
*/
class Enterable: TravelConnectorLink, Fixture
/*
* "Enter" action this simply causes the actor to travel via the
* connector.
*/
dobjFor(Enter) remapTo(TravelVia, self)
/* explicitly define the push-travel indirect object mapping */
mapPushTravelIobj(PushTravelEnter, TravelVia)
;
/*
* An Exitable is like an Enterable, except that you exit it rather than
* enter it. This can be used for objects representing the current
* location as an enclosure (a jail cell), or an exit door.
*/
class Exitable: TravelConnectorLink, Fixture
/* Get Out Of/Exit action - this simply maps to travel via the connector */
dobjFor(GetOutOf) remapTo(TravelVia, self)
/* explicitly define the push-travel indirect object mapping */
mapPushTravelIobj(PushTravelGetOutOf, TravelVia)
;
/*
* An EntryPortal is just like an Enterable, except that "go through"
* also works on it. Likewise, an ExitPortal is just like an Exitable
* but accepts "go through" as well.
*/
class EntryPortal: Enterable
dobjFor(GoThrough) remapTo(TravelVia, self)
;
class ExitPortal: Exitable
dobjFor(GoThrough) remapTo(TravelVia, self)
;
/* ------------------------------------------------------------------------ */
/*
* A "TravelPushable" is an object that can't be taken, but can be moved
* from one location to another via commands of the form "push obj dir,"
* "push obj through passage," and the like.
*
* TravelPushables tend to be rather rare, and we expect that instances
* will almost always be special cases that require additional
* specialized code. This is therefore only a general framework for
* pushability.
*/
class TravelPushable: Immovable
cannotTakeMsg = &cannotTakePushableMsg
cannotMoveMsg = &cannotMovePushableMsg
cannotPutMsg = &cannotPutPushableMsg
/* can we be pushed via the given travel connector? */
canPushTravelVia(connector, dest) { return true; }
/* explain why canPushTravelVia said we can't be pushed this way */
explainNoPushTravelVia(connector, dest) { }
/*
* Receive notification that we're about to be pushed somewhere.
* This is called just before the underlying traveler performs the
* actual travel. (By default, we don't even define this method, to
* ensure that if we're combined with another base class that
* overrides the method, the overrider will be called.)
*/
// beforeMovePushable(traveler, connector, dest) { }
/*
* Move the object to a new location as part of a push-travel
* operation. By default, this simply uses moveInto to move the
* object, but subclasses can override this to apply conditions to
* the pushing, put the object somewhere else in some cases, display
* extra messages, or do anything else that's necessary.
*
* Our special PushTraveler calls this routine after the underlying
* real traveler has finished its travel to the new location, so the
* traveler's location will indicate the destination of the travel.
* Note that this routine is never called if the traveler ends up in
* its original location after the travel, so this routine isn't
* called when travel isn't allowed for the underlying traveler.
*/
movePushable(traveler, connector)
{
/* move me to the traveler's new location */
moveIntoForTravel(traveler.location);
/* describe what we're doing */
describeMovePushable(traveler, connector);
}
/*
* Describe the actor pushing the object into the new location.
* This is called from movePushable; we pull this out as a separate
* routine so that the description of the pushing can be overridden
* without having to override all of movePushable.
*/
describeMovePushable(traveler, connector)
{
/*
* If the actor is the player character, mention that we're
* pushing the object with us. For an NPC, show nothing,
* because the normal travel message will mention that the NPC
* is pushing the object as part of the normal travel report
* (thanks to PushTraveler's name override).
*/
if (gActor.isPlayerChar)
mainReport(&okayPushTravelMsg, self);
}
dobjFor(PushTravel)
{
verify() { }
action()
{
local newTrav;
local oldTrav;
local wasExcluded;
/*
* Create a push traveler to coordinate the travel. The
* push traveler performs the normal travel, and also moves
* the object being pushed.
*/
newTrav = pushTravelerClass.createInstance(
self, gActor.getPushTraveler(self));
/* set the actor's special traveler to our push traveler */
oldTrav = gActor.setSpecialTraveler(newTrav);
/*
* Add myself to the actor's look-around exclusion list -
* this ensures that we won't be listed among the objects in
* the new location when we show the description on arrival.
* This is desirable because of how we describe the travel:
* we first want to show the new location's description, then
* describe pushing this object into the new location. But
* we actually have to move the object first, to make sure
* any side effects of its presence in the new location are
* taken into account when we describe the location - because
* by the time we're in the room enough to have a look
* around, the pushable will be in the room with us. Even
* so, we don't actually want to describe the pushable as in
* the room at this stage, because from the player's
* perspective we're really still in the process of pushing
* it; describing it as already settled into the new location
* sounds weird because it makes it seem like the object was
* already in place when we arrived. To avoid this
* weirdness, suppress it from the new location's initial
* description on arrival.
*/
wasExcluded = gActor.excludeFromLookAround(self);
/* make sure we undo our global changes when we're done */
try
{
/*
* Now that we've activated our special push traveler
* for the actor, simply perform the ordinary travel
* command. The travel command we perform depends on
* the kind of push-travel command we attempted, so
* simply let the current action carry out the action.
*/
gAction.performTravel();
}
finally
{
/* restore the actor's old special traveler on the way out */
gActor.setSpecialTraveler(oldTrav);
/*
* if we weren't in the actor's 'look around' exclusion
* list before, remove us from the list
*/
if (!wasExcluded)
gActor.unexcludeFromLookAround(self);
}
}
}
/*
* The class we create for our special push traveler - by default,
* this is PushTraveler, but we parameterize this via this property
* to allow special PushTraveler subclasses to be created; this
* could be useful, for example, to customize the traveler name
* messages.
*/
pushTravelerClass = PushTraveler
;
/*
* A special Traveler class for travel involving pushing an object from
* one room to another. This class encapsulates the object being pushed
* and the actual Traveler performing the travel.
*
* For the most part, we refer Traveler methods to the underlying
* Traveler. We override a few methods to provide special handling.
*/
class PushTraveler: object
construct(obj, traveler)
{
/* remember the object being pushed and the real traveler */
obj_ = obj;
traveler_ = traveler;
}
/* the object being pushed */
obj_ = nil
/*
* the underlying Traveler - this is the real Traveler that will
* move to a new location
*/
traveler_ = nil
/*
* Travel to a new location. We'll run the normal travel routine
* for the underlying real traveler; then, if we ended up in a new
* location, we'll move the object being pushed to the traveler's
* new location.
*/
travelerTravelTo(dest, connector, backConnector)
{
local oldLoc;
local origin;
/* remember the traveler's origin, so we can tell if we moved */
origin = traveler_.location;
/* let the object being pushed describe the departure */
obj_.beforeMovePushable(traveler_, connector, dest);
/*
* *Tentatively* move the pushable to its new location. Just do
* the basic move-into for this, since it's only tentative - this
* is just so that we get any side effects of its presence in the
* new location for the purposes of describing the new location.
*/
oldLoc = location;
obj_.baseMoveInto(dest);
/*
* Call the traveler's normal travel routine, to perform the
* actual movement of the underlying traveler.
*/
traveler_.travelerTravelTo(dest, connector, backConnector);
/* undo the tentative move of the pushable */
obj_.baseMoveInto(oldLoc);
/*
* If we moved to a new location, we can now actually move the
* pushable object to the new location.
*/
if (traveler_.location != origin)
obj_.movePushable(traveler_, connector);
}
/*
* Perform local travel, between nested rooms within a top-level
* location. By default, we simply don't allow pushing objects
* between nested rooms.
*
* To allow pushing an object between nested rooms, override this in
* parallel with travelerTravelTo(). Note that you'll have to call
* travelerTravelWithin() on the underlying traveler (which will
* generally be the actor), and you'll probably want to set up a new
* set of notifiers parallel to beforeMovePushable() and
* movePushable(). You'll probably particularly need to customize
* the report in your parallel for movePushable() - the default ("you
* push x into the area") isn't very good when nested rooms are
* involved, and you'll probably want something more specific.
*/
travelerTravelWithin(actor, dest)
{
reportFailure(&cannotPushObjectNestedMsg, obj_);
exit;
}
/*
* Can we travel via the given connector? We'll ask our underlying
* traveler first, and if that succeeds, we'll ask the object we're
* pushing.
*/
canTravelVia(connector, dest)
{
/* ask the underlying traveler first, then our pushed object */
return (traveler_.canTravelVia(connector, dest)
&& obj_.canPushTravelVia(connector, dest));
}
/*
* Explain why the given travel is not possible. If our underlying
* traveler raised the objection, let it explain; otherwise, let our
* pushed object explain.
*/
explainNoTravelVia(connector, dest)
{
if (!traveler_.canTravelVia(connector, dest))
traveler_.explainNoTravelVia(connector, dest);
else
obj_.explainNoPushTravelVia(connector, dest);
}
/* by default, send everything to the underlying Traveler */
propNotDefined(prop, [args]) { return traveler_.(prop)(args...); }
;
/*
* A PushTravelBarrier is a TravelConnector that allows regular travel,
* but not travel that involves pushing something. By default, we block
* all push travel, but subclasses can customize this so that we block
* only specific objects.
*/
class PushTravelBarrier: TravelBarrier
/*
* Determine if the given pushed object is allowed to pass. Returns
* true if so, nil if not. By default, we'll return nil for every
* object; subclasses can override this to allow some objects to be
* pushed through the barrier but not others.
*/
canPushedObjectPass(obj) { return nil; }
/* explain why an object can't pass */
explainTravelBarrier(traveler)
{
reportFailure(&cannotPushObjectThatWayMsg, traveler.obj_);
}
/*
* Determine if the given traveler can pass through this connector.
* If the traveler isn't a push traveler, we'll allow the travel;
* otherwise, we'll block the travel if our canPushedObjectPass
* routine says the object being pushed can pass.
*/
canTravelerPass(traveler)
{
/* if it's not a push traveler, it can pass */
if (!traveler.ofKind(PushTraveler))
return true;
/* it can pass if we can pass the object being pushed */
return canPushedObjectPass(traveler.obj_);
}
;
/* ------------------------------------------------------------------------ */
/*
* A basic location - this is the base class for locations that can
* contain actors.
*/
class BasicLocation: Thing
/*
* Get the nested room list grouper for an actor in the given
* posture directly in this room. This is used when we're listing
* the actors within the nested room as
*
* By default, we maintain a lookup table, and store one nested
* actor grouper object for each posture. This makes it so that we
* show one group per posture in this room; for example, if we
* contain two sitting actors and three standing actors, we'll say
* something like "bill and bob are sitting on the stage, and jill,
* jane, and jack are standing on the stage." This can be
* overridden if a different arrangement of groups is desired; for
* example, an override could simply return a single grouper to list
* everyone in the room together, regardless of posture.
*/
listWithActorIn(posture)
{
/* if we don't have a lookup table for this yet, create one */
if (listWithActorInTable == nil)
listWithActorInTable = new LookupTable(5, 5);
/* if this posture isn't in the table yet, create a grouper for it */
if (listWithActorInTable[posture] == nil)
listWithActorInTable[posture] =
new RoomActorGrouper(self, posture);
/* return the grouper for this posture */
return listWithActorInTable[posture];
}
/*
* our listWithActorIn table - this gets initialized to a
* LookupTable as soon as we need one (in listWithActorIn)
*/
listWithActorInTable = nil
/*
* Check the ambient illumination level in the room for the given
* actor's senses to determine if the actor would be able to see if
* the actor were in this room without any additional light sources.
* Returns true if the room is lit for the purposes of the actor's
* visual senses, nil if not.
*
* Note that if the actor is already in this location, there's no
* need to run this test, since we could get the information from
* the actor directly. The point of this test is to determine the
* light level in this location without the actor having to be
* present.
*/
wouldBeLitFor(actor)
{
/*
* Check for a simple, common case before running the more
* expensive full what-if test. Most rooms provide their own
* illumination in the actor's 'sight' sense; if this room does
* provide its own interior 'brightness' of at least 2, and the
* actor has 'sight' among its visual senses, then the room is
* lit. Note that we must use transSensingOut() to determine
* how we transmit our own brightness to our interior, since
* that gives the transparency for looking from within this room
* at objects outside the room; our own intrinsic brightness is
* defined as the brightness of our exterior surface.
*/
if (actor.sightlikeSenses.indexOf(sight) != nil
&& brightness > 1
&& transSensingOut(sight) == transparent)
return true;
/*
* We can't determine for sure that the location is lit with a
* simple test, so run a full what-if test, checking what
* ambient light level our "probe" object would see if it were
* moved to this location. Return true if the ambient light
* level is higher than the "self-lit" value of 1, nil if not.
*/
return (lightProbe.whatIf(
{: senseAmbientMax(actor.sightlikeSenses) },
&moveInto, self) > 1);
}
/*
* Show our room description: this is the interior description of
* the room, for use when the room is viewed by an actor within the
* room. By default, we show our ordinary 'desc'.
*/
roomDesc { desc; }
/* as part of a room description, mention an actor in this room */
roomActorHereDesc(actor) { gLibMessages.actorInRoom(actor, self); }
/*
* Provide a default description for an actor in this location, as
* seen from a remote location (i.e., from a separate top-level room
* that's linked to our top-level room by a sense connector of some
* kind). By default, we'll describe the actor as being in this
* nested room.
*/
roomActorThereDesc(actor)
{
local pov = getPOV();
local outer;
/* get the outermost visible enclosing room */
outer = getOutermostVisibleRoom(pov);
/*
* If we found a room, and it's not us (i.e., we found something
* outside this room that can be seen from the current point of
* view), use the three-part description: actor in nested room
* (self) in outer room. If we didn't find a room, or it's the
* same as us, all we can say is that the actor is in the nested
* room.
*/
if (outer not in (nil, self))
{
/* use the three-part description: actor in self in outer */
gLibMessages.actorInRemoteNestedRoom(actor, self, outer, pov);
}
else
{
/* we're as far out as we can see: just say actor is in self */
gLibMessages.actorInRemoteRoom(actor, self, pov);
}
}
/* show the status addendum for an actor in this location */
roomActorStatus(actor) { gLibMessages.actorInRoomStatus(actor, self); }
/* describe the actor's posture while in this location */
roomActorPostureDesc(actor)
{ gLibMessages.actorInRoomPosture(actor, self); }
/* acknowledge a posture change while in this location */
roomOkayPostureChange(actor)
{ defaultReport(&roomOkayPostureChangeMsg, actor.posture, self); }
/*
* describe the actor's posture as part of the EXAMINE description of
* the nested room
*/
roomListActorPosture(actor)
{ gLibMessages.actorInRoom(actor, self); }
/*
* Prefix and suffix messages for listing a group of actors
* nominally in this location. 'posture' is the posture of the
* actors. 'remote' is the outermost visible room containing the
* actors, but only if that room is remote from the point-of-view
* actor; if everything is local, this will be nil. 'lst' is the
* list of actors being listed. By default, we'll just show the
* standard library messages.
*/
actorInGroupPrefix(pov, posture, remote, lst)
{
if (remote == nil)
gLibMessages.actorInGroupPrefix(posture, self, lst);
else
gLibMessages.actorInRemoteGroupPrefix(
pov, posture, self, remote, lst);
}
actorInGroupSuffix(pov, posture, remote, lst)
{
if (remote == nil)
gLibMessages.actorInGroupSuffix(posture, self, lst);
else
gLibMessages.actorInRemoteGroupSuffix(
pov, posture, self, remote, lst);
}
/*
* Show a list of exits from this room as part of failed travel
* ("you can't go that way").
*/
cannotGoShowExits(actor)
{
/* if we have an exit lister, ask it to show exits */
if (gExitLister != nil)
gExitLister.cannotGoShowExits(actor, self);
}
/* show the exit list in the status line */
showStatuslineExits()
{
/* if we have a global exit lister, ask it to show the exits */
if (gExitLister != nil)
gExitLister.showStatuslineExits();
}
/*
* 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.
*/
getStatuslineExitsHeight()
{
if (gExitLister != nil)
return gExitLister.getStatuslineExitsHeight();
else
return 0;
}
/*
* Make the actor stand up from this location. By default, we'll
* simply change the actor's posture to "standing," and show a
* default success report.
*
* Subclasses might need to override this. For example, a chair
* will set the actor's location to the room containing the chair
* when the actor stands up from the chair.
*/
makeStandingUp()
{
/* simply set the actor's new posture */
gActor.makePosture(standing);
/* issue a default report of the change */
defaultReport(&okayPostureChangeMsg, standing);
}
/*
* Default posture for an actor in the location. This is the
* posture assumed by an actor when moving out of a nested room
* within this location.
*/
defaultPosture = standing
/* failure report we issue when we can't return to default posture */
mustDefaultPostureProp = &mustBeStandingMsg
/* run the appropriate implied command to achieve our default posture */
tryMakingDefaultPosture()
{
return defaultPosture.tryMakingPosture(self);
}
/*
* Check this object as a staging location. We're a valid location,
* so we allow this.
*/
checkStagingLocation(dest)
{
/* we've valid, so we don't need to do anything */
}
/*
* Try moving the actor into this location.
*/
checkMovingActorInto(allowImplicit)
{
/*
* If the actor isn't somewhere within us, we can't move the
* actor here implicitly - we have no generic way of causing
* implicit travel between top-level locations. Note that some
* rooms might want to override this when travel between
* adjacent locations makes sense as an implicit action; we
* expect that such cases will be rare, so we don't attempt to
* generalize this possibility.
*/
if (!gActor.isIn(self))
{
reportFailure(&cannotDoFromHereMsg);
exit;
}
/*
* if the actor is already directly in me, simply check to make
* sure the actor is in the default posture for the room - if
* not, try running an appropriate implied command to change the
* posture
*/
if (gActor.isDirectlyIn(self))
{
/* if the actor's already in the default posture, we're okay */
if (gActor.posture == defaultPosture)
return nil;
/* run the implied command to stand up (or whatever) */
if (allowImplicit && tryMakingDefaultPosture())
{
/* make sure we're in the proper posture now */
if (gActor.posture != defaultPosture)
exit;
/* note that we ran an implied command */
return true;
}
/* we couldn't get into the default posture - give up */
reportFailure(mustDefaultPostureProp);
exit;
}
/*
* The actor is within a nested room within me. Find our
* immediate child containing the actor, and remove the actor
* from the child.
*/
foreach (local cur in contents)
{
/* if this is the one containing the actor, remove the actor */
if (gActor.isIn(cur))
return cur.checkActorOutOfNested(allowImplicit);
}
/* we didn't find the nested room with the actor, so give up */
reportFailure(&cannotDoFromHereMsg);
exit;
}
/*
* Check, using pre-condition rules, that the actor is ready to
* enter this room as a nested location. By default, we do nothing,
* since we're not designed as a nested location.
*/
checkActorReadyToEnterNestedRoom(allowImplicit)
{
return nil;
}
/*
* Check that the traveler is directly in the given room, using
* pre-condition rules. 'nested' is the nested location immediately
* within this room that contains the actor (directly or
* indirectly).
*/
checkTravelerDirectlyInRoom(traveler, allowImplicit)
{
/* if the actor is already directly in this room, we're done */
if (traveler.isDirectlyIn(self))
return nil;
/* try moving the actor here */
return traveler.checkMovingTravelerInto(self, allowImplicit);
}
/*
* Check, using pre-condition rules, that the actor is removed from
* this nested location and moved to its exit destination. By
* default, we're not a nested location, so there's nothing for us
* to do.
*/
checkActorOutOfNested(allowImplicit)
{
/* we're not a nested location, so there's nothing for us to do */
return nil;
}
/*
* Determine if the current gActor, who is directly in this location,
* is "travel ready." This means that the actor is ready, as far as
* this location is concerned, to traverse the given connector. By
* default, we consider an actor to be travel-ready if the actor is
* standing; this takes care of most nested room situations, such as
* chairs and beds, automatically.
*/
isActorTravelReady(conn) { return gActor.posture == standing; }
/*
* Run an implicit action, if possible, to make the current actor
* "travel ready." This will be called if the actor is directly in
* this location and isActorTravelReady() returns nil. By default,
* we try to make the actor stand up. This should always be paired
* with isActorTravelReady - the condition that routine tests should
* be the condition this routine tries to bring into effect. If no
* implicit action is possible, simply return nil.
*/
tryMakingTravelReady(conn) { return tryImplicitAction(Stand); }
/* the message explaining what we must do to be travel-ready */
notTravelReadyMsg = &mustBeStandingMsg
/*
* An actor is attempting to disembark this location. By default,
* we'll simply turn this into an "exit" command.
*/
disembarkRoom()
{
/* treat this as an 'exit' command */
replaceAction(Out);
}
/*
* The destination for objects explicitly dropped by an actor within
* this room. By default, we'll return self, because items dropped
* should simply go in the room itself. Some types of rooms will
* want to override this; for example, a room that represents the
* middle of a tightrope would probably want to set the drop
* destination to the location below the tightrope. Likewise,
* objects like chairs will usually prefer to have dropped items go
* into the enclosing room.
*/
getDropDestination(objToDrop, path)
{
/* by default, objects dropped in this room end up in this room */
return self;
}
/*
* The nominal drop destination - this is the location where objects
* are *reported* to go when dropped by an actor in this location.
* By default, we simply return 'self'.
*
* The difference between the actual drop location and the nominal
* drop location is that the nominal drop location is used only for
* reporting messages, while the actual drop location is the
* location where objects are moved on 'drop' or equivalent actions.
* Rooms, for example, want to report that a dropped object lands on
* the floor (or the ground, or whatever), even though the room
* itself is the location where the object actually ends up. We
* distinguish between the nominal and actual drop location to allow
* these distinctions in reported messages.
*/
getNominalDropDestination() { return self; }
/*
* The "nominal actor container" - this is the container which we'll
* say actors are in when we describe actors who are actually in
* this location. By default, this simply returns self, but it's
* sometimes useful to describe actors as being in some object other
* than self. The most common case is that normal top-level rooms
* usually want to describe actors as being "on the floor" or
* similar.
*/
getNominalActorContainer(posture) { return self; }
/*
* Get any extra items in scope for an actor in this location.
* These are items that are to be in scope even if they're not
* reachable through any of the normal sense paths (so they'll be in
* scope even in the dark, for example).
*
* By default, this returns nothing. Subclasses can override as
* necessary to include additional items in scope. For example, a
* chair would probably want to include itself in scope, since the
* actor presumably knows he or she is sitting in a chair even if
* it's too dark to see the chair.
*/
getExtraScopeItems(actor) { return []; }
/*
* Receive notification that we're about to perform a command within
* this location. This is called on the outermost room first, then
* on the nested rooms, from the outside in, until reaching the room
* directly containing the actor performing the command.
*/
roomBeforeAction()
{
}
/*
* Receive notification that we've just finished a command within
* this location. This is called on the room immediately containing
* the actor performing the command, then on the room containing
* that room, and so on to the outermost room.
*/
roomAfterAction()
{
}
/*
* Get my notification list - this is a list of objects on which we
* must call beforeAction and afterAction when an action is
* performed within this room.
*
* We'll also include any registered notification items for all of
* our containing rooms up to the outermost container.
*
* The general notification mechanism always includes in the
* notification list all of the objects connected by containment to
* the actor, so objects that are in this room need not register for
* explicit notification.
*/
getRoomNotifyList()
{
local lst;
/* start with our explicitly registered list */
lst = roomNotifyList;
/* add notification items for our immediate locations */
forEachContainer(
{cont: lst = lst.appendUnique(cont.getRoomNotifyList())});
/* return the result */
return lst;
}
/*
* Add an item to our registered notification list for actions in
* the room.
*
* Items can be added here if they must be notified of actions
* performed by within the room even when the items aren't in the
* room at the time of the action. All items connected by
* containment with the actor performing an action are automatically
* notified of the action; only items that must receive notification
* even when not connected by containment need to be registered
* here.
*/
addRoomNotifyItem(obj)
{
roomNotifyList += obj;
}
/* remove an item from the registered notification list */
removeRoomNotifyItem(obj)
{
roomNotifyList -= obj;
}
/* our list of registered notification items */
roomNotifyList = []
/*
* Get the room location. Since we're capable of holding actors, we
* are our own room location.
*/
roomLocation = (self)
/*
* Receive notification that a traveler is arriving. This is a
* convenience method that rooms can override to carry out side
* effects of arrival. This is called just before the room's
* arrival message (usually the location description) is displayed,
* so the method can make any adjustments to the room's status or
* contents needed for the arrival. By default, we do nothing.
*/
enteringRoom(traveler) { }
/*
* Receive notification that a traveler is leaving. This is a
* convenience method that rooms can override to carry out side
* effects of departure. This is called just after any departure
* message is displayed. By default, we do nothing.
*/
leavingRoom(traveler) { }
/*
* Receive notification that a traveler is about to leave the room.
* 'traveler' is the object actually traveling. In most cases this
* is simply the actor; but when the actor is in a vehicle, this is
* the vehicle instead.
*
* By default, we describe the traveler's departure if the traveler's
* destination is different from its present location.
*/
travelerLeaving(traveler, dest, connector)
{
/* describe the departure */
if (dest != traveler.location)
traveler.describeDeparture(dest, connector);
/* run the departure notification */
leavingRoom(traveler);
}
/*
* Receive notification that a traveler is arriving in the room.
* 'traveler' is the object actually traveling. In most cases this
* is simply the actor; but when the actor is in a vehicle, this is
* the vehicle instead.
*
* By default, we set each of the "motive" actors to its default
* posture, then describe the arrival.
*/
travelerArriving(traveler, origin, connector, backConnector)
{
/*
* Set the self-motive actors into the proper default posture
* for the location. We only do this for actors moving under
* their own power, since actors in vehicles will presumably
* just stay in the posture that's appropriate for the vehicle.
*/
foreach (local actor in traveler.getTravelerMotiveActors)
{
/*
* If the actor isn't in this posture already, set the actor
* to the new posture. Note that we set the new posture
* directly, rather than via a nested command; we don't want
* the travel to consist of a NORTH plus a SIT, but simply of
* a NORTH. Note that this could bypass side effects
* normally associated with the SIT (or whatever), but we
* assume that when a room with a specific posture is linked
* directly from a separate location, the travel connector
* linking up to the new room will take care of the necessary
* side effects.
*/
if (actor.posture != defaultPosture)
actor.makePosture(defaultPosture);
}
/* run the arrival notification */
enteringRoom(traveler);
/* describe the arrival */
traveler.describeArrival(origin, backConnector);
}
/*
* Receive notification of travel among nested rooms. When an actor
* moves between two locations related directly by containing (such
* as from a chair to the room containing the chair, or vice versa),
* we first call this routine on the origin of the travel, then we
* move the actor, then we call this same routine on the destination
* of the travel.
*
* This routine is used any time an actor is moved with
* travelWithin(). This is not used when an actor travels between
* locations related by a TravelConnector object rather than by
* direct containment.
*
* We do nothing by default. Locations can override this if they
* wish to perform any special handling during this type of travel.
*/
actorTravelingWithin(origin, dest)
{
}
/*
* Determine if the given actor has "intrinsic" knowledge of the
* destination of the given travel connector leading away from this
* location. This knowledge is independent of any memory the actor
* has of actual travel through the connector in the course of the
* game, which we track separately via the TravelConnector's travel
* memory mechanism.
*
* There are two main reasons an actor would have intrinsic
* knowledge of a connector's destination:
*
* 1. The actor is supposed to be familiar with the location and its
* surroundings, within the context of the game. For example, if
* part of the game is the player character's own house, the PC
* would probably know where all of the connections among rooms go.
*
* 2. The destination location is plainly visible from this location
* or is clearly marked (such as with a sign). For example, if the
* current location is an open field, a nearby hilltop to the east
* might be visible from here, so we could see from here where we'll
* end up by going east. Alternatively, if we're in a lobby, and
* the passage to the west is marked with a sign reading "electrical
* room," an actor would have good reason to think an electrical
* room lies to the west.
*
* We handle case (1) automatically through our actorIsFamiliar()
* method: if the actor is familiar with the location, we assume by
* default that the actor knows where all of the connectors from
* here go. We don't have any default handling for case (2), so
* individual rooms (or subclasses) must override this method if
* they want to specify intrinsic knowledge for any of their
* outgoing connectors.
*/
actorKnowsDestination(actor, conn)
{
/*
* if the actor is familiar with this location, then the actor
* by default knows where all of the outgoing connections go
*/
if (actorIsFamiliar(actor))
return true;
/* there's no other way the actor would know the destination */
return nil;
}
/*
* Is the actor familiar with this location? In other words, is the
* actor supposed to know the location well at the start of the game?
*
* This should return true if the actor is familiar with this
* location, nil if not. By default, we return nil, since actors
* are not by default familiar with any locations.
*
* The purpose of this routine is to determine if the actor is meant
* to know the location well, within the context of the game, even
* before the game starts. For example, if an area in the game is
* an actor's own house, the actor would naturally be familiar,
* within the context of the game, with the locations making up the
* house.
*
* Note that this routine doesn't need to "learn" based on the
* events of the game. The familiarity here is meant only to model
* the actor's knowledge as of the start of the game.
*/
actorIsFamiliar(actor) { return nil; }
/*
* The default "you can't go that way" message for travel within this
* location in directions that don't allow travel. This is shown
* whenever an actor tries to travel in one of the directions we have
* set to point to noTravel. A room can override this to produce a
* different, customized message for unset travel directions - this
* is an easy way to change the cannot-travel message for several
* directions at once.
*
* The handling depends on whether or not it's dark. If it's dark,
* we don't want to reveal whether or not it's actually possible to
* perform the travel, since there's no light to see where the exits
* are.
*/
cannotTravel()
{
/* check for darkness */
if (!gActor.isLocationLit())
{
/* the actor is in the dark - use our dark travel message */
cannotGoThatWayInDark();
}
else
{
/* use the standard "can't go that way" routine */
cannotGoThatWay();
}
}
/*
* Receive notification of travel from one dark location to another.
* This is called before the actor is moved from the source
* location, and can cancel the travel if desired by using 'exit' to
* terminate the command.
*
* By default, we'll simply display the same handler we do when the
* player attempts travel in a direction with no travel possible in
* the dark (cannotGoThatWayInDark), and then use 'exit' to cancel
* the command. This default behavior provides the player with no
* mapping information in the dark, since the same message is
* generated whether or not travel would be possible in a given
* direction were light present.
*/
roomDarkTravel(actor)
{
/*
* show the same message we would show if we attempted travel in
* the dark in a direction with no exit
*/
cannotGoThatWayInDark();
/* terminate the command */
exit;
}
/*
* Show the default "you can't go that way" message for this
* location. By default, we show a generic message, but individual
* rooms might want to override this to provide a more specific
* description of why travel isn't allowed.
*/
cannotGoThatWay()
{
/* "you can't go that way" */
reportFailure(cannotGoThatWayMsg);
/* show a list of exits, if appropriate */
cannotGoShowExits(gActor);
}
/*
* The message to display when it's not possible to travel in a given
* direction from this room; this is either a single-quoted string or
* an actor action messages property (by default, it's the latter,
* giving a default library message).
*/
cannotGoThatWayMsg = &cannotGoThatWayMsg
/*
* Show a version of the "you can't go that way" message for travel
* while in the dark. This is called when the actor is in the dark
* (i.e., there's no ambient light at the actor) and attempts to
* travel in a direction that doesn't allow travel. By default, we
* show a generic "you can't see where you're going in the dark"
* message.
*
* This routine is essentially a replacement for the
* cannotGoThatWay() routine that we use when the actor is in the
* dark.
*/
cannotGoThatWayInDark()
{
/* "it's too dark; you can't see where you're going */
reportFailure(&cannotGoThatWayInDarkMsg);
}
/*
* Get preconditions for travel for an actor in this location. These
* preconditions should be applied by any command that will involve
* travel from this location. By default, we impose no additional
* requirements.
*/
roomTravelPreCond = []
/*
* Get the effective location of an actor directly within me, for
* the purposes of a "follow" command. To follow someone, we must
* have the same effective follow location that the target had when
* we last observed the target leaving.
*
* For most rooms, this is simply the room itself.
*/
effectiveFollowLocation = (self)
/*
* Dispatch the room daemon. This is a daemon routine invoked once
* per turn; we in turn invoke roomDaemon on the current player
* character's current location.
*/
dispatchRoomDaemon()
{
/* call roomDaemon on the player character's location */
if (gPlayerChar.location != nil)
gPlayerChar.location.roomDaemon();
}
;
/* ------------------------------------------------------------------------ */
/*
* Room: the basic class for top-level game locations (that is, game
* locations that aren't inside any other simulation objects, but are at
* the top level of the containment hierarchy). This is the smallest
* unit of movement; we do not distinguish among locations within a
* room, even if a Room represents a physically large location. If it
* is necessary to distinguish among different locations in a large
* physical room, simply divide the physical room into sections and
* represent each section with a separate Room object.
*
* A Room is not necessarily indoors; it is simply a location where an
* actor can be located. This peculiar usage of "room" to denote any
* atomic location, even outdoors, was adopted by the authors of the
* earliest adventure games, and has been the convention ever since.
*
* A room's contents are the objects contained directly within the room.
* These include fixed features of the room as well as loose items in
* the room, which are effectively "on the floor" in the room.
*
* The Room class implements the Travel Connector interface in such a
* way that travel from one room to another can be established simply by
* setting a direction property (north, south, etc) in the origin room
* to point to the destination room. This type of travel link has no
* side effects and is unconditional.
*
* A room is by default an indoor location; this means that it contains
* walls, floor, and ceiling. An outdoor location should be based on
* OutdoorRoom rather than Room.
*/
class Room: Fixture, BasicLocation, RoomAutoConnector
/*
* Initialize
*/
initializeThing()
{
/* inherit default handling */
inherited();
/*
* Add my room parts to my contents list. Only include room
* parts that don't have explicit locations.
*/
contents += roomParts.subset({x: x.location == nil});
}
/*
* we're a "top-level" location: we don't have any other object
* containing us, but we're nonetheless part of the game world, so
* we're at the top level of the containment tree
*/
isTopLevel = true
/*
* we generally do not want rooms to be included when a command
* refers to 'all'
*/
hideFromAll(action) { return true; }
/* don't consider myself a default for STAND ON, SIT ON, or LIE ON */
hideFromDefault(action)
{
/* don't hide from STAND ON, SIT ON, LIE ON */
if (action.ofKind(StandOnAction)
|| action.ofKind(SitOnAction)
|| action.ofKind(LieOnAction))
return nil;
/* don't hide from defaults for other actions, though */
return inherited(action);
}
/*
* Most rooms provide their own implicit lighting. We'll use
* 'medium' lighting (level 3) by default, which provides enough
* light for all activities, but is reduced to dim light (level 2)
* when it goes through obscuring media or over distance.
*/
brightness = 3
/*
* Get my "destination name," as seen by the given actor from the
* given origin location. This gives the name we can use to
* describe this location from the perspective of an actor in an
* adjoining location looking at a travel connector from that
* location to here.
*
* By default, we simply return our destName property. This default
* behavior can be overridden if it's necessary for a location to
* have different destination names in different adjoining
* locations, or when seen by different actors.
*
* If this location's name cannot or should not be described from an
* adjoining location, this should simply return nil.
*/
getDestName(actor, origin) { return destName; }
/*
* Our destination name, if we have one. By default, we make this
* nil, which means the room cannot be described as a destination of
* connectors from adjoining locations.
*/
destName = nil
/*
* My "atmosphere" list. This can be set to an EventList object to
* provide atmosphere messages while the player character is within
* this room. The default roomDaemon will show one message from this
* EventList (by calling the EventList's doScript() method) on each
* turn the player character is in this location.
*/
atmosphereList = nil
/*
* Room daemon - this is invoked on the player character's immediate
* location once per turn in a daemon.
*/
roomDaemon()
{
/*
* if we have an atmosphere message list, display the next
* message
*/
if (atmosphereList != nil)
{
/* show visual separation, then the current atmosphere message */
"<.commandsep>";
atmosphereList.doScript();
}
}
/*
* The nominal drop destination - this is the location where we
* describe objects as being when they're actually directly within
* the room.
*
* By default, we return the object representing the room's floor.
* If there's no floor, we simply return 'self'.
*/
getNominalDropDestination()
{
local floor;
/*
* if there's a floor, it's the nominal drop destination;
* otherwise, just indicate that our contents are in 'self'
*/
return ((floor = roomFloor) != nil ? floor : self);
}
/*
* Since we could be our own nominal drop destination, we need a
* message to describe things being put here.
*/
putDestMessage = &putDestRoom
/*
* The nominal actor container. By default, this is the room's
* nominal drop destination, which is usually the floor or
* equivalent.
*/
getNominalActorContainer(posture) { return getNominalDropDestination(); }
/*
* move something into a room is accomplished by putting the object
* on the floor
*/
tryMovingObjInto(obj)
{
local floor;
/* if we have a floor, put the object there */
if ((floor = roomFloor) != nil)
return tryImplicitAction(PutOn, obj, floor);
else
return nil;
}
/* explain that something must be in the room first */
mustMoveObjInto(obj)
{
local floor;
/* if we have a floor, say that the object has to go there */
if ((floor = roomFloor) != nil)
reportFailure(&mustBeInMsg, obj, floor);
else
inherited(obj);
}
/*
* Get the apparent location of one of our room parts.
*
* In most cases, we use generic objects (defaultFloor,
* defaultNorthWall, etc.) for the room parts. There's only one
* instance of each of these generic objects in the whole game -
* there's only one floor, one north wall, and so on - so these
* instances can't have specific locations the way normal objects do.
* Thus the need for this method: this tells us the *apparent*
* location of one of the room part objects as perceived from this
* room.
*
* If the part isn't in this location, we'll return nil.
*/
getRoomPartLocation(part)
{
local loc;
/*
* if this part is in our part list, then its apparent location
* is 'self'
*/
if (roomParts.indexOf(part) != nil)
return self;
/*
* if the room part has an explicit location itself, and that
* location is either 'self' or is in 'self', return the
* location
*/
if (part != nil
&& (loc = part.location) != nil
&& (loc == self || loc.isIn(self)))
return loc;
/* we don't have the part */
return nil;
}
/*
* Get the list of extra parts for the room. An indoor location has
* walls, floor, and ceiling; these are all generic objects that are
* included for completeness only.
*
* A room with special walls, floor, or ceiling should override this
* to eliminate the default objects from appearing in the room.
* Note that if the room has a floor, it should always be
* represented by an object of class Floor, and should always be
* part of this list.
*/
roomParts = [defaultFloor, defaultCeiling,
defaultNorthWall, defaultSouthWall,
defaultEastWall, defaultWestWall]
/*
* Get the room's floor. This looks for an object of class Floor in
* the roomParts list; if there is no such object, we'll return nil,
* indicating that the room has no floor at all.
*/
roomFloor = (roomParts.valWhich({x: x.ofKind(Floor)}))
/*
* Get any extra items in scope in this location. These are items
* that are to be in scope even if they're not reachable through any
* of the normal sense paths (so they'll be in scope even in the
* dark, for example).
*
* By default, if we have a floor, and the actor is directly in this
* room, we return our floor: this is because an actor is presumed to
* be in physical contact with the floor whenever directly in the
* room, and thus the actor would be aware that there's a floor
* there, even if the actor can't see the floor. In some rooms, it's
* desirable to have certain objects in scope because they're
* essential features of the room; for example, a location that is
* part of a stairway would probably have the stairs in scope by
* virtue of the actor standing on them.
*/
getExtraScopeItems(actor)
{
local floor;
/*
* if we have a floor, and the actor is in this room, explicitly
* make the floor in scope
*/
if ((floor = roomFloor) != nil && actor.isDirectlyIn(self))
return [floor];
else
return [];
}
/*
* When we're in the room, treat EXAMINE <ROOM> the same as LOOK
* AROUND. (This will only work if the room is given vocabulary
* like a normal object.)
*/
dobjFor(Examine)
{
verify()
{
/*
* When we're in the room, downgrade the likelihood a bit, as
* we'd rather inspect an object within the room if there's
* something with the same name. When we're *not* in the
* room - meaning this is a remote room that's visible from
* the player's location - downgrade the likelihood even
* more, since we're more likely to want to examine the room
* we're actually in than a remote room with the same name.
*/
if (gActor.isIn(self))
logicalRank(80, 'x room');
else
logicalRank(70, 'x room');
}
action()
{
/*
* if the looker is within the room, replace EXAMINE <self>
* with LOOK AROUND; otherwise, use the normal description
*/
if (gActor.isIn(self) && gActor.canSee(self))
gActor.lookAround(LookRoomDesc | LookListSpecials
| LookListPortables);
else
inherited();
}
}
/* treat LOOK IN <room> as EXAMINE <room> */
dobjFor(LookIn) remapTo(Examine, self)
/* LOOK UNDER and BEHIND are illogical */
dobjFor(LookUnder) { verify { illogical(&cannotLookUnderMsg); } }
dobjFor(LookBehind) { verify { illogical(&cannotLookBehindMsg); } }
/* treat SMELL/LISTEN TO <room> as just SMELL/LISTEN */
dobjFor(Smell) remapTo(SmellImplicit)
dobjFor(ListenTo) remapTo(ListenImplicit)
/* map STAND/SIT/LIE ON <room> to my default floor */
dobjFor(StandOn) maybeRemapTo(roomFloor != nil, StandOn, roomFloor)
dobjFor(SitOn) maybeRemapTo(roomFloor != nil, SitOn, roomFloor)
dobjFor(LieOn) maybeRemapTo(roomFloor != nil, LieOn, roomFloor)
/*
* treat an explicit GET OUT OF <ROOM> as OUT if there's an apparent
* destination for OUT; otherwise treat it as "vague travel," which
* simply tells the player that they need to specify a direction
*/
dobjFor(GetOutOf)
{
remap()
{
/* remap only if this isn't an implied action */
if (gAction.parentAction == nil)
{
/*
* if we have an apparent Out connection, go there;
* otherwise it's not obvious where we're meant to go
*/
if (out != nil && out.isConnectorApparent(self, gActor))
return [OutAction];
else
return [VagueTravelAction];
}
/* don't remap here - use the standard handling */
return inherited();
}
}
/*
* for BOARD and ENTER, there are three possibilities:
*
* - we're already directly in this room, in which case it's
* illogical to travel here again
*
* - we're in a nested room within this room, in which case ENTER
* <self> is the same as GET OUT OF <outermost nested room within
* self>
*
* - we're in a separate top-level room that's connected by a sense
* connector, in which case ENTER <self> should be handled as TRAVEL
* VIA <connector from actor's current location to self>
*/
dobjFor(Board) asDobjFor(Enter)
dobjFor(Enter)
{
verify()
{
/*
* if we're already here, entering the same location is
* redundant; if we're not in a nested room, we need a travel
* connector to get there from here
*/
if (gActor.isDirectlyIn(self))
illogicalAlready(&alreadyInLocMsg);
else if (!gActor.isIn(self)
&& gActor.location.getConnectorTo(gActor, self) == nil)
illogicalNow(&whereToGoMsg);
}
preCond()
{
/*
* if we're in a different top-level room, and there's a
* travel connector, we'll simply travel via the connector,
* so we don't need to impose any pre-conditions of our own
*/
if (!gActor.isIn(self)
&& gActor.location.getConnectorTo(gActor, self) != nil)
return [];
/*
* if we're in a nested room within this object, we'll
* replace the action with "get out of <outermost nested
* room>", so there's no need for any extra preconditions
* here
*/
if (gActor.isIn(self) && !gActor.isDirectlyIn(self))
return [];
/* otherwise, use the default conditions */
return inherited();
}
action()
{
/*
* if we're in a nested room, get out; otherwise travel via a
* suitable travel connector
*/
if (gActor.isIn(self) && !gActor.isDirectlyIn(self))
{
/*
* get out of the *outermost* nested room - that is, our
* direct child that contains the actor
*/
local chi = contents.valWhich({x: gActor.isIn(x)});
/* if we found it, get out of it */
if (chi != nil)
replaceAction(GetOutOf, chi);
}
else
{
/* get the connector from here to there */
local conn = gActor.location.getConnectorTo(gActor, self);
/* if we found it, go that way */
if (conn != nil)
replaceAction(TravelVia, conn);
}
/*
* if we didn't replace the action yet, we can't figure out
* how to get here from the actor's current location
*/
reportFailure(&whereToGoMsg);
}
}
;
/*
* A dark room, which provides no light of its own
*/
class DarkRoom: Room
/*
* turn off the lights
*/
brightness = 0
;
/*
* An outdoor location. This differs from an indoor location in that it
* has ground and sky rather than floor and ceiling, and has no walls.
*/
class OutdoorRoom: Room
/* an outdoor room has ground and sky, but no walls */
roomParts = [defaultGround, defaultSky]
;
/*
* A shipboard room. This is a simple mix-in class: it can be used
* along with any type of Room to indicate that this room is aboard a
* ship. When a room is aboard a ship, the shipboard travel directions
* (port, starboard, fore, aft) are allowed; these directions normally
* make no sense.
*
* This is a mix-in class rather than a Room subclass to allow it to be
* used in conjunction with any other Room subclass. To make a room
* shipboard, simply declare your room like this:
*
* mainDeck: Shipboard, Room // etc
*/
class Shipboard: object
/* mark the location as being aboard ship */
isShipboard = true
;
/*
* For convenience, we define ShipboardRoom as a shipboard version of the
* basic Room type.
*/
class ShipboardRoom: Shipboard, Room
;
/* ------------------------------------------------------------------------ */
/*
* Make a room "floorless." This is a mix-in class that you can include
* in a superclass list ahead of Room or any of its subclasses to create
* a room where support is provided by some means other than standing on
* a surface, or where there's simply no support. Examples: hanging on a
* rope over a chasm; climbing a ladder; in free-fall after jumping out
* of a plane; levitating in mid-air.
*
* There are two main special features of a floorless room. First, and
* most obviously, there's no "floor" or "ground" object among the room
* parts. We accomplish this by simply subtracting out any object of
* class Floor from the room parts list inherited from the combined base
* room class.
*
* Second, there's no place to put anything down, so objects dropped here
* either disappear from the game or are transported to another location
* (the room at the bottom of the chasm, for example).
*/
class Floorless: object
/*
* Omit the default floor/ground objects from the room parts list.
* Room classes generally have static room parts lists, so calculate
* this once per instance and store the results.
*
* NOTE - if you combine Floorless with a base Room class that has a
* dynamic room parts list, you'll need to override this to calculate
* the subset dynamically on each invocation.
*/
roomParts = perInstance(inherited().subset({x: !x.ofKind(Floor)}))
/*
* The room below, if any - this is where objects dropped here will
* actually end up. By default, this is nil, which means that
* objects dropped here simply disappear from the game. If there's a
* "bottom of chasm" location where dropped objects should land,
* provide it here.
*/
bottomRoom = nil
/* receive a dropped object */
receiveDrop(obj, desc)
{
/*
* move the dropped object to the room at the bottom of whatever
* it is we're suspended over; if there is no bottom room, we'll
* simply remove the dropped object from the game
*/
obj.moveInto(bottomRoom);
/*
* Say that the object drops out of sight below. Build this by
* combining the generic report prefix from the drop descriptor
* with our generic suffix, which describes the object as
* vanishing below.
*/
mainReport(desc.getReportPrefix(obj, self)
+ gActor.getActionMessageObj().floorlessDropMsg(obj));
}
;
/*
* For convenience, provide a combination of Floorless with the ordinary
* Room.
*/
class FloorlessRoom: Floorless, Room;
/* ------------------------------------------------------------------------ */
/*
* Room Part - base class for "parts" of rooms, such as floors and walls.
* Room parts are unusual in a couple of ways.
*
* First, room parts are frequently re-used widely throughout a game. We
* define a single instance of each of several parts that are found in
* typical rooms, and then re-use those instances in all rooms with those
* parts. For example, we define one "default floor" object, and then
* use that object in most or all rooms that have floors. We do this for
* efficiency, to avoid creating hundreds of essentially identical copies
* of the common parts.
*
* Second, because room parts are designed to be re-used, things that are
* in or on the parts are actually represented in the containment model
* as being directly in their containing rooms. For example, an object
* that is said to be "on the floor" actually has its 'location' property
* set to its immediate room container, and the 'contents' list that
* contains the object is that of the room, not of the floor object. We
* must therefore override some of the normal handling for object
* locations within room parts, in order to make it appear (for the
* purposes of command input and descriptive messages) that the things
* are in/on their room parts, even though they're not really represented
* that way in the containment model.
*/
class RoomPart: Fixture
/*
* When we explicitly examine a RoomPart, list any object that's
* nominally contained in the room part, as long it doesn't have a
* special description for the purposes of the room part. (If it
* does have a special description, then examining the room part will
* automatically display that special desc, so we don't want to
* include the object in a separate list of miscellaneous contents of
* the room part.)
*/
isObjListedInRoomPart(obj)
{
/*
* list the object *unless* it has a special description for the
* purposes of examining this room part
*/
return !obj.useSpecialDescInRoomPart(self);
}
/*
* Add this room part to the given room.
*
* Room parts don't have normal "location" properties. Instead, a
* room part explicitly appears in the "roomParts" list of each room
* that contains it. For the most part, room parts are static -
* they're initialized in the room definitions and never changed.
* However, if you need to dynamically add a room part to a room
* during the game, you can do so using this method.
*/
moveIntoAdd(room)
{
/* add me to the room's 'roomParts' and 'contents' lists */
room.roomParts += self;
room.contents += self;
}
/*
* Remove this room part from the given room. This can be used if
* it's necessary to remove the room part dynamically from a room.
*/
moveOutOf(room)
{
/* remove me from the room's 'roomParts' and 'contents' lists */
room.roomParts -= self;
room.contents -= self;
}
/*
* Don't include room parts in 'all'. Room parts are so ubiquitous
* that we never want to assume that they're involved in a command
* except when it is specifically so stated.
*/
hideFromAll(action) { return true; }
/* do allow use as a default, though */
hideFromDefault(action) { return nil; }
/*
* When multiple room parts show up in a resolve list, and some of
* the parts are local to the actor's immediate location and others
* aren't, keep only the local ones. This helps avoid pointless
* ambiguity in cases where two (or more) top-level locations are
* linked with a sense connector, and one or the other location has
* custom room part objects.
*/
filterResolveList(lst, action, whichObj, np, requiredNum)
{
/* if a definite number of objects is required, check ambiguity */
if (requiredNum != nil)
{
/* get the subset that's just RoomParts */
local partLst = lst.subset({x: x.obj_.ofKind(RoomPart)});
/*
* get the *remote* subset - this is the subset that's not in
* the outermost room of the target actor
*/
local outer = action.actor_.getOutermostRoom();
local remoteLst = partLst.subset({x: !x.obj_.isIn(outer)});
/*
* If all of the objects are remote, or all of them are
* local, we can't narrow things down on this basis; but if
* we found some remote and some local, eliminate the remote
* items, since we want to favor the local ones
*/
if (remoteLst.length() not in (0, partLst.length()))
lst -= remoteLst;
}
/* now do any inherited work, and return the result */
return inherited(lst, action, whichObj, np, requiredNum);
}
/*
* Since room parts are generally things like walls and floors that
* enclose the entire room, they're typically visually large, and
* tend to have fairly large-scale details (such as doors and
* windows). So, by default we set the sightSize to 'large' so that
* the details are visible at a distance.
*/
sightSize = large
/*
* as with decorations, downgrade the likelihood for Examine, as the
* standard walls, floors, etc. are pretty much background noise
* that are just here in case someone wants to refer to them
* explicitly
*/
dobjFor(Examine)
{
verify()
{
inherited();
logicalRank(70, 'x decoration');
}
}
/* describe the status - shows the things that are in/on the part */
examineStatus()
{
/* show the contents of the room part */
examinePartContents(&descContentsLister);
}
/* show our contents */
examinePartContents(listerProp)
{
/*
* Get my location, as perceived by the actor - this is the room
* that contains this part. If I don't have a location as
* perceived by the actor, then we can't show any contents.
*/
local loc = gActor.location.getRoomPartLocation(self);
if (loc == nil)
return;
/*
* create a copy of the lister customized for this part, if we
* haven't already done so
*/
if (self.(listerProp).part_ == nil)
{
self.(listerProp) = self.(listerProp).createClone();
self.(listerProp).part_ = self;
}
/* show the contents of the containing location */
self.(listerProp).showList(gActor, self, loc.contents, 0, 0,
gActor.visibleInfoTable(), nil);
}
/*
* show our special contents - this shows objects with special
* descriptions that are specifically in this room part
*/
examineSpecialContents()
{
local infoTab;
local lst;
/* get the actor's list of visible items */
infoTab = gActor.visibleInfoTable();
/*
* get the list of special description items, using only the
* subset that uses special descriptions in this room part
*/
lst = specialDescList(infoTab,
{obj: obj.useSpecialDescInRoomPart(self)});
/* show the list */
specialContentsLister.showList(gActor, nil, lst, 0, 0, infoTab, nil);
}
/*
* Get the destination for a thrown object that hits me. Since we
* don't have a real location, we must ask the actor for our room
* part location, and then use its hit-and-fall destination.
*/
getHitFallDestination(thrownObj, path)
{
local loc;
local dest;
/*
* if we have an explicit location, start with it; otherwise, ask
* the actor's location to find us; if we can't even find
* ourselves there, just use the actor's current location
*/
if ((loc = location) == nil
&& (loc = gActor.location.getRoomPartLocation(self)) == nil)
loc = gActor.location;
/* use the location's drop destination for thrown objects */
dest = loc.getDropDestination(thrownObj, path);
/* give the destination a chance to make adjustments */
return dest.adjustThrowDestination(thrownObj, path);
}
/* consider me to be in any room of which I'm a part */
isIn(loc)
{
local rpl;
/*
* get the room-part location of this room part, from the
* perspective of the prospective location we're asking about
*/
if (loc != nil && (rpl = loc.getRoomPartLocation(self)) != nil)
{
/*
* We indeed have a room part location in the given
* location, so we're a part of the overall location. We
* might be directly in the location (i.e., 'rpl' could
* equal 'loc'), or we might be somewhere relative to 'loc'
* (for example, we could be within a nested room within
* 'loc', in which case 'rpl' is a nested room unequal to
* 'loc' but is within 'loc'). So, if 'rpl' equals 'loc' or
* is contained in 'loc', I'm within 'loc', because I'm
* within 'rpl'.
*/
if (rpl == loc || rpl.isIn(loc))
return true;
}
/*
* we don't appear to be in 'loc' on the basis of our special
* room-part location; fall back on the inherited handling
*/
return inherited(loc);
}
/* our contents listers */
contentsLister = roomPartContentsLister
descContentsLister = roomPartDescContentsLister
lookInLister = roomPartLookInLister
specialContentsLister = specialDescLister
/* look in/on: show our contents */
dobjFor(LookIn)
{
verify() { }
action()
{
/* show my contents */
examinePartContents(&lookInLister);
/* show my special contents */
examineSpecialContents();
}
}
/* we can't look behind/through/under a room part by default */
nothingUnderMsg = &cannotLookUnderMsg
nothingBehindMsg = &cannotLookBehindMsg
nothingThroughMsg = &cannotLookThroughMsg
/*
* initialization - add myself to my location's roomPart list if I
* have an explicit location
*/
initializeThing()
{
/* do the normal work first */
inherited();
/*
* if I have an explicit location, and I'm not in my location's
* roomPart list, add myself to the list
*/
if (location != nil && location.roomParts.indexOf(self) == nil)
location.roomParts += self;
}
;
/*
* A floor for a nested room. This should be placed directly within a
* nested room object if the nested room is to be described as having a
* floor separate from the nested room itself. We simply remap any
* commands relating to using the floor as a surface (Put On, Throw At,
* Sit On, Lie On, Stand On) to the enclosing nested room.
*/
class NestedRoomFloor: Fixture
iobjFor(PutOn) remapTo(PutOn, DirectObject, location)
iobjFor(ThrowAt) remapTo(ThrowAt, DirectObject, location)
dobjFor(SitOn) remapTo(SitOn, location)
dobjFor(LieOn) remapTo(LieOn, location)
dobjFor(StandOn) remapTo(StandOn, location)
;
/*
* Base class for the default floor and the default ground of a top-level
* room. The floor and ground are where things usually go when dropped,
* and they're the locations where actors within a room are normally
* standing.
*/
class Floor: RoomPart
/* specifically allow me as a default for STAND ON, SIT ON, and LIE ON */
hideFromDefault(action)
{
/* don't hide from STAND ON, SIT ON, LIE ON */
if (action.ofKind(StandOnAction)
|| action.ofKind(SitOnAction)
|| action.ofKind(LieOnAction))
return nil;
/* for other actions, use the standard handling */
return inherited(action);
}
/*
* When explicitly examining a Floor object, list any objects that
* are listed in the normal room description (as in LOOK AROUND). By
* default, the floor is the nominal container for anything directly
* in the room, so we'll normally want LOOK AROUND and LOOK AT FLOOR
* to produce the same list of objects.
*/
isObjListedInRoomPart(obj)
{
/* list the object if it's listed in a normal LOOK AROUND */
return obj.isListed;
}
/*
* 'put x on floor' equals 'drop x'. Add a precondition that the
* drop destination is the main room, since otherwise we could have
* strange results if we dropped something inside a nested room.
*/
iobjFor(PutOn)
{
preCond()
{
/*
* require that this floor object itself is reachable, and
* that the drop destination for the direct object is an
* outermost room
*/
return [touchObj, new ObjectPreCondition(
gDobj, dropDestinationIsOuterRoom)];
}
verify() { }
action() { replaceAction(Drop, gDobj); }
}
/*
* The message we use to describe this object prepositionally, as the
* destination of a throw or drop. This should be a gLibMessages
* property with the appropriate prepositional phrase. We use a
* custom message specific to floor-like objects.
*/
putDestMessage = &putDestFloor
/* 'throw x at floor' */
iobjFor(ThrowAt)
{
check()
{
/*
* If I'm reachable, suggest just putting it down instead.
* We only make the suggestion, rather than automatically
* treating the command as DROP, because a player explicitly
* typing THROW <obj> AT FLOOR is probably attempting to
* express something more violent than merely putting the
* object down; the player probably is thinking in terms of
* breaking the object (or the floor).
*/
if (canBeTouchedBy(gActor))
{
mainReport(&shouldNotThrowAtFloorMsg);
exit;
}
}
}
/* is the given actor already on the floor? */
isActorOnFloor(actor)
{
/*
* the actor is on the floor if the actor is directly in the
* floor's room-part-location for the actor's location
*/
return actor.isDirectlyIn(actor.location.getRoomPartLocation(self));
}
/* verify sitting/standing/lying on the floor */
verifyEntry(newPosture, alreadyMsg)
{
/*
* If we're already in my location, and we're in the desired
* posture, this command is illogical because we're already
* where they want us to end up. Otherwise, it's logical to
* stand/sit/lie on the floor, but rank it low since we don't
* want the floor to interfere with selecting a default if
* there's anything around that's actually like a chair.
*
* If it's logical, note that we've verified okay for the
* action. On a future pass, we might have enforced a
* precondition that moved us here, at which point our work will
* be done - but we don't want to complain in that case, since
* it was logical from the player's perspective to carry out the
* command even though we have nothing left to do.
*/
if (gActor.posture == newPosture
&& isActorOnFloor(gActor)
&& gAction.verifiedOkay.indexOf(self) == nil)
{
/* we're already on the floor in the desired posture */
illogicalNow(alreadyMsg);
}
else
{
/*
* it's logical, but rank it low in case there's something
* more special we can stand/sit/lie on
*/
logicalRank(50, 'on floor');
/*
* note that we've verified okay, so we don't complain on a
* future pass if we discover that a precondition has
* brought us into compliance with the request prematurely
*/
gAction.verifiedOkay += self;
}
}
/* perform sitting/standing/lying on the floor */
performEntry(newPosture)
{
/*
* bring the new posture into effect; there's no need for
* actually moving the actor, since the preconditions will have
* moved us to our main enclosing room already
*/
gActor.makePosture(newPosture);
/* report success */
defaultReport(&roomOkayPostureChangeMsg, newPosture, self);
}
/* 'stand on floor' causes actor to stand in the containing room */
dobjFor(StandOn)
{
preCond = [touchObj,
new ObjectPreCondition(gActor.location.getOutermostRoom(),
actorDirectlyInRoom)]
verify() { verifyEntry(standing, &alreadyStandingOnMsg); }
action() { performEntry(standing); }
}
/* 'sit on floor' causes the actor to sit in the containing room */
dobjFor(SitOn)
{
preCond = [touchObj,
new ObjectPreCondition(gActor.location.getOutermostRoom(),
actorDirectlyInRoom)]
verify() { verifyEntry(sitting, &alreadySittingOnMsg); }
action() { performEntry(sitting); }
}
/* 'lie on floor' causes the actor to lie down in the room */
dobjFor(LieOn)
{
preCond = [touchObj,
new ObjectPreCondition(gActor.location.getOutermostRoom(),
actorDirectlyInRoom)]
verify() { verifyEntry(lying, &alreadyLyingOnMsg); }
action() { performEntry(lying); }
}
/*
* Mention that an actor is here, as part of a room description.
* When the actor is standing, just say that the actor is here, since
* it's overstating the obvious to say that the actor is standing on
* the floor. For other postures, do mention the floor.
*/
roomActorHereDesc(actor)
{
/*
* if we're standing, just say that the actor is "here";
* otherwise, say that the actor is sitting/lying/etc on self
*/
if (actor.posture == standing)
gLibMessages.roomActorHereDesc(actor);
else
gLibMessages.actorInRoom(actor, self);
}
/*
* Mention that an actor is here, as part of a room description.
* Since a floor is a trivial part of its enclosing room, there's no
* point in mentioning that we're on the floor, as that's stating the
* obvious; instead, simply describe the actor as being in the
* actor's actual enclosing room.
*/
roomActorThereDesc(actor) { actor.location.roomActorThereDesc(actor); }
/*
* Show our room name status for an actor on the floor. Since
* standing on the floor is the trivial default for any room, we
* won't bother mentioning it. Other postures we'll mention the same
* way we would for any nested room.
*/
roomActorStatus(actor)
{
if (actor.posture != standing)
gLibMessages.actorInRoomStatus(actor, self);
}
/*
* Show the actor's posture here. When we're standing on the floor,
* don't mention the posture, as this is too trivial a condition to
* state. Otherwise, mention it as normal for a nested room.
*/
roomActorPostureDesc(actor)
{
if (actor.posture != standing)
gLibMessages.actorInRoomPosture(actor, self);
}
/*
* Generate an acknowledgment for a posture change here. If the
* actor is standing, just say "okay, you're now standing" without
* mentioning the floor, since standing on the floor is the trivial
* default. For other postures, say that we're sitting/lying/etc on
* the floor.
*/
roomOkayPostureChange(actor)
{
if (actor.posture == standing)
defaultReport(&okayPostureChangeMsg, standing);
else
defaultReport(&roomOkayPostureChangeMsg, actor.posture, self);
}
/*
* mention the actor as part of the EXAMINE description of a nested
* room containing the actor
*/
roomListActorPosture(actor)
{
/*
* Since standing is the default posture for an actor, and since
* the floor (or equivalent) is the default place to be standing,
* don't bother mentioning actors standing on a floor.
* Otherwise, mention that the actor is sitting/lying/etc here.
*/
if (actor.posture != standing)
gLibMessages.actorInRoom(actor, self);
}
/*
* Prefix and suffix messages for listing a group of actors
* nominally on the this floor. Actors are said to be on the floor
* when they're really in the location containing the floor.
*
* If we're talking about a remote location, simply describe it as
* the location rather than mentioning the floor, since the floor is
* a trivial part of the remote location not worth mentioning.
*
* If we're local, and we're standing, we'll simply say that we're
* "standing here"; again, saying that we're standing on the floor
* is stating the obvious. If we're not standing, we will mention
* that we're on the floor.
*/
actorInGroupPrefix(pov, posture, remote, lst)
{
if (remote != nil)
gLibMessages.actorThereGroupPrefix(pov, posture, remote, lst);
else if (posture == standing)
gLibMessages.actorHereGroupPrefix(posture, lst);
else
gLibMessages.actorInGroupPrefix(posture, self, lst);
}
actorInGroupSuffix(pov, posture, remote, lst)
{
if (remote != nil)
gLibMessages.actorThereGroupSuffix(pov, posture, remote, lst);
else if (posture == standing)
gLibMessages.actorHereGroupSuffix(posture, lst);
else
gLibMessages.actorInGroupSuffix(posture, self, lst);
}
;
/* ------------------------------------------------------------------------ */
/*
* Define the default room parts.
*/
/*
* the default floor, for indoor locations
*/
defaultFloor: Floor
;
/*
* the default ceiling, for indoor locations
*/
defaultCeiling: RoomPart
;
/*
* The default walls, for indoor locations. We provide a north, south,
* east, and west wall in each indoor location by default.
*/
class DefaultWall: RoomPart
;
defaultNorthWall: DefaultWall
;
defaultSouthWall: DefaultWall
;
defaultEastWall: DefaultWall
;
defaultWestWall: DefaultWall
;
/*
* the default sky, for outdoor locations
*/
defaultSky: Distant, RoomPart
;
/*
* The default ground, for outdoor locations.
*/
defaultGround: Floor
;
/* ------------------------------------------------------------------------ */
/*
* A "room part item" is an object that's specially described as being
* part of, or attached to, a RoomPart (a wall, ceiling, floor, or the
* like). This is a mix-in class that can be combined with any ordinary
* object class (but usually with something non-portable, such as a
* Fixture or Immovable). The effect of adding RoomPartItem to an
* object's superclasses is that a command like EXAMINE EAST WALL (or
* whichever room part the object is associated with) will display the
* object's specialDesc, but a simple LOOK will not. This class is
* sometimes useful for things like doors, windows, ceiling fans, and
* other things attached to the room.
*
* Note that this is a mix-in class, so you should always combine it with
* a regular Thing-based class.
*
* When using this class, you should define two properties in the object:
* specialNominalRoomPartLocation, which you should set to the RoomPart
* (such as a wall) where the object should be described; and
* specialDesc, which is the description to show when the room part is
* examined. Alternatively (or in addition), you can define
* initNominalRoomPartLocation and initSpecialDesc - these work the same
* way, but will only be in effect until the object is moved.
*/
class RoomPartItem: object
/*
* show our special description when examining our associated room
* part, as long as we actually define a special description
*/
useSpecialDescInRoomPart(part)
{
/* only show the special description in our associated room part */
if (!isNominallyInRoomPart(part))
return nil;
/*
* if we define an initial special description, and this is our
* nominal room part for that description, use it
*/
if (isInInitState
&& propType(&initSpecialDesc) != TypeNil
&& initNominalRoomPartLocation == part)
return true;
/* likewise for our specialDesc */
if (propType(&specialDesc) != TypeNil
&& specialNominalRoomPartLocation == part)
return true;
/* otherwise, don't use the special description */
return nil;
}
/*
* don't use the special description in room descriptions, or in
* examining any other container
*/
useSpecialDescInRoom(room) { return nil; }
useSpecialDescInContents(cont) { return nil; }
;
/* ------------------------------------------------------------------------ */
/*
* A Nested Room is any object that isn't a room but which can contain
* an actor: chairs, beds, platforms, vehicles, and the like.
*
* An important property of nested rooms is that they're not
* full-fledged rooms for the purposes of actor arrivals and departures.
* Specifically, an actor moving from a room to a nested room within the
* room does not trigger an actor.travelTo invocation, but simply moves
* the actor from the containing room to the nested room. Moving from
* the nested room to the containing room likewise triggers no
* actor.travelTo invocation. The travelTo method is not applicable for
* intra-room travel because no TravelConnector objects are traversed in
* such travel; we simply move in and out of contained objects. To
* mitigate this loss of notification, we instead call
* actor.travelWithin() when moving among nested locations.
*
* By default, an actor attempting to travel from a nested location via
* a directional command will simply attempt the travel as though the
* actor were in the enclosing location.
*/
class NestedRoom: BasicLocation
/*
* Our interior room name. This is the status line name we display
* when an actor is within this object and can't see out to the
* enclosing room. Since we can't rely on the enclosing room's
* status line name if we can't see the enclosing room, we must
* provide one of our own.
*
* By default, we'll use our regular name.
*/
roomName = (name)
/*
* Show our interior room description. We use this to generate the
* long "look" description for the room when an actor is within the
* room and cannot see the enclosing room.
*
* Note that this is used ONLY when the actor cannot see the
* enclosing room - when the enclosing room is visible (because the
* nested room is something like a chair that doesn't enclose the
* actor, or can enclose the actor but is open or transparent), then
* we'll simply use the description of the enclosing room instead,
* adding a note to the short name shown at the start of the room
* description indicating that the actor is in the nested room.
*
* By default, we'll show the appropriate "actor here" description
* for the posture, so we'll say something like "You are sitting on
* the red chair" or "You are in the phone booth." Instances can
* override this to customize the description with something more
* detailed, if desired.
*/
roomDesc
{
local pov = getPOVActorDefault(gActor);
pov.listActorPosture(pov);
}
/*
* The maximum bulk the room can hold. We'll define this to a large
* number by default so that bulk isn't a concern.
*
* Lower numbers here can be used, for example, to limit the seating
* capacity of a chair.
*/
bulkCapacity = 10000
/*
* Check for ownership. For a nested room, an actor can be taken to
* own the nested room by virtue of being inside the room - the
* chair Bob is sitting in can be called "bob's chair".
*
* If we don't have an explicit owner, and the potential owner 'obj'
* is in me and can own me, we'll report that 'obj' does in fact own
* me. Otherwise, we'll defer to the inherited implementation.
*/
isOwnedBy(obj)
{
/*
* if we're not explicitly owned, and 'obj' can own me, and
* 'obj' is inside me, consider us owned by 'obj'
*/
if (owner == nil && obj.isIn(self) && obj.canOwn(self))
return true;
/* defer to the inherited definition of ownership */
return inherited(obj);
}
/*
* Get the extra scope items within this room. Normally, the
* immediately enclosing nested room is in scope for an actor in the
* room. So, if the actor is directly in 'self', return 'self'.
*/
getExtraScopeItems(actor)
{
/* if the actor is directly in the nested room, return it */
if (actor.isDirectlyIn(self))
return [self];
else
return [];
}
/*
* By default, 'out' within a nested room should take us out of the
* nested room itself. The easy way to accomplish this is to set up
* a 'nestedRoomOut' connector for the nested room, which will
* automatically try a GET OUT command. If we didn't do this, we'd
* *usually* pick up the noTravelOut from our enclosing room, but
* only when the enclosing room didn't override 'out' to point
* somewhere else. Explicitly setting up a 'noTravelOut' here
* ensures that we'll consistently GET OUT of the nested room even if
* the enclosing room has its own 'out' destination.
*
* Note that nestedRoomOut shows as a listed exit in exit listings
* (for the EXITS command and in the status line). If you don't want
* OUT to be listed as an available exit for the nested room, you
* should override this to use noTravelOut instead.
*/
out = nestedRoomOut
/*
* An actor is attempting to "get out" while in this location. By
* default, we'll treat this as getting out of this object. This
* can be overridden if "get out" should do something different.
*/
disembarkRoom()
{
/* run the appropriate command to get out of this nested room */
removeFromNested();
}
/*
* Make the actor stand up from this location. By default, we'll
* cause the actor to travel (using travelWithin) to our container,
* and assume the appropriate posture for the container.
*/
makeStandingUp()
{
/* remember the old posture, in case the travel fails */
local oldPosture = gActor.posture;
/* get the exit destination; if there isn't one, we can't proceed */
local dest = exitDestination;
if (dest == nil)
{
reportFailure(&cannotDoFromHereMsg);
exit;
}
/*
* Set the actor's posture to the default for the destination.
* Do this before effecting the actual travel, so that the
* destination can change this default if it wants.
*/
gActor.makePosture(dest.defaultPosture);
/* protect against 'exit' and the like during the travel attempt */
try
{
/*
* move the actor to our exit destination, traveling entirely
* within nested locations
*/
gActor.travelWithin(dest);
}
finally
{
/* if we didn't end up traveling, restore the old posture */
if (gActor.isIn(self))
gActor.makePosture(oldPosture);
}
/* generate the appropriate default for the new location */
gActor.okayPostureChange();
}
/*
* Try an implied command to move the actor from outside of this
* nested room into this nested room. This must be overridden in
* subclasses to carry out the appropriate implied command. Returns
* the result of tryImplicitAction().
*
* This is called when we need to move an actor into this location
* as part of an implied command. We use an overridable method
* because different kinds of nested rooms have different commands
* for entering: SIT ON CHAIR, LIE ON BED, GET IN CAR, RIDE BIKE,
* and so on. This should be normally be overridden imply by
* calling tryImplicitAction() with the appropriate command for the
* specific type of nested room, and returning the result.
*/
tryMovingIntoNested()
{
/* do nothing by default - subclasses must override */
return nil;
}
/*
* message property to use for reportFailure when
* tryMovingIntoNested fails
*/
mustMoveIntoProp = nil
/*
* Try an implied command to remove an actor from this location and
* place the actor in my immediate containing location. This must
* be overridden in subclasses to carry out the appropriate implied
* command. Returns the result of tryImplicitAction().
*
* This is essentially the reverse of tryMovingIntoNested(), and
* should in most cases be implemented by calling
* tryImplicitAction() with the appropriate command to get out of
* the room, and returning the result.
*/
tryRemovingFromNested()
{
/* do nothing by default - subclasses must override */
return nil;
}
/*
* Replace the current action with one that removes the actor from
* this nested room. This is used to implement the GET OUT command
* when the actor is directly in this nested room. In most cases,
* this should simply be implemented with a call to replaceAction()
* with the appropriate command.
*/
removeFromNested()
{
/* subclasses must override */
}
/*
* Try moving the actor into this location. This is used to move
* the actor into this location as part of meeting preconditions,
* and we use the normal precondition check protocol: we return nil
* if the condition (actor is in this room) is already met; we
* return true if we successfully execute an implied command to meet
* the condition; and we report a failure message and terminate the
* command with 'exit' if we don't know how to meet the condition or
* the implied command we try to execute fails or fails to satisfy
* the condition.
*
* This does not normally need to be overridden in subclasses.
*/
checkMovingActorInto(allowImplicit)
{
/* if the actor is within me, use default handling */
if (gActor.isIn(self))
return inherited(allowImplicit);
/* try an implied command to move the actor into this nested room */
if (allowImplicit && tryMovingIntoNested())
{
/* if we didn't succeed, terminate the command */
if (!gActor.isDirectlyIn(self))
exit;
/* tell the caller we executed an implied command */
return true;
}
/*
* if we can be seen, report that the actor must travel here
* first; if we can't be seen, simply say that this can't be done
* from here
*/
if (gActor.canSee(self))
{
/* report that we have to move into 'self' first */
reportFailure(mustMoveIntoProp, self);
}
else
{
/*
* we can't be seen; simply say this we can't do this command
* from the current location
*/
reportFailure(&cannotDoFromHereMsg);
}
/* terminate the action */
exit;
}
/*
* Check, using pre-condition rules, that the actor is removed from
* this nested location and moved to my immediate location. This is
* used to enforce a precondition that the actor is in the enclosing
* location.
*
* This isn't normally overridden in subclasses.
*/
checkActorOutOfNested(allowImplicit)
{
/* try removing the actor from this nested location */
if (allowImplicit && tryRemovingFromNested())
{
/*
* make sure we managed to move the actor to our exit
* destination
*/
if (!gActor.isDirectlyIn(exitDestination))
exit;
/* indicate that we carried out an implied command */
return true;
}
/* we can't carry out our implied departure plan - fail */
reportFailure(&cannotDoFromMsg, self);
exit;
}
/*
* Check, using pre-condition rules, that the actor is ready to
* enter this room as a nested location.
*
* This isn't normally overridden in subclasses.
*/
checkActorReadyToEnterNestedRoom(allowImplicit)
{
/*
* If the actor is directly in this room, we obviously need do
* nothing, as the actor is already in this nested room.
*/
if (gActor.isDirectlyIn(self))
return nil;
/*
* If the actor isn't within us (directly or indirectly), we
* must move the actor to a valid "staging location," so that
* the actor can move from the staging location into us. (A
* staging location is simply any location from which we can
* move directly into this nested room without any intervening
* travel in or out of other nested rooms.)
*/
if (!gActor.isIn(self))
return checkActorInStagingLocation(allowImplicit);
/*
* The actor is within us, but isn't directly within us, so
* handle this with the normal routine to move the actor into
* this room.
*/
return checkMovingActorInto(allowImplicit);
}
/*
* Check, using precondition rules, that the actor is in a valid
* "staging location" for entering this nested room. We'll ensure
* that the actor is directly in one of the locations in our
* stagingLocations list, running an appropriate implicit command to
* move the actor to the first item in that list if the actor isn't
* in any of them.
*
* This isn't normally overridden in subclasses.
*/
checkActorInStagingLocation(allowImplicit)
{
local lst;
local target;
/* get the list of staging locations */
lst = stagingLocations;
/* if there are no valid staging locations, we can't move here */
if (lst.length() == 0)
{
cannotMoveActorToStagingLocation();
exit;
}
/*
* Try each of the locations in our staging list, to see if the
* actor is directly in any of them.
*/
foreach (local cur in lst)
{
/*
* if the actor is directly in this staging location, then
* the actor can reach the destination with no additional
* intervening travel - simply return nil in this case to
* indicate that no implicit commands are needed before the
* proposed nested room entry
*/
if (gActor.isDirectlyIn(cur))
return nil;
}
/*
* The actor isn't directly in any staging location, so we must
* move the actor to an appropriate staging location before we
* can proceed. Choose a staging location based on the actor's
* current location.
*/
if ((target = chooseStagingLocation()) != nil)
{
/*
* We've chosen a target staging location. First, check to
* make sure the location we've chosen is valid - we might
* have chosen a default (such as the nested room's
* immediate container) that isn't usable as a staging
* location, so we need to check with it first to make sure
* it's willing to allow this.
*/
target.checkStagingLocation(self);
/*
* The check routine didn't abort the command, so try an
* appropriate implicit command to move the actor into the
* chosen staging location.
*/
return target.checkMovingActorInto(allowImplicit);
}
/*
* There's no apparent intermediate staging location given the
* actor's current location. We thus cannot proceed with the
* command; simply report that we can't get there from here.
*/
cannotMoveActorToStagingLocation();
exit;
}
/*
* Choose an intermediate staging location, given the actor's
* current location. This routine is called when the actor is
* attempting to move into 'self', but isn't in any of the allowed
* staging locations for 'self'; this routine's purpose is to choose
* the staging location that the actor should implicitly try to
* reach on the way to 'self'.
*
* By default, we'll attempt to find the first of our staging
* locations that indirectly contains the actor. (We know none of
* the staging locations directly contains the actor, because if one
* did, we wouldn't be called in the first place - we're only called
* when the actor isn't already directly in one of our staging
* locations.) This approach is appropriate when nested rooms are
* related purely by containment: if an actor is in a nested room
* within one of our staging locations, we can reach that staging
* location by having the actor get out of the more deeply nested
* room.
*
* However, this default approach is not appropriate when nested
* rooms are related in some way other than simple containment. We
* don't have any general framework for other types of nested room
* relationships, so this routine must be overridden in such a case
* with special-purpose code defining the special relationship.
*
* If we fail to find any staging location indirectly containing the
* actor, we'll return the result of defaultStagingLocation().
*/
chooseStagingLocation()
{
/* look for a staging location indirectly containing the actor */
foreach (local cur in stagingLocations)
{
/*
* if the actor is indirectly in this staging location,
* choose it as the target intermediate staging location
*/
if (gActor.isIn(cur))
return cur;
}
/*
* We didn't find any locations in the staging list that
* indirectly contain the actor, so use the default staging
* location.
*/
return defaultStagingLocation();
}
/*
* The default staging location for this nested room. This is the
* staging location we'll attempt to reach implicitly if the actor
* isn't in any of the rooms in the stagingLocations list already.
* We'll return the first element of our stagingLocations list for
* which isStagingLocationKnown returns true.
*/
defaultStagingLocation()
{
local lst;
/* get the list of valid staging locations */
lst = stagingLocations;
/* find the first element which is known to the actor */
foreach (local cur in lst)
{
/* if this staging location is known, take it as the default */
if (isStagingLocationKnown(cur))
return cur;
}
/* we didn't find any known staging locations - there's no default */
return nil;
}
/*
* Report that we are unable to move an actor to any staging
* location for this nested room. By default, we'll generate the
* message "you can't do that from here," but this can overridden to
* provide a more specific if desired.
*/
cannotMoveActorToStagingLocation()
{
/* report the standard "you can't do that from here" message */
reportFailure(&cannotDoFromHereMsg);
}
/*
* Report that we are unable to move an actor out of this nested
* room, because there's no valid 'exit destination'. This is
* called when we attempt to GET OUT OF the nested room, and the
* 'exitDestination' property is nil.
*/
cannotMoveActorOutOf()
{
/* report the standard "you can't do that from here" message */
reportFailure(&cannotDoFromHereMsg);
}
/*
* The valid "staging locations" for this nested room. This is a
* list of the rooms from which an actor can DIRECTLY reach this
* nested room; in other words, the actor will be allowed to enter
* 'self', with no intervening travel, if the actor is directly in
* any of these locations.
*
* If the list is empty, there are no valid staging locations.
*
* The point of listing staging locations is to make certain that
* the actor has to go through one of these locations in order to
* get into this nested room. This ensures that we enforce any
* conditions or trigger any side effects of moving through the
* staging locations, so that a player can't bypass a puzzle by
* trying to move directly from one location to another without
* going through the required intermediate steps. Since we always
* require that an actor go through one of our staging locations in
* order to enter this nested room, and since we carry out the
* travel to the staging location using implied commands (which are
* just ordinary commands, entered and executed automatically by the
* parser), we can avoid having to code any checks redudantly in
* both the staging locations and any other nearby locations.
*
* By default, an actor can only enter a nested room from the room's
* direct container. For example, if a chair is on a stage, an
* actor must be standing on the stage before the actor can sit on
* the chair.
*/
stagingLocations = [location]
/*
* Our exit destination. This is where an actor ends up when the
* actor is immediately inside this nested room and uses a "get out
* of" or equivalent command to exit the nested room.
*
* By default, we'll use the default staging location as the exit
* destination.
*/
exitDestination = (defaultStagingLocation())
/*
* Is the given staging location "known"? This returns true if the
* staging location is usable as a default, nil if not. If this
* returns true, then the location can be used in an implied command
* to move the actor to the staging location in order to move the
* actor into self.
*
* If this returns nil, no implied command will be attempted for
* this possible staging location. This doesn't mean that an actor
* gets a free pass through the staging location; on the contrary,
* it simply means that we won't try any automatic command to move
* an actor to the staging location, hence travel from a non-staging
* location to this nested room will simply fail. This can be used
* when part of the puzzle is to figure out that moving to the
* staging location is required in the first place: if we allowed an
* implied command in such cases, we'd give away the puzzle by
* solving it automatically.
*
* By default, we'll treat all of our staging locations as known.
*/
isStagingLocationKnown(loc) { return true; }
/*
* Get the travel preconditions for an actor in this location. By
* default, if we have a container, and the actor can see the
* container, we'll return its travel preconditions; otherwise, we'll
* use our inherited preconditions.
*/
roomTravelPreCond()
{
local ret;
/*
* If we can see out to our location, use the location's
* conditions, since by default we'll try traveling from the
* location; if we can't see out to our location, we won't be
* attempting travel through our location's connectors, so use
* our own preconditions instead.
*/
if (location != nil && gActor.canSee(location))
ret = location.roomTravelPreCond();
else
ret = inherited();
/* return the results */
return ret;
}
/*
* We cannot take a nested room that the actor is occupying
*/
dobjFor(Take)
{
verify()
{
/* it's illogical to take something that contains the actor */
if (gActor.isIn(self))
illogicalNow(&cannotTakeLocationMsg);
/* inherit the default handling */
inherited();
}
}
/*
* "get out of" action - exit the nested room
*/
dobjFor(GetOutOf)
{
preCond()
{
return [new ObjectPreCondition(self, actorDirectlyInRoom)];
}
verify()
{
/*
* the actor must be located on the platform; but allow the
* actor to be indirectly on the platform, since we'll use a
* precondition to move the actor out of any more nested
* rooms within us
*/
if (!gActor.isIn(self))
illogicalNow(¬OnPlatformMsg);
}
check()
{
/*
* If we have no 'exit destination' - that is, we have
* nowhere to go when we GET OUT OF the nested room - then
* prohibit the operation.
*/
if (exitDestination == nil)
{
/* explain the problem and terminate the command */
cannotMoveActorOutOf();
exit;
}
}
action()
{
/* travel to our get-out-of destination */
gActor.travelWithin(exitDestination);
/*
* set the actor's posture to the default posture for the
* new location
*/
gActor.makePosture(gActor.location.defaultPosture);
/* issue a default report of the change */
defaultReport(&okayNotStandingOnMsg);
}
}
/* explicitly define the push-travel indirect object mappings */
mapPushTravelIobj(PushTravelGetOutOf, TravelVia)
;
/* ------------------------------------------------------------------------ */
/*
* A "high nested room" is a nested room that is elevated above the rest
* of the room. This specializes the staging location handling so that
* it generates more specific messages.
*/
class HighNestedRoom: NestedRoom
/* report that we're unable to move to a staging location */
cannotMoveActorToStagingLocation()
{
reportFailure(&nestedRoomTooHighMsg, self);
}
/* if we can't get out, report that it's because we're too high up */
cannotMoveActorOutOf()
{
reportFailure(&nestedRoomTooHighToExitMsg, self);
}
/*
* Staging locations. By default, we'll return an empty list,
* because a high location is not usually reachable directly from its
* containing location.
*
* Note that puzzles involving moving platforms will have to manage
* this list dynamically, which could be done either by writing a
* method here that returns a list of currently valid staging
* locations, or by adding objects to this list as they become valid
* staging locations and removing them when they cease to be. For
* example, if we have an air vent in the ceiling that we can only
* reach when a chair is placed under the vent, this property could
* be implemented as a method that returns a list containing the
* chair only when the chair is in the under-the-vent state.
*
* Note that this empty default setting will also give us no exit
* destination, since the default exit location is the default
* staging location.
*/
stagingLocations = []
;
/* ------------------------------------------------------------------------ */
/*
* A chair is an item that an actor can sit on. When an actor is sitting
* on a chair, the chair contains the actor. In addition to sitting,
* chairs can optionally allow standing as well.
*
* We define the "BasicChair" as something that an actor can sit on, and
* then subclass this with the standard "Chair", which adds surface
* capabilities.
*/
class BasicChair: NestedRoom
/*
* A list of the allowed postures for this object. By default, we
* can sit and stand on a chair, since most ordinary chairs are
* suitable for both.
*/
allowedPostures = [sitting, standing]
/*
* A list of the obvious postures for this object. The only obvious,
* default thing you do with most ordinary chairs is sit on them,
* even they allow other postures. Something like a large sofa might
* want to allow both sitting and lying.
*
* This list differs from the allowed postures list because some
* postures might be possible but not probable. For most ordinary
* chairs, standing is possible, but it's not the first thing you'd
* think of doing with the chair.
*/
obviousPostures = [sitting]
/*
* A chair's effective follow location is usually its location's
* effective follow location, because we don't usually want to treat
* a chair as a separate location for the purposes of "follow."
* That is, if A and B are in the same room, and A sits down on a
* chair in the room, we don't want to count this as a move that B
* could follow.
*/
effectiveFollowLocation = (location.effectiveFollowLocation)
/*
* Try an implied command to move the actor from outside of this
* nested room into this nested room. By default, we'll call upon
* our default posture object to activate its command to move the
* actor into this object in the default posture. For a chair, the
* default posture is typically sitting, so the 'sitting' posture
* will perform a SIT ON <self> command.
*/
tryMovingIntoNested()
{
/*
* ask our default posture object to carry out the appropriate
* command to move the actor into 'self' in that posture
*/
return defaultPosture.tryMakingPosture(self);
}
/* tryMovingIntoNested failure message is "must sit on chair" */
mustMoveIntoProp = &mustSitOnMsg
/* default posture in this nested room is sitting */
defaultPosture = sitting
/*
* by default, objects dropped while sitting in a chair go into the
* enclosing location's drop destination
*/
getDropDestination(obj, path)
{
return location != nil
? location.getDropDestination(obj, path)
: self;
}
/*
* Remove an actor from the chair. By default, we'll simply stand
* up, since this is the normal way out of a chair.
*/
tryRemovingFromNested()
{
/* try standing up */
if (gActor.posture == sitting)
return tryImplicitAction(Stand);
else
return tryImplicitAction(GetOffOf, self);
}
/*
* Run the appropriate command to remove us from this nested
* container, as a replacement command.
*/
removeFromNested()
{
/* to get out of a chair, we simply stand up */
if (gActor.posture == sitting)
replaceAction(Stand);
else
replaceAction(GetOutOf, self);
}
/*
* "sit on" action
*/
dobjFor(SitOn)
{
preCond = (preCondForEntry(sitting))
verify()
{
/* verify entering the chair in a 'sitting' posture */
if (verifyEntry(sitting, &alreadySittingOnMsg, &noRoomToSitMsg))
inherited();
}
action()
{
/* enter the chair in the 'sitting' posture */
performEntry(sitting);
}
}
/*
* "stand on" action
*/
dobjFor(StandOn)
{
/* if it's allowed, use the same preconditions as 'sit on' */
preCond = (preCondForEntry(standing))
verify()
{
/* verify entering in a 'standing' posture */
if (verifyEntry(standing, &alreadyStandingOnMsg,
&noRoomToStandMsg))
inherited();
}
action()
{
/* enter the chair in the 'standing' posture */
performEntry(standing);
}
}
/*
* "lie on" action
*/
dobjFor(LieOn)
{
preCond = (preCondForEntry(lying))
verify()
{
/* verify entering in a 'lying' posture */
if (verifyEntry(lying, &alreadyLyingOnMsg, &noRoomToLieMsg))
inherited();
}
action()
{
/* enter in the 'lying' posture */
performEntry(lying);
}
}
/*
* For "get on/in" / "board", let our default posture object handle
* it, by running the appropriate nested action that moves the actor
* into self in the default posture.
*/
dobjFor(Board)
{
verify() { }
action() { defaultPosture.setActorToPosture(gActor, self); }
}
/* "get off of" is the same as "get out of" */
dobjFor(GetOffOf) asDobjFor(GetOutOf)
/* standard preconditions for sitting/lying/standing on the chair */
preCondForEntry(posture)
{
/*
* if this is not among my allowed postures, we don't need any
* special preconditions, since we'll fail in the verify
*/
if (allowedPostures.indexOf(posture) == nil)
return inherited();
/*
* in order to enter the chair, we have to be able to touch it
* and we have to be able to enter it as a nested room
*/
return [touchObj,
new ObjectPreCondition(self, actorReadyToEnterNestedRoom)];
}
/*
* Verify that we can enter the chair in the given posture. This
* performs verification work common to SIT ON, LIE ON, and STAND ON.
* If this returns true, the caller should inherit the base class
* default handling, otherwise it shouldn't.
*/
verifyEntry(posture, alreadyMsg, noRoomMsg)
{
/*
* if the given posture isn't allowed, tell the caller to use the
* inherited default handling
*/
if (allowedPostures.indexOf(posture) == nil)
return true;
/* this posture is allowed, but it might not be obvious */
if (obviousPostures.indexOf(posture) == nil)
nonObvious;
/*
* If the actor is already on this chair in the given posture,
* this action is redundant. If we already verified okay on this
* point for this same action, ignore the repeated command - it
* must mean that we applied a precondition that did all of our
* work for us (such as moving us out of a nested room
* immediately within us).
*/
if (gActor.posture == posture && gActor.isDirectlyIn(self)
&& gAction.verifiedOkay.indexOf(self) == nil)
illogicalNow(alreadyMsg);
else
gAction.verifiedOkay += self;
/*
* If there's not room for the actor's added bulk, don't allow
* the actor to sit/lie/stand on the chair. If the actor is
* already within the chair, there's no need to add the actor's
* bulk for this change, since it's already counted as being
* within us.
*/
if (!gActor.isIn(self)
&& getBulkWithin() + gActor.getBulk() > bulkCapacity)
illogicalNow(noRoomMsg);
/* we can't sit/stand/lie on something the actor is holding */
if (isIn(gActor))
illogicalNow(&cannotEnterHeldMsg);
/*
* if the actor is already in me, but in a different posture,
* boost the likelihood slightly
*/
if (gActor.isDirectlyIn(self) && gActor.posture != posture)
logicalRank(120, 'already in');
/* tell the caller we don't want to inherit the base class handling */
return nil;
}
/*
* Perform entry in the given posture. This carries out the common
* actions for SIT ON, LIE ON, and STAND ON.
*/
performEntry(posture)
{
/*
* Move the actor into me - this counts as interior travel within
* the enclosing room. Note that we move the actor before
* changing the actor's posture in case the travel fails.
*/
gActor.travelWithin(self);
/* set the actor to the desired posture */
gActor.makePosture(posture);
/* report success */
defaultReport(&roomOkayPostureChangeMsg, posture, self);
}
;
/*
* A Chair is a basic chair with the addition of being a Surface.
*/
class Chair: BasicChair, Surface
/*
* By default, a chair has a seating capacity of one person, so use
* a maximum bulk that only allows one actor to occupy the chair at
* a time.
*/
bulkCapacity = 10
;
/*
* Bed. This is an extension of Chair that allows actors to lie on it
* as well as sit on it. As with chairs, we have a basic bed, plus a
* regular bed that serves as a surface as well.
*/
class BasicBed: BasicChair
/*
* we can sit, lie, and stand on a typical bed, but only sitting and
* lying are obvious default actions
*/
allowedPostures = [sitting, lying, standing]
obviousPostures = [sitting, lying]
/* tryMovingIntoNested failure message is "must sit on chair" */
mustMoveIntoProp = &mustLieOnMsg
/* default posture in this nested room is sitting */
defaultPosture = lying
;
/*
* A Bed is a basic bed with the addition of Surface capabilities.
*/
class Bed: BasicBed, Surface
;
/*
* A Platform is a nested room upon which an actor can stand. In
* general, when you can stand on something, you can also sit and lie on
* it as well (it might not be comfortable, but it is usually at least
* possible), so we make this a subclass of Bed.
*
* The main difference between a platform and a chair that allows
* standing is that a platform is more of a mini-room. In particular,
* items an actor drops while standing on a platform land on the platform
* itself, whereas items dropped while sitting (or standing) on a chair
* land in the enclosing room. In addition, the obvious default action
* for a chair is to sit on it, while the obvious default action for a
* platform is to stand on it.
*/
class BasicPlatform: BasicBed
/*
* we can sit, lie, and stand on a typical platform, and all of
* these could be reasonably expected to be done
*/
allowedPostures = [sitting, lying, standing]
obviousPostures = [sitting, lying, standing]
/* an actor can follow another actor onto or off of a platform */
effectiveFollowLocation = (self)
/* tryMovingIntoNested failure message is "must get on platform" */
mustMoveIntoProp = &mustGetOnMsg
/* default posture in this nested room is sitting */
defaultPosture = standing
/* by default, objects dropped on a platform go onto the platform */
getDropDestination(obj, path)
{
return self;
}
/*
* Remove an actor from the platform. "Get off" is the normal
* command to leave a platform.
*/
tryRemovingFromNested()
{
/* try getting off of the platform */
return tryImplicitAction(GetOffOf, self);
}
/*
* Replace the current action with one that removes the actor from
* this nested room.
*/
removeFromNested()
{
/* get off of the platform */
replaceAction(GetOffOf, self);
}
/*
* Make the actor stand up. On a platform, standing is normally
* allowed, so STAND doesn't usually imply "get off platform" as it
* does in the base class.
*/
makeStandingUp()
{
/*
* If standing isn't among my allowed postures, inherit the
* default behavior, which is to get out of the nested room.
*/
if (allowedPostures.indexOf(standing) == nil)
{
/* we can't stand on the platform, so use the default handling */
inherited();
}
else
{
/* we can stand on the platform, so make the actor stand */
gActor.makePosture(standing);
/* issue a default report of the change */
defaultReport(&roomOkayPostureChangeMsg, standing, self);
}
}
/*
* Traveling 'down' from a platform should generally be taken to
* mean 'get off platform'.
*/
down = noTravelDown
;
/*
* A Platform is a basic platform with the addition of Surface behavior.
*/
class Platform: BasicPlatform, Surface
;
/*
* A "nominal platform" is a named place where NPC's can stand. This
* class makes it easy to arrange for an NPC to be described as standing
* in a particular location in the room: for example, we could have an
* actor "standing in a doorway", or "leaning against the streetlamp."
*
* In most cases, a nominal platform is a "secret" object, in that it
* won't be listed in a room's contents and it won't have any vocabulary
* words. So, the player will never be able to refer to the object in a
* command.
*
* To use this class, instantiate it with an object located in the room
* containing the pseudo-platform. Don't give the object any vocabulary
* words. Locate actors within the pseudo-platform to give them the
* special description.
*
* For simple platform-like "standing on" descriptions, just define the
* name. For descriptions like "standing in", "standing under", or
* "standing near", where only the preposition needs to be customized,
* define the name and define actorInPrep. For more elaborate
* customizations, such as "leaning against the streetlamp", you'll need
* to override roomActorHereDesc, roomActorStatus, roomActorPostureDesc,
* roomListActorPosture, and actorInGroupPrefix/Suffix,
*/
class NominalPlatform: Fixture, Platform
/* don't let anyone stand/sit/lie here via a command */
dobjFor(StandOn) { verify() { illogical(&cannotStandOnMsg); } }
dobjFor(SitOn) { verify() { illogical(&cannotSitOnMsg); } }
dobjFor(LieOn) { verify() { illogical(&cannotLieOnMsg); } }
/* ignore me for 'all' and object defaulting */
hideFromAll(action) { return true; }
hideFromDefault(action) { return true; }
/*
* nominal platforms are internal objects only, not part of the
* visible game world structure, so treat them as equivalent to their
* location for FOLLOW purposes
*/
effectiveFollowLocation = (location.effectiveFollowLocation)
;
/*
* A booth is a nested room that serves as a small enclosure within a
* larger room. Booths can serve as regular containers as well as
* nested rooms, and can be made openable by addition of the Openable
* mix-in class. Note that booths don't have to be fully enclosed, nor
* do they actually have to be closable.
*
* Examples of booths: a cardboard box large enough for an actor can
* stand in; a closet; a shallow pit.
*/
class Booth: BasicPlatform, Container
/*
* Try an implied command to move the actor from outside of this
* nested room into this nested room.
*/
tryMovingIntoNested()
{
/* try getting in me */
return tryImplicitAction(Board, self);
}
/*
* Remove an actor from the booth. "Get out" is the normal command
* to leave this type of room.
*/
tryRemovingFromNested()
{
/* try getting out of the object */
return tryImplicitAction(GetOutOf, self);
}
/*
* Replace the current action with one that removes the actor from
* this nested room.
*/
removeFromNested()
{
/* get out of the object */
replaceAction(GetOutOf, self);
}
/*
* "Enter" is equivalent to "get in" (or "board") for a booth
*/
dobjFor(Enter) asDobjFor(Board)
/* explicitly define the push-travel indirect object mapping */
mapPushTravelIobj(PushTravelEnter, Board)
;
/* ------------------------------------------------------------------------ */
/*
* A Vehicle is a special type of nested room that moves instead of the
* actor in response to travel commands. When an actor in a vehicle
* types, for example, "go north," the vehicle moves north, not the
* actor.
*
* In most cases, a Vehicle should multiply inherit from one of the
* other nested room subclasses to make it more specialized. For
* example, a bicycle might inherit from Chair, so that actors can sit
* on the bike.
*
* Note that because Vehicle inherits from NestedRoom, the OUT direction
* in the vehicle by default means what it does in NestedRoom -
* specifically, getting out of the vehicle. This is appropriate for
* vehicles where we'd describe passengers as being inside the vehicle,
* such as a car or a boat. However, if the vehicle is something you
* ride on, like a horse or a bike, it's probably more appropriate for
* OUT to mean "ride the vehicle out of the enclosing room." To get
* this effect, simply override the "out" property and set it to nil;
* this will prevent the NestedRoom definition from being inherited,
* which will make us look for the OUT location of the enclosing room as
* the travel destination.
*/
class Vehicle: NestedRoom, Traveler
/*
* When a traveler is in a vehicle, and the traveler performs a
* travel command, the vehicle is what changes location; the
* contained traveler simply stays put while the vehicle moves.
*/
getLocTraveler(trav, conn)
{
local stage;
/*
* If the connector is contained within the vehicle, take it as
* leading out of the vehicle - this means we want to move
* traveler within the vehicle rather than the vehicle.
* Consider the connector be inside the vehicle if it's a
* physical object (a Thing) that's inside the vehicle, or one
* of the vehicle's own directional links points directly to the
* connector.
*
* Likewise, if the connector is marked with the vehicle or any
* object inside the vehicle as its staging location, the
* vehicle obviously isn't involved in the travel.
*/
if ((conn != nil && conn.ofKind(Thing) && conn.isIn(self))
|| Direction.allDirections.indexWhich(
{dir: self.(dir.dirProp) == conn}) != nil
|| ((stage = conn.connectorStagingLocation) != nil
&& (stage == self || stage.isIn(self))))
{
/*
* this connector leads out from within the vehicle - move
* the inner traveler rather than the vehicle itself
*/
return trav;
}
/*
* If we have a location, ask it who travels when the VEHICLE is
* the traveler within it; otherwise, the vehicle is the
* traveler.
*
* We ask the location, because the location might itself be a
* vehicle, in which case it might want us to be driving around
* the enclosing vehicle. However, we pass ourselves (i.e.,
* this vehicle) as the inner traveler, rather than the traveler
* we were passed, because a traveler within a vehicle moves the
* vehicle when traveling.
*/
return (location != nil ? location.getLocTraveler(self, conn) : self);
}
/*
* An OUT command while within a vehicle could mean one of two
* things: either to GET OUT of the vehicle, or to ride/drive the
* vehicle out of its enclosing location.
*
* There's no good way of guessing which meaning the player intends,
* so we have to choose one or the other. We choose the ride/drive
* interpretation as the default, for two reasons. First, it seems
* to be what most players expect. Second, the other interpretation
* leaves no standard way of expressing the ride/drive meaning. We
* return nil here to indicate to the OUT action that we want the
* enclosing location's 'out' connector to be used while an actor is
* in the vehicle.
*
* For some vehicles, it might be more appropriate for OUT to mean
* GET OUT. In these cases, simply override this so that it returns
* nestedRoomOut.
*/
out = nil
/*
* Get the "location push traveler" - this is the traveler when a
* push-travel command is performed by a traveler within this
* location. If the object we're trying to push is within me, use
* the contained traveler, since the contained traveler must be
* trying to push the object around directly. If the object isn't
* inside me, then we're presumably trying to use the vehicle to push
* around the object, so the traveler is the vehicle or something
* containing the vehicle.
*/
getLocPushTraveler(trav, obj)
{
/*
* If the object is inside me, use the nested traveler;
* otherwise, we're presumably trying to use the vehicle to move
* the object.
*/
if (obj.isIn(self))
{
/*
* we're moving something around inside me; use the
* contained traveler
*/
return trav;
}
else if (location != nil)
{
/*
* we're pushing something around outside me, so we're
* probably trying to use the vehicle to do so; we have a
* location, so ask it what it thinks, passing myself as the
* new suggested traveler
*/
return location.getLocPushTraveler(self, obj);
}
else
{
/*
* we're pushing something around outside me, and I have no
* location, so I must be the traveler
*/
return self;
}
}
/*
* Determine if an actor is traveling with me. The normal base
* class implementation works, but it's more efficient just to check
* to see if the actor is inside this object than to construct the
* entire nested contents list just to check to see if the actor's
* in that list.
*/
isActorTraveling(actor) { return actor.isIn(self); }
/* invoke a callback for each actor traveling with us */
forEachTravelingActor(func)
{
/* invoke the callback on each actor in our contents */
allContents().forEach(function(obj) {
if (obj.isActor)
(func)(obj);
});
}
/*
* Get the actors involved in the travel. This is a list consisting
* of all of the actors contained within the vehicle.
*/
getTravelerActors = (allContents().subset({x: x.isActor}))
/*
* there are no self-motive actors in a vehicle - the vehicle is
* doing the travel, and the actors within are just moving along
* with it as cargo
*/
getTravelerMotiveActors = []
/*
* Traveler preconditions for the vehicle. By default, we add no
* preconditions of our own, but specific vehicles might want to
* override this. For example, a car might want to require that the
* doors are closed, the engine is running, and the seatbelts are
* fastened before it can travel.
*/
travelerPreCond(conn) { return []; }
/*
* Check, using pre-condition rules, that the traveler is in the
* given room, moving the traveler to the room if possible.
*/
checkMovingTravelerInto(room, allowImplicit)
{
/* if we're in the desired location, we're set */
if (isDirectlyIn(room))
return nil;
/*
* By default, we can't move a vehicle into a room implicitly.
* Individual vehicles can override this when there's an obvious
* way of moving the vehicle in and out of nested rooms.
*/
reportFailure(&vehicleCannotDoFromMsg, self);
exit;
}
/*
* the lister object we use to display the list of actors aboard, in
* arrival and departure messages for the vehicle
*/
aboardVehicleListerObj = aboardVehicleLister
;
/*
* A VehicleBarrier is a TravelConnector that allows actors to travel,
* but blocks vehicles. By default, we block all vehicles, but
* subclasses can customize this so that we block only specific
* vehicles.
*/
class VehicleBarrier: TravelBarrier
/*
* Determine if the given traveler can pass through this connector.
* By default, we'll return nil for a Vehicle, true for anything
* else. This can be overridden to allow specific vehicles to pass,
* or to filter on any other criteria.
*/
canTravelerPass(traveler) { return !traveler.ofKind(Vehicle); }
/* explain why we can't pass */
explainTravelBarrier(traveler)
{
reportFailure(&cannotGoThatWayInVehicleMsg, traveler);
}
;
TADS 3 Library Manual
Generated on 5/16/2013 from TADS version 3.1.3
Generated on 5/16/2013 from TADS version 3.1.3