3.0.6 "But What About Five?"

This release has been slowly bubbling up for a long time, and over a year since the last SquidLib release, here we are. Some GWT-related changed in libraries forced a more concrete release than JitPack would provide with just commits; if you use GWT you do need to update a few .gwt.xml files. The actual features here are less clear than the necessary changes, but there are quite a few bug fixes. DijkstraMap, for instance, had a bug present for literal years that was finally found and fixed. There's some other fixes to math things, like fastFloor() and also to symmetrical FOV. There's a new UnifiedNoise class that uses the same, more legible technique to generate Simplex noise in 2D through 6D, instead of how SeededNoise uses different styles of code for 4D, 5D, and 6D. There's some fixes in FastNoise, such as one that affected 4D ridged cubic noise only.

So, if you use GWT, you need to change .gwt.xml files. All SquidLib usage needs squidlib-util, so GWT needs:

    <inherits name="squidpony.squidlib-util" />

If you use the display module, you also need

    <inherits name="squidpony.squidlib" />

And if you use squidlib-extra, you also need

    <inherits name="squidpony.squidlib-extra" />

Other dependencies, if you use them separately, changed as well. An inherit on regexodus will need to change to regexodus.regexodus, and an inherit on anim8 changes to com.github.tommyettinger.anim8 . In general, any library that didn't have a . in the inherits was risking causing some strange GWT bugs, so I've been going through and updating a lot of libraries.

The assets are here as well, only in a .zip file this time, because if you are using the JVM, you can open a .zip file.

3.0.4 "Rolling Ever Onward"

This release updates quite a lot of dependencies of SquidLib, such as libGDX (1.10.0), RegExodus (0.1.12), and anim8-gdx (0.2.10). It adds some new features, like better handling for repeated rolls of dice using the Dice class, more things it can generate with Thesaurus, and a lot of attention to noise in the Noise subclasses and FastNoise. As the new CHANGES file documents, there is a breaking change in RNG and AbstractRNG with nextLong(long) and nextSignedLong(long); these behaved quite badly before in some cases, and should be correct now. Some seeded generation will be different if you use Noise.Ridged varieties or Thesaurus; the Ridged noise types now rotate octaves after the first, which helps reduce some unpleasant artifacts with ClassicNoise and some other types, while Thesaurus can generate more types of plants and such. FastNoise has a fractalSpiral option that can be set on to rotate later octaves, like Noise.Ridged but only applying to varieties of noise that will see a difference (Foam, for instance, doesn't change noticeably, so fractalSpiral does nothing to it). Some fonts are updated or added, and these are in the assets archives here.

Good luck, and I hope you make something great!

3.0.3 "New Year's Hack'n'Slashing Eve"

Well, it's been a rollercoaster year, but SquidLib 3.0.0 was released, followed by a 3.0.1 that I quickly forgot about, and a 3.0.2 release that was top-notch at the time... But then libGDX 1.9.12 came out about 2 months ago, and broke compatibility with earlier versions. Whoops! Time for 3.0.3, better late than never! This release updates the libGDX dependency to 1.9.12, the anim8-gdx dependency to 0.2.4, and includes some fixes from SquidSquad (see the note in the README at the bottom for an introduction to SquidSquad; it's the early-stage re-assembly of SquidLib for the 4.x line). Notably, a many-year-old bug (that occurred extremely rarely) in SerpentDeepMapGenerator is fixed, as is an odd bug in FakeLanguageGen's accent-mark detection. There's some noise range improvements for a few kinds of noise, we have triangular-mapped blue noise in the library now (useful for smoother dithering and some other applications that need to look subtle), there's a generalized bias-gain function by Jon Barron that's very handy for adjusting distributions, the asin(), acos(), and related methods are much faster, and there's a new font (Cascadia Mono; it's quite eye-pleasing IMO). Sound good?

3.0.2 "The Fixer"

This release mostly fixes an incompatibility in the last release (3.0.1) with JDK 7 and JDK 8, but also fixes a long-standing bug in IRNG.nextSignedInt() and nextSignedLong() when the bound is negative. It updates the anim8-gdx dependency to 0.2.2, which allows using the excellent SCATTER dithering algorithm. OrganicMapGenerator seems much better thanks to a good idea by Discord user tann, of "Slice & Dice" fame. Perhaps most useful in the future, SparseLayers now lets you get the main chars displayed on the grid (not invisible ones and not chars behind other chars) as a 2D char array using frontChars(); this could be handy for "bones files."

