This project followed a semester of learning the basic ins and outs of Unity, specifically how its single-threaded nature means making game elements function simultaneously is a challenge. Its solution is to have a "Coroutine," which can run an event, function, or other game element as if it was in parallel to the rest of the game. While I would learn better techniques in the future, I pushed myself to use Coroutines for much of this prototype, certainly overusing that aspect of Unity's design.

Almost every part of the main combat loop relies on Coroutines. Each enemy and party member's turn is inside a Coroutine, the inputs for the attacks and magic skills are handled with Coroutines, and even the overarching turn/round loop itself uses Coroutines. It all works, but the overreliance causes the game to be relatively sluggish on the backend.

The two main gimmicks of this prototype involve how skills are executed in combat and how powering up party members can be achieved. Skills (and magic spells) each have an associated set of inputs that must be hit to maximize damage. The inputs are generated as little bubbles at the arrow and float over to the target. The Player must then press the associated key with precise timing to give the attack power. This system is reminiscent of the Mario RPG games, though the actual input track is most influenced by the GBA version of Harry Potter and the Order of the Phoenix.

An extra wrinkle for strategy is the turn list and the ability for party members to join together to create a combo attack. Depicting turn order is something that hearkens back to D&D, but the randomized order of turns is something I first encountered in Octopath Traveler, and I chose to recreate that system here. During a turn, the Player can choose to combine forces on one party member's turn and execute it on the selected partner's turn. Thus, knowing where each party member falls in the input track creates strategic decisions that the Player can use.