Initially drafted on May 11th, revised and published on the .
The Beginnings of Starloader
The Idea was born
Even though the idea for Starloader in this specific manner only sprang up until around January 2021, the groundworks for it have been laid a long time before it.
In 2018 I started to toy around with Java, as I had almost no idea on what I was doing, I wasn't able to create anything of importance even if I wanted to,
however the experience that I gained from it was very valueable and probably life defining for me. At the same time I was - though not as much as in 2017 - an
active Member of the Theotown community. What I did not know at the time and only learned a bit later is that Theotown was also written in Java, but it was for
android only and not of much relevance of being moddable (yet). At the same time I played another game, Galimulator. Unlike for Theotown I was not involved in the community
at all (I didn't use Discord at that time and the Galimulator community is not present outside Discord), so the thought of modding Galimulator would have been unthinkable
for me at that time. However the tables took a turn in late 2019, when I released bake, a bukkit plugin. I also bought Galimulator at that time and quickly realised
that it was also developed in Java due to the distinctive look of Java AWT Components (at that time Dialogs used Java AWT instead of libGDX Widgets) however I did
not think too much of it other than a "oh nice, but this is annoying". Throughout 2020 I radically became more and more involved in Bukkit and the more time I spent with it
the more experience with java in general I had. With the required experience I had always the idea of modding Theotown, which by then released to Desktop versions. However since I never actually
bought the game on there this never happened. I somehow became invested in the Minestom (a Minecraft server reimplementation) community and learned about the basics
of Spongepowered Mixins and I eventually tried to mod Galimulator by using a simple wrapper using Minestom classloading. This wrapper ended up being named Galimulator-Starloader
though I most often omit the Galimulator part nowadays.
In brief: Starloader could have just as easily been the first Theotown modding framework or yet another minecraft mod API.
Very early life: Jan + Feb
Galimulator-Starloader was written initially as a boilerplate solution, though what was initially boilerplate became more permament. I have yet to get rid of minestom internals
and I likely will never do so in the near future. However the reliance of Spongepowered Mixins had some limitations that became quickly visible as Galimulator is obfuscated and
Mixin is not meant to work in an environment that is as obfuscated as Galimulator. Now don't get me wrong, Galimulator's obfuscation is nothing compared to other games such
as Runescape. However the obfuscation was large enough that I asked myself whether it was easier to just create a Mapping project on myself. This was initially done in the form of
the "PROPOSED-NAMES" file however later I worked on something more serious, Starmap. Starmap, along efforts of decompiling galimulator quickly drowned the progress done in starloader.
However even then I also worked on another project, the Starloader API which was heavily inspirated by Bukkit. The main reason it was brought to life and would be maintained regardless
of Starmap process is that the API it provided would end up being reliant on the original Galimulator jar. However this all changed with 4.8 released on March 3rd.
Galimulator version 4.8
Galimulator version 4.8 came with two important News for me, one short term, one long term. In the short term I wouldn't be able to continue with Starmap as the Jar was (accidentally)
crafted in such a way that it would crash Enigma, which generated and applied the mappings for me. In the long term I would be not so reliant on Starmap as many of the class names and fields
were no longer obfuscated. Due to this I temporarily halted progress on Starmap.
Mar - May 2021
Within the early days of March I created a Discord account (for the second time, I left Discord in December 2020) and joined the Galimulator discord server to ask what was going on with the invalid classes
that prevented me from using Enigma. Additionally the linux release was bork in a few more ways, such as the Windows libraries being present within the jar. This question was met with confusion
as noone there had an idea of what I was doing. While the code for the project was open sourced a few weeks before it, noone really knew of the exsitence of the project as I did not advertise the framework
in any manner and the confrontration with discord ended up being the first one where anyone heard of this project.
After some explaination and discussion we came to the agreement that the galimulator jar should not be published in any way (well, duh) but more importantly that any deobfuscation efforts
should not be published (I never told them about Starmap, nor the other efforts I undertake to decompile the game). During this period people got interested in this project, even if I
believe that noone tried it out for themselves. Meanwhile I continued to expand the Starloader API in a radical fashion and released version 1.1 in early april. The version expanded on
many concepts present at that time and also added new concepts such as a primitive GUI library or Sound sample playback support. It also included a new novel concept: Enum Registries,
which allowed to expand the normally hardcoded enums set by the game with better interoperabillity. Within the Starloader loader side more changes were made and the application was no longer a wrapper
but more of a launcher with a working albeit minimalistic GUI written with Java Swing. It also supported a fork of Fabric's AccessWideners and Heretere's Config Handler (which was never tested in any way).
In late april I attempted to decompile Galimulator again, though this time with the proper tools. I also became involved (though on the passive side) in another wave of fabric drama where
several people promoted an upcoming fork (Quilt) as a better alternative. Quilt came with it's own fork of Fernflower, so I contributed to it. However this did not really suffice as planned so I came up with
my own tools. The project for this - Oaktree (name might get changed till release) - attempts to mitigate several obfuscation tactics used by the game (though the inner class information
recovery was the only one that worked in a reliable manner). Even with it I eventually saw no way I could do it properly given that it still had around 3k recompile errors
and went to do more productive stuff.
The first real extension - Timelapser
While the framework existed there was nothing that actually made use of it. To solve this issue I created Timelapser which had the goal to snapshot the game's status and to dump it into an image within another thread.
The project took a lot of time as well as knowledge with dealing with Voronoi cells. As the Voronoi libary used by the game was insufficent and so
AWTVoronoi was born, which attempted to make my life easier by using AWT Components as well as having some performance fixes here and there. But while actually implementing this I had an issue:
I had to somehow assemble the graph edges (basically a component that says that a line should be drawn between X and Y) into working polygons. This is easier said than done
because the order of the points matter. Aligning them arbitarily does not look good at all. And so I wrote around 200 lines of code in several days and probably a dozen hours that
converted the lines into polygons. It still has a few bugs (especially floating point related) but many of those aren't grave enough to warrant a deeper look into it.
And so by May 11 2021 the extension is almost ready for general availiabillity. With the extension being 100% reliant on StarloaderAPI and nothing else it is pretty
version and plattform independent at it's heart, which should promote the novelty of backwards support early on, something that was a leading factor to bukkit's success (which the API is heavily inspired from).