squidpony.squidai.DijkstraMap

All Implemented Interfaces:: Serializable

public class DijkstraMap
extends Object
implements Serializable

An alternative to AStarSearch when you want to fully explore a search space, or when you want a gradient floodfill. It's currently significantly faster that AStarSearch, and also supports pathfinding to the nearest of multiple goals, which is not possible with AStarSearch. This last feature enables a whole host of others, like pathfinding for creatures that can attack targets between a specified minimum and maximum distance, and there's also the standard uses of Dijkstra Maps such as finding ideal paths to run away. One unique optimization made possible by Dijkstra Maps is for when only one endpoint of a path can change in some section of a game, such as when you want to draw a path from the player's current cell to the cell the mouse is over, and while the mouse can move quickly, the player doesn't move until instructed to. This can be done very efficiently by setting the player as a goal with setGoal(Coord), scanning the map to find distances with scan(Collection), and then as long as the player's position is unchanged (and no obstacles are added/moved), you can get the path by calling findPathPreScanned(Coord) and giving it the mouse position as a Coord. If various parts of the path can change instead of just one (such as other NPCs moving around), then you should set a goal or goals and call findPath(int, Collection, Collection, Coord, Coord...). The parameters for this are used in various methods in this class with only slight differences: length is the length of path that can be moved "in one go," so 1 for most roguelikes and more for most strategy games, impassable used for enemies and solid moving obstacles, onlyPassable can be null in most roguelikes but in strategy games should contain ally positions that can be moved through as long as no one stops in them, start is the NPC's starting position, and targets is an array or vararg of Coord that the NPC should pathfind toward (it could be just one Coord, with or without explicitly putting it in an array, or it could be more and the NPC will pick the closest).
As a bit of introduction, the article http://www.roguebasin.com/index.php?title=Dijkstra_Maps_Visualized can provide some useful information on how these work and how to visualize the information they can produce, while http://www.roguebasin.com/index.php?title=The_Incredible_Power_of_Dijkstra_Maps is an inspiring list of the various features Dijkstra Maps can enable.
If you can't remember how to spell this, just remember: Does It Just Know Stuff? That's Really Awesome! Created by Tommy Ettinger on 4/4/2015.

See Also:: Serialized Form

Field Summary

Fields
Modifier and Type	Field	Description
`double[][]`	`costMap`	This stores the entry cost multipliers for each cell; that is, a value of 1.0 is a normal, unmodified cell, but a value of 0.5 can be entered easily (two cells of its cost can be entered for the cost of one 1.0 cell), and a value of 2.0 can only be entered with difficulty (one cell of its cost can be entered for the cost of two 1.0 cells).
`boolean`	`cutShort`
`static double`	`DARK`	This is used to mark cells that the scan couldn't reach, and these dark cells are marked with a high number equal to 999800.0 .
`static double`	`FLOOR`	Floor cells, which include any walkable cell, are marked with a high number equal to 999200.0 .
`protected IntVLA`	`fresh`	Goals that pathfinding will seek out.
`static double`	`GOAL`	Goals are always marked with 0.
`protected IntVLA`	`goals`	Goals that pathfinding will seek out.
`double[][]`	`gradientMap`	The frequently-changing values that are often the point of using this class; goals will have a value of 0, and any cells that can have a character reach a goal in n steps will have a value of n.
`int`	`height`	Height of the map.
`Measurement`	`measurement`	This affects how distance is measured on diagonal directions vs.
`ArrayList<Coord>`	`path`	The latest path that was obtained by calling findPath().
`double[][]`	`physicalMap`	Stores which parts of the map are accessible and which are not.
`IRNG`	`rng`	The IRNG used to decide which one of multiple equally-short paths to take.
`boolean`	`standardCosts`
`Coord[][]`	`targetMap`
`static double`	`WALL`	Walls, which are solid no-entry cells, are marked with a high number equal to 999500.0 .
`int`	`width`	Width of the map.

Constructor Summary

Constructors
Constructor	Description
`DijkstraMap()`	Construct a DijkstraMap without a level to actually scan.
`DijkstraMap(char[][] level)`	Constructor meant to take a char[][] returned by DungeonBoneGen.generate(), or any other char[][] where '#' means a wall and anything else is a walkable tile.
`DijkstraMap(char[][] level, char alternateWall)`	Constructor meant to take a char[][] returned by DungeonBoneGen.generate(), or any other char[][] where one char means a wall and anything else is a walkable tile.
`DijkstraMap(char[][] level, Measurement measurement)`	Constructor meant to take a char[][] returned by DungeonBoneGen.generate(), or any other char[][] where '#' means a wall and anything else is a walkable tile.
`DijkstraMap(char[][] level, Measurement measurement, IRNG rng)`	Constructor meant to take a char[][] returned by DungeonBoneGen.generate(), or any other char[][] where '#' means a wall and anything else is a walkable tile.
`DijkstraMap(char[][] level, IRNG rng)`	Constructor meant to take a char[][] returned by DungeonBoneGen.generate(), or any other char[][] where '#' means a wall and anything else is a walkable tile.
`DijkstraMap(double[][] level)`	Used to construct a DijkstraMap from the output of another.
`DijkstraMap(double[][] level, Measurement measurement)`	Used to construct a DijkstraMap from the output of another, specifying a distance calculation.
`DijkstraMap(IRNG random)`	Construct a DijkstraMap without a level to actually scan.

Method Summary

