Overview
Role: System Designer
Developer: Fractured Tactic Works (7-person DigiPen student team)
Overview: Lunar Sword is an academic game project featuring of a series of battles with turn-based RPG combat and light roguelike elements.
Medium: Video Game (Custom-made C++ Engine)
Timeframe: September 2022 – May 2023
Contributions
On this project, I served as a system designer. This involved designing the core combat systems, as well as balancing a large amount of content. In addition to that main role, I also worked extensively on the UI/UX design of the project.
Some of my primary contributions to this project include:
● Implementing content into the custom engine using JSON
● Wireframing, playtesting, and iterating frequently on menus and UI
● Developing several small, proof-of-concept prototypes for rapid playtesting and team reference
System Design and Balancing
Lunar Sword is a very systems-dense game. It features a wide variety of skill effects, multiple stats, positive and negative status effects, and a dynamic turn system. As the team’s system designer, I designed the technical details and intended implementations of all of these systems.
For a complex systems-based game encouraging strategic play above all else, it was essential to balance carefully and minimize the prevalence of clearly dominant or underperforming strategies. While perfect balancing was impossible given the amount of content and overall complexity, solid balancing was one of my primary focuses, and I sought to balance both from a numerical perspective and by taking into account psychological bias.
Thus, my approach to balancing was both quantitative and qualitative. I made extensive use of spreadsheets, custom calculators, and writing my own code simulations to mathematically balance Lunar Sword‘s many skills, classes, and enemies. Likewise, I took into account observations and feedback gathered from playtesters, factoring in a psychological element to my balancing. For example, the listed accuracy values of special effects that could miss or fail were lower than their true values (a stated 25% hit rate was actually 33%, for instance) to account for people’s generally poor intuition when it comes to probabilities.
Having in-depth knowledge of the precise math behind the systems I designed was also crucial in later development. For example, I caught a major damage calculation bug early on purely due to how familiar I was with the math of my systems. When the damage calculation was implemented, it mistakenly retrieved the attacker’s Defense value to perform the calculation instead of the defender’s. In most cases, this would only result in a slightly different number than intended, so it would be extremely difficult to spot an inconsistency. However, as I had dedicated many hours to refining that exact formula, I knew right away that the numbers–although only a few points off—had to be incorrect. This bug easily could have slipped through into the final game, but by being very in-tune with my systems and math, I managed to diagnose and fix the issue.
A simulation testing the average effect of Speed on the dynamic turn system
The many damage formula variations I experimented with during development
Final iteration of the damage formula
A skill balancing spreadsheet
Working in a Custom C++ Engine
Lunar Sword runs on the Celestial Engine, an engine developed by our team from scratch in C++. While the engine itself was created by the engineers, it was up to the designers to communicate what features the engine would need to support our design work.
Content could be added to the Celestial Engine via data-dense JSON files. This high density was a trade-off; it meant that content was highly customizable without the need to frequently modify engine code, but it also made the files comparatively cumbersome to parse and edit.
Before this point, I was mostly used to the more user-friendly interfaces offered by commercial game engines, but from this project I learned to efficiently work with more complex data structures like this, and I now feel comfortable working with either style.
UI/UX Design
In addition to system design, I also did a considerable amount of UI and UX design for Lunar Sword. As a turn-based RPG, nearly all player interaction is conducted through the UI, and as such, a significant amount of development time was dedicated to refining the UI to enhance user experience as much as possible.
Different iterations of the UI were playtested to determine which elements were easily understood, which were often found ambiguous, and which tended to be ignored outright. The UI was slowly revised through multiple repetitions of iterating and playtesting.
Earlier prototype UI iteration
Final UI iteration
Prototyping
As the Celestial Engine was developed concurrently with Lunar Sword itself, design work started with rapid prototyping in the Unity Engine. My initial goal was to develop and refine a good Minimum Viable Product prototype which could serve as a useful reference for our engineers as they added relevant features to the engine.
Rapid prototyping continued to be useful even later in development, especially for UI design. Using powerful existing tools allowed me to quickly iterate and test with different UI styles and elements before making significant alterations to the game proper. This was especially useful for experimenting with UI animations and other feedback, which would have been cumbersome to iterate on frequently in-engine.
Connor Runyon 