Package com.planet_ink.coffee_mud.Libraries.interfaces

Interface TrackingLibrary

All Superinterfaces:

java.lang.Cloneable, CMLibrary, CMObject, java.lang.Comparable<CMObject>

All Known Implementing Classes:

MUDTracker

public interface TrackingLibrary
extends CMLibrary

The Tracking and NPC movement library. Contains functionality to map out regions of rooms for finding trails from one room to another, or for searching regions of rooms. This also contains methods for helping NPCs get around in a RP-friendly way. Another really important aspect of this library is the ability to filter rooms by criteria, in order to achieve trails that will work for players for npcs, and provide efficiency by skipping impassable terrain.

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static interface	TrackingLibrary.RFilter	A filtering interface for rooms, or for moving from a host room to a target room.
static interface	TrackingLibrary.RFilters	A filtering interface for rooms, or for moving from a host room to a target room.
static class	TrackingLibrary.TrackingFlag	A Tracking Flag is a form of RFiler that is an enum that includes various pre-configured rfilters used throughout the engine.
static interface	TrackingLibrary.TrackingFlags	A collection of tracking flags, which are really just RFilter objects wrappers.
static class	TrackingLibrary.TrailFlag	Trail flags when building a description of trail description.

Field Summary

Fields inherited from interface com.planet_ink.coffee_mud.core.interfaces.CMObject

idConverter

Method Summary