I hope this release works better than the last one!

3.0.1 "The Fifth-Dimensional Planet Smasher"

This release mostly consists of improvements to the noise code to support 5D noise (4D and 6D were supported before, with a weird gap for 5D), a hybrid noise type called Honey, and a hash-caching subclass of FastNoise called VastNoise. It also has some bug fixes of varying levels of importance (such as the toArray() methods on several collections being incorrect), and performance boosts for world map generation. It shouldn't have any backwards-incompatible API changes. The closest thing to a breaking change is that ColoredStringList is now deprecated, because its API is more confusing than helpful. There are a few other minor additions, like some code to help with Gaussian distributions in MathExtras (the probit() method), and the ability to save and load archive files of Thesaurus data so results can be replicated if Thesaurus changes in the future.

One dependency is possibly different; anim8-gdx (which is only required by squidlib) is at version 0.2.0 in this release. RegExodus and libGDX are the same, 0.1.10 and 1.9.11 respectively.

I hope this small set of changes is helpful! SquidSetup should be updated soon for 3.0.1 support.

3.0.0 Stable: "The Kraken"

Nearly 5 years. 2167 commits. A complete remaking of SquidLib from a Swing-based roguelike library that could barely handle animations, to a full-blown optionally-libGDX-based colossus of procedural generation. We're finally here. The changelog from 2.x to 3.0.0 is too much to write here; Swing is no longer used at all in SquidLib, the text-based display is in the optional squidlib module (it uses libGDX 1.9.11 and anim8-gdx 0.1.6), and most of the code is in squidlib-util (which uses RegExodus 0.1.10).

All of the assets, the JARs for squidlib-util, squidlib, squidlib-extra, and some of their dependencies, RegExodus and anim8-gdx, are here, but you're strongly encouraged to build a Gradle project using SquidSetup, either a "JITPACK" release that grabs the latest commit to SquidLib from JitPack.io, or a stable 3.0.0 release. The libGDX JARs aren't here because there are quite a lot of them, and they vary with usage.

What's new? Well, quite a bit.

In squidlib-util, there's most of the updates. There's lots more dungeon generators, and existing ones have been improved and standardized. DijkstraMap has been heavily optimized, and is supplanted by A-Star code from simple-graphs, making pathfinding much faster. There's lots of random number stuff that people are unlikely to use, but some adds features that are useful in everyday cases. There's lots of improvements to continuous noise (such as Perlin and Simplex); see FastNoise for the current best part for a lot of usage. There's lots more text generation code; FakeLanguageGen roughly imitates various real-world and/or fictional languages, but can also generate new languages and mix existing ones. In the readable-English-generation arena, there's Thesaurus, Messaging, ProceduralMessaging, StringKit, and more. There's world map and wild-area map generators. Everything is compatible with GWT unless specifically marked otherwise, so you can use SquidLib in pure-Java games that target web browsers using GWT (you can also target web browsers with TeaVM if you use Arc, and that allows using Kotlin, Scala, or other languages, but Arc is in constant development).

The squidlib text display code has seen some updates too. It uses libGDX now, mostly taking advantage of some convenient features in scene2d.ui while ignoring the complex layout there. There's many, many more colors in SColor, all documented heavily so you can see a preview of a color from the docs. Fonts use TextCellFactory now, usually a predefined one from DefaultResources, and can have a "stretchable" (signed distance-field) or "crisp" (multi-channel signed distance field) effect to let them stretch cleanly. You can still use the old SquidPanel and SquidLayers code, but you are encouraged to use SparseLayers instead, since it handles the layers-of-mostly-empty-cells situation much more easily, and has a cleaner API. You can filter colors using Filters or FloatFilters, with various color adjustments defined in those classes (you can define more yourself, too). There's some scene2d-based effects in PanelEffect, which can make explosions and projectiles of various types easier to add.

There's also a small new squidlib-extra module just for handling serialization; it depends on libGDX but not for display (just file handling and JSON support). It should help a lot if you want to save to Preferences on GWT; no options other than Preferences are available to save there.

