TravelConnectorclass | travel.t[1186], objtime.t[348]

A TravelConnector is an object that can be attached to the directional exit property of a room to facilitate (or optionally block) travel in the associated direction and carry out any side-effects of that travel. A TravelConnector may be used as an abstract object to implement travel, or a subclass of TravelConnector such as Door, Passage, StairwayUp or StairwayDown may be used to represent a physical object via which travel occurs. The Room class also inherits from TravelConnector.

Whether the base TravelConnector class or one of its subclasses is used, travel is carried out via a TravelConnector by calling its travelVia() method.

Modified in objtime.t[348]:
Modifications to TravelConnector for the OBJTIME EXTENSION. The purpose of these modifications is to allow different TravelConnectors to take different amounts of time to traverse.

`class TravelConnector : object`

Superclass Tree (in declaration order)

`TravelConnector`
`object`

Subclass Tree

`TravelConnector`
`Door`
`DSDoor`
`SecretDoor`
`Passage`
`PathPassage`
`Room`
`OutdoorRoom`
`StairwayDown`
`StairwayUp`
`SymConnector`
`SymPassage`
`SymDoor`
`SymPathPassage`
`SymStairway`
`UnlistedProxyConnector`

Global Objects

`noExit`

Summary of Properties

`destination isConnectorApparent isConnectorListed isOpen PushTravelVia suppressTravelDescForPushTravel transmitsLight travelBarriers traversalTime traversed traversedBy`

Summary of Methods

`afterTravelNotifications beforeTravelNotifications canTravelerPass checkPushTravel checkTravelBarriers dobjFor(GoThrough) dobjFor(TravelVia) execTravel explainTravelBarrier getDepartingDirection getDestination getTraveler hasBeenTraversedBy iobjFor(PushTravelThrough) isConnectorVisible isDestinationKnown noteTraversal sayActorFollowing sayDeparting sayNoDestination travelDesc travelVia traversalMsg traversalTimeFrom`

Properties

`destination` | `travel.t[1225]`

The room to which this TravelConnector leads when it is traversed

`isConnectorApparent` | `travel.t[1194]`

Is this connector apparent? That is, would it be apparent to an observer under normal lighting conditions, as opposed to being concealed? By default we'll suppose a TravelConnector is apparent unless it's explicitly hidden.

`isConnectorListed` | `travel.t[1200]`

Should this exit be shown in the exit lister? By default we'll assumed it should be it it's visible.

`isOpen` | `travel.t[1250]`

A travel connector is usually open.

`PushTravelVia` | `travel.t[1616]`

The appropriate PushTravelAction for pushing something something through a TravelConnector.

`suppressTravelDescForPushTravel` | `travel.t[1624]`

If we display a message for pushing something via us, we probably don't also want the travelDesc describing the actor's travel. Game code can override if both messages are wanted when push-travelling.

`transmitsLight` | `travel.t[1206]`