Modifier and Type	Method	Description
boolean	areNearEachOther(MOB whichM, MOB nearM)	Returns true if the two give mobs are in the same room, or adjacent rooms.
boolean	autoTrack(MOB mob, Room destR)	Starts the given mob tracking from their current location to the given room.
boolean	beMobile(MOB mob, boolean dooropen, boolean wander, boolean roomprefer, boolean roomobject, int[] status, java.util.Set<Room> rooms)	The random mobility method, for controlling movement of a move from one room to an ajacent one.
PairVector<Room,int[]>	buildGridList(Room room, java.lang.String ownerName, int maxDepth)	Builts a radiating room list that is assumed to be in grid formation, and owned as private property.
boolean	canValidTrail(Room startR, java.util.List<Room> radiantV, java.lang.String where, int radius, java.util.Set<Room> ignoreRooms, int maxSecs)	Searches for a room fitting to the given search string, within the given radiant rooms, with a trail fitting the given trail flags, optionally ignoring any ignore rooms.
MOB	createNavigationMob(NavigableItem ship)	When large sailing ships or caravans navigate from room to room, a fake temporary mob is used to represent the agency of the ship per se.
boolean	doFallenOffCheck(MOB mob)	If the given mob is riding anything, this will schedule a check to see if it is STILL riding.
Rideable	findALadder(MOB mob, Room room)	If theres a ladder that can be seen in the same room as the given mob, this returns it.
java.util.List<java.util.List<java.lang.Integer>>	findAllTrails(Room from, Room to, java.util.List<Room> radiantTrail)	Returns every trail found from the starting to the ending room, given a radiantTrail that includes both.
java.util.List<java.util.List<java.lang.Integer>>	findAllTrails(Room from, java.util.List<Room> tos, java.util.List<Room> radiantTrail)	Returns every trail found from the starting to each ending room, given a radiantTrail that includes all.
int	findExitDir(MOB mob, Room R, java.lang.String desc)	Given a mob with eyes, and their location, and a match string, this will attempt to match one of the exits and return it.
int	findRoomDir(MOB mob, Room R)	Given a mob and a room, returns the direction from the mobs direction to the target room, if possible.
java.util.List<Room>	findTrailToAnyRoom(Room location, TrackingLibrary.RFilter destFilter, TrackingLibrary.TrackingFlags flags, int maxRadius)	Returns a trail of rooms to move through in order to go from the given location to a room that is not filtered out of the destFilter.
java.util.List<Room>	findTrailToAnyRoom(Room location, java.util.List<Room> destRooms, TrackingLibrary.TrackingFlags flags, int maxRadius)	Returns a trail of rooms to move through in order to go from the given location to one of the given destination rooms.
java.util.List<Room>	findTrailToRoom(Room location, Room destRoom, TrackingLibrary.TrackingFlags flags, int maxRadius)	Returns a trail of rooms to move through in order to go from the given location to the given destination room.
java.util.List<Room>	findTrailToRoom(Room location, Room destRoom, TrackingLibrary.TrackingFlags flags, int maxRadius, java.util.List<Room> radiant)	Returns a trail of rooms to move through in order to go from the given location to the given destination room.
void	forceRecall(MOB mob, boolean includeFollowers)	Attempts to recall the given mob, and optinally all their followers, by generating a recall message and previewing and sending it.
Room	getCalculatedAdjacentGridRoom(PairVector<Room,int[]> rooms, Room R, int dir)	Given a set of rooms built with grid coordinates, and a starting room inside that grid, and a direction, this will return the adjacent room based on the built grid.
Room	getNearestValidIDRoom(Room R)	Based on radiating rooms from the given room, this will return the nearest room that has a valid room id.
java.util.List<Area>	getRadiantAreas(Area area, int maxDepth)	Generates an ordered list of areas radiating from the given area, with max depth.
java.util.List<Room>	getRadiantRooms(Room room, TrackingLibrary.RFilters filters, int maxDepth)	Generates an ordered list of rooms radiating from the given room, with max depth and optional room radiating filters.
java.util.List<Room>	getRadiantRooms(Room room, TrackingLibrary.TrackingFlags flags, int maxDepth)	Generates an ordered list of rooms radiating from the given room, with max depth and optional room radiating filters.
void	getRadiantRooms(Room room, java.util.List<Room> rooms, TrackingLibrary.RFilters filters, Room radiateTo, int maxDepth, java.util.Set<Room> ignoreRooms)	Generates an ordered list of rooms radiating from the given room, with max depth, and optional ignore rooms, and radiating room filters.
void	getRadiantRooms(Room room, java.util.List<Room> rooms, TrackingLibrary.TrackingFlags flags, Room radiateTo, int maxDepth, java.util.Set<Room> ignoreRooms)	Generates an ordered list of rooms radiating from the given room, with max depth, and optional stopping room, ignore rooms, and flags.
java.util.Enumeration<Room>	getRadiantRoomsEnum(Room room, TrackingLibrary.RFilters filters, Room radiateTo, int maxDepth, java.util.Set<Room> ignoreRooms)	Generates a enumerator for an ordered list of rooms radiating from the given room, with max depth, and optional ignore rooms, and radiating room filters.
boolean	getRadiantRoomsToTarget(Room room, java.util.List<Room> rooms, TrackingLibrary.TrackingFlags flags, TrackingLibrary.RFilter radiateTo, int maxDepth)	Generates an ordered list of rooms radiating from the given room, to a given target room filter in, with max depth, and optional ignore rooms, and radiating room filters/flags.
Room	getRadiantRoomTarget(Room room, TrackingLibrary.RFilters filters, TrackingLibrary.RFilter radiateTo)	Returns a room that is not filtered out of the rooms radiating from the given room.
java.util.List<java.lang.Integer>	getShortestTrail(java.util.List<java.util.List<java.lang.Integer>> finalSets)	Does nothing interesting.
java.lang.String	getTrailToDescription(Room startR, java.util.List<Room> radiantV, java.lang.String where, java.util.Set<TrackingLibrary.TrailFlag> trailFlags, int radius, java.util.Set<Room> ignoreRooms, int maxSecs)	Searches for a room fitting to the given search string, within the given radiant rooms, with a trail fitting the given trail flags, optionally ignoring any ignore rooms.
CMMsg.CheckedMsgResponse	isOkWaterSurfaceAffect(Room room, CMMsg msg)	Utility method for handling movement into a water surface type room.
boolean	makeFall(Physical P, Room room, boolean reverseFall)	Causes the given mob or item to 'fall' from one room to another, usually down, if it can.
void	makeSink(Physical P, Room room, boolean reverseSink)	Causes the given mob or item to 'sink' from one room to another, usually down, if it can.
void	markToWanderHomeLater(MOB M, int ticks)	Marks the mob with a temporary behavior that will force the mob to wander back to their start room as soon as possible.
TrackingLibrary.TrackingFlags	newFlags()	Constructs a new set of TrackingFlags, which are filters for use in radiant and room finding methods.
void	postMountLadder(MOB mob, Rideable ladder)	Causes the given mob to mount the given ladder.
int	radiatesFromDir(Room room, java.util.List<Room> rooms)	This method is helpful for traversing room trails.
boolean	run(MOB mob, int directionCode, boolean flee, boolean nolook, boolean noriders)	Causes the given mob to attempt to run in the given direction.
boolean	run(MOB mob, int directionCode, boolean flee, boolean nolook, boolean noriders, boolean always)	Causes the given mob to attempt to run in the given direction.
void	stopTracking(MOB mob)	Uninvokes and deletes any Tracking-related effects on the given mob.
int	trackNextDirectionFromHere(java.util.List<Room> theTrail, Room location, boolean openOnly)	Given a room trail, with the destination room first, and the location last, this will return the next direction to travel from the given location, optionally stopping at doors.
boolean	walk(Item I, int directionCode)	Narrates the movement of an item, usually a rideable, in a given direction, from its current location.
boolean	walk(MOB mob, int directionCode, boolean flee, boolean nolook)	Causes the given mob to attempt to walk in the given direction.
boolean	walk(MOB mob, int directionCode, boolean flee, boolean nolook, boolean noriders)	Causes the given mob to attempt to walk in the given direction.
boolean	walk(MOB mob, int directionCode, boolean flee, boolean nolook, boolean noriders, boolean always)	Causes the given mob to attempt to walk in the given direction.
void	walkForced(MOB M, Room fromHere, Room toHere, boolean andFollowers, boolean forceLook, java.lang.String msgStr)	Forces the given mob to leave the from room and enter to the room, without preview.
void	wanderAway(MOB M, boolean mindPCs, boolean andGoHome)	Forces the given mob to leave the room, for aesthetic purposes.
boolean	wanderCheckedAway(MOB M, boolean mindPCs, boolean andGoHome)	Forces the given mob to leave the room, for aesthetic purposes.
boolean	wanderCheckedFromTo(MOB M, Room toHere, boolean mindPCs)	Aesthetically transports a mob from their location to a target room by having them leave their current room legitimately, and enter the target one.
void	wanderFromTo(MOB M, Room toHere, boolean mindPCs)	Aesthetically transports a mob from their location to a target room by having them leave their current room legitimately, and enter the target one.
void	wanderIn(MOB M, Room toHere)	Aesthetically transports a mob from their location to a target room by having them leave their current room legitimately, and enter the target one.

Methods inherited from interface com.planet_ink.coffee_mud.Libraries.interfaces.CMLibrary

activate, getServiceClient, L, propertiesLoaded, shutdown

Methods inherited from interface com.planet_ink.coffee_mud.core.interfaces.CMObject

copyOf, ID, initializeClass, name, newInstance

Methods inherited from interface java.lang.Comparable

compareTo

Method Detail

findTrailToRoom

