...

Early sketch of the world of WITH THE LAST MOONBEAM.

Looking back

Last month when I published WITH THE LAST MOONBEAM I said that I wanted to write something to reflect on the project. A couple of days after that, however, my partner and I had twins… so I’ve been a little too exhausted to do any blogging. Honestly I’m still exhausted (and I’m not expecting that to change any time soon), but I really want to get some thoughts down while they’re still fresh in my mind. So here goes!

In one prototype the player was a goat with a sword.

Project timeline

MOONBEAM began as a response to creative doldrums I was stuck in during the early phases of the pandemic. After several years of exclusively focusing my game making practice on Bitsy and Bitsy games I was feeling some burnout and wanted to branch out a little.

I’d also become interested in the advantages of emulators and virtual machines as a way to distribute software, in large part thanks to the writings of Hundred Rabbits. Having some prior experience with GBA programming, I felt I could pick that up again with relative ease, and I knew I liked the hardware’s balance of capabilities and constraints.

What I didn't realize was that I was embarking on a two and a half year project!

Here’s a rough outline of how I spent that time:

• Fall 2020: Got reacquainted with the basics of GBA programming. No clear idea yet what sort of game I wanted to make.
• Winter 2020: Decided to try and build some momentum by working on a small non-game project. Ended up making the music toy POCKET CALLIOPE ADV and learned more about GBA audio hardware in the process.
• January 2021: Our first kid is born! Put down work on GBA programming for most of the first half of the year.
• Summer 2021: Tried to restart work on the game by joining GBA Jam 2021, but didn't make much progress during the jam.
• Fall 2021 - Winter 2021: Worked on a series of prototypes, none of which went anywhere. A low point for the project; considered giving up and moving onto something else.
• Spring 2022: Had my first big breakthrough on the project when I settled on how I wanted to tackle the art and mechanics for the game. This clarified the requirements for the game engine and allowed me to start making real progress.
• Summer 2022: Around this time I had my second big breakthrough - this time on the nature of the setting and story for the game. Made WE FLY THE LOOP to explore these ideas further. Momentum on the project finally picking up.
• Fall 2022 - Winter 2022: Work on MOONBEAM really gets going. The work proceeds through a series of drafts: blocking out the overworld, filling in the tutorial area, implementing a skeleton of the main quest, detailing the rest of the overworld, filling in the story details, etc. I do some playtesting between drafts.
• Winter 2023 - Spring 2023: The final stretch! Added music and save system, fixed a lot of bugs, and made final story revisions. Published the game on itch.io on March 15th.

In the tileset for MOONBEAM's overworld (shown here open in Aseprite) you can see tiles from several of my past Bitsy games. Choosing to stick with Bitsy-style tiles was a big turning point in the project.

Struggles & breakthroughs

I want to expand a little on the two breakthroughs I mentioned in the previous section, since I think they're both interesting in different ways:

• Breakthrough 1 - Art & mechanics: One thing I struggled with at first in this project was how to approach the art for the game. I had a preconception in my head about what GBA game art "should" look like (think the big sprites and detailed backgrounds of a Minish Cap or a Mother 3). I experimented with larger sprites in my prototypes, but it was obvious it was going to be too labor intensive. Instead I ended up embracing the large library of 8x8 sprites and tiles I'd created over the years for my Bitsy games. Reusing this art not only saved a ton of time, but it also influenced the way I approached the design of the game. Placing the little Bitsy sprites in the comparatively large canvas of the GBA screen gave the game space an open, slightly lonely feeling that I liked. And it reminded me of one of my favorite games: Knytt (and its sequel Knytt Stories). I decided I would make a Knytt-like, borrowing that game's climbing mechanics and its quilt-like world map of fixed-size screens, while putting my own spin on it with Bitsy-like dialogue and graphics. I think this is an interesting illustration of the way a practical, time-saving decision can end up impacting the fundamental feel of a game.
• Breakthrough 2 - Setting & story: I also struggled with the story for MOONBEAM. I had some vague notions of the themes and mood of the game from start - maintenance and repair, community and connection - but I had tremendous difficulty honing in on the specifics. Then one day, while walking home from the park with our toddler, I daydreamed about a universe where planets are born from seeds, then take the form of giant animals and wander the cosmos until they eventually settle into orbit around a star, after which they slowly accumulate landmasses, seas, etc. until they become an ordinary planet. It plays only a background role in the story I ended up telling in the game, and it's not necessarily the most original idea, but somehow this was the spark that unstuck me. The rest of the story seemed to come relatively easily. This breakthrough, in contrast to the previous one, was not a result of a practical decision on my part - in fact it has an almost mystical quality in its out-of-nowhere-ness. It was a good reminder to me of the way art relies on elements of ourselves that are outside our direct control. We can't summon them on our own schedule; we just have to be ready to listen when they arrive.

