GalacticMap

All Superinterfaces:

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

All Known Implementing Classes:

CoffeeDark
```
public interface GalacticMap
extends CMLibrary
```
The Galactic Map of All Space Objects is more than a simple object cache of things in space, but a sophisticated system for tracking where those things are in relation to each other, and finding things around a particular part of space quickly. This Library is also the place to go for ALL space calculations related to movement.

Field Summary
- Fields inherited from interface com.planet_ink.coffee_mud.core.interfaces.CMObject
  idConverter

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`double`	`accelSpaceObject(double[] curDirection, double curSpeed, double[] accelDirection, double newAcceleration)`	This method does not actually move anything, but returns a change in direction, and a change in speed caused by an acceleration in a new direction.
`void`	`accelSpaceObject(SpaceObject O, double[] accelDirection, double newAcceleration)`	This method does not actually move anything, but given a space object, and an acceleration direction and an acceleration speed, this will alter the space objects direction and speed based on the new acceleration.
`void`	`addObjectToSpace(SpaceObject O)`	Adds the given SpaceObject to the galactic map cache.
`void`	`addObjectToSpace(SpaceObject O, long[] coords)`	Adds the given SpaceObject to the galactic map cache at the given coordinates.
`void`	`applyAngleDiff(double[] angle, double[] delta)`	Given an angle and a simple delta, with positive and negative values, this will add the delta to the angle and normalize the angle.
`Pair<double[],java.lang.Long>`	`calculateIntercept(SpaceObject chaserO, SpaceObject runnerO, long maxChaserSpeed, int maxTicks)`	Returns the proper direction and speed to allow the given chaser to intercept the given runner.
`boolean`	`canMaybeIntercept(SpaceObject chaserO, SpaceObject runnerO, int maxTicks, double maxSpeed)`	Returns whether the vectors described by the chaser and runners, their speeds, and the amount of time in movement can even POSSIBLY intercept, because the two vectors overlap
`void`	`changeDirection(double[] dir, double[] delta)`	Changes the given direction by the given delta variable.
`void`	`changeDirection(double[] dir, double delta0, double delta1)`	Changes the given direction by the given delta variables.
`void`	`delObjectInSpace(SpaceObject O)`	Removes a SpaceObject from the galactic map cache.
`SpaceObject`	`findSpaceObject(java.lang.String s, boolean exactOnly)`	Given the name of an object in space, preferably a unique name, this will attempt to find and return it using standard search methods.
`ShipDirectional.ShipDir`	`getAbsoluteDirectionalFromDir(double[] direction)`	Given a direction this will return a relative direction object describing the directions absolute facing.
`double`	`getAngleDelta(double[] fromAngle, double[] toAngle)`	Given two angles, this returns the difference between them as a single angle.
`double[]`	`getAngleDiff(double[] fromAngle, double[] toAngle)`	Given two angles, this returns the difference between them in pitch and yaw.
`ShipDirectional.ShipDir[]`	`getCurrentBattleCoveredDirections(ShipDirectional comp)`	Given a ship war component, returns the directions in which it is currently covering.
`double[]`	`getDirection(long[] fromCoords, long[] toCoords)`	Given two galactic coordinates, this will return the direction in radians from the first to the second.
`double[]`	`getDirection(SpaceObject fromObj, SpaceObject toObj)`	Given two space objects, this will return the direction in radians from the first to the second.
`ShipDirectional.ShipDir`	`getDirectionFromDir(double[] facing, double roll, double[] direction)`	Given a facing direction (NOT direction of travel), and a roll angle (belly/axis), and a direction to some other object, this will return a relative direction object describing the ships relationship to the other object.
`long`	`getDistanceFrom(long[] coord1, long[] coord2)`	Given two galactic coordinates, this returns the actual distance between the two.
`long`	`getDistanceFrom(SpaceObject O1, SpaceObject O2)`	Given two space objects, this returns the actual distance between the two.
`double`	`getGravityForce(SpaceObject S, SpaceObject cO)`	If the two given objects are within an appropriate distance from each other, this will return the correct amount of acceleration g-force applied by the second object to the first.
`long[]`	`getInSectorCoords(long[] coordinates)`	Given absolute space coordinates, from -Long.MAX to Long.MAX, this will return the relative coordinates INSIDE the sector, whose bounds are determined by lots of math.
`java.util.List<LocationRoom>`	`getLandingPoints(SpaceObject ship, Environmental O)`	Given a space ship, and an object that can be reduced to an Area, this will return a list of all valid LocationRoom objects, sorted by their present distance from the ship, from each other, and whether its a space port.
`long[]`	`getLocation(long[] oldLocation, double[] direction, long distance)`	Given some galactic coordinates, a direction of travel, and a distance, this will return the new coordinates.
`double[]`	`getMiddleAngle(double[] angle1, double[] angle2)`	Given two angles, this returns the angle between them.
`double`	`getMinDistanceFrom(long[] prevPos, long[] curPosition, long[] objPos)`	Given a previous position and a current position, this will return the minimum distance approached to the given object position.
`double[]`	`getOffsetAngle(double[] correctAngle, double[] wrongAngle)`	Given a base 'correct' angle and another 'wrong' angle, this will return the angle that it opposite to, but equal in distance.
`double[]`	`getOppositeDir(double[] dir)`	Given a direction, this will return its opposite
`double[][]`	`getPerpendicularAngles(double[] angle)`	Given an angle from origin, this will return the other trivial angles that are 90 degrees from the given one.
`long[][]`	`getPerpendicularPoints(long[] origin, double[] angle, long distance)`	Given the origin point and an angle from the origin, this will return the other points that are 90 degrees from the given one, at the given distance.
`long`	`getRelativeSpeed(SpaceObject O1, SpaceObject O2)`	Calculates the relative speed of two SpaceObjects to each other.
`java.util.Map<java.lang.String,BoundedObject.BoundedCube>`	`getSectorMap()`	Returns the name of all the sectors, and the cube that covers its domain.
`java.lang.String`	`getSectorName(long[] coordinates)`	Given some absolute space coordinates, this will return the name of the sector the coordinates are in.
`SpaceObject`	`getSpaceObject(CMObject o, boolean ignoreMobs)`	Given a random object, this will return null, or the "nearest" space object, by crawling up an item container tree, or however it needs to.
`java.util.Enumeration<java.util.Map.Entry<SpaceObject,java.util.List<java.lang.ref.WeakReference<TrackingVector<SpaceObject>>>>>`	`getSpaceObjectEntries()`	Returns an enumeration of all objects, along with a list of their tracking vectors? I have no idea why anyone would want this, so I won't explain any more until someone does try to use this.
`java.util.Enumeration<SpaceObject>`	`getSpaceObjects()`	Returns an enumeration of all object in the galactic space map.
`java.util.List<SpaceObject>`	`getSpaceObjectsByCenterpointWithin(long[] centerCoordinates, long minDistance, long maxDistance)`	Given a center galactic coordinates, and a minimum and maximum distance from that coordinate, this will return all objects in the caches space map that is within the "donut" defined by those things.
`java.util.List<SpaceObject>`	`getSpaceObjectsInBound(BoundedObject.BoundedCube cube)`	Given a bounded cube, this will return all space objects within that cube, and by within, i mean even just intersecting it.
`java.util.List<SpaceObject>`	`getSpaceObjectsWithin(SpaceObject ofObj, long minDistance, long maxDistance)`	Given a space object to use as a center point on the galactic map, this will return all objects in the caches space map that is within the "donut" defined by those things.
`boolean`	`isObjectInSpace(SpaceObject O)`	Returns whether the given object is actually in the galactic map cache at the moment -- it could be landed somewhere.
`long[]`	`moveSpaceObject(long[] coordinates, double[] direction, long speed)`	Given a set of galactic coordinates, and a direction angle, and a speed, this will return the new coordinates after applying all the inputs.
`void`	`moveSpaceObject(SpaceObject O)`	Given a SpaceObject that is moving, this will alter the given objects coordinates based on its speed and direction.
`void`	`moveSpaceObject(SpaceObject O, long[] coords)`	Given a SpaceObject and its coordinates, this will alter the given coordinates based on the speed and direction of the given space object.
`int`	`numSpaceObjects()`	Returns the number of objects in the galactic map cache.
`java.util.List<long[]>`	`plotCourse(long[] osrc, long sradius, long[] otarget, long tradius, int maxTicks)`	Plots a course from the source to the target, with a maximum number of steps/ticks.
`boolean`	`sendSpaceEmissionEvent(SpaceObject srcP, Environmental tool, int emissionType, java.lang.String msgStr)`	Generates an sends a message representing an emission in space, which might be picked up by various sensors.
`boolean`	`sendSpaceEmissionEvent(SpaceObject srcP, Environmental tool, long range, int emissionType, java.lang.String msgStr)`	Generates an sends a message representing an emission in space, which might be picked up by various sensors.
`java.util.Enumeration<Area>`	`spaceAreas()`	Returns an enumeration of all Areas that are also SpaceObjects, typically planets.

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
  - spaceAreas
