All Classes
| Class | Description |
|---|---|
| AbstractRNG |
A helper class for implementing
IRNG without so much busy-work. |
| Adjacency |
Some classes need detailed information about what cells are considered adjacent to other cells, and may
need to construct a customized mapping of cells to their neighbors.
|
| Adjacency.BasicAdjacency | |
| Adjacency.RotationAdjacency | |
| Adjacency.ThinWallAdjacency | |
| AestheticDifference |
Used by DetailedMimic to allow different kinds of detail, including differentiating color or map features.
|
| AimLimit |
Enum used for common targeting limitations (or lack thereof, in the case of AimLimit.FREE ).
|
| Algorithms<V> |
Most of the algorithms that operate on a
Graph are defined here, with some specific cases in subclasses. |
| AOE |
Area of Effect interface meant to be implemented by various specific burst, line, flowing, and user-made AOE types.
|
| AreaUtils |
Static utilities for use in AOE and anything else that might need HashMaps of Coord keys to Double values.
|
| Arrangement<K> |
A bi-directional mapping of objects to positions in an ordering (which this generates), and vice versa.
|
| ArrayTools |
Static methods for various frequently-used operations on 1D and 2D arrays.
|
| AStarSearch |
Performs A* search to find the shortest path between two Coord points.
|
| AStarSearch.SearchType |
The type of heuristic to use.
|
| BalancedPermutations |
Based on Martin Roberts' blog post about
blue noise point sets, this class generates "balanced" permutations of a specific size with good performance.
|
| BasicCaveGenerator | |
| BasicRandom32 |
A low-quality but very fast RNG that has no apparent visual artifacts here; uses Mark Overton's CMR subcycle
generator type, but modified to be especially GWT-friendly.
|
| BasicRandom64 |
A high-quality and very fast RNG that has no apparent visual artifacts here; uses Mark Overton's CMR subcycle
generator type, with a multiplication on the output.
|
| BathtubDistribution |
An IDistribution that produces results between 0.0 inclusive and 1.0 exclusive, but is much more likely to produce
results near 0.0 or 1.0, further from 0.5.
|
| BeamAOE |
Beam Area of Effect that affects an slightly expanded (Elias) line from a given origin Coord out to a given length,
plus an optional radius of cells around the path of the line, while respecting obstacles in its path and possibly
stopping if obstructed.
|
| Beta |
Signifies that a public API (public class, method or field) is subject to
incompatible changes, or even removal, in a future release.
|
| BinaryHeap<T extends BinaryHeap.Node> |
A binary heap that stores nodes which each have a double value and are sorted either lowest first or highest first.
|
| BinaryHeap.Node |
A binary heap node.
|
| BlastAOE |
An AOE type that has a center and a radius, and will blast outward and somewhat around corners/obstacles, out to
the distance specified by radius.
|
| BlueNoise |
Provides access to a precalculated, tiling plane of 2D blue noise, that is, noise without high-frequency components,
as well as seeded modifications to that tiling blue noise plane that make it have even fewer patterns.
|
| Bresenham |
Provides a means to generate Bresenham lines in 2D and 3D.
|
| BurstAOE |
An AOE type that has a center and a radius, and uses shadowcasting to create a burst of rays from the center, out to
the distance specified by radius.
|
| ByteStringEncoding |
An experimental variant on LZSEncoding to encode byte arrays to compressed Strings, and decode them back.
|
| CavesLimitConnectivity | |
| CavesTinyCorridors | |
| CellularAutomaton |
Created by Tommy Ettinger on 7/3/2017.
|
| ChaosRNG |
An RNG that cannot be seeded and should be fairly hard to predict what it will return next.
|
| ClassicNoise |
"Classic Perlin" noise, as opposed to the Simplex Noise also created by Ken Perlin (which is produced by
SeededNoise; both can be produced by FastNoise). |
| ClassicRogueMapGenerator |
Creates a dungeon in the style of the original Rogue game.
|
| CloudAOE |
An AOE type that has a center and a volume, and will randomly expand in all directions until it reaches volume or
cannot expand further.
|
| ColoredStringList<T> |
An helper class for code that deals with lists of
IColoredStrings. |
| CombinationGenerator<T> |
Combination generator for generating all combinations of a given size from
the specified set of elements.
|
| ConeAOE |
An AOE type that has an origin, a radius, an angle, and a span; it will blast from the origin to a length equal to
radius along the angle (in degrees), moving somewhat around corners/obstacles, and also spread a total of span
degrees around the angle (a span of 90 will affect a full quadrant, centered on angle).
|
| Config |
Part of the JSON that defines a tileset.
|
| ConnectingMapGenerator |
A room placing algorithm developed by Rayvolution for his game Fail To Hero, this was simple to implement but
delivers complex connectivity.
|
| Connection<V> |
The most-commonly-used class that represents an edge between nodes on a Graph.
|
| Connection.DirectedConnection<V> |
A Connection that treats A-to-B as a different edge from B-to-A.
|
| Connection.UndirectedConnection<V> |
A Connection that treats A-to-B and B-to-A as the same edge.
|
| Converters |
Ways to produce concrete implementations of StringConvert for various data structures.
|
| Coord |
A 2D coordinate with (constant) x and y fields.
|
| Coord3D |
Generic three dimensional coordinate class.
|
| CoordDouble |
Coord using double values for x and y instead of int.
|
| CoordPacker |
Provides static methods to encode Coords as single primitive ints in various ways, hence the namesake, but also
provides advanced methods to encode 2D arrays of various sorts produced by SquidLib in extremely memory-efficient
representations, and decode those representations to various types of 2D array on-demand.
|
| CoordPackerZone |
A zone constructed by
CoordPacker. |
| CornerCaves | |
| CosmicNumbering |
Like a kind of RNG, but fully deterministic in a way that depends on a "connected" double array.
|
| CostlyGraph |
A default setting for a DirectedGraph of Coord vertices where each passable cell has a cost to enter it from any
passable neighbor.
|
| CriticalRNG |
A type of RNG that can generate values larger or smaller than the normal maximum or minimum, based on a modifier.
|
| CrossHash |
64-bit and 32-bit hashing functions that we can rely on staying the same cross-platform.
|
| CrossHash.Curlup |
Like Yolk, this is a class for hash functors, each an object with a 64-bit long seed.
|
| CrossHash.Hive |
A reasonably-fast hashing function that passes some of SMHasher's quality tests, but neither critically fails nor
overwhelmingly succeeds the full SMHasher test battery.
|
| CrossHash.IHasher |
An interface that can be used to move the logic for the hashCode() and equals() methods from a class' methods to
an implementation of IHasher that certain collections in SquidLib can use.
|
| CrossHash.Lightning |
A quick, simple hashing function that seems to have good results.
|
| CrossHash.Mist |
A whole cluster of Wisp-like hash functions that sacrifice a small degree of speed, but can be built with up
to 128 bits of salt values that help to obscure what hashing function is actually being used.
|
| CrossHash.Water |
A fairly fast hashing algorithm in general, Water performs especially well on large arrays, and passes SMHasher's
newest and most stringent version of tests.
|
| CrossHash.Wisp |
The fastest hash in CrossHash, with middling quality.
|
| CrossHash.Yolk |
Like Mist, this is a class for hash functors, each an object with a 64-bit long seed, but it uses about the same
algorithm as
CrossHash.Water instead of the older, less-robust style Mist uses. |
| CurvedBoundedDistribution |
An IDistribution that allows a parameter to determine how many calls to
IRNG.nextDouble() to make and average
whenever a double is requested. |
| CustomDijkstraMap |
An alternative to AStarSearch when you want to fully explore a search space, or when you want a gradient
floodfill, with customizable rules for what is considered adjacent.
|
| DamerauLevenshteinAlgorithm |
The Damerau-Levenshtein Algorithm is an extension to the Levenshtein
Algorithm which solves the edit distance problem between a source string and
a target string with the following operations:
Character Insertion
Character Deletion
Character Replacement
Adjacent Character Swap
Note that the adjacent character swap operation is an edit that may be
applied when two adjacent characters in the source string match two adjacent
characters in the target string, but in reverse order, rather than a general
allowance for adjacent character swaps.
|
| DDALine |
A fixed-point line-drawing algorithm that should have good performance; may be useful for LOS.
|
| DeckRNG |
An RNG variant that has 16 possible grades of value it can produce and shuffles them like a deck of cards.
|
| DefaultDungeon | |
| DefaultGraph |
A default setting for an
UndirectedGraph of Coord vertices where all connections have cost 1. |
| DelaunayTriangulator |
A Java implementation of an incremental 2D Delaunay triangulation algorithm.
|
| DelaunayTriangulator.Edge | |
| DelaunayTriangulator.Triangle | |
| DenseRoomMapGenerator |
Map generator that constructs a large number of overlapping rectangular rooms.
|
| DetailedMimic |
Similar to MimicFill, this class can be used to imitate the style of an existing piece of data, but this works on
more than just booleans; it can produce similar styles of texture (its original use in SynTex), of map, of item
placement, and so on by specifying a different technique for differentiating two int values.
|
| DharmaRNG |
An alteration to a RandomnessSource that attempts to produce values that are perceived as fair to an imperfect user.
|
| Dice |
Class for emulating various traditional RPG-style dice rolls.
|
| DijkstraMap |
An alternative to AStarSearch when you want to fully explore a search space, or when you want a gradient floodfill.
|
| DirectedGraph<V> |
A kind of
Graph where all connections between vertices are one-way (but a connection may exist that goes from
A to B and another connection may go from B to A), and each connection can have a different cost. |
| DirectedGraphAlgorithms<V> |
Algorithms specific to directed graphs, like
CostlyGraph, as well as general Algorithms. |
| Direction |
Represents the eight grid directions and the deltaX, deltaY values associated
with those directions.
|
| DistributedRNG |
An implementation of
IRNG that allows specifying a distribution for all random numbers it produces via a
IDistribution.SimpleDistribution value. |
| DiverRNG |
A very-high-quality StatefulRandomness that is the fastest 64-bit generator in this library that passes statistical
tests and is one-dimensionally equidistributed across all 64-bit outputs.
|
| DividedMazeGenerator |
Recursively divided maze.
|
| DungeonBoneGen |
Generate a dungeon using Sean T.
|
| DungeonGenerator |
The primary way to create a more-complete dungeon, layering different effects and modifications on top of
a DungeonBoneGen's dungeon or another dungeon without such effects.
|
| DungeonGenerator.FillEffect |
The effects that can be applied to this dungeon.
|
| DungeonUtility |
A static class that can be used to modify the char[][] dungeons that other generators produce.
|
| Edge<V> |
Abstract superclass of any connection between nodes on a graph.
|
| EditRNG |
A subclass of StatefulRNG (and thus RNG) that allows customizing many parts of the random number generation.
|
| Elias |
Contains methods to draw anti-aliased lines based on floating-point
coordinates.
|
| EnumOrderedMap<K extends Enum<?>,V> |
A simple alternative to EnumMap that has a zero-argument constructor (which makes serialization easier) but is a
little less efficient.
|
| EnumOrderedSet<K extends Enum<?>> |
A simple Set of Enum items (which are already unique if used in a normal Set) that keeps insertion order.
|
| ExponentialDistribution |
An IDistribution that implements the Exponential
distribution.
|
| FakeLanguageGen |
A text generator for producing sentences and/or words in nonsense languages that fit a theme.
|
| FakeLanguageGen.Alteration | |
| FakeLanguageGen.Modifier | |
| FakeLanguageGen.SentenceForm |
A simple way to bundle a FakeLanguageGen with the arguments that would be passed to it when calling
FakeLanguageGen.sentence(IRNG, int, int, String[], String[], double, int) or one of its overloads. |
| FantasyPoliticalMapper |
When you have a world map as produced by
WorldMapGenerator, you may want to fill it with claims by various
factions, where each faction may be hand-made and may consist of humans or some fantasy species, such as goblins,
elves, or demons. |
| FantasyPoliticalMapper.Faction |
Represents a group that claims territory on a world-map, such as a nation.
|
| FastNoise |
A wide range of noise functions that can all be called from one configurable object.
|
| 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.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.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.
|
| FlawedRandomness |
An interface to indicate a
RandomnessSource that is intentionally flawed to create output patterns where a
truly random sequence would have none. |
| FlawedRandomness.AddRotate |
A flawed randomness source that adds a rotation of its state, to its state, every generation.
|
| FlawedRandomness.BigCounter |
A flawed randomness source that depends almost entirely on its starting state for any random-seeming results in
its output.
|
| FlowingCaveGenerator |
An IDungeonGenerator that distorts and smooths an ordinary dungeon map to make it appear like a cave complex.
|
| FoamNoise |
An unusual continuous noise generator that tends to produce organic-looking forms, currently supporting 2D, 3D, 4D
and 6D.
|
| FOV |
This class provides methods for calculating Field of View in grids.
|
| GapShuffler<T> |
Meant to take a fixed-size set of items and produce a shuffled stream of them such that an element is never chosen in
quick succession; that is, there should always be a gap between the same item's occurrences.
|
| Garbler |
Tools for garbling Strings (making them appear to be gibberish) and degarbling earlier outputs to get the original
inputs.
|
| GaussianDistribution |
An IDistribution that produces double results with a Gaussian (normal) distribution.
|
| GearRNG |
A larger-period generator with 127 bits of state (two longs, one is always odd), a period of 2 to the 127, and what
should be slightly better speed than the related OrbitRNG.
|
| GlitchNoise |
A noise generator for 1D, 2D, 3D, 4D, or 6D noise that should look "glitchy", with waves of changing values moving
through triangular shapes.
|
| GoatRNG |
A larger-period generator with 128 bits of state, good speed, and high quality in PractRand testing; it is at least
1-dimensionally equidistributed.
|
| GoldPointHash |
A relatively simple
IPointHash that multiplies each of the x, y, etc. |
| Graph<V> |
Abstract superclass of actual Graph types, like
DirectedGraph and UndirectedGraph. |
| GreasedRegion |
Region encoding of on/off information about areas using bitsets; uncompressed (fatty), but fast (greased lightning).
|
| GreasedZOI |
Calculates the Zone of Influence, also known as Zone of Control, for different points on a map.
|
| GridCompression |
Very early way of additional compression that can be applied to 2D double and byte arrays.
|
| GrowingTreeMazeGenerator |
A maze generator that can be configured using a
GrowingTreeMazeGenerator.ChoosingMethod, which can be customized for the app. |
| GrowingTreeMazeGenerator.ChoosingMethod |
A way to configure how
GrowingTreeMazeGenerator.generate(ChoosingMethod) places paths through the maze. |
| GwtIncompatible |
An annotation for the GWT compiler.
|
| GWTRNG |
An IRNG implementation that is meant to provide random numbers very quickly when targeting GWT but also to produce
the same numbers when used on desktop, Android, or other platforms, and that can have its state read as a
StatefulRandomness.
|
| HashCommon |
Code used internally for hashing OrderedMap, OrderedSet, IntDoubleOrderedMap, Arrangement, and so on.
|
| HashCommon.EnumHasher | |
| Hashers |
Additional implementations of the
CrossHash.IHasher interface for more specialized uses, like for use in an
OrderedSet or OrderedMap with String keys that should use case-insensitive equality/hashing. |
| HastyPointHash |
A group of similar methods for getting hashes of points based on long coordinates in 2, 3, 4, or 6 dimensions and
a long for state; like
PointHash but faster and maybe not as high-quality. |
| HeightMapFactory |
Tools to create maps.
|
| Heuristic<V> |
A
Heuristic generates estimates of the cost to move from a given node to the goal. |
| HorizontalCorridorsV1 | |
| HorizontalCorridorsV2 | |
| HorizontalCorridorsV3 | |
| IColorCenter<T> |
How to manage colors, making sure that a color is allocated at most once.
|
| IColorCenter.Skeleton<T> |
A skeletal implementation of
IColorCenter. |
| IColoredString<T> |
A
String divided in chunks of different colors. |
| IColoredString.Bucket<T> |
A piece of a
IColoredString: a text and its color. |
| IColoredString.Impl<T> |
A basic implementation of
IColoredString. |
| IDistribution |
A way to take an
IRNG and get one or more random numbers from it to produce a double in some statistical
distribution, such as Gaussian (also called the normal distribution), exponential, or various simpler schemes that
don't have common mathematical names. |
| IDistribution.SimpleDistribution | |
| IDungeonGenerator |
Created by Tommy Ettinger on 6/1/2017.
|
| IFilter<T> |
A filter is a function on colors.
|
| IFlawed |
An empty marker interface to indicate that an implementor has known or intentional issues with a key property of its
functionality.
|
| IMarkup<T> |
An interface that lets non-display code request some special rendering for a
T value, and an implementation
can handle this appropriately in display code. |
| IMarkup.StringMarkup |
Probably not that useful on its own, but may be good as an example.
|
| ImmutableZone |
Created by Tommy Ettinger on 11/24/2016.
|
| IndexedDelaunayTriangulator |
Delaunay triangulation.
|
| IntDoubleOrderedMap |
An int-key and int-value insertion-ordered hash map with with a fast implementation, originally from fastutil as
Object2ObjectLinkedOpenHashMap but modified (in
OrderedMap) to support constant-time indexed access of keys,
values, and entries, and reordering. |
| IntIntOrderedMap |
An int-key and int-value insertion-ordered hash map with with a fast implementation, originally from fastutil as
Object2ObjectLinkedOpenHashMap but modified (in
OrderedMap) to support constant-time indexed access of keys,
values, and entries, and reordering. |
| 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
HastyPointHash but will be much faster on GWT. |
| IntSet |
An unordered set where the items are unboxed ints.
|
| IntSet.IntSetIterator | |
| IntVLA |
A resizable, ordered or unordered variable-length int array.
|
| 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.
|
| IRNG |
Interface for full-featured random number generators to implement (it does more than, and includes all of,
RandomnessSource). |
| IsaacRNG |
This is a port of the public domain Isaac64 (cryptographic) random number generator to Java.
|
| IStatefulRNG |
Simply groups the two interfaces
IRNG and StatefulRandomness so some implementations of IRNG can have
their states read from and written to. |
| JitterNoise |
"Classic Perlin" noise with jitter applied to the grid it operates on.
|
| K2<A,B> |
An ordered bidirectional map-like data structure, with unique A keys and unique B keys updated together like a map
that can be queried by A keys, B keys, or int indices.
|
| K2V1<A,B,Q> |
An ordered multi-directional map-like data structure with two sets of keys and one list of values.
|
| LanesMapGenerator |
Generate dungeons with between 1 and 3 primary "lanes" going from the upper left "base" to the bottom right "base"
(and vice versa, since this is symmetrical).
|
| Lathe32RNG |
A modification of Blackman and Vigna's xoroshiro128+ generator using two 32-bit ints of state instead of two 64-bit
longs, as well as modifying the output with two additional operations on the existing state; this is both the fastest
generator on GWT I have found without statistical failures, and a StatefulRandomness.
|
| LFSR |
A Linear Feedback Shift Register that may be used like a StatefulRandomness but is not truly random.
|
| LightRNG |
This is a SplittableRandom-style generator, meant to have a tiny state
that permits storing many different generators with low overhead.
|
| LimitConnectivityFat | |
| LimitedConnectivity | |
| LineAOE |
Line Area of Effect that affects an slightly expanded (DDA) line from a given origin Coord to a given end Coord,
plus an optional radius of cells around the path of the line, while respecting obstacles in its path and possibly
stopping if obstructed.
|
| LineKit |
Tools for constructing patterns using box-drawing characters.
|
| LinnormRNG |
A mid-high-quality StatefulRandomness that is the second-fastest 64-bit generator in this library that is
1-dimensionally equidistributed across its 64-bit outputs.
|
| ListZone |
A zone defined by a
List. |
| LongPeriodRNG |
An RNG that has a drastically longer period than the other generators in SquidLib, other than
IsaacRNG,
without sacrificing speed or GWT support. |
| LOS |
Line of Sight (LOS) algorithms find if there is or is not a path between two
given points.
|
| LowStorageShuffler |
Gets a sequence of distinct pseudo-random ints (typically used as indices) from 0 to some bound, without storing all
of the sequence in memory.
|
| LZSEncoding |
LZ-String compression; wrapped by
LZSPlus for convenience, but extended functionality is available here. |
| LZSPlus |
LZ-String compression, taking Strings and compressing them to other Strings, optionally with some encryption.
|
| Maker |
Utility methods for more easily constructing data structures, particularly those in Java's standard library.
|
| MapModule |
A subsection of a (typically modern-day or sci-fi) area map that can be placed by ModularMapGenerator.
|
| MarkovChar |
A simple Markov chain text generator; call
MarkovChar.analyze(CharSequence) once on a large sample text, then you can
call MarkovChar.chain(long) many times to get odd-sounding "remixes" of the sample text. |
| MarkovObject<T> |
A simple Markov chain generator that works with Lists of some type instead of text like
MarkovTextLimited. |
| MarkovText |
A simple Markov chain text generator; call
MarkovText.analyze(CharSequence) once on a large sample text, then you can
call MarkovText.chain(long) many times to get odd-sounding "remixes" of the sample text. |
| MarkovTextLimited |
A simple Markov chain text generator; it is called "Limited" because it only can be used as an order-1 Markov chain,
meaning only one prior word is looked at.
|
| MaskedShapeGenerator |
Generates procedural shapes based on a mask that determines what values can exist at a location.
|
| MasonNoise |
Noise functions that delegate work to the best-suited noise type for the requested dimensionality, plus some extra
functions that affect a large multi-dimensional area at once.
|
| MathExtras |
Mathematical operations not provided by
java.lang.Math. |
| Maximums |
Part of the JSON that defines a tileset.
|
| Maze2Wide | |
| MazePlus2Wide | |
| Measurement |
A way of measuring what cells are adjacent and how much further any adjacent cells are from other adjacent cells.
|
| MerlinNoise |
Really strange noise functions that typically produce curving black and white shapes when rendered.
|
| MersenneTwister |
Mersenne Twister, 64-bit version as a RandomnessSource.
|
| Messaging |
Helps handle formation of messages from a template, using correct pronouns and helping handle various idiosyncrasies
in English-language text.
|
| Messaging.BeingSubstitution | |
| Messaging.Group | |
| Messaging.NounTrait |
Properties of nouns needed to correctly conjugate those nouns and refer to them with pronouns, such as genders.
|
| MetsaMapFactory |
A map generation factory using Perlin noise to make island chain style maps.
|
| MimicFill |
A class that imitates patterns in an existing 2D boolean array and uses it to generate a new boolean array with a
similar visual style.
|
| MimicWFC |
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.
|
| MiniMover64RNG |
The fastest generator in this library on desktop JVMs; one of Mark Overton's subcycle generators from
this article, specifically a CMR with a 64-bit state, that has
its result multiplied by a constant.
|
| MitchellNoise |
An arbitrary-dimensional noise generator; it's not suitable for real-time use, but could be very useful when used
with unconventional axes, particularly during level generation.
|
| MitchellNoise.Vec4 | |
| MixedGenerator |
A dungeon generator that can use a mix of techniques to have part-cave, part-room dungeons.
|
| MizuchiRNG |
A high-quality StatefulRandomness based on
LinnormRNG but modified to allow any odd number as a stream,
instead of LinnormRNG's hardcoded stream of 1. |
| Mnemonic |
A utility class to print (typically very large) numbers in a way that players can more-meaningfully tell them apart.
|
| ModularMapGenerator |
Generator for maps of high-tech areas like space stations or starships, with repeated modules laid out in random ways.
|
| MonsterGen |
A class for generating random monster descriptions; can be subclassed to generate stats for a specific game.
|
| MonsterGen.Chimera |
A creature that can be mixed with other Chimeras or given additional descriptors, then printed in a usable format
for game text.
|
| MoonwalkRNG |
An IRNG implementation that allows the extra functionality of a StatefulRandomness and a SkippingRandomness, as well
as allowing reverse-lookup of the state that produced a long using the static
MoonwalkRNG.inverseNextLong(long) method,
and distance checks between two generated numbers with the static MoonwalkRNG.distance(long, long) method. |
| Mover32RNG |
One of Mark Overton's subcycle generators from this article,
specifically a cmr^cmr with two 32-bit states; this is the fastest 32-bit generator that still passes statistical
tests, plus it's optimized for GWT (sometimes).
|
| Mover64RNG |
One of Mark Overton's subcycle generators from this article,
specifically a cmr^cmr with two 64-bit states.
|
| MultiSpill |
A randomized flood-fill implementation that can be used for level generation (e.g.
|
| MutableZone |
Created by Tommy Ettinger on 11/24/2016.
|
| NaturalLanguageCipher |
Class that builds up a dictionary of words in an English-language source text to words generated by a
FakeLanguageGen, and can translate a source text to a similarly-punctuated, similarly-capitalized fake text;
it will try to use variants on the translation of the same root word when it encounters conjugations of that root
word or that root word with common English prefixes/suffixes. |
| NeuralParticle |
Creates a field of particles that tend to form a neuron image type
distribution.
|
| NLFSR |
A Non-Linear Feedback Shift Register that may be used like a StatefulRandomness but is not truly random.
|
| Node<V> |
An extended version of
BinaryHeap.Node that also stores a reference to the parent Graph,
a vertex object of type V, a Map of neighbor Nodes to the appropriate Connection per Node, an extra
List of those same Connections for faster iteration, and a lot of internal data used by algorithms in this package. |
| Noise |
A container class for various interfaces and implementing classes that affect continuous noise, such as that produced
by
WhirlingNoise or SeededNoise, as well as static utility methods used throughout noise code. |
| Noise.Basic1D |
A very simple 1D noise implementation, because a full-blown Perlin or Simplex noise implementation is probably
overkill for 1D noise.
|
| Noise.Exponential1D | |
| Noise.Exponential2D | |
| Noise.Exponential3D | |
| Noise.Exponential4D | |
| Noise.Exponential6D | |
| Noise.InverseLayered1D | |
| Noise.InverseLayered2D | |
| Noise.InverseLayered3D | |
| Noise.InverseLayered4D | |
| Noise.InverseLayered6D | |
| Noise.Layered1D | |
| Noise.Layered2D | |
| Noise.Layered3D | |
| Noise.Layered4D | |
| Noise.Layered6D | |
| Noise.Noise1D | |
| Noise.Noise2D | |
| Noise.Noise3D | |
| Noise.Noise4D | |
| Noise.Noise6D | |
| Noise.QuilezNoise |
A hybrid between value and gradient noise that may be faster for 1D noise.
|
| Noise.Ridged2D | |
| Noise.Ridged3D | |
| Noise.Ridged4D | |
| Noise.Ridged6D | |
| Noise.Scaled1D | |
| Noise.Scaled2D | |
| Noise.Scaled3D | |
| Noise.Scaled4D | |
| Noise.Scaled6D | |
| Noise.Slick2D | |
| Noise.Slick3D | |
| Noise.Slick4D | |
| Noise.Slick6D | |
| Noise.Sway1D | |
| Noise.Sway2D | |
| Noise.Turbulent2D | |
| Noise.Turbulent3D | |
| Noise.Turbulent4D | |
| Noise.Turbulent6D | |
| Noise.Viny2D | |
| Noise.Viny3D | |
| Noise.Viny4D | |
| Noise.Viny6D | |
| NumberTools |
Various numeric functions that are important to performance but need alternate implementations on GWT to obtain it.
|
| ObText |
A simple format parser for String-based configuration or data files where JSON is overkill.
|
| ObText.ContentMatcher | |
| ObText.ObTextEntry | |
| OpenAreas | |
| OrbitRNG |
A variant on
ThrustAltRNG that gives up some speed to gain a much better period and the ability to produce
all possible long values over that period. |
| OrderedMap<K,V> |
A generic insertion-ordered hash map with with a fast implementation, originally from fastutil as
Object2ObjectLinkedOpenHashMap but modified to support constant-time indexed access of keys, values, and entries,
reordering, and optional hash strategies for unusual keys, such as arrays or usually-dense numeric values.
|
| OrderedSet<K> |
A generic linked hash set with with a fast implementation, originally from fastutil as ObjectLinkedOpenHashSet but
modified to support indexed access of items, reordering, and optional hash strategies for array keys (which fastutil
does differently).
|
| OrganicMapGenerator |
Map generator using Simplex noise for the formation of "rooms" and then WobblyLine to connect with corridors.
|
| Oriole32RNG |
A modification of Blackman and Vigna's xoroshiro128+ generator using two 32-bit ints of state instead of two 64-bit
longs and also incorporating a large-increment counter (Weyl sequence) that is added to the rotated xoroshiro output;
this is tied with
Lathe32RNG for the fastest generator on GWT I have found that also passes the full 32TB
battery of PractRand's statistical tests. |
| OrthoLine |
A simple line-drawing algorithm that only takes orthogonal steps; may be useful for LOS in games that use Manhattan
distances for measurements.
|
| PacMazeGenerator |
Meant to produce the sort of narrow, looping, not-quite-maze-like passages found in a certain famous early arcade game.
|
| PerlinNoise |
Delegates to
ClassicNoise methods and always uses the same seed (123456789); that means this produces
"Classic Perlin Noise" and not Simplex Noise (both were created by Ken Perlin). |
| PermutationGenerator<T> |
Permutation generator for generating all permutations for all sets up to
20 elements in size.
|
| PermutedRNG |
This is a RandomnessSource in the PCG-Random family.
|
| PhantomNoise |
Arbitrary-dimensional continuous noise that maintains most of the same style even as the dimensionality gets fairly
high.
|
| PintRNG |
A RandomnessSource based on PCG-Random that has a single int of state.
|
| Placement |
Utility class for finding areas where game-specific terrain features might be suitable to place.
|
| PointAOE |
An AOE type that has a center Coord only and only affects that single Coord.
|
| PointHash |
A group of similar methods for getting hashes of points based on long coordinates in 2, 3, 4, or 6 dimensions and
a long for state.
|
| PoissonDisk |
This provides a Uniform Poisson Disk Sampling technique that can be used to generate random points that have a
uniform minimum distance between each other.
|
| PoliticalMapper |
When you have a world map as produced by
WorldMapGenerator or some other source, you may want to fill it with
claims by various nations/factions, possibly procedural or possibly hand-made. |
| ProbabilityTable<T> |
A generic method of holding a probability table to determine weighted random
outcomes.
|
| ProceduralMessaging |
Combines
Messaging with Thesaurus and optionally NaturalLanguageCipher to make variations on
a sentence structure. |
| ProceduralMessaging.AssociatedName |
Data class that stores a name String and one or more Strings that may be used as part of a title with that name,
typically using categories from
Thesaurus to add variety. |
| ProjectionTools |
Added to SquidLib by Tommy Ettinger on 7/4/2018, using MIT-licensed work by Justin Kunimune from
his Map-Projections repo.
|
| PulleyRNG |
A very-high-quality StatefulRandomness that is meant to be reasonably fast, but also to be robust against frequent
state changes, and is built around a strong determine() method.
|
| Radius |
Basic radius strategy implementations likely to be used for roguelikes.
|
| RandomBias |
A class that wraps an RNG and allows different String keys to be associated with biases toward low or high results
when a method is called that gets a number from the wrapped RNG.
|
| RandomnessSource |
This interface defines the interactions required of a random number
generator.
|
| Reach |
A struct-like class that holds information about targeting rules for actions or other effects that reach from one
square into another one, with certain potential restrictions.
|
| Rectangle |
Rectangles in 2D grids.
|
| Rectangle.Impl | |
| Rectangle.Utils |
Utilities pertaining to
Rectangle |
| RectangleRoomFinder |
An algorithm to find rectangle areas in dungeons.
|
| Ref2CornerCaves | |
| Region |
NOTE: You should consider
GreasedRegion before using this class, unless you know Region does exactly
what you want. |
| RegionMap<V> |
A small extension of OrderedMap that specifically handles
short[] regions as produced by CoordPacker. |
| RNG |
A wrapper class for working with random number generators in a more friendly way.
|
| RNG.CustomRandom |
A subclass of java.util.Random that uses a RandomnessSource supplied by the user instead of the default.
|
| RoomFinder |
A small class that can analyze a dungeon or other map and identify areas as being "room" or "corridor" based on how
thick the walkable areas are (corridors are at most 2 cells wide at their widest, rooms are anything else).
|
| RoomsAndCorridors | |
| RoomsAndCorridors2WideDiagonalBias | |
| RoomsLimitConnectivity | |
| RoundRoomsDiagonalCorridors | |
| SectionDungeonGenerator |
A good way to create a more-complete dungeon, layering different effects and modifications on top of a dungeon
produced by DungeonBoneGen or another dungeon without such effects.
|
| SectionDungeonGenerator.FillEffect |
The effects that can be applied to this dungeon.
|
| SectionMap |
A Map-like collection that allows storing subdivisions of a 2D array with names (always Strings) and
identifying numbers, then looking up
Coords to find the associated name and/or number, or or looking up
a subdivision with a name or number to get a GreasedRegion back. |
| SeededNoise |
More advanced noise functions, in 2D, 3D, 4D, and 6D, with the last two as options for generating seamlessly-tiling
noise using
Noise.seamless2D(double[][], long, int, Noise.Noise4D) and/or
Noise.seamless3D(double[][][], long, int, Noise.Noise6D). |
| SerpentDeepMapGenerator |
Generate dungeons based on a random, winding, looping path through 3D space, requiring a character to move up and
down as well as north/south/east/west to get through the dungeon.
|
| SerpentMapGenerator |
Generate dungeons based on a random, winding, looping path through 2D space.
|
| ShortVLA |
A resizable, ordered or unordered short variable-length array.
|
| ShuffledIntSequence |
An infinite sequence of pseudo-random ints (typically used as indices) from 0 to some bound, with all possible ints
returned in a shuffled order before re-shuffling for the next result.
|
| SilkRNG |
An IStatefulRNG implementation that is meant to provide random numbers very quickly when targeting GWT but also to
produce the same numbers when used on desktop, Android, or other platforms, and that can have its state read as a
StatefulRandomness; it is thus like
GWTRNG but should perform better on recent desktop JVMs. |
| SimpleCaves2Wide | |
| SkippingRandomness |
A simple interface for RandomnessSources that have the additional capability to skip forward or backward in their
generated number stream.
|
| SobolQRNG |
Implementation of a Sobol sequence as a Quasi-Random Number Generator.
|
| SoundMap |
This class is used to determine when a sound is audible on a map and at what positions.
|
| SpatialMap<I,E> |
A data structure that seems to be re-implemented often for games, this associates Coord positions and generic I
identities with generic E elements.
|
| SpatialMap.SpatialTriple<I,E> | |
| SpikeDistribution |
An IDistribution that produces results between -1.0 inclusive and 1.0 exclusive, but is much more likely to produce
results near 0.0, and does not "round off" like a Gaussian curve around the midpoint.
|
| SpikeDistribution.SimpleSpikeDistribution |
A variant on SpikeDistribution that has its range shrunk and moved from
[-1,1) to [0,1). |
| Spill |
A randomized flood-fill implementation that can be used for level generation (e.g.
|
| SpillWorldMap |
Generates a procedural world map and fills it with the requested number of factions, keeping some land unclaimed.
|
| SquareRoomsWithRandomRects | |
| SquidID |
A UUID-like identifier; not compatible with Java's standard UUID but will work on GWT.
|
| SquidIterator |
Iterators that return instances of
Coord and that are useful in
roguelikes. |
| SquidIterators |
Instances of
SquidIterator. |
| SquidIterators.AroundCounterClockWise |
An iterator that iterates around a starting position (counter clockwise).
|
| SquidIterators.BottomLeftToTopRight |
Iterator that starts from the bottom left element of the grid, to the top
right.
|
| SquidIterators.CenteredSquare |
An iterator that returns cells in a square around a location.
|
| SquidIterators.Down | |
| SquidIterators.Left | |
| SquidIterators.Linear |
An iterator to iterate from a starting position (inclusive) and going in
one Direction.
|
| SquidIterators.RectangleFromBottomLeftToTopRight |
An iterator that starts from a cell and iterates from the bottom left to
the top right, in the rectangle defined by the given width and height.
|
| SquidIterators.Right | |
| SquidIterators.Up | |
| SquidIterators.VerticalUp |
An iterator to iterate from a starting position (exclusive) and going up.
|
| SquidTags |
Tags used by SquidLib when calling libgdx's logging system.
|
| Starfish32RNG |
A modification of Blackman and Vigna's xoroshiro64** generator; uses two 32-bit ints of state like
Lathe32RNG
but has better equidistribution. |
| StatefulRandomness |
A simple interface for RandomnessSources that have the additional property of a state that can be re-set.
|
| StatefulRNG |
A slight variant on RNG that always uses a stateful RandomessSource and so can have its state
set or retrieved using setState() or getState().
|
| StringConvert<T> |
Used to standardize conversion for a given type,
T, to and from a serialized String format. |
| StringKit |
Various utility functions for dealing with Strings, CharSequences, and char[]s; this has lots of methods to convert
to and from Strings and numbers, but also has tools to wrap long CharSequences to fit in a maximum width, join arrays
of various items into long Strings, split/search/count occurrences of literal char arrays or CharSequences without
using any regex, and generally tidy up generated text.
|
| SymmetryDungeonGenerator |
A variant on
MixedGenerator that creates bi-radially symmetric maps (basically a yin-yang shape). |
| TangleRNG |
A very fast generator on 64-bit systems that allows choosing any of 2 to the 63 odd-number streams.
|
| Technique |
A simple struct-like class that stores various public fields which describe the targeting properties of a skill,
spell, tech, or any other game-specific term for a targeted (typically offensive) ability we call a Technique.
|
| Thesaurus |
A text processing class that can swap out occurrences of words and replace them with their synonyms.
|
| ThinDungeonGenerator |
Created by Tommy Ettinger on 8/7/2016.
|
| Threat |
A small class to store the area that a creature is perceived by other creatures to threaten.
|
| ThrustAltRNG |
A random number generator that is extremely fast but can't return all possible results.
|
| Tile |
Part of the JSON that defines a tileset.
|
| Tileset |
The outermost class in the JSON that defines a tileset.
|
| TilesetType |
An enumeration of all the kinds of dungeon that DungeonBoneGen
knows how to draw already.
|
| TimSort<T> |
A stable, adaptive, iterative mergesort that requires far fewer than n lg(n) comparisons when running on partially sorted
arrays, while offering performance comparable to a traditional mergesort when run on random arrays.
|
| TuringPattern |
A technique for producing organic-seeming patterns via iterative processing of random values (reaction-diffusion).
|
| TweakRNG |
Somewhat experimental RNG that can be configured to smoothly transition between producing mostly values in the
center of its range, to producing more values at or near the extremes, as well as favoring high or low results.
|
| TwistedLine |
Like
WobblyLine, this generates orthogonally-connected paths of Coord that meander through an area;
unlike WobblyLine, this won't ever generate paths that cross themselves. |
| UndirectedGraph<V> |
A kind of
Graph where all connections between vertices are two-way and have equal cost for traveling A to B
or B to A. |
| UndirectedGraphAlgorithms<V> |
Algorithms specific to undirected graphs, like
DefaultGraph, as well as general Algorithms. |
| UnorderedMap<K,V> |
A generic unordered hash map; generally prefer
HashMap unless you need array keys. |
| UnorderedSet<K> |
A generic unordered hash set with with a fast implementation, based on
OrderedSet in this library, which is
based on the fastutil library's ObjectLinkedOpenHashSet class; the ordering and indexed access have been removed to
potentially reduce the time cost of insertion and removal at the expense of increasing time cost for access by index. |
| ValueNoise |
A low-quality continuous noise generator with strong grid artifacts, this is nonetheless useful as a building block.
|
| VanDerCorputQRNG |
A quasi-random number generator that goes through one of many sub-random sequences found by J.G.
|
| Voronoi |
A Java implementation of both a 2D Delaunay triangulation algorithm and a Voronoi polygon data structure.
|
| Voronoi.Edge | |
| Voronoi.Polygon | |
| Voronoi.Triangle | |
| WaypointPathfinder |
Pathfind to known connections between rooms or other "chokepoints" without needing full-map Dijkstra scans.
|
| WeightedLetterNamegen |
Based on work by Nolithius available at the following two sites
https://github.com/Nolithius/weighted-letter-namegen
http://code.google.com/p/weighted-letter-namegen/
|
| WeightedTable |
A different approach to the same task
ProbabilityTable solves, though this only looks up an appropriate index
instead of also storing items it can choose; allows positive doubles for weights but does not allow nested tables for
simplicity. |
| WhirlingNoise |
A Noise class that's here for compatibility; it extends
SeededNoise and delegates to it for all methods
except WhirlingNoise.noiseAlt(double, double) and WhirlingNoise.noiseAlt(double, double, double). |
| WhiteNoise |
Performance-oriented white noise generator for 1D, 2D, 3D, 4D, and 6D.
|
| WildMap |
A finite 2D area map for some kind of wilderness, adapting to different ecosystems by changing its output.
|
| WildMap.MixedWildMap |
A subclass of
WildMap that serves as a ragged edge between 2, 3, or 4 WildMaps in a square intersection. |
| WobblyLine |
A drunkard's-walk-like algorithm for line-drawing "wobbly" paths.
|
| WorldMapGenerator |
Can be used to generate world maps with a wide variety of data, starting with height, temperature and moisture.
|
| WorldMapGenerator.BiomeMapper | |
| WorldMapGenerator.DetailedBiomeMapper |
A way to get biome information for the cells on a map when you want an area's biome to be a combination of two
main biome types, such as "Grassland" or "TropicalRainforest", with the biomes varying in weight between areas.
|
| WorldMapGenerator.EllipticalHammerMap |
A concrete implementation of
WorldMapGenerator that projects the world map onto an ellipse that should be
twice as wide as it is tall (although you can stretch it by width and height that don't have that ratio). |
| WorldMapGenerator.EllipticalMap |
A concrete implementation of
WorldMapGenerator that projects the world map onto an ellipse that should be
twice as wide as it is tall (although you can stretch it by width and height that don't have that ratio). |
| WorldMapGenerator.HyperellipticalMap |
A concrete implementation of
WorldMapGenerator that projects the world map onto a shape that resembles a
mix part-way between an ellipse and a rectangle. |
| WorldMapGenerator.LocalMap |
A concrete implementation of
WorldMapGenerator that does no projection of the map, as if the area were
completely flat or small enough that curvature is impossible to see. |
| WorldMapGenerator.LocalMimicMap |
An unusual map generator that imitates an existing local map (such as a map of Australia, which it can do by
default), without applying any projection or changing heat levels in the polar regions or equator.
|
| WorldMapGenerator.MimicMap |
An unusual map generator that imitates an existing map (such as a map of Earth, which it can do by default).
|
| WorldMapGenerator.RotatingSpaceMap |
A concrete implementation of
WorldMapGenerator that imitates an infinite-distance perspective view of a
world, showing only one hemisphere, that should be as wide as it is tall (its outline is a circle). |
| WorldMapGenerator.RoundSideMap |
A concrete implementation of
WorldMapGenerator that projects the world map onto a shape with a flat top
and bottom but near-circular sides. |
| WorldMapGenerator.SimpleBiomeMapper |
A way to get biome information for the cells on a map when you only need a single value to describe a biome, such
as "Grassland" or "TropicalRainforest".
|
| WorldMapGenerator.SpaceViewMap |
A concrete implementation of
WorldMapGenerator that imitates an infinite-distance perspective view of a
world, showing only one hemisphere, that should be as wide as it is tall (its outline is a circle). |
| WorldMapGenerator.SphereMap |
A concrete implementation of
WorldMapGenerator that distorts the map as it nears the poles, expanding the
smaller-diameter latitude lines in extreme north and south regions so they take up the same space as the equator;
this counteracts certain artifacts that are common in Simplex noise world maps by using a 4D noise call to
generate terrain, using a normal 3D noise call's result as the extra 4th dimension. |
| WorldMapGenerator.TilingMap |
A concrete implementation of
WorldMapGenerator that tiles both east-to-west and north-to-south. |
| XoRoRNG |
A port of Blackman and Vigna's xoroshiro128+ generator; should be very fast and produce medium-quality output.
|
| XoshiroStarPhi32RNG |
A modification of Blackman and Vigna's xoshiro128 generator with a different "scrambler" than the default; this
generator has four 32-bit states and passes at least 32TB of PractRand (with one "unusual" anomaly at 4TB).
|
| ZOI |
Calculates the Zone of Influence, also known as Zone of Control, for different points on a map.
|
| Zone |
Abstraction over a list of
Coord. |
| Zone.Helper | |
| Zone.Skeleton |
A convenience partial implementation.
|