Thanks for being a part of this journey! Let's see what you will make!

Beta 10 for 3.0.0

This release is just a relatively-more-stable mark in the seemingly-indefinite sequence of JitPack commit-releases, but it's an important mark to make because this release is the first commit to depend on the new libGDX 1.9.10 release, and some things have changed in 1.9.10 (libGDX was able to update to GWT 2.8.2, which is a worthwhile improvement, so setup stuff will need changes). The last beta release was almost 2 years ago, so... it's time.

If you only use stable/beta versions, a ton will have changed or have been added since b9. A recent breaking change was DijkstraMap.Measurement and virtually-identical copies to that enum in other classes getting consolidated into Measurement in the squidpony.squidgrid package; this just reduces repetition of incompatible enums. An earlier, non-breaking change is the suggestion to use FilterBatch instead of libGDX's SpriteBatch, since FilterBatch adds features, keeps compatibility with SpriteBatch from libGDX 1.9.8 and earlier, and is a little faster. The usage of packed floats to encode colors has increased, and they're a main way of using the API for the newer, faster SparseLayers and related classes. If you don't want to deal primarily with floats for colors, SColor constants have a very simple toFloatBits() method that doesn't need to recalculate the packed float value if the SColor hasn't been modified (so you can keep using SColor constants from the huge list in that file, and only get their float encoding when necessary). The term "YCwCm" sometimes shows up in color-related code now; this is a way of handling colors and modifications to those colors that represents a color as a Y value for brightness (from 0 for black to 1 for white), a Cw value for color warmth (green or blue near -1, yellow or red near 1), and a Cm value for color "mildness" (red or blue near -1, yellow or green near 1). YCwCm edits to colors are a handy new way of increasing or decreasing the aesthetic warmth of colors when certain effects in a game may change the actual warmth of an area. There's MSDF fonts in the assets and in DefaultResources now, which are very crisp when resized. Noise code has been somewhat consolidated into SeededNoise and FastNoise, both of which are fairly fast, but SeededNoise uses a long seed and natively produces double results (it ties in well to the Noise nested classes), while FastNoise uses an int seed by default, natively produces float results, and has features within itself to choose different noise options that would need things like Noise.Ridged3D otherwise. The default random number generator and hashing code has changed, so any seeds given to RNG are likely to result in different values, but the current code is very high-quality and, in particular for the hashing code in CrossHash, passes stringent tests that earlier versions didn't, while also being a little faster. Data structures have gotten some attention; OrderedMap and OrderedSet now can be sorted given a Comparator, which is a very reasonable feature considering they already could be reordered. There's a few new primitive-backed Maps and Sets, and even though there are UnorderedMap and UnorderedSet, you probably only want to use those if you need a custom IHasher (such as for array keys), since they aren't as fast as HashMap and HashSet. World map generation has had a lot of additions, and you can get a rotating view of a planet now, among other features.

There's a lot of new additions, so I hope you enjoy this release!

3.0.0 Beta 9

This release includes many changes since the last beta in February, probably too many to list here. Potentially of note are:

• Better support for scrolling a camera to follow a character and center on that character in the text-based display.
• New "sparse" rendering option for text-based display using SparseLayers, which is generally cleaner and requires fewer special cases than SquidPanel/SquidLayers; it doesn't use up any time trying to render cells that don't have anything in them (such as cells that have unknown contents)
  • This has excellent support for the aforementioned camera scroll
• PanelEffect allows various "special effects" to be placed into either a SquidPanel or a SparseLayers, such as explosions
• Various utilities for Simplex Noise and related types of coherent noise
• World map generation algorithms that use the previously-mentioned noise to make landmasses and establish climate types for areas
  • Political maps can be generated as well
• Dungeon map generators that produce better caves or unusual layouts for room-and-corridor maps
• More assets in the accompanying .zip file, including the new font Iosevka (with several variants, including multiple slab-serif versions)
• Distance field fonts are all rendered more cleanly now, and will resize to smaller sizes and look fine
• Improved random number tools
  • ThrustRNG is a StatefulRandomness (meaning it can be given to StatefulRNG or RNG) that may become the default RandomnessSource at some point due to its high speed and optimal quality, while having rare features like skip()
  • CriticalRNG is an unusual subclass of RNG that can have a luck variable affect its results to be higher or lower than the normal limits for what a method is allowed to return; it may be useful for simulating some rare events that are affected by some "fortune" number