```
java.util.Enumeration<Area> spaceAreas()
```
    Returns an enumeration of all Areas that are also SpaceObjects, typically planets.
    
    Returns:
    
    an enumeration of all space Areas
  - numSpaceObjects
```
int numSpaceObjects()
```
    Returns the number of objects in the galactic map cache.
    
    Returns:
    
    the number of objects in the galactic map
  - getSectorMap
```
java.util.Map<java.lang.String,BoundedObject.BoundedCube> getSectorMap()
```
    Returns the name of all the sectors, and the cube that covers its domain.
    
    Returns:
    
    the sector map
  - isObjectInSpace
```
boolean isObjectInSpace(SpaceObject O)
```
    Returns whether the given object is actually in the galactic map cache at the moment -- it could be landed somewhere.
    
    Parameters:
    
    O - the space object to look for
    
    Returns:
    
    true if it's in space
    
    See Also:
    
    numSpaceObjects(), isObjectInSpace(SpaceObject), delObjectInSpace(SpaceObject), addObjectToSpace(SpaceObject, long[]), addObjectToSpace(SpaceObject), findSpaceObject(String, boolean)
  - delObjectInSpace
```
void delObjectInSpace(SpaceObject O)
```
    Removes a SpaceObject from the galactic map cache. This is normally required if it is moving.
    
    Parameters:
    
    O - the object to remove
    
    See Also:
    
    numSpaceObjects(), isObjectInSpace(SpaceObject), delObjectInSpace(SpaceObject), addObjectToSpace(SpaceObject, long[]), addObjectToSpace(SpaceObject), findSpaceObject(String, boolean)
  - addObjectToSpace