java.util.List<Room> findTrailToRoom(Room location,
                                     Room destRoom,
                                     TrackingLibrary.TrackingFlags flags,
                                     int maxRadius)

Returns a trail of rooms to move through in order to go from the given location to the given destination room. The trail will have the destination room first, and the location last.

Parameters:

location - the starting room for the trail

destRoom - the target room for the trail

flags - any Radiant flags -- not used in the trail calculation

maxRadius - maximum radius for the Radiant rooms

Returns:

the trail, or null if a failure

See Also:

trackNextDirectionFromHere(List, Room, boolean), findAllTrails(Room, List, List), findAllTrails(Room, Room, List), findTrailToAnyRoom(Room, List, TrackingFlags, int), findTrailToAnyRoom(Room, RFilter, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int, List), getShortestTrail(List), getTrailToDescription(Room, List, String, Set, int, Set, int), canValidTrail(Room, List, String, int, Set, int)

findTrailToRoom

java.util.List<Room> findTrailToRoom(Room location,
                                     Room destRoom,
                                     TrackingLibrary.TrackingFlags flags,
                                     int maxRadius,
                                     java.util.List<Room> radiant)

Returns a trail of rooms to move through in order to go from the given location to the given destination room. The trail will have the destination room first, and the location last. Providing radiant rooms is optional, but they should have the location first and destination last.

Parameters:

location - the starting room for the trail

destRoom - the target room for the trail

flags - any Radiant flags -- not used in the trail calculation

maxRadius - maximum radius for the Radiant rooms

radiant - optional radiant rooms list

Returns:

the trail, or null if a failure

See Also:

trackNextDirectionFromHere(List, Room, boolean), findAllTrails(Room, List, List), findAllTrails(Room, Room, List), findTrailToAnyRoom(Room, List, TrackingFlags, int), findTrailToAnyRoom(Room, RFilter, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int), getShortestTrail(List), getTrailToDescription(Room, List, String, Set, int, Set, int), canValidTrail(Room, List, String, int, Set, int)

findTrailToAnyRoom

java.util.List<Room> findTrailToAnyRoom(Room location,
                                        java.util.List<Room> destRooms,
                                        TrackingLibrary.TrackingFlags flags,
                                        int maxRadius)

Returns a trail of rooms to move through in order to go from the given location to one of the given destination rooms. It will prefer the closest, and prefer one in the same area as the start room. It does every search to make sure. The trail will have the destination room first, and the location last.

Parameters:

location - the starting room for the trail

destRooms - a list of rooms, any of which may be the destination

flags - any Radiant flags -- not used in the trail calculation

maxRadius - maximum radius for the Radiant rooms

Returns:

the trail, or null if a failure

See Also:

trackNextDirectionFromHere(List, Room, boolean), findAllTrails(Room, List, List), findAllTrails(Room, Room, List), findTrailToAnyRoom(Room, RFilter, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int, List), getShortestTrail(List), getTrailToDescription(Room, List, String, Set, int, Set, int), canValidTrail(Room, List, String, int, Set, int)

findTrailToAnyRoom

java.util.List<Room> findTrailToAnyRoom(Room location,
                                        TrackingLibrary.RFilter destFilter,
                                        TrackingLibrary.TrackingFlags flags,
                                        int maxRadius)

Returns a trail of rooms to move through in order to go from the given location to a room that is not filtered out of the destFilter. It will prefer the closest, and prefer one in the same area as the start room. It does every search to make sure. The trail will have the destination room first, and the location last.

Parameters:

location - the starting room for the trail

destFilter - a filter to identify the destination, by filtering OUT

flags - any Radiant flags -- not used in the trail calculation

maxRadius - maximum radius for the Radiant rooms

Returns:

the trail, or null if a failure

See Also:

trackNextDirectionFromHere(List, Room, boolean), findAllTrails(Room, List, List), findAllTrails(Room, Room, List), findTrailToAnyRoom(Room, List, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int, List), getShortestTrail(List), getTrailToDescription(Room, List, String, Set, int, Set, int), canValidTrail(Room, List, String, int, Set, int)

findAllTrails

java.util.List<java.util.List<java.lang.Integer>> findAllTrails(Room from,
                                                                Room to,
                                                                java.util.List<Room> radiantTrail)

Returns every trail found from the starting to the ending room, given a radiantTrail that includes both. The trails will have the direction from starting room first. Providing radiant rooms is required, and they should have the location first and destination last.

Parameters:

from - the starting room

to - the target room

radiantTrail - the radiant rooms from the starting room

Returns:

the set of all valid trails, as directions

See Also:

findAllTrails(Room, List, List), findTrailToAnyRoom(Room, List, TrackingFlags, int), findTrailToAnyRoom(Room, RFilter, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int, List), getShortestTrail(List), getTrailToDescription(Room, List, String, Set, int, Set, int), canValidTrail(Room, List, String, int, Set, int)

findAllTrails

java.util.List<java.util.List<java.lang.Integer>> findAllTrails(Room from,
                                                                java.util.List<Room> tos,
                                                                java.util.List<Room> radiantTrail)

Returns every trail found from the starting to each ending room, given a radiantTrail that includes all. The trails will have the direction from starting room first. Providing radiant rooms is required, and they should have the location first and destination last.

Parameters:

from - the starting room

tos - the target rooms

radiantTrail - the radiant rooms from the starting room

Returns:

the set of all valid trails, as directions

See Also:

findAllTrails(Room, Room, List), findTrailToAnyRoom(Room, List, TrackingFlags, int), findTrailToAnyRoom(Room, RFilter, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int, List), getShortestTrail(List), getTrailToDescription(Room, List, String, Set, int, Set, int), canValidTrail(Room, List, String, int, Set, int)

