Ever since I got my Atomic Purple Game Boy Color when I was nine-years-old, I've wanted to make a Game Boy Color game of my own. Now, 20+ years later and after 251 hours of development (I tracked it), my new Game Boy Color game, Michael the Ant Thumper, is officially released! There are four endings to the story, can you unlock them all?!

Fun Numbers

• 93 hours of tooling development
• 158 hours of programming and art
• Untold numbers of playthroughs
• 3 beta testers (thank you!)
• ~30 minute average time to complete the game
• $1.99 and the game is yours!

A Bit More Detail

• I used GB Studio to develop the code and compile the ROM
• I wrote custom tooling in Golang to allow me to design the levels and cutscenes in the LDtk level editor and import the data into GB Studio
• I used a combination of Pixaki and Aseprite for the art

Tooling Deep Dive

At the beginning of the project, I put in enough hours to vanilla GB Studio development to realize where the pain points were in level creation and then started building some automation/tooling to help. I mostly wanted to use a level editor with support for 9-slicing and tiling rules and landed on LDtk, "a modern 2D level editor from the creator of Dead Cells, with a strong focus on user-friendliness." The final version of my tooling really accelerates level development times.

For example, I can create a level in LDtk that looks like this:

Which then uses my tiling rules to turn into this:

Which is then automatically imported into GB Studio:

And I don't have to manually place collision tiles. Neat!

That's cool and all, but the real meat is in a feature I built called "Storyboards". Storyboards are text blocks containing a custom scripting/markup language that's parsed by my tooling and translated into GB Studio scripts and configuration. Storyboards let me quickly script cutscenes, scene transitions, item pickups, NPC interaction, and more!

There's a lot of cool features built into the Storyboards "language," but here are some of my favorites:

You can show emotes above specific actors or the player:

#shock lewis
#anger

Call a GB Studio script (a script called "demo_script" in this example):

!demo_script

Create and manipulate variable values:

$collected_var=true
$collected_var=false
$custom_var=3
$custom_var+2
$custom_var-1
$custom_var/2
$custom_var*2
$custom_var%2
$another_var=custom_var

Check the value of a variable and react (everything between the start of the variable check or from the `?else` and the `?end` keyword is normal Storyboard syntax):

?another_var=3
This var is equal to 3!
~Michael~That's beautiful!
?else
This var is not equal to 3...
~Lewis~That's sad...
?end

Pose a question to the player and save which option is chosen to the variable specified (`player_choice` in this example)

>player_choice>Choice 1>Choice 2

Generate and show a GB Studio scene called `lewis_intro` using the `cutscene_lewis` background image. The `once` keyword limits the cutscene to only displaying one time (useful for introducing NPCs and then having them say something else the next time you interact with them):

@lewis_intro cutscene_lewis once
~Lewis~Yo, Mike! Killer party. Love your couch. It's super long. What's for breakfast?
Lewis didn't realize that it was actually 1pm.
@end

Additionally, my tooling handles:

• Importing/updating generated scene background images
• Setting the player's starting location
• Updating level size
• Importing collision data
• Generating warp points (useful for doors and teleportation pads)
• Automatically creating scene transition triggers on the edge of GB Studio scenes for Metroidvania-style map traversal
• Importing and placing actors
• Counting collectables and setting a global GB Studio variable for tracking player progress collecting stuff
• Word wrapping dialogue messages (with custom font support) so text doesn't run off the screen
• Generating GBVM tile swap animations for specific background tiles (e.g. swaying flowers/grass)

All these features really sped up iteration time for Michael the Ant Thumper. I was able to super quickly make edits to dialogue, cutscenes, level layout, and actor/entity placement.

Golang Woes

Not everything was smooth sailing though...

I started out my tooling development with a Bash script that could import generated .png images as GB Studio scene backgrounds along with some automatic collision data, but once I began creating really large amounts of JSON to inject into the GB Studio file, Bash became too slow and I migrated over to Golang. Golang was MUCH faster and easier to develop, but it had some quirks related to how GB Studio stores data.

The GB Studio project file format is a custom schema .json file. Fun fact: you can open up any GB Studio project file in a text editor and peruse and edit the data without GB Studio's UI. As long as the data you edit or insert is valid according to the schema, the UI will load it up just fine and happily compile. The problem is that Golang as a language is very opinionated and strict about what it thinks "good JSON" is and it doesn't like certain things GB Studio does.

The GB Studio schema overloads a couple JSON keys with multiple value types. For example, using a GB Studio "Script" object, you can set the direction an actor is facing. This Script object shows up in the GB Studio .json file as a number value wrapped in a JSON object ("4" being one of the cardinal directions):

"direction": {
    "value": "4"
},

However, you can also use a different GB Studio script to launch a projectile in a direction using the same "direction" key in the JSON schema. For that particular action, GB Studio throws a compilation error if the direction value isn't a string value (as opposed to the integer shown above):

"direction": {
    "value": "right"
},

Go REALLY doesn't like this because technically it's an antipattern to have a JSON key pair with multiple value types (int and string in this case). I managed to get around it by implementing a custom Golang JSON unmarshaller, but it was a pain. If I'd used a language that was more lax with JSON structure and typing (like Python or Node.js) it wouldn't have been as much of an issue, but I opted to use the strongly-typed Golang language because I'm familiar with it and it's fast compared to non-compiled languages.

Wrap Up

I'm pleased with how Michael the Ant Thumper turned out! My tooling, which I'm calling GBtk-Stitch (since it stitches together GB Studio and LDtk), isn't ready for public consumption yet and lives in a private GitHub repo. GBtk-Stitch relies on a custom version of GB Studio and a specific version of LDtk to function and some of the features are finicky if you don't know how they work internally so it wouldn't be the best user experience for a non-GBtk-Stitch dev. Maybe I'll release it to the public one day, but for now I plan to use it to create more CompyCore Games games for the Game Boy Color!

Stay tuned for the next CompyCore adventure!