```
void addObjectToSpace(SpaceObject O,
                      long[] coords)
```
    Adds the given SpaceObject to the galactic map cache at the given coordinates.
    
    Parameters:
    
    O - the SpaceObject to add
    
    coords - the coordinates to add it at
    
    See Also:
    
    numSpaceObjects(), isObjectInSpace(SpaceObject), delObjectInSpace(SpaceObject), addObjectToSpace(SpaceObject, long[]), addObjectToSpace(SpaceObject), findSpaceObject(String, boolean)
  - addObjectToSpace
```
void addObjectToSpace(SpaceObject O)
```
    Adds the given SpaceObject to the galactic map cache.
    
    Parameters:
    
    O - the object to put in space
    
    See Also:
    
    numSpaceObjects(), isObjectInSpace(SpaceObject), delObjectInSpace(SpaceObject), addObjectToSpace(SpaceObject, long[]), addObjectToSpace(SpaceObject), findSpaceObject(String, boolean)
  - getDistanceFrom
```
long getDistanceFrom(SpaceObject O1,
                     SpaceObject O2)
```
    Given two space objects, this returns the actual distance between the two.
    
    Parameters:
    
    O1 - the first space object
    
    O2 - the second space object
    
    Returns:
    
    the distance between the two
    
    See Also:
    
    getDistanceFrom(long[], long[]), getDistanceFrom(SpaceObject, SpaceObject), getMinDistanceFrom(long[], long[], long[])
  - getDistanceFrom
```
long getDistanceFrom(long[] coord1,
                     long[] coord2)
```
    Given two galactic coordinates, this returns the actual distance between the two.
    
    Parameters:
    
    coord1 - first galactic coords
    
    coord2 - second galactic coords
    
    Returns:
    
    distance between the two
    
    See Also:
    
    getDistanceFrom(long[], long[]), getDistanceFrom(SpaceObject, SpaceObject), getMinDistanceFrom(long[], long[], long[])
  - getMinDistanceFrom