getShortestTrail

java.util.List<java.lang.Integer> getShortestTrail(java.util.List<java.util.List<java.lang.Integer>> finalSets)

Does nothing interesting. Just returns the shortest list of integers given a list of lists.

Parameters:

finalSets - the shorted list > 0

Returns:

the shortest list.

See Also:

findAllTrails(Room, List, List), findAllTrails(Room, Room, List), findTrailToAnyRoom(Room, List, TrackingFlags, int), findTrailToAnyRoom(Room, RFilter, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int, List), getTrailToDescription(Room, List, String, Set, int, Set, int), canValidTrail(Room, List, String, int, Set, int)

getTrailToDescription

java.lang.String getTrailToDescription(Room startR,
                                       java.util.List<Room> radiantV,
                                       java.lang.String where,
                                       java.util.Set<TrackingLibrary.TrailFlag> trailFlags,
                                       int radius,
                                       java.util.Set<Room> ignoreRooms,
                                       int maxSecs)

Searches for a room fitting to the given search string, within the given radiant rooms, with a trail fitting the given trail flags, optionally ignoring any ignore rooms. Returns a descriptions of the turns and movements from the start room to the target, or null. Can also have a time limit on finding the way.

Parameters:

startR - the starting room

radiantV - the complete radiant rooms

where - the target to search for

trailFlags - the flags for rooms to travel through

radius - the maximum radius to travel

ignoreRooms - optional set of rooms to ignore in the trail

maxSecs - maximum seconds to keep looking for trail

Returns:

the description of the way to get there

See Also:

findAllTrails(Room, List, List), findAllTrails(Room, Room, List), findTrailToAnyRoom(Room, List, TrackingFlags, int), findTrailToAnyRoom(Room, RFilter, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int, List), getShortestTrail(List), canValidTrail(Room, List, String, int, Set, int)

canValidTrail

boolean canValidTrail(Room startR,
                      java.util.List<Room> radiantV,
                      java.lang.String where,
                      int radius,
                      java.util.Set<Room> ignoreRooms,
                      int maxSecs)

Searches for a room fitting to the given search string, within the given radiant rooms, with a trail fitting the given trail flags, optionally ignoring any ignore rooms. Returns whether there is a trail from the start room to the target, or not. Can also have a time limit on finding the way.

Parameters:

startR - the starting room

radiantV - the complete radiant rooms

where - the target to search for

radius - the maximum radius to travel

ignoreRooms - optional set of rooms to ignore in the trail

maxSecs - maximum seconds to keep looking for trail

Returns:

true if you can get from here to there

See Also:

findAllTrails(Room, List, List), findAllTrails(Room, Room, List), findTrailToAnyRoom(Room, List, TrackingFlags, int), findTrailToAnyRoom(Room, RFilter, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int, List), getShortestTrail(List), getTrailToDescription(Room, List, String, Set, int, Set, int)

trackNextDirectionFromHere

int trackNextDirectionFromHere(java.util.List<Room> theTrail,
                               Room location,
                               boolean openOnly)

Given a room trail, with the destination room first, and the location last, this will return the next direction to travel from the given location, optionally stopping at doors.

Parameters:

theTrail - the room trail

location - the current room on the trail

openOnly - true to skip doors

Returns:

the next direction, or -1, or 999 if you have arrived

See Also:

findTrailToAnyRoom(Room, List, TrackingFlags, int), findTrailToAnyRoom(Room, RFilter, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int), findTrailToRoom(Room, Room, TrackingFlags, int, List)

stopTracking

void stopTracking(MOB mob)

Uninvokes and deletes any Tracking-related effects on the given mob.

Parameters:

mob - the mob to untrack

See Also:

autoTrack(MOB, Room)

autoTrack

boolean autoTrack(MOB mob,
                  Room destR)

Starts the given mob tracking from their current location to the given room.

Parameters:

mob - the mob to start tracking

destR - the target room

Returns:

true if tracking was successfully started, false otherwise

See Also:

stopTracking(MOB)

makeFall

boolean makeFall(Physical P,
                 Room room,
                 boolean reverseFall)

Causes the given mob or item to 'fall' from one room to another, usually down, if it can.

Parameters:

P - the thing to fall

room - the things location

reverseFall - true to fall UP instead of down

Returns:

true if falling was started, false otherwise

doFallenOffCheck

boolean doFallenOffCheck(MOB mob)

If the given mob is riding anything, this will schedule a check to see if it is STILL riding. This must be done on the mobs tick because boats dont tick.

Parameters:

mob - the mob to check

Returns:

n/a

makeSink

void makeSink(Physical P,
              Room room,
              boolean reverseSink)

Causes the given mob or item to 'sink' from one room to another, usually down, if it can.

Parameters:

P - the thing to fall

room - the things location

reverseSink - true to sink 'up'

isOkWaterSurfaceAffect

CMMsg.CheckedMsgResponse isOkWaterSurfaceAffect(Room room,
                                                CMMsg msg)

Utility method for handling movement into a water surface type room. It receives the room being moved into or out of, and an event message to preview. It returns a Tri-State response: Either to approve immediately, fail immediately, or continue with any other checks.

Parameters:

room - the watery room an event occurred in

msg - the event happening in the

Returns:

the state that the caller should respect.

getRadiantRooms

void getRadiantRooms(Room room,
                     java.util.List<Room> rooms,
                     TrackingLibrary.TrackingFlags flags,
                     Room radiateTo,
                     int maxDepth,
                     java.util.Set<Room> ignoreRooms)

Generates an ordered list of rooms radiating from the given room, with max depth, and optional stopping room, ignore rooms, and flags. The radiant rooms start with the origin room and get increasingly outward as you go down the list.

