Tales of the Tunneler | Madilyn Tavares Portfolio

Project Overview & Postmortem

Language: C#

Tools Used: Unity, Aseprite, FL Studio, paint.NET

Platform: Windows

Role: Lead Developer, Writer

Overview: Tales of the Tunneler is a roguelite mining game developed in Unity by me and my husband (boyfriend at the time) over a period of 2 years. The inspiration for the game came from Stardew Valley--specifically, the part wherein you enter a cave and mine resources for your farm. During a play session, I expressed my enjoyment of that particular mechanic and my belief that such a mechanic, if expanded upon, could work very well as a standalone game. One frenzied branstorming session later, and Tales of the Tunneler was born.

Postmortem: We learned right away that making a decent-sized game and profiting from it was not nearly as easy as other people made it seem. From the very beginning, our scope was far too large; we wanted to implement over 350 "floors" (35+ distinct biomes) and hundreds of ores and enemies. Thankfully for our sanity, we realized that was much too ambitious for a team of two, so we scaled that down to 100 floors (10 biomes) and a few (on average 4) new ores and enemies per biome.

Our inexperience was also a major hurdle to our success; many things we did not know well or at all so certain things were implemented roughly with the knowledge we did have. One example is that very early on, I hadn't even the faintest inkling of Scriptable Objects, so all of the tools and ores had their own scripts. (I cringe even writing this, now.)

Combat

Goal: To create a combat system that could supplement the core mining/exploration loop

Result: A simple yet intuitive combat system fun at all points of the game, with flexibility for different weapon types

Details: As we began designing Tales of the Tunneler's combat, we knew right away that it couldn't be anything too complicated--yet it still had to retain its fun, for players would potentially be doing hundreds of runs on their way to the end of the game. In order to achieve that goal, we decided to keep the mechanics of the combat itself simple (no combinations or timings to memorize), and add variety via the types of enemies faced (melee, ranged, AoE) and weapons collected (swords, bows, or special). Later on came the VFX, which I implemented using Unity's built-in particle system, lights, and trails (for applicable effects).

One of the difficulties I had when initially implementing the combat system was timing the sword attacks--that is, applying damage to the enemy when the sword touches the enemy, and not anytime before or after. I solved this by using animation events to determine when the sword was "active" and could reasonably damage an enemy.

Inventory

Goal: To create a split inventory system divided between the "home base" storage and the player's in-run inventory

Result: An easy-to-use inventory interface with quick placement and automated stack combination

Details: As is the nature of roguelites, the players have a minimal inventory they can take with them during 'runs.' However, the lite part of the genre means that (unlike a traditional roguelike) upon death, a player's progress/items is not permanently lost, but instead used as a foundation for deeper, better runs. This meant, because Tales of the Tunneler is an item-heavy game, we needed to create two inventories: one massive storage the player can access in their "base," and one smaller that the player takes with them during a run.

The most significant challenge of implementing this split inventory system was the method of combining stacks of items. An item stack simply refers to the maximum amount of one item any inventory slot can hold, before further copies of that item must be relocated to another slot (if you have played Minecraft, this concept should be familiar). When dragging things between the "base" storage and the player inventory, the system needed to recognize if an item already existed in the destination inventory, and if so, to divide the new items between the existing stack and a new stack (if necessary).

Lore Guidebook

Goal: To flesh out the world of Tales of the Tunneler with pieces of lore similar to titles such as Risk of Rain 2.

Result: An in-depth lore system giving players glimpses into the world Tales of the Tunneler takes place in.

Details: I have always loved lore in games (the deeper the better!) so I wanted to use Tales of the Tunneler as a way to step into the world of narrative/world design. Because the game revolves around a character delving into an abandoned mineshaft on their own, I could not fill out the world via traditional methods such as dialogue, so I took inspiration from games like Risk of Rain 2 and created a "guidebook" whose entries would be unlocked when the player picked up the corresponding item. Each entry gives an insight into the creature/object itself and a peek into the bustling era before the mineshaft was shut down.

I also created the UI, using Unity's UI system to display entry data (held in scriptable objects) and dynamically update the size of the textbox based on the length of the entry.

Something I learned from this experience was to spread out the writing of these entries--there would be some days where I'd write dozens of them, and I'd feel very burned out at the end of the day. Burnout in general is something to be mindful of, no matter your discipline; if a break is needed, it is better to take it instead of trying to "push through" and careening into an exhaustion requiring much more time to recover from.