```
double getMinDistanceFrom(long[] prevPos,
                          long[] curPosition,
                          long[] objPos)
```
    Given a previous position and a current position, this will return the minimum distance approached to the given object position.
    
    Parameters:
    
    prevPos - previous position on galactic chart
    
    curPosition - current position on galactic chart
    
    objPos - the object position curious about minimum distance to
    
    Returns:
    
    the minimum distance in high precision
    
    See Also:
    
    getDistanceFrom(long[], long[]), getDistanceFrom(SpaceObject, SpaceObject), getMinDistanceFrom(long[], long[], long[])
  - getAngleDelta
```
double getAngleDelta(double[] fromAngle,
                     double[] toAngle)
```
    Given two angles, this returns the difference between them as a single angle.
    
    Parameters:
    
    fromAngle - the first angle
    
    toAngle - the second angle
    
    Returns:
    
    the angle delta
    
    See Also:
    
    getAngleDiff(double[], double[])
  - getMiddleAngle
```
double[] getMiddleAngle(double[] angle1,
                        double[] angle2)
```
    Given two angles, this returns the angle between them.
    
    Parameters:
    
    angle1 - the first angle
    
    angle2 - the second angle
    
    Returns:
    
    the middle angle
  - getOffsetAngle
```
double[] getOffsetAngle(double[] correctAngle,
                        double[] wrongAngle)
```
    Given a base 'correct' angle and another 'wrong' angle, this will return the angle that it opposite to, but equal in distance.
    
    Parameters:
    
    correctAngle - the base angle
    
    wrongAngle - the wrong angle
    
    Returns:
    
    another wrong angle, on the other 'side' of the base
  - getAngleDiff
```
double[] getAngleDiff(double[] fromAngle,
                      double[] toAngle)
```
    Given two angles, this returns the difference between them in pitch and yaw.
    
    Parameters:
    
    fromAngle - the first angle
    
    toAngle - the second angle
    
    Returns:
    
    the angle delta
    
    See Also:
    
    getAngleDelta(double[], double[])
  - applyAngleDiff
```
void applyAngleDiff(double[] angle,
                    double[] delta)
```
    Given an angle and a simple delta, with positive and negative values, this will add the delta to the angle and normalize the angle.
    
    Parameters:
    
    angle - the angle to modify
    
    delta - the delta
  - getDirection
```
double[] getDirection(SpaceObject fromObj,
                      SpaceObject toObj)
```
    Given two space objects, this will return the direction in radians from the first to the second.
    
    Parameters:
    
    fromObj - the first SpaceObject
    
    toObj - the second SpaceObject
    
    Returns:
    
    the direction in radians from the first to the second
    
    See Also:
    
    getDirection(long[], long[]), getDirection(SpaceObject, SpaceObject), getDirectionFromDir(double[], double, double[]), getOppositeDir(double[])
  - getDirection
```
double[] getDirection(long[] fromCoords,
                      long[] toCoords)
```
    Given two galactic coordinates, this will return the direction in radians from the first to the second.
    
    Parameters:
    
    fromCoords - the first coordinates
    
    toCoords - the second coordinates
    
    Returns:
    
    the angle of direction from the first to the second
    
    See Also:
    
    getDirection(long[], long[]), getDirection(SpaceObject, SpaceObject), getDirectionFromDir(double[], double, double[]), getOppositeDir(double[])
  - getDirectionFromDir
```
ShipDirectional.ShipDir getDirectionFromDir(double[] facing,
                                            double roll,
                                            double[] direction)
```
    Given a facing direction (NOT direction of travel), and a roll angle (belly/axis), and a direction to some other object, this will return a relative direction object describing the ships relationship to the other object. This is mostly for combat, where you need to know when a missile his the belly or ass, or whether you can fire a forward missile at it.
    
    Parameters:
    
    facing - the direction of facing
    
    roll - the roll angle
    
    direction - the direction to the other object
    
    Returns:
    
    the relative direction code
    
    See Also:
    
    ShipDirectional.ShipDir, getDirection(long[], long[]), getDirection(SpaceObject, SpaceObject), getDirectionFromDir(double[], double, double[]), getOppositeDir(double[]), getAbsoluteDirectionalFromDir(double[])
  - getAbsoluteDirectionalFromDir