Does light pass through this TravelConnector from its destination (so that it's visible in the dark even its location is dark.).

`travelBarriers` | `travel.t[1456]`

an additional TravelBarrier or a list of TravelBarriers to check on this TravelConnector to see if travel is allowed.

`traversalTime` | `objtime.t[353]`

The number of seconds it takes to traverse this connector (in addition to any that come from the Travel action). [OBJTIME EXTENSION ONLY]

`traversed` | `travel.t[1383]`

Have we been traversed by the player character? Return true if and only if we have.

`traversedBy` | `travel.t[1370]`

A list of the actors, vehicles and pushTraverers that have traversed this TravelConnector. This is maintained by the noteTraversal(), so game code should normally treat this property as read-only.

Methods

`afterTravelNotifications (actor)` | `travel.t[1405]`

Carry out the after travel notifications for this actor

`beforeTravelNotifications (actor)` | `travel.t[1386]`

Carry out the before travel notifications for this actor.

`canTravelerPass (actor)` | `travel.t[1429]`

Method that should return true is actor is allowed to pass through this TravelConnector and nil otherwise. We allow travel by default but this could be overridden to block travel under certain conditions.

`checkPushTravel ( )` | `travel.t[1600]`

Check the travel barriers on the indirect object of the action

`checkTravelBarriers (traveler)` | `travel.t[1464]`

Check all the travel barriers associated with this connector to determine whether the traveler is allowed to pass through this travel connector.

`dobjFor(GoThrough)` | `travel.t[1581]`

For now, we just call the travelVia() method on the TravelConnector. Subsequentlly we might add appropriate code for the other action phases.

`dobjFor(TravelVia)` | `travel.t[1566]`

The TravelVia action is supplied so game code can execute a TravelVia action on a TravelConnector; there is no TRAVEL VIA command that can be issued directly by a player, but a player command may be translated into this action.

`execTravel (actor, traveler, conn)` | `travel.t[1300]`

Execute the travel for this actor via this connector

`explainTravelBarrier (actor)` | `travel.t[1436]`

If canTravelerPass returns nil explainTravelBarrier should display a message explaining why travel has been prohibited.

`getDepartingDirection (traveler)` | `travel.t[1551]`

Get the direction traveler needs to go in to traverse this connector from traveler's current location.

`getDestination (origin)` | `travel.t[1231]`

The room to which this TravelConnector leads when it is traversed from origin.

`getTraveler (actor)` | `travel.t[1282]`

Get the traveler associated with this actor. Normally the traveler will be the same as the actor, but if the actor is in a vehicle, then the traveler will be the vehicle.

`hasBeenTraversedBy (traveler)` | `travel.t[1376]`

Test whether this TravelConnector has been traversed by traveler (which may be an actor, a vehicle, or something pushed through the TravelConnector by an actor).

`iobjFor(PushTravelThrough)` | `travel.t[1587]`

no description available

`isConnectorVisible ( )` | `travel.t[1213]`

A TravelConnector (or at least, the exit it represents) is visible if it's apparent (i.e. not concealed in some way) and if the lighting conditions are adequate, or if it's visible in the dark.

`isDestinationKnown ( )` | `travel.t[1242]`

Does the player char know where this travel connector leads? By default s/he doesn't until s/he's visited its destination, but this could be overridden for an area the PC is supposed to know well when the game starts, such as their own house.

`noteTraversal (actor)` | `travel.t[1347]`

If the actor doing the traveling is the player character, display the travelDesc. Note that although this might normally be a simple description of the travel, the travelDesc method could also be used to carry out any other side-effects of the travel via this connector.

`sayActorFollowing (follower, leader)` | `travel.t[1518]`

Display a message to say that follower is following leader in the direction of this connector.

`sayDeparting (traveler)` | `travel.t[1497]`

Display a message to say that an actor is departing via this connector. On the base class the default behaviour is to describe the departure via a compass direction. The actor in question would normally be an NPC visible to the player character.

`sayNoDestination ( )` | `travel.t[1335]`

Display a message saying that this travel connector doesn't actually lead anywhere; this may be needed if our destination is nil and our noteTraversal() method doesn't display anything.

`travelDesc ( )` | `travel.t[1446]`

Carry out any side effects of travel if the traveler is the player character. Typically we might just display some text describing the travel here, but this method could be used for any side-effects of the travel. If the TravelConnector is mixed in with an EventList class then the default behaviour is to call the doScript() method here to drive the EventList.

`travelVia (actor)` | `travel.t[1256]`

Carrier out travel via this connector, first checking that travel through this connector is permitted for this actor.

`traversalMsg ( )` | `travel.t[1539]`

Create a phrase describing the direction of travel through this connector (e.g. 'to the north')

`traversalTimeFrom (origin)` | `objtime.t[360]`

If we want to vary the time to go through this TravelConnector depending on where the traveler is starting from (only really relevant for rooms), we can override this method instead. [OBJTIME EXTENSION ONLY]

Adv3Lite Library Reference Manual
Generated on 01/03/2024 from adv3Lite version 1.6.2