Modifier and Type	Method	Description
`void`	`clearGoals()`	Used to remove all goals and undo any changes to gradientMap made by having a goal present.
`Coord`	`decode(int encoded)`	If you for some reason have one of the internally-used ints produced by `encode(Coord)`, this will convert it back to a Coord if you need it as such.
`int`	`decodeX(int encoded)`	If you for some reason have one of the internally-used ints produced by `encode(Coord)`, this will decode the x component of the point encoded in that int.
`int`	`decodeY(int encoded)`	If you for some reason have one of the internally-used ints produced by `encode(Coord)`, this will decode the y component of the point encoded in that int.
`int`	`encode(int x, int y)`	Internally, DijkstraMap uses int primitives instead of Coord objects, but the specific encoding depends on this DijkstraMap's width and height.
`int`	`encode(Coord point)`	Internally, DijkstraMap uses int primitives instead of Coord objects, but the specific encoding depends on this DijkstraMap's width and height.
`ArrayList<Coord>`	`findAttackPath(int moveLength, int minPreferredRange, int maxPreferredRange, LOS los, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)`	Scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to a goal, until a cell is reached with a distance from a goal that is at least equal to minPreferredRange and no more than maxPreferredRange, which may go further from a goal if the minPreferredRange has not been met at the current distance.
`ArrayList<Coord>`	`findAttackPath(int moveLength, int preferredRange, LOS los, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)`	Scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to a goal, until preferredRange is reached, or further from a goal if the preferredRange has not been met at the current distance.
`ArrayList<Coord>`	`findAttackPath(ArrayList<Coord> buffer, int moveLength, int minPreferredRange, int maxPreferredRange, LOS los, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)`	Scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to a goal, until a cell is reached with a distance from a goal that is at least equal to minPreferredRange and no more than maxPreferredRange, which may go further from a goal if the minPreferredRange has not been met at the current distance.
`ArrayList<Coord>`	`findAttackPathLarge(int size, int moveLength, int minPreferredRange, int maxPreferredRange, LOS los, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)`	Scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to a goal, until a cell is reached with a distance from a goal that is at least equal to minPreferredRange and no more than maxPreferredRange, which may go further from a goal if the minPreferredRange has not been met at the current distance.
`ArrayList<Coord>`	`findAttackPathLarge(int size, int moveLength, int preferredRange, LOS los, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)`	For pathfinding creatures larger than 1x1 cell; scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to a goal, until preferredRange is reached, or further from a goal if the preferredRange has not been met at the current distance.
`ArrayList<Coord>`	`findFleePath(int length, double preferLongerPaths, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... fearSources)`	Scans the dungeon using DijkstraMap.scan with the listed fearSources and start point, and returns a list of Coord positions (using Manhattan distance) needed to get further from the closest fearSources, meant for running away.
`ArrayList<Coord>`	`findFleePath(int length, int scanLimit, double preferLongerPaths, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... fearSources)`	Scans the dungeon using DijkstraMap.scan or DijkstraMap.partialScan with the listed fearSources and start point, and returns a list of Coord positions (using this DijkstraMap's metric) needed to get further from the closest fearSources, meant for running away.
`ArrayList<Coord>`	`findFleePath(ArrayList<Coord> buffer, int length, int scanLimit, double preferLongerPaths, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... fearSources)`	Scans the dungeon using DijkstraMap.scan or DijkstraMap.partialScan with the listed fearSources and start point, and returns a list of Coord positions (using this DijkstraMap's metric) needed to get further from the closest fearSources, meant for running away.
`ArrayList<Coord>`	`findFleePathLarge(int size, int length, double preferLongerPaths, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... fearSources)`	Scans the dungeon using DijkstraMap.scan with the listed fearSources and start point, and returns a list of Coord positions (using Manhattan distance) needed to get further from the closest fearSources, meant for running away.
`static Measurement`	`findMeasurement(Radius radius)`	Gets the appropriate Measurement to pass to a constructor if you already have a Radius.
`Coord`	`findNearest(Coord start, Collection<Coord> targets)`	Recalculate the Dijkstra map until it reaches a Coord in targets, then returns the first target found.
`Coord`	`findNearest(Coord start, Coord... targets)`	Recalculate the Dijkstra map until it reaches a Coord in targets, then returns the first target found.
`ArrayList<Coord>`	`findNearestMultiple(Coord start, int limit, Collection<Coord> targets)`	Recalculate the Dijkstra map until it reaches a Coord in targets, then returns the first several targets found, up to limit or less if the map is fully searched without finding enough.
`ArrayList<Coord>`	`findPath(int length, int scanLimit, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)`	Scans the dungeon using DijkstraMap.scan or DijkstraMap.partialScan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to the closest reachable goal.
`ArrayList<Coord>`	`findPath(int length, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)`	Scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to the closest reachable goal.
`ArrayList<Coord>`	`findPath(ArrayList<Coord> buffer, int length, int scanLimit, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)`	Scans the dungeon using DijkstraMap.scan or DijkstraMap.partialScan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to the closest reachable goal.
`ArrayList<Coord>`	`findPathLarge(int size, int length, int scanLimit, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)`
`ArrayList<Coord>`	`findPathLarge(int size, int length, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)`	For pathfinding creatures larger than 1x1 cell; scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to the closest reachable goal.
`ArrayList<Coord>`	`findPathPreScanned(ArrayList<Coord> buffer, Coord target)`	When you can control how often the (relatively time-intensive) scan() method is called, but may need simple paths very frequently (such as for a path that follows the mouse), you can use this method to reduce the amount of work needed to find paths.
`ArrayList<Coord>`	`findPathPreScanned(Coord target)`	When you can control how often the (relatively time-intensive) scan() method is called, but may need simple paths very frequently (such as for a path that follows the mouse), you can use this method to reduce the amount of work needed to find paths.
`static Radius`	`findRadius(Measurement measurement)`	Gets the appropriate Radius corresponding to a Measurement.
`ArrayList<Coord>`	`findShortcutPath(Coord start, Coord... targets)`	If you have a target or group of targets you want to pathfind to without scanning the full map, this can be good.
`ArrayList<Coord>`	`findTechniquePath(int moveLength, Technique tech, char[][] dungeon, LOS los, Collection<Coord> impassable, Collection<Coord> allies, Coord start, Collection<Coord> targets)`	Scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to a goal, where goals are considered valid if they are at a valid range for the given Technique to hit at least one target and ideal if that Technique can affect as many targets as possible from a cell that can be moved to with at most movelength steps.
`ArrayList<Coord>`	`findTechniquePath(ArrayList<Coord> buffer, int moveLength, Technique tech, char[][] dungeon, LOS los, Collection<Coord> impassable, Collection<Coord> allies, Coord start, Collection<Coord> targets)`	Scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to a goal, where goals are considered valid if they are at a valid range for the given Technique to hit at least one target and ideal if that Technique can affect as many targets as possible from a cell that can be moved to with at most movelength steps.
`OrderedMap<Coord,Double>`	`floodFill(int radius, Coord... starts)`	A simple limited flood-fill that returns a OrderedMap of Coord keys to the Double values in the DijkstraMap, only calculating out to a number of steps determined by limit.
`int`	`getBlockingRequirement()`	If you want obstacles present in orthogonal cells to prevent pathfinding along the diagonal between them, this can be used to make thin diagonal walls non-viable to move through, or even to prevent diagonal movement if any one obstacle is orthogonally adjacent to both the start and target cell of a diagonal move.
`int`	`getMappedCount()`
`DijkstraMap`	`initialize(char[][] level)`	Used to initialize or re-initialize a DijkstraMap that needs a new physicalMap because it either wasn't given one when it was constructed, or because the contents of the terrain have changed permanently (not if a creature moved; for that you pass the positions of creatures that block paths to scan() or findPath() ).
`DijkstraMap`	`initialize(char[][] level, char alternateWall)`	Used to initialize or re-initialize a DijkstraMap that needs a new PhysicalMap because it either wasn't given one when it was constructed, or because the contents of the terrain have changed permanently (not if a creature moved; for that you pass the positions of creatures that block paths to scan() or findPath() ).
`DijkstraMap`	`initialize(double[][] level)`	Used to initialize or re-initialize a DijkstraMap that needs a new physicalMap because it either wasn't given one when it was constructed, or because the contents of the terrain have changed permanently (not if a creature moved; for that you pass the positions of creatures that block paths to scan() or findPath() ).
`DijkstraMap`	`initializeCost(char[][] level)`	Used to initialize the entry cost modifiers for games that require variable costs to enter squares.
`DijkstraMap`	`initializeCost(char[][] level, char alternateWall)`	Used to initialize the entry cost modifiers for games that require variable costs to enter squares.
`DijkstraMap`	`initializeCost(double[][] costs)`	Used to initialize the entry cost modifiers for games that require variable costs to enter squares.
`double[][]`	`partialScan(int limit)`	Recalculate the Dijkstra map up to a limit and return it.
`double[][]`	`partialScan(int limit, Collection<Coord> impassable)`	Recalculate the Dijkstra map up to a limit and return it.
`double[][]`	`partialScan(int limit, Collection<Coord> impassable, int size)`	Recalculate the Dijkstra map for a creature that is potentially larger than 1x1 cell and return it.
`void`	`partialScan(int limit, Coord start, Collection<Coord> impassable, int size)`	Recalculate the Dijkstra map for a creature that is potentially larger than 1x1 cell and return it.
`void`	`partialScan(Coord start, int limit, Collection<Coord> impassable)`	Recalculate the Dijkstra map up to a limit and return it.
`void`	`partialScan(Coord start, int limit, Collection<Coord> impassable, boolean nonZeroOptimum)`	Recalculate the Dijkstra map up to a limit and return it.
`void`	`reset()`	Resets this DijkstraMap to a state with no goals, no discovered path, and no changes made to gradientMap relative to physicalMap.
`void`	`resetCell(int x, int y)`	Reverts a cell to the value stored in the original state of the level as known by physicalMap.
`void`	`resetCell(Coord pt)`	Reverts a cell to the value stored in the original state of the level as known by physicalMap.
`void`	`resetMap()`	Resets the gradientMap to its original value from physicalMap.
`void`	`resetTargetMap()`	Resets the targetMap (which is only assigned in the first place if you use findTechniquePath() ).
`double[][]`	`scan()`	Recalculate the Dijkstra map and return it.
`double[][]`	`scan(Collection<Coord> impassable)`	Recalculate the Dijkstra map and return it.
`double[][]`	`scan(Collection<Coord> impassable, int size)`	Recalculate the Dijkstra map for a creature that is potentially larger than 1x1 cell and return it.
`void`	`scan(Coord start, Collection<Coord> impassable)`	Recalculate the Dijkstra map and return it.
`void`	`scan(Coord start, Collection<Coord> impassable, boolean nonZeroOptimum)`	Recalculate the Dijkstra map and return it.
`void`	`scan(Coord start, Collection<Coord> impassable, int size)`	Recalculate the Dijkstra map for a creature that is potentially larger than 1x1 cell and return it.
`void`	`setBlockingRequirement(int blockingRequirement)`	If you want obstacles present in orthogonal cells to prevent pathfinding along the diagonal between them, this can be used to make thin diagonal walls non-viable to move through, or even to prevent diagonal movement if any one obstacle is orthogonally adjacent to both the start and target cell of a diagonal move.
`void`	`setCost(int x, int y, double cost)`	Marks a cell's cost for pathfinding as cost, unless the cell is a wall or unreachable area (then it always sets the cost to the value of the WALL field).
`void`	`setCost(Coord pt, double cost)`	Marks a cell's cost for pathfinding as cost, unless the cell is a wall or unreachable area (then it always sets the cost to the value of the WALL field).
`void`	`setGoal(int x, int y)`	Marks a cell as a goal for pathfinding, unless the cell is a wall or unreachable area (then it does nothing).
`void`	`setGoal(Coord pt)`	Marks a cell as a goal for pathfinding, unless the cell is a wall or unreachable area (then it does nothing).
`void`	`setGoals(Iterable<Coord> pts)`	Marks many cells as goals for pathfinding, ignoring cells in walls or unreachable areas.
`void`	`setGoals(Coord[] pts)`	Marks many cells as goals for pathfinding, ignoring cells in walls or unreachable areas.
`void`	`setGoals(GreasedRegion pts)`	Marks many cells as goals for pathfinding, ignoring cells in walls or unreachable areas.
`void`	`setOccupied(int x, int y)`	Marks a specific cell in gradientMap as completely impossible to enter.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details
- measurement
  
  public Measurement measurement
  
  This affects how distance is measured on diagonal directions vs. orthogonal directions. MANHATTAN should form a diamond shape on a featureless map, while CHEBYSHEV and EUCLIDEAN will form a square. EUCLIDEAN does not affect the length of paths, though it will change the DijkstraMap's gradientMap to have many non-integer values, and that in turn will make paths this finds much more realistic and smooth (favoring orthogonal directions unless a diagonal one is a better option).
- physicalMap
  
  public double[][] physicalMap
  
  Stores which parts of the map are accessible and which are not. Should not be changed unless the actual physical terrain has changed. You should call initialize() with a new map instead of changing this directly.
- gradientMap
  
  public double[][] gradientMap
  
  The frequently-changing values that are often the point of using this class; goals will have a value of 0, and any cells that can have a character reach a goal in n steps will have a value of n. Cells that cannot be entered because they are solid will have a very high value equal to the WALL constant in this class, and cells that cannot be entered because they cannot reach a goal will have a different very high value equal to the DARK constant in this class.
- costMap
  
  public double[][] costMap
  
  This stores the entry cost multipliers for each cell; that is, a value of 1.0 is a normal, unmodified cell, but a value of 0.5 can be entered easily (two cells of its cost can be entered for the cost of one 1.0 cell), and a value of 2.0 can only be entered with difficulty (one cell of its cost can be entered for the cost of two 1.0 cells). Unlike the measurement field, this does affect the length of paths, as well as the numbers assigned to gradientMap during a scan. The values for walls are identical to the value used by gradientMap, that is, this class' WALL static final field. Floors, however, are never given FLOOR as a value, and default to 1.0 .
- standardCosts
  
  public boolean standardCosts
- height
  
  public int height
  
  Height of the map. Exciting stuff. Don't change this, instead call initialize().
- width
  
  public int width
  
  Width of the map. Exciting stuff. Don't change this, instead call initialize().
- path
  
  public ArrayList<Coord> path
  
  The latest path that was obtained by calling findPath(). It will not contain the value passed as a starting cell; only steps that require movement will be included, and so if the path has not been found or a valid path toward a goal is impossible, this ArrayList will be empty.
- cutShort
  
  public boolean cutShort
- GOAL
  
  public static final double GOAL
  
  Goals are always marked with 0.
  
  See Also:
  
  Constant Field Values
- FLOOR
  
  public static final double FLOOR
  
  Floor cells, which include any walkable cell, are marked with a high number equal to 999200.0 .
  
  See Also:
  
  Constant Field Values
- WALL
  
  public static final double WALL
  
  Walls, which are solid no-entry cells, are marked with a high number equal to 999500.0 .
  
  See Also:
  
  Constant Field Values
- DARK
  
  public static final double DARK
  
  This is used to mark cells that the scan couldn't reach, and these dark cells are marked with a high number equal to 999800.0 .
  
  See Also:
  
  Constant Field Values
- goals
  
  protected IntVLA goals
  
  Goals that pathfinding will seek out. The Double value should almost always be 0.0 , the same as the static GOAL constant in this class.
- fresh
  
  protected IntVLA fresh
  
  Goals that pathfinding will seek out. The Double value should almost always be 0.0 , the same as the static GOAL constant in this class.
- rng
  
  public IRNG rng
  
  The IRNG used to decide which one of multiple equally-short paths to take. You may want to give this a GWTRNG if you may target web browsers with GWT, or a RNG or StatefulRNG otherwise.
- targetMap
  
  public Coord[][] targetMap
Constructor Details
- DijkstraMap
  
  public DijkstraMap()
  
  Construct a DijkstraMap without a level to actually scan. If you use this constructor, you must call an initialize() method before using this class.
- DijkstraMap
  
  public DijkstraMap(IRNG random)
  
  Construct a DijkstraMap without a level to actually scan. This constructor allows you to specify an IRNG, such as an RNG, before it is ever used in this class. If you use this constructor, you must call an initialize() method before using any other methods in the class.
- DijkstraMap
  
  public DijkstraMap(double[][] level)
  
  Used to construct a DijkstraMap from the output of another.
  
  Parameters:
  
  level -
- DijkstraMap
  
  public DijkstraMap(double[][] level, Measurement measurement)
  
  Used to construct a DijkstraMap from the output of another, specifying a distance calculation.
  
  Parameters:
  
  level -
  
  measurement -
- DijkstraMap
  
  public DijkstraMap(char[][] level)
  
  Constructor meant to take a char[][] returned by DungeonBoneGen.generate(), or any other char[][] where '#' means a wall and anything else is a walkable tile. If you only have a map that uses box-drawing characters, use DungeonUtility.linesToHashes() to get a map that can be used here.
  
  Parameters:
  
  level -
- DijkstraMap
  
  public DijkstraMap(char[][] level, IRNG rng)
  
  Constructor meant to take a char[][] returned by DungeonBoneGen.generate(), or any other char[][] where '#' means a wall and anything else is a walkable tile. If you only have a map that uses box-drawing characters, use DungeonUtility.linesToHashes() to get a map that can be used here. Also takes an IRNG, such as an RNG, that ensures predictable path choices given otherwise identical inputs and circumstances.
  
  Parameters:
  
  level -
  
  rng - The RNG to use for certain decisions; only affects find* methods like findPath, not scan.
- DijkstraMap
  
  public DijkstraMap(char[][] level, char alternateWall)
  
  Constructor meant to take a char[][] returned by DungeonBoneGen.generate(), or any other char[][] where one char means a wall and anything else is a walkable tile. If you only have a map that uses box-drawing characters, use DungeonUtility.linesToHashes() to get a map that can be used here. You can specify the character used for walls.
  
  Parameters:
  
  level -
- DijkstraMap
  
  public DijkstraMap(char[][] level, Measurement measurement)
  
  Constructor meant to take a char[][] returned by DungeonBoneGen.generate(), or any other char[][] where '#' means a wall and anything else is a walkable tile. If you only have a map that uses box-drawing characters, use DungeonUtility.linesToHashes() to get a map that can be used here. This constructor specifies a distance measurement.
  
  Parameters:
  
  level -
  
  measurement -
- DijkstraMap
  
  public DijkstraMap(char[][] level, Measurement measurement, IRNG rng)
  
  Constructor meant to take a char[][] returned by DungeonBoneGen.generate(), or any other char[][] where '#' means a wall and anything else is a walkable tile. If you only have a map that uses box-drawing characters, use DungeonUtility.linesToHashes() to get a map that can be used here. Also takes a distance measurement and an RNG that ensures predictable path choices given otherwise identical inputs and circumstances.
  
  Parameters:
  
  level -
  
  rng - The RNG to use for certain decisions; only affects find* methods like findPath, not scan.
Method Details
- initialize
  
  public DijkstraMap initialize(double[][] level)
  
  Used to initialize or re-initialize a DijkstraMap that needs a new physicalMap because it either wasn't given one when it was constructed, or because the contents of the terrain have changed permanently (not if a creature moved; for that you pass the positions of creatures that block paths to scan() or findPath() ).
  
  Parameters:
  
  level - a 2D double array that should be used as the physicalMap for this DijkstraMap
  
  Returns:
  
  this for chaining
- initialize
  
  public DijkstraMap initialize(char[][] level)
  
  Used to initialize or re-initialize a DijkstraMap that needs a new physicalMap because it either wasn't given one when it was constructed, or because the contents of the terrain have changed permanently (not if a creature moved; for that you pass the positions of creatures that block paths to scan() or findPath() ).
  
  Parameters:
  
  level - a 2D char array that this will use to establish which cells are walls ('#' as wall, others as floor)
  
  Returns:
  
  this for chaining
- initialize
  
  public DijkstraMap initialize(char[][] level, char alternateWall)
  
  Used to initialize or re-initialize a DijkstraMap that needs a new PhysicalMap because it either wasn't given one when it was constructed, or because the contents of the terrain have changed permanently (not if a creature moved; for that you pass the positions of creatures that block paths to scan() or findPath() ). This initialize() method allows you to specify an alternate wall char other than the default character, '#' .
  
  Parameters:
  
  level - a 2D char array that this will use to establish which cells are walls (alternateWall defines the wall char, everything else is floor)
  
  alternateWall - the char to consider a wall when it appears in level
  
  Returns:
  
  this for chaining
- initializeCost
  
  public DijkstraMap initializeCost(char[][] level)
  
  Used to initialize the entry cost modifiers for games that require variable costs to enter squares. This expects a char[][] of the same exact dimensions as the 2D array that was used to previously initialize() this DijkstraMap, treating the '#' char as a wall (impassable) and anything else as having a normal cost to enter. The costs can be accessed later by using costMap directly (which will have a valid value when this does not throw an exception), or by calling setCost().
  
  Parameters:
  
  level - a 2D char array that uses '#' for walls
  
  Returns:
  
  this DijkstraMap for chaining.
- initializeCost
  
  public DijkstraMap initializeCost(char[][] level, char alternateWall)
  
  Used to initialize the entry cost modifiers for games that require variable costs to enter squares. This expects a char[][] of the same exact dimensions as the 2D array that was used to previously initialize() this DijkstraMap, treating the '#' char as a wall (impassable) and anything else as having a normal cost to enter. The costs can be accessed later by using costMap directly (which will have a valid value when this does not throw an exception), or by calling setCost().
  This method allows you to specify an alternate wall char other than the default character, '#' .
  
  Parameters:
  
  level - a 2D char array that uses alternateChar for walls.
  
  alternateWall - a char to use to represent walls.
  
  Returns:
  
  this DijkstraMap for chaining.
- initializeCost
  
  public DijkstraMap initializeCost(double[][] costs)
  
  Used to initialize the entry cost modifiers for games that require variable costs to enter squares. This expects a double[][] of the same exact dimensions as the 2D array that was used to previously initialize() this DijkstraMap, using the exact values given in costs as the values to enter cells, even if they aren't what this class would assign normally -- walls and other impassable values should be given WALL as a value, however. The costs can be accessed later by using costMap directly (which will have a valid value when this does not throw an exception), or by calling setCost(). Causes findPath() to always explore the full map instead of stopping as soon as it finds any path, since unequal costs could make some paths cost less but be discovered later in the pathfinding process.
  This method should be slightly more efficient than the other initializeCost methods.
  
  Parameters:
  
  costs - a 2D double array that already has the desired cost values
  
  Returns:
  
  this DijkstraMap for chaining.
- encode
  
  public int encode(Coord point)
  
  Internally, DijkstraMap uses int primitives instead of Coord objects, but the specific encoding depends on this DijkstraMap's width and height. This method converts from a Coord to an encoded int that stores the same information, but is specific to this width and height and is somewhat more efficient to work with.
  
  Parameters:
  
  point - a Coord to find an encoded int for
  
  Returns:
  
  an int that encodes the given Coord for this DijkstraMap's width and height
- encode
  
  public int encode(int x, int y)
  
  Internally, DijkstraMap uses int primitives instead of Coord objects, but the specific encoding depends on this DijkstraMap's width and height. This method converts from an x,y point to an encoded int that stores the same information, but is specific to this width and height and is somewhat more efficient to work with.
  
  Parameters:
  
  x - the x component of the point to find an encoded int for
  
  y - the y component of the point to find an encoded int for
  
  Returns:
  
  an int that encodes the given x,y point for this DijkstraMap's width and height
- decode
  
  public Coord decode(int encoded)
  
  If you for some reason have one of the internally-used ints produced by encode(Coord), this will convert it back to a Coord if you need it as such. You may prefer using decodeX(int) and decodeY(int) to get the x and y components independently and without involving objects.
  
  Parameters:
  
  encoded - an encoded int specific to this DijkstraMap's height and width; see encode(Coord)
  
  Returns:
  
  the Coord that represents the same x,y position that the given encoded int stores
- decodeX
  
  public int decodeX(int encoded)
  
  If you for some reason have one of the internally-used ints produced by encode(Coord), this will decode the x component of the point encoded in that int. This is an extremely simple method that is equivalent to the code encoded % width, where width is a public field in this class. You probably would use this method in conjunction with decodeY(int), or would instead use decode(int) to get a Coord.
  
  Parameters:
  
  encoded - an encoded int specific to this DijkstraMap's height and width; see encode(Coord)
  
  Returns:
  
  the x component of the position that the given encoded int stores
- decodeY
  
  public int decodeY(int encoded)
  
  If you for some reason have one of the internally-used ints produced by encode(Coord), this will decode the y component of the point encoded in that int. This is an extremely simple method that is equivalent to the code encoded / width, where width is a public field in this class. You probably would use this method in conjunction with decodeX(int), or would instead use decode(int) to get a Coord.
  
  Parameters:
  
  encoded - an encoded int specific to this DijkstraMap's height and width; see encode(Coord)
  
  Returns:
  
  the y component of the position that the given encoded int stores
- findMeasurement
  
  public static Measurement findMeasurement(Radius radius)
  
  Gets the appropriate Measurement to pass to a constructor if you already have a Radius. Matches SQUARE or CUBE to CHEBYSHEV, DIAMOND or OCTAHEDRON to MANHATTAN, and CIRCLE or SPHERE to EUCLIDEAN.
  
  Parameters:
  
  radius - the Radius to find the corresponding Measurement for
  
  Returns:
  
  a Measurement that matches radius; SQUARE to CHEBYSHEV, DIAMOND to MANHATTAN, etc.
- findRadius
  
  public static Radius findRadius(Measurement measurement)
  
  Gets the appropriate Radius corresponding to a Measurement. Matches CHEBYSHEV to SQUARE, MANHATTAN to DIAMOND, and EUCLIDEAN to CIRCLE.
  See also Measurement.matchingRadius() as a method on Measurement.
  
  Parameters:
  
  measurement - the Measurement to find the corresponding Radius for
  
  Returns:
  
  a Radius that matches measurement; CHEBYSHEV to SQUARE, MANHATTAN to DIAMOND, etc.
- resetMap
  
  public void resetMap()
  
  Resets the gradientMap to its original value from physicalMap.
- resetTargetMap
  
  public void resetTargetMap()
  
  Resets the targetMap (which is only assigned in the first place if you use findTechniquePath() ).
- reset
  
  public void reset()
  
  Resets this DijkstraMap to a state with no goals, no discovered path, and no changes made to gradientMap relative to physicalMap.
- setGoal
  
  public void setGoal(int x, int y)
  
  Marks a cell as a goal for pathfinding, unless the cell is a wall or unreachable area (then it does nothing).
  
  Parameters:
  
  x -
  
  y -
- setGoal
  
  public void setGoal(Coord pt)
  
  Marks a cell as a goal for pathfinding, unless the cell is a wall or unreachable area (then it does nothing).
  
  Parameters:
  
  pt -
- setGoals
  
  public void setGoals(GreasedRegion pts)
  
  Marks many cells as goals for pathfinding, ignoring cells in walls or unreachable areas. Possibly more efficient than a loop that calls setGoal(Coord) over and over, since this doesn't need to do a bounds check. The GreasedRegion passed to this should have the same (or smaller) width and height as this DijkstraMap.
  
  Parameters:
  
  pts - a GreasedRegion containing "on" cells to treat as goals; should have the same width and height as this
- setGoals
  
  public void setGoals(Iterable<Coord> pts)
  
  Marks many cells as goals for pathfinding, ignoring cells in walls or unreachable areas. Simply loops through pts and calls setGoal(Coord) on each Coord in pts. If you have a GreasedRegion, you should use it with setGoals(GreasedRegion), which is faster.
  
  Parameters:
  
  pts - any Iterable of Coord, which can be a List, Set, Queue, etc. of Coords to mark as goals
- setGoals
  
  public void setGoals(Coord[] pts)
  
  Marks many cells as goals for pathfinding, ignoring cells in walls or unreachable areas. Simply loops through pts and calls setGoal(Coord) on each Coord in pts.
  
  Parameters:
  
  pts - an array of Coord to mark as goals
- setCost
  
  public void setCost(Coord pt, double cost)
  
  Marks a cell's cost for pathfinding as cost, unless the cell is a wall or unreachable area (then it always sets the cost to the value of the WALL field).
  
  Parameters:
  
  pt -
  
  cost -
- setCost
  
  public void setCost(int x, int y, double cost)
  
  Marks a cell's cost for pathfinding as cost, unless the cell is a wall or unreachable area (then it always sets the cost to the value of the WALL field).
  
  Parameters:
  
  x -
  
  y -
  
  cost -
- setOccupied
  
  public void setOccupied(int x, int y)
  
  Marks a specific cell in gradientMap as completely impossible to enter.
  
  Parameters:
  
  x -
  
  y -
- resetCell
  
  public void resetCell(int x, int y)
  
  Reverts a cell to the value stored in the original state of the level as known by physicalMap.
  
  Parameters:
  
  x -
  
  y -
- resetCell
  
  public void resetCell(Coord pt)
  
  Reverts a cell to the value stored in the original state of the level as known by physicalMap.
  
  Parameters:
  
  pt -
- clearGoals
  
  public void clearGoals()
  
  Used to remove all goals and undo any changes to gradientMap made by having a goal present.
- scan
  
  public double[][] scan()
  
  Recalculate the Dijkstra map and return it. Cells that were marked as goals with setGoal will have a value of 0, the cells adjacent to goals will have a value of 1, and cells progressively further from goals will have a value equal to the distance from the nearest goal. The exceptions are walls, which will have a value defined by the WALL constant in this class, and areas that the scan was unable to reach, which will have a value defined by the DARK constant in this class (typically, these areas should not be used to place NPCs or items and should be filled with walls). This uses the current measurement. The result is stored in the gradientMap field and a copy is returned.
  
  Returns:
  
  A 2D double[width][height] using the width and height of what this knows about the physical map.
- scan
  
  public double[][] scan(Collection<Coord> impassable)
  
  Recalculate the Dijkstra map and return it. Cells that were marked as goals with setGoal will have a value of 0, the cells adjacent to goals will have a value of 1, and cells progressively further from goals will have a value equal to the distance from the nearest goal. The exceptions are walls, which will have a value defined by the WALL constant in this class, and areas that the scan was unable to reach, which will have a value defined by the DARK constant in this class (typically, these areas should not be used to place NPCs or items and should be filled with walls). This uses the current measurement. The result is stored in the gradientMap field and a copy is returned.
  
  Parameters:
  
  impassable - A Collection of Coord keys representing the locations of enemies or other moving obstacles to a path that cannot be moved through; this can be null if there are no such obstacles.
  
  Returns:
  
  A 2D double[width][height] using the width and height of what this knows about the physical map.
- scan
  
  public void scan(Coord start, Collection<Coord> impassable)
  
  Recalculate the Dijkstra map and return it. Cells that were marked as goals with setGoal will have a value of 0, the cells adjacent to goals will have a value of 1, and cells progressively further from goals will have a value equal to the distance from the nearest goal. The exceptions are walls, which will have a value defined by the WALL constant in this class, and areas that the scan was unable to reach, which will have a value defined by the DARK constant in this class (typically, these areas should not be used to place NPCs or items and should be filled with walls). This uses the current measurement. The result is stored in the gradientMap field, and nothing is returned. If you want the data returned, you can use scan(Collection) (which calls this method with null for the start parameter, then modifies the gradientMap field and returns a copy), or you can just retrieve the gradientMap (maybe copying it; ArrayTools.copy(double[][]) is a convenient option for copying a 2D double array). If start is non-null, which is usually used when finding a single path, then cells that didn't need to be explored (because they were further than the path needed to go from start to goal) will have the value FLOOR. You may wish to assign a different value to these cells in some cases (especially if start is null, which means any cells that are still FLOOR could not be reached from any goal), and the overloads of scan that return 2D double arrays do change FLOOR to DARK, which is usually treated similarly to WALL.
  
  Parameters:
  
  start - a Coord representing the location of the pathfinder; may be null, which has this scan the whole map
  
  impassable - A Collection of Coord keys representing the locations of enemies or other moving obstacles to a path that cannot be moved through; this can be null if there are no such obstacles.
- scan
  
  public void scan(Coord start, Collection<Coord> impassable, boolean nonZeroOptimum)
  
  Recalculate the Dijkstra map and return it. Cells in gradientMap that had the lowest value will be treated as goals if nonZeroOptimum is true; otherwise, only cells marked as goals with setGoal(Coord) will be considered goals and some overhead will be saved. The cells adjacent to goals will have a value of 1, and cells progressively further from goals will have a value equal to the distance from the nearest goal. The exceptions are walls, which will have a value defined by the WALL constant in this class, and areas that the scan was unable to reach, which will have a value defined by the DARK constant in this class (typically, these areas should not be used to place NPCs or items and should be filled with walls). This uses the current measurement. The result is stored in the gradientMap field, and nothing is returned. If you want the data returned, you can use scan(Collection) (which calls this method with null for the start parameter, then modifies the gradientMap field and returns a copy), or you can just retrieve the gradientMap (maybe copying it; ArrayTools.copy(double[][]) is a convenient option for copying a 2D double array). If start is non-null, which is usually used when finding a single path, then cells that didn't need to be explored (because they were further than the path needed to go from start to goal) will have the value FLOOR. You may wish to assign a different value to these cells in some cases (especially if start is null, which means any cells that are still FLOOR could not be reached from any goal), and the overloads of scan that return 2D double arrays do change FLOOR to DARK, which is usually treated similarly to WALL.
  
  Parameters:
  
  start - a Coord representing the location of the pathfinder; may be null, which has this scan the whole map
  
  impassable - A Collection of Coord keys representing the locations of enemies or other moving obstacles to a path that cannot be moved through; this can be null if there are no such obstacles.
  
  nonZeroOptimum - if the cell to pathfind toward should have a value of GOAL (0.0), this should be false; if it should have a different value or if you don't know, it should be true
- partialScan
  
  public double[][] partialScan(int limit)
  
  Recalculate the Dijkstra map up to a limit and return it. Cells that were marked as goals with setGoal will have a value of 0, the cells adjacent to goals will have a value of 1, and cells progressively further from goals will have a value equal to the distance from the nearest goal. If a cell would take more steps to reach than the given limit, it will have a value of DARK if it was passable instead of the distance. The exceptions are walls, which will have a value defined by the WALL constant in this class, and areas that the scan was unable to reach, which will have a value defined by the DARK constant in this class. This uses the current measurement. The result is stored in the gradientMap field and a copy is returned.
  
  Parameters:
  
  limit - The maximum number of steps to scan outward from a goal.
  
  Returns:
  
  A 2D double[width][height] using the width and height of what this knows about the physical map.
- partialScan
  
  public double[][] partialScan(int limit, Collection<Coord> impassable)
  
  Recalculate the Dijkstra map up to a limit and return it. Cells that were marked as goals with setGoal will have a value of 0, the cells adjacent to goals will have a value of 1, and cells progressively further from goals will have a value equal to the distance from the nearest goal. If a cell would take more steps to reach than the given limit, it will have a value of DARK if it was passable instead of the distance. The exceptions are walls, which will have a value defined by the WALL constant in this class, and areas that the scan was unable to reach, which will have a value defined by the DARK constant in this class. This uses the current measurement. The result is stored in the gradientMap field and a copy is returned.
  
  Parameters:
  
  limit - The maximum number of steps to scan outward from a goal.
  
  impassable - A Collection of Coord keys representing the locations of enemies or other moving obstacles to a path that cannot be moved through; this can be null if there are no such obstacles.
  
  Returns:
  
  A 2D double[width][height] using the width and height of what this knows about the physical map.
- partialScan
  
  public void partialScan(Coord start, int limit, Collection<Coord> impassable)
  
  Recalculate the Dijkstra map up to a limit and return it. Cells that were marked as goals with setGoal will have a value of 0, the cells adjacent to goals will have a value of 1, and cells progressively further from goals will have a value equal to the distance from the nearest goal. If a cell would take more steps to reach than the given limit, or if it was otherwise unreachable, it will have a value of FLOOR or greater if it was passable instead of the distance. The exceptions are walls, which will have a value defined by the WALL constant in this class. This uses the current measurement. The result is stored in the gradientMap field, and nothing is returned.If you want the data returned, you can use partialScan(int, Collection) (which calls this method with null for the start parameter, then modifies the gradientMap field and returns a copy), or you can just retrieve the gradientMap (maybe copying it; ArrayTools.copy(double[][]) is a convenient option for copying a 2D double array).
  If start is non-null, which is usually used when finding a single path, then cells that didn't need to be explored (because they were further than the path needed to go from start to goal) will have the value FLOOR. You may wish to assign a different value to these cells in some cases (especially if start is null, which means any cells that are still FLOOR could not be reached from any goal), and the overloads of partialScan that return 2D double arrays do change FLOOR to DARK, which is usually treated similarly to WALL.
  
  Parameters:
  
  start - a Coord representing the location of the pathfinder; may be null to have this scan more of the map
  
  limit - The maximum number of steps to scan outward from a goal.
  
  impassable - A Collection of Coord keys representing the locations of enemies or other moving obstacles to a path that cannot be moved through; this can be null if there are no such obstacles.
- partialScan
  
  public void partialScan(Coord start, int limit, Collection<Coord> impassable, boolean nonZeroOptimum)
  
  Recalculate the Dijkstra map up to a limit and return it. Cells in gradientMap that had the lowest value will be treated as goals if nonZeroOptimum is true; otherwise, only cells marked as goals with setGoal(Coord) will be considered goals and some overhead will be saved. If a cell would take more steps to reach than the given limit, or if it was otherwise unreachable, it will have a value of FLOOR or greater if it was passable instead of the distance. The exceptions are walls, which will have a value defined by the WALL constant in this class. This uses the current measurement. The result is stored in the gradientMap field, and nothing is returned.If you want the data returned, you can use partialScan(int, Collection) (which calls this method with null for the start parameter, then modifies the gradientMap field and returns a copy), or you can just retrieve the gradientMap (maybe copying it; ArrayTools.copy(double[][]) is a convenient option for copying a 2D double array).
  If start is non-null, which is usually used when finding a single path, then cells that didn't need to be explored (because they were further than the path needed to go from start to goal) will have the value FLOOR. You may wish to assign a different value to these cells in some cases (especially if start is null, which means any cells that are still FLOOR could not be reached from any goal), and the overloads of partialScan that return 2D double arrays do change FLOOR to DARK, which is usually treated similarly to WALL.
  
  Parameters:
  
  start - a Coord representing the location of the pathfinder; may be null to have this scan more of the map
  
  limit - The maximum number of steps to scan outward from a goal.
  
  impassable - A Collection of Coord keys representing the locations of enemies or other moving obstacles to a path that cannot be moved through; this can be null if there are no such obstacles.
  
  nonZeroOptimum - if the cell to pathfind toward should have a value of GOAL (0.0), this should be false; if it should have a different value or if you don't know, it should be true
- findNearest
  
  public Coord findNearest(Coord start, Collection<Coord> targets)
  
  Recalculate the Dijkstra map until it reaches a Coord in targets, then returns the first target found. This uses the current measurement.
  
  Parameters:
  
  start - the cell to use as the origin for finding the nearest target
  
  targets - the Coords that this is trying to find; it will stop once it finds one
  
  Returns:
  
  the Coord that it found first.
- findNearest
  
  public Coord findNearest(Coord start, Coord... targets)
  
  Recalculate the Dijkstra map until it reaches a Coord in targets, then returns the first target found. This uses the current measurement.
  
  Parameters:
  
  start - the cell to use as the origin for finding the nearest target
  
  targets - the Coords that this is trying to find; it will stop once it finds one
  
  Returns:
  
  the Coord that it found first.
- findShortcutPath
  
  public ArrayList<Coord> findShortcutPath(Coord start, Coord... targets)
  
  If you have a target or group of targets you want to pathfind to without scanning the full map, this can be good. It may find sub-optimal paths in the presence of costs to move into cells. It is useful when you want to move in a straight line to a known nearby goal.
  
  Parameters:
  
  start - your starting location
  
  targets - an array or vararg of Coords to pathfind to the nearest of
  
  Returns:
  
  an ArrayList of Coord that goes from a cell adjacent to start and goes to one of the targets. Copy of path.
- findNearestMultiple
  
  public ArrayList<Coord> findNearestMultiple(Coord start, int limit, Collection<Coord> targets)
  
  Recalculate the Dijkstra map until it reaches a Coord in targets, then returns the first several targets found, up to limit or less if the map is fully searched without finding enough. This uses the current measurement.
  
  Parameters:
  
  start - the cell to use as the origin for finding the nearest targets
  
  limit - the maximum number of targets to find before returning
  
  targets - the Coords that this is trying to find; it will stop once it finds enough (based on limit)
  
  Returns:
  
  the Coords that it found first.
- scan
  
  public double[][] scan(Collection<Coord> impassable, int size)
  
  Recalculate the Dijkstra map for a creature that is potentially larger than 1x1 cell and return it. The value of a cell in the returned Dijkstra map assumes that a creature is square, with a side length equal to the passed size, that its minimum-x, minimum-y cell is the starting cell, and that any cell with a distance number represents the distance for the creature's minimum-x, minimum-y cell to reach it. Cells that cannot be entered by the minimum-x, minimum-y cell because of sizing (such as a floor cell next to a maximum-x and/or maximum-y wall if size is > 1) will be marked as DARK. Cells that were marked as goals with setGoal will have a value of 0, the cells adjacent to goals will have a value of 1, and cells progressively further from goals will have a value equal to the distance from the nearest goal. The exceptions are walls, which will have a value defined by the WALL constant in this class, and areas that the scan was unable to reach, which will have a value defined by the DARK constant in this class. (typically, these areas should not be used to place NPCs or items and should be filled with walls). This uses the current measurement. The result is stored in the gradientMap field and a copy is returned.
  
  Parameters:
  
  impassable - A Collection of Coord keys representing the locations of enemies or other moving obstacles to a path that cannot be moved through; this can be null if there are no such obstacles.
  
  size - The length of one side of a square creature using this to find a path, i.e. 2 for a 2x2 cell creature. Non-square creatures are not supported because turning is really hard.
  
  Returns:
  
  A 2D double[width][height] using the width and height of what this knows about the physical map.
- scan
  
  public void scan(Coord start, Collection<Coord> impassable, int size)
  
  Recalculate the Dijkstra map for a creature that is potentially larger than 1x1 cell and return it. The value of a cell in the returned Dijkstra map assumes that a creature is square, with a side length equal to the passed size, that its minimum-x, minimum-y cell is the starting cell, and that any cell with a distance number represents the distance for the creature's minimum-x, minimum-y cell to reach it. Cells that cannot be entered by the minimum-x, minimum-y cell because of sizing (such as a floor cell next to a maximum-x and/or maximum-y wall if size is > 1) will be marked as DARK. Cells that were marked as goals with setGoal will have a value of 0, the cells adjacent to goals will have a value of 1, and cells progressively further from goals will have a value equal to the distance from the nearest goal. The exceptions are walls, which will have a value defined by the WALL constant in this class, and areas that the scan was unable to reach, which will have a value defined by the DARK constant in this class. (typically, these areas should not be used to place NPCs or items and should be filled with walls). This uses the current measurement. The result is stored in the gradientMap field, and nothing is returned. If you want the data returned, you can use scan(Collection, int) (which calls this method with null for the start parameter, then modifies the gradientMap field and returns a copy), or you can just retrieve the gradientMap (maybe copying it; ArrayTools.copy(double[][]) is a convenient option for copying a 2D double array). If start is non-null, which is usually used when finding a single path, then cells that didn't need to be explored (because they were further than the path needed to go from start to goal) will have the value FLOOR. You may wish to assign a different value to these cells in some cases (especially if start is null, which means any cells that are still FLOOR could not be reached from any goal), and the overloads of scan that return 2D double arrays do change FLOOR to DARK, which is usually treated similarly to WALL.
  
  Parameters:
  
  impassable - A Collection of Coord keys representing the locations of enemies or other moving obstacles to a path that cannot be moved through; this can be null if there are no such obstacles.
  
  size - The length of one side of a square creature using this to find a path, i.e. 2 for a 2x2 cell creature. Non-square creatures are not supported because turning is really hard.
- partialScan
  
  public double[][] partialScan(int limit, Collection<Coord> impassable, int size)
  
  Recalculate the Dijkstra map for a creature that is potentially larger than 1x1 cell and return it. The value of a cell in the returned Dijkstra map assumes that a creature is square, with a side length equal to the passed size, that its minimum-x, minimum-y cell is the starting cell, and that any cell with a distance number represents the distance for the creature's minimum-x, minimum-y cell to reach it. Cells that cannot be entered by the minimum-x, minimum-y cell because of sizing (such as a floor cell next to a maximum-x and/or maximum-y wall if size is > 1) will be marked as DARK. Cells that were marked as goals with setGoal will have a value of 0, the cells adjacent to goals will have a value of 1, and cells progressively further from goals will have a value equal to the distance from the nearest goal. The exceptions are walls, which will have a value defined by the WALL constant in this class, and areas that the scan was unable to reach, which will have a value defined by the DARK constant in this class. (typically, these areas should not be used to place NPCs or items and should be filled with walls). This uses the current measurement. The result is stored in the gradientMap field and a copy is returned.
  
  Parameters:
  
  impassable - A Collection of Coord keys representing the locations of enemies or other moving obstacles to a path that cannot be moved through; this can be null if there are no such obstacles.
  
  size - The length of one side of a square creature using this to find a path, i.e. 2 for a 2x2 cell creature. Non-square creatures are not supported because turning is really hard.
  
  Returns:
  
  A 2D double[width][height] using the width and height of what this knows about the physical map.
- partialScan
  
  public void partialScan(int limit, Coord start, Collection<Coord> impassable, int size)
  
  Recalculate the Dijkstra map for a creature that is potentially larger than 1x1 cell and return it. The value of a cell in the returned Dijkstra map assumes that a creature is square, with a side length equal to the passed size, that its minimum-x, minimum-y cell is the starting cell, and that any cell with a distance number represents the distance for the creature's minimum-x, minimum-y cell to reach it. Cells that cannot be entered by the minimum-x, minimum-y cell because of sizing (such as a floor cell next to a maximum-x and/or maximum-y wall if size is > 1) will be marked as DARK. Cells that were marked as goals with setGoal will have a value of 0, the cells adjacent to goals will have a value of 1, and cells progressively further from goals will have a value equal to the distance from the nearest goal. The exceptions are walls, which will have a value defined by the WALL constant in this class, and areas that the scan was unable to reach, which will have a value defined by the DARK constant in this class. (typically, these areas should not be used to place NPCs or items and should be filled with walls). This uses the current measurement. The result is stored in the gradientMap field, and nothing is returned. If you want the data returned, you can use partialScan(int, Collection, int) (which calls this method with null for the start parameter, then modifies the gradientMap field and returns a copy), or you can just retrieve the gradientMap (maybe copying it; ArrayTools.copy(double[][]) is a convenient option for copying a 2D double array). If start is non-null, which is usually used when finding a single path, then cells that didn't need to be explored (because they were further than the path needed to go from start to goal) will have the value FLOOR. You may wish to assign a different value to these cells in some cases (especially if start is null, which means any cells that are still FLOOR could not be reached from any goal), and the overloads of partialScan that return 2D double arrays do change FLOOR to DARK, which is usually treated similarly to WALL.
  
  Parameters:
  
  impassable - A Collection of Coord keys representing the locations of enemies or other moving obstacles to a path that cannot be moved through; this can be null if there are no such obstacles.
  
  size - The length of one side of a square creature using this to find a path, i.e. 2 for a 2x2 cell creature. Non-square creatures are not supported because turning is really hard.
- findPath
  
  public ArrayList<Coord> findPath(int length, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)
  
  Scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to the closest reachable goal. The maximum length of the returned list is given by length, which represents movement in a system where a single move can be multiple cells if length is greater than 1 and should usually be 1 in standard roguelikes; if moving the full length of the list would place the mover in a position shared by one of the positions in onlyPassable (which is typically filled with friendly units that can be passed through in multi-cell-movement scenarios), it will recalculate a move so that it does not pass into that cell. The keys in impassable should be the positions of enemies and obstacles that cannot be moved through, and will be ignored if there is a goal overlapping one. This overload always scans the whole map; use findPath(int, int, Collection, Collection, Coord, Coord...) to scan a smaller area for performance reasons.
  This caches its result in a member field, path, which can be fetched after finding a path and will change with each call to a pathfinding method.
  
  Parameters:
  
  length - the length of the path to calculate
  
  impassable - a Set of impassable Coord positions that may change (not constant like walls); can be null
  
  onlyPassable - a Set of Coord positions that this pathfinder cannot end a path occupying (typically allies); can be null
  
  start - the start of the path, should correspond to the minimum-x, minimum-y position of the pathfinder
  
  targets - a vararg or array of Coord that this will try to pathfind toward
  
  Returns:
  
  an ArrayList of Coord that will contain the locations of this creature as it goes toward a target. Copy of path.
- findPath
  
  public ArrayList<Coord> findPath(int length, int scanLimit, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)
  
  Scans the dungeon using DijkstraMap.scan or DijkstraMap.partialScan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to the closest reachable goal. The maximum length of the returned list is given by length, which represents movement in a system where a single move can be multiple cells if length is greater than 1 and should usually be 1 in standard roguelikes; if moving the full length of the list would place the mover in a position shared by one of the positions in onlyPassable (which is typically filled with friendly units that can be passed through in multi-cell-movement scenarios), it will recalculate a move so that it does not pass into that cell. The keys in impassable should be the positions of enemies and obstacles that cannot be moved through, and will be ignored if there is a goal overlapping one. The full map will only be scanned if scanLimit is 0 or less; for positive scanLimit values this will scan only that distance out from each goal, which can save processing time on maps where only a small part matters. Generally, scanLimit should be significantly greater than length.
  This caches its result in a member field, path, which can be fetched after finding a path and will change with each call to a pathfinding method.
  
  Parameters:
  
  length - the length of the path to calculate
  
  scanLimit - how many cells away from a goal to actually process; negative to process whole map
  
  impassable - a Set of impassable Coord positions that may change (not constant like walls); can be null
  
  onlyPassable - a Set of Coord positions that this pathfinder cannot end a path occupying (typically allies); can be null
  
  start - the start of the path, should correspond to the minimum-x, minimum-y position of the pathfinder
  
  targets - a vararg or array of Coord that this will try to pathfind toward
  
  Returns:
  
  an ArrayList of Coord that will contain the locations of this creature as it goes toward a target. Copy of path.
- findPath
  
  public ArrayList<Coord> findPath(ArrayList<Coord> buffer, int length, int scanLimit, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)
  
  Scans the dungeon using DijkstraMap.scan or DijkstraMap.partialScan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to the closest reachable goal. The maximum length of the returned list is given by length, which represents movement in a system where a single move can be multiple cells if length is greater than 1 and should usually be 1 in standard roguelikes; if moving the full length of the list would place the mover in a position shared by one of the positions in onlyPassable (which is typically filled with friendly units that can be passed through in multi-cell-movement scenarios), it will recalculate a move so that it does not pass into that cell. The keys in impassable should be the positions of enemies and obstacles that cannot be moved through, and will be ignored if there is a goal overlapping one. The full map will only be scanned if scanLimit is 0 or less; for positive scanLimit values this will scan only that distance out from each goal, which can save processing time on maps where only a small part matters. Generally, scanLimit should be significantly greater than length.
  This overload takes a buffer parameter, an ArrayList of Coord, that the results will be appended to. If the buffer is null, a new ArrayList will be made and appended to. This caches its result in a member field, path, which can be fetched after finding a path and will change with each call to a pathfinding method. Any existing contents of buffer will not affect the path field of this DijkstraMap.
  
  Parameters:
  
  buffer - an existing ArrayList of Coord that will have the result appended to it (in-place); if null, this will make a new ArrayList
  
  length - the length of the path to calculate
  
  scanLimit - how many cells away from a goal to actually process; negative to process whole map
  
  impassable - a Set of impassable Coord positions that may change (not constant like walls); can be null
  
  onlyPassable - a Set of Coord positions that this pathfinder cannot end a path occupying (typically allies); can be null
  
  start - the start of the path, should correspond to the minimum-x, minimum-y position of the pathfinder
  
  targets - a vararg or array of Coord that this will try to pathfind toward
  
  Returns:
  
  an ArrayList of Coord that will contain the locations of this creature as it goes toward a target. Copy of path.
- findAttackPath
  
  public ArrayList<Coord> findAttackPath(int moveLength, int preferredRange, LOS los, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)
  
  Scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to a goal, until preferredRange is reached, or further from a goal if the preferredRange has not been met at the current distance. The maximum length of the returned list is given by moveLength; if moving the full length of the list would place the mover in a position shared by one of the positions in onlyPassable (which is typically filled with friendly units that can be passed through in multi-tile- movement scenarios), it will recalculate a move so that it does not pass into that cell. The keys in impassable should be the positions of enemies and obstacles that cannot be moved through, and will be ignored if there is a goal overlapping one.
  This caches its result in a member field, path, which can be fetched after finding a path and will change with each call to a pathfinding method.
  
  Parameters:
  
  moveLength - the length of the path to calculate
  
  preferredRange - the distance this unit will try to keep from a target
  
  los - a squidgrid.LOS object if the preferredRange should try to stay in line of sight, or null if LoS should be disregarded.
  
  impassable - a Set of impassable Coord positions that may change (not constant like walls); can be null
  
  onlyPassable - a Set of Coord positions that this pathfinder cannot end a path occupying (typically allies); can be null
  
  start - the start of the path, should correspond to the minimum-x, minimum-y position of the pathfinder
  
  targets - a vararg or array of Coord that this will try to pathfind toward
  
  Returns:
  
  an ArrayList of Coord that will contain the locations of this creature as it goes toward a target. Copy of path.
- findAttackPath
  
  public ArrayList<Coord> findAttackPath(int moveLength, int minPreferredRange, int maxPreferredRange, LOS los, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)
  
  Scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to a goal, until a cell is reached with a distance from a goal that is at least equal to minPreferredRange and no more than maxPreferredRange, which may go further from a goal if the minPreferredRange has not been met at the current distance. The maximum length of the returned list is given by moveLength; if moving the full length of the list would place the mover in a position shared by one of the positions in onlyPassable (which is typically filled with friendly units that can be passed through in multi-tile- movement scenarios), it will recalculate a move so that it does not pass into that cell. The keys in impassable should be the positions of enemies and obstacles that cannot be moved through, and will be ignored if there is a goal overlapping one.
  This caches its result in a member field, path, which can be fetched after finding a path and will change with each call to a pathfinding method.
  
  Parameters:
  
  moveLength - the length of the path to calculate
  
  minPreferredRange - the (inclusive) lower bound of the distance this unit will try to keep from a target
  
  maxPreferredRange - the (inclusive) upper bound of the distance this unit will try to keep from a target
  
  los - a squidgrid.LOS object if the preferredRange should try to stay in line of sight, or null if LoS should be disregarded.
  
  impassable - a Set of impassable Coord positions that may change (not constant like walls); can be null
  
  onlyPassable - a Set of Coord positions that this pathfinder cannot end a path occupying (typically allies); can be null
  
  start - the start of the path, should correspond to the minimum-x, minimum-y position of the pathfinder
  
  targets - a vararg or array of Coord that this will try to pathfind toward
  
  Returns:
  
  an ArrayList of Coord that will contain the locations of this creature as it goes toward a target. Copy of path.
- findAttackPath
  
  public ArrayList<Coord> findAttackPath(ArrayList<Coord> buffer, int moveLength, int minPreferredRange, int maxPreferredRange, LOS los, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)
  
  Scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to a goal, until a cell is reached with a distance from a goal that is at least equal to minPreferredRange and no more than maxPreferredRange, which may go further from a goal if the minPreferredRange has not been met at the current distance. The maximum length of the returned list is given by moveLength; if moving the full length of the list would place the mover in a position shared by one of the positions in onlyPassable (which is typically filled with friendly units that can be passed through in multi-tile- movement scenarios), it will recalculate a move so that it does not pass into that cell. In most roguelikes where movement happens one cell at a time, moveLength should be 1; if it is higher then the path will prefer getting further away from the target (using up most or all of moveLength) while minPreferredRange and maxPreferredRange can be satisfied. This does ensure a pathfinder with a ranged weapon stays far from melee range, but it may not be the expected behavior because it will try to find the best path rather than the shortest it can attack from. The keys in impassable should be the positions of enemies and obstacles that cannot be moved through, and will be ignored if there is a goal overlapping one.
  This overload takes a buffer parameter, an ArrayList of Coord, that the results will be appended to. If the buffer is null, a new ArrayList will be made and appended to. This caches its result in a member field, path, which can be fetched after finding a path and will change with each call to a pathfinding method. Any existing contents of buffer will not affect the path field of this DijkstraMap.
  
  Parameters:
  
  buffer - an existing ArrayList of Coord that will have the result appended to it (in-place); if null, this will make a new ArrayList
  
  moveLength - the length of the path to calculate; almost always, the pathfinder will try to use this length in full to obtain the best range
  
  minPreferredRange - the (inclusive) lower bound of the distance this unit will try to keep from a target
  
  maxPreferredRange - the (inclusive) upper bound of the distance this unit will try to keep from a target
  
  los - a squidgrid.LOS object if the preferredRange should try to stay in line of sight, or null if LoS should be disregarded.
  
  impassable - a Set of impassable Coord positions that may change (not constant like walls); can be null
  
  onlyPassable - a Set of Coord positions that this pathfinder cannot end a path occupying (typically allies); can be null
  
  start - the start of the path, should correspond to the minimum-x, minimum-y position of the pathfinder
  
  targets - a vararg or array of Coord that this will try to pathfind toward
  
  Returns:
  
  an ArrayList of Coord that will contain the locations of this creature as it goes toward a target. Copy of path.
- findTechniquePath
  
  public ArrayList<Coord> findTechniquePath(int moveLength, Technique tech, char[][] dungeon, LOS los, Collection<Coord> impassable, Collection<Coord> allies, Coord start, Collection<Coord> targets)
  
  Scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to a goal, where goals are considered valid if they are at a valid range for the given Technique to hit at least one target and ideal if that Technique can affect as many targets as possible from a cell that can be moved to with at most movelength steps.
  The return value of this method is the path to get to a location to attack, but on its own it does not tell the user how to perform the attack. It does set the targetMap 2D Coord array field so that if your position at the end of the returned path is non-null in targetMap, it will be a Coord that can be used as a target position for Technique.apply() . If your position at the end of the returned path is null, then an ideal attack position was not reachable by the path.
  This needs a char[][] dungeon as an argument because DijkstraMap does not always have a char[][] version of the map available to it, and certain AOE implementations that a Technique uses may need a char[][] specifically to determine what they affect.
  The maximum length of the returned list is given by moveLength; if moving the full length of the list would place the mover in a position shared by one of the positions in allies (which is typically filled with friendly units that can be passed through in multi-tile- movement scenarios, and is also used considered an undesirable thing to affect for the Technique), it will recalculate a move so that it does not pass into that cell.
  The keys in impassable should be the positions of enemies and obstacles that cannot be moved through, and will be ignored if there is a target overlapping one.
  This caches its result in a member field, path, which can be fetched after finding a path and will change with each call to a pathfinding method.
  
  Parameters:
  
  moveLength - the maximum distance to try to pathfind out to; if a spot to use a Technique can be found while moving no more than this distance, then the targetMap field in this object will have a target Coord that is ideal for the given Technique at the x, y indices corresponding to the last Coord in the returned path.
  
  tech - a Technique that we will try to find an ideal place to use, and/or a path toward that place.
  
  dungeon - a char 2D array with '#' for walls.
  
  los - a squidgrid.LOS object if the preferred range should try to stay in line of sight, or null if LoS should be disregarded.
  
  impassable - locations of enemies or mobile hazards/obstacles that aren't in the map as walls
  
  allies - called onlyPassable in other methods, here it also represents allies for Technique things
  
  start - the Coord the pathfinder starts at.
  
  targets - a Set of Coord, not an array of Coord or variable argument list as in other methods.
  
  Returns:
  
  an ArrayList of Coord that represents a path to travel to get to an ideal place to use tech. Copy of path.
- findTechniquePath
  
  public ArrayList<Coord> findTechniquePath(ArrayList<Coord> buffer, int moveLength, Technique tech, char[][] dungeon, LOS los, Collection<Coord> impassable, Collection<Coord> allies, Coord start, Collection<Coord> targets)
  
  Scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to a goal, where goals are considered valid if they are at a valid range for the given Technique to hit at least one target and ideal if that Technique can affect as many targets as possible from a cell that can be moved to with at most movelength steps.
  The return value of this method is the path to get to a location to attack, but on its own it does not tell the user how to perform the attack. It does set the targetMap 2D Coord array field so that if your position at the end of the returned path is non-null in targetMap, it will be a Coord that can be used as a target position for Technique.apply() . If your position at the end of the returned path is null, then an ideal attack position was not reachable by the path.
  This needs a char[][] dungeon as an argument because DijkstraMap does not always have a char[][] version of the map available to it, and certain AOE implementations that a Technique uses may need a char[][] specifically to determine what they affect.
  The maximum length of the returned list is given by moveLength; if moving the full length of the list would place the mover in a position shared by one of the positions in allies (which is typically filled with friendly units that can be passed through in multi-tile- movement scenarios, and is also used considered an undesirable thing to affect for the Technique), it will recalculate a move so that it does not pass into that cell.
  The keys in impassable should be the positions of enemies and obstacles that cannot be moved through, and will be ignored if there is a target overlapping one.
  This overload takes a buffer parameter, an ArrayList of Coord, that the results will be appended to. If the buffer is null, a new ArrayList will be made and appended to. This caches its result in a member field, path, which can be fetched after finding a path and will change with each call to a pathfinding method. Any existing contents of buffer will not affect the path field of this DijkstraMap.
  
  Parameters:
  
  buffer - an existing ArrayList of Coord that will have the result appended to it (in-place); if null, this will make a new ArrayList
  
  moveLength - the maximum distance to try to pathfind out to; if a spot to use a Technique can be found while moving no more than this distance, then the targetMap field in this object will have a target Coord that is ideal for the given Technique at the x, y indices corresponding to the last Coord in the returned path.
  
  tech - a Technique that we will try to find an ideal place to use, and/or a path toward that place.
  
  dungeon - a char 2D array with '#' for walls.
  
  los - a squidgrid.LOS object if the preferred range should try to stay in line of sight, or null if LoS should be disregarded.
  
  impassable - locations of enemies or mobile hazards/obstacles that aren't in the map as walls
  
  allies - called onlyPassable in other methods, here it also represents allies for Technique things
  
  start - the Coord the pathfinder starts at.
  
  targets - a Set of Coord, not an array of Coord or variable argument list as in other methods.
  
  Returns:
  
  an ArrayList of Coord that represents a path to travel to get to an ideal place to use tech. Copy of path.
- findFleePath
  
  public ArrayList<Coord> findFleePath(int length, double preferLongerPaths, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... fearSources)
  
  Scans the dungeon using DijkstraMap.scan with the listed fearSources and start point, and returns a list of Coord positions (using Manhattan distance) needed to get further from the closest fearSources, meant for running away. The maximum length of the returned list is given by length; if moving the full length of the list would place the mover in a position shared by one of the positions in onlyPassable (which is typically filled with friendly units that can be passed through in multi-tile- movement scenarios), it will recalculate a move so that it does not pass into that cell. The keys in impassable should be the positions of enemies and obstacles that cannot be moved through, and will be ignored if there is a fearSource overlapping one. The preferLongerPaths parameter is meant to be tweaked and adjusted; higher values should make creatures prefer to escape out of doorways instead of hiding in the closest corner, and a value of 1.2 should be typical for many maps. The parameters preferLongerPaths, impassable, and the varargs used for fearSources will be cached, and any subsequent calls that use the same values as the last values passed will avoid recalculating unnecessary scans.
  This caches its result in a member field, path, which can be fetched after finding a path and will change with each call to a pathfinding method.
  
  Parameters:
  
  length - the length of the path to calculate
  
  preferLongerPaths - Set this to 1.2 if you aren't sure; it will probably need tweaking for different maps.
  
  impassable - a Set of impassable Coord positions that may change (not constant like walls); can be null
  
  onlyPassable - a Set of Coord positions that this pathfinder cannot end a path occupying (typically allies); can be null
  
  start - the start of the path, should correspond to the minimum-x, minimum-y position of the pathfinder
  
  fearSources - a vararg or array of Coord positions to run away from
  
  Returns:
  
  an ArrayList of Coord that will contain the locations of this creature as it goes away from fear sources. Copy of path.
- findFleePath
  
  public ArrayList<Coord> findFleePath(int length, int scanLimit, double preferLongerPaths, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... fearSources)
  
  Scans the dungeon using DijkstraMap.scan or DijkstraMap.partialScan with the listed fearSources and start point, and returns a list of Coord positions (using this DijkstraMap's metric) needed to get further from the closest fearSources, meant for running away. The maximum length of the returned list is given by length, which represents movement in a system where a single move can be multiple cells if length is greater than 1 and should usually be 1 in standard roguelikes; if moving the full length of the list would place the mover in a position shared by one of the positions in onlyPassable (which is typically filled with friendly units that can be passed through in multi-cell-movement scenarios), it will recalculate a move so that it does not pass into that cell. The keys in impassable should be the positions of enemies and obstacles that cannot be moved through, and will be ignored if there is a fearSource overlapping one. The preferLongerPaths parameter is meant to be tweaked and adjusted; higher values should make creatures prefer to escape out of doorways instead of hiding in the closest corner, and a value of 1.2 should be typical for many maps. The parameters preferLongerPaths, impassable, and the varargs used for fearSources will be cached, and any subsequent calls that use the same values as the last values passed will avoid recalculating unnecessary scans. However, scanLimit is not cached; if you use scanLimit then it is assumed you are using some value for it that shouldn't change relative to the other parameters (like twice the length). The full map will only be scanned if scanLimit is 0 or less; for positive scanLimit values this will scan only that distance out from each goal, which can save processing time on maps where only a small part matters. Generally, scanLimit should be significantly greater than length.
  This caches its result in a member field, path, which can be fetched after finding a path and will change with each call to a pathfinding method.
  
  Parameters:
  
  length - the length of the path to calculate
  
  scanLimit - how many steps away from a fear source to calculate; negative scans the whole map
  
  preferLongerPaths - Set this to 1.2 if you aren't sure; it will probably need tweaking for different maps.
  
  impassable - a Set of impassable Coord positions that may change (not constant like walls); can be null
  
  onlyPassable - a Set of Coord positions that this pathfinder cannot end a path occupying (typically allies); can be null
  
  start - the start of the path, should correspond to the minimum-x, minimum-y position of the pathfinder
  
  fearSources - a vararg or array of Coord positions to run away from
  
  Returns:
  
  an ArrayList of Coord that will contain the locations of this creature as it goes away from fear sources. Copy of path.
- findFleePath
  
  public ArrayList<Coord> findFleePath(ArrayList<Coord> buffer, int length, int scanLimit, double preferLongerPaths, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... fearSources)
  
  Scans the dungeon using DijkstraMap.scan or DijkstraMap.partialScan with the listed fearSources and start point, and returns a list of Coord positions (using this DijkstraMap's metric) needed to get further from the closest fearSources, meant for running away. The maximum length of the returned list is given by length, which represents movement in a system where a single move can be multiple cells if length is greater than 1 and should usually be 1 in standard roguelikes; if moving the full length of the list would place the mover in a position shared by one of the positions in onlyPassable (which is typically filled with friendly units that can be passed through in multi-cell-movement scenarios), it will recalculate a move so that it does not pass into that cell. The keys in impassable should be the positions of enemies and obstacles that cannot be moved through, and will be ignored if there is a fearSource overlapping one. The preferLongerPaths parameter is meant to be tweaked and adjusted; higher values should make creatures prefer to escape out of doorways instead of hiding in the closest corner, and a value of 1.2 should be typical for many maps. The parameters preferLongerPaths, impassable, and the varargs used for fearSources will be cached, and any subsequent calls that use the same values as the last values passed will avoid recalculating unnecessary scans. However, scanLimit is not cached; if you use scanLimit then it is assumed you are using some value for it that shouldn't change relative to the other parameters (like twice the length). The full map will only be scanned if scanLimit is 0 or less; for positive scanLimit values this will scan only that distance out from each goal, which can save processing time on maps where only a small part matters. Generally, scanLimit should be significantly greater than length.
  This overload takes a buffer parameter, an ArrayList of Coord, that the results will be appended to. If the buffer is null, a new ArrayList will be made and appended to. This caches its result in a member field, path, which can be fetched after finding a path and will change with each call to a pathfinding method. Any existing contents of buffer will not affect the path field of this DijkstraMap.
  
  Parameters:
  
  buffer - an existing ArrayList of Coord that will have the result appended to it (in-place); if null, this will make a new ArrayList
  
  length - the length of the path to calculate
  
  scanLimit - how many steps away from a fear source to calculate; negative scans the whole map
  
  preferLongerPaths - Set this to 1.2 if you aren't sure; it will probably need tweaking for different maps.
  
  impassable - a Set of impassable Coord positions that may change (not constant like walls); can be null
  
  onlyPassable - a Set of Coord positions that this pathfinder cannot end a path occupying (typically allies); can be null
  
  start - the start of the path, should correspond to the minimum-x, minimum-y position of the pathfinder
  
  fearSources - a vararg or array of Coord positions to run away from
  
  Returns:
  
  an ArrayList of Coord that will contain the locations of this creature as it goes away from fear sources. Copy of path.
- findPathLarge
  
  public ArrayList<Coord> findPathLarge(int size, int length, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)
  
  For pathfinding creatures larger than 1x1 cell; scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to the closest reachable goal. The maximum length of the returned list is given by length; if moving the full length of the list would place the mover in a position shared by one of the positions in onlyPassable (which is typically filled with friendly units that can be passed through in multi-tile- movement scenarios), it will recalculate a move so that it does not pass into that cell. The keys in impassable should be the positions of enemies and obstacles that cannot be moved through, and will be ignored if there is a goal overlapping one. The parameter size refers to the side length of a square unit, such as 2 for a 2x2 unit. The parameter start must refer to the minimum-x, minimum-y cell of that unit if size is > 1, and all positions in the returned path will refer to movement of the minimum-x, minimum-y cell.
  This caches its result in a member field, path, which can be fetched after finding a path and will change with each call to a pathfinding method.
  
  Parameters:
  
  size - the side length of the creature trying to find a path
  
  length - the length of the path to calculate
  
  impassable - a Set of impassable Coord positions that may change (not constant like walls); can be null
  
  onlyPassable - a Set of Coord positions that this pathfinder cannot end a path occupying (typically allies); can be null
  
  start - the start of the path, should correspond to the minimum-x, minimum-y position of the pathfinder
  
  targets - a vararg or array of Coord that this will try to pathfind toward
  
  Returns:
  
  an ArrayList of Coord that will contain the min-x, min-y locations of this creature as it goes toward a target. Copy of path.
- findPathLarge
  
  public ArrayList<Coord> findPathLarge(int size, int length, int scanLimit, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)
- findAttackPathLarge
  
  public ArrayList<Coord> findAttackPathLarge(int size, int moveLength, int preferredRange, LOS los, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)
  
  For pathfinding creatures larger than 1x1 cell; scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to a goal, until preferredRange is reached, or further from a goal if the preferredRange has not been met at the current distance. The maximum length of the returned list is given by moveLength; if moving the full length of the list would place the mover in a position shared by one of the positions in onlyPassable (which is typically filled with friendly units that can be passed through in multi-tile- movement scenarios), it will recalculate a move so that it does not pass into that cell. The keys in impassable should be the positions of enemies and obstacles that cannot be moved through, and will be ignored if there is a goal overlapping one. The parameter size refers to the side length of a square unit, such as 2 for a 2x2 unit. The parameter start must refer to the minimum-x, minimum-y cell of that unit if size is > 1, and all positions in the returned path will refer to movement of the minimum-x, minimum-y cell.
  This caches its result in a member field, path, which can be fetched after finding a path and will change with each call to a pathfinding method.
  
  Parameters:
  
  size - the side length of the creature trying to find a path
  
  moveLength - the length of the path to calculate
  
  preferredRange - the distance this unit will try to keep from a target
  
  los - a squidgrid.LOS object if the preferredRange should try to stay in line of sight, or null if LoS should be disregarded.
  
  impassable - a Set of impassable Coord positions that may change (not constant like walls); can be null
  
  onlyPassable - a Set of Coord positions that this pathfinder cannot end a path occupying (typically allies); can be null
  
  start - the start of the path, should correspond to the minimum-x, minimum-y position of the pathfinder
  
  targets - a vararg or array of Coord that this will try to pathfind toward
  
  Returns:
  
  an ArrayList of Coord that will contain the min-x, min-y locations of this creature as it goes toward a target. Copy of path.
- findAttackPathLarge
  
  public ArrayList<Coord> findAttackPathLarge(int size, int moveLength, int minPreferredRange, int maxPreferredRange, LOS los, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... targets)
  
  Scans the dungeon using DijkstraMap.scan with the listed goals and start point, and returns a list of Coord positions (using the current measurement) needed to get closer to a goal, until a cell is reached with a distance from a goal that is at least equal to minPreferredRange and no more than maxPreferredRange, which may go further from a goal if the minPreferredRange has not been met at the current distance. The maximum length of the returned list is given by moveLength; if moving the full length of the list would place the mover in a position shared by one of the positions in onlyPassable (which is typically filled with friendly units that can be passed through in multi-tile- movement scenarios), it will recalculate a move so that it does not pass into that cell. The keys in impassable should be the positions of enemies and obstacles that cannot be moved through, and will be ignored if there is a goal overlapping one. The parameter size refers to the side length of a square unit, such as 2 for a 2x2 unit. The parameter start must refer to the minimum-x, minimum-y cell of that unit if size is > 1, and all positions in the returned path will refer to movement of the minimum-x, minimum-y cell.
  This caches its result in a member field, path, which can be fetched after finding a path and will change with each call to a pathfinding method.
  
  Parameters:
  
  size - the side length of the creature trying to find a path
  
  moveLength - the length of the path to calculate
  
  minPreferredRange - the (inclusive) lower bound of the distance this unit will try to keep from a target
  
  maxPreferredRange - the (inclusive) upper bound of the distance this unit will try to keep from a target
  
  los - a squidgrid.LOS object if the preferredRange should try to stay in line of sight, or null if LoS should be disregarded.
  
  impassable - a Set of impassable Coord positions that may change (not constant like walls); can be null
  
  onlyPassable - a Set of Coord positions that this pathfinder cannot end a path occupying (typically allies); can be null
  
  start - the start of the path, should correspond to the minimum-x, minimum-y position of the pathfinder
  
  targets - a vararg or array of Coord that this will try to pathfind toward
  
  Returns:
  
  an ArrayList of Coord that will contain the min-x, min-y locations of this creature as it goes toward a target. Copy of path.
- findFleePathLarge
  
  public ArrayList<Coord> findFleePathLarge(int size, int length, double preferLongerPaths, Collection<Coord> impassable, Collection<Coord> onlyPassable, Coord start, Coord... fearSources)
  
  Scans the dungeon using DijkstraMap.scan with the listed fearSources and start point, and returns a list of Coord positions (using Manhattan distance) needed to get further from the closest fearSources, meant for running away. The maximum length of the returned list is given by length; if moving the full length of the list would place the mover in a position shared by one of the positions in onlyPassable (which is typically filled with friendly units that can be passed through in multi-tile- movement scenarios), it will recalculate a move so that it does not pass into that cell. The keys in impassable should be the positions of enemies and obstacles that cannot be moved through, and will be ignored if there is a fearSource overlapping one. The preferLongerPaths parameter is meant to be tweaked and adjusted; higher values should make creatures prefer to escape out of doorways instead of hiding in the closest corner, and a value of 1.2 should be typical for many maps. The parameters size, preferLongerPaths, impassable, and the varargs used for fearSources will be cached, and any subsequent calls that use the same values as the last values passed will avoid recalculating unnecessary scans. Calls to findFleePath will cache as if size is 1, and may share a cache with this function. The parameter size refers to the side length of a square unit, such as 2 for a 2x2 unit. The parameter start must refer to the minimum-x, minimum-y cell of that unit if size is > 1, and all positions in the returned path will refer to movement of the minimum-x, minimum-y cell.
  This caches its result in a member field, path, which can be fetched after finding a path and will change with each call to a pathfinding method.
  
  Parameters:
  
  size - the side length of the creature trying the find a path
  
  length - the length of the path to calculate
  
  preferLongerPaths - Set this to 1.2 if you aren't sure; it will probably need tweaking for different maps.
  
  impassable - a Set of impassable Coord positions that may change (not constant like walls); can be null
  
  onlyPassable - a Set of Coord positions that this pathfinder cannot end a path occupying (typically allies); can be null
  
  start - the start of the path, should correspond to the minimum-x, minimum-y position of the pathfinder
  
  fearSources - a vararg or array of Coord positions to run away from
  
  Returns:
  
  an ArrayList of Coord that will contain the locations of this creature as it goes away from fear sources. Copy of path.
- findPathPreScanned
  
  public ArrayList<Coord> findPathPreScanned(Coord target)
  
  When you can control how often the (relatively time-intensive) scan() method is called, but may need simple paths very frequently (such as for a path that follows the mouse), you can use this method to reduce the amount of work needed to find paths. Needs scan() or partialScan() to already be called and at least one goal to already be set, and does not restrict the length of the path or behave as if the pathfinder has allies or enemies.
  This caches its result in a member field, path, which can be fetched after finding a path and will change with each call to a pathfinding method.
  
  Parameters:
  
  target - the target cell
  
  Returns:
  
  an ArrayList of Coord that make up the best path. Copy of path.
- findPathPreScanned
  
  public ArrayList<Coord> findPathPreScanned(ArrayList<Coord> buffer, Coord target)
  
  When you can control how often the (relatively time-intensive) scan() method is called, but may need simple paths very frequently (such as for a path that follows the mouse), you can use this method to reduce the amount of work needed to find paths. Needs scan() or partialScan() to already be called and at least one goal to already be set, and does not restrict the length of the path or behave as if the pathfinder has allies or enemies.
  This overload takes a buffer parameter, an ArrayList of Coord, that the results will be appended to. If the buffer is null, a new ArrayList will be made and appended to. This caches its result in a member field, path, which can be fetched after finding a path and will change with each call to a pathfinding method. Any existing contents of buffer will not affect the path field of this DijkstraMap.
  
  Parameters:
  
  buffer - an existing ArrayList of Coord that will have the result appended to it (in-place); if null, this will make a new ArrayList
  
  target - the target cell
  
  Returns:
  
  an ArrayList of Coord that make up the best path, appended to buffer (if non-null)
- floodFill
  
  public OrderedMap<Coord,Double> floodFill(int radius, Coord... starts)
  
  A simple limited flood-fill that returns a OrderedMap of Coord keys to the Double values in the DijkstraMap, only calculating out to a number of steps determined by limit. This can be useful if you need many flood-fills and don't need a large area for each, or if you want to have an effect spread to a certain number of cells away.
  
  Parameters:
  
  radius - the number of steps to take outward from each starting position.
  
  starts - a vararg group of Points to step outward from; this often will only need to be one Coord.
  
  Returns:
  
  A OrderedMap of Coord keys to Double values; the starts are included in this with the value 0.0.
- getMappedCount
  
  public int getMappedCount()
- getBlockingRequirement
  
  public int getBlockingRequirement()
  
  If you want obstacles present in orthogonal cells to prevent pathfinding along the diagonal between them, this can be used to make thin diagonal walls non-viable to move through, or even to prevent diagonal movement if any one obstacle is orthogonally adjacent to both the start and target cell of a diagonal move. If you haven't set this yet, then the default is 2.
  If this is 0, as a special case no orthogonal obstacles will block diagonal moves.
  If this is 1, having one orthogonal obstacle adjacent to both the current cell and the cell the pathfinder is trying to diagonally enter will block diagonal moves. This generally blocks movement around corners, the "hard corner" rule used in some games.
  If this is 2 (the default), having two orthogonal obstacles adjacent to both the current cell and the cell the pathfinder is trying to diagonally enter will block diagonal moves. As an example, if there is a wall to the north and a wall to the east, then the pathfinder won't be able to move northeast even if there is a floor there.
  
  Returns:
  
  the current level of blocking required to stop a diagonal move
- setBlockingRequirement
  
  public void setBlockingRequirement(int blockingRequirement)
  
  If you want obstacles present in orthogonal cells to prevent pathfinding along the diagonal between them, this can be used to make thin diagonal walls non-viable to move through, or even to prevent diagonal movement if any one obstacle is orthogonally adjacent to both the start and target cell of a diagonal move. If you haven't set this yet, then the default is 2.
  If this is 0, as a special case no orthogonal obstacles will block diagonal moves.
  If this is 1, having one orthogonal obstacle adjacent to both the current cell and the cell the pathfinder is trying to diagonally enter will block diagonal moves. This generally blocks movement around corners, the "hard corner" rule used in some games.
  If this is 2 (the default), having two orthogonal obstacles adjacent to both the current cell and the cell the pathfinder is trying to diagonally enter will block diagonal moves. As an example, if there is a wall to the north and a wall to the east, then the pathfinder won't be able to move northeast even if there is a floor there.
  
  Parameters:
  
  blockingRequirement - the desired level of blocking required to stop a diagonal move

Class DijkstraMap

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Details

Constructor Details

Method Details