In December of 2023 I arrived in Lisbon, Portugal. It was my 11th and final flight that year, and I have not had a private room to sleep in or a desk to work at since July. But at that moment I finally had both, and there wouldn't be any flights for the whole year! I was eager to start working on personal projects after such a long break.
This year I spent a lot of time on gamedev! I did not do it as consistently as I'd like, but I still learned a lot and tried many new things! I decided to write this post as part of my effort to do more journaling and documentation of my work.
Just like my physical environment has changed, so did my development environment.
A lot of coding I did this year was on my low-powered Linux laptop. I used C++ with simple frameworks like openFrameworks and later raylib, as opposed to my usual environment of Unreal Engine on Windows. I found that prototyping in a more bare-bones environment allowed me to focus on the systems I'm trying to build and not get distracted too much by making cool visuals, or figuring out the best way to incorporate my code into Unreal's own gameplay framework.
I haven't abandoned Unreal though - I still used it in projects that used physics extensively, or when I really wanted to make cool visuals. If I'll ever make a commercial game, I would most likely do it in Unreal, for all the tools it provides to create the things you would expect from a modern game, like UI, settings, localization, input, etc.
2D Rope Puzzle Game (unreleased)
The first prototype I made is a revisit of an older idea for a 2D puzzle game with rope physics. I reimplemented it in openFrameworks, and this time I figured out how to make ropes reliably react to moving objects.
I haven't seen a lot of this kind of rope simulation around, except for Robot Detour, which uses a similar approach. Here's a video of the developer Ivan Bushmin talking about it. I'd like to come back to my implementation at some point and make an interactive demo demonstrating how the algorithm works.
During this project I was thinking about what makes a good puzzle game and analyzed some of my favorites to learn how the mechanics and puzzle design work together to create an engaging experience. That would pay off later during the development of Tome Tumble Tournament.
I also realized the value of a toy in game design. I knew about "Build the Toy First" for a long time, but only then it really clicked, and I saw that a good toy isn't just a game that is unfinished, but is a tool specifically designed to help the designer to test and experiment.
Strictly speaking, this was still a 2023 project, but it led to a different prototype I made with my friend Nikolay Shikhachevskiy (LQFP), which we called...
Junkyard (unreleased)
Junkyard is a 2D toy featuring big rectangular blocks that are filled with destructible material. The player controls a small character, also represented by a rectangle, that has tools to manipulate the blocks and create and destroy the material inside.
The blocks can be used as obstacles, construction material, or puzzle elements. We discussed a few possible game ideas that could use these mechanics. I made a simple level editor with a logic system inspired by Source's IO entities.
During this project, I started learning and using flecs, an ECS library, to simulate large number of movable blocks and other game objects. Its built-in serialization functionality also proved useful for building the level editor.
While working on Junkyard, I thought a lot about different "brain modes" you go into when filling many different roles on the project. Designer Brain works very differently from Programmer Brain, and different still from Producer Brain. How to find good balance between them? How to easily switch to a mode your tasks require right now? Re-watching Keep Your Hands Off Eizouken! was a big inspiration and made me reflect on the value of creative collaboration and teamwork.
Junkyard was not published in any form, but we'd like to return to it at some point. Jumping on blocks and building structures out of them was instantly fun and we think this prototype has a lot of potential.
Floaty Boat (unreleased)
Another prototype I and Nick worked on is a 3D physics sandbox with a working title Floaty Boat where the player controls a small vessel with a grapple mechanism nicknamed The Frog.
This one was built in Unreal Engine, as I was not confident enough to start working with a physics engine in openFrameworks. I made a gym level where the player could tug cargo barges, tear off objects from walls, use gateways with varying water level, toss bombs and even cut objects with a laser. Another demo level I made involved the player clearing a path for a train to pass through, and finding fuel canisters hidden across the area.
Here are some of the cool artworks made by Nikolay Shikhachevskiy for the project:
The project started at a good pace. We had a call every week or two and set immediate goals to work towards. However, we struggled to build a game around this toy, and eventually I even burned out from constantly thinking about it.
During this project, I was trying to learn about systems-based game design, and how to even start designing something that is made of parts that all depend and interact with each other. I re-read Game Mechanics: Advanced Game Design by Ernest Adams and Joris Dormans. I found these videos on systemic design by Board to Bits Games incredibly helpful.
Rosabelle (released, sort of?)
Next game project this year was a dice-based solitaire game called Rosabelle. It started as a Ludum Dare 55 entry (my first LD!). Dissatisfied that I did not have enough time to work on visuals, I decided to make a post-jam update.
This small update unexpectedly turned into a few months of redesigning the game rules multiple times, coming up with narrative, building and rebuilding systems, and even launching my first ever public playtest. This game was surprisingly code-heavy!
I made a GameToken system that tracks all the game pieces like dice and cards and the values they represent, allows to move them between different GameTokenCollections, provides event dispatches, and visually organizes their representations in the 3D scene by putting them into manually or procedurally defined slots. It works together with a PlayerAction system, which determines what the player can (and can not) do at any given turn, provides visual cues and gives contextual feedback to the player.
In Rosabelle, these GameTokens are components attached to Actors that represent dice and cards, so the game state ends up being scattered across multiple entities. If I were to implement this again, I would have the entire state reside in a separate abstract structure, and have the Actors read and write into it. This way the structure could be swapped on the go for things like Undo function, or have copies of itself created to simulate a multi-step action in the background and determine if the action is valid, depending on the outcome.
I also implemented a stack-based state machine that executes "Tasks" that control how the player's turns play out, and also do stuff like sequential animation of game pieces moving around. It is a simple and flexible system that can potentially be used for stuff like modal menus and dialogue trees and AI. I still use versions of this system in other projects. I also made a debugging mode that would only allow the focused task to change when I clicked a button, allowing to go through the tasks one by one.
Ultimately, even though players seemed to enjoy interacting with the dice and complimented the visuals, the basic idea of managing the possible rolled values by constantly studying the reference card seemed too inaccessible. I canned the project shortly after the playtest.
The biggest thing I learned while making this project is that digital board games like this require a lot of UX work. Even while the rules themselves are simple, I spent a lot of effort trying to make sure these rules are properly enforced and communicated to the player as they interact with the game.
You can play the original Ludum Dare version here and the final playtest version here (the password is rosabellebelieve)
Tome Tumble Tournament (released)
My next project was Tome Tumble Tournament, a Thinky Puzzle Game Jam 4 entry. It's a Sokoban-style game where you have to roll giant books into specific positions. The gimmick is that the book spreads open when landing on its spine, creating a number of unexpected and fun behaviors.
You can play the jam version here.
I prepared for the jam in advance. During the Rosabelle playtest I got feedback from people who had experienced some friction while downloading and running the game. I wanted to make my next game work in the browser to minimize any such friction.
Unreal Engine dropped web support a while ago, so I went back to openFrameworks and tried building a project for Webassembly with emscripten. That turned out to be surprisingly easy, so by the time the jam started I had everything ready to both test locally and upload web builds to my website.
I used flecs again dor this project. This time not for efficient simulation of many entities, but rather for its querying system. By building queries that looked for certain configurations of objects, I could define game rules in a way similar to how it works in PuzzleScript (although nowhere near as concise). Flecs' serialization system was once again useful for quickly implementing the essential Undo function.
After the jam ended, I decided to port the game to raylib. It is similar to openFrameworks, but is actually targeted towards game development, and turned out to be a better fit overall. I do miss the built-in glm library in openFrameworks and the ease of working with vectors that comes with it though.
The second half of the year was much slower, as I worked on a few projects at my main job, and also had to deal with some minor health problems. I kept working on Tome Tumble Tournament, adding a slippery ice mechanic (not included in the itch.io version, sorry!) and even brought it to a game showcase at DevGAMM Lisbon. People seemed to like it! It was great to see so many strangers play the game and have fun with it. My friend Rodrigo also showcased his puzzle game, CMYK, and we took turns manning each other's booths.
These are some of the smaller projects I worked on:
- I participated in a Global Game Jam this year. It was not my first GGJ, but it was the first one where my team was total strangers to me! It was also my first video game project where I almost did not do any coding (I did write a single function for mouselook).
- While working on Floaty Boat, I wanted to recreate my IO logic setup from Junkyard in Unreal. That meant making and visualizing connections between different actors in editor viewport. Turns out it's harder that it sounds! I documented what I was able to achieve in this post.
- While my friend Alex was visiting, we recreated one of my old prototypes about flying a spinning spaceship through thin gaps as a rhythm game prototype.
- I tried implementing the 2D Radiance Cascades algorithm, and combined it with a classic Wolfensein-style raycaster rendering method.
- I briefly tried to make an SDF-based snowboarding prototype, but didn't get too far before I had to start preparations for the DevGAMM showcase.
- Right now I am working on an extended version of a pre-simulated saggy cable visual effect I made for NVRWLK. I plan to release it some time soon as an explainer post with a complimentary Unreal Engine demo project. Here's a teaser!
I don't have videos for some of these projects, because they are on my currently broken laptop. I'll add them later (if I don't forget!)
If you want to know more about anything I mentioned, post a reply and I will do my best to answer!
I'm hoping for more exciting (and hopefully released) projects in 2025! Making games is awesome!