Macrowave Mayhem
Gameplay Video
About the project in short
Macrowave Mayhem is a project created by a team of 3 people (and a little outsourcing) for the Game Off 2025 Game Jam.
It is a Tower Defense game where the towers can be placed all around the level on a grid (except on top of existing furniture, of course.)
The game features food-based enemies and towers.
The player can choose from 4 tower types in this game:
Barrier: A table that blocks enemies, forcing them to reroute. Cheap, but can’t shoot.
Cookie Tower: A glass of milk with a cookie. Shoots cookies that deal decent damage.
Donut Stack: Shoots donuts that trap enemies on contact, stopping them for a short time. Low damage output.
Drink Cabinet: Rapidly shoots corks at multiple enemies. Great against groups of enemies, but it’s expensive.
Roles:
Programming: Justin Stolk (that’s me!).
Tower Design: Justin Stolk & Bo Vogelzang.
Creature Design & Modelling: Bo Vogelzang.
2D & UI Art: Bo Vogelzang.
Environment Design: Ruben Schellekens & Bo Vogelzang.
Environment & Tower Modelling: Ruben Schellekens.
Shaders: Ruben Schellekens.
Set Dressing and Game Balancing: Ruben Schellekens.
Music: Sander Schellekens.
Font: Khurasan
To clarify and reiterate, on this project I was a: Gameplay Programmer, Game AI Developer, UI Developer, Tower Concept Artist and System Developer.
It was great to work together with Ruben & Bo, whom I consider both very skilled people, as well as great friends!
Early Design Decisions
In this game jam, the theme was “Waves“
As such, we considered different ways to interpret waves, such as the waves the ocean creates or maybe sound waves/shock waves.
I created a mind map and just wrote down all kinds of associations with waves, even writing down microwave and then macrowave(?) connected to it. What it could even mean, I didn’t know at the time.
The macrowave did turn out to become an important element as we decided to do a double interpretation of “Waves“ with waves of enemies, as well as the idea of the gone-haywire huge microwave: the macrowave.
With this, the connection to food was quickly made and we opted for a medieval-fantasy setting, as we could all see it work with the design ideas we had. It also fit our interests well.
We decided that all three of us would make sketches for towers and then meet up later.
When designing my towers, I tried to stay within the realm of food, but not necessarily be restricted by realism or the maximum amount of logic.
I did think about tower defense games and the way towers are usually balanced and tried to come up with designs that support that.
These were my considerations:
Basic tower: shoots projectiles at one target, medium speed and power. Usually your starting tower.
Speed tower: shoots really fast projectiles that are weak. Best against fast enemies with lower health.
Area tower: can manifest in two ways, attacking a large area around it continuously (here the stovetop tower) or with exploding projectiles (the gyoza bomber). The first usually has limited range and the second is often rather slow.
Effect tower: tower that slows, burns or does something else to hinder enemies. Often weak, but the debuff helps defeat enemies easier.
Damage over time tower: A tower that hits one enemy continuously, increasing damage output as long as the target stays the same.
A few of my tower ideas:
Cookie Tower: A basic projectile tower. A cookie in a glass of milk.
Stovetop Tower: Continuously damages enemies close by and leaves them burning for a little while, dealing damage over time.
Gyoza Bomber: Shoots gyoza from the steam basket, which explode on impact. (I love gyoza)
Pizza Oven/Donut Tower: Towers that stall enemies. Donuts would encapsulate enemies, while the pizza could distract multiple enemies.
Stew Shooter: The thick stew slows enemies down.
Oil Spray: The hot oil does increased damage over time.
Ballista: Rapid fires projectiles for low damage (quite the opposite of a real ballista)
In the end, my cookie tower and donut stack designs were used in the game as 2 of the 4 towers. Not that bad coming from the programmer!
Starting with the basics
To get everything up and running as soon as possible, I worked on the towers and enemies using basic shapes in Unity. I made these children of the root objects that contained their functionality, so that later on, only the meshes needed to be swapped without breaking anything.
The towers use the Physics.OverlapSphere to find enemies to attack. They then shoot a projectile at them.
The enemies use the Navmesh to find their path towards the endpoint. On spawning, an enemy calls a public static event within its own class with itself as a parameter. This then reaches the class where the endpoint/target for the enemy is set.
Early prototype of the towers and enemies. The endpoint is visualised using a rotated, red cube.
Code
Activating and Deactivating towers was necessary both for pausing the game, as well as them not shooting while the player is still planning to position them when buying it.
The virtual AttackTarget function in the Tower class only handles the reset of the timer and the playing of the shooting sound, so that these don’t have to be reïmplemented in every concrete Tower.
The FindTarget function is abstract, as the concrete towers handle how many enemies they can attack and how they even attack them.
The functionality of towers comes together in this abstract class’ Update method.
Without knowing exactly what the target is going to be and how we can attack it, it is already properly set up to do the attacks, as long as the concrete towers have implemented these functions correctly.
The towers then don’t need to have their own implementation to find and attack targets, only definitions how they do it.
In the end, Towers inherited from a class named GridObject.
This was done because the barrier table used to be a tower.
Since the table can’t attack, it would have Power, an Attack Interval and Range for no reason. These would have to be set to 0 in the inspector, which gave us the correct behaviour, but the system that displayed the range still made a very small circle of non-range, which just didn’t look nice.
The Tower class itself is abstract, as there are multiple kinds of towers, which attack in different ways. It is up to specific tower classes to handle how they find their target.
Classes that require information from them receive this information as a Tower, following the Liskov Substitute Principle.
