Package com.github.yellowstonegames.grid

package com.github.yellowstonegames.grid

Class	Description
BadgerNoise	Combined higher-dimensional value noise with simplex noise as one of its axes.
BasicHashNoise	Makes 2D through 6D value noise that simply preserves the behavior of an IPointHash, including intentional (or unintentional) artifacts that the point hash produces.
BitNoise	An unusual kind of INoise that typically only outputs -1 or 1, for cases where you want binary results of blobby noise, but can also produce more bits if constructed as such.
BlueNoise	Provides access to precalculated tiling planes of 2D blue noise, that is, noise without high-frequency components, as well as seeded mixes of different blue noise planes that make it have even fewer patterns.
BresenhamLine	Provides a means to generate Bresenham lines in 2D.
CellularAutomaton	Various simple cellular-automata rules and the data they operate on.
CellularNoise	An INoise implementation that divides space up into cells, and has configurable ways to get values from cells.
CellularNoise.NoiseType
ConvChain	A class that imitates patterns in an existing Region and uses it to fill another Region so it has a similar visual style.
Coord	A 2D coordinate with (constant) x and y fields.
CoordFloatMap	A variant on jdkgdxds' ObjectFloatMap class that only uses Coord keys, and can do so more efficiently.
CoordFloatOrderedMap	A variant on jdkgdxds' ObjectFloatOrderedMap class that only uses Coord keys, and can do so more efficiently.
CoordIntMap	A variant on jdkgdxds' ObjectIntMap class that only uses Coord keys, and can do so more efficiently.
CoordIntOrderedMap	A variant on jdkgdxds' ObjectIntOrderedMap class that only uses Coord keys, and can do so more efficiently.
CoordLongMap	A variant on jdkgdxds' ObjectLongMap class that only uses Coord keys, and can do so more efficiently.
CoordLongOrderedMap	A variant on jdkgdxds' ObjectLongOrderedMap class that only uses Coord keys, and can do so more efficiently.
CoordObjectMap<V>	A variant on jdkgdxds' ObjectObjectMap class that only uses Coord keys, and can do so more efficiently.
CoordObjectOrderedMap<V>	A variant on jdkgdxds' ObjectObjectMap class that only uses Coord keys, and can do so more efficiently.
CoordOrderedSet	A variant on jdkgdxds' ObjectOrderedSet class that only holds Coord items, and can do so more efficiently.
CoordSet	A variant on jdkgdxds' ObjectSet class that only holds Coord items, and can do so more efficiently.
CyclicNoise	A periodic type of continuous noise that looks good when frequencies are low, and rather bad when frequencies are high.
Direction	Represents the eight grid directions and the deltaX, deltaY values associated with those directions.
DrunkenWalk	A drunkard's-walk-like algorithm for line-drawing "wobbly" paths.
DualMutantNoiseWrapper	A wrapper around an INoise that allows two extra degrees of freedom to adjust the inputs by a small amount, continuously rather than in jumps (as adjusting the seed would do).
EliasWuLine	Contains methods to draw anti-aliased lines based on floating-point coordinates.
FlanNoise	A variant on PhantomNoise that also produces arbitrary-dimensional continuous noise, but that is optimized for higher-dimensional output (4 and up, in particular).
FlawedPointHash	An interface for point hashes that are statistically biased, as well as a holder for inner classes that implement this.
FlawedPointHash.CubeHash	Very similar to FlawedPointHash.QuiltHash, but this doesn't change the pattern in different large squares, and instead repeats a square or cube of symmetric and patterned results over and over (so it can be tiled).
FlawedPointHash.FlowerHash
FlawedPointHash.FNVHash	FNV32a is OK as a hash for bytes when used in some hash tables, but it has major issues on its low-order bits when used as a point hash (the high bits aren't much better).
FlawedPointHash.LowLeaningHash	Makes smaller results on average, with a biased average at about 25% of the range instead of 50% of the range for most non-biased hashes.
FlawedPointHash.QuiltHash	Extremely flawed if you're using this as a point hash, but meant to be aesthetically interesting, this produces different symmetrical patterns in squares, as if on a quilt.
FlawedPointHash.RugHash	Produces hashes that show strong bias on one axis (usually the later axes matter more) and have nice-looking patterns of dots.
FlawedPointHash.SquishedCubeHash	Like CubeHash, but with a squished Z axis in 3D and 4D, as well as a squashed W axis in 4D.
FoamNoise	Foam noise code as an INoise implementation.
FoamplexNoise	Foam noise but using Simplex noise instead of Value noise.
FOV	This class provides methods for calculating Field of View in grids.
GradientVectors	Stores arrays representing vectors on the unit hypersphere in 2D through 6D.
GridIterator
GridIterator.CenteredSquare	An iterator that returns cells in a square around a location.
GridIterator.SquareSpiral	Iterates in a square spiral going outward from a starting position.
GridIterator.VerticalUp	An iterator to iterate from a starting position (exclusive) and going up.
HighDimensionalValueNoise	Arbitrary-dimensional continuous noise that always looks very blocky.
HilbertCurve	Calculates and stores 2D and optionally 3D Hilbert Curves up to a reasonable size.
HoneyNoise	An INoise implementation that combines and accentuates SimplexNoise and ValueNoise.
HuskyNoise	A variant on CyclicNoise that always uses 7D noise internally, filling in any dimensions that it doesn't have with 1s.
IGridIdentified	Combines IGridPositioned and IIdentified for objects that have a Coord position and an int identifier.
IGridPositioned	Allows getting and setting the position of an object, as a Coord.
INoise	Shared interface for all continuous noise algorithms that can produce at least one dimensionality of noise between 2D and 7D.
INoise.Serializer
IntPointHash	A group of similar methods for getting hashes of points based on int coordinates in 2, 3, 4, or 6 dimensions and an int for state; the code is similar to LongPointHash but will be much faster on GWT.
IPointHash	An interface for "point hashes", that is, functions that produce usually-unique integer results given multiple integer inputs.
IPointHash.IntImpl	A convenience abstract class to implement IPointHash when you have an int for state.
IPointHash.LongImpl	A convenience abstract class to implement IPointHash when you have a long for state.
KnownSizePointHash	A very simple point hash meant only for fixed-size grids, and only for when the hash must be unique but does not need to be randomized.
LightingManager	A convenience class that makes dealing with multiple colored light sources easier.
LightingManager.FovFunction	A functional interface that is really only meant to be one of two functions: FOV.reuseFOV(float[][], float[][], int, int, float, Radius) or FOV.reuseFOVSymmetrical(float[][], float[][], int, int, float, Radius).
LightingManager.SymmetryMode	Used to choose whether FOV calculations should be done as quickly as possible (without symmetry guarantees) or more precisely (and more slowly, but with a symmetry guarantee).
LightingManagerRgb	A convenience class that makes dealing with multiple colored light sources easier.
LightSource	A tiny data wrapper around a LightSource.radiance and a Coord LightSource.position for that Radiance, as well as, optionally, an angle to project a cone of light in and a span for how wide of a cone to project.
LineDrawer	A shared interface for line-drawing classes, so instances can be interchanged.
LineTools	Tools for constructing patterns using box-drawing characters in grids.
LongPointHash	A group of similar methods for getting hashes of points based on long coordinates in 2, 3, 4, 5, or 6 dimensions and a long for state.
Measurement	A way of measuring what cells are adjacent and how much further any adjacent cells are from other adjacent cells.
MutantNoiseWrapper	A wrapper around an INoise that allows an extra degree of freedom to adjust the inputs by a small amount, continuously rather than in jumps (as adjusting the seed would do).
Noise	A wide range of noise functions that can all be called from one configurable object.
NoiseAdjustment	Wraps another INoise and alters its output by running it through an Interpolations.Interpolator.
NoiseWrapper
NumberPairing	Utility functions for pairing (and tripling) functions, which take two (or three) numbers, typically ints, and return an int with magnitude dependent on the input number with maximum magnitude.
OpenSimplex2	K.jpg's OpenSimplex 2, faster variant.
OpenSimplex2Smooth	K.jpg's OpenSimplex 2, smoother variant.
OrthoLine	A simple line-drawing algorithm that only takes orthogonal steps; may be useful for LOS in games that use Manhattan distances for measurements.
PerlinNoise	"Classic" Perlin noise, written by Ken Perlin before he created Simplex Noise, with minor adjustments.
PerlueNoise	A mix of "Classic" PerlinNoise, written by Ken Perlin before he created Simplex Noise, with ValueNoise calculated at the same time.
PhantomNoise	Arbitrary-dimensional continuous noise that maintains most of the same style even as the dimensionality gets fairly high.
Point2Float	A mutable 2D point with float components implementing Point2, PrimitiveCollection.OfFloat, and PointNFloat.
Point2Int	A mutable 2D point with int components implementing Point2, PrimitiveCollection.OfInt, and PointNInt.
Point3Float	A mutable 3D point with float components implementing Point3, PrimitiveCollection.OfFloat, and PointNFloat.
Point3Int	A mutable 3D point with int components implementing Point3, PrimitiveCollection.OfInt, and PointNInt.
Point4Float	A mutable 4D point with float components implementing Point4, PrimitiveCollection.OfFloat, and PointNFloat.
Point4Int	A mutable 4D point with int components implementing Point4, PrimitiveCollection.OfInt, and PointNInt.
Point5Float	A mutable 5D point with float components implementing Point5, PrimitiveCollection.OfFloat, and PointNFloat.
Point5Int	A mutable 5D point with int components implementing Point5, PrimitiveCollection.OfInt, and PointNInt.
Point6Float	A mutable 6D point with float components implementing Point6, PrimitiveCollection.OfFloat, and PointNFloat.
Point6Int	A mutable 6D point with int components implementing Point6, PrimitiveCollection.OfInt, and PointNInt.
PointNFloat<P extends PointNFloat<P,R>, R extends com.github.tommyettinger.crux.PointN<?>>	Groups functionality common to points with float components, in any dimension.
PointNFloatIterator	A FloatIterator that iterates over the components in a PointNFloat using PointNFloat.get(int).
PointNInt<P extends PointNInt<P,R>, R extends com.github.tommyettinger.crux.PointN<?>>	Groups functionality common to points with int components, in any dimension.
PointNIntIterator	An IntIterator that iterates over the components in a PointNInt using PointNInt.get(int).
PoissonDisk	An implementation of the Poisson Disk sampling algorithm on a discrete grid.
PuffyNoise	A variant on CyclicNoise that always uses 7D noise internally, filling in any dimensions that it doesn't have with 1s.
QuasiRandomTools	Static methods to produce numbers and points from quasi-random sequences (which seem like random sequences, but have lower "discrepancy" between results).
RadialNoiseWrapper	A NoiseWrapper that makes its output radially symmetric around a given center point.
Radiance	Grouping of qualities related to glow and light emission.
Radius	Basic radius strategy implementations likely to be used for roguelikes.
Region	Region encoding of on/off information about areas using bitsets; uncompressed but fast at bulk operations.
RotationTools	This has tools for generating and applying matrix rotations, potentially in higher dimensions than the typical 2 or 3.
RotationTools.Rotator	A wrapper around similar logic to RotationTools, but with no allocation after construction.
ShapedFoamNoise	Foam noise code as an INoise implementation, additionally taking a shape parameter for its interpolations (to allow using something shaped differently from a cubic Hermite spline, which is otherwise the default).
SimplexNoise	Simplex noise functions, in 2D, 3D, 4D, 5D, and 6D.
SimplexNoiseHard	Simplex noise functions, in 2D, 3D, 4D, 5D, and 6D.
SimplexNoiseScaled	Simplex noise functions, in 2D, 3D, 4D, 5D, and 6D.
SnakeNoise	Combines value noise with simplex noise, like HoneyNoise, but has more sinuous squashing and stretching of its lattice because each axis is run through LineWobble.bicubicWobble(int, float).
SorbetNoise	A mix of CyclicNoise with Simplex noise; much less periodic than CyclicNoise alone.
SpatialMap<V extends IGridIdentified>	A kind of Map-like data structure that allows lookup by int id or Coord position, and retains its insertion order.
Spill	Performs randomized flood-fill operations on arbitrarily-shaped areas, until a volume is reached.
TaffyNoise	A variant on PhantomNoise that also produces arbitrary-dimensional continuous noise, but that is optimized for higher-dimensional output (4 and up, in particular).
ValueNoise	An INoise implementation that produces blocky noise from 1D to 7D.
VisionFramework	A "one-stop shop" for handling field-of-view, line-of-sight, (colorful) light sources, and more.
VisionFrameworkRgb	A "one-stop shop" for handling field-of-view, line-of-sight, (colorful) light sources, and more.
VroomNoise	A type of continuous noise that is meant to look "similar in character" regardless of dimension.
WaveFunctionCollapse	A port of WaveFunctionCollapse by ExUtumno/mxgmn; takes a single sample of a grid to imitate and produces one or more grids of requested sizes that have a similar layout of cells to the sample.
WhiteNoise	Makes 2D through 6D value noise that effectively produces a random float result for every different set of arguments given to a WhiteNoise.getNoise(float, float) or WhiteNoise.getNoiseWithSeed(float, float, long) call.