```
ShipDirectional.ShipDir getAbsoluteDirectionalFromDir(double[] direction)
```
    Given a direction this will return a relative direction object describing the directions absolute facing. This is arbitrary, and just allows zones of direction to be described more easily.
    
    Parameters:
    
    direction - the direction to the other object
    
    Returns:
    
    the absolute direction code
    
    See Also:
    
    ShipDirectional.ShipDir, getDirection(long[], long[]), getDirection(SpaceObject, SpaceObject), getDirectionFromDir(double[], double, double[]), getOppositeDir(double[]), getDirectionFromDir(double[], double, double[])
  - getOppositeDir
```
double[] getOppositeDir(double[] dir)
```
    Given a direction, this will return its opposite
    
    Parameters:
    
    dir - the direction
    
    Returns:
    
    the opposite direction
    
    See Also:
    
    getDirection(long[], long[]), getDirection(SpaceObject, SpaceObject), getDirectionFromDir(double[], double, double[]), getOppositeDir(double[])
  - getPerpendicularAngles
```
double[][] getPerpendicularAngles(double[] angle)
```
    Given an angle from origin, this will return the other trivial angles that are 90 degrees from the given one. Will NOT include the given one.
    
    Parameters:
    
    angle - the angle from origin
    
    Returns:
    
    the set of angles (usually 4 of them).
  - getPerpendicularPoints
```
long[][] getPerpendicularPoints(long[] origin,
                                double[] angle,
                                long distance)
```
    Given the origin point and an angle from the origin, this will return the other points that are 90 degrees from the given one, at the given distance.
    
    Parameters:
    
    origin - the origin points
    
    angle - the angle from origin
    
    distance - the distance from origin of the points to return
    
    Returns:
    
    the set of points (usually 4 of them)
    
    See Also:
    
    getPerpendicularAngles(double[])
  - changeDirection
```
void changeDirection(double[] dir,
                     double delta0,
                     double delta1)
```
    Changes the given direction by the given delta variables. Corrects any crossover bounds, and checks the delta bounds.
    
    Parameters:
    
    dir - the current direction to change
    
    delta0 - the port/starboard delta
    
    delta1 - the ventral/dorsel delta
  - changeDirection
```
void changeDirection(double[] dir,
                     double[] delta)
```
    Changes the given direction by the given delta variable. Corrects any crossover bounds, and checks the delta bounds.
    
    Parameters:
    
    dir - the current direction to change
    
    delta - the delta to change it by, + or -
  - getRelativeSpeed
```
long getRelativeSpeed(SpaceObject O1,
                      SpaceObject O2)
```
    Calculates the relative speed of two SpaceObjects to each other. The math is based entirely on coordinates and speed, not direction, so take it for what you will. Do they both need to be going the same direction for this to work?
    
    Parameters:
    
    O1 - the first Space Object
    
    O2 - the second Space Object
    
    Returns:
    
    the relative speed of the two objects
  - accelSpaceObject
```
void accelSpaceObject(SpaceObject O,
                      double[] accelDirection,
                      double newAcceleration)
```
    This method does not actually move anything, but given a space object, and an acceleration direction and an acceleration speed, this will alter the space objects direction and speed based on the new acceleration.
    
    Parameters:
    
    O - the space object to modify
    
    accelDirection - the acceleration direction
    
    newAcceleration - the acceleration amount
    
    See Also:
    
    accelSpaceObject(double[], double, double[], double)
  - accelSpaceObject
```
double accelSpaceObject(double[] curDirection,
                        double curSpeed,
                        double[] accelDirection,
                        double newAcceleration)
```
    This method does not actually move anything, but returns a change in direction, and a change in speed caused by an acceleration in a new direction.
    
    Parameters:
    
    curDirection - the current direction, *AND* the new direction
    
    curSpeed - the current speed
    
    accelDirection - the direction of acceleration
    
    newAcceleration - the amount of acceleration
    
    Returns:
    
    the new speed
    
    See Also:
    
    accelSpaceObject(double[], double, double[], double)
  - getLocation
```
long[] getLocation(long[] oldLocation,
                   double[] direction,
                   long distance)
```
    Given some galactic coordinates, a direction of travel, and a distance, this will return the new coordinates.
    
    Parameters:
    
    oldLocation - the previous location
    
    direction - the direction of travel
    
    distance - the distance of travel
    
    Returns:
    
    the new location
    
    See Also:
    
    moveSpaceObject(SpaceObject), moveSpaceObject(SpaceObject, long[]), moveSpaceObject(long[], double[], long)
  - moveSpaceObject