Parameters:

room - the starting room

rooms - the radiant rooms output

flags - optional flags to limit the radiant paths

radiateTo - optional room to stop at, which would be last on the list

maxDepth - the maximum depth of the radiation

ignoreRooms - optional rooms to ignore in radiation

See Also:

getRadiantAreas(Area, int), getRadiantRooms(Room, RFilters, int), getRadiantRooms(Room, TrackingFlags, int), getRadiantRooms(Room, List, RFilters, Room, int, Set), getRadiantRoomsEnum(Room, RFilters, Room, int, Set), getRadiantRoomsToTarget(Room, List, TrackingFlags, RFilter, int), getRadiantRoomTarget(Room, RFilters, RFilter)

getRadiantRooms

java.util.List<Room> getRadiantRooms(Room room,
                                     TrackingLibrary.RFilters filters,
                                     int maxDepth)

Generates an ordered list of rooms radiating from the given room, with max depth and optional room radiating filters. The radiant rooms start with the origin room and get increasingly outward as you go down the list.

Parameters:

room - the starting room

filters - one or more filters that blocks various radiation paths

maxDepth - the maximum depth of the radiation

Returns:

the radiant rooms list

See Also:

getRadiantAreas(Area, int), getRadiantRooms(Room, TrackingFlags, int), getRadiantRooms(Room, List, RFilters, Room, int, Set), getRadiantRooms(Room, List, TrackingFlags, Room, int, Set), getRadiantRoomsEnum(Room, RFilters, Room, int, Set), getRadiantRoomsToTarget(Room, List, TrackingFlags, RFilter, int), getRadiantRoomTarget(Room, RFilters, RFilter)

getRadiantRooms

void getRadiantRooms(Room room,
                     java.util.List<Room> rooms,
                     TrackingLibrary.RFilters filters,
                     Room radiateTo,
                     int maxDepth,
                     java.util.Set<Room> ignoreRooms)

Generates an ordered list of rooms radiating from the given room, with max depth, and optional ignore rooms, and radiating room filters. The radiant rooms start with the origin room and get increasingly outward as you go down the list.

Parameters:

room - the starting room

rooms - the radiant rooms output

filters - one or more filters that blocks various radiation paths

radiateTo - optional room to stop at, which would be last on the list

maxDepth - the maximum depth of the radiation

ignoreRooms - optional rooms to ignore in radiation

See Also:

getRadiantAreas(Area, int), getRadiantRooms(Room, RFilters, int), getRadiantRooms(Room, TrackingFlags, int), getRadiantRooms(Room, List, TrackingFlags, Room, int, Set), getRadiantRoomsEnum(Room, RFilters, Room, int, Set), getRadiantRoomsToTarget(Room, List, TrackingFlags, RFilter, int), getRadiantRoomTarget(Room, RFilters, RFilter)

getRadiantRoomsToTarget

boolean getRadiantRoomsToTarget(Room room,
                                java.util.List<Room> rooms,
                                TrackingLibrary.TrackingFlags flags,
                                TrackingLibrary.RFilter radiateTo,
                                int maxDepth)

Generates an ordered list of rooms radiating from the given room, to a given target room filter in, with max depth, and optional ignore rooms, and radiating room filters/flags. The radiant rooms start with the origin room and get increasingly outward as you go down the list.

Parameters:

room - the starting room

rooms - the radiant rooms output

flags - one or more filters that blocks various radiation paths

radiateTo - filter for the room to stop at, which would be last on the list

maxDepth - the maximum depth of the radiation

Returns:

true if the radiation was successful, false otherwise

See Also:

getRadiantAreas(Area, int), getRadiantRooms(Room, RFilters, int), getRadiantRooms(Room, TrackingFlags, int), getRadiantRooms(Room, List, RFilters, Room, int, Set), getRadiantRooms(Room, List, TrackingFlags, Room, int, Set), getRadiantRoomsEnum(Room, RFilters, Room, int, Set), getRadiantRoomTarget(Room, RFilters, RFilter)

getRadiantRooms

java.util.List<Room> getRadiantRooms(Room room,
                                     TrackingLibrary.TrackingFlags flags,
                                     int maxDepth)

Generates an ordered list of rooms radiating from the given room, with max depth and optional room radiating filters. The radiant rooms start with the origin room and get increasingly outward as you go down the list.

Parameters:

room - the starting room

flags - one or more filters that blocks various radiation paths

maxDepth - the maximum depth of the radiation

Returns:

the radiant rooms output

See Also:

getRadiantAreas(Area, int), getRadiantRooms(Room, RFilters, int), getRadiantRooms(Room, List, RFilters, Room, int, Set), getRadiantRooms(Room, List, TrackingFlags, Room, int, Set), getRadiantRoomsEnum(Room, RFilters, Room, int, Set), getRadiantRoomsToTarget(Room, List, TrackingFlags, RFilter, int), getRadiantRoomTarget(Room, RFilters, RFilter)

getRadiantAreas

java.util.List<Area> getRadiantAreas(Area area,
                                     int maxDepth)

Generates an ordered list of areas radiating from the given area, with max depth. The radiant areas start with the origin area and get increasingly outward as you go down the list.

Parameters:

area - the starting area

maxDepth - the maximum depth of the radiation

Returns:

the radiant areas output

See Also:

getRadiantRooms(Room, RFilters, int), getRadiantRooms(Room, TrackingFlags, int), getRadiantRooms(Room, List, RFilters, Room, int, Set), getRadiantRooms(Room, List, TrackingFlags, Room, int, Set), getRadiantRoomsEnum(Room, RFilters, Room, int, Set), getRadiantRoomsToTarget(Room, List, TrackingFlags, RFilter, int), getRadiantRoomTarget(Room, RFilters, RFilter)