• More serialization support, in and out of squidlib-extra
  • Many classes can be written to or read from Strings in squidlib-util, and more gain this ability in squidlib-extra
  • There is support for scrambling saved files in a reversible way to make it harder for players to tamper with save or read-only configuration files
• StringKit supplies more ways to convert certain values to and from Strings, and also stores large Strings holding organized sections of the characters that can be reasonably used with the fonts in the display module
• Many more languages in FakeLanguageGen, and more ways to manipulate them
• Many more colors in SColor, including some that are named specially so they can be looked up conveniently
  • Documentation has also improved for all colors in SColor, with the hue, saturation, value, and RGB values all listed for each color
• Improvements to SquidInput to allow remapping keyboard inputs to the inputs they should be handled as
• GWT improvements; now that this uses libGDX 1.9.6 and GWT 2.8.0, much more of the JDK is available to use, and some code that can be optimized on GWT is given a special-case implementation using GWT's super-sourcing feature
  • NumberTools is the main example of this, and it takes advantage of JS Typed Arrays when on GWT to significantly speed up some conversions between double/float and int/long.

The main way of relying on this release should be either using SquidSetup (the JAR is in the downloads below) or via Maven Central. Existing Gradle, Maven, Leiningen, SBT, and other kinds of projects can depend on the releases on Maven Central with the instructions at that link. SquidSetup will handle creating a Gradle project and acts like the libGDX setup tool in that way, but includes SquidLib's assets and a sample project. If you want to manually manage your dependencies, JARs are provided below as well (this includes a dependency that all the other JARs need, RegExodus 0.1.9). regexodus is needed by squidlib-util (the core), which is needed by squidlib (the display module) and squidlib-extra (for serialization). Both squidlib and squidlib-extra depend on libGDX 1.9.6 .

I hope you find this release useful!

3.0.0 beta 8

This release has a lot of new features and some breaking changes relative to beta 6. It's recommended to upgrade if you used an older version; if you encounter bugs, please post an issue here on GitHub. Beta 7 had issues with a dependency that made it fail to compile on GWT, so now there's a new version of that dependency and a new version of SquidLib's beta. Otherwise, beta 8 is almost identical to beta 7, just with an additional bugfix in squidlib-extra and a small added class (LFSR, for generating random-seeming sequences that go through every number in their period except 0). So, the release notes aren't going to change either.

The biggest breaking change is probably the switch to our OrderedMap and OrderedSet classes instead of LinkedHashMap and LinkedHashSet, which allows some nice performance improvement on things like iteration, as well as constant-time lookup by index. That change can be adjusted in almost all cases by just doing a find/replace in your code from LinkedHash to Ordered and import squidpony.squidmath.OrderedMap; and/or import squidpony.squidmath.OrderedSet; as needed. Some methods have also been changed to be more lenient on what data structures they can take as parameters, so the change to OrderedSet sometimes isn't significant where code now takes a Set or Collection interface instead of a LinkedHashSet specifically. The second-biggest breaking change is that the default assets are no longer distributed inside the squidlib display module's jar, and you can download the assets separately if you want them (and since you only need the ones you use, the size of a distributed game should be smaller). The file assets.jar here and in the top-level directory of this repo has the full set of assets, and you can download files individually from the assets/ folder of this repo. The dependency on RegExodus is updated to 0.1.9, which has been fixed since 0.1.8's failure on GWT. The dependency on libGDX is 1.9.3, because 1.9.4 and 1.9.5 each have serious bugs that affect BitmapFonts and so affect our display a lot. LibGDX is not included in the dependencies here, but the current versions of RegExodus and BlazingChain (only needed for the optional squidlib-extra module) are provided here to avoid any hassle tracking them down.