```
void moveSpaceObject(SpaceObject O)
```
    Given a SpaceObject that is moving, this will alter the given objects coordinates based on its speed and direction.
    
    Parameters:
    
    O - the SpaceObject to move
    
    See Also:
    
    moveSpaceObject(SpaceObject, long[]), moveSpaceObject(long[], double[], long), getLocation(long[], double[], long)
  - moveSpaceObject
```
void moveSpaceObject(SpaceObject O,
                     long[] coords)
```
    Given a SpaceObject and its coordinates, this will alter the given coordinates based on the speed and direction of the given space object.
    
    Parameters:
    
    O - the space object that is moving
    
    coords - the coordinates to modify based on speed/dir of the object
    
    See Also:
    
    moveSpaceObject(SpaceObject), moveSpaceObject(long[], double[], long), getLocation(long[], double[], long)
  - moveSpaceObject
```
long[] moveSpaceObject(long[] coordinates,
                       double[] direction,
                       long speed)
```
    Given a set of galactic coordinates, and a direction angle, and a speed, this will return the new coordinates after applying all the inputs.
    
    Parameters:
    
    coordinates - the galactic coordinates
    
    direction - the direction angle
    
    speed - the speed
    
    Returns:
    
    the new coordinates
    
    See Also:
    
    moveSpaceObject(SpaceObject), moveSpaceObject(SpaceObject, long[]), getLocation(long[], double[], long)
  - calculateIntercept
```
Pair<double[],java.lang.Long> calculateIntercept(SpaceObject chaserO,
                                                 SpaceObject runnerO,
                                                 long maxChaserSpeed,
                                                 int maxTicks)
```
    Returns the proper direction and speed to allow the given chaser to intercept the given runner.
    
    Parameters:
    
    chaserO - the chasing object
    
    runnerO - the running object
    
    maxChaserSpeed - the max chasing speed
    
    maxTicks - the maximum number of movements
    
    Returns:
    
    null if no intercept possible, or the new dir and speed
    
    See Also:
    
    canMaybeIntercept(SpaceObject, SpaceObject, int, double)
  - canMaybeIntercept
```
boolean canMaybeIntercept(SpaceObject chaserO,
                          SpaceObject runnerO,
                          int maxTicks,
                          double maxSpeed)
```
    Returns whether the vectors described by the chaser and runners, their speeds, and the amount of time in movement can even POSSIBLY intercept, because the two vectors overlap
    
    Parameters:
    
    chaserO - the chasing object
    
    runnerO - the running object
    
    maxTicks - the maximum number of movements
    
    maxSpeed - the max speed of the chaser
    
    Returns:
    
    true if there is a possible intercept, false otherwise
    
    See Also:
    
    calculateIntercept(SpaceObject, SpaceObject, long, int)
  - getSpaceObjects
```
java.util.Enumeration<SpaceObject> getSpaceObjects()
```
    Returns an enumeration of all object in the galactic space map.
    
    Returns:
    
    an enumeration of all object in the galactic space map
    
    See Also:
    
    getSpaceObjectEntries(), getSpaceObjectsWithin(SpaceObject, long, long), getSpaceObjectsByCenterpointWithin(long[], long, long), findSpaceObject(String, boolean), getSpaceObject(CMObject, boolean)
  - getSpaceObjectEntries
```
java.util.Enumeration<java.util.Map.Entry<SpaceObject,java.util.List<java.lang.ref.WeakReference<TrackingVector<SpaceObject>>>>> getSpaceObjectEntries()
```
    Returns an enumeration of all objects, along with a list of their tracking vectors? I have no idea why anyone would want this, so I won't explain any more until someone does try to use this.
    
    Returns:
    
    returns all of the objects in space
    
    See Also:
    
    getSpaceObjects(), getSpaceObjectsWithin(SpaceObject, long, long), getSpaceObjectsByCenterpointWithin(long[], long, long), findSpaceObject(String, boolean), getSpaceObject(CMObject, boolean), getSpaceObjectsInBound(BoundedCube)
  - getSpaceObjectsWithin
