Class GreasedRegion

java.lang.Object
squidpony.squidgrid.zone.Zone.Skeleton
squidpony.squidmath.GreasedRegion
All Implemented Interfaces:
Serializable, Iterable<Coord>, Collection<Coord>, MutableZone, Zone

public class GreasedRegion
extends Zone.Skeleton
implements Collection<Coord>, Serializable, MutableZone
Region encoding of on/off information about areas using bitsets; uncompressed (fatty), but fast (greased lightning). This can handle any size of 2D data, and is not strictly limited to 256x256 as CoordPacker is. It stores several long arrays and uses each bit in one of those numbers to represent a single point, though sometimes this does waste bits if the height of the area this encodes is not a multiple of 64 (if you store a 80x64 map, this uses 80 longs; if you store an 80x65 map, this uses 160 longs, 80 for the first 64 rows and 80 more to store the next row). It's much faster than CoordPacker at certain operations (anything that expands or retracts an area, including expand()), retract()), fringe()), surface(), and flood(GreasedRegion), and slightly faster on others, like and(GreasedRegion) (called intersectPacked() in CoordPacker) and or(GreasedRegion) (called unionPacked() in CoordPacker).
Each GreasedRegion is mutable, and instance methods typically modify that instance and return it for chaining. There are exceptions, usually where multiple GreasedRegion values are returned and the instance is not modified.
Typical usage involves constructing a GreasedRegion from some input data, like a char[][] for a map or a double[][] from DijkstraMap, and modifying it spatially with expand(), retract(), flood(), etc. It's common to mix in data from other GreasedRegions with and() (which gets the intersection of two GreasedRegions and stores it in one), or() (which is like and() but for the union), xor() (like and() but for exclusive or, finding only cells that are on in exactly one of the two GreasedRegions), and andNot() (which can be considered the "subtract another region from me" method). There are 8-way (Chebyshev distance) variants on all of the spatial methods, and methods without "8way" in the name are either 4-way (Manhattan distance) or not affected by distance measurement. Once you have a GreasedRegion, you may want to:
You may also want to produce some 2D data from one or more GreasedRegions, as with sum(GreasedRegion...) or toChars(). The most effective techniques regarding GreasedRegion involve multiple methods, like getting a few random points from an existing GreasedRegion representing floor tiles in a dungeon with randomRegion(IRNG, int), then finding a random expansion of those initial points with spill(GreasedRegion, int, IRNG), giving the original GreasedRegion of floor tiles as the first argument. This could be used to position puddles of water or toxic waste in a dungeon level, while still keeping the starting points and finished points within the boundaries of valid (floor) cells. If you wanted to place something like mold that can be on floors or on cells immediately adjacent to floors (like walls), you could call expand() on the floor tiles before calling spill, allowing the spill to spread onto non-floor cells that are next to floors.
For efficiency, you can place one GreasedRegion into another (typically a temporary value that is no longer needed and can be recycled) using remake(GreasedRegion), or give the information that would normally be used to construct a fresh GreasedRegion to an existing one of the same dimensions with refill(boolean[][]) or any of the overloads of refill(). These re-methods don't do as much work as a constructor does if the width and height of their argument are identical to their current width and height, and don't create more garbage for the GC.
Created by Tommy Ettinger on 6/24/2016.
See Also:
Serialized Form
  • Nested Class Summary

    Nested Classes 
    Modifier and Type Class Description
    class  GreasedRegion.GRIterator  

    Nested classes/interfaces inherited from interface squidpony.squidgrid.zone.Zone

    Zone.Helper, Zone.Skeleton
  • Field Summary

    Fields 
    Modifier and Type Field Description
    long[] data  
    int height  
    int width  
  • Constructor Summary

    Constructors 
    Constructor Description
    GreasedRegion()
    Constructs an empty 64x64 GreasedRegion.
    GreasedRegion​(boolean[][] bits)
    Constructs a GreasedRegion with the given rectangular boolean array, with width of bits.length and height of bits[0].length, any value of true considered "on", and any value of false considered "off."
    GreasedRegion​(boolean[] bits, int width, int height)
    Constructs a GreasedRegion with the given 1D boolean array, with the given width and height, where an [x][y] position is obtained from bits given an index n with x = n / height, y = n % height, any value of true considered "on", and any value of false considered "off."
    GreasedRegion​(byte[][] map, int lower, int upper)
    Constructs this GreasedRegion using a byte[][], treating cells as on if they are greater than or equal to lower and less than upper, or off otherwise.
    GreasedRegion​(char[][] map, char yes)
    Constructs a GreasedRegion with the given rectangular char array, with width of map.length and height of map[0].length, any value that equals yes is considered "on", and any other value considered "off."
    GreasedRegion​(char[][] map, char[] yes)
    Constructs a GreasedRegion with the given rectangular char array, with width of map.length and height of map[0].length, any value that equals yes is considered "on", and any other value considered "off."
    GreasedRegion​(double[][] map, double upperBound)
    Constructs this GreasedRegion using a double[][] (typically one generated by DijkstraMap) that only stores two relevant states: an "on" state for values less than or equal to upperBound (inclusive), and an "off" state for anything else.
    GreasedRegion​(double[][] map, double lowerBound, double upperBound)
    Constructs this GreasedRegion using a double[][] (typically one generated by DijkstraMap) that only stores two relevant states: an "on" state for values between lowerBound (inclusive) and upperBound (exclusive), and an "off" state for anything else.
    GreasedRegion​(double[][] map, double lowerBound, double upperBound, int scale)
    Constructs this GreasedRegion using a double[][] that only stores two relevant states: an "on" state for values between lowerBound (inclusive) and upperBound (exclusive), and an "off" state for anything else.
    GreasedRegion​(int[][] map, int yes)
    Constructs a GreasedRegion with the given rectangular int array, with width of map.length and height of map[0].length, any value that equals yes is considered "on", and any other value considered "off."
    GreasedRegion​(int[][] map, int lower, int upper)
    Constructs this GreasedRegion using an int[][], treating cells as on if they are greater than or equal to lower and less than upper, or off otherwise.
    GreasedRegion​(int width, int height)
    Constructor for an empty GreasedRegion of the given width and height.
    GreasedRegion​(int width, int height, Iterable<Coord> points)
    Constructor for a GreasedRegion that can have several "on" cells specified, and has the given width and height.
    GreasedRegion​(int width, int height, Coord... points)
    Constructor for a GreasedRegion that can have several "on" cells specified, and has the given width and height.
    GreasedRegion​(long[] data2, int width, int height)
    Primarily for internal use, this constructor copies data2 exactly into the internal long array the new GreasedRegion will use, and does not perform any validation steps to ensure that cells that would be "on" but are outside the actual height of the GreasedRegion are actually removed (this only matters if height is not a multiple of 64).
    GreasedRegion​(long[] data2, int dataWidth, int dataHeight, int width, int height)
    Primarily for internal use, this constructor copies data2 into the internal long array the new GreasedRegion will use, but treats data2 as having the dimensions [dataWidth][dataHeight], and uses the potentially-different dimensions [width][height] for the constructed GreasedRegion.
    GreasedRegion​(short[][] map, int lower, int upper)
    Constructs this GreasedRegion using a short[][], treating cells as on if they are greater than or equal to lower and less than upper, or off otherwise.
    GreasedRegion​(String[] map, char yes)
    Weird constructor that takes a String array, _as it would be printed_, so each String is a row and indexing would be done with y, x instead of the normal x, y.
    GreasedRegion​(Coord single, int width, int height)
    Constructor for a GreasedRegion that contains a single "on" cell, and has the given width and height.
    GreasedRegion​(GreasedRegion other)
    Copy constructor that takes another GreasedRegion and copies all of its data into this new one.
    GreasedRegion​(IRNG random, int width, int height)
    Constructor for a random GreasedRegion of the given width and height, typically assigning approximately half of the cells in this to "on" and the rest to off.
    GreasedRegion​(RandomnessSource random, double fraction, int width, int height)
    Constructor for a random GreasedRegion of the given width and height, trying to set the given fraction of cells to on.
    GreasedRegion​(RandomnessSource random, int width, int height)
    Constructor for a random GreasedRegion of the given width and height, typically assigning approximately half of the cells in this to "on" and the rest to off.
  • Method Summary

    Modifier and Type Method Description
    boolean add​(Coord coord)  
    boolean addAll​(Collection<? extends Coord> c)  
    GreasedRegion allOn()
    Sets all cells in this to "on."
    GreasedRegion alterBounds​(int widthChange, int heightChange)
    Changes the width and/or height of this GreasedRegion, enlarging or shrinking starting at the edges where x == width - 1 and y == height - 1.
    GreasedRegion and​(GreasedRegion other)
    Intersection of two GreasedRegions, assigning the result into this GreasedRegion.
    GreasedRegion andNot​(GreasedRegion other)
    Difference of two GreasedRegions, assigning the result into this GreasedRegion.
    GreasedRegion andWrapping64​(GreasedRegion other)
    Intersection of two GreasedRegions, assigning the result into this GreasedRegion, with the special requirement that other must be a 64x64 area, and the special property that other will be considered tiled to cover all of the area of this GreasedRegion.
    static Collection<GreasedRegion> appendContaining​(Collection<GreasedRegion> into, int x, int y, Collection<GreasedRegion> packed)
    Tries to look up the position x,y in each GreasedRegion in packed; each GreasedRegion that contains that x,y point is appended into the Collection into.
    static Collection<GreasedRegion> appendContaining​(Collection<GreasedRegion> into, int x, int y, GreasedRegion... packed)
    Tries to look up the position x,y in each GreasedRegion in packed; each GreasedRegion that contains that x,y point is appended into the Collection into.
    static long approximateBits​(RandomnessSource random, int bitCount)
    Generates a random 64-bit long with a number of '1' bits (Hamming weight) equal on average to bitCount.
    Coord[] asCoords()  
    Coord[] asCoords​(Coord[] points)  
    int[] asEncoded()  
    int[] asTightEncoded()  
    Coord atFraction​(double fraction)  
    int atFractionTight​(double fraction)  
    static int[][] bitSum​(GreasedRegion... regions)
    Generates a 2D int array from an array or vararg of GreasedRegions, treating each cell in the nth region as the nth bit of the int at the corresponding x,y cell in the int array.
    void clear()  
    GreasedRegion connect()
    Takes the pairs of "on" cells in this GreasedRegion that are separated by exactly one cell in an orthogonal line, and changes the gap cells to "on" as well.
    GreasedRegion connect8way()
    Takes the pairs of "on" cells in this GreasedRegion that are separated by exactly one cell in an orthogonal or diagonal line, and changes the gap cells to "on" as well.
    GreasedRegion connectLines()
    Takes the pairs of "on" cells in this GreasedRegion that are separated by exactly one cell in an orthogonal or diagonal line, and changes the gap cells to "on" as well.
    boolean contains​(int x, int y)  
    boolean contains​(Object o)  
    boolean contains​(Zone other)
    Checks whether all Coords in other are also present in this.
    boolean contains​(Coord c)
    Checks if c is present in this GreasedRegion.
    boolean containsAll​(Collection<?> c)  
    GreasedRegion copy()
    Simple method that returns a newly-allocated copy of this GreasedRegion; modifications to one won't change the other, and this method returns the copy while leaving the original unchanged.
    GreasedRegion copyRotated​(int turns)
    Makes a copy of this GreasedRegion that has been rotated 90 degrees turns times.
    boolean[][] decode()
    Returns this GreasedRegion's data as a 2D boolean array, [width][height] in size, with on treated as true and off treated as false.
    static GreasedRegion decompress​(String compressed)
    Decompresses a String returned by toCompressedString(), returning a new GreasedRegion with identical width, height, and contents to the GreasedRegion before compression.
    static GreasedRegion deserializeFromString​(String s)  
    GreasedRegion deteriorate​(RandomnessSource random, double preservation)
    Randomly removes points from a GreasedRegion, with preservation as a fraction between 1.0 (keep all) and 0.0 (remove all).
    GreasedRegion deteriorate​(RandomnessSource rng, int preservation)
    Randomly removes points from a GreasedRegion, with larger values for preservation keeping more of the existing shape intact.
    static double[][] dijkstraScan​(char[][] map, Coord... goals)
    Discouraged from active use; slower than DijkstraMap and has less features.
    static double[][] dijkstraScan8way​(char[][] map, Coord... goals)
    Discouraged from active use; slower than DijkstraMap and has less features.
    GreasedRegion disperse()
    Removes "on" cells that are orthogonally adjacent to other "on" cells, keeping at least one cell in a group "on." Uses a "checkerboard" pattern to determine which cells to turn off, with all cells that would be black on a checkerboard turned off and all others kept as-is.
    GreasedRegion disperse8way()
    Removes "on" cells that are 8-way adjacent to other "on" cells, keeping at least one cell in a group "on." Uses a "grid-like" pattern to determine which cells to turn off, with all cells with even x and even y kept as-is but all other cells (with either or both odd x or odd y) turned off.
    static int disperseBits​(int n)
    Narrow-purpose; takes an int that represents a distance down the Z-order curve and moves its bits around so that its x component is stored in the bottom 16 bits (use (n & 0xffff) to obtain) and its y component is stored in the upper 16 bits (use (n >>> 16) to obtain).
    GreasedRegion disperseRandom​(RandomnessSource random)
    Removes "on" cells that are nearby other "on" cells, with a random factor to which bits are actually turned off that still ensures exactly half of the bits are kept as-is (the one exception is when height is an odd number, which makes the bottom row slightly random).
    GreasedRegion empty()
    Equivalent to clear(), setting all cells to "off," but also returns this for chaining.
    boolean equals​(Object o)  
    GreasedRegion expand()
    Takes the "on" cells in this GreasedRegion and expands them by one cell in the 4 orthogonal directions, making each "on" cell take up a plus-shaped area that may overlap with other "on" cells (which is just a normal "on" cell then).
    GreasedRegion expand​(int amount)
    Takes the "on" cells in this GreasedRegion and expands them by amount cells in the 4 orthogonal directions, making each "on" cell take up a plus-shaped area that may overlap with other "on" cells (which is just a normal "on" cell then).
    GreasedRegion expand8way()  
    GreasedRegion expand8way​(int amount)
    Expands this Zone in the four cardinal and four diagonal directions, performing the expansion consecutively distance times.
    GreasedRegion[] expandSeries​(int amount)
    Takes the "on" cells in this GreasedRegion and produces amount GreasedRegions, each one expanded by 1 cell in the 4 orthogonal directions relative to the previous GreasedRegion, making each "on" cell take up a plus-shaped area that may overlap with other "on" cells (which is just a normal "on" cell then).
    GreasedRegion[] expandSeries8way​(int amount)  
    ArrayList<GreasedRegion> expandSeriesToLimit()  
    ArrayList<GreasedRegion> expandSeriesToLimit8way()  
    GreasedRegion extend()
    Gets a new Zone that contains all the Coords in this plus all neighboring Coords, which can be orthogonally or diagonally adjacent to any Coord this has in it.
    GreasedRegion fill​(boolean contents)
    Sets all cells in this to "on" if contents is true, or "off" if contents is false.
    Coord first()
    Gets the first Coord in the iteration order, or (-1,-1) if this GreasedRegion is empty.
    int firstTight()  
    Coord fit​(double xFraction, double yFraction)  
    int[][] fit​(int[][] basis, int defaultValue)  
    GreasedRegion flip​(boolean leftRight, boolean upDown)  
    GreasedRegion flood​(GreasedRegion bounds)
    Like expand(), but limits expansion to the "on" cells of bounds.
    GreasedRegion flood​(GreasedRegion bounds, int amount)
    Like expand(int), but limits expansion to the "on" cells of bounds.
    GreasedRegion flood8way​(GreasedRegion bounds)
    Like expand8way(), but limits expansion to the "on" cells of bounds.
    GreasedRegion flood8way​(GreasedRegion bounds, int amount)
    Like expand8way(int), but limits expansion to the "on" cells of bounds.
    GreasedRegion[] floodSeries​(GreasedRegion bounds, int amount)
    Repeatedly calls flood(GreasedRegion) amount times and returns the intermediate steps in a GreasedRegion array of size amount.
    GreasedRegion[] floodSeries8way​(GreasedRegion bounds, int amount)
    Repeatedly calls flood8way(GreasedRegion) amount times and returns the intermediate steps in a GreasedRegion array of size amount.
    ArrayList<GreasedRegion> floodSeriesToLimit​(GreasedRegion bounds)
    Repeatedly generates new GreasedRegions, each one cell expanded in 4 directions from the previous GreasedRegion and staying inside the "on" cells of bounds, until it can't expand any more.
    ArrayList<GreasedRegion> floodSeriesToLimit8way​(GreasedRegion bounds)
    Repeatedly generates new GreasedRegions, each one cell expanded in 8 directions from the previous GreasedRegion and staying inside the "on" cells of bounds, until it can't expand any more.
    GreasedRegion fray​(double fractionKept)
    Like retract(), this removes the "on" cells that are 4-way-adjacent to any "off" cell, but unlike that method it keeps a fraction of those surface cells, quasi-randomly selecting them.
    GreasedRegion fringe()
    Takes the "on" cells in this GreasedRegion and expands them by one cell in the 4 orthogonal directions, producing a diamoond shape, then removes the original area before expansion, producing only the cells that were "off" in this and within 1 cell (orthogonal-only) of an "on" cell.
    GreasedRegion fringe​(int amount)
    Takes the "on" cells in this GreasedRegion and expands them by amount cells in the 4 orthogonal directions (iteratively, producing a diamond shape), then removes the original area before expansion, producing only the cells that were "off" in this and within amount cells (orthogonal-only) of an "on" cell.
    GreasedRegion fringe8way()  
    GreasedRegion fringe8way​(int amount)  
    GreasedRegion[] fringeSeries​(int amount)
    Takes the "on" cells in this GreasedRegion and produces amount GreasedRegions, each one expanded by 1 cell in the 4 orthogonal directions relative to the previous GreasedRegion, making each "on" cell take up a diamond- shaped area.
    GreasedRegion[] fringeSeries8way​(int amount)  
    ArrayList<GreasedRegion> fringeSeriesToLimit()  
    ArrayList<GreasedRegion> fringeSeriesToLimit8way()  
    List<Coord> getAll()  
    double getDiagonal()
    Gets the diagonal distance from the point combining the lowest x-value present in this GreasedRegion with the lowest y-value in this, to the point combining the highest x-value and the highest y-value.
    GreasedRegion getExternalBorder()
    Gets a Collection of Coord values that are not in this GreasedRegion, but are adjacent to it, either orthogonally or diagonally.
    int getHeight()
    Gets the distance between the minimum y-value contained in this GreasedRegion and the maximum y-value in it.
    GreasedRegion getInternalBorder()  
    int getWidth()
    Gets the distance between the minimum x-value contained in this GreasedRegion and the maximum x-value in it.
    long hash64()  
    long hash64​(long seed)
    Computes a 64-bit hash code of this GreasedRegion given a 64-bit seed; even if given two very similar seeds, this should produce very different hash codes for the same GreasedRegion.
    int hashCode()  
    GreasedRegion insert​(int tight)
    Sets the given cell, "tightly" encoded for a specific width/height as by asTightEncoded(), to "on".
    GreasedRegion insert​(int x, int y)
    Sets the cell at x,y to "on".
    GreasedRegion insert​(int x, int y, GreasedRegion other)
    Takes another GreasedRegion, called other, with potentially different size and inserts its "on" cells into thi GreasedRegion at the given x,y offset, allowing negative x and/or y to put only part of other in this.
    GreasedRegion insert​(Coord point)
    Sets the cell at point to "on".
    GreasedRegion insertCircle​(Coord center, int radius)  
    GreasedRegion insertRectangle​(int startX, int startY, int rectangleWidth, int rectangleHeight)  
    GreasedRegion insertSeveral​(int[] points)  
    GreasedRegion insertSeveral​(Iterable<Coord> points)  
    GreasedRegion insertSeveral​(Coord... points)  
    GreasedRegion insertTranslation​(int x, int y)
    Adds to this GreasedRegion with a moved set of its own "on" cells, moved to the given x and y offset.
    static int interleaveBits​(int x, int y)
    Narrow-purpose; takes an x and a y value, each between 0 and 65535 inclusive, and interleaves their bits so the least significant bit and every other bit after it are filled with the bits of x, while the second-least-significant bit and every other bit after that are filled with the bits of y.
    boolean intersects​(GreasedRegion other)
    Returns true if any cell is "on" in both this GreasedRegion and in other; returns false otherwise.
    boolean intersectsWith​(Zone other)  
    char[][] intoChars​(char[][] chars, char on)
    Fills this GreasedRegion's data into the given 2D char array, modifying it and returning it, with "on" cells filled with the char parameter on and "off" cells left as-is.
    char[][] intoChars​(char[][] chars, char on, char off)
    Fills this GreasedRegion's data into the given 2D char array, modifying it and returning it, with "on" cells filled with the char parameter on and "off" cells with the parameter off.
    char[][] inverseMask​(char[][] map, char toWrite)
    Returns a copy of map where if a cell is "off" in this GreasedRegion, this keeps the value in map intact, and where a cell is "on", it instead writes the char toWrite.
    boolean isEmpty()  
    Iterator<Coord> iterator()  
    GreasedRegion largestPart()
    Finds the largest contiguous area of "on" cells in this GreasedRegion and returns it; does not modify this GreasedRegion.
    GreasedRegion largestPart8way()
    Finds the largest contiguous area of "on" cells in this GreasedRegion and returns it; does not modify this GreasedRegion.
    Coord last()
    Gets the last Coord in the iteration order, or (-1,-1) if this GreasedRegion is empty.
    int lastTight()  
    char[][] mask​(char[][] map, char filler)
    Returns a copy of map where if a cell is "on" in this GreasedRegion, this keeps the value in map intact, and where a cell is "off", it instead writes the char filler.
    short[][] mask​(short[][] map, short filler)
    Returns a copy of map where if a cell is "on" in this GreasedRegion, this keeps the value in map intact, and where a cell is "off", it instead writes the short filler.
    GreasedRegion mirrorY()
    Returns a new GreasedRegion that has been mirrored along the rightmost edge, parallel to the y-axis.
    GreasedRegion mixedRandomRegion​(double fraction)
    Modifies this GreasedRegion so it contains a deterministic but random-seeming subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this.
    GreasedRegion mixedRandomRegion​(double fraction, int limit)
    Modifies this GreasedRegion so it contains a deterministic but random-seeming subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this.
    GreasedRegion mixedRandomRegion​(double fraction, int limit, long seed)
    Modifies this GreasedRegion so it contains a deterministic but random-seeming subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this.
    Coord[] mixedRandomSeparated​(double fraction)
    Gets a Coord array from the "on" contents of this GreasedRegion, using a deterministic but random-seeming scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this.
    Coord[] mixedRandomSeparated​(double fraction, int limit)
    Gets a Coord array from the "on" contents of this GreasedRegion, using a deterministic but random-seeming scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this.
    Coord[] mixedRandomSeparated​(double fraction, int limit, long seed)
    Gets a Coord array from the "on" contents of this GreasedRegion, using a deterministic but random-seeming scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this.
    Coord[] mixedRandomSeparatedAlt​(double fraction, int limit, long seed)
    Gets a Coord array from the "on" contents of this GreasedRegion, using a deterministic but random-seeming scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this.
    GreasedRegion neighborDown()
    Modifies this GreasedRegion so the only cells that will be "on" have a neighbor downwards when this is called.
    GreasedRegion neighborDownLeft()
    Modifies this GreasedRegion so the only cells that will be "on" have a neighbor downwards and to the left when this is called.
    GreasedRegion neighborDownRight()
    Modifies this GreasedRegion so the only cells that will be "on" have a neighbor downwards and to the right when this is called.
    GreasedRegion neighborLeft()
    Modifies this GreasedRegion so the only cells that will be "on" have a neighbor to the left when this is called.
    GreasedRegion neighborRight()
    Modifies this GreasedRegion so the only cells that will be "on" have a neighbor to the right when this is called.
    GreasedRegion neighborUp()
    Modifies this GreasedRegion so the only cells that will be "on" have a neighbor upwards when this is called.
    GreasedRegion neighborUpLeft()
    Modifies this GreasedRegion so the only cells that will be "on" have a neighbor upwards and to the left when this is called.
    GreasedRegion neighborUpRight()
    Modifies this GreasedRegion so the only cells that will be "on" have a neighbor upwards and to the right when this is called.
    GreasedRegion not()
    Negates this GreasedRegion, turning "on" to "off" and "off" to "on."
    GreasedRegion notAnd​(GreasedRegion other)
    Like andNot, but subtracts this GreasedRegion from other and stores the result in this GreasedRegion, without mutating other.
    Coord nth​(int index)  
    Coord nthZCurve​(int index)
    Like nth(int), this gets the Coord at a given index along a path through the GreasedRegion, but unlike nth(), this traverses the path in a zig-zag pattern called the Z-Order Curve.
    int nthZCurveTight​(int index)
    Like nth(int), this finds a given index along a path through the GreasedRegion, but unlike nth(), this traverses the path in a zig-zag pattern called the Z-Order Curve, and unlike nthZCurve(int), this does not return a Coord and instead produces a "tight"-encoded int.
    static GreasedRegion of​(int width, int height, long... data)
    Constructs a GreasedRegion using a vararg for data.
    GreasedRegion or​(GreasedRegion other)
    Union of two GreasedRegions, assigning the result into this GreasedRegion.
    void perceptualHashQuick​(long[] into, int[] working)
    Calculates a perceptual hash for this GreasedRegion using a method that is only precise for some sizes of GreasedRegion; it writes a result to into, and uses working as a temporary buffer.
    GreasedRegion quasiRandomRegion​(double fraction)
    Modifies this GreasedRegion so it contains a quasi-random subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this.
    GreasedRegion quasiRandomRegion​(double fraction, int limit)
    Modifies this GreasedRegion so it contains a quasi-random subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this.
    Coord[] quasiRandomSeparated​(double fraction)
    Gets a Coord array from the "on" contents of this GreasedRegion, using a quasi-random scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this.
    Coord[] quasiRandomSeparated​(double fraction, int limit)
    Gets a Coord array from the "on" contents of this GreasedRegion, using a quasi-random scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this.
    static long randomInterleave​(RandomnessSource random)
    Gets a somewhat-random long with exactly 32 bits set; in each pair of bits starting at bit 0 and bit 1, then bit 2 and bit 3, up to bit 62 and bit 3, one bit will be 1 and one bit will be 0 in each pair.
    Coord[] randomPortion​(IRNG rng, int size)  
    GreasedRegion randomRegion​(IRNG rng, int size)  
    GreasedRegion randomScatter​(IRNG rng, int minimumDistance)
    Modifies this GreasedRegion so it contains a random subset of its previous contents, choosing cells so that the distance between any two "on" cells is at least minimumDistance, with at least one cell as "on" if any were "on" in this originally.
    GreasedRegion randomScatter​(IRNG rng, int minimumDistance, int limit)
    Modifies this GreasedRegion so it contains a random subset of its previous contents, choosing cells so that the distance between any two "on" cells is at least minimumDistance, with at least one cell as "on" if any were "on" in this originally.
    Coord[] randomSeparated​(double fraction, IRNG rng)
    Don't use this in new code; prefer mixedRandomSeparated(double, int, long) with a random long as the last parameter.
    Coord[] randomSeparated​(double fraction, IRNG rng, int limit)
    Don't use this in new code; prefer mixedRandomSeparated(double, int, long) with a random long as the last parameter.
    double rateDensity()  
    double rateRegularity()  
    GreasedRegion refill​(boolean[][] map)
    Reassigns this GreasedRegion with the given rectangular boolean array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length.
    GreasedRegion refill​(boolean[] bits, int width, int height)
    Reassigns this GreasedRegion with the given 1D boolean array, reusing the current data storage (without extra allocations) if this.width == width and this.height == height, where an [x][y] position is obtained from bits given an index n with x = n / height, y = n % height, any value of true considered "on", and any value of false considered "off."
    GreasedRegion refill​(byte[][] map, int lower, int upper)
    Reassigns this GreasedRegion with the given rectangular byte array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length.
    GreasedRegion refill​(char[][] map, char yes)
    Reassigns this GreasedRegion with the given rectangular char array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length.
    GreasedRegion refill​(char[][] map, char[] yes)
    Reassigns this GreasedRegion with the given rectangular char array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length.
    GreasedRegion refill​(double[][] map, double upperBound)
    Reassigns this GreasedRegion with the given rectangular double array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length.
    GreasedRegion refill​(double[][] map, double lower, double upper)
    Reassigns this GreasedRegion with the given rectangular double array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length.
    GreasedRegion refill​(double[][] map, double lowerBound, double upperBound, int scale)
    Reassigns this GreasedRegion with the given rectangular double array, reusing the current data storage (without extra allocations) if this.width == map.length * scale && this.height == map[0].length * scale.
    GreasedRegion refill​(int[][] map, int yes)
    Reassigns this GreasedRegion with the given rectangular int array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length.
    GreasedRegion refill​(int[][] map, int lower, int upper)
    Reassigns this GreasedRegion with the given rectangular int array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length.
    GreasedRegion refill​(long[] data2, int dataWidth, int dataHeight, int width, int height)
    Primarily for internal use, this method copies data2 into the internal long array the new GreasedRegion will use, but treats data2 as having the dimensions [dataWidth][dataHeight], and uses the potentially-different dimensions [width][height] for this GreasedRegion, potentially re-allocating the internal data this uses if width and/or height are different from what they were.
    GreasedRegion refill​(short[][] map, int lower, int upper)
    Reassigns this GreasedRegion with the given rectangular short array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length.
    GreasedRegion refill​(String[] map, char yes)
    Weird refill method that takes a String array, _as it would be printed_, so each String is a row and indexing would be done with y, x instead of the normal x, y.
    GreasedRegion refill​(IRNG random, int width, int height)
    Reassigns this GreasedRegion by filling it with random values from random, reusing the current data storage (without extra allocations) if this.width == width and this.height == height, and typically assigning approximately half of the cells in this to "on" and the rest to off.
    GreasedRegion refill​(RandomnessSource random, double fraction, int width, int height)
    Reassigns this GreasedRegion randomly, reusing the current data storage (without extra allocations) if this.width == width and this.height == height, while trying to set the given fraction of cells to on.
    GreasedRegion refill​(RandomnessSource random, int width, int height)
    Reassigns this GreasedRegion by filling it with random values from random, reusing the current data storage (without extra allocations) if this.width == width and this.height == height, and typically assigning approximately half of the cells in this to "on" and the rest to off.
    GreasedRegion remake​(GreasedRegion other)
    A useful method for efficiency, remake() reassigns this GreasedRegion to have its contents replaced by other.
    GreasedRegion remove​(int x, int y)  
    GreasedRegion remove​(int x, int y, GreasedRegion other)
    Takes another GreasedRegion, called other, with potentially different size and removes its "on" cells from this GreasedRegion at the given x,y offset, allowing negative x and/or y to remove only part of other in this.
    boolean remove​(Object o)  
    GreasedRegion remove​(Coord point)  
    boolean removeAll​(Collection<?> c)  
    GreasedRegion removeCircle​(Coord center, int radius)  
    GreasedRegion removeCorners()
    Where a cell is "on" but forms a right-angle with exactly two orthogonally-adjacent "on" cells and exactly two orthogonally-adjacent "off" cells, this turns each of those cells "off." This won't affect east-west lines of flat "on" cells, nor north-south lines.
    GreasedRegion removeEdges()
    Turns all cells that are adjacent to the boundaries of the GreasedRegion to "off".
    GreasedRegion removeIsolated()  
    GreasedRegion removeRectangle​(int startX, int startY, int rectangleWidth, int rectangleHeight)
    Removes all "on" cells from (startX, startY) inclusive to (startX+rectangleWidth, startY+rectangleHeight) exclusive, removing a total width of rectangleWidth and a total height of rectangleHeight in cells.
    GreasedRegion removeSeveral​(Iterable<Coord> points)  
    GreasedRegion removeSeveral​(Coord... points)  
    GreasedRegion resizeAndEmpty​(int width, int height)
    If this GreasedRegion has the same width and height passed as parameters, this acts the same as empty(), makes no allocations, and returns this GreasedRegion with its contents all "off"; otherwise, this does allocate a differently-sized amount of internal data to match the new width and height, sets the fields to all match the new width and height, and returns this GreasedRegion with its new width and height, with all contents "off".
    boolean retainAll​(Collection<?> c)  
    GreasedRegion retract()
    Takes the "on" cells in this GreasedRegion and retracts them by one cell in the 4 orthogonal directions, making each "on" cell that was orthogonally adjacent to an "off" cell into an "off" cell.
    GreasedRegion retract​(int amount)
    Takes the "on" cells in this GreasedRegion and retracts them by one cell in the 4 orthogonal directions, doing this iteeratively amount times, making each "on" cell that was within amount orthogonal distance to an "off" cell into an "off" cell.
    GreasedRegion retract8way()  
    GreasedRegion retract8way​(int amount)  
    GreasedRegion[] retractSeries​(int amount)  
    GreasedRegion[] retractSeries8way​(int amount)  
    ArrayList<GreasedRegion> retractSeriesToLimit()  
    ArrayList<GreasedRegion> retractSeriesToLimit8way()  
    Coord[] separatedBlue​(double fraction)
    Gets a Coord array from the "on" contents of this GreasedRegion, using a quasi-random scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this.
    Coord[] separatedBlue​(double fraction, int limit)
    Gets a Coord array from the "on" contents of this GreasedRegion, using a quasi-random scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this.
    Coord[] separatedPortion​(double fraction)
    GreasedRegion separatedRegionBlue​(double fraction)
    Modifies this GreasedRegion so it contains a quasi-random subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this.
    GreasedRegion separatedRegionBlue​(double fraction, int limit)
    Modifies this GreasedRegion so it contains a quasi-random subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this.
    GreasedRegion separatedRegionZCurve​(double fraction)
    Modifies this GreasedRegion so it contains a quasi-random subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this.
    GreasedRegion separatedRegionZCurve​(double fraction, int limit)
    Modifies this GreasedRegion so it contains a quasi-random subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this.
    Coord[] separatedZCurve​(double fraction)
    Gets a Coord array from the "on" contents of this GreasedRegion, using a quasi-random scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this.
    Coord[] separatedZCurve​(double fraction, int limit)
    Gets a Coord array from the "on" contents of this GreasedRegion, using a quasi-random scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this.
    String serializeToString()  
    GreasedRegion set​(boolean value, int x, int y)
    Sets the cell at x,y to on if value is true or off if value is false.
    GreasedRegion set​(boolean value, Coord point)
    Sets the cell at point to on if value is true or off if value is false.
    StringBuilder show​(char on, char off)
    Returns this GreasedRegion's data as a StringBuilder, with each row made of the parameter on for "on" cells and the parameter off for "off" cells, separated by newlines, with no trailing newline at the end.
    Coord singleRandom​(IRNG rng)
    Gets a single random Coord from the "on" positions in this GreasedRegion, or the Coord (-1,-1) if this is empty.
    int singleRandomTight​(IRNG rng)  
    int size()  
    GreasedRegion spill​(GreasedRegion bounds, int volume, IRNG rng)
    A randomized flood-fill that modifies this GreasedRegion so it randomly adds adjacent cells while staying inside the "on" cells of bounds, until size() is equal to volume or there are no more cells this can expand into.
    ArrayList<GreasedRegion> split()
    If this GreasedRegion stores multiple unconnected "on" areas, this finds each isolated area (areas that are only adjacent diagonally are considered separate from each other) and returns it as an element in an ArrayList of GreasedRegion, with one GreasedRegion per isolated area.
    ArrayList<GreasedRegion> split8way()
    If this GreasedRegion stores multiple unconnected "on" areas, this finds each isolated area (areas that are only adjacent diagonally are considered one area with this) and returns it as an element in an ArrayList of GreasedRegion, with one GreasedRegion per isolated area.
    static int[][] sum​(List<GreasedRegion> regions)
    Generates a 2D int array from a List of GreasedRegions, starting at all 0 and adding 1 to the int at a position once for every GreasedRegion that has that cell as "on." This means if you give 8 GreasedRegions to this method, it can produce any number between 0 and 8 in a cell; if you give 16 GreasedRegions, then it can produce any number between 0 and 16 in a cell.
    static int[][] sum​(GreasedRegion... regions)
    Generates a 2D int array from an array or vararg of GreasedRegions, starting at all 0 and adding 1 to the int at a position once for every GreasedRegion that has that cell as "on." This means if you give 8 GreasedRegions to this method, it can produce any number between 0 and 8 in a cell; if you give 16 GreasedRegions, then it can produce any number between 0 and 16 in a cell.
    static double[][] sumDouble​(List<GreasedRegion> regions)
    Generates a 2D double array from a List of GreasedRegions, starting at all 0 and adding 1 to the double at a position once for every GreasedRegion that has that cell as "on." This means if you give 8 GreasedRegions to this method, it can produce any number between 0 and 8 in a cell; if you give 16 GreasedRegions, then it can produce any number between 0 and 16 in a cell.
    static double[][] sumDouble​(GreasedRegion... regions)
    Generates a 2D double array from an array or vararg of GreasedRegions, starting at all 0 and adding 1 to the double at a position once for every GreasedRegion that has that cell as "on." This means if you give 8 GreasedRegions to this method, it can produce any number between 0 and 8 in a cell; if you give 16 GreasedRegions, then it can produce any number between 0 and 16 in a cell.
    static int[][] sumInto​(int[][] existing, GreasedRegion... regions)
    Adds to an existing 2D int array with an array or vararg of GreasedRegions, adding 1 to the int in existing at a position once for every GreasedRegion that has that cell as "on." This means if you give 8 GreasedRegions to this method, it can increment by any number between 0 and 8 in a cell; if you give 16 GreasedRegions, then it can increase the value in existing by any number between 0 and 16 in a cell.
    static double[][] sumIntoDouble​(double[][] existing, GreasedRegion... regions)
    Adds to an existing 2D double array with an array or vararg of GreasedRegions, adding 1 to the double in existing at a position once for every GreasedRegion that has that cell as "on." This means if you give 8 GreasedRegions to this method, it can increment by any number between 0 and 8 in a cell; if you give 16 GreasedRegions, then it can increase the value in existing by any number between 0 and 16 in a cell.
    static int[][] sumWeighted​(GreasedRegion[] regions, int[] weights)
    Generates a 2D int array from an array of GreasedRegions and an array of weights, starting the 2D result at all 0 and, for every GreasedRegion that has that cell as "on," adding the int in the corresponding weights array at the position of that cell.
    static double[][] sumWeightedDouble​(GreasedRegion[] regions, double[] weights)
    Generates a 2D double array from an array of GreasedRegions and an array of weights, starting the 2D result at all 0 and, for every GreasedRegion that has that cell as "on," adding the double in the corresponding weights array at the position of that cell.
    GreasedRegion surface()  
    GreasedRegion surface​(int amount)  
    GreasedRegion surface8way()  
    GreasedRegion surface8way​(int amount)  
    GreasedRegion[] surfaceSeries​(int amount)  
    GreasedRegion[] surfaceSeries8way​(int amount)  
    ArrayList<GreasedRegion> surfaceSeriesToLimit()  
    ArrayList<GreasedRegion> surfaceSeriesToLimit8way()  
    GreasedRegion thin()
    Like retract(), this reduces the width of thick areas of this GreasedRegion, but thin() will not remove areas that would be identical in a subsequent call to retract(), such as if the area would be eliminated.
    GreasedRegion thin8way()
    Like retract8way(), this reduces the width of thick areas of this GreasedRegion, but thin8way() will not remove areas that would be identical in a subsequent call to retract8way(), such as if the area would be eliminated.
    GreasedRegion thinFully()
    Calls thin() repeatedly, until the result is unchanged from the last call.
    GreasedRegion thinFully8way()
    Calls thin8way() repeatedly, until the result is unchanged from the last call.
    Object[] toArray()  
    <T> T[] toArray​(T[] a)  
    char[][] toChars()
    Returns this GreasedRegion's data as a 2D char array, [width][height] in size, with "on" cells filled with '.' and "off" cells with '#'.
    char[][] toChars​(char on, char off)
    Returns this GreasedRegion's data as a 2D char array, [width][height] in size, with "on" cells filled with the char parameter on and "off" cells with the parameter off.
    String toCompressedString()
    Compresses this GreasedRegion into a UTF-16 String and returns the String without modifying this GreasedRegion.
    GreasedRegion toggle​(int x, int y)
    Changes the on/off state of the cell with the given x and y, making an on cell into an off cell, or an off cell into an on cell.
    String toString()
    Returns a legible String representation of this that can be printed over multiple lines, with all "on" cells represented by '.' and all "off" cells by '#', in roguelike floors-on walls-off convention, separating each row by newlines (without a final trailing newline, so you could append text right after this).
    GreasedRegion translate​(int x, int y)
    Moves the "on" cells in this GreasedRegion to the given x and y offset, removing cells that move out of bounds.
    GreasedRegion translate​(Coord c)
    Translates a copy of this by the x,y values in c.
    static OrderedSet<GreasedRegion> whichContain​(int x, int y, Collection<GreasedRegion> packed)  
    static OrderedSet<GreasedRegion> whichContain​(int x, int y, GreasedRegion... packed)  
    char[][] writeCharsInto​(char[][] map, char toWrite)
    Like inverseMask(char[][], char), but modifies map in-place and returns it.
    double[][] writeDoubles​(double[][] map, double toWrite)
    "Inverse mask for doubles;" returns a copy of map where if a cell is "off" in this GreasedRegion, this keeps the value in map intact, and where a cell is "on", it instead writes the double toWrite.
    double[][] writeDoublesInto​(double[][] map, double toWrite)
    "Inverse mask for doubles;" returns a copy of map where if a cell is "off" in this GreasedRegion, this keeps the value in map intact, and where a cell is "on", it instead writes the double toWrite.
    int[][] writeInts​(int[][] map, int toWrite)
    "Inverse mask for ints;" returns a copy of map where if a cell is "off" in this GreasedRegion, this keeps the value in map intact, and where a cell is "on", it instead writes the int toWrite.
    int[][] writeIntsInto​(int[][] map, int toWrite)
    "Inverse mask for ints;" returns a copy of map where if a cell is "off" in this GreasedRegion, this keeps the value in map intact, and where a cell is "on", it instead writes the int toWrite.
    int xBound​(boolean findSmallest)  
    GreasedRegion xor​(GreasedRegion other)
    Symmetric difference (more commonly known as exclusive or, hence the name) of two GreasedRegions, assigning the result into this GreasedRegion.
    int yBound​(boolean findSmallest)  
    GreasedRegion zoom​(int x, int y)
    Effectively doubles the x and y values of each cell this contains (not scaling each cell to be larger, so each "on" cell will be surrounded by "off" cells), and re-maps the positions so the given x and y in the doubled space become 0,0 in the resulting GreasedRegion (which is this, assigning to itself).

    Methods inherited from class squidpony.squidgrid.zone.Zone.Skeleton

    getCenter

    Methods inherited from class java.lang.Object

    clone, finalize, getClass, notify, notifyAll, wait, wait, wait

    Methods inherited from interface java.util.Collection

    parallelStream, removeIf, spliterator, stream, toArray

    Methods inherited from interface java.lang.Iterable

    forEach

    Methods inherited from interface squidpony.squidgrid.zone.Zone

    getCenter
  • Field Details

  • Constructor Details

    • GreasedRegion

      public GreasedRegion()
      Constructs an empty 64x64 GreasedRegion. GreasedRegions are mutable, so you can add to this with insert() or insertSeveral(), among others.
    • GreasedRegion

      public GreasedRegion​(boolean[][] bits)
      Constructs a GreasedRegion with the given rectangular boolean array, with width of bits.length and height of bits[0].length, any value of true considered "on", and any value of false considered "off."
      Parameters:
      bits - a rectangular 2D boolean array where true is on and false is off
    • GreasedRegion

      public GreasedRegion​(char[][] map, char yes)
      Constructs a GreasedRegion with the given rectangular char array, with width of map.length and height of map[0].length, any value that equals yes is considered "on", and any other value considered "off."
      Parameters:
      map - a rectangular 2D char array where yes is on and everything else is off
      yes - which char to encode as "on"
    • GreasedRegion

      public GreasedRegion​(char[][] map, char[] yes)
      Constructs a GreasedRegion with the given rectangular char array, with width of map.length and height of map[0].length, any value that equals yes is considered "on", and any other value considered "off."
      Parameters:
      map - a rectangular 2D char array where yes is on and everything else is off
      yes - which char to encode as "on"
    • GreasedRegion

      public GreasedRegion​(String[] map, char yes)
      Weird constructor that takes a String array, _as it would be printed_, so each String is a row and indexing would be done with y, x instead of the normal x, y.
      Parameters:
      map - String array (as printed, not the normal storage) where each String is a row
      yes - the char to consider "on" in the GreasedRegion
    • GreasedRegion

      public GreasedRegion​(int[][] map, int yes)
      Constructs a GreasedRegion with the given rectangular int array, with width of map.length and height of map[0].length, any value that equals yes is considered "on", and any other value considered "off."
      Parameters:
      map - a rectangular 2D int array where an int == yes is on and everything else is off
      yes - which int to encode as "on"
    • GreasedRegion

      public GreasedRegion​(int[][] map, int lower, int upper)
      Constructs this GreasedRegion using an int[][], treating cells as on if they are greater than or equal to lower and less than upper, or off otherwise.
      Parameters:
      map - an int[][] that should have some ints between lower and upper
      lower - lower bound, inclusive; all on cells will have values in map that are at least equal to lower
      upper - upper bound, exclusive; all on cells will have values in map that are less than upper
    • GreasedRegion

      public GreasedRegion​(byte[][] map, int lower, int upper)
      Constructs this GreasedRegion using a byte[][], treating cells as on if they are greater than or equal to lower and less than upper, or off otherwise.
      Parameters:
      map - a byte[][] that should have some bytes between lower and upper
      lower - lower bound, inclusive; all on cells will have values in map that are at least equal to lower
      upper - upper bound, exclusive; all on cells will have values in map that are less than upper
    • GreasedRegion

      public GreasedRegion​(short[][] map, int lower, int upper)
      Constructs this GreasedRegion using a short[][], treating cells as on if they are greater than or equal to lower and less than upper, or off otherwise.
      Parameters:
      map - a short[][] that should have some shorts between lower and upper
      lower - lower bound, inclusive; all on cells will have values in map that are at least equal to lower
      upper - upper bound, exclusive; all on cells will have values in map that are less than upper
    • GreasedRegion

      public GreasedRegion​(double[][] map, double upperBound)
      Constructs this GreasedRegion using a double[][] (typically one generated by DijkstraMap) that only stores two relevant states: an "on" state for values less than or equal to upperBound (inclusive), and an "off" state for anything else.
      Parameters:
      map - a double[][] that probably relates in some way to DijkstraMap.
      upperBound - upper inclusive; any double greater than this will be off, any others will be on
    • GreasedRegion

      public GreasedRegion​(double[][] map, double lowerBound, double upperBound)
      Constructs this GreasedRegion using a double[][] (typically one generated by DijkstraMap) that only stores two relevant states: an "on" state for values between lowerBound (inclusive) and upperBound (exclusive), and an "off" state for anything else.
      Parameters:
      map - a double[][] that probably relates in some way to DijkstraMap.
      lowerBound - lower inclusive; any double lower than this will be off, any equal to or greater than this, but less than upper, will be on
      upperBound - upper exclusive; any double greater than or equal to this this will be off, any doubles both less than this and equal to or greater than lower will be on
    • GreasedRegion

      public GreasedRegion​(double[][] map, double lowerBound, double upperBound, int scale)
      Constructs this GreasedRegion using a double[][] that only stores two relevant states: an "on" state for values between lowerBound (inclusive) and upperBound (exclusive), and an "off" state for anything else. This variant scales the input so each "on" position in map produces a 2x2 on area if scale is 2, a 3x3 area if scale is 3, and so on.
      Parameters:
      map - a double[][]; depending on scale, the GreasedRegion may have different width and height
      lowerBound - lower inclusive; any double lower than this will be off, any equal to or greater than this, but less than upper, will be on
      upperBound - upper exclusive; any double greater than or equal to this this will be off, any doubles both less than this and equal to or greater than lower will be on
      scale - the size of the square of cells in this that each "on" value in map will correspond to
    • GreasedRegion

      public GreasedRegion​(boolean[] bits, int width, int height)
      Constructs a GreasedRegion with the given 1D boolean array, with the given width and height, where an [x][y] position is obtained from bits given an index n with x = n / height, y = n % height, any value of true considered "on", and any value of false considered "off."
      Parameters:
      bits - a 1D boolean array where true is on and false is off
      width - the width of the desired GreasedRegion; width * height should equal bits.length
      height - the height of the desired GreasedRegion; width * height should equal bits.length
    • GreasedRegion

      public GreasedRegion​(int width, int height)
      Constructor for an empty GreasedRegion of the given width and height. GreasedRegions are mutable, so you can add to this with insert() or insertSeveral(), among others.
      Parameters:
      width - the maximum width for the GreasedRegion
      height - the maximum height for the GreasedRegion
    • GreasedRegion

      public GreasedRegion​(Coord single, int width, int height)
      Constructor for a GreasedRegion that contains a single "on" cell, and has the given width and height. Note that to avoid confusion with the constructor that takes multiple Coord values, this takes the single "on" Coord first, while the multiple-Coord constructor takes its vararg or array of Coords last.
      Parameters:
      single - the one (x,y) point to store as "on" in this GreasedRegion
      width - the maximum width for the GreasedRegion
      height - the maximum height for the GreasedRegion
    • GreasedRegion

      public GreasedRegion​(int width, int height, Coord... points)
      Constructor for a GreasedRegion that can have several "on" cells specified, and has the given width and height. Note that to avoid confusion with the constructor that takes one Coord value, this takes the vararg or array of Coords last, while the single-Coord constructor takes its one Coord first.
      Parameters:
      width - the maximum width for the GreasedRegion
      height - the maximum height for the GreasedRegion
      points - an array or vararg of Coord to store as "on" in this GreasedRegion
    • GreasedRegion

      public GreasedRegion​(int width, int height, Iterable<Coord> points)
      Constructor for a GreasedRegion that can have several "on" cells specified, and has the given width and height. Note that to avoid confusion with the constructor that takes one Coord value, this takes the Iterable of Coords last, while the single-Coord constructor takes its one Coord first.
      Parameters:
      width - the maximum width for the GreasedRegion
      height - the maximum height for the GreasedRegion
      points - an array or vararg of Coord to store as "on" in this GreasedRegion
    • GreasedRegion

      public GreasedRegion​(RandomnessSource random, int width, int height)
      Constructor for a random GreasedRegion of the given width and height, typically assigning approximately half of the cells in this to "on" and the rest to off. A RandomnessSource can be slightly more efficient than an RNG when you're making a lot of calls on it.
      Parameters:
      random - a RandomnessSource that should have a good nextLong() method; DiverRNG is excellent but Lathe32RNG is faster on GWT (only there)
      width - the maximum width for the GreasedRegion
      height - the maximum height for the GreasedRegion
    • GreasedRegion

      public GreasedRegion​(IRNG random, int width, int height)
      Constructor for a random GreasedRegion of the given width and height, typically assigning approximately half of the cells in this to "on" and the rest to off. A RandomnessSource can be slightly more efficient than an RNG when you're making a lot of calls on it, so you may prefer GreasedRegion(RandomnessSource, int, int).
      Parameters:
      random - an IRNG, such as an RNG, that this will use to generate its contents
      width - the maximum width for the GreasedRegion
      height - the maximum height for the GreasedRegion
    • GreasedRegion

      public GreasedRegion​(RandomnessSource random, double fraction, int width, int height)
      Constructor for a random GreasedRegion of the given width and height, trying to set the given fraction of cells to on. Depending on the value of fraction, this makes between 0 and 6 calls to the nextLong() method of random's internal RandomnessSource, per 64 cells of this GreasedRegion (if height is not a multiple of 64, round up to get the number of calls this makes). As such, this sacrifices the precision of the fraction to obtain significantly better speed than generating one random number per cell, although the precision is probably good enough (fraction is effectively rounded down to the nearest multiple of 0.015625, and clamped between 0.0 and 1.0). The parameter random can be an object like a DiverRNG, an RNG backed by a well-distributed RandomnessSource like its default, DiverRNG, a GWTRNG (especially if you target GWT, where it will perform much better than most alternatives), or any of various other RandomnessSource implementations that distribute bits well for RandomnessSource.nextLong(), but should not be intentionally-biased RNGs like DharmaRNG or EditRNG, nor double-based QRNGs like VanDerCorputQRNG or SobolQRNG.
      Parameters:
      random - a RandomnessSource that should produce high-quality long values, like the defaults for RNG
      fraction - between 0.0 and 1.0 (clamped), only considering a precision of 1/64.0 (0.015625) between steps
      width - the maximum width for the GreasedRegion
      height - the maximum height for the GreasedRegion
    • GreasedRegion

      public GreasedRegion​(GreasedRegion other)
      Copy constructor that takes another GreasedRegion and copies all of its data into this new one. If you find yourself frequently using this constructor and assigning it to the same variable, consider using the remake(GreasedRegion) method on the variable instead, which will, if it has the same width and height as the other GreasedRegion, avoid creating garbage and quickly fill the variable with the other's contents.
      Parameters:
      other - another GreasedRegion that will be copied into this new GreasedRegion
      See Also:
      for a convenience method that just uses this constructor
    • GreasedRegion

      public GreasedRegion​(long[] data2, int width, int height)
      Primarily for internal use, this constructor copies data2 exactly into the internal long array the new GreasedRegion will use, and does not perform any validation steps to ensure that cells that would be "on" but are outside the actual height of the GreasedRegion are actually removed (this only matters if height is not a multiple of 64).
      Parameters:
      data2 - a long array that is typically from another GreasedRegion, and would be hard to make otherwise
      width - the width of the GreasedRegion to construct
      height - the height of the GreasedRegion to construct
    • GreasedRegion

      public GreasedRegion​(long[] data2, int dataWidth, int dataHeight, int width, int height)
      Primarily for internal use, this constructor copies data2 into the internal long array the new GreasedRegion will use, but treats data2 as having the dimensions [dataWidth][dataHeight], and uses the potentially-different dimensions [width][height] for the constructed GreasedRegion. This will truncate data2 on width, height, or both if width or height is smaller than dataWidth or dataHeight. It will fill extra space with all "off" if width or height is larger than dataWidth or dataHeight. It will interpret data2 as the same 2D shape regardless of the width or height it is being assigned to, and data2 will not be reshaped by truncation.
      Parameters:
      data2 - a long array that is typically from another GreasedRegion, and would be hard to make otherwise
      dataWidth - the width to interpret data2 as having
      dataHeight - the height to interpret data2 as having
      width - the width of the GreasedRegion to construct
      height - the height of the GreasedRegion to construct
  • Method Details

    • refill

      public GreasedRegion refill​(boolean[][] map)
      Reassigns this GreasedRegion with the given rectangular boolean array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length. The current values stored in this are always cleared, then any value of true in map is considered "on", and any value of false in map is considered "off."
      Parameters:
      map - a rectangular 2D boolean array where true is on and false is off
      Returns:
      this for chaining
    • refill

      public GreasedRegion refill​(char[][] map, char yes)
      Reassigns this GreasedRegion with the given rectangular char array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length. The current values stored in this are always cleared, then any value that equals yes is considered "on", and any other value considered "off."
      Parameters:
      map - a rectangular 2D char array where yes is on and everything else is off
      yes - which char to encode as "on"
      Returns:
      this for chaining
    • refill

      public GreasedRegion refill​(char[][] map, char[] yes)
      Reassigns this GreasedRegion with the given rectangular char array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length. The current values stored in this are always cleared, then any value that equals yes is considered "on", and any other value considered "off."
      Parameters:
      map - a rectangular 2D char array where yes is on and everything else is off
      yes - which char to encode as "on"
      Returns:
      this for chaining
    • refill

      public GreasedRegion refill​(String[] map, char yes)
      Weird refill method that takes a String array, _as it would be printed_, so each String is a row and indexing would be done with y, x instead of the normal x, y.
      Parameters:
      map - String array (as printed, not the normal storage) where each String is a row
      yes - the char to consider "on" in the GreasedRegion
      Returns:
      this for chaining
    • refill

      public GreasedRegion refill​(int[][] map, int yes)
      Reassigns this GreasedRegion with the given rectangular int array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length. The current values stored in this are always cleared, then any value that equals yes is considered "on", and any other value considered "off."
      Parameters:
      map - a rectangular 2D int array where an int == yes is on and everything else is off
      yes - which int to encode as "on"
      Returns:
      this for chaining
    • refill

      public GreasedRegion refill​(int[][] map, int lower, int upper)
      Reassigns this GreasedRegion with the given rectangular int array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length. The current values stored in this are always cleared, then cells are treated as on if they are greater than or equal to lower and less than upper, or off otherwise.
      Parameters:
      map - a rectangular 2D int array that should have some values between lower and upper
      lower - lower bound, inclusive; all on cells will have values in map that are at least equal to lower
      upper - upper bound, exclusive; all on cells will have values in map that are less than upper
      Returns:
      this for chaining
    • refill

      public GreasedRegion refill​(byte[][] map, int lower, int upper)
      Reassigns this GreasedRegion with the given rectangular byte array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length. The current values stored in this are always cleared, then cells are treated as on if they are greater than or equal to lower and less than upper, or off otherwise.
      Parameters:
      map - a rectangular 2D byte array that should have some values between lower and upper
      lower - lower bound, inclusive; all on cells will have values in map that are at least equal to lower
      upper - upper bound, exclusive; all on cells will have values in map that are less than upper
      Returns:
      this for chaining
    • refill

      public GreasedRegion refill​(short[][] map, int lower, int upper)
      Reassigns this GreasedRegion with the given rectangular short array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length. The current values stored in this are always cleared, then cells are treated as on if they are greater than or equal to lower and less than upper, or off otherwise.
      Parameters:
      map - a rectangular 2D short array that should have some values between lower and upper
      lower - lower bound, inclusive; all on cells will have values in map that are at least equal to lower
      upper - upper bound, exclusive; all on cells will have values in map that are less than upper
      Returns:
      this for chaining
    • refill

      public GreasedRegion refill​(double[][] map, double upperBound)
      Reassigns this GreasedRegion with the given rectangular double array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length. The current values stored in this are always cleared, then cells are treated as on if they are less than or equal to upperBound, or off otherwise.
      Parameters:
      map - a rectangular 2D double array that should usually have some values less than or equal to upperBound
      upperBound - upper bound, inclusive; all on cells will have values in map that are less than or equal to this
      Returns:
      this for chaining
    • refill

      public GreasedRegion refill​(double[][] map, double lower, double upper)
      Reassigns this GreasedRegion with the given rectangular double array, reusing the current data storage (without extra allocations) if this.width == map.length and this.height == map[0].length. The current values stored in this are always cleared, then cells are treated as on if they are greater than or equal to lower and less than upper, or off otherwise.
      Parameters:
      map - a rectangular 2D double array that should have some values between lower and upper
      lower - lower bound, inclusive; all on cells will have values in map that are at least equal to lower
      upper - upper bound, exclusive; all on cells will have values in map that are less than upper
      Returns:
      this for chaining
    • refill

      public GreasedRegion refill​(double[][] map, double lowerBound, double upperBound, int scale)
      Reassigns this GreasedRegion with the given rectangular double array, reusing the current data storage (without extra allocations) if this.width == map.length * scale && this.height == map[0].length * scale. The current values stored in this are always cleared, then cells are treated as on if they are greater than or equal to lower and less than upper, or off otherwise, before considering scaling. This variant scales the input so each "on" position in map produces a 2x2 on area if scale is 2, a 3x3 area if scale is 3, and so on.
      Parameters:
      map - a double[][]; depending on scale, the GreasedRegion may have different width and height
      lowerBound - lower inclusive; any double lower than this will be off, any equal to or greater than this, but less than upper, will be on
      upperBound - upper exclusive; any double greater than or equal to this this will be off, any doubles both less than this and equal to or greater than lower will be on
      scale - the size of the square of cells in this that each "on" value in map will correspond to
      Returns:
      this for chaining
    • refill

      public GreasedRegion refill​(boolean[] bits, int width, int height)
      Reassigns this GreasedRegion with the given 1D boolean array, reusing the current data storage (without extra allocations) if this.width == width and this.height == height, where an [x][y] position is obtained from bits given an index n with x = n / height, y = n % height, any value of true considered "on", and any value of false considered "off."
      Parameters:
      bits - a 1D boolean array where true is on and false is off
      width - the width of the desired GreasedRegion; width * height should equal bits.length
      height - the height of the desired GreasedRegion; width * height should equal bits.length
      Returns:
      this for chaining
    • resizeAndEmpty

      public GreasedRegion resizeAndEmpty​(int width, int height)
      If this GreasedRegion has the same width and height passed as parameters, this acts the same as empty(), makes no allocations, and returns this GreasedRegion with its contents all "off"; otherwise, this does allocate a differently-sized amount of internal data to match the new width and height, sets the fields to all match the new width and height, and returns this GreasedRegion with its new width and height, with all contents "off". This is meant for cases where a GreasedRegion may be reused effectively, but its size may not always be the same.
      Parameters:
      width - the width to potentially resize this GreasedRegion to
      height - the height to potentially resize this GreasedRegion to
      Returns:
      this GreasedRegion, always with all contents "off", and with the height and width set.
    • refill

      public GreasedRegion refill​(RandomnessSource random, int width, int height)
      Reassigns this GreasedRegion by filling it with random values from random, reusing the current data storage (without extra allocations) if this.width == width and this.height == height, and typically assigning approximately half of the cells in this to "on" and the rest to off. A RandomnessSource can be slightly more efficient than an RNG when you're making a lot of calls on it.
      Parameters:
      random - a RandomnessSource that should have a good nextLong() method; DiverRNG is excellent but Lathe32RNG is faster on GWT (only there)
      width - the width of the desired GreasedRegion
      height - the height of the desired GreasedRegion
      Returns:
      this for chaining
    • refill

      public GreasedRegion refill​(IRNG random, int width, int height)
      Reassigns this GreasedRegion by filling it with random values from random, reusing the current data storage (without extra allocations) if this.width == width and this.height == height, and typically assigning approximately half of the cells in this to "on" and the rest to off.
      Parameters:
      random - an IRNG that should have a good nextLong() method; an RNG constructed with the default RandomnessSource will be fine
      width - the width of the desired GreasedRegion
      height - the height of the desired GreasedRegion
      Returns:
      this for chaining
    • refill

      public GreasedRegion refill​(RandomnessSource random, double fraction, int width, int height)
      Reassigns this GreasedRegion randomly, reusing the current data storage (without extra allocations) if this.width == width and this.height == height, while trying to set the given fraction of cells to on. Depending on the value of fraction, this makes between 0 and 6 calls to the nextLong() method of random's internal RandomnessSource, per 64 cells of this GreasedRegion (if height is not a multiple of 64, round up to get the number of calls this makes). As such, this sacrifices the precision of the fraction to obtain significantly better speed than generating one random number per cell, although the precision is probably good enough (fraction is effectively rounded down to the nearest multiple of 0.015625, and clamped between 0.0 and 1.0). The parameter random can be an object like a DiverRNG, an RNG backed by a well-distributed RandomnessSource like its default, DiverRNG, a GWTRNG (especially if you target GWT, where it will perform much better than most alternatives), or any of various other RandomnessSource implementations that distribute bits well for RandomnessSource.nextLong(), but should not be intentionally-biased RNGs like DharmaRNG or EditRNG, nor double-based QRNGs like VanDerCorputQRNG or SobolQRNG.
      Parameters:
      random - a RandomnessSource that should produce high-quality long values, like the defaults for RNG
      fraction - between 0.0 and 1.0 (clamped), only considering a precision of 1/64.0 (0.015625) between steps
      width - the maximum width for the GreasedRegion
      height - the maximum height for the GreasedRegion
      Returns:
      this for chaining
    • refill

      public GreasedRegion refill​(long[] data2, int dataWidth, int dataHeight, int width, int height)
      Primarily for internal use, this method copies data2 into the internal long array the new GreasedRegion will use, but treats data2 as having the dimensions [dataWidth][dataHeight], and uses the potentially-different dimensions [width][height] for this GreasedRegion, potentially re-allocating the internal data this uses if width and/or height are different from what they were. This will truncate data2 on width, height, or both if width or height is smaller than dataWidth or dataHeight. It will fill extra space with all "off" if width or height is larger than dataWidth or dataHeight. It will interpret data2 as the same 2D shape regardless of the width or height it is being assigned to, and data2 will not be reshaped by truncation.
      Parameters:
      data2 - a long array that is typically from another GreasedRegion, and would be hard to make otherwise
      dataWidth - the width to interpret data2 as having
      dataHeight - the height to interpret data2 as having
      width - the width to set this GreasedRegion to have
      height - the height to set this GreasedRegion to have
    • remake

      public GreasedRegion remake​(GreasedRegion other)
      A useful method for efficiency, remake() reassigns this GreasedRegion to have its contents replaced by other. If other and this GreasedRegion have identical width and height, this is very efficient and performs no additional allocations, simply replacing the cell data in this with the cell data from other. If width and height are not both equal between this and other, this does allocate a new data array, but still reassigns this GreasedRegion in-place and acts similarly to when width and height are both equal (it just uses some more memory).
      Using remake() or the similar refill() methods in chains of operations on multiple GreasedRegions can be key to maintaining good performance and memory usage. You often can recycle a no-longer-used GreasedRegion by assigning a GreasedRegion you want to keep to it with remake(), then mutating either the remade value or the one that was just filled into this but keeping one version around for later usage.
      Parameters:
      other - another GreasedRegion to replace the data in this GreasedRegion with
      Returns:
      this for chaining
    • alterBounds

      public GreasedRegion alterBounds​(int widthChange, int heightChange)
      Changes the width and/or height of this GreasedRegion, enlarging or shrinking starting at the edges where x == width - 1 and y == height - 1. There isn't an especially efficient way to expand from the other edges, but this method is able to copy data in bulk, so at least this method should be very fast. You can use insert(int, int, GreasedRegion) if you want to place one GreasedRegion inside another one, potentially with a different size. The space created by any enlargement starts all off; shrinking doesn't change the existing data where it isn't removed by the shrink.
      Parameters:
      widthChange - the amount to change width by; can be positive, negative, or zero
      heightChange - the amount to change height by; can be positive, negative, or zero
      Returns:
      this for chaining
    • copyRotated

      public GreasedRegion copyRotated​(int turns)
      Makes a copy of this GreasedRegion that has been rotated 90 degrees turns times. If using y-down coordinates, then these rotations are clockwise; otherwise, they are counter-clockwise. This uses a copy because in many caseswhere the GreasedRegion has non-equal width and height, the rotated version has different dimensions, and that requires allocating most of a new GreasedRegion anyway. This GreasedRegion is never modifed as a result of this method.
      Parameters:
      turns - how many times to rotate the copy (clockwise if using y-down, counterclockwise otherwise)
      Returns:
      a potentially-rotated copy of this GreasedRegion
    • flip

      public GreasedRegion flip​(boolean leftRight, boolean upDown)
    • set

      public GreasedRegion set​(boolean value, int x, int y)
      Sets the cell at x,y to on if value is true or off if value is false. Does nothing if x,y is out of bounds.
      Parameters:
      value - the value to set in the cell
      x - the x-position of the cell
      y - the y-position of the cell
      Returns:
      this for chaining
    • set

      public GreasedRegion set​(boolean value, Coord point)
      Sets the cell at point to on if value is true or off if value is false. Does nothing if point is out of bounds, or if point is null.
      Parameters:
      value - the value to set in the cell
      point - the x,y Coord of the cell to set
      Returns:
      this for chaining
    • insert

      public GreasedRegion insert​(int x, int y)
      Sets the cell at x,y to "on". Does nothing if x,y is out of bounds. More efficient, slightly, than set(boolean, int, int) if you just need to set a cell to "on".
      Parameters:
      x - the x-position of the cell
      y - the y-position of the cell
      Returns:
      this for chaining
    • insert

      public GreasedRegion insert​(int tight)
      Sets the given cell, "tightly" encoded for a specific width/height as by asTightEncoded(), to "on". Does nothing if the cell is out of bounds.
      Parameters:
      tight - a cell tightly encoded for this GreasedRegion's width and height
      Returns:
      this for chaining
    • insert

      public GreasedRegion insert​(Coord point)
      Sets the cell at point to "on". Does nothing if point is out of bounds, or if point is null. More efficient, slightly, than set(boolean, Coord) if you just need to set a cell to "on".
      Parameters:
      point - the x,y Coord of the cell
      Returns:
      this for chaining
    • insert

      public GreasedRegion insert​(int x, int y, GreasedRegion other)
      Takes another GreasedRegion, called other, with potentially different size and inserts its "on" cells into thi GreasedRegion at the given x,y offset, allowing negative x and/or y to put only part of other in this.
      This is a rather complex method internally, but should be about as efficient as a general insert-region method can be.
      Parameters:
      x - the x offset to start inserting other at; may be negative
      y - the y offset to start inserting other at; may be negative
      other - the other GreasedRegion to insert
      Returns:
      this for chaining
    • insertSeveral

      public GreasedRegion insertSeveral​(Coord... points)
    • insertSeveral

      public GreasedRegion insertSeveral​(int[] points)
    • insertSeveral

    • insertRectangle

      public GreasedRegion insertRectangle​(int startX, int startY, int rectangleWidth, int rectangleHeight)
    • insertCircle

      public GreasedRegion insertCircle​(Coord center, int radius)
    • remove

      public GreasedRegion remove​(int x, int y)
    • remove

      public GreasedRegion remove​(Coord point)
    • remove

      public GreasedRegion remove​(int x, int y, GreasedRegion other)
      Takes another GreasedRegion, called other, with potentially different size and removes its "on" cells from this GreasedRegion at the given x,y offset, allowing negative x and/or y to remove only part of other in this.
      This is a rather complex method internally, but should be about as efficient as a general remove-region method can be. The code is identical to insert(int, int, GreasedRegion) except that where insert only adds cells, this only removes cells. Essentially, insert() is to or(GreasedRegion) as remove() is to andNot(GreasedRegion).
      Parameters:
      x - the x offset to start removing other from; may be negative
      y - the y offset to start removing other from; may be negative
      other - the other GreasedRegion to remove
      Returns:
      this for chaining
    • removeSeveral

      public GreasedRegion removeSeveral​(Coord... points)
    • removeSeveral

    • removeRectangle

      public GreasedRegion removeRectangle​(int startX, int startY, int rectangleWidth, int rectangleHeight)
      Removes all "on" cells from (startX, startY) inclusive to (startX+rectangleWidth, startY+rectangleHeight) exclusive, removing a total width of rectangleWidth and a total height of rectangleHeight in cells.
      Parameters:
      startX - left side x-coordinate
      startY - top side (or bottom if positive y is up) y-coordinate
      rectangleWidth - how many cells wide the area to remove is
      rectangleHeight - how many cells tal the area to remove is
      Returns:
      this, after modification, for chaining
    • removeCircle

      public GreasedRegion removeCircle​(Coord center, int radius)
    • empty

      public GreasedRegion empty()
      Equivalent to clear(), setting all cells to "off," but also returns this for chaining.
      Returns:
      this for chaining
    • allOn

      public GreasedRegion allOn()
      Sets all cells in this to "on."
      Returns:
      this for chaining
    • fill

      public GreasedRegion fill​(boolean contents)
      Sets all cells in this to "on" if contents is true, or "off" if contents is false.
      Parameters:
      contents - true to set all cells to on, false to set all cells to off
      Returns:
      this for chaining
    • removeEdges

      Turns all cells that are adjacent to the boundaries of the GreasedRegion to "off".
      Returns:
      this for chaining
    • copy

      public GreasedRegion copy()
      Simple method that returns a newly-allocated copy of this GreasedRegion; modifications to one won't change the other, and this method returns the copy while leaving the original unchanged.
      Returns:
      a copy of this GreasedRegion; the copy can be changed without altering the original
    • decode

      public boolean[][] decode()
      Returns this GreasedRegion's data as a 2D boolean array, [width][height] in size, with on treated as true and off treated as false.
      Returns:
      a 2D boolean array that represents this GreasedRegion's data
    • intoChars

      public char[][] intoChars​(char[][] chars, char on, char off)
      Fills this GreasedRegion's data into the given 2D char array, modifying it and returning it, with "on" cells filled with the char parameter on and "off" cells with the parameter off.
      Parameters:
      chars - a 2D char array that will be modified; must not be null, nor can it contain null elements
      on - the char to use for "on" cells
      off - the char to use for "off" cells
      Returns:
      a 2D char array that represents this GreasedRegion's data
    • intoChars

      public char[][] intoChars​(char[][] chars, char on)
      Fills this GreasedRegion's data into the given 2D char array, modifying it and returning it, with "on" cells filled with the char parameter on and "off" cells left as-is.
      Parameters:
      chars - a 2D char array that will be modified; must not be null, nor can it contain null elements
      on - the char to use for "on" cells
      Returns:
      a 2D char array that represents the "on" cells in this GreasedRegion's data written over chars
    • toChars

      public char[][] toChars​(char on, char off)
      Returns this GreasedRegion's data as a 2D char array, [width][height] in size, with "on" cells filled with the char parameter on and "off" cells with the parameter off.
      Parameters:
      on - the char to use for "on" cells
      off - the char to use for "off" cells
      Returns:
      a 2D char array that represents this GreasedRegion's data
    • toChars

      public char[][] toChars()
      Returns this GreasedRegion's data as a 2D char array, [width][height] in size, with "on" cells filled with '.' and "off" cells with '#'.
      Returns:
      a 2D char array that represents this GreasedRegion's data
    • show

      public StringBuilder show​(char on, char off)
      Returns this GreasedRegion's data as a StringBuilder, with each row made of the parameter on for "on" cells and the parameter off for "off" cells, separated by newlines, with no trailing newline at the end.
      Parameters:
      on - the char to use for "on" cells
      off - the char to use for "off" cells
      Returns:
      a StringBuilder that stores each row of this GreasedRegion as chars, with rows separated by newlines.
    • toString

      public String toString()
      Returns a legible String representation of this that can be printed over multiple lines, with all "on" cells represented by '.' and all "off" cells by '#', in roguelike floors-on walls-off convention, separating each row by newlines (without a final trailing newline, so you could append text right after this).
      Overrides:
      toString in class Object
      Returns:
      a String representation of this GreasedRegion using '.' for on, '#' for off, and newlines between rows
    • mask

      public char[][] mask​(char[][] map, char filler)
      Returns a copy of map where if a cell is "on" in this GreasedRegion, this keeps the value in map intact, and where a cell is "off", it instead writes the char filler.
      Parameters:
      map - a 2D char array that will not be modified
      filler - the char to use where this GreasedRegion stores an "off" cell
      Returns:
      a masked copy of map
    • mask

      public short[][] mask​(short[][] map, short filler)
      Returns a copy of map where if a cell is "on" in this GreasedRegion, this keeps the value in map intact, and where a cell is "off", it instead writes the short filler. Meant for use with MultiSpill, but may be used anywhere you have a 2D short array. mask(char[][], char) is more likely to be useful.
      Parameters:
      map - a 2D short array that will not be modified
      filler - the short to use where this GreasedRegion stores an "off" cell
      Returns:
      a masked copy of map
    • inverseMask

      public char[][] inverseMask​(char[][] map, char toWrite)
      Returns a copy of map where if a cell is "off" in this GreasedRegion, this keeps the value in map intact, and where a cell is "on", it instead writes the char toWrite.
      Parameters:
      map - a 2D char array that will not be modified
      toWrite - the char to use where this GreasedRegion stores an "on" cell
      Returns:
      a masked copy of map
    • writeInts

      public int[][] writeInts​(int[][] map, int toWrite)
      "Inverse mask for ints;" returns a copy of map where if a cell is "off" in this GreasedRegion, this keeps the value in map intact, and where a cell is "on", it instead writes the int toWrite.
      Parameters:
      map - a 2D int array that will not be modified
      toWrite - the int to use where this GreasedRegion stores an "on" cell
      Returns:
      an altered copy of map
    • writeIntsInto

      public int[][] writeIntsInto​(int[][] map, int toWrite)
      "Inverse mask for ints;" returns a copy of map where if a cell is "off" in this GreasedRegion, this keeps the value in map intact, and where a cell is "on", it instead writes the int toWrite. Modifies map in-place, unlike writeInts(int[][], int).
      Parameters:
      map - a 2D int array that will be modified
      toWrite - the int to use where this GreasedRegion stores an "on" cell
      Returns:
      map, with the changes applied; not a copy
    • writeDoubles

      public double[][] writeDoubles​(double[][] map, double toWrite)
      "Inverse mask for doubles;" returns a copy of map where if a cell is "off" in this GreasedRegion, this keeps the value in map intact, and where a cell is "on", it instead writes the double toWrite.
      Parameters:
      map - a 2D double array that will not be modified
      toWrite - the double to use where this GreasedRegion stores an "on" cell
      Returns:
      an altered copy of map
    • writeDoublesInto

      public double[][] writeDoublesInto​(double[][] map, double toWrite)
      "Inverse mask for doubles;" returns a copy of map where if a cell is "off" in this GreasedRegion, this keeps the value in map intact, and where a cell is "on", it instead writes the double toWrite. Modifies map in-place, unlike writeDoubles(double[][], double).
      Parameters:
      map - a 2D double array that will be modified
      toWrite - the double to use where this GreasedRegion stores an "on" cell
      Returns:
      map, with the changes applied; not a copy
    • writeCharsInto

      public char[][] writeCharsInto​(char[][] map, char toWrite)
      Like inverseMask(char[][], char), but modifies map in-place and returns it. If a cell is "off" in this GreasedRegion, this keeps the value in map intact, and where a cell is "on", it instead writes the char toWrite. Modifies map in-place, unlike inverseMask(char[][], char).
      Parameters:
      map - a 2D char array that will be modified
      toWrite - the char to use where this GreasedRegion stores an "on" cell
      Returns:
      map, with the changes applied; not a copy
    • or

      public GreasedRegion or​(GreasedRegion other)
      Union of two GreasedRegions, assigning the result into this GreasedRegion. Any cell that is "on" in either GreasedRegion will be made "on" in this GreasedRegion.
      Parameters:
      other - another GreasedRegion that will not be modified
      Returns:
      this, after modification, for chaining
    • and

      public GreasedRegion and​(GreasedRegion other)
      Intersection of two GreasedRegions, assigning the result into this GreasedRegion. Any cell that is "on" in both GreasedRegions will be kept "on" in this GreasedRegion, but all other cells will be made "off."
      Parameters:
      other - another GreasedRegion that will not be modified
      Returns:
      this, after modification, for chaining
    • andWrapping64

      Intersection of two GreasedRegions, assigning the result into this GreasedRegion, with the special requirement that other must be a 64x64 area, and the special property that other will be considered tiled to cover all of the area of this GreasedRegion. Any cell that is "on" in both GreasedRegions (treating other as tiling) will be kept "on" in this GreasedRegion, but all other cells will be made "off."
      Parameters:
      other - another GreasedRegion that will not be modified but must be 64x64 in size; will act as if it tiles
      Returns:
      this, after modification, for chaining
    • andNot

      public GreasedRegion andNot​(GreasedRegion other)
      Difference of two GreasedRegions, assigning the result into this GreasedRegion. Any cell that is "on" in this GreasedRegion and "off" in other will be kept "on" in this GreasedRegion, but all other cells will be made "off."
      Parameters:
      other - another GreasedRegion that will not be modified
      Returns:
      this, after modification, for chaining
      See Also:
      notAnd is a very similar method that acts sort-of in reverse of this method
    • notAnd

      public GreasedRegion notAnd​(GreasedRegion other)
      Like andNot, but subtracts this GreasedRegion from other and stores the result in this GreasedRegion, without mutating other.
      Parameters:
      other - another GreasedRegion that will not be modified
      Returns:
      this, after modification, for chaining
      See Also:
      andNot is a very similar method that acts sort-of in reverse of this method
    • xor

      public GreasedRegion xor​(GreasedRegion other)
      Symmetric difference (more commonly known as exclusive or, hence the name) of two GreasedRegions, assigning the result into this GreasedRegion. Any cell that is "on" in this and "off" in other, or "off" in this and "on" in other, will be made "on" in this; all other cells will be made "off." Useful to find cells that are "on" in exactly one of two GreasedRegions (not "on" in both, or "off" in both).
      Parameters:
      other - another GreasedRegion that will not be modified
      Returns:
      this, after modification, for chaining
    • not

      public GreasedRegion not()
      Negates this GreasedRegion, turning "on" to "off" and "off" to "on."
      Returns:
      this, after modification, for chaining
    • translate

      public GreasedRegion translate​(int x, int y)
      Moves the "on" cells in this GreasedRegion to the given x and y offset, removing cells that move out of bounds.
      Specified by:
      translate in interface Zone
      Overrides:
      translate in class Zone.Skeleton
      Parameters:
      x - the x offset to translate by; can be negative
      y - the y offset to translate by; can be negative
      Returns:
      this for chaining
    • insertTranslation

      public GreasedRegion insertTranslation​(int x, int y)
      Adds to this GreasedRegion with a moved set of its own "on" cells, moved to the given x and y offset. Ignores cells that would be added out of bounds. Keeps all cells that are currently "on" unchanged.
      Parameters:
      x - the x offset to translate by; can be negative
      y - the y offset to translate by; can be negative
      Returns:
      this for chaining
    • zoom

      public GreasedRegion zoom​(int x, int y)
      Effectively doubles the x and y values of each cell this contains (not scaling each cell to be larger, so each "on" cell will be surrounded by "off" cells), and re-maps the positions so the given x and y in the doubled space become 0,0 in the resulting GreasedRegion (which is this, assigning to itself).
      Parameters:
      x - in the doubled coordinate space, the x position that should become 0 x in the result; can be negative
      y - in the doubled coordinate space, the y position that should become 0 y in the result; can be negative
      Returns:
      this for chaining
    • connect

      Takes the pairs of "on" cells in this GreasedRegion that are separated by exactly one cell in an orthogonal line, and changes the gap cells to "on" as well.
      This method is very efficient due to how the class is implemented, and the various spatial increase/decrease methods (including expand(), retract(), fringe(), and surface()) all perform very well by operating in bulk on up to 64 cells at a time.
      Returns:
      this for chaining
    • connect8way

      Takes the pairs of "on" cells in this GreasedRegion that are separated by exactly one cell in an orthogonal or diagonal line, and changes the gap cells to "on" as well.
      This method is very efficient due to how the class is implemented, and the various spatial increase/decrease methods (including expand(), retract(), fringe(), and surface()) all perform very well by operating in bulk on up to 64 cells at a time.
      Returns:
      this for chaining
    • connectLines

      Takes the pairs of "on" cells in this GreasedRegion that are separated by exactly one cell in an orthogonal or diagonal line, and changes the gap cells to "on" as well. As a special case, this requires diagonals to either have no "on" cells adjacent along the perpendicular diagonal, or both cells on that perpendicular diagonal need to be "on." This is useful to counteract some less-desirable behavior of connect8way(), where a right angle would always get the inner corners filled because it was considered a diagonal.
      This method is very efficient due to how the class is implemented, and the various spatial increase/decrease methods (including expand(), retract(), fringe(), and surface()) all perform very well by operating in bulk on up to 64 cells at a time.
      Returns:
      this for chaining
    • thin

      public GreasedRegion thin()
      Like retract(), this reduces the width of thick areas of this GreasedRegion, but thin() will not remove areas that would be identical in a subsequent call to retract(), such as if the area would be eliminated. This is useful primarily for adjusting areas so they do not exceed a width of 2 cells, though their length (the longer of the two dimensions) will be unaffected by this. Especially wide, irregularly-shaped areas may have unintended appearances if you call this repeatedly or use thinFully(); consider using this sparingly, or primarily when an area has just gotten thicker than desired.
      This currently uses 4-way adjacency, but had previously used 8-way; if you want the behavior this previously had, you can use thin8way(), but it may be a good idea to try this method as well (some of the old behavior had problems where it yielded significantly larger minimum widths in some areas).
      Returns:
      this for chaining
    • thinFully

      Calls thin() repeatedly, until the result is unchanged from the last call. Consider using the idiom expand8way().retract().thinFully() to help change a possibly-strange appearance when the GreasedRegion this is called on touches the edges of the grid. In general, this method is likely to go too far when it tries to thin a round or irregular area, and this often results in many diagonal lines spanning the formerly-thick area.
      This currently uses 4-way adjacency, but had previously used 8-way; if you want the behavior this previously had, you can use thinFully8way(), but it may be a good idea to try this method as well (some of the old behavior had problems where it yielded significantly larger minimum widths in some areas).
      Returns:
      this for chaining
    • thin8way

      Like retract8way(), this reduces the width of thick areas of this GreasedRegion, but thin8way() will not remove areas that would be identical in a subsequent call to retract8way(), such as if the area would be eliminated. This is useful primarily for adjusting areas so they do not exceed a width of 2 cells, though their length (the longer of the two dimensions) will be unaffected by this. Especially wide, irregularly-shaped areas may have unintended appearances if you call this repeatedly or use thinFully8way(); consider using this sparingly, or primarily when an area has just gotten thicker than desired.
      This method was called thin(), but now that name refers to a variant that uses 4-way adjacency.
      Returns:
      this for chaining
    • thinFully8way

      Calls thin8way() repeatedly, until the result is unchanged from the last call. Consider using the idiom expand8way().retract().thinFully8way() to help change a strange appearance when the GreasedRegion this is called on touches the edges of the grid. In general, this method is likely to go too far when it tries to thin a round or irregular area, and this often results in many diagonal lines spanning the formerly-thick area.
      This method was called thinFully(), but now that name refers to a variant that uses 4-way adjacency.
      Returns:
      this for chaining
    • disperse

      Removes "on" cells that are orthogonally adjacent to other "on" cells, keeping at least one cell in a group "on." Uses a "checkerboard" pattern to determine which cells to turn off, with all cells that would be black on a checkerboard turned off and all others kept as-is.
      Returns:
      this for chaining
    • disperse8way

      Removes "on" cells that are 8-way adjacent to other "on" cells, keeping at least one cell in a group "on." Uses a "grid-like" pattern to determine which cells to turn off, with all cells with even x and even y kept as-is but all other cells (with either or both odd x or odd y) turned off.
      Returns:
      this for chaining
    • disperseRandom

      Removes "on" cells that are nearby other "on" cells, with a random factor to which bits are actually turned off that still ensures exactly half of the bits are kept as-is (the one exception is when height is an odd number, which makes the bottom row slightly random).
      Parameters:
      random - the RNG used for a random factor
      Returns:
      this for chaining
    • approximateBits

      public static long approximateBits​(RandomnessSource random, int bitCount)
      Generates a random 64-bit long with a number of '1' bits (Hamming weight) equal on average to bitCount. For example, calling this with a parameter of 32 will be equivalent to calling nextLong() on the given RandomnessSource, which could be an RNG or any RandomnessSource with good 64-bit generation quality. Calling this with a parameter of 16 will have on average 16 of the 64 bits in the returned long set to '1', distributed pseudo-randomly, while a parameter of 47 will have on average 47 bits set. This can be useful for certain code that uses bits to represent data but needs a different ratio of set bits to unset bits than 1:1.
      The parameter random can be an object like a DiverRNG, an RNG backed by a well-distributed RandomnessSource like its default, DiverRNG, a GWTRNG (especially if you target GWT, where it will perform much better than most alternatives), or any of various other RandomnessSource implementations that distribute bits well for RandomnessSource.nextLong(), but should not be intentionally-biased RNGs like DharmaRNG or EditRNG, nor double-based QRNGs like VanDerCorputQRNG or SobolQRNG.
      Parameters:
      random - used to determine random factors; likely to be an RNG, DiverRNG, or GWTRNG
      bitCount - an int, only considered if between 0 and 64, that is the average number of bits to set
      Returns:
      a 64-bit long that, on average, should have bitCount bits set to 1, potentially anywhere in the long
    • randomInterleave

      public static long randomInterleave​(RandomnessSource random)
      Gets a somewhat-random long with exactly 32 bits set; in each pair of bits starting at bit 0 and bit 1, then bit 2 and bit 3, up to bit 62 and bit 3, one bit will be 1 and one bit will be 0 in each pair.
      Not exactly general-use; meant for generating data for GreasedRegion.
      Returns:
      a random long with 32 "1" bits, distributed so exactly one bit is "1" for each pair of bits
    • expand

      Takes the "on" cells in this GreasedRegion and expands them by one cell in the 4 orthogonal directions, making each "on" cell take up a plus-shaped area that may overlap with other "on" cells (which is just a normal "on" cell then).
      This method is very efficient due to how the class is implemented, and the various spatial increase/decrease methods (including expand(), retract(), fringe(), and surface()) all perform very well by operating in bulk on up to 64 cells at a time.
      Returns:
      this for chaining
    • expand

      public GreasedRegion expand​(int amount)
      Takes the "on" cells in this GreasedRegion and expands them by amount cells in the 4 orthogonal directions, making each "on" cell take up a plus-shaped area that may overlap with other "on" cells (which is just a normal "on" cell then).
      This method is very efficient due to how the class is implemented, and the various spatial increase/decrease methods (including expand(), retract(), fringe(), and surface()) all perform very well by operating in bulk on up to 64 cells at a time.
      Specified by:
      expand in interface MutableZone
      Parameters:
      amount - the amount to expand outward using Manhattan distance (diamond shape)
      Returns:
      this for chaining
    • expandSeries

      public GreasedRegion[] expandSeries​(int amount)
      Takes the "on" cells in this GreasedRegion and produces amount GreasedRegions, each one expanded by 1 cell in the 4 orthogonal directions relative to the previous GreasedRegion, making each "on" cell take up a plus-shaped area that may overlap with other "on" cells (which is just a normal "on" cell then). This returns an array of GreasedRegions with progressively greater expansions, and does not modify this GreasedRegion.
      This method is very efficient due to how the class is implemented, and the various spatial increase/decrease methods (including expand(), retract(), fringe(), and surface()) all perform very well by operating in bulk on up to 64 cells at a time.
      Returns:
      an array of new GreasedRegions, length == amount, where each one is expanded by 1 relative to the last
    • expandSeriesToLimit

    • fringe

      Takes the "on" cells in this GreasedRegion and expands them by one cell in the 4 orthogonal directions, producing a diamoond shape, then removes the original area before expansion, producing only the cells that were "off" in this and within 1 cell (orthogonal-only) of an "on" cell. This method is similar to surface(), but surface finds cells inside the current GreasedRegion, while fringe finds cells outside it.
      This method is very efficient due to how the class is implemented, and the various spatial increase/decrease methods (including expand(), retract(), fringe(), and surface()) all perform very well by operating in bulk on up to 64 cells at a time. The surface and fringe methods do allocate one temporary GreasedRegion to store the original before modification, but the others generally don't.
      Returns:
      this for chaining
    • fringe

      public GreasedRegion fringe​(int amount)
      Takes the "on" cells in this GreasedRegion and expands them by amount cells in the 4 orthogonal directions (iteratively, producing a diamond shape), then removes the original area before expansion, producing only the cells that were "off" in this and within amount cells (orthogonal-only) of an "on" cell. This method is similar to surface(), but surface finds cells inside the current GreasedRegion, while fringe finds cells outside it.
      This method is very efficient due to how the class is implemented, and the various spatial increase/decrease methods (including expand(), retract(), fringe(), and surface()) all perform very well by operating in bulk on up to 64 cells at a time. The surface and fringe methods do allocate one temporary GreasedRegion to store the original before modification, but the others generally don't.
      Returns:
      this for chaining
    • fringeSeries

      public GreasedRegion[] fringeSeries​(int amount)
      Takes the "on" cells in this GreasedRegion and produces amount GreasedRegions, each one expanded by 1 cell in the 4 orthogonal directions relative to the previous GreasedRegion, making each "on" cell take up a diamond- shaped area. After producing the expansions, this removes the previous GreasedRegion from the next GreasedRegion in the array, making each "fringe" in the series have 1 "thickness," which can be useful for finding which layer of expansion a cell lies in. This returns an array of GreasedRegions with progressively greater expansions without the cells of this GreasedRegion, and does not modify this GreasedRegion.
      This method is very efficient due to how the class is implemented, and the various spatial increase/decrease methods (including expand(), retract(), fringe(), and surface()) all perform very well by operating in bulk on up to 64 cells at a time.
      Returns:
      an array of new GreasedRegions, length == amount, where each one is a 1-depth fringe pushed further out from this
    • fringeSeriesToLimit

    • retract

      Takes the "on" cells in this GreasedRegion and retracts them by one cell in the 4 orthogonal directions, making each "on" cell that was orthogonally adjacent to an "off" cell into an "off" cell.
      This method is very efficient due to how the class is implemented, and the various spatial increase/decrease methods (including expand(), retract(), fringe(), and surface()) all perform very well by operating in bulk on up to 64 cells at a time.
      Returns:
      this for chaining
    • retract

      public GreasedRegion retract​(int amount)
      Takes the "on" cells in this GreasedRegion and retracts them by one cell in the 4 orthogonal directions, doing this iteeratively amount times, making each "on" cell that was within amount orthogonal distance to an "off" cell into an "off" cell.
      This method is very efficient due to how the class is implemented, and the various spatial increase/decrease methods (including expand(), retract(), fringe(), and surface()) all perform very well by operating in bulk on up to 64 cells at a time.
      Returns:
      this for chaining
    • retractSeries

      public GreasedRegion[] retractSeries​(int amount)
    • retractSeriesToLimit

    • surface

    • surface

      public GreasedRegion surface​(int amount)
    • surfaceSeries

      public GreasedRegion[] surfaceSeries​(int amount)
    • surfaceSeriesToLimit

    • expand8way

    • expand8way

      public GreasedRegion expand8way​(int amount)
      Description copied from interface: MutableZone
      Expands this Zone in the four cardinal and four diagonal directions, performing the expansion consecutively distance times. Modified this Zone in-place and returns it for chaining.
      Specified by:
      expand8way in interface MutableZone
      Parameters:
      amount - the amount to expand outward using Chebyshev distance (square shape)
      Returns:
      this for chaining, after being modified in-place
    • expandSeries8way

      public GreasedRegion[] expandSeries8way​(int amount)
    • expandSeriesToLimit8way

    • fringe8way

    • fringe8way

      public GreasedRegion fringe8way​(int amount)
    • fringeSeries8way

      public GreasedRegion[] fringeSeries8way​(int amount)
    • fringeSeriesToLimit8way

    • retract8way

    • retract8way

      public GreasedRegion retract8way​(int amount)
    • retractSeries8way

      public GreasedRegion[] retractSeries8way​(int amount)
    • retractSeriesToLimit8way

    • surface8way

    • surface8way

      public GreasedRegion surface8way​(int amount)
    • surfaceSeries8way

      public GreasedRegion[] surfaceSeries8way​(int amount)
    • surfaceSeriesToLimit8way

    • flood

      public GreasedRegion flood​(GreasedRegion bounds)
      Like expand(), but limits expansion to the "on" cells of bounds. Expands in all 4-way directions by one cell simultaneously, and only successfully affects the cells that are adjacent to this and are in bounds.
      Parameters:
      bounds - the set of "on" cells that limits where this can expand into
      Returns:
      this, after expanding, for chaining
    • flood

      public GreasedRegion flood​(GreasedRegion bounds, int amount)
      Like expand(int), but limits expansion to the "on" cells of bounds. Repeatedly expands in the 4-way directions by one cell simultaneously, and only successfully affects the cells that are adjacent to the previous expansion and are in bounds. This won't skip over gaps in bounds, even if amount is high enough that a call to expand(int) would reach past the gap; it will stop at the gap and only pass it if expansion takes it around.
      Parameters:
      bounds - the set of "on" cells that limits where this can expand into
      amount - how far to expand this outward by, in cells
      Returns:
      this, after expanding, for chaining
    • floodSeries

      public GreasedRegion[] floodSeries​(GreasedRegion bounds, int amount)
      Repeatedly calls flood(GreasedRegion) amount times and returns the intermediate steps in a GreasedRegion array of size amount. Doesn't modify this GreasedRegion, and doesn't return it in the array (it may return a copy of it if and only if no flood8way() calls can expand the area). If this fills bounds as fully as possible and still has steps left, the remaining steps are all copies of the fully-filled area.
      Parameters:
      bounds - the set of "on" cells that this will attempt to fill in steps
      amount - how many steps to flood outward, and the size of the array to return
      Returns:
      an array of GreasedRegion, amount in size, containing larger and larger expansions of this
    • floodSeriesToLimit

      Repeatedly generates new GreasedRegions, each one cell expanded in 4 directions from the previous GreasedRegion and staying inside the "on" cells of bounds, until it can't expand any more. Returns an ArrayList of the GreasedRegion steps this generated; this list does not include this GreasedRegion (or any unmodified copy of this GreasedRegion), and this method does not modify it.
      Parameters:
      bounds - the set of "on" cells that this will attempt to fill in steps
      Returns:
      an ArrayList of steps from one flood(GreasedRegion) call to possibly many chained after it
    • flood8way

      Like expand8way(), but limits expansion to the "on" cells of bounds. Expands in all directions by one cell simultaneously, and only successfully affects the cells that are adjacent to this and are in bounds.
      Parameters:
      bounds - the set of "on" cells that limits where this can expand into
      Returns:
      this, after expanding, for chaining
    • flood8way

      public GreasedRegion flood8way​(GreasedRegion bounds, int amount)
      Like expand8way(int), but limits expansion to the "on" cells of bounds. Repeatedly expands in all directions by one cell simultaneously, and only successfully affects the cells that are adjacent to the previous expansion and are in bounds. This won't skip over gaps in bounds, even if amount is high enough that a call to expand8way(int) would reach past the gap; it will stop at the gap and only pass it if expansion takes it around.
      Parameters:
      bounds - the set of "on" cells that limits where this can expand into
      amount - how far to expand this outward by, in cells
      Returns:
      this, after expanding, for chaining
    • floodSeries8way

      public GreasedRegion[] floodSeries8way​(GreasedRegion bounds, int amount)
      Repeatedly calls flood8way(GreasedRegion) amount times and returns the intermediate steps in a GreasedRegion array of size amount. Doesn't modify this GreasedRegion, and doesn't return it in the array (it may return a copy of it if and only if no flood8way() calls can expand the area). If this fills bounds as fully as possible and still has steps left, the remaining steps are all copies of the fully-filled area.
      Parameters:
      bounds - the set of "on" cells that this will attempt to fill in steps
      amount - how many steps to flood outward, and the size of the array to return
      Returns:
      an array of GreasedRegion, amount in size, containing larger and larger expansions of this
    • floodSeriesToLimit8way

      Repeatedly generates new GreasedRegions, each one cell expanded in 8 directions from the previous GreasedRegion and staying inside the "on" cells of bounds, until it can't expand any more. Returns an ArrayList of the GreasedRegion steps this generated; this list does not include this GreasedRegion (or any unmodified copy of this GreasedRegion), and this method does not modify it.
      Parameters:
      bounds - the set of "on" cells that this will attempt to fill in steps
      Returns:
      an ArrayList of steps from one flood8way(GreasedRegion) call to possibly many chained after it
    • spill

      public GreasedRegion spill​(GreasedRegion bounds, int volume, IRNG rng)
      A randomized flood-fill that modifies this GreasedRegion so it randomly adds adjacent cells while staying inside the "on" cells of bounds, until size() is equal to volume or there are no more cells this can expand into. This GreasedRegion acts as the initial state, and often contains just one cell before this is called. This method is useful for imitating the movement of fluids like water or smoke within some boundaries.
      Parameters:
      bounds - this GreasedRegion will only expand to cells that are "on" in bounds; bounds should overlap with this
      volume - the maximum size() this GreasedRegion can reach before this stops expanding
      rng - a random number generator, like RNG or GWTRNG
      Returns:
      this, after expanding randomly, for chaining
    • removeCorners

      Where a cell is "on" but forms a right-angle with exactly two orthogonally-adjacent "on" cells and exactly two orthogonally-adjacent "off" cells, this turns each of those cells "off." This won't affect east-west lines of flat "on" cells, nor north-south lines.
      Returns:
      this, after removing right-angle corner "on" cells, for chaining
    • split

      If this GreasedRegion stores multiple unconnected "on" areas, this finds each isolated area (areas that are only adjacent diagonally are considered separate from each other) and returns it as an element in an ArrayList of GreasedRegion, with one GreasedRegion per isolated area. Not to be confused with split8way(), which considers diagonally-adjacent cells as part of one region, while this method requires cells to be orthogonally adjacent.
      Useful when you have, for example, all the rooms in a dungeon with their connecting corridors removed, but want to separate the rooms. You can get the aforementioned data assuming a bare dungeon called map using:
      GreasedRegion floors = new GreasedRegion(map, '.'), rooms = floors.copy().retract8way().flood(floors, 2), corridors = floors.copy().andNot(rooms), doors = rooms.copy().and(corridors.copy().fringe());
      You can then get all rooms as separate regions with List<GreasedRegion> apart = split(rooms);, or substitute split(corridors) to get the corridors. The room-finding technique works by shrinking floors by a radius of 1 (8-way), which causes thin areas like corridors of 2 or less width to be removed, then flood-filling the floors out from the area that produces by 2 cells (4-way this time) to restore the original size of non-corridor areas (plus some extra to ensure odd shapes are kept). Corridors are obtained by removing the rooms from floors. The example code also gets the doors (which overlap with rooms, not corridors) by finding where the a room and a corridor are adjacent. This technique is used with some enhancements in the RoomFinder class.
      Returns:
      an ArrayList containing each unconnected area from packed as a GreasedRegion element
      See Also:
      for a class that uses this technique without exposing GreasedRegion
    • split8way

      If this GreasedRegion stores multiple unconnected "on" areas, this finds each isolated area (areas that are only adjacent diagonally are considered one area with this) and returns it as an element in an ArrayList of GreasedRegion, with one GreasedRegion per isolated area. This should not be confused with split(), which is almost identical except that split() considers only orthogonal connections, while this method considers both orthogonal and diagonal connections between cells as joining an area.
      Useful when you have, for example, all the rooms in a dungeon with their connecting corridors removed, but want to separate the rooms. You can get the aforementioned data assuming a bare dungeon called map using:
      GreasedRegion floors = new GreasedRegion(map, '.'), rooms = floors.copy().retract8way().flood(floors, 2), corridors = floors.copy().andNot(rooms), doors = rooms.copy().and(corridors.copy().fringe());
      You can then get all rooms as separate regions with List<GreasedRegion> apart = split(rooms);, or substitute split(corridors) to get the corridors. The room-finding technique works by shrinking floors by a radius of 1 (8-way), which causes thin areas like corridors of 2 or less width to be removed, then flood-filling the floors out from the area that produces by 2 cells (4-way this time) to restore the original size of non-corridor areas (plus some extra to ensure odd shapes are kept). Corridors are obtained by removing the rooms from floors. The example code also gets the doors (which overlap with rooms, not corridors) by finding where the a room and a corridor are adjacent. This technique is used with some enhancements in the RoomFinder class.
      Returns:
      an ArrayList containing each unconnected area from packed as a GreasedRegion element
      See Also:
      for a class that uses this technique without exposing GreasedRegion
    • largestPart

      Finds the largest contiguous area of "on" cells in this GreasedRegion and returns it; does not modify this GreasedRegion. If there are multiple areas that are all equally large with no larger area, this returns the region it checks first and still is largest (first determined by the same ordering nth(int) takes). This may return an empty GreasedRegion if there are no "on" cells, but it will never return null. Here, contiguous means adjacent on an orthogonal direction, and this doesn't consider diagonally-connected cells as contiguous unless they also have an orthogonal connection.
      Returns:
      a new GreasedRegion that corresponds to the largest contiguous sub-region of "on" cells in this.
    • largestPart8way

      Finds the largest contiguous area of "on" cells in this GreasedRegion and returns it; does not modify this GreasedRegion. If there are multiple areas that are all equally large with no larger area, this returns the region it checks first and still is largest (first determined by the same ordering nth(int) takes). This may return an empty GreasedRegion if there are no "on" cells, but it will never return null. Here, contiguous means adjacent on any 8-way direction, and considers cells as part of a contiguous area even if all connections but one, which can be orthogonal or diagonal, are blocked by "off" cells.
      Returns:
      a new GreasedRegion that corresponds to the largest contiguous sub-region of "on" cells in this.
    • neighborUp

      Modifies this GreasedRegion so the only cells that will be "on" have a neighbor upwards when this is called. Up is defined as negative y. Neighbors are "on" cells exactly one cell away. A cell can have a neighbor without itself being on; this is useful when finding the "shadow" cast away from "on" cells in one direction.
      Returns:
      this, after modifications, for chaining
    • neighborDown

      Modifies this GreasedRegion so the only cells that will be "on" have a neighbor downwards when this is called. Down is defined as positive y. Neighbors are "on" cells exactly one cell away. A cell can have a neighbor without itself being on; this is useful when finding the "shadow" cast away from "on" cells in one direction.
      Returns:
      this, after modifications, for chaining
    • neighborLeft

      Modifies this GreasedRegion so the only cells that will be "on" have a neighbor to the left when this is called. Left is defined as negative x. Neighbors are "on" cells exactly one cell away. A cell can have a neighbor without itself being on; this is useful when finding the "shadow" cast away from "on" cells in one direction.
      Returns:
      this, after modifications, for chaining
    • neighborRight

      Modifies this GreasedRegion so the only cells that will be "on" have a neighbor to the right when this is called. Right is defined as positive x. Neighbors are "on" cells exactly one cell away. A cell can have a neighbor without itself being on; this is useful when finding the "shadow" cast away from "on" cells in one direction.
      Returns:
      this, after modifications, for chaining
    • neighborUpLeft

      Modifies this GreasedRegion so the only cells that will be "on" have a neighbor upwards and to the left when this is called. Up is defined as negative y, left as negative x. Neighbors are "on" cells exactly one cell away. A cell can have a neighbor without itself being on; this is useful when finding the "shadow" cast away from "on" cells in one direction.
      Returns:
      this, after modifications, for chaining
    • neighborUpRight

      Modifies this GreasedRegion so the only cells that will be "on" have a neighbor upwards and to the right when this is called. Up is defined as negative y, right as positive x. Neighbors are "on" cells exactly one cell away. A cell can have a neighbor without itself being on; this is useful when finding the "shadow" cast away from "on" cells in one direction.
      Returns:
      this, after modifications, for chaining
    • neighborDownLeft

      Modifies this GreasedRegion so the only cells that will be "on" have a neighbor downwards and to the left when this is called. Down is defined as positive y, left as negative x. Neighbors are "on" cells exactly one cell away. A cell can have a neighbor without itself being on; this is useful when finding the "shadow" cast away from "on" cells in one direction.
      Returns:
      this, after modifications, for chaining
    • neighborDownRight

      Modifies this GreasedRegion so the only cells that will be "on" have a neighbor downwards and to the right when this is called. Down is defined as positive y, right as positive x. Neighbors are "on" cells exactly one cell away. A cell can have a neighbor without itself being on; this is useful when finding the "shadow" cast away from "on" cells in one direction.
      Returns:
      this, after modifications, for chaining
    • removeIsolated

    • intersects

      public boolean intersects​(GreasedRegion other)
      Returns true if any cell is "on" in both this GreasedRegion and in other; returns false otherwise. For example, if (1,1) is "on" in this and (1,1) is "on" in other, this would return true, regardless of other cells.
      Parameters:
      other - another GreasedRegion; its size does not have to match this GreasedRegion's size
      Returns:
      true if this shares any "on" cells with other
    • whichContain

      public static OrderedSet<GreasedRegion> whichContain​(int x, int y, GreasedRegion... packed)
    • whichContain

      public static OrderedSet<GreasedRegion> whichContain​(int x, int y, Collection<GreasedRegion> packed)
    • appendContaining

      public static Collection<GreasedRegion> appendContaining​(Collection<GreasedRegion> into, int x, int y, GreasedRegion... packed)
      Tries to look up the position x,y in each GreasedRegion in packed; each GreasedRegion that contains that x,y point is appended into the Collection into.
      Parameters:
      into - a Collection of GreasedRegion that will be modified if this succeeds
      x - the x-coordinate to look up
      y - the y-coordinate to look up
      packed - the array or varargs of GreasedRegion to try to look up the given position in
      Returns:
      into, potentially modified
    • appendContaining

      public static Collection<GreasedRegion> appendContaining​(Collection<GreasedRegion> into, int x, int y, Collection<GreasedRegion> packed)
      Tries to look up the position x,y in each GreasedRegion in packed; each GreasedRegion that contains that x,y point is appended into the Collection into.
      Parameters:
      into - a Collection of GreasedRegion that will be modified if this succeeds
      x - the x-coordinate to look up
      y - the y-coordinate to look up
      packed - the Collection of GreasedRegion to try to look up the given position in
      Returns:
      into, potentially modified
    • size

      public int size()
      Specified by:
      size in interface Collection<Coord>
      Specified by:
      size in interface Zone
      Overrides:
      size in class Zone.Skeleton
      Returns:
      The number of cells that this zone contains (the size Zone.getAll()).
    • fit

      public Coord fit​(double xFraction, double yFraction)
    • fit

      public int[][] fit​(int[][] basis, int defaultValue)
    • separatedPortion

      public Coord[] separatedPortion​(double fraction)
      Don't use this in new code; prefer mixedRandomSeparated(double), quasiRandomSeparated(double), or separatedZCurve(double). This method has issues with being unable to fill the requested fraction, but the others mentioned don't. See their documentation for what all these group of methods do.
      Parameters:
      fraction - between 0.0 and 1.0
      Returns:
      a Coord array that may not have the full fraction used; you have been advised
    • randomSeparated

      public Coord[] randomSeparated​(double fraction, IRNG rng)
      Don't use this in new code; prefer mixedRandomSeparated(double, int, long) with a random long as the last parameter. This method has issues with being unable to fill the requested fraction, but mixedRandomSeparated does not. See its documentation for what this method is supposed to do.
      Parameters:
      fraction - between 0.0 and 1.0
      rng - an IRNG that will be used to get a random starting point in the Sobol sequence this uses internally
      Returns:
      a Coord array that may not have the full fraction used; you have been advised
    • randomSeparated

      public Coord[] randomSeparated​(double fraction, IRNG rng, int limit)
      Don't use this in new code; prefer mixedRandomSeparated(double, int, long) with a random long as the last parameter. This method has issues with being unable to fill the requested fraction, but mixedRandomSeparated does not. See its documentation for what this method is supposed to do.
      Parameters:
      fraction - between 0.0 and 1.0
      rng - an IRNG that will be used to get a random starting point in the Sobol sequence this uses internally
      limit - how many Coord values this should return, at most; typically this will return less
      Returns:
      a Coord array that may not have the full fraction used; you have been advised
    • mixedRandomSeparated

      public Coord[] mixedRandomSeparated​(double fraction)
      Gets a Coord array from the "on" contents of this GreasedRegion, using a deterministic but random-seeming scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this. This is pseudo-random with a fixed seed, but is very good at avoiding overlap (just as good as separatedRegionZCurve(double, int), and probably faster). If you request too many cells (too high of a value for fraction), it will start to overlap, but a fraction value of 0.4 reliably has had no overlap in testing. Does not restrict the size of the returned array other than only using up to fraction * size() cells.
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      Returns:
      a freshly-allocated Coord array containing the quasi-random cells
    • mixedRandomSeparated

      public Coord[] mixedRandomSeparated​(double fraction, int limit)
      Gets a Coord array from the "on" contents of this GreasedRegion, using a deterministic but random-seeming scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this. This is pseudo-random with a fixed seed, but is very good at avoiding overlap (just as good as separatedRegionZCurve(double, int), and probably faster). If you request too many cells (too high of a value for fraction), it will start to overlap, but a fraction value of 0.4 reliably has had no overlap in testing. Restricts the total size of the returned array to a maximum of limit (minimum is 0 if no cells are "on"). If limit is negative, this will not restrict the size.
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      limit - the maximum size of the array to return
      Returns:
      a freshly-allocated Coord array containing the pseudo-random cells
    • mixedRandomSeparated

      public Coord[] mixedRandomSeparated​(double fraction, int limit, long seed)
      Gets a Coord array from the "on" contents of this GreasedRegion, using a deterministic but random-seeming scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this. This is pseudo-random with the given seed (which will be made into an odd number if it is not one already), and is very good at avoiding overlap (just as good as separatedZCurve(double, int), and probably faster). If you request too many cells (too high of a value for fraction), it will start to overlap, but a fraction value of 0.4 reliably has had no overlap in testing. Restricts the total size of the returned array to a maximum of limit (minimum is 0 if no cells are "on"). If limit is negative, this will not restrict the size.
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      limit - the maximum size of the array to return
      seed - a long seed to change the points; the most significant 21 bits (except the sign bit) and least significant bit are ignored
      Returns:
      a freshly-allocated Coord array containing the pseudo-random cells
    • mixedRandomRegion

      public GreasedRegion mixedRandomRegion​(double fraction)
      Modifies this GreasedRegion so it contains a deterministic but random-seeming subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this. This is pseudo-random with a fixed seed, and is very good at avoiding overlap (just as good as separatedRegionZCurve(double, int), and probably faster). If you request too many cells (too high of a value for fraction), it will start to overlap, but a fraction value of 0.4 reliably has had no overlap in testing. Does not restrict the count of "on" cells after this returns other than by only using up to fraction * size() cells.
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      Returns:
      this for chaining
    • mixedRandomRegion

      public GreasedRegion mixedRandomRegion​(double fraction, int limit)
      Modifies this GreasedRegion so it contains a deterministic but random-seeming subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this. This is pseudo-random with a fixed seed, and is very good at avoiding overlap (just as good as separatedRegionZCurve(double, int), and probably faster). If you request too many cells (too high of a value for fraction), it will start to overlap, but a fraction value of 0.4 reliably has had no overlap in testing. Restricts the total count of "on" cells after this returns to a maximum of limit (minimum is 0 if no cells are "on"). If limit is negative, this will not restrict the count.
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      limit - the maximum count of "on" cells to keep
      Returns:
      this for chaining
    • mixedRandomRegion

      public GreasedRegion mixedRandomRegion​(double fraction, int limit, long seed)
      Modifies this GreasedRegion so it contains a deterministic but random-seeming subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this. This is pseudo-random with the given seed (which will be made into an odd number if it is not one already), and is very good at avoiding overlap (just as good as separatedZCurve(double, int), and probably faster). If you request too many cells (too high of a value for fraction), it will start to overlap, but a fraction value of 0.4 reliably has had no overlap in testing. Restricts the total count of "on" cells after this returns to a maximum of limit (minimum is 0 if no cells are "on"). If limit is negative, this will not restrict the count.
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      limit - the maximum count of "on" cells to keep
      Returns:
      this for chaining
    • quasiRandomSeparated

      public Coord[] quasiRandomSeparated​(double fraction)
      Gets a Coord array from the "on" contents of this GreasedRegion, using a quasi-random scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this. This is quasi- random instead of pseudo-random because it is somewhat less likely to produce nearby cells in the result. If you request too many cells (too high of a value for fraction), it will start to overlap, however. Does not restrict the size of the returned array other than only using up to fraction * size() cells.
      You can choose between mixedRandomSeparated(double), separatedZCurve(double), separatedBlue(double), and this method, where all are quasi-random, mixedRandom and separatedBlue are probably fastest, ZCurve and separatedBlue may have better 2-dimensional gaps between cells, and this method is somewhere in the middle.
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      Returns:
      a freshly-allocated Coord array containing the quasi-random cells
    • quasiRandomSeparated

      public Coord[] quasiRandomSeparated​(double fraction, int limit)
      Gets a Coord array from the "on" contents of this GreasedRegion, using a quasi-random scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this. This is quasi- random instead of pseudo-random because it is somewhat less likely to produce nearby cells in the result. If you request too many cells (too high of a value for fraction), it will start to overlap, however. Restricts the total size of the returned array to a maximum of limit (minimum is 0 if no cells are "on"). If limit is negative, this will not restrict the size.
      You can choose between mixedRandomSeparated(double), separatedZCurve(double), separatedBlue(double), and this method, where all are quasi-random, mixedRandom and separatedBlue are probably fastest, ZCurve and separatedBlue may have better 2-dimensional gaps between cells, and this method is somewhere in the middle.
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      limit - the maximum size of the array to return
      Returns:
      a freshly-allocated Coord array containing the quasi-random cells
    • quasiRandomRegion

      public GreasedRegion quasiRandomRegion​(double fraction)
      Modifies this GreasedRegion so it contains a quasi-random subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this. This is quasi- random instead of pseudo-random because it is somewhat less likely to produce nearby cells in the result. If you request too many cells (too high of a value for fraction), it will start to overlap, however. Does not restrict the count of "on" cells after this returns other than by only using up to fraction * size() cells.
      You can choose between mixedRandomRegion(double), separatedRegionZCurve(double), separatedRegionBlue(double), and this method, where all are quasi-random, mixedRandom and separatedRegionBlue are probably fastest, ZCurve and separatedRegionBlue may have better 2-dimensional gaps between cells, and this method is somewhere in the middle.
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      Returns:
      this for chaining
    • quasiRandomRegion

      public GreasedRegion quasiRandomRegion​(double fraction, int limit)
      Modifies this GreasedRegion so it contains a quasi-random subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this. This is quasi- random instead of pseudo-random because it is somewhat less likely to produce nearby cells in the result. If you request too many cells (too high of a value for fraction), it will start to overlap, however. Restricts the total count of "on" cells after this returns to a maximum of limit (minimum is 0 if no cells are "on"). If limit is negative, this will not restrict the count.
      You can choose between mixedRandomRegion(double), separatedRegionZCurve(double), separatedRegionBlue(double), and this method, where all are quasi-random, mixedRandom and separatedRegionBlue are probably fastest, ZCurve and separatedRegionBlue may have better 2-dimensional gaps between cells, and this method is somewhere in the middle.
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      limit - the maximum count of "on" cells to keep
      Returns:
      this for chaining
    • fray

      public GreasedRegion fray​(double fractionKept)
      Like retract(), this removes the "on" cells that are 4-way-adjacent to any "off" cell, but unlike that method it keeps a fraction of those surface cells, quasi-randomly selecting them. This can be thought of as running surface() on a copy of this GreasedRegion, running quasiRandomRegion(double) on that surface with the given fractionKept, taking the original GreasedRegion and removing its whole surface with retract(), then inserting the quasi-randomly-removed surface into this GreasedRegion to replace its surface with a randomly "damaged" one.
      Parameters:
      fractionKept - the fraction between 0.0 and 1.0 of how many cells on the outer surface of this to keep "on"
      Returns:
      this for chaining
    • randomScatter

      public GreasedRegion randomScatter​(IRNG rng, int minimumDistance)
      Modifies this GreasedRegion so it contains a random subset of its previous contents, choosing cells so that the distance between any two "on" cells is at least minimumDistance, with at least one cell as "on" if any were "on" in this originally. Does not limit the count of "on" cells in the result.
      Parameters:
      rng - used to generate random positions
      minimumDistance - the minimum distance between "on" cells in the result
      Returns:
      this for chaining
    • randomScatter

      public GreasedRegion randomScatter​(IRNG rng, int minimumDistance, int limit)
      Modifies this GreasedRegion so it contains a random subset of its previous contents, choosing cells so that the distance between any two "on" cells is at least minimumDistance, with at least one cell as "on" if any were "on" in this originally. Restricts the total count of "on" cells after this returns to a maximum of limit (minimum is 0 if no cells are "on"). If limit is negative, this will not restrict the count.
      Parameters:
      rng - used to generate random positions
      minimumDistance - the minimum distance between "on" cells in the result
      limit - the maximum count of "on" cells to keep
      Returns:
      this for chaining
    • rateDensity

      public double rateDensity()
    • rateRegularity

      public double rateRegularity()
    • perceptualHashQuick

      public void perceptualHashQuick​(long[] into, int[] working)
      Calculates a perceptual hash for this GreasedRegion using a method that is only precise for some sizes of GreasedRegion; it writes a result to into, and uses working as a temporary buffer. The lengths of into and working should be related; if into is length 1, then working should be length 64, and though the hash won't be very detailed, it will work well for images with width and height that are multiples of 8; if into is length 4, then working should be length 256, and this will work with more detail on images that have width and height that are multiples of 16. If working is null or is too small, then this won't reuse it and will allocate an appropriately-sized array for internal use.
      Ported from https://github.com/commonsmachinery/blockhash/blob/master/blockhash.c , which is MIT-licensed.
      Parameters:
      into - should be a long array of length 1 or 4; the contents don't matter and this will be where output is written to
      working - should be an int array of length 64 (if into has length 1) or 256 (if into has length 4); may be null if you like garbage collection
    • asCoords

      public Coord[] asCoords()
    • asCoords

      public Coord[] asCoords​(Coord[] points)
    • asEncoded

      public int[] asEncoded()
    • asTightEncoded

      public int[] asTightEncoded()
    • getAll

      public List<Coord> getAll()
      Specified by:
      getAll in interface Zone
      Returns:
      All cells in this zone.
    • first

      public Coord first()
      Gets the first Coord in the iteration order, or (-1,-1) if this GreasedRegion is empty.
      Returns:
      the first Coord in the iteration order, or (-1,-1) if this GreasedRegion is empty
    • firstTight

      public int firstTight()
    • last

      public Coord last()
      Gets the last Coord in the iteration order, or (-1,-1) if this GreasedRegion is empty.
      Returns:
      the last Coord in the iteration order, or (-1,-1) if this GreasedRegion is empty
    • lastTight

      public int lastTight()
    • nth

      public Coord nth​(int index)
    • atFraction

      public Coord atFraction​(double fraction)
    • atFractionTight

      public int atFractionTight​(double fraction)
    • singleRandom

      public Coord singleRandom​(IRNG rng)
      Gets a single random Coord from the "on" positions in this GreasedRegion, or the Coord (-1,-1) if this is empty. Uses the given IRNG to generate one random int, which is used as an index. The technique this uses to iterate over bits can be credited to Erling Ellingsen and Daniel Lemire, found here, and seems to be a little faster than the previous method. The fastest way to get a random Coord from a GreasedRegion is to avoid iterating over the bits at all, so if your region data doesn't change you should get it as a Coord array with asCoords() and call IRNG.getRandomElement(Object[]) with that array as the parameter. If you take the asCoords() call out of consideration, getting random elements out of an array (especially a large one) can be hundreds of times faster.
      Parameters:
      rng - an IRNG such as an RNG or GWTRNG
      Returns:
      a single randomly-chosen Coord from the "on" positions in this GreasedRegion, or (-1,-1) if empty
    • singleRandomTight

      public int singleRandomTight​(IRNG rng)
    • interleaveBits

      public static int interleaveBits​(int x, int y)
      Narrow-purpose; takes an x and a y value, each between 0 and 65535 inclusive, and interleaves their bits so the least significant bit and every other bit after it are filled with the bits of x, while the second-least-significant bit and every other bit after that are filled with the bits of y. Essentially, this takes two numbers with bits labeled like a b c for x and R S T for y and makes a number with those bits arranged like R a S b T c.
      Parameters:
      x - an int between 0 and 65535, inclusive
      y - an int between 0 and 65535, inclusive
      Returns:
      an int that interleaves x and y, with x in the least significant bit position
    • disperseBits

      public static int disperseBits​(int n)
      Narrow-purpose; takes an int that represents a distance down the Z-order curve and moves its bits around so that its x component is stored in the bottom 16 bits (use (n & 0xffff) to obtain) and its y component is stored in the upper 16 bits (use (n >>> 16) to obtain). This may be useful for ordering traversals of all points in a GreasedRegion less predictably.
      Parameters:
      n - an int that has already been interleaved, though this can really be any int
      Returns:
      an int with x in its lower bits (x = n & 0xffff;) and y in its upper bits (y = n >>> 16;)
    • nthZCurve

      public Coord nthZCurve​(int index)
      Like nth(int), this gets the Coord at a given index along a path through the GreasedRegion, but unlike nth(), this traverses the path in a zig-zag pattern called the Z-Order Curve. This method is often not very fast compared to nth(), but this different path can help if iteration needs to seem less regular while still covering all "on" cells in the GresedRegion eventually.
      Parameters:
      index - the distance along the Z-order curve to travel, only counting "on" cells in this GreasedRegion.
      Returns:
      the Coord at the given distance, or the Coord with x and y both -1 if index is too high or low
    • nthZCurveTight

      public int nthZCurveTight​(int index)
      Like nth(int), this finds a given index along a path through the GreasedRegion, but unlike nth(), this traverses the path in a zig-zag pattern called the Z-Order Curve, and unlike nthZCurve(int), this does not return a Coord and instead produces a "tight"-encoded int. This method is often not very fast compared to nth(), but this different path can help if iteration needs to seem less regular while still covering all "on" cells in the GreasedRegion eventually, and the tight encoding may be handy if you need to use ints.
      Parameters:
      index - the distance along the Z-order curve to travel, only counting "on" cells in this GreasedRegion.
      Returns:
      the "tight" encoded point at the given distance, or -1 if index is too high or low
    • separatedZCurve

      public Coord[] separatedZCurve​(double fraction)
      Gets a Coord array from the "on" contents of this GreasedRegion, using a quasi-random scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this. This is quasi- random instead of pseudo-random because it is somewhat less likely to produce nearby cells in the result. If you request too many cells (too high of a value for fraction), it will start to overlap, however. Contrast with mixedRandomSeparated(double, int), which tends to overlap more frequently. This method seems to work well because it chooses quasi-random points by their index in the Z-Order Curve as opposed to the simpler approach mixedRandomSeparated uses to traverse points (which just runs through the "on" cells a column at a time, not caring if two points are in adjacent cells as long as they are in different columns). Testing with a dungeon layout of mostly-on cells, this method has no overlap with a fraction of 0.4, while mixedRandomSeparated has overlap as early as 0.15 for fraction, and it only gets worse at higher values. A change to the algorithm used by quasiRandomSeparated(double) has it overlapping at the same rate as this method, though it should be much faster. This method can be especially slow, since each Z-Order traversal may need to try many cells that are outside the GreasedRegion but are on the Z-Order Curve. Does not restrict the size of the returned array other than only using up to fraction * size() cells.
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      Returns:
      a freshly-allocated Coord array containing the quasi-random cells
    • separatedZCurve

      public Coord[] separatedZCurve​(double fraction, int limit)
      Gets a Coord array from the "on" contents of this GreasedRegion, using a quasi-random scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this. This is quasi- random instead of pseudo-random because it is somewhat less likely to produce nearby cells in the result. If you request too many cells (too high of a value for fraction), it will start to overlap, however. Contrast with mixedRandomSeparated(double, int), which tends to overlap more frequently. This method seems to work well because it chooses quasi-random points by their index in the Z-Order Curve as opposed to the simpler approach mixedRandomSeparated uses to traverse points (which just runs through the "on" cells a column at a time, not caring if two points are in adjacent cells as long as they are in different columns). Testing with a dungeon layout of mostly-on cells, this method has no overlap with a fraction of 0.4, while mixedRandomSeparated has overlap as early as 0.15 for fraction, and it only gets worse at higher values. A change to the algorithm used by quasiRandomSeparated(double, int) has it overlapping at the same rate as this method, though it should be much faster. This method can be especially slow, since each Z-Order traversal may need to try many cells that are outside the GreasedRegion but are on the Z-Order Curve. Restricts the total size of the returned array to a maximum of limit (minimum is 0 if no cells are "on"). If limit is negative, this will not restrict the size.
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      limit - the maximum size of the array to return
      Returns:
      a freshly-allocated Coord array containing the quasi-random cells
    • separatedRegionZCurve

      public GreasedRegion separatedRegionZCurve​(double fraction)
      Modifies this GreasedRegion so it contains a quasi-random subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this. This is quasi- random instead of pseudo-random because it is somewhat less likely to produce nearby cells in the result. If you request too many cells (too high of a value for fraction), it will start to overlap, however. Contrast with mixedRandomRegion(double), which tends to overlap more frequently. This method seems to work well because it chooses quasi-random points by their index in the Z-Order Curve as opposed to the simpler approach mixedRandomRegion uses to traverse points (which just runs through the "on" cells a column at a time, not caring if two points are in adjacent cells as long as they are in different columns). Testing with a dungeon layout of mostly-on cells, this method has no overlap with a fraction of 0.4, while mixedRandomRegion has overlap as early as 0.15 for fraction, and it only gets worse at higher values. A change to the algorithm used by quasiRandomRegion(double) has it overlapping at the same rate as this method, though it should be much faster. This method can be especially slow, since each Z-Order traversal may need to try many cells that are outside the GreasedRegion but are on the Z-Order Curve. Does not restrict the size of the returned array other than only using up to fraction * size() cells.
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      Returns:
      this, after modifications, for chaining
    • separatedRegionZCurve

      public GreasedRegion separatedRegionZCurve​(double fraction, int limit)
      Modifies this GreasedRegion so it contains a quasi-random subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this. This is quasi- random instead of pseudo-random because it is somewhat less likely to produce nearby cells in the result. If you request too many cells (too high of a value for fraction), it will start to overlap, however. Contrast with mixedRandomRegion(double, int), which tends to overlap more frequently. This method seems to work well because it chooses quasi-random points by their index in the Z-Order Curve as opposed to the simpler approach mixedRandomRegion uses to traverse points (which just runs through the "on" cells a column at a time, not caring if two points are in adjacent cells as long as they are in different columns). Testing with a dungeon layout of mostly-on cells, this method has no overlap with a fraction of 0.4, while mixedRandomRegion has overlap as early as 0.15 for fraction, and it only gets worse at higher values. A change to the algorithm used by quasiRandomRegion(double, int) has it overlapping at the same rate as this method, though it should be much faster. This method can be especially slow, since each Z-Order traversal may need to try many cells that are outside the GreasedRegion but are on the Z-Order Curve. Restricts the total size of the returned array to a maximum of limit (minimum is 0 if no cells are "on"). If limit is negative, this will not restrict the size.
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      limit - the maximum size of the array to return
      Returns:
      this, after modifications, for chaining
    • separatedBlue

      public Coord[] separatedBlue​(double fraction)
      Gets a Coord array from the "on" contents of this GreasedRegion, using a quasi-random scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this. This is quasi- random instead of pseudo-random because it uses blue noise to sharply limit the likelihood of nearby points being chosen when fraction is small. If you request too many cells (too high of a value for fraction), it will start to have nearby cells, however. Does not restrict the size of the returned array other than only using up to fraction * size() cells.
      Also take a look at separatedZCurve(double, int), quasiRandomSeparated(double, int), mixedRandomSeparated(double, int, long), and separatedRegionBlue(double, int). Internally, this is a thin wrapper around separatedRegionBlue(double, int), and won't be more efficient than that method.
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      Returns:
      a freshly-allocated Coord array containing the quasi-random cells
    • separatedBlue

      public Coord[] separatedBlue​(double fraction, int limit)
      Gets a Coord array from the "on" contents of this GreasedRegion, using a quasi-random scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this. This is quasi- random instead of pseudo-random because it uses blue noise to sharply limit the likelihood of nearby points being chosen when fraction is small. If you request too many cells (too high of a value for fraction), it will start to have nearby cells, however. Restricts the total size of the returned array to a maximum of limit (minimum is 0 if no cells are "on"). If limit is negative, this will not restrict the size.
      Also take a look at separatedZCurve(double, int), quasiRandomSeparated(double, int), mixedRandomSeparated(double, int, long), and separatedRegionBlue(double, int). Internally, this is a thin wrapper around separatedRegionBlue(double, int), and won't be more efficient than that method.
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      limit - the maximum size of the array to return; may return less
      Returns:
      a freshly-allocated Coord array containing the quasi-random cells
    • separatedRegionBlue

      public GreasedRegion separatedRegionBlue​(double fraction)
      Modifies this GreasedRegion so it contains a quasi-random subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this. This is quasi- random instead of pseudo-random because it uses blue noise to sharply limit the likelihood of nearby points being chosen when fraction is small. If you request too many cells (too high of a value for fraction), it will start to have nearby cells, however. Does not restrict the size of the returned GreasedRegion other than only using up to fraction * size() cells.
      Also take a look at separatedRegionZCurve(double, int), quasiRandomRegion(double, int), mixedRandomRegion(double, int, long), and separatedBlue(double, int).
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      Returns:
      this, after modifications, for chaining
    • separatedRegionBlue

      public GreasedRegion separatedRegionBlue​(double fraction, int limit)
      Modifies this GreasedRegion so it contains a quasi-random subset of its previous contents, choosing cells so that the size() matches the given fraction of the total amount of "on" cells in this. This is quasi- random instead of pseudo-random because it uses blue noise to sharply limit the likelihood of nearby points being chosen when fraction is small. If you request too many cells (too high of a value for fraction), it will start to have nearby cells, however. Restricts the total size of the returned GreasedRegion to a maximum of limit (minimum is 0 if no cells are "on"). If limit is negative, this will not restrict the size.
      Also take a look at separatedRegionZCurve(double, int), quasiRandomRegion(double, int), mixedRandomRegion(double, int, long), and separatedBlue(double, int).
      Parameters:
      fraction - the fraction of "on" cells to quasi-randomly select, between 0.0 and 1.0
      limit - the maximum size of the array to return; may return less
      Returns:
      this, after modifications, for chaining
    • randomPortion

      public Coord[] randomPortion​(IRNG rng, int size)
    • randomRegion

      public GreasedRegion randomRegion​(IRNG rng, int size)
    • contains

      public boolean contains​(int x, int y)
      Specified by:
      contains in interface Zone
      Overrides:
      contains in class Zone.Skeleton
      Returns:
      Whether this zone contains the coordinate (x,y).
    • isEmpty

      public boolean isEmpty()
      Specified by:
      isEmpty in interface Collection<Coord>
      Specified by:
      isEmpty in interface Zone
      Returns:
      Whether this zone is empty.
    • sum

      public static int[][] sum​(GreasedRegion... regions)
      Generates a 2D int array from an array or vararg of GreasedRegions, starting at all 0 and adding 1 to the int at a position once for every GreasedRegion that has that cell as "on." This means if you give 8 GreasedRegions to this method, it can produce any number between 0 and 8 in a cell; if you give 16 GreasedRegions, then it can produce any number between 0 and 16 in a cell.
      Parameters:
      regions - an array or vararg of GreasedRegions; must all have the same width and height
      Returns:
      a 2D int array with the same width and height as the regions, where an int cell equals the number of given GreasedRegions that had an "on" cell at that position
    • sum

      public static int[][] sum​(List<GreasedRegion> regions)
      Generates a 2D int array from a List of GreasedRegions, starting at all 0 and adding 1 to the int at a position once for every GreasedRegion that has that cell as "on." This means if you give 8 GreasedRegions to this method, it can produce any number between 0 and 8 in a cell; if you give 16 GreasedRegions, then it can produce any number between 0 and 16 in a cell.
      Parameters:
      regions - a List of GreasedRegions; must all have the same width and height
      Returns:
      a 2D int array with the same width and height as the regions, where an int cell equals the number of given GreasedRegions that had an "on" cell at that position
    • sumDouble

      public static double[][] sumDouble​(GreasedRegion... regions)
      Generates a 2D double array from an array or vararg of GreasedRegions, starting at all 0 and adding 1 to the double at a position once for every GreasedRegion that has that cell as "on." This means if you give 8 GreasedRegions to this method, it can produce any number between 0 and 8 in a cell; if you give 16 GreasedRegions, then it can produce any number between 0 and 16 in a cell.
      Parameters:
      regions - an array or vararg of GreasedRegions; must all have the same width and height
      Returns:
      a 2D double array with the same width and height as the regions, where an double cell equals the number of given GreasedRegions that had an "on" cell at that position
    • sumDouble

      public static double[][] sumDouble​(List<GreasedRegion> regions)
      Generates a 2D double array from a List of GreasedRegions, starting at all 0 and adding 1 to the double at a position once for every GreasedRegion that has that cell as "on." This means if you give 8 GreasedRegions to this method, it can produce any number between 0 and 8 in a cell; if you give 16 GreasedRegions, then it can produce any number between 0 and 16 in a cell.
      Parameters:
      regions - a List of GreasedRegions; must all have the same width and height
      Returns:
      a 2D double array with the same width and height as the regions, where an double cell equals the number of given GreasedRegions that had an "on" cell at that position
    • sumWeighted

      public static int[][] sumWeighted​(GreasedRegion[] regions, int[] weights)
      Generates a 2D int array from an array of GreasedRegions and an array of weights, starting the 2D result at all 0 and, for every GreasedRegion that has that cell as "on," adding the int in the corresponding weights array at the position of that cell. This means if you give an array of 4 GreasedRegions to this method along with the weights 1, 2, 3, 4, it can produce a number between 0 and 10 in a cell (where 10 is used when all 4 GreasedRegions have a cell "on," since 1 + 2 + 3 + 4 == 10); if the weights are instead 1, 10, 100, 1000, then the results can vary between 0 and 1111, where 1111 is only if all GreasedRegions have a cell as "on." The weights array must have a length at least equal to the length of the regions array.
      Parameters:
      regions - an array of GreasedRegions; must all have the same width and height
      weights - an array of ints; must have length at least equal to regions' length
      Returns:
      a 2D int array with the same width and height as the regions, where an int cell equals the sum of the weights corresponding to GreasedRegions that had an "on" cell at that position
    • sumWeightedDouble

      public static double[][] sumWeightedDouble​(GreasedRegion[] regions, double[] weights)
      Generates a 2D double array from an array of GreasedRegions and an array of weights, starting the 2D result at all 0 and, for every GreasedRegion that has that cell as "on," adding the double in the corresponding weights array at the position of that cell. This means if you give an array of 4 GreasedRegions to this method along with the weights 1, 2, 3, 4, it can produce a number between 0 and 10 in a cell (where 10 is used when all 4 GreasedRegions have a cell "on," since 1 + 2 + 3 + 4 == 10); if the weights are instead 1, 10, 100, 1000, then the results can vary between 0 and 1111, where 1111 is only if all GreasedRegions have a cell as "on." The weights array must have a length at least equal to the length of the regions array.
      Parameters:
      regions - an array of GreasedRegions; must all have the same width and height
      weights - an array of doubles; must have length at least equal to regions' length
      Returns:
      a 2D double array with the same width and height as the regions, where an double cell equals the sum of the weights corresponding to GreasedRegions that had an "on" cell at that position
    • sumInto

      public static int[][] sumInto​(int[][] existing, GreasedRegion... regions)
      Adds to an existing 2D int array with an array or vararg of GreasedRegions, adding 1 to the int in existing at a position once for every GreasedRegion that has that cell as "on." This means if you give 8 GreasedRegions to this method, it can increment by any number between 0 and 8 in a cell; if you give 16 GreasedRegions, then it can increase the value in existing by any number between 0 and 16 in a cell.
      Parameters:
      existing - a non-null 2D int array that will have each cell incremented by the sum of the GreasedRegions
      regions - an array or vararg of GreasedRegions; must all have the same width and height
      Returns:
      existing, after modification, where an int cell will be changed by the number of given GreasedRegions that had an "on" cell at that position
    • sumIntoDouble

      public static double[][] sumIntoDouble​(double[][] existing, GreasedRegion... regions)
      Adds to an existing 2D double array with an array or vararg of GreasedRegions, adding 1 to the double in existing at a position once for every GreasedRegion that has that cell as "on." This means if you give 8 GreasedRegions to this method, it can increment by any number between 0 and 8 in a cell; if you give 16 GreasedRegions, then it can increase the value in existing by any number between 0 and 16 in a cell.
      Parameters:
      existing - a non-null 2D double array that will have each cell incremented by the sum of the GreasedRegions
      regions - an array or vararg of GreasedRegions; must all have the same width and height
      Returns:
      existing, after modification, where a double cell will be changed by the number of given GreasedRegions that had an "on" cell at that position
    • dijkstraScan

      public static double[][] dijkstraScan​(char[][] map, Coord... goals)
      Discouraged from active use; slower than DijkstraMap and has less features.
      Parameters:
      map - a 2D char array where '#' is a wall
      goals - an array or vararg of Coord to get the distances toward
      Returns:
      a 2D double array of distances from a cell to the nearest goal
    • dijkstraScan8way

      public static double[][] dijkstraScan8way​(char[][] map, Coord... goals)
      Discouraged from active use; slower than DijkstraMap and has less features.
      Parameters:
      map - a 2D char array where '#' is a wall
      goals - an array or vararg of Coord to get the distances toward
      Returns:
      a 2D double array of distances from a cell to the nearest goal
    • bitSum

      public static int[][] bitSum​(GreasedRegion... regions)
      Generates a 2D int array from an array or vararg of GreasedRegions, treating each cell in the nth region as the nth bit of the int at the corresponding x,y cell in the int array. This means if you give 8 GreasedRegions to this method, it can produce any 8-bit number in a cell (0-255); if you give 16 GreasedRegions, then it can produce any 16-bit number (0-65535).
      Parameters:
      regions - an array or vararg of GreasedRegions; must all have the same width and height
      Returns:
      a 2D int array with the same width and height as the regions, with bits per int taken from the regions
    • equals

      public boolean equals​(Object o)
      Specified by:
      equals in interface Collection<Coord>
      Overrides:
      equals in class Object
    • hashCode

      public int hashCode()
      Specified by:
      hashCode in interface Collection<Coord>
      Overrides:
      hashCode in class Object
    • hash64

      public long hash64()
    • hash64

      public long hash64​(long seed)
      Computes a 64-bit hash code of this GreasedRegion given a 64-bit seed; even if given two very similar seeds, this should produce very different hash codes for the same GreasedRegion.
      Meant for potential use in Bloom filters. Uses CrossHash.Yolk's algorithm(s).
      Parameters:
      seed - a seed that will determine how the hashing algorithm works; all 64 bits are used.
      Returns:
      a 64-bit hash code for this GreasedRegion
    • serializeToString

    • deserializeFromString

    • of

      public static GreasedRegion of​(int width, int height, long... data)
      Constructs a GreasedRegion using a vararg for data. Primarily meant for generated code, since serializeToString() produces a String that happens to be a valid parameter list for this method.
      Parameters:
      width - width of the GreasedRegion to produce
      height - height of the GreasedRegion to produce
      data - array or vararg of long containing the exact data, probably from an existing GreasedRegion
      Returns:
      a new GreasedRegion with the given width, height, and data
    • toCompressedString

      Compresses this GreasedRegion into a UTF-16 String and returns the String without modifying this GreasedRegion. Uses CoordPacker's algorithm and data to compress this GreasedRegion in 256x128 blocks, storing the CoordPacker-like data as chars with values from 256 to 33023 (a concept also used in LZSEncoding), and using ASCII semicolons to separate them or store other info (just width and height, which are given first as 16 hex digits). This finishes by running the result through LZSEncoding, a combination which typically gets very good compression.
      Returns:
      a String that could be used to reconstruct this GreasedRegion using decompress(String)
    • decompress

      public static GreasedRegion decompress​(String compressed)
      Decompresses a String returned by toCompressedString(), returning a new GreasedRegion with identical width, height, and contents to the GreasedRegion before compression. This decompresses the LZSEncoding applied to the data, then decompresses the CoordPacker-type Hilbert Curve RLE data to get the original GreasedRegion back.
      Parameters:
      compressed - a String that was compressed by toCompressedString(), without changes
      Returns:
      a new copy of the GreasedRegion that was previously compressed
    • contains

      public boolean contains​(Object o)
      Specified by:
      contains in interface Collection<Coord>
    • iterator

      public Iterator<Coord> iterator()
      Specified by:
      iterator in interface Collection<Coord>
      Specified by:
      iterator in interface Iterable<Coord>
      Overrides:
      iterator in class Zone.Skeleton
    • toArray

      public Object[] toArray()
      Specified by:
      toArray in interface Collection<Coord>
    • toArray

      public <T> T[] toArray​(T[] a)
      Specified by:
      toArray in interface Collection<Coord>
    • add

      public boolean add​(Coord coord)
      Specified by:
      add in interface Collection<Coord>
    • clear

      public void clear()
      Specified by:
      clear in interface Collection<Coord>
    • remove

      public boolean remove​(Object o)
      Specified by:
      remove in interface Collection<Coord>
    • containsAll

      public boolean containsAll​(Collection<?> c)
      Specified by:
      containsAll in interface Collection<Coord>
    • addAll

      public boolean addAll​(Collection<? extends Coord> c)
      Specified by:
      addAll in interface Collection<Coord>
    • removeAll

      public boolean removeAll​(Collection<?> c)
      Specified by:
      removeAll in interface Collection<Coord>
    • retainAll

      public boolean retainAll​(Collection<?> c)
      Specified by:
      retainAll in interface Collection<Coord>
    • deteriorate

      public GreasedRegion deteriorate​(RandomnessSource rng, int preservation)
      Randomly removes points from a GreasedRegion, with larger values for preservation keeping more of the existing shape intact. If preservation is 1, roughly 1/2 of all points will be removed; if 2, roughly 1/4, if 3, roughly 1/8, and so on, so that preservation can be thought of as a negative exponent of 2.
      Parameters:
      rng - used to determine random factors
      preservation - roughly what degree of points to remove (higher keeps more); removes about 1/(2^preservation) points
      Returns:
      a randomly modified change to this GreasedRegion
    • deteriorate

      public GreasedRegion deteriorate​(RandomnessSource random, double preservation)
      Randomly removes points from a GreasedRegion, with preservation as a fraction between 1.0 (keep all) and 0.0 (remove all). If preservation is 0.5, roughly 1/2 of all points will be removed; if 0.25, roughly 3/4 will be removed (roughly 0.25 will be _kept_), if 0.8, roughly 1/5 will be removed (and about 0.8 will be kept), and so on. Preservation must be between 0.0 and 1.0 for this to have the intended behavior; 1.0 or higher will keep all points without change (returning this GreasedRegion), while anything less than 0.015625 (1.0/64) will empty this GreasedRegion (using empty()) and then return it. The parameter random can be an object like a DiverRNG, an RNG backed by a well-distributed RandomnessSource like its default, DiverRNG, a GWTRNG (especially if you target GWT, where it will perform much better than most alternatives), or any of various other RandomnessSource implementations that distribute bits well for RandomnessSource.nextLong(), but should not be intentionally-biased RNGs like DharmaRNG or EditRNG, nor double-based QRNGs like VanDerCorputQRNG or SobolQRNG.
      Parameters:
      random - used to determine random factors; likely to be an RNG, DiverRNG, or GWTRNG
      preservation - the rough fraction of points to keep, between 0.0 and 1.0
      Returns:
      a randomly modified change to this GreasedRegion
    • toggle

      public GreasedRegion toggle​(int x, int y)
      Changes the on/off state of the cell with the given x and y, making an on cell into an off cell, or an off cell into an on cell.
      This was called flip(), but that name would be confusing since flipping a rectangular area usually means reversing an axis.
      Parameters:
      x - the x position of the cell to flip
      y - the y position of the cell to flip
      Returns:
      this for chaining, modified
    • mirrorY

      Returns a new GreasedRegion that has been mirrored along the rightmost edge, parallel to the y-axis. The new GreasedRegion will have exactly twice the width, the additional width will have the contents of the original GreasesRegion in reversed order. The positions shared by both GreasedRegions will be the same, that is, any area not added to the original will be equal to the original.
      Returns:
      a new GreasedRegion with twice the width of this, that is mirrored along the rightmost edge
    • intersectsWith

      public boolean intersectsWith​(Zone other)
      Specified by:
      intersectsWith in interface Zone
      Overrides:
      intersectsWith in class Zone.Skeleton
      Returns:
      true if this and other have a common cell.
    • translate

      public GreasedRegion translate​(Coord c)
      Translates a copy of this by the x,y values in c. Implemented with return copy().translate(c.x, c.y);
      Specified by:
      translate in interface Zone
      Overrides:
      translate in class Zone.Skeleton
      Returns:
      this copied and shifted by (c.x,c.y)
    • getExternalBorder

      Gets a Collection of Coord values that are not in this GreasedRegion, but are adjacent to it, either orthogonally or diagonally. Related to the fringe() methods in CoordPacker and GreasedRegion, but guaranteed to use 8-way adjacency and to return a new Collection of Coord. This implementation returns a GreasedRegion produced simply by return copy().fringe8way(); .
      Specified by:
      getExternalBorder in interface Zone
      Overrides:
      getExternalBorder in class Zone.Skeleton
      Returns:
      Cells adjacent to this (orthogonally or diagonally) that aren't in this
    • extend

      Gets a new Zone that contains all the Coords in this plus all neighboring Coords, which can be orthogonally or diagonally adjacent to any Coord this has in it. Related to the expand() methods in CoordPacker and GreasedRegion, but guaranteed to use 8-way adjacency and to return a new Zone. This implementation returns a GreasedRegion produced simply by return copy().expand8way(); .
      Specified by:
      extend in interface Zone
      Overrides:
      extend in class Zone.Skeleton
      Returns:
      A new GreasedRegion where "off" cells adjacent to this (orthogonally or diagonally) have been added to the "on" cells in this
    • contains

      public boolean contains​(Coord c)
      Checks if c is present in this GreasedRegion. Returns true if and only if c is present in this GreasedRegion as an "on" cell. This will never be true if c is null, has negative x or y, has a value for x that is equal to or greater than width, or has a value for y that is equal to or greater than height, but none of those conditions will cause Exceptions to be thrown.
      Specified by:
      contains in interface Zone
      Overrides:
      contains in class Zone.Skeleton
      Parameters:
      c - a Coord to try to find in this GreasedRegion; if null this will always return false
      Returns:
      true if c is an "on" cell in this GreasedRegion, or false otherwise, including if c is null
    • contains

      public boolean contains​(Zone other)
      Checks whether all Coords in other are also present in this. Requires that other won't give a null Coord while this method iterates over it.
      Specified by:
      contains in interface Zone
      Overrides:
      contains in class Zone.Skeleton
      Parameters:
      other - another Zone, such as a GreasedRegion or a CoordPackerZone
      Returns:
      true if all Coords in other are "on" in this GreasedRegion, or false otherwise
    • xBound

      public int xBound​(boolean findSmallest)
      Specified by:
      xBound in interface Zone
      Overrides:
      xBound in class Zone.Skeleton
      Parameters:
      findSmallest - if true, finds the smallest x-coordinate value; if false, finds the biggest.
      Returns:
      The x-coordinate of the Coord within this that has the smallest (or biggest) x-coordinate. Or -1 if the zone is empty.
    • yBound

      public int yBound​(boolean findSmallest)
      Specified by:
      yBound in interface Zone
      Overrides:
      yBound in class Zone.Skeleton
      Parameters:
      findSmallest - if true, finds the smallest y-coordinate value; if false, finds the biggest.
      Returns:
      The y-coordinate of the Coord within this that has the smallest (or biggest) y-coordinate. Or -1 if the zone is empty.
    • getWidth

      public int getWidth()
      Gets the distance between the minimum x-value contained in this GreasedRegion and the maximum x-value in it. Not the same as accessing the field width on a GreasedRegion! The field will get the span of the space that the GreasedRegion can use, including "on" and "off" cells. This method will only get the distance between the furthest-separated "on" cells on the x-axis, and won't consider "off" cells. This method can return -1 if the GreasedRegion is empty, 0 if the "on" cells are all in a vertical line (that is, when the minimum x is equal to the maximum x), or a positive int in other cases with multiple x-values.
      Specified by:
      getWidth in interface Zone
      Overrides:
      getWidth in class Zone.Skeleton
      Returns:
      the distance on the x-axis between the "on" cell with the lowest x-value and the one with the highest
    • getHeight

      public int getHeight()
      Gets the distance between the minimum y-value contained in this GreasedRegion and the maximum y-value in it. Not the same as accessing the field height on a GreasedRegion! The field will get the span of the space that the GreasedRegion can use, including "on" and "off" cells. This method will only get the distance between the furthest-separated "on" cells on the y-axis, and won't consider "off" cells. This method can return -1 if the GreasedRegion is empty, 0 if the "on" cells are all in a horizontal line (that is, when the minimum y is equal to the maximum y), or a positive int in other cases with multiple y-values.
      Specified by:
      getHeight in interface Zone
      Overrides:
      getHeight in class Zone.Skeleton
      Returns:
      the distance on the y-axis between the "on" cell with the lowest y-value and the one with the highest
    • getDiagonal

      public double getDiagonal()
      Gets the diagonal distance from the point combining the lowest x-value present in this GreasedRegion with the lowest y-value in this, to the point combining the highest x-value and the highest y-value. These minimum and maximum values don't necessarily match a single "on" cell for each min and max corner, and can take their x and y values from two different points. The diagonal distance uses Euclidean measurement (basic Pythagorean Theorem math here), and will be a double.
      Specified by:
      getDiagonal in interface Zone
      Overrides:
      getDiagonal in class Zone.Skeleton
      Returns:
      the diagonal distance from (min x, min y) to (max x, max y), as a double
    • getInternalBorder

      Specified by:
      getInternalBorder in interface Zone
      Overrides:
      getInternalBorder in class Zone.Skeleton
      Returns:
      Cells in this that are adjacent to a cell not in this
    • mixedRandomSeparatedAlt

      public Coord[] mixedRandomSeparatedAlt​(double fraction, int limit, long seed)
      Gets a Coord array from the "on" contents of this GreasedRegion, using a deterministic but random-seeming scattering of chosen cells with a count that matches the given fraction of the total amount of "on" cells in this. This is pseudo-random with the given seed (which will be made into an odd number if it is not one already), and is very good at avoiding overlap (just as good as separatedZCurve(double, int), and much faster). If you request too many cells (too high of a value for fraction), it will start to overlap, but a fraction value of 0.4 reliably has had no overlap in testing. Restricts the total size of the returned array to a maximum of limit (minimum is 0 if no cells are "on"). If limit is negative, this will not restrict the size.
      Parameters:
      fraction - the fraction of "on" cells to randomly select, between 0.0 and 1.0
      limit - the maximum size of the array to return
      seed - a long seed to change the points; the most significant 21 bits (except the sign bit) and least significant bit are ignored
      Returns:
      a freshly-allocated Coord array containing the pseudo-random cells