Uploaded April 2018 | Updated November 2026, 4 days ago
Reading up on some of the features of Groovy I stumbled upon the @Memoized annotation. This method annotation allows you to tell Groovy to memoize the results from a function. What is memoizing? Think of it as caching the results of a complex computation.
For example the Fibonacci sequence requires us to recursively calculate f(n) = f(n - 1) + f(n - 2). In order to calculate fibonacci for f(100) this means we need to calculate f(1) a hundred times! Why? The answer is going to be the same every time. The idea of memoizing is to take the results of the complex function and store the results after the first computation into a data structure that makes it easier to lookup. For fibonacci this might be as simple as an array with the results of f(n) stored at index n in our array. The general idea being to replace a complex or slow function with a relatively quick table lookup.
In Groovy we get memoization for free as a feature of the language. By adding @Memoized to a function we can tell Groovy to cache the results of a function for the given inputs and use that cache when the same inputs are used again. In our tests we dropped the time of computing the 40th fibonacci number from over 7 seconds (for 20 computations) to 60 milliseconds. An increase of more than 100 times! And it only took us a single line of code to get this advantage too. That's a lot of power for a single line of code.
The code from this video is available on GitHub here: gist.github.com/runewake2/2d63de01f53619d2d5b976043dc12420
More on Groovy at groovy-lang.org
The Groovy documentation on @Memoized, including help on managing the backing cache and additional examples: docs.groovy-lang.org/latest/html/gapi/groovy/transform/Memoized.html
Wikipedia's article on Time Complexity and what it means (don't let some of the more obscure terms intimidate you, focus on constant, logarithmic, linear, exponential and factorial time complexity): en.wikipedia.org/wiki/Time_complexity
The World of Zero Discord channel: discord.gg/hU5Kq2u
Reading up on some of the features of Groovy I stumbled upon the @Memoized annotation. This method annotation allows you to tell Groovy to memoize the results from a function. What is memoizing? Think of it as caching the results of a complex computation.
For example the Fibonacci sequence requires us to recursively calculate f(n) = f(n - 1) + f(n - 2). In order to calculate fibonacci for f(100) this means we need to calculate f(1) a hundred times! Why? The answer is going to be the same every time. The idea of memoizing is to take the results of the complex function and store the results after the first computation into a data structure that makes it easier to lookup. For fibonacci this might be as simple as an array with the results of f(n) stored at index n in our array. The general idea being to replace a complex or slow function with a relatively quick table lookup.
In Groovy we get memoization for free as a feature of the language. By adding @Memoized to a function we can tell Groovy to cache the results of a function for the given inputs and use that cache when the same inputs are used again. In our tests we dropped the time of computing the 40th fibonacci number from over 7 seconds (for 20 computations) to 60 milliseconds. An increase of more than 100 times! And it only took us a single line of code to get this advantage too. That's a lot of power for a single line of code.
The code from this video is available on GitHub here: gist.github.com/runewake2/2d63de01f53619d2d5b976043dc12420
More on Groovy at groovy-lang.org
The Groovy documentation on @Memoized, including help on managing the backing cache and additional examples: docs.groovy-lang.org/latest/html/gapi/groovy/transform/Memoized.html
Wikipedia's article on Time Complexity and what it means (don't let some of the more obscure terms intimidate you, focus on constant, logarithmic, linear, exponential and factorial time complexity): en.wikipedia.org/wiki/Time_complexity
The World of Zero Discord channel: discord.gg/hU5Kq2u
 or [Construct](https://www.construct.net/en/make-games/games-editor) as two examples.
My twitch streams are at https://www.twitch.tv/worldofzerodev
Join the World of Zero Discord Server: https://discord.gg/hU5Kq2u Building OBS Overlays in Unity 3D](https://i.ytimg.com/vi/940uUL0Nvwc/mqdefault.jpg)
.
{{% youtube id=Oq2ytDvHTYM %}}
***
The Unity Animator Controller is documented here: https://docs.unity3d.com/Manual/class-AnimatorController.html
Unity has published a tutorial series on learn.unity.com about using the animator controller: https://learn.unity.com/tutorial/animator-controllers-2019-3
Join the World of Zero Discord Server: https://discord.gg/hU5Kq2u Animating the Elevator - An Elevator Between Scenes - Part 1](https://i.ytimg.com/vi/96iaO7kl2Xg/mqdefault.jpg)

![Expanding our Mindustry Server with Custom Maps, Saves and More
Lets expand the dockerized Mindustry server weve been building by dynamically downloading the `server.jar` when we build our image and enabling custom maps, automatic hosting, persistent save files and more! Well be taking a look at how we can use volumes to mount local directories in our container so were able to add custom maps or access our servers config files locally. Then well look at using scripts that can automatically start our server using the custom map file we choose when starting our server.
Our expanded Dockerfile looks like this:
```dockerfile
FROM openjdk:25-slim
ARG MINDUSTRY_VERSION
ENV MINDUSTRY_VERSION=${MINDUSTRY_VERSION:-v146}
COPY run-server.sh /mindustry/run-server.sh
ADD https://github.com/Anuken/Mindustry/releases/download/$MINDUSTRY_VERSION/server-release.jar /mindustry/server.jar
CMD [ sh, /mindustry/run-server.sh ]
```
`ADD` lets us add remote files to our container image, this means we can directly link to the github release binaries to add them to the image without having to download them to our computer first.
Our `run-server.sh` script hosts a random map or the map provided in the `MINDUSTRY_MAP` environment variable if you provide it.
```sh
if [ -z ${MINDUSTRY_MAP} ]; then
java -jar /mindustry/server.jar host
else
java -jar /mindustry/server.jar host $MINDUSTRY_MAP
fi
```
Once we have created those two files, we are able to build our server using `docker build`:
```sh
docker build tag mindustry-server build-arg MINDUSTRY_VERSION=v146 .
```
This builds our `mindustry-server` image with the `MINDUSTRY_VERSION` version of Mindustry - in this case `v146`.
Once we have both of these scripts we can run our server using:
```sh
docker run -it -p 6567:6567 -p 6567:6567/udp -v ${pwd}/config:/config -v ${pwd}/maps:/config/maps -e MINDUSTRY_MAP=Veins mindustry-server
```
This command runs a new `Veins` map including our maps and config settings for persistence using volumes.
The current version of this container is available on GitHub at https://github.com/WorldOfZero/mindustry-server
***
Mindustry is available on Itch or Steam for desktop players or you can get a copy for your mobile phones:
* Itch.io: https://anuke.itch.io/mindustry
* Steam: https://store.steampowered.com/app/1127400/Mindustry/
* Google Play Store (Android): https://play.google.com/store/apps/details?id=io.anuke.mindustry&pli=1
* Apple App Store (iOS): https://apps.apple.com/us/app/mindustry/id1385258906?ls=1
(I dont have any association with this game, I just like playing it)
***
If you missed the first video in our Dockerized Mindustry Server, you can catch up here: https://youtu.be/m3mowhqXsXE Expanding our Mindustry Server with Custom Maps, Saves and More](https://i.ytimg.com/vi/9kenUFJqoVc/mqdefault.jpg)






![Pseudo-Random Colors with Hashed Strings
In this video were going to explore a way I approach reproducible pseudo-random number generation that uses calculated hashes to select a random item or property for an object. In this case well be assigning hue shifted colors to text strings. This helps easily identify elements in a list by searching for both a memorable name but also a color that will always be the same for a similar string.
To convert a string into an integer using an `MD5` hash you could write something like this:
```csharp
var stringToHash = World of Zero;
var hasher = MD5.Create();
var hash = hasher.ComputeHash(Encoding.UTF8.GetBytes(stringToHash));
var hashedInteger = BitConverter.ToInt32(hash, 0);
```
Then to convert an integer into a random color use this. In this example 256 hues will be selected from the color wheel:
```csharp
var color = Color.HSVToRGB((Math.Abs(hashedInteger) % 256) / 256.0f, 1.0f, 0.75f);
```
This same technique can be applied to other things as well. For example we can use the hashed value to index into a lookup table of names. Other approaches could apply a specific texture to a material or instantiate a specific prefab:
```csharp
var potentialNames = new string[] { World of Zero, YouTube, Unity 3D };
var name = potentialNames[Math.Abs(hashedInteger) % potentialNames.Count];
```
The `System.Security.Cryptography.MD5` class is documented here: https://docs.microsoft.com/en-us/dotnet/api/system.security.cryptography.md5
More information on how hashes work on Wikipedia: https://en.wikipedia.org/wiki/Hash_function
Join the World of Zero Discord Server: https://discord.gg/hU5Kq2u Pseudo-Random Colors with Hashed Strings](https://i.ytimg.com/vi/BHtKrZSuZMk/mqdefault.jpg)