getRadiantRoomsEnum

java.util.Enumeration<Room> getRadiantRoomsEnum(Room room,
                                                TrackingLibrary.RFilters filters,
                                                Room radiateTo,
                                                int maxDepth,
                                                java.util.Set<Room> ignoreRooms)

Generates a enumerator for an ordered list of rooms radiating from the given room, with max depth, and optional ignore rooms, and radiating room filters. The radiant rooms start with the origin room and get increasingly outward as you go down the list.

Parameters:

room - the starting room

filters - one or more filters that blocks various radiation paths

radiateTo - optional room to stop at, which would be last on the list

maxDepth - the maximum depth of the radiation

ignoreRooms - optional rooms to ignore in radiation

Returns:

the enumerator of radiating rooms

See Also:

getRadiantAreas(Area, int), getRadiantRooms(Room, RFilters, int), getRadiantRooms(Room, TrackingFlags, int), getRadiantRooms(Room, List, RFilters, Room, int, Set), getRadiantRooms(Room, List, TrackingFlags, Room, int, Set), getRadiantRoomsToTarget(Room, List, TrackingFlags, RFilter, int), getRadiantRoomTarget(Room, RFilters, RFilter)

getRadiantRoomTarget

Room getRadiantRoomTarget(Room room,
                          TrackingLibrary.RFilters filters,
                          TrackingLibrary.RFilter radiateTo)

Returns a room that is not filtered out of the rooms radiating from the given room. May also include optional filters for the radiating room path. No max depth, so this will just continue until it runs through the entire connected map!

Parameters:

room - the starting room

filters - one or more filters that blocks various radiation paths

radiateTo - filter that the returned room is NOT filtered out of

Returns:

null, or the found room

See Also:

getRadiantAreas(Area, int), getRadiantRooms(Room, RFilters, int), getRadiantRooms(Room, TrackingFlags, int), getRadiantRooms(Room, List, RFilters, Room, int, Set), getRadiantRooms(Room, List, TrackingFlags, Room, int, Set), getRadiantRoomsEnum(Room, RFilters, Room, int, Set), getRadiantRoomsToTarget(Room, List, TrackingFlags, RFilter, int)

buildGridList

PairVector<Room,int[]> buildGridList(Room room,
                                     java.lang.String ownerName,
                                     int maxDepth)

Builts a radiating room list that is assumed to be in grid formation, and owned as private property. The list of rooms is returned with their relative grid position to the starting room. Only rooms owned by the given owner, if given, are returned.

Parameters:

room - the starting room

ownerName - "", or the owner of the rooms to return

maxDepth - the max depth to radiate

Returns:

the list of rooms and grid information

See Also:

getCalculatedAdjacentGridRoom(PairVector, Room, int)

wanderCheckedAway

boolean wanderCheckedAway(MOB M,
                          boolean mindPCs,
                          boolean andGoHome)

Forces the given mob to leave the room, for aesthetic purposes.

Parameters:

M - the mob to leave

mindPCs - true to NOT leave if pcs are present

andGoHome - true to be transported to start room

Returns:

true if this was successful, and false otherwise

See Also:

wanderAway(MOB, boolean, boolean), wanderCheckedFromTo(MOB, Room, boolean), wanderFromTo(MOB, Room, boolean), wanderIn(MOB, Room), markToWanderHomeLater(MOB, int), forceRecall(MOB, boolean)

wanderCheckedFromTo

boolean wanderCheckedFromTo(MOB M,
                            Room toHere,
                            boolean mindPCs)

Aesthetically transports a mob from their location to a target room by having them leave their current room legitimately, and enter the target one. Will optionally abort if PCs are present.

Parameters:

M - the mob to move

toHere - the target room

mindPCs - true to not leave if pcs are present

Returns:

true if the movement was successful

See Also:

wanderAway(MOB, boolean, boolean), wanderCheckedAway(MOB, boolean, boolean), wanderFromTo(MOB, Room, boolean), wanderIn(MOB, Room), markToWanderHomeLater(MOB, int), forceRecall(MOB, boolean)

wanderAway

void wanderAway(MOB M,
                boolean mindPCs,
                boolean andGoHome)

Forces the given mob to leave the room, for aesthetic purposes. Always aborts if mob is a mount with a rider nearby. Optionally aborts if pcs are present, and optionally does a legit re-enter of their start room.

Parameters:

M - the mob to move

mindPCs - true to not leave if pcs are present

andGoHome - true to also aesthetically go back to start room

See Also:

wanderCheckedAway(MOB, boolean, boolean), wanderCheckedFromTo(MOB, Room, boolean), wanderFromTo(MOB, Room, boolean), wanderIn(MOB, Room), markToWanderHomeLater(MOB, int), forceRecall(MOB, boolean)

wanderFromTo

void wanderFromTo(MOB M,
                  Room toHere,
                  boolean mindPCs)

Aesthetically transports a mob from their location to a target room by having them leave their current room legitimately, and enter the target one.

Parameters:

M - the mob to move

toHere - the destination room

mindPCs - true to not leave if pcs are present

See Also:

wanderAway(MOB, boolean, boolean), wanderCheckedAway(MOB, boolean, boolean), wanderCheckedFromTo(MOB, Room, boolean), wanderIn(MOB, Room), markToWanderHomeLater(MOB, int), forceRecall(MOB, boolean)

wanderIn

void wanderIn(MOB M,
              Room toHere)

Aesthetically transports a mob from their location to a target room by having them leave their current room legitimately, and enter the target one. It will force them to enter if necessary.