```
java.util.List<SpaceObject> getSpaceObjectsWithin(SpaceObject ofObj,
                                                  long minDistance,
                                                  long maxDistance)
```
    Given a space object to use as a center point on the galactic map, this will return all objects in the caches space map that is within the "donut" defined by those things.
    
    Parameters:
    
    ofObj - the space object to use as a center point
    
    minDistance - the minimum distance to return
    
    maxDistance - the maximum distance to return
    
    Returns:
    
    all objects matching the distance scan
    
    See Also:
    
    getSpaceObjects(), getSpaceObjectEntries(), getSpaceObjectsByCenterpointWithin(long[], long, long), findSpaceObject(String, boolean), getSpaceObject(CMObject, boolean), getSpaceObjectsInBound(BoundedCube)
  - getSpaceObjectsInBound
```
java.util.List<SpaceObject> getSpaceObjectsInBound(BoundedObject.BoundedCube cube)
```
    Given a bounded cube, this will return all space objects within that cube, and by within, i mean even just intersecting it.
    
    Parameters:
    
    cube - the cube to look within
    
    Returns:
    
    the objects in space in that cube
    
    See Also:
    
    getSpaceObjects(), getSpaceObjectEntries(), getSpaceObjectsByCenterpointWithin(long[], long, long), findSpaceObject(String, boolean), getSpaceObject(CMObject, boolean)
  - getSpaceObjectsByCenterpointWithin
```
java.util.List<SpaceObject> getSpaceObjectsByCenterpointWithin(long[] centerCoordinates,
                                                               long minDistance,
                                                               long maxDistance)
```
    Given a center galactic coordinates, and a minimum and maximum distance from that coordinate, this will return all objects in the caches space map that is within the "donut" defined by those things.
    
    Parameters:
    
    centerCoordinates - the full galactic coordinates of the center point
    
    minDistance - the minimum distance to return
    
    maxDistance - the maximum distance to return
    
    Returns:
    
    all objects matching the distance scan
    
    See Also:
    
    getSpaceObjects(), getSpaceObjectEntries(), getSpaceObjectsWithin(SpaceObject, long, long), findSpaceObject(String, boolean), getSpaceObject(CMObject, boolean), getSpaceObjectsInBound(BoundedCube)
  - getSpaceObject
```
SpaceObject getSpaceObject(CMObject o,
                           boolean ignoreMobs)
```
    Given a random object, this will return null, or the "nearest" space object, by crawling up an item container tree, or however it needs to.
    
    Parameters:
    
    o - the game object, of almost any sort (item, area, room, mob)
    
    ignoreMobs - true to return null on mobs, false otherwise
    
    Returns:
    
    the nearest SpaceObject the object IS, or is inside
    
    See Also:
    
    getSpaceObjects(), getSpaceObjectEntries(), getSpaceObjectsWithin(SpaceObject, long, long), getSpaceObjectsByCenterpointWithin(long[], long, long), findSpaceObject(String, boolean), getSpaceObjectsInBound(BoundedCube)
  - findSpaceObject
```
SpaceObject findSpaceObject(java.lang.String s,
                            boolean exactOnly)
```
    Given the name of an object in space, preferably a unique name, this will attempt to find and return it using standard search methods. That means class IDs, Names, and display texts are all game. Preference to the first hit, but supporting the .1, .2, etc syntax.
    
    Parameters:
    
    s - the search string
    
    exactOnly - true to only match full terms, false for partial matches
    
    Returns:
    
    the SpaceObject found, or null
    
    See Also:
    
    getSpaceObjects(), getSpaceObjectEntries(), getSpaceObjectsWithin(SpaceObject, long, long), getSpaceObjectsByCenterpointWithin(long[], long, long), getSpaceObject(CMObject, boolean), getSpaceObjectsInBound(BoundedCube)
  - getSectorName
```
java.lang.String getSectorName(long[] coordinates)
```
    Given some absolute space coordinates, this will return the name of the sector the coordinates are in.
    
    Parameters:
    
    coordinates - the space coordinates
    
    Returns:
    
    the name of the sector the coordinates are in
    
    See Also:
    
    getInSectorCoords(long[])
  - getInSectorCoords
```
long[] getInSectorCoords(long[] coordinates)
```
    Given absolute space coordinates, from -Long.MAX to Long.MAX, this will return the relative coordinates INSIDE the sector, whose bounds are determined by lots of math.
    
    Parameters:
    
    coordinates - the space coordinates
    
    Returns:
    
    the inner bounds
    
    See Also:
    
    getSectorName(long[])
  - getLandingPoints