Top-left: A passage (fisher1) in Twine. Bottom-right: The game code generated from that passage.

This is map where the passage is used open in Tiled, with the fisher NPC selected. You can see the JavaScript that triggers the dialogue in the custom properties panel on the bottom left of the window.

And this is the resulting conversation playing in-game.

Tools & resources

I’m always curious about what tools people use to make their games, so I thought I’d do a rundown of the toolkit I ended up using for MOONBEAM:

• 🌳 Dogwood Engine: This is the game engine I wrote for MOONBEAM (“dogwood” was my placeholder name for the project - chosen for the tree I used to climb in my front yard as a kid). It’s all written in C but it also has a JavaScript scripting layer which I used for one-off interactions, cinematics, and dialogue (more on that below). The core of the engine is an entity component system which is used for the main game logic, player control, and NPC behavior. There are also smaller systems for managing tile-mapped stages, the world map, sound effects, and music. There’s a fixed point math library and even a small physics engine (which was probably kind of overkill: at one point I thought physics would be important to gameplay but in the end I mainly used it for the jumping frogs - they are quite cute though, so really who can say whether spending the time to write the physics engine was good or bad).
• 🦆 Duktape: This is the JavaScript engine I used. I’d used it before for bitsybox and liked it, which is why I chose it for my scripting layer in this project. Honestly I was pretty impressed with how well it worked on the limited resources of the GBA! I did encounter some memory constraints when using it for the dialogue system though.
• 🛠 devkitARM: This toolchain, which is maintained by the devkitPro group, is what I used to compile my C program to GBA-compatible machine code. As far as I can tell, it’s been the standard for GBA homebrew for a long time. There are some other options now which I think could be interesting to explore someday, but most tutorials I found assume you’re using devkitARM so that was the easiest option for me.
• 🕹 mGBA: This is the GBA emulator I did all my testing on. It works great, has nice debug tools, and it's actively maintained - there are some great features on the roadmap for the future. Recommended!
• ⌨️ Sublime Text: My text editor. I've done most of my programming in it for years and you’ll have a hard time prying me away from it. Don’t talk to me about VS Code - I’m sure it’s lovely, but I wouldn’t know. >:P Anyway I made a lot of use of Sublime Text’s build system feature for this project to launch various scripts for converting data into GBA compatible formats, building the game, etc.
• 📓 Obsidian: I began using Obsidian as my note-taking software partway through working on MOONBEAM and I really love it! (In fact I'm writing this blog post in obsidian right now.) It quickly became the place I did all my note taking, brainstorming, and project management. It has an extensive plugin library, and I made particular use of kanban plugin for task tracking while I was working on for MOONBEAM. I started using Obsidian based on a recommendation from my dad: so, thanks dad!
• 🗺 Tiled: The map editor I used for creating individual stages and laying out the overworld. Overall works really well for its main purpose, but I do wish the custom properties for map objects allowed nested/structured data - it would have been really helpful for organizing the properties on objects by component type (instead I had to resort to using a special naming convention). I used its scripting API to export the levels into the format (C files) my engine could understand.
• 🎨 Aseprite: The sprite editor I used for this game. I'd played with it a little before, but this was the first large project I used it for - and it's as good as everyone says. Similar to Tiled, I used its scripting API for exporting sprites as C files - scriptable extensions are nice!
• 🖋 Twine 1.4.2: I wrote all the dialogue in Twine, which worked well for me - it was nice to be able to see the conversation flow laid out spatially. (Why not use Twine 2 or Yarn Spinner? tbh I just think Twine 1 is neat) To get the dialogue into the game I first would export it as a .twee file, then use a script I wrote to convert it to a frankly extremely hacky hybrid JS + C output. The reason for this odd format is that originally the output was all JS: this started out fine (and the flexibility was nice for early experimentation), but as the size of the project grew eventually the memory required by Duktape to interpret all that JS became too much for the poor GBA to handle. By then however the dialogue flow logic was so en-twined (get it?) with the scripting layer that it was more trouble than it was worth to completely move everything to C, so I ended up porting enough C to keep memory demands low without having to extract all of the logic from the JS scripting layer. Whew. Let’s just say I’m glad no one except for me has to read or understand this code… (But hey - it works!)
• 🎹 Bosca Ceoil: This is a capable little music tool by Terry Cavanagh (yes, “Super Hexagon Terry Cavanagh"!). I found it friendly to learn for a non-expert like me, and the musical scale feature was a helpful aid to composition. Plus it outputs a simple text format that wasn’t hard to parse.

If you’re reading this and are interested in GBA programming but aren’t sure where to start, here are some of the resources I found helpful:

• GBA By Example: This set of tutorials by Kyle Halliday was what I used to reacquaint myself with GBA programming. It covers basic topics like game loops, reading input, and graphics modes. I found it really helpful to have a step by step guide like this at the start.
• Tonc: This is probably the most thorough and well-known text on GBA programming out there. I didn’t read it cover to cover but I referred to most chapters at least once in the course of this project, and some I reread several times. The chapters on tiles and sprites in particular were indispensable.
• GBATEK: This is documentation of the GBA hardware (rather than a guide or tutorial). Not something I used frequently but it was helpful for trickier topics like audio and save memory. A good reference to have handy.
• gbadev.net: For more, I suggest this list of resources (from articles and guides to toolkits and game engines) as a jumping off point. It's maintained by the group that runs the GBA jams on itch, and they also have a discord!

A panel from "On a Sunbeam" by Tillie Walden.

Influences & inspirations

Another thing I'm always curious about is what influences people are drawing from when they make their games. It's fascinating to me to see the ways folks' games are in conversation with each other, as well as with other media, and ordinary life. So here's a (necessarily only partial) list of things that inspired me while working on MOONBEAM:

• Knytt / Knytt Stories, Nifflas. I already mentioned above how much of an influence these games had on MOONBEAM. They're freeware, so go play them right now! >:P
• Night in the Woods, Infinite Fall. I was definitely thinking about NITW when making the dialogue system for MOONBEAM. It's also one of my go-to reference points for games with a protagonist who feels like a real person (as opposed to just being an avatar for the player).
• On a Sunbeam, Tillie Walden. Beautiful, surreal, melancholy space opera - one of my all-time favorite comics.
• Bee and PuppyCat, Natasha Allegri et al.
• Yokohama Kaidashi Kikou, Hitoshi Ashinano.
• Nausicaä of the Valley of the Wind, Hayao Miyazaki et al.
• The Dispossessed, Ursula K. Le Guin.
• Every Bitsy game. Is this one cheating? I don't know, but I do know that playing and making Bitsy games has been foundational to how I design games, especially when it comes to storytelling and pacing. To just pick one, I think I am constantly trying to make a game with vibes as pitch-perfect as G.P.'s The Tower At Night.
• Walking around my neighborhood.
• Writing by other game makers.
• My partner, Mary-Margaret. When I got stuck on some design decision or other, I'd always ask myself: What would Mary-Margaret enjoy? What would amuse or annoy her? This game could not exist without her. <3

More sketches and notes about WITH THE LAST MOONBEAM from my notebook.

Looking ahead

Thanks for indulging me in this bit of retrospection! I’ve been living with this project for a while now, so it feels good to take a moment to look back over the whole process before moving on.

This game was my largest to date. If there's one thing I’ve learned working on it that I will carry forward with me for future games, it's probably that when working on a larger project you have to get comfortable with not always being able to see the whole picture of what you’re making. Any designs or plans you have at the start are at best a map through untravelled country.

I'm not sure exactly what I'm going to work on next. I think it would be interesting to see if I can make another game with the Dogwood Engine (ideally something smaller though) to see how re-usable it is beyond this one game. Or maybe I'll try participating in a couple of jams. Of course, I also have a long list of potential game ideas in my notebook... but for now I think I want to try to allow myself some time where I'm not committed to anything very large.

If you want to keep up with what I'm working on, please consider subscribing to my blog via RSS.

Stay well y'all! :)

If you want to get updates when I publish a new post, you can follow my RSS feed or subscribe to my email newsletter. Thanks for reading!