Parameters:

M - the mob to move

toHere - the destination room

See Also:

wanderAway(MOB, boolean, boolean), wanderCheckedAway(MOB, boolean, boolean), wanderCheckedFromTo(MOB, Room, boolean), wanderFromTo(MOB, Room, boolean), markToWanderHomeLater(MOB, int), forceRecall(MOB, boolean)

forceRecall

void forceRecall(MOB mob,
                 boolean includeFollowers)

Attempts to recall the given mob, and optinally all their followers, by generating a recall message and previewing and sending it.

Parameters:

mob - the mob to move

includeFollowers - true to also recall followers

See Also:

wanderAway(MOB, boolean, boolean), wanderCheckedAway(MOB, boolean, boolean), wanderCheckedFromTo(MOB, Room, boolean), wanderFromTo(MOB, Room, boolean), wanderIn(MOB, Room), markToWanderHomeLater(MOB, int)

markToWanderHomeLater

void markToWanderHomeLater(MOB M,
                           int ticks)

Marks the mob with a temporary behavior that will force the mob to wander back to their start room as soon as possible.

Parameters:

M - the mob to move

ticks - the number of ticks to wait, or 0

See Also:

wanderAway(MOB, boolean, boolean), wanderCheckedAway(MOB, boolean, boolean), wanderCheckedFromTo(MOB, Room, boolean), wanderFromTo(MOB, Room, boolean), wanderIn(MOB, Room), forceRecall(MOB, boolean)

beMobile

boolean beMobile(MOB mob,
                 boolean dooropen,
                 boolean wander,
                 boolean roomprefer,
                 boolean roomobject,
                 int[] status,
                 java.util.Set<Room> rooms)

The random mobility method, for controlling movement of a move from one room to an ajacent one. Will swim if they can swim, crawl if crawling needed, climb if possible, etc.

Parameters:

mob - the mob who needs to be moved

dooropen - true attempt to open any closed doors, unless its private property

wander - true to cross area boundaries

roomprefer - only take a room on the optional list

roomobject - take any room UNLES it is on the optional list

status - optional status tracker for debugging

rooms - optional set of rooms for prefer or object

Returns:

true if the movement was successful

See Also:

walk(Item, int), walk(MOB, int, boolean, boolean), walk(MOB, int, boolean, boolean, boolean), walk(MOB, int, boolean, boolean, boolean, boolean), walkForced(MOB, Room, Room, boolean, boolean, String), run(MOB, int, boolean, boolean, boolean), run(MOB, int, boolean, boolean, boolean, boolean)

walk

boolean walk(MOB mob,
             int directionCode,
             boolean flee,
             boolean nolook)

Causes the given mob to attempt to walk in the given direction.

Parameters:

mob - the mob who needs to move

directionCode - the direction to walk

flee - true to generate a FLEE from combat message

nolook - true to avoid looking around when entering the next room

Returns:

true if the movement was successful

See Also:

beMobile(MOB, boolean, boolean, boolean, boolean, int[], Set), walk(Item, int), walk(MOB, int, boolean, boolean, boolean), walk(MOB, int, boolean, boolean, boolean, boolean), walkForced(MOB, Room, Room, boolean, boolean, String), run(MOB, int, boolean, boolean, boolean), run(MOB, int, boolean, boolean, boolean, boolean)

walk

boolean walk(MOB mob,
             int directionCode,
             boolean flee,
             boolean nolook,
             boolean noriders)

Causes the given mob to attempt to walk in the given direction.

Parameters:

mob - the mob who needs to move

directionCode - the direction to walk

flee - true to generate a FLEE from combat message

nolook - true to avoid looking around when entering the next room

noriders - true to prevent rideables being involved

Returns:

true if the movement was successful

See Also:

beMobile(MOB, boolean, boolean, boolean, boolean, int[], Set), walk(Item, int), walk(MOB, int, boolean, boolean), walk(MOB, int, boolean, boolean, boolean, boolean), walkForced(MOB, Room, Room, boolean, boolean, String), run(MOB, int, boolean, boolean, boolean), run(MOB, int, boolean, boolean, boolean, boolean)

walk

boolean walk(MOB mob,
             int directionCode,
             boolean flee,
             boolean nolook,
             boolean noriders,
             boolean always)

Causes the given mob to attempt to walk in the given direction.

Parameters:

mob - the mob who needs to move

directionCode - the direction to walk

flee - true to generate a FLEE from combat message

nolook - true to avoid looking around when entering the next room

noriders - true to prevent rideables being involved

always - true to set the always message flag, preventing preventative checks

Returns:

true if the movement was successful

See Also:

beMobile(MOB, boolean, boolean, boolean, boolean, int[], Set), walk(Item, int), walk(MOB, int, boolean, boolean), walk(MOB, int, boolean, boolean, boolean), walkForced(MOB, Room, Room, boolean, boolean, String), run(MOB, int, boolean, boolean, boolean), run(MOB, int, boolean, boolean, boolean, boolean)

walkForced

void walkForced(MOB M,
                Room fromHere,
                Room toHere,
                boolean andFollowers,
                boolean forceLook,
                java.lang.String msgStr)

Forces the given mob to leave the from room and enter to the room, without preview.

Parameters:

M - the mob who needs to move

fromHere - the room left

toHere - the room entered

andFollowers - true to include followers

forceLook - true to force the mob to look around after entering the new room

msgStr - the entering message string

See Also:

beMobile(MOB, boolean, boolean, boolean, boolean, int[], Set), walk(Item, int), walk(MOB, int, boolean, boolean), walk(MOB, int, boolean, boolean, boolean), walk(MOB, int, boolean, boolean, boolean, boolean), run(MOB, int, boolean, boolean, boolean), run(MOB, int, boolean, boolean, boolean, boolean)

walk

boolean walk(Item I,
             int directionCode)

Narrates the movement of an item, usually a rideable, in a given direction, from its current location. Will move as a rideable with riders if possible.

Parameters:

I - the item to move

directionCode - the direction to walk

Returns:

true if the movement was successful

See Also:

beMobile(MOB, boolean, boolean, boolean, boolean, int[], Set), walk(MOB, int, boolean, boolean), walk(MOB, int, boolean, boolean, boolean), walk(MOB, int, boolean, boolean, boolean, boolean), walkForced(MOB, Room, Room, boolean, boolean, String), run(MOB, int, boolean, boolean, boolean), run(MOB, int, boolean, boolean, boolean, boolean)

run

boolean run(MOB mob,
            int directionCode,
            boolean flee,
            boolean nolook,
            boolean noriders)

Causes the given mob to attempt to run in the given direction.

Parameters:

mob - the mob who needs to move

directionCode - the direction to walk

flee - true to generate a FLEE from combat message

nolook - true to avoid looking around when entering the next room

noriders - true to prevent rideables being involved

Returns:

true if the movement was successful

See Also:

beMobile(MOB, boolean, boolean, boolean, boolean, int[], Set), walk(Item, int), walk(MOB, int, boolean, boolean), walk(MOB, int, boolean, boolean, boolean), walk(MOB, int, boolean, boolean, boolean, boolean), walkForced(MOB, Room, Room, boolean, boolean, String), run(MOB, int, boolean, boolean, boolean, boolean)

run

boolean run(MOB mob,
            int directionCode,
            boolean flee,
            boolean nolook,
            boolean noriders,
            boolean always)

Causes the given mob to attempt to run in the given direction.

Parameters:

mob - the mob who needs to move

directionCode - the direction to walk

flee - true to generate a FLEE from combat message

nolook - true to avoid looking around when entering the next room

noriders - true to prevent rideables being involved

always - true to set the always message flag, preventing preventative checks

Returns:

true if the movement was successful

See Also:

beMobile(MOB, boolean, boolean, boolean, boolean, int[], Set), walk(Item, int), walk(MOB, int, boolean, boolean), walk(MOB, int, boolean, boolean, boolean), walk(MOB, int, boolean, boolean, boolean, boolean), walkForced(MOB, Room, Room, boolean, boolean, String), run(MOB, int, boolean, boolean, boolean)

radiatesFromDir

int radiatesFromDir(Room room,
                    java.util.List<Room> rooms)

This method is helpful for traversing room trails. If the given room is higher in the given room list than a connecting room, it returns -1. If a room that connects to this one is found, the direction from the given room to that one is returned.

Parameters:

room - the source room

rooms - the list of rooms

Returns:

the direction from the room to the lowest room in the list

areNearEachOther

boolean areNearEachOther(MOB whichM,
                         MOB nearM)

Returns true if the two give mobs are in the same room, or adjacent rooms.

Parameters:

whichM - the first mob

nearM - the second mob

Returns:

true if they are near each other, false otherwise

getCalculatedAdjacentGridRoom

Room getCalculatedAdjacentGridRoom(PairVector<Room,int[]> rooms,
                                   Room R,
                                   int dir)

Given a set of rooms built with grid coordinates, and a starting room inside that grid, and a direction, this will return the adjacent room based on the built grid.

Parameters:

rooms - the built grid array of rooms and locations

R - the room to start from

dir - the direction to inquire about

Returns:

the room in that direction, or null

See Also:

buildGridList(Room, String, int)

findExitDir

int findExitDir(MOB mob,
                Room R,
                java.lang.String desc)

Given a mob with eyes, and their location, and a match string, this will attempt to match one of the exits and return it. It does not check direction codes, it must be an exit name-like match.

Parameters:

mob - the mob who needs to move

R - the room to find exits in

desc - the exit match string

Returns:

null, or the exit direction

findRoomDir

int findRoomDir(MOB mob,
                Room R)

Given a mob and a room, returns the direction from the mobs direction to the target room, if possible.

Parameters:

mob - the mob

R - the target room

Returns:

the direction or -1

getNearestValidIDRoom

Room getNearestValidIDRoom(Room R)

Based on radiating rooms from the given room, this will return the nearest room that has a valid room id.

Parameters:

R - the room that is prob not valid

Returns:

the nearest valid room

newFlags

TrackingLibrary.TrackingFlags newFlags()

Constructs a new set of TrackingFlags, which are filters for use in radiant and room finding methods. These must then be filled with TrackingFlag (RFilter) objects.

Returns:

the new tracking flags set

findALadder

Rideable findALadder(MOB mob,
                     Room room)

If theres a ladder that can be seen in the same room as the given mob, this returns it.

Parameters:

mob - the mob who wants a ladder

room - the room that might have a ladder in it

Returns:

null, or the ladder

See Also:

postMountLadder(MOB, Rideable)

postMountLadder

void postMountLadder(MOB mob,
                     Rideable ladder)

Causes the given mob to mount the given ladder. So they can ride it up, presumably.

Parameters:

mob - the mob who wants to use a ladder

ladder - the ladder

See Also:

findALadder(MOB, Room)

createNavigationMob

MOB createNavigationMob(NavigableItem ship)

When large sailing ships or caravans navigate from room to room, a fake temporary mob is used to represent the agency of the ship per se. This will create that mob. The mob MUST be destroyed after use.

Parameters:

ship - the navigable ship

Returns:

the mob to use, then destroy