For features, the squidlib-extra module is now available with serialization code that depends on libGDX but doesn't handle rendering, so it can be used in graphical games that use squidlib-util (or text-based ones that use squidlib) and want a good way to save and load certain data in a compact way (including on GWT). CustomDijkstraMap is an alternate way of handling pathfinding when the rules for adjacent cells are more complex than just (x,y) being next to (x+1,y), such as on some maps with thin walls, games with rotation within a cell, or possibly maps with elevation blocking movement between cells. A few demos are present to test it, for thin walls and rotation mainly. All of the pathfinding code has been seriously optimized. There's improvements to the text generation code. There's improvements to the text display code for variable-width fonts (thanks to @smelc and noticeable in Dungeon Mercenary). There's better color handling in the display module. The Zone interface helps bridge the gap between different ways of representing collections of points in a 2D area, with GreasedRegion implementing it and CoordPacker able to produce data that can be used with it. In general, most parts of the code have gotten some attention.

3.0.0 beta 6

This is a small release that adds a few useful features, but is mainly being pushed out so close to b5 because it fixes a very annoying bug that affects the display module. If certain animations were started too close to each other in time, the counter for ongoing animations would get stuck above 0, and any game logic that waited for animations to finish would continue to wait forever (effectively freezing games that did that waiting behavior, including EverythingDemo in SquidLib itself). This is already uploaded to Maven Central, so games that don't need the new assets can simply change "3.0.0-b5" to "3.0.0-b6" in their dependencies.

New features include:

• MimicFill, a port of the amazing ConvChain library in C# to Java that's integrated with SquidLib's conventions
• GapShuffler, a nice way to shuffle mid-sized sequences without the same item appearing twice in a short span of the sequence. It's used by...
• Thesaurus, which can be handy for procedurally generating varied passages of text, or thematic names of groups like "Glorious Blaçeglè Dynasty." It only needs a set of words it knows synonyms for, or special keywords that will get replaced by one of a list (shuffled by GapShuffler to ensure a word doesn't appear too often in a "clump").
• Maker, a very simple class that provides convenience methods for constructing cumbersome classes from Java's standard lib with one method call. It can construct LinkedHashMap, ArrayList, and LinkedHashSet currently because those 3 showed up the most within SquidLib.
• Various improvements to LinesPanel, including a general cleanup of the API, top-to-bottom and bottom-to-top modes of placement, and text wrapping.
• Improvements to various color-related things, including ColoredStringList being added to -util and IColorCenter (plus its two implementations, one being SquidColorCenter in the display module) gaining methods to adjust saturation ("greify"-ing a color or making it more vivid) and interpolate between colors. SquidColorCenter also has a way to generate a very-non-linear gradient between two colors that can make many variations along the way, zigzagGradient().
• Region, a simplified wrapper around the functionality of CoordPacker. It is usable now but should continue to gain features on an ongoing basis.
• FOV can now mix FOV maps more easily, which can be useful if lighting a distant area using an FOV map. This is able to limit the visible area to the area inside one "LOS map" (just a very-high-radius FOV map) where someone like the player can actually see a distant light.
• Various improvements to FakeLanguageGen, including better handling of modifiers (not all-or-nothing in each word anymore), changes to how Imitation Hindi is romanized, and the new Imitation Arabic (along with a recommended modifier that simplifies the generated Arabic so it is more pronounceable in general, though it probably changes some sounds from what would be more authentic).
• Small additions to LanguageCipher so you can choose not to store different dictionaries if memory is a concern. It also won't duplicate existing words by default (though it needs to store a reverse dictionary), which allows the deciphering to be much more reliable.
• All variants of RNG and RandomnessSource can be copied using copy(), with the expected behavior for all but ChaosRNG (which shouldn't allow copying to prevent possible prediction).
• Icons from http://game-icons.net have been added to the assets directory here and to SquidSetup's default group of assets, with a distance field effect added that will make them usable and resizable in conjunction with the various "stretchable" fonts in DefaultResources. These are CC-BY licensed, so if you use them, you should respect the license supplied with them (either here or with SquidSetup's generated projects).
• LibGDX and RegExodus versions updated to 1.9.3 and 0.1.5, respectively. If you need the jars for RegExodus, they're here .

So, I hope this comes in handy; there were other bugs fixed as well but only one was as serious as the one already mentioned (a long-standing problem where DijkstraMap would throw ArrayIndexOutOfBoundsExceptions with maps not sealed by walls all around).