```
java.util.List<LocationRoom> getLandingPoints(SpaceObject ship,
                                              Environmental O)
```
    Given a space ship, and an object that can be reduced to an Area, this will return a list of all valid LocationRoom objects, sorted by their present distance from the ship, from each other, and whether its a space port. Best closest match at the top of the list.
    
    Parameters:
    
    ship - the ship looking for a landing spot
    
    O - an area, room, boardable, whatever
    
    Returns:
    
    a list of LocationRoom objects, best on top
  - getGravityForce
```
double getGravityForce(SpaceObject S,
                       SpaceObject cO)
```
    If the two given objects are within an appropriate distance from each other, this will return the correct amount of acceleration g-force applied by the second object to the first. typically <= 1G
    
    Parameters:
    
    S - the object being pulled
    
    cO - the object pulling
    
    Returns:
    
    the amount of gravity force, or 0
  - getCurrentBattleCoveredDirections
```
ShipDirectional.ShipDir[] getCurrentBattleCoveredDirections(ShipDirectional comp)
```
    Given a ship war component, returns the directions in which it is currently covering.
    
    Parameters:
    
    comp - the war component
    
    Returns:
    
    the directions being covered
  - sendSpaceEmissionEvent
```
boolean sendSpaceEmissionEvent(SpaceObject srcP,
                               Environmental tool,
                               int emissionType,
                               java.lang.String msgStr)
```
    Generates an sends a message representing an emission in space, which might be picked up by various sensors. Includes broadcast messages.
    
    Parameters:
    
    srcP - the generator of the event/the center
    
    tool - the means by which the event was generated
    
    emissionType - the CMMsg type of the event
    
    msgStr - a description of the sensory message
    
    Returns:
    
    true if the event was propogated
  - sendSpaceEmissionEvent
```
boolean sendSpaceEmissionEvent(SpaceObject srcP,
                               Environmental tool,
                               long range,
                               int emissionType,
                               java.lang.String msgStr)
```
    Generates an sends a message representing an emission in space, which might be picked up by various sensors. Includes broadcast messages.
    
    Parameters:
    
    srcP - the generator of the event/the center
    
    tool - the means by which the event was generated
    
    range - the range at which the emission can be detected
    
    emissionType - the CMMsg type of the event
    
    msgStr - a description of the sensory message
    
    Returns:
    
    true if the event was propogated
  - plotCourse
```
java.util.List<long[]> plotCourse(long[] osrc,
                                  long sradius,
                                  long[] otarget,
                                  long tradius,
                                  int maxTicks)
```
    Plots a course from the source to the target, with a maximum number of steps/ticks. Will return a list of coordinates for the steps of the course. If the list contains the given otarget, then the plotting is complete. The list will never contain the source, as it is implied. If the course list comes back empty, then either something terrible went wrong, or the source is already close enough to the target for a course to be impossible.
    
    Parameters:
    
    osrc - the source coordinates
    
    sradius - the source object radius
    
    otarget - the target coordinates
    
    tradius - the target object radius
    
    maxTicks - maximum number of direction changes .. always send something gt 0
    
    Returns:
    
    the step coordinates in the course, with the source implied

Interface GalacticMap

Field Summary

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

Method Summary

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

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

Methods inherited from interface java.lang.Comparable

Method Detail

spaceAreas

numSpaceObjects

getSectorMap

isObjectInSpace

delObjectInSpace

addObjectToSpace

addObjectToSpace

getDistanceFrom

getDistanceFrom

getMinDistanceFrom

getAngleDelta

getMiddleAngle

getOffsetAngle

getAngleDiff

applyAngleDiff

getDirection

getDirection

getDirectionFromDir

getAbsoluteDirectionalFromDir

getOppositeDir

getPerpendicularAngles

getPerpendicularPoints

changeDirection

changeDirection

getRelativeSpeed

accelSpaceObject

accelSpaceObject

getLocation

moveSpaceObject

moveSpaceObject

moveSpaceObject

calculateIntercept

canMaybeIntercept

getSpaceObjects

getSpaceObjectEntries

getSpaceObjectsWithin

getSpaceObjectsInBound

getSpaceObjectsByCenterpointWithin

getSpaceObject

findSpaceObject

getSectorName

getInSectorCoords

getLandingPoints

getGravityForce

getCurrentBattleCoveredDirections

sendSpaceEmissionEvent

sendSpaceEmissionEvent

plotCourse